135268 2014-07-24 16:42:41 -0700 Compute and store snap point positions 2014-08-13 17:16:26 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Mac Unspecified RESOLVED FIXED P2 Enhancement --- 134301 134283 1 wenson_hsieh webkit-unassigned bdakin bunhere cmarcelo commit-queue dino esprehn+autocc glenn gyuyoung.kim jamesr kangil.han kondapallykalyan luiz rakuco sergio simon.fraser syoichi thorton tonikitoo zalan oldest_to_newest 1024672 0 wenson_hsieh 2014-07-24 16:42:41 -0700 Compute and store the positions (i.e. in LayoutUnit, not Length) for snap points on the Mac. Note that this does not include iOS, since XPC calls are required in order to ship the snap point positions over (that will be the goal for either the next patch or the one after that). This will also introduce ScrollSnapManager, the class which handles nearly all of the snap point logic, including the snapping animations on Mac. For this patch, functions not necessary for just the computation of snap points will be stubbed out, with UNUSED_PARAMs as needed. There should be no changes in behavior. 1027391 1 236164 wenson_hsieh 2014-08-06 19:12:02 -0700 Created attachment 236164 Patch 1027662 2 236234 wenson_hsieh 2014-08-07 15:15:27 -0700 Created attachment 236234 Patch 1027946 3 236307 wenson_hsieh 2014-08-08 14:28:31 -0700 Created attachment 236307 Patch 1027960 4 236310 wenson_hsieh 2014-08-08 14:55:18 -0700 Created attachment 236310 Patch 1027992 5 236310 simon.fraser 2014-08-08 16:21:48 -0700 Comment on attachment 236310 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236310&action=review > Source/JavaScriptCore/ChangeLog:6 > + Enable CSS_SCROLL_SNAP on iPhoneOS and simulator. It seems odd to do this in the same commit. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:41 > +SnapPositionList::SnapPositionList() > +{ > +} Can probably remove this constructor > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:43 > +SnapPositionList::SnapPositionList(Vector<LayoutUnit> snapPositions) You're copying a Vector by value here. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:51 > +size_t SnapPositionList::size() const > +{ > + return positions.size(); > +} Should be inline > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:66 > +void SnapPositionList::clear() > +{ > + positions.clear(); > +} > + > +void SnapPositionList::resize(size_t size) > +{ > + positions.resize(size); > +} > + > +void SnapPositionList::append(LayoutUnit position) > +{ > + positions.append(position); > +} This is just exposing Vector functionality. Maybe you don't need SnapPositionList at all? > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:68 > +LayoutUnit SnapPositionList::closestSnapPosition(LayoutUnit scrollDestination, float velocity) const This could either be a static function or a function on ScrollSnap"Manager"? > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:74 > + if (scrollDestination >= positions.at(positions.size() - 1)) > + return positions.at(positions.size() - 1); Vector has last(). You'd better check that size() > 0. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:80 > + middleIndex = (lowerIndex + upperIndex) / 2; middleIndex should be declared here. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:89 > + if (scrollDestination < positions.at(middleIndex)) > + upperIndex = middleIndex; > + else if (scrollDestination > positions.at(middleIndex)) > + lowerIndex = middleIndex; > + else { > + upperIndex = middleIndex; > + lowerIndex = middleIndex; > + break; > + } Maybe std::binary_search? > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:96 > + // If velocity is zero, then the user released without flicking, so we simply snap to the closer point. I don't think this comment is useful. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:97 > + return scrollDestination - lowerSnapPosition <= upperSnapPosition - scrollDestination ? lowerSnapPosition : upperSnapPosition; Break out "scrollDestination - lowerSnapPosition <= upperSnapPosition - scrollDestination" into a named variable so I can tell what it is. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:100 > +ScrollSnapManager::ScrollSnapManager(ScrollEventAxis axis) Maybe the name should reflect that this "manager" only handles a single axis. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:148 > +void ScrollSnapManager::updateSnapDataFromFrameView(FrameView* frameView) > +{ > + if (RenderView* renderView = frameView->renderView()) { > + HTMLElement* body = renderView->document().body(); > + if (body) { > + const RenderStyle& style = body->renderer()->style(); > + LayoutUnit size = m_axis == ScrollEventAxis::Horizontal ? renderView->width() : renderView->height(); > + LayoutUnit scrollSize = m_axis == ScrollEventAxis::Horizontal ? renderView->scrollWidth() : renderView->scrollHeight(); > + if (scrollSize <= 0 || size <= 0 || size >= scrollSize) > + return; > + > + maxScrollOffset = scrollSize - size; > + if ((m_axis == ScrollEventAxis::Horizontal && !style.scrollSnapUsesElementsX()) > + || (m_axis == ScrollEventAxis::Vertical && !style.scrollSnapUsesElementsY())) > + updateSnapDataFromStyle(style, size); > + else > + updateSnapDataFromStyleAndParentElement(style, body, size); > + } > + } > +} > + > +void ScrollSnapManager::updateSnapDataFromParentElement(HTMLElement* parent) > +{ > + if (RenderBox* parentBox = parent->renderBox()) { > + const RenderStyle& style = parentBox->style(); > + LayoutUnit size = m_axis == ScrollEventAxis::Horizontal ? parentBox->width() : parentBox->height(); > + LayoutUnit scrollSize = m_axis == ScrollEventAxis::Horizontal ? parentBox->scrollWidth() : parentBox->scrollHeight(); > + if (scrollSize <= 0 || size <= 0 || size >= scrollSize) > + return; > + > + maxScrollOffset = scrollSize - size; > + if ((m_axis == ScrollEventAxis::Horizontal && !style.scrollSnapUsesElementsX()) > + || (m_axis == ScrollEventAxis::Vertical && !style.scrollSnapUsesElementsY())) > + updateSnapDataFromStyle(style, size); > + else > + updateSnapDataFromStyleAndParentElement(style, parent, size); > + } > +} The point of ScrollableArea is to abstract out differences between different scrollable things, so you should re-write this in terms of ScrollableArea, and not have different function for FrameView and overflow. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:154 > + LayoutUnit parentOffset = m_axis == ScrollEventAxis::Horizontal ? parent->renderBox()->offsetLeft() : parent->renderBox()->offsetTop(); We try not to use offset* in our own code. It usually indicates code that failed to consider CSS transforms. I don' think you need parentOffset at all here. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:160 > + while (child && lastPotentialSnapPosition < maxScrollOffset) { This walking of the nodes under the "elements" scroller could be very expensive. I think it would be better to somehow register RenderObjects with scrollSnapCoordinates() with their enclosing scroller. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:164 > + LayoutUnit childOffset = (m_axis == ScrollEventAxis::Horizontal ? childBox->offsetLeft() : childBox->offsetTop()) - parentOffset; This should use localToContainerPoint() or similar. You should test content with CSS transforms between the scrolling thing and the target elements. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:178 > + // Always put a snap point on the maximum scroll offset. Is that behavior defined in the spec? > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:183 > +void ScrollSnapManager::updateSnapDataFromStyle(const RenderStyle& style, LayoutUnit size) It's unclear what the "size" param refers to. > Source/WebCore/page/scrolling/ScrollSnapManager.cpp:202 > + LayoutUnit curSnapPositionShift = -destinationOffset; Not clear why. > Source/WebCore/page/scrolling/ScrollSnapManager.h:42 > +#include <wtf/Vector.h> > +#include <wtf/text/CString.h> > +#include <wtf/text/WTFString.h> I don't think you need these. > Source/WebCore/page/scrolling/ScrollSnapManager.h:58 > +class ScrollSnapManager { http://blog.codinghorror.com/i-shall-call-it-somethingmanager/ > Source/WebCore/page/scrolling/ScrollSnapManager.h:66 > + LayoutUnit maxScrollOffset; m_maxScrollOffset > Source/WebCore/page/scrolling/ScrollSnapManager.h:67 > + SnapPositionList snapPositions; m_snapPositions. I think both these should be private. 1028106 6 236348 wenson_hsieh 2014-08-10 12:51:59 -0700 Created attachment 236348 Patch 1028113 7 236310 wenson_hsieh 2014-08-10 13:17:55 -0700 Comment on attachment 236310 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236310&action=review Thanks for the feedback! I've restructured my code to avoid having a "ScrollSnapManager" altogether, mainly by separating snap position storage from snap animation into classes that are less vague than "Manager". >> Source/JavaScriptCore/ChangeLog:6 >> + Enable CSS_SCROLL_SNAP on iPhoneOS and simulator. > > It seems odd to do this in the same commit. Removed. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:68 >> +LayoutUnit SnapPositionList::closestSnapPosition(LayoutUnit scrollDestination, float velocity) const > > This could either be a static function or a function on ScrollSnap"Manager"? I'll change this to a static function. Good call. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:74 >> + return positions.at(positions.size() - 1); > > Vector has last(). You'd better check that size() > 0. Fixed to use last(), and added early return for empty vector. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:80 >> + middleIndex = (lowerIndex + upperIndex) / 2; > > middleIndex should be declared here. Fixed. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:89 >> + } > > Maybe std::binary_search? I'll update the implementation to use std's binary search. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:96 >> + // If velocity is zero, then the user released without flicking, so we simply snap to the closer point. > > I don't think this comment is useful. Removed. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:97 >> + return scrollDestination - lowerSnapPosition <= upperSnapPosition - scrollDestination ? lowerSnapPosition : upperSnapPosition; > > Break out "scrollDestination - lowerSnapPosition <= upperSnapPosition - scrollDestination" into a named variable so I can tell what it is. Fixed. It indicates whether or not the scroll destination is closer to the lower snap point. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:100 >> +ScrollSnapManager::ScrollSnapManager(ScrollEventAxis axis) > > Maybe the name should reflect that this "manager" only handles a single axis. Fixed -- does SingleAxisSnapList sound better? I'm also separating animation code from the SingleAxisSnapList. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:148 >> +} > > The point of ScrollableArea is to abstract out differences between different scrollable things, so you should re-write this in terms of ScrollableArea, and not have different function for FrameView and overflow. Moved the bulk of the logic over to ScrollableArea, which is shared by FrameView and RenderLayer. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:160 >> + while (child && lastPotentialSnapPosition < maxScrollOffset) { > > This walking of the nodes under the "elements" scroller could be very expensive. I think it would be better to somehow register RenderObjects with scrollSnapCoordinates() with their enclosing scroller. Agreed. If it's alright, I think I'll keep it like this for this patch, and it can be an optimization later on. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:164 >> + LayoutUnit childOffset = (m_axis == ScrollEventAxis::Horizontal ? childBox->offsetLeft() : childBox->offsetTop()) - parentOffset; > > This should use localToContainerPoint() or similar. You should test content with CSS transforms between the scrolling thing and the target elements. Good point -- I'll fix this. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:178 >> + // Always put a snap point on the maximum scroll offset. > > Is that behavior defined in the spec? Added a comment indicating that it's something I added to prevent unreachable content. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:183 >> +void ScrollSnapManager::updateSnapDataFromStyle(const RenderStyle& style, LayoutUnit size) > > It's unclear what the "size" param refers to. Changed to viewSize. >> Source/WebCore/page/scrolling/ScrollSnapManager.cpp:202 >> + LayoutUnit curSnapPositionShift = -destinationOffset; > > Not clear why. Agreed, looks kind of weird. Changed implementation to not use -destinationOffset. >> Source/WebCore/page/scrolling/ScrollSnapManager.h:58 >> +class ScrollSnapManager { > > http://blog.codinghorror.com/i-shall-call-it-somethingmanager/ This was enlightening :) The ScrollSnapManager was originally intended to handle storing snap positions, and handling snapping animations/determining where to snap. I plan on separating the snap point data from the snap animation code, so the former will be in SingleAxisSnapList and the latter in something like ScrollSnapAnimator (hopefully "Animator" is a lot less nebulous than "Manager"). 1028218 8 236348 zalan 2014-08-11 10:31:01 -0700 Comment on attachment 236348 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236348&action=review > Source/WebCore/html/HTMLElement.cpp:364 > +void HTMLElement::appendChildSnapOffsetsToVector(ScrollEventAxis axis, Vector<LayoutUnit>& snapOffsets) > +{ > + Element* child = children()->collectionBegin(); > + while (child) { > + child->appendSnapOffsetsToVector(axis, snapOffsets); > + child = child->nextElementSibling(); > + } > +} > + > +void HTMLElement::appendSnapOffsetsToVector(ScrollEventAxis axis, Vector<LayoutUnit>& snapOffsets) > +{ > + RenderBox* box = renderBox(); > + LayoutUnit viewSize = axis == ScrollEventAxis::Horizontal ? box->width() : box->height(); > + LayoutUnit positionOffset = axis == ScrollEventAxis::Horizontal ? box->x() : box->y(); > + for (SnapCoordinate coordinate : box->style().scrollSnapCoordinates()) { > + LayoutUnit lastPotentialSnapPosition = positionOffset + valueForLength(axis == ScrollEventAxis::Horizontal ? coordinate.first : coordinate.second, viewSize); > + if (lastPotentialSnapPosition > 0) > + snapOffsets.append(lastPotentialSnapPosition); > + } > +} > +#endif > + Are you sure these functions need to be on Element? RenderBox is not even guaranteed here. (HTMLElement vs. RenderBox). These functions look to me like simple helpers and I am sure there are better places to put them. > Source/WebCore/html/HTMLElement.h:108 > +#if ENABLE(CSS_SCROLL_SNAP) > + void appendChildSnapOffsetsToVector(ScrollEventAxis, Vector<LayoutUnit>&); > + virtual void appendSnapOffsetsToVector(ScrollEventAxis, Vector<LayoutUnit>&) override; > +#endif Same question. Why are these on HTMLElement? > Source/WebCore/page/FrameView.cpp:856 > + if (!renderView() || !renderView()->document().body()) > + return; > + > + Element* body = renderView()->document().body(); if you use frame().document().body(), no need to check against renderview. > Source/WebCore/page/FrameView.cpp:857 > + updateSnapAxisFromElementAndStyle(axis, body, renderView(), body->renderer()->style()); body always has renderer() here? -and we always have body? 1028331 9 236405 wenson_hsieh 2014-08-11 14:47:58 -0700 Created attachment 236405 Patch 1028339 10 236405 zalan 2014-08-11 15:47:15 -0700 Comment on attachment 236405 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236405&action=review > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:43 > +void AxisScrollSnapOffsets::appendChildSnapOffsetsToVector(HTMLElement* parent, ScrollEventAxis axis, Vector<LayoutUnit>& snapOffsetSubsequence) HTMLElement& ? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:31 > +#include "HTMLElement.h" class HTMLElement instead? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:47 > + void updateFromOffsets(LayoutUnit, LayoutUnit, const Vector<LayoutUnit>&, LayoutUnit, bool, LayoutUnit); > + LayoutUnit closestSnapPosition(LayoutUnit, float = 0) const; Could you add the argument names? There's no way to tell what those LayoutUnits are for by looking at the .h file. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:52 > + Vector<LayoutUnit> offsets; private? m_offsets? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:53 > + bool dirty; not used. > Source/WebCore/platform/ScrollableArea.cpp:45 > +#include "Element.h" HTMLElement.h includes Element.h (indirectly) > Source/WebCore/platform/ScrollableArea.cpp:59 > + void* horizontalSnapAxisPointer; > + void* verticalSnapAxisPointer; > +#endif not used? > Source/WebCore/platform/ScrollableArea.cpp:207 > +void ScrollableArea::updateSnapAxisFromElementAndStyle(ScrollEventAxis axis, Element* scrollingElement, RenderBox* box, const RenderStyle& style) Element& RenderBox& ? > Source/WebCore/platform/ScrollableArea.h:31 > +#include "AxisScrollSnapOffsets.h" wrong order. > Source/WebCore/platform/ScrollableArea.h:47 > +class AxisScrollSnapOffsets; already included. 1028348 11 236405 simon.fraser 2014-08-11 16:25:04 -0700 Comment on attachment 236405 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236405&action=review r- for the ScrollableArea layering violation. > Source/WebCore/page/FrameView.cpp:860 > + updateSnapAxisFromElementAndStyle(axis, body, renderView(), body->renderer()->style()); To get document scroll snapping, are authors expected to style the body element? Maybe this is a spec issue; what if they specify scroll snap points on <html>? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:57 > + Element* child = parent->children()->collectionBegin(); > + while (child) { > + RenderBox* box = child->renderBox(); > + LayoutUnit viewSize = isHorizontalAxis ? box->width() : box->height(); > + LayoutUnit positionOffset = isHorizontalAxis ? box->x() : box->y(); > + for (SnapCoordinate coordinate : box->style().scrollSnapCoordinates()) { > + LayoutUnit lastPotentialSnapPosition = positionOffset + valueForLength(isHorizontalAxis ? coordinate.first : coordinate.second, viewSize); > + if (lastPotentialSnapPosition > 0) > + snapOffsetSubsequence.append(lastPotentialSnapPosition); > + } > + child = child->nextElementSibling(); > + } Please add a FIXME that this is temporary code. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:65 > +void AxisScrollSnapOffsets::updateFromOffsets(LayoutUnit viewSize, LayoutUnit scrollSize, const Vector<LayoutUnit>& snapOffsetSubsequence, LayoutUnit destinationOffset, bool hasRepeat, LayoutUnit repeatOffset) AxisScrollSnapOffsets::updateFromOffsets is awkward. updateFromStyle()? Can it just take a RenderStyle&? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:146 > + for (size_t i = 0; i < snapAxis.offsets.size(); i++) { > + if (snapAxis.offsets.at(i) != offsets.at(i)) > + return false; > + } Can't you just compare the Vectors? >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:52 >> + Vector<LayoutUnit> offsets; > > private? m_offsets? Yes. > Source/WebCore/platform/ScrollableArea.cpp:49 > +#include "HTMLElement.h" > +#include "RenderBox.h" > +#include "RenderStyle.h" > +#endif Bunch of layering violations here. ScrollableArea should not know anything about elements or renderers. > Source/WebCore/platform/ScrollableArea.h:72 > + virtual void updateSnapAxis(ScrollEventAxis) { }; The name could be better; you're updating offsets for an axis, not the axis itself. Also, this means you're doing TWO tree walks per update (one per axis). You should do both axes at the same time. > Source/WebCore/platform/ScrollableArea.h:279 > + void updateSnapAxisFromElementAndStyle(ScrollEventAxis, Element*, RenderBox*, const RenderStyle&); To resolve this layering violation, you either have to make this virtual, or compute the offsets externally and put them onto ScrollableArea. > Source/WebCore/platform/ScrollableArea.h:298 > + mutable OwnPtr<AxisScrollSnapOffsets> m_horizontalSnapAxis; > + mutable OwnPtr<AxisScrollSnapOffsets> m_verticalSnapAxis; Why mutable? Better names would be m_horizontalSnapOffsets etc. 1028518 12 236405 wenson_hsieh 2014-08-12 09:05:22 -0700 Comment on attachment 236405 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236405&action=review Thank you Simon and Zalan for the reviews! The logic is now contained in AxisScrollSnapOffsets, so I won't need Element and ScrollableArea to know about classes they shouldn't. >> Source/WebCore/page/FrameView.cpp:860 >> + updateSnapAxisFromElementAndStyle(axis, body, renderView(), body->renderer()->style()); > > To get document scroll snapping, are authors expected to style the body element? Maybe this is a spec issue; what if they specify scroll snap points on <html>? I'll contact Ted about this. Thanks! >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:43 >> +void AxisScrollSnapOffsets::appendChildSnapOffsetsToVector(HTMLElement* parent, ScrollEventAxis axis, Vector<LayoutUnit>& snapOffsetSubsequence) > > HTMLElement& ? Fixed. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:57 >> + } > > Please add a FIXME that this is temporary code. Ah, right -- added a FIXME. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:65 >> +void AxisScrollSnapOffsets::updateFromOffsets(LayoutUnit viewSize, LayoutUnit scrollSize, const Vector<LayoutUnit>& snapOffsetSubsequence, LayoutUnit destinationOffset, bool hasRepeat, LayoutUnit repeatOffset) > > AxisScrollSnapOffsets::updateFromOffsets is awkward. updateFromStyle()? Can it just take a RenderStyle&? I agree -- using RenderStyle makes things a bit simpler. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:146 >> + } > > Can't you just compare the Vectors? Removed the operator==. I'll keep this in mind for the next patch though. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:31 >> +#include "HTMLElement.h" > > class HTMLElement instead? Changed to forward declaration. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:47 >> + LayoutUnit closestSnapPosition(LayoutUnit, float = 0) const; > > Could you add the argument names? There's no way to tell what those LayoutUnits are for by looking at the .h file. Fixed. >>> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:52 >>> + Vector<LayoutUnit> offsets; >> >> private? m_offsets? > > Yes. Made it private. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:53 >> + bool dirty; > > not used. Removed. >> Source/WebCore/platform/ScrollableArea.cpp:45 >> +#include "Element.h" > > HTMLElement.h includes Element.h (indirectly) Got it. Removed Element.h >> Source/WebCore/platform/ScrollableArea.cpp:49 >> +#endif > > Bunch of layering violations here. ScrollableArea should not know anything about elements or renderers. Got it. Moved bulk of logic to AxisScrollSnapOffsets. >> Source/WebCore/platform/ScrollableArea.cpp:59 >> +#endif > > not used? Used to add pointers to the snap axes in ScrollableArea. >> Source/WebCore/platform/ScrollableArea.cpp:207 >> +void ScrollableArea::updateSnapAxisFromElementAndStyle(ScrollEventAxis axis, Element* scrollingElement, RenderBox* box, const RenderStyle& style) > > Element& RenderBox& ? Fixed. >> Source/WebCore/platform/ScrollableArea.h:31 >> +#include "AxisScrollSnapOffsets.h" > > wrong order. Changed to use just a forward declaration. >> Source/WebCore/platform/ScrollableArea.h:47 >> +class AxisScrollSnapOffsets; > > already included. Removed. >> Source/WebCore/platform/ScrollableArea.h:72 >> + virtual void updateSnapAxis(ScrollEventAxis) { }; > > The name could be better; you're updating offsets for an axis, not the axis itself. > Also, this means you're doing TWO tree walks per update (one per axis). You should do both axes at the same time. Changed to updateSnapOffsets(). Also changed to make sure only 1 tree walk happens iff at least 1 axis depends on elements. >> Source/WebCore/platform/ScrollableArea.h:279 >> + void updateSnapAxisFromElementAndStyle(ScrollEventAxis, Element*, RenderBox*, const RenderStyle&); > > To resolve this layering violation, you either have to make this virtual, or compute the offsets externally and put them onto ScrollableArea. Moved logic to AxisScrollSnapOffsets. >> Source/WebCore/platform/ScrollableArea.h:298 >> + mutable OwnPtr<AxisScrollSnapOffsets> m_verticalSnapAxis; > > Why mutable? > Better names would be m_horizontalSnapOffsets etc. It was mutable because my getter was marked const but created a new snap offset list if it didn't exist (I looked to scrollAnimator() const for reference -- m_scrollAnimator is also a mutable OwnPtr). I've changed the getter to not use const. 1028521 13 236449 wenson_hsieh 2014-08-12 09:18:08 -0700 Created attachment 236449 Patch 1028525 14 236450 wenson_hsieh 2014-08-12 09:48:01 -0700 Created attachment 236450 Patch 1028532 15 236453 wenson_hsieh 2014-08-12 10:18:30 -0700 Created attachment 236453 Patch 1028543 16 236453 simon.fraser 2014-08-12 11:25:16 -0700 Comment on attachment 236453 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236453&action=review > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:94 > + LayoutUnit viewWidth = box->width(); > + LayoutUnit viewHeight = box->height(); > + LayoutUnit positionX = box->x(); > + LayoutUnit positionY = box->y(); This is making assumptions about the render tree that may not be correct in some cases; box->x() isn't necessarily the offset from parent's renderer. It also ignores CSS transforms (for which you need to add test cases). You should use RenderObject conversion functions. What happens if the snap points are non-ordered (e.g. child has position: absolute; left: -200px). Do you need to sort the sequence somewhere? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:130 > + m_offsets.append(potentialSnapPosition); > + lastSnapPosition = potentialSnapPosition + destinationOffset; As we discussed, this is susceptible to memory explosion with crazy content (repeat 1px). Please add a FIXME. > Source/WebCore/platform/ScrollableArea.cpp:36 > +#include "AxisScrollSnapOffsets.h" Uh oh, platform code can't include page/scrolling code. > Source/WebCore/platform/ScrollableArea.h:288 > + OwnPtr<AxisScrollSnapOffsets> m_horizontalSnapOffsets; > + OwnPtr<AxisScrollSnapOffsets> m_verticalSnapOffsets; I think these need to be raw Vector<LayoutUnit> here to avoid layering violations. That turns AxisScrollSnapOffsets into a helper that just spits out a Vector<LayoutUnit>. 1028649 17 236453 wenson_hsieh 2014-08-12 16:10:44 -0700 Comment on attachment 236453 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236453&action=review Thank you for the review! >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:94 >> + LayoutUnit positionY = box->y(); > > This is making assumptions about the render tree that may not be correct in some cases; box->x() isn't necessarily the offset from parent's renderer. It also ignores CSS transforms (for which you need to add test cases). > > You should use RenderObject conversion functions. > > What happens if the snap points are non-ordered (e.g. child has position: absolute; left: -200px). Do you need to sort the sequence somewhere? Good point -- totally missed this. I'll need to sort the subsequence here after iterating through the children. Same goes for the "... repeat(...)" case. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:130 >> + lastSnapPosition = potentialSnapPosition + destinationOffset; > > As we discussed, this is susceptible to memory explosion with crazy content (repeat 1px). Please add a FIXME. Got it. >> Source/WebCore/platform/ScrollableArea.cpp:36 >> +#include "AxisScrollSnapOffsets.h" > > Uh oh, platform code can't include page/scrolling code. :( >> Source/WebCore/platform/ScrollableArea.h:288 >> + OwnPtr<AxisScrollSnapOffsets> m_verticalSnapOffsets; > > I think these need to be raw Vector<LayoutUnit> here to avoid layering violations. That turns AxisScrollSnapOffsets into a helper that just spits out a Vector<LayoutUnit>. Fixed. (I've made AxisScrollSnapOffsets just contain a helper function for constructing snap points. It will also contain a function to get the closest snap offset in the future.) 1028665 18 236482 wenson_hsieh 2014-08-12 16:33:36 -0700 Created attachment 236482 Patch 1028727 19 236482 sam 2014-08-12 22:56:03 -0700 Comment on attachment 236482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236482&action=review > Source/WebCore/platform/ScrollableArea.h:271 > + OwnPtr<Vector<LayoutUnit>> m_horizontalSnapOffsets; > + OwnPtr<Vector<LayoutUnit>> m_verticalSnapOffsets; These should be std::unique_ptrs 1028785 20 236522 wenson_hsieh 2014-08-13 06:54:25 -0700 Created attachment 236522 Patch 1028786 21 236482 wenson_hsieh 2014-08-13 06:54:54 -0700 Comment on attachment 236482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236482&action=review >> Source/WebCore/platform/ScrollableArea.h:271 >> + OwnPtr<Vector<LayoutUnit>> m_verticalSnapOffsets; > > These should be std::unique_ptrs Fixed. Thanks! 1028818 22 236522 simon.fraser 2014-08-13 10:24:56 -0700 Comment on attachment 236522 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236522&action=review > Source/WebCore/page/FrameView.cpp:869 > + if (!m_horizontalSnapOffsets) > + m_horizontalSnapOffsets = std::make_unique<Vector<LayoutUnit>>(); > + > + if (!m_verticalSnapOffsets) > + m_verticalSnapOffsets = std::make_unique<Vector<LayoutUnit>>(); You shouldn't allocate these vectors if there are no snap points. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:98 > +void updateHorizontalVerticalSnapOffsets(Vector<LayoutUnit>& horizontalSnapOffsets, Vector<LayoutUnit>& verticalSnapOffsets, HTMLElement& scrollingElement, const RenderBox& box, const RenderStyle& style) This should have two unique_ptr<Vector<LayoutUnit>>& out params so that you can only allocate the vectors if you have snap points. > Source/WebCore/platform/ScrollableArea.h:271 > + std::unique_ptr<Vector<LayoutUnit>> m_horizontalSnapOffsets; > + std::unique_ptr<Vector<LayoutUnit>> m_verticalSnapOffsets; Please make these private and provide protected setters. 1028898 23 236550 wenson_hsieh 2014-08-13 14:05:20 -0700 Created attachment 236550 Patch 1028903 24 236552 wenson_hsieh 2014-08-13 14:10:13 -0700 Created attachment 236552 Patch 1028906 25 236550 simon.fraser 2014-08-13 14:13:49 -0700 Comment on attachment 236550 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236550&action=review > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:60 > + std::sort(horizontalSnapOffsetSubsequence.begin(), horizontalSnapOffsetSubsequence.end()); sort somehow knows how to sort LayoutUnits? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:75 > + LayoutUnit potentialSnapPosition; This should be declared inside the loop. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:112 > + if (!computeHorizontalSnapOffsets && !computeVerticalSnapOffsets) > + return; Shouldn't you call scrollableArea.clearHorizontalSnapOffsets() etc here too? Or just return after the next two blocks. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:130 > + if (style.scrollSnapUsesElementsX() || style.scrollSnapUsesElementsY()) > + appendAndSortChildSnapOffsets(scrollingElement, computeHorizontalSnapOffsets, horizontalSnapOffsetSubsequence, computeVerticalSnapOffsets, verticalSnapOffsetSubsequence); > + > + if (computeHorizontalSnapOffsets) { > + if (!style.scrollSnapUsesElementsX()) { This logic is awkward. Would be nicer to set computeHorizontalSnapOffsets to false if style.scrollSnapUsesElementsX() is set, and rename it to horizontalOffsetsNeedsRecomputing. > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:134 > + for (Length snapLength : style.scrollSnapOffsetsX()) > + horizontalSnapOffsetSubsequence.append(valueForLength(snapLength, viewWidth)); > + > + std::sort(horizontalSnapOffsetSubsequence.begin(), horizontalSnapOffsetSubsequence.end()); Why doesn't updateFromStyle() do this work? > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:43 > +void updateSnapOffsetsForScrollableArea(ScrollableArea&, HTMLElement& scrollingElement, const RenderBox&, const RenderStyle&); The RenderBox needs a name; does it correspond with the element? So does the style; which element's style is it? > Source/WebCore/platform/ScrollableArea.cpp:396 > + m_horizontalSnapOffsets.reset(); m_horizontalSnapOffsets.reset = nullptr > Source/WebCore/platform/ScrollableArea.cpp:401 > + m_verticalSnapOffsets.reset(); m_verticalSnapOffsets = nullptr > Source/WebCore/platform/ScrollableArea.h:63 > + Vector<LayoutUnit>* horizontalSnapOffsets() const { return m_horizontalSnapOffsets.get(); }; > + Vector<LayoutUnit>* verticalSnapOffsets() const { return m_verticalSnapOffsets.get(); }; Should turn const Vector<>..... Don't want the caller messing with it. 1028935 26 236550 wenson_hsieh 2014-08-13 15:37:18 -0700 Comment on attachment 236550 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236550&action=review >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:60 >> + std::sort(horizontalSnapOffsetSubsequence.begin(), horizontalSnapOffsetSubsequence.end()); > > sort somehow knows how to sort LayoutUnits? By default, std::sort uses operator<, which is declared in LayoutUnit.h, so this should be fine. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:75 >> + LayoutUnit potentialSnapPosition; > > This should be declared inside the loop. Fixed. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:112 >> + return; > > Shouldn't you call scrollableArea.clearHorizontalSnapOffsets() etc here too? Or just return after the next two blocks. Good catch -- the early return should happen afterwards. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:130 >> + if (!style.scrollSnapUsesElementsX()) { > > This logic is awkward. Would be nicer to set computeHorizontalSnapOffsets to false if style.scrollSnapUsesElementsX() is set, and rename it to horizontalOffsetsNeedsRecomputing. Moved around some logic and renamed variables to make what I'm doing more clear. The part where I build the subsequence from "elements" or from "...repeat(...)" is now in the same place, which happens before I make calls to updateFromStyle. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:134 >> + std::sort(horizontalSnapOffsetSubsequence.begin(), horizontalSnapOffsetSubsequence.end()); > > Why doesn't updateFromStyle() do this work? Moved sorting and size check over to updateFromStyle. >> Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h:43 >> +void updateSnapOffsetsForScrollableArea(ScrollableArea&, HTMLElement& scrollingElement, const RenderBox&, const RenderStyle&); > > The RenderBox needs a name; does it correspond with the element? So does the style; which element's style is it? Fixed (scrollingElement___) >> Source/WebCore/platform/ScrollableArea.cpp:396 >> + m_horizontalSnapOffsets.reset(); > > m_horizontalSnapOffsets.reset = nullptr Changed to = nullptr. >> Source/WebCore/platform/ScrollableArea.cpp:401 >> + m_verticalSnapOffsets.reset(); > > m_verticalSnapOffsets = nullptr Changed to = nullptr. >> Source/WebCore/platform/ScrollableArea.h:63 >> + Vector<LayoutUnit>* verticalSnapOffsets() const { return m_verticalSnapOffsets.get(); }; > > Should turn const Vector<>..... Don't want the caller messing with it. Fixed. 1028936 27 236558 wenson_hsieh 2014-08-13 15:37:43 -0700 Created attachment 236558 Patch 1028937 28 236558 wenson_hsieh 2014-08-13 15:39:34 -0700 Comment on attachment 236558 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=236558&action=review > Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp:128 > + if (!scrollingElementStyle.scrollSnapUsesElementsY() && canComputeHorizontalOffsets) { Typo: canComputeVerticalOffsets 1028939 29 236560 wenson_hsieh 2014-08-13 15:43:32 -0700 Created attachment 236560 Patch 1028969 30 236560 commit-queue 2014-08-13 17:16:19 -0700 Comment on attachment 236560 Patch Clearing flags on attachment: 236560 Committed r172543: <http://trac.webkit.org/changeset/172543> 1028970 31 commit-queue 2014-08-13 17:16:26 -0700 All reviewed patches have been landed. Closing bug. 236164 2014-08-06 19:12:02 -0700 2014-08-07 15:15:20 -0700 Patch bug-135268-20140806191150.patch text/plain 32155 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyMTk4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz YzkyNjJlOWQyNjFkZTE3OWYxNmVjN2Q1NGY0N2Q5Y2Y3NDg0NzQyLi5kMDRlYmVlYmYxMDhlNzBi YjcyMDE0OGY2Y2EwNjY0ZjIwYTNhZWI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxNC0wOC0wNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisK KyAgICAgICAgRW5hYmxlIENTU19TQ1JPTExfU05BUCBvbiBpUGhvbmVPUyBhbmQgc2ltdWxhdG9y LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogQ29u ZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDYgIE1hcmsg TGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAgICAgIEdhcmRlbmluZzogZml4IGZvciBi dWlsZCBmYWlsdXJlIG9uIEVGTCBib3RzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDk2ZDM1OTljOTNkZjc4ZTYy M2ZkMDA3NTVlYTAyMzE0NzM5MjFmNTUuLmI4ZDRlYTIzZGI4ZjM4ODgwYWRmNjYzNDY4NzQ5ZDRk NWY1YWE3MDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0MCBAQAorMjAxNC0wOC0wNiAgV2Vuc29u IEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBz dG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV29ya2luZyB0b3dhcmRzIGltcGxlbWVudGluZyBhIHdheSB0byBl eHRyYWN0IHNuYXAgcG9zaXRpb25zIChpLmUuIExheW91dFVuaXRzKSBmcm9tIHRoZSBwYXJzZWQg c25hcCBwb2ludCBwcm9wZXJ0aWVzIGZyb20gQ1NTLAorICAgICAgICBhcyB3ZWxsIGFzIGEgd2F5 IG9mIHN0b3JpbmcgdGhlIGluZm9ybWF0aW9uLiBTdXBwb3J0cyBib3RoIG1haW5mcmFtZSBhbmQg b3ZlcmZsb3cgc2Nyb2xsaW5nLgorCisgICAgICAgIENhbid0IGZpbmQgYSB3YXkgdG8gdGVzdCB0 aGlzIHlldC4KKworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIENvbmZpZ3Vy YXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFw TWFuYWdlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6 U25hcFBvc2l0aW9uTGlzdCk6IEluaXRpYWxpemVzIGFuIGVtcHR5IFNuYXBQb3NpdGlvbkxpc3Qu CisgICAgICAgIChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0OjpzaXplKToKKyAgICAgICAgKFdl YkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6OmNsZWFyKToKKyAgICAgICAgKFdlYkNvcmU6OlNuYXBQ b3NpdGlvbkxpc3Q6OnJlc2l6ZSk6CisgICAgICAgIChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0 OjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNu YXBQb3NpdGlvbik6IENvbXB1dGUgdGhlIGNsb3Nlc3Qgc25hcCBwb3NpdGlvbiBnaXZlbiBpbml0 aWFsIHNjcm9sbCB2ZWxvY2l0eS4KKyAgICAgICAgKFdlYkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6 OnRvU3RyaW5nKTogVmVyeSBjb252ZW5pZW50IGZvciB0ZXN0aW5nLiBXaWxsIGJlIHJlbW92ZWQg c29vbi4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjpTY3JvbGxTbmFwTWFu YWdlcik6CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6Y3JlYXRlKTogSW5p dGlhbGl6ZXMgYW5kIHJldHVybnMgYSBuZXcgU2Nyb2xsU25hcE1hbmFnZXIuCisgICAgICAgIChX ZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tRnJhbWVWaWV3KTog VXNlZCB0byB1cGRhdGUgc25hcCBkYXRhIGluIHRoZSBjYXNlIG9mIG1haW5mcmFtZSBzY3JvbGxp bmcuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFG cm9tUGFyZW50RWxlbWVudCk6IFVzZWQgdG8gdXBkYXRlIHNuYXAgZGF0YSBpbiB0aGUgY2FzZSBv ZiBvdmVyZmxvdyBzY3JvbGxpbmcuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdl cjo6dXBkYXRlU25hcERhdGFGcm9tU3R5bGVBbmRQYXJlbnRFbGVtZW50KTogSGVscGVyIG1ldGhv ZC4gVXNlZCB3aGVuICJlbGVtZW50cyIgaXMgc3BlY2lmaWVkIGZvciAtc25hcC1wb2ludHMteC95 LgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJv bVN0eWxlKTogSGVscGVyIG1ldGhvZC4gVXNlZCB3aGVuIHNuYXAgcG9pbnRzIGFyZSBzcGVjaWZp ZWQgaW4gYSBsaXN0L3JlcGVhdCg8bGVuZ3RoPikgZm9ybWF0LgorICAgICAgICAoV2ViQ29yZTo6 U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBQb3NpdGlvbnNGcm9tT2Zmc2V0cyk6IEhlbHBl ciBtZXRob2QuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6c2Nyb2xsYWJs ZUFyZWEpOiBUaGUgU2Nyb2xsYWJsZUFyZWEgdGhpcyBTY3JvbGxTbmFwTWFuYWdlciB3aWxsIHVz ZSB0byBwcm9ncmFtbWF0aWNhbGx5IHNjcm9sbCBpbi4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9s bFNuYXBNYW5hZ2VyOjpheGlzKTogRGV0ZXJtaW5lcyB0aGUgc2Nyb2xsaW5nIGF4aXMgKGhvcml6 b250YWwgb3IgdmVydGljYWwpIG9mIHRoZSBTY3JvbGxTbmFwTWFuYWdlci4KKyAgICAgICAgKiBw YWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdlci5oOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0 Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJl YTo6c2Nyb2xsU25hcE1hbmFnZXIpOgorICAgICAgICAqIHBsYXRmb3JtL1Njcm9sbGFibGVBcmVh Lmg6CisKIDIwMTQtMDgtMDYgIE15bGVzIEMuIE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxlLmNv bT4KIAogICAgICAgICBbaU9TXSBNYWtlIGRvY3VtZW50IG1hcmtlciBhc3NldHMgbm90IHNwZWNp ZmljIHRvIHBhcnRpY3VsYXIgc2NhbGUgZmFjdG9ycwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9tYWMvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDMyYTJi Nzc1NWJiMDAyNzNlMWQ3Y2RjMzM2ZmMxMzA2ZWQ5NjZlNGYuLjcyODEwZTE0NDNjYzBhNWMwNDc0 NDcxMzFhMjIwMDJkODQyMDE4OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAor MjAxNC0wOC0wNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAg ICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlZCBDU1NfU0NST0xMX1NO QVAgZm9yIGlQaG9uZU9TIGFuZCB0aGUgc2ltdWxhdG9yLgorCisgICAgICAgICogQ29uZmlndXJh dGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDYgIERlYW4gSmFja3Nv biAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAgIEVOQUJMRV9DU1NfVFJBTlNGT1JNU19BTklN QVRJT05TX1VOUFJFRklYRUQgaXMgbm90IHVzZWQgYW55d2hlcmUuIFJlbW92ZSBpdC4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxv ZwppbmRleCA5NGUzZTcwZjk5OTkxN2ZiYjk1MDJkNDNjOWEyYjFkMWJkNGQ5MDU2Li5iMWJjMzA4 ZGZiZDQzYmNlZjVjYjliNTYyNjVjM2RmMjgxNTBhM2VlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTQgQEAKKzIwMTQtMDgtMDYgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+ CisKKyAgICAgICAgQ29tcHV0ZSBhbmQgc3RvcmUgc25hcCBwb2ludCBwb3NpdGlvbnMKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNTI2OAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZWQgQ1NTX1ND Uk9MTF9TTkFQIGZvciBpUGhvbmVPUyBhbmQgdGhlIHNpbXVsYXRvci4KKworICAgICAgICAqIENv bmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnOgorCiAyMDE0LTA4LTA2ICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KIAogICAgICAgICBFTkFCTEVfQ1NTX1RSQU5TRk9S TVNfQU5JTUFUSU9OU19VTlBSRUZJWEVEIGlzIG5vdCB1c2VkIGFueXdoZXJlLiBSZW1vdmUgaXQu CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ29uZmlndXJhdGlvbnMvRmVhdHVy ZURlZmluZXMueGNjb25maWcgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ29uZmlndXJhdGlvbnMv RmVhdHVyZURlZmluZXMueGNjb25maWcKaW5kZXggMzEwYzZlZmRlZDM5YzQ2ZTI3ZGRhZjQ5YmNi ZWRkNTQ3ZWVkMDBhZi4uMTAwMzM1YTY5NDM0MDdmNTg4MDQ1YTFjNDBjNzZlNjY0NWY0ZmYyZSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVE ZWZpbmVzLnhjY29uZmlnCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Db25maWd1cmF0aW9u cy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAtMTg3LDYgKzE4Nyw4IEBAIEVOQUJMRV9TQ1JJ UFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVfU0hBUkVEX1dPUktFUlMgPSBFTkFCTEVfU0hBUkVEX1dP UktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQ XyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUF9tYWNvc3ggPSBFTkFC TEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyA9IEVO QUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVs YXRvciA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNI X1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQRUVDSF9TWU5USEVTSVNfJChQTEFURk9STV9OQU1FKSk7 CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5B QkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJMRV9TUUxfREFUQUJBU0U7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0 CmluZGV4IDBkZTQ5NmM0OWM1OGM2ZTg4YmEwZjJhYzBlYjE1ZDkwYzc2Mjk3YmEuLmQ3ZjlkNmJh MGQ4YTYxNTMzM2U5ZjBiNmE0Yzc0YTM2YmEwNTgxYjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CkBA IC0xOTY3LDYgKzE5NjcsNyBAQCBzZXQoV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGFnZS9zY3JvbGxp bmcvU2Nyb2xsaW5nU3RhdGVTY3JvbGxpbmdOb2RlLmNwcAogICAgIHBhZ2Uvc2Nyb2xsaW5nL1Nj cm9sbGluZ1N0YXRlU3RpY2t5Tm9kZS5jcHAKICAgICBwYWdlL3Njcm9sbGluZy9TY3JvbGxpbmdT dGF0ZVRyZWUuY3BwCisgICAgcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3BwCiAK ICAgICBwbGF0Zm9ybS9DYWxjdWxhdGlvblZhbHVlLmNwcAogICAgIHBsYXRmb3JtL0Nsb2NrLmNw cApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmlu ZXMueGNjb25maWcgYi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5l cy54Y2NvbmZpZwppbmRleCAzMTBjNmVmZGVkMzljNDZlMjdkZGFmNDliY2JlZGQ1NDdlZWQwMGFm Li4xMDAzMzVhNjk0MzQwN2Y1ODgwNDVhMWM0MGM3NmU2NjQ1ZjRmZjJlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpA QCAtMTg3LDYgKzE4Nyw4IEBAIEVOQUJMRV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVfU0hB UkVEX1dPUktFUlMgPSBFTkFCTEVfU0hBUkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9MTF9T TkFQID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxF X0NTU19TQ1JPTExfU05BUF9tYWNvc3ggPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxF X0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFC TEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NTU19TQ1JPTExf U05BUF9pcGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQRUVD SF9TWU5USEVTSVNfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9 IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJMRV9T UUxfREFUQUJBU0U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKaW5kZXggZWM4OTYzYTJiZjEzZTEwYzdlYTI4NWMzZWQ4YzhlNjY1MzQ0ZGI5 Zi4uNzE4YjhhZWZiMzVkYjI4ZDgyYWE0MGVjYzc3NmI1YjYxNTQzZjAxOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNjI1OCw2 ICs2MjU4LDggQEAKIAkJRjQyRkZCNDYxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQyRkZCNDUx OTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovOyB9OwogCQlGNDdBNUUzRTE5NUI4 QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyog U3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNw cCAqLzsgfTsKKwkJRjQ5NDBCREYxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2Vy LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0OTQw QkREMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdlci5jcHAgKi87IH07CisJCUY0 OTQwQkUwMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdlci5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ5NDBCREUxOTgyRjQ2QTAwMTdE QjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAo UHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250 cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CiAJ CUY1MDY2NEY4MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUwNjY0RjYxNTdGNTJEQzAwQUMy MjZGIC8qIEZvcm1Db250cm9sbGVyLmggKi87IH07CiAJCUY1MTNBM0VBMTVGRjQ4NDEwMDE1MjZE QiAvKiBWYWxpZGF0aW9uTWVzc2FnZUNsaWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gRjUxM0EzRTkxNUZGNDg0MTAwMTUyNkRCIC8qIFZhbGlkYXRp b25NZXNzYWdlQ2xpZW50LmggKi87IH07CkBAIC0xMzc5MCw2ICsxMzc5Miw4IEBACiAJCUY0MkZG QjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUY0N0E1RTNBMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9p bnRzLmNwcDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNj cm9sbFNuYXBQb2ludHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU3R5bGVT Y3JvbGxTbmFwUG9pbnRzLmg7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ5NDBCREQxOTgyRjQ2QTAwMTdEQjYxIC8q IFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ RjQ5NDBCREUxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJv bGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGb3JtQ29udHJv bGxlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY2MTU3RjUyREMw MEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBGb3JtQ29udHJvbGxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTEz QTNFOTE1RkY0ODQxMDAxNTI2REIgLyogVmFsaWRhdGlvbk1lc3NhZ2VDbGllbnQuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVmFsaWRhdGlvbk1lc3NhZ2VDbGllbnQuaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1MTY1LDYgKzE1MTY5LDggQEAKIAkJCQk5Mzkx QTk5QjE2MjlENzAwMDAyOTczMzAgLyogU2Nyb2xsaW5nVHJlZVNjcm9sbGluZ05vZGUuaCAqLywK IAkJCQkwRjYzODNEQjE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmNw cCAqLywKIAkJCQkwRjYzODNEQzE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3JvbGxpbmdU cmVlLmggKi8sCisJCQkJRjQ5NDBCREQxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5h Z2VyLmNwcCAqLywKKwkJCQlGNDk0MEJERTE5ODJGNDZBMDAxN0RCNjEgLyogU2Nyb2xsU25hcE1h bmFnZXIuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gc2Nyb2xsaW5nOwogCQkJc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsKQEAgLTI0MDM5LDYgKzI0MDQ1LDcgQEAKIAkJCQlBMUM3OTcxRDE4ODNFNTFG MDAwRjVFMUYgLyogRE9NSFRNTFRleHRBcmVhRWxlbWVudFByaXZhdGUuaCBpbiBIZWFkZXJzICov LAogCQkJCTg1OTkyRUMwMEFBNTA2OTUwMEFDMDc4NSAvKiBET01IVE1MVGl0bGVFbGVtZW50Lmgg aW4gSGVhZGVycyAqLywKIAkJCQk4NUU3MTFDRjBBQzVENTM1MDA1MzI3MEYgLyogRE9NSFRNTFRp dGxlRWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywKKwkJCQlGNDk0MEJFMDE5ODJGNDZB MDAxN0RCNjEgLyogU2Nyb2xsU25hcE1hbmFnZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTg1QkE0 RDE3MEFBNjg4NjgwMDg4MDUyRCAvKiBET01IVE1MVUxpc3RFbGVtZW50LmggaW4gSGVhZGVycyAq LywKIAkJCQk4NUU3MTFEMDBBQzVENTM1MDA1MzI3MEYgLyogRE9NSFRNTFVMaXN0RWxlbWVudElu dGVybmFsLmggaW4gSGVhZGVycyAqLywKIAkJCQlBODE4NUYzQjA5NzY1NzY2MDA1ODI2RDkgLyog RE9NSW1wbGVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovLApAQCAtMjc0MDMsNiArMjc0MTAsNyBA QAogCQkJCUE4ODJEQTIwMTU5Mzg0NkEwMDAxMTVFRCAvKiBDU1NUb1N0eWxlTWFwLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTM3MUY1M0VBMEQyNzA0RjkwMEVDRTBENSAvKiBDU1NVbmljb2RlUmFu Z2VWYWx1ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBRDAzQUFGQTE0Njg0NTUzMDBBMzlCNUIg LyogQ1NTVmFsdWUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ5NDBCREYxOTgyRjQ2QTAwMTdE QjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTFBQkE3NkNC MTFEMjBFNTcwMDRDMjAxQyAvKiBDU1NWYWx1ZUtleXdvcmRzLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCUE4MEU2Q0U0MEExOTg5Q0EwMDdGQjhDNSAvKiBDU1NWYWx1ZUxpc3QuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJRTQ5QkRBMEIxMzFGRDNFNTAwM0M1NkYwIC8qIENTU1ZhbHVlUG9vbC5jcHAg aW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5n L1Njcm9sbFNuYXBNYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Nj cm9sbFNuYXBNYW5hZ2VyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMzhhZTQ5ZGJkMmQ3NGIzNGVlMWNmNTk3 YWU3MTRiMTEzZDdiOWJiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9z Y3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3BwCkBAIC0wLDAgKzEsMjY2IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YK KyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up CisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlNjcm9sbFNuYXBNYW5hZ2VyLmgi CisKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjaW5jbHVkZSAiRnJhbWVWaWV3Lmgi CisjaW5jbHVkZSAiSFRNTENvbGxlY3Rpb24uaCIKKyNpbmNsdWRlICJSZW5kZXJCb3guaCIKKyNp bmNsdWRlICJSZW5kZXJWaWV3LmgiCisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5o PgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1NuYXBQb3NpdGlvbkxpc3Q6OlNuYXBQb3NpdGlv bkxpc3QoKQoreworfQorCitTbmFwUG9zaXRpb25MaXN0OjpTbmFwUG9zaXRpb25MaXN0KFZlY3Rv cjxMYXlvdXRVbml0PiBzbmFwUG9zaXRpb25zKQorICAgIDogcG9zaXRpb25zKHNuYXBQb3NpdGlv bnMpCit7Cit9CisKK3NpemVfdCBTbmFwUG9zaXRpb25MaXN0OjpzaXplKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gcG9zaXRpb25zLnNpemUoKTsKK30KKwordm9pZCBTbmFwUG9zaXRpb25MaXN0Ojpj bGVhcigpCit7CisgICAgcG9zaXRpb25zLmNsZWFyKCk7Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9u TGlzdDo6cmVzaXplKHNpemVfdCBzaXplKQoreworICAgIHBvc2l0aW9ucy5yZXNpemUoc2l6ZSk7 Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9uTGlzdDo6YXBwZW5kKExheW91dFVuaXQgcG9zaXRpb24p Cit7CisgICAgcG9zaXRpb25zLmFwcGVuZChwb3NpdGlvbik7Cit9CisKK0xheW91dFVuaXQgU25h cFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNuYXBQb3NpdGlvbihMYXlvdXRVbml0IHNjcm9sbERlc3Rp bmF0aW9uLCBmbG9hdCB2ZWxvY2l0eSkgY29uc3QKK3sKKyAgICBpZiAoc2Nyb2xsRGVzdGluYXRp b24gPD0gMCkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKHNjcm9sbERlc3RpbmF0aW9uID49 IHBvc2l0aW9ucy5hdChwb3NpdGlvbnMuc2l6ZSgpIC0gMSkpCisgICAgICAgIHJldHVybiBwb3Np dGlvbnMuYXQocG9zaXRpb25zLnNpemUoKSAtIDEpOworICAgIHNpemVfdCBsb3dlckluZGV4ID0g MDsKKyAgICBzaXplX3QgdXBwZXJJbmRleCA9IHBvc2l0aW9ucy5zaXplKCkgLSAxOworICAgIHNp emVfdCBtaWRkbGVJbmRleDsKKworICAgIHdoaWxlIChsb3dlckluZGV4IDwgdXBwZXJJbmRleCAt IDEpIHsKKyAgICAgICAgbWlkZGxlSW5kZXggPSAobG93ZXJJbmRleCArIHVwcGVySW5kZXgpIC8g MjsKKyAgICAgICAgaWYgKHNjcm9sbERlc3RpbmF0aW9uIDwgcG9zaXRpb25zLmF0KG1pZGRsZUlu ZGV4KSkKKyAgICAgICAgICAgIHVwcGVySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgZWxz ZSBpZiAoc2Nyb2xsRGVzdGluYXRpb24gPiBwb3NpdGlvbnMuYXQobWlkZGxlSW5kZXgpKQorICAg ICAgICAgICAgbG93ZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICBlbHNlIHsKKyAgICAg ICAgICAgIHVwcGVySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGxvd2VySW5kZXgg PSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorICAg IExheW91dFVuaXQgbG93ZXJTbmFwUG9zaXRpb24gPSBwb3NpdGlvbnMuYXQobG93ZXJJbmRleCk7 CisgICAgTGF5b3V0VW5pdCB1cHBlclNuYXBQb3NpdGlvbiA9IHBvc2l0aW9ucy5hdCh1cHBlcklu ZGV4KTsKKyAgICAvLyBOb256ZXJvIHZlbG9jaXR5IGluZGljYXRlcyBhIGZsaWNrIGdlc3R1cmUu IEV2ZW4gaWYgYW5vdGhlciBzbmFwIHBvaW50IGlzIGNsb3Nlciwgc25hcCB0byB0aGUgb25lIGlu IHRoZSBkaXJlY3Rpb24gb2YgdGhlIGZsaWNrIGdlc3R1cmUuCisgICAgaWYgKHZlbG9jaXR5KQor ICAgICAgICByZXR1cm4gdmVsb2NpdHkgPCAwID8gbG93ZXJTbmFwUG9zaXRpb24gOiB1cHBlclNu YXBQb3NpdGlvbjsKKyAgICAvLyBJZiB2ZWxvY2l0eSBpcyB6ZXJvLCB0aGVuIHRoZSB1c2VyIHJl bGVhc2VkIHdpdGhvdXQgZmxpY2tpbmcsIHNvIHdlIHNpbXBseSBzbmFwIHRvIHRoZSBjbG9zZXIg cG9pbnQuCisgICAgcmV0dXJuIHNjcm9sbERlc3RpbmF0aW9uIC0gbG93ZXJTbmFwUG9zaXRpb24g PD0gdXBwZXJTbmFwUG9zaXRpb24gLSBzY3JvbGxEZXN0aW5hdGlvbiA/IGxvd2VyU25hcFBvc2l0 aW9uIDogdXBwZXJTbmFwUG9zaXRpb247Cit9CisKK1N0cmluZyBTbmFwUG9zaXRpb25MaXN0Ojp0 b1N0cmluZygpIGNvbnN0Cit7CisgICAgLy8gRklYTUU6IFRoaXMgaXMganVzdCBmb3IgZGVidWdn aW5nL3Rlc3RpbmcgcHVycG9zZXMuIFJlbW92ZSBpbiB0aGUgZmluYWwgdmVyc2lvbi4KKyAgICBT dHJpbmdCdWlsZGVyIGJ1aWxkZXI7CisgICAgYnVpbGRlci5hcHBlbmQoIlsgIik7CisgICAgZm9y IChMYXlvdXRVbml0IHBvc2l0aW9uIDogcG9zaXRpb25zKSB7CisgICAgICAgIGJ1aWxkZXIuYXBw ZW5kKFN0cmluZzo6bnVtYmVyVG9TdHJpbmdGaXhlZFdpZHRoKHBvc2l0aW9uLnRvSW50KCksIDAp KTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmRMaXRlcmFsKCIgIik7CisgICAgfQorICAgIGJ1aWxk ZXIuYXBwZW5kKCJdIik7CisgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKK30KKworU2Ny b2xsU25hcE1hbmFnZXI6OlNjcm9sbFNuYXBNYW5hZ2VyKFNjcm9sbGFibGVBcmVhKiBzY3JvbGxh YmxlQXJlYSwgU2Nyb2xsRXZlbnRBeGlzIGF4aXMpCisgICAgOiBwcm94aW1pdHkoMCkKKyAgICAs IG1heFNjcm9sbE9mZnNldCgwKQorICAgICwgaXNEaXJ0eShmYWxzZSkKKyAgICAsIG1fc2Nyb2xs YWJsZUFyZWEoc2Nyb2xsYWJsZUFyZWEpCisgICAgLCBtX2F4aXMoYXhpcykKK3sKK30KKworUGFz c093blB0cjxTY3JvbGxTbmFwTWFuYWdlcj4gU2Nyb2xsU25hcE1hbmFnZXI6OmNyZWF0ZShTY3Jv bGxhYmxlQXJlYSogc2Nyb2xsYWJsZUFyZWEsIFNjcm9sbEV2ZW50QXhpcyBheGlzKQoreworICAg IHJldHVybiBhZG9wdFB0cihuZXcgU2Nyb2xsU25hcE1hbmFnZXIoc2Nyb2xsYWJsZUFyZWEsIGF4 aXMpKTsKK30KKwordm9pZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tRnJh bWVWaWV3KEZyYW1lVmlldyogZnJhbWVWaWV3KQoreworICAgIGlmIChSZW5kZXJWaWV3KiByZW5k ZXJWaWV3ID0gZnJhbWVWaWV3LT5yZW5kZXJWaWV3KCkpIHsKKyAgICAgICAgSFRNTEVsZW1lbnQq IGJvZHkgPSByZW5kZXJWaWV3LT5kb2N1bWVudCgpLmJvZHkoKTsKKyAgICAgICAgaWYgKGJvZHkp IHsKKyAgICAgICAgICAgIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSA9IGJvZHktPnJlbmRlcmVy KCktPnN0eWxlKCk7CisgICAgICAgICAgICBMYXlvdXRVbml0IHNjcm9sbFNpemUgPSBtX2F4aXMg PT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gcmVuZGVyVmlldy0+c2Nyb2xsV2lkdGgo KSA6IHJlbmRlclZpZXctPnNjcm9sbEhlaWdodCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCBz aXplID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHJlbmRlclZpZXct PndpZHRoKCkgOiByZW5kZXJWaWV3LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIGlmICgobV9heGlz ID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCAmJiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNF bGVtZW50c1goKSkKKyAgICAgICAgICAgICAgICB8fCAobV9heGlzID09IFNjcm9sbEV2ZW50QXhp czo6VmVydGljYWwgJiYgIXN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNZKCkpKQorICAgICAg ICAgICAgICAgIHVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlKHN0eWxlLCBzaXplLCBzY3JvbGxTaXpl KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB1cGRhdGVTbmFwRGF0YUZyb21T dHlsZUFuZFBhcmVudEVsZW1lbnQoc3R5bGUsIGJvZHksIHNpemUsIHNjcm9sbFNpemUsIDApOwor ICAgICAgICB9CisgICAgfQorfQorCit2b2lkIFNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFw RGF0YUZyb21QYXJlbnRFbGVtZW50KEhUTUxFbGVtZW50KiBwYXJlbnQpCit7CisgICAgaWYgKFJl bmRlckJveCogcGFyZW50Qm94ID0gcGFyZW50LT5yZW5kZXJCb3goKSkgeworICAgICAgICBjb25z dCBSZW5kZXJTdHlsZSYgc3R5bGUgPSBwYXJlbnRCb3gtPnN0eWxlKCk7CisgICAgICAgIExheW91 dFVuaXQgc2l6ZSA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBwYXJl bnRCb3gtPndpZHRoKCkgOiBwYXJlbnRCb3gtPmhlaWdodCgpOworICAgICAgICBMYXlvdXRVbml0 IHNjcm9sbFNpemUgPSBtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gcGFy ZW50Qm94LT5zY3JvbGxXaWR0aCgpIDogcGFyZW50Qm94LT5zY3JvbGxIZWlnaHQoKTsKKyAgICAg ICAgaWYgKChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsICYmICFzdHlsZS5z Y3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpKQorICAgICAgICAgICAgfHwgKG1fYXhpcyA9PSBTY3Jv bGxFdmVudEF4aXM6OlZlcnRpY2FsICYmICFzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgp KSkKKyAgICAgICAgICAgIHVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlKHN0eWxlLCBzaXplLCBzY3Jv bGxTaXplKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgdXBkYXRlU25hcERhdGFGcm9tU3R5 bGVBbmRQYXJlbnRFbGVtZW50KHN0eWxlLCBwYXJlbnQsIHNpemUsIHNjcm9sbFNpemUsIG1fYXhp cyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBwYXJlbnRCb3gtPm9mZnNldExlZnQo KSA6IHBhcmVudEJveC0+b2Zmc2V0VG9wKCkpOworICAgIH0KK30KKwordm9pZCBTY3JvbGxTbmFw TWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tU3R5bGVBbmRQYXJlbnRFbGVtZW50KGNvbnN0IFJl bmRlclN0eWxlJiBzdHlsZSwgSFRNTEVsZW1lbnQqIHBhcmVudCwgTGF5b3V0VW5pdCBzaXplLCBM YXlvdXRVbml0IHNjcm9sbFNpemUsIExheW91dFVuaXQgcGFyZW50T2Zmc2V0KQoreworICAgIHN3 aXRjaCAoc3R5bGUuc2Nyb2xsU25hcFR5cGUoKSkgeworICAgIC8vIEZJWE1FOiBDbGFyaWZ5IGZy b20gdGhlIHNuYXAgcG9pbnRzIHNwZWMgZXhhY3RseSB3aGF0IHByb3hpbWl0eSBpcyBzdXBwb3Nl ZCB0byBkbyEgVGhpcyBpcyBqdXN0IGEgcGxhY2Vob2xkZXIuCisgICAgY2FzZSBTY3JvbGxTbmFw VHlwZTo6Tm9uZToKKyAgICAgICAgcmV0dXJuOworICAgIGNhc2UgU2Nyb2xsU25hcFR5cGU6OlBy b3hpbWl0eToKKyAgICAgICAgcHJveGltaXR5ID0gMTAwOworICAgICAgICBicmVhazsKKyAgICBj YXNlIFNjcm9sbFNuYXBUeXBlOjpNYW5kYXRvcnk6CisgICAgICAgIHByb3hpbWl0eSA9IHNjcm9s bFNpemU7CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICBtYXhTY3JvbGxPZmZzZXQgPSBzY3Jv bGxTaXplIC0gc2l6ZTsKKyAgICAvLyBIYW5kbGUgImVsZW1lbnRzIiBzcGVjaWZpY2F0aW9uIGJ5 IHRyYXZlcnNpbmcgY2hpbGRyZW4uCisgICAgc25hcFBvc2l0aW9ucy5jbGVhcigpOworICAgIEVs ZW1lbnQqIGNoaWxkID0gcGFyZW50LT5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAg ICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0ID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhp czo6SG9yaXpvbnRhbCA/IHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlv blgoKSwgc2l6ZSkgOiB2YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25Z KCksIHNpemUpOworICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAg ICBzbmFwUG9zaXRpb25zLmFwcGVuZCgwKTsKKyAgICB3aGlsZSAoY2hpbGQgJiYgbGFzdFBvdGVu dGlhbFNuYXBQb3NpdGlvbiA8IG1heFNjcm9sbE9mZnNldCkgeworICAgICAgICBpZiAoY2hpbGQt PmlzSFRNTEVsZW1lbnQoKSAmJiB0b0hUTUxFbGVtZW50KGNoaWxkKS0+cmVuZGVyQm94KCkpIHsK KyAgICAgICAgICAgIFJlbmRlckJveCogY2hpbGRCb3ggPSB0b0hUTUxFbGVtZW50KGNoaWxkKS0+ cmVuZGVyQm94KCk7CisgICAgICAgICAgICBMYXlvdXRVbml0IGNoaWxkU2l6ZSA9IG1fYXhpcyA9 PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBjaGlsZEJveC0+d2lkdGgoKSA6IGNoaWxk Qm94LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIExheW91dFVuaXQgY2hpbGRPZmZzZXQgPSAobV9h eGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IGNoaWxkQm94LT5vZmZzZXRMZWZ0 KCkgOiBjaGlsZEJveC0+b2Zmc2V0VG9wKCkpIC0gcGFyZW50T2Zmc2V0OworICAgICAgICAgICAg Zm9yIChTbmFwQ29vcmRpbmF0ZSBjb29yZGluYXRlIDogY2hpbGRCb3gtPnN0eWxlKCkuc2Nyb2xs U25hcENvb3JkaW5hdGVzKCkpIHsKKyAgICAgICAgICAgICAgICBMYXlvdXRVbml0IGNvb3JkaW5h dGVPZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jp em9udGFsID8gY29vcmRpbmF0ZS5maXJzdCA6IGNvb3JkaW5hdGUuc2Vjb25kLCBjaGlsZFNpemUp OworICAgICAgICAgICAgICAgIGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjaGlsZE9mZnNl dCArIGNvb3JkaW5hdGVPZmZzZXQgLSBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAgICAgICAg ICBpZiAobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbiA8PSAwKQorICAgICAgICAgICAgICAgICAg ICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICBpZiAobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlv biA+PSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAg ICAgICAgICAgIHNuYXBQb3NpdGlvbnMuYXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24p OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRF bGVtZW50U2libGluZygpOworICAgIH0KKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBv biB0aGUgbWF4aW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIGlmIChzbmFwUG9zaXRpb25zLnBvc2l0 aW9uc1tzbmFwUG9zaXRpb25zLnNpemUoKSAtIDFdICE9IG1heFNjcm9sbE9mZnNldCkKKyAgICAg ICAgc25hcFBvc2l0aW9ucy5hcHBlbmQobWF4U2Nyb2xsT2Zmc2V0KTsKK30KKwordm9pZCBTY3Jv bGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tU3R5bGUoY29uc3QgUmVuZGVyU3R5bGUm IHN0eWxlLCBMYXlvdXRVbml0IHNpemUsIExheW91dFVuaXQgc2Nyb2xsU2l6ZSkKK3sKKyAgICBp ZiAoc2Nyb2xsU2l6ZSA8PSAwIHx8IHNpemUgPD0gMCB8fCBzaXplID49IHNjcm9sbFNpemUpCisg ICAgICAgIHJldHVybjsKKyAgICAKKyAgICBzd2l0Y2ggKHN0eWxlLnNjcm9sbFNuYXBUeXBlKCkp IHsKKyAgICAvLyBGSVhNRTogQ2xhcmlmeSBmcm9tIHRoZSBzbmFwIHBvaW50cyBzcGVjIGV4YWN0 bHkgd2hhdCBwcm94aW1pdHkgaXMgc3VwcG9zZWQgdG8gZG8hIFRoaXMgaXMganVzdCBhIHBsYWNl aG9sZGVyLgorICAgIGNhc2UgU2Nyb2xsU25hcFR5cGU6Ok5vbmU6CisgICAgICAgIHJldHVybjsK KyAgICBjYXNlIFNjcm9sbFNuYXBUeXBlOjpQcm94aW1pdHk6CisgICAgICAgIHByb3hpbWl0eSA9 IDEwMDsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBTY3JvbGxTbmFwVHlwZTo6TWFuZGF0b3J5 OgorICAgICAgICBwcm94aW1pdHkgPSBzY3JvbGxTaXplOworICAgICAgICBicmVhazsKKyAgICB9 CisgICAgbWF4U2Nyb2xsT2Zmc2V0ID0gc2Nyb2xsU2l6ZSAtIHNpemU7CisgICAgVmVjdG9yPExl bmd0aD4gc25hcE9mZnNldHMgPSBtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFs ID8gc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNYKCkgOiBzdHlsZS5zY3JvbGxTbmFwT2Zmc2V0c1ko KTsKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gc25hcFBvc2l0aW9uU3Vic2VxdWVuY2U7CisgICAg Zm9yIChMZW5ndGggc25hcE9mZnNldCA6IHNuYXBPZmZzZXRzKQorICAgICAgICBzbmFwUG9zaXRp b25TdWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgoc25hcE9mZnNldCwgc2l6ZSkpOwor ICAgIGlmICghc25hcFBvc2l0aW9uU3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICBzbmFwUG9z aXRpb25TdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICBpZiAobV9heGlzID09IFNjcm9sbEV2 ZW50QXhpczo6SG9yaXpvbnRhbCkKKyAgICAgICAgdXBkYXRlU25hcFBvc2l0aW9uc0Zyb21PZmZz ZXRzKHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlLCB2YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxT bmFwRGVzdGluYXRpb25YKCksIHNpemUpLCBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WCgpLCB2 YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0WCgpLCBzaXplKSk7Cisg ICAgZWxzZQorICAgICAgICB1cGRhdGVTbmFwUG9zaXRpb25zRnJvbU9mZnNldHMoc25hcFBvc2l0 aW9uU3Vic2VxdWVuY2UsIHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlv blkoKSwgc2l6ZSksIHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRZKCksIHZhbHVlRm9yTGVuZ3Ro KHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZKCksIHNpemUpKTsKK30KKwordm9pZCBTY3Jv bGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcFBvc2l0aW9uc0Zyb21PZmZzZXRzKGNvbnN0IFZlY3Rv cjxMYXlvdXRVbml0PiYgc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UsIExheW91dFVuaXQgZGVzdGlu YXRpb25PZmZzZXQsIGJvb2wgaGFzUmVwZWF0LCBMYXlvdXRVbml0IHJlcGVhdE9mZnNldCkKK3sK KyAgICBzbmFwUG9zaXRpb25zLmNsZWFyKCk7CisgICAgTGF5b3V0VW5pdCBjdXJTbmFwUG9zaXRp b25TaGlmdCA9IC1kZXN0aW5hdGlvbk9mZnNldDsKKyAgICBMYXlvdXRVbml0IGxhc3RTbmFwUG9z aXRpb24gPSBjdXJTbmFwUG9zaXRpb25TaGlmdDsKKyAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNu YXBQb3NpdGlvbjsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0aGUgbWluaW11 bSBzY3JvbGwgb2Zmc2V0LgorICAgIHNuYXBQb3NpdGlvbnMuYXBwZW5kKDApOworICAgIGRvIHsK KyAgICAgICAgZm9yIChMYXlvdXRVbml0IHNuYXBQb3NpdGlvbiA6IHNuYXBQb3NpdGlvblN1YnNl cXVlbmNlKSB7CisgICAgICAgICAgICBwb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9z aXRpb25TaGlmdCArIHNuYXBQb3NpdGlvbjsKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFw UG9zaXRpb24gPD0gMCkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlm IChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAgICAgc25hcFBvc2l0aW9ucy5hcHBlbmQocG90ZW50aWFsU25h cFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFwUG9zaXRpb24gPSBwb3RlbnRpYWxTbmFw UG9zaXRpb247CisgICAgICAgIH0KKyAgICAgICAgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSBsYXN0 U25hcFBvc2l0aW9uICsgcmVwZWF0T2Zmc2V0OworICAgIH0gd2hpbGUgKGhhc1JlcGVhdCAmJiBj dXJTbmFwUG9zaXRpb25TaGlmdCA8IG1heFNjcm9sbE9mZnNldCk7CisgICAgLy8gQWx3YXlzIHB1 dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1heGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICBpZiAoc25h cFBvc2l0aW9ucy5wb3NpdGlvbnNbc25hcFBvc2l0aW9ucy5zaXplKCkgLSAxXSAhPSBtYXhTY3Jv bGxPZmZzZXQpCisgICAgICAgIHNuYXBQb3NpdGlvbnMuYXBwZW5kKG1heFNjcm9sbE9mZnNldCk7 Cit9CisKK1Njcm9sbGFibGVBcmVhKiBTY3JvbGxTbmFwTWFuYWdlcjo6c2Nyb2xsYWJsZUFyZWEo KSBjb25zdAoreworICAgIHJldHVybiBtX3Njcm9sbGFibGVBcmVhOworfQorCitTY3JvbGxFdmVu dEF4aXMgU2Nyb2xsU25hcE1hbmFnZXI6OmF4aXMoKSBjb25zdAoreworICAgIHJldHVybiBtX2F4 aXM7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExf U05BUApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25h cE1hbmFnZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5h Z2VyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNmM0ZGNhNzljYzJkZDdhMzFlM2E4MjE4OTNmZmY4MWU1OWEyZTU3 YQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9s bFNuYXBNYW5hZ2VyLmgKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx NCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgU2Ny b2xsU25hcE1hbmFnZXJfaAorI2RlZmluZSBTY3JvbGxTbmFwTWFuYWdlcl9oCisKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKKyNpbmNsdWRl ICJMYXlvdXRVbml0LmgiCisjaW5jbHVkZSAiTGVuZ3RoLmgiCisjaW5jbHVkZSAiUmVuZGVyU3R5 bGUuaCIKKyNpbmNsdWRlICJTY3JvbGxUeXBlcy5oIgorI2luY2x1ZGUgIlNjcm9sbGFibGVBcmVh LmgiCisjaW5jbHVkZSAiU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmgiCisKKyNpbmNsdWRlIDx3dGYv UGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKyNpbmNsdWRlIDx3dGYv dGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdHJ1Y3QgU25hcFBv c2l0aW9uTGlzdCB7CisgICAgU25hcFBvc2l0aW9uTGlzdCgpOworICAgIFNuYXBQb3NpdGlvbkxp c3QoVmVjdG9yPExheW91dFVuaXQ+IHNuYXBQb3NpdGlvbnMpOworICAgIHNpemVfdCBzaXplKCkg Y29uc3Q7CisgICAgdm9pZCBjbGVhcigpOworICAgIHZvaWQgcmVzaXplKHNpemVfdCk7CisgICAg dm9pZCBhcHBlbmQoTGF5b3V0VW5pdCk7CisgICAgTGF5b3V0VW5pdCBjbG9zZXN0U25hcFBvc2l0 aW9uKExheW91dFVuaXQsIGZsb2F0IHZlbG9jaXR5ID0gMCkgY29uc3Q7CisgICAgU3RyaW5nIHRv U3RyaW5nKCkgY29uc3Q7CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gcG9zaXRpb25zOworfTsK KworY2xhc3MgU2Nyb2xsU25hcE1hbmFnZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3du UHRyPFNjcm9sbFNuYXBNYW5hZ2VyPiBjcmVhdGUoU2Nyb2xsYWJsZUFyZWEqLCBTY3JvbGxFdmVu dEF4aXMpOworCisgICAgU2Nyb2xsU25hcE1hbmFnZXIoU2Nyb2xsYWJsZUFyZWEqLCBTY3JvbGxF dmVudEF4aXMpOworCisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21GcmFtZVZpZXcoRnJhbWVW aWV3Kik7CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21QYXJlbnRFbGVtZW50KEhUTUxFbGVt ZW50Kik7CisKKyAgICBTY3JvbGxhYmxlQXJlYSogc2Nyb2xsYWJsZUFyZWEoKSBjb25zdDsKKyAg ICBTY3JvbGxFdmVudEF4aXMgYXhpcygpIGNvbnN0OworCisgICAgTGF5b3V0VW5pdCBwcm94aW1p dHk7CisgICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQ7CisgICAgU25hcFBvc2l0aW9uTGlz dCBzbmFwUG9zaXRpb25zOworICAgIGJvb2wgaXNEaXJ0eTsKKyAgICAKK3ByaXZhdGU6CisgICAg dm9pZCB1cGRhdGVTbmFwRGF0YUZyb21TdHlsZUFuZFBhcmVudEVsZW1lbnQoY29uc3QgUmVuZGVy U3R5bGUmLCBIVE1MRWxlbWVudCosIExheW91dFVuaXQsIExheW91dFVuaXQsIExheW91dFVuaXQp OworICAgIHZvaWQgdXBkYXRlU25hcERhdGFGcm9tU3R5bGUoY29uc3QgUmVuZGVyU3R5bGUmLCBM YXlvdXRVbml0LCBMYXlvdXRVbml0KTsKKyAgICB2b2lkIHVwZGF0ZVNuYXBQb3NpdGlvbnNGcm9t T2Zmc2V0cyhjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mLCBMYXlvdXRVbml0IGRlc3RpbmF0aW9u T2Zmc2V0ID0gMCwgYm9vbCBoYXNSZXBlYXQgPSBmYWxzZSwgTGF5b3V0VW5pdCByZXBlYXRPZmZz ZXQgPSAwKTsKKworICAgIFNjcm9sbGFibGVBcmVhKiBtX3Njcm9sbGFibGVBcmVhOworICAgIFNj cm9sbEV2ZW50QXhpcyBtX2F4aXM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNl bmRpZiAvLyBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjZW5kaWYgLy8gU2Nyb2xsU25hcE1h bmFnZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFy ZWEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCmluZGV4 IGM3ZDk0OTQ1NDcxMWY4M2M2YmQ3YmI1MTBjYjIzMWM4OTEyODAxMDAuLmJmMzJhODg0NWZlYTgz NDY4ZTFlNzIyNmUzMDZlMWIxYmI0YmIyNDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5jcHAKQEAgLTQ2LDYgKzQ2LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK IHN0cnVjdCBTYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewogICAgIHZpcnR1YWwgflNhbWVTaXpl QXNTY3JvbGxhYmxlQXJlYSgpOwogICAgIHZvaWQqIHBvaW50ZXI7CisjaWYgRU5BQkxFKENTU19T Q1JPTExfU05BUCkKKyAgICB2b2lkKiBwb2ludGVyMjsKKyAgICB2b2lkKiBwb2ludGVyMzsKKyNl bmRpZgogICAgIEludFBvaW50IG9yaWdpbjsKICAgICB1bnNpZ25lZCBiaXRmaWVsZHMgOiAxNjsK IH07CkBAIC03NSw2ICs3OSwyNCBAQCBTY3JvbGxBbmltYXRvciogU2Nyb2xsYWJsZUFyZWE6OnNj cm9sbEFuaW1hdG9yKCkgY29uc3QKICAgICByZXR1cm4gbV9zY3JvbGxBbmltYXRvci5nZXQoKTsK IH0KIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCitTY3JvbGxTbmFwTWFuYWdlciogU2Ny b2xsYWJsZUFyZWE6OnNjcm9sbFNuYXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcyBheGlzKSBjb25z dAoreworICAgIGlmIChheGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCkgeworICAg ICAgICBpZiAoIW1fc2Nyb2xsU25hcE1hbmFnZXJYKQorICAgICAgICAgICAgbV9zY3JvbGxTbmFw TWFuYWdlclggPSBTY3JvbGxTbmFwTWFuYWdlcjo6Y3JlYXRlKGNvbnN0X2Nhc3Q8U2Nyb2xsYWJs ZUFyZWEqPih0aGlzKSwgU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsKTsKKyAgICAgICAgcmV0 dXJuIG1fc2Nyb2xsU25hcE1hbmFnZXJYLmdldCgpOworICAgIH0KKyAgICBpZiAoYXhpcyA9PSBT Y3JvbGxFdmVudEF4aXM6OlZlcnRpY2FsKSB7CisgICAgICAgIGlmICghbV9zY3JvbGxTbmFwTWFu YWdlclkpCisgICAgICAgICAgICBtX3Njcm9sbFNuYXBNYW5hZ2VyWSA9IFNjcm9sbFNuYXBNYW5h Z2VyOjpjcmVhdGUoY29uc3RfY2FzdDxTY3JvbGxhYmxlQXJlYSo+KHRoaXMpLCBTY3JvbGxFdmVu dEF4aXM6OlZlcnRpY2FsKTsKKyAgICAgICAgcmV0dXJuIG1fc2Nyb2xsU25hcE1hbmFnZXJZLmdl dCgpOworICAgIH0KKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICByZXR1cm4gbnVsbHB0 cjsKK30KKyNlbmRpZgorCiB2b2lkIFNjcm9sbGFibGVBcmVhOjpzZXRTY3JvbGxPcmlnaW4oY29u c3QgSW50UG9pbnQmIG9yaWdpbikKIHsKICAgICBpZiAobV9zY3JvbGxPcmlnaW4gIT0gb3JpZ2lu KSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaAppbmRleCAyZmUyNzQ5 MTQ1MjhmYTUwN2EzMThhNDVlYTkxMDA2ZTFlMjg0ZjFiLi4xNTY2NThkODNmYWJlMTVmNjBhY2Q4 NmYxYTU2MmE4MGFjNTg2ZmE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVB cmVhLmgKQEAgLTI3LDYgKzI3LDExIEBACiAjZGVmaW5lIFNjcm9sbGFibGVBcmVhX2gKIAogI2lu Y2x1ZGUgIlNjcm9sbGJhci5oIgorCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyNpbmNs dWRlICJTY3JvbGxTbmFwTWFuYWdlci5oIgorI2VuZGlmCisKICNpbmNsdWRlIDx3dGYvVmVjdG9y Lmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQwLDYgKzQ1LDkgQEAgY2xhc3MgUGxhdGZv cm1XaGVlbEV2ZW50OwogY2xhc3MgU2Nyb2xsQW5pbWF0b3I7CiBjbGFzcyBHcmFwaGljc0xheWVy OwogY2xhc3MgVGlsZWRCYWNraW5nOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCitjbGFz cyBTY3JvbGxTbmFwTWFuYWdlcjsKKyNlbmRpZgogCiBjbGFzcyBTY3JvbGxhYmxlQXJlYSB7CiBw dWJsaWM6CkBAIC0xMDksNiArMTE3LDExIEBAIHB1YmxpYzoKICAgICAvLyBUaGlzIGdldHRlciB3 aWxsIGNyZWF0ZSBhIFNjcm9sbEFuaW1hdG9yIGlmIGl0IGRvZXNuJ3QgYWxyZWFkeSBleGlzdC4K ICAgICBTY3JvbGxBbmltYXRvciogc2Nyb2xsQW5pbWF0b3IoKSBjb25zdDsKIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCisgICAgLy8gVGhpcyBnZXR0ZXIgd2lsbCBjcmVhdGUgYSBTY3Jv bGxTbmFwTWFuYWdlciBpZiBpdCBkb2Vzbid0IGFscmVhZHkgZXhpc3QuCisgICAgU2Nyb2xsU25h cE1hbmFnZXIqIHNjcm9sbFNuYXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcykgY29uc3Q7CisjZW5k aWYKKwogICAgIC8vIFRoaXMgZ2V0dGVyIHdpbGwgcmV0dXJuIG51bGwgaWYgdGhlIFNjcm9sbEFu aW1hdG9yIGhhc24ndCBiZWVuIGNyZWF0ZWQgeWV0LgogICAgIFNjcm9sbEFuaW1hdG9yKiBleGlz dGluZ1Njcm9sbEFuaW1hdG9yKCkgY29uc3QgeyByZXR1cm4gbV9zY3JvbGxBbmltYXRvci5nZXQo KTsgfQogCkBAIC0yNzUsNiArMjg4LDExIEBAIHByaXZhdGU6CiAKICAgICBtdXRhYmxlIE93blB0 cjxTY3JvbGxBbmltYXRvcj4gbV9zY3JvbGxBbmltYXRvcjsKIAorI2lmIEVOQUJMRShDU1NfU0NS T0xMX1NOQVApCisgICAgbXV0YWJsZSBPd25QdHI8U2Nyb2xsU25hcE1hbmFnZXI+IG1fc2Nyb2xs U25hcE1hbmFnZXJYOworICAgIG11dGFibGUgT3duUHRyPFNjcm9sbFNuYXBNYW5hZ2VyPiBtX3Nj cm9sbFNuYXBNYW5hZ2VyWTsKKyNlbmRpZgorCiAgICAgLy8gVGhlcmUgYXJlIDggcG9zc2libGUg Y29tYmluYXRpb25zIG9mIHdyaXRpbmcgbW9kZSBhbmQgZGlyZWN0aW9uLiBTY3JvbGwgb3JpZ2lu IHdpbGwgYmUgbm9uLXplcm8gaW4gdGhlIHggb3IgeSBheGlzCiAgICAgLy8gaWYgdGhlcmUgaXMg YW55IHJldmVyc2VkIGRpcmVjdGlvbiBvciB3cml0aW5nLW1vZGUuIFRoZSBjb21iaW5hdGlvbnMg YXJlOgogICAgIC8vIHdyaXRpbmctbW9kZSAvIGRpcmVjdGlvbiAgICAgc2Nyb2xsT3JpZ2luLngo KSBzZXQgICAgc2Nyb2xsT3JpZ2luLnkoKSBzZXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv bWFjL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnIGIvU291cmNlL1dlYktp dC9tYWMvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKaW5kZXggMzEwYzZl ZmRlZDM5YzQ2ZTI3ZGRhZjQ5YmNiZWRkNTQ3ZWVkMDBhZi4uMTAwMzM1YTY5NDM0MDdmNTg4MDQ1 YTFjNDBjNzZlNjY0NWY0ZmYyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvQ29uZmln dXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKKysrIGIvU291cmNlL1dlYktpdC9tYWMv Q29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKQEAgLTE4Nyw2ICsxODcsOCBA QCBFTkFCTEVfU0NSSVBURURfU1BFRUNIID0gOwogRU5BQkxFX1NIQVJFRF9XT1JLRVJTID0gRU5B QkxFX1NIQVJFRF9XT1JLRVJTOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUCA9ICQoRU5BQkxFX0NT U19TQ1JPTExfU05BUF8kKFBMQVRGT1JNX05BTUUpKTsKIEVOQUJMRV9DU1NfU0NST0xMX1NOQVBf bWFjb3N4ID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NOQVBf aXBob25lb3MgPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05B UF9pcGhvbmVzaW11bGF0b3IgPSAkKEVOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3MpOwog RU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSAkKEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTXyQoUExB VEZPUk1fTkFNRSkpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSBFTkFCTEVfU1BFRUNIX1NZ TlRIRVNJUzsKIEVOQUJMRV9TUUxfREFUQUJBU0UgPSBFTkFCTEVfU1FMX0RBVEFCQVNFOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNj b25maWcgYi9Tb3VyY2UvV2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2Nv bmZpZwppbmRleCAzMTBjNmVmZGVkMzljNDZlMjdkZGFmNDliY2JlZGQ1NDdlZWQwMGFmLi4xMDAz MzVhNjk0MzQwN2Y1ODgwNDVhMWM0MGM3NmU2NjQ1ZjRmZjJlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZworKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAtMTg3 LDYgKzE4Nyw4IEBAIEVOQUJMRV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVfU0hBUkVEX1dP UktFUlMgPSBFTkFCTEVfU0hBUkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQID0g JChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX0NTU19T Q1JPTExfU05BUF9tYWNvc3ggPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19T Q1JPTExfU05BUF9pcGhvbmVvcyA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NT X1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF9p cGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQRUVDSF9TWU5U SEVTSVNfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9IEVOQUJM RV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJMRV9TUUxfREFU QUJBU0U7Cg== 236234 2014-08-07 15:15:27 -0700 2014-08-08 14:28:25 -0700 Patch bug-135268-20140807151515.patch text/plain 30695 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyMjgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 ZDE3ODM1MmE0MjRiNjgyOTg3ZGUwODMxYmRkMTExZjc3YWUxY2RjLi5jZGNhOTIxMTVkNmRkMGRk MDI2NTAyMTFlZGIxNWZmODkxNGE0ZWMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxNC0wOC0wNyAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisK KyAgICAgICAgRW5hYmxlIENTU19TQ1JPTExfU05BUCBvbiBpUGhvbmVPUyBhbmQgc2ltdWxhdG9y LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogQ29u ZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcgIE1hcmsg SGFobmVuYmVyZyAgPG1oYWhuZW5iZXJnQGFwcGxlLmNvbT4KIAogICAgICAgICBTcGVjdWxhdGVJ bnQzMk9wZXJhbmQgaXMgc29tZXRpbWVzIHVzZWQgaW4gYSA2NC1iaXQgY29udGV4dCwgd2hpY2gg aGFzIHVuZGVmaW5lZCBiZWhhdmlvcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDg3ZDRjN2EzMTUzYTQ1MzA2NWYz OTQwYzFjZTg4YWViNzQ5MTVkNjEuLjUxOTE4ZTA0OGE3MWViYTM5ZWVjNmY1YmVmYjRjOWFlNWJh ZTVkMzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOSBAQAorMjAxNC0wOC0wNyAgV2Vuc29uIEhz aWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9y ZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgV29ya2luZyB0b3dhcmRzIGltcGxlbWVudGluZyBhIHdheSB0byBleHRy YWN0IHNuYXAgcG9zaXRpb25zIChpLmUuIExheW91dFVuaXRzKSBmcm9tIHRoZSBwYXJzZWQgc25h cCBwb2ludCBwcm9wZXJ0aWVzIGZyb20gQ1NTLAorICAgICAgICBhcyB3ZWxsIGFzIGEgd2F5IG9m IHN0b3JpbmcgdGhlIGluZm9ybWF0aW9uLiBTdXBwb3J0cyBib3RoIG1haW5mcmFtZSBhbmQgb3Zl cmZsb3cgc2Nyb2xsaW5nLgorCisgICAgICAgIENhbid0IGZpbmQgYSB3YXkgdG8gdGVzdCB0aGlz IHlldC4KKworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIENvbmZpZ3VyYXRp b25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFu YWdlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6U25h cFBvc2l0aW9uTGlzdCk6IEluaXRpYWxpemVzIGFuIGVtcHR5IFNuYXBQb3NpdGlvbkxpc3QuCisg ICAgICAgIChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0OjpzaXplKToKKyAgICAgICAgKFdlYkNv cmU6OlNuYXBQb3NpdGlvbkxpc3Q6OmNsZWFyKToKKyAgICAgICAgKFdlYkNvcmU6OlNuYXBQb3Np dGlvbkxpc3Q6OnJlc2l6ZSk6CisgICAgICAgIChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0Ojph cHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNuYXBQ b3NpdGlvbik6IENvbXB1dGUgdGhlIGNsb3Nlc3Qgc25hcCBwb3NpdGlvbiBnaXZlbiBpbml0aWFs IHNjcm9sbCB2ZWxvY2l0eS4KKyAgICAgICAgKFdlYkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6OnRv U3RyaW5nKTogVmVyeSBjb252ZW5pZW50IGZvciB0ZXN0aW5nLiBXaWxsIGJlIHJlbW92ZWQgc29v bi4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjpTY3JvbGxTbmFwTWFuYWdl cik6CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6Y3JlYXRlKTogSW5pdGlh bGl6ZXMgYW5kIHJldHVybnMgYSBuZXcgU2Nyb2xsU25hcE1hbmFnZXIuCisgICAgICAgIChXZWJD b3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tRnJhbWVWaWV3KTogVXNl ZCB0byB1cGRhdGUgc25hcCBkYXRhIGluIHRoZSBjYXNlIG9mIG1haW5mcmFtZSBzY3JvbGxpbmcu CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9t UGFyZW50RWxlbWVudCk6IFVzZWQgdG8gdXBkYXRlIHNuYXAgZGF0YSBpbiB0aGUgY2FzZSBvZiBv dmVyZmxvdyBzY3JvbGxpbmcuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6 dXBkYXRlU25hcERhdGFGcm9tU3R5bGVBbmRQYXJlbnRFbGVtZW50KTogSGVscGVyIG1ldGhvZC4g VXNlZCB3aGVuICJlbGVtZW50cyIgaXMgc3BlY2lmaWVkIGZvciAtc25hcC1wb2ludHMteC95Lgor ICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVN0 eWxlKTogSGVscGVyIG1ldGhvZC4gVXNlZCB3aGVuIHNuYXAgcG9pbnRzIGFyZSBzcGVjaWZpZWQg aW4gYSBsaXN0L3JlcGVhdCg8bGVuZ3RoPikgZm9ybWF0LgorICAgICAgICAoV2ViQ29yZTo6U2Ny b2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBQb3NpdGlvbnNGcm9tT2Zmc2V0cyk6IEhlbHBlciBt ZXRob2QuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6YXhpcyk6IERldGVy bWluZXMgdGhlIHNjcm9sbGluZyBheGlzIChob3Jpem9udGFsIG9yIHZlcnRpY2FsKSBvZiB0aGUg U2Nyb2xsU25hcE1hbmFnZXIuCisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1h bmFnZXIuaDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsYWJsZUFyZWE6OnNjcm9sbFNuYXBNYW5hZ2VyKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oOgorCiAyMDE0LTA4LTA3ICBEYW5pZWwg QmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBTb21ldGltZXMgR21haWwgY2Fu bm90IGxvYWQgbWVzc2FnZXMsIHBhcnRpY3VsYXJseSBvbiByZWZyZXNoICgiLi4udGhlIGFwcGxp Y2F0aW9uIHJhbiBpbnRvIGFuIHVuZXhwZWN0ZWQgZXJyb3IuLi4iKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmlu ZGV4IDUxODgzMDE2N2JiYzcyODRkMzQ4YWNjNTc3ZTZlNjc5N2Y4Y2ViYjUuLmZhZjYxNjczNGUx YzIzNjcyYTZiMWNlYTI0OTc3YzMzZGEwYzY2NmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv bWFjL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNCBAQAorMjAxNC0wOC0wNyAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNv bT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlZCBDU1Nf U0NST0xMX1NOQVAgZm9yIGlQaG9uZU9TIGFuZCB0aGUgc2ltdWxhdG9yLgorCisgICAgICAgICog Q29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcgIEJl bmphbWluIFBvdWxhaW4gIDxicG91bGFpbkBhcHBsZS5jb20+CiAKICAgICAgICAgR2V0IHJpZCBv ZiBJTlBVVF9TUEVFQ0gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCBiYWI4MjRiNjRkY2IwOGVjNTVjMDQwN2E0MzAw Y2JmNWJkZTEyMTBiLi40MmZkN2RjY2E3OTlhYzJlNTk2NzQwZTlhZWMxOGY1MTBjMGZjNjdiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTQtMDgtMDcgIFdlbnNvbiBIc2llaCAgPHdl bnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgQ29tcHV0ZSBhbmQgc3RvcmUgc25hcCBw b2ludCBwb3NpdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTEzNTI2OAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEVuYWJsZWQgQ1NTX1NDUk9MTF9TTkFQIGZvciBpUGhvbmVPUyBhbmQgdGhlIHNpbXVs YXRvci4KKworICAgICAgICAqIENvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmln OgorCiAyMDE0LTA4LTA3ICBCZW5qYW1pbiBQb3VsYWluICA8YnBvdWxhaW5AYXBwbGUuY29tPgog CiAgICAgICAgIEdldCByaWQgb2YgSU5QVVRfU1BFRUNICmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcK aW5kZXggZGJlYWUwY2QwMmI5ZTA5M2E4ODMzMzA5Y2RkMTEyN2E3OGVjODAyYy4uYmY2MzRhNzdi ZWEwMWU4M2Q1NzliNWY3YzU1YjU5YzEyYmU3NDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZp ZwpAQCAtMTg2LDYgKzE4Niw4IEBAIEVOQUJMRV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVf U0hBUkVEX1dPUktFUlMgPSBFTkFCTEVfU0hBUkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9M TF9TTkFQID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQXyQoUExBVEZPUk1fTkFNRSkpOwogRU5B QkxFX0NTU19TQ1JPTExfU05BUF9tYWNvc3ggPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5B QkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitF TkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NTU19TQ1JP TExfU05BUF9pcGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQ RUVDSF9TWU5USEVTSVNfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJ UyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJM RV9TUUxfREFUQUJBU0U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4 dCBiL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDMwZjZkYzBjZTA4ODhhNWM2 ZWU4ZTVlYzMzNmEwOGZkZmQwZDk2MjcuLjBmMzU0YTEyMWUzN2VmNWYxZmZhZjE0ZjQxZmQxZjdk MmEwM2RjMTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBi L1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CkBAIC0xOTYwLDYgKzE5NjAsNyBAQCBzZXQo V2ViQ29yZV9TT1VSQ0VTCiAgICAgcGFnZS9zY3JvbGxpbmcvU2Nyb2xsaW5nU3RhdGVTY3JvbGxp bmdOb2RlLmNwcAogICAgIHBhZ2Uvc2Nyb2xsaW5nL1Njcm9sbGluZ1N0YXRlU3RpY2t5Tm9kZS5j cHAKICAgICBwYWdlL3Njcm9sbGluZy9TY3JvbGxpbmdTdGF0ZVRyZWUuY3BwCisgICAgcGFnZS9z Y3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3BwCiAKICAgICBwbGF0Zm9ybS9DYWxjdWxhdGlv blZhbHVlLmNwcAogICAgIHBsYXRmb3JtL0Nsb2NrLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcgYi9Tb3VyY2UvV2Vi Q29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwppbmRleCBkYmVhZTBj ZDAyYjllMDkzYTg4MzMzMDljZGQxMTI3YTc4ZWM4MDJjLi5iZjYzNGE3N2JlYTAxZTgzZDU3OWI1 ZjdjNTViNTljMTJiZTc0NmYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0 aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZworKysgYi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1 cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAtMTg2LDYgKzE4Niw4IEBAIEVOQUJM RV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVfU0hBUkVEX1dPUktFUlMgPSBFTkFCTEVfU0hB UkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQID0gJChFTkFCTEVfQ1NTX1NDUk9M TF9TTkFQXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUF9tYWNvc3gg PSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVv cyA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9u ZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyk7CiBFTkFCTEVf U1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQRUVDSF9TWU5USEVTSVNfJChQTEFURk9STV9O QU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lT OwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJMRV9TUUxfREFUQUJBU0U7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZThkNTFl Y2Y0YmQwMzlkYTNkOGIzMzA0ZmY0ZjAzYTJjOGY5MWI3My4uZGUyOGQ5YzVjMjgxODc1NjFjZWE3 ZmFkNGI0MWUxN2Q2YWFiYjE1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNjI0Nyw2ICs2MjQ3LDggQEAKIAkJRjQyRkZCNDYx OTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQyRkZCNDUxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0 aFJlcGVhdC5oICovOyB9OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3Jv bGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVF M0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0 ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKKwkJRjQ5NDBCREYxOTgy RjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0OTQwQkREMTk4MkY0NkEwMDE3REI2MSAvKiBT Y3JvbGxTbmFwTWFuYWdlci5jcHAgKi87IH07CisJCUY0OTQwQkUwMTk4MkY0NkEwMDE3REI2MSAv KiBTY3JvbGxTbmFwTWFuYWdlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gRjQ5NDBCREUxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2Vy LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjUw NjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2 RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CiAJCUY1MDY2NEY4MTU3RjUyREMwMEFDMjI2 RiAvKiBGb3JtQ29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gRjUwNjY0RjYxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmgg Ki87IH07CiAJCUY1MTNBM0VBMTVGRjQ4NDEwMDE1MjZEQiAvKiBWYWxpZGF0aW9uTWVzc2FnZUNs aWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUx M0EzRTkxNUZGNDg0MTAwMTUyNkRCIC8qIFZhbGlkYXRpb25NZXNzYWdlQ2xpZW50LmggKi87IH07 CkBAIC0xMzc2NCw2ICsxMzc2Niw4IEBACiAJCUY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBM ZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVw ZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNBMTk1QjhDOEEwMDQ4 MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgcGF0aCA9IHN0eWxlL1N0 eWxlU2Nyb2xsU25hcFBvaW50cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0 N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmg7IHBhdGgg PSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJRjQ5NDBCREQxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ5NDBCREUxOTgyRjQ2QTAwMTdEQjYx IC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IFNjcm9sbFNuYXBNYW5hZ2VyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2 NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGb3JtQ29udHJvbGxlci5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUY1MDY2NEY2MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxl ci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGb3JtQ29udHJvbGxlci5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTEzQTNFOTE1RkY0ODQxMDAxNTI2REIgLyog VmFsaWRhdGlvbk1lc3NhZ2VDbGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gVmFsaWRhdGlvbk1lc3NhZ2VDbGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK QEAgLTE1MTM5LDYgKzE1MTQzLDggQEAKIAkJCQk5MzkxQTk5QjE2MjlENzAwMDAyOTczMzAgLyog U2Nyb2xsaW5nVHJlZVNjcm9sbGluZ05vZGUuaCAqLywKIAkJCQkwRjYzODNEQjE4NjE1QjI5MDAz RTVEQjUgLyogVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmNwcCAqLywKIAkJCQkwRjYzODNEQzE4NjE1 QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmggKi8sCisJCQkJRjQ5NDBCREQx OTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAqLywKKwkJCQlGNDk0MEJE RTE5ODJGNDZBMDAxN0RCNjEgLyogU2Nyb2xsU25hcE1hbmFnZXIuaCAqLywKIAkJCSk7CiAJCQlw YXRoID0gc2Nyb2xsaW5nOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTIzOTk4LDYg KzI0MDA0LDcgQEAKIAkJCQlBMUM3OTcxRDE4ODNFNTFGMDAwRjVFMUYgLyogRE9NSFRNTFRleHRB cmVhRWxlbWVudFByaXZhdGUuaCBpbiBIZWFkZXJzICovLAogCQkJCTg1OTkyRUMwMEFBNTA2OTUw MEFDMDc4NSAvKiBET01IVE1MVGl0bGVFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk4NUU3 MTFDRjBBQzVENTM1MDA1MzI3MEYgLyogRE9NSFRNTFRpdGxlRWxlbWVudEludGVybmFsLmggaW4g SGVhZGVycyAqLywKKwkJCQlGNDk0MEJFMDE5ODJGNDZBMDAxN0RCNjEgLyogU2Nyb2xsU25hcE1h bmFnZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTg1QkE0RDE3MEFBNjg4NjgwMDg4MDUyRCAvKiBE T01IVE1MVUxpc3RFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk4NUU3MTFEMDBBQzVENTM1 MDA1MzI3MEYgLyogRE9NSFRNTFVMaXN0RWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywK IAkJCQlBODE4NUYzQjA5NzY1NzY2MDA1ODI2RDkgLyogRE9NSW1wbGVtZW50YXRpb24uaCBpbiBI ZWFkZXJzICovLApAQCAtMjczNTMsNiArMjczNjAsNyBAQAogCQkJCUE4ODJEQTIwMTU5Mzg0NkEw MDAxMTVFRCAvKiBDU1NUb1N0eWxlTWFwLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3MUY1M0VB MEQyNzA0RjkwMEVDRTBENSAvKiBDU1NVbmljb2RlUmFuZ2VWYWx1ZS5jcHAgaW4gU291cmNlcyAq LywKIAkJCQlBRDAzQUFGQTE0Njg0NTUzMDBBMzlCNUIgLyogQ1NTVmFsdWUuY3BwIGluIFNvdXJj ZXMgKi8sCisJCQkJRjQ5NDBCREYxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2Vy LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTFBQkE3NkNCMTFEMjBFNTcwMDRDMjAxQyAvKiBDU1NW YWx1ZUtleXdvcmRzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUE4MEU2Q0U0MEExOTg5Q0EwMDdG QjhDNSAvKiBDU1NWYWx1ZUxpc3QuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTQ5QkRBMEIxMzFG RDNFNTAwM0M1NkYwIC8qIENTU1ZhbHVlUG9vbC5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi45NjEyY2U4NGYxNDk4NDAzMjFkY2FkMDkwYjU4OTk4ODcxMzkyYzA4Ci0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFn ZXIuY3BwCkBAIC0wLDAgKzEsMjQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycn CisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUwor ICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICog SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIlNjcm9sbFNuYXBNYW5hZ2VyLmgiCisKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQorCisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiSFRNTENvbGxlY3Rp b24uaCIKKyNpbmNsdWRlICJSZW5kZXJCb3guaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisj aW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKK1NuYXBQb3NpdGlvbkxpc3Q6OlNuYXBQb3NpdGlvbkxpc3QoKQoreworfQorCitTbmFwUG9z aXRpb25MaXN0OjpTbmFwUG9zaXRpb25MaXN0KFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwUG9zaXRp b25zKQorICAgIDogcG9zaXRpb25zKHNuYXBQb3NpdGlvbnMpCit7Cit9CisKK3NpemVfdCBTbmFw UG9zaXRpb25MaXN0OjpzaXplKCkgY29uc3QKK3sKKyAgICByZXR1cm4gcG9zaXRpb25zLnNpemUo KTsKK30KKwordm9pZCBTbmFwUG9zaXRpb25MaXN0OjpjbGVhcigpCit7CisgICAgcG9zaXRpb25z LmNsZWFyKCk7Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9uTGlzdDo6cmVzaXplKHNpemVfdCBzaXpl KQoreworICAgIHBvc2l0aW9ucy5yZXNpemUoc2l6ZSk7Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9u TGlzdDo6YXBwZW5kKExheW91dFVuaXQgcG9zaXRpb24pCit7CisgICAgcG9zaXRpb25zLmFwcGVu ZChwb3NpdGlvbik7Cit9CisKK0xheW91dFVuaXQgU25hcFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNu YXBQb3NpdGlvbihMYXlvdXRVbml0IHNjcm9sbERlc3RpbmF0aW9uLCBmbG9hdCB2ZWxvY2l0eSkg Y29uc3QKK3sKKyAgICBpZiAoc2Nyb2xsRGVzdGluYXRpb24gPD0gMCkKKyAgICAgICAgcmV0dXJu IDA7CisgICAgaWYgKHNjcm9sbERlc3RpbmF0aW9uID49IHBvc2l0aW9ucy5hdChwb3NpdGlvbnMu c2l6ZSgpIC0gMSkpCisgICAgICAgIHJldHVybiBwb3NpdGlvbnMuYXQocG9zaXRpb25zLnNpemUo KSAtIDEpOworICAgIHNpemVfdCBsb3dlckluZGV4ID0gMDsKKyAgICBzaXplX3QgdXBwZXJJbmRl eCA9IHBvc2l0aW9ucy5zaXplKCkgLSAxOworICAgIHNpemVfdCBtaWRkbGVJbmRleDsKKworICAg IHdoaWxlIChsb3dlckluZGV4IDwgdXBwZXJJbmRleCAtIDEpIHsKKyAgICAgICAgbWlkZGxlSW5k ZXggPSAobG93ZXJJbmRleCArIHVwcGVySW5kZXgpIC8gMjsKKyAgICAgICAgaWYgKHNjcm9sbERl c3RpbmF0aW9uIDwgcG9zaXRpb25zLmF0KG1pZGRsZUluZGV4KSkKKyAgICAgICAgICAgIHVwcGVy SW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgZWxzZSBpZiAoc2Nyb2xsRGVzdGluYXRpb24g PiBwb3NpdGlvbnMuYXQobWlkZGxlSW5kZXgpKQorICAgICAgICAgICAgbG93ZXJJbmRleCA9IG1p ZGRsZUluZGV4OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIHVwcGVySW5kZXggPSBtaWRk bGVJbmRleDsKKyAgICAgICAgICAgIGxvd2VySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorICAgIExheW91dFVuaXQgbG93ZXJTbmFwUG9z aXRpb24gPSBwb3NpdGlvbnMuYXQobG93ZXJJbmRleCk7CisgICAgTGF5b3V0VW5pdCB1cHBlclNu YXBQb3NpdGlvbiA9IHBvc2l0aW9ucy5hdCh1cHBlckluZGV4KTsKKyAgICAvLyBOb256ZXJvIHZl bG9jaXR5IGluZGljYXRlcyBhIGZsaWNrIGdlc3R1cmUuIEV2ZW4gaWYgYW5vdGhlciBzbmFwIHBv aW50IGlzIGNsb3Nlciwgc25hcCB0byB0aGUgb25lIGluIHRoZSBkaXJlY3Rpb24gb2YgdGhlIGZs aWNrIGdlc3R1cmUuCisgICAgaWYgKHZlbG9jaXR5KQorICAgICAgICByZXR1cm4gdmVsb2NpdHkg PCAwID8gbG93ZXJTbmFwUG9zaXRpb24gOiB1cHBlclNuYXBQb3NpdGlvbjsKKyAgICAvLyBJZiB2 ZWxvY2l0eSBpcyB6ZXJvLCB0aGVuIHRoZSB1c2VyIHJlbGVhc2VkIHdpdGhvdXQgZmxpY2tpbmcs IHNvIHdlIHNpbXBseSBzbmFwIHRvIHRoZSBjbG9zZXIgcG9pbnQuCisgICAgcmV0dXJuIHNjcm9s bERlc3RpbmF0aW9uIC0gbG93ZXJTbmFwUG9zaXRpb24gPD0gdXBwZXJTbmFwUG9zaXRpb24gLSBz Y3JvbGxEZXN0aW5hdGlvbiA/IGxvd2VyU25hcFBvc2l0aW9uIDogdXBwZXJTbmFwUG9zaXRpb247 Cit9CisKK1N0cmluZyBTbmFwUG9zaXRpb25MaXN0Ojp0b1N0cmluZygpIGNvbnN0Cit7CisgICAg Ly8gRklYTUU6IFRoaXMgaXMganVzdCBmb3IgZGVidWdnaW5nL3Rlc3RpbmcgcHVycG9zZXMuIFJl bW92ZSBpbiB0aGUgZmluYWwgdmVyc2lvbi4KKyAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7Cisg ICAgYnVpbGRlci5hcHBlbmQoIlsgIik7CisgICAgZm9yIChMYXlvdXRVbml0IHBvc2l0aW9uIDog cG9zaXRpb25zKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyVG9TdHJp bmdGaXhlZFdpZHRoKHBvc2l0aW9uLnRvSW50KCksIDApKTsKKyAgICAgICAgYnVpbGRlci5hcHBl bmRMaXRlcmFsKCIgIik7CisgICAgfQorICAgIGJ1aWxkZXIuYXBwZW5kKCJdIik7CisgICAgcmV0 dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKK30KKworU2Nyb2xsU25hcE1hbmFnZXI6OlNjcm9sbFNu YXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcyBheGlzKQorICAgIDogbWF4U2Nyb2xsT2Zmc2V0KDAp CisgICAgLCBtX2F4aXMoYXhpcykKK3sKK30KKworUGFzc093blB0cjxTY3JvbGxTbmFwTWFuYWdl cj4gU2Nyb2xsU25hcE1hbmFnZXI6OmNyZWF0ZShTY3JvbGxFdmVudEF4aXMgYXhpcykKK3sKKyAg ICByZXR1cm4gYWRvcHRQdHIobmV3IFNjcm9sbFNuYXBNYW5hZ2VyKGF4aXMpKTsKK30KKwordm9p ZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tRnJhbWVWaWV3KEZyYW1lVmll dyogZnJhbWVWaWV3KQoreworICAgIGlmIChSZW5kZXJWaWV3KiByZW5kZXJWaWV3ID0gZnJhbWVW aWV3LT5yZW5kZXJWaWV3KCkpIHsKKyAgICAgICAgSFRNTEVsZW1lbnQqIGJvZHkgPSByZW5kZXJW aWV3LT5kb2N1bWVudCgpLmJvZHkoKTsKKyAgICAgICAgaWYgKGJvZHkpIHsKKyAgICAgICAgICAg IGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSA9IGJvZHktPnJlbmRlcmVyKCktPnN0eWxlKCk7Cisg ICAgICAgICAgICBMYXlvdXRVbml0IHNpemUgPSBtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpI b3Jpem9udGFsID8gcmVuZGVyVmlldy0+d2lkdGgoKSA6IHJlbmRlclZpZXctPmhlaWdodCgpOwor ICAgICAgICAgICAgTGF5b3V0VW5pdCBzY3JvbGxTaXplID0gbV9heGlzID09IFNjcm9sbEV2ZW50 QXhpczo6SG9yaXpvbnRhbCA/IHJlbmRlclZpZXctPnNjcm9sbFdpZHRoKCkgOiByZW5kZXJWaWV3 LT5zY3JvbGxIZWlnaHQoKTsKKyAgICAgICAgICAgIGlmIChzY3JvbGxTaXplIDw9IDAgfHwgc2l6 ZSA8PSAwIHx8IHNpemUgPj0gc2Nyb2xsU2l6ZSkKKyAgICAgICAgICAgICAgICByZXR1cm47CisK KyAgICAgICAgICAgIG1heFNjcm9sbE9mZnNldCA9IHNjcm9sbFNpemUgLSBzaXplOworICAgICAg ICAgICAgaWYgKChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsICYmICFzdHls ZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpKQorICAgICAgICAgICAgICAgIHx8IChtX2F4aXMg PT0gU2Nyb2xsRXZlbnRBeGlzOjpWZXJ0aWNhbCAmJiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVt ZW50c1koKSkpCisgICAgICAgICAgICAgICAgdXBkYXRlU25hcERhdGFGcm9tU3R5bGUoc3R5bGUs IHNpemUpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHVwZGF0ZVNuYXBEYXRh RnJvbVN0eWxlQW5kUGFyZW50RWxlbWVudChzdHlsZSwgYm9keSwgc2l6ZSk7CisgICAgICAgIH0K KyAgICB9Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVBh cmVudEVsZW1lbnQoSFRNTEVsZW1lbnQqIHBhcmVudCkKK3sKKyAgICBpZiAoUmVuZGVyQm94KiBw YXJlbnRCb3ggPSBwYXJlbnQtPnJlbmRlckJveCgpKSB7CisgICAgICAgIGNvbnN0IFJlbmRlclN0 eWxlJiBzdHlsZSA9IHBhcmVudEJveC0+c3R5bGUoKTsKKyAgICAgICAgTGF5b3V0VW5pdCBzaXpl ID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHBhcmVudEJveC0+d2lk dGgoKSA6IHBhcmVudEJveC0+aGVpZ2h0KCk7CisgICAgICAgIExheW91dFVuaXQgc2Nyb2xsU2l6 ZSA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBwYXJlbnRCb3gtPnNj cm9sbFdpZHRoKCkgOiBwYXJlbnRCb3gtPnNjcm9sbEhlaWdodCgpOworICAgICAgICBpZiAoc2Ny b2xsU2l6ZSA8PSAwIHx8IHNpemUgPD0gMCB8fCBzaXplID49IHNjcm9sbFNpemUpCisgICAgICAg ICAgICByZXR1cm47CisKKyAgICAgICAgbWF4U2Nyb2xsT2Zmc2V0ID0gc2Nyb2xsU2l6ZSAtIHNp emU7CisgICAgICAgIGlmICgobV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCAm JiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1goKSkKKyAgICAgICAgICAgIHx8IChtX2F4 aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpWZXJ0aWNhbCAmJiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNF bGVtZW50c1koKSkpCisgICAgICAgICAgICB1cGRhdGVTbmFwRGF0YUZyb21TdHlsZShzdHlsZSwg c2l6ZSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxl QW5kUGFyZW50RWxlbWVudChzdHlsZSwgcGFyZW50LCBzaXplKTsKKyAgICB9Cit9CisKK3ZvaWQg U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlQW5kUGFyZW50RWxlbWVu dChjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUsIEhUTUxFbGVtZW50KiBwYXJlbnQsIExheW91dFVu aXQgc2l6ZSkKK3sKKyAgICAvLyBIYW5kbGUgImVsZW1lbnRzIiBzcGVjaWZpY2F0aW9uIGJ5IHRy YXZlcnNpbmcgY2hpbGRyZW4uCisgICAgc25hcFBvc2l0aW9ucy5jbGVhcigpOworICAgIExheW91 dFVuaXQgcGFyZW50T2Zmc2V0ID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRh bCA/IHBhcmVudC0+cmVuZGVyQm94KCktPm9mZnNldExlZnQoKSA6IHBhcmVudC0+cmVuZGVyQm94 KCktPm9mZnNldFRvcCgpOworICAgIExheW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQgPSBtX2F4 aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gdmFsdWVGb3JMZW5ndGgoc3R5bGUu c2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpLCBzaXplKSA6IHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNj cm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgc2l6ZSk7CisgICAgTGF5b3V0VW5pdCBsYXN0UG90ZW50 aWFsU25hcFBvc2l0aW9uOworICAgIC8vIEFsd2F5cyBwdXQgYSBzbmFwIHBvaW50IG9uIHRoZSBt aW5pbXVtIHNjcm9sbCBvZmZzZXQuCisgICAgc25hcFBvc2l0aW9ucy5hcHBlbmQoMCk7CisgICAg RWxlbWVudCogY2hpbGQgPSBwYXJlbnQtPmNoaWxkcmVuKCktPmNvbGxlY3Rpb25CZWdpbigpOwor ICAgIHdoaWxlIChjaGlsZCAmJiBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uIDwgbWF4U2Nyb2xs T2Zmc2V0KSB7CisgICAgICAgIGlmIChjaGlsZC0+aXNIVE1MRWxlbWVudCgpICYmIHRvSFRNTEVs ZW1lbnQoY2hpbGQpLT5yZW5kZXJCb3goKSkgeworICAgICAgICAgICAgUmVuZGVyQm94KiBjaGls ZEJveCA9IHRvSFRNTEVsZW1lbnQoY2hpbGQpLT5yZW5kZXJCb3goKTsKKyAgICAgICAgICAgIExh eW91dFVuaXQgY2hpbGRTaXplID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRh bCA/IGNoaWxkQm94LT53aWR0aCgpIDogY2hpbGRCb3gtPmhlaWdodCgpOworICAgICAgICAgICAg TGF5b3V0VW5pdCBjaGlsZE9mZnNldCA9IChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jp em9udGFsID8gY2hpbGRCb3gtPm9mZnNldExlZnQoKSA6IGNoaWxkQm94LT5vZmZzZXRUb3AoKSkg LSBwYXJlbnRPZmZzZXQ7CisgICAgICAgICAgICBmb3IgKFNuYXBDb29yZGluYXRlIGNvb3JkaW5h dGUgOiBjaGlsZEJveC0+c3R5bGUoKS5zY3JvbGxTbmFwQ29vcmRpbmF0ZXMoKSkgeworICAgICAg ICAgICAgICAgIExheW91dFVuaXQgY29vcmRpbmF0ZU9mZnNldCA9IHZhbHVlRm9yTGVuZ3RoKG1f YXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBjb29yZGluYXRlLmZpcnN0IDog Y29vcmRpbmF0ZS5zZWNvbmQsIGNoaWxkU2l6ZSk7CisgICAgICAgICAgICAgICAgbGFzdFBvdGVu dGlhbFNuYXBQb3NpdGlvbiA9IGNoaWxkT2Zmc2V0ICsgY29vcmRpbmF0ZU9mZnNldCAtIGRlc3Rp bmF0aW9uT2Zmc2V0OworICAgICAgICAgICAgICAgIGlmIChsYXN0UG90ZW50aWFsU25hcFBvc2l0 aW9uIDw9IDApCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICAg ICAgaWYgKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Nyb2xsT2Zmc2V0KQorICAg ICAgICAgICAgICAgICAgICBicmVhazsKKworICAgICAgICAgICAgICAgIHNuYXBQb3NpdGlvbnMu YXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24pOworICAgICAgICAgICAgfQorICAgICAg ICB9CisgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRFbGVtZW50U2libGluZygpOworICAgIH0K KyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0aGUgbWF4aW11bSBzY3JvbGwgb2Zm c2V0LgorICAgIGlmIChzbmFwUG9zaXRpb25zLnBvc2l0aW9uc1tzbmFwUG9zaXRpb25zLnNpemUo KSAtIDFdICE9IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAgc25hcFBvc2l0aW9ucy5hcHBlbmQo bWF4U2Nyb2xsT2Zmc2V0KTsKK30KKwordm9pZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25h cERhdGFGcm9tU3R5bGUoY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlLCBMYXlvdXRVbml0IHNpemUp Cit7CisgICAgVmVjdG9yPExlbmd0aD4gc25hcE9mZnNldHMgPSBtX2F4aXMgPT0gU2Nyb2xsRXZl bnRBeGlzOjpIb3Jpem9udGFsID8gc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNYKCkgOiBzdHlsZS5z Y3JvbGxTbmFwT2Zmc2V0c1koKTsKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gc25hcFBvc2l0aW9u U3Vic2VxdWVuY2U7CisgICAgZm9yIChMZW5ndGggc25hcE9mZnNldCA6IHNuYXBPZmZzZXRzKQor ICAgICAgICBzbmFwUG9zaXRpb25TdWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgoc25h cE9mZnNldCwgc2l6ZSkpOworICAgIGlmICghc25hcFBvc2l0aW9uU3Vic2VxdWVuY2Uuc2l6ZSgp KQorICAgICAgICBzbmFwUG9zaXRpb25TdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICBpZiAo bV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCkKKyAgICAgICAgdXBkYXRlU25h cFBvc2l0aW9uc0Zyb21PZmZzZXRzKHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlLCB2YWx1ZUZvckxl bmd0aChzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25YKCksIHNpemUpLCBzdHlsZS5zY3JvbGxT bmFwSGFzUmVwZWF0WCgpLCB2YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zm c2V0WCgpLCBzaXplKSk7CisgICAgZWxzZQorICAgICAgICB1cGRhdGVTbmFwUG9zaXRpb25zRnJv bU9mZnNldHMoc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UsIHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNj cm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgc2l6ZSksIHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRZ KCksIHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZKCksIHNpemUp KTsKK30KKwordm9pZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcFBvc2l0aW9uc0Zyb21P ZmZzZXRzKGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYgc25hcFBvc2l0aW9uU3Vic2VxdWVuY2Us IExheW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQsIGJvb2wgaGFzUmVwZWF0LCBMYXlvdXRVbml0 IHJlcGVhdE9mZnNldCkKK3sKKyAgICBzbmFwUG9zaXRpb25zLmNsZWFyKCk7CisgICAgTGF5b3V0 VW5pdCBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IC1kZXN0aW5hdGlvbk9mZnNldDsKKyAgICBMYXlv dXRVbml0IGxhc3RTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRpb25TaGlmdDsKKyAgICBMYXlv dXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBw b2ludCBvbiB0aGUgbWluaW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIHNuYXBQb3NpdGlvbnMuYXBw ZW5kKDApOworICAgIGRvIHsKKyAgICAgICAgZm9yIChMYXlvdXRVbml0IHNuYXBQb3NpdGlvbiA6 IHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlKSB7CisgICAgICAgICAgICBwb3RlbnRpYWxTbmFwUG9z aXRpb24gPSBjdXJTbmFwUG9zaXRpb25TaGlmdCArIHNuYXBQb3NpdGlvbjsKKyAgICAgICAgICAg IGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPD0gMCkKKyAgICAgICAgICAgICAgICBjb250aW51 ZTsKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Nyb2xsT2Zm c2V0KQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgc25hcFBvc2l0aW9ucy5h cHBlbmQocG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFwUG9zaXRp b24gPSBwb3RlbnRpYWxTbmFwUG9zaXRpb247CisgICAgICAgIH0KKyAgICAgICAgY3VyU25hcFBv c2l0aW9uU2hpZnQgPSBsYXN0U25hcFBvc2l0aW9uICsgcmVwZWF0T2Zmc2V0OworICAgIH0gd2hp bGUgKGhhc1JlcGVhdCAmJiBjdXJTbmFwUG9zaXRpb25TaGlmdCA8IG1heFNjcm9sbE9mZnNldCk7 CisgICAgLy8gQWx3YXlzIHB1dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1heGltdW0gc2Nyb2xsIG9m ZnNldC4KKyAgICBpZiAoc25hcFBvc2l0aW9ucy5wb3NpdGlvbnNbc25hcFBvc2l0aW9ucy5zaXpl KCkgLSAxXSAhPSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAgIHNuYXBQb3NpdGlvbnMuYXBwZW5k KG1heFNjcm9sbE9mZnNldCk7Cit9CisKK1Njcm9sbEV2ZW50QXhpcyBTY3JvbGxTbmFwTWFuYWdl cjo6YXhpcygpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fYXhpczsKK30KKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdlci5oIGIvU291cmNlL1dl YkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kMzY5 OTUwYTRkNmVlYWRiMjNkOWI4NWQ4OWI2YzNlODZlNTBhNzk5Ci0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuaApAQCAtMCww ICsxLDg1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBTY3JvbGxTbmFwTWFuYWdlcl9oCisjZGVm aW5lIFNjcm9sbFNuYXBNYW5hZ2VyX2gKKworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisK KyNpbmNsdWRlICJIVE1MRWxlbWVudC5oIgorI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNs dWRlICJMZW5ndGguaCIKKyNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgorI2luY2x1ZGUgIlNjcm9s bFR5cGVzLmgiCisjaW5jbHVkZSAiU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmgiCisKKyNpbmNsdWRl IDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKyNpbmNsdWRl IDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdHJ1Y3Qg U25hcFBvc2l0aW9uTGlzdCB7CisgICAgU25hcFBvc2l0aW9uTGlzdCgpOworICAgIFNuYXBQb3Np dGlvbkxpc3QoVmVjdG9yPExheW91dFVuaXQ+IHNuYXBQb3NpdGlvbnMpOworICAgIHNpemVfdCBz aXplKCkgY29uc3Q7CisgICAgdm9pZCBjbGVhcigpOworICAgIHZvaWQgcmVzaXplKHNpemVfdCk7 CisgICAgdm9pZCBhcHBlbmQoTGF5b3V0VW5pdCk7CisgICAgTGF5b3V0VW5pdCBjbG9zZXN0U25h cFBvc2l0aW9uKExheW91dFVuaXQsIGZsb2F0IHZlbG9jaXR5ID0gMCkgY29uc3Q7CisgICAgU3Ry aW5nIHRvU3RyaW5nKCkgY29uc3Q7CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gcG9zaXRpb25z OworfTsKKworY2xhc3MgU2Nyb2xsU25hcE1hbmFnZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQ YXNzT3duUHRyPFNjcm9sbFNuYXBNYW5hZ2VyPiBjcmVhdGUoU2Nyb2xsRXZlbnRBeGlzKTsKKwor ICAgIFNjcm9sbFNuYXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcyk7CisKKyAgICB2b2lkIHVwZGF0 ZVNuYXBEYXRhRnJvbUZyYW1lVmlldyhGcmFtZVZpZXcqKTsKKyAgICB2b2lkIHVwZGF0ZVNuYXBE YXRhRnJvbVBhcmVudEVsZW1lbnQoSFRNTEVsZW1lbnQqKTsKKworICAgIFNjcm9sbEV2ZW50QXhp cyBheGlzKCkgY29uc3Q7CisKKyAgICBMYXlvdXRVbml0IG1heFNjcm9sbE9mZnNldDsKKyAgICBT bmFwUG9zaXRpb25MaXN0IHNuYXBQb3NpdGlvbnM7CisgICAgCitwcml2YXRlOgorICAgIHZvaWQg dXBkYXRlU25hcERhdGFGcm9tU3R5bGVBbmRQYXJlbnRFbGVtZW50KGNvbnN0IFJlbmRlclN0eWxl JiwgSFRNTEVsZW1lbnQqLCBMYXlvdXRVbml0KTsKKyAgICB2b2lkIHVwZGF0ZVNuYXBEYXRhRnJv bVN0eWxlKGNvbnN0IFJlbmRlclN0eWxlJiwgTGF5b3V0VW5pdCk7CisgICAgdm9pZCB1cGRhdGVT bmFwUG9zaXRpb25zRnJvbU9mZnNldHMoY29uc3QgVmVjdG9yPExheW91dFVuaXQ+JiwgTGF5b3V0 VW5pdCBkZXN0aW5hdGlvbk9mZnNldCA9IDAsIGJvb2wgaGFzUmVwZWF0ID0gZmFsc2UsIExheW91 dFVuaXQgcmVwZWF0T2Zmc2V0ID0gMCk7CisKKyAgICBTY3JvbGxFdmVudEF4aXMgbV9heGlzOwor fTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKENTU19TQ1JP TExfU05BUCkKKworI2VuZGlmIC8vIFNjcm9sbFNuYXBNYW5hZ2VyX2gKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAppbmRleCBjN2Q5NDk0NTQ3MTFmODNjNmJkN2Ji NTEwY2IyMzFjODkxMjgwMTAwLi4yZmYwNzBlMzU3NTcxNzlmNTBjYmE4MDAyYzQyZmEzYTZkMWMz Y2JhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCkBAIC00 Niw2ICs0NiwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBzdHJ1Y3QgU2FtZVNpemVBc1Njcm9s bGFibGVBcmVhIHsKICAgICB2aXJ0dWFsIH5TYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEoKTsKICAg ICB2b2lkKiBwb2ludGVyOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdm9pZCog cG9pbnRlcjI7CisgICAgdm9pZCogcG9pbnRlcjM7CisjZW5kaWYKICAgICBJbnRQb2ludCBvcmln aW47CiAgICAgdW5zaWduZWQgYml0ZmllbGRzIDogMTY7CiB9OwpAQCAtNzUsNiArNzksMjAgQEAg U2Nyb2xsQW5pbWF0b3IqIFNjcm9sbGFibGVBcmVhOjpzY3JvbGxBbmltYXRvcigpIGNvbnN0CiAg ICAgcmV0dXJuIG1fc2Nyb2xsQW5pbWF0b3IuZ2V0KCk7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1ND Uk9MTF9TTkFQKQorU2Nyb2xsU25hcE1hbmFnZXIqIFNjcm9sbGFibGVBcmVhOjpzY3JvbGxTbmFw TWFuYWdlcihTY3JvbGxFdmVudEF4aXMgYXhpcykgY29uc3QKK3sKKyAgICBpZiAoYXhpcyA9PSBT Y3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpIHsKKyAgICAgICAgaWYgKCFtX3Njcm9sbFNuYXBN YW5hZ2VyWCkKKyAgICAgICAgICAgIG1fc2Nyb2xsU25hcE1hbmFnZXJYID0gU2Nyb2xsU25hcE1h bmFnZXI6OmNyZWF0ZShTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpOworICAgICAgICByZXR1 cm4gbV9zY3JvbGxTbmFwTWFuYWdlclguZ2V0KCk7CisgICAgfQorICAgIGlmICghbV9zY3JvbGxT bmFwTWFuYWdlclkpCisgICAgICAgIG1fc2Nyb2xsU25hcE1hbmFnZXJZID0gU2Nyb2xsU25hcE1h bmFnZXI6OmNyZWF0ZShTY3JvbGxFdmVudEF4aXM6OlZlcnRpY2FsKTsKKyAgICByZXR1cm4gbV9z Y3JvbGxTbmFwTWFuYWdlclkuZ2V0KCk7Cit9CisjZW5kaWYKKwogdm9pZCBTY3JvbGxhYmxlQXJl YTo6c2V0U2Nyb2xsT3JpZ2luKGNvbnN0IEludFBvaW50JiBvcmlnaW4pCiB7CiAgICAgaWYgKG1f c2Nyb2xsT3JpZ2luICE9IG9yaWdpbikgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vU2Nyb2xsYWJsZUFyZWEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFi bGVBcmVhLmgKaW5kZXggMmZlMjc0OTE0NTI4ZmE1MDdhMzE4YTQ1ZWE5MTAwNmUxZTI4NGYxYi4u MTU2NjU4ZDgzZmFiZTE1ZjYwYWNkODZmMWE1NjJhODBhYzU4NmZhNiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCkBAIC0yNyw2ICsyNywxMSBAQAogI2RlZmluZSBT Y3JvbGxhYmxlQXJlYV9oCiAKICNpbmNsdWRlICJTY3JvbGxiYXIuaCIKKworI2lmIEVOQUJMRShD U1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiU2Nyb2xsU25hcE1hbmFnZXIuaCIKKyNlbmRpZgor CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00MCw2 ICs0NSw5IEBAIGNsYXNzIFBsYXRmb3JtV2hlZWxFdmVudDsKIGNsYXNzIFNjcm9sbEFuaW1hdG9y OwogY2xhc3MgR3JhcGhpY3NMYXllcjsKIGNsYXNzIFRpbGVkQmFja2luZzsKKyNpZiBFTkFCTEUo Q1NTX1NDUk9MTF9TTkFQKQorY2xhc3MgU2Nyb2xsU25hcE1hbmFnZXI7CisjZW5kaWYKIAogY2xh c3MgU2Nyb2xsYWJsZUFyZWEgewogcHVibGljOgpAQCAtMTA5LDYgKzExNywxMSBAQCBwdWJsaWM6 CiAgICAgLy8gVGhpcyBnZXR0ZXIgd2lsbCBjcmVhdGUgYSBTY3JvbGxBbmltYXRvciBpZiBpdCBk b2Vzbid0IGFscmVhZHkgZXhpc3QuCiAgICAgU2Nyb2xsQW5pbWF0b3IqIHNjcm9sbEFuaW1hdG9y KCkgY29uc3Q7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIC8vIFRoaXMgZ2V0 dGVyIHdpbGwgY3JlYXRlIGEgU2Nyb2xsU25hcE1hbmFnZXIgaWYgaXQgZG9lc24ndCBhbHJlYWR5 IGV4aXN0LgorICAgIFNjcm9sbFNuYXBNYW5hZ2VyKiBzY3JvbGxTbmFwTWFuYWdlcihTY3JvbGxF dmVudEF4aXMpIGNvbnN0OworI2VuZGlmCisKICAgICAvLyBUaGlzIGdldHRlciB3aWxsIHJldHVy biBudWxsIGlmIHRoZSBTY3JvbGxBbmltYXRvciBoYXNuJ3QgYmVlbiBjcmVhdGVkIHlldC4KICAg ICBTY3JvbGxBbmltYXRvciogZXhpc3RpbmdTY3JvbGxBbmltYXRvcigpIGNvbnN0IHsgcmV0dXJu IG1fc2Nyb2xsQW5pbWF0b3IuZ2V0KCk7IH0KIApAQCAtMjc1LDYgKzI4OCwxMSBAQCBwcml2YXRl OgogCiAgICAgbXV0YWJsZSBPd25QdHI8U2Nyb2xsQW5pbWF0b3I+IG1fc2Nyb2xsQW5pbWF0b3I7 CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIG11dGFibGUgT3duUHRyPFNjcm9s bFNuYXBNYW5hZ2VyPiBtX3Njcm9sbFNuYXBNYW5hZ2VyWDsKKyAgICBtdXRhYmxlIE93blB0cjxT Y3JvbGxTbmFwTWFuYWdlcj4gbV9zY3JvbGxTbmFwTWFuYWdlclk7CisjZW5kaWYKKwogICAgIC8v IFRoZXJlIGFyZSA4IHBvc3NpYmxlIGNvbWJpbmF0aW9ucyBvZiB3cml0aW5nIG1vZGUgYW5kIGRp cmVjdGlvbi4gU2Nyb2xsIG9yaWdpbiB3aWxsIGJlIG5vbi16ZXJvIGluIHRoZSB4IG9yIHkgYXhp cwogICAgIC8vIGlmIHRoZXJlIGlzIGFueSByZXZlcnNlZCBkaXJlY3Rpb24gb3Igd3JpdGluZy1t b2RlLiBUaGUgY29tYmluYXRpb25zIGFyZToKICAgICAvLyB3cml0aW5nLW1vZGUgLyBkaXJlY3Rp b24gICAgIHNjcm9sbE9yaWdpbi54KCkgc2V0ICAgIHNjcm9sbE9yaWdpbi55KCkgc2V0CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54 Y2NvbmZpZyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVz LnhjY29uZmlnCmluZGV4IGRiZWFlMGNkMDJiOWUwOTNhODgzMzMwOWNkZDExMjdhNzhlYzgwMmMu LmJmNjM0YTc3YmVhMDFlODNkNTc5YjVmN2M1NWI1OWMxMmJlNzQ2ZjEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvbWFjL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCisr KyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29u ZmlnCkBAIC0xODYsNiArMTg2LDggQEAgRU5BQkxFX1NDUklQVEVEX1NQRUVDSCA9IDsKIEVOQUJM RV9TSEFSRURfV09SS0VSUyA9IEVOQUJMRV9TSEFSRURfV09SS0VSUzsKIEVOQUJMRV9DU1NfU0NS T0xMX1NOQVAgPSAkKEVOQUJMRV9DU1NfU0NST0xMX1NOQVBfJChQTEFURk9STV9OQU1FKSk7CiBF TkFCTEVfQ1NTX1NDUk9MTF9TTkFQX21hY29zeCA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitF TkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZW9zID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsK K0VOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lc2ltdWxhdG9yID0gJChFTkFCTEVfQ1NTX1ND Uk9MTF9TTkFQX2lwaG9uZW9zKTsKIEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTID0gJChFTkFCTEVf U1BFRUNIX1NZTlRIRVNJU18kKFBMQVRGT1JNX05BTUUpKTsKIEVOQUJMRV9TUEVFQ0hfU1lOVEhF U0lTID0gRU5BQkxFX1NQRUVDSF9TWU5USEVTSVM7CiBFTkFCTEVfU1FMX0RBVEFCQVNFID0gRU5B QkxFX1NRTF9EQVRBQkFTRTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NvbmZpZ3VyYXRp b25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnIGIvU291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlv bnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKaW5kZXggZGJlYWUwY2QwMmI5ZTA5M2E4ODMzMzA5 Y2RkMTEyN2E3OGVjODAyYy4uYmY2MzRhNzdiZWEwMWU4M2Q1NzliNWY3YzU1YjU5YzEyYmU3NDZm MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmlu ZXMueGNjb25maWcKKysrIGIvU291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURl ZmluZXMueGNjb25maWcKQEAgLTE4Niw2ICsxODYsOCBAQCBFTkFCTEVfU0NSSVBURURfU1BFRUNI ID0gOwogRU5BQkxFX1NIQVJFRF9XT1JLRVJTID0gRU5BQkxFX1NIQVJFRF9XT1JLRVJTOwogRU5B QkxFX0NTU19TQ1JPTExfU05BUCA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF8kKFBMQVRGT1JN X05BTUUpKTsKIEVOQUJMRV9DU1NfU0NST0xMX1NOQVBfbWFjb3N4ID0gRU5BQkxFX0NTU19TQ1JP TExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3MgPSBFTkFCTEVfQ1NTX1ND Uk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVzaW11bGF0b3IgPSAkKEVO QUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3MpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMg PSAkKEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX1NQ RUVDSF9TWU5USEVTSVMgPSBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUzsKIEVOQUJMRV9TUUxfREFU QUJBU0UgPSBFTkFCTEVfU1FMX0RBVEFCQVNFOwo= 236307 2014-08-08 14:28:31 -0700 2014-08-08 14:55:13 -0700 Patch bug-135268-20140808142820.patch text/plain 27074 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyMjgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 ZDE3ODM1MmE0MjRiNjgyOTg3ZGUwODMxYmRkMTExZjc3YWUxY2RjLi5iZDM1NGI3ODZkOGYzZDg2 YWNjZjM4MDFiNTZhYzQ5NzE3ODhhYWVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxNC0wOC0wOCAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisK KyAgICAgICAgRW5hYmxlIENTU19TQ1JPTExfU05BUCBvbiBpUGhvbmVPUyBhbmQgc2ltdWxhdG9y LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogQ29u ZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcgIE1hcmsg SGFobmVuYmVyZyAgPG1oYWhuZW5iZXJnQGFwcGxlLmNvbT4KIAogICAgICAgICBTcGVjdWxhdGVJ bnQzMk9wZXJhbmQgaXMgc29tZXRpbWVzIHVzZWQgaW4gYSA2NC1iaXQgY29udGV4dCwgd2hpY2gg aGFzIHVuZGVmaW5lZCBiZWhhdmlvcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDg3ZDRjN2EzMTUzYTQ1MzA2NWYz OTQwYzFjZTg4YWViNzQ5MTVkNjEuLmQyNTNiMzI0ZjA5OWMzMDU1MTNiMzc1MzA3ZDFmMmI2MzA0 MTYyMTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxNC0wOC0wOCAgV2Vuc29uIEhz aWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9y ZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgV29ya2luZyB0b3dhcmRzIGltcGxlbWVudGluZyBhIHdheSB0byBleHRy YWN0IHNuYXAgcG9zaXRpb25zIChpLmUuIExheW91dFVuaXRzKSBmcm9tIHRoZSBwYXJzZWQgc25h cCBwb2ludCBwcm9wZXJ0aWVzIGZyb20gQ1NTLAorICAgICAgICBhcyB3ZWxsIGFzIGEgd2F5IG9m IHN0b3JpbmcgdGhlIGluZm9ybWF0aW9uLiBTdXBwb3J0cyBib3RoIG1haW5mcmFtZSBhbmQgb3Zl cmZsb3cgc2Nyb2xsaW5nLgorCisgICAgICAgIE5vIGNoYW5nZXMgaW4gYmVoYXZpb3IuIEkgd2ls bCB3cml0ZSB0ZXN0cyB3aGVuIEkgaW1wbGVtZW50IHNuYXBwaW5nIGZvciBpT1MgYW5kIE1hYy4K KworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIENvbmZpZ3VyYXRpb25zL0Zl YXR1cmVEZWZpbmVzLnhjY29uZmlnOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvajoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdlci5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6U25hcFBvc2l0 aW9uTGlzdCk6IEluaXRpYWxpemVzIGFuIGVtcHR5IFNuYXBQb3NpdGlvbkxpc3QuCisgICAgICAg IChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0OjpzaXplKTogV3JhcHMgY2FsbCB0byBWZWN0b3Iu CisgICAgICAgIChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0OjpjbGVhcik6IERpdHRvLgorICAg ICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6cmVzaXplKTogRGl0dG8uCisgICAgICAg IChXZWJDb3JlOjpTbmFwUG9zaXRpb25MaXN0OjphcHBlbmQpOiBEaXR0by4KKyAgICAgICAgKFdl YkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6OmNsb3Nlc3RTbmFwUG9zaXRpb24pOiBDb21wdXRlIHRo ZSBjbG9zZXN0IHNuYXAgcG9zaXRpb24gZ2l2ZW4gaW5pdGlhbCBzY3JvbGwgdmVsb2NpdHkuCisg ICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6U2Nyb2xsU25hcE1hbmFnZXIpOgor ICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OmNyZWF0ZSk6IEluaXRpYWxpemVz IGFuZCByZXR1cm5zIGEgbmV3IFNjcm9sbFNuYXBNYW5hZ2VyLgorICAgICAgICAoV2ViQ29yZTo6 U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbUZyYW1lVmlldyk6IFVzZWQgdG8g dXBkYXRlIHNuYXAgZGF0YSBpbiB0aGUgY2FzZSBvZiBtYWluZnJhbWUgc2Nyb2xsaW5nLgorICAg ICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVBhcmVu dEVsZW1lbnQpOiBVc2VkIHRvIHVwZGF0ZSBzbmFwIGRhdGEgaW4gdGhlIGNhc2Ugb2Ygb3ZlcmZs b3cgc2Nyb2xsaW5nLgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0 ZVNuYXBEYXRhRnJvbVN0eWxlQW5kUGFyZW50RWxlbWVudCk6IEhlbHBlciBtZXRob2QuIFVzZWQg d2hlbiAiZWxlbWVudHMiIGlzIHNwZWNpZmllZCBmb3IgLXNuYXAtcG9pbnRzLXgveS4KKyAgICAg ICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFwRGF0YUZyb21TdHlsZSk6 IEhlbHBlciBtZXRob2QuIFVzZWQgd2hlbiBzbmFwIHBvaW50cyBhcmUgc3BlY2lmaWVkIGluIGEg bGlzdC9yZXBlYXQoPGxlbmd0aD4pIGZvcm1hdC4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFNu YXBNYW5hZ2VyOjp1cGRhdGVTbmFwUG9zaXRpb25zRnJvbU9mZnNldHMpOiBIZWxwZXIgbWV0aG9k LgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OmF4aXMpOiBEZXRlcm1pbmVz IHRoZSBzY3JvbGxpbmcgYXhpcyAoaG9yaXpvbnRhbCBvciB2ZXJ0aWNhbCkgb2YgdGhlIFNjcm9s bFNuYXBNYW5hZ2VyLgorICAgICAgICAqIHBhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2Vy Lmg6IEFkZGVkLgorCiAyMDE0LTA4LTA3ICBEYW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNv bT4KIAogICAgICAgICBTb21ldGltZXMgR21haWwgY2Fubm90IGxvYWQgbWVzc2FnZXMsIHBhcnRp Y3VsYXJseSBvbiByZWZyZXNoICgiLi4udGhlIGFwcGxpY2F0aW9uIHJhbiBpbnRvIGFuIHVuZXhw ZWN0ZWQgZXJyb3IuLi4iKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9n IGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDUxODgzMDE2N2JiYzcyODRkMzQ4 YWNjNTc3ZTZlNjc5N2Y4Y2ViYjUuLmRjZDlhM2FlMjAxNmM5ZmY5Yjg1NTYyOTcyYjBmNjI5NTUw NWI0NzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxNC0wOC0wOCAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDb21wdXRlIGFu ZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlZCBDU1NfU0NST0xMX1NOQVAgZm9yIGlQaG9uZU9T IGFuZCB0aGUgc2ltdWxhdG9yLgorCisgICAgICAgICogQ29uZmlndXJhdGlvbnMvRmVhdHVyZURl ZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcgIEJlbmphbWluIFBvdWxhaW4gIDxicG91bGFp bkBhcHBsZS5jb20+CiAKICAgICAgICAgR2V0IHJpZCBvZiBJTlBVVF9TUEVFQ0gKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpp bmRleCBiYWI4MjRiNjRkY2IwOGVjNTVjMDQwN2E0MzAwY2JmNWJkZTEyMTBiLi4yZDk3YWMyYjRl MDg0ZDc4ZDMzMGFmYTRjZTRiODQ0NzNkODYyYjQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQg QEAKKzIwMTQtMDgtMDggIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisK KyAgICAgICAgQ29tcHV0ZSBhbmQgc3RvcmUgc25hcCBwb2ludCBwb3NpdGlvbnMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNTI2OAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZWQgQ1NTX1NDUk9M TF9TTkFQIGZvciBpUGhvbmVPUyBhbmQgdGhlIHNpbXVsYXRvci4KKworICAgICAgICAqIENvbmZp Z3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnOgorCiAyMDE0LTA4LTA3ICBCZW5qYW1p biBQb3VsYWluICA8YnBvdWxhaW5AYXBwbGUuY29tPgogCiAgICAgICAgIEdldCByaWQgb2YgSU5Q VVRfU1BFRUNICmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ29uZmlndXJhdGlv bnMvRmVhdHVyZURlZmluZXMueGNjb25maWcgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ29uZmln dXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKaW5kZXggZGJlYWUwY2QwMmI5ZTA5M2E4 ODMzMzA5Y2RkMTEyN2E3OGVjODAyYy4uYmY2MzRhNzdiZWEwMWU4M2Q1NzliNWY3YzU1YjU5YzEy YmU3NDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NvbmZpZ3VyYXRpb25z L0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Db25m aWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAtMTg2LDYgKzE4Niw4IEBAIEVO QUJMRV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBFTkFCTEVfU0hBUkVEX1dPUktFUlMgPSBFTkFCTEVf U0hBUkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQID0gJChFTkFCTEVfQ1NTX1ND Uk9MTF9TTkFQXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUF9tYWNv c3ggPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhv bmVvcyA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lw aG9uZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyk7CiBFTkFC TEVfU1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5BQkxFX1NQRUVDSF9TWU5USEVTSVNfJChQTEFURk9S TV9OQU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhF U0lTOwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9IEVOQUJMRV9TUUxfREFUQUJBU0U7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL0NNYWtl TGlzdHMudHh0CmluZGV4IDMwZjZkYzBjZTA4ODhhNWM2ZWU4ZTVlYzMzNmEwOGZkZmQwZDk2Mjcu LjBmMzU0YTEyMWUzN2VmNWYxZmZhZjE0ZjQxZmQxZjdkMmEwM2RjMTcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlz dHMudHh0CkBAIC0xOTYwLDYgKzE5NjAsNyBAQCBzZXQoV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGFn ZS9zY3JvbGxpbmcvU2Nyb2xsaW5nU3RhdGVTY3JvbGxpbmdOb2RlLmNwcAogICAgIHBhZ2Uvc2Ny b2xsaW5nL1Njcm9sbGluZ1N0YXRlU3RpY2t5Tm9kZS5jcHAKICAgICBwYWdlL3Njcm9sbGluZy9T Y3JvbGxpbmdTdGF0ZVRyZWUuY3BwCisgICAgcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFn ZXIuY3BwCiAKICAgICBwbGF0Zm9ybS9DYWxjdWxhdGlvblZhbHVlLmNwcAogICAgIHBsYXRmb3Jt L0Nsb2NrLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvRmVh dHVyZURlZmluZXMueGNjb25maWcgYi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0 dXJlRGVmaW5lcy54Y2NvbmZpZwppbmRleCBkYmVhZTBjZDAyYjllMDkzYTg4MzMzMDljZGQxMTI3 YTc4ZWM4MDJjLi5iZjYzNGE3N2JlYTAxZTgzZDU3OWI1ZjdjNTViNTljMTJiZTc0NmYxIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2Nv bmZpZworKysgYi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54 Y2NvbmZpZwpAQCAtMTg2LDYgKzE4Niw4IEBAIEVOQUJMRV9TQ1JJUFRFRF9TUEVFQ0ggPSA7CiBF TkFCTEVfU0hBUkVEX1dPUktFUlMgPSBFTkFCTEVfU0hBUkVEX1dPUktFUlM7CiBFTkFCTEVfQ1NT X1NDUk9MTF9TTkFQID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQXyQoUExBVEZPUk1fTkFNRSkp OwogRU5BQkxFX0NTU19TQ1JPTExfU05BUF9tYWNvc3ggPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQ OworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyA9IEVOQUJMRV9DU1NfU0NST0xMX1NO QVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVsYXRvciA9ICQoRU5BQkxFX0NT U19TQ1JPTExfU05BUF9pcGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9ICQoRU5B QkxFX1NQRUVDSF9TWU5USEVTSVNfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfU1BFRUNIX1NZ TlRIRVNJUyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5BQkxFX1NRTF9EQVRBQkFTRSA9 IEVOQUJMRV9TUUxfREFUQUJBU0U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZThkNTFlY2Y0YmQwMzlkYTNkOGIzMzA0ZmY0ZjAz YTJjOGY5MWI3My4uZGUyOGQ5YzVjMjgxODc1NjFjZWE3ZmFkNGI0MWUxN2Q2YWFiYjE1ZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpA QCAtNjI0Nyw2ICs2MjQ3LDggQEAKIAkJRjQyRkZCNDYxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0 aFJlcGVhdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RjQyRkZCNDUxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovOyB9OwogCQlGNDdB NUUzRTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0 ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVU RVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0 eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFw UG9pbnRzLmNwcCAqLzsgfTsKKwkJRjQ5NDBCREYxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNu YXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEY0OTQwQkREMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdlci5jcHAgKi87 IH07CisJCUY0OTQwQkUwMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdlci5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ5NDBCREUxOTgy RjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmggKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8q IEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAg Ki87IH07CiAJCUY1MDY2NEY4MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUwNjY0RjYxNTdG NTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmggKi87IH07CiAJCUY1MTNBM0VBMTVGRjQ4 NDEwMDE1MjZEQiAvKiBWYWxpZGF0aW9uTWVzc2FnZUNsaWVudC5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUxM0EzRTkxNUZGNDg0MTAwMTUyNkRCIC8q IFZhbGlkYXRpb25NZXNzYWdlQ2xpZW50LmggKi87IH07CkBAIC0xMzc2NCw2ICsxMzc2Niw4IEBA CiAJCUY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUY0N0E1RTNBMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQ b2ludHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3R5bGVTY3Jv bGxTbmFwUG9pbnRzLmNwcDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAv KiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1l ID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmg7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQ b2ludHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ5NDBCREQxOTgyRjQ2QTAw MTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJRjQ5NDBCREUxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBG b3JtQ29udHJvbGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBG b3JtQ29udHJvbGxlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY2 MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBGb3JtQ29udHJvbGxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlGNTEzQTNFOTE1RkY0ODQxMDAxNTI2REIgLyogVmFsaWRhdGlvbk1lc3NhZ2VDbGllbnQu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVmFsaWRhdGlvbk1lc3NhZ2VDbGll bnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1MTM5LDYgKzE1MTQzLDggQEAK IAkJCQk5MzkxQTk5QjE2MjlENzAwMDAyOTczMzAgLyogU2Nyb2xsaW5nVHJlZVNjcm9sbGluZ05v ZGUuaCAqLywKIAkJCQkwRjYzODNEQjE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3JvbGxp bmdUcmVlLmNwcCAqLywKIAkJCQkwRjYzODNEQzE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRT Y3JvbGxpbmdUcmVlLmggKi8sCisJCQkJRjQ5NDBCREQxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9s bFNuYXBNYW5hZ2VyLmNwcCAqLywKKwkJCQlGNDk0MEJERTE5ODJGNDZBMDAxN0RCNjEgLyogU2Ny b2xsU25hcE1hbmFnZXIuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gc2Nyb2xsaW5nOwogCQkJc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTIzOTk4LDYgKzI0MDA0LDcgQEAKIAkJCQlBMUM3OTcx RDE4ODNFNTFGMDAwRjVFMUYgLyogRE9NSFRNTFRleHRBcmVhRWxlbWVudFByaXZhdGUuaCBpbiBI ZWFkZXJzICovLAogCQkJCTg1OTkyRUMwMEFBNTA2OTUwMEFDMDc4NSAvKiBET01IVE1MVGl0bGVF bGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk4NUU3MTFDRjBBQzVENTM1MDA1MzI3MEYgLyog RE9NSFRNTFRpdGxlRWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywKKwkJCQlGNDk0MEJF MDE5ODJGNDZBMDAxN0RCNjEgLyogU2Nyb2xsU25hcE1hbmFnZXIuaCBpbiBIZWFkZXJzICovLAog CQkJCTg1QkE0RDE3MEFBNjg4NjgwMDg4MDUyRCAvKiBET01IVE1MVUxpc3RFbGVtZW50LmggaW4g SGVhZGVycyAqLywKIAkJCQk4NUU3MTFEMDBBQzVENTM1MDA1MzI3MEYgLyogRE9NSFRNTFVMaXN0 RWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywKIAkJCQlBODE4NUYzQjA5NzY1NzY2MDA1 ODI2RDkgLyogRE9NSW1wbGVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovLApAQCAtMjczNTMsNiAr MjczNjAsNyBAQAogCQkJCUE4ODJEQTIwMTU5Mzg0NkEwMDAxMTVFRCAvKiBDU1NUb1N0eWxlTWFw LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3MUY1M0VBMEQyNzA0RjkwMEVDRTBENSAvKiBDU1NV bmljb2RlUmFuZ2VWYWx1ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBRDAzQUFGQTE0Njg0NTUz MDBBMzlCNUIgLyogQ1NTVmFsdWUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ5NDBCREYxOTgy RjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJ CTFBQkE3NkNCMTFEMjBFNTcwMDRDMjAxQyAvKiBDU1NWYWx1ZUtleXdvcmRzLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUE4MEU2Q0U0MEExOTg5Q0EwMDdGQjhDNSAvKiBDU1NWYWx1ZUxpc3QuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJRTQ5QkRBMEIxMzFGRDNFNTAwM0M1NkYwIC8qIENTU1ZhbHVl UG9vbC5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv c2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Ny b2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kYTQ0ZDYzNjI2Mzg2ZDY4 ZDhhOGRjZWYyZWU0NzE3MjBmMTg4MWUyCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3BwCkBAIC0wLDAgKzEsMjMwIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlNjcm9sbFNuYXBN YW5hZ2VyLmgiCisKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjaW5jbHVkZSAiRnJh bWVWaWV3LmgiCisjaW5jbHVkZSAiSFRNTENvbGxlY3Rpb24uaCIKKyNpbmNsdWRlICJSZW5kZXJC b3guaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5n QnVpbGRlci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1NuYXBQb3NpdGlvbkxpc3Q6OlNu YXBQb3NpdGlvbkxpc3QoKQoreworfQorCitTbmFwUG9zaXRpb25MaXN0OjpTbmFwUG9zaXRpb25M aXN0KFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwUG9zaXRpb25zKQorICAgIDogcG9zaXRpb25zKHNu YXBQb3NpdGlvbnMpCit7Cit9CisKK3NpemVfdCBTbmFwUG9zaXRpb25MaXN0OjpzaXplKCkgY29u c3QKK3sKKyAgICByZXR1cm4gcG9zaXRpb25zLnNpemUoKTsKK30KKwordm9pZCBTbmFwUG9zaXRp b25MaXN0OjpjbGVhcigpCit7CisgICAgcG9zaXRpb25zLmNsZWFyKCk7Cit9CisKK3ZvaWQgU25h cFBvc2l0aW9uTGlzdDo6cmVzaXplKHNpemVfdCBzaXplKQoreworICAgIHBvc2l0aW9ucy5yZXNp emUoc2l6ZSk7Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9uTGlzdDo6YXBwZW5kKExheW91dFVuaXQg cG9zaXRpb24pCit7CisgICAgcG9zaXRpb25zLmFwcGVuZChwb3NpdGlvbik7Cit9CisKK0xheW91 dFVuaXQgU25hcFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNuYXBQb3NpdGlvbihMYXlvdXRVbml0IHNj cm9sbERlc3RpbmF0aW9uLCBmbG9hdCB2ZWxvY2l0eSkgY29uc3QKK3sKKyAgICBpZiAoc2Nyb2xs RGVzdGluYXRpb24gPD0gMCkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKHNjcm9sbERlc3Rp bmF0aW9uID49IHBvc2l0aW9ucy5hdChwb3NpdGlvbnMuc2l6ZSgpIC0gMSkpCisgICAgICAgIHJl dHVybiBwb3NpdGlvbnMuYXQocG9zaXRpb25zLnNpemUoKSAtIDEpOworICAgIHNpemVfdCBsb3dl ckluZGV4ID0gMDsKKyAgICBzaXplX3QgdXBwZXJJbmRleCA9IHBvc2l0aW9ucy5zaXplKCkgLSAx OworICAgIHNpemVfdCBtaWRkbGVJbmRleDsKKworICAgIHdoaWxlIChsb3dlckluZGV4IDwgdXBw ZXJJbmRleCAtIDEpIHsKKyAgICAgICAgbWlkZGxlSW5kZXggPSAobG93ZXJJbmRleCArIHVwcGVy SW5kZXgpIC8gMjsKKyAgICAgICAgaWYgKHNjcm9sbERlc3RpbmF0aW9uIDwgcG9zaXRpb25zLmF0 KG1pZGRsZUluZGV4KSkKKyAgICAgICAgICAgIHVwcGVySW5kZXggPSBtaWRkbGVJbmRleDsKKyAg ICAgICAgZWxzZSBpZiAoc2Nyb2xsRGVzdGluYXRpb24gPiBwb3NpdGlvbnMuYXQobWlkZGxlSW5k ZXgpKQorICAgICAgICAgICAgbG93ZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICBlbHNl IHsKKyAgICAgICAgICAgIHVwcGVySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGxv d2VySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9Cisg ICAgfQorICAgIExheW91dFVuaXQgbG93ZXJTbmFwUG9zaXRpb24gPSBwb3NpdGlvbnMuYXQobG93 ZXJJbmRleCk7CisgICAgTGF5b3V0VW5pdCB1cHBlclNuYXBQb3NpdGlvbiA9IHBvc2l0aW9ucy5h dCh1cHBlckluZGV4KTsKKyAgICAvLyBOb256ZXJvIHZlbG9jaXR5IGluZGljYXRlcyBhIGZsaWNr IGdlc3R1cmUuIEV2ZW4gaWYgYW5vdGhlciBzbmFwIHBvaW50IGlzIGNsb3Nlciwgc25hcCB0byB0 aGUgb25lIGluIHRoZSBkaXJlY3Rpb24gb2YgdGhlIGZsaWNrIGdlc3R1cmUuCisgICAgaWYgKHZl bG9jaXR5KQorICAgICAgICByZXR1cm4gdmVsb2NpdHkgPCAwID8gbG93ZXJTbmFwUG9zaXRpb24g OiB1cHBlclNuYXBQb3NpdGlvbjsKKyAgICAvLyBJZiB2ZWxvY2l0eSBpcyB6ZXJvLCB0aGVuIHRo ZSB1c2VyIHJlbGVhc2VkIHdpdGhvdXQgZmxpY2tpbmcsIHNvIHdlIHNpbXBseSBzbmFwIHRvIHRo ZSBjbG9zZXIgcG9pbnQuCisgICAgcmV0dXJuIHNjcm9sbERlc3RpbmF0aW9uIC0gbG93ZXJTbmFw UG9zaXRpb24gPD0gdXBwZXJTbmFwUG9zaXRpb24gLSBzY3JvbGxEZXN0aW5hdGlvbiA/IGxvd2Vy U25hcFBvc2l0aW9uIDogdXBwZXJTbmFwUG9zaXRpb247Cit9CisKK1Njcm9sbFNuYXBNYW5hZ2Vy OjpTY3JvbGxTbmFwTWFuYWdlcihTY3JvbGxFdmVudEF4aXMgYXhpcykKKyAgICA6IG1heFNjcm9s bE9mZnNldCgwKQorICAgICwgbV9heGlzKGF4aXMpCit7Cit9CisKK1Bhc3NPd25QdHI8U2Nyb2xs U25hcE1hbmFnZXI+IFNjcm9sbFNuYXBNYW5hZ2VyOjpjcmVhdGUoU2Nyb2xsRXZlbnRBeGlzIGF4 aXMpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBTY3JvbGxTbmFwTWFuYWdlcihheGlzKSk7 Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbUZyYW1lVmll dyhGcmFtZVZpZXcqIGZyYW1lVmlldykKK3sKKyAgICBpZiAoUmVuZGVyVmlldyogcmVuZGVyVmll dyA9IGZyYW1lVmlldy0+cmVuZGVyVmlldygpKSB7CisgICAgICAgIEhUTUxFbGVtZW50KiBib2R5 ID0gcmVuZGVyVmlldy0+ZG9jdW1lbnQoKS5ib2R5KCk7CisgICAgICAgIGlmIChib2R5KSB7Cisg ICAgICAgICAgICBjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUgPSBib2R5LT5yZW5kZXJlcigpLT5z dHlsZSgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCBzaXplID0gbV9heGlzID09IFNjcm9sbEV2 ZW50QXhpczo6SG9yaXpvbnRhbCA/IHJlbmRlclZpZXctPndpZHRoKCkgOiByZW5kZXJWaWV3LT5o ZWlnaHQoKTsKKyAgICAgICAgICAgIExheW91dFVuaXQgc2Nyb2xsU2l6ZSA9IG1fYXhpcyA9PSBT Y3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyByZW5kZXJWaWV3LT5zY3JvbGxXaWR0aCgpIDog cmVuZGVyVmlldy0+c2Nyb2xsSGVpZ2h0KCk7CisgICAgICAgICAgICBpZiAoc2Nyb2xsU2l6ZSA8 PSAwIHx8IHNpemUgPD0gMCB8fCBzaXplID49IHNjcm9sbFNpemUpCisgICAgICAgICAgICAgICAg cmV0dXJuOworCisgICAgICAgICAgICBtYXhTY3JvbGxPZmZzZXQgPSBzY3JvbGxTaXplIC0gc2l6 ZTsKKyAgICAgICAgICAgIGlmICgobV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRh bCAmJiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1goKSkKKyAgICAgICAgICAgICAgICB8 fCAobV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6VmVydGljYWwgJiYgIXN0eWxlLnNjcm9sbFNu YXBVc2VzRWxlbWVudHNZKCkpKQorICAgICAgICAgICAgICAgIHVwZGF0ZVNuYXBEYXRhRnJvbVN0 eWxlKHN0eWxlLCBzaXplKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB1cGRh dGVTbmFwRGF0YUZyb21TdHlsZUFuZFBhcmVudEVsZW1lbnQoc3R5bGUsIGJvZHksIHNpemUpOwor ICAgICAgICB9CisgICAgfQorfQorCit2b2lkIFNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFw RGF0YUZyb21QYXJlbnRFbGVtZW50KEhUTUxFbGVtZW50KiBwYXJlbnQpCit7CisgICAgaWYgKFJl bmRlckJveCogcGFyZW50Qm94ID0gcGFyZW50LT5yZW5kZXJCb3goKSkgeworICAgICAgICBjb25z dCBSZW5kZXJTdHlsZSYgc3R5bGUgPSBwYXJlbnRCb3gtPnN0eWxlKCk7CisgICAgICAgIExheW91 dFVuaXQgc2l6ZSA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBwYXJl bnRCb3gtPndpZHRoKCkgOiBwYXJlbnRCb3gtPmhlaWdodCgpOworICAgICAgICBMYXlvdXRVbml0 IHNjcm9sbFNpemUgPSBtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gcGFy ZW50Qm94LT5zY3JvbGxXaWR0aCgpIDogcGFyZW50Qm94LT5zY3JvbGxIZWlnaHQoKTsKKyAgICAg ICAgaWYgKHNjcm9sbFNpemUgPD0gMCB8fCBzaXplIDw9IDAgfHwgc2l6ZSA+PSBzY3JvbGxTaXpl KQorICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgIG1heFNjcm9sbE9mZnNldCA9IHNjcm9s bFNpemUgLSBzaXplOworICAgICAgICBpZiAoKG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhv cml6b250YWwgJiYgIXN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkpCisgICAgICAgICAg ICB8fCAobV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6VmVydGljYWwgJiYgIXN0eWxlLnNjcm9s bFNuYXBVc2VzRWxlbWVudHNZKCkpKQorICAgICAgICAgICAgdXBkYXRlU25hcERhdGFGcm9tU3R5 bGUoc3R5bGUsIHNpemUpOworICAgICAgICBlbHNlCisgICAgICAgICAgICB1cGRhdGVTbmFwRGF0 YUZyb21TdHlsZUFuZFBhcmVudEVsZW1lbnQoc3R5bGUsIHBhcmVudCwgc2l6ZSk7CisgICAgfQor fQorCit2b2lkIFNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFwRGF0YUZyb21TdHlsZUFuZFBh cmVudEVsZW1lbnQoY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlLCBIVE1MRWxlbWVudCogcGFyZW50 LCBMYXlvdXRVbml0IHNpemUpCit7CisgICAgLy8gSGFuZGxlICJlbGVtZW50cyIgc3BlY2lmaWNh dGlvbiBieSB0cmF2ZXJzaW5nIGNoaWxkcmVuLgorICAgIHNuYXBQb3NpdGlvbnMuY2xlYXIoKTsK KyAgICBMYXlvdXRVbml0IHBhcmVudE9mZnNldCA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6 Okhvcml6b250YWwgPyBwYXJlbnQtPnJlbmRlckJveCgpLT5vZmZzZXRMZWZ0KCkgOiBwYXJlbnQt PnJlbmRlckJveCgpLT5vZmZzZXRUb3AoKTsKKyAgICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zm c2V0ID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHZhbHVlRm9yTGVu Z3RoKHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblgoKSwgc2l6ZSkgOiB2YWx1ZUZvckxlbmd0 aChzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25ZKCksIHNpemUpOworICAgIExheW91dFVuaXQg bGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2lu dCBvbiB0aGUgbWluaW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIHNuYXBQb3NpdGlvbnMuYXBwZW5k KDApOworICAgIEVsZW1lbnQqIGNoaWxkID0gcGFyZW50LT5jaGlsZHJlbigpLT5jb2xsZWN0aW9u QmVnaW4oKTsKKyAgICB3aGlsZSAoY2hpbGQgJiYgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbiA8 IG1heFNjcm9sbE9mZnNldCkgeworICAgICAgICBpZiAoY2hpbGQtPmlzSFRNTEVsZW1lbnQoKSAm JiB0b0hUTUxFbGVtZW50KGNoaWxkKS0+cmVuZGVyQm94KCkpIHsKKyAgICAgICAgICAgIFJlbmRl ckJveCogY2hpbGRCb3ggPSB0b0hUTUxFbGVtZW50KGNoaWxkKS0+cmVuZGVyQm94KCk7CisgICAg ICAgICAgICBMYXlvdXRVbml0IGNoaWxkU2l6ZSA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6 Okhvcml6b250YWwgPyBjaGlsZEJveC0+d2lkdGgoKSA6IGNoaWxkQm94LT5oZWlnaHQoKTsKKyAg ICAgICAgICAgIExheW91dFVuaXQgY2hpbGRPZmZzZXQgPSAobV9heGlzID09IFNjcm9sbEV2ZW50 QXhpczo6SG9yaXpvbnRhbCA/IGNoaWxkQm94LT5vZmZzZXRMZWZ0KCkgOiBjaGlsZEJveC0+b2Zm c2V0VG9wKCkpIC0gcGFyZW50T2Zmc2V0OworICAgICAgICAgICAgZm9yIChTbmFwQ29vcmRpbmF0 ZSBjb29yZGluYXRlIDogY2hpbGRCb3gtPnN0eWxlKCkuc2Nyb2xsU25hcENvb3JkaW5hdGVzKCkp IHsKKyAgICAgICAgICAgICAgICBMYXlvdXRVbml0IGNvb3JkaW5hdGVPZmZzZXQgPSB2YWx1ZUZv ckxlbmd0aChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gY29vcmRpbmF0 ZS5maXJzdCA6IGNvb3JkaW5hdGUuc2Vjb25kLCBjaGlsZFNpemUpOworICAgICAgICAgICAgICAg IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjaGlsZE9mZnNldCArIGNvb3JkaW5hdGVPZmZz ZXQgLSBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAgICAgICAgICBpZiAobGFzdFBvdGVudGlh bFNuYXBQb3NpdGlvbiA8PSAwKQorICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAg ICAgICAgICAgICAgIGlmIChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uID49IG1heFNjcm9sbE9m ZnNldCkKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgICAgICBzbmFw UG9zaXRpb25zLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0RWxlbWVudFNpYmxpbmco KTsKKyAgICB9CisgICAgLy8gQWx3YXlzIHB1dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1heGltdW0g c2Nyb2xsIG9mZnNldC4KKyAgICBpZiAoc25hcFBvc2l0aW9ucy5wb3NpdGlvbnNbc25hcFBvc2l0 aW9ucy5zaXplKCkgLSAxXSAhPSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAgIHNuYXBQb3NpdGlv bnMuYXBwZW5kKG1heFNjcm9sbE9mZnNldCk7Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6 OnVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlKGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSwgTGF5b3V0 VW5pdCBzaXplKQoreworICAgIFZlY3RvcjxMZW5ndGg+IHNuYXBPZmZzZXRzID0gbV9heGlzID09 IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRzWCgp IDogc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNZKCk7CisgICAgVmVjdG9yPExheW91dFVuaXQ+IHNu YXBQb3NpdGlvblN1YnNlcXVlbmNlOworICAgIGZvciAoTGVuZ3RoIHNuYXBPZmZzZXQgOiBzbmFw T2Zmc2V0cykKKyAgICAgICAgc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UuYXBwZW5kKHZhbHVlRm9y TGVuZ3RoKHNuYXBPZmZzZXQsIHNpemUpKTsKKyAgICBpZiAoIXNuYXBQb3NpdGlvblN1YnNlcXVl bmNlLnNpemUoKSkKKyAgICAgICAgc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UuYXBwZW5kKDApOwor CisgICAgaWYgKG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpCisgICAgICAg IHVwZGF0ZVNuYXBQb3NpdGlvbnNGcm9tT2Zmc2V0cyhzbmFwUG9zaXRpb25TdWJzZXF1ZW5jZSwg dmFsdWVGb3JMZW5ndGgoc3R5bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpLCBzaXplKSwgc3R5 bGUuc2Nyb2xsU25hcEhhc1JlcGVhdFgoKSwgdmFsdWVGb3JMZW5ndGgoc3R5bGUuc2Nyb2xsU25h cFJlcGVhdE9mZnNldFgoKSwgc2l6ZSkpOworICAgIGVsc2UKKyAgICAgICAgdXBkYXRlU25hcFBv c2l0aW9uc0Zyb21PZmZzZXRzKHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlLCB2YWx1ZUZvckxlbmd0 aChzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25ZKCksIHNpemUpLCBzdHlsZS5zY3JvbGxTbmFw SGFzUmVwZWF0WSgpLCB2YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0 WSgpLCBzaXplKSk7Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBQb3Np dGlvbnNGcm9tT2Zmc2V0cyhjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBQb3NpdGlvblN1 YnNlcXVlbmNlLCBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0LCBib29sIGhhc1JlcGVhdCwg TGF5b3V0VW5pdCByZXBlYXRPZmZzZXQpCit7CisgICAgc25hcFBvc2l0aW9ucy5jbGVhcigpOwor ICAgIExheW91dFVuaXQgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSAtZGVzdGluYXRpb25PZmZzZXQ7 CisgICAgTGF5b3V0VW5pdCBsYXN0U25hcFBvc2l0aW9uID0gY3VyU25hcFBvc2l0aW9uU2hpZnQ7 CisgICAgTGF5b3V0VW5pdCBwb3RlbnRpYWxTbmFwUG9zaXRpb247CisgICAgLy8gQWx3YXlzIHB1 dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1pbmltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICBzbmFwUG9z aXRpb25zLmFwcGVuZCgwKTsKKyAgICBkbyB7CisgICAgICAgIGZvciAoTGF5b3V0VW5pdCBzbmFw UG9zaXRpb24gOiBzbmFwUG9zaXRpb25TdWJzZXF1ZW5jZSkgeworICAgICAgICAgICAgcG90ZW50 aWFsU25hcFBvc2l0aW9uID0gY3VyU25hcFBvc2l0aW9uU2hpZnQgKyBzbmFwUG9zaXRpb247Cisg ICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAg ICAgY29udGludWU7CisgICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uID49IG1h eFNjcm9sbE9mZnNldCkKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIHNuYXBQ b3NpdGlvbnMuYXBwZW5kKHBvdGVudGlhbFNuYXBQb3NpdGlvbik7CisgICAgICAgICAgICBsYXN0 U25hcFBvc2l0aW9uID0gcG90ZW50aWFsU25hcFBvc2l0aW9uOworICAgICAgICB9CisgICAgICAg IGN1clNuYXBQb3NpdGlvblNoaWZ0ID0gbGFzdFNuYXBQb3NpdGlvbiArIHJlcGVhdE9mZnNldDsK KyAgICB9IHdoaWxlIChoYXNSZXBlYXQgJiYgY3VyU25hcFBvc2l0aW9uU2hpZnQgPCBtYXhTY3Jv bGxPZmZzZXQpOworICAgIC8vIEFsd2F5cyBwdXQgYSBzbmFwIHBvaW50IG9uIHRoZSBtYXhpbXVt IHNjcm9sbCBvZmZzZXQuCisgICAgaWYgKHNuYXBQb3NpdGlvbnMucG9zaXRpb25zW3NuYXBQb3Np dGlvbnMuc2l6ZSgpIC0gMV0gIT0gbWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICBzbmFwUG9zaXRp b25zLmFwcGVuZChtYXhTY3JvbGxPZmZzZXQpOworfQorCitTY3JvbGxFdmVudEF4aXMgU2Nyb2xs U25hcE1hbmFnZXI6OmF4aXMoKSBjb25zdAoreworICAgIHJldHVybiBtX2F4aXM7Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuaCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmgKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uZjQxNDhlNGJkMGRiMjg5ZmRkODIwOTY4MTRkYTMxZDg1NzQ0YzUwNAotLS0gL2Rldi9u dWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2Vy LmgKQEAgLTAsMCArMSw4NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICog QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgU2Nyb2xsU25hcE1hbmFn ZXJfaAorI2RlZmluZSBTY3JvbGxTbmFwTWFuYWdlcl9oCisKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQorCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKKyNpbmNsdWRlICJMYXlvdXRVbml0 LmgiCisjaW5jbHVkZSAiTGVuZ3RoLmgiCisjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKKyNpbmNs dWRlICJTY3JvbGxUeXBlcy5oIgorI2luY2x1ZGUgIlN0eWxlU2Nyb2xsU25hcFBvaW50cy5oIgor CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5o PgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK Kworc3RydWN0IFNuYXBQb3NpdGlvbkxpc3QgeworICAgIFNuYXBQb3NpdGlvbkxpc3QoKTsKKyAg ICBTbmFwUG9zaXRpb25MaXN0KFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwUG9zaXRpb25zKTsKKyAg ICBzaXplX3Qgc2l6ZSgpIGNvbnN0OworICAgIHZvaWQgY2xlYXIoKTsKKyAgICB2b2lkIHJlc2l6 ZShzaXplX3QpOworICAgIHZvaWQgYXBwZW5kKExheW91dFVuaXQpOworICAgIExheW91dFVuaXQg Y2xvc2VzdFNuYXBQb3NpdGlvbihMYXlvdXRVbml0LCBmbG9hdCB2ZWxvY2l0eSA9IDApIGNvbnN0 OworCisgICAgVmVjdG9yPExheW91dFVuaXQ+IHBvc2l0aW9uczsKK307CisKK2NsYXNzIFNjcm9s bFNuYXBNYW5hZ2VyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxTY3JvbGxTbmFw TWFuYWdlcj4gY3JlYXRlKFNjcm9sbEV2ZW50QXhpcyk7CisKKyAgICBTY3JvbGxTbmFwTWFuYWdl cihTY3JvbGxFdmVudEF4aXMpOworCisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21GcmFtZVZp ZXcoRnJhbWVWaWV3Kik7CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21QYXJlbnRFbGVtZW50 KEhUTUxFbGVtZW50Kik7CisKKyAgICBTY3JvbGxFdmVudEF4aXMgYXhpcygpIGNvbnN0OworCisg ICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQ7CisgICAgU25hcFBvc2l0aW9uTGlzdCBzbmFw UG9zaXRpb25zOworICAgIAorcHJpdmF0ZToKKyAgICB2b2lkIHVwZGF0ZVNuYXBEYXRhRnJvbVN0 eWxlQW5kUGFyZW50RWxlbWVudChjb25zdCBSZW5kZXJTdHlsZSYsIEhUTUxFbGVtZW50KiwgTGF5 b3V0VW5pdCk7CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21TdHlsZShjb25zdCBSZW5kZXJT dHlsZSYsIExheW91dFVuaXQpOworICAgIHZvaWQgdXBkYXRlU25hcFBvc2l0aW9uc0Zyb21PZmZz ZXRzKGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYsIExheW91dFVuaXQgZGVzdGluYXRpb25PZmZz ZXQgPSAwLCBib29sIGhhc1JlcGVhdCA9IGZhbHNlLCBMYXlvdXRVbml0IHJlcGVhdE9mZnNldCA9 IDApOworCisgICAgU2Nyb2xsRXZlbnRBeGlzIG1fYXhpczsKK307CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKKyNlbmRpZiAv LyBTY3JvbGxTbmFwTWFuYWdlcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9Db25m aWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZyBiL1NvdXJjZS9XZWJLaXQvbWFjL0Nv bmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCmluZGV4IGRiZWFlMGNkMDJiOWUw OTNhODgzMzMwOWNkZDExMjdhNzhlYzgwMmMuLmJmNjM0YTc3YmVhMDFlODNkNTc5YjVmN2M1NWI1 OWMxMmJlNzQ2ZjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NvbmZpZ3VyYXRpb25z L0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NvbmZpZ3Vy YXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCkBAIC0xODYsNiArMTg2LDggQEAgRU5BQkxF X1NDUklQVEVEX1NQRUVDSCA9IDsKIEVOQUJMRV9TSEFSRURfV09SS0VSUyA9IEVOQUJMRV9TSEFS RURfV09SS0VSUzsKIEVOQUJMRV9DU1NfU0NST0xMX1NOQVAgPSAkKEVOQUJMRV9DU1NfU0NST0xM X1NOQVBfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX21hY29zeCA9 IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZW9z ID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25l c2ltdWxhdG9yID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZW9zKTsKIEVOQUJMRV9T UEVFQ0hfU1lOVEhFU0lTID0gJChFTkFCTEVfU1BFRUNIX1NZTlRIRVNJU18kKFBMQVRGT1JNX05B TUUpKTsKIEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTID0gRU5BQkxFX1NQRUVDSF9TWU5USEVTSVM7 CiBFTkFCTEVfU1FMX0RBVEFCQVNFID0gRU5BQkxFX1NRTF9EQVRBQkFTRTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnIGIv U291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKaW5k ZXggZGJlYWUwY2QwMmI5ZTA5M2E4ODMzMzA5Y2RkMTEyN2E3OGVjODAyYy4uYmY2MzRhNzdiZWEw MWU4M2Q1NzliNWY3YzU1YjU5YzEyYmU3NDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv Q29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKKysrIGIvU291cmNlL1dlYktp dDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKQEAgLTE4Niw2ICsxODYs OCBAQCBFTkFCTEVfU0NSSVBURURfU1BFRUNIID0gOwogRU5BQkxFX1NIQVJFRF9XT1JLRVJTID0g RU5BQkxFX1NIQVJFRF9XT1JLRVJTOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUCA9ICQoRU5BQkxF X0NTU19TQ1JPTExfU05BUF8kKFBMQVRGT1JNX05BTUUpKTsKIEVOQUJMRV9DU1NfU0NST0xMX1NO QVBfbWFjb3N4ID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NO QVBfaXBob25lb3MgPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExf U05BUF9pcGhvbmVzaW11bGF0b3IgPSAkKEVOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3Mp OwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSAkKEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTXyQo UExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSBFTkFCTEVfU1BFRUNI X1NZTlRIRVNJUzsKIEVOQUJMRV9TUUxfREFUQUJBU0UgPSBFTkFCTEVfU1FMX0RBVEFCQVNFOwo= 236310 2014-08-08 14:55:18 -0700 2014-08-13 14:04:19 -0700 Patch bug-135268-20140808145506.patch text/plain 27149 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyMzU3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw NTI5MzU0OGY4ZDNhZGZkNTA4NjU1MmRiYmU5ZGRiNmI3ZjI5MDMxLi4zNDYzYzczOGVhY2Y4Nzlk MTQ3ZTlhZmU0MzYwNTQ4YjY3MGY0ZDU0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxNC0wOC0wOCAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisK KyAgICAgICAgRW5hYmxlIENTU19TQ1JPTExfU05BUCBvbiBpUGhvbmVPUyBhbmQgc2ltdWxhdG9y LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogQ29u ZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcgIFNhYW0g QmFyYXRpICA8c2JhcmF0aUBhcHBsZS5jb20+CiAKICAgICAgICAgQ3JlYXRlIGEgbW9yZSBnZW5l cmljIHdheSBmb3IgVk1FbnRyeVNjb3BlIHRvIG5vdGlmeSB0aG9zZSBpbnRlcmVzdGVkIHRoYXQg aXQgd2lsbCBiZSBkZXN0cm95ZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBmN2VkNjVmNzA1ODE1NWRiNTAzNTcy NWI3NzZmYjFhNGU0YWY1N2RjLi42YTY4OTYwNWRkYThlZGNmY2I0OWZhMjg4YTVlYWY2ZTMxZjE3 YjYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTQtMDgtMDggIFdlbnNvbiBIc2ll aCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgQ29tcHV0ZSBhbmQgc3RvcmUg c25hcCBwb2ludCBwb3NpdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEzNTI2OAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFdvcmtpbmcgdG93YXJkcyBpbXBsZW1lbnRpbmcgYSB3YXkgdG8gZXh0cmFj dCBzbmFwIHBvc2l0aW9ucyAoaS5lLiBMYXlvdXRVbml0cykgZnJvbSB0aGUgcGFyc2VkIHNuYXAg cG9pbnQgcHJvcGVydGllcyBmcm9tIENTUywKKyAgICAgICAgYXMgd2VsbCBhcyBhIHdheSBvZiBz dG9yaW5nIHRoZSBpbmZvcm1hdGlvbi4gU3VwcG9ydHMgYm90aCBtYWluZnJhbWUgYW5kIG92ZXJm bG93IHNjcm9sbGluZy4KKworICAgICAgICBObyBjaGFuZ2VzIGluIGJlaGF2aW9yLiBJIHdpbGwg d3JpdGUgdGVzdHMgd2hlbiBJIGltcGxlbWVudCBzbmFwcGluZyBmb3IgaU9TIGFuZCBNYWMuCisK KyAgICAgICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBDb25maWd1cmF0aW9ucy9GZWF0 dXJlRGVmaW5lcy54Y2NvbmZpZzoKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2o6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6OlNuYXBQb3NpdGlv bkxpc3QpOiBJbml0aWFsaXplcyBhbiBlbXB0eSBTbmFwUG9zaXRpb25MaXN0LgorICAgICAgICAo V2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6c2l6ZSk6IFdyYXBzIGNhbGwgdG8gVmVjdG9yLgor ICAgICAgICAoV2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6Y2xlYXIpOiBEaXR0by4KKyAgICAg ICAgKFdlYkNvcmU6OlNuYXBQb3NpdGlvbkxpc3Q6OnJlc2l6ZSk6IERpdHRvLgorICAgICAgICAo V2ViQ29yZTo6U25hcFBvc2l0aW9uTGlzdDo6YXBwZW5kKTogRGl0dG8uCisgICAgICAgIChXZWJD b3JlOjpTbmFwUG9zaXRpb25MaXN0OjpjbG9zZXN0U25hcFBvc2l0aW9uKTogQ29tcHV0ZSB0aGUg Y2xvc2VzdCBzbmFwIHBvc2l0aW9uIGdpdmVuIGluaXRpYWwgc2Nyb2xsIHZlbG9jaXR5LgorICAg ICAgICAoV2ViQ29yZTo6U2Nyb2xsU25hcE1hbmFnZXI6OlNjcm9sbFNuYXBNYW5hZ2VyKToKKyAg ICAgICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjpjcmVhdGUpOiBJbml0aWFsaXplcyBh bmQgcmV0dXJucyBhIG5ldyBTY3JvbGxTbmFwTWFuYWdlci4KKyAgICAgICAgKFdlYkNvcmU6OlNj cm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFwRGF0YUZyb21GcmFtZVZpZXcpOiBVc2VkIHRvIHVw ZGF0ZSBzbmFwIGRhdGEgaW4gdGhlIGNhc2Ugb2YgbWFpbmZyYW1lIHNjcm9sbGluZy4KKyAgICAg ICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVTbmFwRGF0YUZyb21QYXJlbnRF bGVtZW50KTogVXNlZCB0byB1cGRhdGUgc25hcCBkYXRhIGluIHRoZSBjYXNlIG9mIG92ZXJmbG93 IHNjcm9sbGluZy4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjp1cGRhdGVT bmFwRGF0YUZyb21TdHlsZUFuZFBhcmVudEVsZW1lbnQpOiBIZWxwZXIgbWV0aG9kLiBVc2VkIHdo ZW4gImVsZW1lbnRzIiBpcyBzcGVjaWZpZWQgZm9yIC1zbmFwLXBvaW50cy14L3kuCisgICAgICAg IChXZWJDb3JlOjpTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9tU3R5bGUpOiBI ZWxwZXIgbWV0aG9kLiBVc2VkIHdoZW4gc25hcCBwb2ludHMgYXJlIHNwZWNpZmllZCBpbiBhIGxp c3QvcmVwZWF0KDxsZW5ndGg+KSBmb3JtYXQuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxTbmFw TWFuYWdlcjo6dXBkYXRlU25hcFBvc2l0aW9uc0Zyb21PZmZzZXRzKTogSGVscGVyIG1ldGhvZC4K KyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFNuYXBNYW5hZ2VyOjpheGlzKTogRGV0ZXJtaW5lcyB0 aGUgc2Nyb2xsaW5nIGF4aXMgKGhvcml6b250YWwgb3IgdmVydGljYWwpIG9mIHRoZSBTY3JvbGxT bmFwTWFuYWdlci4KKyAgICAgICAgKiBwYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdlci5o OiBBZGRlZC4KKwogMjAxNC0wOC0wOCAgQmVtIEpvbmVzLUJleSAgPGJqb25lc2JlQGFkb2JlLmNv bT4KIAogICAgICAgICBbQ1NTIFNoYXBlc10gUmVmYWN0b3IgZ2V0RXhjbHVkZWRJbnRlcnZhbHMg c2luY2Ugb25seSBvbmUgTGluZVNlZ21lbnQgaXMgZXZlciByZXR1cm5lZApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9n CmluZGV4IGI0OGY4MDU5ZmRjOTdjOWViYTI3M2M4NTQ1M2I4MGRhMDcyZTIwMzkuLmNmMDJkZDFj NTQ2OTYzYjRiODEzYTFhOTQ5MzYwNTA2YjVhMjAyZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvbWFjL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxNC0wOC0wOCAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KKworICAgICAgICBDb21wdXRlIGFuZCBzdG9yZSBzbmFwIHBvaW50IHBvc2l0aW9ucwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM1MjY4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlZCBD U1NfU0NST0xMX1NOQVAgZm9yIGlQaG9uZU9TIGFuZCB0aGUgc2ltdWxhdG9yLgorCisgICAgICAg ICogQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWc6CisKIDIwMTQtMDgtMDcg IEJlbmphbWluIFBvdWxhaW4gIDxicG91bGFpbkBhcHBsZS5jb20+CiAKICAgICAgICAgR2V0IHJp ZCBvZiBTQ1JJUFRFRF9TUEVFQ0gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA0NjViYmQ1NzNiYTg0OTYwMDJiZWFj Y2Y0OGI2MDFiMjBlYWU3MmM3Li4xZDE2ZTFmNTYyNmJmYTY1ZmU5NGZkMmZlNzNiYjNmN2U3ZGQ0 ZmIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTQtMDgtMDggIFdlbnNvbiBIc2ll aCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgQ29tcHV0ZSBhbmQgc3RvcmUg c25hcCBwb2ludCBwb3NpdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEzNTI2OAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEVuYWJsZWQgQ1NTX1NDUk9MTF9TTkFQIGZvciBpUGhvbmVPUyBhbmQgdGhl IHNpbXVsYXRvci4KKworICAgICAgICAqIENvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhj Y29uZmlnOgorCiAyMDE0LTA4LTA4ICBUaW1vdGh5IEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFw cGxlLmNvbT4KIAogICAgICAgICBTZXJ2aWNlcyBvdmVybGF5IGRyb3Bkb3duIGlzIG9mdGVuIGlu IHRoZSB3cm9uZyBwbGFjZSB3aXRoIHpvb21lZCBwYWdlcyBvciBob3Jpem9udGFsIHNjcm9sbGlu ZwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1 cmVEZWZpbmVzLnhjY29uZmlnIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NvbmZpZ3VyYXRpb25z L0ZlYXR1cmVEZWZpbmVzLnhjY29uZmlnCmluZGV4IDcwNmM0OTk1NjllNzQ2ODM3ZTQ3OWNjZDEy ODdiYjA3ZTZlYmNlMWYuLjBkMDI2ZDBkZTIxNDZiMDFjNjdjODAxMzU4NGEzNmNhMDdlODY2NGUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Db25maWd1cmF0aW9ucy9GZWF0dXJl RGVmaW5lcy54Y2NvbmZpZworKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ29uZmlndXJhdGlv bnMvRmVhdHVyZURlZmluZXMueGNjb25maWcKQEAgLTE4NSw2ICsxODUsOCBAQCBFTkFCTEVfUkVT T0xVVElPTl9NRURJQV9RVUVSWSA9IDsKIEVOQUJMRV9TSEFSRURfV09SS0VSUyA9IEVOQUJMRV9T SEFSRURfV09SS0VSUzsKIEVOQUJMRV9DU1NfU0NST0xMX1NOQVAgPSAkKEVOQUJMRV9DU1NfU0NS T0xMX1NOQVBfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX21hY29z eCA9IEVOQUJMRV9DU1NfU0NST0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9u ZW9zID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBo b25lc2ltdWxhdG9yID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZW9zKTsKIEVOQUJM RV9TUEVFQ0hfU1lOVEhFU0lTID0gJChFTkFCTEVfU1BFRUNIX1NZTlRIRVNJU18kKFBMQVRGT1JN X05BTUUpKTsKIEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTID0gRU5BQkxFX1NQRUVDSF9TWU5USEVT SVM7CiBFTkFCTEVfU1FMX0RBVEFCQVNFID0gRU5BQkxFX1NRTF9EQVRBQkFTRTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0IGIvU291cmNlL1dlYkNvcmUvQ01ha2VM aXN0cy50eHQKaW5kZXggN2RkM2JkZWZiN2JlODAyODU0MTNiMGI4YzZjMzg3NjBjZjFjYTY2NC4u NzYxOTQ4MmRjNTVkZGRmNjY1ZWU4MWQxMTFiYTE5OGI5NjIxNzIxMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKKysrIGIvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0 cy50eHQKQEAgLTE5NjksNiArMTk2OSw3IEBAIHNldChXZWJDb3JlX1NPVVJDRVMKICAgICBwYWdl L3Njcm9sbGluZy9TY3JvbGxpbmdTdGF0ZVNjcm9sbGluZ05vZGUuY3BwCiAgICAgcGFnZS9zY3Jv bGxpbmcvU2Nyb2xsaW5nU3RhdGVTdGlja3lOb2RlLmNwcAogICAgIHBhZ2Uvc2Nyb2xsaW5nL1Nj cm9sbGluZ1N0YXRlVHJlZS5jcHAKKyAgICBwYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdl ci5jcHAKIAogICAgIHBsYXRmb3JtL0NhbGN1bGF0aW9uVmFsdWUuY3BwCiAgICAgcGxhdGZvcm0v Q2xvY2suY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9GZWF0 dXJlRGVmaW5lcy54Y2NvbmZpZyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1 cmVEZWZpbmVzLnhjY29uZmlnCmluZGV4IDcwNmM0OTk1NjllNzQ2ODM3ZTQ3OWNjZDEyODdiYjA3 ZTZlYmNlMWYuLjBkMDI2ZDBkZTIxNDZiMDFjNjdjODAxMzU4NGEzNmNhMDdlODY2NGUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhjY29u ZmlnCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL0ZlYXR1cmVEZWZpbmVzLnhj Y29uZmlnCkBAIC0xODUsNiArMTg1LDggQEAgRU5BQkxFX1JFU09MVVRJT05fTUVESUFfUVVFUlkg PSA7CiBFTkFCTEVfU0hBUkVEX1dPUktFUlMgPSBFTkFCTEVfU0hBUkVEX1dPUktFUlM7CiBFTkFC TEVfQ1NTX1NDUk9MTF9TTkFQID0gJChFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQXyQoUExBVEZPUk1f TkFNRSkpOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUF9tYWNvc3ggPSBFTkFCTEVfQ1NTX1NDUk9M TF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyA9IEVOQUJMRV9DU1NfU0NS T0xMX1NOQVA7CitFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQX2lwaG9uZXNpbXVsYXRvciA9ICQoRU5B QkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVvcyk7CiBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUyA9 ICQoRU5BQkxFX1NQRUVDSF9TWU5USEVTSVNfJChQTEFURk9STV9OQU1FKSk7CiBFTkFCTEVfU1BF RUNIX1NZTlRIRVNJUyA9IEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTOwogRU5BQkxFX1NRTF9EQVRB QkFTRSA9IEVOQUJMRV9TUUxfREFUQUJBU0U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMzkyMzIzNWY3MTBhZTZhYjE1OGY5ZGUy ODIzYTZjMmE3ODNkNjBkMi4uNWE2MjAwMzExYTViNDIzMDZmYjJkODg0MGMyMDcxNDkxZDVjYzll MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagpAQCAtNjI0OCw2ICs2MjQ4LDggQEAKIAkJRjQyRkZCNDYxOTg0QjcxNjAwRjY4MzdGIC8q IExlbmd0aFJlcGVhdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRjQyRkZCNDUxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovOyB9Owog CQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4 QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FU VFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAw IC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3Jv bGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKKwkJRjQ5NDBCREYxOTgyRjQ2QTAwMTdEQjYxIC8qIFNj cm9sbFNuYXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEY0OTQwQkREMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdlci5j cHAgKi87IH07CisJCUY0OTQwQkUwMTk4MkY0NkEwMDE3REI2MSAvKiBTY3JvbGxTbmFwTWFuYWdl ci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ5NDBC REUxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMy MjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxl ci5jcHAgKi87IH07CiAJCUY1MDY2NEY4MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxl ci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUwNjY0 RjYxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmggKi87IH07CiAJCUY1MTNBM0VB MTVGRjQ4NDEwMDE1MjZEQiAvKiBWYWxpZGF0aW9uTWVzc2FnZUNsaWVudC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUxM0EzRTkxNUZGNDg0MTAwMTUy NkRCIC8qIFZhbGlkYXRpb25NZXNzYWdlQ2xpZW50LmggKi87IH07CkBAIC0xMzc2Niw2ICsxMzc2 OCw4IEBACiAJCUY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNBMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9s bFNuYXBQb2ludHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3R5 bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50 cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNCMTk1QjhDOEEwMDQ4 MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmg7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9s bFNuYXBQb2ludHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ5NDBCREQxOTgy RjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJRjQ5NDBCREUxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5h Z2VyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFNjcm9sbFNuYXBNYW5hZ2Vy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY1MTU3RjUyREMwMEFDMjI2 RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBGb3JtQ29udHJvbGxlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1 MDY2NEY2MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBGb3JtQ29udHJvbGxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlGNTEzQTNFOTE1RkY0ODQxMDAxNTI2REIgLyogVmFsaWRhdGlvbk1lc3NhZ2VD bGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVmFsaWRhdGlvbk1lc3Nh Z2VDbGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1MTQxLDYgKzE1MTQ1 LDggQEAKIAkJCQk5MzkxQTk5QjE2MjlENzAwMDAyOTczMzAgLyogU2Nyb2xsaW5nVHJlZVNjcm9s bGluZ05vZGUuaCAqLywKIAkJCQkwRjYzODNEQjE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRT Y3JvbGxpbmdUcmVlLmNwcCAqLywKIAkJCQkwRjYzODNEQzE4NjE1QjI5MDAzRTVEQjUgLyogVGhy ZWFkZWRTY3JvbGxpbmdUcmVlLmggKi8sCisJCQkJRjQ5NDBCREQxOTgyRjQ2QTAwMTdEQjYxIC8q IFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCAqLywKKwkJCQlGNDk0MEJERTE5ODJGNDZBMDAxN0RCNjEg LyogU2Nyb2xsU25hcE1hbmFnZXIuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gc2Nyb2xsaW5nOwog CQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTI0MDAxLDYgKzI0MDA3LDcgQEAKIAkJCQlB MUM3OTcxRDE4ODNFNTFGMDAwRjVFMUYgLyogRE9NSFRNTFRleHRBcmVhRWxlbWVudFByaXZhdGUu aCBpbiBIZWFkZXJzICovLAogCQkJCTg1OTkyRUMwMEFBNTA2OTUwMEFDMDc4NSAvKiBET01IVE1M VGl0bGVFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk4NUU3MTFDRjBBQzVENTM1MDA1MzI3 MEYgLyogRE9NSFRNTFRpdGxlRWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywKKwkJCQlG NDk0MEJFMDE5ODJGNDZBMDAxN0RCNjEgLyogU2Nyb2xsU25hcE1hbmFnZXIuaCBpbiBIZWFkZXJz ICovLAogCQkJCTg1QkE0RDE3MEFBNjg4NjgwMDg4MDUyRCAvKiBET01IVE1MVUxpc3RFbGVtZW50 LmggaW4gSGVhZGVycyAqLywKIAkJCQk4NUU3MTFEMDBBQzVENTM1MDA1MzI3MEYgLyogRE9NSFRN TFVMaXN0RWxlbWVudEludGVybmFsLmggaW4gSGVhZGVycyAqLywKIAkJCQlBODE4NUYzQjA5NzY1 NzY2MDA1ODI2RDkgLyogRE9NSW1wbGVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovLApAQCAtMjcz NTYsNiArMjczNjMsNyBAQAogCQkJCUE4ODJEQTIwMTU5Mzg0NkEwMDAxMTVFRCAvKiBDU1NUb1N0 eWxlTWFwLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3MUY1M0VBMEQyNzA0RjkwMEVDRTBENSAv KiBDU1NVbmljb2RlUmFuZ2VWYWx1ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBRDAzQUFGQTE0 Njg0NTUzMDBBMzlCNUIgLyogQ1NTVmFsdWUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ5NDBC REYxOTgyRjQ2QTAwMTdEQjYxIC8qIFNjcm9sbFNuYXBNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTFBQkE3NkNCMTFEMjBFNTcwMDRDMjAxQyAvKiBDU1NWYWx1ZUtleXdvcmRzLmNwcCBp biBTb3VyY2VzICovLAogCQkJCUE4MEU2Q0U0MEExOTg5Q0EwMDdGQjhDNSAvKiBDU1NWYWx1ZUxp c3QuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTQ5QkRBMEIxMzFGRDNFNTAwM0M1NkYwIC8qIENT U1ZhbHVlUG9vbC5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBNYW5hZ2VyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hZDkwZmRjOTg4 MzMyOGY0YmFkYzYzMzI1NjEwYmRiMmQ4M2ZlOWIwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2Nyb2xsU25hcE1hbmFnZXIuY3BwCkBAIC0wLDAgKzEs MjMyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlNjcm9s bFNuYXBNYW5hZ2VyLmgiCisKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjaW5jbHVk ZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiSFRNTENvbGxlY3Rpb24uaCIKKyNpbmNsdWRlICJS ZW5kZXJCb3guaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisjaW5jbHVkZSA8d3RmL3RleHQv U3RyaW5nQnVpbGRlci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1NuYXBQb3NpdGlvbkxp c3Q6OlNuYXBQb3NpdGlvbkxpc3QoKQoreworfQorCitTbmFwUG9zaXRpb25MaXN0OjpTbmFwUG9z aXRpb25MaXN0KFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwUG9zaXRpb25zKQorICAgIDogcG9zaXRp b25zKHNuYXBQb3NpdGlvbnMpCit7Cit9CisKK3NpemVfdCBTbmFwUG9zaXRpb25MaXN0OjpzaXpl KCkgY29uc3QKK3sKKyAgICByZXR1cm4gcG9zaXRpb25zLnNpemUoKTsKK30KKwordm9pZCBTbmFw UG9zaXRpb25MaXN0OjpjbGVhcigpCit7CisgICAgcG9zaXRpb25zLmNsZWFyKCk7Cit9CisKK3Zv aWQgU25hcFBvc2l0aW9uTGlzdDo6cmVzaXplKHNpemVfdCBzaXplKQoreworICAgIHBvc2l0aW9u cy5yZXNpemUoc2l6ZSk7Cit9CisKK3ZvaWQgU25hcFBvc2l0aW9uTGlzdDo6YXBwZW5kKExheW91 dFVuaXQgcG9zaXRpb24pCit7CisgICAgcG9zaXRpb25zLmFwcGVuZChwb3NpdGlvbik7Cit9CisK K0xheW91dFVuaXQgU25hcFBvc2l0aW9uTGlzdDo6Y2xvc2VzdFNuYXBQb3NpdGlvbihMYXlvdXRV bml0IHNjcm9sbERlc3RpbmF0aW9uLCBmbG9hdCB2ZWxvY2l0eSkgY29uc3QKK3sKKyAgICBpZiAo c2Nyb2xsRGVzdGluYXRpb24gPD0gMCkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBpZiAoc2Ny b2xsRGVzdGluYXRpb24gPj0gcG9zaXRpb25zLmF0KHBvc2l0aW9ucy5zaXplKCkgLSAxKSkKKyAg ICAgICAgcmV0dXJuIHBvc2l0aW9ucy5hdChwb3NpdGlvbnMuc2l6ZSgpIC0gMSk7CisKKyAgICBz aXplX3QgbG93ZXJJbmRleCA9IDA7CisgICAgc2l6ZV90IHVwcGVySW5kZXggPSBwb3NpdGlvbnMu c2l6ZSgpIC0gMTsKKyAgICBzaXplX3QgbWlkZGxlSW5kZXg7CisgICAgd2hpbGUgKGxvd2VySW5k ZXggPCB1cHBlckluZGV4IC0gMSkgeworICAgICAgICBtaWRkbGVJbmRleCA9IChsb3dlckluZGV4 ICsgdXBwZXJJbmRleCkgLyAyOworICAgICAgICBpZiAoc2Nyb2xsRGVzdGluYXRpb24gPCBwb3Np dGlvbnMuYXQobWlkZGxlSW5kZXgpKQorICAgICAgICAgICAgdXBwZXJJbmRleCA9IG1pZGRsZUlu ZGV4OworICAgICAgICBlbHNlIGlmIChzY3JvbGxEZXN0aW5hdGlvbiA+IHBvc2l0aW9ucy5hdCht aWRkbGVJbmRleCkpCisgICAgICAgICAgICBsb3dlckluZGV4ID0gbWlkZGxlSW5kZXg7CisgICAg ICAgIGVsc2UgeworICAgICAgICAgICAgdXBwZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAg ICAgICAgbG93ZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIH0KKyAgICB9CisgICAgTGF5b3V0VW5pdCBsb3dlclNuYXBQb3NpdGlvbiA9IHBvc2l0aW9u cy5hdChsb3dlckluZGV4KTsKKyAgICBMYXlvdXRVbml0IHVwcGVyU25hcFBvc2l0aW9uID0gcG9z aXRpb25zLmF0KHVwcGVySW5kZXgpOworICAgIC8vIE5vbnplcm8gdmVsb2NpdHkgaW5kaWNhdGVz IGEgZmxpY2sgZ2VzdHVyZS4gRXZlbiBpZiBhbm90aGVyIHNuYXAgcG9pbnQgaXMgY2xvc2VyLCBz bmFwIHRvIHRoZSBvbmUgaW4gdGhlIGRpcmVjdGlvbiBvZiB0aGUgZmxpY2sgZ2VzdHVyZS4KKyAg ICBpZiAodmVsb2NpdHkpCisgICAgICAgIHJldHVybiB2ZWxvY2l0eSA8IDAgPyBsb3dlclNuYXBQ b3NpdGlvbiA6IHVwcGVyU25hcFBvc2l0aW9uOworICAgIC8vIElmIHZlbG9jaXR5IGlzIHplcm8s IHRoZW4gdGhlIHVzZXIgcmVsZWFzZWQgd2l0aG91dCBmbGlja2luZywgc28gd2Ugc2ltcGx5IHNu YXAgdG8gdGhlIGNsb3NlciBwb2ludC4KKyAgICByZXR1cm4gc2Nyb2xsRGVzdGluYXRpb24gLSBs b3dlclNuYXBQb3NpdGlvbiA8PSB1cHBlclNuYXBQb3NpdGlvbiAtIHNjcm9sbERlc3RpbmF0aW9u ID8gbG93ZXJTbmFwUG9zaXRpb24gOiB1cHBlclNuYXBQb3NpdGlvbjsKK30KKworU2Nyb2xsU25h cE1hbmFnZXI6OlNjcm9sbFNuYXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcyBheGlzKQorICAgIDog bWF4U2Nyb2xsT2Zmc2V0KDApCisgICAgLCBtX2F4aXMoYXhpcykKK3sKK30KKworUGFzc093blB0 cjxTY3JvbGxTbmFwTWFuYWdlcj4gU2Nyb2xsU25hcE1hbmFnZXI6OmNyZWF0ZShTY3JvbGxFdmVu dEF4aXMgYXhpcykKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IFNjcm9sbFNuYXBNYW5hZ2Vy KGF4aXMpKTsKK30KKwordm9pZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRlU25hcERhdGFGcm9t RnJhbWVWaWV3KEZyYW1lVmlldyogZnJhbWVWaWV3KQoreworICAgIGlmIChSZW5kZXJWaWV3KiBy ZW5kZXJWaWV3ID0gZnJhbWVWaWV3LT5yZW5kZXJWaWV3KCkpIHsKKyAgICAgICAgSFRNTEVsZW1l bnQqIGJvZHkgPSByZW5kZXJWaWV3LT5kb2N1bWVudCgpLmJvZHkoKTsKKyAgICAgICAgaWYgKGJv ZHkpIHsKKyAgICAgICAgICAgIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSA9IGJvZHktPnJlbmRl cmVyKCktPnN0eWxlKCk7CisgICAgICAgICAgICBMYXlvdXRVbml0IHNpemUgPSBtX2F4aXMgPT0g U2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gcmVuZGVyVmlldy0+d2lkdGgoKSA6IHJlbmRl clZpZXctPmhlaWdodCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCBzY3JvbGxTaXplID0gbV9h eGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHJlbmRlclZpZXctPnNjcm9sbFdp ZHRoKCkgOiByZW5kZXJWaWV3LT5zY3JvbGxIZWlnaHQoKTsKKyAgICAgICAgICAgIGlmIChzY3Jv bGxTaXplIDw9IDAgfHwgc2l6ZSA8PSAwIHx8IHNpemUgPj0gc2Nyb2xsU2l6ZSkKKyAgICAgICAg ICAgICAgICByZXR1cm47CisKKyAgICAgICAgICAgIG1heFNjcm9sbE9mZnNldCA9IHNjcm9sbFNp emUgLSBzaXplOworICAgICAgICAgICAgaWYgKChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpI b3Jpem9udGFsICYmICFzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpKQorICAgICAgICAg ICAgICAgIHx8IChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpWZXJ0aWNhbCAmJiAhc3R5bGUu c2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSkpCisgICAgICAgICAgICAgICAgdXBkYXRlU25hcERh dGFGcm9tU3R5bGUoc3R5bGUsIHNpemUpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAg ICAgIHVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlQW5kUGFyZW50RWxlbWVudChzdHlsZSwgYm9keSwg c2l6ZSk7CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6OnVw ZGF0ZVNuYXBEYXRhRnJvbVBhcmVudEVsZW1lbnQoSFRNTEVsZW1lbnQqIHBhcmVudCkKK3sKKyAg ICBpZiAoUmVuZGVyQm94KiBwYXJlbnRCb3ggPSBwYXJlbnQtPnJlbmRlckJveCgpKSB7CisgICAg ICAgIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSA9IHBhcmVudEJveC0+c3R5bGUoKTsKKyAgICAg ICAgTGF5b3V0VW5pdCBzaXplID0gbV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRh bCA/IHBhcmVudEJveC0+d2lkdGgoKSA6IHBhcmVudEJveC0+aGVpZ2h0KCk7CisgICAgICAgIExh eW91dFVuaXQgc2Nyb2xsU2l6ZSA9IG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250 YWwgPyBwYXJlbnRCb3gtPnNjcm9sbFdpZHRoKCkgOiBwYXJlbnRCb3gtPnNjcm9sbEhlaWdodCgp OworICAgICAgICBpZiAoc2Nyb2xsU2l6ZSA8PSAwIHx8IHNpemUgPD0gMCB8fCBzaXplID49IHNj cm9sbFNpemUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgbWF4U2Nyb2xsT2Zmc2V0 ID0gc2Nyb2xsU2l6ZSAtIHNpemU7CisgICAgICAgIGlmICgobV9heGlzID09IFNjcm9sbEV2ZW50 QXhpczo6SG9yaXpvbnRhbCAmJiAhc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1goKSkKKyAg ICAgICAgICAgIHx8IChtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpWZXJ0aWNhbCAmJiAhc3R5 bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSkpCisgICAgICAgICAgICB1cGRhdGVTbmFwRGF0 YUZyb21TdHlsZShzdHlsZSwgc2l6ZSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHVwZGF0 ZVNuYXBEYXRhRnJvbVN0eWxlQW5kUGFyZW50RWxlbWVudChzdHlsZSwgcGFyZW50LCBzaXplKTsK KyAgICB9Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1hbmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVN0 eWxlQW5kUGFyZW50RWxlbWVudChjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUsIEhUTUxFbGVtZW50 KiBwYXJlbnQsIExheW91dFVuaXQgc2l6ZSkKK3sKKyAgICAvLyBIYW5kbGUgImVsZW1lbnRzIiBz cGVjaWZpY2F0aW9uIGJ5IHRyYXZlcnNpbmcgY2hpbGRyZW4uCisgICAgc25hcFBvc2l0aW9ucy5j bGVhcigpOworICAgIExheW91dFVuaXQgcGFyZW50T2Zmc2V0ID0gbV9heGlzID09IFNjcm9sbEV2 ZW50QXhpczo6SG9yaXpvbnRhbCA/IHBhcmVudC0+cmVuZGVyQm94KCktPm9mZnNldExlZnQoKSA6 IHBhcmVudC0+cmVuZGVyQm94KCktPm9mZnNldFRvcCgpOworICAgIExheW91dFVuaXQgZGVzdGlu YXRpb25PZmZzZXQgPSBtX2F4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gdmFs dWVGb3JMZW5ndGgoc3R5bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpLCBzaXplKSA6IHZhbHVl Rm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgc2l6ZSk7CisgICAgTGF5 b3V0VW5pdCBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uOworICAgIC8vIEFsd2F5cyBwdXQgYSBz bmFwIHBvaW50IG9uIHRoZSBtaW5pbXVtIHNjcm9sbCBvZmZzZXQuCisgICAgc25hcFBvc2l0aW9u cy5hcHBlbmQoMCk7CisgICAgRWxlbWVudCogY2hpbGQgPSBwYXJlbnQtPmNoaWxkcmVuKCktPmNv bGxlY3Rpb25CZWdpbigpOworICAgIHdoaWxlIChjaGlsZCAmJiBsYXN0UG90ZW50aWFsU25hcFBv c2l0aW9uIDwgbWF4U2Nyb2xsT2Zmc2V0KSB7CisgICAgICAgIGlmIChjaGlsZC0+aXNIVE1MRWxl bWVudCgpICYmIHRvSFRNTEVsZW1lbnQoY2hpbGQpLT5yZW5kZXJCb3goKSkgeworICAgICAgICAg ICAgUmVuZGVyQm94KiBjaGlsZEJveCA9IHRvSFRNTEVsZW1lbnQoY2hpbGQpLT5yZW5kZXJCb3go KTsKKyAgICAgICAgICAgIExheW91dFVuaXQgY2hpbGRTaXplID0gbV9heGlzID09IFNjcm9sbEV2 ZW50QXhpczo6SG9yaXpvbnRhbCA/IGNoaWxkQm94LT53aWR0aCgpIDogY2hpbGRCb3gtPmhlaWdo dCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCBjaGlsZE9mZnNldCA9IChtX2F4aXMgPT0gU2Ny b2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gY2hpbGRCb3gtPm9mZnNldExlZnQoKSA6IGNoaWxk Qm94LT5vZmZzZXRUb3AoKSkgLSBwYXJlbnRPZmZzZXQ7CisgICAgICAgICAgICBmb3IgKFNuYXBD b29yZGluYXRlIGNvb3JkaW5hdGUgOiBjaGlsZEJveC0+c3R5bGUoKS5zY3JvbGxTbmFwQ29vcmRp bmF0ZXMoKSkgeworICAgICAgICAgICAgICAgIExheW91dFVuaXQgY29vcmRpbmF0ZU9mZnNldCA9 IHZhbHVlRm9yTGVuZ3RoKG1fYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwgPyBj b29yZGluYXRlLmZpcnN0IDogY29vcmRpbmF0ZS5zZWNvbmQsIGNoaWxkU2l6ZSk7CisgICAgICAg ICAgICAgICAgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbiA9IGNoaWxkT2Zmc2V0ICsgY29vcmRp bmF0ZU9mZnNldCAtIGRlc3RpbmF0aW9uT2Zmc2V0OworICAgICAgICAgICAgICAgIGlmIChsYXN0 UG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVl OworICAgICAgICAgICAgICAgIGlmIChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uID49IG1heFNj cm9sbE9mZnNldCkKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgICAg ICBzbmFwUG9zaXRpb25zLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0RWxlbWVudFNp YmxpbmcoKTsKKyAgICB9CisgICAgLy8gQWx3YXlzIHB1dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1h eGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICBpZiAoc25hcFBvc2l0aW9ucy5wb3NpdGlvbnNbc25h cFBvc2l0aW9ucy5zaXplKCkgLSAxXSAhPSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAgIHNuYXBQ b3NpdGlvbnMuYXBwZW5kKG1heFNjcm9sbE9mZnNldCk7Cit9CisKK3ZvaWQgU2Nyb2xsU25hcE1h bmFnZXI6OnVwZGF0ZVNuYXBEYXRhRnJvbVN0eWxlKGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSwg TGF5b3V0VW5pdCBzaXplKQoreworICAgIFZlY3RvcjxMZW5ndGg+IHNuYXBPZmZzZXRzID0gbV9h eGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCA/IHN0eWxlLnNjcm9sbFNuYXBPZmZz ZXRzWCgpIDogc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNZKCk7CisgICAgVmVjdG9yPExheW91dFVu aXQ+IHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlOworICAgIGZvciAoTGVuZ3RoIHNuYXBPZmZzZXQg OiBzbmFwT2Zmc2V0cykKKyAgICAgICAgc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UuYXBwZW5kKHZh bHVlRm9yTGVuZ3RoKHNuYXBPZmZzZXQsIHNpemUpKTsKKworICAgIGlmICghc25hcFBvc2l0aW9u U3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICBzbmFwUG9zaXRpb25TdWJzZXF1ZW5jZS5hcHBl bmQoMCk7CisKKyAgICBpZiAobV9heGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCkK KyAgICAgICAgdXBkYXRlU25hcFBvc2l0aW9uc0Zyb21PZmZzZXRzKHNuYXBQb3NpdGlvblN1YnNl cXVlbmNlLCB2YWx1ZUZvckxlbmd0aChzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25YKCksIHNp emUpLCBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WCgpLCB2YWx1ZUZvckxlbmd0aChzdHlsZS5z Y3JvbGxTbmFwUmVwZWF0T2Zmc2V0WCgpLCBzaXplKSk7CisgICAgZWxzZQorICAgICAgICB1cGRh dGVTbmFwUG9zaXRpb25zRnJvbU9mZnNldHMoc25hcFBvc2l0aW9uU3Vic2VxdWVuY2UsIHZhbHVl Rm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgc2l6ZSksIHN0eWxlLnNj cm9sbFNuYXBIYXNSZXBlYXRZKCksIHZhbHVlRm9yTGVuZ3RoKHN0eWxlLnNjcm9sbFNuYXBSZXBl YXRPZmZzZXRZKCksIHNpemUpKTsKK30KKwordm9pZCBTY3JvbGxTbmFwTWFuYWdlcjo6dXBkYXRl U25hcFBvc2l0aW9uc0Zyb21PZmZzZXRzKGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYgc25hcFBv c2l0aW9uU3Vic2VxdWVuY2UsIExheW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQsIGJvb2wgaGFz UmVwZWF0LCBMYXlvdXRVbml0IHJlcGVhdE9mZnNldCkKK3sKKyAgICBzbmFwUG9zaXRpb25zLmNs ZWFyKCk7CisgICAgTGF5b3V0VW5pdCBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IC1kZXN0aW5hdGlv bk9mZnNldDsKKyAgICBMYXlvdXRVbml0IGxhc3RTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRp b25TaGlmdDsKKyAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICAvLyBB bHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0aGUgbWluaW11bSBzY3JvbGwgb2Zmc2V0LgorICAg IHNuYXBQb3NpdGlvbnMuYXBwZW5kKDApOworICAgIGRvIHsKKyAgICAgICAgZm9yIChMYXlvdXRV bml0IHNuYXBQb3NpdGlvbiA6IHNuYXBQb3NpdGlvblN1YnNlcXVlbmNlKSB7CisgICAgICAgICAg ICBwb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRpb25TaGlmdCArIHNuYXBQb3Np dGlvbjsKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPD0gMCkKKyAgICAg ICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRp b24gPj0gbWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAg ICAgICBzbmFwUG9zaXRpb25zLmFwcGVuZChwb3RlbnRpYWxTbmFwUG9zaXRpb24pOworICAgICAg ICAgICAgbGFzdFNuYXBQb3NpdGlvbiA9IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICAgICAg fQorICAgICAgICBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IGxhc3RTbmFwUG9zaXRpb24gKyByZXBl YXRPZmZzZXQ7CisgICAgfSB3aGlsZSAoaGFzUmVwZWF0ICYmIGN1clNuYXBQb3NpdGlvblNoaWZ0 IDwgbWF4U2Nyb2xsT2Zmc2V0KTsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0 aGUgbWF4aW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIGlmIChzbmFwUG9zaXRpb25zLnBvc2l0aW9u c1tzbmFwUG9zaXRpb25zLnNpemUoKSAtIDFdICE9IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAg c25hcFBvc2l0aW9ucy5hcHBlbmQobWF4U2Nyb2xsT2Zmc2V0KTsKK30KKworU2Nyb2xsRXZlbnRB eGlzIFNjcm9sbFNuYXBNYW5hZ2VyOjpheGlzKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9heGlz OworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDU1NfU0NST0xMX1NO QVAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Njcm9sbFNuYXBN YW5hZ2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9TY3JvbGxTbmFwTWFuYWdl ci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmFmNzMwZGY1YjVkMmI5M2VjNjc0NmM1NzE5ZTdjYzM1NWMyZGUwYWQK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9TY3JvbGxT bmFwTWFuYWdlci5oCkBAIC0wLDAgKzEsODEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFT IElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVU T1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT CisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YK KyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFNjcm9s bFNuYXBNYW5hZ2VyX2gKKyNkZWZpbmUgU2Nyb2xsU25hcE1hbmFnZXJfaAorCisjaWYgRU5BQkxF KENTU19TQ1JPTExfU05BUCkKKworI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5jbHVkZSAi TGF5b3V0VW5pdC5oIgorI2luY2x1ZGUgIkxlbmd0aC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxl LmgiCisjaW5jbHVkZSAiU2Nyb2xsVHlwZXMuaCIKKyNpbmNsdWRlICJTdHlsZVNjcm9sbFNuYXBQ b2ludHMuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Jl ZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisjaW5jbHVkZSA8d3RmL3RleHQv Q1N0cmluZy5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK3N0cnVjdCBTbmFwUG9zaXRpb25MaXN0IHsKKyAgICBTbmFwUG9zaXRpb25M aXN0KCk7CisgICAgU25hcFBvc2l0aW9uTGlzdChWZWN0b3I8TGF5b3V0VW5pdD4gc25hcFBvc2l0 aW9ucyk7CisgICAgc2l6ZV90IHNpemUoKSBjb25zdDsKKyAgICB2b2lkIGNsZWFyKCk7CisgICAg dm9pZCByZXNpemUoc2l6ZV90KTsKKyAgICB2b2lkIGFwcGVuZChMYXlvdXRVbml0KTsKKyAgICBM YXlvdXRVbml0IGNsb3Nlc3RTbmFwUG9zaXRpb24oTGF5b3V0VW5pdCwgZmxvYXQgdmVsb2NpdHkg PSAwKSBjb25zdDsKKworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBwb3NpdGlvbnM7Cit9OworCitj bGFzcyBTY3JvbGxTbmFwTWFuYWdlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8 U2Nyb2xsU25hcE1hbmFnZXI+IGNyZWF0ZShTY3JvbGxFdmVudEF4aXMpOworICAgIFNjcm9sbFNu YXBNYW5hZ2VyKFNjcm9sbEV2ZW50QXhpcyk7CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21G cmFtZVZpZXcoRnJhbWVWaWV3Kik7CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZyb21QYXJlbnRF bGVtZW50KEhUTUxFbGVtZW50Kik7CisgICAgU2Nyb2xsRXZlbnRBeGlzIGF4aXMoKSBjb25zdDsK KworICAgIExheW91dFVuaXQgbWF4U2Nyb2xsT2Zmc2V0OworICAgIFNuYXBQb3NpdGlvbkxpc3Qg c25hcFBvc2l0aW9uczsKKyAgICAKK3ByaXZhdGU6CisgICAgdm9pZCB1cGRhdGVTbmFwRGF0YUZy b21TdHlsZUFuZFBhcmVudEVsZW1lbnQoY29uc3QgUmVuZGVyU3R5bGUmLCBIVE1MRWxlbWVudCos IExheW91dFVuaXQpOworICAgIHZvaWQgdXBkYXRlU25hcERhdGFGcm9tU3R5bGUoY29uc3QgUmVu ZGVyU3R5bGUmLCBMYXlvdXRVbml0KTsKKyAgICB2b2lkIHVwZGF0ZVNuYXBQb3NpdGlvbnNGcm9t T2Zmc2V0cyhjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mLCBMYXlvdXRVbml0IGRlc3RpbmF0aW9u T2Zmc2V0ID0gMCwgYm9vbCBoYXNSZXBlYXQgPSBmYWxzZSwgTGF5b3V0VW5pdCByZXBlYXRPZmZz ZXQgPSAwKTsKKworICAgIFNjcm9sbEV2ZW50QXhpcyBtX2F4aXM7Cit9OworCit9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCisjZW5k aWYgLy8gU2Nyb2xsU25hcE1hbmFnZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMv Q29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMueGNjb25maWcgYi9Tb3VyY2UvV2ViS2l0L21h Yy9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwppbmRleCA3MDZjNDk5NTY5 ZTc0NjgzN2U0NzljY2QxMjg3YmIwN2U2ZWJjZTFmLi4wZDAyNmQwZGUyMTQ2YjAxYzY3YzgwMTM1 ODRhMzZjYTA3ZTg2NjRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L21hYy9Db25maWd1cmF0 aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZworKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9Db25m aWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAtMTg1LDYgKzE4NSw4IEBAIEVO QUJMRV9SRVNPTFVUSU9OX01FRElBX1FVRVJZID0gOwogRU5BQkxFX1NIQVJFRF9XT1JLRVJTID0g RU5BQkxFX1NIQVJFRF9XT1JLRVJTOwogRU5BQkxFX0NTU19TQ1JPTExfU05BUCA9ICQoRU5BQkxF X0NTU19TQ1JPTExfU05BUF8kKFBMQVRGT1JNX05BTUUpKTsKIEVOQUJMRV9DU1NfU0NST0xMX1NO QVBfbWFjb3N4ID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VOQUJMRV9DU1NfU0NST0xMX1NO QVBfaXBob25lb3MgPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOworRU5BQkxFX0NTU19TQ1JPTExf U05BUF9pcGhvbmVzaW11bGF0b3IgPSAkKEVOQUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3Mp OwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSAkKEVOQUJMRV9TUEVFQ0hfU1lOVEhFU0lTXyQo UExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSBFTkFCTEVfU1BFRUNI X1NZTlRIRVNJUzsKIEVOQUJMRV9TUUxfREFUQUJBU0UgPSBFTkFCTEVfU1FMX0RBVEFCQVNFOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ29uZmlndXJhdGlvbnMvRmVhdHVyZURlZmluZXMu eGNjb25maWcgYi9Tb3VyY2UvV2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54 Y2NvbmZpZwppbmRleCA3MDZjNDk5NTY5ZTc0NjgzN2U0NzljY2QxMjg3YmIwN2U2ZWJjZTFmLi4w ZDAyNmQwZGUyMTQ2YjAxYzY3YzgwMTM1ODRhMzZjYTA3ZTg2NjRlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZworKysgYi9T b3VyY2UvV2ViS2l0Mi9Db25maWd1cmF0aW9ucy9GZWF0dXJlRGVmaW5lcy54Y2NvbmZpZwpAQCAt MTg1LDYgKzE4NSw4IEBAIEVOQUJMRV9SRVNPTFVUSU9OX01FRElBX1FVRVJZID0gOwogRU5BQkxF X1NIQVJFRF9XT1JLRVJTID0gRU5BQkxFX1NIQVJFRF9XT1JLRVJTOwogRU5BQkxFX0NTU19TQ1JP TExfU05BUCA9ICQoRU5BQkxFX0NTU19TQ1JPTExfU05BUF8kKFBMQVRGT1JNX05BTUUpKTsKIEVO QUJMRV9DU1NfU0NST0xMX1NOQVBfbWFjb3N4ID0gRU5BQkxFX0NTU19TQ1JPTExfU05BUDsKK0VO QUJMRV9DU1NfU0NST0xMX1NOQVBfaXBob25lb3MgPSBFTkFCTEVfQ1NTX1NDUk9MTF9TTkFQOwor RU5BQkxFX0NTU19TQ1JPTExfU05BUF9pcGhvbmVzaW11bGF0b3IgPSAkKEVOQUJMRV9DU1NfU0NS T0xMX1NOQVBfaXBob25lb3MpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVTSVMgPSAkKEVOQUJMRV9T UEVFQ0hfU1lOVEhFU0lTXyQoUExBVEZPUk1fTkFNRSkpOwogRU5BQkxFX1NQRUVDSF9TWU5USEVT SVMgPSBFTkFCTEVfU1BFRUNIX1NZTlRIRVNJUzsKIEVOQUJMRV9TUUxfREFUQUJBU0UgPSBFTkFC TEVfU1FMX0RBVEFCQVNFOwo= 236348 2014-08-10 12:51:59 -0700 2014-08-13 14:04:27 -0700 Patch bug-135268-20140810125148.patch text/plain 27229 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyMzc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYjZhYjY2MWIxYTdkNjFl NWFjNzk4NGFlMWJkMmNjNDc0ODRhNWY0ZC4uOGViODgyODZmMjBmZTUyMzI2ZGQwNzQwOWUzNWMw NTlmMTdhYmM0OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE0LTA4LTEwICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIGRvbS9FbGVtZW50Lmg6IEFkZGVkIG1ldGhvZCB0byBjb2xsZWN0IHNuYXAgb2Zmc2V0 cyBmcm9tIGEgY2hpbGQgZWxlbWVudC4KKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6OmFwcGVu ZFNuYXBPZmZzZXRzVG9WZWN0b3IpOiBCeSBkZWZhdWx0LCB0aGlzIGlzIGEgbm8tb3AgKG92ZXJy aWRkZW4gYmVsb3cpLgorICAgICAgICAqIGh0bWwvSFRNTEVsZW1lbnQuY3BwOiBBZGRlZCBtZXRo b2QgdG8gY29sbGVjdCBzbmFwIG9mZnNldHMuCisgICAgICAgIChXZWJDb3JlOjpIVE1MRWxlbWVu dDo6YXBwZW5kQ2hpbGRTbmFwT2Zmc2V0c1RvVmVjdG9yKTogQ29sbGVjdHMgc25hcCBvZmZzZXRz IGZyb20gY2hpbGRyZW4uCisgICAgICAgIChXZWJDb3JlOjpIVE1MRWxlbWVudDo6YXBwZW5kU25h cE9mZnNldHNUb1ZlY3Rvcik6CisgICAgICAgICogaHRtbC9IVE1MRWxlbWVudC5oOgorICAgICAg ICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6dXBk YXRlU25hcEF4aXMpOiBVcGRhdGVzIHRoZSBGcmFtZVZpZXcncyBzbmFwIG9mZnNldHMgZm9yIGEg Z2l2ZSBheGlzLgorICAgICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9z Y3JvbGxpbmcvU2luZ2xlQXhpc1NuYXBMaXN0LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3Jl OjpTaW5nbGVBeGlzU25hcExpc3Q6OnVwZGF0ZUZyb21PZmZzZXRzKTogVXBkYXRlcyB0aGlzIHNu YXAgYXhpcy4gT3ZlcnJpZGRlbiBmcm9tIFNjcm9sbGFibGVBcmVhLgorICAgICAgICAoV2ViQ29y ZTo6U2luZ2xlQXhpc1NuYXBMaXN0OjpjbG9zZXN0U25hcFBvc2l0aW9uKTogRmluZHMgdGhlIGNs b3Nlc3Qgc25hcCBwb3NpdGlvbiwgYWNjb3VudGluZyBmb3IgdmVsb2NpdHkuCisgICAgICAgICog cGFnZS9zY3JvbGxpbmcvU2luZ2xlQXhpc1NuYXBMaXN0Lmg6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6U2luZ2xlQXhpc1NuYXBMaXN0OjpjcmVhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmNwcDogQWRkZWQgbWV0aG9kIHRvIHVwZGF0ZSBzbmFwIGF4ZXMgZ2l2ZW4g cmVsZXZhbnQgaW5mb3JtYXRpb24uCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJlYTo6 c2luZ2xlQXhpc1NuYXBMaXN0KTogUmV0dXJucyBhIHNuYXAgYXhpcywgY3JlYXRpbmcgb25lIGlm IG5lY2Vzc2FyeS4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1cGRhdGVTbmFw QXhpc0Zyb21FbGVtZW50QW5kU3R5bGUpOiBDb250YWlucyBsb2dpYyB0byB1cGRhdGUgYSBzcGVj aWZpZWQgc25hcCBheGlzLgorICAgICAgICAqIHBsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmg6Cisg ICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJlYTo6dXBkYXRlU25hcEF4aXMpOiBNZXRob2Qg dG8gdXBkYXRlIGEgc3BlY2lmaWVkIHNuYXAgYXhpcy4gTm8tb3AgYnkgZGVmYXVsdCwgb3ZlcnJp ZGRlbiBpbiBSZW5kZXJMYXllciwgRnJhbWVWaWV3LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJMYXllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6dXBkYXRlU25hcEF4 aXMpOiBVcGRhdGVzIHRoaXMgc25hcCBheGlzLiBPdmVycmlkZGVuIGZyb20gU2Nyb2xsYWJsZUFy ZWEuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMDkgIFph bGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBTdWJwaXhlbCByZW5kZXJp bmc6IFRyYW5zZm9ybXMgb24gbm9uLWNvbXBvc2l0aW5nIGxheWVycyBsZWF2ZSBiaXRzIGJlaGlu ZCB3aGVuIHRoZSBib3ggYm91bmRhcmllcyBjaGFuZ2VzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDM5MjMyMzVmNzEwYWU2YWIx NThmOWRlMjgyM2E2YzJhNzgzZDYwZDIuLjJiMDY2ZDgwY2Y1YzA2ZWNjMmU4MWE3ZTJmMjJmYTY3 NjYyZjY3NTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKQEAgLTYyNDYsNiArNjI0Niw4IEBACiAJCUYzRjVDRjExMTJFRDgxQTgwMDg0 QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4NEM1Njkg LyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1Q0YxMzEy RUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEyMTJFRDgx QjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovOyB9Owog CQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggKi87IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAv KiBTaW5nbGVBeGlzU25hcExpc3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIFNpbmdsZUF4aXNTbmFw TGlzdC5jcHAgKi87IH07CisJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBTaW5nbGVBeGlz U25hcExpc3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBTaW5nbGVBeGlzU25hcExpc3QuaCAqLzsgc2V0 dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4 QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyog U3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNw cCAqLzsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1 MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CkBAIC0xMzc2NCw2 ICsxMzc2Niw4IEBACiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25z b2xlSW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElu c3BlY3RvckNvbnNvbGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1 bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckRh dGFiYXNlSW5zdHJ1bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0 MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBTaW5nbGVBeGlzU25hcExpc3QuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU2luZ2xlQXhpc1NuYXBMaXN0 LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZF MkUzIC8qIFNpbmdsZUF4aXNTbmFwTGlzdC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTaW5nbGVBeGlzU25hcExpc3QuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMu Y3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9s bFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9y bUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9y bUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTUxNDEsNiAr MTUxNDUsOCBAQAogCQkJCTkzOTFBOTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVl U2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJl YWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAv KiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUy RTMgLyogU2luZ2xlQXhpc1NuYXBMaXN0LmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNCMDBB NkUyRTMgLyogU2luZ2xlQXhpc1NuYXBMaXN0LmggKi8sCiAJCQkpOwogCQkJcGF0aCA9IHNjcm9s bGluZzsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQyNCw2ICsyNDQzMCw3IEBA CiAJCQkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50LmggaW4g SGVhZGVycyAqLywKIAkJCQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJRWxlbWVu dC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8qIEhUTUxM aW5rRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAwQTZFMkUz IC8qIFNpbmdsZUF4aXNTbmFwTGlzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThFQTdEMkMwQTE5 Mzg1NTAwQThFRjVGIC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVB N0NBQjBBMTkyQjlDMDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4gSGVhZGVycyAq LywKIAkJCQlFNDQ2MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxlbWVudC5oIGlu IEhlYWRlcnMgKi8sCkBAIC0yNzc2MCw2ICsyNzc2Nyw3IEBACiAJCQkJQjJBRkZDN0QwRDAwQTVD MTAwMzAwNzREIC8qIEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJjZXMgKi8sCiAJ CQkJMzcxRjRGNDEwRDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTM3QUNDRjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRpb24uY3BwIGlu IFNvdXJjZXMgKi8sCisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIFNpbmdsZUF4aXNT bmFwTGlzdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAyMkZFMDBBMDdFMjAg LyogRm9udEZhc3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5RkM3MTNDMTdENTcw MDQ2QTdGOCAvKiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUU0 NEVFM0E4MTc1NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVzLmNwcCBpbiBTb3Vy Y2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuaCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKaW5kZXggNjA0ODlkOTI5NWYzYzk3ZjI3NThkZGMxM2E1 MTBkMjkyMzVlYmQyOC4uMTVmNmRlZGNkOTFhNWVjZjg1OTUxMGE0MDBiYzJjNTczNDgzOGNiZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9kb20vRWxlbWVudC5oCkBAIC01NjUsNiArNTY1LDEwIEBAIHB1YmxpYzoKIAogICAgIFVS TCBhYnNvbHV0ZUxpbmtVUkwoKSBjb25zdDsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVAp CisgICAgdmlydHVhbCB2b2lkIGFwcGVuZFNuYXBPZmZzZXRzVG9WZWN0b3IoU2Nyb2xsRXZlbnRB eGlzLCBWZWN0b3I8TGF5b3V0VW5pdD4mKSB7IH0KKyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAg RWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCYgZG9jdW1lbnQs IENvbnN0cnVjdGlvblR5cGUgdHlwZSkKICAgICAgICAgOiBDb250YWluZXJOb2RlKGRvY3VtZW50 LCB0eXBlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRWxlbWVudC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50LmNwcAppbmRleCBmNWU1MmU5YjE3OTc1 Mjk4ZjhlMDQ2N2E4Njg2OTViMDdiYWQyYmYxLi5kMTc2OTFjODU3ZjgxOTY0Zjk2YzVlZWZlMWZj MzQ1YjE1MWEwODhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50LmNwcApAQCAtNTAsNiAr NTAsOSBAQAogI2luY2x1ZGUgIkhUTUxUZW1wbGF0ZUVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1M VGV4dEZvcm1Db250cm9sRWxlbWVudC5oIgogI2luY2x1ZGUgIk5vZGVUcmF2ZXJzYWwuaCIKKyNp ZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIlJlbmRlckJveC5oIgorI2VuZGlm CiAjaW5jbHVkZSAiUmVuZGVyTGluZUJyZWFrLmgiCiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxl ci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCkBAIC0zMzYsNiArMzM5LDI5IEBAIHZvaWQgSFRN TEVsZW1lbnQ6OnBvcHVsYXRlRXZlbnROYW1lRm9yQXR0cmlidXRlTG9jYWxOYW1lTWFwKEhhc2hN YXA8QXRvbWljU3RyaW5nCiAgICAgICAgIG1hcC5hZGQoY3VzdG9tVGFibGVbaV0uYXR0cmlidXRl TmFtZS5sb2NhbE5hbWUoKS5pbXBsKCksIGN1c3RvbVRhYmxlW2ldLmV2ZW50TmFtZSk7CiB9CiAK KyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBIVE1MRWxlbWVudDo6YXBwZW5kQ2hp bGRTbmFwT2Zmc2V0c1RvVmVjdG9yKFNjcm9sbEV2ZW50QXhpcyBheGlzLCBWZWN0b3I8TGF5b3V0 VW5pdD4mIHNuYXBPZmZzZXRzKQoreworICAgIEVsZW1lbnQqIGNoaWxkID0gY2hpbGRyZW4oKS0+ Y29sbGVjdGlvbkJlZ2luKCk7CisgICAgd2hpbGUgKGNoaWxkKSB7CisgICAgICAgIGNoaWxkLT5h cHBlbmRTbmFwT2Zmc2V0c1RvVmVjdG9yKGF4aXMsIHNuYXBPZmZzZXRzKTsKKyAgICAgICAgY2hp bGQgPSBjaGlsZC0+bmV4dEVsZW1lbnRTaWJsaW5nKCk7CisgICAgfQorfQorCit2b2lkIEhUTUxF bGVtZW50OjphcHBlbmRTbmFwT2Zmc2V0c1RvVmVjdG9yKFNjcm9sbEV2ZW50QXhpcyBheGlzLCBW ZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBPZmZzZXRzKQoreworICAgIFJlbmRlckJveCogYm94ID0g cmVuZGVyQm94KCk7CisgICAgTGF5b3V0VW5pdCB2aWV3U2l6ZSA9IGF4aXMgPT0gU2Nyb2xsRXZl bnRBeGlzOjpIb3Jpem9udGFsID8gYm94LT53aWR0aCgpIDogYm94LT5oZWlnaHQoKTsKKyAgICBM YXlvdXRVbml0IHBvc2l0aW9uT2Zmc2V0ID0gYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6 b250YWwgPyBib3gtPngoKSA6IGJveC0+eSgpOworICAgIGZvciAoU25hcENvb3JkaW5hdGUgY29v cmRpbmF0ZSA6IGJveC0+c3R5bGUoKS5zY3JvbGxTbmFwQ29vcmRpbmF0ZXMoKSkgeworICAgICAg ICBMYXlvdXRVbml0IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBwb3NpdGlvbk9mZnNldCAr IHZhbHVlRm9yTGVuZ3RoKGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsID8gY29v cmRpbmF0ZS5maXJzdCA6IGNvb3JkaW5hdGUuc2Vjb25kLCB2aWV3U2l6ZSk7CisgICAgICAgIGlm IChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uID4gMCkKKyAgICAgICAgICAgIHNuYXBPZmZzZXRz LmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICB9Cit9CisjZW5kaWYKKwog dm9pZCBIVE1MRWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUoY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFt ZSwgY29uc3QgQXRvbWljU3RyaW5nJiB2YWx1ZSkKIHsKICAgICBpZiAobmFtZSA9PSBIVE1MTmFt ZXM6OmlkQXR0ciB8fCBuYW1lID09IEhUTUxOYW1lczo6Y2xhc3NBdHRyIHx8IG5hbWUgPT0gSFRN TE5hbWVzOjpzdHlsZUF0dHIpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxF bGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50LmgKaW5kZXggZDJiYjQw NGVhOTc2YmIyOWQ2MGM5ZjJkMjQyNzA4NjI2YTY4NjdjZS4uYmNiZmQ3MDhmNGZkZTVmOThiODZk MTg5NTZiMDQyZjk1MDU3M2E5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuaApAQCAtMTAy LDYgKzEwMiwxMSBAQCBwdWJsaWM6CiAKICAgICBib29sIGhhc1RhZ05hbWUoY29uc3QgSFRNTFF1 YWxpZmllZE5hbWUmIG5hbWUpIGNvbnN0IHsgcmV0dXJuIGhhc0xvY2FsTmFtZShuYW1lLmxvY2Fs TmFtZSgpKTsgfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2b2lkIGFwcGVu ZENoaWxkU25hcE9mZnNldHNUb1ZlY3RvcihTY3JvbGxFdmVudEF4aXMsIFZlY3RvcjxMYXlvdXRV bml0PiYpOworICAgIHZpcnR1YWwgdm9pZCBhcHBlbmRTbmFwT2Zmc2V0c1RvVmVjdG9yKFNjcm9s bEV2ZW50QXhpcywgVmVjdG9yPExheW91dFVuaXQ+Jikgb3ZlcnJpZGU7CisjZW5kaWYKKwogcHJv dGVjdGVkOgogICAgIEhUTUxFbGVtZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUsIERv Y3VtZW50JiwgQ29uc3RydWN0aW9uVHlwZSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApp bmRleCAzODEwNzFkODcwNDUxMDIxNjc1ODkyNDI5ZmRhNDg5YTg0MjU1N2Y5Li4xODQzOWMyODEw ODhlYWNjOWViZDZhZjNjNmE3MjdlM2IzNDMxOThjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwCkBAIC04NDcsNiArODQ3LDE3IEBAIEdyYXBoaWNzTGF5ZXIqIEZyYW1lVmlldzo6c2V0V2Fu dHNMYXllckZvckJvdHRvbU92ZXJIYW5nQXJlYShib29sIHdhbnRzTGF5ZXIpIGNvCiAKICNlbmRp ZiAvLyBFTkFCTEUoUlVCQkVSX0JBTkRJTkcpCiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQordm9pZCBGcmFtZVZpZXc6OnVwZGF0ZVNuYXBBeGlzKFNjcm9sbEV2ZW50QXhpcyBheGlzKQor eworICAgIGlmICghcmVuZGVyVmlldygpIHx8ICFyZW5kZXJWaWV3KCktPmRvY3VtZW50KCkuYm9k eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBFbGVtZW50KiBib2R5ID0gcmVuZGVyVmlldygp LT5kb2N1bWVudCgpLmJvZHkoKTsKKyAgICB1cGRhdGVTbmFwQXhpc0Zyb21FbGVtZW50QW5kU3R5 bGUoYXhpcywgYm9keSwgcmVuZGVyVmlldygpLCBib2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsK K30KKyNlbmRpZgorCiBib29sIEZyYW1lVmlldzo6Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhp c0ZyYW1lKEZyYW1lKiByb290RnJhbWVGb3JGbHVzaCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5k ZXJWaWV3ID0gdGhpcy0+cmVuZGVyVmlldygpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXgg ZGJlOWQ1ZGE4Yzc0MGY5ODE3YTNiNDkzOWZiZmU3OGJlNDA0ZTUzMS4uMWFiMTVjOGRiY2QyYjQ3 Nzc5ODA0NDdkZDAyODVkZmU4ZmNhMTQ0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9GcmFtZVZpZXcuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC0z Myw2ICszMyw5IEBACiAjaW5jbHVkZSAiUGFpbnRQaGFzZS5oIgogI2luY2x1ZGUgIlJlbmRlclB0 ci5oIgogI2luY2x1ZGUgIlNjcm9sbFZpZXcuaCIKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQorI2luY2x1ZGUgIlNpbmdsZUF4aXNTbmFwTGlzdC5oIgorI2VuZGlmCiAjaW5jbHVkZSA8bWVt b3J5PgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+CiAjaW5jbHVkZSA8d3RmL0xpc3RIYXNoU2V0 Lmg+CkBAIC01Nyw2ICs2MCw5IEBAIGNsYXNzIFJlbmRlclNjcm9sbGJhclBhcnQ7CiBjbGFzcyBS ZW5kZXJTdHlsZTsKIGNsYXNzIFJlbmRlclZpZXc7CiBjbGFzcyBSZW5kZXJXaWRnZXQ7CisjaWYg RU5BQkxFKENTU19TQ1JPTExfU05BUCkKK2NsYXNzIFNpbmdsZUF4aXNTbmFwTGlzdDsKKyNlbmRp ZgogCiBQYWdpbmF0aW9uOjpNb2RlIHBhZ2luYXRpb25Nb2RlRm9yUmVuZGVyU3R5bGUoY29uc3Qg UmVuZGVyU3R5bGUmKTsKIApAQCAtNDk2LDYgKzUwMiwxMCBAQCBwdWJsaWM6CiAgICAgdm9pZCBz ZXRFeHBvc2VkUmVjdChGbG9hdFJlY3QpOwogICAgIEZsb2F0UmVjdCBleHBvc2VkUmVjdCgpIGNv bnN0IHsgcmV0dXJuIG1fZXhwb3NlZFJlY3Q7IH0KIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NO QVApCisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBBeGlzKFNjcm9sbEV2ZW50QXhpcykgb3Zl cnJpZGU7CisjZW5kaWYKKwogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgYm9vbCBzY3JvbGxDb250 ZW50c0Zhc3RQYXRoKGNvbnN0IEludFNpemUmIHNjcm9sbERlbHRhLCBjb25zdCBJbnRSZWN0JiBy ZWN0VG9TY3JvbGwsIGNvbnN0IEludFJlY3QmIGNsaXBSZWN0KSBvdmVycmlkZTsKICAgICB2aXJ0 dWFsIHZvaWQgc2Nyb2xsQ29udGVudHNTbG93UGF0aChjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0 KSBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1Np bmdsZUF4aXNTbmFwTGlzdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9TaW5n bGVBeGlzU25hcExpc3QuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjRjMGI1ZDM1Nzc0NzUxNGEwMGFhNTA2ZWU0 ZmE3ZGU1OTBlMDIxNmMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Nj cm9sbGluZy9TaW5nbGVBeGlzU25hcExpc3QuY3BwCkBAIC0wLDAgKzEsOTcgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRT IENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5D LiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgor ICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkK KyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU2luZ2xlQXhpc1NuYXBMaXN0Lmgi CisKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFNpbmdsZUF4aXNTbmFwTGlzdDo6 dXBkYXRlRnJvbU9mZnNldHMoTGF5b3V0VW5pdCB2aWV3U2l6ZSwgTGF5b3V0VW5pdCBzY3JvbGxT aXplLCBjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBPZmZzZXRzLCBMYXlvdXRVbml0IGRl c3RpbmF0aW9uT2Zmc2V0LCBib29sIGhhc1JlcGVhdCwgTGF5b3V0VW5pdCByZXBlYXRPZmZzZXQp Cit7CisgICAgbV9wb3NpdGlvbnMuY2xlYXIoKTsKKyAgICBMYXlvdXRVbml0IGN1clNuYXBQb3Np dGlvblNoaWZ0ID0gMDsKKyAgICBMYXlvdXRVbml0IG1heFNjcm9sbE9mZnNldCA9IHNjcm9sbFNp emUgLSB2aWV3U2l6ZTsKKyAgICBMYXlvdXRVbml0IGxhc3RTbmFwUG9zaXRpb24gPSBjdXJTbmFw UG9zaXRpb25TaGlmdDsKKyAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAg ICBtX3Bvc2l0aW9ucy5hcHBlbmQoMCk7CisgICAgZG8geworICAgICAgICBmb3IgKExheW91dFVu aXQgc25hcFBvc2l0aW9uIDogc25hcE9mZnNldHMpIHsKKyAgICAgICAgICAgIHBvdGVudGlhbFNu YXBQb3NpdGlvbiA9IGN1clNuYXBQb3NpdGlvblNoaWZ0ICsgc25hcFBvc2l0aW9uIC0gZGVzdGlu YXRpb25PZmZzZXQ7CisgICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDAp CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBpZiAocG90ZW50aWFsU25h cFBvc2l0aW9uID49IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAgICAgICAgICBicmVhazsKKwor ICAgICAgICAgICAgbV9wb3NpdGlvbnMuYXBwZW5kKHBvdGVudGlhbFNuYXBQb3NpdGlvbik7Cisg ICAgICAgICAgICBsYXN0U25hcFBvc2l0aW9uID0gcG90ZW50aWFsU25hcFBvc2l0aW9uICsgZGVz dGluYXRpb25PZmZzZXQ7CisgICAgICAgIH0KKyAgICAgICAgY3VyU25hcFBvc2l0aW9uU2hpZnQg PSBsYXN0U25hcFBvc2l0aW9uICsgcmVwZWF0T2Zmc2V0OworICAgIH0gd2hpbGUgKGhhc1JlcGVh dCAmJiBjdXJTbmFwUG9zaXRpb25TaGlmdCA8IG1heFNjcm9sbE9mZnNldCk7CisgICAgLy8gQWx3 YXlzIHB1dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1heGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICAv LyBOb3QgYSBwYXJ0IG9mIHRoZSBzcGVjLCBidXQgbmVjZXNzYXJ5IHRvIHByZXZlbnQgdW5yZWFj aGFibGUgY29udGVudCB3aGVuIHNuYXBwaW5nLgorICAgIGlmIChtX3Bvc2l0aW9ucy5sYXN0KCkg IT0gbWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICBtX3Bvc2l0aW9ucy5hcHBlbmQobWF4U2Nyb2xs T2Zmc2V0KTsKK30KKworTGF5b3V0VW5pdCBTaW5nbGVBeGlzU25hcExpc3Q6OmNsb3Nlc3RTbmFw UG9zaXRpb24oTGF5b3V0VW5pdCBzY3JvbGxEZXN0aW5hdGlvbiwgZmxvYXQgdmVsb2NpdHkpIGNv bnN0Cit7CisgICAgQVNTRVJUKG1fcG9zaXRpb25zLnNpemUoKSA+IDApOworICAgIGlmIChzY3Jv bGxEZXN0aW5hdGlvbiA8PSBtX3Bvc2l0aW9ucy5maXJzdCgpKQorICAgICAgICByZXR1cm4gbV9w b3NpdGlvbnMuZmlyc3QoKTsKKworICAgIGlmIChzY3JvbGxEZXN0aW5hdGlvbiA+PSBtX3Bvc2l0 aW9ucy5sYXN0KCkpCisgICAgICAgIHJldHVybiBtX3Bvc2l0aW9ucy5sYXN0KCk7CisKKyAgICBz aXplX3QgbG93ZXJJbmRleCA9IDA7CisgICAgc2l6ZV90IHVwcGVySW5kZXggPSBtX3Bvc2l0aW9u cy5zaXplKCkgLSAxOworICAgIHdoaWxlIChsb3dlckluZGV4IDwgdXBwZXJJbmRleCAtIDEpIHsK KyAgICAgICAgc2l6ZV90IG1pZGRsZUluZGV4ID0gKGxvd2VySW5kZXggKyB1cHBlckluZGV4KSAv IDI7CisgICAgICAgIGlmIChzY3JvbGxEZXN0aW5hdGlvbiA8IG1fcG9zaXRpb25zLmF0KG1pZGRs ZUluZGV4KSkKKyAgICAgICAgICAgIHVwcGVySW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAg ZWxzZSBpZiAoc2Nyb2xsRGVzdGluYXRpb24gPiBtX3Bvc2l0aW9ucy5hdChtaWRkbGVJbmRleCkp CisgICAgICAgICAgICBsb3dlckluZGV4ID0gbWlkZGxlSW5kZXg7CisgICAgICAgIGVsc2Ugewor ICAgICAgICAgICAgdXBwZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICAgICAgbG93ZXJJ bmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9 CisgICAgTGF5b3V0VW5pdCBsb3dlclNuYXBQb3NpdGlvbiA9IG1fcG9zaXRpb25zLmF0KGxvd2Vy SW5kZXgpOworICAgIExheW91dFVuaXQgdXBwZXJTbmFwUG9zaXRpb24gPSBtX3Bvc2l0aW9ucy5h dCh1cHBlckluZGV4KTsKKyAgICAvLyBOb256ZXJvIHZlbG9jaXR5IGluZGljYXRlcyBhIGZsaWNr IGdlc3R1cmUuIEV2ZW4gaWYgYW5vdGhlciBzbmFwIHBvaW50IGlzIGNsb3Nlciwgc25hcCB0byB0 aGUgb25lIGluIHRoZSBkaXJlY3Rpb24gb2YgdGhlIGZsaWNrIGdlc3R1cmUuCisgICAgaWYgKHZl bG9jaXR5KQorICAgICAgICByZXR1cm4gdmVsb2NpdHkgPCAwID8gbG93ZXJTbmFwUG9zaXRpb24g OiB1cHBlclNuYXBQb3NpdGlvbjsKKworICAgIGJvb2wgaXNDbG9zZXJUb0xvd2VyU25hcFBvc2l0 aW9uID0gc2Nyb2xsRGVzdGluYXRpb24gLSBsb3dlclNuYXBQb3NpdGlvbiA8IHVwcGVyU25hcFBv c2l0aW9uIC0gc2Nyb2xsRGVzdGluYXRpb247CisgICAgcmV0dXJuIGlzQ2xvc2VyVG9Mb3dlclNu YXBQb3NpdGlvbiA/IGxvd2VyU25hcFBvc2l0aW9uIDogdXBwZXJTbmFwUG9zaXRpb247Cit9CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2luZ2xlQXhpc1NuYXBMaXN0 LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9TaW5nbGVBeGlzU25hcExpc3QuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lZTFhZDFjZjExNzhhNzUzNzY5NzZjZTBiMmU1N2U2YjYwODE1OTNmCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvU2luZ2xlQXhpc1Nu YXBMaXN0LmgKQEAgLTAsMCArMSw1NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMn JworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMK KyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAq IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICog VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgU2luZ2xlQXhp c1NuYXBMaXN0X2gKKyNkZWZpbmUgU2luZ2xlQXhpc1NuYXBMaXN0X2gKKworI2lmIEVOQUJMRShD U1NfU0NST0xMX1NOQVApCisKKyNpbmNsdWRlICJMYXlvdXRVbml0LmgiCisjaW5jbHVkZSAiU2Ny b2xsVHlwZXMuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9S ZWZDb3VudGVkLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK2NsYXNzIFNpbmdsZUF4aXNTbmFwTGlzdCB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NPd25QdHI8U2luZ2xlQXhpc1NuYXBMaXN0PiBjcmVhdGUoKQorICAgIHsKKyAgICAgICAgcmV0 dXJuIGFkb3B0UHRyKG5ldyBTaW5nbGVBeGlzU25hcExpc3QoKSk7CisgICAgfQorICAgIHZvaWQg dXBkYXRlRnJvbU9mZnNldHMoTGF5b3V0VW5pdCwgTGF5b3V0VW5pdCwgY29uc3QgVmVjdG9yPExh eW91dFVuaXQ+JiwgTGF5b3V0VW5pdCwgYm9vbCwgTGF5b3V0VW5pdCk7CisgICAgTGF5b3V0VW5p dCBjbG9zZXN0U25hcFBvc2l0aW9uKExheW91dFVuaXQsIGZsb2F0ID0gMCkgY29uc3Q7CisKK3By aXZhdGU6CisgICAgVmVjdG9yPExheW91dFVuaXQ+IG1fcG9zaXRpb25zOworfTsKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCisKKyNlbmRpZiAv LyBTaW5nbGVBeGlzU25hcExpc3RfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vU2Nyb2xsYWJsZUFyZWEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJs ZUFyZWEuY3BwCmluZGV4IGM3ZDk0OTQ1NDcxMWY4M2M2YmQ3YmI1MTBjYjIzMWM4OTEyODAxMDAu LjYyODRjNjQyNmM2ZThkMDQ0MzA4ZjY2ODEwMzAxZDZjM2MzZTRkMDkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKQEAgLTQxLDExICs0MSwyMiBAQAogI2lu Y2x1ZGUgIlNjcm9sbGJhclRoZW1lLmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KIAor I2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1 ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94LmgiCisjaW5jbHVkZSAiUmVu ZGVyU3R5bGUuaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0cnVjdCBTYW1l U2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewogICAgIHZpcnR1YWwgflNhbWVTaXplQXNTY3JvbGxhYmxl QXJlYSgpOwogICAgIHZvaWQqIHBvaW50ZXI7CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkK KyAgICB2b2lkKiBob3Jpem9udGFsU25hcEF4aXNQb2ludGVyOworICAgIHZvaWQqIHZlcnRpY2Fs U25hcEF4aXNQb2ludGVyOworI2VuZGlmCiAgICAgSW50UG9pbnQgb3JpZ2luOwogICAgIHVuc2ln bmVkIGJpdGZpZWxkcyA6IDE2OwogfTsKQEAgLTE3OCw2ICsxODksNTUgQEAgYm9vbCBTY3JvbGxh YmxlQXJlYTo6aGFuZGxlV2hlZWxFdmVudChjb25zdCBQbGF0Zm9ybVdoZWVsRXZlbnQmIHdoZWVs RXZlbnQpCiAgICAgcmV0dXJuIHNjcm9sbEFuaW1hdG9yKCktPmhhbmRsZVdoZWVsRXZlbnQod2hl ZWxFdmVudCk7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorU2luZ2xlQXhpc1Nu YXBMaXN0KiBTY3JvbGxhYmxlQXJlYTo6c2luZ2xlQXhpc1NuYXBMaXN0KFNjcm9sbEV2ZW50QXhp cyBheGlzKQoreworICAgIGlmIChheGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCkg eworICAgICAgICBpZiAoIW1faG9yaXpvbnRhbFNuYXBBeGlzKQorICAgICAgICAgICAgbV9ob3Jp em9udGFsU25hcEF4aXMgPSBTaW5nbGVBeGlzU25hcExpc3Q6OmNyZWF0ZSgpOworCisgICAgICAg IHJldHVybiBtX2hvcml6b250YWxTbmFwQXhpcy5nZXQoKTsKKyAgICB9CisgICAgaWYgKCFtX3Zl cnRpY2FsU25hcEF4aXMpCisgICAgICAgIG1fdmVydGljYWxTbmFwQXhpcyA9IFNpbmdsZUF4aXNT bmFwTGlzdDo6Y3JlYXRlKCk7CisKKyAgICByZXR1cm4gbV92ZXJ0aWNhbFNuYXBBeGlzLmdldCgp OworfQorCit2b2lkIFNjcm9sbGFibGVBcmVhOjp1cGRhdGVTbmFwQXhpc0Zyb21FbGVtZW50QW5k U3R5bGUoU2Nyb2xsRXZlbnRBeGlzIGF4aXMsIEVsZW1lbnQqIHNjcm9sbGluZ0VsZW1lbnQsIFJl bmRlckJveCogYm94LCBjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUpCit7CisgICAgaWYgKHN0eWxl LnNjcm9sbFNuYXBUeXBlKCkgPT0gU2Nyb2xsU25hcFR5cGU6Ok5vbmUpCisgICAgICAgIHJldHVy bjsKKyAgICAKKyAgICBBU1NFUlQoc2Nyb2xsaW5nRWxlbWVudCAmJiBib3gpOworICAgIGJvb2wg aXNIb3Jpem9udGFsQXhpcyA9IGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsOwor ICAgIExheW91dFVuaXQgdmlld1NpemUgPSBpc0hvcml6b250YWxBeGlzID8gYm94LT53aWR0aCgp IDogYm94LT5oZWlnaHQoKTsKKyAgICBMYXlvdXRVbml0IHNjcm9sbFNpemUgPSBpc0hvcml6b250 YWxBeGlzID8gYm94LT5zY3JvbGxXaWR0aCgpIDogYm94LT5zY3JvbGxIZWlnaHQoKTsKKyAgICBp ZiAoc2Nyb2xsU2l6ZSA8PSAwIHx8IHZpZXdTaXplIDw9IDAgfHwgdmlld1NpemUgPj0gc2Nyb2xs U2l6ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgYm9vbCB1c2VzRWxlbWVudHMgPSAoaXNIb3Jp em9udGFsQXhpcyAmJiBzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpKSB8fCAoIWlzSG9y aXpvbnRhbEF4aXMgJiYgc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSk7CisgICAgaWYg KHVzZXNFbGVtZW50cyAmJiAhc2Nyb2xsaW5nRWxlbWVudC0+aXNIVE1MRWxlbWVudCgpKQorICAg ICAgICByZXR1cm47CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gc25hcE9mZnNldHM7CisgICAg aWYgKHVzZXNFbGVtZW50cykKKyAgICAgICAgdG9IVE1MRWxlbWVudChzY3JvbGxpbmdFbGVtZW50 KS0+YXBwZW5kQ2hpbGRTbmFwT2Zmc2V0c1RvVmVjdG9yKGF4aXMsIHNuYXBPZmZzZXRzKTsKKyAg ICBlbHNlIHsKKyAgICAgICAgVmVjdG9yPExlbmd0aD4gc25hcExlbmd0aHMgPSBpc0hvcml6b250 YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNYKCkgOiBzdHlsZS5zY3JvbGxTbmFwT2Zm c2V0c1koKTsKKyAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHNuYXBMZW5ndGhzKQor ICAgICAgICAgICAgc25hcE9mZnNldHMuYXBwZW5kKHZhbHVlRm9yTGVuZ3RoKHNuYXBMZW5ndGgs IHZpZXdTaXplKSk7CisgICAgfQorICAgIGlmICghc25hcE9mZnNldHMuc2l6ZSgpKQorICAgICAg ICBzbmFwT2Zmc2V0cy5hcHBlbmQoMCk7CisKKyAgICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zm c2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBE ZXN0aW5hdGlvblgoKSA6IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgdmlld1NpemUp OworICAgIGJvb2wgaGFzUmVwZWF0ID0gaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNu YXBIYXNSZXBlYXRYKCkgOiBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WSgpOworICAgIExheW91 dFVuaXQgcmVwZWF0T2Zmc2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0 eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRYKCkgOiBzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zm c2V0WSgpLCB2aWV3U2l6ZSk7CisgICAgc2luZ2xlQXhpc1NuYXBMaXN0KGF4aXMpLT51cGRhdGVG cm9tT2Zmc2V0cyh2aWV3U2l6ZSwgc2Nyb2xsU2l6ZSwgc25hcE9mZnNldHMsIGRlc3RpbmF0aW9u T2Zmc2V0LCAhdXNlc0VsZW1lbnRzICYmIGhhc1JlcGVhdCwgcmVwZWF0T2Zmc2V0KTsKK30KKyNl bmRpZgorCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIGJvb2wgU2Nyb2xsYWJsZUFyZWE6Omhh bmRsZVRvdWNoRXZlbnQoY29uc3QgUGxhdGZvcm1Ub3VjaEV2ZW50JiB0b3VjaEV2ZW50KQogewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKaW5kZXggMmZlMjc0OTE0NTI4 ZmE1MDdhMzE4YTQ1ZWE5MTAwNmUxZTI4NGYxYi4uZjUzMDU3OGNmNzUxYTYzZjNhMjU3OGY3NDI4 ZTNjNDE1ZDZjY2EwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5o CkBAIC0yNyw2ICsyNyw5IEBACiAjZGVmaW5lIFNjcm9sbGFibGVBcmVhX2gKIAogI2luY2x1ZGUg IlNjcm9sbGJhci5oIgorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiU2lu Z2xlQXhpc1NuYXBMaXN0LmgiCisjZW5kaWYKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQwLDYgKzQzLDEyIEBAIGNsYXNzIFBsYXRmb3JtV2hlZWxF dmVudDsKIGNsYXNzIFNjcm9sbEFuaW1hdG9yOwogY2xhc3MgR3JhcGhpY3NMYXllcjsKIGNsYXNz IFRpbGVkQmFja2luZzsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorY2xhc3MgRWxlbWVu dDsKK2NsYXNzIFJlbmRlckJveDsKK2NsYXNzIFJlbmRlclN0eWxlOworY2xhc3MgU2luZ2xlQXhp c1NuYXBMaXN0OworI2VuZGlmCiAKIGNsYXNzIFNjcm9sbGFibGVBcmVhIHsKIHB1YmxpYzoKQEAg LTU4LDYgKzY3LDExIEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFuZGxlV2hlZWxFdmVudChjb25z dCBQbGF0Zm9ybVdoZWVsRXZlbnQmKTsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisg ICAgU2luZ2xlQXhpc1NuYXBMaXN0KiBzaW5nbGVBeGlzU25hcExpc3QoU2Nyb2xsRXZlbnRBeGlz KTsKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcEF4aXMoU2Nyb2xsRXZlbnRBeGlzKSB7IH07 CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgdmlydHVhbCBib29sIGlz VG91Y2hTY3JvbGxhYmxlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJv b2wgaGFuZGxlVG91Y2hFdmVudChjb25zdCBQbGF0Zm9ybVRvdWNoRXZlbnQmKTsKQEAgLTI2MSw2 ICsyNzUsMTAgQEAgcHJvdGVjdGVkOgogCiAgICAgYm9vbCBoYXNMYXllckZvclNjcm9sbENvcm5l cigpIGNvbnN0OwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2b2lkIHVwZGF0 ZVNuYXBBeGlzRnJvbUVsZW1lbnRBbmRTdHlsZShTY3JvbGxFdmVudEF4aXMsIEVsZW1lbnQqLCBS ZW5kZXJCb3gqLCBjb25zdCBSZW5kZXJTdHlsZSYpOworI2VuZGlmCisKIHByaXZhdGU6CiAgICAg dmlydHVhbCBJbnRSZWN0IHZpc2libGVDb250ZW50UmVjdEludGVybmFsKFZpc2libGVDb250ZW50 UmVjdEluY2x1ZGVzU2Nyb2xsYmFycywgVmlzaWJsZUNvbnRlbnRSZWN0QmVoYXZpb3IpIGNvbnN0 OwogICAgIHZvaWQgc2Nyb2xsUG9zaXRpb25DaGFuZ2VkKGNvbnN0IEludFBvaW50Jik7CkBAIC0y NzUsNiArMjkzLDExIEBAIHByaXZhdGU6CiAKICAgICBtdXRhYmxlIE93blB0cjxTY3JvbGxBbmlt YXRvcj4gbV9zY3JvbGxBbmltYXRvcjsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisg ICAgbXV0YWJsZSBPd25QdHI8U2luZ2xlQXhpc1NuYXBMaXN0PiBtX2hvcml6b250YWxTbmFwQXhp czsKKyAgICBtdXRhYmxlIE93blB0cjxTaW5nbGVBeGlzU25hcExpc3Q+IG1fdmVydGljYWxTbmFw QXhpczsKKyNlbmRpZgorCiAgICAgLy8gVGhlcmUgYXJlIDggcG9zc2libGUgY29tYmluYXRpb25z IG9mIHdyaXRpbmcgbW9kZSBhbmQgZGlyZWN0aW9uLiBTY3JvbGwgb3JpZ2luIHdpbGwgYmUgbm9u LXplcm8gaW4gdGhlIHggb3IgeSBheGlzCiAgICAgLy8gaWYgdGhlcmUgaXMgYW55IHJldmVyc2Vk IGRpcmVjdGlvbiBvciB3cml0aW5nLW1vZGUuIFRoZSBjb21iaW5hdGlvbnMgYXJlOgogICAgIC8v IHdyaXRpbmctbW9kZSAvIGRpcmVjdGlvbiAgICAgc2Nyb2xsT3JpZ2luLngoKSBzZXQgICAgc2Ny b2xsT3JpZ2luLnkoKSBzZXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJMYXllci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3Bw CmluZGV4IDA0MjRlY2I4NWVkOGU3YjMyYjYwMTAwYTllMGVmYzIxMmM4ZTU0ZWMuLmE1NWQxMDRl NDBiYzdhNGY0MWNjNTI5NWZiNjc3NmU5ZThlYjQzZTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckxheWVyLmNwcApAQCAtMzAyOSw2ICszMDI5LDE3IEBAIFNjcm9sbGFibGVBcmVh KiBSZW5kZXJMYXllcjo6ZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBjb25zdAogICAgIHJldHVy biAwOwogfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3ZvaWQgUmVuZGVyTGF5ZXI6 OnVwZGF0ZVNuYXBBeGlzKFNjcm9sbEV2ZW50QXhpcyBheGlzKQoreworICAgIGlmICghZW5jbG9z aW5nRWxlbWVudCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpKQorICAgICAg ICByZXR1cm47CisKKyAgICBSZW5kZXJCb3gqIGJveCA9IGVuY2xvc2luZ0VsZW1lbnQoKS0+cmVu ZGVyQm94KCk7CisgICAgdXBkYXRlU25hcEF4aXNGcm9tRWxlbWVudEFuZFN0eWxlKGF4aXMsIGVu Y2xvc2luZ0VsZW1lbnQoKSwgYm94LCBib3gtPnN0eWxlKCkpOworfQorI2VuZGlmCisKIGludCBS ZW5kZXJMYXllcjo6dmVydGljYWxTY3JvbGxiYXJXaWR0aChPdmVybGF5U2Nyb2xsYmFyU2l6ZVJl bGV2YW5jeSByZWxldmFuY3kpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3ZCYXIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxheWVyLmgKaW5kZXggMjY2NTU5YWZmYjhjZmEwODhjMGVhYzAzOGZk NmViN2M5ZjhiMWY0Ny4uNDIyZWMxNzRiNmE1NGQ5YjNkNzVhZWFkMDNkNGQzZDQzZDk4YTYyMSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKQEAgLTQ5LDYgKzQ5LDkgQEAK ICNpbmNsdWRlICJSZW5kZXJCb3guaCIKICNpbmNsdWRlICJSZW5kZXJQdHIuaCIKICNpbmNsdWRl ICJTY3JvbGxhYmxlQXJlYS5oIgorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVk ZSAiU2luZ2xlQXhpc1NuYXBMaXN0LmgiCisjZW5kaWYKICNpbmNsdWRlIDxtZW1vcnk+CiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKQEAgLTcwLDYgKzczLDkgQEAgY2xhc3MgUmVuZGVyU2Nyb2xsYmFy UGFydDsKIGNsYXNzIFJlbmRlclN0eWxlOwogY2xhc3MgUmVuZGVyVmlldzsKIGNsYXNzIFNjcm9s bGJhcjsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorY2xhc3MgU2luZ2xlQXhpc1NuYXBM aXN0OworI2VuZGlmCiBjbGFzcyBUcmFuc2Zvcm1hdGlvbk1hdHJpeDsKIAogZW51bSBCb3JkZXJS YWRpdXNDbGlwcGluZ1J1bGUgeyBJbmNsdWRlU2VsZkZvckJvcmRlclJhZGl1cywgRG9Ob3RJbmNs dWRlU2VsZkZvckJvcmRlclJhZGl1cyB9OwpAQCAtNDM5LDYgKzQ0NSw5IEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIFNjcm9sbGJhciogaG9yaXpvbnRhbFNjcm9sbGJhcigpIGNvbnN0IG92ZXJyaWRl IHsgcmV0dXJuIG1faEJhci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Nyb2xsYmFyKiB2ZXJ0aWNh bFNjcm9sbGJhcigpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1fdkJhci5nZXQoKTsgfQogICAg IHZpcnR1YWwgU2Nyb2xsYWJsZUFyZWEqIGVuY2xvc2luZ1Njcm9sbGFibGVBcmVhKCkgY29uc3Qg b3ZlcnJpZGU7CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQg dXBkYXRlU25hcEF4aXMoU2Nyb2xsRXZlbnRBeGlzKSBvdmVycmlkZTsKKyNlbmRpZgogCiAjaWYg UExBVEZPUk0oSU9TKQogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCg== 236405 2014-08-11 14:47:58 -0700 2014-08-13 14:04:34 -0700 Patch bug-135268-20140811144747.patch text/plain 25233 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNDEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDFiZWNlMmJjOTA0ZWQx ZDVkYjUwMDdhMTAwYzQxMjQxOWNhYjAxNy4uMGU3ZmZkMWVhNTA1Y2Y3MjExNDAyMjBkZmJjNDhm ZTBjMDI5ODRkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDE0LTA4LTExICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcEF4aXMpOiBVcGRhdGVzIHRoZSBGcmFtZVZpZXcncyBzbmFwIG9mZnNldHMgZm9y IGEgZ2l2ZSBheGlzLgorICAgICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFn ZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmFwcGVuZENoaWxkU25hcE9mZnNldHNUb1ZlY3Rvcik6 CisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OkF4aXNTY3JvbGxTbmFw T2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0 ZUZyb21PZmZzZXRzKTogVXBkYXRlcyB0aGlzIHNuYXAgYXhpcy4gT3ZlcnJpZGRlbiBmcm9tIFNj cm9sbGFibGVBcmVhLgorICAgICAgICAoV2ViQ29yZTo6QXhpc1Njcm9sbFNuYXBPZmZzZXRzOjpj bG9zZXN0U25hcFBvc2l0aW9uKTogRmluZHMgdGhlIGNsb3Nlc3Qgc25hcCBwb3NpdGlvbiwgYWNj b3VudGluZyBmb3IgdmVsb2NpdHkuCisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9m ZnNldHM6Om1pbmltdW1TbmFwUG9zaXRpb24pOiBSZXR1cm5zIHRoZSBtaW5pbXVtIHNuYXAgcG9z aXRpb24uCisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6Om1heGltdW1T bmFwUG9zaXRpb24pOiBSZXR1cm5zIHRoZSBtYXhpbXVtIHNuYXAgcG9zaXRpb24uCisgICAgICAg IChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6Om9wZXJhdG9yPT0pOiBDb21wYXJlcyB0 aGUgc25hcCBvZmZzZXRzIG9mIHR3byBzbmFwIGF4ZXMuCisgICAgICAgICogcGFnZS9zY3JvbGxp bmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmg6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmNwcDogQWRkZWQgbWV0aG9kIHRvIHVwZGF0ZSBzbmFwIGF4ZXMgZ2l2ZW4g cmVsZXZhbnQgaW5mb3JtYXRpb24uCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJlYTo6 YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyBhIHNuYXAgYXhpcywgY3JlYXRpbmcgb25l IGlmIG5lY2Vzc2FyeS4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1cGRhdGVT bmFwQXhpc0Zyb21FbGVtZW50QW5kU3R5bGUpOiBDb250YWlucyBsb2dpYyB0byB1cGRhdGUgYSBz cGVjaWZpZWQgc25hcCBheGlzLgorICAgICAgICAqIHBsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmg6 CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJlYTo6dXBkYXRlU25hcEF4aXMpOiBNZXRo b2QgdG8gdXBkYXRlIGEgc3BlY2lmaWVkIHNuYXAgYXhpcy4gTm8tb3AgYnkgZGVmYXVsdCwgb3Zl cnJpZGRlbiBpbiBSZW5kZXJMYXllciwgRnJhbWVWaWV3LgorICAgICAgICAqIHJlbmRlcmluZy9S ZW5kZXJMYXllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6dXBkYXRlU25h cEF4aXMpOiBVcGRhdGVzIHRoaXMgc25hcCBheGlzLiBPdmVycmlkZGVuIGZyb20gU2Nyb2xsYWJs ZUFyZWEuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMTEg IEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFBhc3MgaW5oZXJp dGVkIHN0eWxlIG9ubHkgd2hlbiByZXNvbHZpbmcgdHJlZSBzdHlsZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGY1NjE1YjlmNmI1 YjUyMjc0YTZjNjFiOTA4NzM5ZDhkOWM0NzViZTAuLjUxMWI3MTVjYzlkMTkwOWUxYjM2NDgwMWNh Y2Y3M2Y3YzRmYWIyZmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oKQEAgLTYyNDUsNiArNjI0NSw4IEBACiAJCUYzRjVDRjExMTJFRDgx QTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4 NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1 Q0YxMzEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEy MTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICov OyB9OwogCQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2 MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggKi87IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2 RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNT Y3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi87IH07CisJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAv KiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25h cE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5 NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgz MTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVT Y3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8q IEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAg Ki87IH07CkBAIC0xMzc2Miw2ICsxMzc2NCw4IEBACiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2 OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckNvbnNvbGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3Bl Y3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlz U2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK KwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8q IFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3Jv bGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0Ix OTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxl L1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlG NTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9ybUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9ybUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtMTUxMzgsNiArMTUxNDIsOCBAQAogCQkJCTkzOTFBOTlCMTYy OUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVlU2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBG NjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAog CQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAq LywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRz LmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBP ZmZzZXRzLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9IHNjcm9sbGluZzsKIAkJCXNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7CkBAIC0yNDQyMSw2ICsyNDQyNyw3IEBACiAJCQkJQTgxMzY5RTAwOTczNzRG NjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVB NzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8qIEhUTUxMaW5rRWxlbWVudC5oIGluIEhlYWRl cnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zm c2V0cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThFQTdEMkMwQTE5Mzg1NTAwQThFRjVGIC8qIEhU TUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBN0NBQjBBMTkyQjlDMDBBOEVG NUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlFNDQ2MTNBNTBD RDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCkBAIC0y Nzc1Niw2ICsyNzc2Myw3IEBACiAJCQkJQjJBRkZDN0QwRDAwQTVDMTAwMzAwNzREIC8qIEZvbnRD dXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzcxRjRGNDEwRDI1QjlB RjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3QUNDRjY5MERB NDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRpb24uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJ RjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgaW4g U291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAyMkZFMDBBMDdFMjAgLyogRm9udEZhc3RQYXRo LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5RkM3MTNDMTdENTcwMDQ2QTdGOCAvKiBGb250 RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUU0NEVFM0E4MTc1NzdFQkQw MEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVzLmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDM4MTA3MWQ4NzA0NTEwMjE2NzU4OTI0MjlmZGE0ODlh ODQyNTU3ZjkuLjNhYjA0MmJhMjNjYjc2OGFmYmYzNTI4ODdlZjAyNjg4ZmYzNmU3ZWMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTg0Nyw2ICs4NDcsMjAgQEAgR3JhcGhpY3NMYXll ciogRnJhbWVWaWV3OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3ZlckhhbmdBcmVhKGJvb2wgd2Fu dHNMYXllcikgY28KIAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJfQkFORElORykKIAorI2lmIEVO QUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6dXBkYXRlU25hcEF4aXMoU2Ny b2xsRXZlbnRBeGlzIGF4aXMpCit7CisgICAgaWYgKCFmcmFtZSgpLmRvY3VtZW50KCkpCisgICAg ICAgIHJldHVybjsKKyAgICAKKyAgICBFbGVtZW50KiBib2R5ID0gZnJhbWUoKS5kb2N1bWVudCgp LT5ib2R5KCk7CisgICAgaWYgKCFib2R5IHx8ICFib2R5LT5yZW5kZXJlcigpIHx8ICFyZW5kZXJW aWV3KCkpCisgICAgICAgIHJldHVybjsKKworICAgIHVwZGF0ZVNuYXBBeGlzRnJvbUVsZW1lbnRB bmRTdHlsZShheGlzLCBib2R5LCByZW5kZXJWaWV3KCksIGJvZHktPnJlbmRlcmVyKCktPnN0eWxl KCkpOworfQorI2VuZGlmCisKIGJvb2wgRnJhbWVWaWV3OjpmbHVzaENvbXBvc2l0aW5nU3RhdGVG b3JUaGlzRnJhbWUoRnJhbWUqIHJvb3RGcmFtZUZvckZsdXNoKQogewogICAgIFJlbmRlclZpZXcq IHJlbmRlclZpZXcgPSB0aGlzLT5yZW5kZXJWaWV3KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaApp bmRleCBkYmU5ZDVkYThjNzQwZjk4MTdhM2I0OTM5ZmJmZTc4YmU0MDRlNTMxLi4yMzYwYTY4NGUz ZWQ0OWQ3ZGIzYTViZGE2MDZlNjNhN2Y2OGQ3MWI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgK QEAgLTQ5Niw2ICs0OTYsMTAgQEAgcHVibGljOgogICAgIHZvaWQgc2V0RXhwb3NlZFJlY3QoRmxv YXRSZWN0KTsKICAgICBGbG9hdFJlY3QgZXhwb3NlZFJlY3QoKSBjb25zdCB7IHJldHVybiBtX2V4 cG9zZWRSZWN0OyB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZpcnR1YWwg dm9pZCB1cGRhdGVTbmFwQXhpcyhTY3JvbGxFdmVudEF4aXMpIG92ZXJyaWRlOworI2VuZGlmCisK IHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGJvb2wgc2Nyb2xsQ29udGVudHNGYXN0UGF0aChjb25z dCBJbnRTaXplJiBzY3JvbGxEZWx0YSwgY29uc3QgSW50UmVjdCYgcmVjdFRvU2Nyb2xsLCBjb25z dCBJbnRSZWN0JiBjbGlwUmVjdCkgb3ZlcnJpZGU7CiAgICAgdmlydHVhbCB2b2lkIHNjcm9sbENv bnRlbnRzU2xvd1BhdGgoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCkgb3ZlcnJpZGU7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNl dHMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi41ZWJlMjliY2RiMTI1NGM2M2NkY2JlYzYwMGVhZWNhN2ZhNTRm Zjc1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhp c1Njcm9sbFNuYXBPZmZzZXRzLmNwcApAQCAtMCwwICsxLDE1MiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKwor I2luY2x1ZGUgIkVsZW1lbnQuaCIKKyNpbmNsdWRlICJIVE1MQ29sbGVjdGlvbi5oIgorI2luY2x1 ZGUgIlJlbmRlckJveC5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NPd25QdHI8 QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmNyZWF0ZSgpCit7 CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBeGlzU2Nyb2xsU25hcE9mZnNldHMoKSk7Cit9CisK K3ZvaWQgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjphcHBlbmRDaGlsZFNuYXBPZmZzZXRzVG9WZWN0 b3IoSFRNTEVsZW1lbnQqIHBhcmVudCwgU2Nyb2xsRXZlbnRBeGlzIGF4aXMsIFZlY3RvcjxMYXlv dXRVbml0PiYgc25hcE9mZnNldFN1YnNlcXVlbmNlKQoreworICAgIGJvb2wgaXNIb3Jpem9udGFs QXhpcyA9IGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsOworICAgIEVsZW1lbnQq IGNoaWxkID0gcGFyZW50LT5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAgICB3aGls ZSAoY2hpbGQpIHsKKyAgICAgICAgUmVuZGVyQm94KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94KCk7 CisgICAgICAgIExheW91dFVuaXQgdmlld1NpemUgPSBpc0hvcml6b250YWxBeGlzID8gYm94LT53 aWR0aCgpIDogYm94LT5oZWlnaHQoKTsKKyAgICAgICAgTGF5b3V0VW5pdCBwb3NpdGlvbk9mZnNl dCA9IGlzSG9yaXpvbnRhbEF4aXMgPyBib3gtPngoKSA6IGJveC0+eSgpOworICAgICAgICBmb3Ig KFNuYXBDb29yZGluYXRlIGNvb3JkaW5hdGUgOiBib3gtPnN0eWxlKCkuc2Nyb2xsU25hcENvb3Jk aW5hdGVzKCkpIHsKKyAgICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3Np dGlvbiA9IHBvc2l0aW9uT2Zmc2V0ICsgdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/ IGNvb3JkaW5hdGUuZmlyc3QgOiBjb29yZGluYXRlLnNlY29uZCwgdmlld1NpemUpOworICAgICAg ICAgICAgaWYgKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb24gPiAwKQorICAgICAgICAgICAgICAg IHNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvbik7 CisgICAgICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEVsZW1lbnRTaWJsaW5nKCk7 CisgICAgfQorfQorCitBeGlzU2Nyb2xsU25hcE9mZnNldHM6OkF4aXNTY3JvbGxTbmFwT2Zmc2V0 cygpCisgICAgOiBkaXJ0eShmYWxzZSkKK3sKK30KKwordm9pZCBBeGlzU2Nyb2xsU25hcE9mZnNl dHM6OnVwZGF0ZUZyb21PZmZzZXRzKExheW91dFVuaXQgdmlld1NpemUsIExheW91dFVuaXQgc2Ny b2xsU2l6ZSwgY29uc3QgVmVjdG9yPExheW91dFVuaXQ+JiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2Us IExheW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQsIGJvb2wgaGFzUmVwZWF0LCBMYXlvdXRVbml0 IHJlcGVhdE9mZnNldCkKK3sKKyAgICBvZmZzZXRzLmNsZWFyKCk7CisgICAgTGF5b3V0VW5pdCBj dXJTbmFwUG9zaXRpb25TaGlmdCA9IDA7CisgICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQg PSBzY3JvbGxTaXplIC0gdmlld1NpemU7CisgICAgTGF5b3V0VW5pdCBsYXN0U25hcFBvc2l0aW9u ID0gY3VyU25hcFBvc2l0aW9uU2hpZnQ7CisgICAgTGF5b3V0VW5pdCBwb3RlbnRpYWxTbmFwUG9z aXRpb247CisgICAgb2Zmc2V0cy5hcHBlbmQoMCk7CisgICAgZG8geworICAgICAgICBmb3IgKExh eW91dFVuaXQgc25hcFBvc2l0aW9uIDogc25hcE9mZnNldFN1YnNlcXVlbmNlKSB7CisgICAgICAg ICAgICBwb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRpb25TaGlmdCArIHNuYXBQ b3NpdGlvbiAtIGRlc3RpbmF0aW9uT2Zmc2V0OworICAgICAgICAgICAgaWYgKHBvdGVudGlhbFNu YXBQb3NpdGlvbiA8PSAwKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAg ICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uID49IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAg ICAgICAgICBicmVhazsKKworICAgICAgICAgICAgb2Zmc2V0cy5hcHBlbmQocG90ZW50aWFsU25h cFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFwUG9zaXRpb24gPSBwb3RlbnRpYWxTbmFw UG9zaXRpb24gKyBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAgfQorICAgICAgICBjdXJTbmFw UG9zaXRpb25TaGlmdCA9IGxhc3RTbmFwUG9zaXRpb24gKyByZXBlYXRPZmZzZXQ7CisgICAgfSB3 aGlsZSAoaGFzUmVwZWF0ICYmIGN1clNuYXBQb3NpdGlvblNoaWZ0IDwgbWF4U2Nyb2xsT2Zmc2V0 KTsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0aGUgbWF4aW11bSBzY3JvbGwg b2Zmc2V0LgorICAgIC8vIE5vdCBhIHBhcnQgb2YgdGhlIHNwZWMsIGJ1dCBuZWNlc3NhcnkgdG8g cHJldmVudCB1bnJlYWNoYWJsZSBjb250ZW50IHdoZW4gc25hcHBpbmcuCisgICAgaWYgKG9mZnNl dHMubGFzdCgpICE9IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAgb2Zmc2V0cy5hcHBlbmQobWF4 U2Nyb2xsT2Zmc2V0KTsKK30KKworTGF5b3V0VW5pdCBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmNs b3Nlc3RTbmFwUG9zaXRpb24oTGF5b3V0VW5pdCBzY3JvbGxEZXN0aW5hdGlvbiwgZmxvYXQgdmVs b2NpdHkpIGNvbnN0Cit7CisgICAgQVNTRVJUKG9mZnNldHMuc2l6ZSgpID4gMCk7CisgICAgaWYg KHNjcm9sbERlc3RpbmF0aW9uIDw9IG9mZnNldHMuZmlyc3QoKSkKKyAgICAgICAgcmV0dXJuIG9m ZnNldHMuZmlyc3QoKTsKKworICAgIGlmIChzY3JvbGxEZXN0aW5hdGlvbiA+PSBvZmZzZXRzLmxh c3QoKSkKKyAgICAgICAgcmV0dXJuIG9mZnNldHMubGFzdCgpOworCisgICAgc2l6ZV90IGxvd2Vy SW5kZXggPSAwOworICAgIHNpemVfdCB1cHBlckluZGV4ID0gb2Zmc2V0cy5zaXplKCkgLSAxOwor ICAgIHdoaWxlIChsb3dlckluZGV4IDwgdXBwZXJJbmRleCAtIDEpIHsKKyAgICAgICAgc2l6ZV90 IG1pZGRsZUluZGV4ID0gKGxvd2VySW5kZXggKyB1cHBlckluZGV4KSAvIDI7CisgICAgICAgIGlm IChzY3JvbGxEZXN0aW5hdGlvbiA8IG9mZnNldHMuYXQobWlkZGxlSW5kZXgpKQorICAgICAgICAg ICAgdXBwZXJJbmRleCA9IG1pZGRsZUluZGV4OworICAgICAgICBlbHNlIGlmIChzY3JvbGxEZXN0 aW5hdGlvbiA+IG9mZnNldHMuYXQobWlkZGxlSW5kZXgpKQorICAgICAgICAgICAgbG93ZXJJbmRl eCA9IG1pZGRsZUluZGV4OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIHVwcGVySW5kZXgg PSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGxvd2VySW5kZXggPSBtaWRkbGVJbmRleDsKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorICAgIExheW91dFVuaXQgbG93ZXJT bmFwUG9zaXRpb24gPSBvZmZzZXRzLmF0KGxvd2VySW5kZXgpOworICAgIExheW91dFVuaXQgdXBw ZXJTbmFwUG9zaXRpb24gPSBvZmZzZXRzLmF0KHVwcGVySW5kZXgpOworICAgIC8vIE5vbnplcm8g dmVsb2NpdHkgaW5kaWNhdGVzIGEgZmxpY2sgZ2VzdHVyZS4gRXZlbiBpZiBhbm90aGVyIHNuYXAg cG9pbnQgaXMgY2xvc2VyLCBzbmFwIHRvIHRoZSBvbmUgaW4gdGhlIGRpcmVjdGlvbiBvZiB0aGUg ZmxpY2sgZ2VzdHVyZS4KKyAgICBpZiAodmVsb2NpdHkpCisgICAgICAgIHJldHVybiB2ZWxvY2l0 eSA8IDAgPyBsb3dlclNuYXBQb3NpdGlvbiA6IHVwcGVyU25hcFBvc2l0aW9uOworCisgICAgYm9v bCBpc0Nsb3NlclRvTG93ZXJTbmFwUG9zaXRpb24gPSBzY3JvbGxEZXN0aW5hdGlvbiAtIGxvd2Vy U25hcFBvc2l0aW9uIDwgdXBwZXJTbmFwUG9zaXRpb24gLSBzY3JvbGxEZXN0aW5hdGlvbjsKKyAg ICByZXR1cm4gaXNDbG9zZXJUb0xvd2VyU25hcFBvc2l0aW9uID8gbG93ZXJTbmFwUG9zaXRpb24g OiB1cHBlclNuYXBQb3NpdGlvbjsKK30KKworTGF5b3V0VW5pdCBBeGlzU2Nyb2xsU25hcE9mZnNl dHM6Om1pbmltdW1TbmFwUG9zaXRpb24oKSBjb25zdAoreworICAgIEFTU0VSVChvZmZzZXRzLnNp emUoKSA+IDApOworICAgIHJldHVybiBvZmZzZXRzLmZpcnN0KCk7Cit9CisKK0xheW91dFVuaXQg QXhpc1Njcm9sbFNuYXBPZmZzZXRzOjptYXhpbXVtU25hcFBvc2l0aW9uKCkgY29uc3QKK3sKKyAg ICBBU1NFUlQob2Zmc2V0cy5zaXplKCkgPiAwKTsKKyAgICByZXR1cm4gb2Zmc2V0cy5sYXN0KCk7 Cit9CisKK2Jvb2wgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjpvcGVyYXRvcj09KGNvbnN0IEF4aXNT Y3JvbGxTbmFwT2Zmc2V0cyYgc25hcEF4aXMpIGNvbnN0Cit7CisgICAgaWYgKHNuYXBBeGlzLm9m ZnNldHMuc2l6ZSgpICE9IG9mZnNldHMuc2l6ZSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisK KyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHNuYXBBeGlzLm9mZnNldHMuc2l6ZSgpOyBpKysp IHsKKyAgICAgICAgaWYgKHNuYXBBeGlzLm9mZnNldHMuYXQoaSkgIT0gb2Zmc2V0cy5hdChpKSkK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHRydWU7Cit9CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNl dHMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5mNTk2M2M1M2FhZThhMTM5YThiZjE4ZDMyODRmOTdhMzVmOTQ2MDdi Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmgKQEAgLTAsMCArMSw2MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4g UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JT IGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05U UklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYg QXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKKyNkZWZpbmUgQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gK KworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKKyNpbmNsdWRlICJIVE1MRWxlbWVudC5o IgorI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNsdWRlICJTY3JvbGxUeXBlcy5oIgorI2lu Y2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKyNp bmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXhp c1Njcm9sbFNuYXBPZmZzZXRzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgdm9pZCBhcHBlbmRDaGls ZFNuYXBPZmZzZXRzVG9WZWN0b3IoSFRNTEVsZW1lbnQqLCBTY3JvbGxFdmVudEF4aXMsIFZlY3Rv cjxMYXlvdXRVbml0PiYpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEF4aXNTY3JvbGxTbmFwT2Zm c2V0cz4gY3JlYXRlKCk7CisKKyAgICBBeGlzU2Nyb2xsU25hcE9mZnNldHMoKTsKKyAgICB2b2lk IHVwZGF0ZUZyb21PZmZzZXRzKExheW91dFVuaXQsIExheW91dFVuaXQsIGNvbnN0IFZlY3RvcjxM YXlvdXRVbml0PiYsIExheW91dFVuaXQsIGJvb2wsIExheW91dFVuaXQpOworICAgIExheW91dFVu aXQgY2xvc2VzdFNuYXBQb3NpdGlvbihMYXlvdXRVbml0LCBmbG9hdCA9IDApIGNvbnN0OworICAg IExheW91dFVuaXQgbWluaW11bVNuYXBQb3NpdGlvbigpIGNvbnN0OworICAgIExheW91dFVuaXQg bWF4aW11bVNuYXBQb3NpdGlvbigpIGNvbnN0OworICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBB eGlzU2Nyb2xsU25hcE9mZnNldHMmKSBjb25zdDsKKworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBv ZmZzZXRzOworICAgIGJvb2wgZGlydHk7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBDU1NfU0NST0xMX1NOQVAKKworI2VuZGlmIC8vIEF4aXNTY3JvbGxTbmFwT2Zm c2V0c19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJl YS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKaW5kZXgg YzdkOTQ5NDU0NzExZjgzYzZiZDdiYjUxMGNiMjMxYzg5MTI4MDEwMC4uYmJkMGM0NjViOTQ0YjI1 NTBhYTUzNTYxOTc3ZTNkNzI5ZGZhODVjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmNwcApAQCAtNDEsMTEgKzQxLDIyIEBACiAjaW5jbHVkZSAiU2Nyb2xsYmFy VGhlbWUuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogCisjaWYgRU5BQkxFKENTU19T Q1JPTExfU05BUCkKKyNpbmNsdWRlICJFbGVtZW50LmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQu aCIKKyNpbmNsdWRlICJSZW5kZXJCb3guaCIKKyNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgorI2Vu ZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RydWN0IFNhbWVTaXplQXNTY3JvbGxhYmxl QXJlYSB7CiAgICAgdmlydHVhbCB+U2FtZVNpemVBc1Njcm9sbGFibGVBcmVhKCk7CiAgICAgdm9p ZCogcG9pbnRlcjsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZvaWQqIGhvcml6 b250YWxTbmFwQXhpc1BvaW50ZXI7CisgICAgdm9pZCogdmVydGljYWxTbmFwQXhpc1BvaW50ZXI7 CisjZW5kaWYKICAgICBJbnRQb2ludCBvcmlnaW47CiAgICAgdW5zaWduZWQgYml0ZmllbGRzIDog MTY7CiB9OwpAQCAtMTc4LDYgKzE4OSw1NSBAQCBib29sIFNjcm9sbGFibGVBcmVhOjpoYW5kbGVX aGVlbEV2ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYgd2hlZWxFdmVudCkKICAgICByZXR1 cm4gc2Nyb2xsQW5pbWF0b3IoKS0+aGFuZGxlV2hlZWxFdmVudCh3aGVlbEV2ZW50KTsKIH0KIAor I2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCitBeGlzU2Nyb2xsU25hcE9mZnNldHMqIFNjcm9s bGFibGVBcmVhOjpheGlzU2Nyb2xsU25hcE9mZnNldHMoU2Nyb2xsRXZlbnRBeGlzIGF4aXMpCit7 CisgICAgaWYgKGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsKSB7CisgICAgICAg IGlmICghbV9ob3Jpem9udGFsU25hcEF4aXMpCisgICAgICAgICAgICBtX2hvcml6b250YWxTbmFw QXhpcyA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6Y3JlYXRlKCk7CisKKyAgICAgICAgcmV0dXJu IG1faG9yaXpvbnRhbFNuYXBBeGlzLmdldCgpOworICAgIH0KKyAgICBpZiAoIW1fdmVydGljYWxT bmFwQXhpcykKKyAgICAgICAgbV92ZXJ0aWNhbFNuYXBBeGlzID0gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzOjpjcmVhdGUoKTsKKworICAgIHJldHVybiBtX3ZlcnRpY2FsU25hcEF4aXMuZ2V0KCk7Cit9 CisKK3ZvaWQgU2Nyb2xsYWJsZUFyZWE6OnVwZGF0ZVNuYXBBeGlzRnJvbUVsZW1lbnRBbmRTdHls ZShTY3JvbGxFdmVudEF4aXMgYXhpcywgRWxlbWVudCogc2Nyb2xsaW5nRWxlbWVudCwgUmVuZGVy Qm94KiBib3gsIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSkKK3sKKyAgICBpZiAoc3R5bGUuc2Ny b2xsU25hcFR5cGUoKSA9PSBTY3JvbGxTbmFwVHlwZTo6Tm9uZSkKKyAgICAgICAgcmV0dXJuOwor ICAgIAorICAgIEFTU0VSVChzY3JvbGxpbmdFbGVtZW50ICYmIGJveCk7CisgICAgYm9vbCBpc0hv cml6b250YWxBeGlzID0gYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWw7CisgICAg TGF5b3V0VW5pdCB2aWV3U2l6ZSA9IGlzSG9yaXpvbnRhbEF4aXMgPyBib3gtPndpZHRoKCkgOiBi b3gtPmhlaWdodCgpOworICAgIExheW91dFVuaXQgc2Nyb2xsU2l6ZSA9IGlzSG9yaXpvbnRhbEF4 aXMgPyBib3gtPnNjcm9sbFdpZHRoKCkgOiBib3gtPnNjcm9sbEhlaWdodCgpOworICAgIGlmIChz Y3JvbGxTaXplIDw9IDAgfHwgdmlld1NpemUgPD0gMCB8fCB2aWV3U2l6ZSA+PSBzY3JvbGxTaXpl KQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIHVzZXNFbGVtZW50cyA9IChpc0hvcml6b250 YWxBeGlzICYmIHN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkpIHx8ICghaXNIb3Jpem9u dGFsQXhpcyAmJiBzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgpKTsKKyAgICBpZiAodXNl c0VsZW1lbnRzICYmICFzY3JvbGxpbmdFbGVtZW50LT5pc0hUTUxFbGVtZW50KCkpCisgICAgICAg IHJldHVybjsKKworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2U7 CisgICAgaWYgKHVzZXNFbGVtZW50cykKKyAgICAgICAgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjph cHBlbmRDaGlsZFNuYXBPZmZzZXRzVG9WZWN0b3IodG9IVE1MRWxlbWVudChzY3JvbGxpbmdFbGVt ZW50KSwgYXhpcywgc25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAgICBlbHNlIHsKKyAgICAgICAg VmVjdG9yPExlbmd0aD4gc25hcExlbmd0aHMgPSBpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Ny b2xsU25hcE9mZnNldHNYKCkgOiBzdHlsZS5zY3JvbGxTbmFwT2Zmc2V0c1koKTsKKyAgICAgICAg Zm9yIChMZW5ndGggc25hcExlbmd0aCA6IHNuYXBMZW5ndGhzKQorICAgICAgICAgICAgc25hcE9m ZnNldFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3U2l6 ZSkpOworICAgIH0KKyAgICBpZiAoIXNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5zaXplKCkpCisgICAg ICAgIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICBMYXlvdXRVbml0IGRl c3RpbmF0aW9uT2Zmc2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxl LnNjcm9sbFNuYXBEZXN0aW5hdGlvblgoKSA6IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblko KSwgdmlld1NpemUpOworICAgIGJvb2wgaGFzUmVwZWF0ID0gaXNIb3Jpem9udGFsQXhpcyA/IHN0 eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRYKCkgOiBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WSgp OworICAgIExheW91dFVuaXQgcmVwZWF0T2Zmc2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9u dGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRYKCkgOiBzdHlsZS5zY3JvbGxT bmFwUmVwZWF0T2Zmc2V0WSgpLCB2aWV3U2l6ZSk7CisgICAgYXhpc1Njcm9sbFNuYXBPZmZzZXRz KGF4aXMpLT51cGRhdGVGcm9tT2Zmc2V0cyh2aWV3U2l6ZSwgc2Nyb2xsU2l6ZSwgc25hcE9mZnNl dFN1YnNlcXVlbmNlLCBkZXN0aW5hdGlvbk9mZnNldCwgIXVzZXNFbGVtZW50cyAmJiBoYXNSZXBl YXQsIHJlcGVhdE9mZnNldCk7Cit9CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMp CiBib29sIFNjcm9sbGFibGVBcmVhOjpoYW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91 Y2hFdmVudCYgdG91Y2hFdmVudCkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Njcm9sbGFibGVBcmVhLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxl QXJlYS5oCmluZGV4IDJmZTI3NDkxNDUyOGZhNTA3YTMxOGE0NWVhOTEwMDZlMWUyODRmMWIuLjgx YThjZGJmNjkzN2UzNmFjNDA2ZTkwZjBmMDQ4NTA2YjkxNjI1YzAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaApAQCAtMjcsNiArMjcsOSBAQAogI2RlZmluZSBTY3Jv bGxhYmxlQXJlYV9oCiAKICNpbmNsdWRlICJTY3JvbGxiYXIuaCIKKyNpZiBFTkFCTEUoQ1NTX1ND Uk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIgorI2VuZGlmCiAj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00MCw2ICs0 MywxMiBAQCBjbGFzcyBQbGF0Zm9ybVdoZWVsRXZlbnQ7CiBjbGFzcyBTY3JvbGxBbmltYXRvcjsK IGNsYXNzIEdyYXBoaWNzTGF5ZXI7CiBjbGFzcyBUaWxlZEJhY2tpbmc7CisjaWYgRU5BQkxFKENT U19TQ1JPTExfU05BUCkKK2NsYXNzIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czsKK2NsYXNzIEVsZW1l bnQ7CitjbGFzcyBSZW5kZXJCb3g7CitjbGFzcyBSZW5kZXJTdHlsZTsKKyNlbmRpZgogCiBjbGFz cyBTY3JvbGxhYmxlQXJlYSB7CiBwdWJsaWM6CkBAIC01OCw2ICs2NywxMSBAQCBwdWJsaWM6CiAK ICAgICBib29sIGhhbmRsZVdoZWVsRXZlbnQoY29uc3QgUGxhdGZvcm1XaGVlbEV2ZW50Jik7CiAK KyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyog YXhpc1Njcm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2ZW50QXhpcyk7CisgICAgdmlydHVhbCB2b2lk IHVwZGF0ZVNuYXBBeGlzKFNjcm9sbEV2ZW50QXhpcykgeyB9OworI2VuZGlmCisKICNpZiBFTkFC TEUoVE9VQ0hfRVZFTlRTKQogICAgIHZpcnR1YWwgYm9vbCBpc1RvdWNoU2Nyb2xsYWJsZSgpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGhhbmRsZVRvdWNoRXZlbnQo Y29uc3QgUGxhdGZvcm1Ub3VjaEV2ZW50Jik7CkBAIC0yNjEsNiArMjc1LDEwIEBAIHByb3RlY3Rl ZDoKIAogICAgIGJvb2wgaGFzTGF5ZXJGb3JTY3JvbGxDb3JuZXIoKSBjb25zdDsKIAorI2lmIEVO QUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdm9pZCB1cGRhdGVTbmFwQXhpc0Zyb21FbGVtZW50 QW5kU3R5bGUoU2Nyb2xsRXZlbnRBeGlzLCBFbGVtZW50KiwgUmVuZGVyQm94KiwgY29uc3QgUmVu ZGVyU3R5bGUmKTsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIHZpcnR1YWwgSW50UmVjdCB2aXNp YmxlQ29udGVudFJlY3RJbnRlcm5hbChWaXNpYmxlQ29udGVudFJlY3RJbmNsdWRlc1Njcm9sbGJh cnMsIFZpc2libGVDb250ZW50UmVjdEJlaGF2aW9yKSBjb25zdDsKICAgICB2b2lkIHNjcm9sbFBv c2l0aW9uQ2hhbmdlZChjb25zdCBJbnRQb2ludCYpOwpAQCAtMjc1LDYgKzI5MywxMSBAQCBwcml2 YXRlOgogCiAgICAgbXV0YWJsZSBPd25QdHI8U2Nyb2xsQW5pbWF0b3I+IG1fc2Nyb2xsQW5pbWF0 b3I7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIG11dGFibGUgT3duUHRyPEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cz4gbV9ob3Jpem9udGFsU25hcEF4aXM7CisgICAgbXV0YWJsZSBP d25QdHI8QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBtX3ZlcnRpY2FsU25hcEF4aXM7CisjZW5kaWYK KwogICAgIC8vIFRoZXJlIGFyZSA4IHBvc3NpYmxlIGNvbWJpbmF0aW9ucyBvZiB3cml0aW5nIG1v ZGUgYW5kIGRpcmVjdGlvbi4gU2Nyb2xsIG9yaWdpbiB3aWxsIGJlIG5vbi16ZXJvIGluIHRoZSB4 IG9yIHkgYXhpcwogICAgIC8vIGlmIHRoZXJlIGlzIGFueSByZXZlcnNlZCBkaXJlY3Rpb24gb3Ig d3JpdGluZy1tb2RlLiBUaGUgY29tYmluYXRpb25zIGFyZToKICAgICAvLyB3cml0aW5nLW1vZGUg LyBkaXJlY3Rpb24gICAgIHNjcm9sbE9yaWdpbi54KCkgc2V0ICAgIHNjcm9sbE9yaWdpbi55KCkg c2V0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAppbmRleCAwNDI0ZWNi ODVlZDhlN2IzMmI2MDEwMGE5ZTBlZmMyMTJjOGU1NGVjLi5hNTVkMTA0ZTQwYmM3YTRmNDFjYzUy OTVmYjY3NzZlOWU4ZWI0M2U5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyTGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXll ci5jcHAKQEAgLTMwMjksNiArMzAyOSwxNyBAQCBTY3JvbGxhYmxlQXJlYSogUmVuZGVyTGF5ZXI6 OmVuY2xvc2luZ1Njcm9sbGFibGVBcmVhKCkgY29uc3QKICAgICByZXR1cm4gMDsKIH0KIAorI2lm IEVOQUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIFJlbmRlckxheWVyOjp1cGRhdGVTbmFwQXhp cyhTY3JvbGxFdmVudEF4aXMgYXhpcykKK3sKKyAgICBpZiAoIWVuY2xvc2luZ0VsZW1lbnQoKSB8 fCAhZW5jbG9zaW5nRWxlbWVudCgpLT5yZW5kZXJCb3goKSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgUmVuZGVyQm94KiBib3ggPSBlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpOworICAg IHVwZGF0ZVNuYXBBeGlzRnJvbUVsZW1lbnRBbmRTdHlsZShheGlzLCBlbmNsb3NpbmdFbGVtZW50 KCksIGJveCwgYm94LT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBpbnQgUmVuZGVyTGF5ZXI6OnZl cnRpY2FsU2Nyb2xsYmFyV2lkdGgoT3ZlcmxheVNjcm9sbGJhclNpemVSZWxldmFuY3kgcmVsZXZh bmN5KSBjb25zdAogewogICAgIGlmICghbV92QmFyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJMYXllci5oCmluZGV4IDI2NjU1OWFmZmI4Y2ZhMDg4YzBlYWMwMzhmZDZlYjdjOWY4YjFmNDcu LjQ3MWJhYTc5ZDhiYWIwNjg2MDZlMTUyYjA2NjM1MTFiNjYwYzhlZDIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMYXllci5oCkBAIC00MzksNiArNDM5LDkgQEAgcHVibGljOgogICAg IHZpcnR1YWwgU2Nyb2xsYmFyKiBob3Jpem9udGFsU2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUg eyByZXR1cm4gbV9oQmFyLmdldCgpOyB9CiAgICAgdmlydHVhbCBTY3JvbGxiYXIqIHZlcnRpY2Fs U2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4gbV92QmFyLmdldCgpOyB9CiAgICAg dmlydHVhbCBTY3JvbGxhYmxlQXJlYSogZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBjb25zdCBv dmVycmlkZTsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZpcnR1YWwgdm9pZCB1 cGRhdGVTbmFwQXhpcyhTY3JvbGxFdmVudEF4aXMpIG92ZXJyaWRlOworI2VuZGlmCiAKICNpZiBQ TEFURk9STShJT1MpCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykK 236449 2014-08-12 09:18:08 -0700 2014-08-13 14:04:42 -0700 Patch bug-135268-20140812091758.patch text/plain 24127 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNDcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTI0OTM1ZWZmMTg5YzQ1 ZjliNDg1YjJlODYzODI1MmU1ZGE4NDU1ZC4uOGYxNGY1ZDBlN2UwMzVmODUyOTljMWRmNDdkOWY2 MDA4NGQ4ZTg4MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMzIEBACisyMDE0LTA4LTEyICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMpOiBJbnZva2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Ny b2xsU25hcE9mZnNldHMgdG8gdXBkYXRlIHNuYXAgb2Zmc2V0cyBmb3IgbWFpbmZyYW1lLgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xs U25hcE9mZnNldHM6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9m ZnNldHM6OnVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEpOiBVcGRhdGUgdGhlIFNj cm9sbGFibGVBcmVhJ3Mgc25hcCBheGVzLgorICAgICAgICAoV2ViQ29yZTo6QXhpc1Njcm9sbFNu YXBPZmZzZXRzOjphcHBlbmRDaGlsZFNuYXBPZmZzZXRzKTogSGVscGVyIGZ1bmN0aW9uIHRoYXQg YXBwZW5kcyB0aGUgc25hcCBwb3NpdGlvbnMgb2YgcmVsZXZhbnQgY2hpbGQgZWxlbWVudHMuCisg ICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZUZyb21TdHlsZSk6 IEhlbHBlciBmdW5jdGlvbiB0aGF0IHVwZGF0ZXMgYSBzbmFwIG9mZnNldCBsaXN0LgorICAgICAg ICAqIHBhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOiBBZGRlZC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3Jv bGxhYmxlQXJlYTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyB0aGUgU2Nyb2xsYWJs ZUFyZWEncyBzbmFwIG9mZnNldHMgaW4gdGhlIGdpdmVuIGF4aXMuCisgICAgICAgICogcGxhdGZv cm0vU2Nyb2xsYWJsZUFyZWEuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1 cGRhdGVTbmFwT2Zmc2V0cyk6IAorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMpOiBJbnZv a2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Nyb2xsU25hcE9mZnNldHMgdG8gdXBkYXRl IHNuYXAgb2Zmc2V0cyBmb3IgYW4gb3ZlcmZsb3cgYXJlYS4KKyAgICAgICAgKiByZW5kZXJpbmcv UmVuZGVyTGF5ZXIuaDoKKwogMjAxNC0wOC0xMiAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQGFw cGxlLmNvbT4KIAogICAgICAgICBbV2luXSBVbnJldmlld2VkIGJ1aWxkIGZpeCBhZnRlciByMTc0 MjUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agppbmRleCBmNTYxNWI5ZjZiNWI1MjI3NGE2YzYxYjkwODczOWQ4ZDljNDc1YmUwLi41MTFiNzE1 Y2M5ZDE5MDllMWIzNjQ4MDFjYWNmNzNmN2M0ZmFiMmZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNv cmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC02MjQ1LDYgKzYyNDUsOCBA QAogCQlGM0Y1Q0YxMTEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1l bnRhdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RjNGNUNGMTAxMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNvbGVJbnN0cnVtZW50YXRp b24uaCAqLzsgfTsKIAkJRjNGNUNGMTMxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFi YXNlSW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGM0Y1Q0YxMjEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJ bnN0cnVtZW50YXRpb24uaCAqLzsgfTsKIAkJRjQyRkZCNDYxOTg0QjcxNjAwRjY4MzdGIC8qIExl bmd0aFJlcGVhdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRjQyRkZCNDUxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovOyB9OworCQlG NDVDMjMxRDE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFCMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovOyB9OworCQlGNDVDMjMx RTE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMxQzE5OTVCNzNCMDBBNkUy RTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0UxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxl U2Nyb2xsU25hcFBvaW50cy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50 cy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0 N0E1RTNGMTk1QjhFNDgwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ3QTVFM0ExOTVCOEM4 QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi87IH07CiAJCUY1MDY2NEY3 MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyog Rm9ybUNvbnRyb2xsZXIuY3BwICovOyB9OwpAQCAtMTM3NjIsNiArMTM3NjQsOCBAQAogCQlGM0Y1 Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1lbnRhdGlvbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1 bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUYzRjVDRjEyMTJFRDgx QjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlv bi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDJGRkI0NTE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IExl bmd0aFJlcGVhdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGNDVDMjMxQjE5OTVC NzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Ny b2xsU25hcE9mZnNldHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNB MTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgcGF0 aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2lu dHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9p bnRzLmg7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjUwNjY0RjUxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9s bGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZvcm1Db250cm9s bGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1MTM4LDYgKzE1MTQyLDgg QEAKIAkJCQk5MzkxQTk5QjE2MjlENzAwMDAyOTczMzAgLyogU2Nyb2xsaW5nVHJlZVNjcm9sbGlu Z05vZGUuaCAqLywKIAkJCQkwRjYzODNEQjE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3Jv bGxpbmdUcmVlLmNwcCAqLywKIAkJCQkwRjYzODNEQzE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFk ZWRTY3JvbGxpbmdUcmVlLmggKi8sCisJCQkJRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi8sCisJCQkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUz IC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovLAogCQkJKTsKIAkJCXBhdGggPSBzY3JvbGxp bmc7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpAQCAtMjQ0MjEsNiArMjQ0MjcsNyBAQAog CQkJCUE4MTM2OUUwMDk3Mzc0RjYwMEQ3NDQ2MyAvKiBIVE1MTGVnZW5kRWxlbWVudC5oIGluIEhl YWRlcnMgKi8sCiAJCQkJQThFQTc5RjYwQTE5MTZERjAwQThFRjVGIC8qIEhUTUxMSUVsZW1lbnQu aCBpbiBIZWFkZXJzICovLAogCQkJCUE4NzFEQzIwMEExNTIwNTcwMEIxMkE2OCAvKiBIVE1MTGlu a0VsZW1lbnQuaCBpbiBIZWFkZXJzICovLAorCQkJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAv KiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4RUE3RDJDMEEx OTM4NTUwMEE4RUY1RiAvKiBIVE1MTWFwRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThF QTdDQUIwQTE5MkI5QzAwQThFRjVGIC8qIEhUTUxNYXJxdWVlRWxlbWVudC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJRTQ0NjEzQTUwQ0Q2MzMxMDAwRkFEQTc1IC8qIEhUTUxNZWRpYUVsZW1lbnQuaCBp biBIZWFkZXJzICovLApAQCAtMjc3NTYsNiArMjc3NjMsNyBAQAogCQkJCUIyQUZGQzdEMEQwMEE1 QzEwMDMwMDc0RCAvKiBGb250Q3VzdG9tUGxhdGZvcm1EYXRhLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTM3MUY0RjQxMEQyNUI5QUYwMEVDRTBENSAvKiBGb250RGF0YS5jcHAgaW4gU291cmNlcyAq LywKIAkJCQkzN0FDQ0Y2OTBEQTQxNEU3MDA4OUU2MDIgLyogRm9udERlc2NyaXB0aW9uLmNwcCBp biBTb3VyY2VzICovLAorCQkJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xs U25hcE9mZnNldHMuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNzI2MjZFMDIwRUYwMjJGRTAwQTA3 RTIwIC8qIEZvbnRGYXN0UGF0aC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk0QTZFOUZDNzEzQzE3 RDU3MDA0NkE3RjggLyogRm9udEZlYXR1cmVTZXR0aW5ncy5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQlFNDRFRTNBODE3NTc3RUJEMDBFRUU4Q0YgLyogRm9udEdlbmVyaWNGYW1pbGllcy5jcHAgaW4g U291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAppbmRleCAzODEwNzFkODcwNDUx MDIxNjc1ODkyNDI5ZmRhNDg5YTg0MjU1N2Y5Li40NGEwZDNjOWMyYzQzZjZlOWUzYWU2ZjJlYmUw OTZhZDVlNTk0ZjMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC05OCw2ICs5OCwx MCBAQAogI2luY2x1ZGUgIlRleHRBdXRvc2l6ZXIuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKENT U19TQ1JPTExfU05BUCkKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRp ZgorCiAjaWYgUExBVEZPUk0oSU9TKQogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5j bHVkZSAiTGVnYWN5VGlsZUNhY2hlLmgiCkBAIC04NDcsNiArODUxLDIwIEBAIEdyYXBoaWNzTGF5 ZXIqIEZyYW1lVmlldzo6c2V0V2FudHNMYXllckZvckJvdHRvbU92ZXJIYW5nQXJlYShib29sIHdh bnRzTGF5ZXIpIGNvCiAKICNlbmRpZiAvLyBFTkFCTEUoUlVCQkVSX0JBTkRJTkcpCiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBGcmFtZVZpZXc6OnVwZGF0ZVNuYXBPZmZzZXRz KCkKK3sKKyAgICBpZiAoIWZyYW1lKCkuZG9jdW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworICAg IC8vIEZJWE1FOiBTaG91bGQgd2UgYWxsb3cgc3BlY2lmeWluZyBzbmFwIHBvaW50cyB0aHJvdWdo IDxodG1sPiB0YWdzIHRvbz8KKyAgICBIVE1MRWxlbWVudCogYm9keSA9IGZyYW1lKCkuZG9jdW1l bnQoKS0+Ym9keSgpOworICAgIGlmICghYm9keSB8fCAhYm9keS0+cmVuZGVyZXIoKSB8fCAhcmVu ZGVyVmlldygpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgQXhpc1Njcm9sbFNuYXBPZmZz ZXRzOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKCp0aGlzLCAqYm9keSwgKnJl bmRlclZpZXcoKSwgYm9keS0+cmVuZGVyZXIoKS0+c3R5bGUoKSk7Cit9CisjZW5kaWYKKwogYm9v bCBGcmFtZVZpZXc6OmZsdXNoQ29tcG9zaXRpbmdTdGF0ZUZvclRoaXNGcmFtZShGcmFtZSogcm9v dEZyYW1lRm9yRmx1c2gpCiB7CiAgICAgUmVuZGVyVmlldyogcmVuZGVyVmlldyA9IHRoaXMtPnJl bmRlclZpZXcoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCmluZGV4IGRiZTlkNWRhOGM3NDBmOTgx N2EzYjQ5MzlmYmZlNzhiZTQwNGU1MzEuLjk3OGY1NDQ5OGJhOTgzNmFjMjIzMzk0Y2JjYjhlNzcw MzFhZWU2ZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaApAQCAtNDk2LDYgKzQ5NiwxMCBAQCBw dWJsaWM6CiAgICAgdm9pZCBzZXRFeHBvc2VkUmVjdChGbG9hdFJlY3QpOwogICAgIEZsb2F0UmVj dCBleHBvc2VkUmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhwb3NlZFJlY3Q7IH0KIAorI2lmIEVO QUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRz KCkgb3ZlcnJpZGU7CisjZW5kaWYKKwogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgYm9vbCBzY3Jv bGxDb250ZW50c0Zhc3RQYXRoKGNvbnN0IEludFNpemUmIHNjcm9sbERlbHRhLCBjb25zdCBJbnRS ZWN0JiByZWN0VG9TY3JvbGwsIGNvbnN0IEludFJlY3QmIGNsaXBSZWN0KSBvdmVycmlkZTsKICAg ICB2aXJ0dWFsIHZvaWQgc2Nyb2xsQ29udGVudHNTbG93UGF0aChjb25zdCBJbnRSZWN0JiB1cGRh dGVSZWN0KSBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xs aW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9s bGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRmMDM2M2I1ZDRiMDgw ODlhN2U1NjgzNDE2OGZjMjY0NjY1OGEzNWEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwCkBAIC0wLDAgKzEs MTQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkF4aXNT Y3JvbGxTbmFwT2Zmc2V0cy5oIgorCisjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUgIkhU TUxDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKKyNpbmNsdWRlICJSZW5k ZXJCb3guaCIKKyNpbmNsdWRlICJTY3JvbGxhYmxlQXJlYS5oIgorCisjaWYgRU5BQkxFKENTU19T Q1JPTExfU05BUCkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzT3duUHRyPEF4aXNTY3Jv bGxTbmFwT2Zmc2V0cz4gQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjpjcmVhdGUoKQoreworICAgIHJl dHVybiBhZG9wdFB0cihuZXcgQXhpc1Njcm9sbFNuYXBPZmZzZXRzKCkpOworfQorCit2b2lkIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0czo6dXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYShT Y3JvbGxhYmxlQXJlYSYgc2Nyb2xsYWJsZUFyZWEsIEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVt ZW50LCBjb25zdCBSZW5kZXJCb3gmIGJveCwgY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlKQorewor ICAgIGlmIChzdHlsZS5zY3JvbGxTbmFwVHlwZSgpID09IFNjcm9sbFNuYXBUeXBlOjpOb25lKQor ICAgICAgICByZXR1cm47CisgICAgCisgICAgTGF5b3V0VW5pdCB2aWV3V2lkdGggPSBib3gud2lk dGgoKTsKKyAgICBMYXlvdXRVbml0IHZpZXdIZWlnaHQgPSBib3guaGVpZ2h0KCk7CisgICAgTGF5 b3V0VW5pdCBzY3JvbGxXaWR0aCA9IGJveC5zY3JvbGxXaWR0aCgpOworICAgIExheW91dFVuaXQg c2Nyb2xsSGVpZ2h0ID0gYm94LnNjcm9sbEhlaWdodCgpOworICAgIGJvb2wgY29tcHV0ZUhvcml6 b250YWxTbmFwT2Zmc2V0cyA9IHNjcm9sbFdpZHRoID4gMCAmJiB2aWV3V2lkdGggPiAwICYmIHZp ZXdXaWR0aCA8IHNjcm9sbFdpZHRoOworICAgIGJvb2wgY29tcHV0ZVZlcnRpY2FsU25hcE9mZnNl dHMgPSBzY3JvbGxIZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPCBz Y3JvbGxIZWlnaHQ7CisgICAgaWYgKCFjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzICYmICFj b21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAgcmV0dXJuOworCisgICAgVmVjdG9y PExheW91dFVuaXQ+IGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAgVmVjdG9y PExheW91dFVuaXQ+IHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlOworICAgIGlmIChzdHls ZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpIHx8IHN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVu dHNZKCkpCisgICAgICAgIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6YXBwZW5kQ2hpbGRTbmFwT2Zm c2V0cyhzY3JvbGxpbmdFbGVtZW50LCBjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzLCBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBjb21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cywg dmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOworCisgICAgaWYgKGNvbXB1dGVIb3Jpem9u dGFsU25hcE9mZnNldHMpIHsKKyAgICAgICAgaWYgKCFzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1l bnRzWCgpKSB7CisgICAgICAgICAgICBmb3IgKExlbmd0aCBzbmFwTGVuZ3RoIDogc3R5bGUuc2Ny b2xsU25hcE9mZnNldHNYKCkpCisgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRT dWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgoc25hcExlbmd0aCwgdmlld1dpZHRoKSk7 CisgICAgICAgIH0KKyAgICAgICAgaWYgKCFob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNl LnNpemUoKSkKKyAgICAgICAgICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBw ZW5kKDApOworCisgICAgICAgIHNjcm9sbGFibGVBcmVhLmF4aXNTY3JvbGxTbmFwT2Zmc2V0cyhT Y3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpLT51cGRhdGVGcm9tU3R5bGUoc3R5bGUsIFNjcm9s bEV2ZW50QXhpczo6SG9yaXpvbnRhbCwgdmlld1dpZHRoLCBzY3JvbGxXaWR0aCwgaG9yaXpvbnRh bFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisgICAgfQorCisgICAgaWYgKGNvbXB1dGVWZXJ0aWNh bFNuYXBPZmZzZXRzKSB7CisgICAgICAgIGlmICghc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50 c1koKSkgeworICAgICAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHN0eWxlLnNjcm9s bFNuYXBPZmZzZXRzWSgpKQorICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNl cXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3SGVpZ2h0KSk7Cisg ICAgICAgIH0KKyAgICAgICAgaWYgKCF2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5zaXpl KCkpCisgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7 CisKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuYXhpc1Njcm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2 ZW50QXhpczo6VmVydGljYWwpLT51cGRhdGVGcm9tU3R5bGUoc3R5bGUsIFNjcm9sbEV2ZW50QXhp czo6VmVydGljYWwsIHZpZXdIZWlnaHQsIHNjcm9sbEhlaWdodCwgdmVydGljYWxTbmFwT2Zmc2V0 U3Vic2VxdWVuY2UpOworICAgIH0KK30KKwordm9pZCBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmFw cGVuZENoaWxkU25hcE9mZnNldHMoSFRNTEVsZW1lbnQmIHBhcmVudCwgYm9vbCBjb21wdXRlSG9y aXpvbnRhbCwgVmVjdG9yPExheW91dFVuaXQ+JiBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVl bmNlLCBib29sIGNvbXB1dGVWZXJ0aWNhbCwgVmVjdG9yPExheW91dFVuaXQ+JiB2ZXJ0aWNhbFNu YXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBFbGVtZW50KiBjaGlsZCA9IHBhcmVudC5jaGls ZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAgICAvLyBGSVhNRTogSW5zdGVhZCBvZiB0cmF2 ZXJzaW5nIGFsbCBjaGlsZHJlbiwgcmVnaXN0ZXIgY2hpbGRyZW4gd2l0aCBzbmFwIGNvb3JkaW5h dGVzIGJlZm9yZSBhcHBlbmRpbmcgdG8gc25hcE9mZnNldFN1YnNlcXVlbmNlLgorICAgIHdoaWxl IChjaGlsZCkgeworICAgICAgICBpZiAoUmVuZGVyQm94KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94 KCkpIHsKKyAgICAgICAgICAgIExheW91dFVuaXQgdmlld1dpZHRoID0gYm94LT53aWR0aCgpOwor ICAgICAgICAgICAgTGF5b3V0VW5pdCB2aWV3SGVpZ2h0ID0gYm94LT5oZWlnaHQoKTsKKyAgICAg ICAgICAgIExheW91dFVuaXQgcG9zaXRpb25YID0gYm94LT54KCk7CisgICAgICAgICAgICBMYXlv dXRVbml0IHBvc2l0aW9uWSA9IGJveC0+eSgpOworICAgICAgICAgICAgZm9yIChTbmFwQ29vcmRp bmF0ZSBjb29yZGluYXRlIDogYm94LT5zdHlsZSgpLnNjcm9sbFNuYXBDb29yZGluYXRlcygpKSB7 CisgICAgICAgICAgICAgICAgTGF5b3V0VW5pdCBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA9 IHBvc2l0aW9uWCArIHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuZmlyc3QsIHZpZXdXaWR0aCk7 CisgICAgICAgICAgICAgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsICYmIGxhc3RQb3RlbnRpYWxT bmFwUG9zaXRpb25YID4gMCkKKyAgICAgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblgpOworICAgICAg ICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkgPSBwb3NpdGlv blkgKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLnNlY29uZCwgdmlld0hlaWdodCk7CisgICAg ICAgICAgICAgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbCAmJiBsYXN0UG90ZW50aWFsU25hcFBvc2l0 aW9uWSA+IDApCisgICAgICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVl bmNlLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWSk7CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEVsZW1lbnRTaWJsaW5nKCk7Cisg ICAgfQorfQorCit2b2lkIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6dXBkYXRlRnJvbVN0eWxlKGNv bnN0IFJlbmRlclN0eWxlJiBzdHlsZSwgU2Nyb2xsRXZlbnRBeGlzIGF4aXMsIExheW91dFVuaXQg dmlld1NpemUsIExheW91dFVuaXQgc2Nyb2xsU2l6ZSwgY29uc3QgVmVjdG9yPExheW91dFVuaXQ+ JiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UpCit7CisgICAgYm9vbCBpc0hvcml6b250YWxBeGlzID0g YXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWw7CisgICAgYm9vbCBoYXNSZXBlYXQg PSBpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcEhhc1JlcGVhdFgoKSA6IHN0eWxl LnNjcm9sbFNuYXBIYXNSZXBlYXRZKCk7CisgICAgTGF5b3V0VW5pdCByZXBlYXRPZmZzZXQgPSB2 YWx1ZUZvckxlbmd0aChpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcFJlcGVhdE9m ZnNldFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZKCksIHZpZXdTaXplKTsKKyAg ICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9u dGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblgoKSA6IHN0eWxlLnNjcm9sbFNu YXBEZXN0aW5hdGlvblkoKSwgdmlld1NpemUpOworICAgIExheW91dFVuaXQgY3VyU25hcFBvc2l0 aW9uU2hpZnQgPSAwOworICAgIExheW91dFVuaXQgbWF4U2Nyb2xsT2Zmc2V0ID0gc2Nyb2xsU2l6 ZSAtIHZpZXdTaXplOworICAgIExheW91dFVuaXQgbGFzdFNuYXBQb3NpdGlvbiA9IGN1clNuYXBQ b3NpdGlvblNoaWZ0OworICAgIExheW91dFVuaXQgcG90ZW50aWFsU25hcFBvc2l0aW9uOworICAg IG1fb2Zmc2V0cy5jbGVhcigpOworICAgIG1fb2Zmc2V0cy5hcHBlbmQoMCk7CisgICAgZG8gewor ICAgICAgICBmb3IgKExheW91dFVuaXQgc25hcFBvc2l0aW9uIDogc25hcE9mZnNldFN1YnNlcXVl bmNlKSB7CisgICAgICAgICAgICBwb3RlbnRpYWxTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRp b25TaGlmdCArIHNuYXBQb3NpdGlvbiAtIGRlc3RpbmF0aW9uT2Zmc2V0OworICAgICAgICAgICAg aWYgKHBvdGVudGlhbFNuYXBQb3NpdGlvbiA8PSAwKQorICAgICAgICAgICAgICAgIGNvbnRpbnVl OworCisgICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uID49IG1heFNjcm9sbE9m ZnNldCkKKyAgICAgICAgICAgICAgICBicmVhazsKKworICAgICAgICAgICAgbV9vZmZzZXRzLmFw cGVuZChwb3RlbnRpYWxTbmFwUG9zaXRpb24pOworICAgICAgICAgICAgbGFzdFNuYXBQb3NpdGlv biA9IHBvdGVudGlhbFNuYXBQb3NpdGlvbiArIGRlc3RpbmF0aW9uT2Zmc2V0OworICAgICAgICB9 CisgICAgICAgIGN1clNuYXBQb3NpdGlvblNoaWZ0ID0gbGFzdFNuYXBQb3NpdGlvbiArIHJlcGVh dE9mZnNldDsKKyAgICB9IHdoaWxlIChoYXNSZXBlYXQgJiYgY3VyU25hcFBvc2l0aW9uU2hpZnQg PCBtYXhTY3JvbGxPZmZzZXQpOworICAgIC8vIEFsd2F5cyBwdXQgYSBzbmFwIHBvaW50IG9uIHRo ZSBtYXhpbXVtIHNjcm9sbCBvZmZzZXQuCisgICAgLy8gTm90IGEgcGFydCBvZiB0aGUgc3BlYywg YnV0IG5lY2Vzc2FyeSB0byBwcmV2ZW50IHVucmVhY2hhYmxlIGNvbnRlbnQgd2hlbiBzbmFwcGlu Zy4KKyAgICBpZiAobV9vZmZzZXRzLmxhc3QoKSAhPSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAg IG1fb2Zmc2V0cy5hcHBlbmQobWF4U2Nyb2xsT2Zmc2V0KTsKK30KKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjUwMDYxMDRlNTNlNmYzZTQ1Njg3Njg5ZWEzNDZhZjA0ZDZiMDQ5N2QKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMu aApAQCAtMCwwICsxLDY1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICog YXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBeGlzU2Nyb2xsU25hcE9m ZnNldHNfaAorI2RlZmluZSBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAorCisjaWYgRU5BQkxFKENT U19TQ1JPTExfU05BUCkKKworI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNsdWRlICJTY3Jv bGxUeXBlcy5oIgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitjbGFzcyBIVE1MRWxlbWVudDsKK2NsYXNzIFJlbmRlckJveDsKK2NsYXNzIFJlbmRlclN0 eWxlOworY2xhc3MgU2Nyb2xsYWJsZUFyZWE7CisKK3N0cnVjdCBTbmFwT2Zmc2V0c1VwZGF0ZVBh cmFtZXRlcnMgeworICAgIExheW91dFVuaXQgdmlld1NpemU7CisgICAgTGF5b3V0VW5pdCBzY3Jv bGxTaXplOworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisK K307CisKK2NsYXNzIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB7CitwdWJsaWM6CisgICAgc3RhdGlj IFBhc3NPd25QdHI8QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBjcmVhdGUoKTsKKyAgICBzdGF0aWMg dm9pZCB1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKFNjcm9sbGFibGVBcmVhJiwg SFRNTEVsZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNvbnN0IFJlbmRlckJveCYsIGNvbnN0IFJl bmRlclN0eWxlJik7CisKK3ByaXZhdGU6CisgICAgc3RhdGljIHZvaWQgYXBwZW5kQ2hpbGRTbmFw T2Zmc2V0cyhIVE1MRWxlbWVudCYgcGFyZW50LCBib29sIGNvbXB1dGVIb3Jpem9udGFsLCBWZWN0 b3I8TGF5b3V0VW5pdD4mIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UsIGJvb2wgY29t cHV0ZVZlcnRpY2FsLCBWZWN0b3I8TGF5b3V0VW5pdD4mIHZlcnRpY2FsU25hcE9mZnNldFN1YnNl cXVlbmNlKTsKKyAgICB2b2lkIHVwZGF0ZUZyb21TdHlsZShjb25zdCBSZW5kZXJTdHlsZSYsIFNj cm9sbEV2ZW50QXhpcywgTGF5b3V0VW5pdCB2aWV3U2l6ZSwgTGF5b3V0VW5pdCBzY3JvbGxTaXpl LCBjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisKKyAg ICBWZWN0b3I8TGF5b3V0VW5pdD4gbV9vZmZzZXRzOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCisKKyNlbmRpZiAvLyBBeGlzU2Nyb2xs U25hcE9mZnNldHNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3Bw CmluZGV4IGM3ZDk0OTQ1NDcxMWY4M2M2YmQ3YmI1MTBjYjIzMWM4OTEyODAxMDAuLjJmNTIzYWNh YTFhMzkxZjQzOWY5ZWIzNjY1Mzc2MDYxZGNkZjYwNDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKQEAgLTMyLDYgKzMyLDkgQEAKICNpbmNsdWRlICJjb25m aWcuaCIKICNpbmNsdWRlICJTY3JvbGxhYmxlQXJlYS5oIgogCisjaWYgRU5BQkxFKENTU19TQ1JP TExfU05BUCkKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRpZgogI2lu Y2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIKICNp bmNsdWRlICJGbG9hdFBvaW50LmgiCkBAIC00Niw2ICs0OSwxMCBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiBzdHJ1Y3QgU2FtZVNpemVBc1Njcm9sbGFibGVBcmVhIHsKICAgICB2aXJ0dWFsIH5TYW1l U2l6ZUFzU2Nyb2xsYWJsZUFyZWEoKTsKICAgICB2b2lkKiBwb2ludGVyOworI2lmIEVOQUJMRShD U1NfU0NST0xMX1NOQVApCisgICAgdm9pZCogaG9yaXpvbnRhbFNuYXBPZmZzZXRzUG9pbnRlcjsK KyAgICB2b2lkKiB2ZXJ0aWNhbFNuYXBPZmZzZXRzUG9pbnRlcjsKKyNlbmRpZgogICAgIEludFBv aW50IG9yaWdpbjsKICAgICB1bnNpZ25lZCBiaXRmaWVsZHMgOiAxNjsKIH07CkBAIC0xNzgsNiAr MTg1LDIyIEBAIGJvb2wgU2Nyb2xsYWJsZUFyZWE6OmhhbmRsZVdoZWVsRXZlbnQoY29uc3QgUGxh dGZvcm1XaGVlbEV2ZW50JiB3aGVlbEV2ZW50KQogICAgIHJldHVybiBzY3JvbGxBbmltYXRvcigp LT5oYW5kbGVXaGVlbEV2ZW50KHdoZWVsRXZlbnQpOwogfQogCisjaWYgRU5BQkxFKENTU19TQ1JP TExfU05BUCkKK0F4aXNTY3JvbGxTbmFwT2Zmc2V0cyogU2Nyb2xsYWJsZUFyZWE6OmF4aXNTY3Jv bGxTbmFwT2Zmc2V0cyhTY3JvbGxFdmVudEF4aXMgYXhpcykKK3sKKyAgICBpZiAoYXhpcyA9PSBT Y3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpIHsKKyAgICAgICAgaWYgKCFtX2hvcml6b250YWxT bmFwT2Zmc2V0cykKKyAgICAgICAgICAgIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gQXhpc1Nj cm9sbFNuYXBPZmZzZXRzOjpjcmVhdGUoKTsKKworICAgICAgICByZXR1cm4gbV9ob3Jpem9udGFs U25hcE9mZnNldHMuZ2V0KCk7CisgICAgfQorICAgIGlmICghbV92ZXJ0aWNhbFNuYXBPZmZzZXRz KQorICAgICAgICBtX3ZlcnRpY2FsU25hcE9mZnNldHMgPSBBeGlzU2Nyb2xsU25hcE9mZnNldHM6 OmNyZWF0ZSgpOworCisgICAgcmV0dXJuIG1fdmVydGljYWxTbmFwT2Zmc2V0cy5nZXQoKTsKK30K KyNlbmRpZgorCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIGJvb2wgU2Nyb2xsYWJsZUFyZWE6 OmhhbmRsZVRvdWNoRXZlbnQoY29uc3QgUGxhdGZvcm1Ub3VjaEV2ZW50JiB0b3VjaEV2ZW50KQog ewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKaW5kZXggMmZlMjc0OTE0 NTI4ZmE1MDdhMzE4YTQ1ZWE5MTAwNmUxZTI4NGYxYi4uMTYzOTIzNjNlOGUyNThkMjA3MmVkNmI0 OTY2NmI1NWRhOGM5OTdiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Ny b2xsYWJsZUFyZWEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJl YS5oCkBAIC0zMSw2ICszMSw5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCitjbGFzcyBBeGlzU2Nyb2xsU25hcE9mZnNldHM7CisjZW5kaWYK IGNsYXNzIEZsb2F0UG9pbnQ7CiBjbGFzcyBHcmFwaGljc0NvbnRleHQ7CiBjbGFzcyBMYXlvdXRQ b2ludDsKQEAgLTU4LDYgKzYxLDExIEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFuZGxlV2hlZWxF dmVudChjb25zdCBQbGF0Zm9ybVdoZWVsRXZlbnQmKTsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xM X1NOQVApCisgICAgQXhpc1Njcm9sbFNuYXBPZmZzZXRzKiBheGlzU2Nyb2xsU25hcE9mZnNldHMo U2Nyb2xsRXZlbnRBeGlzKTsKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSB7 IH07CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgdmlydHVhbCBib29s IGlzVG91Y2hTY3JvbGxhYmxlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFs IGJvb2wgaGFuZGxlVG91Y2hFdmVudChjb25zdCBQbGF0Zm9ybVRvdWNoRXZlbnQmKTsKQEAgLTI3 NSw2ICsyODMsMTEgQEAgcHJpdmF0ZToKIAogICAgIG11dGFibGUgT3duUHRyPFNjcm9sbEFuaW1h dG9yPiBtX3Njcm9sbEFuaW1hdG9yOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAg ICBPd25QdHI8QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBtX2hvcml6b250YWxTbmFwT2Zmc2V0czsK KyAgICBPd25QdHI8QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBtX3ZlcnRpY2FsU25hcE9mZnNldHM7 CisjZW5kaWYKKwogICAgIC8vIFRoZXJlIGFyZSA4IHBvc3NpYmxlIGNvbWJpbmF0aW9ucyBvZiB3 cml0aW5nIG1vZGUgYW5kIGRpcmVjdGlvbi4gU2Nyb2xsIG9yaWdpbiB3aWxsIGJlIG5vbi16ZXJv IGluIHRoZSB4IG9yIHkgYXhpcwogICAgIC8vIGlmIHRoZXJlIGlzIGFueSByZXZlcnNlZCBkaXJl Y3Rpb24gb3Igd3JpdGluZy1tb2RlLiBUaGUgY29tYmluYXRpb25zIGFyZToKICAgICAvLyB3cml0 aW5nLW1vZGUgLyBkaXJlY3Rpb24gICAgIHNjcm9sbE9yaWdpbi54KCkgc2V0ICAgIHNjcm9sbE9y aWdpbi55KCkgc2V0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy TGF5ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAppbmRl eCAwNDI0ZWNiODVlZDhlN2IzMmI2MDEwMGE5ZTBlZmMyMTJjOGU1NGVjLi40NjYxMjU1Yzk0NTA3 ZDU0YmVmMjNkOGI5MWU1N2JmMjlmM2NkYmYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJMYXllci5jcHAKQEAgLTEyMiw2ICsxMjIsMTAgQEAKICNpbmNsdWRlICJSZW5kZXJMYXll ckZpbHRlckluZm8uaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyNp bmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRpZgorCiAjZGVmaW5lIE1JTl9J TlRFUlNFQ1RfRk9SX1JFVkVBTCAzMgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0zMDI5LDYg KzMwMzMsMTggQEAgU2Nyb2xsYWJsZUFyZWEqIFJlbmRlckxheWVyOjplbmNsb3NpbmdTY3JvbGxh YmxlQXJlYSgpIGNvbnN0CiAgICAgcmV0dXJuIDA7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQordm9pZCBSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMoKQoreworICAgIC8v IEZJWE1FOiBFeHRlbmQgc3VwcG9ydCBiZXlvbmQgSFRNTEVsZW1lbnRzLgorICAgIGlmICghZW5j bG9zaW5nRWxlbWVudCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpIHx8ICFl bmNsb3NpbmdFbGVtZW50KCktPmlzSFRNTEVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworICAg IAorICAgIFJlbmRlckJveCogYm94ID0gZW5jbG9zaW5nRWxlbWVudCgpLT5yZW5kZXJCb3goKTsK KyAgICBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJs ZUFyZWEoKnRoaXMsICp0b0hUTUxFbGVtZW50KGVuY2xvc2luZ0VsZW1lbnQoKSksICpib3gsIGJv eC0+c3R5bGUoKSk7Cit9CisjZW5kaWYKKwogaW50IFJlbmRlckxheWVyOjp2ZXJ0aWNhbFNjcm9s bGJhcldpZHRoKE92ZXJsYXlTY3JvbGxiYXJTaXplUmVsZXZhbmN5IHJlbGV2YW5jeSkgY29uc3QK IHsKICAgICBpZiAoIW1fdkJhcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckxheWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaApp bmRleCAyNjY1NTlhZmZiOGNmYTA4OGMwZWFjMDM4ZmQ2ZWI3YzlmOGIxZjQ3Li5iZDI2MWE3YTQ5 ODdlNzE0N2YwMmFiZDM1YzgwMjM0M2FmZDA0YzNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyTGF5ZXIuaApAQCAtNDM5LDYgKzQzOSw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFNj cm9sbGJhciogaG9yaXpvbnRhbFNjcm9sbGJhcigpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1f aEJhci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Nyb2xsYmFyKiB2ZXJ0aWNhbFNjcm9sbGJhcigp IGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1fdkJhci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Ny b2xsYWJsZUFyZWEqIGVuY2xvc2luZ1Njcm9sbGFibGVBcmVhKCkgY29uc3Qgb3ZlcnJpZGU7Cisj aWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9m ZnNldHMoKSBvdmVycmlkZTsKKyNlbmRpZgogCiAjaWYgUExBVEZPUk0oSU9TKQogI2lmIEVOQUJM RShUT1VDSF9FVkVOVFMpCg== 236450 2014-08-12 09:48:01 -0700 2014-08-13 14:04:50 -0700 Patch bug-135268-20140812094751.patch text/plain 23978 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNDcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTI0OTM1ZWZmMTg5YzQ1 ZjliNDg1YjJlODYzODI1MmU1ZGE4NDU1ZC4uOGYxNGY1ZDBlN2UwMzVmODUyOTljMWRmNDdkOWY2 MDA4NGQ4ZTg4MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMzIEBACisyMDE0LTA4LTEyICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMpOiBJbnZva2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Ny b2xsU25hcE9mZnNldHMgdG8gdXBkYXRlIHNuYXAgb2Zmc2V0cyBmb3IgbWFpbmZyYW1lLgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xs U25hcE9mZnNldHM6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9m ZnNldHM6OnVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEpOiBVcGRhdGUgdGhlIFNj cm9sbGFibGVBcmVhJ3Mgc25hcCBheGVzLgorICAgICAgICAoV2ViQ29yZTo6QXhpc1Njcm9sbFNu YXBPZmZzZXRzOjphcHBlbmRDaGlsZFNuYXBPZmZzZXRzKTogSGVscGVyIGZ1bmN0aW9uIHRoYXQg YXBwZW5kcyB0aGUgc25hcCBwb3NpdGlvbnMgb2YgcmVsZXZhbnQgY2hpbGQgZWxlbWVudHMuCisg ICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZUZyb21TdHlsZSk6 IEhlbHBlciBmdW5jdGlvbiB0aGF0IHVwZGF0ZXMgYSBzbmFwIG9mZnNldCBsaXN0LgorICAgICAg ICAqIHBhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOiBBZGRlZC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3Jv bGxhYmxlQXJlYTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyB0aGUgU2Nyb2xsYWJs ZUFyZWEncyBzbmFwIG9mZnNldHMgaW4gdGhlIGdpdmVuIGF4aXMuCisgICAgICAgICogcGxhdGZv cm0vU2Nyb2xsYWJsZUFyZWEuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1 cGRhdGVTbmFwT2Zmc2V0cyk6IAorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMpOiBJbnZv a2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Nyb2xsU25hcE9mZnNldHMgdG8gdXBkYXRl IHNuYXAgb2Zmc2V0cyBmb3IgYW4gb3ZlcmZsb3cgYXJlYS4KKyAgICAgICAgKiByZW5kZXJpbmcv UmVuZGVyTGF5ZXIuaDoKKwogMjAxNC0wOC0xMiAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQGFw cGxlLmNvbT4KIAogICAgICAgICBbV2luXSBVbnJldmlld2VkIGJ1aWxkIGZpeCBhZnRlciByMTc0 MjUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agppbmRleCBmNTYxNWI5ZjZiNWI1MjI3NGE2YzYxYjkwODczOWQ4ZDljNDc1YmUwLi41MTFiNzE1 Y2M5ZDE5MDllMWIzNjQ4MDFjYWNmNzNmN2M0ZmFiMmZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNv cmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC02MjQ1LDYgKzYyNDUsOCBA QAogCQlGM0Y1Q0YxMTEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1l bnRhdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RjNGNUNGMTAxMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNvbGVJbnN0cnVtZW50YXRp b24uaCAqLzsgfTsKIAkJRjNGNUNGMTMxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFi YXNlSW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGM0Y1Q0YxMjEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJ bnN0cnVtZW50YXRpb24uaCAqLzsgfTsKIAkJRjQyRkZCNDYxOTg0QjcxNjAwRjY4MzdGIC8qIExl bmd0aFJlcGVhdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRjQyRkZCNDUxOTg0QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovOyB9OworCQlG NDVDMjMxRDE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFCMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovOyB9OworCQlGNDVDMjMx RTE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMxQzE5OTVCNzNCMDBBNkUy RTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0UxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxl U2Nyb2xsU25hcFBvaW50cy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50 cy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0 N0E1RTNGMTk1QjhFNDgwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ3QTVFM0ExOTVCOEM4 QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi87IH07CiAJCUY1MDY2NEY3 MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyog Rm9ybUNvbnRyb2xsZXIuY3BwICovOyB9OwpAQCAtMTM3NjIsNiArMTM3NjQsOCBAQAogCQlGM0Y1 Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1lbnRhdGlvbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1 bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUYzRjVDRjEyMTJFRDgx QjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlv bi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDJGRkI0NTE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IExl bmd0aFJlcGVhdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGNDVDMjMxQjE5OTVC NzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Ny b2xsU25hcE9mZnNldHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0N0E1RTNB MTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgcGF0 aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2lu dHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU3R5bGVTY3JvbGxTbmFwUG9p bnRzLmg7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjUwNjY0RjUxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9s bGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZvcm1Db250cm9s bGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1MTM4LDYgKzE1MTQyLDgg QEAKIAkJCQk5MzkxQTk5QjE2MjlENzAwMDAyOTczMzAgLyogU2Nyb2xsaW5nVHJlZVNjcm9sbGlu Z05vZGUuaCAqLywKIAkJCQkwRjYzODNEQjE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFkZWRTY3Jv bGxpbmdUcmVlLmNwcCAqLywKIAkJCQkwRjYzODNEQzE4NjE1QjI5MDAzRTVEQjUgLyogVGhyZWFk ZWRTY3JvbGxpbmdUcmVlLmggKi8sCisJCQkJRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi8sCisJCQkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUz IC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovLAogCQkJKTsKIAkJCXBhdGggPSBzY3JvbGxp bmc7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpAQCAtMjQ0MjEsNiArMjQ0MjcsNyBAQAog CQkJCUE4MTM2OUUwMDk3Mzc0RjYwMEQ3NDQ2MyAvKiBIVE1MTGVnZW5kRWxlbWVudC5oIGluIEhl YWRlcnMgKi8sCiAJCQkJQThFQTc5RjYwQTE5MTZERjAwQThFRjVGIC8qIEhUTUxMSUVsZW1lbnQu aCBpbiBIZWFkZXJzICovLAogCQkJCUE4NzFEQzIwMEExNTIwNTcwMEIxMkE2OCAvKiBIVE1MTGlu a0VsZW1lbnQuaCBpbiBIZWFkZXJzICovLAorCQkJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAv KiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4RUE3RDJDMEEx OTM4NTUwMEE4RUY1RiAvKiBIVE1MTWFwRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThF QTdDQUIwQTE5MkI5QzAwQThFRjVGIC8qIEhUTUxNYXJxdWVlRWxlbWVudC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJRTQ0NjEzQTUwQ0Q2MzMxMDAwRkFEQTc1IC8qIEhUTUxNZWRpYUVsZW1lbnQuaCBp biBIZWFkZXJzICovLApAQCAtMjc3NTYsNiArMjc3NjMsNyBAQAogCQkJCUIyQUZGQzdEMEQwMEE1 QzEwMDMwMDc0RCAvKiBGb250Q3VzdG9tUGxhdGZvcm1EYXRhLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTM3MUY0RjQxMEQyNUI5QUYwMEVDRTBENSAvKiBGb250RGF0YS5jcHAgaW4gU291cmNlcyAq LywKIAkJCQkzN0FDQ0Y2OTBEQTQxNEU3MDA4OUU2MDIgLyogRm9udERlc2NyaXB0aW9uLmNwcCBp biBTb3VyY2VzICovLAorCQkJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xs U25hcE9mZnNldHMuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNzI2MjZFMDIwRUYwMjJGRTAwQTA3 RTIwIC8qIEZvbnRGYXN0UGF0aC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk0QTZFOUZDNzEzQzE3 RDU3MDA0NkE3RjggLyogRm9udEZlYXR1cmVTZXR0aW5ncy5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQlFNDRFRTNBODE3NTc3RUJEMDBFRUU4Q0YgLyogRm9udEdlbmVyaWNGYW1pbGllcy5jcHAgaW4g U291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAppbmRleCAzODEwNzFkODcwNDUx MDIxNjc1ODkyNDI5ZmRhNDg5YTg0MjU1N2Y5Li40NGEwZDNjOWMyYzQzZjZlOWUzYWU2ZjJlYmUw OTZhZDVlNTk0ZjMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC05OCw2ICs5OCwx MCBAQAogI2luY2x1ZGUgIlRleHRBdXRvc2l6ZXIuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKENT U19TQ1JPTExfU05BUCkKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRp ZgorCiAjaWYgUExBVEZPUk0oSU9TKQogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5j bHVkZSAiTGVnYWN5VGlsZUNhY2hlLmgiCkBAIC04NDcsNiArODUxLDIwIEBAIEdyYXBoaWNzTGF5 ZXIqIEZyYW1lVmlldzo6c2V0V2FudHNMYXllckZvckJvdHRvbU92ZXJIYW5nQXJlYShib29sIHdh bnRzTGF5ZXIpIGNvCiAKICNlbmRpZiAvLyBFTkFCTEUoUlVCQkVSX0JBTkRJTkcpCiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBGcmFtZVZpZXc6OnVwZGF0ZVNuYXBPZmZzZXRz KCkKK3sKKyAgICBpZiAoIWZyYW1lKCkuZG9jdW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworICAg IC8vIEZJWE1FOiBTaG91bGQgd2UgYWxsb3cgc3BlY2lmeWluZyBzbmFwIHBvaW50cyB0aHJvdWdo IDxodG1sPiB0YWdzIHRvbz8KKyAgICBIVE1MRWxlbWVudCogYm9keSA9IGZyYW1lKCkuZG9jdW1l bnQoKS0+Ym9keSgpOworICAgIGlmICghYm9keSB8fCAhYm9keS0+cmVuZGVyZXIoKSB8fCAhcmVu ZGVyVmlldygpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgQXhpc1Njcm9sbFNuYXBPZmZz ZXRzOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKCp0aGlzLCAqYm9keSwgKnJl bmRlclZpZXcoKSwgYm9keS0+cmVuZGVyZXIoKS0+c3R5bGUoKSk7Cit9CisjZW5kaWYKKwogYm9v bCBGcmFtZVZpZXc6OmZsdXNoQ29tcG9zaXRpbmdTdGF0ZUZvclRoaXNGcmFtZShGcmFtZSogcm9v dEZyYW1lRm9yRmx1c2gpCiB7CiAgICAgUmVuZGVyVmlldyogcmVuZGVyVmlldyA9IHRoaXMtPnJl bmRlclZpZXcoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCmluZGV4IGRiZTlkNWRhOGM3NDBmOTgx N2EzYjQ5MzlmYmZlNzhiZTQwNGU1MzEuLjk3OGY1NDQ5OGJhOTgzNmFjMjIzMzk0Y2JjYjhlNzcw MzFhZWU2ZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaApAQCAtNDk2LDYgKzQ5NiwxMCBAQCBw dWJsaWM6CiAgICAgdm9pZCBzZXRFeHBvc2VkUmVjdChGbG9hdFJlY3QpOwogICAgIEZsb2F0UmVj dCBleHBvc2VkUmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhwb3NlZFJlY3Q7IH0KIAorI2lmIEVO QUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRz KCkgb3ZlcnJpZGU7CisjZW5kaWYKKwogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgYm9vbCBzY3Jv bGxDb250ZW50c0Zhc3RQYXRoKGNvbnN0IEludFNpemUmIHNjcm9sbERlbHRhLCBjb25zdCBJbnRS ZWN0JiByZWN0VG9TY3JvbGwsIGNvbnN0IEludFJlY3QmIGNsaXBSZWN0KSBvdmVycmlkZTsKICAg ICB2aXJ0dWFsIHZvaWQgc2Nyb2xsQ29udGVudHNTbG93UGF0aChjb25zdCBJbnRSZWN0JiB1cGRh dGVSZWN0KSBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xs aW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9s bGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYxZGY1ODZhZjY2MmQw YzFlNzczOTNkYmNhMjBhYzFlMzY1NjQ1NTgKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwCkBAIC0wLDAgKzEs MTQyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkF4aXNT Y3JvbGxTbmFwT2Zmc2V0cy5oIgorCisjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUgIkhU TUxDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKKyNpbmNsdWRlICJSZW5k ZXJCb3guaCIKKyNpbmNsdWRlICJTY3JvbGxhYmxlQXJlYS5oIgorCisjaWYgRU5BQkxFKENTU19T Q1JPTExfU05BUCkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzT3duUHRyPEF4aXNTY3Jv bGxTbmFwT2Zmc2V0cz4gQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjpjcmVhdGUoKQoreworICAgIHJl dHVybiBhZG9wdFB0cihuZXcgQXhpc1Njcm9sbFNuYXBPZmZzZXRzKCkpOworfQorCit2b2lkIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0czo6dXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYShT Y3JvbGxhYmxlQXJlYSYgc2Nyb2xsYWJsZUFyZWEsIEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVt ZW50LCBjb25zdCBSZW5kZXJCb3gmIGJveCwgY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlKQorewor ICAgIGlmIChzdHlsZS5zY3JvbGxTbmFwVHlwZSgpID09IFNjcm9sbFNuYXBUeXBlOjpOb25lKQor ICAgICAgICByZXR1cm47CisgICAgCisgICAgTGF5b3V0VW5pdCB2aWV3V2lkdGggPSBib3gud2lk dGgoKTsKKyAgICBMYXlvdXRVbml0IHZpZXdIZWlnaHQgPSBib3guaGVpZ2h0KCk7CisgICAgTGF5 b3V0VW5pdCBzY3JvbGxXaWR0aCA9IGJveC5zY3JvbGxXaWR0aCgpOworICAgIExheW91dFVuaXQg c2Nyb2xsSGVpZ2h0ID0gYm94LnNjcm9sbEhlaWdodCgpOworICAgIGJvb2wgY29tcHV0ZUhvcml6 b250YWxTbmFwT2Zmc2V0cyA9IHNjcm9sbFdpZHRoID4gMCAmJiB2aWV3V2lkdGggPiAwICYmIHZp ZXdXaWR0aCA8IHNjcm9sbFdpZHRoOworICAgIGJvb2wgY29tcHV0ZVZlcnRpY2FsU25hcE9mZnNl dHMgPSBzY3JvbGxIZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPCBz Y3JvbGxIZWlnaHQ7CisgICAgaWYgKCFjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzICYmICFj b21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAgcmV0dXJuOworCisgICAgVmVjdG9y PExheW91dFVuaXQ+IGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAgVmVjdG9y PExheW91dFVuaXQ+IHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlOworICAgIGlmIChzdHls ZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpIHx8IHN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVu dHNZKCkpCisgICAgICAgIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6YXBwZW5kQ2hpbGRTbmFwT2Zm c2V0cyhzY3JvbGxpbmdFbGVtZW50LCBjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzLCBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBjb21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cywg dmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOworCisgICAgaWYgKGNvbXB1dGVIb3Jpem9u dGFsU25hcE9mZnNldHMpIHsKKyAgICAgICAgaWYgKCFzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1l bnRzWCgpKSB7CisgICAgICAgICAgICBmb3IgKExlbmd0aCBzbmFwTGVuZ3RoIDogc3R5bGUuc2Ny b2xsU25hcE9mZnNldHNYKCkpCisgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRT dWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgoc25hcExlbmd0aCwgdmlld1dpZHRoKSk7 CisgICAgICAgIH0KKyAgICAgICAgaWYgKCFob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNl LnNpemUoKSkKKyAgICAgICAgICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBw ZW5kKDApOworCisgICAgICAgIHNjcm9sbGFibGVBcmVhLmF4aXNTY3JvbGxTbmFwT2Zmc2V0cyhT Y3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwpLT51cGRhdGVGcm9tU3R5bGUoc3R5bGUsIFNjcm9s bEV2ZW50QXhpczo6SG9yaXpvbnRhbCwgdmlld1dpZHRoLCBzY3JvbGxXaWR0aCwgaG9yaXpvbnRh bFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisgICAgfQorICAgIGlmIChjb21wdXRlVmVydGljYWxT bmFwT2Zmc2V0cykgeworICAgICAgICBpZiAoIXN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNZ KCkpIHsKKyAgICAgICAgICAgIGZvciAoTGVuZ3RoIHNuYXBMZW5ndGggOiBzdHlsZS5zY3JvbGxT bmFwT2Zmc2V0c1koKSkKKyAgICAgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1 ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgoc25hcExlbmd0aCwgdmlld0hlaWdodCkpOworICAg ICAgICB9CisgICAgICAgIGlmICghdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2Uuc2l6ZSgp KQorICAgICAgICAgICAgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBwZW5kKDApOwor CisgICAgICAgIHNjcm9sbGFibGVBcmVhLmF4aXNTY3JvbGxTbmFwT2Zmc2V0cyhTY3JvbGxFdmVu dEF4aXM6OlZlcnRpY2FsKS0+dXBkYXRlRnJvbVN0eWxlKHN0eWxlLCBTY3JvbGxFdmVudEF4aXM6 OlZlcnRpY2FsLCB2aWV3SGVpZ2h0LCBzY3JvbGxIZWlnaHQsIHZlcnRpY2FsU25hcE9mZnNldFN1 YnNlcXVlbmNlKTsKKyAgICB9Cit9CisKK3ZvaWQgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjphcHBl bmRDaGlsZFNuYXBPZmZzZXRzKEhUTUxFbGVtZW50JiBwYXJlbnQsIGJvb2wgY29tcHV0ZUhvcml6 b250YWwsIFZlY3RvcjxMYXlvdXRVbml0PiYgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZSwgYm9vbCBjb21wdXRlVmVydGljYWwsIFZlY3RvcjxMYXlvdXRVbml0PiYgdmVydGljYWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2UpCit7CisgICAgRWxlbWVudCogY2hpbGQgPSBwYXJlbnQuY2hpbGRy ZW4oKS0+Y29sbGVjdGlvbkJlZ2luKCk7CisgICAgLy8gRklYTUU6IEluc3RlYWQgb2YgdHJhdmVy c2luZyBhbGwgY2hpbGRyZW4sIHJlZ2lzdGVyIGNoaWxkcmVuIHdpdGggc25hcCBjb29yZGluYXRl cyBiZWZvcmUgYXBwZW5kaW5nIHRvIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZS4KKyAgICB3aGlsZSAo Y2hpbGQpIHsKKyAgICAgICAgaWYgKFJlbmRlckJveCogYm94ID0gY2hpbGQtPnJlbmRlckJveCgp KSB7CisgICAgICAgICAgICBMYXlvdXRVbml0IHZpZXdXaWR0aCA9IGJveC0+d2lkdGgoKTsKKyAg ICAgICAgICAgIExheW91dFVuaXQgdmlld0hlaWdodCA9IGJveC0+aGVpZ2h0KCk7CisgICAgICAg ICAgICBMYXlvdXRVbml0IHBvc2l0aW9uWCA9IGJveC0+eCgpOworICAgICAgICAgICAgTGF5b3V0 VW5pdCBwb3NpdGlvblkgPSBib3gtPnkoKTsKKyAgICAgICAgICAgIGZvciAoU25hcENvb3JkaW5h dGUgY29vcmRpbmF0ZSA6IGJveC0+c3R5bGUoKS5zY3JvbGxTbmFwQ29vcmRpbmF0ZXMoKSkgewor ICAgICAgICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblggPSBw b3NpdGlvblggKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLmZpcnN0LCB2aWV3V2lkdGgpOwor ICAgICAgICAgICAgICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbCAmJiBsYXN0UG90ZW50aWFsU25h cFBvc2l0aW9uWCA+IDApCisgICAgICAgICAgICAgICAgICAgIGhvcml6b250YWxTbmFwT2Zmc2V0 U3Vic2VxdWVuY2UuYXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25YKTsKKyAgICAgICAg ICAgICAgICBMYXlvdXRVbml0IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25ZID0gcG9zaXRpb25Z ICsgdmFsdWVGb3JMZW5ndGgoY29vcmRpbmF0ZS5zZWNvbmQsIHZpZXdIZWlnaHQpOworICAgICAg ICAgICAgICAgIGlmIChjb21wdXRlVmVydGljYWwgJiYgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlv blkgPiAwKQorICAgICAgICAgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkpOworICAgICAgICAgICAgfQorICAg ICAgICB9CisgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRFbGVtZW50U2libGluZygpOworICAg IH0KK30KKwordm9pZCBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZUZyb21TdHlsZShjb25z dCBSZW5kZXJTdHlsZSYgc3R5bGUsIFNjcm9sbEV2ZW50QXhpcyBheGlzLCBMYXlvdXRVbml0IHZp ZXdTaXplLCBMYXlvdXRVbml0IHNjcm9sbFNpemUsIGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYg c25hcE9mZnNldFN1YnNlcXVlbmNlKQoreworICAgIGJvb2wgaXNIb3Jpem9udGFsQXhpcyA9IGF4 aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsOworICAgIGJvb2wgaGFzUmVwZWF0ID0g aXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRYKCkgOiBzdHlsZS5z Y3JvbGxTbmFwSGFzUmVwZWF0WSgpOworICAgIExheW91dFVuaXQgcmVwZWF0T2Zmc2V0ID0gdmFs dWVGb3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZz ZXRYKCkgOiBzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0WSgpLCB2aWV3U2l6ZSk7CisgICAg TGF5b3V0VW5pdCBkZXN0aW5hdGlvbk9mZnNldCA9IHZhbHVlRm9yTGVuZ3RoKGlzSG9yaXpvbnRh bEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25YKCkgOiBzdHlsZS5zY3JvbGxTbmFw RGVzdGluYXRpb25ZKCksIHZpZXdTaXplKTsKKyAgICBMYXlvdXRVbml0IGN1clNuYXBQb3NpdGlv blNoaWZ0ID0gMDsKKyAgICBMYXlvdXRVbml0IG1heFNjcm9sbE9mZnNldCA9IHNjcm9sbFNpemUg LSB2aWV3U2l6ZTsKKyAgICBMYXlvdXRVbml0IGxhc3RTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9z aXRpb25TaGlmdDsKKyAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICBt X29mZnNldHMuY2xlYXIoKTsKKyAgICBtX29mZnNldHMuYXBwZW5kKDApOworICAgIGRvIHsKKyAg ICAgICAgZm9yIChMYXlvdXRVbml0IHNuYXBQb3NpdGlvbiA6IHNuYXBPZmZzZXRTdWJzZXF1ZW5j ZSkgeworICAgICAgICAgICAgcG90ZW50aWFsU25hcFBvc2l0aW9uID0gY3VyU25hcFBvc2l0aW9u U2hpZnQgKyBzbmFwUG9zaXRpb24gLSBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAgICAgIGlm IChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPD0gMCkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsK KworICAgICAgICAgICAgaWYgKHBvdGVudGlhbFNuYXBQb3NpdGlvbiA+PSBtYXhTY3JvbGxPZmZz ZXQpCisgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIG1fb2Zmc2V0cy5hcHBl bmQocG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFwUG9zaXRpb24g PSBwb3RlbnRpYWxTbmFwUG9zaXRpb24gKyBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAgfQor ICAgICAgICBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IGxhc3RTbmFwUG9zaXRpb24gKyByZXBlYXRP ZmZzZXQ7CisgICAgfSB3aGlsZSAoaGFzUmVwZWF0ICYmIGN1clNuYXBQb3NpdGlvblNoaWZ0IDwg bWF4U2Nyb2xsT2Zmc2V0KTsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0aGUg bWF4aW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIC8vIE5vdCBhIHBhcnQgb2YgdGhlIHNwZWMsIGJ1 dCBuZWNlc3NhcnkgdG8gcHJldmVudCB1bnJlYWNoYWJsZSBjb250ZW50IHdoZW4gc25hcHBpbmcu CisgICAgaWYgKG1fb2Zmc2V0cy5sYXN0KCkgIT0gbWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICBt X29mZnNldHMuYXBwZW5kKG1heFNjcm9sbE9mZnNldCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5m Y2YxNjBlNzBjZWU5NGZiYzg3ZDRlNjRlZTc5MWM5OGU0MDcxMDllCi0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgK QEAgLTAsMCArMSw1OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXhpc1Njcm9sbFNuYXBPZmZz ZXRzX2gKKyNkZWZpbmUgQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKKworI2lmIEVOQUJMRShDU1Nf U0NST0xMX1NOQVApCisKKyNpbmNsdWRlICJMYXlvdXRVbml0LmgiCisjaW5jbHVkZSAiU2Nyb2xs VHlwZXMuaCIKKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworY2xhc3MgSFRNTEVsZW1lbnQ7CitjbGFzcyBSZW5kZXJCb3g7CitjbGFzcyBSZW5kZXJTdHls ZTsKK2NsYXNzIFNjcm9sbGFibGVBcmVhOworCitjbGFzcyBBeGlzU2Nyb2xsU25hcE9mZnNldHMg eworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEF4aXNTY3JvbGxTbmFwT2Zmc2V0cz4g Y3JlYXRlKCk7CisgICAgc3RhdGljIHZvaWQgdXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxl QXJlYShTY3JvbGxhYmxlQXJlYSYsIEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVtZW50LCBjb25z dCBSZW5kZXJCb3gmLCBjb25zdCBSZW5kZXJTdHlsZSYpOworCitwcml2YXRlOgorICAgIHN0YXRp YyB2b2lkIGFwcGVuZENoaWxkU25hcE9mZnNldHMoSFRNTEVsZW1lbnQmIHBhcmVudCwgYm9vbCBj b21wdXRlSG9yaXpvbnRhbCwgVmVjdG9yPExheW91dFVuaXQ+JiBob3Jpem9udGFsU25hcE9mZnNl dFN1YnNlcXVlbmNlLCBib29sIGNvbXB1dGVWZXJ0aWNhbCwgVmVjdG9yPExheW91dFVuaXQ+JiB2 ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisgICAgdm9pZCB1cGRhdGVGcm9tU3R5bGUo Y29uc3QgUmVuZGVyU3R5bGUmLCBTY3JvbGxFdmVudEF4aXMsIExheW91dFVuaXQgdmlld1NpemUs IExheW91dFVuaXQgc2Nyb2xsU2l6ZSwgY29uc3QgVmVjdG9yPExheW91dFVuaXQ+JiBzbmFwT2Zm c2V0U3Vic2VxdWVuY2UpOworCisgICAgVmVjdG9yPExheW91dFVuaXQ+IG1fb2Zmc2V0czsKK307 CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUAor CisjZW5kaWYgLy8gQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Njcm9sbGFibGVBcmVhLmNwcAppbmRleCBjN2Q5NDk0NTQ3MTFmODNjNmJkN2JiNTEwY2Iy MzFjODkxMjgwMTAwLi4yZjUyM2FjYWExYTM5MWY0MzlmOWViMzY2NTM3NjA2MWRjZGY2MDQ4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCkBAIC0zMiw2ICsz Miw5IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYWJsZUFyZWEuaCIK IAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBP ZmZzZXRzLmgiCisjZW5kaWYKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRl ICJHcmFwaGljc0xheWVyLmgiCiAjaW5jbHVkZSAiRmxvYXRQb2ludC5oIgpAQCAtNDYsNiArNDks MTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogc3RydWN0IFNhbWVTaXplQXNTY3JvbGxhYmxlQXJl YSB7CiAgICAgdmlydHVhbCB+U2FtZVNpemVBc1Njcm9sbGFibGVBcmVhKCk7CiAgICAgdm9pZCog cG9pbnRlcjsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZvaWQqIGhvcml6b250 YWxTbmFwT2Zmc2V0c1BvaW50ZXI7CisgICAgdm9pZCogdmVydGljYWxTbmFwT2Zmc2V0c1BvaW50 ZXI7CisjZW5kaWYKICAgICBJbnRQb2ludCBvcmlnaW47CiAgICAgdW5zaWduZWQgYml0ZmllbGRz IDogMTY7CiB9OwpAQCAtMTc4LDYgKzE4NSwyMiBAQCBib29sIFNjcm9sbGFibGVBcmVhOjpoYW5k bGVXaGVlbEV2ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYgd2hlZWxFdmVudCkKICAgICBy ZXR1cm4gc2Nyb2xsQW5pbWF0b3IoKS0+aGFuZGxlV2hlZWxFdmVudCh3aGVlbEV2ZW50KTsKIH0K IAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCitBeGlzU2Nyb2xsU25hcE9mZnNldHMqIFNj cm9sbGFibGVBcmVhOjpheGlzU2Nyb2xsU25hcE9mZnNldHMoU2Nyb2xsRXZlbnRBeGlzIGF4aXMp Cit7CisgICAgaWYgKGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsKSB7CisgICAg ICAgIGlmICghbV9ob3Jpem9udGFsU25hcE9mZnNldHMpCisgICAgICAgICAgICBtX2hvcml6b250 YWxTbmFwT2Zmc2V0cyA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6Y3JlYXRlKCk7CisKKyAgICAg ICAgcmV0dXJuIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzLmdldCgpOworICAgIH0KKyAgICBpZiAo IW1fdmVydGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAgbV92ZXJ0aWNhbFNuYXBPZmZzZXRzID0g QXhpc1Njcm9sbFNuYXBPZmZzZXRzOjpjcmVhdGUoKTsKKworICAgIHJldHVybiBtX3ZlcnRpY2Fs U25hcE9mZnNldHMuZ2V0KCk7Cit9CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMp CiBib29sIFNjcm9sbGFibGVBcmVhOjpoYW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91 Y2hFdmVudCYgdG91Y2hFdmVudCkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Njcm9sbGFibGVBcmVhLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxl QXJlYS5oCmluZGV4IDJmZTI3NDkxNDUyOGZhNTA3YTMxOGE0NWVhOTEwMDZlMWUyODRmMWIuLjE2 MzkyMzYzZThlMjU4ZDIwNzJlZDZiNDk2NjZiNTVkYThjOTk3YmYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaApAQCAtMzEsNiArMzEsOSBAQAogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorY2xhc3MgQXhpc1Njcm9s bFNuYXBPZmZzZXRzOworI2VuZGlmCiBjbGFzcyBGbG9hdFBvaW50OwogY2xhc3MgR3JhcGhpY3ND b250ZXh0OwogY2xhc3MgTGF5b3V0UG9pbnQ7CkBAIC01OCw2ICs2MSwxMSBAQCBwdWJsaWM6CiAK ICAgICBib29sIGhhbmRsZVdoZWVsRXZlbnQoY29uc3QgUGxhdGZvcm1XaGVlbEV2ZW50Jik7CiAK KyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyog YXhpc1Njcm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2ZW50QXhpcyk7CisgICAgdmlydHVhbCB2b2lk IHVwZGF0ZVNuYXBPZmZzZXRzKCkgeyB9OworI2VuZGlmCisKICNpZiBFTkFCTEUoVE9VQ0hfRVZF TlRTKQogICAgIHZpcnR1YWwgYm9vbCBpc1RvdWNoU2Nyb2xsYWJsZSgpIGNvbnN0IHsgcmV0dXJu IGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGhhbmRsZVRvdWNoRXZlbnQoY29uc3QgUGxhdGZv cm1Ub3VjaEV2ZW50Jik7CkBAIC0yNzUsNiArMjgzLDExIEBAIHByaXZhdGU6CiAKICAgICBtdXRh YmxlIE93blB0cjxTY3JvbGxBbmltYXRvcj4gbV9zY3JvbGxBbmltYXRvcjsKIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCisgICAgT3duUHRyPEF4aXNTY3JvbGxTbmFwT2Zmc2V0cz4gbV9o b3Jpem9udGFsU25hcE9mZnNldHM7CisgICAgT3duUHRyPEF4aXNTY3JvbGxTbmFwT2Zmc2V0cz4g bV92ZXJ0aWNhbFNuYXBPZmZzZXRzOworI2VuZGlmCisKICAgICAvLyBUaGVyZSBhcmUgOCBwb3Nz aWJsZSBjb21iaW5hdGlvbnMgb2Ygd3JpdGluZyBtb2RlIGFuZCBkaXJlY3Rpb24uIFNjcm9sbCBv cmlnaW4gd2lsbCBiZSBub24temVybyBpbiB0aGUgeCBvciB5IGF4aXMKICAgICAvLyBpZiB0aGVy ZSBpcyBhbnkgcmV2ZXJzZWQgZGlyZWN0aW9uIG9yIHdyaXRpbmctbW9kZS4gVGhlIGNvbWJpbmF0 aW9ucyBhcmU6CiAgICAgLy8gd3JpdGluZy1tb2RlIC8gZGlyZWN0aW9uICAgICBzY3JvbGxPcmln aW4ueCgpIHNldCAgICBzY3JvbGxPcmlnaW4ueSgpIHNldApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMYXllci5jcHAKaW5kZXggMDQyNGVjYjg1ZWQ4ZTdiMzJiNjAxMDBhOWUwZWZjMjEy YzhlNTRlYy4uNDY2MTI1NWM5NDUwN2Q1NGJlZjIzZDhiOTFlNTdiZjI5ZjNjZGJmMCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCkBAIC0xMjIsNiArMTIyLDEwIEBA CiAjaW5jbHVkZSAiUmVuZGVyTGF5ZXJGaWx0ZXJJbmZvLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgiCisj ZW5kaWYKKwogI2RlZmluZSBNSU5fSU5URVJTRUNUX0ZPUl9SRVZFQUwgMzIKIAogbmFtZXNwYWNl IFdlYkNvcmUgewpAQCAtMzAyOSw2ICszMDMzLDE4IEBAIFNjcm9sbGFibGVBcmVhKiBSZW5kZXJM YXllcjo6ZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBjb25zdAogICAgIHJldHVybiAwOwogfQog CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3ZvaWQgUmVuZGVyTGF5ZXI6OnVwZGF0ZVNu YXBPZmZzZXRzKCkKK3sKKyAgICAvLyBGSVhNRTogRXh0ZW5kIHN1cHBvcnQgYmV5b25kIEhUTUxF bGVtZW50cy4KKyAgICBpZiAoIWVuY2xvc2luZ0VsZW1lbnQoKSB8fCAhZW5jbG9zaW5nRWxlbWVu dCgpLT5yZW5kZXJCb3goKSB8fCAhZW5jbG9zaW5nRWxlbWVudCgpLT5pc0hUTUxFbGVtZW50KCkp CisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBSZW5kZXJCb3gqIGJveCA9IGVuY2xvc2luZ0Vs ZW1lbnQoKS0+cmVuZGVyQm94KCk7CisgICAgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjp1cGRhdGVT bmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKCp0aGlzLCAqdG9IVE1MRWxlbWVudChlbmNsb3Np bmdFbGVtZW50KCkpLCAqYm94LCBib3gtPnN0eWxlKCkpOworfQorI2VuZGlmCisKIGludCBSZW5k ZXJMYXllcjo6dmVydGljYWxTY3JvbGxiYXJXaWR0aChPdmVybGF5U2Nyb2xsYmFyU2l6ZVJlbGV2 YW5jeSByZWxldmFuY3kpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3ZCYXIKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckxheWVyLmgKaW5kZXggMjY2NTU5YWZmYjhjZmEwODhjMGVhYzAzOGZkNmVi N2M5ZjhiMWY0Ny4uYmQyNjFhN2E0OTg3ZTcxNDdmMDJhYmQzNWM4MDIzNDNhZmQwNGMzYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKQEAgLTQzOSw2ICs0MzksOSBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCBTY3JvbGxiYXIqIGhvcml6b250YWxTY3JvbGxiYXIoKSBjb25z dCBvdmVycmlkZSB7IHJldHVybiBtX2hCYXIuZ2V0KCk7IH0KICAgICB2aXJ0dWFsIFNjcm9sbGJh ciogdmVydGljYWxTY3JvbGxiYXIoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX3ZCYXIuZ2V0 KCk7IH0KICAgICB2aXJ0dWFsIFNjcm9sbGFibGVBcmVhKiBlbmNsb3NpbmdTY3JvbGxhYmxlQXJl YSgpIGNvbnN0IG92ZXJyaWRlOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdmly dHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzKCkgb3ZlcnJpZGU7CisjZW5kaWYKIAogI2lmIFBM QVRGT1JNKElPUykKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQo= 236453 2014-08-12 10:18:30 -0700 2014-08-13 14:04:58 -0700 Patch bug-135268-20140812101820.patch text/plain 24024 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNDcyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYjRmOGZjNGEwMDgxNjVm MjEzNjBmMDc1YjVmYzU3YWI5YmExMzNiZC4uNTFkNzNhMzYzM2I1OTBmMTI1YTNhZDIzYmIyMWJl ODg5YjVlZDc0ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMzIEBACisyMDE0LTA4LTEyICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMpOiBJbnZva2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Ny b2xsU25hcE9mZnNldHMgdG8gdXBkYXRlIHNuYXAgb2Zmc2V0cyBmb3IgbWFpbmZyYW1lLgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xs U25hcE9mZnNldHM6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9m ZnNldHM6OnVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEpOiBVcGRhdGUgdGhlIFNj cm9sbGFibGVBcmVhJ3Mgc25hcCBheGVzLgorICAgICAgICAoV2ViQ29yZTo6QXhpc1Njcm9sbFNu YXBPZmZzZXRzOjphcHBlbmRDaGlsZFNuYXBPZmZzZXRzKTogSGVscGVyIGZ1bmN0aW9uIHRoYXQg YXBwZW5kcyB0aGUgc25hcCBwb3NpdGlvbnMgb2YgcmVsZXZhbnQgY2hpbGQgZWxlbWVudHMuCisg ICAgICAgIChXZWJDb3JlOjpBeGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZUZyb21TdHlsZSk6 IEhlbHBlciBmdW5jdGlvbiB0aGF0IHVwZGF0ZXMgYSBzbmFwIG9mZnNldCBsaXN0LgorICAgICAg ICAqIHBhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOiBBZGRlZC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3Jv bGxhYmxlQXJlYTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyB0aGUgU2Nyb2xsYWJs ZUFyZWEncyBzbmFwIG9mZnNldHMgaW4gdGhlIGdpdmVuIGF4aXMuCisgICAgICAgICogcGxhdGZv cm0vU2Nyb2xsYWJsZUFyZWEuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1 cGRhdGVTbmFwT2Zmc2V0cyk6IAorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMpOiBJbnZv a2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Nyb2xsU25hcE9mZnNldHMgdG8gdXBkYXRl IHNuYXAgb2Zmc2V0cyBmb3IgYW4gb3ZlcmZsb3cgYXJlYS4KKyAgICAgICAgKiByZW5kZXJpbmcv UmVuZGVyTGF5ZXIuaDoKKwogMjAxNC0wOC0xMiAgRmFiaWVuIFZhbGzDqWUgIDxmdmFsbGVlQGNv bm5lY3RlZC1sYWJzLmNvbT4KIAogICAgICAgICBbR1N0cmVhbWVyXSBwbGF5YmFjayByYXRlIGlz IHJvdW5kZWQgdG8gaW50ZWdlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGY1NjE1YjlmNmI1YjUyMjc0YTZjNjFiOTA4NzM5ZDhk OWM0NzViZTAuLjUxMWI3MTVjYzlkMTkwOWUxYjM2NDgwMWNhY2Y3M2Y3YzRmYWIyZmYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagor KysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAg LTYyNDUsNiArNjI0NSw4IEBACiAJCUYzRjVDRjExMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0 b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29u c29sZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1Q0YxMzEyRUQ4MUIzMDA4NEM1Njkg LyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEyMTJFRDgxQjMwMDg0QzU2OSAvKiBJ bnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGNDJGRkI0NjE5ODRC NzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVw ZWF0LmggKi87IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25h cE9mZnNldHMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAg Ki87IH07CisJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNl dHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMy MzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4QzhB MDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5 bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25h cFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAq LzsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3 RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CkBAIC0xMzc2Miw2ICsx Mzc2NCw4IEBACiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xl SW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3Bl Y3RvckNvbnNvbGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVu dGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckRhdGFi YXNlSW5zdHJ1bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0MkZG QjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAw QTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJRjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50 cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNu YXBQb2ludHMuY3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0 eWxlU2Nyb2xsU25hcFBvaW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBT dHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50 cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIy NkYgLyogRm9ybUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gRm9ybUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt MTUxMzgsNiArMTUxNDIsOCBAQAogCQkJCTkzOTFBOTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3Jv bGxpbmdUcmVlU2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURC NSAvKiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkw MDNFNURCNSAvKiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVC NzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLywKKwkJCQlGNDVDMjMx QzE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8sCiAJCQkpOwog CQkJcGF0aCA9IHNjcm9sbGluZzsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQy MSw2ICsyNDQyNyw3IEBACiAJCQkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdl bmRFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYg LyogSFRNTExJRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAw QjEyQTY4IC8qIEhUTUxMaW5rRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUx OTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGluIEhlYWRlcnMgKi8s CiAJCQkJQThFQTdEMkMwQTE5Mzg1NTAwQThFRjVGIC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVh ZGVycyAqLywKIAkJCQlBOEVBN0NBQjBBMTkyQjlDMDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVt ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlFNDQ2MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRN TE1lZGlhRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCkBAIC0yNzc1Niw2ICsyNzc2Myw3IEBACiAJ CQkJQjJBRkZDN0QwRDAwQTVDMTAwMzAwNzREIC8qIEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJMzcxRjRGNDEwRDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRh LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3QUNDRjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250 RGVzY3JpcHRpb24uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZF MkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYy NkUwMjBFRjAyMkZFMDBBMDdFMjAgLyogRm9udEZhc3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTRBNkU5RkM3MTNDMTdENTcwMDQ2QTdGOCAvKiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBp biBTb3VyY2VzICovLAogCQkJCUU0NEVFM0E4MTc1NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJp Y0ZhbWlsaWVzLmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmlu ZGV4IDM4MTA3MWQ4NzA0NTEwMjE2NzU4OTI0MjlmZGE0ODlhODQyNTU3ZjkuLjQ0YTBkM2M5YzJj NDNmNmU5ZTNhZTZmMmViZTA5NmFkNWU1OTRmMzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKQEAgLTk4LDYgKzk4LDEwIEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogI2VuZGlm CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFw T2Zmc2V0cy5oIgorI2VuZGlmCisKICNpZiBQTEFURk9STShJT1MpCiAjaW5jbHVkZSAiRG9jdW1l bnRMb2FkZXIuaCIKICNpbmNsdWRlICJMZWdhY3lUaWxlQ2FjaGUuaCIKQEAgLTg0Nyw2ICs4NTEs MjAgQEAgR3JhcGhpY3NMYXllciogRnJhbWVWaWV3OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3Zl ckhhbmdBcmVhKGJvb2wgd2FudHNMYXllcikgY28KIAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJf QkFORElORykKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMoKQoreworICAgIGlmICghZnJhbWUoKS5kb2N1bWVudCgpKQorICAg ICAgICByZXR1cm47CisgICAgLy8gRklYTUU6IFNob3VsZCB3ZSBhbGxvdyBzcGVjaWZ5aW5nIHNu YXAgcG9pbnRzIHRocm91Z2ggPGh0bWw+IHRhZ3MgdG9vPworICAgIEhUTUxFbGVtZW50KiBib2R5 ID0gZnJhbWUoKS5kb2N1bWVudCgpLT5ib2R5KCk7CisgICAgaWYgKCFib2R5IHx8ICFib2R5LT5y ZW5kZXJlcigpIHx8ICFyZW5kZXJWaWV3KCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBB eGlzU2Nyb2xsU25hcE9mZnNldHM6OnVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEo KnRoaXMsICpib2R5LCAqcmVuZGVyVmlldygpLCBib2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsK K30KKyNlbmRpZgorCiBib29sIEZyYW1lVmlldzo6Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhp c0ZyYW1lKEZyYW1lKiByb290RnJhbWVGb3JGbHVzaCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5k ZXJWaWV3ID0gdGhpcy0+cmVuZGVyVmlldygpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXgg ZGJlOWQ1ZGE4Yzc0MGY5ODE3YTNiNDkzOWZiZmU3OGJlNDA0ZTUzMS4uOTc4ZjU0NDk4YmE5ODM2 YWMyMjMzOTRjYmNiOGU3NzAzMWFlZTZkZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9GcmFtZVZpZXcuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC00 OTYsNiArNDk2LDEwIEBAIHB1YmxpYzoKICAgICB2b2lkIHNldEV4cG9zZWRSZWN0KEZsb2F0UmVj dCk7CiAgICAgRmxvYXRSZWN0IGV4cG9zZWRSZWN0KCkgY29uc3QgeyByZXR1cm4gbV9leHBvc2Vk UmVjdDsgfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQg dXBkYXRlU25hcE9mZnNldHMoKSBvdmVycmlkZTsKKyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAg dmlydHVhbCBib29sIHNjcm9sbENvbnRlbnRzRmFzdFBhdGgoY29uc3QgSW50U2l6ZSYgc2Nyb2xs RGVsdGEsIGNvbnN0IEludFJlY3QmIHJlY3RUb1Njcm9sbCwgY29uc3QgSW50UmVjdCYgY2xpcFJl Y3QpIG92ZXJyaWRlOwogICAgIHZpcnR1YWwgdm9pZCBzY3JvbGxDb250ZW50c1Nsb3dQYXRoKGNv bnN0IEludFJlY3QmIHVwZGF0ZVJlY3QpIG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uNjFkZjU4NmFmNjYyZDBjMWU3NzM5M2RiY2EyMGFjMWUzNjU2NDU1OAotLS0gL2Rldi9udWxs CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5jcHAKQEAgLTAsMCArMSwxNDIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycK KyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisg KiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgiCisKKyNpbmNsdWRlICJFbGVtZW50 LmgiCisjaW5jbHVkZSAiSFRNTENvbGxlY3Rpb24uaCIKKyNpbmNsdWRlICJIVE1MRWxlbWVudC5o IgorI2luY2x1ZGUgIlJlbmRlckJveC5oIgorI2luY2x1ZGUgIlNjcm9sbGFibGVBcmVhLmgiCisK KyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bh c3NPd25QdHI8QXhpc1Njcm9sbFNuYXBPZmZzZXRzPiBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmNy ZWF0ZSgpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBeGlzU2Nyb2xsU25hcE9mZnNldHMo KSk7Cit9CisKK3ZvaWQgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjp1cGRhdGVTbmFwT2Zmc2V0c0Zv clNjcm9sbGFibGVBcmVhKFNjcm9sbGFibGVBcmVhJiBzY3JvbGxhYmxlQXJlYSwgSFRNTEVsZW1l bnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNvbnN0IFJlbmRlckJveCYgYm94LCBjb25zdCBSZW5kZXJT dHlsZSYgc3R5bGUpCit7CisgICAgaWYgKHN0eWxlLnNjcm9sbFNuYXBUeXBlKCkgPT0gU2Nyb2xs U25hcFR5cGU6Ok5vbmUpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBMYXlvdXRVbml0IHZp ZXdXaWR0aCA9IGJveC53aWR0aCgpOworICAgIExheW91dFVuaXQgdmlld0hlaWdodCA9IGJveC5o ZWlnaHQoKTsKKyAgICBMYXlvdXRVbml0IHNjcm9sbFdpZHRoID0gYm94LnNjcm9sbFdpZHRoKCk7 CisgICAgTGF5b3V0VW5pdCBzY3JvbGxIZWlnaHQgPSBib3guc2Nyb2xsSGVpZ2h0KCk7CisgICAg Ym9vbCBjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gc2Nyb2xsV2lkdGggPiAwICYmIHZp ZXdXaWR0aCA+IDAgJiYgdmlld1dpZHRoIDwgc2Nyb2xsV2lkdGg7CisgICAgYm9vbCBjb21wdXRl VmVydGljYWxTbmFwT2Zmc2V0cyA9IHNjcm9sbEhlaWdodCA+IDAgJiYgdmlld0hlaWdodCA+IDAg JiYgdmlld0hlaWdodCA8IHNjcm9sbEhlaWdodDsKKyAgICBpZiAoIWNvbXB1dGVIb3Jpem9udGFs U25hcE9mZnNldHMgJiYgIWNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRzKQorICAgICAgICByZXR1 cm47CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1 ZW5jZTsKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVu Y2U7CisgICAgaWYgKHN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkgfHwgc3R5bGUuc2Ny b2xsU25hcFVzZXNFbGVtZW50c1koKSkKKyAgICAgICAgQXhpc1Njcm9sbFNuYXBPZmZzZXRzOjph cHBlbmRDaGlsZFNuYXBPZmZzZXRzKHNjcm9sbGluZ0VsZW1lbnQsIGNvbXB1dGVIb3Jpem9udGFs U25hcE9mZnNldHMsIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UsIGNvbXB1dGVWZXJ0 aWNhbFNuYXBPZmZzZXRzLCB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisKKyAgICBp ZiAoY29tcHV0ZUhvcml6b250YWxTbmFwT2Zmc2V0cykgeworICAgICAgICBpZiAoIXN0eWxlLnNj cm9sbFNuYXBVc2VzRWxlbWVudHNYKCkpIHsKKyAgICAgICAgICAgIGZvciAoTGVuZ3RoIHNuYXBM ZW5ndGggOiBzdHlsZS5zY3JvbGxTbmFwT2Zmc2V0c1goKSkKKyAgICAgICAgICAgICAgICBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVu Z3RoLCB2aWV3V2lkdGgpKTsKKyAgICAgICAgfQorICAgICAgICBpZiAoIWhvcml6b250YWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuYXhpc1Nj cm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCktPnVwZGF0ZUZyb21T dHlsZShzdHlsZSwgU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsLCB2aWV3V2lkdGgsIHNjcm9s bFdpZHRoLCBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAgICB9CisgICAgaWYg KGNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRzKSB7CisgICAgICAgIGlmICghc3R5bGUuc2Nyb2xs U25hcFVzZXNFbGVtZW50c1koKSkgeworICAgICAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0 aCA6IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRzWSgpKQorICAgICAgICAgICAgICAgIHZlcnRpY2Fs U25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2 aWV3SGVpZ2h0KSk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCF2ZXJ0aWNhbFNuYXBPZmZzZXRT dWJzZXF1ZW5jZS5zaXplKCkpCisgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1 ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuYXhpc1Njcm9sbFNuYXBP ZmZzZXRzKFNjcm9sbEV2ZW50QXhpczo6VmVydGljYWwpLT51cGRhdGVGcm9tU3R5bGUoc3R5bGUs IFNjcm9sbEV2ZW50QXhpczo6VmVydGljYWwsIHZpZXdIZWlnaHQsIHNjcm9sbEhlaWdodCwgdmVy dGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOworICAgIH0KK30KKwordm9pZCBBeGlzU2Nyb2xs U25hcE9mZnNldHM6OmFwcGVuZENoaWxkU25hcE9mZnNldHMoSFRNTEVsZW1lbnQmIHBhcmVudCwg Ym9vbCBjb21wdXRlSG9yaXpvbnRhbCwgVmVjdG9yPExheW91dFVuaXQ+JiBob3Jpem9udGFsU25h cE9mZnNldFN1YnNlcXVlbmNlLCBib29sIGNvbXB1dGVWZXJ0aWNhbCwgVmVjdG9yPExheW91dFVu aXQ+JiB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBFbGVtZW50KiBjaGls ZCA9IHBhcmVudC5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAgICAvLyBGSVhNRTog SW5zdGVhZCBvZiB0cmF2ZXJzaW5nIGFsbCBjaGlsZHJlbiwgcmVnaXN0ZXIgY2hpbGRyZW4gd2l0 aCBzbmFwIGNvb3JkaW5hdGVzIGJlZm9yZSBhcHBlbmRpbmcgdG8gc25hcE9mZnNldFN1YnNlcXVl bmNlLgorICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoUmVuZGVyQm94KiBib3ggPSBj aGlsZC0+cmVuZGVyQm94KCkpIHsKKyAgICAgICAgICAgIExheW91dFVuaXQgdmlld1dpZHRoID0g Ym94LT53aWR0aCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCB2aWV3SGVpZ2h0ID0gYm94LT5o ZWlnaHQoKTsKKyAgICAgICAgICAgIExheW91dFVuaXQgcG9zaXRpb25YID0gYm94LT54KCk7Cisg ICAgICAgICAgICBMYXlvdXRVbml0IHBvc2l0aW9uWSA9IGJveC0+eSgpOworICAgICAgICAgICAg Zm9yIChTbmFwQ29vcmRpbmF0ZSBjb29yZGluYXRlIDogYm94LT5zdHlsZSgpLnNjcm9sbFNuYXBD b29yZGluYXRlcygpKSB7CisgICAgICAgICAgICAgICAgTGF5b3V0VW5pdCBsYXN0UG90ZW50aWFs U25hcFBvc2l0aW9uWCA9IHBvc2l0aW9uWCArIHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuZmly c3QsIHZpZXdXaWR0aCk7CisgICAgICAgICAgICAgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsICYm IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25YID4gMCkKKyAgICAgICAgICAgICAgICAgICAgaG9y aXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3Np dGlvblgpOworICAgICAgICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3Np dGlvblkgPSBwb3NpdGlvblkgKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLnNlY29uZCwgdmll d0hlaWdodCk7CisgICAgICAgICAgICAgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbCAmJiBsYXN0UG90 ZW50aWFsU25hcFBvc2l0aW9uWSA+IDApCisgICAgICAgICAgICAgICAgICAgIHZlcnRpY2FsU25h cE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWSk7Cisg ICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEVsZW1l bnRTaWJsaW5nKCk7CisgICAgfQorfQorCit2b2lkIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6dXBk YXRlRnJvbVN0eWxlKGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSwgU2Nyb2xsRXZlbnRBeGlzIGF4 aXMsIExheW91dFVuaXQgdmlld1NpemUsIExheW91dFVuaXQgc2Nyb2xsU2l6ZSwgY29uc3QgVmVj dG9yPExheW91dFVuaXQ+JiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UpCit7CisgICAgYm9vbCBpc0hv cml6b250YWxBeGlzID0gYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWw7CisgICAg Ym9vbCBoYXNSZXBlYXQgPSBpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcEhhc1Jl cGVhdFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRZKCk7CisgICAgTGF5b3V0VW5pdCBy ZXBlYXRPZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Ny b2xsU25hcFJlcGVhdE9mZnNldFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZKCks IHZpZXdTaXplKTsKKyAgICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0ID0gdmFsdWVGb3JM ZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblgoKSA6 IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgdmlld1NpemUpOworICAgIExheW91dFVu aXQgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSAwOworICAgIExheW91dFVuaXQgbWF4U2Nyb2xsT2Zm c2V0ID0gc2Nyb2xsU2l6ZSAtIHZpZXdTaXplOworICAgIExheW91dFVuaXQgbGFzdFNuYXBQb3Np dGlvbiA9IGN1clNuYXBQb3NpdGlvblNoaWZ0OworICAgIExheW91dFVuaXQgcG90ZW50aWFsU25h cFBvc2l0aW9uOworICAgIG1fb2Zmc2V0cy5jbGVhcigpOworICAgIG1fb2Zmc2V0cy5hcHBlbmQo MCk7CisgICAgZG8geworICAgICAgICBmb3IgKExheW91dFVuaXQgc25hcFBvc2l0aW9uIDogc25h cE9mZnNldFN1YnNlcXVlbmNlKSB7CisgICAgICAgICAgICBwb3RlbnRpYWxTbmFwUG9zaXRpb24g PSBjdXJTbmFwUG9zaXRpb25TaGlmdCArIHNuYXBQb3NpdGlvbiAtIGRlc3RpbmF0aW9uT2Zmc2V0 OworICAgICAgICAgICAgaWYgKHBvdGVudGlhbFNuYXBQb3NpdGlvbiA8PSAwKQorICAgICAgICAg ICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9u ID49IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAgICAgICAgICBicmVhazsKKworICAgICAgICAg ICAgbV9vZmZzZXRzLmFwcGVuZChwb3RlbnRpYWxTbmFwUG9zaXRpb24pOworICAgICAgICAgICAg bGFzdFNuYXBQb3NpdGlvbiA9IHBvdGVudGlhbFNuYXBQb3NpdGlvbiArIGRlc3RpbmF0aW9uT2Zm c2V0OworICAgICAgICB9CisgICAgICAgIGN1clNuYXBQb3NpdGlvblNoaWZ0ID0gbGFzdFNuYXBQ b3NpdGlvbiArIHJlcGVhdE9mZnNldDsKKyAgICB9IHdoaWxlIChoYXNSZXBlYXQgJiYgY3VyU25h cFBvc2l0aW9uU2hpZnQgPCBtYXhTY3JvbGxPZmZzZXQpOworICAgIC8vIEFsd2F5cyBwdXQgYSBz bmFwIHBvaW50IG9uIHRoZSBtYXhpbXVtIHNjcm9sbCBvZmZzZXQuCisgICAgLy8gTm90IGEgcGFy dCBvZiB0aGUgc3BlYywgYnV0IG5lY2Vzc2FyeSB0byBwcmV2ZW50IHVucmVhY2hhYmxlIGNvbnRl bnQgd2hlbiBzbmFwcGluZy4KKyAgICBpZiAobV9vZmZzZXRzLmxhc3QoKSAhPSBtYXhTY3JvbGxP ZmZzZXQpCisgICAgICAgIG1fb2Zmc2V0cy5hcHBlbmQobWF4U2Nyb2xsT2Zmc2V0KTsKK30KKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNl dHMuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjIxYTdkMzBhMzRjMWJiZjJmNDg1N2I5MThkNmU5MWQ2YmY0OTFkZTEK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Ny b2xsU25hcE9mZnNldHMuaApAQCAtMCwwICsxLDU5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMg YGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRS SUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBB eGlzU2Nyb2xsU25hcE9mZnNldHNfaAorI2RlZmluZSBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAor CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKworI2luY2x1ZGUgIkxheW91dFVuaXQuaCIK KyNpbmNsdWRlICJTY3JvbGxUeXBlcy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+Cisj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEhU TUxFbGVtZW50OworY2xhc3MgUmVuZGVyQm94OworY2xhc3MgUmVuZGVyU3R5bGU7CitjbGFzcyBT Y3JvbGxhYmxlQXJlYTsKKworY2xhc3MgQXhpc1Njcm9sbFNuYXBPZmZzZXRzIHsKK3B1YmxpYzoK KyAgICBzdGF0aWMgUGFzc093blB0cjxBeGlzU2Nyb2xsU25hcE9mZnNldHM+IGNyZWF0ZSgpOwor ICAgIHN0YXRpYyB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoU2Nyb2xs YWJsZUFyZWEmLCBIVE1MRWxlbWVudCYgc2Nyb2xsaW5nRWxlbWVudCwgY29uc3QgUmVuZGVyQm94 JiwgY29uc3QgUmVuZGVyU3R5bGUmKTsKKworcHJpdmF0ZToKKyAgICBzdGF0aWMgdm9pZCBhcHBl bmRDaGlsZFNuYXBPZmZzZXRzKEhUTUxFbGVtZW50JiBwYXJlbnQsIGJvb2wgY29tcHV0ZUhvcml6 b250YWwsIFZlY3RvcjxMYXlvdXRVbml0PiYgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZSwgYm9vbCBjb21wdXRlVmVydGljYWwsIFZlY3RvcjxMYXlvdXRVbml0PiYgdmVydGljYWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2UpOworICAgIHZvaWQgdXBkYXRlRnJvbVN0eWxlKGNvbnN0IFJlbmRl clN0eWxlJiwgU2Nyb2xsRXZlbnRBeGlzLCBMYXlvdXRVbml0IHZpZXdTaXplLCBMYXlvdXRVbml0 IHNjcm9sbFNpemUsIGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYgc25hcE9mZnNldFN1YnNlcXVl bmNlKTsKKworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBtX29mZnNldHM7Cit9OworCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDU1NfU0NST0xMX1NOQVAKKworI2VuZGlmIC8v IEF4aXNTY3JvbGxTbmFwT2Zmc2V0c19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxh YmxlQXJlYS5jcHAKaW5kZXggYzdkOTQ5NDU0NzExZjgzYzZiZDdiYjUxMGNiMjMxYzg5MTI4MDEw MC4uMmY1MjNhY2FhMWEzOTFmNDM5ZjllYjM2NjUzNzYwNjFkY2RmNjA0OCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcApAQCAtMzIsNiArMzIsOSBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIlNjcm9sbGFibGVBcmVhLmgiCiAKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIgor I2VuZGlmCiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NM YXllci5oIgogI2luY2x1ZGUgIkZsb2F0UG9pbnQuaCIKQEAgLTQ2LDYgKzQ5LDEwIEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIHN0cnVjdCBTYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewogICAgIHZp cnR1YWwgflNhbWVTaXplQXNTY3JvbGxhYmxlQXJlYSgpOwogICAgIHZvaWQqIHBvaW50ZXI7Cisj aWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2b2lkKiBob3Jpem9udGFsU25hcE9mZnNl dHNQb2ludGVyOworICAgIHZvaWQqIHZlcnRpY2FsU25hcE9mZnNldHNQb2ludGVyOworI2VuZGlm CiAgICAgSW50UG9pbnQgb3JpZ2luOwogICAgIHVuc2lnbmVkIGJpdGZpZWxkcyA6IDE2OwogfTsK QEAgLTE3OCw2ICsxODUsMjIgQEAgYm9vbCBTY3JvbGxhYmxlQXJlYTo6aGFuZGxlV2hlZWxFdmVu dChjb25zdCBQbGF0Zm9ybVdoZWVsRXZlbnQmIHdoZWVsRXZlbnQpCiAgICAgcmV0dXJuIHNjcm9s bEFuaW1hdG9yKCktPmhhbmRsZVdoZWVsRXZlbnQod2hlZWxFdmVudCk7CiB9CiAKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorQXhpc1Njcm9sbFNuYXBPZmZzZXRzKiBTY3JvbGxhYmxlQXJl YTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2ZW50QXhpcyBheGlzKQoreworICAgIGlm IChheGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbCkgeworICAgICAgICBpZiAoIW1f aG9yaXpvbnRhbFNuYXBPZmZzZXRzKQorICAgICAgICAgICAgbV9ob3Jpem9udGFsU25hcE9mZnNl dHMgPSBBeGlzU2Nyb2xsU25hcE9mZnNldHM6OmNyZWF0ZSgpOworCisgICAgICAgIHJldHVybiBt X2hvcml6b250YWxTbmFwT2Zmc2V0cy5nZXQoKTsKKyAgICB9CisgICAgaWYgKCFtX3ZlcnRpY2Fs U25hcE9mZnNldHMpCisgICAgICAgIG1fdmVydGljYWxTbmFwT2Zmc2V0cyA9IEF4aXNTY3JvbGxT bmFwT2Zmc2V0czo6Y3JlYXRlKCk7CisKKyAgICByZXR1cm4gbV92ZXJ0aWNhbFNuYXBPZmZzZXRz LmdldCgpOworfQorI2VuZGlmCisKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogYm9vbCBTY3Jv bGxhYmxlQXJlYTo6aGFuZGxlVG91Y2hFdmVudChjb25zdCBQbGF0Zm9ybVRvdWNoRXZlbnQmIHRv dWNoRXZlbnQpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxh YmxlQXJlYS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaAppbmRl eCAyZmUyNzQ5MTQ1MjhmYTUwN2EzMThhNDVlYTkxMDA2ZTFlMjg0ZjFiLi4xNjM5MjM2M2U4ZTI1 OGQyMDcyZWQ2YjQ5NjY2YjU1ZGE4Yzk5N2JmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmgKQEAgLTMxLDYgKzMxLDkgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK2NsYXNzIEF4aXNTY3JvbGxTbmFwT2Zmc2V0 czsKKyNlbmRpZgogY2xhc3MgRmxvYXRQb2ludDsKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDsKIGNs YXNzIExheW91dFBvaW50OwpAQCAtNTgsNiArNjEsMTEgQEAgcHVibGljOgogCiAgICAgYm9vbCBo YW5kbGVXaGVlbEV2ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYpOwogCisjaWYgRU5BQkxF KENTU19TQ1JPTExfU05BUCkKKyAgICBBeGlzU2Nyb2xsU25hcE9mZnNldHMqIGF4aXNTY3JvbGxT bmFwT2Zmc2V0cyhTY3JvbGxFdmVudEF4aXMpOworICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFw T2Zmc2V0cygpIHsgfTsKKyNlbmRpZgorCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICAgICB2 aXJ0dWFsIGJvb2wgaXNUb3VjaFNjcm9sbGFibGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQog ICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91Y2hFdmVu dCYpOwpAQCAtMjc1LDYgKzI4MywxMSBAQCBwcml2YXRlOgogCiAgICAgbXV0YWJsZSBPd25QdHI8 U2Nyb2xsQW5pbWF0b3I+IG1fc2Nyb2xsQW5pbWF0b3I7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQorICAgIE93blB0cjxBeGlzU2Nyb2xsU25hcE9mZnNldHM+IG1faG9yaXpvbnRhbFNu YXBPZmZzZXRzOworICAgIE93blB0cjxBeGlzU2Nyb2xsU25hcE9mZnNldHM+IG1fdmVydGljYWxT bmFwT2Zmc2V0czsKKyNlbmRpZgorCiAgICAgLy8gVGhlcmUgYXJlIDggcG9zc2libGUgY29tYmlu YXRpb25zIG9mIHdyaXRpbmcgbW9kZSBhbmQgZGlyZWN0aW9uLiBTY3JvbGwgb3JpZ2luIHdpbGwg YmUgbm9uLXplcm8gaW4gdGhlIHggb3IgeSBheGlzCiAgICAgLy8gaWYgdGhlcmUgaXMgYW55IHJl dmVyc2VkIGRpcmVjdGlvbiBvciB3cml0aW5nLW1vZGUuIFRoZSBjb21iaW5hdGlvbnMgYXJlOgog ICAgIC8vIHdyaXRpbmctbW9kZSAvIGRpcmVjdGlvbiAgICAgc2Nyb2xsT3JpZ2luLngoKSBzZXQg ICAgc2Nyb2xsT3JpZ2luLnkoKSBzZXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJMYXllci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5 ZXIuY3BwCmluZGV4IDA0MjRlY2I4NWVkOGU3YjMyYjYwMTAwYTllMGVmYzIxMmM4ZTU0ZWMuLjQ2 NjEyNTVjOTQ1MDdkNTRiZWYyM2Q4YjkxZTU3YmYyOWYzY2RiZjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcApAQCAtMTIyLDYgKzEyMiwxMCBAQAogI2luY2x1ZGUg IlJlbmRlckxheWVyRmlsdGVySW5mby5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIgorI2VuZGlmCisKICNk ZWZpbmUgTUlOX0lOVEVSU0VDVF9GT1JfUkVWRUFMIDMyCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTMwMjksNiArMzAzMywxOCBAQCBTY3JvbGxhYmxlQXJlYSogUmVuZGVyTGF5ZXI6OmVuY2xv c2luZ1Njcm9sbGFibGVBcmVhKCkgY29uc3QKICAgICByZXR1cm4gMDsKIH0KIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCit2b2lkIFJlbmRlckxheWVyOjp1cGRhdGVTbmFwT2Zmc2V0cygp Cit7CisgICAgLy8gRklYTUU6IEV4dGVuZCBzdXBwb3J0IGJleW9uZCBIVE1MRWxlbWVudHMuCisg ICAgaWYgKCFlbmNsb3NpbmdFbGVtZW50KCkgfHwgIWVuY2xvc2luZ0VsZW1lbnQoKS0+cmVuZGVy Qm94KCkgfHwgIWVuY2xvc2luZ0VsZW1lbnQoKS0+aXNIVE1MRWxlbWVudCgpKQorICAgICAgICBy ZXR1cm47CisgICAgCisgICAgUmVuZGVyQm94KiBib3ggPSBlbmNsb3NpbmdFbGVtZW50KCktPnJl bmRlckJveCgpOworICAgIEF4aXNTY3JvbGxTbmFwT2Zmc2V0czo6dXBkYXRlU25hcE9mZnNldHNG b3JTY3JvbGxhYmxlQXJlYSgqdGhpcywgKnRvSFRNTEVsZW1lbnQoZW5jbG9zaW5nRWxlbWVudCgp KSwgKmJveCwgYm94LT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBpbnQgUmVuZGVyTGF5ZXI6OnZl cnRpY2FsU2Nyb2xsYmFyV2lkdGgoT3ZlcmxheVNjcm9sbGJhclNpemVSZWxldmFuY3kgcmVsZXZh bmN5KSBjb25zdAogewogICAgIGlmICghbV92QmFyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJMYXllci5oCmluZGV4IDI2NjU1OWFmZmI4Y2ZhMDg4YzBlYWMwMzhmZDZlYjdjOWY4YjFmNDcu LmJkMjYxYTdhNDk4N2U3MTQ3ZjAyYWJkMzVjODAyMzQzYWZkMDRjM2MgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMYXllci5oCkBAIC00MzksNiArNDM5LDkgQEAgcHVibGljOgogICAg IHZpcnR1YWwgU2Nyb2xsYmFyKiBob3Jpem9udGFsU2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUg eyByZXR1cm4gbV9oQmFyLmdldCgpOyB9CiAgICAgdmlydHVhbCBTY3JvbGxiYXIqIHZlcnRpY2Fs U2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4gbV92QmFyLmdldCgpOyB9CiAgICAg dmlydHVhbCBTY3JvbGxhYmxlQXJlYSogZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBjb25zdCBv dmVycmlkZTsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZpcnR1YWwgdm9pZCB1 cGRhdGVTbmFwT2Zmc2V0cygpIG92ZXJyaWRlOworI2VuZGlmCiAKICNpZiBQTEFURk9STShJT1Mp CiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykK 236482 2014-08-12 16:33:36 -0700 2014-08-13 14:05:04 -0700 Patch bug-135268-20140812163325.patch text/plain 23388 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYjg0MWMyZjczNGVmNzUy MDRjMTJlYTNhZDk5ODgwZDk0OGY5ZjEzMi4uZWU3MjE0YTEwMTI4MzQ2YmVhYzIxNmQ5NTk0MmQz ZGM1NDFjMzkwMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisyMDE0LTA4LTEyICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMpOiBJbnZva2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Ny b2xsU25hcE9mZnNldHMgdG8gdXBkYXRlIHNuYXAgb2Zmc2V0cyBmb3IgbWFpbmZyYW1lLgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjphcHBlbmRBbmRT b3J0Q2hpbGRTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVGcm9tU3R5bGUp OgorICAgICAgICAoV2ViQ29yZTo6dXBkYXRlSG9yaXpvbnRhbFZlcnRpY2FsU25hcE9mZnNldHMp OiBVcGRhdGUgdGhlIFNjcm9sbGFibGVBcmVhJ3Mgc25hcCBheGVzLgorICAgICAgICAqIHBhZ2Uv c2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0 Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJl YTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyB0aGUgU2Nyb2xsYWJsZUFyZWEncyBz bmFwIG9mZnNldHMgaW4gdGhlIGdpdmVuIGF4aXMuCisgICAgICAgICogcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1cGRhdGVTbmFw T2Zmc2V0cyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlJlbmRlckxheWVyOjp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0 YXRpYyByb3V0aW5lIGluIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZz ZXRzIGZvciBhbiBvdmVyZmxvdyBhcmVhLgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXll ci5oOgorCiAyMDE0LTA4LTEyICBDb21taXQgUXVldWUgIDxjb21taXQtcXVldWVAd2Via2l0Lm9y Zz4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTcyNDk0LgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGEyOGVl MWEzZDMxMjFlMDk1ZGY5YTllNTA1MDc4ZGM0Yjk2MWFmN2EuLmYwYWEwNDFkY2IyN2JlM2U4MmY4 OGNiOGFkMTY2MzhmODU1Mzk1ZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTYyNDUsNiArNjI0NSw4IEBACiAJCUYzRjVDRjEx MTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4 MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3RydW1lbnRhdGlvbi5oICovOyB9Owog CQlGM0Y1Q0YxMzEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50 YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEYz RjVDRjEyMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlv bi5oICovOyB9OwogCQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0Lmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDJGRkI0NTE5 ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggKi87IH07CisJCUY0NUMyMzFEMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8q IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi87IH07CisJCUY0NUMyMzFFMTk5NUI3M0IwMEE2 RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Ny b2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9p bnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdB NUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggKi87IHNldHRp bmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ3QTVFM0YxOTVCOEU0 ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyog U3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKIAkJRjUwNjY0RjcxNTdGNTJEQzAwQUMy MjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3JtQ29udHJvbGxl ci5jcHAgKi87IH07CkBAIC0xMzc2Miw2ICsxMzc2NCw4IEBACiAJCUYzRjVDRjEwMTJFRDgxQTgw MDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckNvbnNvbGVJbnN0cnVtZW50YXRpb24uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8q IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhS ZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoUmVwZWF0Lmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAv KiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNl dHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0ExOTVCOEM4QTAwNDgz MTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwOyBwYXRoID0gc3R5bGUvU3R5 bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3 QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaDsgcGF0aCA9 IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9ybUNvbnRyb2xsZXIuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9ybUNvbnRyb2xsZXIuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTUxMzcsNiArMTUxNDEsOCBAQAogCQkJCTkzOTFB OTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVlU2Nyb2xsaW5nTm9kZS5oICovLAog CQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3Bw ICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJlYWRlZFNjcm9sbGluZ1Ry ZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBP ZmZzZXRzLmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9IHNjcm9sbGluZzsKIAkJCXNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQxOSw2ICsyNDQyNSw3IEBACiAJCQkJQTgxMzY5RTAw OTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJ CQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJRWxlbWVudC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8qIEhUTUxMaW5rRWxlbWVudC5oIGlu IEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxT bmFwT2Zmc2V0cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThFQTdEMkMwQTE5Mzg1NTAwQThFRjVG IC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBN0NBQjBBMTkyQjlD MDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlFNDQ2 MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxlbWVudC5oIGluIEhlYWRlcnMgKi8s CkBAIC0yNzc1NCw2ICsyNzc2MSw3IEBACiAJCQkJQjJBRkZDN0QwRDAwQTVDMTAwMzAwNzREIC8q IEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzcxRjRGNDEw RDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3QUND RjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRpb24uY3BwIGluIFNvdXJjZXMgKi8s CisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5j cHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAyMkZFMDBBMDdFMjAgLyogRm9udEZh c3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5RkM3MTNDMTdENTcwMDQ2QTdGOCAv KiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUU0NEVFM0E4MTc1 NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVzLmNwcCBpbiBTb3VyY2VzICovLApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dl YkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDM4MTA3MWQ4NzA0NTEwMjE2NzU4OTI0Mjlm ZGE0ODlhODQyNTU3ZjkuLmZhYzhmYjk4OTJmNjk3ODRmMTQ2NTRlMjQ2YmY3OWQyNjRjMWYyN2Ig MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTk4LDYgKzk4LDEwIEBACiAjaW5jbHVk ZSAiVGV4dEF1dG9zaXplci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIgorI2VuZGlmCisKICNpZiBQTEFU Rk9STShJT1MpCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIuaCIKICNpbmNsdWRlICJMZWdhY3lU aWxlQ2FjaGUuaCIKQEAgLTg0Nyw2ICs4NTEsMjcgQEAgR3JhcGhpY3NMYXllciogRnJhbWVWaWV3 OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3ZlckhhbmdBcmVhKGJvb2wgd2FudHNMYXllcikgY28K IAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJfQkFORElORykKIAorI2lmIEVOQUJMRShDU1NfU0NS T0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6dXBkYXRlU25hcE9mZnNldHMoKQoreworICAgIGlm ICghZnJhbWUoKS5kb2N1bWVudCgpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBGSVhNRTog U2hvdWxkIHdlIGFsbG93IHNwZWNpZnlpbmcgc25hcCBwb2ludHMgdGhyb3VnaCA8aHRtbD4gdGFn cyB0b28/CisgICAgSFRNTEVsZW1lbnQqIGJvZHkgPSBmcmFtZSgpLmRvY3VtZW50KCktPmJvZHko KTsKKyAgICBpZiAoIWJvZHkgfHwgIWJvZHktPnJlbmRlcmVyKCkgfHwgIXJlbmRlclZpZXcoKSkK KyAgICAgICAgcmV0dXJuOworICAgIAorICAgIGlmICghbV9ob3Jpem9udGFsU25hcE9mZnNldHMp CisgICAgICAgIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gYWRvcHRQdHIobmV3IFZlY3RvcjxM YXlvdXRVbml0Pik7CisKKyAgICBpZiAoIW1fdmVydGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAg bV92ZXJ0aWNhbFNuYXBPZmZzZXRzID0gYWRvcHRQdHIobmV3IFZlY3RvcjxMYXlvdXRVbml0Pik7 CisKKyAgICB1cGRhdGVIb3Jpem9udGFsVmVydGljYWxTbmFwT2Zmc2V0cygqbV9ob3Jpem9udGFs U25hcE9mZnNldHMuZ2V0KCksICptX3ZlcnRpY2FsU25hcE9mZnNldHMuZ2V0KCksICpib2R5LCAq cmVuZGVyVmlldygpLCBib2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBi b29sIEZyYW1lVmlldzo6Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhpc0ZyYW1lKEZyYW1lKiBy b290RnJhbWVGb3JGbHVzaCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5kZXJWaWV3ID0gdGhpcy0+ cmVuZGVyVmlldygpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu aCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXggZGJlOWQ1ZGE4Yzc0MGY5 ODE3YTNiNDkzOWZiZmU3OGJlNDA0ZTUzMS4uOTc4ZjU0NDk4YmE5ODM2YWMyMjMzOTRjYmNiOGU3 NzAzMWFlZTZkZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC00OTYsNiArNDk2LDEwIEBA IHB1YmxpYzoKICAgICB2b2lkIHNldEV4cG9zZWRSZWN0KEZsb2F0UmVjdCk7CiAgICAgRmxvYXRS ZWN0IGV4cG9zZWRSZWN0KCkgY29uc3QgeyByZXR1cm4gbV9leHBvc2VkUmVjdDsgfQogCisjaWYg RU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNl dHMoKSBvdmVycmlkZTsKKyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAgdmlydHVhbCBib29sIHNj cm9sbENvbnRlbnRzRmFzdFBhdGgoY29uc3QgSW50U2l6ZSYgc2Nyb2xsRGVsdGEsIGNvbnN0IElu dFJlY3QmIHJlY3RUb1Njcm9sbCwgY29uc3QgSW50UmVjdCYgY2xpcFJlY3QpIG92ZXJyaWRlOwog ICAgIHZpcnR1YWwgdm9pZCBzY3JvbGxDb250ZW50c1Nsb3dQYXRoKGNvbnN0IEludFJlY3QmIHVw ZGF0ZVJlY3QpIG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3Jv bGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Ny b2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMmNmZGM0YThhM2Qz ZTY0Mjg2NDZhYmExOWZlZmUyYzNlODBmOTllYQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKQEAgLTAsMCAr MSwxNDcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S CisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgor ICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXhp c1Njcm9sbFNuYXBPZmZzZXRzLmgiCisKKyNpbmNsdWRlICJIVE1MQ29sbGVjdGlvbi5oIgorI2lu Y2x1ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94LmgiCisKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyB2b2lk IGFwcGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKEhUTUxFbGVtZW50JiBwYXJlbnQsIGJvb2wg Y29tcHV0ZUhvcml6b250YWwsIFZlY3RvcjxMYXlvdXRVbml0PiYgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZSwgYm9vbCBjb21wdXRlVmVydGljYWwsIFZlY3RvcjxMYXlvdXRVbml0PiYg dmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpCit7CisgICAgRWxlbWVudCogY2hpbGQgPSBw YXJlbnQuY2hpbGRyZW4oKS0+Y29sbGVjdGlvbkJlZ2luKCk7CisgICAgLy8gRklYTUU6IEluc3Rl YWQgb2YgdHJhdmVyc2luZyBhbGwgY2hpbGRyZW4sIHJlZ2lzdGVyIGNoaWxkcmVuIHdpdGggc25h cCBjb29yZGluYXRlcyBiZWZvcmUgYXBwZW5kaW5nIHRvIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZS4K KyAgICB3aGlsZSAoY2hpbGQpIHsKKyAgICAgICAgaWYgKFJlbmRlckJveCogYm94ID0gY2hpbGQt PnJlbmRlckJveCgpKSB7CisgICAgICAgICAgICBMYXlvdXRVbml0IHZpZXdXaWR0aCA9IGJveC0+ d2lkdGgoKTsKKyAgICAgICAgICAgIExheW91dFVuaXQgdmlld0hlaWdodCA9IGJveC0+aGVpZ2h0 KCk7CisgICAgICAgICAgICBGbG9hdFBvaW50IHBvc2l0aW9uID0gYm94LT5sb2NhbFRvQ29udGFp bmVyUG9pbnQoRmxvYXRQb2ludChib3gtPngoKSwgYm94LT55KCkpLCBwYXJlbnQucmVuZGVyQm94 KCkpOworICAgICAgICAgICAgTGF5b3V0VW5pdCBvZmZzZXRYID0gcG9zaXRpb24ueCgpOworICAg ICAgICAgICAgTGF5b3V0VW5pdCBvZmZzZXRZID0gcG9zaXRpb24ueSgpOworICAgICAgICAgICAg Zm9yIChTbmFwQ29vcmRpbmF0ZSBjb29yZGluYXRlIDogYm94LT5zdHlsZSgpLnNjcm9sbFNuYXBD b29yZGluYXRlcygpKSB7CisgICAgICAgICAgICAgICAgTGF5b3V0VW5pdCBsYXN0UG90ZW50aWFs U25hcFBvc2l0aW9uWCA9IG9mZnNldFggKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLmZpcnN0 LCB2aWV3V2lkdGgpOworICAgICAgICAgICAgICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbCAmJiBs YXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA+IDApCisgICAgICAgICAgICAgICAgICAgIGhvcml6 b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRp b25YKTsKKyAgICAgICAgICAgICAgICBMYXlvdXRVbml0IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRp b25ZID0gb2Zmc2V0WSArIHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuc2Vjb25kLCB2aWV3SGVp Z2h0KTsKKyAgICAgICAgICAgICAgICBpZiAoY29tcHV0ZVZlcnRpY2FsICYmIGxhc3RQb3RlbnRp YWxTbmFwUG9zaXRpb25ZID4gMCkKKyAgICAgICAgICAgICAgICAgICAgdmVydGljYWxTbmFwT2Zm c2V0U3Vic2VxdWVuY2UuYXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25ZKTsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0RWxlbWVudFNp YmxpbmcoKTsKKyAgICB9CisgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsKQorICAgICAgICBzdGQ6 OnNvcnQoaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigpLCBob3Jpem9udGFs U25hcE9mZnNldFN1YnNlcXVlbmNlLmVuZCgpKTsKKworICAgIGlmIChjb21wdXRlVmVydGljYWwp CisgICAgICAgIHN0ZDo6c29ydCh2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigp LCB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7Cit9CisKK3N0YXRpYyB2b2lk IHVwZGF0ZUZyb21TdHlsZShWZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBPZmZzZXRzLCBjb25zdCBS ZW5kZXJTdHlsZSYgc3R5bGUsIFNjcm9sbEV2ZW50QXhpcyBheGlzLCBMYXlvdXRVbml0IHZpZXdT aXplLCBMYXlvdXRVbml0IHNjcm9sbFNpemUsIGNvbnN0IFZlY3RvcjxMYXlvdXRVbml0PiYgc25h cE9mZnNldFN1YnNlcXVlbmNlKQoreworICAgIGJvb2wgaXNIb3Jpem9udGFsQXhpcyA9IGF4aXMg PT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsOworICAgIGJvb2wgaGFzUmVwZWF0ID0gaXNI b3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRYKCkgOiBzdHlsZS5zY3Jv bGxTbmFwSGFzUmVwZWF0WSgpOworICAgIExheW91dFVuaXQgcmVwZWF0T2Zmc2V0ID0gdmFsdWVG b3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRY KCkgOiBzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0WSgpLCB2aWV3U2l6ZSk7CisgICAgTGF5 b3V0VW5pdCBkZXN0aW5hdGlvbk9mZnNldCA9IHZhbHVlRm9yTGVuZ3RoKGlzSG9yaXpvbnRhbEF4 aXMgPyBzdHlsZS5zY3JvbGxTbmFwRGVzdGluYXRpb25YKCkgOiBzdHlsZS5zY3JvbGxTbmFwRGVz dGluYXRpb25ZKCksIHZpZXdTaXplKTsKKyAgICBMYXlvdXRVbml0IGN1clNuYXBQb3NpdGlvblNo aWZ0ID0gMDsKKyAgICBMYXlvdXRVbml0IG1heFNjcm9sbE9mZnNldCA9IHNjcm9sbFNpemUgLSB2 aWV3U2l6ZTsKKyAgICBMYXlvdXRVbml0IGxhc3RTbmFwUG9zaXRpb24gPSBjdXJTbmFwUG9zaXRp b25TaGlmdDsKKyAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbjsKKyAgICBzbmFw T2Zmc2V0cy5jbGVhcigpOworICAgIHNuYXBPZmZzZXRzLmFwcGVuZCgwKTsKKyAgICBkbyB7Cisg ICAgICAgIGZvciAoTGF5b3V0VW5pdCBzbmFwUG9zaXRpb24gOiBzbmFwT2Zmc2V0U3Vic2VxdWVu Y2UpIHsKKyAgICAgICAgICAgIHBvdGVudGlhbFNuYXBQb3NpdGlvbiA9IGN1clNuYXBQb3NpdGlv blNoaWZ0ICsgc25hcFBvc2l0aW9uIC0gZGVzdGluYXRpb25PZmZzZXQ7CisgICAgICAgICAgICBp ZiAocG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Nyb2xsT2Zm c2V0KQorICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBzbmFwT2Zmc2V0cy5h cHBlbmQocG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFwUG9zaXRp b24gPSBwb3RlbnRpYWxTbmFwUG9zaXRpb24gKyBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAg fQorICAgICAgICBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IGxhc3RTbmFwUG9zaXRpb24gKyByZXBl YXRPZmZzZXQ7CisgICAgfSB3aGlsZSAoaGFzUmVwZWF0ICYmIGN1clNuYXBQb3NpdGlvblNoaWZ0 IDwgbWF4U2Nyb2xsT2Zmc2V0KTsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2ludCBvbiB0 aGUgbWF4aW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIC8vIE5vdCBhIHBhcnQgb2YgdGhlIHNwZWMs IGJ1dCBuZWNlc3NhcnkgdG8gcHJldmVudCB1bnJlYWNoYWJsZSBjb250ZW50IHdoZW4gc25hcHBp bmcuCisgICAgaWYgKHNuYXBPZmZzZXRzLmxhc3QoKSAhPSBtYXhTY3JvbGxPZmZzZXQpCisgICAg ICAgIHNuYXBPZmZzZXRzLmFwcGVuZChtYXhTY3JvbGxPZmZzZXQpOworfQorCit2b2lkIHVwZGF0 ZUhvcml6b250YWxWZXJ0aWNhbFNuYXBPZmZzZXRzKFZlY3RvcjxMYXlvdXRVbml0PiYgaG9yaXpv bnRhbFNuYXBPZmZzZXRzLCBWZWN0b3I8TGF5b3V0VW5pdD4mIHZlcnRpY2FsU25hcE9mZnNldHMs IEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVtZW50LCBjb25zdCBSZW5kZXJCb3gmIGJveCwgY29u c3QgUmVuZGVyU3R5bGUmIHN0eWxlKQoreworICAgIGlmIChzdHlsZS5zY3JvbGxTbmFwVHlwZSgp ID09IFNjcm9sbFNuYXBUeXBlOjpOb25lKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgTGF5 b3V0VW5pdCB2aWV3V2lkdGggPSBib3gud2lkdGgoKTsKKyAgICBMYXlvdXRVbml0IHZpZXdIZWln aHQgPSBib3guaGVpZ2h0KCk7CisgICAgTGF5b3V0VW5pdCBzY3JvbGxXaWR0aCA9IGJveC5zY3Jv bGxXaWR0aCgpOworICAgIExheW91dFVuaXQgc2Nyb2xsSGVpZ2h0ID0gYm94LnNjcm9sbEhlaWdo dCgpOworICAgIGJvb2wgY29tcHV0ZUhvcml6b250YWxTbmFwT2Zmc2V0cyA9IHNjcm9sbFdpZHRo ID4gMCAmJiB2aWV3V2lkdGggPiAwICYmIHZpZXdXaWR0aCA8IHNjcm9sbFdpZHRoOworICAgIGJv b2wgY29tcHV0ZVZlcnRpY2FsU25hcE9mZnNldHMgPSBzY3JvbGxIZWlnaHQgPiAwICYmIHZpZXdI ZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPCBzY3JvbGxIZWlnaHQ7CisgICAgaWYgKCFjb21wdXRl SG9yaXpvbnRhbFNuYXBPZmZzZXRzICYmICFjb21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cykKKyAg ICAgICAgcmV0dXJuOworCisgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRzLmNsZWFyKCk7CisgICAg dmVydGljYWxTbmFwT2Zmc2V0cy5jbGVhcigpOworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlOworICAgIFZlY3RvcjxMYXlvdXRVbml0PiB2ZXJ0 aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZTsKKyAgICBpZiAoc3R5bGUuc2Nyb2xsU25hcFVzZXNF bGVtZW50c1goKSB8fCBzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgpKQorICAgICAgICBh cHBlbmRBbmRTb3J0Q2hpbGRTbmFwT2Zmc2V0cyhzY3JvbGxpbmdFbGVtZW50LCBjb21wdXRlSG9y aXpvbnRhbFNuYXBPZmZzZXRzLCBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBjb21w dXRlVmVydGljYWxTbmFwT2Zmc2V0cywgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOwor CisgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsU25hcE9mZnNldHMpIHsKKyAgICAgICAgaWYgKCFz dHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpKSB7CisgICAgICAgICAgICBmb3IgKExlbmd0 aCBzbmFwTGVuZ3RoIDogc3R5bGUuc2Nyb2xsU25hcE9mZnNldHNYKCkpCisgICAgICAgICAgICAg ICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVGb3JMZW5ndGgo c25hcExlbmd0aCwgdmlld1dpZHRoKSk7CisKKyAgICAgICAgICAgIHN0ZDo6c29ydChob3Jpem9u dGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLmJlZ2luKCksIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vi c2VxdWVuY2UuZW5kKCkpOworICAgICAgICB9CisgICAgICAgIGlmICghaG9yaXpvbnRhbFNuYXBP ZmZzZXRTdWJzZXF1ZW5jZS5zaXplKCkpCisgICAgICAgICAgICBob3Jpem9udGFsU25hcE9mZnNl dFN1YnNlcXVlbmNlLmFwcGVuZCgwKTsKKworICAgICAgICB1cGRhdGVGcm9tU3R5bGUoaG9yaXpv bnRhbFNuYXBPZmZzZXRzLCBzdHlsZSwgU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsLCB2aWV3 V2lkdGgsIHNjcm9sbFdpZHRoLCBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAg ICB9CisgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRzKSB7CisgICAgICAgIGlmICgh c3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSkgeworICAgICAgICAgICAgZm9yIChMZW5n dGggc25hcExlbmd0aCA6IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRzWSgpKQorICAgICAgICAgICAg ICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChz bmFwTGVuZ3RoLCB2aWV3SGVpZ2h0KSk7CisKKyAgICAgICAgICAgIHN0ZDo6c29ydCh2ZXJ0aWNh bFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigpLCB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1 ZW5jZS5lbmQoKSk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCF2ZXJ0aWNhbFNuYXBPZmZzZXRT dWJzZXF1ZW5jZS5zaXplKCkpCisgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1 ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgdXBkYXRlRnJvbVN0eWxlKHZlcnRpY2FsU25hcE9m ZnNldHMsIHN0eWxlLCBTY3JvbGxFdmVudEF4aXM6OlZlcnRpY2FsLCB2aWV3SGVpZ2h0LCBzY3Jv bGxIZWlnaHQsIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAgICB9Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRz LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMu aApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5lOTliNGIyZGYxODcyMzIwZjdjNWYyN2JlNTA5ZDIwZmE5ZDIwYTQ0Ci0t LSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmgKQEAgLTAsMCArMSw0OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx NCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXhp c1Njcm9sbFNuYXBPZmZzZXRzX2gKKyNkZWZpbmUgQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKKwor I2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKKyNpbmNsdWRlICJMYXlvdXRVbml0LmgiCisj aW5jbHVkZSAiU2Nyb2xsVHlwZXMuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBIVE1M RWxlbWVudDsKK2NsYXNzIFJlbmRlckJveDsKK2NsYXNzIFJlbmRlclN0eWxlOworCit2b2lkIHVw ZGF0ZUhvcml6b250YWxWZXJ0aWNhbFNuYXBPZmZzZXRzKFZlY3RvcjxMYXlvdXRVbml0PiYgaG9y aXpvbnRhbFNuYXBPZmZzZXRzLCBWZWN0b3I8TGF5b3V0VW5pdD4mIHZlcnRpY2FsU25hcE9mZnNl dHMsIEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVtZW50LCBjb25zdCBSZW5kZXJCb3gmLCBjb25z dCBSZW5kZXJTdHlsZSYpOworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBD U1NfU0NST0xMX1NOQVAKKworI2VuZGlmIC8vIEF4aXNTY3JvbGxTbmFwT2Zmc2V0c19oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKaW5kZXggYzdkOTQ5NDU0NzEx ZjgzYzZiZDdiYjUxMGNiMjMxYzg5MTI4MDEwMC4uZmRhOGVkMGMyZTU2NjIzZjBhYWIwN2MzNDgx MTM4MDFmYzcyNmVhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVh LmNwcApAQCAtNDUsNyArNDUsMTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBzdHJ1Y3QgU2Ft ZVNpemVBc1Njcm9sbGFibGVBcmVhIHsKICAgICB2aXJ0dWFsIH5TYW1lU2l6ZUFzU2Nyb2xsYWJs ZUFyZWEoKTsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZvaWQqIHBvaW50ZXJz WzNdOworI2Vsc2UKICAgICB2b2lkKiBwb2ludGVyOworI2VuZGlmCiAgICAgSW50UG9pbnQgb3Jp Z2luOwogICAgIHVuc2lnbmVkIGJpdGZpZWxkcyA6IDE2OwogfTsKQEAgLTE3OCw2ICsxODIsMTYg QEAgYm9vbCBTY3JvbGxhYmxlQXJlYTo6aGFuZGxlV2hlZWxFdmVudChjb25zdCBQbGF0Zm9ybVdo ZWVsRXZlbnQmIHdoZWVsRXZlbnQpCiAgICAgcmV0dXJuIHNjcm9sbEFuaW1hdG9yKCktPmhhbmRs ZVdoZWVsRXZlbnQod2hlZWxFdmVudCk7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQorVmVjdG9yPExheW91dFVuaXQ+KiBTY3JvbGxhYmxlQXJlYTo6YXhpc1Njcm9sbFNuYXBPZmZz ZXRzKFNjcm9sbEV2ZW50QXhpcyBheGlzKQoreworICAgIGlmIChheGlzID09IFNjcm9sbEV2ZW50 QXhpczo6SG9yaXpvbnRhbCkKKyAgICAgICAgcmV0dXJuIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRz LmdldCgpOworICAgIAorICAgIHJldHVybiBtX3ZlcnRpY2FsU25hcE9mZnNldHMuZ2V0KCk7Cit9 CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiBib29sIFNjcm9sbGFibGVBcmVh OjpoYW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91Y2hFdmVudCYgdG91Y2hFdmVudCkK IHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCmluZGV4IDJmZTI3NDkx NDUyOGZhNTA3YTMxOGE0NWVhOTEwMDZlMWUyODRmMWIuLjIwMmU4MTg1NDA2MWU4NmIxM2NlZjJi NDU0NmYyOTUwYzY5MDRjZDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFy ZWEuaApAQCAtNTgsNiArNTgsMTEgQEAgcHVibGljOgogCiAgICAgYm9vbCBoYW5kbGVXaGVlbEV2 ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYpOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4qIGF4aXNTY3JvbGxTbmFwT2Zmc2V0cyhTY3Jv bGxFdmVudEF4aXMpOworICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFwT2Zmc2V0cygpIHsgfTsK KyNlbmRpZgorCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICAgICB2aXJ0dWFsIGJvb2wgaXNU b3VjaFNjcm9sbGFibGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9v bCBoYW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91Y2hFdmVudCYpOwpAQCAtMjYxLDYg KzI2NiwxMSBAQCBwcm90ZWN0ZWQ6CiAKICAgICBib29sIGhhc0xheWVyRm9yU2Nyb2xsQ29ybmVy KCkgY29uc3Q7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIE93blB0cjxWZWN0 b3I8TGF5b3V0VW5pdD4+IG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzOworICAgIE93blB0cjxWZWN0 b3I8TGF5b3V0VW5pdD4+IG1fdmVydGljYWxTbmFwT2Zmc2V0czsKKyNlbmRpZgorCiBwcml2YXRl OgogICAgIHZpcnR1YWwgSW50UmVjdCB2aXNpYmxlQ29udGVudFJlY3RJbnRlcm5hbChWaXNpYmxl Q29udGVudFJlY3RJbmNsdWRlc1Njcm9sbGJhcnMsIFZpc2libGVDb250ZW50UmVjdEJlaGF2aW9y KSBjb25zdDsKICAgICB2b2lkIHNjcm9sbFBvc2l0aW9uQ2hhbmdlZChjb25zdCBJbnRQb2ludCYp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKaW5kZXggMDQyNGVjYjg1 ZWQ4ZTdiMzJiNjAxMDBhOWUwZWZjMjEyYzhlNTRlYy4uNjNkMTA5ZDk1MGVkZWU0ZjhkNDE3NDM2 MjM0ODUwMTQyOGY1ZjI3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckxheWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIu Y3BwCkBAIC0xMjIsNiArMTIyLDEwIEBACiAjaW5jbHVkZSAiUmVuZGVyTGF5ZXJGaWx0ZXJJbmZv LmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiQXhp c1Njcm9sbFNuYXBPZmZzZXRzLmgiCisjZW5kaWYKKwogI2RlZmluZSBNSU5fSU5URVJTRUNUX0ZP Ul9SRVZFQUwgMzIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzAyOSw2ICszMDMzLDI0IEBA IFNjcm9sbGFibGVBcmVhKiBSZW5kZXJMYXllcjo6ZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBj b25zdAogICAgIHJldHVybiAwOwogfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3Zv aWQgUmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBPZmZzZXRzKCkKK3sKKyAgICAvLyBGSVhNRTogRXh0 ZW5kIHN1cHBvcnQgYmV5b25kIEhUTUxFbGVtZW50cy4KKyAgICBpZiAoIWVuY2xvc2luZ0VsZW1l bnQoKSB8fCAhZW5jbG9zaW5nRWxlbWVudCgpLT5yZW5kZXJCb3goKSB8fCAhZW5jbG9zaW5nRWxl bWVudCgpLT5pc0hUTUxFbGVtZW50KCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBpZiAo IW1faG9yaXpvbnRhbFNuYXBPZmZzZXRzKQorICAgICAgICBtX2hvcml6b250YWxTbmFwT2Zmc2V0 cyA9IGFkb3B0UHRyKG5ldyBWZWN0b3I8TGF5b3V0VW5pdD4pOworCisgICAgaWYgKCFtX3ZlcnRp Y2FsU25hcE9mZnNldHMpCisgICAgICAgIG1fdmVydGljYWxTbmFwT2Zmc2V0cyA9IGFkb3B0UHRy KG5ldyBWZWN0b3I8TGF5b3V0VW5pdD4pOworCisgICAgUmVuZGVyQm94KiBib3ggPSBlbmNsb3Np bmdFbGVtZW50KCktPnJlbmRlckJveCgpOworICAgIHVwZGF0ZUhvcml6b250YWxWZXJ0aWNhbFNu YXBPZmZzZXRzKCptX2hvcml6b250YWxTbmFwT2Zmc2V0cy5nZXQoKSwgKm1fdmVydGljYWxTbmFw T2Zmc2V0cy5nZXQoKSwgKnRvSFRNTEVsZW1lbnQoZW5jbG9zaW5nRWxlbWVudCgpKSwgKmJveCwg Ym94LT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBpbnQgUmVuZGVyTGF5ZXI6OnZlcnRpY2FsU2Ny b2xsYmFyV2lkdGgoT3ZlcmxheVNjcm9sbGJhclNpemVSZWxldmFuY3kgcmVsZXZhbmN5KSBjb25z dAogewogICAgIGlmICghbV92QmFyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyTGF5ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5o CmluZGV4IDI2NjU1OWFmZmI4Y2ZhMDg4YzBlYWMwMzhmZDZlYjdjOWY4YjFmNDcuLmJkMjYxYTdh NDk4N2U3MTQ3ZjAyYWJkMzVjODAyMzQzYWZkMDRjM2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMYXllci5oCkBAIC00MzksNiArNDM5LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwg U2Nyb2xsYmFyKiBob3Jpem9udGFsU2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4g bV9oQmFyLmdldCgpOyB9CiAgICAgdmlydHVhbCBTY3JvbGxiYXIqIHZlcnRpY2FsU2Nyb2xsYmFy KCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4gbV92QmFyLmdldCgpOyB9CiAgICAgdmlydHVhbCBT Y3JvbGxhYmxlQXJlYSogZW5jbG9zaW5nU2Nyb2xsYWJsZUFyZWEoKSBjb25zdCBvdmVycmlkZTsK KyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFw T2Zmc2V0cygpIG92ZXJyaWRlOworI2VuZGlmCiAKICNpZiBQTEFURk9STShJT1MpCiAjaWYgRU5B QkxFKFRPVUNIX0VWRU5UUykK 236522 2014-08-13 06:54:25 -0700 2014-08-13 14:05:13 -0700 Patch bug-135268-20140813065414.patch text/plain 23441 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTIwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWYwOWI3Y2QwYzdjNTE5 ODAwYjM1Y2ViYTFhMjk4MTFkYmZiOWYwOC4uY2VhODBkZmVjMTY2ZTJjYmUxOGZmYTM2NWVhNThj YjBiMTk1NDkzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisyMDE0LTA4LTEzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorCisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6 dXBkYXRlU25hcE9mZnNldHMpOiBJbnZva2VzIHRoZSBzdGF0aWMgcm91dGluZSBpbiBBeGlzU2Ny b2xsU25hcE9mZnNldHMgdG8gdXBkYXRlIHNuYXAgb2Zmc2V0cyBmb3IgbWFpbmZyYW1lLgorICAg ICAgICAqIHBhZ2UvRnJhbWVWaWV3Lmg6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjphcHBlbmRBbmRT b3J0Q2hpbGRTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVGcm9tU3R5bGUp OgorICAgICAgICAoV2ViQ29yZTo6dXBkYXRlSG9yaXpvbnRhbFZlcnRpY2FsU25hcE9mZnNldHMp OiBVcGRhdGUgdGhlIFNjcm9sbGFibGVBcmVhJ3Mgc25hcCBheGVzLgorICAgICAgICAqIHBhZ2Uv c2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0 Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxlQXJl YTo6YXhpc1Njcm9sbFNuYXBPZmZzZXRzKTogUmV0dXJucyB0aGUgU2Nyb2xsYWJsZUFyZWEncyBz bmFwIG9mZnNldHMgaW4gdGhlIGdpdmVuIGF4aXMuCisgICAgICAgICogcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGFibGVBcmVhOjp1cGRhdGVTbmFw T2Zmc2V0cyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlJlbmRlckxheWVyOjp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0 YXRpYyByb3V0aW5lIGluIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZz ZXRzIGZvciBhbiBvdmVyZmxvdyBhcmVhLgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXll ci5oOgorCiAyMDE0LTA4LTEzICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAog ICAgICAgICBEb24ndCByZWN1cnNlIGludG8gbm9uLXJlbmRlcmVkIHN1YnRyZWVzIHdoZW4gY29t cHV0aW5nIHN0eWxlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKaW5kZXggYTI4ZWUxYTNkMzEyMWUwOTVkZjlhOWU1MDUwNzhkYzRiOTYxYWY3 YS4uZjBhYTA0MWRjYjI3YmUzZTgyZjg4Y2I4YWQxNjYzOGY4NTUzOTVlOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNjI0NSw2 ICs2MjQ1LDggQEAKIAkJRjNGNUNGMTExMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNv bGVJbnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5z dHJ1bWVudGF0aW9uLmggKi87IH07CiAJCUYzRjVDRjEzMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNw ZWN0b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3Rv ckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmggKi87IH07CiAJCUY0MkZGQjQ2MTk4NEI3MTYwMEY2 ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAq LzsgfTsKKwkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVD MjMxQjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLzsgfTsK KwkJRjQ1QzIzMUUxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIzMUMxOTk1 QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0N0E1RTNFMTk1QjhDOEEwMDQ4MzEw MCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9s bFNuYXBQb2ludHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwogCQlGNDdBNUUzRjE5NUI4RTQ4MDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRz LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0N0E1 RTNBMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwICovOyB9Owog CQlGNTA2NjRGNzE1N0Y1MkRDMDBBQzIyNkYgLyogRm9ybUNvbnRyb2xsZXIuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUwNjY0RjUxNTdGNTJEQzAw QUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCAqLzsgfTsKQEAgLTEzNzYyLDYgKzEzNzY0LDgg QEAKIAkJRjNGNUNGMTAxMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNvbGVJbnN0cnVt ZW50YXRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVjdG9yQ29u c29sZUluc3RydW1lbnRhdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGM0Y1 Q0YxMjEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24u aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVjdG9yRGF0YWJhc2VJbnN0 cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQyRkZCNDUxOTg0 QjcxNjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBMZW5ndGhSZXBlYXQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1 QzIzMUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGNDVDMjMxQzE5OTVCNzNCMDBBNkUyRTMg LyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlGNDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFN0eWxlU2Nyb2xsU25hcFBvaW50 cy5jcHA7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3Jv bGxTbmFwUG9pbnRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFN0eWxlU2Ny b2xsU25hcFBvaW50cy5oOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBG b3JtQ29udHJvbGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBG b3JtQ29udHJvbGxlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xNTEzNyw2 ICsxNTE0MSw4IEBACiAJCQkJOTM5MUE5OUIxNjI5RDcwMDAwMjk3MzMwIC8qIFNjcm9sbGluZ1Ry ZWVTY3JvbGxpbmdOb2RlLmggKi8sCiAJCQkJMEY2MzgzREIxODYxNUIyOTAwM0U1REI1IC8qIFRo cmVhZGVkU2Nyb2xsaW5nVHJlZS5jcHAgKi8sCiAJCQkJMEY2MzgzREMxODYxNUIyOTAwM0U1REI1 IC8qIFRocmVhZGVkU2Nyb2xsaW5nVHJlZS5oICovLAorCQkJCUY0NUMyMzFCMTk5NUI3M0IwMEE2 RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovLAorCQkJCUY0NUMyMzFDMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLywKIAkJCSk7CiAJCQlwYXRo ID0gc2Nyb2xsaW5nOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTI0NDE5LDYgKzI0 NDI1LDcgQEAKIAkJCQlBODEzNjlFMDA5NzM3NEY2MDBENzQ0NjMgLyogSFRNTExlZ2VuZEVsZW1l bnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4RUE3OUY2MEExOTE2REYwMEE4RUY1RiAvKiBIVE1M TElFbGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBODcxREMyMDBBMTUyMDU3MDBCMTJBNjgg LyogSFRNTExpbmtFbGVtZW50LmggaW4gSGVhZGVycyAqLywKKwkJCQlGNDVDMjMxRTE5OTVCNzNC MDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4gSGVhZGVycyAqLywKIAkJCQlB OEVBN0QyQzBBMTkzODU1MDBBOEVGNUYgLyogSFRNTE1hcEVsZW1lbnQuaCBpbiBIZWFkZXJzICov LAogCQkJCUE4RUE3Q0FCMEExOTJCOUMwMEE4RUY1RiAvKiBIVE1MTWFycXVlZUVsZW1lbnQuaCBp biBIZWFkZXJzICovLAogCQkJCUU0NDYxM0E1MENENjMzMTAwMEZBREE3NSAvKiBIVE1MTWVkaWFF bGVtZW50LmggaW4gSGVhZGVycyAqLywKQEAgLTI3NzU0LDYgKzI3NzYxLDcgQEAKIAkJCQlCMkFG RkM3RDBEMDBBNUMxMDAzMDA3NEQgLyogRm9udEN1c3RvbVBsYXRmb3JtRGF0YS5jcHAgaW4gU291 cmNlcyAqLywKIAkJCQkzNzFGNEY0MTBEMjVCOUFGMDBFQ0UwRDUgLyogRm9udERhdGEuY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJMzdBQ0NGNjkwREE0MTRFNzAwODlFNjAyIC8qIEZvbnREZXNjcmlw dGlvbi5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlGNDVDMjMxRDE5OTVCNzNCMDBBNkUyRTMgLyog QXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTcyNjI2RTAyMEVG MDIyRkUwMEEwN0UyMCAvKiBGb250RmFzdFBhdGguY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNEE2 RTlGQzcxM0MxN0Q1NzAwNDZBN0Y4IC8qIEZvbnRGZWF0dXJlU2V0dGluZ3MuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJRTQ0RUUzQTgxNzU3N0VCRDAwRUVFOENGIC8qIEZvbnRHZW5lcmljRmFtaWxp ZXMuY3BwIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKaW5kZXggMzgx MDcxZDg3MDQ1MTAyMTY3NTg5MjQyOWZkYTQ4OWE4NDI1NTdmOS4uZTQ4ZWJhODE2NDcxYjk2YWEw YTU0MTQ3OWUwNjAwNjIxYWMxOGI2MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9G cmFtZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApAQCAt OTgsNiArOTgsMTAgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAjZW5kaWYKIAorI2lm IEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZzZXRz LmgiCisjZW5kaWYKKwogI2lmIFBMQVRGT1JNKElPUykKICNpbmNsdWRlICJEb2N1bWVudExvYWRl ci5oIgogI2luY2x1ZGUgIkxlZ2FjeVRpbGVDYWNoZS5oIgpAQCAtODQ3LDYgKzg1MSwyNyBAQCBH cmFwaGljc0xheWVyKiBGcmFtZVZpZXc6OnNldFdhbnRzTGF5ZXJGb3JCb3R0b21PdmVySGFuZ0Fy ZWEoYm9vbCB3YW50c0xheWVyKSBjbwogCiAjZW5kaWYgLy8gRU5BQkxFKFJVQkJFUl9CQU5ESU5H KQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3ZvaWQgRnJhbWVWaWV3Ojp1cGRhdGVT bmFwT2Zmc2V0cygpCit7CisgICAgaWYgKCFmcmFtZSgpLmRvY3VtZW50KCkpCisgICAgICAgIHJl dHVybjsKKworICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYWxsb3cgc3BlY2lmeWluZyBzbmFwIHBv aW50cyB0aHJvdWdoIDxodG1sPiB0YWdzIHRvbz8KKyAgICBIVE1MRWxlbWVudCogYm9keSA9IGZy YW1lKCkuZG9jdW1lbnQoKS0+Ym9keSgpOworICAgIGlmICghYm9keSB8fCAhYm9keS0+cmVuZGVy ZXIoKSB8fCAhcmVuZGVyVmlldygpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgaWYgKCFt X2hvcml6b250YWxTbmFwT2Zmc2V0cykKKyAgICAgICAgbV9ob3Jpem9udGFsU25hcE9mZnNldHMg PSBzdGQ6Om1ha2VfdW5pcXVlPFZlY3RvcjxMYXlvdXRVbml0Pj4oKTsKKworICAgIGlmICghbV92 ZXJ0aWNhbFNuYXBPZmZzZXRzKQorICAgICAgICBtX3ZlcnRpY2FsU25hcE9mZnNldHMgPSBzdGQ6 Om1ha2VfdW5pcXVlPFZlY3RvcjxMYXlvdXRVbml0Pj4oKTsKKworICAgIHVwZGF0ZUhvcml6b250 YWxWZXJ0aWNhbFNuYXBPZmZzZXRzKCptX2hvcml6b250YWxTbmFwT2Zmc2V0cywgKm1fdmVydGlj YWxTbmFwT2Zmc2V0cywgKmJvZHksICpyZW5kZXJWaWV3KCksIGJvZHktPnJlbmRlcmVyKCktPnN0 eWxlKCkpOworfQorI2VuZGlmCisKIGJvb2wgRnJhbWVWaWV3OjpmbHVzaENvbXBvc2l0aW5nU3Rh dGVGb3JUaGlzRnJhbWUoRnJhbWUqIHJvb3RGcmFtZUZvckZsdXNoKQogewogICAgIFJlbmRlclZp ZXcqIHJlbmRlclZpZXcgPSB0aGlzLT5yZW5kZXJWaWV3KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu aAppbmRleCBkYmU5ZDVkYThjNzQwZjk4MTdhM2I0OTM5ZmJmZTc4YmU0MDRlNTMxLi45NzhmNTQ0 OThiYTk4MzZhYzIyMzM5NGNiY2I4ZTc3MDMxYWVlNmRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmgKQEAgLTQ5Niw2ICs0OTYsMTAgQEAgcHVibGljOgogICAgIHZvaWQgc2V0RXhwb3NlZFJlY3Qo RmxvYXRSZWN0KTsKICAgICBGbG9hdFJlY3QgZXhwb3NlZFJlY3QoKSBjb25zdCB7IHJldHVybiBt X2V4cG9zZWRSZWN0OyB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZpcnR1 YWwgdm9pZCB1cGRhdGVTbmFwT2Zmc2V0cygpIG92ZXJyaWRlOworI2VuZGlmCisKIHByb3RlY3Rl ZDoKICAgICB2aXJ0dWFsIGJvb2wgc2Nyb2xsQ29udGVudHNGYXN0UGF0aChjb25zdCBJbnRTaXpl JiBzY3JvbGxEZWx0YSwgY29uc3QgSW50UmVjdCYgcmVjdFRvU2Nyb2xsLCBjb25zdCBJbnRSZWN0 JiBjbGlwUmVjdCkgb3ZlcnJpZGU7CiAgICAgdmlydHVhbCB2b2lkIHNjcm9sbENvbnRlbnRzU2xv d1BhdGgoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCkgb3ZlcnJpZGU7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4yY2ZkYzRhOGEzZDNlNjQyODY0NmFiYTE5ZmVmZTJjM2U4MGY5OWVhCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNu YXBPZmZzZXRzLmNwcApAQCAtMCwwICsxLDE0NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx NCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKworI2luY2x1ZGUg IkhUTUxDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKKyNpbmNsdWRlICJS ZW5kZXJCb3guaCIKKworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworc3RhdGljIHZvaWQgYXBwZW5kQW5kU29ydENoaWxkU25hcE9mZnNldHMoSFRN TEVsZW1lbnQmIHBhcmVudCwgYm9vbCBjb21wdXRlSG9yaXpvbnRhbCwgVmVjdG9yPExheW91dFVu aXQ+JiBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBib29sIGNvbXB1dGVWZXJ0aWNh bCwgVmVjdG9yPExheW91dFVuaXQ+JiB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sK KyAgICBFbGVtZW50KiBjaGlsZCA9IHBhcmVudC5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4o KTsKKyAgICAvLyBGSVhNRTogSW5zdGVhZCBvZiB0cmF2ZXJzaW5nIGFsbCBjaGlsZHJlbiwgcmVn aXN0ZXIgY2hpbGRyZW4gd2l0aCBzbmFwIGNvb3JkaW5hdGVzIGJlZm9yZSBhcHBlbmRpbmcgdG8g c25hcE9mZnNldFN1YnNlcXVlbmNlLgorICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAo UmVuZGVyQm94KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94KCkpIHsKKyAgICAgICAgICAgIExheW91 dFVuaXQgdmlld1dpZHRoID0gYm94LT53aWR0aCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCB2 aWV3SGVpZ2h0ID0gYm94LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIEZsb2F0UG9pbnQgcG9zaXRp b24gPSBib3gtPmxvY2FsVG9Db250YWluZXJQb2ludChGbG9hdFBvaW50KGJveC0+eCgpLCBib3gt PnkoKSksIHBhcmVudC5yZW5kZXJCb3goKSk7CisgICAgICAgICAgICBMYXlvdXRVbml0IG9mZnNl dFggPSBwb3NpdGlvbi54KCk7CisgICAgICAgICAgICBMYXlvdXRVbml0IG9mZnNldFkgPSBwb3Np dGlvbi55KCk7CisgICAgICAgICAgICBmb3IgKFNuYXBDb29yZGluYXRlIGNvb3JkaW5hdGUgOiBi b3gtPnN0eWxlKCkuc2Nyb2xsU25hcENvb3JkaW5hdGVzKCkpIHsKKyAgICAgICAgICAgICAgICBM YXlvdXRVbml0IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25YID0gb2Zmc2V0WCArIHZhbHVlRm9y TGVuZ3RoKGNvb3JkaW5hdGUuZmlyc3QsIHZpZXdXaWR0aCk7CisgICAgICAgICAgICAgICAgaWYg KGNvbXB1dGVIb3Jpem9udGFsICYmIGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25YID4gMCkKKyAg ICAgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQo bGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblgpOworICAgICAgICAgICAgICAgIExheW91dFVuaXQg bGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkgPSBvZmZzZXRZICsgdmFsdWVGb3JMZW5ndGgoY29v cmRpbmF0ZS5zZWNvbmQsIHZpZXdIZWlnaHQpOworICAgICAgICAgICAgICAgIGlmIChjb21wdXRl VmVydGljYWwgJiYgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkgPiAwKQorICAgICAgICAgICAg ICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQobGFzdFBvdGVudGlh bFNuYXBQb3NpdGlvblkpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIGNoaWxk ID0gY2hpbGQtPm5leHRFbGVtZW50U2libGluZygpOworICAgIH0KKyAgICBpZiAoY29tcHV0ZUhv cml6b250YWwpCisgICAgICAgIHN0ZDo6c29ydChob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVl bmNlLmJlZ2luKCksIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuZW5kKCkpOworCisg ICAgaWYgKGNvbXB1dGVWZXJ0aWNhbCkKKyAgICAgICAgc3RkOjpzb3J0KHZlcnRpY2FsU25hcE9m ZnNldFN1YnNlcXVlbmNlLmJlZ2luKCksIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmVu ZCgpKTsKK30KKworc3RhdGljIHZvaWQgdXBkYXRlRnJvbVN0eWxlKFZlY3RvcjxMYXlvdXRVbml0 PiYgc25hcE9mZnNldHMsIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSwgU2Nyb2xsRXZlbnRBeGlz IGF4aXMsIExheW91dFVuaXQgdmlld1NpemUsIExheW91dFVuaXQgc2Nyb2xsU2l6ZSwgY29uc3Qg VmVjdG9yPExheW91dFVuaXQ+JiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UpCit7CisgICAgYm9vbCBp c0hvcml6b250YWxBeGlzID0gYXhpcyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWw7Cisg ICAgYm9vbCBoYXNSZXBlYXQgPSBpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcEhh c1JlcGVhdFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBIYXNSZXBlYXRZKCk7CisgICAgTGF5b3V0VW5p dCByZXBlYXRPZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChpc0hvcml6b250YWxBeGlzID8gc3R5bGUu c2Nyb2xsU25hcFJlcGVhdE9mZnNldFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZ KCksIHZpZXdTaXplKTsKKyAgICBMYXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0ID0gdmFsdWVG b3JMZW5ndGgoaXNIb3Jpem9udGFsQXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblgo KSA6IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblkoKSwgdmlld1NpemUpOworICAgIExheW91 dFVuaXQgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSAwOworICAgIExheW91dFVuaXQgbWF4U2Nyb2xs T2Zmc2V0ID0gc2Nyb2xsU2l6ZSAtIHZpZXdTaXplOworICAgIExheW91dFVuaXQgbGFzdFNuYXBQ b3NpdGlvbiA9IGN1clNuYXBQb3NpdGlvblNoaWZ0OworICAgIExheW91dFVuaXQgcG90ZW50aWFs U25hcFBvc2l0aW9uOworICAgIHNuYXBPZmZzZXRzLmNsZWFyKCk7CisgICAgc25hcE9mZnNldHMu YXBwZW5kKDApOworICAgIGRvIHsKKyAgICAgICAgZm9yIChMYXlvdXRVbml0IHNuYXBQb3NpdGlv biA6IHNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkgeworICAgICAgICAgICAgcG90ZW50aWFsU25hcFBv c2l0aW9uID0gY3VyU25hcFBvc2l0aW9uU2hpZnQgKyBzbmFwUG9zaXRpb24gLSBkZXN0aW5hdGlv bk9mZnNldDsKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPD0gMCkKKyAg ICAgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgaWYgKHBvdGVudGlhbFNuYXBQ b3NpdGlvbiA+PSBtYXhTY3JvbGxPZmZzZXQpCisgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAg ICAgICAgICAgIHNuYXBPZmZzZXRzLmFwcGVuZChwb3RlbnRpYWxTbmFwUG9zaXRpb24pOworICAg ICAgICAgICAgbGFzdFNuYXBQb3NpdGlvbiA9IHBvdGVudGlhbFNuYXBQb3NpdGlvbiArIGRlc3Rp bmF0aW9uT2Zmc2V0OworICAgICAgICB9CisgICAgICAgIGN1clNuYXBQb3NpdGlvblNoaWZ0ID0g bGFzdFNuYXBQb3NpdGlvbiArIHJlcGVhdE9mZnNldDsKKyAgICB9IHdoaWxlIChoYXNSZXBlYXQg JiYgY3VyU25hcFBvc2l0aW9uU2hpZnQgPCBtYXhTY3JvbGxPZmZzZXQpOworICAgIC8vIEFsd2F5 cyBwdXQgYSBzbmFwIHBvaW50IG9uIHRoZSBtYXhpbXVtIHNjcm9sbCBvZmZzZXQuCisgICAgLy8g Tm90IGEgcGFydCBvZiB0aGUgc3BlYywgYnV0IG5lY2Vzc2FyeSB0byBwcmV2ZW50IHVucmVhY2hh YmxlIGNvbnRlbnQgd2hlbiBzbmFwcGluZy4KKyAgICBpZiAoc25hcE9mZnNldHMubGFzdCgpICE9 IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAgc25hcE9mZnNldHMuYXBwZW5kKG1heFNjcm9sbE9m ZnNldCk7Cit9CisKK3ZvaWQgdXBkYXRlSG9yaXpvbnRhbFZlcnRpY2FsU25hcE9mZnNldHMoVmVj dG9yPExheW91dFVuaXQ+JiBob3Jpem9udGFsU25hcE9mZnNldHMsIFZlY3RvcjxMYXlvdXRVbml0 PiYgdmVydGljYWxTbmFwT2Zmc2V0cywgSFRNTEVsZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNv bnN0IFJlbmRlckJveCYgYm94LCBjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUpCit7CisgICAgaWYg KHN0eWxlLnNjcm9sbFNuYXBUeXBlKCkgPT0gU2Nyb2xsU25hcFR5cGU6Ok5vbmUpCisgICAgICAg IHJldHVybjsKKyAgICAKKyAgICBMYXlvdXRVbml0IHZpZXdXaWR0aCA9IGJveC53aWR0aCgpOwor ICAgIExheW91dFVuaXQgdmlld0hlaWdodCA9IGJveC5oZWlnaHQoKTsKKyAgICBMYXlvdXRVbml0 IHNjcm9sbFdpZHRoID0gYm94LnNjcm9sbFdpZHRoKCk7CisgICAgTGF5b3V0VW5pdCBzY3JvbGxI ZWlnaHQgPSBib3guc2Nyb2xsSGVpZ2h0KCk7CisgICAgYm9vbCBjb21wdXRlSG9yaXpvbnRhbFNu YXBPZmZzZXRzID0gc2Nyb2xsV2lkdGggPiAwICYmIHZpZXdXaWR0aCA+IDAgJiYgdmlld1dpZHRo IDwgc2Nyb2xsV2lkdGg7CisgICAgYm9vbCBjb21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cyA9IHNj cm9sbEhlaWdodCA+IDAgJiYgdmlld0hlaWdodCA+IDAgJiYgdmlld0hlaWdodCA8IHNjcm9sbEhl aWdodDsKKyAgICBpZiAoIWNvbXB1dGVIb3Jpem9udGFsU25hcE9mZnNldHMgJiYgIWNvbXB1dGVW ZXJ0aWNhbFNuYXBPZmZzZXRzKQorICAgICAgICByZXR1cm47CisKKyAgICBob3Jpem9udGFsU25h cE9mZnNldHMuY2xlYXIoKTsKKyAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRzLmNsZWFyKCk7CisgICAg VmVjdG9yPExheW91dFVuaXQ+IGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAg VmVjdG9yPExheW91dFVuaXQ+IHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlOworICAgIGlm IChzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpIHx8IHN0eWxlLnNjcm9sbFNuYXBVc2Vz RWxlbWVudHNZKCkpCisgICAgICAgIGFwcGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKHNjcm9s bGluZ0VsZW1lbnQsIGNvbXB1dGVIb3Jpem9udGFsU25hcE9mZnNldHMsIGhvcml6b250YWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2UsIGNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRzLCB2ZXJ0aWNhbFNu YXBPZmZzZXRTdWJzZXF1ZW5jZSk7CisKKyAgICBpZiAoY29tcHV0ZUhvcml6b250YWxTbmFwT2Zm c2V0cykgeworICAgICAgICBpZiAoIXN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkpIHsK KyAgICAgICAgICAgIGZvciAoTGVuZ3RoIHNuYXBMZW5ndGggOiBzdHlsZS5zY3JvbGxTbmFwT2Zm c2V0c1goKSkKKyAgICAgICAgICAgICAgICBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNl LmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3V2lkdGgpKTsKKworICAgICAg ICAgICAgc3RkOjpzb3J0KGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYmVnaW4oKSwg aG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7CisgICAgICAgIH0KKyAgICAg ICAgaWYgKCFob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLnNpemUoKSkKKyAgICAgICAg ICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBwZW5kKDApOworCisgICAgICAg IHVwZGF0ZUZyb21TdHlsZShob3Jpem9udGFsU25hcE9mZnNldHMsIHN0eWxlLCBTY3JvbGxFdmVu dEF4aXM6Okhvcml6b250YWwsIHZpZXdXaWR0aCwgc2Nyb2xsV2lkdGgsIGhvcml6b250YWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2UpOworICAgIH0KKyAgICBpZiAoY29tcHV0ZVZlcnRpY2FsU25hcE9m ZnNldHMpIHsKKyAgICAgICAgaWYgKCFzdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgpKSB7 CisgICAgICAgICAgICBmb3IgKExlbmd0aCBzbmFwTGVuZ3RoIDogc3R5bGUuc2Nyb2xsU25hcE9m ZnNldHNZKCkpCisgICAgICAgICAgICAgICAgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2Uu YXBwZW5kKHZhbHVlRm9yTGVuZ3RoKHNuYXBMZW5ndGgsIHZpZXdIZWlnaHQpKTsKKworICAgICAg ICAgICAgc3RkOjpzb3J0KHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmJlZ2luKCksIHZl cnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmVuZCgpKTsKKyAgICAgICAgfQorICAgICAgICBp ZiAoIXZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLnNpemUoKSkKKyAgICAgICAgICAgIHZl cnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZCgwKTsKKworICAgICAgICB1cGRhdGVG cm9tU3R5bGUodmVydGljYWxTbmFwT2Zmc2V0cywgc3R5bGUsIFNjcm9sbEV2ZW50QXhpczo6VmVy dGljYWwsIHZpZXdIZWlnaHQsIHNjcm9sbEhlaWdodCwgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2Vx dWVuY2UpOworICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8g Q1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGlu Zy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5n L0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU5OWI0YjJkZjE4NzIzMjBmN2M1 ZjI3YmU1MDlkMjBmYTlkMjBhNDQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w YWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaApAQCAtMCwwICsxLDQ4IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g QU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2lmbmRlZiBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAorI2RlZmluZSBBeGlz U2Nyb2xsU25hcE9mZnNldHNfaAorCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKworI2lu Y2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNsdWRlICJTY3JvbGxUeXBlcy5oIgorI2luY2x1ZGUg PHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK2NsYXNzIEhUTUxFbGVtZW50OworY2xhc3MgUmVuZGVyQm94OworY2xhc3Mg UmVuZGVyU3R5bGU7CisKK3ZvaWQgdXBkYXRlSG9yaXpvbnRhbFZlcnRpY2FsU25hcE9mZnNldHMo VmVjdG9yPExheW91dFVuaXQ+JiBob3Jpem9udGFsU25hcE9mZnNldHMsIFZlY3RvcjxMYXlvdXRV bml0PiYgdmVydGljYWxTbmFwT2Zmc2V0cywgSFRNTEVsZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQs IGNvbnN0IFJlbmRlckJveCYsIGNvbnN0IFJlbmRlclN0eWxlJik7CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUAorCisjZW5kaWYgLy8gQXhpc1Nj cm9sbFNuYXBPZmZzZXRzX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVh LmNwcAppbmRleCBjN2Q5NDk0NTQ3MTFmODNjNmJkN2JiNTEwY2IyMzFjODkxMjgwMTAwLi41Y2Iy ZGEwZjc5NmRmMjNmYzI2ZjE2NjE4YWI1OWEwNGJlODgwNzNlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCkBAIC00NSw3ICs0NSwxMSBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKIHN0cnVjdCBTYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewogICAgIHZpcnR1 YWwgflNhbWVTaXplQXNTY3JvbGxhYmxlQXJlYSgpOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NO QVApCisgICAgdm9pZCogcG9pbnRlcnNbM107CisjZWxzZQogICAgIHZvaWQqIHBvaW50ZXI7Cisj ZW5kaWYKICAgICBJbnRQb2ludCBvcmlnaW47CiAgICAgdW5zaWduZWQgYml0ZmllbGRzIDogMTY7 CiB9OwpAQCAtMTc4LDYgKzE4MiwxNiBAQCBib29sIFNjcm9sbGFibGVBcmVhOjpoYW5kbGVXaGVl bEV2ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYgd2hlZWxFdmVudCkKICAgICByZXR1cm4g c2Nyb2xsQW5pbWF0b3IoKS0+aGFuZGxlV2hlZWxFdmVudCh3aGVlbEV2ZW50KTsKIH0KIAorI2lm IEVOQUJMRShDU1NfU0NST0xMX1NOQVApCitWZWN0b3I8TGF5b3V0VW5pdD4qIFNjcm9sbGFibGVB cmVhOjpheGlzU2Nyb2xsU25hcE9mZnNldHMoU2Nyb2xsRXZlbnRBeGlzIGF4aXMpIGNvbnN0Cit7 CisgICAgaWYgKGF4aXMgPT0gU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsKQorICAgICAgICBy ZXR1cm4gbV9ob3Jpem9udGFsU25hcE9mZnNldHMuZ2V0KCk7CisgICAgCisgICAgcmV0dXJuIG1f dmVydGljYWxTbmFwT2Zmc2V0cy5nZXQoKTsKK30KKyNlbmRpZgorCiAjaWYgRU5BQkxFKFRPVUNI X0VWRU5UUykKIGJvb2wgU2Nyb2xsYWJsZUFyZWE6OmhhbmRsZVRvdWNoRXZlbnQoY29uc3QgUGxh dGZvcm1Ub3VjaEV2ZW50JiB0b3VjaEV2ZW50KQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmgKaW5kZXggMmZlMjc0OTE0NTI4ZmE1MDdhMzE4YTQ1ZWE5MTAwNmUxZTI4 NGYxYi4uMTA1OGJkNzMzYzQyNDMxOWUzMjY2YmQzY2RlZjc3M2VmNTFkOThiOCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCkBAIC01OCw2ICs1OCwxMSBAQCBwdWJs aWM6CiAKICAgICBib29sIGhhbmRsZVdoZWVsRXZlbnQoY29uc3QgUGxhdGZvcm1XaGVlbEV2ZW50 Jik7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIFZlY3RvcjxMYXlvdXRVbml0 PiogYXhpc1Njcm9sbFNuYXBPZmZzZXRzKFNjcm9sbEV2ZW50QXhpcykgY29uc3Q7CisgICAgdmly dHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzKCkgeyB9OworI2VuZGlmCisKICNpZiBFTkFCTEUo VE9VQ0hfRVZFTlRTKQogICAgIHZpcnR1YWwgYm9vbCBpc1RvdWNoU2Nyb2xsYWJsZSgpIGNvbnN0 IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGhhbmRsZVRvdWNoRXZlbnQoY29u c3QgUGxhdGZvcm1Ub3VjaEV2ZW50Jik7CkBAIC0yNjEsNiArMjY2LDExIEBAIHByb3RlY3RlZDoK IAogICAgIGJvb2wgaGFzTGF5ZXJGb3JTY3JvbGxDb3JuZXIoKSBjb25zdDsKIAorI2lmIEVOQUJM RShDU1NfU0NST0xMX1NOQVApCisgICAgc3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxMYXlvdXRVbml0 Pj4gbV9ob3Jpem9udGFsU25hcE9mZnNldHM7CisgICAgc3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxM YXlvdXRVbml0Pj4gbV92ZXJ0aWNhbFNuYXBPZmZzZXRzOworI2VuZGlmCisKIHByaXZhdGU6CiAg ICAgdmlydHVhbCBJbnRSZWN0IHZpc2libGVDb250ZW50UmVjdEludGVybmFsKFZpc2libGVDb250 ZW50UmVjdEluY2x1ZGVzU2Nyb2xsYmFycywgVmlzaWJsZUNvbnRlbnRSZWN0QmVoYXZpb3IpIGNv bnN0OwogICAgIHZvaWQgc2Nyb2xsUG9zaXRpb25DaGFuZ2VkKGNvbnN0IEludFBvaW50Jik7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAppbmRleCAwNDI0ZWNiODVlZDhl N2IzMmI2MDEwMGE5ZTBlZmMyMTJjOGU1NGVjLi4yNTMwMTJiNWI5ODM0OWJmYzU2YzRjMzljMjBk M2RlMTg4Y2I5OTliIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy TGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAK QEAgLTEyMiw2ICsxMjIsMTAgQEAKICNpbmNsdWRlICJSZW5kZXJMYXllckZpbHRlckluZm8uaCIK ICNlbmRpZgogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyNpbmNsdWRlICJBeGlzU2Ny b2xsU25hcE9mZnNldHMuaCIKKyNlbmRpZgorCiAjZGVmaW5lIE1JTl9JTlRFUlNFQ1RfRk9SX1JF VkVBTCAzMgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0zMDI5LDYgKzMwMzMsMjQgQEAgU2Ny b2xsYWJsZUFyZWEqIFJlbmRlckxheWVyOjplbmNsb3NpbmdTY3JvbGxhYmxlQXJlYSgpIGNvbnN0 CiAgICAgcmV0dXJuIDA7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBS ZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMoKQoreworICAgIC8vIEZJWE1FOiBFeHRlbmQg c3VwcG9ydCBiZXlvbmQgSFRNTEVsZW1lbnRzLgorICAgIGlmICghZW5jbG9zaW5nRWxlbWVudCgp IHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50 KCktPmlzSFRNTEVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIGlmICghbV9o b3Jpem9udGFsU25hcE9mZnNldHMpCisgICAgICAgIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzID0g c3RkOjptYWtlX3VuaXF1ZTxWZWN0b3I8TGF5b3V0VW5pdD4+KCk7CisKKyAgICBpZiAoIW1fdmVy dGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAgbV92ZXJ0aWNhbFNuYXBPZmZzZXRzID0gc3RkOjpt YWtlX3VuaXF1ZTxWZWN0b3I8TGF5b3V0VW5pdD4+KCk7CisKKyAgICBSZW5kZXJCb3gqIGJveCA9 IGVuY2xvc2luZ0VsZW1lbnQoKS0+cmVuZGVyQm94KCk7CisgICAgdXBkYXRlSG9yaXpvbnRhbFZl cnRpY2FsU25hcE9mZnNldHMoKm1faG9yaXpvbnRhbFNuYXBPZmZzZXRzLCAqbV92ZXJ0aWNhbFNu YXBPZmZzZXRzLCAqdG9IVE1MRWxlbWVudChlbmNsb3NpbmdFbGVtZW50KCkpLCAqYm94LCBib3gt PnN0eWxlKCkpOworfQorI2VuZGlmCisKIGludCBSZW5kZXJMYXllcjo6dmVydGljYWxTY3JvbGxi YXJXaWR0aChPdmVybGF5U2Nyb2xsYmFyU2l6ZVJlbGV2YW5jeSByZWxldmFuY3kpIGNvbnN0CiB7 CiAgICAgaWYgKCFtX3ZCYXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJMYXllci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKaW5k ZXggMjY2NTU5YWZmYjhjZmEwODhjMGVhYzAzOGZkNmViN2M5ZjhiMWY0Ny4uYmQyNjFhN2E0OTg3 ZTcxNDdmMDJhYmQzNWM4MDIzNDNhZmQwNGMzYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxheWVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckxheWVyLmgKQEAgLTQzOSw2ICs0MzksOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTY3Jv bGxiYXIqIGhvcml6b250YWxTY3JvbGxiYXIoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX2hC YXIuZ2V0KCk7IH0KICAgICB2aXJ0dWFsIFNjcm9sbGJhciogdmVydGljYWxTY3JvbGxiYXIoKSBj b25zdCBvdmVycmlkZSB7IHJldHVybiBtX3ZCYXIuZ2V0KCk7IH0KICAgICB2aXJ0dWFsIFNjcm9s bGFibGVBcmVhKiBlbmNsb3NpbmdTY3JvbGxhYmxlQXJlYSgpIGNvbnN0IG92ZXJyaWRlOworI2lm IEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZz ZXRzKCkgb3ZlcnJpZGU7CisjZW5kaWYKIAogI2lmIFBMQVRGT1JNKElPUykKICNpZiBFTkFCTEUo VE9VQ0hfRVZFTlRTKQo= 236550 2014-08-13 14:05:20 -0700 2014-08-13 15:37:26 -0700 Patch bug-135268-20140813140507.patch text/plain 24553 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTM1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjVhYzNmNTY0NDBkNzA3 MmQ0Njk0Mzk3ZDM3OWYyODE0MmY0YWE5Yy4uNzI2OTZkOTc4Y2E4ZjdhMGQ0Nzk2ZjE4ZjM2MzZm NjFjOGM4OWRiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE0LTA4LTEzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorICAgICAgICAKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVWaWV3Ojp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0YXRpYyByb3V0aW5lIGlu IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZzZXRzIGZvciBtYWluZnJh bWUuCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGlu Zy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmFw cGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKToKKyAgICAgICAgKFdlYkNvcmU6OnVwZGF0ZUZy b21TdHlsZSk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFi bGVBcmVhKTogVXBkYXRlIHRoZSBTY3JvbGxhYmxlQXJlYSdzIHNuYXAgYXhlcy4KKyAgICAgICAg KiBwYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaDogQWRkZWQuCisgICAgICAg ICogcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xs YWJsZUFyZWE6OnNldEhvcml6b250YWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JvbGxhYmxlQXJlYTo6c2V0VmVydGljYWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJIb3Jpem9udGFsU25hcE9mZnNldHMpOiBSZXNldHMgdGhl IHVuaXF1ZV9wdHIgZm9yIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKTogUmVzZXRzIHRoZSB1 bmlxdWVfcHRyIGZvciB2ZXJ0aWNhbCBzbmFwIHBvaW50cy4KKyAgICAgICAgKiBwbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5oOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsYWJsZUFyZWE6Omhvcml6 b250YWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3JvbGxhYmxlQXJl YSdzIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxl QXJlYTo6dmVydGljYWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3Jv bGxhYmxlQXJlYSdzIHZlcnRpY2FsIHNuYXAgcG9pbnRzLgorICAgICAgICAoV2ViQ29yZTo6U2Ny b2xsYWJsZUFyZWE6OnVwZGF0ZVNuYXBPZmZzZXRzKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBP ZmZzZXRzKTogSW52b2tlcyB0aGUgc3RhdGljIHJvdXRpbmUgaW4gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzIHRvIHVwZGF0ZSBzbmFwIG9mZnNldHMgZm9yIGFuIG92ZXJmbG93IGFyZWEuCisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMTMgIEFsZXggQ2hyaXN0ZW5z ZW4gIDxhY2hyaXN0ZW5zZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZW1vdmVkIGRlYWQgcGx1 Z2lucyBjb2RlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCmluZGV4IGEyOGVlMWEzZDMxMjFlMDk1ZGY5YTllNTA1MDc4ZGM0Yjk2MWFmN2Eu LmYwYWEwNDFkY2IyN2JlM2U4MmY4OGNiOGFkMTY2MzhmODU1Mzk1ZTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTYyNDUsNiAr NjI0NSw4IEBACiAJCUYzRjVDRjExMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xl SW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3Ry dW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1Q0YxMzEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVj dG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEyMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JE YXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggKi87 IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIz MUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi87IH07CisJ CUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRU UklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAg LyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxT bmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUz QTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKIAkJ RjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFD MjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CkBAIC0xMzc2Miw2ICsxMzc2NCw4IEBA CiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVu dGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckNvbnNv bGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjNGNUNG MTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1 bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0MkZGQjQ1MTk4NEI3 MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMy MzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8q IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMu Y3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9s bFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9y bUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9y bUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTUxMzcsNiAr MTUxNDEsOCBAQAogCQkJCTkzOTFBOTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVl U2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJl YWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAv KiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUy RTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNC MDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9 IHNjcm9sbGluZzsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQxOSw2ICsyNDQy NSw3IEBACiAJCQkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50 LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJ RWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8q IEhUTUxMaW5rRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAw QTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThF QTdEMkMwQTE5Mzg1NTAwQThFRjVGIC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQlBOEVBN0NBQjBBMTkyQjlDMDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4g SGVhZGVycyAqLywKIAkJCQlFNDQ2MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxl bWVudC5oIGluIEhlYWRlcnMgKi8sCkBAIC0yNzc1NCw2ICsyNzc2MSw3IEBACiAJCQkJQjJBRkZD N0QwRDAwQTVDMTAwMzAwNzREIC8qIEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJMzcxRjRGNDEwRDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTM3QUNDRjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRp b24uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAy MkZFMDBBMDdFMjAgLyogRm9udEZhc3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5 RkM3MTNDMTdENTcwMDQ2QTdGOCAvKiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCUU0NEVFM0E4MTc1NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVz LmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDM4MTA3 MWQ4NzA0NTEwMjE2NzU4OTI0MjlmZGE0ODlhODQyNTU3ZjkuLmNiZTdiZGI0OTZiY2Y5N2M3NzJi YmI1OWNkZGNhNWJiOGVhYmYwYmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTk4 LDYgKzk4LDEwIEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogI2VuZGlmCiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5o IgorI2VuZGlmCisKICNpZiBQTEFURk9STShJT1MpCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIu aCIKICNpbmNsdWRlICJMZWdhY3lUaWxlQ2FjaGUuaCIKQEAgLTg0Nyw2ICs4NTEsMjEgQEAgR3Jh cGhpY3NMYXllciogRnJhbWVWaWV3OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3ZlckhhbmdBcmVh KGJvb2wgd2FudHNMYXllcikgY28KIAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJfQkFORElORykK IAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6dXBkYXRlU25h cE9mZnNldHMoKQoreworICAgIGlmICghZnJhbWUoKS5kb2N1bWVudCgpKQorICAgICAgICByZXR1 cm47CisKKyAgICAvLyBGSVhNRTogU2hvdWxkIHdlIGFsbG93IHNwZWNpZnlpbmcgc25hcCBwb2lu dHMgdGhyb3VnaCA8aHRtbD4gdGFncyB0b28/CisgICAgSFRNTEVsZW1lbnQqIGJvZHkgPSBmcmFt ZSgpLmRvY3VtZW50KCktPmJvZHkoKTsKKyAgICBpZiAoIXJlbmRlclZpZXcoKSB8fCAhYm9keSB8 fCAhYm9keS0+cmVuZGVyZXIoKSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIHVwZGF0ZVNu YXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoKnRoaXMsICpib2R5LCAqcmVuZGVyVmlldygpLCBi b2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBib29sIEZyYW1lVmlldzo6 Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhpc0ZyYW1lKEZyYW1lKiByb290RnJhbWVGb3JGbHVz aCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5kZXJWaWV3ID0gdGhpcy0+cmVuZGVyVmlldygpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXggZGJlOWQ1ZGE4Yzc0MGY5ODE3YTNiNDkzOWZiZmU3 OGJlNDA0ZTUzMS4uOTc4ZjU0NDk4YmE5ODM2YWMyMjMzOTRjYmNiOGU3NzAzMWFlZTZkZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC00OTYsNiArNDk2LDEwIEBAIHB1YmxpYzoKICAgICB2 b2lkIHNldEV4cG9zZWRSZWN0KEZsb2F0UmVjdCk7CiAgICAgRmxvYXRSZWN0IGV4cG9zZWRSZWN0 KCkgY29uc3QgeyByZXR1cm4gbV9leHBvc2VkUmVjdDsgfQogCisjaWYgRU5BQkxFKENTU19TQ1JP TExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSBvdmVycmlkZTsK KyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAgdmlydHVhbCBib29sIHNjcm9sbENvbnRlbnRzRmFz dFBhdGgoY29uc3QgSW50U2l6ZSYgc2Nyb2xsRGVsdGEsIGNvbnN0IEludFJlY3QmIHJlY3RUb1Nj cm9sbCwgY29uc3QgSW50UmVjdCYgY2xpcFJlY3QpIG92ZXJyaWRlOwogICAgIHZpcnR1YWwgdm9p ZCBzY3JvbGxDb250ZW50c1Nsb3dQYXRoKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QpIG92ZXJy aWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3Jv bGxTbmFwT2Zmc2V0cy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOGJjNzZiN2NmOTE4NTMxNzVlOGFlOTNmNzlj ZWJhOTc5YWFkNTRkZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Ny b2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKQEAgLTAsMCArMSwxNTcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQg SVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmgiCisKKyNpbmNsdWRlICJIVE1MQ29sbGVjdGlvbi5oIgorI2luY2x1ZGUgIkhUTUxFbGVt ZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94LmgiCisjaW5jbHVkZSAiU2Nyb2xsYWJsZUFyZWEu aCIKKworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK Kworc3RhdGljIHZvaWQgYXBwZW5kQW5kU29ydENoaWxkU25hcE9mZnNldHMoSFRNTEVsZW1lbnQm IHBhcmVudCwgYm9vbCBjb21wdXRlSG9yaXpvbnRhbCwgVmVjdG9yPExheW91dFVuaXQ+JiBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBib29sIGNvbXB1dGVWZXJ0aWNhbCwgVmVjdG9y PExheW91dFVuaXQ+JiB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBFbGVt ZW50KiBjaGlsZCA9IHBhcmVudC5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAgICAv LyBGSVhNRTogSW5zdGVhZCBvZiB0cmF2ZXJzaW5nIGFsbCBjaGlsZHJlbiwgcmVnaXN0ZXIgY2hp bGRyZW4gd2l0aCBzbmFwIGNvb3JkaW5hdGVzIGJlZm9yZSBhcHBlbmRpbmcgdG8gc25hcE9mZnNl dFN1YnNlcXVlbmNlLgorICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoUmVuZGVyQm94 KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94KCkpIHsKKyAgICAgICAgICAgIExheW91dFVuaXQgdmll d1dpZHRoID0gYm94LT53aWR0aCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCB2aWV3SGVpZ2h0 ID0gYm94LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBDaGVjayBiZWhhdmlvciB3 aXRoIENTUyByb3RhdGlvbnMuCisgICAgICAgICAgICBGbG9hdFBvaW50IHBvc2l0aW9uID0gYm94 LT5sb2NhbFRvQ29udGFpbmVyUG9pbnQoRmxvYXRQb2ludCgpLCBwYXJlbnQucmVuZGVyQm94KCkp OworICAgICAgICAgICAgZm9yIChTbmFwQ29vcmRpbmF0ZSBjb29yZGluYXRlIDogYm94LT5zdHls ZSgpLnNjcm9sbFNuYXBDb29yZGluYXRlcygpKSB7CisgICAgICAgICAgICAgICAgTGF5b3V0VW5p dCBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA9IExheW91dFVuaXQocG9zaXRpb24ueCgpKSAr IHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuZmlyc3QsIHZpZXdXaWR0aCk7CisgICAgICAgICAg ICAgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsICYmIGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25Y ID4gMCkKKyAgICAgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblgpOworICAgICAgICAgICAgICAgIExh eW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkgPSBMYXlvdXRVbml0KHBvc2l0aW9u LnkoKSkgKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLnNlY29uZCwgdmlld0hlaWdodCk7Cisg ICAgICAgICAgICAgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbCAmJiBsYXN0UG90ZW50aWFsU25hcFBv c2l0aW9uWSA+IDApCisgICAgICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNl cXVlbmNlLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWSk7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEVsZW1lbnRTaWJsaW5nKCk7 CisgICAgfQorICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbCkKKyAgICAgICAgc3RkOjpzb3J0KGhv cml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYmVnaW4oKSwgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZS5lbmQoKSk7CisKKyAgICBpZiAoY29tcHV0ZVZlcnRpY2FsKQorICAgICAg ICBzdGQ6OnNvcnQodmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYmVnaW4oKSwgdmVydGlj YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuZW5kKCkpOworfQorCitzdGF0aWMgdm9pZCB1cGRhdGVG cm9tU3R5bGUoVmVjdG9yPExheW91dFVuaXQ+KiBzbmFwT2Zmc2V0cywgY29uc3QgUmVuZGVyU3R5 bGUmIHN0eWxlLCBTY3JvbGxFdmVudEF4aXMgYXhpcywgTGF5b3V0VW5pdCB2aWV3U2l6ZSwgTGF5 b3V0VW5pdCBzY3JvbGxTaXplLCBjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4mIHNuYXBPZmZzZXRT dWJzZXF1ZW5jZSkKK3sKKyAgICBib29sIGlzSG9yaXpvbnRhbEF4aXMgPSBheGlzID09IFNjcm9s bEV2ZW50QXhpczo6SG9yaXpvbnRhbDsKKyAgICBib29sIGhhc1JlcGVhdCA9IGlzSG9yaXpvbnRh bEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WCgpIDogc3R5bGUuc2Nyb2xsU25hcEhh c1JlcGVhdFkoKTsKKyAgICBMYXlvdXRVbml0IHJlcGVhdE9mZnNldCA9IHZhbHVlRm9yTGVuZ3Ro KGlzSG9yaXpvbnRhbEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0WCgpIDogc3R5 bGUuc2Nyb2xsU25hcFJlcGVhdE9mZnNldFkoKSwgdmlld1NpemUpOworICAgIExheW91dFVuaXQg ZGVzdGluYXRpb25PZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChpc0hvcml6b250YWxBeGlzID8gc3R5 bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpIDogc3R5bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9u WSgpLCB2aWV3U2l6ZSk7CisgICAgTGF5b3V0VW5pdCBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IDA7 CisgICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQgPSBzY3JvbGxTaXplIC0gdmlld1NpemU7 CisgICAgTGF5b3V0VW5pdCBsYXN0U25hcFBvc2l0aW9uID0gY3VyU25hcFBvc2l0aW9uU2hpZnQ7 CisgICAgTGF5b3V0VW5pdCBwb3RlbnRpYWxTbmFwUG9zaXRpb247CisgICAgc25hcE9mZnNldHMt PmNsZWFyKCk7CisgICAgc25hcE9mZnNldHMtPmFwcGVuZCgwKTsKKyAgICBkbyB7CisgICAgICAg IGZvciAoTGF5b3V0VW5pdCBzbmFwUG9zaXRpb24gOiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UpIHsK KyAgICAgICAgICAgIHBvdGVudGlhbFNuYXBQb3NpdGlvbiA9IGN1clNuYXBQb3NpdGlvblNoaWZ0 ICsgc25hcFBvc2l0aW9uIC0gZGVzdGluYXRpb25PZmZzZXQ7CisgICAgICAgICAgICBpZiAocG90 ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Nyb2xsT2Zmc2V0KQor ICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBzbmFwT2Zmc2V0cy0+YXBwZW5k KHBvdGVudGlhbFNuYXBQb3NpdGlvbik7CisgICAgICAgICAgICBsYXN0U25hcFBvc2l0aW9uID0g cG90ZW50aWFsU25hcFBvc2l0aW9uICsgZGVzdGluYXRpb25PZmZzZXQ7CisgICAgICAgIH0KKyAg ICAgICAgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSBsYXN0U25hcFBvc2l0aW9uICsgcmVwZWF0T2Zm c2V0OworICAgIH0gd2hpbGUgKGhhc1JlcGVhdCAmJiBjdXJTbmFwUG9zaXRpb25TaGlmdCA8IG1h eFNjcm9sbE9mZnNldCk7CisgICAgLy8gQWx3YXlzIHB1dCBhIHNuYXAgcG9pbnQgb24gdGhlIG1h eGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICAvLyBOb3QgYSBwYXJ0IG9mIHRoZSBzcGVjLCBidXQg bmVjZXNzYXJ5IHRvIHByZXZlbnQgdW5yZWFjaGFibGUgY29udGVudCB3aGVuIHNuYXBwaW5nLgor ICAgIGlmIChzbmFwT2Zmc2V0cy0+bGFzdCgpICE9IG1heFNjcm9sbE9mZnNldCkKKyAgICAgICAg c25hcE9mZnNldHMtPmFwcGVuZChtYXhTY3JvbGxPZmZzZXQpOworfQorCit2b2lkIHVwZGF0ZVNu YXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoU2Nyb2xsYWJsZUFyZWEmIHNjcm9sbGFibGVBcmVh LCBIVE1MRWxlbWVudCYgc2Nyb2xsaW5nRWxlbWVudCwgY29uc3QgUmVuZGVyQm94JiBib3gsIGNv bnN0IFJlbmRlclN0eWxlJiBzdHlsZSkKK3sKKyAgICBpZiAoc3R5bGUuc2Nyb2xsU25hcFR5cGUo KSA9PSBTY3JvbGxTbmFwVHlwZTo6Tm9uZSkgeworICAgICAgICBzY3JvbGxhYmxlQXJlYS5jbGVh ckhvcml6b250YWxTbmFwT2Zmc2V0cygpOworICAgICAgICBzY3JvbGxhYmxlQXJlYS5jbGVhclZl cnRpY2FsU25hcE9mZnNldHMoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBMYXlvdXRV bml0IHZpZXdXaWR0aCA9IGJveC53aWR0aCgpOworICAgIExheW91dFVuaXQgdmlld0hlaWdodCA9 IGJveC5oZWlnaHQoKTsKKyAgICBMYXlvdXRVbml0IHNjcm9sbFdpZHRoID0gYm94LnNjcm9sbFdp ZHRoKCk7CisgICAgTGF5b3V0VW5pdCBzY3JvbGxIZWlnaHQgPSBib3guc2Nyb2xsSGVpZ2h0KCk7 CisgICAgYm9vbCBjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gc2Nyb2xsV2lkdGggPiAw ICYmIHZpZXdXaWR0aCA+IDAgJiYgdmlld1dpZHRoIDwgc2Nyb2xsV2lkdGg7CisgICAgYm9vbCBj b21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cyA9IHNjcm9sbEhlaWdodCA+IDAgJiYgdmlld0hlaWdo dCA+IDAgJiYgdmlld0hlaWdodCA8IHNjcm9sbEhlaWdodDsKKyAgICBpZiAoIWNvbXB1dGVIb3Jp em9udGFsU25hcE9mZnNldHMgJiYgIWNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRzKQorICAgICAg ICByZXR1cm47CisKKyAgICBpZiAoIWNvbXB1dGVIb3Jpem9udGFsU25hcE9mZnNldHMpCisgICAg ICAgIHNjcm9sbGFibGVBcmVhLmNsZWFySG9yaXpvbnRhbFNuYXBPZmZzZXRzKCk7CisgICAgZWxz ZSBpZiAoIXNjcm9sbGFibGVBcmVhLmhvcml6b250YWxTbmFwT2Zmc2V0cygpKQorICAgICAgICBz Y3JvbGxhYmxlQXJlYS5zZXRIb3Jpem9udGFsU25hcE9mZnNldHMoc3RkOjptYWtlX3VuaXF1ZTxW ZWN0b3I8TGF5b3V0VW5pdD4+KCkpOworCisgICAgaWYgKCFjb21wdXRlVmVydGljYWxTbmFwT2Zm c2V0cykKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuY2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKCk7 CisgICAgZWxzZSBpZiAoIXNjcm9sbGFibGVBcmVhLnZlcnRpY2FsU25hcE9mZnNldHMoKSkKKyAg ICAgICAgc2Nyb2xsYWJsZUFyZWEuc2V0VmVydGljYWxTbmFwT2Zmc2V0cyhzdGQ6Om1ha2VfdW5p cXVlPFZlY3RvcjxMYXlvdXRVbml0Pj4oKSk7CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gaG9y aXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZTsKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4gdmVy dGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAgaWYgKHN0eWxlLnNjcm9sbFNuYXBVc2Vz RWxlbWVudHNYKCkgfHwgc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSkKKyAgICAgICAg YXBwZW5kQW5kU29ydENoaWxkU25hcE9mZnNldHMoc2Nyb2xsaW5nRWxlbWVudCwgY29tcHV0ZUhv cml6b250YWxTbmFwT2Zmc2V0cywgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSwgY29t cHV0ZVZlcnRpY2FsU25hcE9mZnNldHMsIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsK KworICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRzKSB7CisgICAgICAgIGlmICgh c3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1goKSkgeworICAgICAgICAgICAgZm9yIChMZW5n dGggc25hcExlbmd0aCA6IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRzWCgpKQorICAgICAgICAgICAg ICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBwZW5kKHZhbHVlRm9yTGVuZ3Ro KHNuYXBMZW5ndGgsIHZpZXdXaWR0aCkpOworCisgICAgICAgICAgICBzdGQ6OnNvcnQoaG9yaXpv bnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigpLCBob3Jpem9udGFsU25hcE9mZnNldFN1 YnNlcXVlbmNlLmVuZCgpKTsKKyAgICAgICAgfQorICAgICAgICBpZiAoIWhvcml6b250YWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgdXBkYXRlRnJvbVN0eWxlKHNjcm9s bGFibGVBcmVhLmhvcml6b250YWxTbmFwT2Zmc2V0cygpLCBzdHlsZSwgU2Nyb2xsRXZlbnRBeGlz OjpIb3Jpem9udGFsLCB2aWV3V2lkdGgsIHNjcm9sbFdpZHRoLCBob3Jpem9udGFsU25hcE9mZnNl dFN1YnNlcXVlbmNlKTsKKyAgICB9CisgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbFNuYXBPZmZzZXRz KSB7CisgICAgICAgIGlmICghc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1koKSkgeworICAg ICAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRz WSgpKQorICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVu ZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3SGVpZ2h0KSk7CisKKyAgICAgICAgICAg IHN0ZDo6c29ydCh2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigpLCB2ZXJ0aWNh bFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCF2 ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5zaXplKCkpCisgICAgICAgICAgICB2ZXJ0aWNh bFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgdXBkYXRlRnJvbVN0 eWxlKHNjcm9sbGFibGVBcmVhLnZlcnRpY2FsU25hcE9mZnNldHMoKSwgc3R5bGUsIFNjcm9sbEV2 ZW50QXhpczo6VmVydGljYWwsIHZpZXdIZWlnaHQsIHNjcm9sbEhlaWdodCwgdmVydGljYWxTbmFw T2Zmc2V0U3Vic2VxdWVuY2UpOworICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY5ZDE4NDdj YTBjMTMzYTM4MWVlZTE3Mzg3ZDFiOTQ4OWQ0NjhiOWEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaApAQCAtMCww ICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAor I2RlZmluZSBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAorCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKKworI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNsdWRlICJTY3JvbGxUeXBlcy5o IgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEhUTUxFbGVtZW50OworY2xhc3MgUmVuZGVy Qm94OworY2xhc3MgUmVuZGVyU3R5bGU7CitjbGFzcyBTY3JvbGxhYmxlQXJlYTsKKwordm9pZCB1 cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKFNjcm9sbGFibGVBcmVhJiwgSFRNTEVs ZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNvbnN0IFJlbmRlckJveCYsIGNvbnN0IFJlbmRlclN0 eWxlJik7CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExf U05BUAorCisjZW5kaWYgLy8gQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAppbmRleCBjN2Q5NDk0NTQ3MTFmODNjNmJkN2Ji NTEwY2IyMzFjODkxMjgwMTAwLi4wNmE0NzU4YmI4NDc4MjZhOGE3M2I3OWVlNjk4MjU2NjFhOTE3 ZjhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCkBAIC00 NSw3ICs0NSwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0cnVjdCBTYW1lU2l6ZUFzU2Ny b2xsYWJsZUFyZWEgewogICAgIHZpcnR1YWwgflNhbWVTaXplQXNTY3JvbGxhYmxlQXJlYSgpOwor I2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdm9pZCogcG9pbnRlcnNbM107CisjZWxz ZQogICAgIHZvaWQqIHBvaW50ZXI7CisjZW5kaWYKICAgICBJbnRQb2ludCBvcmlnaW47CiAgICAg dW5zaWduZWQgYml0ZmllbGRzIDogMTY7CiB9OwpAQCAtMzc2LDYgKzM4MCwyOCBAQCBib29sIFNj cm9sbGFibGVBcmVhOjpoYXNMYXllckZvclNjcm9sbENvcm5lcigpIGNvbnN0CiAgICAgcmV0dXJu IGxheWVyRm9yU2Nyb2xsQ29ybmVyKCk7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQordm9pZCBTY3JvbGxhYmxlQXJlYTo6c2V0SG9yaXpvbnRhbFNuYXBPZmZzZXRzKHN0ZDo6dW5p cXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IGhvcml6b250YWxTbmFwT2Zmc2V0cykKK3sKKyAg ICBtX2hvcml6b250YWxTbmFwT2Zmc2V0cyA9IFdURjo6bW92ZShob3Jpem9udGFsU25hcE9mZnNl dHMpOworfQorCit2b2lkIFNjcm9sbGFibGVBcmVhOjpzZXRWZXJ0aWNhbFNuYXBPZmZzZXRzKHN0 ZDo6dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IHZlcnRpY2FsU25hcE9mZnNldHMpCit7 CisgICAgbV92ZXJ0aWNhbFNuYXBPZmZzZXRzID0gV1RGOjptb3ZlKHZlcnRpY2FsU25hcE9mZnNl dHMpOworfQorCit2b2lkIFNjcm9sbGFibGVBcmVhOjpjbGVhckhvcml6b250YWxTbmFwT2Zmc2V0 cygpCit7CisgICAgbV9ob3Jpem9udGFsU25hcE9mZnNldHMucmVzZXQoKTsKK30KKwordm9pZCBT Y3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKCkKK3sKKyAgICBtX3ZlcnRp Y2FsU25hcE9mZnNldHMucmVzZXQoKTsKK30KKyNlbmRpZgorCiB2b2lkIFNjcm9sbGFibGVBcmVh OjpzZXJ2aWNlU2Nyb2xsQW5pbWF0aW9ucygpCiB7CiAgICAgaWYgKFNjcm9sbEFuaW1hdG9yKiBz Y3JvbGxBbmltYXRvciA9IGV4aXN0aW5nU2Nyb2xsQW5pbWF0b3IoKSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCmluZGV4IDJmZTI3NDkxNDUyOGZhNTA3YTMxOGE0NWVh OTEwMDZlMWUyODRmMWIuLjQ1MmQ3MjlmMWU1OWZiNDU4ODUwNjMwODg5MzU3MTI3OTA3MGIzM2Mg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaApAQCAtNTgsNiArNTgs MTYgQEAgcHVibGljOgogCiAgICAgYm9vbCBoYW5kbGVXaGVlbEV2ZW50KGNvbnN0IFBsYXRmb3Jt V2hlZWxFdmVudCYpOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICBWZWN0b3I8 TGF5b3V0VW5pdD4qIGhvcml6b250YWxTbmFwT2Zmc2V0cygpIGNvbnN0IHsgcmV0dXJuIG1faG9y aXpvbnRhbFNuYXBPZmZzZXRzLmdldCgpOyB9OworICAgIFZlY3RvcjxMYXlvdXRVbml0PiogdmVy dGljYWxTbmFwT2Zmc2V0cygpIGNvbnN0IHsgcmV0dXJuIG1fdmVydGljYWxTbmFwT2Zmc2V0cy5n ZXQoKTsgfTsKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSB7IH07CisgICAg dm9pZCBzZXRIb3Jpem9udGFsU25hcE9mZnNldHMoc3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxMYXlv dXRVbml0Pj4pOworICAgIHZvaWQgc2V0VmVydGljYWxTbmFwT2Zmc2V0cyhzdGQ6OnVuaXF1ZV9w dHI8VmVjdG9yPExheW91dFVuaXQ+Pik7CisgICAgdm9pZCBjbGVhckhvcml6b250YWxTbmFwT2Zm c2V0cygpOworICAgIHZvaWQgY2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKCk7CisjZW5kaWYKKwog I2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgdmlydHVhbCBib29sIGlzVG91Y2hTY3JvbGxh YmxlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlVG91 Y2hFdmVudChjb25zdCBQbGF0Zm9ybVRvdWNoRXZlbnQmKTsKQEAgLTI3NSw2ICsyODUsMTEgQEAg cHJpdmF0ZToKIAogICAgIG11dGFibGUgT3duUHRyPFNjcm9sbEFuaW1hdG9yPiBtX3Njcm9sbEFu aW1hdG9yOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAgICBzdGQ6OnVuaXF1ZV9w dHI8VmVjdG9yPExheW91dFVuaXQ+PiBtX2hvcml6b250YWxTbmFwT2Zmc2V0czsKKyAgICBzdGQ6 OnVuaXF1ZV9wdHI8VmVjdG9yPExheW91dFVuaXQ+PiBtX3ZlcnRpY2FsU25hcE9mZnNldHM7Cisj ZW5kaWYKKwogICAgIC8vIFRoZXJlIGFyZSA4IHBvc3NpYmxlIGNvbWJpbmF0aW9ucyBvZiB3cml0 aW5nIG1vZGUgYW5kIGRpcmVjdGlvbi4gU2Nyb2xsIG9yaWdpbiB3aWxsIGJlIG5vbi16ZXJvIGlu IHRoZSB4IG9yIHkgYXhpcwogICAgIC8vIGlmIHRoZXJlIGlzIGFueSByZXZlcnNlZCBkaXJlY3Rp b24gb3Igd3JpdGluZy1tb2RlLiBUaGUgY29tYmluYXRpb25zIGFyZToKICAgICAvLyB3cml0aW5n LW1vZGUgLyBkaXJlY3Rpb24gICAgIHNjcm9sbE9yaWdpbi54KCkgc2V0ICAgIHNjcm9sbE9yaWdp bi55KCkgc2V0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5 ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAppbmRleCAw M2QwZjZiN2QzZTNlNTk5M2IyOGQ0YmIzYTlmYzMwZmJlNDBjNWQ2Li5kNjZkYTEzYzhiYzFjMWZm MTY2NTAwODMzYzMxZTQwYWUwODQxOTgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJMYXllci5jcHAKQEAgLTEyMiw2ICsxMjIsMTAgQEAKICNpbmNsdWRlICJSZW5kZXJMYXllckZp bHRlckluZm8uaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyNpbmNs dWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRpZgorCiAjZGVmaW5lIE1JTl9JTlRF UlNFQ1RfRk9SX1JFVkVBTCAzMgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0zMDI4LDYgKzMw MzIsMTggQEAgU2Nyb2xsYWJsZUFyZWEqIFJlbmRlckxheWVyOjplbmNsb3NpbmdTY3JvbGxhYmxl QXJlYSgpIGNvbnN0CiAgICAgcmV0dXJuIDA7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9T TkFQKQordm9pZCBSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNldHMoKQoreworICAgIC8vIEZJ WE1FOiBFeHRlbmQgc3VwcG9ydCBiZXlvbmQgSFRNTEVsZW1lbnRzLgorICAgIGlmICghZW5jbG9z aW5nRWxlbWVudCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpIHx8ICFlbmNs b3NpbmdFbGVtZW50KCktPmlzSFRNTEVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAg UmVuZGVyQm94KiBib3ggPSBlbmNsb3NpbmdFbGVtZW50KCktPnJlbmRlckJveCgpOworICAgIHVw ZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoKnRoaXMsICp0b0hUTUxFbGVtZW50KGVu Y2xvc2luZ0VsZW1lbnQoKSksICpib3gsIGJveC0+c3R5bGUoKSk7Cit9CisjZW5kaWYKKwogaW50 IFJlbmRlckxheWVyOjp2ZXJ0aWNhbFNjcm9sbGJhcldpZHRoKE92ZXJsYXlTY3JvbGxiYXJTaXpl UmVsZXZhbmN5IHJlbGV2YW5jeSkgY29uc3QKIHsKICAgICBpZiAoIW1fdkJhcgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmggYi9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaAppbmRleCAyNjY1NTlhZmZiOGNmYTA4OGMwZWFjMDM4 ZmQ2ZWI3YzlmOGIxZjQ3Li5iZDI2MWE3YTQ5ODdlNzE0N2YwMmFiZDM1YzgwMjM0M2FmZDA0YzNj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaApAQCAtNDM5LDYgKzQzOSw5 IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFNjcm9sbGJhciogaG9yaXpvbnRhbFNjcm9sbGJhcigp IGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1faEJhci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Ny b2xsYmFyKiB2ZXJ0aWNhbFNjcm9sbGJhcigpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1fdkJh ci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Nyb2xsYWJsZUFyZWEqIGVuY2xvc2luZ1Njcm9sbGFi bGVBcmVhKCkgY29uc3Qgb3ZlcnJpZGU7CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKyAg ICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSBvdmVycmlkZTsKKyNlbmRpZgogCiAj aWYgUExBVEZPUk0oSU9TKQogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCg== 236552 2014-08-13 14:10:13 -0700 2014-08-13 15:37:36 -0700 Patch bug-135268-20140813141000.patch text/plain 24571 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTM1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjVhYzNmNTY0NDBkNzA3 MmQ0Njk0Mzk3ZDM3OWYyODE0MmY0YWE5Yy4uNzI2OTZkOTc4Y2E4ZjdhMGQ0Nzk2ZjE4ZjM2MzZm NjFjOGM4OWRiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE0LTA4LTEzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorICAgICAgICAKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVWaWV3Ojp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0YXRpYyByb3V0aW5lIGlu IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZzZXRzIGZvciBtYWluZnJh bWUuCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGlu Zy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmFw cGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKToKKyAgICAgICAgKFdlYkNvcmU6OnVwZGF0ZUZy b21TdHlsZSk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFi bGVBcmVhKTogVXBkYXRlIHRoZSBTY3JvbGxhYmxlQXJlYSdzIHNuYXAgYXhlcy4KKyAgICAgICAg KiBwYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaDogQWRkZWQuCisgICAgICAg ICogcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xs YWJsZUFyZWE6OnNldEhvcml6b250YWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JvbGxhYmxlQXJlYTo6c2V0VmVydGljYWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJIb3Jpem9udGFsU25hcE9mZnNldHMpOiBSZXNldHMgdGhl IHVuaXF1ZV9wdHIgZm9yIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKTogUmVzZXRzIHRoZSB1 bmlxdWVfcHRyIGZvciB2ZXJ0aWNhbCBzbmFwIHBvaW50cy4KKyAgICAgICAgKiBwbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5oOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsYWJsZUFyZWE6Omhvcml6 b250YWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3JvbGxhYmxlQXJl YSdzIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxl QXJlYTo6dmVydGljYWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3Jv bGxhYmxlQXJlYSdzIHZlcnRpY2FsIHNuYXAgcG9pbnRzLgorICAgICAgICAoV2ViQ29yZTo6U2Ny b2xsYWJsZUFyZWE6OnVwZGF0ZVNuYXBPZmZzZXRzKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBP ZmZzZXRzKTogSW52b2tlcyB0aGUgc3RhdGljIHJvdXRpbmUgaW4gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzIHRvIHVwZGF0ZSBzbmFwIG9mZnNldHMgZm9yIGFuIG92ZXJmbG93IGFyZWEuCisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMTMgIEFsZXggQ2hyaXN0ZW5z ZW4gIDxhY2hyaXN0ZW5zZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZW1vdmVkIGRlYWQgcGx1 Z2lucyBjb2RlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCmluZGV4IGEyOGVlMWEzZDMxMjFlMDk1ZGY5YTllNTA1MDc4ZGM0Yjk2MWFmN2Eu LmYwYWEwNDFkY2IyN2JlM2U4MmY4OGNiOGFkMTY2MzhmODU1Mzk1ZTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTYyNDUsNiAr NjI0NSw4IEBACiAJCUYzRjVDRjExMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xl SW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3Ry dW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1Q0YxMzEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVj dG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEyMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JE YXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggKi87 IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIz MUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi87IH07CisJ CUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRU UklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAg LyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxT bmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUz QTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKIAkJ RjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFD MjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CkBAIC0xMzc2Miw2ICsxMzc2NCw4IEBA CiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVu dGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckNvbnNv bGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjNGNUNG MTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1 bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0MkZGQjQ1MTk4NEI3 MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMy MzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8q IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMu Y3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9s bFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9y bUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9y bUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTUxMzcsNiAr MTUxNDEsOCBAQAogCQkJCTkzOTFBOTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVl U2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJl YWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAv KiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUy RTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNC MDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9 IHNjcm9sbGluZzsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQxOSw2ICsyNDQy NSw3IEBACiAJCQkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50 LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJ RWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8q IEhUTUxMaW5rRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAw QTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThF QTdEMkMwQTE5Mzg1NTAwQThFRjVGIC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQlBOEVBN0NBQjBBMTkyQjlDMDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4g SGVhZGVycyAqLywKIAkJCQlFNDQ2MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxl bWVudC5oIGluIEhlYWRlcnMgKi8sCkBAIC0yNzc1NCw2ICsyNzc2MSw3IEBACiAJCQkJQjJBRkZD N0QwRDAwQTVDMTAwMzAwNzREIC8qIEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJMzcxRjRGNDEwRDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTM3QUNDRjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRp b24uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAy MkZFMDBBMDdFMjAgLyogRm9udEZhc3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5 RkM3MTNDMTdENTcwMDQ2QTdGOCAvKiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCUU0NEVFM0E4MTc1NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVz LmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDM4MTA3 MWQ4NzA0NTEwMjE2NzU4OTI0MjlmZGE0ODlhODQyNTU3ZjkuLmNiZTdiZGI0OTZiY2Y5N2M3NzJi YmI1OWNkZGNhNWJiOGVhYmYwYmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTk4 LDYgKzk4LDEwIEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogI2VuZGlmCiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5o IgorI2VuZGlmCisKICNpZiBQTEFURk9STShJT1MpCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIu aCIKICNpbmNsdWRlICJMZWdhY3lUaWxlQ2FjaGUuaCIKQEAgLTg0Nyw2ICs4NTEsMjEgQEAgR3Jh cGhpY3NMYXllciogRnJhbWVWaWV3OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3ZlckhhbmdBcmVh KGJvb2wgd2FudHNMYXllcikgY28KIAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJfQkFORElORykK IAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6dXBkYXRlU25h cE9mZnNldHMoKQoreworICAgIGlmICghZnJhbWUoKS5kb2N1bWVudCgpKQorICAgICAgICByZXR1 cm47CisKKyAgICAvLyBGSVhNRTogU2hvdWxkIHdlIGFsbG93IHNwZWNpZnlpbmcgc25hcCBwb2lu dHMgdGhyb3VnaCA8aHRtbD4gdGFncyB0b28/CisgICAgSFRNTEVsZW1lbnQqIGJvZHkgPSBmcmFt ZSgpLmRvY3VtZW50KCktPmJvZHkoKTsKKyAgICBpZiAoIXJlbmRlclZpZXcoKSB8fCAhYm9keSB8 fCAhYm9keS0+cmVuZGVyZXIoKSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIHVwZGF0ZVNu YXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoKnRoaXMsICpib2R5LCAqcmVuZGVyVmlldygpLCBi b2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBib29sIEZyYW1lVmlldzo6 Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhpc0ZyYW1lKEZyYW1lKiByb290RnJhbWVGb3JGbHVz aCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5kZXJWaWV3ID0gdGhpcy0+cmVuZGVyVmlldygpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXggZGJlOWQ1ZGE4Yzc0MGY5ODE3YTNiNDkzOWZiZmU3 OGJlNDA0ZTUzMS4uOTc4ZjU0NDk4YmE5ODM2YWMyMjMzOTRjYmNiOGU3NzAzMWFlZTZkZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC00OTYsNiArNDk2LDEwIEBAIHB1YmxpYzoKICAgICB2 b2lkIHNldEV4cG9zZWRSZWN0KEZsb2F0UmVjdCk7CiAgICAgRmxvYXRSZWN0IGV4cG9zZWRSZWN0 KCkgY29uc3QgeyByZXR1cm4gbV9leHBvc2VkUmVjdDsgfQogCisjaWYgRU5BQkxFKENTU19TQ1JP TExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSBvdmVycmlkZTsK KyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAgdmlydHVhbCBib29sIHNjcm9sbENvbnRlbnRzRmFz dFBhdGgoY29uc3QgSW50U2l6ZSYgc2Nyb2xsRGVsdGEsIGNvbnN0IEludFJlY3QmIHJlY3RUb1Nj cm9sbCwgY29uc3QgSW50UmVjdCYgY2xpcFJlY3QpIG92ZXJyaWRlOwogICAgIHZpcnR1YWwgdm9p ZCBzY3JvbGxDb250ZW50c1Nsb3dQYXRoKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QpIG92ZXJy aWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3Jv bGxTbmFwT2Zmc2V0cy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWQxYjQ0MTUyYjZkZjdhMGFmZjBhYTAxMjU4 MDRmMDg5ODU4MmE3NAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Ny b2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKQEAgLTAsMCArMSwxNTggQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQg SVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmgiCisKKyNpbmNsdWRlICJIVE1MQ29sbGVjdGlvbi5oIgorI2luY2x1ZGUgIkhUTUxFbGVt ZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94LmgiCisjaW5jbHVkZSAiU2Nyb2xsYWJsZUFyZWEu aCIKKworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK Kworc3RhdGljIHZvaWQgYXBwZW5kQW5kU29ydENoaWxkU25hcE9mZnNldHMoSFRNTEVsZW1lbnQm IHBhcmVudCwgYm9vbCBjb21wdXRlSG9yaXpvbnRhbCwgVmVjdG9yPExheW91dFVuaXQ+JiBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBib29sIGNvbXB1dGVWZXJ0aWNhbCwgVmVjdG9y PExheW91dFVuaXQ+JiB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBFbGVt ZW50KiBjaGlsZCA9IHBhcmVudC5jaGlsZHJlbigpLT5jb2xsZWN0aW9uQmVnaW4oKTsKKyAgICAv LyBGSVhNRTogSW5zdGVhZCBvZiB0cmF2ZXJzaW5nIGFsbCBjaGlsZHJlbiwgcmVnaXN0ZXIgY2hp bGRyZW4gd2l0aCBzbmFwIGNvb3JkaW5hdGVzIGJlZm9yZSBhcHBlbmRpbmcgdG8gc25hcE9mZnNl dFN1YnNlcXVlbmNlLgorICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoUmVuZGVyQm94 KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94KCkpIHsKKyAgICAgICAgICAgIExheW91dFVuaXQgdmll d1dpZHRoID0gYm94LT53aWR0aCgpOworICAgICAgICAgICAgTGF5b3V0VW5pdCB2aWV3SGVpZ2h0 ID0gYm94LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBDaGVjayBiZWhhdmlvciB3 aXRoIENTUyByb3RhdGlvbnMuCisgICAgICAgICAgICBGbG9hdFBvaW50IHBvc2l0aW9uID0gYm94 LT5sb2NhbFRvQ29udGFpbmVyUG9pbnQoRmxvYXRQb2ludCgpLCBwYXJlbnQucmVuZGVyQm94KCkp OworICAgICAgICAgICAgZm9yIChTbmFwQ29vcmRpbmF0ZSBjb29yZGluYXRlIDogYm94LT5zdHls ZSgpLnNjcm9sbFNuYXBDb29yZGluYXRlcygpKSB7CisgICAgICAgICAgICAgICAgTGF5b3V0VW5p dCBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA9IExheW91dFVuaXQocG9zaXRpb24ueCgpKSAr IHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuZmlyc3QsIHZpZXdXaWR0aCk7CisgICAgICAgICAg ICAgICAgaWYgKGNvbXB1dGVIb3Jpem9udGFsICYmIGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25Y ID4gMCkKKyAgICAgICAgICAgICAgICAgICAgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZS5hcHBlbmQobGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblgpOworICAgICAgICAgICAgICAgIAor ICAgICAgICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblkgPSBM YXlvdXRVbml0KHBvc2l0aW9uLnkoKSkgKyB2YWx1ZUZvckxlbmd0aChjb29yZGluYXRlLnNlY29u ZCwgdmlld0hlaWdodCk7CisgICAgICAgICAgICAgICAgaWYgKGNvbXB1dGVWZXJ0aWNhbCAmJiBs YXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWSA+IDApCisgICAgICAgICAgICAgICAgICAgIHZlcnRp Y2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9u WSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4 dEVsZW1lbnRTaWJsaW5nKCk7CisgICAgfQorICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbCkKKyAg ICAgICAgc3RkOjpzb3J0KGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYmVnaW4oKSwg aG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7CisKKyAgICBpZiAoY29tcHV0 ZVZlcnRpY2FsKQorICAgICAgICBzdGQ6OnNvcnQodmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVu Y2UuYmVnaW4oKSwgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuZW5kKCkpOworfQorCitz dGF0aWMgdm9pZCB1cGRhdGVGcm9tU3R5bGUoVmVjdG9yPExheW91dFVuaXQ+KiBzbmFwT2Zmc2V0 cywgY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlLCBTY3JvbGxFdmVudEF4aXMgYXhpcywgTGF5b3V0 VW5pdCB2aWV3U2l6ZSwgTGF5b3V0VW5pdCBzY3JvbGxTaXplLCBjb25zdCBWZWN0b3I8TGF5b3V0 VW5pdD4mIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBib29sIGlzSG9yaXpvbnRhbEF4 aXMgPSBheGlzID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbDsKKyAgICBib29sIGhhc1Jl cGVhdCA9IGlzSG9yaXpvbnRhbEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WCgpIDog c3R5bGUuc2Nyb2xsU25hcEhhc1JlcGVhdFkoKTsKKyAgICBMYXlvdXRVbml0IHJlcGVhdE9mZnNl dCA9IHZhbHVlRm9yTGVuZ3RoKGlzSG9yaXpvbnRhbEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwUmVw ZWF0T2Zmc2V0WCgpIDogc3R5bGUuc2Nyb2xsU25hcFJlcGVhdE9mZnNldFkoKSwgdmlld1NpemUp OworICAgIExheW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChpc0hv cml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpIDogc3R5bGUuc2Ny b2xsU25hcERlc3RpbmF0aW9uWSgpLCB2aWV3U2l6ZSk7CisgICAgTGF5b3V0VW5pdCBjdXJTbmFw UG9zaXRpb25TaGlmdCA9IDA7CisgICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQgPSBzY3Jv bGxTaXplIC0gdmlld1NpemU7CisgICAgTGF5b3V0VW5pdCBsYXN0U25hcFBvc2l0aW9uID0gY3Vy U25hcFBvc2l0aW9uU2hpZnQ7CisgICAgTGF5b3V0VW5pdCBwb3RlbnRpYWxTbmFwUG9zaXRpb247 CisgICAgc25hcE9mZnNldHMtPmNsZWFyKCk7CisgICAgc25hcE9mZnNldHMtPmFwcGVuZCgwKTsK KyAgICBkbyB7CisgICAgICAgIGZvciAoTGF5b3V0VW5pdCBzbmFwUG9zaXRpb24gOiBzbmFwT2Zm c2V0U3Vic2VxdWVuY2UpIHsKKyAgICAgICAgICAgIHBvdGVudGlhbFNuYXBQb3NpdGlvbiA9IGN1 clNuYXBQb3NpdGlvblNoaWZ0ICsgc25hcFBvc2l0aW9uIC0gZGVzdGluYXRpb25PZmZzZXQ7Cisg ICAgICAgICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAg ICAgY29udGludWU7CisKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0g bWF4U2Nyb2xsT2Zmc2V0KQorICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBz bmFwT2Zmc2V0cy0+YXBwZW5kKHBvdGVudGlhbFNuYXBQb3NpdGlvbik7CisgICAgICAgICAgICBs YXN0U25hcFBvc2l0aW9uID0gcG90ZW50aWFsU25hcFBvc2l0aW9uICsgZGVzdGluYXRpb25PZmZz ZXQ7CisgICAgICAgIH0KKyAgICAgICAgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSBsYXN0U25hcFBv c2l0aW9uICsgcmVwZWF0T2Zmc2V0OworICAgIH0gd2hpbGUgKGhhc1JlcGVhdCAmJiBjdXJTbmFw UG9zaXRpb25TaGlmdCA8IG1heFNjcm9sbE9mZnNldCk7CisgICAgLy8gQWx3YXlzIHB1dCBhIHNu YXAgcG9pbnQgb24gdGhlIG1heGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICAvLyBOb3QgYSBwYXJ0 IG9mIHRoZSBzcGVjLCBidXQgbmVjZXNzYXJ5IHRvIHByZXZlbnQgdW5yZWFjaGFibGUgY29udGVu dCB3aGVuIHNuYXBwaW5nLgorICAgIGlmIChzbmFwT2Zmc2V0cy0+bGFzdCgpICE9IG1heFNjcm9s bE9mZnNldCkKKyAgICAgICAgc25hcE9mZnNldHMtPmFwcGVuZChtYXhTY3JvbGxPZmZzZXQpOwor fQorCit2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoU2Nyb2xsYWJsZUFy ZWEmIHNjcm9sbGFibGVBcmVhLCBIVE1MRWxlbWVudCYgc2Nyb2xsaW5nRWxlbWVudCwgY29uc3Qg UmVuZGVyQm94JiBib3gsIGNvbnN0IFJlbmRlclN0eWxlJiBzdHlsZSkKK3sKKyAgICBpZiAoc3R5 bGUuc2Nyb2xsU25hcFR5cGUoKSA9PSBTY3JvbGxTbmFwVHlwZTo6Tm9uZSkgeworICAgICAgICBz Y3JvbGxhYmxlQXJlYS5jbGVhckhvcml6b250YWxTbmFwT2Zmc2V0cygpOworICAgICAgICBzY3Jv bGxhYmxlQXJlYS5jbGVhclZlcnRpY2FsU25hcE9mZnNldHMoKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKyAgICBMYXlvdXRVbml0IHZpZXdXaWR0aCA9IGJveC53aWR0aCgpOworICAgIExheW91 dFVuaXQgdmlld0hlaWdodCA9IGJveC5oZWlnaHQoKTsKKyAgICBMYXlvdXRVbml0IHNjcm9sbFdp ZHRoID0gYm94LnNjcm9sbFdpZHRoKCk7CisgICAgTGF5b3V0VW5pdCBzY3JvbGxIZWlnaHQgPSBi b3guc2Nyb2xsSGVpZ2h0KCk7CisgICAgYm9vbCBjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRz ID0gc2Nyb2xsV2lkdGggPiAwICYmIHZpZXdXaWR0aCA+IDAgJiYgdmlld1dpZHRoIDwgc2Nyb2xs V2lkdGg7CisgICAgYm9vbCBjb21wdXRlVmVydGljYWxTbmFwT2Zmc2V0cyA9IHNjcm9sbEhlaWdo dCA+IDAgJiYgdmlld0hlaWdodCA+IDAgJiYgdmlld0hlaWdodCA8IHNjcm9sbEhlaWdodDsKKyAg ICBpZiAoIWNvbXB1dGVIb3Jpem9udGFsU25hcE9mZnNldHMgJiYgIWNvbXB1dGVWZXJ0aWNhbFNu YXBPZmZzZXRzKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIWNvbXB1dGVIb3Jpem9udGFs U25hcE9mZnNldHMpCisgICAgICAgIHNjcm9sbGFibGVBcmVhLmNsZWFySG9yaXpvbnRhbFNuYXBP ZmZzZXRzKCk7CisgICAgZWxzZSBpZiAoIXNjcm9sbGFibGVBcmVhLmhvcml6b250YWxTbmFwT2Zm c2V0cygpKQorICAgICAgICBzY3JvbGxhYmxlQXJlYS5zZXRIb3Jpem9udGFsU25hcE9mZnNldHMo c3RkOjptYWtlX3VuaXF1ZTxWZWN0b3I8TGF5b3V0VW5pdD4+KCkpOworCisgICAgaWYgKCFjb21w dXRlVmVydGljYWxTbmFwT2Zmc2V0cykKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuY2xlYXJWZXJ0 aWNhbFNuYXBPZmZzZXRzKCk7CisgICAgZWxzZSBpZiAoIXNjcm9sbGFibGVBcmVhLnZlcnRpY2Fs U25hcE9mZnNldHMoKSkKKyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuc2V0VmVydGljYWxTbmFwT2Zm c2V0cyhzdGQ6Om1ha2VfdW5pcXVlPFZlY3RvcjxMYXlvdXRVbml0Pj4oKSk7CisKKyAgICBWZWN0 b3I8TGF5b3V0VW5pdD4gaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZTsKKyAgICBWZWN0 b3I8TGF5b3V0VW5pdD4gdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAgaWYgKHN0 eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkgfHwgc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVt ZW50c1koKSkKKyAgICAgICAgYXBwZW5kQW5kU29ydENoaWxkU25hcE9mZnNldHMoc2Nyb2xsaW5n RWxlbWVudCwgY29tcHV0ZUhvcml6b250YWxTbmFwT2Zmc2V0cywgaG9yaXpvbnRhbFNuYXBPZmZz ZXRTdWJzZXF1ZW5jZSwgY29tcHV0ZVZlcnRpY2FsU25hcE9mZnNldHMsIHZlcnRpY2FsU25hcE9m ZnNldFN1YnNlcXVlbmNlKTsKKworICAgIGlmIChjb21wdXRlSG9yaXpvbnRhbFNuYXBPZmZzZXRz KSB7CisgICAgICAgIGlmICghc3R5bGUuc2Nyb2xsU25hcFVzZXNFbGVtZW50c1goKSkgeworICAg ICAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHN0eWxlLnNjcm9sbFNuYXBPZmZzZXRz WCgpKQorICAgICAgICAgICAgICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBw ZW5kKHZhbHVlRm9yTGVuZ3RoKHNuYXBMZW5ndGgsIHZpZXdXaWR0aCkpOworCisgICAgICAgICAg ICBzdGQ6OnNvcnQoaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5iZWdpbigpLCBob3Jp em9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLmVuZCgpKTsKKyAgICAgICAgfQorICAgICAgICBp ZiAoIWhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICAgICAg aG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICAgICAgdXBk YXRlRnJvbVN0eWxlKHNjcm9sbGFibGVBcmVhLmhvcml6b250YWxTbmFwT2Zmc2V0cygpLCBzdHls ZSwgU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsLCB2aWV3V2lkdGgsIHNjcm9sbFdpZHRoLCBo b3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAgICB9CisgICAgaWYgKGNvbXB1dGVW ZXJ0aWNhbFNuYXBPZmZzZXRzKSB7CisgICAgICAgIGlmICghc3R5bGUuc2Nyb2xsU25hcFVzZXNF bGVtZW50c1koKSkgeworICAgICAgICAgICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHN0eWxl LnNjcm9sbFNuYXBPZmZzZXRzWSgpKQorICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNl dFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3SGVpZ2h0 KSk7CisKKyAgICAgICAgICAgIHN0ZDo6c29ydCh2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZS5iZWdpbigpLCB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7CisgICAgICAg IH0KKyAgICAgICAgaWYgKCF2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5zaXplKCkpCisg ICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAg ICAgICAgdXBkYXRlRnJvbVN0eWxlKHNjcm9sbGFibGVBcmVhLnZlcnRpY2FsU25hcE9mZnNldHMo KSwgc3R5bGUsIFNjcm9sbEV2ZW50QXhpczo6VmVydGljYWwsIHZpZXdIZWlnaHQsIHNjcm9sbEhl aWdodCwgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOworICAgIH0KK30KKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjY5ZDE4NDdjYTBjMTMzYTM4MWVlZTE3Mzg3ZDFiOTQ4OWQ0NjhiOWEKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25h cE9mZnNldHMuaApAQCAtMCwwICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJ UycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9S UworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUwor ICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisg KiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBeGlzU2Ny b2xsU25hcE9mZnNldHNfaAorI2RlZmluZSBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAorCisjaWYg RU5BQkxFKENTU19TQ1JPTExfU05BUCkKKworI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNs dWRlICJTY3JvbGxUeXBlcy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEhUTUxFbGVt ZW50OworY2xhc3MgUmVuZGVyQm94OworY2xhc3MgUmVuZGVyU3R5bGU7CitjbGFzcyBTY3JvbGxh YmxlQXJlYTsKKwordm9pZCB1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKFNjcm9s bGFibGVBcmVhJiwgSFRNTEVsZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNvbnN0IFJlbmRlckJv eCYsIGNvbnN0IFJlbmRlclN0eWxlJik7CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIENTU19TQ1JPTExfU05BUAorCisjZW5kaWYgLy8gQXhpc1Njcm9sbFNuYXBPZmZzZXRz X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcAppbmRleCBjN2Q5 NDk0NTQ3MTFmODNjNmJkN2JiNTEwY2IyMzFjODkxMjgwMTAwLi4wNmE0NzU4YmI4NDc4MjZhOGE3 M2I3OWVlNjk4MjU2NjFhOTE3ZjhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9TY3JvbGxhYmxlQXJlYS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xs YWJsZUFyZWEuY3BwCkBAIC00NSw3ICs0NSwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0 cnVjdCBTYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewogICAgIHZpcnR1YWwgflNhbWVTaXplQXNT Y3JvbGxhYmxlQXJlYSgpOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgdm9pZCog cG9pbnRlcnNbM107CisjZWxzZQogICAgIHZvaWQqIHBvaW50ZXI7CisjZW5kaWYKICAgICBJbnRQ b2ludCBvcmlnaW47CiAgICAgdW5zaWduZWQgYml0ZmllbGRzIDogMTY7CiB9OwpAQCAtMzc2LDYg KzM4MCwyOCBAQCBib29sIFNjcm9sbGFibGVBcmVhOjpoYXNMYXllckZvclNjcm9sbENvcm5lcigp IGNvbnN0CiAgICAgcmV0dXJuIGxheWVyRm9yU2Nyb2xsQ29ybmVyKCk7CiB9CiAKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBTY3JvbGxhYmxlQXJlYTo6c2V0SG9yaXpvbnRhbFNu YXBPZmZzZXRzKHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IGhvcml6b250YWxT bmFwT2Zmc2V0cykKK3sKKyAgICBtX2hvcml6b250YWxTbmFwT2Zmc2V0cyA9IFdURjo6bW92ZSho b3Jpem9udGFsU25hcE9mZnNldHMpOworfQorCit2b2lkIFNjcm9sbGFibGVBcmVhOjpzZXRWZXJ0 aWNhbFNuYXBPZmZzZXRzKHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IHZlcnRp Y2FsU25hcE9mZnNldHMpCit7CisgICAgbV92ZXJ0aWNhbFNuYXBPZmZzZXRzID0gV1RGOjptb3Zl KHZlcnRpY2FsU25hcE9mZnNldHMpOworfQorCit2b2lkIFNjcm9sbGFibGVBcmVhOjpjbGVhckhv cml6b250YWxTbmFwT2Zmc2V0cygpCit7CisgICAgbV9ob3Jpem9udGFsU25hcE9mZnNldHMucmVz ZXQoKTsKK30KKwordm9pZCBTY3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRz KCkKK3sKKyAgICBtX3ZlcnRpY2FsU25hcE9mZnNldHMucmVzZXQoKTsKK30KKyNlbmRpZgorCiB2 b2lkIFNjcm9sbGFibGVBcmVhOjpzZXJ2aWNlU2Nyb2xsQW5pbWF0aW9ucygpCiB7CiAgICAgaWYg KFNjcm9sbEFuaW1hdG9yKiBzY3JvbGxBbmltYXRvciA9IGV4aXN0aW5nU2Nyb2xsQW5pbWF0b3Io KSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCmluZGV4IDJmZTI3NDkx NDUyOGZhNTA3YTMxOGE0NWVhOTEwMDZlMWUyODRmMWIuLjQ1MmQ3MjlmMWU1OWZiNDU4ODUwNjMw ODg5MzU3MTI3OTA3MGIzM2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbGFibGVBcmVhLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFy ZWEuaApAQCAtNTgsNiArNTgsMTYgQEAgcHVibGljOgogCiAgICAgYm9vbCBoYW5kbGVXaGVlbEV2 ZW50KGNvbnN0IFBsYXRmb3JtV2hlZWxFdmVudCYpOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4qIGhvcml6b250YWxTbmFwT2Zmc2V0cygpIGNv bnN0IHsgcmV0dXJuIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzLmdldCgpOyB9OworICAgIFZlY3Rv cjxMYXlvdXRVbml0PiogdmVydGljYWxTbmFwT2Zmc2V0cygpIGNvbnN0IHsgcmV0dXJuIG1fdmVy dGljYWxTbmFwT2Zmc2V0cy5nZXQoKTsgfTsKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9m ZnNldHMoKSB7IH07CisgICAgdm9pZCBzZXRIb3Jpem9udGFsU25hcE9mZnNldHMoc3RkOjp1bmlx dWVfcHRyPFZlY3RvcjxMYXlvdXRVbml0Pj4pOworICAgIHZvaWQgc2V0VmVydGljYWxTbmFwT2Zm c2V0cyhzdGQ6OnVuaXF1ZV9wdHI8VmVjdG9yPExheW91dFVuaXQ+Pik7CisgICAgdm9pZCBjbGVh ckhvcml6b250YWxTbmFwT2Zmc2V0cygpOworICAgIHZvaWQgY2xlYXJWZXJ0aWNhbFNuYXBPZmZz ZXRzKCk7CisjZW5kaWYKKwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgdmlydHVhbCBi b29sIGlzVG91Y2hTY3JvbGxhYmxlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0 dWFsIGJvb2wgaGFuZGxlVG91Y2hFdmVudChjb25zdCBQbGF0Zm9ybVRvdWNoRXZlbnQmKTsKQEAg LTI3NSw2ICsyODUsMTEgQEAgcHJpdmF0ZToKIAogICAgIG11dGFibGUgT3duUHRyPFNjcm9sbEFu aW1hdG9yPiBtX3Njcm9sbEFuaW1hdG9yOwogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkK KyAgICBzdGQ6OnVuaXF1ZV9wdHI8VmVjdG9yPExheW91dFVuaXQ+PiBtX2hvcml6b250YWxTbmFw T2Zmc2V0czsKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8VmVjdG9yPExheW91dFVuaXQ+PiBtX3ZlcnRp Y2FsU25hcE9mZnNldHM7CisjZW5kaWYKKwogICAgIC8vIFRoZXJlIGFyZSA4IHBvc3NpYmxlIGNv bWJpbmF0aW9ucyBvZiB3cml0aW5nIG1vZGUgYW5kIGRpcmVjdGlvbi4gU2Nyb2xsIG9yaWdpbiB3 aWxsIGJlIG5vbi16ZXJvIGluIHRoZSB4IG9yIHkgYXhpcwogICAgIC8vIGlmIHRoZXJlIGlzIGFu eSByZXZlcnNlZCBkaXJlY3Rpb24gb3Igd3JpdGluZy1tb2RlLiBUaGUgY29tYmluYXRpb25zIGFy ZToKICAgICAvLyB3cml0aW5nLW1vZGUgLyBkaXJlY3Rpb24gICAgIHNjcm9sbE9yaWdpbi54KCkg c2V0ICAgIHNjcm9sbE9yaWdpbi55KCkgc2V0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxheWVyLmNwcAppbmRleCAwM2QwZjZiN2QzZTNlNTk5M2IyOGQ0YmIzYTlmYzMwZmJlNDBjNWQ2 Li5kNjZkYTEzYzhiYzFjMWZmMTY2NTAwODMzYzMxZTQwYWUwODQxOTgwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKQEAgLTEyMiw2ICsxMjIsMTAgQEAKICNpbmNs dWRlICJSZW5kZXJMYXllckZpbHRlckluZm8uaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKENTU19T Q1JPTExfU05BUCkKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCIKKyNlbmRpZgor CiAjZGVmaW5lIE1JTl9JTlRFUlNFQ1RfRk9SX1JFVkVBTCAzMgogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CkBAIC0zMDI4LDYgKzMwMzIsMTggQEAgU2Nyb2xsYWJsZUFyZWEqIFJlbmRlckxheWVyOjpl bmNsb3NpbmdTY3JvbGxhYmxlQXJlYSgpIGNvbnN0CiAgICAgcmV0dXJuIDA7CiB9CiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBSZW5kZXJMYXllcjo6dXBkYXRlU25hcE9mZnNl dHMoKQoreworICAgIC8vIEZJWE1FOiBFeHRlbmQgc3VwcG9ydCBiZXlvbmQgSFRNTEVsZW1lbnRz LgorICAgIGlmICghZW5jbG9zaW5nRWxlbWVudCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPnJl bmRlckJveCgpIHx8ICFlbmNsb3NpbmdFbGVtZW50KCktPmlzSFRNTEVsZW1lbnQoKSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgUmVuZGVyQm94KiBib3ggPSBlbmNsb3NpbmdFbGVtZW50KCktPnJl bmRlckJveCgpOworICAgIHVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoKnRoaXMs ICp0b0hUTUxFbGVtZW50KGVuY2xvc2luZ0VsZW1lbnQoKSksICpib3gsIGJveC0+c3R5bGUoKSk7 Cit9CisjZW5kaWYKKwogaW50IFJlbmRlckxheWVyOjp2ZXJ0aWNhbFNjcm9sbGJhcldpZHRoKE92 ZXJsYXlTY3JvbGxiYXJTaXplUmVsZXZhbmN5IHJlbGV2YW5jeSkgY29uc3QKIHsKICAgICBpZiAo IW1fdkJhcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVy LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaAppbmRleCAyNjY1NTlh ZmZiOGNmYTA4OGMwZWFjMDM4ZmQ2ZWI3YzlmOGIxZjQ3Li5iZDI2MWE3YTQ5ODdlNzE0N2YwMmFi ZDM1YzgwMjM0M2FmZDA0YzNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyTGF5ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIu aApAQCAtNDM5LDYgKzQzOSw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFNjcm9sbGJhciogaG9y aXpvbnRhbFNjcm9sbGJhcigpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1faEJhci5nZXQoKTsg fQogICAgIHZpcnR1YWwgU2Nyb2xsYmFyKiB2ZXJ0aWNhbFNjcm9sbGJhcigpIGNvbnN0IG92ZXJy aWRlIHsgcmV0dXJuIG1fdkJhci5nZXQoKTsgfQogICAgIHZpcnR1YWwgU2Nyb2xsYWJsZUFyZWEq IGVuY2xvc2luZ1Njcm9sbGFibGVBcmVhKCkgY29uc3Qgb3ZlcnJpZGU7CisjaWYgRU5BQkxFKENT U19TQ1JPTExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSBvdmVy cmlkZTsKKyNlbmRpZgogCiAjaWYgUExBVEZPUk0oSU9TKQogI2lmIEVOQUJMRShUT1VDSF9FVkVO VFMpCg== 236558 2014-08-13 15:37:43 -0700 2014-08-13 15:43:25 -0700 Patch bug-135268-20140813153730.patch text/plain 24504 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTM1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjVhYzNmNTY0NDBkNzA3 MmQ0Njk0Mzk3ZDM3OWYyODE0MmY0YWE5Yy4uNzI2OTZkOTc4Y2E4ZjdhMGQ0Nzk2ZjE4ZjM2MzZm NjFjOGM4OWRiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE0LTA4LTEzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorICAgICAgICAKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVWaWV3Ojp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0YXRpYyByb3V0aW5lIGlu IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZzZXRzIGZvciBtYWluZnJh bWUuCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGlu Zy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmFw cGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKToKKyAgICAgICAgKFdlYkNvcmU6OnVwZGF0ZUZy b21TdHlsZSk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFi bGVBcmVhKTogVXBkYXRlIHRoZSBTY3JvbGxhYmxlQXJlYSdzIHNuYXAgYXhlcy4KKyAgICAgICAg KiBwYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaDogQWRkZWQuCisgICAgICAg ICogcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xs YWJsZUFyZWE6OnNldEhvcml6b250YWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JvbGxhYmxlQXJlYTo6c2V0VmVydGljYWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJIb3Jpem9udGFsU25hcE9mZnNldHMpOiBSZXNldHMgdGhl IHVuaXF1ZV9wdHIgZm9yIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKTogUmVzZXRzIHRoZSB1 bmlxdWVfcHRyIGZvciB2ZXJ0aWNhbCBzbmFwIHBvaW50cy4KKyAgICAgICAgKiBwbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5oOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsYWJsZUFyZWE6Omhvcml6 b250YWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3JvbGxhYmxlQXJl YSdzIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxl QXJlYTo6dmVydGljYWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3Jv bGxhYmxlQXJlYSdzIHZlcnRpY2FsIHNuYXAgcG9pbnRzLgorICAgICAgICAoV2ViQ29yZTo6U2Ny b2xsYWJsZUFyZWE6OnVwZGF0ZVNuYXBPZmZzZXRzKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBP ZmZzZXRzKTogSW52b2tlcyB0aGUgc3RhdGljIHJvdXRpbmUgaW4gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzIHRvIHVwZGF0ZSBzbmFwIG9mZnNldHMgZm9yIGFuIG92ZXJmbG93IGFyZWEuCisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMTMgIEFsZXggQ2hyaXN0ZW5z ZW4gIDxhY2hyaXN0ZW5zZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZW1vdmVkIGRlYWQgcGx1 Z2lucyBjb2RlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCmluZGV4IGEyOGVlMWEzZDMxMjFlMDk1ZGY5YTllNTA1MDc4ZGM0Yjk2MWFmN2Eu LmYwYWEwNDFkY2IyN2JlM2U4MmY4OGNiOGFkMTY2MzhmODU1Mzk1ZTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTYyNDUsNiAr NjI0NSw4IEBACiAJCUYzRjVDRjExMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xl SW5zdHJ1bWVudGF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGM0Y1Q0YxMDEyRUQ4MUE4MDA4NEM1NjkgLyogSW5zcGVjdG9yQ29uc29sZUluc3Ry dW1lbnRhdGlvbi5oICovOyB9OwogCQlGM0Y1Q0YxMzEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVj dG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEYzRjVDRjEyMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0b3JE YXRhYmFzZUluc3RydW1lbnRhdGlvbi5oICovOyB9OwogCQlGNDJGRkI0NjE5ODRCNzE2MDBGNjgz N0YgLyogTGVuZ3RoUmVwZWF0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGNDJGRkI0NTE5ODRCNzE2MDBGNjgzN0YgLyogTGVuZ3RoUmVwZWF0LmggKi87 IH07CisJCUY0NUMyMzFEMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIz MUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi87IH07CisJ CUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3 M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRU UklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDdBNUUzRTE5NUI4QzhBMDA0ODMxMDAg LyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxT bmFwUG9pbnRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJRjQ3QTVFM0YxOTVCOEU0ODAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDdBNUUz QTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLzsgfTsKIAkJ RjUwNjY0RjcxNTdGNTJEQzAwQUMyMjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY1MDY2NEY1MTU3RjUyREMwMEFD MjI2RiAvKiBGb3JtQ29udHJvbGxlci5jcHAgKi87IH07CkBAIC0xMzc2Miw2ICsxMzc2NCw4IEBA CiAJCUYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1bWVu dGF0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckNvbnNv bGVJbnN0cnVtZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjNGNUNG MTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1bWVudGF0aW9uLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluc3BlY3RvckRhdGFiYXNlSW5zdHJ1 bWVudGF0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0MkZGQjQ1MTk4NEI3 MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gTGVuZ3RoUmVwZWF0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NUMy MzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8q IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RjQ3QTVFM0ExOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xsU25hcFBvaW50cy5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBTdHlsZVNjcm9sbFNuYXBQb2ludHMu Y3BwOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRjQ3QTVFM0IxOTVCOEM4QTAwNDgzMTAwIC8qIFN0eWxlU2Nyb2xs U25hcFBvaW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBTdHlsZVNjcm9s bFNuYXBQb2ludHMuaDsgcGF0aCA9IHN0eWxlL1N0eWxlU2Nyb2xsU25hcFBvaW50cy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNTA2NjRGNTE1N0Y1MkRDMDBBQzIyNkYgLyogRm9y bUNvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9y bUNvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTUxMzcsNiAr MTUxNDEsOCBAQAogCQkJCTkzOTFBOTlCMTYyOUQ3MDAwMDI5NzMzMCAvKiBTY3JvbGxpbmdUcmVl U2Nyb2xsaW5nTm9kZS5oICovLAogCQkJCTBGNjM4M0RCMTg2MTVCMjkwMDNFNURCNSAvKiBUaHJl YWRlZFNjcm9sbGluZ1RyZWUuY3BwICovLAogCQkJCTBGNjM4M0RDMTg2MTVCMjkwMDNFNURCNSAv KiBUaHJlYWRlZFNjcm9sbGluZ1RyZWUuaCAqLywKKwkJCQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUy RTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLywKKwkJCQlGNDVDMjMxQzE5OTVCNzNC MDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9 IHNjcm9sbGluZzsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0yNDQxOSw2ICsyNDQy NSw3IEBACiAJCQkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50 LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVBNzlGNjBBMTkxNkRGMDBBOEVGNUYgLyogSFRNTExJ RWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg3MURDMjAwQTE1MjA1NzAwQjEyQTY4IC8q IEhUTUxMaW5rRWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRjQ1QzIzMUUxOTk1QjczQjAw QTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThF QTdEMkMwQTE5Mzg1NTAwQThFRjVGIC8qIEhUTUxNYXBFbGVtZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQlBOEVBN0NBQjBBMTkyQjlDMDBBOEVGNUYgLyogSFRNTE1hcnF1ZWVFbGVtZW50LmggaW4g SGVhZGVycyAqLywKIAkJCQlFNDQ2MTNBNTBDRDYzMzEwMDBGQURBNzUgLyogSFRNTE1lZGlhRWxl bWVudC5oIGluIEhlYWRlcnMgKi8sCkBAIC0yNzc1NCw2ICsyNzc2MSw3IEBACiAJCQkJQjJBRkZD N0QwRDAwQTVDMTAwMzAwNzREIC8qIEZvbnRDdXN0b21QbGF0Zm9ybURhdGEuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJMzcxRjRGNDEwRDI1QjlBRjAwRUNFMEQ1IC8qIEZvbnREYXRhLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTM3QUNDRjY5MERBNDE0RTcwMDg5RTYwMiAvKiBGb250RGVzY3JpcHRp b24uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4 aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3MjYyNkUwMjBFRjAy MkZFMDBBMDdFMjAgLyogRm9udEZhc3RQYXRoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTRBNkU5 RkM3MTNDMTdENTcwMDQ2QTdGOCAvKiBGb250RmVhdHVyZVNldHRpbmdzLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCUU0NEVFM0E4MTc1NzdFQkQwMEVFRThDRiAvKiBGb250R2VuZXJpY0ZhbWlsaWVz LmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDM4MTA3 MWQ4NzA0NTEwMjE2NzU4OTI0MjlmZGE0ODlhODQyNTU3ZjkuLmNiZTdiZGI0OTZiY2Y5N2M3NzJi YmI1OWNkZGNhNWJiOGVhYmYwYmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTk4 LDYgKzk4LDEwIEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogI2VuZGlmCiAKKyNpZiBF TkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5o IgorI2VuZGlmCisKICNpZiBQTEFURk9STShJT1MpCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIu aCIKICNpbmNsdWRlICJMZWdhY3lUaWxlQ2FjaGUuaCIKQEAgLTg0Nyw2ICs4NTEsMjEgQEAgR3Jh cGhpY3NMYXllciogRnJhbWVWaWV3OjpzZXRXYW50c0xheWVyRm9yQm90dG9tT3ZlckhhbmdBcmVh KGJvb2wgd2FudHNMYXllcikgY28KIAogI2VuZGlmIC8vIEVOQUJMRShSVUJCRVJfQkFORElORykK IAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCit2b2lkIEZyYW1lVmlldzo6dXBkYXRlU25h cE9mZnNldHMoKQoreworICAgIGlmICghZnJhbWUoKS5kb2N1bWVudCgpKQorICAgICAgICByZXR1 cm47CisKKyAgICAvLyBGSVhNRTogU2hvdWxkIHdlIGFsbG93IHNwZWNpZnlpbmcgc25hcCBwb2lu dHMgdGhyb3VnaCA8aHRtbD4gdGFncyB0b28/CisgICAgSFRNTEVsZW1lbnQqIGJvZHkgPSBmcmFt ZSgpLmRvY3VtZW50KCktPmJvZHkoKTsKKyAgICBpZiAoIXJlbmRlclZpZXcoKSB8fCAhYm9keSB8 fCAhYm9keS0+cmVuZGVyZXIoKSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIHVwZGF0ZVNu YXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoKnRoaXMsICpib2R5LCAqcmVuZGVyVmlldygpLCBi b2R5LT5yZW5kZXJlcigpLT5zdHlsZSgpKTsKK30KKyNlbmRpZgorCiBib29sIEZyYW1lVmlldzo6 Zmx1c2hDb21wb3NpdGluZ1N0YXRlRm9yVGhpc0ZyYW1lKEZyYW1lKiByb290RnJhbWVGb3JGbHVz aCkKIHsKICAgICBSZW5kZXJWaWV3KiByZW5kZXJWaWV3ID0gdGhpcy0+cmVuZGVyVmlldygpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWVWaWV3LmgKaW5kZXggZGJlOWQ1ZGE4Yzc0MGY5ODE3YTNiNDkzOWZiZmU3 OGJlNDA0ZTUzMS4uOTc4ZjU0NDk4YmE5ODM2YWMyMjMzOTRjYmNiOGU3NzAzMWFlZTZkZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5oCkBAIC00OTYsNiArNDk2LDEwIEBAIHB1YmxpYzoKICAgICB2 b2lkIHNldEV4cG9zZWRSZWN0KEZsb2F0UmVjdCk7CiAgICAgRmxvYXRSZWN0IGV4cG9zZWRSZWN0 KCkgY29uc3QgeyByZXR1cm4gbV9leHBvc2VkUmVjdDsgfQogCisjaWYgRU5BQkxFKENTU19TQ1JP TExfU05BUCkKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlU25hcE9mZnNldHMoKSBvdmVycmlkZTsK KyNlbmRpZgorCiBwcm90ZWN0ZWQ6CiAgICAgdmlydHVhbCBib29sIHNjcm9sbENvbnRlbnRzRmFz dFBhdGgoY29uc3QgSW50U2l6ZSYgc2Nyb2xsRGVsdGEsIGNvbnN0IEludFJlY3QmIHJlY3RUb1Nj cm9sbCwgY29uc3QgSW50UmVjdCYgY2xpcFJlY3QpIG92ZXJyaWRlOwogICAgIHZpcnR1YWwgdm9p ZCBzY3JvbGxDb250ZW50c1Nsb3dQYXRoKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QpIG92ZXJy aWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL0F4aXNTY3Jv bGxTbmFwT2Zmc2V0cy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDRlMTJlOGFiMDRlNDA3MDUyMDBhZmI2N2Jl MTFjNDg3ZmUzOTkyNQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Ny b2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAKQEAgLTAsMCArMSwxNDcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQg SVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZz ZXRzLmgiCisKKyNpbmNsdWRlICJIVE1MQ29sbGVjdGlvbi5oIgorI2luY2x1ZGUgIkhUTUxFbGVt ZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94LmgiCisjaW5jbHVkZSAiU2Nyb2xsYWJsZUFyZWEu aCIKKworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK Kworc3RhdGljIHZvaWQgYXBwZW5kQ2hpbGRTbmFwT2Zmc2V0cyhIVE1MRWxlbWVudCYgcGFyZW50 LCBib29sIHNob3VsZEFkZEhvcml6b250YWxDaGlsZE9mZnNldHMsIFZlY3RvcjxMYXlvdXRVbml0 PiYgaG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZSwgYm9vbCBzaG91bGRBZGRWZXJ0aWNh bENoaWxkT2Zmc2V0cywgVmVjdG9yPExheW91dFVuaXQ+JiB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJz ZXF1ZW5jZSkKK3sKKyAgICBFbGVtZW50KiBjaGlsZCA9IHBhcmVudC5jaGlsZHJlbigpLT5jb2xs ZWN0aW9uQmVnaW4oKTsKKyAgICAvLyBGSVhNRTogSW5zdGVhZCBvZiB0cmF2ZXJzaW5nIGFsbCBj aGlsZHJlbiwgcmVnaXN0ZXIgY2hpbGRyZW4gd2l0aCBzbmFwIGNvb3JkaW5hdGVzIGJlZm9yZSBh cHBlbmRpbmcgdG8gc25hcE9mZnNldFN1YnNlcXVlbmNlLgorICAgIHdoaWxlIChjaGlsZCkgewor ICAgICAgICBpZiAoUmVuZGVyQm94KiBib3ggPSBjaGlsZC0+cmVuZGVyQm94KCkpIHsKKyAgICAg ICAgICAgIExheW91dFVuaXQgdmlld1dpZHRoID0gYm94LT53aWR0aCgpOworICAgICAgICAgICAg TGF5b3V0VW5pdCB2aWV3SGVpZ2h0ID0gYm94LT5oZWlnaHQoKTsKKyAgICAgICAgICAgIC8vIEZJ WE1FOiBDaGVjayBiZWhhdmlvciB3aXRoIENTUyByb3RhdGlvbnMuCisgICAgICAgICAgICBGbG9h dFBvaW50IHBvc2l0aW9uID0gYm94LT5sb2NhbFRvQ29udGFpbmVyUG9pbnQoRmxvYXRQb2ludCgp LCBwYXJlbnQucmVuZGVyQm94KCkpOworICAgICAgICAgICAgZm9yIChTbmFwQ29vcmRpbmF0ZSBj b29yZGluYXRlIDogYm94LT5zdHlsZSgpLnNjcm9sbFNuYXBDb29yZGluYXRlcygpKSB7CisgICAg ICAgICAgICAgICAgTGF5b3V0VW5pdCBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA9IExheW91 dFVuaXQocG9zaXRpb24ueCgpKSArIHZhbHVlRm9yTGVuZ3RoKGNvb3JkaW5hdGUuZmlyc3QsIHZp ZXdXaWR0aCk7CisgICAgICAgICAgICAgICAgaWYgKHNob3VsZEFkZEhvcml6b250YWxDaGlsZE9m ZnNldHMgJiYgbGFzdFBvdGVudGlhbFNuYXBQb3NpdGlvblggPiAwKQorICAgICAgICAgICAgICAg ICAgICBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZChsYXN0UG90ZW50aWFs U25hcFBvc2l0aW9uWCk7CisKKyAgICAgICAgICAgICAgICBMYXlvdXRVbml0IGxhc3RQb3RlbnRp YWxTbmFwUG9zaXRpb25ZID0gTGF5b3V0VW5pdChwb3NpdGlvbi55KCkpICsgdmFsdWVGb3JMZW5n dGgoY29vcmRpbmF0ZS5zZWNvbmQsIHZpZXdIZWlnaHQpOworICAgICAgICAgICAgICAgIGlmIChz aG91bGRBZGRWZXJ0aWNhbENoaWxkT2Zmc2V0cyAmJiBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9u WSA+IDApCisgICAgICAgICAgICAgICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNl LmFwcGVuZChsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWSk7CisgICAgICAgICAgICB9CisgICAg ICAgIH0KKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEVsZW1lbnRTaWJsaW5nKCk7CisgICAg fQorfQorCitzdGF0aWMgdm9pZCB1cGRhdGVGcm9tU3R5bGUoVmVjdG9yPExheW91dFVuaXQ+KiBz bmFwT2Zmc2V0cywgY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlLCBTY3JvbGxFdmVudEF4aXMgYXhp cywgTGF5b3V0VW5pdCB2aWV3U2l6ZSwgTGF5b3V0VW5pdCBzY3JvbGxTaXplLCBWZWN0b3I8TGF5 b3V0VW5pdD4mIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZSkKK3sKKyAgICBzdGQ6OnNvcnQoc25hcE9m ZnNldFN1YnNlcXVlbmNlLmJlZ2luKCksIHNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5lbmQoKSk7Cisg ICAgaWYgKCFzbmFwT2Zmc2V0U3Vic2VxdWVuY2Uuc2l6ZSgpKQorICAgICAgICBzbmFwT2Zmc2V0 U3Vic2VxdWVuY2UuYXBwZW5kKDApOworCisgICAgYm9vbCBpc0hvcml6b250YWxBeGlzID0gYXhp cyA9PSBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWw7CisgICAgYm9vbCBoYXNSZXBlYXQgPSBp c0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcEhhc1JlcGVhdFgoKSA6IHN0eWxlLnNj cm9sbFNuYXBIYXNSZXBlYXRZKCk7CisgICAgTGF5b3V0VW5pdCByZXBlYXRPZmZzZXQgPSB2YWx1 ZUZvckxlbmd0aChpc0hvcml6b250YWxBeGlzID8gc3R5bGUuc2Nyb2xsU25hcFJlcGVhdE9mZnNl dFgoKSA6IHN0eWxlLnNjcm9sbFNuYXBSZXBlYXRPZmZzZXRZKCksIHZpZXdTaXplKTsKKyAgICBM YXlvdXRVbml0IGRlc3RpbmF0aW9uT2Zmc2V0ID0gdmFsdWVGb3JMZW5ndGgoaXNIb3Jpem9udGFs QXhpcyA/IHN0eWxlLnNjcm9sbFNuYXBEZXN0aW5hdGlvblgoKSA6IHN0eWxlLnNjcm9sbFNuYXBE ZXN0aW5hdGlvblkoKSwgdmlld1NpemUpOworICAgIExheW91dFVuaXQgY3VyU25hcFBvc2l0aW9u U2hpZnQgPSAwOworICAgIExheW91dFVuaXQgbWF4U2Nyb2xsT2Zmc2V0ID0gc2Nyb2xsU2l6ZSAt IHZpZXdTaXplOworICAgIExheW91dFVuaXQgbGFzdFNuYXBQb3NpdGlvbiA9IGN1clNuYXBQb3Np dGlvblNoaWZ0OworICAgIHNuYXBPZmZzZXRzLT5hcHBlbmQoMCk7CisgICAgZG8geworICAgICAg ICBmb3IgKExheW91dFVuaXQgc25hcFBvc2l0aW9uIDogc25hcE9mZnNldFN1YnNlcXVlbmNlKSB7 CisgICAgICAgICAgICBMYXlvdXRVbml0IHBvdGVudGlhbFNuYXBQb3NpdGlvbiA9IGN1clNuYXBQ b3NpdGlvblNoaWZ0ICsgc25hcFBvc2l0aW9uIC0gZGVzdGluYXRpb25PZmZzZXQ7CisgICAgICAg ICAgICBpZiAocG90ZW50aWFsU25hcFBvc2l0aW9uIDw9IDApCisgICAgICAgICAgICAgICAgY29u dGludWU7CisKKyAgICAgICAgICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPj0gbWF4U2Ny b2xsT2Zmc2V0KQorICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBzbmFwT2Zm c2V0cy0+YXBwZW5kKHBvdGVudGlhbFNuYXBQb3NpdGlvbik7CisgICAgICAgICAgICBsYXN0U25h cFBvc2l0aW9uID0gcG90ZW50aWFsU25hcFBvc2l0aW9uICsgZGVzdGluYXRpb25PZmZzZXQ7Cisg ICAgICAgIH0KKyAgICAgICAgY3VyU25hcFBvc2l0aW9uU2hpZnQgPSBsYXN0U25hcFBvc2l0aW9u ICsgcmVwZWF0T2Zmc2V0OworICAgIH0gd2hpbGUgKGhhc1JlcGVhdCAmJiBjdXJTbmFwUG9zaXRp b25TaGlmdCA8IG1heFNjcm9sbE9mZnNldCk7CisgICAgLy8gQWx3YXlzIHB1dCBhIHNuYXAgcG9p bnQgb24gdGhlIG1heGltdW0gc2Nyb2xsIG9mZnNldC4KKyAgICAvLyBOb3QgYSBwYXJ0IG9mIHRo ZSBzcGVjLCBidXQgbmVjZXNzYXJ5IHRvIHByZXZlbnQgdW5yZWFjaGFibGUgY29udGVudCB3aGVu IHNuYXBwaW5nLgorICAgIGlmIChzbmFwT2Zmc2V0cy0+bGFzdCgpICE9IG1heFNjcm9sbE9mZnNl dCkKKyAgICAgICAgc25hcE9mZnNldHMtPmFwcGVuZChtYXhTY3JvbGxPZmZzZXQpOworfQorCit2 b2lkIHVwZGF0ZVNuYXBPZmZzZXRzRm9yU2Nyb2xsYWJsZUFyZWEoU2Nyb2xsYWJsZUFyZWEmIHNj cm9sbGFibGVBcmVhLCBIVE1MRWxlbWVudCYgc2Nyb2xsaW5nRWxlbWVudCwgY29uc3QgUmVuZGVy Qm94JiBzY3JvbGxpbmdFbGVtZW50Qm94LCBjb25zdCBSZW5kZXJTdHlsZSYgc2Nyb2xsaW5nRWxl bWVudFN0eWxlKQoreworICAgIGlmIChzY3JvbGxpbmdFbGVtZW50U3R5bGUuc2Nyb2xsU25hcFR5 cGUoKSA9PSBTY3JvbGxTbmFwVHlwZTo6Tm9uZSkgeworICAgICAgICBzY3JvbGxhYmxlQXJlYS5j bGVhckhvcml6b250YWxTbmFwT2Zmc2V0cygpOworICAgICAgICBzY3JvbGxhYmxlQXJlYS5jbGVh clZlcnRpY2FsU25hcE9mZnNldHMoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBMYXlv dXRVbml0IHZpZXdXaWR0aCA9IHNjcm9sbGluZ0VsZW1lbnRCb3gud2lkdGgoKTsKKyAgICBMYXlv dXRVbml0IHZpZXdIZWlnaHQgPSBzY3JvbGxpbmdFbGVtZW50Qm94LmhlaWdodCgpOworICAgIExh eW91dFVuaXQgc2Nyb2xsV2lkdGggPSBzY3JvbGxpbmdFbGVtZW50Qm94LnNjcm9sbFdpZHRoKCk7 CisgICAgTGF5b3V0VW5pdCBzY3JvbGxIZWlnaHQgPSBzY3JvbGxpbmdFbGVtZW50Qm94LnNjcm9s bEhlaWdodCgpOworICAgIGJvb2wgY2FuQ29tcHV0ZUhvcml6b250YWxPZmZzZXRzID0gc2Nyb2xs V2lkdGggPiAwICYmIHZpZXdXaWR0aCA+IDAgJiYgdmlld1dpZHRoIDwgc2Nyb2xsV2lkdGg7Cisg ICAgYm9vbCBjYW5Db21wdXRlVmVydGljYWxPZmZzZXRzID0gc2Nyb2xsSGVpZ2h0ID4gMCAmJiB2 aWV3SGVpZ2h0ID4gMCAmJiB2aWV3SGVpZ2h0IDwgc2Nyb2xsSGVpZ2h0OworICAgIGlmICghY2Fu Q29tcHV0ZUhvcml6b250YWxPZmZzZXRzKQorICAgICAgICBzY3JvbGxhYmxlQXJlYS5jbGVhckhv cml6b250YWxTbmFwT2Zmc2V0cygpOworCisgICAgaWYgKCFjYW5Db21wdXRlVmVydGljYWxPZmZz ZXRzKQorICAgICAgICBzY3JvbGxhYmxlQXJlYS5jbGVhclZlcnRpY2FsU25hcE9mZnNldHMoKTsK KworICAgIGlmICghY2FuQ29tcHV0ZUhvcml6b250YWxPZmZzZXRzICYmICFjYW5Db21wdXRlVmVy dGljYWxPZmZzZXRzKQorICAgICAgICByZXR1cm47CisKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4g aG9yaXpvbnRhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZTsKKyAgICBWZWN0b3I8TGF5b3V0VW5pdD4g dmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2U7CisgICAgaWYgKHNjcm9sbGluZ0VsZW1lbnRT dHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWCgpIHx8IHNjcm9sbGluZ0VsZW1lbnRTdHlsZS5z Y3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgpKQorICAgICAgICBhcHBlbmRDaGlsZFNuYXBPZmZzZXRz KHNjcm9sbGluZ0VsZW1lbnQsIHNjcm9sbGluZ0VsZW1lbnRTdHlsZS5zY3JvbGxTbmFwVXNlc0Vs ZW1lbnRzWCgpICYmIGNhbkNvbXB1dGVIb3Jpem9udGFsT2Zmc2V0cywgaG9yaXpvbnRhbFNuYXBP ZmZzZXRTdWJzZXF1ZW5jZSwgc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNjcm9sbFNuYXBVc2VzRWxl bWVudHNZKCkgJiYgY2FuQ29tcHV0ZVZlcnRpY2FsT2Zmc2V0cywgdmVydGljYWxTbmFwT2Zmc2V0 U3Vic2VxdWVuY2UpOworCisgICAgaWYgKCFzY3JvbGxpbmdFbGVtZW50U3R5bGUuc2Nyb2xsU25h cFVzZXNFbGVtZW50c1goKSAmJiBjYW5Db21wdXRlSG9yaXpvbnRhbE9mZnNldHMpIHsKKyAgICAg ICAgZm9yIChMZW5ndGggc25hcExlbmd0aCA6IHNjcm9sbGluZ0VsZW1lbnRTdHlsZS5zY3JvbGxT bmFwT2Zmc2V0c1goKSkKKyAgICAgICAgICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVu Y2UuYXBwZW5kKHZhbHVlRm9yTGVuZ3RoKHNuYXBMZW5ndGgsIHZpZXdXaWR0aCkpOworICAgIH0K KworICAgIGlmICghc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNZ KCkgJiYgY2FuQ29tcHV0ZUhvcml6b250YWxPZmZzZXRzKSB7CisgICAgICAgIGZvciAoTGVuZ3Ro IHNuYXBMZW5ndGggOiBzY3JvbGxpbmdFbGVtZW50U3R5bGUuc2Nyb2xsU25hcE9mZnNldHNZKCkp CisgICAgICAgICAgICB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5hcHBlbmQodmFsdWVG b3JMZW5ndGgoc25hcExlbmd0aCwgdmlld0hlaWdodCkpOworICAgIH0KKworICAgIHN0ZDo6dW5p cXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IGhvcml6b250YWxTbmFwT2Zmc2V0cyA9IHN0ZDo6 bWFrZV91bmlxdWU8VmVjdG9yPExheW91dFVuaXQ+PigpOworICAgIHN0ZDo6dW5pcXVlX3B0cjxW ZWN0b3I8TGF5b3V0VW5pdD4+IHZlcnRpY2FsU25hcE9mZnNldHMgPSBzdGQ6Om1ha2VfdW5pcXVl PFZlY3RvcjxMYXlvdXRVbml0Pj4oKTsKKyAgICBpZiAoY2FuQ29tcHV0ZUhvcml6b250YWxPZmZz ZXRzKSB7CisgICAgICAgIHVwZGF0ZUZyb21TdHlsZShob3Jpem9udGFsU25hcE9mZnNldHMuZ2V0 KCksIHNjcm9sbGluZ0VsZW1lbnRTdHlsZSwgU2Nyb2xsRXZlbnRBeGlzOjpIb3Jpem9udGFsLCB2 aWV3V2lkdGgsIHNjcm9sbFdpZHRoLCBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsK KyAgICAgICAgc2Nyb2xsYWJsZUFyZWEuc2V0SG9yaXpvbnRhbFNuYXBPZmZzZXRzKFdURjo6bW92 ZShob3Jpem9udGFsU25hcE9mZnNldHMpKTsKKyAgICB9CisgICAgaWYgKGNhbkNvbXB1dGVWZXJ0 aWNhbE9mZnNldHMpIHsKKyAgICAgICAgdXBkYXRlRnJvbVN0eWxlKHZlcnRpY2FsU25hcE9mZnNl dHMuZ2V0KCksIHNjcm9sbGluZ0VsZW1lbnRTdHlsZSwgU2Nyb2xsRXZlbnRBeGlzOjpWZXJ0aWNh bCwgdmlld0hlaWdodCwgc2Nyb2xsSGVpZ2h0LCB2ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5j ZSk7CisgICAgICAgIHNjcm9sbGFibGVBcmVhLnNldFZlcnRpY2FsU25hcE9mZnNldHMoV1RGOjpt b3ZlKHZlcnRpY2FsU25hcE9mZnNldHMpKTsKKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5l ZGRmYzRhMzlkMjY4NzIwNzAwNDg0OTE3MDI5OGM0NGE1NWRhMzFhCi0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgK QEAgLTAsMCArMSw0OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXhpc1Njcm9sbFNuYXBPZmZz ZXRzX2gKKyNkZWZpbmUgQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKKworI2lmIEVOQUJMRShDU1Nf U0NST0xMX1NOQVApCisKKyNpbmNsdWRlICJMYXlvdXRVbml0LmgiCisjaW5jbHVkZSAiU2Nyb2xs VHlwZXMuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBIVE1MRWxlbWVudDsKK2NsYXNz IFJlbmRlckJveDsKK2NsYXNzIFJlbmRlclN0eWxlOworY2xhc3MgU2Nyb2xsYWJsZUFyZWE7CisK K3ZvaWQgdXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYShTY3JvbGxhYmxlQXJlYSYs IEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVtZW50LCBjb25zdCBSZW5kZXJCb3gmIHNjcm9sbGlu Z0VsZW1lbnRCb3gsIGNvbnN0IFJlbmRlclN0eWxlJiBzY3JvbGxpbmdFbGVtZW50U3R5bGUpOwor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDU1NfU0NST0xMX1NOQVAKKwor I2VuZGlmIC8vIEF4aXNTY3JvbGxTbmFwT2Zmc2V0c19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9TY3JvbGxhYmxlQXJlYS5jcHAKaW5kZXggYzdkOTQ5NDU0NzExZjgzYzZiZDdiYjUxMGNiMjMx Yzg5MTI4MDEwMC4uZGUyN2RmMWM0Zjk2YTc4MmE0ZjY5OGZmZjI4OTQ1M2MzZGJiNzdmNiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcApAQCAtNDUsNyArNDUs MTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBzdHJ1Y3QgU2FtZVNpemVBc1Njcm9sbGFibGVB cmVhIHsKICAgICB2aXJ0dWFsIH5TYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEoKTsKKyNpZiBFTkFC TEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHZvaWQqIHBvaW50ZXJzWzNdOworI2Vsc2UKICAgICB2 b2lkKiBwb2ludGVyOworI2VuZGlmCiAgICAgSW50UG9pbnQgb3JpZ2luOwogICAgIHVuc2lnbmVk IGJpdGZpZWxkcyA6IDE2OwogfTsKQEAgLTM3Niw2ICszODAsMjggQEAgYm9vbCBTY3JvbGxhYmxl QXJlYTo6aGFzTGF5ZXJGb3JTY3JvbGxDb3JuZXIoKSBjb25zdAogICAgIHJldHVybiBsYXllckZv clNjcm9sbENvcm5lcigpOwogfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3ZvaWQg U2Nyb2xsYWJsZUFyZWE6OnNldEhvcml6b250YWxTbmFwT2Zmc2V0cyhzdGQ6OnVuaXF1ZV9wdHI8 VmVjdG9yPExheW91dFVuaXQ+PiBob3Jpem9udGFsU25hcE9mZnNldHMpCit7CisgICAgbV9ob3Jp em9udGFsU25hcE9mZnNldHMgPSBXVEY6Om1vdmUoaG9yaXpvbnRhbFNuYXBPZmZzZXRzKTsKK30K Kwordm9pZCBTY3JvbGxhYmxlQXJlYTo6c2V0VmVydGljYWxTbmFwT2Zmc2V0cyhzdGQ6OnVuaXF1 ZV9wdHI8VmVjdG9yPExheW91dFVuaXQ+PiB2ZXJ0aWNhbFNuYXBPZmZzZXRzKQoreworICAgIG1f dmVydGljYWxTbmFwT2Zmc2V0cyA9IFdURjo6bW92ZSh2ZXJ0aWNhbFNuYXBPZmZzZXRzKTsKK30K Kwordm9pZCBTY3JvbGxhYmxlQXJlYTo6Y2xlYXJIb3Jpem9udGFsU25hcE9mZnNldHMoKQorewor ICAgIG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gbnVsbHB0cjsKK30KKwordm9pZCBTY3JvbGxh YmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKCkKK3sKKyAgICBtX3ZlcnRpY2FsU25h cE9mZnNldHMgPSBudWxscHRyOworfQorI2VuZGlmCisKIHZvaWQgU2Nyb2xsYWJsZUFyZWE6OnNl cnZpY2VTY3JvbGxBbmltYXRpb25zKCkKIHsKICAgICBpZiAoU2Nyb2xsQW5pbWF0b3IqIHNjcm9s bEFuaW1hdG9yID0gZXhpc3RpbmdTY3JvbGxBbmltYXRvcigpKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Njcm9sbGFibGVBcmVhLmgKaW5kZXggMmZlMjc0OTE0NTI4ZmE1MDdhMzE4YTQ1ZWE5MTAw NmUxZTI4NGYxYi4uM2U5YzAzZWIxODUzZDFlMjQ0ZGNlOWQ5MjgyZDBmYTU1MTMwZGI2MiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCkBAIC01OCw2ICs1OCwxNiBA QCBwdWJsaWM6CiAKICAgICBib29sIGhhbmRsZVdoZWVsRXZlbnQoY29uc3QgUGxhdGZvcm1XaGVl bEV2ZW50Jik7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIGNvbnN0IFZlY3Rv cjxMYXlvdXRVbml0PiogaG9yaXpvbnRhbFNuYXBPZmZzZXRzKCkgY29uc3QgeyByZXR1cm4gbV9o b3Jpem9udGFsU25hcE9mZnNldHMuZ2V0KCk7IH07CisgICAgY29uc3QgVmVjdG9yPExheW91dFVu aXQ+KiB2ZXJ0aWNhbFNuYXBPZmZzZXRzKCkgY29uc3QgeyByZXR1cm4gbV92ZXJ0aWNhbFNuYXBP ZmZzZXRzLmdldCgpOyB9OworICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFwT2Zmc2V0cygpIHsg fTsKKyAgICB2b2lkIHNldEhvcml6b250YWxTbmFwT2Zmc2V0cyhzdGQ6OnVuaXF1ZV9wdHI8VmVj dG9yPExheW91dFVuaXQ+Pik7CisgICAgdm9pZCBzZXRWZXJ0aWNhbFNuYXBPZmZzZXRzKHN0ZDo6 dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+KTsKKyAgICB2b2lkIGNsZWFySG9yaXpvbnRh bFNuYXBPZmZzZXRzKCk7CisgICAgdm9pZCBjbGVhclZlcnRpY2FsU25hcE9mZnNldHMoKTsKKyNl bmRpZgorCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICAgICB2aXJ0dWFsIGJvb2wgaXNUb3Vj aFNjcm9sbGFibGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBo YW5kbGVUb3VjaEV2ZW50KGNvbnN0IFBsYXRmb3JtVG91Y2hFdmVudCYpOwpAQCAtMjc1LDYgKzI4 NSwxMSBAQCBwcml2YXRlOgogCiAgICAgbXV0YWJsZSBPd25QdHI8U2Nyb2xsQW5pbWF0b3I+IG1f c2Nyb2xsQW5pbWF0b3I7CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQorICAgIHN0ZDo6 dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IG1faG9yaXpvbnRhbFNuYXBPZmZzZXRzOwor ICAgIHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8TGF5b3V0VW5pdD4+IG1fdmVydGljYWxTbmFwT2Zm c2V0czsKKyNlbmRpZgorCiAgICAgLy8gVGhlcmUgYXJlIDggcG9zc2libGUgY29tYmluYXRpb25z IG9mIHdyaXRpbmcgbW9kZSBhbmQgZGlyZWN0aW9uLiBTY3JvbGwgb3JpZ2luIHdpbGwgYmUgbm9u LXplcm8gaW4gdGhlIHggb3IgeSBheGlzCiAgICAgLy8gaWYgdGhlcmUgaXMgYW55IHJldmVyc2Vk IGRpcmVjdGlvbiBvciB3cml0aW5nLW1vZGUuIFRoZSBjb21iaW5hdGlvbnMgYXJlOgogICAgIC8v IHdyaXRpbmctbW9kZSAvIGRpcmVjdGlvbiAgICAgc2Nyb2xsT3JpZ2luLngoKSBzZXQgICAgc2Ny b2xsT3JpZ2luLnkoKSBzZXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJMYXllci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3Bw CmluZGV4IDAzZDBmNmI3ZDNlM2U1OTkzYjI4ZDRiYjNhOWZjMzBmYmU0MGM1ZDYuLmQ2NmRhMTNj OGJjMWMxZmYxNjY1MDA4MzNjMzFlNDBhZTA4NDE5ODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckxheWVyLmNwcApAQCAtMTIyLDYgKzEyMiwxMCBAQAogI2luY2x1ZGUgIlJlbmRl ckxheWVyRmlsdGVySW5mby5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQ KQorI2luY2x1ZGUgIkF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIgorI2VuZGlmCisKICNkZWZpbmUg TUlOX0lOVEVSU0VDVF9GT1JfUkVWRUFMIDMyCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTMw MjgsNiArMzAzMiwxOCBAQCBTY3JvbGxhYmxlQXJlYSogUmVuZGVyTGF5ZXI6OmVuY2xvc2luZ1Nj cm9sbGFibGVBcmVhKCkgY29uc3QKICAgICByZXR1cm4gMDsKIH0KIAorI2lmIEVOQUJMRShDU1Nf U0NST0xMX1NOQVApCit2b2lkIFJlbmRlckxheWVyOjp1cGRhdGVTbmFwT2Zmc2V0cygpCit7Cisg ICAgLy8gRklYTUU6IEV4dGVuZCBzdXBwb3J0IGJleW9uZCBIVE1MRWxlbWVudHMuCisgICAgaWYg KCFlbmNsb3NpbmdFbGVtZW50KCkgfHwgIWVuY2xvc2luZ0VsZW1lbnQoKS0+cmVuZGVyQm94KCkg fHwgIWVuY2xvc2luZ0VsZW1lbnQoKS0+aXNIVE1MRWxlbWVudCgpKQorICAgICAgICByZXR1cm47 CisKKyAgICBSZW5kZXJCb3gqIGJveCA9IGVuY2xvc2luZ0VsZW1lbnQoKS0+cmVuZGVyQm94KCk7 CisgICAgdXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYSgqdGhpcywgKnRvSFRNTEVs ZW1lbnQoZW5jbG9zaW5nRWxlbWVudCgpKSwgKmJveCwgYm94LT5zdHlsZSgpKTsKK30KKyNlbmRp ZgorCiBpbnQgUmVuZGVyTGF5ZXI6OnZlcnRpY2FsU2Nyb2xsYmFyV2lkdGgoT3ZlcmxheVNjcm9s bGJhclNpemVSZWxldmFuY3kgcmVsZXZhbmN5KSBjb25zdAogewogICAgIGlmICghbV92QmFyCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuaCBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oCmluZGV4IDI2NjU1OWFmZmI4Y2ZhMDg4 YzBlYWMwMzhmZDZlYjdjOWY4YjFmNDcuLmJkMjYxYTdhNDk4N2U3MTQ3ZjAyYWJkMzVjODAyMzQz YWZkMDRjM2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXll ci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oCkBAIC00Mzks NiArNDM5LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgU2Nyb2xsYmFyKiBob3Jpem9udGFsU2Ny b2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4gbV9oQmFyLmdldCgpOyB9CiAgICAgdmly dHVhbCBTY3JvbGxiYXIqIHZlcnRpY2FsU2Nyb2xsYmFyKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1 cm4gbV92QmFyLmdldCgpOyB9CiAgICAgdmlydHVhbCBTY3JvbGxhYmxlQXJlYSogZW5jbG9zaW5n U2Nyb2xsYWJsZUFyZWEoKSBjb25zdCBvdmVycmlkZTsKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9T TkFQKQorICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFwT2Zmc2V0cygpIG92ZXJyaWRlOworI2Vu ZGlmCiAKICNpZiBQTEFURk9STShJT1MpCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykK 236560 2014-08-13 15:43:32 -0700 2014-08-13 17:16:18 -0700 Patch bug-135268-20140813154319.patch text/plain 24725 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMTcyNTM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTIyYzY1ZWMxZTI4MTAz MjI4ZTUxZDgxMDYzOTg4YTBkYjdhYzMxNy4uMjlhZjFlODEwNjY5NzQzZWIxZGQzMDcyNDVlYmY2 Yjk4MDJhNGRmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE0LTA4LTEzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIENvbXB1dGUgYW5k IHN0b3JlIHNuYXAgcG9pbnQgcG9zaXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNjgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXb3JraW5nIHRvd2FyZHMgaW1wbGVtZW50aW5nIGEgd2F5IHRv IGV4dHJhY3Qgc25hcCBwb3NpdGlvbnMgKGkuZS4gTGF5b3V0VW5pdHMpIGZyb20gdGhlIHBhcnNl ZCBzbmFwIHBvaW50IHByb3BlcnRpZXMgZnJvbSBDU1MsCisgICAgICAgIGFzIHdlbGwgYXMgYSB3 YXkgb2Ygc3RvcmluZyB0aGUgaW5mb3JtYXRpb24uIFN1cHBvcnRzIGJvdGggbWFpbmZyYW1lIGFu ZCBvdmVyZmxvdyBzY3JvbGxpbmcuCisKKyAgICAgICAgTm8gY2hhbmdlcyBpbiBiZWhhdmlvci4g SSB3aWxsIHdyaXRlIHRlc3RzIHdoZW4gSSBpbXBsZW1lbnQgc25hcHBpbmcgZm9yIGlPUyBhbmQg TWFjLgorICAgICAgICAKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVWaWV3Ojp1cGRhdGVTbmFwT2Zmc2V0cyk6IEludm9rZXMgdGhlIHN0YXRpYyByb3V0aW5lIGlu IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cyB0byB1cGRhdGUgc25hcCBvZmZzZXRzIGZvciBtYWluZnJh bWUuCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL3Njcm9sbGlu Zy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmFw cGVuZEFuZFNvcnRDaGlsZFNuYXBPZmZzZXRzKToKKyAgICAgICAgKFdlYkNvcmU6OnVwZGF0ZUZy b21TdHlsZSk6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFi bGVBcmVhKTogVXBkYXRlIHRoZSBTY3JvbGxhYmxlQXJlYSdzIHNuYXAgYXhlcy4KKyAgICAgICAg KiBwYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaDogQWRkZWQuCisgICAgICAg ICogcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xs YWJsZUFyZWE6OnNldEhvcml6b250YWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JvbGxhYmxlQXJlYTo6c2V0VmVydGljYWxTbmFwT2Zmc2V0cyk6CisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJIb3Jpem9udGFsU25hcE9mZnNldHMpOiBSZXNldHMgdGhl IHVuaXF1ZV9wdHIgZm9yIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3Jl OjpTY3JvbGxhYmxlQXJlYTo6Y2xlYXJWZXJ0aWNhbFNuYXBPZmZzZXRzKTogUmVzZXRzIHRoZSB1 bmlxdWVfcHRyIGZvciB2ZXJ0aWNhbCBzbmFwIHBvaW50cy4KKyAgICAgICAgKiBwbGF0Zm9ybS9T Y3JvbGxhYmxlQXJlYS5oOgorICAgICAgICAoV2ViQ29yZTo6U2Nyb2xsYWJsZUFyZWE6Omhvcml6 b250YWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3JvbGxhYmxlQXJl YSdzIGhvcml6b250YWwgc25hcCBwb2ludHMuCisgICAgICAgIChXZWJDb3JlOjpTY3JvbGxhYmxl QXJlYTo6dmVydGljYWxTbmFwT2Zmc2V0cyk6IFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBTY3Jv bGxhYmxlQXJlYSdzIHZlcnRpY2FsIHNuYXAgcG9pbnRzLgorICAgICAgICAoV2ViQ29yZTo6U2Ny b2xsYWJsZUFyZWE6OnVwZGF0ZVNuYXBPZmZzZXRzKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBP ZmZzZXRzKTogSW52b2tlcyB0aGUgc3RhdGljIHJvdXRpbmUgaW4gQXhpc1Njcm9sbFNuYXBPZmZz ZXRzIHRvIHVwZGF0ZSBzbmFwIG9mZnNldHMgZm9yIGFuIG92ZXJmbG93IGFyZWEuCisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmg6CisKIDIwMTQtMDgtMTMgIEplciBOb2JsZSAgPGpl ci5ub2JsZUBhcHBsZS5jb20+CiAKICAgICAgICAgW01TRV0gUmVwbGFjaW5nIGV4aXN0aW5nIHNh bXBsZXMgd2l0aCBvdmVybGFwcGluZyBuZXcgc2FtcGxlcyB3aWxsIGNhdXNlIHBsYXliYWNrIHRv IHN0dXR0ZXIuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKaW5kZXggYTI4ZWUxYTNkMzEyMWUwOTVkZjlhOWU1MDUwNzhkYzRiOTYxYWY3YS4u ZjBhYTA0MWRjYjI3YmUzZTgyZjg4Y2I4YWQxNjYzOGY4NTUzOTVlOCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNjI0NSw2ICs2 MjQ1LDggQEAKIAkJRjNGNUNGMTExMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNvbGVJ bnN0cnVtZW50YXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEYzRjVDRjEwMTJFRDgxQTgwMDg0QzU2OSAvKiBJbnNwZWN0b3JDb25zb2xlSW5zdHJ1 bWVudGF0aW9uLmggKi87IH07CiAJCUYzRjVDRjEzMTJFRDgxQjMwMDg0QzU2OSAvKiBJbnNwZWN0 b3JEYXRhYmFzZUluc3RydW1lbnRhdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRjNGNUNGMTIxMkVEODFCMzAwODRDNTY5IC8qIEluc3BlY3RvckRh dGFiYXNlSW5zdHJ1bWVudGF0aW9uLmggKi87IH07CiAJCUY0MkZGQjQ2MTk4NEI3MTYwMEY2ODM3 RiAvKiBMZW5ndGhSZXBlYXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEY0MkZGQjQ1MTk4NEI3MTYwMEY2ODM3RiAvKiBMZW5ndGhSZXBlYXQuaCAqLzsg fTsKKwkJRjQ1QzIzMUQxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMx QjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLzsgfTsKKwkJ RjQ1QzIzMUUxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ1QzIzMUMxOTk1Qjcz QjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0N0E1RTNFMTk1QjhDOEEwMDQ4MzEwMCAv KiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY0N0E1RTNCMTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNu YXBQb2ludHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQlGNDdBNUUzRjE5NUI4RTQ4MDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0N0E1RTNB MTk1QjhDOEEwMDQ4MzEwMCAvKiBTdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwICovOyB9OwogCQlG NTA2NjRGNzE1N0Y1MkRDMDBBQzIyNkYgLyogRm9ybUNvbnRyb2xsZXIuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjUwNjY0RjUxNTdGNTJEQzAwQUMy MjZGIC8qIEZvcm1Db250cm9sbGVyLmNwcCAqLzsgfTsKQEAgLTEzNzYyLDYgKzEzNzY0LDggQEAK IAkJRjNGNUNGMTAxMkVEODFBODAwODRDNTY5IC8qIEluc3BlY3RvckNvbnNvbGVJbnN0cnVtZW50 YXRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVjdG9yQ29uc29s ZUluc3RydW1lbnRhdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGM0Y1Q0Yx MjEyRUQ4MUIzMDA4NEM1NjkgLyogSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVtZW50YXRpb24uaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVjdG9yRGF0YWJhc2VJbnN0cnVt ZW50YXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQyRkZCNDUxOTg0Qjcx NjAwRjY4MzdGIC8qIExlbmd0aFJlcGVhdC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBMZW5ndGhSZXBlYXQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1QzIz MUIxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGNDVDMjMxQzE5OTVCNzNCMDBBNkUyRTMgLyog QXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlG NDdBNUUzQTE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFN0eWxlU2Nyb2xsU25hcFBvaW50cy5j cHA7IHBhdGggPSBzdHlsZS9TdHlsZVNjcm9sbFNuYXBQb2ludHMuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQlGNDdBNUUzQjE5NUI4QzhBMDA0ODMxMDAgLyogU3R5bGVTY3JvbGxT bmFwUG9pbnRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFN0eWxlU2Nyb2xs U25hcFBvaW50cy5oOyBwYXRoID0gc3R5bGUvU3R5bGVTY3JvbGxTbmFwUG9pbnRzLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY1MDY2NEY1MTU3RjUyREMwMEFDMjI2RiAvKiBGb3Jt Q29udHJvbGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGb3Jt Q29udHJvbGxlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xNTEzNyw2ICsx NTE0MSw4IEBACiAJCQkJOTM5MUE5OUIxNjI5RDcwMDAwMjk3MzMwIC8qIFNjcm9sbGluZ1RyZWVT Y3JvbGxpbmdOb2RlLmggKi8sCiAJCQkJMEY2MzgzREIxODYxNUIyOTAwM0U1REI1IC8qIFRocmVh ZGVkU2Nyb2xsaW5nVHJlZS5jcHAgKi8sCiAJCQkJMEY2MzgzREMxODYxNUIyOTAwM0U1REI1IC8q IFRocmVhZGVkU2Nyb2xsaW5nVHJlZS5oICovLAorCQkJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJF MyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovLAorCQkJCUY0NUMyMzFDMTk5NUI3M0Iw MEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0g c2Nyb2xsaW5nOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTI0NDE5LDYgKzI0NDI1 LDcgQEAKIAkJCQlBODEzNjlFMDA5NzM3NEY2MDBENzQ0NjMgLyogSFRNTExlZ2VuZEVsZW1lbnQu aCBpbiBIZWFkZXJzICovLAogCQkJCUE4RUE3OUY2MEExOTE2REYwMEE4RUY1RiAvKiBIVE1MTElF bGVtZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBODcxREMyMDBBMTUyMDU3MDBCMTJBNjggLyog SFRNTExpbmtFbGVtZW50LmggaW4gSGVhZGVycyAqLywKKwkJCQlGNDVDMjMxRTE5OTVCNzNCMDBB NkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEVB N0QyQzBBMTkzODU1MDBBOEVGNUYgLyogSFRNTE1hcEVsZW1lbnQuaCBpbiBIZWFkZXJzICovLAog CQkJCUE4RUE3Q0FCMEExOTJCOUMwMEE4RUY1RiAvKiBIVE1MTWFycXVlZUVsZW1lbnQuaCBpbiBI ZWFkZXJzICovLAogCQkJCUU0NDYxM0E1MENENjMzMTAwMEZBREE3NSAvKiBIVE1MTWVkaWFFbGVt ZW50LmggaW4gSGVhZGVycyAqLywKQEAgLTI3NzU0LDYgKzI3NzYxLDcgQEAKIAkJCQlCMkFGRkM3 RDBEMDBBNUMxMDAzMDA3NEQgLyogRm9udEN1c3RvbVBsYXRmb3JtRGF0YS5jcHAgaW4gU291cmNl cyAqLywKIAkJCQkzNzFGNEY0MTBEMjVCOUFGMDBFQ0UwRDUgLyogRm9udERhdGEuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJMzdBQ0NGNjkwREE0MTRFNzAwODlFNjAyIC8qIEZvbnREZXNjcmlwdGlv bi5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlGNDVDMjMxRDE5OTVCNzNCMDBBNkUyRTMgLyogQXhp c1Njcm9sbFNuYXBPZmZzZXRzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTcyNjI2RTAyMEVGMDIy RkUwMEEwN0UyMCAvKiBGb250RmFzdFBhdGguY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNEE2RTlG QzcxM0MxN0Q1NzAwNDZBN0Y4IC8qIEZvbnRGZWF0dXJlU2V0dGluZ3MuY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJRTQ0RUUzQTgxNzU3N0VCRDAwRUVFOENGIC8qIEZvbnRHZW5lcmljRmFtaWxpZXMu Y3BwIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1l Vmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKaW5kZXggMzgxMDcx ZDg3MDQ1MTAyMTY3NTg5MjQyOWZkYTQ4OWE4NDI1NTdmOS4uY2JlN2JkYjQ5NmJjZjk3Yzc3MmJi YjU5Y2RkY2E1YmI4ZWFiZjBiZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApAQCAtOTgs NiArOTgsMTAgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAjZW5kaWYKIAorI2lmIEVO QUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5jbHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgi CisjZW5kaWYKKwogI2lmIFBMQVRGT1JNKElPUykKICNpbmNsdWRlICJEb2N1bWVudExvYWRlci5o IgogI2luY2x1ZGUgIkxlZ2FjeVRpbGVDYWNoZS5oIgpAQCAtODQ3LDYgKzg1MSwyMSBAQCBHcmFw aGljc0xheWVyKiBGcmFtZVZpZXc6OnNldFdhbnRzTGF5ZXJGb3JCb3R0b21PdmVySGFuZ0FyZWEo Ym9vbCB3YW50c0xheWVyKSBjbwogCiAjZW5kaWYgLy8gRU5BQkxFKFJVQkJFUl9CQU5ESU5HKQog CisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKK3ZvaWQgRnJhbWVWaWV3Ojp1cGRhdGVTbmFw T2Zmc2V0cygpCit7CisgICAgaWYgKCFmcmFtZSgpLmRvY3VtZW50KCkpCisgICAgICAgIHJldHVy bjsKKworICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYWxsb3cgc3BlY2lmeWluZyBzbmFwIHBvaW50 cyB0aHJvdWdoIDxodG1sPiB0YWdzIHRvbz8KKyAgICBIVE1MRWxlbWVudCogYm9keSA9IGZyYW1l KCkuZG9jdW1lbnQoKS0+Ym9keSgpOworICAgIGlmICghcmVuZGVyVmlldygpIHx8ICFib2R5IHx8 ICFib2R5LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgdXBkYXRlU25h cE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYSgqdGhpcywgKmJvZHksICpyZW5kZXJWaWV3KCksIGJv ZHktPnJlbmRlcmVyKCktPnN0eWxlKCkpOworfQorI2VuZGlmCisKIGJvb2wgRnJhbWVWaWV3Ojpm bHVzaENvbXBvc2l0aW5nU3RhdGVGb3JUaGlzRnJhbWUoRnJhbWUqIHJvb3RGcmFtZUZvckZsdXNo KQogewogICAgIFJlbmRlclZpZXcqIHJlbmRlclZpZXcgPSB0aGlzLT5yZW5kZXJWaWV3KCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oIGIvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZVZpZXcuaAppbmRleCBkYmU5ZDVkYThjNzQwZjk4MTdhM2I0OTM5ZmJmZTc4 YmU0MDRlNTMxLi45NzhmNTQ0OThiYTk4MzZhYzIyMzM5NGNiY2I4ZTc3MDMxYWVlNmRlIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWVWaWV3LmgKQEAgLTQ5Niw2ICs0OTYsMTAgQEAgcHVibGljOgogICAgIHZv aWQgc2V0RXhwb3NlZFJlY3QoRmxvYXRSZWN0KTsKICAgICBGbG9hdFJlY3QgZXhwb3NlZFJlY3Qo KSBjb25zdCB7IHJldHVybiBtX2V4cG9zZWRSZWN0OyB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9M TF9TTkFQKQorICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVTbmFwT2Zmc2V0cygpIG92ZXJyaWRlOwor I2VuZGlmCisKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGJvb2wgc2Nyb2xsQ29udGVudHNGYXN0 UGF0aChjb25zdCBJbnRTaXplJiBzY3JvbGxEZWx0YSwgY29uc3QgSW50UmVjdCYgcmVjdFRvU2Ny b2xsLCBjb25zdCBJbnRSZWN0JiBjbGlwUmVjdCkgb3ZlcnJpZGU7CiAgICAgdmlydHVhbCB2b2lk IHNjcm9sbENvbnRlbnRzU2xvd1BhdGgoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCkgb3ZlcnJp ZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xs U25hcE9mZnNldHMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvQXhpc1Njcm9s bFNuYXBPZmZzZXRzLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mMDEzM2ZkZDA0MGZkMjNmYzA4OTg3ZTk0NjZm NjE0MmUwMDQyYmIxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3Jv bGxpbmcvQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcApAQCAtMCwwICsxLDE1MCBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBeGlzU2Nyb2xsU25hcE9mZnNl dHMuaCIKKworI2luY2x1ZGUgIkhUTUxDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiSFRNTEVsZW1l bnQuaCIKKyNpbmNsdWRlICJSZW5kZXJCb3guaCIKKyNpbmNsdWRlICJTY3JvbGxhYmxlQXJlYS5o IgorCisjaWYgRU5BQkxFKENTU19TQ1JPTExfU05BUCkKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitzdGF0aWMgdm9pZCBhcHBlbmRDaGlsZFNuYXBPZmZzZXRzKEhUTUxFbGVtZW50JiBwYXJlbnQs IGJvb2wgc2hvdWxkQWRkSG9yaXpvbnRhbENoaWxkT2Zmc2V0cywgVmVjdG9yPExheW91dFVuaXQ+ JiBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBib29sIHNob3VsZEFkZFZlcnRpY2Fs Q2hpbGRPZmZzZXRzLCBWZWN0b3I8TGF5b3V0VW5pdD4mIHZlcnRpY2FsU25hcE9mZnNldFN1YnNl cXVlbmNlKQoreworICAgIEVsZW1lbnQqIGNoaWxkID0gcGFyZW50LmNoaWxkcmVuKCktPmNvbGxl Y3Rpb25CZWdpbigpOworICAgIC8vIEZJWE1FOiBJbnN0ZWFkIG9mIHRyYXZlcnNpbmcgYWxsIGNo aWxkcmVuLCByZWdpc3RlciBjaGlsZHJlbiB3aXRoIHNuYXAgY29vcmRpbmF0ZXMgYmVmb3JlIGFw cGVuZGluZyB0byBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UuCisgICAgd2hpbGUgKGNoaWxkKSB7Cisg ICAgICAgIGlmIChSZW5kZXJCb3gqIGJveCA9IGNoaWxkLT5yZW5kZXJCb3goKSkgeworICAgICAg ICAgICAgTGF5b3V0VW5pdCB2aWV3V2lkdGggPSBib3gtPndpZHRoKCk7CisgICAgICAgICAgICBM YXlvdXRVbml0IHZpZXdIZWlnaHQgPSBib3gtPmhlaWdodCgpOworICAgICAgICAgICAgLy8gRklY TUU6IENoZWNrIGJlaGF2aW9yIHdpdGggQ1NTIHJvdGF0aW9ucy4KKyAgICAgICAgICAgIEZsb2F0 UG9pbnQgcG9zaXRpb24gPSBib3gtPmxvY2FsVG9Db250YWluZXJQb2ludChGbG9hdFBvaW50KCks IHBhcmVudC5yZW5kZXJCb3goKSk7CisgICAgICAgICAgICBmb3IgKFNuYXBDb29yZGluYXRlIGNv b3JkaW5hdGUgOiBib3gtPnN0eWxlKCkuc2Nyb2xsU25hcENvb3JkaW5hdGVzKCkpIHsKKyAgICAg ICAgICAgICAgICBMYXlvdXRVbml0IGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25YID0gTGF5b3V0 VW5pdChwb3NpdGlvbi54KCkpICsgdmFsdWVGb3JMZW5ndGgoY29vcmRpbmF0ZS5maXJzdCwgdmll d1dpZHRoKTsKKyAgICAgICAgICAgICAgICBpZiAoc2hvdWxkQWRkSG9yaXpvbnRhbENoaWxkT2Zm c2V0cyAmJiBsYXN0UG90ZW50aWFsU25hcFBvc2l0aW9uWCA+IDApCisgICAgICAgICAgICAgICAg ICAgIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UuYXBwZW5kKGxhc3RQb3RlbnRpYWxT bmFwUG9zaXRpb25YKTsKKworICAgICAgICAgICAgICAgIExheW91dFVuaXQgbGFzdFBvdGVudGlh bFNuYXBQb3NpdGlvblkgPSBMYXlvdXRVbml0KHBvc2l0aW9uLnkoKSkgKyB2YWx1ZUZvckxlbmd0 aChjb29yZGluYXRlLnNlY29uZCwgdmlld0hlaWdodCk7CisgICAgICAgICAgICAgICAgaWYgKHNo b3VsZEFkZFZlcnRpY2FsQ2hpbGRPZmZzZXRzICYmIGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25Z ID4gMCkKKyAgICAgICAgICAgICAgICAgICAgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2Uu YXBwZW5kKGxhc3RQb3RlbnRpYWxTbmFwUG9zaXRpb25ZKTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgfQorICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0RWxlbWVudFNpYmxpbmcoKTsKKyAgICB9 Cit9CisKK3N0YXRpYyB2b2lkIHVwZGF0ZUZyb21TdHlsZShWZWN0b3I8TGF5b3V0VW5pdD4qIHNu YXBPZmZzZXRzLCBjb25zdCBSZW5kZXJTdHlsZSYgc3R5bGUsIFNjcm9sbEV2ZW50QXhpcyBheGlz LCBMYXlvdXRVbml0IHZpZXdTaXplLCBMYXlvdXRVbml0IHNjcm9sbFNpemUsIFZlY3RvcjxMYXlv dXRVbml0PiYgc25hcE9mZnNldFN1YnNlcXVlbmNlKQoreworICAgIHN0ZDo6c29ydChzbmFwT2Zm c2V0U3Vic2VxdWVuY2UuYmVnaW4oKSwgc25hcE9mZnNldFN1YnNlcXVlbmNlLmVuZCgpKTsKKyAg ICBpZiAoIXNuYXBPZmZzZXRTdWJzZXF1ZW5jZS5zaXplKCkpCisgICAgICAgIHNuYXBPZmZzZXRT dWJzZXF1ZW5jZS5hcHBlbmQoMCk7CisKKyAgICBib29sIGlzSG9yaXpvbnRhbEF4aXMgPSBheGlz ID09IFNjcm9sbEV2ZW50QXhpczo6SG9yaXpvbnRhbDsKKyAgICBib29sIGhhc1JlcGVhdCA9IGlz SG9yaXpvbnRhbEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwSGFzUmVwZWF0WCgpIDogc3R5bGUuc2Ny b2xsU25hcEhhc1JlcGVhdFkoKTsKKyAgICBMYXlvdXRVbml0IHJlcGVhdE9mZnNldCA9IHZhbHVl Rm9yTGVuZ3RoKGlzSG9yaXpvbnRhbEF4aXMgPyBzdHlsZS5zY3JvbGxTbmFwUmVwZWF0T2Zmc2V0 WCgpIDogc3R5bGUuc2Nyb2xsU25hcFJlcGVhdE9mZnNldFkoKSwgdmlld1NpemUpOworICAgIExh eW91dFVuaXQgZGVzdGluYXRpb25PZmZzZXQgPSB2YWx1ZUZvckxlbmd0aChpc0hvcml6b250YWxB eGlzID8gc3R5bGUuc2Nyb2xsU25hcERlc3RpbmF0aW9uWCgpIDogc3R5bGUuc2Nyb2xsU25hcERl c3RpbmF0aW9uWSgpLCB2aWV3U2l6ZSk7CisgICAgTGF5b3V0VW5pdCBjdXJTbmFwUG9zaXRpb25T aGlmdCA9IDA7CisgICAgTGF5b3V0VW5pdCBtYXhTY3JvbGxPZmZzZXQgPSBzY3JvbGxTaXplIC0g dmlld1NpemU7CisgICAgTGF5b3V0VW5pdCBsYXN0U25hcFBvc2l0aW9uID0gY3VyU25hcFBvc2l0 aW9uU2hpZnQ7CisgICAgc25hcE9mZnNldHMtPmFwcGVuZCgwKTsKKyAgICBkbyB7CisgICAgICAg IGZvciAoTGF5b3V0VW5pdCBzbmFwUG9zaXRpb24gOiBzbmFwT2Zmc2V0U3Vic2VxdWVuY2UpIHsK KyAgICAgICAgICAgIExheW91dFVuaXQgcG90ZW50aWFsU25hcFBvc2l0aW9uID0gY3VyU25hcFBv c2l0aW9uU2hpZnQgKyBzbmFwUG9zaXRpb24gLSBkZXN0aW5hdGlvbk9mZnNldDsKKyAgICAgICAg ICAgIGlmIChwb3RlbnRpYWxTbmFwUG9zaXRpb24gPD0gMCkKKyAgICAgICAgICAgICAgICBjb250 aW51ZTsKKworICAgICAgICAgICAgaWYgKHBvdGVudGlhbFNuYXBQb3NpdGlvbiA+PSBtYXhTY3Jv bGxPZmZzZXQpCisgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIHNuYXBPZmZz ZXRzLT5hcHBlbmQocG90ZW50aWFsU25hcFBvc2l0aW9uKTsKKyAgICAgICAgICAgIGxhc3RTbmFw UG9zaXRpb24gPSBwb3RlbnRpYWxTbmFwUG9zaXRpb24gKyBkZXN0aW5hdGlvbk9mZnNldDsKKyAg ICAgICAgfQorICAgICAgICBjdXJTbmFwUG9zaXRpb25TaGlmdCA9IGxhc3RTbmFwUG9zaXRpb24g KyByZXBlYXRPZmZzZXQ7CisgICAgfSB3aGlsZSAoaGFzUmVwZWF0ICYmIGN1clNuYXBQb3NpdGlv blNoaWZ0IDwgbWF4U2Nyb2xsT2Zmc2V0KTsKKyAgICAvLyBBbHdheXMgcHV0IGEgc25hcCBwb2lu dCBvbiB0aGUgbWF4aW11bSBzY3JvbGwgb2Zmc2V0LgorICAgIC8vIE5vdCBhIHBhcnQgb2YgdGhl IHNwZWMsIGJ1dCBuZWNlc3NhcnkgdG8gcHJldmVudCB1bnJlYWNoYWJsZSBjb250ZW50IHdoZW4g c25hcHBpbmcuCisgICAgaWYgKHNuYXBPZmZzZXRzLT5sYXN0KCkgIT0gbWF4U2Nyb2xsT2Zmc2V0 KQorICAgICAgICBzbmFwT2Zmc2V0cy0+YXBwZW5kKG1heFNjcm9sbE9mZnNldCk7Cit9CisKK3Zv aWQgdXBkYXRlU25hcE9mZnNldHNGb3JTY3JvbGxhYmxlQXJlYShTY3JvbGxhYmxlQXJlYSYgc2Ny b2xsYWJsZUFyZWEsIEhUTUxFbGVtZW50JiBzY3JvbGxpbmdFbGVtZW50LCBjb25zdCBSZW5kZXJC b3gmIHNjcm9sbGluZ0VsZW1lbnRCb3gsIGNvbnN0IFJlbmRlclN0eWxlJiBzY3JvbGxpbmdFbGVt ZW50U3R5bGUpCit7CisgICAgaWYgKHNjcm9sbGluZ0VsZW1lbnRTdHlsZS5zY3JvbGxTbmFwVHlw ZSgpID09IFNjcm9sbFNuYXBUeXBlOjpOb25lKSB7CisgICAgICAgIHNjcm9sbGFibGVBcmVhLmNs ZWFySG9yaXpvbnRhbFNuYXBPZmZzZXRzKCk7CisgICAgICAgIHNjcm9sbGFibGVBcmVhLmNsZWFy VmVydGljYWxTbmFwT2Zmc2V0cygpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIExheW91 dFVuaXQgdmlld1dpZHRoID0gc2Nyb2xsaW5nRWxlbWVudEJveC53aWR0aCgpOworICAgIExheW91 dFVuaXQgdmlld0hlaWdodCA9IHNjcm9sbGluZ0VsZW1lbnRCb3guaGVpZ2h0KCk7CisgICAgTGF5 b3V0VW5pdCBzY3JvbGxXaWR0aCA9IHNjcm9sbGluZ0VsZW1lbnRCb3guc2Nyb2xsV2lkdGgoKTsK KyAgICBMYXlvdXRVbml0IHNjcm9sbEhlaWdodCA9IHNjcm9sbGluZ0VsZW1lbnRCb3guc2Nyb2xs SGVpZ2h0KCk7CisgICAgYm9vbCBjYW5Db21wdXRlSG9yaXpvbnRhbE9mZnNldHMgPSBzY3JvbGxX aWR0aCA+IDAgJiYgdmlld1dpZHRoID4gMCAmJiB2aWV3V2lkdGggPCBzY3JvbGxXaWR0aDsKKyAg ICBib29sIGNhbkNvbXB1dGVWZXJ0aWNhbE9mZnNldHMgPSBzY3JvbGxIZWlnaHQgPiAwICYmIHZp ZXdIZWlnaHQgPiAwICYmIHZpZXdIZWlnaHQgPCBzY3JvbGxIZWlnaHQ7CisgICAgaWYgKCFjYW5D b21wdXRlSG9yaXpvbnRhbE9mZnNldHMpCisgICAgICAgIHNjcm9sbGFibGVBcmVhLmNsZWFySG9y aXpvbnRhbFNuYXBPZmZzZXRzKCk7CisKKyAgICBpZiAoIWNhbkNvbXB1dGVWZXJ0aWNhbE9mZnNl dHMpCisgICAgICAgIHNjcm9sbGFibGVBcmVhLmNsZWFyVmVydGljYWxTbmFwT2Zmc2V0cygpOwor CisgICAgaWYgKCFjYW5Db21wdXRlSG9yaXpvbnRhbE9mZnNldHMgJiYgIWNhbkNvbXB1dGVWZXJ0 aWNhbE9mZnNldHMpCisgICAgICAgIHJldHVybjsKKworICAgIFZlY3RvcjxMYXlvdXRVbml0PiBo b3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlOworICAgIFZlY3RvcjxMYXlvdXRVbml0PiB2 ZXJ0aWNhbFNuYXBPZmZzZXRTdWJzZXF1ZW5jZTsKKyAgICBpZiAoc2Nyb2xsaW5nRWxlbWVudFN0 eWxlLnNjcm9sbFNuYXBVc2VzRWxlbWVudHNYKCkgfHwgc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNj cm9sbFNuYXBVc2VzRWxlbWVudHNZKCkpIHsKKyAgICAgICAgYm9vbCBzaG91bGRBZGRIb3Jpem9u dGFsQ2hpbGRPZmZzZXRzID0gc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNjcm9sbFNuYXBVc2VzRWxl bWVudHNYKCkgJiYgY2FuQ29tcHV0ZUhvcml6b250YWxPZmZzZXRzOworICAgICAgICBib29sIHNo b3VsZEFkZFZlcnRpY2FsQ2hpbGRPZmZzZXRzID0gc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNjcm9s bFNuYXBVc2VzRWxlbWVudHNZKCkgJiYgY2FuQ29tcHV0ZVZlcnRpY2FsT2Zmc2V0czsKKyAgICAg ICAgYXBwZW5kQ2hpbGRTbmFwT2Zmc2V0cyhzY3JvbGxpbmdFbGVtZW50LCBzaG91bGRBZGRIb3Jp em9udGFsQ2hpbGRPZmZzZXRzLCBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLCBzaG91 bGRBZGRWZXJ0aWNhbENoaWxkT2Zmc2V0cywgdmVydGljYWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2Up OworICAgIH0KKworICAgIGlmICghc2Nyb2xsaW5nRWxlbWVudFN0eWxlLnNjcm9sbFNuYXBVc2Vz RWxlbWVudHNYKCkgJiYgY2FuQ29tcHV0ZUhvcml6b250YWxPZmZzZXRzKSB7CisgICAgICAgIGZv ciAoTGVuZ3RoIHNuYXBMZW5ndGggOiBzY3JvbGxpbmdFbGVtZW50U3R5bGUuc2Nyb2xsU25hcE9m ZnNldHNYKCkpCisgICAgICAgICAgICBob3Jpem9udGFsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFw cGVuZCh2YWx1ZUZvckxlbmd0aChzbmFwTGVuZ3RoLCB2aWV3V2lkdGgpKTsKKyAgICB9CisKKyAg ICBpZiAoIXNjcm9sbGluZ0VsZW1lbnRTdHlsZS5zY3JvbGxTbmFwVXNlc0VsZW1lbnRzWSgpICYm IGNhbkNvbXB1dGVWZXJ0aWNhbE9mZnNldHMpIHsKKyAgICAgICAgZm9yIChMZW5ndGggc25hcExl bmd0aCA6IHNjcm9sbGluZ0VsZW1lbnRTdHlsZS5zY3JvbGxTbmFwT2Zmc2V0c1koKSkKKyAgICAg ICAgICAgIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlLmFwcGVuZCh2YWx1ZUZvckxlbmd0 aChzbmFwTGVuZ3RoLCB2aWV3SGVpZ2h0KSk7CisgICAgfQorCisgICAgc3RkOjp1bmlxdWVfcHRy PFZlY3RvcjxMYXlvdXRVbml0Pj4gaG9yaXpvbnRhbFNuYXBPZmZzZXRzID0gc3RkOjptYWtlX3Vu aXF1ZTxWZWN0b3I8TGF5b3V0VW5pdD4+KCk7CisgICAgc3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxM YXlvdXRVbml0Pj4gdmVydGljYWxTbmFwT2Zmc2V0cyA9IHN0ZDo6bWFrZV91bmlxdWU8VmVjdG9y PExheW91dFVuaXQ+PigpOworICAgIGlmIChjYW5Db21wdXRlSG9yaXpvbnRhbE9mZnNldHMpIHsK KyAgICAgICAgdXBkYXRlRnJvbVN0eWxlKGhvcml6b250YWxTbmFwT2Zmc2V0cy5nZXQoKSwgc2Ny b2xsaW5nRWxlbWVudFN0eWxlLCBTY3JvbGxFdmVudEF4aXM6Okhvcml6b250YWwsIHZpZXdXaWR0 aCwgc2Nyb2xsV2lkdGgsIGhvcml6b250YWxTbmFwT2Zmc2V0U3Vic2VxdWVuY2UpOworICAgICAg ICBzY3JvbGxhYmxlQXJlYS5zZXRIb3Jpem9udGFsU25hcE9mZnNldHMoV1RGOjptb3ZlKGhvcml6 b250YWxTbmFwT2Zmc2V0cykpOworICAgIH0KKyAgICBpZiAoY2FuQ29tcHV0ZVZlcnRpY2FsT2Zm c2V0cykgeworICAgICAgICB1cGRhdGVGcm9tU3R5bGUodmVydGljYWxTbmFwT2Zmc2V0cy5nZXQo KSwgc2Nyb2xsaW5nRWxlbWVudFN0eWxlLCBTY3JvbGxFdmVudEF4aXM6OlZlcnRpY2FsLCB2aWV3 SGVpZ2h0LCBzY3JvbGxIZWlnaHQsIHZlcnRpY2FsU25hcE9mZnNldFN1YnNlcXVlbmNlKTsKKyAg ICAgICAgc2Nyb2xsYWJsZUFyZWEuc2V0VmVydGljYWxTbmFwT2Zmc2V0cyhXVEY6Om1vdmUodmVy dGljYWxTbmFwT2Zmc2V0cykpOworICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gQ1NTX1NDUk9MTF9TTkFQCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2Uvc2Nyb2xsaW5nL0F4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVkZGZjNGEz OWQyNjg3MjA3MDA0ODQ5MTcwMjk4YzQ0YTU1ZGEzMWEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9BeGlzU2Nyb2xsU25hcE9mZnNldHMuaApAQCAtMCww ICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAor I2RlZmluZSBBeGlzU2Nyb2xsU25hcE9mZnNldHNfaAorCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKKworI2luY2x1ZGUgIkxheW91dFVuaXQuaCIKKyNpbmNsdWRlICJTY3JvbGxUeXBlcy5o IgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEhUTUxFbGVtZW50OworY2xhc3MgUmVuZGVy Qm94OworY2xhc3MgUmVuZGVyU3R5bGU7CitjbGFzcyBTY3JvbGxhYmxlQXJlYTsKKwordm9pZCB1 cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKFNjcm9sbGFibGVBcmVhJiwgSFRNTEVs ZW1lbnQmIHNjcm9sbGluZ0VsZW1lbnQsIGNvbnN0IFJlbmRlckJveCYgc2Nyb2xsaW5nRWxlbWVu dEJveCwgY29uc3QgUmVuZGVyU3R5bGUmIHNjcm9sbGluZ0VsZW1lbnRTdHlsZSk7CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENTU19TQ1JPTExfU05BUAorCisjZW5kaWYg Ly8gQXhpc1Njcm9sbFNuYXBPZmZzZXRzX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1Njcm9sbGFibGVBcmVhLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Njcm9s bGFibGVBcmVhLmNwcAppbmRleCBjN2Q5NDk0NTQ3MTFmODNjNmJkN2JiNTEwY2IyMzFjODkxMjgw MTAwLi5kZTI3ZGYxYzRmOTZhNzgyYTRmNjk4ZmZmMjg5NDUzYzNkYmI3N2Y2IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsYWJsZUFyZWEuY3BwCkBAIC00NSw3ICs0NSwxMSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0cnVjdCBTYW1lU2l6ZUFzU2Nyb2xsYWJsZUFyZWEgewog ICAgIHZpcnR1YWwgflNhbWVTaXplQXNTY3JvbGxhYmxlQXJlYSgpOworI2lmIEVOQUJMRShDU1Nf U0NST0xMX1NOQVApCisgICAgdm9pZCogcG9pbnRlcnNbM107CisjZWxzZQogICAgIHZvaWQqIHBv aW50ZXI7CisjZW5kaWYKICAgICBJbnRQb2ludCBvcmlnaW47CiAgICAgdW5zaWduZWQgYml0Zmll bGRzIDogMTY7CiB9OwpAQCAtMzc2LDYgKzM4MCwyOCBAQCBib29sIFNjcm9sbGFibGVBcmVhOjpo YXNMYXllckZvclNjcm9sbENvcm5lcigpIGNvbnN0CiAgICAgcmV0dXJuIGxheWVyRm9yU2Nyb2xs Q29ybmVyKCk7CiB9CiAKKyNpZiBFTkFCTEUoQ1NTX1NDUk9MTF9TTkFQKQordm9pZCBTY3JvbGxh YmxlQXJlYTo6c2V0SG9yaXpvbnRhbFNuYXBPZmZzZXRzKHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8 TGF5b3V0VW5pdD4+IGhvcml6b250YWxTbmFwT2Zmc2V0cykKK3sKKyAgICBtX2hvcml6b250YWxT bmFwT2Zmc2V0cyA9IFdURjo6bW92ZShob3Jpem9udGFsU25hcE9mZnNldHMpOworfQorCit2b2lk IFNjcm9sbGFibGVBcmVhOjpzZXRWZXJ0aWNhbFNuYXBPZmZzZXRzKHN0ZDo6dW5pcXVlX3B0cjxW ZWN0b3I8TGF5b3V0VW5pdD4+IHZlcnRpY2FsU25hcE9mZnNldHMpCit7CisgICAgbV92ZXJ0aWNh bFNuYXBPZmZzZXRzID0gV1RGOjptb3ZlKHZlcnRpY2FsU25hcE9mZnNldHMpOworfQorCit2b2lk IFNjcm9sbGFibGVBcmVhOjpjbGVhckhvcml6b250YWxTbmFwT2Zmc2V0cygpCit7CisgICAgbV9o b3Jpem9udGFsU25hcE9mZnNldHMgPSBudWxscHRyOworfQorCit2b2lkIFNjcm9sbGFibGVBcmVh OjpjbGVhclZlcnRpY2FsU25hcE9mZnNldHMoKQoreworICAgIG1fdmVydGljYWxTbmFwT2Zmc2V0 cyA9IG51bGxwdHI7Cit9CisjZW5kaWYKKwogdm9pZCBTY3JvbGxhYmxlQXJlYTo6c2VydmljZVNj cm9sbEFuaW1hdGlvbnMoKQogewogICAgIGlmIChTY3JvbGxBbmltYXRvciogc2Nyb2xsQW5pbWF0 b3IgPSBleGlzdGluZ1Njcm9sbEFuaW1hdG9yKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Ny b2xsYWJsZUFyZWEuaAppbmRleCAyZmUyNzQ5MTQ1MjhmYTUwN2EzMThhNDVlYTkxMDA2ZTFlMjg0 ZjFiLi4zZTljMDNlYjE4NTNkMWUyNDRkY2U5ZDkyODJkMGZhNTUxMzBkYjYyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TY3JvbGxhYmxlQXJlYS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1Njcm9sbGFibGVBcmVhLmgKQEAgLTU4LDYgKzU4LDE2IEBAIHB1Ymxp YzoKIAogICAgIGJvb2wgaGFuZGxlV2hlZWxFdmVudChjb25zdCBQbGF0Zm9ybVdoZWVsRXZlbnQm KTsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgY29uc3QgVmVjdG9yPExheW91 dFVuaXQ+KiBob3Jpem9udGFsU25hcE9mZnNldHMoKSBjb25zdCB7IHJldHVybiBtX2hvcml6b250 YWxTbmFwT2Zmc2V0cy5nZXQoKTsgfTsKKyAgICBjb25zdCBWZWN0b3I8TGF5b3V0VW5pdD4qIHZl cnRpY2FsU25hcE9mZnNldHMoKSBjb25zdCB7IHJldHVybiBtX3ZlcnRpY2FsU25hcE9mZnNldHMu Z2V0KCk7IH07CisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzKCkgeyB9OworICAg IHZvaWQgc2V0SG9yaXpvbnRhbFNuYXBPZmZzZXRzKHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8TGF5 b3V0VW5pdD4+KTsKKyAgICB2b2lkIHNldFZlcnRpY2FsU25hcE9mZnNldHMoc3RkOjp1bmlxdWVf cHRyPFZlY3RvcjxMYXlvdXRVbml0Pj4pOworICAgIHZvaWQgY2xlYXJIb3Jpem9udGFsU25hcE9m ZnNldHMoKTsKKyAgICB2b2lkIGNsZWFyVmVydGljYWxTbmFwT2Zmc2V0cygpOworI2VuZGlmCisK ICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogICAgIHZpcnR1YWwgYm9vbCBpc1RvdWNoU2Nyb2xs YWJsZSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGhhbmRsZVRv dWNoRXZlbnQoY29uc3QgUGxhdGZvcm1Ub3VjaEV2ZW50Jik7CkBAIC0yNzUsNiArMjg1LDExIEBA IHByaXZhdGU6CiAKICAgICBtdXRhYmxlIE93blB0cjxTY3JvbGxBbmltYXRvcj4gbV9zY3JvbGxB bmltYXRvcjsKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisgICAgc3RkOjp1bmlxdWVf cHRyPFZlY3RvcjxMYXlvdXRVbml0Pj4gbV9ob3Jpem9udGFsU25hcE9mZnNldHM7CisgICAgc3Rk Ojp1bmlxdWVfcHRyPFZlY3RvcjxMYXlvdXRVbml0Pj4gbV92ZXJ0aWNhbFNuYXBPZmZzZXRzOwor I2VuZGlmCisKICAgICAvLyBUaGVyZSBhcmUgOCBwb3NzaWJsZSBjb21iaW5hdGlvbnMgb2Ygd3Jp dGluZyBtb2RlIGFuZCBkaXJlY3Rpb24uIFNjcm9sbCBvcmlnaW4gd2lsbCBiZSBub24temVybyBp biB0aGUgeCBvciB5IGF4aXMKICAgICAvLyBpZiB0aGVyZSBpcyBhbnkgcmV2ZXJzZWQgZGlyZWN0 aW9uIG9yIHdyaXRpbmctbW9kZS4gVGhlIGNvbWJpbmF0aW9ucyBhcmU6CiAgICAgLy8gd3JpdGlu Zy1tb2RlIC8gZGlyZWN0aW9uICAgICBzY3JvbGxPcmlnaW4ueCgpIHNldCAgICBzY3JvbGxPcmln aW4ueSgpIHNldApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxh eWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKaW5kZXgg MDNkMGY2YjdkM2UzZTU5OTNiMjhkNGJiM2E5ZmMzMGZiZTQwYzVkNi4uZDY2ZGExM2M4YmMxYzFm ZjE2NjUwMDgzM2MzMWU0MGFlMDg0MTk4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckxheWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyTGF5ZXIuY3BwCkBAIC0xMjIsNiArMTIyLDEwIEBACiAjaW5jbHVkZSAiUmVuZGVyTGF5ZXJG aWx0ZXJJbmZvLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisjaW5j bHVkZSAiQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmgiCisjZW5kaWYKKwogI2RlZmluZSBNSU5fSU5U RVJTRUNUX0ZPUl9SRVZFQUwgMzIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzAyOCw2ICsz MDMyLDE4IEBAIFNjcm9sbGFibGVBcmVhKiBSZW5kZXJMYXllcjo6ZW5jbG9zaW5nU2Nyb2xsYWJs ZUFyZWEoKSBjb25zdAogICAgIHJldHVybiAwOwogfQogCisjaWYgRU5BQkxFKENTU19TQ1JPTExf U05BUCkKK3ZvaWQgUmVuZGVyTGF5ZXI6OnVwZGF0ZVNuYXBPZmZzZXRzKCkKK3sKKyAgICAvLyBG SVhNRTogRXh0ZW5kIHN1cHBvcnQgYmV5b25kIEhUTUxFbGVtZW50cy4KKyAgICBpZiAoIWVuY2xv c2luZ0VsZW1lbnQoKSB8fCAhZW5jbG9zaW5nRWxlbWVudCgpLT5yZW5kZXJCb3goKSB8fCAhZW5j bG9zaW5nRWxlbWVudCgpLT5pc0hUTUxFbGVtZW50KCkpCisgICAgICAgIHJldHVybjsKKworICAg IFJlbmRlckJveCogYm94ID0gZW5jbG9zaW5nRWxlbWVudCgpLT5yZW5kZXJCb3goKTsKKyAgICB1 cGRhdGVTbmFwT2Zmc2V0c0ZvclNjcm9sbGFibGVBcmVhKCp0aGlzLCAqdG9IVE1MRWxlbWVudChl bmNsb3NpbmdFbGVtZW50KCkpLCAqYm94LCBib3gtPnN0eWxlKCkpOworfQorI2VuZGlmCisKIGlu dCBSZW5kZXJMYXllcjo6dmVydGljYWxTY3JvbGxiYXJXaWR0aChPdmVybGF5U2Nyb2xsYmFyU2l6 ZVJlbGV2YW5jeSByZWxldmFuY3kpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3ZCYXIKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5oIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKaW5kZXggMjY2NTU5YWZmYjhjZmEwODhjMGVhYzAz OGZkNmViN2M5ZjhiMWY0Ny4uYmQyNjFhN2E0OTg3ZTcxNDdmMDJhYmQzNWM4MDIzNDNhZmQwNGMz YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmgKQEAgLTQzOSw2ICs0Mzks OSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTY3JvbGxiYXIqIGhvcml6b250YWxTY3JvbGxiYXIo KSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX2hCYXIuZ2V0KCk7IH0KICAgICB2aXJ0dWFsIFNj cm9sbGJhciogdmVydGljYWxTY3JvbGxiYXIoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX3ZC YXIuZ2V0KCk7IH0KICAgICB2aXJ0dWFsIFNjcm9sbGFibGVBcmVhKiBlbmNsb3NpbmdTY3JvbGxh YmxlQXJlYSgpIGNvbnN0IG92ZXJyaWRlOworI2lmIEVOQUJMRShDU1NfU0NST0xMX1NOQVApCisg ICAgdmlydHVhbCB2b2lkIHVwZGF0ZVNuYXBPZmZzZXRzKCkgb3ZlcnJpZGU7CisjZW5kaWYKIAog I2lmIFBMQVRGT1JNKElPUykKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQo=