28862 2009-08-31 19:38:29 -0700 [Qt][API] Add a new QGraphicsWidget based version of the "QWebView" 2009-09-11 06:25:05 -0700 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) PC All RESOLVED FIXED Qt P2 Normal --- 28865 1 tonikitoo webkit-unassigned ariya.hidayat hausmann jwieczorek kenneth kevin.rogovin laszlo.gombos rich tonikitoo vestbo oldest_to_newest 143764 0 tonikitoo 2009-08-31 19:38:29 -0700 [Short Backgroung] After the introduction of the "Graphics View" framework to Qt (since version 4.2), managing and interacting with a large number of custom 2D based graphical items is simple and fast in Qt. As a summary, there are three major entities involved: - QGraphicsScene is a container for QGraphicsItem objects (widgets). - QGraphicsView provides the view widget, which visualizes the content of a scene. - QGraphicsItem is the base class for graphical items in a scene. In order to embed non-QGraphicsItem based objects ( e.g. most of QWidget subclasses ) into a scene, a "proxy" widget (QGraphicsProxyWidget) is necessary, which can represent a pontential performance bottle-neck to applications, specially on mobile devices. [Bug report] This bug is about providing a QGraphicsItem version of the "QWebView" widget, making it to be a straightforward embeddable widget into Graphics View based applications. 143765 1 kenneth 2009-08-31 19:44:47 -0700 There are many other points that shows that a GraphicsItem based widget would be a win for QtWebKit. Many different teams, people have already implemented this, such as one for QML, one for Plasma, etc. I have been told today that the KDE team is very interested in this work, and would like to use it in their new Silk project. It should also be noted that using the proxy widget will result in full update of the viewport for each scroll operation, something not desirable, especially on slow, embedded devices. 144512 2 hausmann 2009-09-03 07:32:24 -0700 For reference, Kenneth's development branch can be found at http://www.gitorious.org/~kenneth/qtwebkit/kenneth-devel/commits/graphicsitem 144513 3 hausmann 2009-09-03 07:33:54 -0700 As discussed with Kenneth briefly in chat, I think it would make sense to get this class reviewed and landed in a basic form. Even without optimizations it's already of big use and help and it would form a good basis allowing other teams to contribute their optimizations or features for better graphicsview support. 144784 4 hausmann 2009-09-04 04:19:29 -0700 Kenneth, why is it a QGraphicsWidget instead of a QGraphicsObject? 144785 5 hausmann 2009-09-04 04:22:19 -0700 FYI, link to the current header file: http://www.gitorious.org/~kenneth/qtwebkit/kenneth-devel/blobs/graphicsitem/WebKit/qt/Api/qwebgraphicsitem.h 144791 6 kenneth 2009-09-04 05:30:24 -0700 In the beginning(In reply to comment #4) > Kenneth, why is it a QGraphicsWidget instead of a QGraphicsObject? In the beginning it was a QGraphicsLayoutItem and a QGraphicsObject, but it made a whole lot more sense making it a QGraphicsWidget as I was basically implementing the same things as it already provided. It should be noted that QGraphicsWidget imherits QGraphicsObject and QGraphicsLayoutItem 144792 7 kenneth 2009-09-04 05:32:29 -0700 Is there any reason for discouraging the usage of QGraphicsWidget? It seems to fit our role pretty well. 144793 8 ariya.hidayat 2009-09-04 06:14:29 -0700 Naming concern: all graphics item use the format QGraphicsFooItem, even QGraphicsSvgItem which is part of QtSvg (not QtGui). But then, in QtWebKit we always use QWebFoo moniker. So what is our choice here? The API and the code look clean and mimic QWebView enough that developers will not have problem switching from one to another. Since we deprecate textSizeMultiplier in QWebView, should we also remove it here? Question: if someone wants to add flick support, is it possible with the current code? Or does this need to be handled in a higher level (think Declarative UI with FxFlickable)? 144795 9 kenneth 2009-09-04 06:24:03 -0700 (In reply to comment #8) > Naming concern: all graphics item use the format QGraphicsFooItem, even > QGraphicsSvgItem which is part of QtSvg (not QtGui). But then, in QtWebKit we > always use QWebFoo moniker. So what is our choice here? This was already discussed with Simon some time ago, and since it is part of the QtWebKit module it should start with QWeb*, hense the current name. > Since we deprecate textSizeMultiplier in QWebView, should we also remove it > here? If that is the case, I'm all for it. > Question: if someone wants to add flick support, is it possible with the > current code? Or does this need to be handled in a higher level (think > Declarative UI with FxFlickable)? I would like to add that support to the QGVLauncher as a menu option, so we should find out soon if that works :-) 145017 10 39117 tonikitoo 2009-09-05 15:40:42 -0700 Created attachment 39117 patch 1 - v0.1 - add QWebGraphicsItem to the API and QGVLauncher sample application. - Add QWebGraphicsItem to the API. - QGVLauncher as a sample. - Change the build system accordingly. * Known isues: cursor depends on a patch from bug 28865. 145051 11 kenneth 2009-09-06 09:25:52 -0700 Antonio, this patch depends on my patch that adds support of handling QGraphicsScene event in QWebPage. Can you attach that one? or I will do it when I am at work Tuesday. Also, there is no patch attached to the other bugzilla entry (28865). 145059 12 39125 tonikitoo 2009-09-06 13:43:48 -0700 Created attachment 39125 patch 2 - v0.1 - Add support for handling QGraphicsScene events. Add support for handling QGraphicsScene events. 145062 13 tonikitoo 2009-09-06 14:12:42 -0700 (In reply to comment #11) > Antonio, this patch depends on my patch that adds support of handling > QGraphicsScene event in QWebPage. in fact, i'd say they are complementary ... > Also, there is no patch attached to the other bugzilla entry (28865). it is there now. 145142 14 39117 hausmann 2009-09-07 07:08:25 -0700 Comment on attachment 39117 patch 1 - v0.1 - add QWebGraphicsItem to the API and QGVLauncher sample application. Looks good to me in principle, just a few minor things that should be fixed IMHO before landing. > * Api/headers.pri: > * Api/qwebgraphicsitem.cpp: Added. > (QWebGraphicsItem::QWebGraphicsItem): > (QWebGraphicsItem::~QWebGraphicsItem): [...lots of functions here...] I think you can leave out the long list of functions from the changelog, it's just bloat :) > +/*! > + \brief The WebPage item allows you to add web content to a canvas. > + \inherits QGraphicsWidget. Please add a \since 4.6 tag here > +void QWebGraphicsItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget*) > +{ > + page()->mainFrame()->render(painter, option->exposedRect.toRect()); > +} I think the paint() function should get a /*! \reimp */ comment, to make it clear in the API docs that this is just a re-implementation. > +/*! > + Makes \a page the new web page of the web view. > + > + The parent QObject of the provided page remains the owner > + of the object. If the current document is a child of the web > + view, it will be deleted. > + > + \sa page() The docs here say "web view" but should say "web graphicsitem". > +void QWebGraphicsItem::setUrl(const QUrl &url) > +{ > + if (url == page()->mainFrame()->url()) I think it's better to avoid the call to page() here and instead simply write: if (d->page && d->page->mainFrame()->url() == url) > +/*! > + \property QWebGraphicsItem::textSizeMultiplier > + \brief the scaling factor for all text in the frame > + \obsolete > + > + Use setZoomFactor instead, in combination with the > + ZoomTextOnly attribute in QWebSettings. > + > + \note Setting this property also enables the > + ZoomTextOnly attribute in QWebSettings. > + > + By default, this property contains a value of 1.0. > +*/ Please don't add this property. It's marked with \obsolete, there's no reason to add new stuff that is already obsolete :-) > +void QWebGraphicsItem::updateGeometry() > +{ > + QGraphicsWidget::updateGeometry(); > + QSize size = geometry().size().toSize(); > + page()->setViewportSize(size); > +} > + > +void QWebGraphicsItem::setGeometry(const QRectF& rect) > +{ > + QGraphicsWidget::setGeometry(rect); > + // NOTE: call geometry() as setGeometry ensures that > + // the geometry is within legal bounds (minimumSize, maximumSize) > + QSize size = geometry().size().toSize(); > + page()->setViewportSize(size); > +} If those two functions are re-implementations from QGraphicsLayoutItem, then they should be marked in the docs with /*! \reimp */ > +QString QWebGraphicsItem::status() const > +{ > + return d->statusBarMessage; > +} This function is missing documentation. > +/*! > + Sets the content of the web view to the specified \a html. > + > + External objects such as stylesheets or images referenced in the HTML > + document are located relative to \a baseUrl. > + > + The \a html is loaded immediately; external objects are loaded asynchronously. > + > + When using this method, WebKit assumes that external resources such as > + JavaScript programs or style sheets are encoded in UTF-8 unless otherwise > + specified. For example, the encoding of an external script can be specified > + through the charset attribute of the HTML script tag. Alternatively, the > + encoding can also be specified by the web server. > + > + \sa load(), setContent(), QWebFrame::toHtml() > +*/ The docs here mentioned "web view" again, where it should be "web graphicsitem". I see this is also the case in some of the other functions. > +void QWebGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent* ev) > +{ > + if (d->interactive && d->page) { > + const bool accepted = ev->isAccepted(); > + QMouseEvent me = QMouseEvent(QEvent::MouseMove, > + ev->pos().toPoint(), Qt::NoButton, > + Qt::NoButton, Qt::NoModifier); > + d->page->setView(ev->widget()); > + d->page->event(&me); > + ev->setAccepted(accepted); > + } > + > + if (!ev->isAccepted()) > + QGraphicsItem::hoverMoveEvent(ev); > +} > + > +void QWebGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* ev) > +{ > + Q_UNUSED(ev); > +} These two re-implementations are missing the \reimp tag in the docs. > +void QWebGraphicsItem::keyPressEvent(QKeyEvent* ev) Ditto :-) > + virtual void setGeometry(const QRectF& rect); > + virtual void updateGeometry(); > + void paint(QPainter*, const QStyleOptionGraphicsItem* options, QWidget* widget = 0); I like the use of the virtual keyword in header files for re-implemented functions, to indicate that it's a re-implementation. I think you forgot it for paint() though :-) > + QGraphicsScene* scene() { return m_scene; } > + QWebGraphicsItem* webItem() { return m_item; } const missing? :) It is a bit unfortunate that the QGVLauncher duplicates code from QtLauncher. It might be a good thing to clean up in the future. > diff --git a/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp b/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > index d659833..e79ae55 100644 > --- a/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > +++ b/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > @@ -45,6 +45,7 @@ > #include "qwebframe_p.h" > #include "qwebsecurityorigin.h" > #include "qwebsecurityorigin_p.h" > +#include "qwebview.h" > > #include <qtooltip.h> > #include <qtextdocument.h> > @@ -307,8 +308,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > { > // No double buffer, so only update the QWidget if content changed. > if (contentChanged) { > - QWidget* view = m_webPage->view(); > - if (view) { > + // Only do implicit paints for QWebView's > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) { > QRect rect(windowRect); > rect = rect.intersected(QRect(QPoint(0, 0), m_webPage->viewportSize())); > if (!rect.isEmpty()) > @@ -323,8 +324,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > > void ChromeClientQt::scroll(const IntSize& delta, const IntRect& scrollViewRect, const IntRect&) > { > - QWidget* view = m_webPage->view(); > - if (view) > + // Only do implicit paints for QWebView's > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) > view->scroll(delta.width(), delta.height(), scrollViewRect); > emit m_webPage->scrollRequested(delta.width(), delta.height(), scrollViewRect); > } Hmm, I'm not so sure about these two changes. The WebGraphicsItem doesn't call setView(), right? So why is this needed? Oh, I just also forgot one more thing: The QWebGraphicsItem destructor calls setView(0) - should it do that? :) 145144 15 39125 hausmann 2009-09-07 07:15:20 -0700 Comment on attachment 39125 patch 2 - v0.1 - Add support for handling QGraphicsScene events. In principle this approach is good, QWebPage _should_ become capable of dealing with QGraphicsScene events. However this implementation duplicates a some of the existing event handlers (drag'n'drop) and it converts the graphicsview events to QWidget events and then calls the original handlers. This means a lot of unnecessary object creation. I think it would be better to change the existing handlers, for example QWebPagePrivate::mousePressEvent, to take a PlatformMouseEvent as argument. Then PlatformMouseEvent should be extended with a constructor that accepts a QGraphicsSceneMouseEvent. This way the code in QWebPage::event() takes care of just calling the right constructors, the PlatformFooEvent constructors take care of extracting the parameters and the logic in QWebPagePrivate's event handlers can remain without the need of duplication. 145202 16 39156 tonikitoo 2009-09-07 10:35:19 -0700 Created attachment 39156 patch 1 - v0.2 - add QWebGraphicsItem to the API and QGVLauncher sample application patch 1 - v0.2 simon, thanks for your comments. all addressed. 145211 17 tonikitoo 2009-09-07 10:44:36 -0700 (... qouted ) > It is a bit unfortunate that the QGVLauncher duplicates code from QtLauncher. > It > might be a good thing to clean up in the future. simon, i agree although we based code in qtlauncher, it is already very cleaned up :) really ... we chould actually clean up qtlauncher code instead. > > diff --git a/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp b/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > > index d659833..e79ae55 100644 > > --- a/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > > +++ b/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp > > @@ -45,6 +45,7 @@ > > #include "qwebframe_p.h" > > #include "qwebsecurityorigin.h" > > #include "qwebsecurityorigin_p.h" > > +#include "qwebview.h" > > > > #include <qtooltip.h> > > #include <qtextdocument.h> > > @@ -307,8 +308,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > > { > > // No double buffer, so only update the QWidget if content changed. > > if (contentChanged) { > > - QWidget* view = m_webPage->view(); > > - if (view) { > > + // Only do implicit paints for QWebView's > > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) { > > QRect rect(windowRect); > > rect = rect.intersected(QRect(QPoint(0, 0), m_webPage->viewportSize())); > > if (!rect.isEmpty()) > > @@ -323,8 +324,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > > > > void ChromeClientQt::scroll(const IntSize& delta, const IntRect& scrollViewRect, const IntRect&) > > { > > - QWidget* view = m_webPage->view(); > > - if (view) > > + // Only do implicit paints for QWebView's > > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) > > view->scroll(delta.width(), delta.height(), scrollViewRect); > > emit m_webPage->scrollRequested(delta.width(), delta.height(), scrollViewRect); > > } > > Hmm, I'm not so sure about these two changes. The WebGraphicsItem doesn't call > setView(), right? So why is this needed? we were getting viewport doabled updated in scroll events. That is the way Kenneth found to avoid that. i will let to kenneth a more detailed answer here, if needed. > Oh, I just also forgot one more thing: The QWebGraphicsItem destructor calls > setView(0) - should it do that? :) simon, QWebView's destructor does the same. Why should not we do the same here ? 145218 18 kenneth 2009-09-07 11:05:19 -0700 I totally agree with you. Actually I was going to make that another follow up patch, as I wanted to do it iteratively. Would that be possible? or do you want me to fix the patch as is? > However this implementation duplicates a some of the existing event handlers > (drag'n'drop) and it converts > the graphicsview events to QWidget events and then calls the original handlers. > This means a lot of unnecessary > object creation. 145220 19 kenneth 2009-09-07 11:11:02 -0700 > we were getting viewport doabled updated in scroll events. That is the way > Kenneth found to avoid that. i will let to kenneth a more detailed answer here, > if needed. Actually the problem is that it is doing implicit updates whenever someone sets the view on the page. For instance if someone does that with the viewport of the graphicsview it will receive wrong updates, and scrolling will be very broken. I do not think it is desirable to let the user be able to do so, so I restricted the *implicit* updates to the QWebPage. That seemed like the right thing to do. Earlier I had another patch allowing the QWebGrapicsItem to privately disable implicit updates. Any reason you want to allow implicit paints on other kind of view than QWebPage? If so that should definately be documented in the setView method. 145240 20 39165 tonikitoo 2009-09-07 15:43:54 -0700 Created attachment 39165 patch 1 - v0.2.1 - add QWebGraphicsItem to the API and QGVLauncher sample application same as "patch 1 - v0.2", but updated to tot. no touch in "patch 2" 145241 21 tonikitoo 2009-09-07 15:48:16 -0700 fwiw, this is my tree w/ latest patches http://gitorious.org/~tonikitoo/qtwebkit/tonikitoos-clone/commits/graphicsitem posted here 145306 22 39165 ariya.hidayat 2009-09-08 03:08:24 -0700 Comment on attachment 39165 patch 1 - v0.2.1 - add QWebGraphicsItem to the API and QGVLauncher sample application > +#include "qwebpage_p.h" Is this really needed? > +#include <QGraphicsScene> > +#include <QGraphicsView> Can we use the <QtGui/Foo> pattern also here? > + setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true); This is Qt 4.6 only. Please guard it with QT_VERSION properly for <= 4.5. > + if (this->progress == progress / 100.0) Please use qFuzzyCompare. > +void QWebGraphicsItemPrivate::_q_doScroll(int dx, int dy, const QRect& rectToScroll) > +{ > + q->scroll(qreal(dx), qreal(dy), QRectF(rectToScroll)); > +} I found out that this does not really work if I subclass QWebGraphicsItem. An example: I have my customized QWebGraphicsItem that clips the painting so that the corners are rounded. When this function is invoked, say scrolling vertically, the whole painted item is scrolled, meaning the bottom rounded corners are also scrolled. The correct thing of course that the _contents_ of the web page is scrolled, not merely the item. The real fix would be to call update, instead of scroll. I understand that this is optimization issue, but I'd rather have a correctly painted item than a fast but garbage one. > +bool QWebGraphicsItem::interactive() const Following Qt-ish naming, this should be isInteractive instead. > + emit interactiveChanged(); The name could be misleading. What about interactivityChanged? > +++ b/WebKit/qt/Api/qwebgraphicsitem_p.h Is there any reason we need separate file for this? Unline other qweb* classes, QWebGraphicsItemPrivate is not need by anyone else, right? Overall, looks really good! r- until the issues above are addressed. 145317 23 kevin.rogovin 2009-09-08 04:30:05 -0700 I'd like to suggest the following coarse of action: Rather than assuming that the viewer of a web page is a particular kind of class, be it QWebView, QWidget, QGraphicsSomething, etc, lets do this: replace QWidget* view() with QSomeCoolSoundingName *view() where class QSomeCoolSoundingName:public QObject { public: virtual QRect windowRect(); virtual void focus(); virtual void unfocus(); virtual void show(); virtual void repaint(const QRect& windowRect, bool contentChanged, bool immediate, bool repaintContentOnly); virtual void scroll(const QRect& delta, const QRect& scrollViewRect, const QRect& clipRect); virtual void setToolTip(const String &tip); //BIG mystery here: virtual QWidget* platformWindow() const; }; then a QWebPage gets a pointer to a view() object. When one uses QtWebKit, then one provides such an object whose implementation one writes for one's way of displaying and handling display. This way those insisting on QWidget can be supported via old style QWebView, newer implementations can have QGraphicsWebView, and others can customize any way they like subject to their needs. With the exception to platformWindow(), all of the above are quite obvious on what to write if one is using a QGraphicsSomething to draw, or even to a QPixmap as part of a something else. The biggest offender is ChromeClientQt.cpp, but there are some others: DragClientQt.cpp, EditorClientQt.cpp, FrameLoaderClientQt.cpp, InspectorClientQt.cpp I am worried about what happens with plugins, and this is where careful attention needs to be taken care in deciding how to handle platformWindow(). 145323 24 ariya.hidayat 2009-09-08 05:55:45 -0700 > replace > QWidget* view() > > with > > QSomeCoolSoundingName *view() This changes is binary incompatible. If we want to introduce other function for that, we end up having two "views". Which one to use? 145328 25 hausmann 2009-09-08 06:25:53 -0700 (In reply to comment #23) > I'd like to suggest the following coarse of action: > > Rather than assuming that the viewer of a web page is a particular kind of > class, be it QWebView, QWidget, QGraphicsSomething, etc, lets do this: > > replace > QWidget* view() > > with > > QSomeCoolSoundingName *view() > > where > > class QSomeCoolSoundingName:public QObject > { > public: > virtual QRect windowRect(); > virtual void focus(); > virtual void unfocus(); > virtual void show(); > virtual void repaint(const QRect& windowRect, bool contentChanged, bool > immediate, bool repaintContentOnly); > virtual void scroll(const QRect& delta, const QRect& scrollViewRect, const > QRect& clipRect); > virtual void setToolTip(const String &tip); > > //BIG mystery here: > virtual QWidget* platformWindow() const; > > }; > > then a QWebPage gets a pointer to a view() object. When one uses QtWebKit, then > one provides such an object whose implementation one writes for one's way of > displaying and handling display. This way those insisting on QWidget can be > supported via old style QWebView, newer implementations can have > QGraphicsWebView, and others can customize any way they like subject to their > needs. > > With the exception to platformWindow(), all of the above are quite obvious on > what to write if one is using a QGraphicsSomething to draw, or even to a > QPixmap as part of a something else. > > The biggest offender is ChromeClientQt.cpp, but there are some others: > DragClientQt.cpp, EditorClientQt.cpp, FrameLoaderClientQt.cpp, > InspectorClientQt.cpp It sounds okay to me to introduce this class, but I would prefer to keep it internal and not make it part of the public API initially. It seems more sensible to me to utilize it as internal interface first to abstract away the difference between QWebGraphicsItem and QWebView. 145332 26 kenneth 2009-09-08 06:34:14 -0700 > > +void QWebGraphicsItemPrivate::_q_doScroll(int dx, int dy, const QRect& rectToScroll) > > +{ > > + q->scroll(qreal(dx), qreal(dy), QRectF(rectToScroll)); > > +} > > I found out that this does not really work if I subclass QWebGraphicsItem. > An example: I have my customized QWebGraphicsItem that clips the painting so > that the corners are rounded. When this function is invoked, say scrolling > vertically, the whole painted item is scrolled, meaning the bottom rounded > corners are also scrolled. The correct thing of course that the _contents_ of > the web page is scrolled, not merely the item. > The real fix would be to call update, instead of scroll. I understand that this > is optimization issue, but I'd rather have a correctly painted item than a fast > but garbage one. According to Alexis, you are supposed to reimplement QPainterPath QGraphicsItem::shape () const [virtual] to not return a rectangular shape anymore, but the shape of the item with clipping. This is also used for events (the clipped area should be able to receive events), collision detection, and the QGraphicsScene::items() function. If thsi doesn't work, it can be considered a graphics view bug, I suspect. 145346 27 vestbo 2009-09-08 07:53:19 -0700 After a discussion with Simon we've come up with a strategy for the future relationship/interface between QWebPage and QWebView et. al. Basically we want the interface between the QWebPage and any clients to be as clean and decoupled as possible, while still giving us freedom to do stuff like the cursor changes. Right now the QWebPage interface is mostly in the form of a model in MVC terms, where we have signals (and setters and getters) for changes in the page. We have some hooks where we go directly to the QWebView, which of course increases coupling. What we propose is that we add a private client interface, QWebPageClient or something, that QWebViewPrivate et al. will implement. The QWebPage will keep a pointer to a client, and WebCore will pass on callbacks to the client for stuff like the cursor change. (Side note: the cursor patch in bug 28865 should follow this pattern in a future update, ie not use the dynamic property approach, but that's OK for now). As we see callbacks mature and stabilize in the private QWebPageClient we can move them to the public QWebPage API by transforming into a proper decoupled clean signal+getter/setter-interface, so any features/callbacks in the QWebPageClient should have this in mind (ie. prepare for the future). I think this will give us a good mix of a stable, well tested and decoupled QWebPage API, while at the same time giving us the chance to do cool stuff for QWebView and QWebGraphicsItem. 145348 28 hausmann 2009-09-08 07:55:06 -0700 (In reply to comment #22) > > +void QWebGraphicsItemPrivate::_q_doScroll(int dx, int dy, const QRect& rectToScroll) > > +{ > > + q->scroll(qreal(dx), qreal(dy), QRectF(rectToScroll)); > > +} > > I found out that this does not really work if I subclass QWebGraphicsItem. > An example: I have my customized QWebGraphicsItem that clips the painting so > that the corners are rounded. When this function is invoked, say scrolling > vertically, the whole painted item is scrolled, meaning the bottom rounded > corners are also scrolled. The correct thing of course that the _contents_ of > the web page is scrolled, not merely the item. > The real fix would be to call update, instead of scroll. I understand that this > is optimization issue, but I'd rather have a correctly painted item than a fast > but garbage one. Hehe, well, being able to _scroll_ the webpage instead of repainting it entirely is one of the primary purposes of QWebGraphicsItem. With a QWebView embedded using a QGraphicsProxyWidget we get exactly that repaint-on-scroll behaviour that makes it so slow to use. I agree with Kenneth that this is either a QGraphicsView bug or we lack a mechanism to determine if it is safe to scroll or not. In the worst case we make it a property of QWebGraphicsItem (scrollMode?), in the best case we can detect this situation automatically, similar to QGraphicsItem::scroll()'s implementation. 145353 29 kenneth 2009-09-08 08:00:07 -0700 > Hehe, well, being able to _scroll_ the webpage instead of repainting it > entirely is one of the primary purposes of QWebGraphicsItem. With a QWebView > embedded using a QGraphicsProxyWidget we get exactly that repaint-on-scroll > behaviour that makes it so slow to use. > > I agree with Kenneth that this is either a QGraphicsView bug or we lack a > mechanism to determine if it is safe to scroll or not. In the worst case we > make it a property of QWebGraphicsItem (scrollMode?), in the best case we can > detect this situation automatically, similar to QGraphicsItem::scroll()'s > implementation. Actually if the shape() doesn't work, we could use it in _q_doScroll to get the inner rect and restrict the scroll area to it, and then call update() for the other areas. 145509 30 tonikitoo 2009-09-08 13:03:53 -0700 for the reference, kenneth landed "patch 2" fixed and reviewed by Simon in r48177 145699 31 39125 tonikitoo 2009-09-09 04:04:45 -0700 Comment on attachment 39125 patch 2 - v0.1 - Add support for handling QGraphicsScene events. marking "patch 2 - v0.1" as obsolete, based on action described in comment #30 145700 32 39260 tonikitoo 2009-09-09 04:06:16 -0700 Created attachment 39260 (landed in r48219) patch 1 - v0.3 - add QWebGraphicsItem to the API and QGVLauncher sample application ( ariya's comments addressed. 145702 33 tonikitoo 2009-09-09 04:14:28 -0700 > Overall, looks really good! > r- until the issues above are addressed. ariya, thanks for your comments. (In reply to comment #22) > (From update of attachment 39165 [details]) > > > +#include "qwebpage_p.h" > Is this really needed? so far, yes ... since we are doing this in dtror: QWebGraphicsItem::~QWebGraphicsItem() { if (d->page) d->page->d->view = 0; (..) > > +#include <QGraphicsScene> > > +#include <QGraphicsView> > Can we use the <QtGui/Foo> pattern also here? done > > + setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true); > This is Qt 4.6 only. Please guard it with QT_VERSION properly for <= 4.5. done > > + if (this->progress == progress / 100.0) > Please use qFuzzyCompare. done > > +bool QWebGraphicsItem::interactive() const > Following Qt-ish naming, this should be isInteractive instead. > > + emit interactiveChanged(); done > The name could be misleading. What about interactivityChanged? > > +++ b/WebKit/qt/Api/qwebgraphicsitem_p.h > Is there any reason we need separate file for this? Unline other qweb* classes, QWebGraphicsItemPrivate is not need by anyone else, right? ok, i removed _p.h > > +void QWebGraphicsItemPrivate::_q_doScroll(int dx, int dy, const QRect& rectToScroll) > > +{ > > + q->scroll(qreal(dx), qreal(dy), QRectF(rectToScroll)); > > +} > > I found out that this does not really work if I subclass QWebGraphicsItem. > An example: I have my customized QWebGraphicsItem that clips the painting so > that the corners are rounded. When this function is invoked, say scrolling > vertically, the whole painted item is scrolled, meaning the bottom rounded > corners are also scrolled. The correct thing of course that the _contents_ of > the web page is scrolled, not merely the item. > The real fix would be to call update, instead of scroll. I understand that this is optimization issue, but I'd rather have a correctly painted item than a fast but garbage one. as per discussed w/ kenneth and others, I would rather let this issue to be fixed in a followup bug if possible, as well as some other changes we are listing here: 1) PageClient class (as well as make up a way to platformWidget to not return a QWidget necessarily) - see comment #27 2) make cursor to work 3) Scroll optimization 145714 34 39260 hausmann 2009-09-09 05:58:38 -0700 Comment on attachment 39260 (landed in r48219) patch 1 - v0.3 - add QWebGraphicsItem to the API and QGVLauncher sample application ( r=me, this is a good start! More comments below of stuff that should be fixed in follow-up patches: > +protected: > + virtual void mousePressEvent(QGraphicsSceneMouseEvent*); > + virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*); > + virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent*); > + virtual void mouseMoveEvent(QGraphicsSceneMouseEvent*); > + virtual void hoverMoveEvent(QGraphicsSceneHoverEvent*); > + virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent*); > +#ifndef QT_NO_WHEELEVENT > + virtual void wheelEvent(QGraphicsSceneWheelEvent*); > +#endif > + virtual void keyPressEvent(QKeyEvent*); > + virtual void keyReleaseEvent(QKeyEvent*); > +#ifndef QT_NO_CONTEXTMENU > + virtual void contextMenuEvent(QContextMenuEvent*); > +#endif > + virtual void dragEnterEvent(QGraphicsSceneDragDropEvent*); > + virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent*); > + virtual void dragMoveEvent(QGraphicsSceneDragDropEvent*); > + virtual void dropEvent(QGraphicsSceneDragDropEvent*); > + virtual void focusInEvent(QFocusEvent*); > + virtual void focusOutEvent(QFocusEvent*); > + virtual void inputMethodEvent(QInputMethodEvent*); > + virtual bool focusNextPrevChild(bool next); Please also re-implement QGraphicsItem::sceneEvent() as well as QObject::event(), similar to QWebView. That allows fixing event-related bugs in patch releases without the need to re-implement an existing virtual function, which by adding a new symbol cannot be done in patch releases otherwise. > +++ b/WebKit/qt/QGVLauncher/main.cpp This file has a fewcoding style violations in them (* placement for example). Please fix before landing. > @@ -307,8 +308,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > { > // No double buffer, so only update the QWidget if content changed. > if (contentChanged) { > - QWidget* view = m_webPage->view(); > - if (view) { > + // Only do implicit paints for QWebView's > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) { > QRect rect(windowRect); > rect = rect.intersected(QRect(QPoint(0, 0), m_webPage->viewportSize())); > if (!rect.isEmpty()) > @@ -323,8 +324,8 @@ void ChromeClientQt::repaint(const IntRect& windowRect, bool contentChanged, boo > > void ChromeClientQt::scroll(const IntSize& delta, const IntRect& scrollViewRect, const IntRect&) > { > - QWidget* view = m_webPage->view(); > - if (view) > + // Only do implicit paints for QWebView's > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) > view->scroll(delta.width(), delta.height(), scrollViewRect); > emit m_webPage->scrollRequested(delta.width(), delta.height(), scrollViewRect); > } I really hope that we can eliminate these casts in the future, for example by making QWebGraphicsItem not call setView() but instead simply keep the widget from the events around but not using it in the above methods. I hoi 145715 35 kevin.rogovin 2009-09-09 06:12:51 -0700 Returning to my idea posted as (In reply to comment #25) > It sounds okay to me to introduce this class, but I would prefer to keep it > internal and not make it part of the public API initially. It seems more > sensible to me to utilize it as internal interface first to abstract away the > difference between QWebGraphicsItem and QWebView. Actually, I'd like to make this _public_. Because right now there is a hassle in the moving from QWidget to QGraphicsThingy, and in the future the view object might change again and there are some use cases where the viewer is not a QWidget or QGraphicsThingy but wants the implicit updates from WebCore and the ability to optimize for scroll, etc. As for binary compatibility, it is NOT binary compatible, but if we take a little care it can atleast be source compatible with the old style QWebView usage. I am totally against having to support two different "view()'s ", rather replace the QWidget with the new dumby class that a user writes and we could also provide 3 public implementations of that class: 1. where view() hooks into a QWebView 2. where view() hooks into a "QGraphicsView" 3. where view() hooks into a QPixmap, i.e. the derived object will have a pointer to a QPixmap to draw too. This way, useful examples (in both showing how and actually useful by themselves) are exposed. 145728 36 hausmann 2009-09-09 07:07:25 -0700 (In reply to comment #35) > Returning to my idea posted as (In reply to comment #25) > > > It sounds okay to me to introduce this class, but I would prefer to keep it > > internal and not make it part of the public API initially. It seems more > > sensible to me to utilize it as internal interface first to abstract away the > > difference between QWebGraphicsItem and QWebView. > > Actually, I'd like to make this _public_. Because right now there is a hassle > in the moving from QWidget to QGraphicsThingy, and in the future the view > object might change again and there are some use cases where the viewer is not > a QWidget or QGraphicsThingy but wants the implicit updates from WebCore and > the ability to optimize for scroll, etc. > > As for binary compatibility, it is NOT binary compatible, but if we take a > little care it can atleast be source compatible with the old style QWebView > usage. I am totally against having to support two different "view()'s ", rather > replace the QWidget with the new dumby class that a user writes and we could > also provide 3 public implementations of that class: > > 1. where view() hooks into a QWebView > 2. where view() hooks into a "QGraphicsView" > 3. where view() hooks into a QPixmap, i.e. the derived object will have a > pointer to a QPixmap to draw too. > > This way, useful examples (in both showing how and actually useful by > themselves) are exposed. Unfortunately if it doesn't remain binary compatible it cannot be part of the public API. That's exactly the issue, and that's also why Tor Arne suggested in an earlier comment that we should use QWebPageClient as a staging area for API that should become public once we're confident that it's a reasonable thing to have in a view of QWebPage. 145732 37 kenneth 2009-09-09 07:22:36 -0700 Tor Arne, what do you feel about: class QWebPageClient { public: virtual update(...) const = 0; virtual scroll(...) const = 0; virtual setWebCursor(const QCursor& cursor) { m_webCursor = cursor; } QCursor lastWebCursor() const { return m_webCursor; } virtual QCursor cursor() = 0; virtual int screenNumber() = 0; ... } 145904 38 kenneth 2009-09-09 13:37:52 -0700 Landed in 48219. > Please also re-implement QGraphicsItem::sceneEvent() as well as > QObject::event(), similar to QWebView. > That allows fixing event-related bugs in patch releases without the need to > re-implement an existing > virtual function, which by adding a new symbol cannot be done in patch releases > otherwise. OK, will do it a follow up. > > +++ b/WebKit/qt/QGVLauncher/main.cpp > > This file has a fewcoding style violations in them (* placement for example). > Please fix before landing. Fixed. > > + // Only do implicit paints for QWebView's > > + if (QWebView* view = qobject_cast<QWebView*>(m_webPage->view())) > I really hope that we can eliminate these casts in the future, for example by > making > QWebGraphicsItem not call setView() but instead simply keep the widget from the > events > around but not using it in the above methods. > With the QWebPageClient we will be able to do so. 145906 39 39260 kenneth 2009-09-09 13:38:46 -0700 Comment on attachment 39260 (landed in r48219) patch 1 - v0.3 - add QWebGraphicsItem to the API and QGVLauncher sample application ( Landed in 48219 145913 40 rich 2009-09-09 13:45:49 -0700 I'd be tempted to name this class QWebGraphicsWidget instead, but it looks good to me. And unit tests! 145915 41 jwieczorek 2009-09-09 13:50:54 -0700 +/*! + \property QWebGraphicsItem::zoomFactor + \since 4.5 + \brief the zoom factor for the view +*/ The \since tag should be removed. +/*! + Returns a pointer to the view's history of navigated web pages. + + It is equivalent to + + \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 0 The snippet is for QWebView, should be removed or we should have another one based on QWebGraphicsItem. +QWebHistory* QWebGraphicsItem::history() const +{ + return d->page->history(); +} A bunch of functions such as settings(), load(), history() would crash when the page is null, they should either construct a QWebPage or silently return. An autotest would catch it, I can help you out with that. :) Very nice, Kenneth. :) 145916 42 39299 kenneth 2009-09-09 13:54:43 -0700 Created attachment 39299 Followup: Implement some virtual event methods so that we can fix event-related bugs in Qt patch releases 145918 43 jwieczorek 2009-09-09 14:01:54 -0700 > Very nice, Kenneth. :) And Antonio of course. :) I apologise, should have read the bug carefully :(. 145919 44 39299 vestbo 2009-09-09 14:09:37 -0700 Comment on attachment 39299 Followup: Implement some virtual event methods so that we can fix event-related bugs in Qt patch releases Cool stuff, minor nitpick: > + // Swallow reimplementation in order to allows fixing event-related bugs in patch releases "Swallow"? I think you can drop the comment, or at least fix the "allows" spelling and say something like "Re-implemented in order ..." 145921 45 39299 kenneth 2009-09-09 14:12:18 -0700 Comment on attachment 39299 Followup: Implement some virtual event methods so that we can fix event-related bugs in Qt patch releases Landed in 48221 145926 46 kenneth 2009-09-09 14:18:23 -0700 > I think you can drop the comment, or at least fix the "allows" spelling and say > something like "Re-implemented in order ..." Missed this comment, fixed now. 145938 47 39302 hausmann 2009-09-09 14:29:01 -0700 Created attachment 39302 Call the right base class function QGraphicsWidget::event() instead of skipping it and using QObject::event() instead. Patch by Simon Hausmann <hausmann@webkit.org> on 2009-09-09 Reviewed by NOBODY (OOPS!). * Api/qwebgraphicsitem.cpp: (QWebGraphicsItem::event): --- 2 files changed, 11 insertions(+), 1 deletions(-) 145939 48 39302 vestbo 2009-09-09 14:34:52 -0700 Comment on attachment 39302 Call the right base class function QGraphicsWidget::event() instead > - return QObject::event(event); > + return QGraphicsWidget::event(event); Oops, missed that one. Sorry :/ 145950 49 kenneth 2009-09-09 14:51:04 -0700 (In reply to comment #48) > (From update of attachment 39302 [details]) > > - return QObject::event(event); > > + return QGraphicsWidget::event(event); > > Oops, missed that one. Sorry :/ Auch! Thanks for fixing Simon. 146094 50 39302 hausmann 2009-09-09 23:58:19 -0700 Comment on attachment 39302 Call the right base class function QGraphicsWidget::event() instead Clearing review as it's been landed in r48246 146095 51 hausmann 2009-09-09 23:59:00 -0700 I'm starting to think we should close this bug and continue with new bugs on follow-up issues, including QWebPageClient. 146155 52 kevin.rogovin 2009-09-10 03:46:12 -0700 > Unfortunately if it doesn't remain binary compatible it cannot be part of the > public API. That's exactly the issue, and that's also why Tor Arne suggested in > an earlier comment that we should use QWebPageClient as a staging area for API > that should become public once we're confident that it's a reasonable thing to > have in a view of QWebPage. You are right, and the QWebPageClient is the right thing to do, but, what I do not see how to do is to keep binary compatibility since the files under qt/WebCoreSupport/ are all thinking "QWidget/QWebView" and to keep binary compatibility would they have to support both QWebView and QWebPageClient with preference to QWebPageClient? 146160 53 tonikitoo 2009-09-10 04:30:08 -0700 (In reply to comment #51) > I'm starting to think we should close this bug and continue with new bugs on > follow-up issues, including QWebPageClient. agreed. guys, please lets move discussion about WebPageClient design/impl/gols to bug 29085 , and spin current bug off into followup bug for remaining issues. 146514 54 tonikitoo 2009-09-11 03:46:50 -0700 some follow up bugs: * Bug 29155 - [Qt] Implement autotests for QWebGraphicsItem * Bug 29156 - [Qt] Fix scrolling implementation on QWebGraphicsItem 146532 55 kenneth 2009-09-11 06:25:05 -0700 (In reply to comment #54) > some follow up bugs: > * Bug 29155 - [Qt] Implement autotests for QWebGraphicsItem > * Bug 29156 - [Qt] Fix scrolling implementation on QWebGraphicsItem That is a bit misleading, as the Oslo guys confirmed that our scrolling implementation is indeed correct and that when subclassing you need to implement the virtual shape function as well. If that isn't working, that is a GraphicsView bug and not a WebKit one. 39117 2009-09-05 15:40:42 -0700 2009-09-07 10:35:19 -0700 patch 1 - v0.1 - add QWebGraphicsItem to the API and QGVLauncher sample application. 0001--.-Qt-Add-the-alternative-QtLauncher-based-on.patch text/plain 48983 tonikitoo RnJvbSAzZWI3ZDQ3YTBmN2JmNmFkY2MyYWRkNmJkNWQ3MzRhOTg0NGJlYzJlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBGcmksIDQgU2VwIDIwMDkgMTc6MjA6NDcgLTAzMDAKU3ViamVjdDog W1BBVENIXSAgICAgLjogW1F0XSBBZGQgdGhlIGFsdGVybmF0aXZlIFF0TGF1bmNoZXIgKGJhc2Vk IG9uIFFHcmFwaGljc1ZpZXcpIHRvIHRoZSBidWlsZC4KCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKCiAgICBXZWJLaXQvcXQ6IEFkZCBhIG5ldyBRR3Jh cGhpY3NXaWRnZXQgYmFzZWQgdmVyc2lvbiBvZiB0aGUgIlFXZWJWaWV3IgogICAgdW5kZXIgdGhl IG5hbWUgIlFXZWJHcmFwaGljc0l0ZW0iLgoKICAgIEluY2x1ZGVzIGFuIGFsdGVybmF0aXZlIFF0 IGxhdW5jaGVyIHVzaW5nIHRoZSBRR3JhcGhpY3NWaWV3LgoKICAgIFBhdGNoIGJ5IEtlbm5ldGgg Um9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPiwgQW50b25pbyBHb21lcyA8 YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIEFwaS9oZWFkZXJzLnByaToKICAgICogQXBpL3F3ZWJn cmFwaGljc2l0ZW0uY3BwOiBBZGRlZC4KICAgIChRV2ViR3JhcGhpY3NJdGVtOjpRV2ViR3JhcGhp Y3NJdGVtKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjp+UVdlYkdyYXBoaWNzSXRlbSk6CiAgICAo UVdlYkdyYXBoaWNzSXRlbTo6cGFnZSk6CiAgICAoUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9x X2RvTG9hZFByb2dyZXNzKToKICAgIChRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9Mb2Fk RmluaXNoZWQpOgogICAgKFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb1Njcm9sbCk6CiAg ICAoUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9xX2RvVXBkYXRlKToKICAgIChRV2ViR3JhcGhp Y3NJdGVtOjpwYWludCk6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6c2V0UGFnZSk6CiAgICAoUVdl YkdyYXBoaWNzSXRlbTo6c2V0VXJsKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjp1cmwpOgogICAg KFFXZWJHcmFwaGljc0l0ZW06OnRpdGxlKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjppY29uKToK ICAgIChRV2ViR3JhcGhpY3NJdGVtOjpzZXRUZXh0U2l6ZU11bHRpcGxpZXIpOgogICAgKFFXZWJH cmFwaGljc0l0ZW06OnRleHRTaXplTXVsdGlwbGllcik6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6 c2V0Wm9vbUZhY3Rvcik6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6em9vbUZhY3Rvcik6CiAgICAo UVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9xX3NldFN0YXR1c0Jhck1lc3NhZ2UpOgogICAgKFFX ZWJHcmFwaGljc0l0ZW06OnVwZGF0ZUdlb21ldHJ5KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpz ZXRHZW9tZXRyeSk6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6c3RhdHVzKToKICAgIChRV2ViR3Jh cGhpY3NJdGVtOjpzdG9wKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpiYWNrKToKICAgIChRV2Vi R3JhcGhpY3NJdGVtOjpmb3J3YXJkKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpyZWxvYWQpOgog ICAgKFFXZWJHcmFwaGljc0l0ZW06OnByb2dyZXNzKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjps b2FkKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpzZXRIdG1sKToKICAgIChRV2ViR3JhcGhpY3NJ dGVtOjp0b0h0bWwpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06OnNldENvbnRlbnQpOgogICAgKFFX ZWJHcmFwaGljc0l0ZW06Omhpc3RvcnkpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06OmludGVyYWN0 aXZlKToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpzZXRJbnRlcmFjdGl2ZSk6CiAgICAoUVdlYkdy YXBoaWNzSXRlbTo6c2V0dGluZ3MpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06OmhvdmVyTW92ZUV2 ZW50KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpob3ZlckxlYXZlRXZlbnQpOgogICAgKFFXZWJH cmFwaGljc0l0ZW06Om1vdXNlTW92ZUV2ZW50KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjptb3Vz ZVByZXNzRXZlbnQpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06Om1vdXNlUmVsZWFzZUV2ZW50KToK ICAgIChRV2ViR3JhcGhpY3NJdGVtOjptb3VzZURvdWJsZUNsaWNrRXZlbnQpOgogICAgKFFXZWJH cmFwaGljc0l0ZW06OmtleVByZXNzRXZlbnQpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06OmtleVJl bGVhc2VFdmVudCk6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6Zm9jdXNJbkV2ZW50KToKICAgIChR V2ViR3JhcGhpY3NJdGVtOjpmb2N1c091dEV2ZW50KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpm b2N1c05leHRQcmV2Q2hpbGQpOgogICAgKFFXZWJHcmFwaGljc0l0ZW06OmRyYWdFbnRlckV2ZW50 KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpkcmFnTGVhdmVFdmVudCk6CiAgICAoUVdlYkdyYXBo aWNzSXRlbTo6ZHJhZ01vdmVFdmVudCk6CiAgICAoUVdlYkdyYXBoaWNzSXRlbTo6ZHJvcEV2ZW50 KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjpjb250ZXh0TWVudUV2ZW50KToKICAgIChRV2ViR3Jh cGhpY3NJdGVtOjp3aGVlbEV2ZW50KToKICAgIChRV2ViR3JhcGhpY3NJdGVtOjppbnB1dE1ldGhv ZEV2ZW50KToKICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uaDogQWRkZWQuCiAgICAqIEFwaS9x d2ViZ3JhcGhpY3NpdGVtX3AuaDogQWRkZWQuCiAgICAoUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6 OlFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlKToKICAgICogQXBpL3F3ZWJwYWdlLmNwcDoKICAgIChp bml0aWFsaXplQXBwbGljYXRpb25DYWNoZVBhdGhJZk5lY2Vzc2FyeSk6CiAgICAqIEFwaS9xd2Vi cGFnZS5oOgogICAgKiBRR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdl YktpdC9xdC9RdExhdW5jaGVyL1F0TGF1bmNoZXIucHJvLgogICAgKiBRR1ZMYXVuY2hlci9tYWlu LmNwcDogQWRkZWQuCiAgICAoV2ViUGFnZTo6V2ViUGFnZSk6CiAgICAoTWFpblZpZXc6Ok1haW5W aWV3KToKICAgIChNYWluVmlldzo6c2V0TWFpbldpZGdldCk6CiAgICAoTWFpblZpZXc6OnJlc2l6 ZUV2ZW50KToKICAgIChTaGFyZWRTY2VuZTo6U2hhcmVkU2NlbmUpOgogICAgKFNoYXJlZFNjZW5l Ojp+U2hhcmVkU2NlbmUpOgogICAgKFNoYXJlZFNjZW5lOjpzY2VuZSk6CiAgICAoU2hhcmVkU2Nl bmU6OndlYkl0ZW0pOgogICAgKE1haW5XaW5kb3c6Ok1haW5XaW5kb3cpOgogICAgKE1haW5XaW5k b3c6OmluaXQpOgogICAgKE1haW5XaW5kb3c6OmxvYWQpOgogICAgKE1haW5XaW5kb3c6Omd1ZXNz VXJsRnJvbVN0cmluZyk6CiAgICAoTWFpbldpbmRvdzo6cGFnZSk6CiAgICAoTWFpbldpbmRvdzo6 Y2hhbmdlTG9jYXRpb24pOgogICAgKE1haW5XaW5kb3c6OmxvYWRGaW5pc2hlZCk6CiAgICAoTWFp bldpbmRvdzo6bmV3V2luZG93KToKICAgIChNYWluV2luZG93OjpjbG9uZSk6CiAgICAoTWFpbldp bmRvdzo6YnVpbGRVSSk6CiAgICAoV2ViUGFnZTo6Y3JlYXRlV2luZG93KToKICAgIChXZWJQYWdl OjphcHBseVByb3h5KToKICAgIChtYWluKToKICAgICogV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xp ZW50UXQuY3BwOgogICAgKFdlYkNvcmU6OkNocm9tZUNsaWVudFF0OjpyZXBhaW50KToKICAgIChX ZWJDb3JlOjpDaHJvbWVDbGllbnRRdDo6c2Nyb2xsKToKCiAgICBXZWJLaXQ6IEFkZCB0aGUgUUdW TGF1bmNoZXIgdGhlIGJ1aWxkIHN5c3RlbS4KCiAgICBQYXRjaCBieSBLZW5uZXRoIFJvaGRlIENo cmlzdGlhbnNlbiA8a2VubmV0aEB3ZWJraXQub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIFdlYktpdC5wcm86CgogICAgV2ViQ29yZTogQWRk IHRoZSBxd2ViZ3JhcGhpY3NpdGVtLmNwcCB0byB0aGUgYnVpbGQgc3lzdGVtLgoKICAgIFBhdGNo IGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuIDxrZW5uZXRoQHdlYmtpdC5vcmc+IG9uIDIw MDktMDktMDQKICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICogV2ViQ29yZS5w cm86Ci0tLQogQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg IDkgKwogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDgg KwogV2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwog V2ViS2l0LnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2Vi S2l0L3F0L0FwaS9oZWFkZXJzLnByaSAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViS2l0 L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcCAgICAgICAgICB8ICA3MjQgKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uaCAgICAgICAg ICAgIHwgIDE0OCArKysrKysKIFdlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbV9wLmggICAg ICAgICAgfCAgIDQzICsrCiBXZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmggICAgICAgICAgICAgICAg ICAgIHwgICAgMSArCiBXZWJLaXQvcXQvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAg IHwgICA5OCArKysrCiBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvUUdWTGF1bmNoZXIucHJvICAgICAg IHwgICAxMyArCiBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAgICAgICAgICAgICAgIHwg IDMwMCArKysrKysrKysrKwogV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0 LmNwcCB8ICAgIDkgKy0KIDEzIGZpbGVzIGNoYW5nZWQsIDEzNTIgaW5zZXJ0aW9ucygrKSwgNCBk ZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGlj c2l0ZW0uY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3Np dGVtLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW1f cC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVy LnBybwogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9xdC9RR1ZMYXVuY2hlci9tYWluLmNwcAoK ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBhNTE1MjljLi43Y2E3NjM3 IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAK KzIwMDktMDktMDQgIEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQu b3JnPgorCisgICAgICAgIFBhdGNoIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuICA8a2Vu bmV0aEB3ZWJraXQub3JnPiwgQW50b25pbyBHb21lcyA8YW50b25pby5nb21lc0BvcGVuYm9zc2Eu b3JnPiBvbiAyMDA5LTA5LTA0CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtRdF0gQWRkIHRoZSBhbHRlcm5hdGl2ZSBRdExhdW5jaGVyIChiYXNlZCBvbiBR R3JhcGhpY3NWaWV3KSB0byB0aGUgYnVpbGQuCisKKyAgICAgICAgKiBXZWJLaXQucHJvOgorCiAy MDA5LTA5LTA0ICBBbGJlcnQgQmFjaGFuZCAgPGFsYmVydGJAZ29vZ2xlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9n IGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODlmYmEwZi4uMWNhNjkzMiAxMDA2NDQKLS0tIGEv V2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMSBA QAorMjAwOS0wOS0wNCAgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4gIDxrZW5uZXRoQHdlYmtp dC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg QWRkIHRoZSBxd2ViZ3JhcGhpY3NpdGVtLmNwcCB0byB0aGUgYnVpbGQgc3lzdGVtLgorCisgICAg ICAgICogV2ViQ29yZS5wcm86CisKIDIwMDktMDktMDQgIERhdmUgSHlhdHQgIDxoeWF0dEBhcHBs ZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBSb2Jlbi4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IGU2MDYzNDIuLmMy MWZjNmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJD b3JlLnBybwpAQCAtMjM2Myw2ICsyMzYzLDcgQEAgU09VUkNFUyArPSBcCiAgICAgLi4vV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwIFwKICAgICAuLi9XZWJL aXQvcXQvV2ViQ29yZVN1cHBvcnQvSW5zcGVjdG9yQ2xpZW50UXQuY3BwIFwKICAgICAuLi9XZWJL aXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgXAorICAgIC4uL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBo aWNzaXRlbS5jcHAgXAogICAgIC4uL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIFwKICAgICAu Li9XZWJLaXQvcXQvQXBpL3F3ZWJ2aWV3LmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L0FwaS9xd2Vi ZWxlbWVudC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViS2l0LnBybyBiL1dlYktpdC5wcm8KaW5kZXgg MGJhMTRlNC4uODY2YmI5YiAxMDA2NDQKLS0tIGEvV2ViS2l0LnBybworKysgYi9XZWJLaXQucHJv CkBAIC01LDYgKzUsNyBAQCBTVUJESVJTICs9IFwKICAgICAgICAgV2ViQ29yZSBcCiAgICAgICAg IEphdmFTY3JpcHRDb3JlL2pzYy5wcm8gXAogICAgICAgICBXZWJLaXQvcXQvUXRMYXVuY2hlciBc CisgICAgICAgIFdlYktpdC9xdC9RR1ZMYXVuY2hlciBcCiAgICAgICAgIFdlYktpdC9xdC90ZXN0 cwogCiAhd2luMzI6IXN5bWJpYW4gewpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9oZWFkZXJz LnByaSBiL1dlYktpdC9xdC9BcGkvaGVhZGVycy5wcmkKaW5kZXggOTJhMTIwZC4uMzBhMzZlZiAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9oZWFkZXJzLnByaQorKysgYi9XZWJLaXQvcXQvQXBp L2hlYWRlcnMucHJpCkBAIC0xLDQgKzEsNSBAQAogV0VCS0lUX0FQSV9IRUFERVJTID0gJCRQV0Qv cXdlYmZyYW1lLmggXAorICAgICAgICAgICAgICAgICAgICAgJCRQV0QvcXdlYmdyYXBoaWNzaXRl bS5oIFwKICAgICAgICAgICAgICAgICAgICAgICQkUFdEL3F3ZWJraXRnbG9iYWwuaCBcCiAgICAg ICAgICAgICAgICAgICAgICAkJFBXRC9xd2VicGFnZS5oIFwKICAgICAgICAgICAgICAgICAgICAg ICQkUFdEL3F3ZWJ2aWV3LmggXApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhp Y3NpdGVtLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTAwNjI2ZQotLS0gL2Rldi9udWxsCisrKyBiL1dl YktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAKQEAgLTAsMCArMSw3MjQgQEAKKy8qCisg ICAgQ29weXJpZ2h0IChDKSAyMDA5IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lk aWFyeSgtaWVzKQorCisgICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgICAgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgICAgdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisg ICAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCisgICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICAgIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICAgWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICAgIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJ ZiBub3QsIHdyaXRlIHRvCisgICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwg NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAgICBCb3N0b24sIE1BIDAyMTEwLTEz MDEsIFVTQS4KKyovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJxd2ViZ3JhcGhp Y3NpdGVtLmgiCisKKyNpbmNsdWRlICJxd2ViZnJhbWUuaCIKKyNpbmNsdWRlICJxd2ViZ3JhcGhp Y3NpdGVtX3AuaCIKKyNpbmNsdWRlICJxd2VicGFnZS5oIgorI2luY2x1ZGUgInF3ZWJwYWdlX3Au aCIKKyNpbmNsdWRlIDxRdC9xc3R5bGVvcHRpb24uaD4KKyNpbmNsdWRlIDxRdEd1aS9xYXBwbGlj YXRpb24uaD4KKyNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhpY3NzY2VuZWV2ZW50Lmg+CisjaW5jbHVk ZSA8UUdyYXBoaWNzU2NlbmU+CisjaW5jbHVkZSA8UUdyYXBoaWNzVmlldz4KKworLyohCisgICAg XGJyaWVmIFRoZSBXZWJQYWdlIGl0ZW0gYWxsb3dzIHlvdSB0byBhZGQgd2ViIGNvbnRlbnQgdG8g YSBjYW52YXMuCisgICAgXGluaGVyaXRzIFFHcmFwaGljc1dpZGdldC4KKyAgICBBIFdlYkdyYXBo aWNzSXRlbSByZW5kZXJzIHdlYiBjb250ZW50IGJhc2VkIG9uIGEgVVJMIG9yIHNldCBkYXRhLgor CisgICAgSWYgdGhlIHdpZHRoIGFuZCBoZWlnaHQgb2YgdGhlIGl0ZW0gaXMgbm90IHNldCwgdGhl eSB3aWxsCisgICAgZHluYW1pY2FsbHkgYWRqdXN0IHRvIGEgc2l6ZSBhcHByb3ByaWF0ZSBmb3Ig dGhlIGNvbnRlbnQuCisgICAgVGhpcyB3aWR0aCBtYXkgYmUgbGFyZ2UgKGVnLiA5ODApIGZvciB0 eXBpY2FsIG9ubGluZSB3ZWIgcGFnZXMuCisqLworCisvKiEKKyAgICBDb25zdHJ1Y3RzIGFuIGVt cHR5IFFXZWJHcmFwaGljc0l0ZW0gd2l0aCBwYXJlbnQgXGEgcGFyZW50LworCisgICAgXHNhIGxv YWQoKQorKi8KK1FXZWJHcmFwaGljc0l0ZW06OlFXZWJHcmFwaGljc0l0ZW0oUUdyYXBoaWNzSXRl bSogcGFyZW50KQorICAgIDogUUdyYXBoaWNzV2lkZ2V0KHBhcmVudCkKKyAgICAsIGQobmV3IFFX ZWJHcmFwaGljc0l0ZW1Qcml2YXRlKHRoaXMpKQoreworICAgIHNldEZsYWcoUUdyYXBoaWNzSXRl bTo6SXRlbVVzZXNFeHRlbmRlZFN0eWxlT3B0aW9uLCB0cnVlKTsKKyAgICBzZXRBY2NlcHRIb3Zl ckV2ZW50cyh0cnVlKTsKKyAgICBzZXRGb2N1c1BvbGljeShRdDo6U3Ryb25nRm9jdXMpOworfQor CisvKiEKKyAgICBEZXN0cm95cyB0aGUgd2ViIGdyYXBoaWNzaXRlbS4KKyovCitRV2ViR3JhcGhp Y3NJdGVtOjp+UVdlYkdyYXBoaWNzSXRlbSgpCit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAg IGQtPnBhZ2UtPnNldFZpZXcoMCk7CisKKyAgICBpZiAoZC0+cGFnZSAmJiBkLT5wYWdlLT5wYXJl bnQoKSA9PSB0aGlzKQorICAgICAgICBkZWxldGUgZC0+cGFnZTsKKworICAgIGRlbGV0ZSBkOwor fQorCisvKiEKKyAgICBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgdW5kZXJseWluZyB3ZWIgcGFn ZS4KKworICAgIFxzYSBzZXRQYWdlKCkKKyovCitRV2ViUGFnZSogUVdlYkdyYXBoaWNzSXRlbTo6 cGFnZSgpIGNvbnN0Cit7CisgICAgaWYgKCFkLT5wYWdlKSB7CisgICAgICAgIFFXZWJHcmFwaGlj c0l0ZW0qIHRoYXQgPSBjb25zdF9jYXN0PFFXZWJHcmFwaGljc0l0ZW0qPih0aGlzKTsKKyAgICAg ICAgUVdlYlBhZ2UqIHBhZ2UgPSBuZXcgUVdlYlBhZ2UodGhhdCk7CisKKyAgICAgICAgLy8gRGVm YXVsdCB0byBub3QgaGF2aW5nIGEgYmFja2dyb3VuZCwgaW4gdGhlIGNhc2UKKyAgICAgICAgLy8g dGhlIHBhZ2UgZG9lc24ndCBwcm92aWRlIG9uZS4KKyAgICAgICAgUVBhbGV0dGUgcGFsZXR0ZSA9 IFFBcHBsaWNhdGlvbjo6cGFsZXR0ZSgpOworICAgICAgICBwYWxldHRlLnNldEJydXNoKFFQYWxl dHRlOjpCYXNlLCBRQ29sb3I6OmZyb21SZ2JGKDAsIDAsIDAsIDApKTsKKyAgICAgICAgcGFnZS0+ c2V0UGFsZXR0ZShwYWxldHRlKTsKKworICAgICAgICB0aGF0LT5zZXRQYWdlKHBhZ2UpOworICAg IH0KKworICAgIHJldHVybiBkLT5wYWdlOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW1Qcml2 YXRlOjpfcV9kb0xvYWRQcm9ncmVzcyhpbnQgcHJvZ3Jlc3MpCit7CisgICAgaWYgKHRoaXMtPnBy b2dyZXNzID09IHByb2dyZXNzIC8gMTAwLjApCisgICAgICAgIHJldHVybjsKKworICAgIHRoaXMt PnByb2dyZXNzID0gcHJvZ3Jlc3MgLyAxMDAuMDsKKworICAgIGVtaXQgcS0+cHJvZ3Jlc3NDaGFu Z2VkKHRoaXMtPnByb2dyZXNzKTsKK30KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6 X3FfZG9Mb2FkRmluaXNoZWQoYm9vbCBzdWNjZXNzKQoreworICAgIC8vIElmIHRoZSBwYWdlIGhh ZCBubyB0aXRsZSwgc3RpbGwgbWFrZSBzdXJlIGl0IGdldHMgdGhlIHNpZ25hbAorICAgIGlmIChx LT50aXRsZSgpLmlzRW1wdHkoKSkKKyAgICAgICAgZW1pdCBxLT51cmxDaGFuZ2VkKHEtPnVybCgp KTsKKworICAgIGlmIChzdWNjZXNzKQorICAgICAgICBlbWl0IHEtPmxvYWRGaW5pc2hlZCgpOwor ICAgIGVsc2UKKyAgICAgICAgZW1pdCBxLT5sb2FkRmFpbGVkKCk7Cit9CisKK3ZvaWQgUVdlYkdy YXBoaWNzSXRlbVByaXZhdGU6Ol9xX2RvU2Nyb2xsKGludCBkeCwgaW50IGR5LCBjb25zdCBRUmVj dCYgcmVjdFRvU2Nyb2xsKQoreworICAgIHEtPnNjcm9sbChxcmVhbChkeCksIHFyZWFsKGR5KSwg UVJlY3RGKHJlY3RUb1Njcm9sbCkpOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRl OjpfcV9kb1VwZGF0ZShjb25zdCBRUmVjdCAmIGRpcnR5UmVjdCkKK3sKKyAgICBxLT51cGRhdGUo UVJlY3RGKGRpcnR5UmVjdCkpOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnBhaW50KFFQ YWludGVyKiBwYWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbiwg UVdpZGdldCopCit7CisgICAgcGFnZSgpLT5tYWluRnJhbWUoKS0+cmVuZGVyKHBhaW50ZXIsIG9w dGlvbi0+ZXhwb3NlZFJlY3QudG9SZWN0KCkpOworfQorCisvKiEKKyAgICBNYWtlcyBcYSBwYWdl IHRoZSBuZXcgd2ViIHBhZ2Ugb2YgdGhlIHdlYiB2aWV3LgorCisgICAgVGhlIHBhcmVudCBRT2Jq ZWN0IG9mIHRoZSBwcm92aWRlZCBwYWdlIHJlbWFpbnMgdGhlIG93bmVyCisgICAgb2YgdGhlIG9i amVjdC4gSWYgdGhlIGN1cnJlbnQgZG9jdW1lbnQgaXMgYSBjaGlsZCBvZiB0aGUgd2ViCisgICAg dmlldywgaXQgd2lsbCBiZSBkZWxldGVkLgorCisgICAgXHNhIHBhZ2UoKQorKi8KK3ZvaWQgUVdl YkdyYXBoaWNzSXRlbTo6c2V0UGFnZShRV2ViUGFnZSogcGFnZSkKK3sKKyAgICBpZiAoZC0+cGFn ZSA9PSBwYWdlKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoZC0+cGFnZSkgeworICAgICAg ICBpZiAoZC0+cGFnZS0+cGFyZW50KCkgPT0gdGhpcykKKyAgICAgICAgICAgIGRlbGV0ZSBkLT5w YWdlOworICAgICAgICBlbHNlCisgICAgICAgICAgICBkLT5wYWdlLT5kaXNjb25uZWN0KHRoaXMp OworICAgIH0KKworICAgIGQtPnBhZ2UgPSBwYWdlOworICAgIGlmICghZC0+cGFnZSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgUVNpemUgc2l6ZSA9IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgp OworICAgIHBhZ2UtPnNldFZpZXdwb3J0U2l6ZShzaXplKTsKKworICAgIFFXZWJGcmFtZSogbWFp bkZyYW1lID0gZC0+cGFnZS0+bWFpbkZyYW1lKCk7CisKKyAgICBjb25uZWN0KG1haW5GcmFtZSwg U0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3RyaW5nJikpLAorICAgICAgICAgICAgdGhpcywg U0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3RyaW5nJikpKTsKKyAgICBjb25uZWN0KG1haW5G cmFtZSwgU0lHTkFMKGljb25DaGFuZ2VkKCkpLAorICAgICAgICAgICAgdGhpcywgU0lHTkFMKGlj b25DaGFuZ2VkKCkpKTsKKyAgICBjb25uZWN0KG1haW5GcmFtZSwgU0lHTkFMKHVybENoYW5nZWQo Y29uc3QgUVVybCYpKSwKKyAgICAgICAgICAgIHRoaXMsIFNJR05BTCh1cmxDaGFuZ2VkKGNvbnN0 IFFVcmwmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKGxvYWRTdGFydGVkKCkpLAor ICAgICAgICAgICAgdGhpcywgU0lHTkFMKGxvYWRTdGFydGVkKCkpKTsKKyAgICBjb25uZWN0KGQt PnBhZ2UsIFNJR05BTChsb2FkUHJvZ3Jlc3MoaW50KSksCisgICAgICAgICAgICB0aGlzLCBTTE9U KF9xX2RvTG9hZFByb2dyZXNzKGludCkpKTsKKyAgICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChs b2FkRmluaXNoZWQoYm9vbCkpLAorICAgICAgICAgICAgdGhpcywgU0xPVChfcV9kb0xvYWRGaW5p c2hlZChib29sKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKHJlcGFpbnRSZXF1ZXN0 ZWQoUVJlY3QpKSwKKyAgICAgICAgICAgIHRoaXMsIFNMT1QoX3FfZG9VcGRhdGUoY29uc3QgUVJl Y3QmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKHNjcm9sbFJlcXVlc3RlZChpbnQs IGludCwgY29uc3QgUVJlY3QmKSksCisgICAgICAgICAgICB0aGlzLCBTTE9UKF9xX2RvU2Nyb2xs KGludCwgaW50LCBjb25zdCBRUmVjdCYpKSk7CisgICAgY29ubmVjdChkLT5wYWdlLCBTSUdOQUwo c3RhdHVzQmFyTWVzc2FnZShjb25zdCBRU3RyaW5nJikpLAorICAgICAgICAgICAgdGhpcywgU0xP VChfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFTdHJpbmcmKSkpOworfQorCisvKiEKKyAg ICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6dXJsCisgICAgXGJyaWVmIHRoZSB1cmwgb2Yg dGhlIHdlYiBwYWdlIGN1cnJlbnRseSB2aWV3ZWQKKworICAgIFNldHRpbmcgdGhpcyBwcm9wZXJ0 eSBjbGVhcnMgdGhlIHZpZXcgYW5kIGxvYWRzIHRoZSBVUkwuCisKKyAgICBCeSBkZWZhdWx0LCB0 aGlzIHByb3BlcnR5IGNvbnRhaW5zIGFuIGVtcHR5LCBpbnZhbGlkIFVSTC4KKworICAgIFxzYSBs b2FkKCksIHVybENoYW5nZWQoKQorKi8KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpzZXRVcmwo Y29uc3QgUVVybCAmdXJsKQoreworICAgIGlmICh1cmwgPT0gcGFnZSgpLT5tYWluRnJhbWUoKS0+ dXJsKCkpCisgICAgICAgIHJldHVybjsKKworICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPnNldFVy bCh1cmwpOworfQorCitRVXJsIFFXZWJHcmFwaGljc0l0ZW06OnVybCgpIGNvbnN0Cit7CisgICAg aWYgKGQtPnBhZ2UpCisgICAgICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJhbWUoKS0+dXJsKCk7 CisKKyAgICByZXR1cm4gUVVybCgpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBo aWNzSXRlbTo6dGl0bGUKKyAgICBcYnJpZWYgdGhlIHRpdGxlIG9mIHRoZSB3ZWIgcGFnZSBjdXJy ZW50bHkgdmlld2VkCisKKyAgICBCeSBkZWZhdWx0LCB0aGlzIHByb3BlcnR5IGNvbnRhaW5zIGFu IGVtcHR5IHN0cmluZy4KKworICAgIFxzYSB0aXRsZUNoYW5nZWQoKQorKi8KK1FTdHJpbmcgUVdl YkdyYXBoaWNzSXRlbTo6dGl0bGUoKSBjb25zdAoreworICAgIGlmIChkLT5wYWdlKQorICAgICAg ICByZXR1cm4gZC0+cGFnZS0+bWFpbkZyYW1lKCktPnRpdGxlKCk7CisKKyAgICByZXR1cm4gUVN0 cmluZygpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6aWNvbgor ICAgIFxicmllZiB0aGUgaWNvbiBhc3NvY2lhdGVkIHdpdGggdGhlIHdlYiBwYWdlIGN1cnJlbnRs eSB2aWV3ZWQKKworICAgIEJ5IGRlZmF1bHQsIHRoaXMgcHJvcGVydHkgY29udGFpbnMgYSBudWxs IGljb24uCisKKyAgICBcc2EgaWNvbkNoYW5nZWQoKSwgUVdlYlNldHRpbmdzOjppY29uRm9yVXJs KCkKKyovCitRSWNvbiBRV2ViR3JhcGhpY3NJdGVtOjppY29uKCkgY29uc3QKK3sKKyAgICByZXR1 cm4gcGFnZSgpLT5tYWluRnJhbWUoKS0+aWNvbigpOworfQorCisvKiEKKyAgXHByb3BlcnR5IFFX ZWJHcmFwaGljc0l0ZW06OnRleHRTaXplTXVsdGlwbGllcgorICBcYnJpZWYgdGhlIHNjYWxpbmcg ZmFjdG9yIGZvciBhbGwgdGV4dCBpbiB0aGUgZnJhbWUKKyAgXG9ic29sZXRlCisKKyAgVXNlIHNl dFpvb21GYWN0b3IgaW5zdGVhZCwgaW4gY29tYmluYXRpb24gd2l0aCB0aGUKKyAgWm9vbVRleHRP bmx5IGF0dHJpYnV0ZSBpbiBRV2ViU2V0dGluZ3MuCisKKyAgXG5vdGUgU2V0dGluZyB0aGlzIHBy b3BlcnR5IGFsc28gZW5hYmxlcyB0aGUKKyAgWm9vbVRleHRPbmx5IGF0dHJpYnV0ZSBpbiBRV2Vi U2V0dGluZ3MuCisKKyAgQnkgZGVmYXVsdCwgdGhpcyBwcm9wZXJ0eSBjb250YWlucyBhIHZhbHVl IG9mIDEuMC4KKyovCisKKy8qIQorICAgIFNldHMgdGhlIHZhbHVlIG9mIHRoZSBtdWx0aXBsaWVy IHVzZWQgdG8gc2NhbGUgdGhlIHRleHQgaW4gYSBXZWIgcGFnZSB0bworICAgIHRoZSBcYSBmYWN0 b3Igc3BlY2lmaWVkLgorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0VGV4dFNpemVNdWx0 aXBsaWVyKHFyZWFsIGZhY3RvcikKK3sKKyAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5zZXRUZXh0 U2l6ZU11bHRpcGxpZXIoZmFjdG9yKTsKK30KKworLyohCisgICAgUmV0dXJucyB0aGUgdmFsdWUg b2YgdGhlIG11bHRpcGxpZXIgdXNlZCB0byBzY2FsZSB0aGUgdGV4dCBpbiBhIFdlYiBwYWdlLgor Ki8KK3FyZWFsIFFXZWJHcmFwaGljc0l0ZW06OnRleHRTaXplTXVsdGlwbGllcigpIGNvbnN0Cit7 CisgICAgcmV0dXJuIHBhZ2UoKS0+bWFpbkZyYW1lKCktPnRleHRTaXplTXVsdGlwbGllcigpOwor fQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6em9vbUZhY3RvcgorICAg IFxzaW5jZSA0LjUKKyAgICBcYnJpZWYgdGhlIHpvb20gZmFjdG9yIGZvciB0aGUgdmlldworKi8K Kwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpzZXRab29tRmFjdG9yKHFyZWFsIGZhY3RvcikKK3sK KyAgICBpZiAoZmFjdG9yID09IHBhZ2UoKS0+bWFpbkZyYW1lKCktPnpvb21GYWN0b3IoKSkKKyAg ICAgICAgcmV0dXJuOworCisgICAgcGFnZSgpLT5tYWluRnJhbWUoKS0+c2V0Wm9vbUZhY3Rvcihm YWN0b3IpOworCisgICAgZW1pdCB6b29tRmFjdG9yQ2hhbmdlZCgpOworfQorCitxcmVhbCBRV2Vi R3JhcGhpY3NJdGVtOjp6b29tRmFjdG9yKCkgY29uc3QKK3sKKyAgICByZXR1cm4gcGFnZSgpLT5t YWluRnJhbWUoKS0+em9vbUZhY3RvcigpOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW1Qcml2 YXRlOjpfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFTdHJpbmcmIHMpCit7CisgICAgc3Rh dHVzQmFyTWVzc2FnZSA9IHM7CisgICAgcS0+ZW1pdCBzdGF0dXNDaGFuZ2VkKCk7Cit9CisKK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6dXBkYXRlR2VvbWV0cnkoKQoreworICAgIFFHcmFwaGljc1dp ZGdldDo6dXBkYXRlR2VvbWV0cnkoKTsKKyAgICBRU2l6ZSBzaXplID0gZ2VvbWV0cnkoKS5zaXpl KCkudG9TaXplKCk7CisgICAgcGFnZSgpLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7Cit9CisKK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0R2VvbWV0cnkoY29uc3QgUVJlY3RGJiByZWN0KQorewor ICAgIFFHcmFwaGljc1dpZGdldDo6c2V0R2VvbWV0cnkocmVjdCk7CisgICAgLy8gTk9URTogY2Fs bCBnZW9tZXRyeSgpIGFzIHNldEdlb21ldHJ5IGVuc3VyZXMgdGhhdAorICAgIC8vIHRoZSBnZW9t ZXRyeSBpcyB3aXRoaW4gbGVnYWwgYm91bmRzIChtaW5pbXVtU2l6ZSwgbWF4aW11bVNpemUpCisg ICAgUVNpemUgc2l6ZSA9IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgpOworICAgIHBhZ2UoKS0+ c2V0Vmlld3BvcnRTaXplKHNpemUpOworfQorCitRU3RyaW5nIFFXZWJHcmFwaGljc0l0ZW06OnN0 YXR1cygpIGNvbnN0Cit7CisgICAgcmV0dXJuIGQtPnN0YXR1c0Jhck1lc3NhZ2U7Cit9CisKKy8q IQorICAgIENvbnZlbmllbmNlIHNsb3QgdGhhdCBzdG9wcyBsb2FkaW5nIHRoZSBkb2N1bWVudC4K KworICAgIFxzYSByZWxvYWQoKSwgcGFnZUFjdGlvbigpLCBsb2FkRmluaXNoZWQoKQorKi8KK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6c3RvcCgpCit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAg IGQtPnBhZ2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBhZ2U6OlN0b3ApOworfQorCisvKiEKKyAgICBD b252ZW5pZW5jZSBzbG90IHRoYXQgbG9hZHMgdGhlIHByZXZpb3VzIGRvY3VtZW50IGluIHRoZSBs aXN0IG9mIGRvY3VtZW50cworICAgIGJ1aWx0IGJ5IG5hdmlnYXRpbmcgbGlua3MuIERvZXMgbm90 aGluZyBpZiB0aGVyZSBpcyBubyBwcmV2aW91cyBkb2N1bWVudC4KKworICAgIFxzYSBmb3J3YXJk KCksIHBhZ2VBY3Rpb24oKQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6YmFjaygpCit7Cisg ICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBhZ2U6 OkJhY2spOworfQorCisvKiEKKyAgICBDb252ZW5pZW5jZSBzbG90IHRoYXQgbG9hZHMgdGhlIG5l eHQgZG9jdW1lbnQgaW4gdGhlIGxpc3Qgb2YgZG9jdW1lbnRzCisgICAgYnVpbHQgYnkgbmF2aWdh dGluZyBsaW5rcy4gRG9lcyBub3RoaW5nIGlmIHRoZXJlIGlzIG5vIG5leHQgZG9jdW1lbnQuCisK KyAgICBcc2EgYmFjaygpLCBwYWdlQWN0aW9uKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06 OmZvcndhcmQoKQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT50cmlnZ2Vy QWN0aW9uKFFXZWJQYWdlOjpGb3J3YXJkKTsKK30KKworLyohCisgICAgUmVsb2FkcyB0aGUgY3Vy cmVudCBkb2N1bWVudC4KKworICAgIFxzYSBzdG9wKCksIHBhZ2VBY3Rpb24oKSwgbG9hZFN0YXJ0 ZWQoKQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6cmVsb2FkKCkKK3sKKyAgICBpZiAoZC0+ cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+dHJpZ2dlckFjdGlvbihRV2ViUGFnZTo6UmVsb2FkKTsK K30KKworLyohCisgICAgXHByb3BlcnR5IFFXZWJHcmFwaGljc0l0ZW06OnByb2dyZXNzCisgICAg XGJyaWVmIHRoZSBwcm9ncmVzcyBvZiBsb2FkaW5nIHRoZSBjdXJyZW50IFVSTCwgZnJvbSAwIHRv IDEuCisqLworcXJlYWwgUVdlYkdyYXBoaWNzSXRlbTo6cHJvZ3Jlc3MoKSBjb25zdAoreworICAg IHJldHVybiBkLT5wcm9ncmVzczsKK30KKworLyohCisgICAgTG9hZHMgdGhlIHNwZWNpZmllZCBc YSB1cmwgYW5kIGRpc3BsYXlzIGl0LgorCisgICAgXG5vdGUgVGhlIHZpZXcgcmVtYWlucyB0aGUg c2FtZSB1bnRpbCBlbm91Z2ggZGF0YSBoYXMgYXJyaXZlZCB0byBkaXNwbGF5IHRoZSBuZXcgXGEg dXJsLgorCisgICAgXHNhIHNldFVybCgpLCB1cmwoKSwgdXJsQ2hhbmdlZCgpCisqLwordm9pZCBR V2ViR3JhcGhpY3NJdGVtOjpsb2FkKGNvbnN0IFFVcmwmIHVybCkKK3sKKyAgICBwYWdlKCktPm1h aW5GcmFtZSgpLT5sb2FkKHVybCk7Cit9CisKKy8qIQorICAgIFxmbiB2b2lkIFFXZWJHcmFwaGlj c0l0ZW06OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0ICZyZXF1ZXN0LCBRTmV0d29ya0FjY2Vz c01hbmFnZXI6Ok9wZXJhdGlvbiBvcGVyYXRpb24sIGNvbnN0IFFCeXRlQXJyYXkgJmJvZHkpCisK KyAgICBMb2FkcyBhIG5ldHdvcmsgcmVxdWVzdCwgXGEgcmVxdWVzdCwgdXNpbmcgdGhlIG1ldGhv ZCBzcGVjaWZpZWQgaW4gXGEgb3BlcmF0aW9uLgorCisgICAgXGEgYm9keSBpcyBvcHRpb25hbCBh bmQgaXMgb25seSB1c2VkIGZvciBQT1NUIG9wZXJhdGlvbnMuCisKKyAgICBcbm90ZSBUaGUgdmll dyByZW1haW5zIHRoZSBzYW1lIHVudGlsIGVub3VnaCBkYXRhIGhhcyBhcnJpdmVkIHRvIGRpc3Bs YXkgdGhlIG5ldyB1cmwuCisKKyAgICBcc2EgdXJsKCksIHVybENoYW5nZWQoKQorKi8KKwordm9p ZCBRV2ViR3JhcGhpY3NJdGVtOjpsb2FkKGNvbnN0IFFOZXR3b3JrUmVxdWVzdCYgcmVxdWVzdCwK KyAgICAgICAgICAgICAgICAgICAgUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyOjpPcGVyYXRpb24gb3Bl cmF0aW9uLAorICAgICAgICAgICAgICAgICAgICBjb25zdCBRQnl0ZUFycmF5JiBib2R5KQorewor ICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPmxvYWQocmVxdWVzdCwgb3BlcmF0aW9uLCBib2R5KTsK K30KKworLyohCisgICAgU2V0cyB0aGUgY29udGVudCBvZiB0aGUgd2ViIHZpZXcgdG8gdGhlIHNw ZWNpZmllZCBcYSBodG1sLgorCisgICAgRXh0ZXJuYWwgb2JqZWN0cyBzdWNoIGFzIHN0eWxlc2hl ZXRzIG9yIGltYWdlcyByZWZlcmVuY2VkIGluIHRoZSBIVE1MCisgICAgZG9jdW1lbnQgYXJlIGxv Y2F0ZWQgcmVsYXRpdmUgdG8gXGEgYmFzZVVybC4KKworICAgIFRoZSBcYSBodG1sIGlzIGxvYWRl ZCBpbW1lZGlhdGVseTsgZXh0ZXJuYWwgb2JqZWN0cyBhcmUgbG9hZGVkIGFzeW5jaHJvbm91c2x5 LgorCisgICAgV2hlbiB1c2luZyB0aGlzIG1ldGhvZCwgV2ViS2l0IGFzc3VtZXMgdGhhdCBleHRl cm5hbCByZXNvdXJjZXMgc3VjaCBhcworICAgIEphdmFTY3JpcHQgcHJvZ3JhbXMgb3Igc3R5bGUg c2hlZXRzIGFyZSBlbmNvZGVkIGluIFVURi04IHVubGVzcyBvdGhlcndpc2UKKyAgICBzcGVjaWZp ZWQuIEZvciBleGFtcGxlLCB0aGUgZW5jb2Rpbmcgb2YgYW4gZXh0ZXJuYWwgc2NyaXB0IGNhbiBi ZSBzcGVjaWZpZWQKKyAgICB0aHJvdWdoIHRoZSBjaGFyc2V0IGF0dHJpYnV0ZSBvZiB0aGUgSFRN TCBzY3JpcHQgdGFnLiBBbHRlcm5hdGl2ZWx5LCB0aGUKKyAgICBlbmNvZGluZyBjYW4gYWxzbyBi ZSBzcGVjaWZpZWQgYnkgdGhlIHdlYiBzZXJ2ZXIuCisKKyAgICBcc2EgbG9hZCgpLCBzZXRDb250 ZW50KCksIFFXZWJGcmFtZTo6dG9IdG1sKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnNl dEh0bWwoY29uc3QgUVN0cmluZyYgaHRtbCwgY29uc3QgUVVybCYgYmFzZVVybCkKK3sKKyAgICBw YWdlKCktPm1haW5GcmFtZSgpLT5zZXRIdG1sKGh0bWwsIGJhc2VVcmwpOworfQorCitRU3RyaW5n IFFXZWJHcmFwaGljc0l0ZW06OnRvSHRtbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIHBhZ2UoKS0+ bWFpbkZyYW1lKCktPnRvSHRtbCgpOworfQorCisvKiEKKyAgICBTZXRzIHRoZSBjb250ZW50IG9m IHRoZSB3ZWIgdmlldyB0byB0aGUgc3BlY2lmaWVkIGNvbnRlbnQgXGEgZGF0YS4gSWYgdGhlIFxh IG1pbWVUeXBlIGFyZ3VtZW50CisgICAgaXMgZW1wdHkgaXQgaXMgY3VycmVudGx5IGFzc3VtZWQg dGhhdCB0aGUgY29udGVudCBpcyBIVE1MIGJ1dCBpbiBmdXR1cmUgdmVyc2lvbnMgd2UgbWF5IGlu dHJvZHVjZQorICAgIGF1dG8tZGV0ZWN0aW9uLgorCisgICAgRXh0ZXJuYWwgb2JqZWN0cyByZWZl cmVuY2VkIGluIHRoZSBjb250ZW50IGFyZSBsb2NhdGVkIHJlbGF0aXZlIHRvIFxhIGJhc2VVcmwu CisKKyAgICBUaGUgXGEgZGF0YSBpcyBsb2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVj dHMgYXJlIGxvYWRlZCBhc3luY2hyb25vdXNseS4KKworICAgIFxzYSBsb2FkKCksIHNldEh0bWwo KSwgUVdlYkZyYW1lOjp0b0h0bWwoKQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0Q29u dGVudChjb25zdCBRQnl0ZUFycmF5JiBkYXRhLCBjb25zdCBRU3RyaW5nJiBtaW1lVHlwZSwgY29u c3QgUVVybCYgYmFzZVVybCkKK3sKKyAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5zZXRDb250ZW50 KGRhdGEsIG1pbWVUeXBlLCBiYXNlVXJsKTsKK30KKworLyohCisgICAgUmV0dXJucyBhIHBvaW50 ZXIgdG8gdGhlIHZpZXcncyBoaXN0b3J5IG9mIG5hdmlnYXRlZCB3ZWIgcGFnZXMuCisKKyAgICBJ dCBpcyBlcXVpdmFsZW50IHRvCisKKyAgICBcc25pcHBldCB3ZWJraXRzbmlwcGV0cy9xdHdlYmtp dF9xd2Vidmlld19zbmlwcGV0LmNwcCAwCisqLworUVdlYkhpc3RvcnkqIFFXZWJHcmFwaGljc0l0 ZW06Omhpc3RvcnkoKSBjb25zdAoreworICAgIHJldHVybiBwYWdlKCktPmhpc3RvcnkoKTsKK30K KworLyohCisgIFxwcm9wZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjppbnRlcmFjdGl2ZQorICBcYnJp ZWYgY29udHJvbHMgd2hldGhlciB0aGUgaXRlbSByZXNwb25kcyB0byBtb3VzZSBhbmQga2V5IGV2 ZW50cy4KKyovCisKK2Jvb2wgUVdlYkdyYXBoaWNzSXRlbTo6aW50ZXJhY3RpdmUoKSBjb25zdAor eworICAgIHJldHVybiBkLT5pbnRlcmFjdGl2ZTsKK30KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVt OjpzZXRJbnRlcmFjdGl2ZShib29sIGFsbG93ZWQpCit7CisgICAgaWYgKGQtPmludGVyYWN0aXZl ID09IGFsbG93ZWQpCisgICAgICAgIHJldHVybjsKKworICAgIGQtPmludGVyYWN0aXZlID0gYWxs b3dlZDsKKyAgICBlbWl0IGludGVyYWN0aXZlQ2hhbmdlZCgpOworfQorCisvKiEKKyAgICBSZXR1 cm5zIGEgcG9pbnRlciB0byB0aGUgdmlldy9wYWdlIHNwZWNpZmljIHNldHRpbmdzIG9iamVjdC4K KworICAgIEl0IGlzIGVxdWl2YWxlbnQgdG8KKworICAgIFxzbmlwcGV0IHdlYmtpdHNuaXBwZXRz L3F0d2Via2l0X3F3ZWJ2aWV3X3NuaXBwZXQuY3BwIDEKKworICAgIFxzYSBRV2ViU2V0dGluZ3M6 Omdsb2JhbFNldHRpbmdzKCkKKyovCitRV2ViU2V0dGluZ3MqIFFXZWJHcmFwaGljc0l0ZW06OnNl dHRpbmdzKCkgY29uc3QKK3sKKyAgICByZXR1cm4gcGFnZSgpLT5zZXR0aW5ncygpOworfQorCit2 b2lkIFFXZWJHcmFwaGljc0l0ZW06OmhvdmVyTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJF dmVudCogZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAg ICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIFFNb3Vz ZUV2ZW50IG1lID0gUU1vdXNlRXZlbnQoUUV2ZW50OjpNb3VzZU1vdmUsCisgICAgICAgICAgICAg ICAgZXYtPnBvcygpLnRvUG9pbnQoKSwgUXQ6Ok5vQnV0dG9uLAorICAgICAgICAgICAgICAgIFF0 OjpOb0J1dHRvbiwgUXQ6Ok5vTW9kaWZpZXIpOworICAgICAgICBkLT5wYWdlLT5zZXRWaWV3KGV2 LT53aWRnZXQoKSk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KCZtZSk7CisgICAgICAgIGV2LT5z ZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgp KQorICAgICAgICBRR3JhcGhpY3NJdGVtOjpob3Zlck1vdmVFdmVudChldik7Cit9CisKK3ZvaWQg UVdlYkdyYXBoaWNzSXRlbTo6aG92ZXJMZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJFdmVu dCogZXYpCit7CisgICAgUV9VTlVTRUQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBR V2ViR3JhcGhpY3NJdGVtOjptb3VzZU1vdmVFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQq IGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNv bnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5l dmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisg ICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZU1v dmVFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06 Om1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAgIGlm IChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0 ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAg ICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNB Y2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZVByZXNzRXZlbnQoZXYpOwor fQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjptb3VzZVJlbGVhc2VF dmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFj dGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNB Y2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRB Y2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQor ICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZVJlbGVhc2VFdmVudChldik7Cit9CisKKy8qISBc cmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06Om1vdXNlRG91YmxlQ2xpY2tFdmVudChR R3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAm JiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRl ZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRl ZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAg ICBRR3JhcGhpY3NJdGVtOjptb3VzZURvdWJsZUNsaWNrRXZlbnQoZXYpOworfQorCit2b2lkIFFX ZWJHcmFwaGljc0l0ZW06OmtleVByZXNzRXZlbnQoUUtleUV2ZW50KiBldikKK3sKKyAgICBpZiAo ZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOwor CisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjprZXlQ cmVzc0V2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRl bTo6a2V5UmVsZWFzZUV2ZW50KFFLZXlFdmVudCogZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0 aXZlICYmIGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKworICAgIGlmICgh ZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6a2V5UmVsZWFzZUV2ZW50 KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6Zm9jdXNJ bkV2ZW50KFFGb2N1c0V2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+cGFnZSkKKyAgICAgICAgZC0+ cGFnZS0+ZXZlbnQoZXYpOworICAgIGVsc2UKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6Zm9jdXNJ bkV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6 Zm9jdXNPdXRFdmVudChRRm9jdXNFdmVudCogZXYpCit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAg ICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICBlbHNlCisgICAgICAgIFFHcmFwaGljc0l0ZW06 OmZvY3VzT3V0RXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLworYm9vbCBRV2ViR3JhcGhp Y3NJdGVtOjpmb2N1c05leHRQcmV2Q2hpbGQoYm9vbCBuZXh0KQoreworICAgIGlmIChkLT5wYWdl KQorICAgICAgICByZXR1cm4gZC0+cGFnZS0+Zm9jdXNOZXh0UHJldkNoaWxkKG5leHQpOworCisg ICAgcmV0dXJuIFFHcmFwaGljc1dpZGdldDo6Zm9jdXNOZXh0UHJldkNoaWxkKG5leHQpOworfQor CisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpkcmFnRW50ZXJFdmVudChR R3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5E RFJPUAorICAgIC8vaWYgKGQtPnBhZ2UpCisgICAgLy8gICAgZC0+cGFnZS0+ZXZlbnQoZXYpOwor ICAgIC8vSnVzdCByZW1vdmUgdGhpcyBsaW5lIGJlbG93IHdoZW4gdGhlIGNvZGUgYWJvdmUgaXMg d29ya2luZworICAgIFFfVU5VU0VEKGV2KTsKKyNlbHNlCisgICAgUV9VTlVTRUQoZXYpOworI2Vu ZGlmCit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmRyYWdMZWF2 ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCogZXYpCit7CisjaWZuZGVmIFFUX05P X0RSQUdBTkREUk9QCisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAg ICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBh Z2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9 CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc1dpZGdldDo6 ZHJhZ0xlYXZlRXZlbnQoZXYpOworI2Vsc2UKKyAgICBRX1VOVVNFRChldik7CisjZW5kaWYKK30K KworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6ZHJhZ01vdmVFdmVudChR R3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5E RFJPUAorICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0 IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVu dChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAg aWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NXaWRnZXQ6OmRyYWdNb3Zl RXZlbnQoZXYpOworI2Vsc2UKKyAgICBRX1VOVVNFRChldik7CisjZW5kaWYKK30KKworLyohIFxy ZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6ZHJvcEV2ZW50KFFHcmFwaGljc1NjZW5l RHJhZ0Ryb3BFdmVudCogZXYpCit7CisjaWZuZGVmIFFUX05PX0RSQUdBTkREUk9QCisgICAgaWYg KGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRl ZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAg ICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0Fj Y2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc1dpZGdldDo6ZHJvcEV2ZW50KGV2KTsKKyNlbHNl CisgICAgUV9VTlVTRUQoZXYpOworI2VuZGlmCit9CisKKyNpZm5kZWYgUVRfTk9fQ09OVEVYVE1F TlUKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmNvbnRleHRNZW51RXZl bnQoUUNvbnRleHRNZW51RXZlbnQqIGV2KQoreworICAgIGlmIChkLT5wYWdlKSB7CisgICAgICAg IGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdl LT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQor fQorI2VuZGlmIC8vIFFUX05PX0NPTlRFWFRNRU5VCisKKyNpZm5kZWYgUVRfTk9fV0hFRUxFVkVO VAorLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6d2hlZWxFdmVudChRR3Jh cGhpY3NTY2VuZVdoZWVsRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBk LT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgp OworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChh Y2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBR R3JhcGhpY3NJdGVtOjp3aGVlbEV2ZW50KGV2KTsKK30KKyNlbmRpZiAvLyBRVF9OT19XSEVFTEVW RU5UCisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmlucHV0TWV0aG9k RXZlbnQoUUlucHV0TWV0aG9kRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAm JiBkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisKKyAgICBpZiAoIWV2LT5p c0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0ZW06OmlucHV0TWV0aG9kRXZlbnQoZXYp OworfQorCisjaW5jbHVkZSAibW9jX3F3ZWJncmFwaGljc2l0ZW0uY3BwIgpkaWZmIC0tZ2l0IGEv V2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJncmFw aGljc2l0ZW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MGJlMWZjCi0t LSAvZGV2L251bGwKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmgKQEAgLTAs MCArMSwxNDggQEAKKy8qCisgICAgQ29weXJpZ2h0IChDKSAyMDA5IE5va2lhIENvcnBvcmF0aW9u IGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorCisgICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICAgIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgICAgTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgICAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorCisgICAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAgICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICAg IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICAg WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICAgIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZp bGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgICAgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAgICBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyovCisKKyNpZm5kZWYgUVdlYkdyYXBoaWNzSXRl bV9oCisjZGVmaW5lIFFXZWJHcmFwaGljc0l0ZW1faAorCisjaW5jbHVkZSAicXdlYmtpdGdsb2Jh bC5oIgorI2luY2x1ZGUgPFF0L3FldmVudC5oPgorI2luY2x1ZGUgPFF0Q29yZS9xdXJsLmg+Cisj aW5jbHVkZSA8UXRHdWkvcWdyYXBoaWNzd2lkZ2V0Lmg+CisjaW5jbHVkZSA8UXRHdWkvcWljb24u aD4KKyNpbmNsdWRlIDxRdEd1aS9xcGFpbnRlci5oPgorI2luY2x1ZGUgPFF0TmV0d29yay9xbmV0 d29ya2FjY2Vzc21hbmFnZXIuaD4KKworY2xhc3MgUVdlYlBhZ2U7CitjbGFzcyBRV2ViSGlzdG9y eTsKK2NsYXNzIFFXZWJTZXR0aW5nczsKKworY2xhc3MgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU7 CisKK2NsYXNzIFFXRUJLSVRfRVhQT1JUIFFXZWJHcmFwaGljc0l0ZW0gOiBwdWJsaWMgUUdyYXBo aWNzV2lkZ2V0IHsKKyAgICBRX09CSkVDVAorCisgICAgUV9QUk9QRVJUWShRU3RyaW5nIHRpdGxl IFJFQUQgdGl0bGUgTk9USUZZIHRpdGxlQ2hhbmdlZCkKKyAgICBRX1BST1BFUlRZKFFJY29uIGlj b24gUkVBRCBpY29uIE5PVElGWSBpY29uQ2hhbmdlZCkKKyAgICBRX1BST1BFUlRZKHFyZWFsIHRl eHRTaXplTXVsdGlwbGllciBSRUFEIHRleHRTaXplTXVsdGlwbGllciBXUklURSBzZXRUZXh0U2l6 ZU11bHRpcGxpZXIgREVTSUdOQUJMRSBmYWxzZSkKKyAgICBRX1BST1BFUlRZKHFyZWFsIHpvb21G YWN0b3IgUkVBRCB6b29tRmFjdG9yIFdSSVRFIHNldFpvb21GYWN0b3IgTk9USUZZIHpvb21GYWN0 b3JDaGFuZ2VkKQorICAgIFFfUFJPUEVSVFkoUVN0cmluZyBzdGF0dXMgUkVBRCBzdGF0dXMgTk9U SUZZIHN0YXR1c0NoYW5nZWQpCisKKyAgICBRX1BST1BFUlRZKFFTdHJpbmcgaHRtbCBSRUFEIHRv SHRtbCBXUklURSBzZXRIdG1sKQorICAgIFFfUFJPUEVSVFkoUVVybCB1cmwgUkVBRCB1cmwgV1JJ VEUgc2V0VXJsIE5PVElGWSB1cmxDaGFuZ2VkKQorICAgIFFfUFJPUEVSVFkocXJlYWwgcHJvZ3Jl c3MgUkVBRCBwcm9ncmVzcyBOT1RJRlkgcHJvZ3Jlc3NDaGFuZ2VkKQorCisgICAgUV9QUk9QRVJU WShib29sIGludGVyYWN0aXZlIFJFQUQgaW50ZXJhY3RpdmUgV1JJVEUgc2V0SW50ZXJhY3RpdmUg Tk9USUZZIGludGVyYWN0aXZlQ2hhbmdlZCkKKworcHVibGljOgorICAgIFFXZWJHcmFwaGljc0l0 ZW0oUUdyYXBoaWNzSXRlbSogcGFyZW50ID0gMCk7CisgICAgflFXZWJHcmFwaGljc0l0ZW0oKTsK KworICAgIFFXZWJQYWdlKiBwYWdlKCkgY29uc3Q7CisgICAgdm9pZCBzZXRQYWdlKFFXZWJQYWdl Kik7CisKKyAgICBRVXJsIHVybCgpIGNvbnN0OworICAgIHZvaWQgc2V0VXJsKGNvbnN0IFFVcmwm KTsKKworICAgIFFTdHJpbmcgdGl0bGUoKSBjb25zdDsKKyAgICBRSWNvbiBpY29uKCkgY29uc3Q7 CisKKyAgICBxcmVhbCB0ZXh0U2l6ZU11bHRpcGxpZXIoKSBjb25zdDsKKyAgICB2b2lkIHNldFRl eHRTaXplTXVsdGlwbGllcihxcmVhbCk7CisKKyAgICBxcmVhbCB6b29tRmFjdG9yKCkgY29uc3Q7 CisgICAgdm9pZCBzZXRab29tRmFjdG9yKHFyZWFsKTsKKworICAgIGJvb2wgaW50ZXJhY3RpdmUo KSBjb25zdDsKKyAgICB2b2lkIHNldEludGVyYWN0aXZlKGJvb2wpOworCisgICAgcXJlYWwgcHJv Z3Jlc3MoKSBjb25zdDsKKworICAgIHZvaWQgbG9hZChjb25zdCBRVXJsICZ1cmwpOworICAgIHZv aWQgbG9hZChjb25zdCBRTmV0d29ya1JlcXVlc3QmIHJlcXVlc3QsIFFOZXR3b3JrQWNjZXNzTWFu YWdlcjo6T3BlcmF0aW9uIG9wZXJhdGlvbiA9IFFOZXR3b3JrQWNjZXNzTWFuYWdlcjo6R2V0T3Bl cmF0aW9uLCBjb25zdCBRQnl0ZUFycmF5JiBib2R5ID0gUUJ5dGVBcnJheSgpKTsKKworICAgIFFT dHJpbmcgdG9IdG1sKCkgY29uc3Q7CisgICAgdm9pZCBzZXRIdG1sKGNvbnN0IFFTdHJpbmcmIGh0 bWwsIGNvbnN0IFFVcmwmIGJhc2VVcmwgPSBRVXJsKCkpOworICAgIC8vIEZJWE1FOiBDb25zaWRl ciByZW5hbWUgdG8gc2V0SHRtbD8KKyAgICB2b2lkIHNldENvbnRlbnQoY29uc3QgUUJ5dGVBcnJh eSYgZGF0YSwgY29uc3QgUVN0cmluZyYgbWltZVR5cGUgPSBRU3RyaW5nKCksIGNvbnN0IFFVcmwm IGJhc2VVcmwgPSBRVXJsKCkpOworCisgICAgUVdlYkhpc3RvcnkqIGhpc3RvcnkoKSBjb25zdDsK KyAgICBRV2ViU2V0dGluZ3MqIHNldHRpbmdzKCkgY29uc3Q7CisKKyAgICBRU3RyaW5nIHN0YXR1 cygpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHNldEdlb21ldHJ5KGNvbnN0IFFSZWN0RiYg cmVjdCk7CisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZUdlb21ldHJ5KCk7CisgICAgdm9pZCBwYWlu dChRUGFpbnRlciosIGNvbnN0IFFTdHlsZU9wdGlvbkdyYXBoaWNzSXRlbSogb3B0aW9ucywgUVdp ZGdldCogd2lkZ2V0ID0gMCk7CisKK3B1YmxpYyBRX1NMT1RTOgorICAgIHZvaWQgc3RvcCgpOwor ICAgIHZvaWQgYmFjaygpOworICAgIHZvaWQgZm9yd2FyZCgpOworICAgIHZvaWQgcmVsb2FkKCk7 CisKK1FfU0lHTkFMUzoKKyAgICB2b2lkIGxvYWRTdGFydGVkKCk7CisgICAgdm9pZCBsb2FkRmlu aXNoZWQoKTsKKyAgICB2b2lkIGxvYWRGYWlsZWQoKTsKKworICAgIHZvaWQgcHJvZ3Jlc3NDaGFu Z2VkKHFyZWFsKTsKKyAgICB2b2lkIGludGVyYWN0aXZlQ2hhbmdlZCgpOworICAgIHZvaWQgdXJs Q2hhbmdlZChjb25zdCBRVXJsJik7CisgICAgdm9pZCB0aXRsZUNoYW5nZWQoY29uc3QgUVN0cmlu ZyYpOworICAgIHZvaWQgaWNvbkNoYW5nZWQoKTsKKyAgICB2b2lkIHN0YXR1c0NoYW5nZWQoKTsK KyAgICB2b2lkIHpvb21GYWN0b3JDaGFuZ2VkKCk7CisgICAgdm9pZCBzdGF0dXNCYXJNZXNzYWdl KGNvbnN0IFFTdHJpbmcmIG1lc3NhZ2UpOworCitwcm90ZWN0ZWQ6CisgICAgdmlydHVhbCB2b2lk IG1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFs IHZvaWQgbW91c2VEb3VibGVDbGlja0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCopOwor ICAgIHZpcnR1YWwgdm9pZCBtb3VzZVJlbGVhc2VFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZl bnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgbW91c2VNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3Vz ZUV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGhvdmVyTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5l SG92ZXJFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBob3ZlckxlYXZlRXZlbnQoUUdyYXBoaWNz U2NlbmVIb3ZlckV2ZW50Kik7CisjaWZuZGVmIFFUX05PX1dIRUVMRVZFTlQKKyAgICB2aXJ0dWFs IHZvaWQgd2hlZWxFdmVudChRR3JhcGhpY3NTY2VuZVdoZWVsRXZlbnQqKTsKKyNlbmRpZgorICAg IHZpcnR1YWwgdm9pZCBrZXlQcmVzc0V2ZW50KFFLZXlFdmVudCopOworICAgIHZpcnR1YWwgdm9p ZCBrZXlSZWxlYXNlRXZlbnQoUUtleUV2ZW50Kik7CisjaWZuZGVmIFFUX05PX0NPTlRFWFRNRU5V CisgICAgdmlydHVhbCB2b2lkIGNvbnRleHRNZW51RXZlbnQoUUNvbnRleHRNZW51RXZlbnQqKTsK KyNlbmRpZgorICAgIHZpcnR1YWwgdm9pZCBkcmFnRW50ZXJFdmVudChRR3JhcGhpY3NTY2VuZURy YWdEcm9wRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgZHJhZ0xlYXZlRXZlbnQoUUdyYXBoaWNz U2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyYWdNb3ZlRXZlbnQoUUdy YXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyb3BFdmVudChR R3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgZm9jdXNJbkV2 ZW50KFFGb2N1c0V2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGZvY3VzT3V0RXZlbnQoUUZvY3Vz RXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgaW5wdXRNZXRob2RFdmVudChRSW5wdXRNZXRob2RF dmVudCopOworICAgIHZpcnR1YWwgYm9vbCBmb2N1c05leHRQcmV2Q2hpbGQoYm9vbCBuZXh0KTsK KworcHJpdmF0ZToKKyAgICBRX1BSSVZBVEVfU0xPVChkLCB2b2lkIF9xX2RvU2Nyb2xsKGludCBk eCwgaW50IGR5LCBjb25zdCBRUmVjdCYpKQorICAgIFFfUFJJVkFURV9TTE9UKGQsIHZvaWQgX3Ff ZG9Mb2FkUHJvZ3Jlc3MoaW50IHByb2dyZXNzKSkKKyAgICBRX1BSSVZBVEVfU0xPVChkLCB2b2lk IF9xX2RvTG9hZEZpbmlzaGVkKGJvb2wgc3VjY2VzcykpCisgICAgUV9QUklWQVRFX1NMT1QoZCwg dm9pZCBfcV9kb1VwZGF0ZShjb25zdCBRUmVjdCYgZGlydHlSZWN0KSkKKyAgICBRX1BSSVZBVEVf U0xPVChkLCB2b2lkIF9xX3NldFN0YXR1c0Jhck1lc3NhZ2UoY29uc3QgUVN0cmluZyYgbWVzc2Fn ZSkpCisKKyAgICBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSogY29uc3QgZDsKKyAgICBmcmllbmQg Y2xhc3MgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU7Cit9OworCisjZW5kaWYgLy8gUVdlYkdyYXBo aWNzSXRlbV9oCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW1fcC5o IGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi45OTJkNDJmCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L3F0L0Fw aS9xd2ViZ3JhcGhpY3NpdGVtX3AuaApAQCAtMCwwICsxLDQzIEBACisvKgorICAgIENvcHlyaWdo dCAoQykgMjAwOSBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykK KworICAgIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAgIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgICBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisq LworCitjbGFzcyBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSB7CitwdWJsaWM6CisgICAgUVdlYkdy YXBoaWNzSXRlbVByaXZhdGUoUVdlYkdyYXBoaWNzSXRlbSogcGFyZW50KQorICAgICAgICA6IHEo cGFyZW50KQorICAgICAgICAsIHBhZ2UoMCkKKyAgICAgICAgLCBpbnRlcmFjdGl2ZSh0cnVlKQor ICAgICAgICAsIHByb2dyZXNzKDEuMCkKKyAgICB7fQorCisgICAgdm9pZCBfcV9kb1Njcm9sbChp bnQgZHgsIGludCBkeSwgY29uc3QgUVJlY3QmKTsKKyAgICB2b2lkIF9xX2RvTG9hZFByb2dyZXNz KGludCBwcm9ncmVzcyk7CisgICAgdm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3Mp OworICAgIHZvaWQgX3FfZG9VcGRhdGUoY29uc3QgUVJlY3QmIGRpcnR5UmVjdCk7CisgICAgdm9p ZCBfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFTdHJpbmcmIG1lc3NhZ2UpOworCisgICAg UVdlYkdyYXBoaWNzSXRlbSogcTsKKyAgICBRV2ViUGFnZSogcGFnZTsKKworICAgIFFTdHJpbmcg c3RhdHVzQmFyTWVzc2FnZTsKKyAgICBib29sIGludGVyYWN0aXZlOworICAgIHFyZWFsIHByb2dy ZXNzOworfTsKKworCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmggYi9XZWJL aXQvcXQvQXBpL3F3ZWJwYWdlLmgKaW5kZXggMjQ3NDFhMS4uMTBjNzkzOCAxMDA2NDQKLS0tIGEv V2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaApA QCAtMzUxLDYgKzM1MSw3IEBAIHByaXZhdGU6CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJGcmFtZTsK ICAgICBmcmllbmQgY2xhc3MgUVdlYlBhZ2VQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2Vi VmlldzsKKyAgICBmcmllbmQgY2xhc3MgUVdlYkdyYXBoaWNzSXRlbTsKICAgICBmcmllbmQgY2xh c3MgV2ViQ29yZTo6Q2hyb21lQ2xpZW50UXQ7CiAgICAgZnJpZW5kIGNsYXNzIFdlYkNvcmU6OkVk aXRvckNsaWVudFF0OwogICAgIGZyaWVuZCBjbGFzcyBXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVu dFF0OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VM b2cKaW5kZXggMWVhZjNiNy4uYjlkNTI4OCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTAxIEBACisyMDA5LTA5LTA0 ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4sIEFudG9u aW8gR29tZXMgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgbmV3IFFHcmFwaGljc1dpZGdl dCBiYXNlZCB2ZXJzaW9uIG9mIHRoZSAiUVdlYlZpZXciCisgICAgICAgIHVuZGVyIHRoZSBuYW1l ICJRV2ViR3JhcGhpY3NJdGVtIi4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKKworICAgICAgICBJbmNsdWRlcyBhbiBhbHRlcm5hdGl2ZSBR dCBsYXVuY2hlciB1c2luZyB0aGUgUUdyYXBoaWNzVmlldy4KKworICAgICAgICAqIEFwaS9oZWFk ZXJzLnByaToKKyAgICAgICAgKiBBcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHA6IEFkZGVkLgorICAg ICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6UVdlYkdyYXBoaWNzSXRlbSk6CisgICAgICAgIChRV2Vi R3JhcGhpY3NJdGVtOjp+UVdlYkdyYXBoaWNzSXRlbSk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJ dGVtOjpwYWdlKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb0xvYWRQ cm9ncmVzcyk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9Mb2FkRmlu aXNoZWQpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9xX2RvU2Nyb2xsKToK KyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb1VwZGF0ZSk6CisgICAgICAg IChRV2ViR3JhcGhpY3NJdGVtOjpwYWludCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpz ZXRQYWdlKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OnNldFVybCk6CisgICAgICAgIChR V2ViR3JhcGhpY3NJdGVtOjp1cmwpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6dGl0bGUp OgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6aWNvbik6CisgICAgICAgIChRV2ViR3JhcGhp Y3NJdGVtOjpzZXRUZXh0U2l6ZU11bHRpcGxpZXIpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRl bTo6dGV4dFNpemVNdWx0aXBsaWVyKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OnNldFpv b21GYWN0b3IpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6em9vbUZhY3Rvcik6CisgICAg ICAgIChRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3Ffc2V0U3RhdHVzQmFyTWVzc2FnZSk6Cisg ICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjp1cGRhdGVHZW9tZXRyeSk6CisgICAgICAgIChRV2Vi R3JhcGhpY3NJdGVtOjpzZXRHZW9tZXRyeSk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpz dGF0dXMpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6c3RvcCk6CisgICAgICAgIChRV2Vi R3JhcGhpY3NJdGVtOjpiYWNrKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmZvcndhcmQp OgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6cmVsb2FkKToKKyAgICAgICAgKFFXZWJHcmFw aGljc0l0ZW06OnByb2dyZXNzKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmxvYWQpOgor ICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6c2V0SHRtbCk6CisgICAgICAgIChRV2ViR3JhcGhp Y3NJdGVtOjp0b0h0bWwpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6c2V0Q29udGVudCk6 CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpoaXN0b3J5KToKKyAgICAgICAgKFFXZWJHcmFw aGljc0l0ZW06OmludGVyYWN0aXZlKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OnNldElu dGVyYWN0aXZlKToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OnNldHRpbmdzKToKKyAgICAg ICAgKFFXZWJHcmFwaGljc0l0ZW06OmhvdmVyTW92ZUV2ZW50KToKKyAgICAgICAgKFFXZWJHcmFw aGljc0l0ZW06OmhvdmVyTGVhdmVFdmVudCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpt b3VzZU1vdmVFdmVudCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjptb3VzZVByZXNzRXZl bnQpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6bW91c2VSZWxlYXNlRXZlbnQpOgorICAg ICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6bW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAgICAgICAg KFFXZWJHcmFwaGljc0l0ZW06OmtleVByZXNzRXZlbnQpOgorICAgICAgICAoUVdlYkdyYXBoaWNz SXRlbTo6a2V5UmVsZWFzZUV2ZW50KToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmZvY3Vz SW5FdmVudCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpmb2N1c091dEV2ZW50KToKKyAg ICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmZvY3VzTmV4dFByZXZDaGlsZCk6CisgICAgICAgIChR V2ViR3JhcGhpY3NJdGVtOjpkcmFnRW50ZXJFdmVudCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJ dGVtOjpkcmFnTGVhdmVFdmVudCk6CisgICAgICAgIChRV2ViR3JhcGhpY3NJdGVtOjpkcmFnTW92 ZUV2ZW50KToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmRyb3BFdmVudCk6CisgICAgICAg IChRV2ViR3JhcGhpY3NJdGVtOjpjb250ZXh0TWVudUV2ZW50KToKKyAgICAgICAgKFFXZWJHcmFw aGljc0l0ZW06OndoZWVsRXZlbnQpOgorICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6aW5wdXRN ZXRob2RFdmVudCk6CisgICAgICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uaDogQWRkZWQuCisg ICAgICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW1fcC5oOiBBZGRlZC4KKyAgICAgICAgKFFXZWJH cmFwaGljc0l0ZW1Qcml2YXRlOjpRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSk6CisgICAgICAgICog QXBpL3F3ZWJwYWdlLmNwcDoKKyAgICAgICAgKGluaXRpYWxpemVBcHBsaWNhdGlvbkNhY2hlUGF0 aElmTmVjZXNzYXJ5KToKKyAgICAgICAgKiBBcGkvcXdlYnBhZ2UuaDoKKyAgICAgICAgKiBRR1ZM YXVuY2hlci9RR1ZMYXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdlYktpdC9xdC9RdExhdW5jaGVy L1F0TGF1bmNoZXIucHJvLgorICAgICAgICAqIFFHVkxhdW5jaGVyL21haW4uY3BwOiBBZGRlZC4K KyAgICAgICAgKFdlYlBhZ2U6OldlYlBhZ2UpOgorICAgICAgICAoTWFpblZpZXc6Ok1haW5WaWV3 KToKKyAgICAgICAgKE1haW5WaWV3OjpzZXRNYWluV2lkZ2V0KToKKyAgICAgICAgKE1haW5WaWV3 OjpyZXNpemVFdmVudCk6CisgICAgICAgIChTaGFyZWRTY2VuZTo6U2hhcmVkU2NlbmUpOgorICAg ICAgICAoU2hhcmVkU2NlbmU6On5TaGFyZWRTY2VuZSk6CisgICAgICAgIChTaGFyZWRTY2VuZTo6 c2NlbmUpOgorICAgICAgICAoU2hhcmVkU2NlbmU6OndlYkl0ZW0pOgorICAgICAgICAoTWFpbldp bmRvdzo6TWFpbldpbmRvdyk6CisgICAgICAgIChNYWluV2luZG93Ojppbml0KToKKyAgICAgICAg KE1haW5XaW5kb3c6OmxvYWQpOgorICAgICAgICAoTWFpbldpbmRvdzo6Z3Vlc3NVcmxGcm9tU3Ry aW5nKToKKyAgICAgICAgKE1haW5XaW5kb3c6OnBhZ2UpOgorICAgICAgICAoTWFpbldpbmRvdzo6 Y2hhbmdlTG9jYXRpb24pOgorICAgICAgICAoTWFpbldpbmRvdzo6bG9hZEZpbmlzaGVkKToKKyAg ICAgICAgKE1haW5XaW5kb3c6Om5ld1dpbmRvdyk6CisgICAgICAgIChNYWluV2luZG93OjpjbG9u ZSk6CisgICAgICAgIChNYWluV2luZG93OjpidWlsZFVJKToKKyAgICAgICAgKFdlYlBhZ2U6OmNy ZWF0ZVdpbmRvdyk6CisgICAgICAgIChXZWJQYWdlOjphcHBseVByb3h5KToKKyAgICAgICAgKG1h aW4pOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkNocm9tZUNsaWVudFF0OjpyZXBhaW50KToKKyAgICAgICAgKFdlYkNvcmU6 OkNocm9tZUNsaWVudFF0OjpzY3JvbGwpOgorCiAyMDA5LTA5LTA0ICBNYXJrIE1lbnRvdmFpICA8 bWFya0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4KZGlm ZiAtLWdpdCBhL1dlYktpdC9xdC9RR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm8gYi9XZWJLaXQv cXQvUUdWTGF1bmNoZXIvUUdWTGF1bmNoZXIucHJvCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLmI4ODNiNTIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvcXQvUUdWTGF1bmNo ZXIvUUdWTGF1bmNoZXIucHJvCkBAIC0wLDAgKzEsMTMgQEAKK1RFTVBMQVRFID0gYXBwCitTT1VS Q0VTICs9IG1haW4uY3BwCitDT05GSUcgLT0gYXBwX2J1bmRsZQorQ09ORklHICs9IHVpdG9vbHMK K0RFU1RESVIgPSAuLi8uLi8uLi9iaW4KKworaW5jbHVkZSguLi8uLi8uLi9XZWJLaXQucHJpKQor CitRVCArPSBuZXR3b3JrCittYWN4OlFUKz14bWwKK1FNQUtFX1JQQVRIRElSID0gJCRPVVRQVVRf RElSL2xpYiAkJFFNQUtFX1JQQVRIRElSCisKK3N5bWJpYW46VEFSR0VULlVJRDMgPSAweDIwMDI2 N0QwCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAgYi9XZWJLaXQv cXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uZmZjN2FkZQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9xdC9RR1ZMYXVuY2hlci9tYWlu LmNwcApAQCAtMCwwICsxLDMwMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBOb2tpYSBD b3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykg MjAwNiBHZW9yZ2UgU3RhaWtvcyA8c3RhaWtvc0BrZGUub3JnPgorICogQ29weXJpZ2h0IChDKSAy MDA2IERpcmsgTXVlbGxlciA8bXVlbGxlckBrZGUub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA2 IFphY2sgUnVzaW4gPHphY2tAa2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwNiBTaW1vbiBI YXVzbWFubiA8aGF1c21hbm5Aa2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBLZW5uZXRo IENocmlzdGlhbnNlbiA8a2VubmV0aEB3ZWJraXQub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA5 IEFudG9uaW8gR29tZXMgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KKyAqCisgKiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF CisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlIDxxd2VicGFnZS5oPgorI2luY2x1ZGUg PHF3ZWJ2aWV3Lmg+CisjaW5jbHVkZSA8cXdlYmdyYXBoaWNzaXRlbS5oPgorI2luY2x1ZGUgPHF3 ZWJmcmFtZS5oPgorI2luY2x1ZGUgPHF3ZWJzZXR0aW5ncy5oPgorI2luY2x1ZGUgPHF3ZWJlbGVt ZW50Lmg+CisKKyNpbmNsdWRlIDxRTmV0d29ya1JlcXVlc3Q+CisjaW5jbHVkZSA8UUdyYXBoaWNz U2NlbmU+CisjaW5jbHVkZSA8UUdyYXBoaWNzVmlldz4KKyNpbmNsdWRlIDxRR3JhcGhpY3NXaWRn ZXQ+CisKKyNpbmNsdWRlIDxRdEd1aT4KKyNpbmNsdWRlIDxRRGVidWc+CisjaW5jbHVkZSA8UXRO ZXR3b3JrL1FOZXR3b3JrUHJveHk+CisKKyNpbmNsdWRlIDxRVmVjdG9yPgorI2luY2x1ZGUgPFFU ZXh0U3RyZWFtPgorI2luY2x1ZGUgPFFGaWxlPgorI2luY2x1ZGUgPGNzdGRpbz4KKworY2xhc3Mg V2ViUGFnZSA6IHB1YmxpYyBRV2ViUGFnZSB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgorICAg IFdlYlBhZ2UoUVdpZGdldCAqcGFyZW50ID0gMCkgOiBRV2ViUGFnZShwYXJlbnQpCisgICAgewor ICAgICAgICBhcHBseVByb3h5KCk7CisgICAgfQorICAgIHZpcnR1YWwgUVdlYlBhZ2UgKmNyZWF0 ZVdpbmRvdyhRV2ViUGFnZTo6V2ViV2luZG93VHlwZSk7CisKK3ByaXZhdGU6CisgICAgdm9pZCBh cHBseVByb3h5KCk7Cit9OworCitjbGFzcyBNYWluVmlldyA6IHB1YmxpYyBRR3JhcGhpY3NWaWV3 IHsKKyAgICBRX09CSkVDVAorCitwdWJsaWM6CisgICAgTWFpblZpZXcoUVdpZGdldCogcGFyZW50 KSA6IFFHcmFwaGljc1ZpZXcocGFyZW50KSwgbV9tYWluV2lkZ2V0KDApCisgICAgeworICAgICAg ICBzZXRIb3Jpem9udGFsU2Nyb2xsQmFyUG9saWN5KFF0OjpTY3JvbGxCYXJBbHdheXNPZmYpOwor ICAgICAgICBzZXRWZXJ0aWNhbFNjcm9sbEJhclBvbGljeShRdDo6U2Nyb2xsQmFyQWx3YXlzT2Zm KTsKKyAgICB9CisKKyAgICB2b2lkIHNldE1haW5XaWRnZXQoUUdyYXBoaWNzV2lkZ2V0KiB3aWRn ZXQpCisgICAgeworICAgICAgICBRUmVjdEYgcmVjdChRUmVjdChRUG9pbnQoMCwgMCksIHNpemUo KSkpOworICAgICAgICB3aWRnZXQtPnNldEdlb21ldHJ5KHJlY3QpOworICAgICAgICBtX21haW5X aWRnZXQgPSB3aWRnZXQ7CisgICAgfQorCisgICAgdm9pZCByZXNpemVFdmVudChRUmVzaXplRXZl bnQqIGV2ZW50KQorICAgIHsKKyAgICAgICAgUUdyYXBoaWNzVmlldzo6cmVzaXplRXZlbnQoZXZl bnQpOworICAgICAgICBRUmVjdEYgcmVjdChRUmVjdChRUG9pbnQoMCwgMCksIGV2ZW50LT5zaXpl KCkpKTsKKyAgICAgICAgaWYgKCFtX21haW5XaWRnZXQpCisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIG1fbWFpbldpZGdldC0+c2V0R2VvbWV0cnkocmVjdCk7CisgICAgfQorCitwcml2YXRl OgorICAgIFFHcmFwaGljc1dpZGdldCogbV9tYWluV2lkZ2V0OworfTsKKworY2xhc3MgU2hhcmVk U2NlbmUgOiBwdWJsaWMgUVNoYXJlZERhdGEgeworcHVibGljOgorICAgIFNoYXJlZFNjZW5lKCkK KyAgICB7CisgICAgICAgIG1fc2NlbmUgPSBuZXcgUUdyYXBoaWNzU2NlbmU7CisKKyAgICAgICAg bV9pdGVtID0gbmV3IFFXZWJHcmFwaGljc0l0ZW07CisgICAgICAgIG1faXRlbS0+c2V0UGFnZShu ZXcgV2ViUGFnZSgpKTsKKworICAgICAgICBtX3NjZW5lLT5hZGRJdGVtKG1faXRlbSk7CisgICAg ICAgIG1fc2NlbmUtPnNldEFjdGl2ZVdpbmRvdyhtX2l0ZW0pOworICAgIH0KKworICAgIH5TaGFy ZWRTY2VuZSgpCisgICAgeworICAgICAgICBkZWxldGUgbV9pdGVtOworICAgICAgICBkZWxldGUg bV9zY2VuZTsKKyAgICB9CisKKyAgICBRR3JhcGhpY3NTY2VuZSogc2NlbmUoKSB7IHJldHVybiBt X3NjZW5lOyB9CisgICAgUVdlYkdyYXBoaWNzSXRlbSogd2ViSXRlbSgpIHsgcmV0dXJuIG1faXRl bTsgfQorCitwcml2YXRlOgorICAgIFFHcmFwaGljc1NjZW5lKiBtX3NjZW5lOworICAgIFFXZWJH cmFwaGljc0l0ZW0qIG1faXRlbTsKK307CisKKworY2xhc3MgTWFpbldpbmRvdyA6IHB1YmxpYyBR TWFpbldpbmRvdyB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgorICAgIE1haW5XaW5kb3coUUV4 cGxpY2l0bHlTaGFyZWREYXRhUG9pbnRlcjxTaGFyZWRTY2VuZT4gb3RoZXIpCisgICAgICAgIDog UU1haW5XaW5kb3coKSwgdmlldyhuZXcgTWFpblZpZXcodGhpcykpLCBzY2VuZShvdGhlcikKKyAg ICB7CisgICAgICAgIGluaXQoKTsKKyAgICB9CisKKyAgICBNYWluV2luZG93KCkKKyAgICAgICAg OiBRTWFpbldpbmRvdygpLCB2aWV3KG5ldyBNYWluVmlldyh0aGlzKSksIHNjZW5lKG5ldyBTaGFy ZWRTY2VuZSgpKQorICAgIHsKKyAgICAgICAgaW5pdCgpOworICAgIH0KKworICAgIHZvaWQgaW5p dCgpCisgICAgeworICAgICAgICBzZXRBdHRyaWJ1dGUoUXQ6OldBX0RlbGV0ZU9uQ2xvc2UpOwor CisgICAgICAgIHZpZXctPnNldFNjZW5lKHNjZW5lLT5zY2VuZSgpKTsKKyAgICAgICAgdmlldy0+ c2V0RnJhbWVTaGFwZShRRnJhbWU6Ok5vRnJhbWUpOworICAgICAgICB2aWV3LT5zZXRTaXplUG9s aWN5KFFTaXplUG9saWN5OjpFeHBhbmRpbmcsIFFTaXplUG9saWN5OjpFeHBhbmRpbmcpOworICAg ICAgICBzZXRDZW50cmFsV2lkZ2V0KHZpZXcpOworCisgICAgICAgIHZpZXctPnNldE1haW5XaWRn ZXQoc2NlbmUtPndlYkl0ZW0oKSk7CisKKyAgICAgICAgY29ubmVjdChzY2VuZS0+d2ViSXRlbSgp LCBTSUdOQUwobG9hZEZpbmlzaGVkKCkpLCB0aGlzLCBTTE9UKGxvYWRGaW5pc2hlZCgpKSk7Cisg ICAgICAgIGNvbm5lY3Qoc2NlbmUtPndlYkl0ZW0oKSwgU0lHTkFMKHRpdGxlQ2hhbmdlZChjb25z dCBRU3RyaW5nJikpLCB0aGlzLCBTTE9UKHNldFdpbmRvd1RpdGxlKGNvbnN0IFFTdHJpbmcmKSkp OworICAgICAgICBjb25uZWN0KHNjZW5lLT53ZWJJdGVtKCktPnBhZ2UoKSwgU0lHTkFMKHdpbmRv d0Nsb3NlUmVxdWVzdGVkKCkpLCB0aGlzLCBTTE9UKGNsb3NlKCkpKTsKKworICAgICAgICByZXNp emUoNjQwLCA0ODApOworICAgICAgICBidWlsZFVJKCk7CisgICAgfQorCisgICAgdm9pZCBsb2Fk KGNvbnN0IFFTdHJpbmcmIHVybCkKKyAgICB7CisgICAgICAgIFFVcmwgZGVkdWNlZFVybCA9IGd1 ZXNzVXJsRnJvbVN0cmluZyh1cmwpOworICAgICAgICBpZiAoIWRlZHVjZWRVcmwuaXNWYWxpZCgp KQorICAgICAgICAgICAgZGVkdWNlZFVybCA9IFFVcmwoImh0dHA6Ly8iICsgdXJsICsgIi8iKTsK KworICAgICAgICB1cmxFZGl0LT5zZXRUZXh0KGRlZHVjZWRVcmwudG9FbmNvZGVkKCkpOworICAg ICAgICBzY2VuZS0+d2ViSXRlbSgpLT5sb2FkKGRlZHVjZWRVcmwpOworICAgICAgICBzY2VuZS0+ d2ViSXRlbSgpLT5zZXRGb2N1cyhRdDo6T3RoZXJGb2N1c1JlYXNvbik7CisgICAgfQorCisgICAg UVVybCBndWVzc1VybEZyb21TdHJpbmcoY29uc3QgUVN0cmluZyYgc3RyaW5nKQorICAgIHsKKyAg ICAgICAgUVN0cmluZyBpbnB1dChzdHJpbmcpOworICAgICAgICBRRmlsZUluZm8gZmkoaW5wdXQp OworICAgICAgICBpZiAoZmkuZXhpc3RzKCkgJiYgZmkuaXNSZWxhdGl2ZSgpKQorICAgICAgICAg ICAgaW5wdXQgPSBmaS5hYnNvbHV0ZUZpbGVQYXRoKCk7CisKKyAgICAgICAgcmV0dXJuIFFXZWJW aWV3OjpndWVzc1VybEZyb21TdHJpbmcoaW5wdXQpOworICAgIH0KKworICAgIFFXZWJQYWdlKiBw YWdlKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBzY2VuZS0+d2ViSXRlbSgpLT5wYWdl KCk7CisgICAgfQorCitwcm90ZWN0ZWQgc2xvdHM6CisgICAgdm9pZCBjaGFuZ2VMb2NhdGlvbigp CisgICAgeworICAgICAgICBsb2FkKHVybEVkaXQtPnRleHQoKSk7CisgICAgfQorCisgICAgdm9p ZCBsb2FkRmluaXNoZWQoKQorICAgIHsKKyAgICAgICAgUVVybCB1cmwgPSBzY2VuZS0+d2ViSXRl bSgpLT51cmwoKTsKKyAgICAgICAgdXJsRWRpdC0+c2V0VGV4dCh1cmwudG9TdHJpbmcoKSk7CisK KyAgICAgICAgUVVybDo6Rm9ybWF0dGluZ09wdGlvbnMgb3B0czsKKyAgICAgICAgb3B0cyB8PSBR VXJsOjpSZW1vdmVTY2hlbWU7CisgICAgICAgIG9wdHMgfD0gUVVybDo6UmVtb3ZlVXNlckluZm87 CisgICAgICAgIG9wdHMgfD0gUVVybDo6U3RyaXBUcmFpbGluZ1NsYXNoOworICAgICAgICBRU3Ry aW5nIHMgPSB1cmwudG9TdHJpbmcob3B0cyk7CisgICAgICAgIHMgPSBzLm1pZCgyKTsKKyAgICAg ICAgaWYgKHMuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAvL0ZJWE1F OiBzb21ldGhpbmcgbWlzc2luZyBoZXJlCisgICAgfQorCitwdWJsaWMgc2xvdHM6CisgICAgdm9p ZCBuZXdXaW5kb3coY29uc3QgUVN0cmluZyAmdXJsID0gUVN0cmluZygpKQorICAgIHsKKyAgICAg ICAgTWFpbldpbmRvdyAqbXcgPSBuZXcgTWFpbldpbmRvdygpOworICAgICAgICBtdy0+bG9hZCh1 cmwpOworICAgICAgICBtdy0+c2hvdygpOworICAgIH0KKworICAgIHZvaWQgY2xvbmUoKQorICAg IHsKKyAgICAgICAgTWFpbldpbmRvdyAqbXcgPSBuZXcgTWFpbldpbmRvdyhzY2VuZSk7CisgICAg ICAgIG13LT5zaG93KCk7CisgICAgfQorCitwcml2YXRlOgorICAgIHZvaWQgYnVpbGRVSSgpCisg ICAgeworICAgICAgICBRV2ViUGFnZSogcGFnZSA9IHNjZW5lLT53ZWJJdGVtKCktPnBhZ2UoKTsK KyAgICAgICAgdXJsRWRpdCA9IG5ldyBRTGluZUVkaXQodGhpcyk7CisgICAgICAgIHVybEVkaXQt PnNldFNpemVQb2xpY3koUVNpemVQb2xpY3k6OkV4cGFuZGluZywgdXJsRWRpdC0+c2l6ZVBvbGlj eSgpLnZlcnRpY2FsUG9saWN5KCkpOworICAgICAgICBjb25uZWN0KHVybEVkaXQsIFNJR05BTChy ZXR1cm5QcmVzc2VkKCkpLCBTTE9UKGNoYW5nZUxvY2F0aW9uKCkpKTsKKworICAgICAgICBRVG9v bEJhciAqYmFyID0gYWRkVG9vbEJhcigiTmF2aWdhdGlvbiIpOworICAgICAgICBiYXItPmFkZEFj dGlvbihwYWdlLT5hY3Rpb24oUVdlYlBhZ2U6OkJhY2spKTsKKyAgICAgICAgYmFyLT5hZGRBY3Rp b24ocGFnZS0+YWN0aW9uKFFXZWJQYWdlOjpGb3J3YXJkKSk7CisgICAgICAgIGJhci0+YWRkQWN0 aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6UmVsb2FkKSk7CisgICAgICAgIGJhci0+YWRkQWN0 aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6U3RvcCkpOworICAgICAgICBiYXItPmFkZFdpZGdl dCh1cmxFZGl0KTsKKworICAgICAgICBRTWVudSAqZmlsZU1lbnUgPSBtZW51QmFyKCktPmFkZE1l bnUoIiZGaWxlIik7CisgICAgICAgIFFBY3Rpb24gKm5ld1dpbmRvdyA9IGZpbGVNZW51LT5hZGRB Y3Rpb24oIk5ldyBXaW5kb3ciLCB0aGlzLCBTTE9UKG5ld1dpbmRvdygpKSk7CisgICAgICAgIFFB Y3Rpb24gKmNsb25lVmlldyA9IGZpbGVNZW51LT5hZGRBY3Rpb24oIkNsb25lIHZpZXciLCB0aGlz LCBTTE9UKGNsb25lKCkpKTsKKyAgICAgICAgZmlsZU1lbnUtPmFkZEFjdGlvbigiQ2xvc2UiLCB0 aGlzLCBTTE9UKGNsb3NlKCkpKTsKKworICAgICAgICBRTWVudSAqdmlld01lbnUgPSBtZW51QmFy KCktPmFkZE1lbnUoIiZWaWV3Iik7CisgICAgICAgIHZpZXdNZW51LT5hZGRBY3Rpb24ocGFnZS0+ YWN0aW9uKFFXZWJQYWdlOjpTdG9wKSk7CisgICAgICAgIHZpZXdNZW51LT5hZGRBY3Rpb24ocGFn ZS0+YWN0aW9uKFFXZWJQYWdlOjpSZWxvYWQpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTWFp blZpZXcgKnZpZXc7CisgICAgUUV4cGxpY2l0bHlTaGFyZWREYXRhUG9pbnRlcjxTaGFyZWRTY2Vu ZT4gc2NlbmU7CisKKyAgICBRTGluZUVkaXQgKnVybEVkaXQ7Cit9OworCitRV2ViUGFnZSAqV2Vi UGFnZTo6Y3JlYXRlV2luZG93KFFXZWJQYWdlOjpXZWJXaW5kb3dUeXBlKQoreworICAgIE1haW5X aW5kb3cgKm13ID0gbmV3IE1haW5XaW5kb3c7CisgICAgbXctPnNob3coKTsKKyAgICByZXR1cm4g bXctPnBhZ2UoKTsKK30KKwordm9pZCBXZWJQYWdlOjphcHBseVByb3h5KCkKK3sKKyAgICBRVXJs IHByb3h5VXJsID0gUVdlYlZpZXc6Omd1ZXNzVXJsRnJvbVN0cmluZyhxZ2V0ZW52KCJodHRwX3By b3h5IikpOworCisgICAgaWYgKHByb3h5VXJsLmlzVmFsaWQoKSAmJiAhcHJveHlVcmwuaG9zdCgp LmlzRW1wdHkoKSkgeworICAgICAgICBpbnQgcHJveHlQb3J0ID0gKHByb3h5VXJsLnBvcnQoKSA+ IDApID8gcHJveHlVcmwucG9ydCgpIDogODA4MDsKKyAgICAgICAgbmV0d29ya0FjY2Vzc01hbmFn ZXIoKS0+c2V0UHJveHkoUU5ldHdvcmtQcm94eShRTmV0d29ya1Byb3h5OjpIdHRwUHJveHksIHBy b3h5VXJsLmhvc3QoKSwgcHJveHlQb3J0KSk7CisgICAgfQorfQorCisjaW5jbHVkZSAibWFpbi5t b2MiCisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKK3sKKyAgICBRQXBwbGljYXRp b24gYXBwKGFyZ2MsIGFyZ3YpOworICAgIFFTdHJpbmcgdXJsID0gUVN0cmluZygiZmlsZTovLyUx LyUyIikuYXJnKFFEaXI6OmhvbWVQYXRoKCkpLmFyZyhRTGF0aW4xU3RyaW5nKCJpbmRleC5odG1s IikpOworCisgICAgYXBwLnNldEFwcGxpY2F0aW9uTmFtZSgiR1FWTGF1bmNoZXIiKTsKKworICAg IFFXZWJTZXR0aW5nczo6c2V0T2JqZWN0Q2FjaGVDYXBhY2l0aWVzKCgxNioxMDI0KjEwMjQpIC8g OCwgKDE2KjEwMjQqMTAyNCkgLyA4LCAxNioxMDI0KjEwMjQpOworICAgIFFXZWJTZXR0aW5nczo6 c2V0TWF4aW11bVBhZ2VzSW5DYWNoZSg0KTsKKyAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRp bmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OlBsdWdpbnNFbmFibGVkLCB0cnVlKTsK KyAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0 dGluZ3M6OkRldmVsb3BlckV4dHJhc0VuYWJsZWQsIHRydWUpOworICAgIFFXZWJTZXR0aW5nczo6 Z2xvYmFsU2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6TG9jYWxTdG9yYWdl RW5hYmxlZCwgdHJ1ZSk7CisKKyAgICBjb25zdCBRU3RyaW5nTGlzdCBhcmdzID0gYXBwLmFyZ3Vt ZW50cygpOworICAgIGlmIChhcmdzLmNvdW50KCkgPiAxKQorICAgICAgICB1cmwgPSBhcmdzLmF0 KDEpOworCisgICAgTWFpbldpbmRvdyogd2luZG93ID0gbmV3IE1haW5XaW5kb3c7CisgICAgd2lu ZG93LT5sb2FkKHVybCk7CisKKyAgICBmb3IgKGludCBpID0gMjsgaSA8IGFyZ3MuY291bnQoKTsg aSsrKQorICAgICAgICB3aW5kb3ctPm5ld1dpbmRvdyhhcmdzLmF0KGkpKTsKKworICAgIHdpbmRv dy0+c2hvdygpOworICAgIHJldHVybiBhcHAuZXhlYygpOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcCBiL1dlYktpdC9xdC9XZWJDb3Jl U3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAKaW5kZXggZDY1OTgzMy4uZTc5YWU1NSAxMDA2NDQK LS0tIGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcAorKysgYi9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50UXQuY3BwCkBAIC00NSw2ICs0NSw3 IEBACiAjaW5jbHVkZSAicXdlYmZyYW1lX3AuaCIKICNpbmNsdWRlICJxd2Vic2VjdXJpdHlvcmln aW4uaCIKICNpbmNsdWRlICJxd2Vic2VjdXJpdHlvcmlnaW5fcC5oIgorI2luY2x1ZGUgInF3ZWJ2 aWV3LmgiCiAKICNpbmNsdWRlIDxxdG9vbHRpcC5oPgogI2luY2x1ZGUgPHF0ZXh0ZG9jdW1lbnQu aD4KQEAgLTMwNyw4ICszMDgsOCBAQCB2b2lkIENocm9tZUNsaWVudFF0OjpyZXBhaW50KGNvbnN0 IEludFJlY3QmIHdpbmRvd1JlY3QsIGJvb2wgY29udGVudENoYW5nZWQsIGJvbwogewogICAgIC8v IE5vIGRvdWJsZSBidWZmZXIsIHNvIG9ubHkgdXBkYXRlIHRoZSBRV2lkZ2V0IGlmIGNvbnRlbnQg Y2hhbmdlZC4KICAgICBpZiAoY29udGVudENoYW5nZWQpIHsKLSAgICAgICAgUVdpZGdldCogdmll dyA9IG1fd2ViUGFnZS0+dmlldygpOwotICAgICAgICBpZiAodmlldykgeworICAgICAgICAvLyBP bmx5IGRvIGltcGxpY2l0IHBhaW50cyBmb3IgUVdlYlZpZXcncworICAgICAgICBpZiAoUVdlYlZp ZXcqIHZpZXcgPSBxb2JqZWN0X2Nhc3Q8UVdlYlZpZXcqPihtX3dlYlBhZ2UtPnZpZXcoKSkpIHsK ICAgICAgICAgICAgIFFSZWN0IHJlY3Qod2luZG93UmVjdCk7CiAgICAgICAgICAgICByZWN0ID0g cmVjdC5pbnRlcnNlY3RlZChRUmVjdChRUG9pbnQoMCwgMCksIG1fd2ViUGFnZS0+dmlld3BvcnRT aXplKCkpKTsKICAgICAgICAgICAgIGlmICghcmVjdC5pc0VtcHR5KCkpCkBAIC0zMjMsOCArMzI0 LDggQEAgdm9pZCBDaHJvbWVDbGllbnRRdDo6cmVwYWludChjb25zdCBJbnRSZWN0JiB3aW5kb3dS ZWN0LCBib29sIGNvbnRlbnRDaGFuZ2VkLCBib28KIAogdm9pZCBDaHJvbWVDbGllbnRRdDo6c2Ny b2xsKGNvbnN0IEludFNpemUmIGRlbHRhLCBjb25zdCBJbnRSZWN0JiBzY3JvbGxWaWV3UmVjdCwg Y29uc3QgSW50UmVjdCYpCiB7Ci0gICAgUVdpZGdldCogdmlldyA9IG1fd2ViUGFnZS0+dmlldygp OwotICAgIGlmICh2aWV3KQorICAgIC8vIE9ubHkgZG8gaW1wbGljaXQgcGFpbnRzIGZvciBRV2Vi VmlldydzCisgICAgaWYgKFFXZWJWaWV3KiB2aWV3ID0gcW9iamVjdF9jYXN0PFFXZWJWaWV3Kj4o bV93ZWJQYWdlLT52aWV3KCkpKQogICAgICAgICB2aWV3LT5zY3JvbGwoZGVsdGEud2lkdGgoKSwg ZGVsdGEuaGVpZ2h0KCksIHNjcm9sbFZpZXdSZWN0KTsKICAgICBlbWl0IG1fd2ViUGFnZS0+c2Ny b2xsUmVxdWVzdGVkKGRlbHRhLndpZHRoKCksIGRlbHRhLmhlaWdodCgpLCBzY3JvbGxWaWV3UmVj dCk7CiB9Ci0tIAoxLjYuMC40Cgo= 39125 2009-09-06 13:43:48 -0700 2009-09-09 04:04:45 -0700 patch 2 - v0.1 - Add support for handling QGraphicsScene events. 0002--Add-support-for-handling-QGraphicsScene-events.patch text/plain 12510 tonikitoo RnJvbSBlZWEwYzk3ZmQ0NDU4MzRiYzY3ZTU3YWQ4NWY0NjAzNjFmMzMwYTJhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBGcmksIDQgU2VwIDIwMDkgMTY6MjM6MDUgLTAzMDAKU3ViamVjdDog W1BBVENIXSAgICAgQWRkIHN1cHBvcnQgZm9yIGhhbmRsaW5nIFFHcmFwaGljc1NjZW5lIGV2ZW50 cy4KCiAgICBbUXRdW0FQSV0gQWRkIGEgbmV3IFFHcmFwaGljc1dpZGdldCBiYXNlZCB2ZXJzaW9u IG9mIHRoZSAiUVdlYlZpZXciIChwYXJ0IElJKQogICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI4ODYyCgogICAgUGF0Y2ggYnkgS2VubmV0aCBSb2hkZSBDaHJpc3Rp YW5zZW4gPGtlbm5ldGhAd2Via2l0Lm9yZz4gb24gMjAwOS0wOS0wNAogICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgogICAgKiBBcGkvcXdlYnBhZ2UuY3BwOgogICAgKFFXZWJQYWdlUHJp dmF0ZTo6bW91c2VNb3ZlRXZlbnQpOgogICAgKFFXZWJQYWdlUHJpdmF0ZTo6bW91c2VQcmVzc0V2 ZW50KToKICAgIChRV2ViUGFnZVByaXZhdGU6Om1vdXNlRG91YmxlQ2xpY2tFdmVudCk6CiAgICAo UVdlYlBhZ2VQcml2YXRlOjptb3VzZVJlbGVhc2VFdmVudCk6CiAgICAoUVdlYlBhZ2VQcml2YXRl Ojp3aGVlbEV2ZW50KToKICAgIChRV2ViUGFnZVByaXZhdGU6OmRyYWdFbnRlckV2ZW50KToKICAg IChRV2ViUGFnZVByaXZhdGU6OmRyYWdMZWF2ZUV2ZW50KToKICAgIChRV2ViUGFnZVByaXZhdGU6 OmRyYWdNb3ZlRXZlbnQpOgogICAgKFFXZWJQYWdlUHJpdmF0ZTo6ZHJvcEV2ZW50KToKICAgIChR V2ViUGFnZTo6ZXZlbnQpOgogICAgKiBBcGkvcXdlYnBhZ2VfcC5oOgotLS0KIFdlYktpdC9xdC9B cGkvcXdlYnBhZ2UuY3BwIHwgIDE0NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKystCiBXZWJLaXQvcXQvQXBpL3F3ZWJwYWdlX3AuaCB8ICAgMTggKysrKy0KIFdlYktp dC9xdC9DaGFuZ2VMb2cgICAgICAgIHwgICAyMiArKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDE3 NyBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9B cGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKaW5kZXggMTRiYjhk MC4uMzQxZWVlZCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTYxOCw2ICs2MTgsMTggQEAgdm9pZCBRV2Vi UGFnZVByaXZhdGU6OnRpbWVyRXZlbnQoUVRpbWVyRXZlbnQgKmV2KQogICAgICAgICBxLT5RT2Jq ZWN0Ojp0aW1lckV2ZW50KGV2KTsKIH0KIAordm9pZCBRV2ViUGFnZVByaXZhdGU6Om1vdXNlTW92 ZUV2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCogZXYpCit7CisgICAgcS0+c2V0Vmlldyhl di0+d2lkZ2V0KCkpOworCisgICAgUU1vdXNlRXZlbnQgbWUgPSBRTW91c2VFdmVudChRRXZlbnQ6 Ok1vdXNlTW92ZSwKKyAgICAgICAgICAgIGV2LT5wb3MoKS50b1BvaW50KCksIGV2LT5idXR0b24o KSwKKyAgICAgICAgICAgIGV2LT5idXR0b25zKCksIDApOworCisgICAgbW91c2VNb3ZlRXZlbnQo Jm1lKTsKKyAgICBldi0+c2V0QWNjZXB0ZWQobWUuaXNBY2NlcHRlZCgpKTsKK30KKwogdm9pZCBR V2ViUGFnZVByaXZhdGU6Om1vdXNlTW92ZUV2ZW50KFFNb3VzZUV2ZW50ICpldikKIHsKICAgICBX ZWJDb3JlOjpGcmFtZSogZnJhbWUgPSBRV2ViRnJhbWVQcml2YXRlOjpjb3JlKG1haW5GcmFtZSk7 CkBAIC02MjgsNiArNjQwLDE4IEBAIHZvaWQgUVdlYlBhZ2VQcml2YXRlOjptb3VzZU1vdmVFdmVu dChRTW91c2VFdmVudCAqZXYpCiAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKIH0KIAor dm9pZCBRV2ViUGFnZVByaXZhdGU6Om1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNl RXZlbnQqIGV2KQoreworICAgIHEtPnNldFZpZXcoZXYtPndpZGdldCgpKTsKKworICAgIFFNb3Vz ZUV2ZW50IG1lID0gUU1vdXNlRXZlbnQoUUV2ZW50OjpNb3VzZUJ1dHRvblByZXNzLAorICAgICAg ICAgICAgZXYtPnBvcygpLnRvUG9pbnQoKSwgZXYtPmJ1dHRvbigpLAorICAgICAgICAgICAgZXYt PmJ1dHRvbnMoKSwgMCk7CisKKyAgICBtb3VzZVByZXNzRXZlbnQoJm1lKTsKKyAgICBldi0+c2V0 QWNjZXB0ZWQobWUuaXNBY2NlcHRlZCgpKTsKK30KKwogdm9pZCBRV2ViUGFnZVByaXZhdGU6Om1v dXNlUHJlc3NFdmVudChRTW91c2VFdmVudCAqZXYpCiB7CiAgICAgV2ViQ29yZTo6RnJhbWUqIGZy YW1lID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShtYWluRnJhbWUpOwpAQCAtNjQ5LDYgKzY3Mywx OCBAQCB2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6bW91c2VQcmVzc0V2ZW50KFFNb3VzZUV2ZW50ICpl dikKICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0ZWQpOwogfQogCit2b2lkIFFXZWJQYWdlUHJp dmF0ZTo6bW91c2VEb3VibGVDbGlja0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCAqZXYp Cit7CisgICAgcS0+c2V0Vmlldyhldi0+d2lkZ2V0KCkpOworCisgICAgUU1vdXNlRXZlbnQgbWUg PSBRTW91c2VFdmVudChRRXZlbnQ6Ok1vdXNlQnV0dG9uRGJsQ2xpY2ssCisgICAgICAgICAgICBl di0+cG9zKCkudG9Qb2ludCgpLCBldi0+YnV0dG9uKCksCisgICAgICAgICAgICBldi0+YnV0dG9u cygpLCAwKTsKKworICAgIG1vdXNlRG91YmxlQ2xpY2tFdmVudCgmbWUpOworICAgIGV2LT5zZXRB Y2NlcHRlZChtZS5pc0FjY2VwdGVkKCkpOworfQorCiB2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6bW91 c2VEb3VibGVDbGlja0V2ZW50KFFNb3VzZUV2ZW50ICpldikKIHsKICAgICBXZWJDb3JlOjpGcmFt ZSogZnJhbWUgPSBRV2ViRnJhbWVQcml2YXRlOjpjb3JlKG1haW5GcmFtZSk7CkBAIC02ODAsNiAr NzE2LDE4IEBAIHZvaWQgUVdlYlBhZ2VQcml2YXRlOjptb3VzZVRyaXBsZUNsaWNrRXZlbnQoUU1v dXNlRXZlbnQgKmV2KQogICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CiB9CiAKK3ZvaWQg UVdlYlBhZ2VQcml2YXRlOjptb3VzZVJlbGVhc2VFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZl bnQqIGV2KQoreworICAgIHEtPnNldFZpZXcoZXYtPndpZGdldCgpKTsKKworICAgIFFNb3VzZUV2 ZW50IG1lID0gUU1vdXNlRXZlbnQoUUV2ZW50OjpNb3VzZUJ1dHRvblJlbGVhc2UsCisgICAgICAg ICAgICBldi0+cG9zKCkudG9Qb2ludCgpLCBldi0+YnV0dG9uKCksCisgICAgICAgICAgICBldi0+ YnV0dG9ucygpLCAwKTsKKworICAgIG1vdXNlUmVsZWFzZUV2ZW50KCZtZSk7CisgICAgZXYtPnNl dEFjY2VwdGVkKG1lLmlzQWNjZXB0ZWQoKSk7Cit9CisKIHZvaWQgUVdlYlBhZ2VQcml2YXRlOjpt b3VzZVJlbGVhc2VFdmVudChRTW91c2VFdmVudCAqZXYpCiB7CiAgICAgV2ViQ29yZTo6RnJhbWUq IGZyYW1lID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShtYWluRnJhbWUpOwpAQCAtNzQ0LDYgKzc5 MiwxOCBAQCBRTWVudSAqUVdlYlBhZ2U6OmNyZWF0ZVN0YW5kYXJkQ29udGV4dE1lbnUoKQogfQog CiAjaWZuZGVmIFFUX05PX1dIRUVMRVZFTlQKK3ZvaWQgUVdlYlBhZ2VQcml2YXRlOjp3aGVlbEV2 ZW50KFFHcmFwaGljc1NjZW5lV2hlZWxFdmVudCogZXYpCit7CisgICAgcS0+c2V0Vmlldyhldi0+ d2lkZ2V0KCkpOworCisgICAgUVdoZWVsRXZlbnQgd2UgPSBRV2hlZWxFdmVudChldi0+c2NlbmVQ b3MoKS50b1BvaW50KCksCisgICAgICAgICAgICBldi0+ZGVsdGEoKSwgZXYtPmJ1dHRvbnMoKSwg ZXYtPm1vZGlmaWVycygpLAorICAgICAgICAgICAgZXYtPm9yaWVudGF0aW9uKCkpOworCisgICAg d2hlZWxFdmVudCgmd2UpOworICAgIGV2LT5zZXRBY2NlcHRlZCh3ZS5pc0FjY2VwdGVkKCkpOwor fQorCiB2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6d2hlZWxFdmVudChRV2hlZWxFdmVudCAqZXYpCiB7 CiAgICAgV2ViQ29yZTo6RnJhbWUqIGZyYW1lID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShtYWlu RnJhbWUpOwpAQCAtODkwLDcgKzk1MCwyMSBAQCB2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6Zm9jdXNP dXRFdmVudChRRm9jdXNFdmVudCAqZXYpCiAgICAgZm9jdXNDb250cm9sbGVyLT5zZXRGb2N1c2Vk KGZhbHNlKTsKIH0KIAotdm9pZCBRV2ViUGFnZVByaXZhdGU6OmRyYWdFbnRlckV2ZW50KFFEcmFn RW50ZXJFdmVudCAqZXYpCit2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6ZHJhZ0VudGVyRXZlbnQoUUdy YXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyAgICBxLT5zZXRWaWV3KGV2LT53aWRn ZXQoKSk7CisKKyNpZm5kZWYgUVRfTk9fRFJBR0FORERST1AKKyAgICBEcmFnRGF0YSBkcmFnRGF0 YShldi0+bWltZURhdGEoKSwgZXYtPnBvcygpLnRvUG9pbnQoKSwKKyAgICAgICAgICAgIFFDdXJz b3I6OnBvcygpLCBkcm9wQWN0aW9uVG9EcmFnT3AoZXYtPnBvc3NpYmxlQWN0aW9ucygpKSk7Cisg ICAgUXQ6OkRyb3BBY3Rpb24gYWN0aW9uID0gZHJhZ09wVG9Ecm9wQWN0aW9uKHBhZ2UtPmRyYWdD b250cm9sbGVyKCktPmRyYWdFbnRlcmVkKCZkcmFnRGF0YSkpOworICAgIGV2LT5zZXREcm9wQWN0 aW9uKGFjdGlvbik7CisgICAgaWYgKGFjdGlvbiAhPSBRdDo6SWdub3JlQWN0aW9uKQorICAgICAg ICBldi0+YWNjZXB0KCk7CisjZW5kaWYKK30KKwordm9pZCBRV2ViUGFnZVByaXZhdGU6OmRyYWdF bnRlckV2ZW50KFFEcmFnRW50ZXJFdmVudCogZXYpCiB7CiAjaWZuZGVmIFFUX05PX0RSQUdBTkRE Uk9QCiAgICAgRHJhZ0RhdGEgZHJhZ0RhdGEoZXYtPm1pbWVEYXRhKCksIGV2LT5wb3MoKSwgUUN1 cnNvcjo6cG9zKCksCkBAIC05MDIsOCArOTc2LDEwIEBAIHZvaWQgUVdlYlBhZ2VQcml2YXRlOjpk cmFnRW50ZXJFdmVudChRRHJhZ0VudGVyRXZlbnQgKmV2KQogI2VuZGlmCiB9CiAKLXZvaWQgUVdl YlBhZ2VQcml2YXRlOjpkcmFnTGVhdmVFdmVudChRRHJhZ0xlYXZlRXZlbnQgKmV2KQordm9pZCBR V2ViUGFnZVByaXZhdGU6OmRyYWdMZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVu dCogZXYpCiB7CisgICAgcS0+c2V0Vmlldyhldi0+d2lkZ2V0KCkpOworCiAjaWZuZGVmIFFUX05P X0RSQUdBTkREUk9QCiAgICAgRHJhZ0RhdGEgZHJhZ0RhdGEoMCwgSW50UG9pbnQoKSwgUUN1cnNv cjo6cG9zKCksIERyYWdPcGVyYXRpb25Ob25lKTsKICAgICBwYWdlLT5kcmFnQ29udHJvbGxlcigp LT5kcmFnRXhpdGVkKCZkcmFnRGF0YSk7CkBAIC05MTEsNyArOTg3LDMwIEBAIHZvaWQgUVdlYlBh Z2VQcml2YXRlOjpkcmFnTGVhdmVFdmVudChRRHJhZ0xlYXZlRXZlbnQgKmV2KQogI2VuZGlmCiB9 CiAKLXZvaWQgUVdlYlBhZ2VQcml2YXRlOjpkcmFnTW92ZUV2ZW50KFFEcmFnTW92ZUV2ZW50ICpl dikKK3ZvaWQgUVdlYlBhZ2VQcml2YXRlOjpkcmFnTGVhdmVFdmVudChRRHJhZ0xlYXZlRXZlbnQq IGV2KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5ERFJPUAorICAgIERyYWdEYXRhIGRyYWdEYXRh KDAsIEludFBvaW50KCksIFFDdXJzb3I6OnBvcygpLCBEcmFnT3BlcmF0aW9uTm9uZSk7CisgICAg cGFnZS0+ZHJhZ0NvbnRyb2xsZXIoKS0+ZHJhZ0V4aXRlZCgmZHJhZ0RhdGEpOworICAgIGV2LT5h Y2NlcHQoKTsKKyNlbmRpZgorfQorCit2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6ZHJhZ01vdmVFdmVu dChRR3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2KQoreworICAgIHEtPnNldFZpZXcoZXYt PndpZGdldCgpKTsKKworI2lmbmRlZiBRVF9OT19EUkFHQU5ERFJPUAorICAgIERyYWdEYXRhIGRy YWdEYXRhKGV2LT5taW1lRGF0YSgpLCBldi0+cG9zKCkudG9Qb2ludCgpLAorICAgICAgICAgICAg UUN1cnNvcjo6cG9zKCksIGRyb3BBY3Rpb25Ub0RyYWdPcChldi0+cG9zc2libGVBY3Rpb25zKCkp KTsKKyAgICBRdDo6RHJvcEFjdGlvbiBhY3Rpb24gPSBkcmFnT3BUb0Ryb3BBY3Rpb24ocGFnZS0+ ZHJhZ0NvbnRyb2xsZXIoKS0+ZHJhZ1VwZGF0ZWQoJmRyYWdEYXRhKSk7CisgICAgZXYtPnNldERy b3BBY3Rpb24oYWN0aW9uKTsKKyAgICBpZiAoYWN0aW9uICE9IFF0OjpJZ25vcmVBY3Rpb24pCisg ICAgICAgIGV2LT5hY2NlcHQoKTsKKyNlbmRpZgorfQorCit2b2lkIFFXZWJQYWdlUHJpdmF0ZTo6 ZHJhZ01vdmVFdmVudChRRHJhZ01vdmVFdmVudCogZXYpCiB7CiAjaWZuZGVmIFFUX05PX0RSQUdB TkREUk9QCiAgICAgRHJhZ0RhdGEgZHJhZ0RhdGEoZXYtPm1pbWVEYXRhKCksIGV2LT5wb3MoKSwg UUN1cnNvcjo6cG9zKCksCkBAIC05MjMsNyArMTAyMiwxOCBAQCB2b2lkIFFXZWJQYWdlUHJpdmF0 ZTo6ZHJhZ01vdmVFdmVudChRRHJhZ01vdmVFdmVudCAqZXYpCiAjZW5kaWYKIH0KIAotdm9pZCBR V2ViUGFnZVByaXZhdGU6OmRyb3BFdmVudChRRHJvcEV2ZW50ICpldikKK3ZvaWQgUVdlYlBhZ2VQ cml2YXRlOjpkcm9wRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyNp Zm5kZWYgUVRfTk9fRFJBR0FORERST1AKKyAgICBEcmFnRGF0YSBkcmFnRGF0YShldi0+bWltZURh dGEoKSwgZXYtPnBvcygpLnRvUG9pbnQoKSwKKyAgICAgICAgICAgIFFDdXJzb3I6OnBvcygpLCBk cm9wQWN0aW9uVG9EcmFnT3AoZXYtPnBvc3NpYmxlQWN0aW9ucygpKSk7CisgICAgUXQ6OkRyb3BB Y3Rpb24gYWN0aW9uID0gZHJhZ09wVG9Ecm9wQWN0aW9uKHBhZ2UtPmRyYWdDb250cm9sbGVyKCkt PnBlcmZvcm1EcmFnKCZkcmFnRGF0YSkpOworICAgIGlmIChhY3Rpb24gIT0gUXQ6Oklnbm9yZUFj dGlvbikKKyAgICAgICAgZXYtPmFjY2VwdCgpOworI2VuZGlmCit9CisKK3ZvaWQgUVdlYlBhZ2VQ cml2YXRlOjpkcm9wRXZlbnQoUURyb3BFdmVudCogZXYpCiB7CiAjaWZuZGVmIFFUX05PX0RSQUdB TkREUk9QCiAgICAgRHJhZ0RhdGEgZHJhZ0RhdGEoZXYtPm1pbWVEYXRhKCksIGV2LT5wb3MoKSwg UUN1cnNvcjo6cG9zKCksCkBAIC0yMDg5LDE1ICsyMTk5LDI3IEBAIGJvb2wgUVdlYlBhZ2U6OmV2 ZW50KFFFdmVudCAqZXYpCiAgICAgY2FzZSBRRXZlbnQ6Ok1vdXNlTW92ZToKICAgICAgICAgZC0+ bW91c2VNb3ZlRXZlbnQoc3RhdGljX2Nhc3Q8UU1vdXNlRXZlbnQqPihldikpOwogICAgICAgICBi cmVhazsKKyAgICBjYXNlIFFFdmVudDo6R3JhcGhpY3NTY2VuZU1vdXNlTW92ZToKKyAgICAgICAg ZC0+bW91c2VNb3ZlRXZlbnQoc3RhdGljX2Nhc3Q8UUdyYXBoaWNzU2NlbmVNb3VzZUV2ZW50Kj4o ZXYpKTsKKyAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBRRXZlbnQ6Ok1vdXNlQnV0dG9uUHJlc3M6 CiAgICAgICAgIGQtPm1vdXNlUHJlc3NFdmVudChzdGF0aWNfY2FzdDxRTW91c2VFdmVudCo+KGV2 KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUUV2ZW50OjpHcmFwaGljc1NjZW5lTW91c2VQ cmVzczoKKyAgICAgICAgZC0+bW91c2VQcmVzc0V2ZW50KHN0YXRpY19jYXN0PFFHcmFwaGljc1Nj ZW5lTW91c2VFdmVudCo+KGV2KSk7CisgICAgICAgIGJyZWFrOwogICAgIGNhc2UgUUV2ZW50OjpN b3VzZUJ1dHRvbkRibENsaWNrOgogICAgICAgICBkLT5tb3VzZURvdWJsZUNsaWNrRXZlbnQoc3Rh dGljX2Nhc3Q8UU1vdXNlRXZlbnQqPihldikpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFFF dmVudDo6R3JhcGhpY3NTY2VuZU1vdXNlRG91YmxlQ2xpY2s6CisgICAgICAgIGQtPm1vdXNlRG91 YmxlQ2xpY2tFdmVudChzdGF0aWNfY2FzdDxRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqPihldikp OworICAgICAgICBicmVhazsKICAgICBjYXNlIFFFdmVudDo6TW91c2VCdXR0b25SZWxlYXNlOgog ICAgICAgICBkLT5tb3VzZVJlbGVhc2VFdmVudChzdGF0aWNfY2FzdDxRTW91c2VFdmVudCo+KGV2 KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUUV2ZW50OjpHcmFwaGljc1NjZW5lTW91c2VS ZWxlYXNlOgorICAgICAgICBkLT5tb3VzZVJlbGVhc2VFdmVudChzdGF0aWNfY2FzdDxRR3JhcGhp Y3NTY2VuZU1vdXNlRXZlbnQqPihldikpOworICAgICAgICBicmVhazsKICNpZm5kZWYgUVRfTk9f Q09OVEVYVE1FTlUKICAgICBjYXNlIFFFdmVudDo6Q29udGV4dE1lbnU6CiAgICAgICAgIGQtPmNv bnRleHRNZW51RXZlbnQoc3RhdGljX2Nhc3Q8UUNvbnRleHRNZW51RXZlbnQqPihldikpOwpAQCAt MjEwNyw2ICsyMjI5LDkgQEAgYm9vbCBRV2ViUGFnZTo6ZXZlbnQoUUV2ZW50ICpldikKICAgICBj YXNlIFFFdmVudDo6V2hlZWw6CiAgICAgICAgIGQtPndoZWVsRXZlbnQoc3RhdGljX2Nhc3Q8UVdo ZWVsRXZlbnQqPihldikpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFFFdmVudDo6R3JhcGhp Y3NTY2VuZVdoZWVsOgorICAgICAgICBkLT53aGVlbEV2ZW50KHN0YXRpY19jYXN0PFFHcmFwaGlj c1NjZW5lV2hlZWxFdmVudCo+KGV2KSk7CisgICAgICAgIGJyZWFrOwogI2VuZGlmCiAgICAgY2Fz ZSBRRXZlbnQ6OktleVByZXNzOgogICAgICAgICBkLT5rZXlQcmVzc0V2ZW50KHN0YXRpY19jYXN0 PFFLZXlFdmVudCo+KGV2KSk7CkBAIC0yMTI0LDE1ICsyMjQ5LDI3IEBAIGJvb2wgUVdlYlBhZ2U6 OmV2ZW50KFFFdmVudCAqZXYpCiAgICAgY2FzZSBRRXZlbnQ6OkRyYWdFbnRlcjoKICAgICAgICAg ZC0+ZHJhZ0VudGVyRXZlbnQoc3RhdGljX2Nhc3Q8UURyYWdFbnRlckV2ZW50Kj4oZXYpKTsKICAg ICAgICAgYnJlYWs7CisgICAgY2FzZSBRRXZlbnQ6OkdyYXBoaWNzU2NlbmVEcmFnRW50ZXI6Cisg ICAgICAgIGQtPmRyYWdFbnRlckV2ZW50KHN0YXRpY19jYXN0PFFHcmFwaGljc1NjZW5lRHJhZ0Ry b3BFdmVudCo+KGV2KSk7CisgICAgICAgIGJyZWFrOwogICAgIGNhc2UgUUV2ZW50OjpEcmFnTGVh dmU6CiAgICAgICAgIGQtPmRyYWdMZWF2ZUV2ZW50KHN0YXRpY19jYXN0PFFEcmFnTGVhdmVFdmVu dCo+KGV2KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUUV2ZW50OjpHcmFwaGljc1NjZW5l RHJhZ0xlYXZlOgorICAgICAgICBkLT5kcmFnTGVhdmVFdmVudChzdGF0aWNfY2FzdDxRR3JhcGhp Y3NTY2VuZURyYWdEcm9wRXZlbnQqPihldikpOworICAgICAgICBicmVhazsKICAgICBjYXNlIFFF dmVudDo6RHJhZ01vdmU6CiAgICAgICAgIGQtPmRyYWdNb3ZlRXZlbnQoc3RhdGljX2Nhc3Q8UURy YWdNb3ZlRXZlbnQqPihldikpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFFFdmVudDo6R3Jh cGhpY3NTY2VuZURyYWdNb3ZlOgorICAgICAgICBkLT5kcmFnTW92ZUV2ZW50KHN0YXRpY19jYXN0 PFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCo+KGV2KSk7CisgICAgICAgIGJyZWFrOwogICAg IGNhc2UgUUV2ZW50OjpEcm9wOgogICAgICAgICBkLT5kcm9wRXZlbnQoc3RhdGljX2Nhc3Q8UURy b3BFdmVudCo+KGV2KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUUV2ZW50OjpHcmFwaGlj c1NjZW5lRHJvcDoKKyAgICAgICAgZC0+ZHJvcEV2ZW50KHN0YXRpY19jYXN0PFFHcmFwaGljc1Nj ZW5lRHJhZ0Ryb3BFdmVudCo+KGV2KSk7CisgICAgICAgIGJyZWFrOwogI2VuZGlmCiAgICAgY2Fz ZSBRRXZlbnQ6OklucHV0TWV0aG9kOgogICAgICAgICBkLT5pbnB1dE1ldGhvZEV2ZW50KHN0YXRp Y19jYXN0PFFJbnB1dE1ldGhvZEV2ZW50Kj4oZXYpKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9B cGkvcXdlYnBhZ2VfcC5oIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZV9wLmgKaW5kZXggODdjNjI0 ZC4uMjI5MTNhYyAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2VicGFnZV9wLmgKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2VicGFnZV9wLmgKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlIDxx bmV0d29ya3Byb3h5Lmg+CiAjaW5jbHVkZSA8cXBvaW50ZXIuaD4KICNpbmNsdWRlIDxxZXZlbnQu aD4KKyNpbmNsdWRlIDxxZ3JhcGhpY3NzY2VuZWV2ZW50Lmg+CiAKICNpbmNsdWRlICJxd2VicGFn ZS5oIgogI2luY2x1ZGUgInF3ZWJoaXN0b3J5LmgiCkBAIC04NSwyNSArODYsMzQgQEAgcHVibGlj OgogICAgIHZvaWQgdGltZXJFdmVudChRVGltZXJFdmVudCopOwogCiAgICAgdm9pZCBtb3VzZU1v dmVFdmVudChRTW91c2VFdmVudCopOworICAgIHZvaWQgbW91c2VNb3ZlRXZlbnQoUUdyYXBoaWNz U2NlbmVNb3VzZUV2ZW50Kik7CiAgICAgdm9pZCBtb3VzZVByZXNzRXZlbnQoUU1vdXNlRXZlbnQq KTsKKyAgICB2b2lkIG1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqKTsK ICAgICB2b2lkIG1vdXNlRG91YmxlQ2xpY2tFdmVudChRTW91c2VFdmVudCopOworICAgIHZvaWQg bW91c2VEb3VibGVDbGlja0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCopOwogICAgIHZv aWQgbW91c2VUcmlwbGVDbGlja0V2ZW50KFFNb3VzZUV2ZW50Kik7CiAgICAgdm9pZCBtb3VzZVJl bGVhc2VFdmVudChRTW91c2VFdmVudCopOworICAgIHZvaWQgbW91c2VSZWxlYXNlRXZlbnQoUUdy YXBoaWNzU2NlbmVNb3VzZUV2ZW50Kik7CiAjaWZuZGVmIFFUX05PX0NPTlRFWFRNRU5VCiAgICAg dm9pZCBjb250ZXh0TWVudUV2ZW50KFFDb250ZXh0TWVudUV2ZW50Kik7CiAjZW5kaWYKICNpZm5k ZWYgUVRfTk9fV0hFRUxFVkVOVAogICAgIHZvaWQgd2hlZWxFdmVudChRV2hlZWxFdmVudCopOwor ICAgIHZvaWQgd2hlZWxFdmVudChRR3JhcGhpY3NTY2VuZVdoZWVsRXZlbnQqKTsKICNlbmRpZgog ICAgIHZvaWQga2V5UHJlc3NFdmVudChRS2V5RXZlbnQqKTsKICAgICB2b2lkIGtleVJlbGVhc2VF dmVudChRS2V5RXZlbnQqKTsKICAgICB2b2lkIGZvY3VzSW5FdmVudChRRm9jdXNFdmVudCopOwog ICAgIHZvaWQgZm9jdXNPdXRFdmVudChRRm9jdXNFdmVudCopOwogCi0gICAgdm9pZCBkcmFnRW50 ZXJFdmVudChRRHJhZ0VudGVyRXZlbnQgKik7Ci0gICAgdm9pZCBkcmFnTGVhdmVFdmVudChRRHJh Z0xlYXZlRXZlbnQgKik7Ci0gICAgdm9pZCBkcmFnTW92ZUV2ZW50KFFEcmFnTW92ZUV2ZW50ICop OwotICAgIHZvaWQgZHJvcEV2ZW50KFFEcm9wRXZlbnQgKik7CisgICAgdm9pZCBkcmFnRW50ZXJF dmVudChRRHJhZ0VudGVyRXZlbnQqKTsKKyAgICB2b2lkIGRyYWdFbnRlckV2ZW50KFFHcmFwaGlj c1NjZW5lRHJhZ0Ryb3BFdmVudCopOworICAgIHZvaWQgZHJhZ0xlYXZlRXZlbnQoUURyYWdMZWF2 ZUV2ZW50Kik7CisgICAgdm9pZCBkcmFnTGVhdmVFdmVudChRR3JhcGhpY3NTY2VuZURyYWdEcm9w RXZlbnQqKTsKKyAgICB2b2lkIGRyYWdNb3ZlRXZlbnQoUURyYWdNb3ZlRXZlbnQqKTsKKyAgICB2 b2lkIGRyYWdNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdm9p ZCBkcm9wRXZlbnQoUURyb3BFdmVudCopOworICAgIHZvaWQgZHJvcEV2ZW50KFFHcmFwaGljc1Nj ZW5lRHJhZ0Ryb3BFdmVudCopOwogCiAgICAgdm9pZCBpbnB1dE1ldGhvZEV2ZW50KFFJbnB1dE1l dGhvZEV2ZW50Kik7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQv cXQvQ2hhbmdlTG9nCmluZGV4IGI5ZDUyODguLjRkNTQxNTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9x dC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisy MDA5LTA5LTA0ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQg c3VwcG9ydCBmb3IgaGFuZGxpbmcgUUdyYXBoaWNzU2NlbmUgZXZlbnRzLgorCisgICAgICAgIEFk ZCBhIG5ldyBRR3JhcGhpY3NXaWRnZXQgYmFzZWQgdmVyc2lvbiBvZiB0aGUgIlFXZWJWaWV3IiAo cGFydCBJSSkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI4ODYyCisKKyAgICAgICAgKiBBcGkvcXdlYnBhZ2UuY3BwOgorICAgICAgICAoUVdlYlBhZ2VQ cml2YXRlOjptb3VzZU1vdmVFdmVudCk6CisgICAgICAgIChRV2ViUGFnZVByaXZhdGU6Om1vdXNl UHJlc3NFdmVudCk6CisgICAgICAgIChRV2ViUGFnZVByaXZhdGU6Om1vdXNlRG91YmxlQ2xpY2tF dmVudCk6CisgICAgICAgIChRV2ViUGFnZVByaXZhdGU6Om1vdXNlUmVsZWFzZUV2ZW50KToKKyAg ICAgICAgKFFXZWJQYWdlUHJpdmF0ZTo6d2hlZWxFdmVudCk6CisgICAgICAgIChRV2ViUGFnZVBy aXZhdGU6OmRyYWdFbnRlckV2ZW50KToKKyAgICAgICAgKFFXZWJQYWdlUHJpdmF0ZTo6ZHJhZ0xl YXZlRXZlbnQpOgorICAgICAgICAoUVdlYlBhZ2VQcml2YXRlOjpkcmFnTW92ZUV2ZW50KToKKyAg ICAgICAgKFFXZWJQYWdlUHJpdmF0ZTo6ZHJvcEV2ZW50KToKKyAgICAgICAgKFFXZWJQYWdlOjpl dmVudCk6CisgICAgICAgICogQXBpL3F3ZWJwYWdlX3AuaDoKKwogMjAwOS0wOS0wNCAgS2VubmV0 aCBSb2hkZSBDaHJpc3RpYW5zZW4gIDxrZW5uZXRoQHdlYmtpdC5vcmc+LCBBbnRvbmlvIEdvbWVz ICA8YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgotLSAKMS42LjAuNAoK 39156 2009-09-07 10:35:19 -0700 2009-09-07 15:43:54 -0700 patch 1 - v0.2 - add QWebGraphicsItem to the API and QGVLauncher sample application 0001--.-Qt-Add-the-alternative-QtLauncher-based-on.patch text/plain 42558 tonikitoo RnJvbSA2NWIzOTg0ZDZmY2YzY2ZmNzllY2ZmMDNmMzAzMGEwYTgyYTA4ZTY2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBGcmksIDQgU2VwIDIwMDkgMTc6MjA6NDcgLTAzMDAKU3ViamVjdDog W1BBVENIXSAgICAgLjogW1F0XSBBZGQgdGhlIGFsdGVybmF0aXZlIFF0TGF1bmNoZXIgKGJhc2Vk IG9uIFFHcmFwaGljc1ZpZXcpIHRvIHRoZSBidWlsZC4KCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKCiAgICBXZWJLaXQvcXQ6IEFkZCBhIG5ldyBRR3Jh cGhpY3NXaWRnZXQgYmFzZWQgdmVyc2lvbiBvZiB0aGUgIlFXZWJWaWV3IgogICAgdW5kZXIgdGhl IG5hbWUgIlFXZWJHcmFwaGljc0l0ZW0iLgoKICAgIEluY2x1ZGVzIGFuIGFsdGVybmF0aXZlIFF0 IGxhdW5jaGVyIHVzaW5nIHRoZSBRR3JhcGhpY3NWaWV3LgoKICAgIFBhdGNoIGJ5IEtlbm5ldGgg Um9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPiwgQW50b25pbyBHb21lcyA8 YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIEFwaS9oZWFkZXJzLnByaToKICAgICogQXBpL3F3ZWJn cmFwaGljc2l0ZW0uY3BwOiBBZGRlZC4KICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uaDogQWRk ZWQuCiAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaDogQWRkZWQuCiAgICAqIEFwaS9xd2Vi cGFnZS5oOgogICAgKiBRR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdl YktpdC9xdC9RdExhdW5jaGVyL1F0TGF1bmNoZXIucHJvLgogICAgKiBRR1ZMYXVuY2hlci9tYWlu LmNwcDogQWRkZWQuCiAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcDoKICAg IChXZWJDb3JlOjpDaHJvbWVDbGllbnRRdDo6cmVwYWludCk6CiAgICAoV2ViQ29yZTo6Q2hyb21l Q2xpZW50UXQ6OnNjcm9sbCk6CgogICAgV2ViS2l0OiBBZGQgdGhlIFFHVkxhdW5jaGVyIHRoZSBi dWlsZCBzeXN0ZW0uCgogICAgUGF0Y2ggYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4gPGtl bm5ldGhAd2Via2l0Lm9yZz4gb24gMjAwOS0wOS0wNAogICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCgogICAgKiBXZWJLaXQucHJvOgoKICAgIFdlYkNvcmU6IEFkZCB0aGUgcXdlYmdyYXBo aWNzaXRlbS5jcHAgdG8gdGhlIGJ1aWxkIHN5c3RlbS4KCiAgICBQYXRjaCBieSBLZW5uZXRoIFJv aGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3ZWJraXQub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIFdlYkNvcmUucHJvOgotLS0KIENoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA5ICsKIFdlYkNvcmUv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA4ICsKIFdlYkNvcmUvV2Vi Q29yZS5wcm8gICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC5wcm8gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC9BcGkvaGVh ZGVycy5wcmkgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC9BcGkvcXdlYmdy YXBoaWNzaXRlbS5jcHAgICAgICAgICAgfCAgNzE2ICsrKysrKysrKysrKysrKysrKysrKysrKysr KwogV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmggICAgICAgICAgICB8ICAxNDMgKysr KysrCiBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW1fcC5oICAgICAgICAgIHwgICA0MyAr KwogV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwog V2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjIgKwogV2Vi S2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVyLnBybyAgICAgICB8ICAgMTMgKwogV2ViS2l0 L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwICAgICAgICAgICAgICB8ICAzMDAgKysrKysrKysrKysK IFdlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAgfCAgICA5ICstCiAx MyBmaWxlcyBjaGFuZ2VkLCAxMjYzIGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCiBjcmVh dGUgbW9kZSAxMDA2NDQgV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcAogY3JlYXRl IG1vZGUgMTAwNjQ0IFdlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5oCiBjcmVhdGUgbW9k ZSAxMDA2NDQgV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaAogY3JlYXRlIG1vZGUg MTAwNjQ0IFdlYktpdC9xdC9RR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm8KIGNyZWF0ZSBtb2Rl IDEwMDY0NCBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAKCmRpZmYgLS1naXQgYS9DaGFu Z2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggYTUxNTI5Yy4uN2NhNzYzNyAxMDA2NDQKLS0tIGEvQ2hh bmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEyIEBACisyMDA5LTA5LTA0ICBLZW5u ZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KKworICAgICAgICBQ YXRjaCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4s IEFudG9uaW8gR29tZXMgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4gb24gMjAwOS0wOS0w NAorICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIEFk ZCB0aGUgYWx0ZXJuYXRpdmUgUXRMYXVuY2hlciAoYmFzZWQgb24gUUdyYXBoaWNzVmlldykgdG8g dGhlIGJ1aWxkLgorCisgICAgICAgICogV2ViS2l0LnBybzoKKwogMjAwOS0wOS0wNCAgQWxiZXJ0 IEJhY2hhbmQgIDxhbGJlcnRiQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJp YyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IDg5ZmJhMGYuLjFjYTY5MzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9n CisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTEgQEAKKzIwMDktMDktMDQgIEtl bm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCB0aGUgcXdlYmdyYXBo aWNzaXRlbS5jcHAgdG8gdGhlIGJ1aWxkIHN5c3RlbS4KKworICAgICAgICAqIFdlYkNvcmUucHJv OgorCiAyMDA5LTA5LTA0ICBEYXZlIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJv IGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCBlNjA2MzQyLi5jMjFmYzZhIDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTIzNjMs NiArMjM2Myw3IEBAIFNPVVJDRVMgKz0gXAogICAgIC4uL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L1dlYkNvcmVTdXBw b3J0L0luc3BlY3RvckNsaWVudFF0LmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L0FwaS9xd2ViZnJh bWUuY3BwIFwKKyAgICAuLi9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwIFwKICAg ICAuLi9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L0FwaS9x d2Vidmlldy5jcHAgXAogICAgIC4uL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuY3BwIFwKZGlm ZiAtLWdpdCBhL1dlYktpdC5wcm8gYi9XZWJLaXQucHJvCmluZGV4IDBiYTE0ZTQuLjg2NmJiOWIg MTAwNjQ0Ci0tLSBhL1dlYktpdC5wcm8KKysrIGIvV2ViS2l0LnBybwpAQCAtNSw2ICs1LDcgQEAg U1VCRElSUyArPSBcCiAgICAgICAgIFdlYkNvcmUgXAogICAgICAgICBKYXZhU2NyaXB0Q29yZS9q c2MucHJvIFwKICAgICAgICAgV2ViS2l0L3F0L1F0TGF1bmNoZXIgXAorICAgICAgICBXZWJLaXQv cXQvUUdWTGF1bmNoZXIgXAogICAgICAgICBXZWJLaXQvcXQvdGVzdHMKIAogIXdpbjMyOiFzeW1i aWFuIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvaGVhZGVycy5wcmkgYi9XZWJLaXQvcXQv QXBpL2hlYWRlcnMucHJpCmluZGV4IDkyYTEyMGQuLjMwYTM2ZWYgMTAwNjQ0Ci0tLSBhL1dlYktp dC9xdC9BcGkvaGVhZGVycy5wcmkKKysrIGIvV2ViS2l0L3F0L0FwaS9oZWFkZXJzLnByaQpAQCAt MSw0ICsxLDUgQEAKIFdFQktJVF9BUElfSEVBREVSUyA9ICQkUFdEL3F3ZWJmcmFtZS5oIFwKKyAg ICAgICAgICAgICAgICAgICAgICQkUFdEL3F3ZWJncmFwaGljc2l0ZW0uaCBcCiAgICAgICAgICAg ICAgICAgICAgICAkJFBXRC9xd2Via2l0Z2xvYmFsLmggXAogICAgICAgICAgICAgICAgICAgICAg JCRQV0QvcXdlYnBhZ2UuaCBcCiAgICAgICAgICAgICAgICAgICAgICAkJFBXRC9xd2Vidmlldy5o IFwKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAgYi9XZWJL aXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjVhZGVlY2EKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJn cmFwaGljc2l0ZW0uY3BwCkBAIC0wLDAgKzEsNzE2IEBACisvKgorICAgIENvcHlyaWdodCAoQykg MjAwOSBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKworICAg IFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh bmQvb3IKKyAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAgIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgICBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwor ICAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVl dCwgRmlmdGggRmxvb3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAicXdlYmdyYXBoaWNzaXRlbS5oIgorCisjaW5j bHVkZSAicXdlYmZyYW1lLmgiCisjaW5jbHVkZSAicXdlYmdyYXBoaWNzaXRlbV9wLmgiCisjaW5j bHVkZSAicXdlYnBhZ2UuaCIKKyNpbmNsdWRlICJxd2VicGFnZV9wLmgiCisjaW5jbHVkZSA8UXQv cXN0eWxlb3B0aW9uLmg+CisjaW5jbHVkZSA8UXRHdWkvcWFwcGxpY2F0aW9uLmg+CisjaW5jbHVk ZSA8UXRHdWkvcWdyYXBoaWNzc2NlbmVldmVudC5oPgorI2luY2x1ZGUgPFFHcmFwaGljc1NjZW5l PgorI2luY2x1ZGUgPFFHcmFwaGljc1ZpZXc+CisKKy8qIQorICAgIFxicmllZiBRV2ViR3JhaGlj c0l0ZW0gYWxsb3dzIHdlYiBjb250ZW50IHRvIGJlIGFkZGVkIHRvIGEgY2FudmFzLgorICAgIFxp bmhlcml0cyBRR3JhcGhpY3NXaWRnZXQuCisgICAgXHNpbmNlIDQuNgorCisgICAgQSBXZWJHcmFw aGljc0l0ZW0gcmVuZGVycyB3ZWIgY29udGVudCBiYXNlZCBvbiBhIFVSTCBvciBzZXQgZGF0YS4K KworICAgIElmIHRoZSB3aWR0aCBhbmQgaGVpZ2h0IG9mIHRoZSBpdGVtIGlzIG5vdCBzZXQsIHRo ZXkgd2lsbAorICAgIGR5bmFtaWNhbGx5IGFkanVzdCB0byBhIHNpemUgYXBwcm9wcmlhdGUgZm9y IHRoZSBjb250ZW50LgorICAgIFRoaXMgd2lkdGggbWF5IGJlIGxhcmdlIChlZy4gOTgwKSBmb3Ig dHlwaWNhbCBvbmxpbmUgd2ViIHBhZ2VzLgorKi8KKworLyohCisgICAgQ29uc3RydWN0cyBhbiBl bXB0eSBRV2ViR3JhcGhpY3NJdGVtIHdpdGggcGFyZW50IFxhIHBhcmVudC8KKworICAgIFxzYSBs b2FkKCkKKyovCitRV2ViR3JhcGhpY3NJdGVtOjpRV2ViR3JhcGhpY3NJdGVtKFFHcmFwaGljc0l0 ZW0qIHBhcmVudCkKKyAgICA6IFFHcmFwaGljc1dpZGdldChwYXJlbnQpCisgICAgLCBkKG5ldyBR V2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSh0aGlzKSkKK3sKKyAgICBzZXRGbGFnKFFHcmFwaGljc0l0 ZW06Okl0ZW1Vc2VzRXh0ZW5kZWRTdHlsZU9wdGlvbiwgdHJ1ZSk7CisgICAgc2V0QWNjZXB0SG92 ZXJFdmVudHModHJ1ZSk7CisgICAgc2V0Rm9jdXNQb2xpY3koUXQ6OlN0cm9uZ0ZvY3VzKTsKK30K KworLyohCisgICAgRGVzdHJveXMgdGhlIHdlYiBncmFwaGljc2l0ZW0uCisqLworUVdlYkdyYXBo aWNzSXRlbTo6flFXZWJHcmFwaGljc0l0ZW0oKQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAg ICBkLT5wYWdlLT5kLT52aWV3ID0gMDsKKworICAgIGlmIChkLT5wYWdlICYmIGQtPnBhZ2UtPnBh cmVudCgpID09IHRoaXMpCisgICAgICAgIGRlbGV0ZSBkLT5wYWdlOworCisgICAgZGVsZXRlIGQ7 Cit9CisKKy8qIQorICAgIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSB1bmRlcmx5aW5nIHdlYiBw YWdlLgorCisgICAgXHNhIHNldFBhZ2UoKQorKi8KK1FXZWJQYWdlKiBRV2ViR3JhcGhpY3NJdGVt OjpwYWdlKCkgY29uc3QKK3sKKyAgICBpZiAoIWQtPnBhZ2UpIHsKKyAgICAgICAgUVdlYkdyYXBo aWNzSXRlbSogdGhhdCA9IGNvbnN0X2Nhc3Q8UVdlYkdyYXBoaWNzSXRlbSo+KHRoaXMpOworICAg ICAgICBRV2ViUGFnZSogcGFnZSA9IG5ldyBRV2ViUGFnZSh0aGF0KTsKKworICAgICAgICAvLyBE ZWZhdWx0IHRvIG5vdCBoYXZpbmcgYSBiYWNrZ3JvdW5kLCBpbiB0aGUgY2FzZQorICAgICAgICAv LyB0aGUgcGFnZSBkb2Vzbid0IHByb3ZpZGUgb25lLgorICAgICAgICBRUGFsZXR0ZSBwYWxldHRl ID0gUUFwcGxpY2F0aW9uOjpwYWxldHRlKCk7CisgICAgICAgIHBhbGV0dGUuc2V0QnJ1c2goUVBh bGV0dGU6OkJhc2UsIFFDb2xvcjo6ZnJvbVJnYkYoMCwgMCwgMCwgMCkpOworICAgICAgICBwYWdl LT5zZXRQYWxldHRlKHBhbGV0dGUpOworCisgICAgICAgIHRoYXQtPnNldFBhZ2UocGFnZSk7Cisg ICAgfQorCisgICAgcmV0dXJuIGQtPnBhZ2U7Cit9CisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbVBy aXZhdGU6Ol9xX2RvTG9hZFByb2dyZXNzKGludCBwcm9ncmVzcykKK3sKKyAgICBpZiAodGhpcy0+ cHJvZ3Jlc3MgPT0gcHJvZ3Jlc3MgLyAxMDAuMCkKKyAgICAgICAgcmV0dXJuOworCisgICAgdGhp cy0+cHJvZ3Jlc3MgPSBwcm9ncmVzcyAvIDEwMC4wOworCisgICAgZW1pdCBxLT5wcm9ncmVzc0No YW5nZWQodGhpcy0+cHJvZ3Jlc3MpOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRl OjpfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3MpCit7CisgICAgLy8gSWYgdGhlIHBhZ2Ug aGFkIG5vIHRpdGxlLCBzdGlsbCBtYWtlIHN1cmUgaXQgZ2V0cyB0aGUgc2lnbmFsCisgICAgaWYg KHEtPnRpdGxlKCkuaXNFbXB0eSgpKQorICAgICAgICBlbWl0IHEtPnVybENoYW5nZWQocS0+dXJs KCkpOworCisgICAgaWYgKHN1Y2Nlc3MpCisgICAgICAgIGVtaXQgcS0+bG9hZEZpbmlzaGVkKCk7 CisgICAgZWxzZQorICAgICAgICBlbWl0IHEtPmxvYWRGYWlsZWQoKTsKK30KKwordm9pZCBRV2Vi R3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9TY3JvbGwoaW50IGR4LCBpbnQgZHksIGNvbnN0IFFS ZWN0JiByZWN0VG9TY3JvbGwpCit7CisgICAgcS0+c2Nyb2xsKHFyZWFsKGR4KSwgcXJlYWwoZHkp LCBRUmVjdEYocmVjdFRvU2Nyb2xsKSk7Cit9CisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbVByaXZh dGU6Ol9xX2RvVXBkYXRlKGNvbnN0IFFSZWN0ICYgZGlydHlSZWN0KQoreworICAgIHEtPnVwZGF0 ZShRUmVjdEYoZGlydHlSZWN0KSk7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFw aGljc0l0ZW06OnBhaW50KFFQYWludGVyKiBwYWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFw aGljc0l0ZW0qIG9wdGlvbiwgUVdpZGdldCopCit7CisgICAgZC0+cGFnZS0+bWFpbkZyYW1lKCkt PnJlbmRlcihwYWludGVyLCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvUmVjdCgpKTsKK30KKworLyoh CisgICAgTWFrZXMgXGEgcGFnZSB0aGUgbmV3IHdlYiBwYWdlIG9mIHRoZSB3ZWIgZ3JhcGhpY3Np dGVtLgorCisgICAgVGhlIHBhcmVudCBRT2JqZWN0IG9mIHRoZSBwcm92aWRlZCBwYWdlIHJlbWFp bnMgdGhlIG93bmVyCisgICAgb2YgdGhlIG9iamVjdC4gSWYgdGhlIGN1cnJlbnQgZG9jdW1lbnQg aXMgYSBjaGlsZCBvZiB0aGUgd2ViCisgICAgdmlldywgaXQgd2lsbCBiZSBkZWxldGVkLgorCisg ICAgXHNhIHBhZ2UoKQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0UGFnZShRV2ViUGFn ZSogcGFnZSkKK3sKKyAgICBpZiAoZC0+cGFnZSA9PSBwYWdlKQorICAgICAgICByZXR1cm47CisK KyAgICBpZiAoZC0+cGFnZSkgeworICAgICAgICBpZiAoZC0+cGFnZS0+cGFyZW50KCkgPT0gdGhp cykKKyAgICAgICAgICAgIGRlbGV0ZSBkLT5wYWdlOworICAgICAgICBlbHNlCisgICAgICAgICAg ICBkLT5wYWdlLT5kaXNjb25uZWN0KHRoaXMpOworICAgIH0KKworICAgIGQtPnBhZ2UgPSBwYWdl OworICAgIGlmICghZC0+cGFnZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUVNpemUgc2l6ZSA9 IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgpOworICAgIHBhZ2UtPnNldFZpZXdwb3J0U2l6ZShz aXplKTsKKworICAgIFFXZWJGcmFtZSogbWFpbkZyYW1lID0gZC0+cGFnZS0+bWFpbkZyYW1lKCk7 CisKKyAgICBjb25uZWN0KG1haW5GcmFtZSwgU0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3Ry aW5nJikpLAorICAgICAgICAgICAgdGhpcywgU0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3Ry aW5nJikpKTsKKyAgICBjb25uZWN0KG1haW5GcmFtZSwgU0lHTkFMKGljb25DaGFuZ2VkKCkpLAor ICAgICAgICAgICAgdGhpcywgU0lHTkFMKGljb25DaGFuZ2VkKCkpKTsKKyAgICBjb25uZWN0KG1h aW5GcmFtZSwgU0lHTkFMKHVybENoYW5nZWQoY29uc3QgUVVybCYpKSwKKyAgICAgICAgICAgIHRo aXMsIFNJR05BTCh1cmxDaGFuZ2VkKGNvbnN0IFFVcmwmKSkpOworICAgIGNvbm5lY3QoZC0+cGFn ZSwgU0lHTkFMKGxvYWRTdGFydGVkKCkpLAorICAgICAgICAgICAgdGhpcywgU0lHTkFMKGxvYWRT dGFydGVkKCkpKTsKKyAgICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChsb2FkUHJvZ3Jlc3MoaW50 KSksCisgICAgICAgICAgICB0aGlzLCBTTE9UKF9xX2RvTG9hZFByb2dyZXNzKGludCkpKTsKKyAg ICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChsb2FkRmluaXNoZWQoYm9vbCkpLAorICAgICAgICAg ICAgdGhpcywgU0xPVChfcV9kb0xvYWRGaW5pc2hlZChib29sKSkpOworICAgIGNvbm5lY3QoZC0+ cGFnZSwgU0lHTkFMKHJlcGFpbnRSZXF1ZXN0ZWQoUVJlY3QpKSwKKyAgICAgICAgICAgIHRoaXMs IFNMT1QoX3FfZG9VcGRhdGUoY29uc3QgUVJlY3QmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwg U0lHTkFMKHNjcm9sbFJlcXVlc3RlZChpbnQsIGludCwgY29uc3QgUVJlY3QmKSksCisgICAgICAg ICAgICB0aGlzLCBTTE9UKF9xX2RvU2Nyb2xsKGludCwgaW50LCBjb25zdCBRUmVjdCYpKSk7Cisg ICAgY29ubmVjdChkLT5wYWdlLCBTSUdOQUwoc3RhdHVzQmFyTWVzc2FnZShjb25zdCBRU3RyaW5n JikpLAorICAgICAgICAgICAgdGhpcywgU0xPVChfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0 IFFTdHJpbmcmKSkpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6 dXJsCisgICAgXGJyaWVmIHRoZSB1cmwgb2YgdGhlIHdlYiBwYWdlIGN1cnJlbnRseSB2aWV3ZWQK KworICAgIFNldHRpbmcgdGhpcyBwcm9wZXJ0eSBjbGVhcnMgdGhlIHZpZXcgYW5kIGxvYWRzIHRo ZSBVUkwuCisKKyAgICBCeSBkZWZhdWx0LCB0aGlzIHByb3BlcnR5IGNvbnRhaW5zIGFuIGVtcHR5 LCBpbnZhbGlkIFVSTC4KKworICAgIFxzYSBsb2FkKCksIHVybENoYW5nZWQoKQorKi8KKwordm9p ZCBRV2ViR3JhcGhpY3NJdGVtOjpzZXRVcmwoY29uc3QgUVVybCAmdXJsKQoreworICAgIGlmICgh ZC0+cGFnZSB8fCBkLT5wYWdlLT5tYWluRnJhbWUoKS0+dXJsKCkgPT0gdXJsKQorICAgICAgICBy ZXR1cm47CisKKyAgICBkLT5wYWdlLT5tYWluRnJhbWUoKS0+c2V0VXJsKHVybCk7Cit9CisKK1FV cmwgUVdlYkdyYXBoaWNzSXRlbTo6dXJsKCkgY29uc3QKK3sKKyAgICBpZiAoZC0+cGFnZSkKKyAg ICAgICAgcmV0dXJuIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT51cmwoKTsKKworICAgIHJldHVybiBR VXJsKCk7Cit9CisKKy8qIQorICAgIFxwcm9wZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjp0aXRsZQor ICAgIFxicmllZiB0aGUgdGl0bGUgb2YgdGhlIHdlYiBwYWdlIGN1cnJlbnRseSB2aWV3ZWQKKwor ICAgIEJ5IGRlZmF1bHQsIHRoaXMgcHJvcGVydHkgY29udGFpbnMgYW4gZW1wdHkgc3RyaW5nLgor CisgICAgXHNhIHRpdGxlQ2hhbmdlZCgpCisqLworUVN0cmluZyBRV2ViR3JhcGhpY3NJdGVtOjp0 aXRsZSgpIGNvbnN0Cit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIHJldHVybiBkLT5wYWdl LT5tYWluRnJhbWUoKS0+dGl0bGUoKTsKKworICAgIHJldHVybiBRU3RyaW5nKCk7Cit9CisKKy8q IQorICAgIFxwcm9wZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjppY29uCisgICAgXGJyaWVmIHRoZSBp Y29uIGFzc29jaWF0ZWQgd2l0aCB0aGUgd2ViIHBhZ2UgY3VycmVudGx5IHZpZXdlZAorCisgICAg QnkgZGVmYXVsdCwgdGhpcyBwcm9wZXJ0eSBjb250YWlucyBhIG51bGwgaWNvbi4KKworICAgIFxz YSBpY29uQ2hhbmdlZCgpLCBRV2ViU2V0dGluZ3M6Omljb25Gb3JVcmwoKQorKi8KK1FJY29uIFFX ZWJHcmFwaGljc0l0ZW06Omljb24oKSBjb25zdAoreworICAgIHJldHVybiBkLT5wYWdlLT5tYWlu RnJhbWUoKS0+aWNvbigpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRl bTo6em9vbUZhY3RvcgorICAgIFxzaW5jZSA0LjUKKyAgICBcYnJpZWYgdGhlIHpvb20gZmFjdG9y IGZvciB0aGUgdmlldworKi8KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpzZXRab29tRmFjdG9y KHFyZWFsIGZhY3RvcikKK3sKKyAgICBpZiAoZmFjdG9yID09IGQtPnBhZ2UtPm1haW5GcmFtZSgp LT56b29tRmFjdG9yKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGQtPnBhZ2UtPm1haW5GcmFt ZSgpLT5zZXRab29tRmFjdG9yKGZhY3Rvcik7CisKKyAgICBlbWl0IHpvb21GYWN0b3JDaGFuZ2Vk KCk7Cit9CisKK3FyZWFsIFFXZWJHcmFwaGljc0l0ZW06Onpvb21GYWN0b3IoKSBjb25zdAorewor ICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJhbWUoKS0+em9vbUZhY3RvcigpOworfQorCit2b2lk IFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFT dHJpbmcmIHMpCit7CisgICAgc3RhdHVzQmFyTWVzc2FnZSA9IHM7CisgICAgcS0+ZW1pdCBzdGF0 dXNDaGFuZ2VkKCk7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06 OnVwZGF0ZUdlb21ldHJ5KCkKK3sKKyAgICBRR3JhcGhpY3NXaWRnZXQ6OnVwZGF0ZUdlb21ldHJ5 KCk7CisgICAgUVNpemUgc2l6ZSA9IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgpOworICAgIGQt PnBhZ2UtPnNldFZpZXdwb3J0U2l6ZShzaXplKTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQg UVdlYkdyYXBoaWNzSXRlbTo6c2V0R2VvbWV0cnkoY29uc3QgUVJlY3RGJiByZWN0KQoreworICAg IFFHcmFwaGljc1dpZGdldDo6c2V0R2VvbWV0cnkocmVjdCk7CisgICAgLy8gTk9URTogY2FsbCBn ZW9tZXRyeSgpIGFzIHNldEdlb21ldHJ5IGVuc3VyZXMgdGhhdAorICAgIC8vIHRoZSBnZW9tZXRy eSBpcyB3aXRoaW4gbGVnYWwgYm91bmRzIChtaW5pbXVtU2l6ZSwgbWF4aW11bVNpemUpCisgICAg UVNpemUgc2l6ZSA9IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgpOworICAgIGQtPnBhZ2UtPnNl dFZpZXdwb3J0U2l6ZShzaXplKTsKK30KKworLyohCisgICAgXGJyaWVmIFRoZSBsb2FkIHN0YXR1 cyBtZXNzYWdlIGFzc29jaWF0ZWQgdG8gdGhlIHdlYiBncmFwaGljc2l0ZW0KKworICAgIFByb3Zp ZGVzIHRoZSBsYXRlc3Qgc3RhdHVzIG1lc3NhZ2Ugc2V0IGR1cmluZyB0aGUgbG9hZCBvZiBhIFVS TC4KKyAgICBDb21tb25seSBzaG93biBieSBTdGF0dXMgQmFyIHdpZGdldHMuCisKKyAgICBcc2Eg c3RhdHVzQ2hhbmdlZCgpCisqLworCitRU3RyaW5nIFFXZWJHcmFwaGljc0l0ZW06OnN0YXR1cygp IGNvbnN0Cit7CisgICAgcmV0dXJuIGQtPnN0YXR1c0Jhck1lc3NhZ2U7Cit9CisKKy8qIQorICAg IENvbnZlbmllbmNlIHNsb3QgdGhhdCBzdG9wcyBsb2FkaW5nIHRoZSBkb2N1bWVudC4KKworICAg IFxzYSByZWxvYWQoKSwgcGFnZUFjdGlvbigpLCBsb2FkRmluaXNoZWQoKQorKi8KK3ZvaWQgUVdl YkdyYXBoaWNzSXRlbTo6c3RvcCgpCit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIGQtPnBh Z2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBhZ2U6OlN0b3ApOworfQorCisvKiEKKyAgICBDb252ZW5p ZW5jZSBzbG90IHRoYXQgbG9hZHMgdGhlIHByZXZpb3VzIGRvY3VtZW50IGluIHRoZSBsaXN0IG9m IGRvY3VtZW50cworICAgIGJ1aWx0IGJ5IG5hdmlnYXRpbmcgbGlua3MuIERvZXMgbm90aGluZyBp ZiB0aGVyZSBpcyBubyBwcmV2aW91cyBkb2N1bWVudC4KKworICAgIFxzYSBmb3J3YXJkKCksIHBh Z2VBY3Rpb24oKQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6YmFjaygpCit7CisgICAgaWYg KGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBhZ2U6OkJhY2sp OworfQorCisvKiEKKyAgICBDb252ZW5pZW5jZSBzbG90IHRoYXQgbG9hZHMgdGhlIG5leHQgZG9j dW1lbnQgaW4gdGhlIGxpc3Qgb2YgZG9jdW1lbnRzCisgICAgYnVpbHQgYnkgbmF2aWdhdGluZyBs aW5rcy4gRG9lcyBub3RoaW5nIGlmIHRoZXJlIGlzIG5vIG5leHQgZG9jdW1lbnQuCisKKyAgICBc c2EgYmFjaygpLCBwYWdlQWN0aW9uKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmZvcndh cmQoKQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT50cmlnZ2VyQWN0aW9u KFFXZWJQYWdlOjpGb3J3YXJkKTsKK30KKworLyohCisgICAgUmVsb2FkcyB0aGUgY3VycmVudCBk b2N1bWVudC4KKworICAgIFxzYSBzdG9wKCksIHBhZ2VBY3Rpb24oKSwgbG9hZFN0YXJ0ZWQoKQor Ki8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6cmVsb2FkKCkKK3sKKyAgICBpZiAoZC0+cGFnZSkK KyAgICAgICAgZC0+cGFnZS0+dHJpZ2dlckFjdGlvbihRV2ViUGFnZTo6UmVsb2FkKTsKK30KKwor LyohCisgICAgXHByb3BlcnR5IFFXZWJHcmFwaGljc0l0ZW06OnByb2dyZXNzCisgICAgXGJyaWVm IHRoZSBwcm9ncmVzcyBvZiBsb2FkaW5nIHRoZSBjdXJyZW50IFVSTCwgZnJvbSAwIHRvIDEuCisq LworcXJlYWwgUVdlYkdyYXBoaWNzSXRlbTo6cHJvZ3Jlc3MoKSBjb25zdAoreworICAgIHJldHVy biBkLT5wcm9ncmVzczsKK30KKworLyohCisgICAgTG9hZHMgdGhlIHNwZWNpZmllZCBcYSB1cmwg YW5kIGRpc3BsYXlzIGl0LgorCisgICAgXG5vdGUgVGhlIHZpZXcgcmVtYWlucyB0aGUgc2FtZSB1 bnRpbCBlbm91Z2ggZGF0YSBoYXMgYXJyaXZlZCB0byBkaXNwbGF5IHRoZSBuZXcgXGEgdXJsLgor CisgICAgXHNhIHNldFVybCgpLCB1cmwoKSwgdXJsQ2hhbmdlZCgpCisqLwordm9pZCBRV2ViR3Jh cGhpY3NJdGVtOjpsb2FkKGNvbnN0IFFVcmwmIHVybCkKK3sKKyAgICBkLT5wYWdlLT5tYWluRnJh bWUoKS0+bG9hZCh1cmwpOworfQorCisvKiEKKyAgICBcZm4gdm9pZCBRV2ViR3JhcGhpY3NJdGVt Ojpsb2FkKGNvbnN0IFFOZXR3b3JrUmVxdWVzdCAmcmVxdWVzdCwgUU5ldHdvcmtBY2Nlc3NNYW5h Z2VyOjpPcGVyYXRpb24gb3BlcmF0aW9uLCBjb25zdCBRQnl0ZUFycmF5ICZib2R5KQorCisgICAg TG9hZHMgYSBuZXR3b3JrIHJlcXVlc3QsIFxhIHJlcXVlc3QsIHVzaW5nIHRoZSBtZXRob2Qgc3Bl Y2lmaWVkIGluIFxhIG9wZXJhdGlvbi4KKworICAgIFxhIGJvZHkgaXMgb3B0aW9uYWwgYW5kIGlz IG9ubHkgdXNlZCBmb3IgUE9TVCBvcGVyYXRpb25zLgorCisgICAgXG5vdGUgVGhlIHZpZXcgcmVt YWlucyB0aGUgc2FtZSB1bnRpbCBlbm91Z2ggZGF0YSBoYXMgYXJyaXZlZCB0byBkaXNwbGF5IHRo ZSBuZXcgdXJsLgorCisgICAgXHNhIHVybCgpLCB1cmxDaGFuZ2VkKCkKKyovCisKK3ZvaWQgUVdl YkdyYXBoaWNzSXRlbTo6bG9hZChjb25zdCBRTmV0d29ya1JlcXVlc3QmIHJlcXVlc3QsCisgICAg ICAgICAgICAgICAgICAgIFFOZXR3b3JrQWNjZXNzTWFuYWdlcjo6T3BlcmF0aW9uIG9wZXJhdGlv biwKKyAgICAgICAgICAgICAgICAgICAgY29uc3QgUUJ5dGVBcnJheSYgYm9keSkKK3sKKyAgICBk LT5wYWdlLT5tYWluRnJhbWUoKS0+bG9hZChyZXF1ZXN0LCBvcGVyYXRpb24sIGJvZHkpOworfQor CisvKiEKKyAgICBTZXRzIHRoZSBjb250ZW50IG9mIHRoZSB3ZWIgZ3JhcGhpY3NpdGVtIHRvIHRo ZSBzcGVjaWZpZWQgXGEgaHRtbC4KKworICAgIEV4dGVybmFsIG9iamVjdHMgc3VjaCBhcyBzdHls ZXNoZWV0cyBvciBpbWFnZXMgcmVmZXJlbmNlZCBpbiB0aGUgSFRNTAorICAgIGRvY3VtZW50IGFy ZSBsb2NhdGVkIHJlbGF0aXZlIHRvIFxhIGJhc2VVcmwuCisKKyAgICBUaGUgXGEgaHRtbCBpcyBs b2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25v dXNseS4KKworICAgIFdoZW4gdXNpbmcgdGhpcyBtZXRob2QsIFdlYktpdCBhc3N1bWVzIHRoYXQg ZXh0ZXJuYWwgcmVzb3VyY2VzIHN1Y2ggYXMKKyAgICBKYXZhU2NyaXB0IHByb2dyYW1zIG9yIHN0 eWxlIHNoZWV0cyBhcmUgZW5jb2RlZCBpbiBVVEYtOCB1bmxlc3Mgb3RoZXJ3aXNlCisgICAgc3Bl Y2lmaWVkLiBGb3IgZXhhbXBsZSwgdGhlIGVuY29kaW5nIG9mIGFuIGV4dGVybmFsIHNjcmlwdCBj YW4gYmUgc3BlY2lmaWVkCisgICAgdGhyb3VnaCB0aGUgY2hhcnNldCBhdHRyaWJ1dGUgb2YgdGhl IEhUTUwgc2NyaXB0IHRhZy4gQWx0ZXJuYXRpdmVseSwgdGhlCisgICAgZW5jb2RpbmcgY2FuIGFs c28gYmUgc3BlY2lmaWVkIGJ5IHRoZSB3ZWIgc2VydmVyLgorCisgICAgXHNhIGxvYWQoKSwgc2V0 Q29udGVudCgpLCBRV2ViRnJhbWU6OnRvSHRtbCgpCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVt OjpzZXRIdG1sKGNvbnN0IFFTdHJpbmcmIGh0bWwsIGNvbnN0IFFVcmwmIGJhc2VVcmwpCit7Cisg ICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPnNldEh0bWwoaHRtbCwgYmFzZVVybCk7Cit9CisKK1FT dHJpbmcgUVdlYkdyYXBoaWNzSXRlbTo6dG9IdG1sKCkgY29uc3QKK3sKKyAgICByZXR1cm4gZC0+ cGFnZS0+bWFpbkZyYW1lKCktPnRvSHRtbCgpOworfQorCisvKiEKKyAgICBTZXRzIHRoZSBjb250 ZW50IG9mIHRoZSB3ZWIgZ3JhcGhpY3NpdGVtIHRvIHRoZSBzcGVjaWZpZWQgY29udGVudCBcYSBk YXRhLiBJZiB0aGUgXGEgbWltZVR5cGUgYXJndW1lbnQKKyAgICBpcyBlbXB0eSBpdCBpcyBjdXJy ZW50bHkgYXNzdW1lZCB0aGF0IHRoZSBjb250ZW50IGlzIEhUTUwgYnV0IGluIGZ1dHVyZSB2ZXJz aW9ucyB3ZSBtYXkgaW50cm9kdWNlCisgICAgYXV0by1kZXRlY3Rpb24uCisKKyAgICBFeHRlcm5h bCBvYmplY3RzIHJlZmVyZW5jZWQgaW4gdGhlIGNvbnRlbnQgYXJlIGxvY2F0ZWQgcmVsYXRpdmUg dG8gXGEgYmFzZVVybC4KKworICAgIFRoZSBcYSBkYXRhIGlzIGxvYWRlZCBpbW1lZGlhdGVseTsg ZXh0ZXJuYWwgb2JqZWN0cyBhcmUgbG9hZGVkIGFzeW5jaHJvbm91c2x5LgorCisgICAgXHNhIGxv YWQoKSwgc2V0SHRtbCgpLCBRV2ViRnJhbWU6OnRvSHRtbCgpCisqLwordm9pZCBRV2ViR3JhcGhp Y3NJdGVtOjpzZXRDb250ZW50KGNvbnN0IFFCeXRlQXJyYXkmIGRhdGEsIGNvbnN0IFFTdHJpbmcm IG1pbWVUeXBlLCBjb25zdCBRVXJsJiBiYXNlVXJsKQoreworICAgIGQtPnBhZ2UtPm1haW5GcmFt ZSgpLT5zZXRDb250ZW50KGRhdGEsIG1pbWVUeXBlLCBiYXNlVXJsKTsKK30KKworLyohCisgICAg UmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIHZpZXcncyBoaXN0b3J5IG9mIG5hdmlnYXRlZCB3ZWIg cGFnZXMuCisKKyAgICBJdCBpcyBlcXVpdmFsZW50IHRvCisKKyAgICBcc25pcHBldCB3ZWJraXRz bmlwcGV0cy9xdHdlYmtpdF9xd2Vidmlld19zbmlwcGV0LmNwcCAwCisqLworUVdlYkhpc3Rvcnkq IFFXZWJHcmFwaGljc0l0ZW06Omhpc3RvcnkoKSBjb25zdAoreworICAgIHJldHVybiBkLT5wYWdl LT5oaXN0b3J5KCk7Cit9CisKKy8qIQorICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6aW50 ZXJhY3RpdmUKKyAgXGJyaWVmIGNvbnRyb2xzIHdoZXRoZXIgdGhlIGl0ZW0gcmVzcG9uZHMgdG8g bW91c2UgYW5kIGtleSBldmVudHMuCisqLworCitib29sIFFXZWJHcmFwaGljc0l0ZW06OmludGVy YWN0aXZlKCkgY29uc3QKK3sKKyAgICByZXR1cm4gZC0+aW50ZXJhY3RpdmU7Cit9CisKK3ZvaWQg UVdlYkdyYXBoaWNzSXRlbTo6c2V0SW50ZXJhY3RpdmUoYm9vbCBhbGxvd2VkKQoreworICAgIGlm IChkLT5pbnRlcmFjdGl2ZSA9PSBhbGxvd2VkKQorICAgICAgICByZXR1cm47CisKKyAgICBkLT5p bnRlcmFjdGl2ZSA9IGFsbG93ZWQ7CisgICAgZW1pdCBpbnRlcmFjdGl2ZUNoYW5nZWQoKTsKK30K KworLyohCisgICAgUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIHZpZXcvcGFnZSBzcGVjaWZpYyBz ZXR0aW5ncyBvYmplY3QuCisKKyAgICBJdCBpcyBlcXVpdmFsZW50IHRvCisKKyAgICBcc25pcHBl dCB3ZWJraXRzbmlwcGV0cy9xdHdlYmtpdF9xd2Vidmlld19zbmlwcGV0LmNwcCAxCisKKyAgICBc c2EgUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpCisqLworUVdlYlNldHRpbmdzKiBRV2Vi R3JhcGhpY3NJdGVtOjpzZXR0aW5ncygpIGNvbnN0Cit7CisgICAgcmV0dXJuIGQtPnBhZ2UtPnNl dHRpbmdzKCk7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06Omhv dmVyTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJFdmVudCogZXYpCit7CisgICAgaWYgKGQt PmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9 IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIFFNb3VzZUV2ZW50IG1lID0gUU1vdXNlRXZlbnQo UUV2ZW50OjpNb3VzZU1vdmUsCisgICAgICAgICAgICAgICAgZXYtPnBvcygpLnRvUG9pbnQoKSwg UXQ6Ok5vQnV0dG9uLAorICAgICAgICAgICAgICAgIFF0OjpOb0J1dHRvbiwgUXQ6Ok5vTW9kaWZp ZXIpOworICAgICAgICBkLT5wYWdlLT5zZXRWaWV3KGV2LT53aWRnZXQoKSk7CisgICAgICAgIGQt PnBhZ2UtPmV2ZW50KCZtZSk7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7Cisg ICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVt Ojpob3Zlck1vdmVFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFw aGljc0l0ZW06OmhvdmVyTGVhdmVFdmVudChRR3JhcGhpY3NTY2VuZUhvdmVyRXZlbnQqIGV2KQor eworICAgIFFfVU5VU0VEKGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBo aWNzSXRlbTo6bW91c2VNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3VzZUV2ZW50KiBldikKK3sK KyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29s IGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYp OworICAgICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICgh ZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6bW91c2VNb3ZlRXZlbnQo ZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjptb3VzZVBy ZXNzRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3VzZUV2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+aW50 ZXJhY3RpdmUgJiYgZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYt PmlzQWNjZXB0ZWQoKTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+ c2V0QWNjZXB0ZWQoYWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQo KSkKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6bW91c2VQcmVzc0V2ZW50KGV2KTsKK30KKworLyoh IFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6bW91c2VSZWxlYXNlRXZlbnQoUUdy YXBoaWNzU2NlbmVNb3VzZUV2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYg ZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQo KTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+c2V0QWNjZXB0ZWQo YWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAg UUdyYXBoaWNzSXRlbTo6bW91c2VSZWxlYXNlRXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1wCisq Lwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjptb3VzZURvdWJsZUNsaWNrRXZlbnQoUUdyYXBoaWNz U2NlbmVNb3VzZUV2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFn ZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAg ICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0 ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBo aWNzSXRlbTo6bW91c2VEb3VibGVDbGlja0V2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8K K3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6a2V5UHJlc3NFdmVudChRS2V5RXZlbnQqIGV2KQorewor ICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5ldmVu dChldik7CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0 ZW06OmtleVByZXNzRXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3Jh cGhpY3NJdGVtOjprZXlSZWxlYXNlRXZlbnQoUUtleUV2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+ aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworCisg ICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjprZXlSZWxl YXNlRXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVt Ojpmb2N1c0luRXZlbnQoUUZvY3VzRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5wYWdlKQorICAg ICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgZWxzZQorICAgICAgICBRR3JhcGhpY3NJdGVt Ojpmb2N1c0luRXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhp Y3NJdGVtOjpmb2N1c091dEV2ZW50KFFGb2N1c0V2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+cGFn ZSkKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgIGVsc2UKKyAgICAgICAgUUdyYXBo aWNzSXRlbTo6Zm9jdXNPdXRFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCitib29sIFFX ZWJHcmFwaGljc0l0ZW06OmZvY3VzTmV4dFByZXZDaGlsZChib29sIG5leHQpCit7CisgICAgaWYg KGQtPnBhZ2UpCisgICAgICAgIHJldHVybiBkLT5wYWdlLT5mb2N1c05leHRQcmV2Q2hpbGQobmV4 dCk7CisKKyAgICByZXR1cm4gUUdyYXBoaWNzV2lkZ2V0Ojpmb2N1c05leHRQcmV2Q2hpbGQobmV4 dCk7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmRyYWdFbnRl ckV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCogZXYpCit7CisjaWZuZGVmIFFUX05P X0RSQUdBTkREUk9QCisgICAgLy9pZiAoZC0+cGFnZSkKKyAgICAvLyAgICBkLT5wYWdlLT5ldmVu dChldik7CisgICAgLy9KdXN0IHJlbW92ZSB0aGlzIGxpbmUgYmVsb3cgd2hlbiB0aGUgY29kZSBh Ym92ZSBpcyB3b3JraW5nCisgICAgUV9VTlVTRUQoZXYpOworI2Vsc2UKKyAgICBRX1VOVVNFRChl dik7CisjZW5kaWYKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6 ZHJhZ0xlYXZlRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyNpZm5k ZWYgUVRfTk9fRFJBR0FORERST1AKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkg eworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAgICAg ICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0ZWQp OworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNz V2lkZ2V0OjpkcmFnTGVhdmVFdmVudChldik7CisjZWxzZQorICAgIFFfVU5VU0VEKGV2KTsKKyNl bmRpZgorfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpkcmFnTW92 ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCogZXYpCit7CisjaWZuZGVmIFFUX05P X0RSQUdBTkREUk9QCisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAg ICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBh Z2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9 CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc1dpZGdldDo6 ZHJhZ01vdmVFdmVudChldik7CisjZWxzZQorICAgIFFfVU5VU0VEKGV2KTsKKyNlbmRpZgorfQor CisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpkcm9wRXZlbnQoUUdyYXBo aWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyNpZm5kZWYgUVRfTk9fRFJBR0FORERST1AK KyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29s IGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYp OworICAgICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICgh ZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNzV2lkZ2V0Ojpkcm9wRXZlbnQoZXYp OworI2Vsc2UKKyAgICBRX1VOVVNFRChldik7CisjZW5kaWYKK30KKworI2lmbmRlZiBRVF9OT19D T05URVhUTUVOVQorLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6Y29udGV4 dE1lbnVFdmVudChRQ29udGV4dE1lbnVFdmVudCogZXYpCit7CisgICAgaWYgKGQtPnBhZ2UpIHsK KyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAg IGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsK KyAgICB9Cit9CisjZW5kaWYgLy8gUVRfTk9fQ09OVEVYVE1FTlUKKworI2lmbmRlZiBRVF9OT19X SEVFTEVWRU5UCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjp3aGVlbEV2 ZW50KFFHcmFwaGljc1NjZW5lV2hlZWxFdmVudCogZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0 aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0Fj Y2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFj Y2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisg ICAgICAgIFFHcmFwaGljc0l0ZW06OndoZWVsRXZlbnQoZXYpOworfQorI2VuZGlmIC8vIFFUX05P X1dIRUVMRVZFTlQKKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6aW5w dXRNZXRob2RFdmVudChRSW5wdXRNZXRob2RFdmVudCogZXYpCit7CisgICAgaWYgKGQtPmludGVy YWN0aXZlICYmIGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKworICAgIGlm ICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6aW5wdXRNZXRob2RF dmVudChldik7Cit9CisKKyNpbmNsdWRlICJtb2NfcXdlYmdyYXBoaWNzaXRlbS5jcHAiCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uaCBiL1dlYktpdC9xdC9BcGkv cXdlYmdyYXBoaWNzaXRlbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE2 NDYxZDgKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0u aApAQCAtMCwwICsxLDE0MyBAQAorLyoKKyAgICBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29y cG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisKKyAgICBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK KyAgICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u OyBlaXRoZXIKKyAgICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VCisgICAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisKKyAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNl ZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAorICAgIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorKi8KKworI2lmbmRlZiBRV2ViR3Jh cGhpY3NJdGVtX2gKKyNkZWZpbmUgUVdlYkdyYXBoaWNzSXRlbV9oCisKKyNpbmNsdWRlICJxd2Vi a2l0Z2xvYmFsLmgiCisjaW5jbHVkZSA8UXQvcWV2ZW50Lmg+CisjaW5jbHVkZSA8UXRDb3JlL3F1 cmwuaD4KKyNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhpY3N3aWRnZXQuaD4KKyNpbmNsdWRlIDxRdEd1 aS9xaWNvbi5oPgorI2luY2x1ZGUgPFF0R3VpL3FwYWludGVyLmg+CisjaW5jbHVkZSA8UXROZXR3 b3JrL3FuZXR3b3JrYWNjZXNzbWFuYWdlci5oPgorCitjbGFzcyBRV2ViUGFnZTsKK2NsYXNzIFFX ZWJIaXN0b3J5OworY2xhc3MgUVdlYlNldHRpbmdzOworCitjbGFzcyBRV2ViR3JhcGhpY3NJdGVt UHJpdmF0ZTsKKworY2xhc3MgUVdFQktJVF9FWFBPUlQgUVdlYkdyYXBoaWNzSXRlbSA6IHB1Ymxp YyBRR3JhcGhpY3NXaWRnZXQgeworICAgIFFfT0JKRUNUCisKKyAgICBRX1BST1BFUlRZKFFTdHJp bmcgdGl0bGUgUkVBRCB0aXRsZSBOT1RJRlkgdGl0bGVDaGFuZ2VkKQorICAgIFFfUFJPUEVSVFko UUljb24gaWNvbiBSRUFEIGljb24gTk9USUZZIGljb25DaGFuZ2VkKQorICAgIFFfUFJPUEVSVFko cXJlYWwgem9vbUZhY3RvciBSRUFEIHpvb21GYWN0b3IgV1JJVEUgc2V0Wm9vbUZhY3RvciBOT1RJ Rlkgem9vbUZhY3RvckNoYW5nZWQpCisgICAgUV9QUk9QRVJUWShRU3RyaW5nIHN0YXR1cyBSRUFE IHN0YXR1cyBOT1RJRlkgc3RhdHVzQ2hhbmdlZCkKKworICAgIFFfUFJPUEVSVFkoUVN0cmluZyBo dG1sIFJFQUQgdG9IdG1sIFdSSVRFIHNldEh0bWwpCisgICAgUV9QUk9QRVJUWShRVXJsIHVybCBS RUFEIHVybCBXUklURSBzZXRVcmwgTk9USUZZIHVybENoYW5nZWQpCisgICAgUV9QUk9QRVJUWShx cmVhbCBwcm9ncmVzcyBSRUFEIHByb2dyZXNzIE5PVElGWSBwcm9ncmVzc0NoYW5nZWQpCisKKyAg ICBRX1BST1BFUlRZKGJvb2wgaW50ZXJhY3RpdmUgUkVBRCBpbnRlcmFjdGl2ZSBXUklURSBzZXRJ bnRlcmFjdGl2ZSBOT1RJRlkgaW50ZXJhY3RpdmVDaGFuZ2VkKQorCitwdWJsaWM6CisgICAgUVdl YkdyYXBoaWNzSXRlbShRR3JhcGhpY3NJdGVtKiBwYXJlbnQgPSAwKTsKKyAgICB+UVdlYkdyYXBo aWNzSXRlbSgpOworCisgICAgUVdlYlBhZ2UqIHBhZ2UoKSBjb25zdDsKKyAgICB2b2lkIHNldFBh Z2UoUVdlYlBhZ2UqKTsKKworICAgIFFVcmwgdXJsKCkgY29uc3Q7CisgICAgdm9pZCBzZXRVcmwo Y29uc3QgUVVybCYpOworCisgICAgUVN0cmluZyB0aXRsZSgpIGNvbnN0OworICAgIFFJY29uIGlj b24oKSBjb25zdDsKKworICAgIHFyZWFsIHpvb21GYWN0b3IoKSBjb25zdDsKKyAgICB2b2lkIHNl dFpvb21GYWN0b3IocXJlYWwpOworCisgICAgYm9vbCBpbnRlcmFjdGl2ZSgpIGNvbnN0OworICAg IHZvaWQgc2V0SW50ZXJhY3RpdmUoYm9vbCk7CisKKyAgICBxcmVhbCBwcm9ncmVzcygpIGNvbnN0 OworCisgICAgdm9pZCBsb2FkKGNvbnN0IFFVcmwgJnVybCk7CisgICAgdm9pZCBsb2FkKGNvbnN0 IFFOZXR3b3JrUmVxdWVzdCYgcmVxdWVzdCwgUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyOjpPcGVyYXRp b24gb3BlcmF0aW9uID0gUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyOjpHZXRPcGVyYXRpb24sIGNvbnN0 IFFCeXRlQXJyYXkmIGJvZHkgPSBRQnl0ZUFycmF5KCkpOworCisgICAgUVN0cmluZyB0b0h0bWwo KSBjb25zdDsKKyAgICB2b2lkIHNldEh0bWwoY29uc3QgUVN0cmluZyYgaHRtbCwgY29uc3QgUVVy bCYgYmFzZVVybCA9IFFVcmwoKSk7CisgICAgLy8gRklYTUU6IENvbnNpZGVyIHJlbmFtZSB0byBz ZXRIdG1sPworICAgIHZvaWQgc2V0Q29udGVudChjb25zdCBRQnl0ZUFycmF5JiBkYXRhLCBjb25z dCBRU3RyaW5nJiBtaW1lVHlwZSA9IFFTdHJpbmcoKSwgY29uc3QgUVVybCYgYmFzZVVybCA9IFFV cmwoKSk7CisKKyAgICBRV2ViSGlzdG9yeSogaGlzdG9yeSgpIGNvbnN0OworICAgIFFXZWJTZXR0 aW5ncyogc2V0dGluZ3MoKSBjb25zdDsKKworICAgIFFTdHJpbmcgc3RhdHVzKCkgY29uc3Q7CisK KyAgICB2aXJ0dWFsIHZvaWQgc2V0R2VvbWV0cnkoY29uc3QgUVJlY3RGJiByZWN0KTsKKyAgICB2 aXJ0dWFsIHZvaWQgdXBkYXRlR2VvbWV0cnkoKTsKKyAgICB2aXJ0dWFsIHZvaWQgcGFpbnQoUVBh aW50ZXIqLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbnMsIFFXaWRnZXQq IHdpZGdldCA9IDApOworCitwdWJsaWMgUV9TTE9UUzoKKyAgICB2b2lkIHN0b3AoKTsKKyAgICB2 b2lkIGJhY2soKTsKKyAgICB2b2lkIGZvcndhcmQoKTsKKyAgICB2b2lkIHJlbG9hZCgpOworCitR X1NJR05BTFM6CisgICAgdm9pZCBsb2FkU3RhcnRlZCgpOworICAgIHZvaWQgbG9hZEZpbmlzaGVk KCk7CisgICAgdm9pZCBsb2FkRmFpbGVkKCk7CisKKyAgICB2b2lkIHByb2dyZXNzQ2hhbmdlZChx cmVhbCk7CisgICAgdm9pZCBpbnRlcmFjdGl2ZUNoYW5nZWQoKTsKKyAgICB2b2lkIHVybENoYW5n ZWQoY29uc3QgUVVybCYpOworICAgIHZvaWQgdGl0bGVDaGFuZ2VkKGNvbnN0IFFTdHJpbmcmKTsK KyAgICB2b2lkIGljb25DaGFuZ2VkKCk7CisgICAgdm9pZCBzdGF0dXNDaGFuZ2VkKCk7CisgICAg dm9pZCB6b29tRmFjdG9yQ2hhbmdlZCgpOworCitwcm90ZWN0ZWQ6CisgICAgdmlydHVhbCB2b2lk IG1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFs IHZvaWQgbW91c2VEb3VibGVDbGlja0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCopOwor ICAgIHZpcnR1YWwgdm9pZCBtb3VzZVJlbGVhc2VFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZl bnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgbW91c2VNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3Vz ZUV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGhvdmVyTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5l SG92ZXJFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBob3ZlckxlYXZlRXZlbnQoUUdyYXBoaWNz U2NlbmVIb3ZlckV2ZW50Kik7CisjaWZuZGVmIFFUX05PX1dIRUVMRVZFTlQKKyAgICB2aXJ0dWFs IHZvaWQgd2hlZWxFdmVudChRR3JhcGhpY3NTY2VuZVdoZWVsRXZlbnQqKTsKKyNlbmRpZgorICAg IHZpcnR1YWwgdm9pZCBrZXlQcmVzc0V2ZW50KFFLZXlFdmVudCopOworICAgIHZpcnR1YWwgdm9p ZCBrZXlSZWxlYXNlRXZlbnQoUUtleUV2ZW50Kik7CisjaWZuZGVmIFFUX05PX0NPTlRFWFRNRU5V CisgICAgdmlydHVhbCB2b2lkIGNvbnRleHRNZW51RXZlbnQoUUNvbnRleHRNZW51RXZlbnQqKTsK KyNlbmRpZgorICAgIHZpcnR1YWwgdm9pZCBkcmFnRW50ZXJFdmVudChRR3JhcGhpY3NTY2VuZURy YWdEcm9wRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgZHJhZ0xlYXZlRXZlbnQoUUdyYXBoaWNz U2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyYWdNb3ZlRXZlbnQoUUdy YXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyb3BFdmVudChR R3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgZm9jdXNJbkV2 ZW50KFFGb2N1c0V2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGZvY3VzT3V0RXZlbnQoUUZvY3Vz RXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgaW5wdXRNZXRob2RFdmVudChRSW5wdXRNZXRob2RF dmVudCopOworICAgIHZpcnR1YWwgYm9vbCBmb2N1c05leHRQcmV2Q2hpbGQoYm9vbCBuZXh0KTsK KworcHJpdmF0ZToKKyAgICBRX1BSSVZBVEVfU0xPVChkLCB2b2lkIF9xX2RvU2Nyb2xsKGludCBk eCwgaW50IGR5LCBjb25zdCBRUmVjdCYpKQorICAgIFFfUFJJVkFURV9TTE9UKGQsIHZvaWQgX3Ff ZG9Mb2FkUHJvZ3Jlc3MoaW50IHByb2dyZXNzKSkKKyAgICBRX1BSSVZBVEVfU0xPVChkLCB2b2lk IF9xX2RvTG9hZEZpbmlzaGVkKGJvb2wgc3VjY2VzcykpCisgICAgUV9QUklWQVRFX1NMT1QoZCwg dm9pZCBfcV9kb1VwZGF0ZShjb25zdCBRUmVjdCYgZGlydHlSZWN0KSkKKyAgICBRX1BSSVZBVEVf U0xPVChkLCB2b2lkIF9xX3NldFN0YXR1c0Jhck1lc3NhZ2UoY29uc3QgUVN0cmluZyYgbWVzc2Fn ZSkpCisKKyAgICBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSogY29uc3QgZDsKKyAgICBmcmllbmQg Y2xhc3MgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU7Cit9OworCisjZW5kaWYgLy8gUVdlYkdyYXBo aWNzSXRlbV9oCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW1fcC5o IGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi45OTJkNDJmCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L3F0L0Fw aS9xd2ViZ3JhcGhpY3NpdGVtX3AuaApAQCAtMCwwICsxLDQzIEBACisvKgorICAgIENvcHlyaWdo dCAoQykgMjAwOSBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykK KworICAgIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAgIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgICBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisq LworCitjbGFzcyBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZSB7CitwdWJsaWM6CisgICAgUVdlYkdy YXBoaWNzSXRlbVByaXZhdGUoUVdlYkdyYXBoaWNzSXRlbSogcGFyZW50KQorICAgICAgICA6IHEo cGFyZW50KQorICAgICAgICAsIHBhZ2UoMCkKKyAgICAgICAgLCBpbnRlcmFjdGl2ZSh0cnVlKQor ICAgICAgICAsIHByb2dyZXNzKDEuMCkKKyAgICB7fQorCisgICAgdm9pZCBfcV9kb1Njcm9sbChp bnQgZHgsIGludCBkeSwgY29uc3QgUVJlY3QmKTsKKyAgICB2b2lkIF9xX2RvTG9hZFByb2dyZXNz KGludCBwcm9ncmVzcyk7CisgICAgdm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3Mp OworICAgIHZvaWQgX3FfZG9VcGRhdGUoY29uc3QgUVJlY3QmIGRpcnR5UmVjdCk7CisgICAgdm9p ZCBfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFTdHJpbmcmIG1lc3NhZ2UpOworCisgICAg UVdlYkdyYXBoaWNzSXRlbSogcTsKKyAgICBRV2ViUGFnZSogcGFnZTsKKworICAgIFFTdHJpbmcg c3RhdHVzQmFyTWVzc2FnZTsKKyAgICBib29sIGludGVyYWN0aXZlOworICAgIHFyZWFsIHByb2dy ZXNzOworfTsKKworCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmggYi9XZWJL aXQvcXQvQXBpL3F3ZWJwYWdlLmgKaW5kZXggMjQ3NDFhMS4uMTBjNzkzOCAxMDA2NDQKLS0tIGEv V2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaApA QCAtMzUxLDYgKzM1MSw3IEBAIHByaXZhdGU6CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJGcmFtZTsK ICAgICBmcmllbmQgY2xhc3MgUVdlYlBhZ2VQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2Vi VmlldzsKKyAgICBmcmllbmQgY2xhc3MgUVdlYkdyYXBoaWNzSXRlbTsKICAgICBmcmllbmQgY2xh c3MgV2ViQ29yZTo6Q2hyb21lQ2xpZW50UXQ7CiAgICAgZnJpZW5kIGNsYXNzIFdlYkNvcmU6OkVk aXRvckNsaWVudFF0OwogICAgIGZyaWVuZCBjbGFzcyBXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVu dFF0OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VM b2cKaW5kZXggMWVhZjNiNy4uYzIxOTc1ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMDktMDktMDQg IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPiwgQW50b25p byBHb21lcyAgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgUUdyYXBoaWNzV2lkZ2V0 IGJhc2VkIHZlcnNpb24gb2YgdGhlICJRV2ViVmlldyIKKyAgICAgICAgdW5kZXIgdGhlIG5hbWUg IlFXZWJHcmFwaGljc0l0ZW0iLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yODg2MgorCisgICAgICAgIEluY2x1ZGVzIGFuIGFsdGVybmF0aXZlIFF0 IGxhdW5jaGVyIHVzaW5nIHRoZSBRR3JhcGhpY3NWaWV3LgorCisgICAgICAgICogQXBpL2hlYWRl cnMucHJpOgorICAgICAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcDogQWRkZWQuCisgICAg ICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uaDogQWRkZWQuCisgICAgICAgICogQXBpL3F3ZWJn cmFwaGljc2l0ZW1fcC5oOiBBZGRlZC4KKyAgICAgICAgKiBBcGkvcXdlYnBhZ2UuaDoKKyAgICAg ICAgKiBRR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdlYktpdC9xdC9R dExhdW5jaGVyL1F0TGF1bmNoZXIucHJvLgorICAgICAgICAqIFFHVkxhdW5jaGVyL21haW4uY3Bw OiBBZGRlZC4KKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpDaHJvbWVDbGllbnRRdDo6cmVwYWludCk6CisgICAgICAgIChXZWJD b3JlOjpDaHJvbWVDbGllbnRRdDo6c2Nyb2xsKToKKwogMjAwOS0wOS0wNCAgTWFyayBNZW50b3Zh aSAgPG1hcmtAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhdmUgSHlhdHQu CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvUUdWTGF1bmNoZXIvUUdWTGF1bmNoZXIucHJvIGIvV2Vi S2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVyLnBybwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5iODgzYjUyCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L3F0L1FHVkxh dW5jaGVyL1FHVkxhdW5jaGVyLnBybwpAQCAtMCwwICsxLDEzIEBACitURU1QTEFURSA9IGFwcAor U09VUkNFUyArPSBtYWluLmNwcAorQ09ORklHIC09IGFwcF9idW5kbGUKK0NPTkZJRyArPSB1aXRv b2xzCitERVNURElSID0gLi4vLi4vLi4vYmluCisKK2luY2x1ZGUoLi4vLi4vLi4vV2ViS2l0LnBy aSkKKworUVQgKz0gbmV0d29yaworbWFjeDpRVCs9eG1sCitRTUFLRV9SUEFUSERJUiA9ICQkT1VU UFVUX0RJUi9saWIgJCRRTUFLRV9SUEFUSERJUgorCitzeW1iaWFuOlRBUkdFVC5VSUQzID0gMHgy MDAyNjdEMApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwIGIvV2Vi S2l0L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjZlM2FiNDUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvcXQvUUdWTGF1bmNoZXIv bWFpbi5jcHAKQEAgLTAsMCArMSwzMDAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgTm9r aWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQg KEMpIDIwMDYgR2VvcmdlIFN0YWlrb3MgPHN0YWlrb3NAa2RlLm9yZz4KKyAqIENvcHlyaWdodCAo QykgMjAwNiBEaXJrIE11ZWxsZXIgPG11ZWxsZXJAa2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykg MjAwNiBaYWNrIFJ1c2luIDx6YWNrQGtkZS5vcmc+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgU2lt b24gSGF1c21hbm4gPGhhdXNtYW5uQGtkZS5vcmc+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgS2Vu bmV0aCBDaHJpc3RpYW5zZW4gPGtlbm5ldGhAd2Via2l0Lm9yZz4KKyAqIENvcHlyaWdodCAoQykg MjAwOSBBbnRvbmlvIEdvbWVzIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CisgKgorICog QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICog YXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSA8cXdlYnBhZ2UuaD4KKyNpbmNs dWRlIDxxd2Vidmlldy5oPgorI2luY2x1ZGUgPHF3ZWJncmFwaGljc2l0ZW0uaD4KKyNpbmNsdWRl IDxxd2ViZnJhbWUuaD4KKyNpbmNsdWRlIDxxd2Vic2V0dGluZ3MuaD4KKyNpbmNsdWRlIDxxd2Vi ZWxlbWVudC5oPgorCisjaW5jbHVkZSA8UU5ldHdvcmtSZXF1ZXN0PgorI2luY2x1ZGUgPFFHcmFw aGljc1NjZW5lPgorI2luY2x1ZGUgPFFHcmFwaGljc1ZpZXc+CisjaW5jbHVkZSA8UUdyYXBoaWNz V2lkZ2V0PgorCisjaW5jbHVkZSA8UXRHdWk+CisjaW5jbHVkZSA8UURlYnVnPgorI2luY2x1ZGUg PFF0TmV0d29yay9RTmV0d29ya1Byb3h5PgorCisjaW5jbHVkZSA8UVZlY3Rvcj4KKyNpbmNsdWRl IDxRVGV4dFN0cmVhbT4KKyNpbmNsdWRlIDxRRmlsZT4KKyNpbmNsdWRlIDxjc3RkaW8+CisKK2Ns YXNzIFdlYlBhZ2UgOiBwdWJsaWMgUVdlYlBhZ2UgeworICAgIFFfT0JKRUNUCisKK3B1YmxpYzoK KyAgICBXZWJQYWdlKFFXaWRnZXQgKnBhcmVudCA9IDApIDogUVdlYlBhZ2UocGFyZW50KQorICAg IHsKKyAgICAgICAgYXBwbHlQcm94eSgpOworICAgIH0KKyAgICB2aXJ0dWFsIFFXZWJQYWdlICpj cmVhdGVXaW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5cGUpOworCitwcml2YXRlOgorICAgIHZv aWQgYXBwbHlQcm94eSgpOworfTsKKworY2xhc3MgTWFpblZpZXcgOiBwdWJsaWMgUUdyYXBoaWNz VmlldyB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgorICAgIE1haW5WaWV3KFFXaWRnZXQqIHBh cmVudCkgOiBRR3JhcGhpY3NWaWV3KHBhcmVudCksIG1fbWFpbldpZGdldCgwKQorICAgIHsKKyAg ICAgICAgc2V0SG9yaXpvbnRhbFNjcm9sbEJhclBvbGljeShRdDo6U2Nyb2xsQmFyQWx3YXlzT2Zm KTsKKyAgICAgICAgc2V0VmVydGljYWxTY3JvbGxCYXJQb2xpY3koUXQ6OlNjcm9sbEJhckFsd2F5 c09mZik7CisgICAgfQorCisgICAgdm9pZCBzZXRNYWluV2lkZ2V0KFFHcmFwaGljc1dpZGdldCog d2lkZ2V0KQorICAgIHsKKyAgICAgICAgUVJlY3RGIHJlY3QoUVJlY3QoUVBvaW50KDAsIDApLCBz aXplKCkpKTsKKyAgICAgICAgd2lkZ2V0LT5zZXRHZW9tZXRyeShyZWN0KTsKKyAgICAgICAgbV9t YWluV2lkZ2V0ID0gd2lkZ2V0OworICAgIH0KKworICAgIHZvaWQgcmVzaXplRXZlbnQoUVJlc2l6 ZUV2ZW50KiBldmVudCkKKyAgICB7CisgICAgICAgIFFHcmFwaGljc1ZpZXc6OnJlc2l6ZUV2ZW50 KGV2ZW50KTsKKyAgICAgICAgUVJlY3RGIHJlY3QoUVJlY3QoUVBvaW50KDAsIDApLCBldmVudC0+ c2l6ZSgpKSk7CisgICAgICAgIGlmICghbV9tYWluV2lkZ2V0KQorICAgICAgICAgICAgcmV0dXJu OworICAgICAgICBtX21haW5XaWRnZXQtPnNldEdlb21ldHJ5KHJlY3QpOworICAgIH0KKworcHJp dmF0ZToKKyAgICBRR3JhcGhpY3NXaWRnZXQqIG1fbWFpbldpZGdldDsKK307CisKK2NsYXNzIFNo YXJlZFNjZW5lIDogcHVibGljIFFTaGFyZWREYXRhIHsKK3B1YmxpYzoKKyAgICBTaGFyZWRTY2Vu ZSgpCisgICAgeworICAgICAgICBtX3NjZW5lID0gbmV3IFFHcmFwaGljc1NjZW5lOworCisgICAg ICAgIG1faXRlbSA9IG5ldyBRV2ViR3JhcGhpY3NJdGVtOworICAgICAgICBtX2l0ZW0tPnNldFBh Z2UobmV3IFdlYlBhZ2UoKSk7CisKKyAgICAgICAgbV9zY2VuZS0+YWRkSXRlbShtX2l0ZW0pOwor ICAgICAgICBtX3NjZW5lLT5zZXRBY3RpdmVXaW5kb3cobV9pdGVtKTsKKyAgICB9CisKKyAgICB+ U2hhcmVkU2NlbmUoKQorICAgIHsKKyAgICAgICAgZGVsZXRlIG1faXRlbTsKKyAgICAgICAgZGVs ZXRlIG1fc2NlbmU7CisgICAgfQorCisgICAgUUdyYXBoaWNzU2NlbmUqIHNjZW5lKCkgY29uc3Qg eyByZXR1cm4gbV9zY2VuZTsgfQorICAgIFFXZWJHcmFwaGljc0l0ZW0qIHdlYkl0ZW0oKSBjb25z dCB7IHJldHVybiBtX2l0ZW07IH0KKworcHJpdmF0ZToKKyAgICBRR3JhcGhpY3NTY2VuZSogbV9z Y2VuZTsKKyAgICBRV2ViR3JhcGhpY3NJdGVtKiBtX2l0ZW07Cit9OworCisKK2NsYXNzIE1haW5X aW5kb3cgOiBwdWJsaWMgUU1haW5XaW5kb3cgeworICAgIFFfT0JKRUNUCisKK3B1YmxpYzoKKyAg ICBNYWluV2luZG93KFFFeHBsaWNpdGx5U2hhcmVkRGF0YVBvaW50ZXI8U2hhcmVkU2NlbmU+IG90 aGVyKQorICAgICAgICA6IFFNYWluV2luZG93KCksIHZpZXcobmV3IE1haW5WaWV3KHRoaXMpKSwg c2NlbmUob3RoZXIpCisgICAgeworICAgICAgICBpbml0KCk7CisgICAgfQorCisgICAgTWFpbldp bmRvdygpCisgICAgICAgIDogUU1haW5XaW5kb3coKSwgdmlldyhuZXcgTWFpblZpZXcodGhpcykp LCBzY2VuZShuZXcgU2hhcmVkU2NlbmUoKSkKKyAgICB7CisgICAgICAgIGluaXQoKTsKKyAgICB9 CisKKyAgICB2b2lkIGluaXQoKQorICAgIHsKKyAgICAgICAgc2V0QXR0cmlidXRlKFF0OjpXQV9E ZWxldGVPbkNsb3NlKTsKKworICAgICAgICB2aWV3LT5zZXRTY2VuZShzY2VuZS0+c2NlbmUoKSk7 CisgICAgICAgIHZpZXctPnNldEZyYW1lU2hhcGUoUUZyYW1lOjpOb0ZyYW1lKTsKKyAgICAgICAg dmlldy0+c2V0U2l6ZVBvbGljeShRU2l6ZVBvbGljeTo6RXhwYW5kaW5nLCBRU2l6ZVBvbGljeTo6 RXhwYW5kaW5nKTsKKyAgICAgICAgc2V0Q2VudHJhbFdpZGdldCh2aWV3KTsKKworICAgICAgICB2 aWV3LT5zZXRNYWluV2lkZ2V0KHNjZW5lLT53ZWJJdGVtKCkpOworCisgICAgICAgIGNvbm5lY3Qo c2NlbmUtPndlYkl0ZW0oKSwgU0lHTkFMKGxvYWRGaW5pc2hlZCgpKSwgdGhpcywgU0xPVChsb2Fk RmluaXNoZWQoKSkpOworICAgICAgICBjb25uZWN0KHNjZW5lLT53ZWJJdGVtKCksIFNJR05BTCh0 aXRsZUNoYW5nZWQoY29uc3QgUVN0cmluZyYpKSwgdGhpcywgU0xPVChzZXRXaW5kb3dUaXRsZShj b25zdCBRU3RyaW5nJikpKTsKKyAgICAgICAgY29ubmVjdChzY2VuZS0+d2ViSXRlbSgpLT5wYWdl KCksIFNJR05BTCh3aW5kb3dDbG9zZVJlcXVlc3RlZCgpKSwgdGhpcywgU0xPVChjbG9zZSgpKSk7 CisKKyAgICAgICAgcmVzaXplKDY0MCwgNDgwKTsKKyAgICAgICAgYnVpbGRVSSgpOworICAgIH0K KworICAgIHZvaWQgbG9hZChjb25zdCBRU3RyaW5nJiB1cmwpCisgICAgeworICAgICAgICBRVXJs IGRlZHVjZWRVcmwgPSBndWVzc1VybEZyb21TdHJpbmcodXJsKTsKKyAgICAgICAgaWYgKCFkZWR1 Y2VkVXJsLmlzVmFsaWQoKSkKKyAgICAgICAgICAgIGRlZHVjZWRVcmwgPSBRVXJsKCJodHRwOi8v IiArIHVybCArICIvIik7CisKKyAgICAgICAgdXJsRWRpdC0+c2V0VGV4dChkZWR1Y2VkVXJsLnRv RW5jb2RlZCgpKTsKKyAgICAgICAgc2NlbmUtPndlYkl0ZW0oKS0+bG9hZChkZWR1Y2VkVXJsKTsK KyAgICAgICAgc2NlbmUtPndlYkl0ZW0oKS0+c2V0Rm9jdXMoUXQ6Ok90aGVyRm9jdXNSZWFzb24p OworICAgIH0KKworICAgIFFVcmwgZ3Vlc3NVcmxGcm9tU3RyaW5nKGNvbnN0IFFTdHJpbmcmIHN0 cmluZykKKyAgICB7CisgICAgICAgIFFTdHJpbmcgaW5wdXQoc3RyaW5nKTsKKyAgICAgICAgUUZp bGVJbmZvIGZpKGlucHV0KTsKKyAgICAgICAgaWYgKGZpLmV4aXN0cygpICYmIGZpLmlzUmVsYXRp dmUoKSkKKyAgICAgICAgICAgIGlucHV0ID0gZmkuYWJzb2x1dGVGaWxlUGF0aCgpOworCisgICAg ICAgIHJldHVybiBRV2ViVmlldzo6Z3Vlc3NVcmxGcm9tU3RyaW5nKGlucHV0KTsKKyAgICB9CisK KyAgICBRV2ViUGFnZSogcGFnZSgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gc2NlbmUt PndlYkl0ZW0oKS0+cGFnZSgpOworICAgIH0KKworcHJvdGVjdGVkIHNsb3RzOgorICAgIHZvaWQg Y2hhbmdlTG9jYXRpb24oKQorICAgIHsKKyAgICAgICAgbG9hZCh1cmxFZGl0LT50ZXh0KCkpOwor ICAgIH0KKworICAgIHZvaWQgbG9hZEZpbmlzaGVkKCkKKyAgICB7CisgICAgICAgIFFVcmwgdXJs ID0gc2NlbmUtPndlYkl0ZW0oKS0+dXJsKCk7CisgICAgICAgIHVybEVkaXQtPnNldFRleHQodXJs LnRvU3RyaW5nKCkpOworCisgICAgICAgIFFVcmw6OkZvcm1hdHRpbmdPcHRpb25zIG9wdHM7Cisg ICAgICAgIG9wdHMgfD0gUVVybDo6UmVtb3ZlU2NoZW1lOworICAgICAgICBvcHRzIHw9IFFVcmw6 OlJlbW92ZVVzZXJJbmZvOworICAgICAgICBvcHRzIHw9IFFVcmw6OlN0cmlwVHJhaWxpbmdTbGFz aDsKKyAgICAgICAgUVN0cmluZyBzID0gdXJsLnRvU3RyaW5nKG9wdHMpOworICAgICAgICBzID0g cy5taWQoMik7CisgICAgICAgIGlmIChzLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgLy9GSVhNRTogc29tZXRoaW5nIG1pc3NpbmcgaGVyZQorICAgIH0KKworcHVibGlj IHNsb3RzOgorICAgIHZvaWQgbmV3V2luZG93KGNvbnN0IFFTdHJpbmcgJnVybCA9IFFTdHJpbmco KSkKKyAgICB7CisgICAgICAgIE1haW5XaW5kb3cgKm13ID0gbmV3IE1haW5XaW5kb3coKTsKKyAg ICAgICAgbXctPmxvYWQodXJsKTsKKyAgICAgICAgbXctPnNob3coKTsKKyAgICB9CisKKyAgICB2 b2lkIGNsb25lKCkKKyAgICB7CisgICAgICAgIE1haW5XaW5kb3cgKm13ID0gbmV3IE1haW5XaW5k b3coc2NlbmUpOworICAgICAgICBtdy0+c2hvdygpOworICAgIH0KKworcHJpdmF0ZToKKyAgICB2 b2lkIGJ1aWxkVUkoKQorICAgIHsKKyAgICAgICAgUVdlYlBhZ2UqIHBhZ2UgPSBzY2VuZS0+d2Vi SXRlbSgpLT5wYWdlKCk7CisgICAgICAgIHVybEVkaXQgPSBuZXcgUUxpbmVFZGl0KHRoaXMpOwor ICAgICAgICB1cmxFZGl0LT5zZXRTaXplUG9saWN5KFFTaXplUG9saWN5OjpFeHBhbmRpbmcsIHVy bEVkaXQtPnNpemVQb2xpY3koKS52ZXJ0aWNhbFBvbGljeSgpKTsKKyAgICAgICAgY29ubmVjdCh1 cmxFZGl0LCBTSUdOQUwocmV0dXJuUHJlc3NlZCgpKSwgU0xPVChjaGFuZ2VMb2NhdGlvbigpKSk7 CisKKyAgICAgICAgUVRvb2xCYXIgKmJhciA9IGFkZFRvb2xCYXIoIk5hdmlnYXRpb24iKTsKKyAg ICAgICAgYmFyLT5hZGRBY3Rpb24ocGFnZS0+YWN0aW9uKFFXZWJQYWdlOjpCYWNrKSk7CisgICAg ICAgIGJhci0+YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6Rm9yd2FyZCkpOworICAg ICAgICBiYXItPmFkZEFjdGlvbihwYWdlLT5hY3Rpb24oUVdlYlBhZ2U6OlJlbG9hZCkpOworICAg ICAgICBiYXItPmFkZEFjdGlvbihwYWdlLT5hY3Rpb24oUVdlYlBhZ2U6OlN0b3ApKTsKKyAgICAg ICAgYmFyLT5hZGRXaWRnZXQodXJsRWRpdCk7CisKKyAgICAgICAgUU1lbnUgKmZpbGVNZW51ID0g bWVudUJhcigpLT5hZGRNZW51KCImRmlsZSIpOworICAgICAgICBRQWN0aW9uICpuZXdXaW5kb3cg PSBmaWxlTWVudS0+YWRkQWN0aW9uKCJOZXcgV2luZG93IiwgdGhpcywgU0xPVChuZXdXaW5kb3co KSkpOworICAgICAgICBRQWN0aW9uICpjbG9uZVZpZXcgPSBmaWxlTWVudS0+YWRkQWN0aW9uKCJD bG9uZSB2aWV3IiwgdGhpcywgU0xPVChjbG9uZSgpKSk7CisgICAgICAgIGZpbGVNZW51LT5hZGRB Y3Rpb24oIkNsb3NlIiwgdGhpcywgU0xPVChjbG9zZSgpKSk7CisKKyAgICAgICAgUU1lbnUgKnZp ZXdNZW51ID0gbWVudUJhcigpLT5hZGRNZW51KCImVmlldyIpOworICAgICAgICB2aWV3TWVudS0+ YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6U3RvcCkpOworICAgICAgICB2aWV3TWVu dS0+YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6UmVsb2FkKSk7CisgICAgfQorCitw cml2YXRlOgorICAgIE1haW5WaWV3ICp2aWV3OworICAgIFFFeHBsaWNpdGx5U2hhcmVkRGF0YVBv aW50ZXI8U2hhcmVkU2NlbmU+IHNjZW5lOworCisgICAgUUxpbmVFZGl0ICp1cmxFZGl0OworfTsK KworUVdlYlBhZ2UgKldlYlBhZ2U6OmNyZWF0ZVdpbmRvdyhRV2ViUGFnZTo6V2ViV2luZG93VHlw ZSkKK3sKKyAgICBNYWluV2luZG93ICptdyA9IG5ldyBNYWluV2luZG93OworICAgIG13LT5zaG93 KCk7CisgICAgcmV0dXJuIG13LT5wYWdlKCk7Cit9CisKK3ZvaWQgV2ViUGFnZTo6YXBwbHlQcm94 eSgpCit7CisgICAgUVVybCBwcm94eVVybCA9IFFXZWJWaWV3OjpndWVzc1VybEZyb21TdHJpbmco cWdldGVudigiaHR0cF9wcm94eSIpKTsKKworICAgIGlmIChwcm94eVVybC5pc1ZhbGlkKCkgJiYg IXByb3h5VXJsLmhvc3QoKS5pc0VtcHR5KCkpIHsKKyAgICAgICAgaW50IHByb3h5UG9ydCA9IChw cm94eVVybC5wb3J0KCkgPiAwKSA/IHByb3h5VXJsLnBvcnQoKSA6IDgwODA7CisgICAgICAgIG5l dHdvcmtBY2Nlc3NNYW5hZ2VyKCktPnNldFByb3h5KFFOZXR3b3JrUHJveHkoUU5ldHdvcmtQcm94 eTo6SHR0cFByb3h5LCBwcm94eVVybC5ob3N0KCksIHByb3h5UG9ydCkpOworICAgIH0KK30KKwor I2luY2x1ZGUgIm1haW4ubW9jIgorCitpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3YpCit7 CisgICAgUUFwcGxpY2F0aW9uIGFwcChhcmdjLCBhcmd2KTsKKyAgICBRU3RyaW5nIHVybCA9IFFT dHJpbmcoImZpbGU6Ly8lMS8lMiIpLmFyZyhRRGlyOjpob21lUGF0aCgpKS5hcmcoUUxhdGluMVN0 cmluZygiaW5kZXguaHRtbCIpKTsKKworICAgIGFwcC5zZXRBcHBsaWNhdGlvbk5hbWUoIkdRVkxh dW5jaGVyIik7CisKKyAgICBRV2ViU2V0dGluZ3M6OnNldE9iamVjdENhY2hlQ2FwYWNpdGllcygo MTYqMTAyNCoxMDI0KSAvIDgsICgxNioxMDI0KjEwMjQpIC8gOCwgMTYqMTAyNCoxMDI0KTsKKyAg ICBRV2ViU2V0dGluZ3M6OnNldE1heGltdW1QYWdlc0luQ2FjaGUoNCk7CisgICAgUVdlYlNldHRp bmdzOjpnbG9iYWxTZXR0aW5ncygpLT5zZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpQbHVnaW5z RW5hYmxlZCwgdHJ1ZSk7CisgICAgUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpLT5zZXRB dHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpEZXZlbG9wZXJFeHRyYXNFbmFibGVkLCB0cnVlKTsKKyAg ICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGlu Z3M6OkxvY2FsU3RvcmFnZUVuYWJsZWQsIHRydWUpOworCisgICAgY29uc3QgUVN0cmluZ0xpc3Qg YXJncyA9IGFwcC5hcmd1bWVudHMoKTsKKyAgICBpZiAoYXJncy5jb3VudCgpID4gMSkKKyAgICAg ICAgdXJsID0gYXJncy5hdCgxKTsKKworICAgIE1haW5XaW5kb3cqIHdpbmRvdyA9IG5ldyBNYWlu V2luZG93OworICAgIHdpbmRvdy0+bG9hZCh1cmwpOworCisgICAgZm9yIChpbnQgaSA9IDI7IGkg PCBhcmdzLmNvdW50KCk7IGkrKykKKyAgICAgICAgd2luZG93LT5uZXdXaW5kb3coYXJncy5hdChp KSk7CisKKyAgICB3aW5kb3ctPnNob3coKTsKKyAgICByZXR1cm4gYXBwLmV4ZWMoKTsKK30KZGlm ZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAgYi9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50UXQuY3BwCmluZGV4IGQ2NTk4MzMu LmU3OWFlNTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGll bnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNw cApAQCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUgInF3ZWJmcmFtZV9wLmgiCiAjaW5jbHVkZSAi cXdlYnNlY3VyaXR5b3JpZ2luLmgiCiAjaW5jbHVkZSAicXdlYnNlY3VyaXR5b3JpZ2luX3AuaCIK KyNpbmNsdWRlICJxd2Vidmlldy5oIgogCiAjaW5jbHVkZSA8cXRvb2x0aXAuaD4KICNpbmNsdWRl IDxxdGV4dGRvY3VtZW50Lmg+CkBAIC0zMDcsOCArMzA4LDggQEAgdm9pZCBDaHJvbWVDbGllbnRR dDo6cmVwYWludChjb25zdCBJbnRSZWN0JiB3aW5kb3dSZWN0LCBib29sIGNvbnRlbnRDaGFuZ2Vk LCBib28KIHsKICAgICAvLyBObyBkb3VibGUgYnVmZmVyLCBzbyBvbmx5IHVwZGF0ZSB0aGUgUVdp ZGdldCBpZiBjb250ZW50IGNoYW5nZWQuCiAgICAgaWYgKGNvbnRlbnRDaGFuZ2VkKSB7Ci0gICAg ICAgIFFXaWRnZXQqIHZpZXcgPSBtX3dlYlBhZ2UtPnZpZXcoKTsKLSAgICAgICAgaWYgKHZpZXcp IHsKKyAgICAgICAgLy8gT25seSBkbyBpbXBsaWNpdCBwYWludHMgZm9yIFFXZWJWaWV3J3MKKyAg ICAgICAgaWYgKFFXZWJWaWV3KiB2aWV3ID0gcW9iamVjdF9jYXN0PFFXZWJWaWV3Kj4obV93ZWJQ YWdlLT52aWV3KCkpKSB7CiAgICAgICAgICAgICBRUmVjdCByZWN0KHdpbmRvd1JlY3QpOwogICAg ICAgICAgICAgcmVjdCA9IHJlY3QuaW50ZXJzZWN0ZWQoUVJlY3QoUVBvaW50KDAsIDApLCBtX3dl YlBhZ2UtPnZpZXdwb3J0U2l6ZSgpKSk7CiAgICAgICAgICAgICBpZiAoIXJlY3QuaXNFbXB0eSgp KQpAQCAtMzIzLDggKzMyNCw4IEBAIHZvaWQgQ2hyb21lQ2xpZW50UXQ6OnJlcGFpbnQoY29uc3Qg SW50UmVjdCYgd2luZG93UmVjdCwgYm9vbCBjb250ZW50Q2hhbmdlZCwgYm9vCiAKIHZvaWQgQ2hy b21lQ2xpZW50UXQ6OnNjcm9sbChjb25zdCBJbnRTaXplJiBkZWx0YSwgY29uc3QgSW50UmVjdCYg c2Nyb2xsVmlld1JlY3QsIGNvbnN0IEludFJlY3QmKQogewotICAgIFFXaWRnZXQqIHZpZXcgPSBt X3dlYlBhZ2UtPnZpZXcoKTsKLSAgICBpZiAodmlldykKKyAgICAvLyBPbmx5IGRvIGltcGxpY2l0 IHBhaW50cyBmb3IgUVdlYlZpZXcncworICAgIGlmIChRV2ViVmlldyogdmlldyA9IHFvYmplY3Rf Y2FzdDxRV2ViVmlldyo+KG1fd2ViUGFnZS0+dmlldygpKSkKICAgICAgICAgdmlldy0+c2Nyb2xs KGRlbHRhLndpZHRoKCksIGRlbHRhLmhlaWdodCgpLCBzY3JvbGxWaWV3UmVjdCk7CiAgICAgZW1p dCBtX3dlYlBhZ2UtPnNjcm9sbFJlcXVlc3RlZChkZWx0YS53aWR0aCgpLCBkZWx0YS5oZWlnaHQo KSwgc2Nyb2xsVmlld1JlY3QpOwogfQotLSAKMS42LjAuNAoK 39165 2009-09-07 15:43:54 -0700 2009-09-09 04:06:16 -0700 patch 1 - v0.2.1 - add QWebGraphicsItem to the API and QGVLauncher sample application 0001--.-Qt-Add-the-alternative-QtLauncher-based-on.patch text/plain 42582 tonikitoo RnJvbSA5N2FiMjMyMTM1ZTY3OTI2NzQyMmQzZTVjMjAzYjE5OGVhZmE5OTI1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBGcmksIDQgU2VwIDIwMDkgMTc6MjA6NDcgLTAzMDAKU3ViamVjdDog W1BBVENIXSAgICAgLjogW1F0XSBBZGQgdGhlIGFsdGVybmF0aXZlIFF0TGF1bmNoZXIgKGJhc2Vk IG9uIFFHcmFwaGljc1ZpZXcpIHRvIHRoZSBidWlsZC4KCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKCiAgICBXZWJLaXQvcXQ6IEFkZCBhIG5ldyBRR3Jh cGhpY3NXaWRnZXQgYmFzZWQgdmVyc2lvbiBvZiB0aGUgIlFXZWJWaWV3IgogICAgdW5kZXIgdGhl IG5hbWUgIlFXZWJHcmFwaGljc0l0ZW0iLgoKICAgIEluY2x1ZGVzIGFuIGFsdGVybmF0aXZlIFF0 IGxhdW5jaGVyIHVzaW5nIHRoZSBRR3JhcGhpY3NWaWV3LgoKICAgIFBhdGNoIGJ5IEtlbm5ldGgg Um9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPiwgQW50b25pbyBHb21lcyA8 YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIEFwaS9oZWFkZXJzLnByaToKICAgICogQXBpL3F3ZWJn cmFwaGljc2l0ZW0uY3BwOiBBZGRlZC4KICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uaDogQWRk ZWQuCiAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaDogQWRkZWQuCiAgICAqIEFwaS9xd2Vi cGFnZS5oOgogICAgKiBRR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdl YktpdC9xdC9RdExhdW5jaGVyL1F0TGF1bmNoZXIucHJvLgogICAgKiBRR1ZMYXVuY2hlci9tYWlu LmNwcDogQWRkZWQuCiAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcDoKICAg IChXZWJDb3JlOjpDaHJvbWVDbGllbnRRdDo6cmVwYWludCk6CiAgICAoV2ViQ29yZTo6Q2hyb21l Q2xpZW50UXQ6OnNjcm9sbCk6CgogICAgV2ViS2l0OiBBZGQgdGhlIFFHVkxhdW5jaGVyIHRoZSBi dWlsZCBzeXN0ZW0uCgogICAgUGF0Y2ggYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4gPGtl bm5ldGhAd2Via2l0Lm9yZz4gb24gMjAwOS0wOS0wNAogICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCgogICAgKiBXZWJLaXQucHJvOgoKICAgIFdlYkNvcmU6IEFkZCB0aGUgcXdlYmdyYXBo aWNzaXRlbS5jcHAgdG8gdGhlIGJ1aWxkIHN5c3RlbS4KCiAgICBQYXRjaCBieSBLZW5uZXRoIFJv aGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3ZWJraXQub3JnPiBvbiAyMDA5LTA5LTA0CiAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAqIFdlYkNvcmUucHJvOgotLS0KIENoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA5ICsKIFdlYkNvcmUv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA4ICsKIFdlYkNvcmUvV2Vi Q29yZS5wcm8gICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC5wcm8gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC9BcGkvaGVh ZGVycy5wcmkgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC9BcGkvcXdlYmdy YXBoaWNzaXRlbS5jcHAgICAgICAgICAgfCAgNzE2ICsrKysrKysrKysrKysrKysrKysrKysrKysr KwogV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmggICAgICAgICAgICB8ICAxNDMgKysr KysrCiBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW1fcC5oICAgICAgICAgIHwgICA0MyAr KwogV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwog V2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjIgKwogV2Vi S2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVyLnBybyAgICAgICB8ICAgMTMgKwogV2ViS2l0 L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwICAgICAgICAgICAgICB8ICAzMDAgKysrKysrKysrKysK IFdlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAgfCAgICA5ICstCiAx MyBmaWxlcyBjaGFuZ2VkLCAxMjYzIGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCiBjcmVh dGUgbW9kZSAxMDA2NDQgV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcAogY3JlYXRl IG1vZGUgMTAwNjQ0IFdlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5oCiBjcmVhdGUgbW9k ZSAxMDA2NDQgV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaAogY3JlYXRlIG1vZGUg MTAwNjQ0IFdlYktpdC9xdC9RR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm8KIGNyZWF0ZSBtb2Rl IDEwMDY0NCBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAKCmRpZmYgLS1naXQgYS9DaGFu Z2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggMTMwNWEzNy4uMzI5NDY4MiAxMDA2NDQKLS0tIGEvQ2hh bmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEyIEBACisyMDA5LTA5LTA3ICBLZW5u ZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KKworICAgICAgICBQ YXRjaCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4s IEFudG9uaW8gR29tZXMgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4gb24gMjAwOS0wOS0w NAorICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIEFk ZCB0aGUgYWx0ZXJuYXRpdmUgUXRMYXVuY2hlciAoYmFzZWQgb24gUUdyYXBoaWNzVmlldykgdG8g dGhlIGJ1aWxkLgorCisgICAgICAgICogV2ViS2l0LnBybzoKKwogMjAwOS0wOS0wNyAgWGFuIExv cGV6ICA8eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgR3Vz dGF2byBOb3JvbmhhLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAyMzQzNjEwLi5lOWQ2NzNiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDExIEBACisyMDA5LTA5LTA3 ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgdGhlIHF3ZWJn cmFwaGljc2l0ZW0uY3BwIHRvIHRoZSBidWlsZCBzeXN0ZW0uCisKKyAgICAgICAgKiBXZWJDb3Jl LnBybzoKKwogMjAwOS0wOS0wNyAgRHJldyBXaWxzb24gIDxhdHdpbHNvbkBnb29nbGUuY29tPgog CiAgICAgICAgIFVucmV2aWV3ZWQgc3BlY3VsYXRpdmUgYnVpbGQgZml4LgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggNzE1OWI1Zi4u YTA5YjRlMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dl YkNvcmUucHJvCkBAIC0yMzYxLDYgKzIzNjEsNyBAQCBTT1VSQ0VTICs9IFwKICAgICAuLi9XZWJL aXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAgXAogICAgIC4uL1dl YktpdC9xdC9XZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRRdC5jcHAgXAogICAgIC4uL1dl YktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBcCisgICAgLi4vV2ViS2l0L3F0L0FwaS9xd2ViZ3Jh cGhpY3NpdGVtLmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAgXAogICAg IC4uL1dlYktpdC9xdC9BcGkvcXdlYnZpZXcuY3BwIFwKICAgICAuLi9XZWJLaXQvcXQvQXBpL3F3 ZWJlbGVtZW50LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJLaXQucHJvIGIvV2ViS2l0LnBybwppbmRl eCAwYmExNGU0Li44NjZiYjliIDEwMDY0NAotLS0gYS9XZWJLaXQucHJvCisrKyBiL1dlYktpdC5w cm8KQEAgLTUsNiArNSw3IEBAIFNVQkRJUlMgKz0gXAogICAgICAgICBXZWJDb3JlIFwKICAgICAg ICAgSmF2YVNjcmlwdENvcmUvanNjLnBybyBcCiAgICAgICAgIFdlYktpdC9xdC9RdExhdW5jaGVy IFwKKyAgICAgICAgV2ViS2l0L3F0L1FHVkxhdW5jaGVyIFwKICAgICAgICAgV2ViS2l0L3F0L3Rl c3RzCiAKICF3aW4zMjohc3ltYmlhbiB7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL2hlYWRl cnMucHJpIGIvV2ViS2l0L3F0L0FwaS9oZWFkZXJzLnByaQppbmRleCA5MmExMjBkLi4zMGEzNmVm IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL2hlYWRlcnMucHJpCisrKyBiL1dlYktpdC9xdC9B cGkvaGVhZGVycy5wcmkKQEAgLTEsNCArMSw1IEBACiBXRUJLSVRfQVBJX0hFQURFUlMgPSAkJFBX RC9xd2ViZnJhbWUuaCBcCisgICAgICAgICAgICAgICAgICAgICAkJFBXRC9xd2ViZ3JhcGhpY3Np dGVtLmggXAogICAgICAgICAgICAgICAgICAgICAgJCRQV0QvcXdlYmtpdGdsb2JhbC5oIFwKICAg ICAgICAgICAgICAgICAgICAgICQkUFdEL3F3ZWJwYWdlLmggXAogICAgICAgICAgICAgICAgICAg ICAgJCRQV0QvcXdlYnZpZXcuaCBcCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJncmFw aGljc2l0ZW0uY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41YWRlZWNhCi0tLSAvZGV2L251bGwKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcApAQCAtMCwwICsxLDcxNiBAQAorLyoK KyAgICBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJz aWRpYXJ5KC1pZXMpCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAgICBMaWNlbnNlIGFzIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgICB2ZXJzaW9uIDIg b2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisK KyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICAgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl CisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4g IElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu LCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICAgIEJvc3RvbiwgTUEgMDIxMTAt MTMwMSwgVVNBLgorKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgInF3ZWJncmFw aGljc2l0ZW0uaCIKKworI2luY2x1ZGUgInF3ZWJmcmFtZS5oIgorI2luY2x1ZGUgInF3ZWJncmFw aGljc2l0ZW1fcC5oIgorI2luY2x1ZGUgInF3ZWJwYWdlLmgiCisjaW5jbHVkZSAicXdlYnBhZ2Vf cC5oIgorI2luY2x1ZGUgPFF0L3FzdHlsZW9wdGlvbi5oPgorI2luY2x1ZGUgPFF0R3VpL3FhcHBs aWNhdGlvbi5oPgorI2luY2x1ZGUgPFF0R3VpL3FncmFwaGljc3NjZW5lZXZlbnQuaD4KKyNpbmNs dWRlIDxRR3JhcGhpY3NTY2VuZT4KKyNpbmNsdWRlIDxRR3JhcGhpY3NWaWV3PgorCisvKiEKKyAg ICBcYnJpZWYgUVdlYkdyYWhpY3NJdGVtIGFsbG93cyB3ZWIgY29udGVudCB0byBiZSBhZGRlZCB0 byBhIGNhbnZhcy4KKyAgICBcaW5oZXJpdHMgUUdyYXBoaWNzV2lkZ2V0LgorICAgIFxzaW5jZSA0 LjYKKworICAgIEEgV2ViR3JhcGhpY3NJdGVtIHJlbmRlcnMgd2ViIGNvbnRlbnQgYmFzZWQgb24g YSBVUkwgb3Igc2V0IGRhdGEuCisKKyAgICBJZiB0aGUgd2lkdGggYW5kIGhlaWdodCBvZiB0aGUg aXRlbSBpcyBub3Qgc2V0LCB0aGV5IHdpbGwKKyAgICBkeW5hbWljYWxseSBhZGp1c3QgdG8gYSBz aXplIGFwcHJvcHJpYXRlIGZvciB0aGUgY29udGVudC4KKyAgICBUaGlzIHdpZHRoIG1heSBiZSBs YXJnZSAoZWcuIDk4MCkgZm9yIHR5cGljYWwgb25saW5lIHdlYiBwYWdlcy4KKyovCisKKy8qIQor ICAgIENvbnN0cnVjdHMgYW4gZW1wdHkgUVdlYkdyYXBoaWNzSXRlbSB3aXRoIHBhcmVudCBcYSBw YXJlbnQvCisKKyAgICBcc2EgbG9hZCgpCisqLworUVdlYkdyYXBoaWNzSXRlbTo6UVdlYkdyYXBo aWNzSXRlbShRR3JhcGhpY3NJdGVtKiBwYXJlbnQpCisgICAgOiBRR3JhcGhpY3NXaWRnZXQocGFy ZW50KQorICAgICwgZChuZXcgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGUodGhpcykpCit7CisgICAg c2V0RmxhZyhRR3JhcGhpY3NJdGVtOjpJdGVtVXNlc0V4dGVuZGVkU3R5bGVPcHRpb24sIHRydWUp OworICAgIHNldEFjY2VwdEhvdmVyRXZlbnRzKHRydWUpOworICAgIHNldEZvY3VzUG9saWN5KFF0 OjpTdHJvbmdGb2N1cyk7Cit9CisKKy8qIQorICAgIERlc3Ryb3lzIHRoZSB3ZWIgZ3JhcGhpY3Np dGVtLgorKi8KK1FXZWJHcmFwaGljc0l0ZW06On5RV2ViR3JhcGhpY3NJdGVtKCkKK3sKKyAgICBp ZiAoZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+ZC0+dmlldyA9IDA7CisKKyAgICBpZiAoZC0+ cGFnZSAmJiBkLT5wYWdlLT5wYXJlbnQoKSA9PSB0aGlzKQorICAgICAgICBkZWxldGUgZC0+cGFn ZTsKKworICAgIGRlbGV0ZSBkOworfQorCisvKiEKKyAgICBSZXR1cm5zIGEgcG9pbnRlciB0byB0 aGUgdW5kZXJseWluZyB3ZWIgcGFnZS4KKworICAgIFxzYSBzZXRQYWdlKCkKKyovCitRV2ViUGFn ZSogUVdlYkdyYXBoaWNzSXRlbTo6cGFnZSgpIGNvbnN0Cit7CisgICAgaWYgKCFkLT5wYWdlKSB7 CisgICAgICAgIFFXZWJHcmFwaGljc0l0ZW0qIHRoYXQgPSBjb25zdF9jYXN0PFFXZWJHcmFwaGlj c0l0ZW0qPih0aGlzKTsKKyAgICAgICAgUVdlYlBhZ2UqIHBhZ2UgPSBuZXcgUVdlYlBhZ2UodGhh dCk7CisKKyAgICAgICAgLy8gRGVmYXVsdCB0byBub3QgaGF2aW5nIGEgYmFja2dyb3VuZCwgaW4g dGhlIGNhc2UKKyAgICAgICAgLy8gdGhlIHBhZ2UgZG9lc24ndCBwcm92aWRlIG9uZS4KKyAgICAg ICAgUVBhbGV0dGUgcGFsZXR0ZSA9IFFBcHBsaWNhdGlvbjo6cGFsZXR0ZSgpOworICAgICAgICBw YWxldHRlLnNldEJydXNoKFFQYWxldHRlOjpCYXNlLCBRQ29sb3I6OmZyb21SZ2JGKDAsIDAsIDAs IDApKTsKKyAgICAgICAgcGFnZS0+c2V0UGFsZXR0ZShwYWxldHRlKTsKKworICAgICAgICB0aGF0 LT5zZXRQYWdlKHBhZ2UpOworICAgIH0KKworICAgIHJldHVybiBkLT5wYWdlOworfQorCit2b2lk IFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb0xvYWRQcm9ncmVzcyhpbnQgcHJvZ3Jlc3Mp Cit7CisgICAgaWYgKHRoaXMtPnByb2dyZXNzID09IHByb2dyZXNzIC8gMTAwLjApCisgICAgICAg IHJldHVybjsKKworICAgIHRoaXMtPnByb2dyZXNzID0gcHJvZ3Jlc3MgLyAxMDAuMDsKKworICAg IGVtaXQgcS0+cHJvZ3Jlc3NDaGFuZ2VkKHRoaXMtPnByb2dyZXNzKTsKK30KKwordm9pZCBRV2Vi R3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9Mb2FkRmluaXNoZWQoYm9vbCBzdWNjZXNzKQorewor ICAgIC8vIElmIHRoZSBwYWdlIGhhZCBubyB0aXRsZSwgc3RpbGwgbWFrZSBzdXJlIGl0IGdldHMg dGhlIHNpZ25hbAorICAgIGlmIChxLT50aXRsZSgpLmlzRW1wdHkoKSkKKyAgICAgICAgZW1pdCBx LT51cmxDaGFuZ2VkKHEtPnVybCgpKTsKKworICAgIGlmIChzdWNjZXNzKQorICAgICAgICBlbWl0 IHEtPmxvYWRGaW5pc2hlZCgpOworICAgIGVsc2UKKyAgICAgICAgZW1pdCBxLT5sb2FkRmFpbGVk KCk7Cit9CisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9xX2RvU2Nyb2xsKGludCBk eCwgaW50IGR5LCBjb25zdCBRUmVjdCYgcmVjdFRvU2Nyb2xsKQoreworICAgIHEtPnNjcm9sbChx cmVhbChkeCksIHFyZWFsKGR5KSwgUVJlY3RGKHJlY3RUb1Njcm9sbCkpOworfQorCit2b2lkIFFX ZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb1VwZGF0ZShjb25zdCBRUmVjdCAmIGRpcnR5UmVj dCkKK3sKKyAgICBxLT51cGRhdGUoUVJlY3RGKGRpcnR5UmVjdCkpOworfQorCisvKiEgXHJlaW1w CisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpwYWludChRUGFpbnRlciogcGFpbnRlciwgY29u c3QgUVN0eWxlT3B0aW9uR3JhcGhpY3NJdGVtKiBvcHRpb24sIFFXaWRnZXQqKQoreworICAgIGQt PnBhZ2UtPm1haW5GcmFtZSgpLT5yZW5kZXIocGFpbnRlciwgb3B0aW9uLT5leHBvc2VkUmVjdC50 b1JlY3QoKSk7Cit9CisKKy8qIQorICAgIE1ha2VzIFxhIHBhZ2UgdGhlIG5ldyB3ZWIgcGFnZSBv ZiB0aGUgd2ViIGdyYXBoaWNzaXRlbS4KKworICAgIFRoZSBwYXJlbnQgUU9iamVjdCBvZiB0aGUg cHJvdmlkZWQgcGFnZSByZW1haW5zIHRoZSBvd25lcgorICAgIG9mIHRoZSBvYmplY3QuIElmIHRo ZSBjdXJyZW50IGRvY3VtZW50IGlzIGEgY2hpbGQgb2YgdGhlIHdlYgorICAgIHZpZXcsIGl0IHdp bGwgYmUgZGVsZXRlZC4KKworICAgIFxzYSBwYWdlKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0 ZW06OnNldFBhZ2UoUVdlYlBhZ2UqIHBhZ2UpCit7CisgICAgaWYgKGQtPnBhZ2UgPT0gcGFnZSkK KyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKGQtPnBhZ2UpIHsKKyAgICAgICAgaWYgKGQtPnBh Z2UtPnBhcmVudCgpID09IHRoaXMpCisgICAgICAgICAgICBkZWxldGUgZC0+cGFnZTsKKyAgICAg ICAgZWxzZQorICAgICAgICAgICAgZC0+cGFnZS0+ZGlzY29ubmVjdCh0aGlzKTsKKyAgICB9CisK KyAgICBkLT5wYWdlID0gcGFnZTsKKyAgICBpZiAoIWQtPnBhZ2UpCisgICAgICAgIHJldHVybjsK KworICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUoKS50b1NpemUoKTsKKyAgICBwYWdl LT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7CisKKyAgICBRV2ViRnJhbWUqIG1haW5GcmFtZSA9IGQt PnBhZ2UtPm1haW5GcmFtZSgpOworCisgICAgY29ubmVjdChtYWluRnJhbWUsIFNJR05BTCh0aXRs ZUNoYW5nZWQoY29uc3QgUVN0cmluZyYpKSwKKyAgICAgICAgICAgIHRoaXMsIFNJR05BTCh0aXRs ZUNoYW5nZWQoY29uc3QgUVN0cmluZyYpKSk7CisgICAgY29ubmVjdChtYWluRnJhbWUsIFNJR05B TChpY29uQ2hhbmdlZCgpKSwKKyAgICAgICAgICAgIHRoaXMsIFNJR05BTChpY29uQ2hhbmdlZCgp KSk7CisgICAgY29ubmVjdChtYWluRnJhbWUsIFNJR05BTCh1cmxDaGFuZ2VkKGNvbnN0IFFVcmwm KSksCisgICAgICAgICAgICB0aGlzLCBTSUdOQUwodXJsQ2hhbmdlZChjb25zdCBRVXJsJikpKTsK KyAgICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChsb2FkU3RhcnRlZCgpKSwKKyAgICAgICAgICAg IHRoaXMsIFNJR05BTChsb2FkU3RhcnRlZCgpKSk7CisgICAgY29ubmVjdChkLT5wYWdlLCBTSUdO QUwobG9hZFByb2dyZXNzKGludCkpLAorICAgICAgICAgICAgdGhpcywgU0xPVChfcV9kb0xvYWRQ cm9ncmVzcyhpbnQpKSk7CisgICAgY29ubmVjdChkLT5wYWdlLCBTSUdOQUwobG9hZEZpbmlzaGVk KGJvb2wpKSwKKyAgICAgICAgICAgIHRoaXMsIFNMT1QoX3FfZG9Mb2FkRmluaXNoZWQoYm9vbCkp KTsKKyAgICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChyZXBhaW50UmVxdWVzdGVkKFFSZWN0KSks CisgICAgICAgICAgICB0aGlzLCBTTE9UKF9xX2RvVXBkYXRlKGNvbnN0IFFSZWN0JikpKTsKKyAg ICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChzY3JvbGxSZXF1ZXN0ZWQoaW50LCBpbnQsIGNvbnN0 IFFSZWN0JikpLAorICAgICAgICAgICAgdGhpcywgU0xPVChfcV9kb1Njcm9sbChpbnQsIGludCwg Y29uc3QgUVJlY3QmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKHN0YXR1c0Jhck1l c3NhZ2UoY29uc3QgUVN0cmluZyYpKSwKKyAgICAgICAgICAgIHRoaXMsIFNMT1QoX3Ffc2V0U3Rh dHVzQmFyTWVzc2FnZShjb25zdCBRU3RyaW5nJikpKTsKK30KKworLyohCisgICAgXHByb3BlcnR5 IFFXZWJHcmFwaGljc0l0ZW06OnVybAorICAgIFxicmllZiB0aGUgdXJsIG9mIHRoZSB3ZWIgcGFn ZSBjdXJyZW50bHkgdmlld2VkCisKKyAgICBTZXR0aW5nIHRoaXMgcHJvcGVydHkgY2xlYXJzIHRo ZSB2aWV3IGFuZCBsb2FkcyB0aGUgVVJMLgorCisgICAgQnkgZGVmYXVsdCwgdGhpcyBwcm9wZXJ0 eSBjb250YWlucyBhbiBlbXB0eSwgaW52YWxpZCBVUkwuCisKKyAgICBcc2EgbG9hZCgpLCB1cmxD aGFuZ2VkKCkKKyovCisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0VXJsKGNvbnN0IFFVcmwg JnVybCkKK3sKKyAgICBpZiAoIWQtPnBhZ2UgfHwgZC0+cGFnZS0+bWFpbkZyYW1lKCktPnVybCgp ID09IHVybCkKKyAgICAgICAgcmV0dXJuOworCisgICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPnNl dFVybCh1cmwpOworfQorCitRVXJsIFFXZWJHcmFwaGljc0l0ZW06OnVybCgpIGNvbnN0Cit7Cisg ICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJhbWUoKS0+dXJs KCk7CisKKyAgICByZXR1cm4gUVVybCgpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdy YXBoaWNzSXRlbTo6dGl0bGUKKyAgICBcYnJpZWYgdGhlIHRpdGxlIG9mIHRoZSB3ZWIgcGFnZSBj dXJyZW50bHkgdmlld2VkCisKKyAgICBCeSBkZWZhdWx0LCB0aGlzIHByb3BlcnR5IGNvbnRhaW5z IGFuIGVtcHR5IHN0cmluZy4KKworICAgIFxzYSB0aXRsZUNoYW5nZWQoKQorKi8KK1FTdHJpbmcg UVdlYkdyYXBoaWNzSXRlbTo6dGl0bGUoKSBjb25zdAoreworICAgIGlmIChkLT5wYWdlKQorICAg ICAgICByZXR1cm4gZC0+cGFnZS0+bWFpbkZyYW1lKCktPnRpdGxlKCk7CisKKyAgICByZXR1cm4g UVN0cmluZygpOworfQorCisvKiEKKyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6aWNv bgorICAgIFxicmllZiB0aGUgaWNvbiBhc3NvY2lhdGVkIHdpdGggdGhlIHdlYiBwYWdlIGN1cnJl bnRseSB2aWV3ZWQKKworICAgIEJ5IGRlZmF1bHQsIHRoaXMgcHJvcGVydHkgY29udGFpbnMgYSBu dWxsIGljb24uCisKKyAgICBcc2EgaWNvbkNoYW5nZWQoKSwgUVdlYlNldHRpbmdzOjppY29uRm9y VXJsKCkKKyovCitRSWNvbiBRV2ViR3JhcGhpY3NJdGVtOjppY29uKCkgY29uc3QKK3sKKyAgICBy ZXR1cm4gZC0+cGFnZS0+bWFpbkZyYW1lKCktPmljb24oKTsKK30KKworLyohCisgICAgXHByb3Bl cnR5IFFXZWJHcmFwaGljc0l0ZW06Onpvb21GYWN0b3IKKyAgICBcc2luY2UgNC41CisgICAgXGJy aWVmIHRoZSB6b29tIGZhY3RvciBmb3IgdGhlIHZpZXcKKyovCisKK3ZvaWQgUVdlYkdyYXBoaWNz SXRlbTo6c2V0Wm9vbUZhY3RvcihxcmVhbCBmYWN0b3IpCit7CisgICAgaWYgKGZhY3RvciA9PSBk LT5wYWdlLT5tYWluRnJhbWUoKS0+em9vbUZhY3RvcigpKQorICAgICAgICByZXR1cm47CisKKyAg ICBkLT5wYWdlLT5tYWluRnJhbWUoKS0+c2V0Wm9vbUZhY3RvcihmYWN0b3IpOworCisgICAgZW1p dCB6b29tRmFjdG9yQ2hhbmdlZCgpOworfQorCitxcmVhbCBRV2ViR3JhcGhpY3NJdGVtOjp6b29t RmFjdG9yKCkgY29uc3QKK3sKKyAgICByZXR1cm4gZC0+cGFnZS0+bWFpbkZyYW1lKCktPnpvb21G YWN0b3IoKTsKK30KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3Ffc2V0U3RhdHVz QmFyTWVzc2FnZShjb25zdCBRU3RyaW5nJiBzKQoreworICAgIHN0YXR1c0Jhck1lc3NhZ2UgPSBz OworICAgIHEtPmVtaXQgc3RhdHVzQ2hhbmdlZCgpOworfQorCisvKiEgXHJlaW1wCisqLwordm9p ZCBRV2ViR3JhcGhpY3NJdGVtOjp1cGRhdGVHZW9tZXRyeSgpCit7CisgICAgUUdyYXBoaWNzV2lk Z2V0Ojp1cGRhdGVHZW9tZXRyeSgpOworICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUo KS50b1NpemUoKTsKKyAgICBkLT5wYWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7Cit9CisKKy8q ISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnNldEdlb21ldHJ5KGNvbnN0IFFS ZWN0RiYgcmVjdCkKK3sKKyAgICBRR3JhcGhpY3NXaWRnZXQ6OnNldEdlb21ldHJ5KHJlY3QpOwor ICAgIC8vIE5PVEU6IGNhbGwgZ2VvbWV0cnkoKSBhcyBzZXRHZW9tZXRyeSBlbnN1cmVzIHRoYXQK KyAgICAvLyB0aGUgZ2VvbWV0cnkgaXMgd2l0aGluIGxlZ2FsIGJvdW5kcyAobWluaW11bVNpemUs IG1heGltdW1TaXplKQorICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUoKS50b1NpemUo KTsKKyAgICBkLT5wYWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7Cit9CisKKy8qIQorICAgIFxi cmllZiBUaGUgbG9hZCBzdGF0dXMgbWVzc2FnZSBhc3NvY2lhdGVkIHRvIHRoZSB3ZWIgZ3JhcGhp Y3NpdGVtCisKKyAgICBQcm92aWRlcyB0aGUgbGF0ZXN0IHN0YXR1cyBtZXNzYWdlIHNldCBkdXJp bmcgdGhlIGxvYWQgb2YgYSBVUkwuCisgICAgQ29tbW9ubHkgc2hvd24gYnkgU3RhdHVzIEJhciB3 aWRnZXRzLgorCisgICAgXHNhIHN0YXR1c0NoYW5nZWQoKQorKi8KKworUVN0cmluZyBRV2ViR3Jh cGhpY3NJdGVtOjpzdGF0dXMoKSBjb25zdAoreworICAgIHJldHVybiBkLT5zdGF0dXNCYXJNZXNz YWdlOworfQorCisvKiEKKyAgICBDb252ZW5pZW5jZSBzbG90IHRoYXQgc3RvcHMgbG9hZGluZyB0 aGUgZG9jdW1lbnQuCisKKyAgICBcc2EgcmVsb2FkKCksIHBhZ2VBY3Rpb24oKSwgbG9hZEZpbmlz aGVkKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnN0b3AoKQoreworICAgIGlmIChkLT5w YWdlKQorICAgICAgICBkLT5wYWdlLT50cmlnZ2VyQWN0aW9uKFFXZWJQYWdlOjpTdG9wKTsKK30K KworLyohCisgICAgQ29udmVuaWVuY2Ugc2xvdCB0aGF0IGxvYWRzIHRoZSBwcmV2aW91cyBkb2N1 bWVudCBpbiB0aGUgbGlzdCBvZiBkb2N1bWVudHMKKyAgICBidWlsdCBieSBuYXZpZ2F0aW5nIGxp bmtzLiBEb2VzIG5vdGhpbmcgaWYgdGhlcmUgaXMgbm8gcHJldmlvdXMgZG9jdW1lbnQuCisKKyAg ICBcc2EgZm9yd2FyZCgpLCBwYWdlQWN0aW9uKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06 OmJhY2soKQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT50cmlnZ2VyQWN0 aW9uKFFXZWJQYWdlOjpCYWNrKTsKK30KKworLyohCisgICAgQ29udmVuaWVuY2Ugc2xvdCB0aGF0 IGxvYWRzIHRoZSBuZXh0IGRvY3VtZW50IGluIHRoZSBsaXN0IG9mIGRvY3VtZW50cworICAgIGJ1 aWx0IGJ5IG5hdmlnYXRpbmcgbGlua3MuIERvZXMgbm90aGluZyBpZiB0aGVyZSBpcyBubyBuZXh0 IGRvY3VtZW50LgorCisgICAgXHNhIGJhY2soKSwgcGFnZUFjdGlvbigpCisqLwordm9pZCBRV2Vi R3JhcGhpY3NJdGVtOjpmb3J3YXJkKCkKK3sKKyAgICBpZiAoZC0+cGFnZSkKKyAgICAgICAgZC0+ cGFnZS0+dHJpZ2dlckFjdGlvbihRV2ViUGFnZTo6Rm9yd2FyZCk7Cit9CisKKy8qIQorICAgIFJl bG9hZHMgdGhlIGN1cnJlbnQgZG9jdW1lbnQuCisKKyAgICBcc2Egc3RvcCgpLCBwYWdlQWN0aW9u KCksIGxvYWRTdGFydGVkKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnJlbG9hZCgpCit7 CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBh Z2U6OlJlbG9hZCk7Cit9CisKKy8qIQorICAgIFxwcm9wZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjpw cm9ncmVzcworICAgIFxicmllZiB0aGUgcHJvZ3Jlc3Mgb2YgbG9hZGluZyB0aGUgY3VycmVudCBV UkwsIGZyb20gMCB0byAxLgorKi8KK3FyZWFsIFFXZWJHcmFwaGljc0l0ZW06OnByb2dyZXNzKCkg Y29uc3QKK3sKKyAgICByZXR1cm4gZC0+cHJvZ3Jlc3M7Cit9CisKKy8qIQorICAgIExvYWRzIHRo ZSBzcGVjaWZpZWQgXGEgdXJsIGFuZCBkaXNwbGF5cyBpdC4KKworICAgIFxub3RlIFRoZSB2aWV3 IHJlbWFpbnMgdGhlIHNhbWUgdW50aWwgZW5vdWdoIGRhdGEgaGFzIGFycml2ZWQgdG8gZGlzcGxh eSB0aGUgbmV3IFxhIHVybC4KKworICAgIFxzYSBzZXRVcmwoKSwgdXJsKCksIHVybENoYW5nZWQo KQorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6bG9hZChjb25zdCBRVXJsJiB1cmwpCit7Cisg ICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPmxvYWQodXJsKTsKK30KKworLyohCisgICAgXGZuIHZv aWQgUVdlYkdyYXBoaWNzSXRlbTo6bG9hZChjb25zdCBRTmV0d29ya1JlcXVlc3QgJnJlcXVlc3Qs IFFOZXR3b3JrQWNjZXNzTWFuYWdlcjo6T3BlcmF0aW9uIG9wZXJhdGlvbiwgY29uc3QgUUJ5dGVB cnJheSAmYm9keSkKKworICAgIExvYWRzIGEgbmV0d29yayByZXF1ZXN0LCBcYSByZXF1ZXN0LCB1 c2luZyB0aGUgbWV0aG9kIHNwZWNpZmllZCBpbiBcYSBvcGVyYXRpb24uCisKKyAgICBcYSBib2R5 IGlzIG9wdGlvbmFsIGFuZCBpcyBvbmx5IHVzZWQgZm9yIFBPU1Qgb3BlcmF0aW9ucy4KKworICAg IFxub3RlIFRoZSB2aWV3IHJlbWFpbnMgdGhlIHNhbWUgdW50aWwgZW5vdWdoIGRhdGEgaGFzIGFy cml2ZWQgdG8gZGlzcGxheSB0aGUgbmV3IHVybC4KKworICAgIFxzYSB1cmwoKSwgdXJsQ2hhbmdl ZCgpCisqLworCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1 ZXN0JiByZXF1ZXN0LAorICAgICAgICAgICAgICAgICAgICBRTmV0d29ya0FjY2Vzc01hbmFnZXI6 Ok9wZXJhdGlvbiBvcGVyYXRpb24sCisgICAgICAgICAgICAgICAgICAgIGNvbnN0IFFCeXRlQXJy YXkmIGJvZHkpCit7CisgICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPmxvYWQocmVxdWVzdCwgb3Bl cmF0aW9uLCBib2R5KTsKK30KKworLyohCisgICAgU2V0cyB0aGUgY29udGVudCBvZiB0aGUgd2Vi IGdyYXBoaWNzaXRlbSB0byB0aGUgc3BlY2lmaWVkIFxhIGh0bWwuCisKKyAgICBFeHRlcm5hbCBv YmplY3RzIHN1Y2ggYXMgc3R5bGVzaGVldHMgb3IgaW1hZ2VzIHJlZmVyZW5jZWQgaW4gdGhlIEhU TUwKKyAgICBkb2N1bWVudCBhcmUgbG9jYXRlZCByZWxhdGl2ZSB0byBcYSBiYXNlVXJsLgorCisg ICAgVGhlIFxhIGh0bWwgaXMgbG9hZGVkIGltbWVkaWF0ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFy ZSBsb2FkZWQgYXN5bmNocm9ub3VzbHkuCisKKyAgICBXaGVuIHVzaW5nIHRoaXMgbWV0aG9kLCBX ZWJLaXQgYXNzdW1lcyB0aGF0IGV4dGVybmFsIHJlc291cmNlcyBzdWNoIGFzCisgICAgSmF2YVNj cmlwdCBwcm9ncmFtcyBvciBzdHlsZSBzaGVldHMgYXJlIGVuY29kZWQgaW4gVVRGLTggdW5sZXNz IG90aGVyd2lzZQorICAgIHNwZWNpZmllZC4gRm9yIGV4YW1wbGUsIHRoZSBlbmNvZGluZyBvZiBh biBleHRlcm5hbCBzY3JpcHQgY2FuIGJlIHNwZWNpZmllZAorICAgIHRocm91Z2ggdGhlIGNoYXJz ZXQgYXR0cmlidXRlIG9mIHRoZSBIVE1MIHNjcmlwdCB0YWcuIEFsdGVybmF0aXZlbHksIHRoZQor ICAgIGVuY29kaW5nIGNhbiBhbHNvIGJlIHNwZWNpZmllZCBieSB0aGUgd2ViIHNlcnZlci4KKwor ICAgIFxzYSBsb2FkKCksIHNldENvbnRlbnQoKSwgUVdlYkZyYW1lOjp0b0h0bWwoKQorKi8KK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0SHRtbChjb25zdCBRU3RyaW5nJiBodG1sLCBjb25zdCBR VXJsJiBiYXNlVXJsKQoreworICAgIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT5zZXRIdG1sKGh0bWws IGJhc2VVcmwpOworfQorCitRU3RyaW5nIFFXZWJHcmFwaGljc0l0ZW06OnRvSHRtbCgpIGNvbnN0 Cit7CisgICAgcmV0dXJuIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT50b0h0bWwoKTsKK30KKworLyoh CisgICAgU2V0cyB0aGUgY29udGVudCBvZiB0aGUgd2ViIGdyYXBoaWNzaXRlbSB0byB0aGUgc3Bl Y2lmaWVkIGNvbnRlbnQgXGEgZGF0YS4gSWYgdGhlIFxhIG1pbWVUeXBlIGFyZ3VtZW50CisgICAg aXMgZW1wdHkgaXQgaXMgY3VycmVudGx5IGFzc3VtZWQgdGhhdCB0aGUgY29udGVudCBpcyBIVE1M IGJ1dCBpbiBmdXR1cmUgdmVyc2lvbnMgd2UgbWF5IGludHJvZHVjZQorICAgIGF1dG8tZGV0ZWN0 aW9uLgorCisgICAgRXh0ZXJuYWwgb2JqZWN0cyByZWZlcmVuY2VkIGluIHRoZSBjb250ZW50IGFy ZSBsb2NhdGVkIHJlbGF0aXZlIHRvIFxhIGJhc2VVcmwuCisKKyAgICBUaGUgXGEgZGF0YSBpcyBs b2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25v dXNseS4KKworICAgIFxzYSBsb2FkKCksIHNldEh0bWwoKSwgUVdlYkZyYW1lOjp0b0h0bWwoKQor Ki8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0Q29udGVudChjb25zdCBRQnl0ZUFycmF5JiBk YXRhLCBjb25zdCBRU3RyaW5nJiBtaW1lVHlwZSwgY29uc3QgUVVybCYgYmFzZVVybCkKK3sKKyAg ICBkLT5wYWdlLT5tYWluRnJhbWUoKS0+c2V0Q29udGVudChkYXRhLCBtaW1lVHlwZSwgYmFzZVVy bCk7Cit9CisKKy8qIQorICAgIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSB2aWV3J3MgaGlzdG9y eSBvZiBuYXZpZ2F0ZWQgd2ViIHBhZ2VzLgorCisgICAgSXQgaXMgZXF1aXZhbGVudCB0bworCisg ICAgXHNuaXBwZXQgd2Via2l0c25pcHBldHMvcXR3ZWJraXRfcXdlYnZpZXdfc25pcHBldC5jcHAg MAorKi8KK1FXZWJIaXN0b3J5KiBRV2ViR3JhcGhpY3NJdGVtOjpoaXN0b3J5KCkgY29uc3QKK3sK KyAgICByZXR1cm4gZC0+cGFnZS0+aGlzdG9yeSgpOworfQorCisvKiEKKyAgXHByb3BlcnR5IFFX ZWJHcmFwaGljc0l0ZW06OmludGVyYWN0aXZlCisgIFxicmllZiBjb250cm9scyB3aGV0aGVyIHRo ZSBpdGVtIHJlc3BvbmRzIHRvIG1vdXNlIGFuZCBrZXkgZXZlbnRzLgorKi8KKworYm9vbCBRV2Vi R3JhcGhpY3NJdGVtOjppbnRlcmFjdGl2ZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGQtPmludGVy YWN0aXZlOworfQorCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnNldEludGVyYWN0aXZlKGJvb2wg YWxsb3dlZCkKK3sKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgPT0gYWxsb3dlZCkKKyAgICAgICAg cmV0dXJuOworCisgICAgZC0+aW50ZXJhY3RpdmUgPSBhbGxvd2VkOworICAgIGVtaXQgaW50ZXJh Y3RpdmVDaGFuZ2VkKCk7Cit9CisKKy8qIQorICAgIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSB2 aWV3L3BhZ2Ugc3BlY2lmaWMgc2V0dGluZ3Mgb2JqZWN0LgorCisgICAgSXQgaXMgZXF1aXZhbGVu dCB0bworCisgICAgXHNuaXBwZXQgd2Via2l0c25pcHBldHMvcXR3ZWJraXRfcXdlYnZpZXdfc25p cHBldC5jcHAgMQorCisgICAgXHNhIFFXZWJTZXR0aW5nczo6Z2xvYmFsU2V0dGluZ3MoKQorKi8K K1FXZWJTZXR0aW5ncyogUVdlYkdyYXBoaWNzSXRlbTo6c2V0dGluZ3MoKSBjb25zdAoreworICAg IHJldHVybiBkLT5wYWdlLT5zZXR0aW5ncygpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBR V2ViR3JhcGhpY3NJdGVtOjpob3Zlck1vdmVFdmVudChRR3JhcGhpY3NTY2VuZUhvdmVyRXZlbnQq IGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNv bnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBRTW91c2VFdmVu dCBtZSA9IFFNb3VzZUV2ZW50KFFFdmVudDo6TW91c2VNb3ZlLAorICAgICAgICAgICAgICAgIGV2 LT5wb3MoKS50b1BvaW50KCksIFF0OjpOb0J1dHRvbiwKKyAgICAgICAgICAgICAgICBRdDo6Tm9C dXR0b24sIFF0OjpOb01vZGlmaWVyKTsKKyAgICAgICAgZC0+cGFnZS0+c2V0Vmlldyhldi0+d2lk Z2V0KCkpOworICAgICAgICBkLT5wYWdlLT5ldmVudCgmbWUpOworICAgICAgICBldi0+c2V0QWNj ZXB0ZWQoYWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAg ICAgICAgUUdyYXBoaWNzSXRlbTo6aG92ZXJNb3ZlRXZlbnQoZXYpOworfQorCisvKiEgXHJlaW1w CisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpob3ZlckxlYXZlRXZlbnQoUUdyYXBoaWNzU2Nl bmVIb3ZlckV2ZW50KiBldikKK3sKKyAgICBRX1VOVVNFRChldik7Cit9CisKKy8qISBccmVpbXAK KyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06Om1vdXNlTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5l TW91c2VFdmVudCogZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsK KyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAg IGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsK KyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0 ZW06Om1vdXNlTW92ZUV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdy YXBoaWNzSXRlbTo6bW91c2VQcmVzc0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCogZXYp Cit7CisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3Qg Ym9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50 KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBp ZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0ZW06Om1vdXNlUHJlc3NF dmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06Om1v dXNlUmVsZWFzZUV2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCogZXYpCit7CisgICAgaWYg KGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRl ZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAg ICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0Fj Y2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0ZW06Om1vdXNlUmVsZWFzZUV2ZW50KGV2KTsK K30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6bW91c2VEb3VibGVD bGlja0V2ZW50KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCogZXYpCit7CisgICAgaWYgKGQtPmlu dGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2 LT5pc0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYt PnNldEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVk KCkpCisgICAgICAgIFFHcmFwaGljc0l0ZW06Om1vdXNlRG91YmxlQ2xpY2tFdmVudChldik7Cit9 CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmtleVByZXNzRXZlbnQo UUtleUV2ZW50KiBldikKK3sKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkKKyAg ICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQor ICAgICAgICBRR3JhcGhpY3NJdGVtOjprZXlQcmVzc0V2ZW50KGV2KTsKK30KKworLyohIFxyZWlt cAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6a2V5UmVsZWFzZUV2ZW50KFFLZXlFdmVudCog ZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpCisgICAgICAgIGQtPnBh Z2UtPmV2ZW50KGV2KTsKKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdy YXBoaWNzSXRlbTo6a2V5UmVsZWFzZUV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6Zm9jdXNJbkV2ZW50KFFGb2N1c0V2ZW50KiBldikKK3sKKyAg ICBpZiAoZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgIGVsc2UKKyAg ICAgICAgUUdyYXBoaWNzSXRlbTo6Zm9jdXNJbkV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAor Ki8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6Zm9jdXNPdXRFdmVudChRRm9jdXNFdmVudCogZXYp Cit7CisgICAgaWYgKGQtPnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICBl bHNlCisgICAgICAgIFFHcmFwaGljc0l0ZW06OmZvY3VzT3V0RXZlbnQoZXYpOworfQorCisvKiEg XHJlaW1wCisqLworYm9vbCBRV2ViR3JhcGhpY3NJdGVtOjpmb2N1c05leHRQcmV2Q2hpbGQoYm9v bCBuZXh0KQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAgICByZXR1cm4gZC0+cGFnZS0+Zm9j dXNOZXh0UHJldkNoaWxkKG5leHQpOworCisgICAgcmV0dXJuIFFHcmFwaGljc1dpZGdldDo6Zm9j dXNOZXh0UHJldkNoaWxkKG5leHQpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3Jh cGhpY3NJdGVtOjpkcmFnRW50ZXJFdmVudChRR3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2 KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5ERFJPUAorICAgIC8vaWYgKGQtPnBhZ2UpCisgICAg Ly8gICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgIC8vSnVzdCByZW1vdmUgdGhpcyBsaW5lIGJl bG93IHdoZW4gdGhlIGNvZGUgYWJvdmUgaXMgd29ya2luZworICAgIFFfVU5VU0VEKGV2KTsKKyNl bHNlCisgICAgUV9VTlVTRUQoZXYpOworI2VuZGlmCit9CisKKy8qISBccmVpbXAKKyovCit2b2lk IFFXZWJHcmFwaGljc0l0ZW06OmRyYWdMZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BF dmVudCogZXYpCit7CisjaWZuZGVmIFFUX05PX0RSQUdBTkREUk9QCisgICAgaWYgKGQtPmludGVy YWN0aXZlICYmIGQtPnBhZ2UpIHsKKyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5p c0FjY2VwdGVkKCk7CisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNl dEFjY2VwdGVkKGFjY2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkp CisgICAgICAgIFFHcmFwaGljc1dpZGdldDo6ZHJhZ0xlYXZlRXZlbnQoZXYpOworI2Vsc2UKKyAg ICBRX1VOVVNFRChldik7CisjZW5kaWYKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdy YXBoaWNzSXRlbTo6ZHJhZ01vdmVFdmVudChRR3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2 KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5ERFJPUAorICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAm JiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRl ZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRl ZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAg ICBRR3JhcGhpY3NXaWRnZXQ6OmRyYWdNb3ZlRXZlbnQoZXYpOworI2Vsc2UKKyAgICBRX1VOVVNF RChldik7CisjZW5kaWYKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRl bTo6ZHJvcEV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCogZXYpCit7CisjaWZuZGVm IFFUX05PX0RSQUdBTkREUk9QCisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpIHsK KyAgICAgICAgY29uc3QgYm9vbCBhY2NlcHRlZCA9IGV2LT5pc0FjY2VwdGVkKCk7CisgICAgICAg IGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFjY2VwdGVkKTsK KyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc1dp ZGdldDo6ZHJvcEV2ZW50KGV2KTsKKyNlbHNlCisgICAgUV9VTlVTRUQoZXYpOworI2VuZGlmCit9 CisKKyNpZm5kZWYgUVRfTk9fQ09OVEVYVE1FTlUKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJH cmFwaGljc0l0ZW06OmNvbnRleHRNZW51RXZlbnQoUUNvbnRleHRNZW51RXZlbnQqIGV2KQorewor ICAgIGlmIChkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNB Y2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRB Y2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorfQorI2VuZGlmIC8vIFFUX05PX0NPTlRFWFRNRU5V CisKKyNpZm5kZWYgUVRfTk9fV0hFRUxFVkVOVAorLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdy YXBoaWNzSXRlbTo6d2hlZWxFdmVudChRR3JhcGhpY3NTY2VuZVdoZWVsRXZlbnQqIGV2KQorewor ICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wg YWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7 CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFl di0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjp3aGVlbEV2ZW50KGV2KTsK K30KKyNlbmRpZiAvLyBRVF9OT19XSEVFTEVWRU5UCisKKy8qISBccmVpbXAKKyovCit2b2lkIFFX ZWJHcmFwaGljc0l0ZW06OmlucHV0TWV0aG9kRXZlbnQoUUlucHV0TWV0aG9kRXZlbnQqIGV2KQor eworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5l dmVudChldik7CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGlj c0l0ZW06OmlucHV0TWV0aG9kRXZlbnQoZXYpOworfQorCisjaW5jbHVkZSAibW9jX3F3ZWJncmFw aGljc2l0ZW0uY3BwIgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVt LmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi4xNjQ2MWQ4Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L3F0L0Fw aS9xd2ViZ3JhcGhpY3NpdGVtLmgKQEAgLTAsMCArMSwxNDMgQEAKKy8qCisgICAgQ29weXJpZ2h0 IChDKSAyMDA5IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQor CisgICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgorICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljCisgICAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgICAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICAgVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg ICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICAgIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAgICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyov CisKKyNpZm5kZWYgUVdlYkdyYXBoaWNzSXRlbV9oCisjZGVmaW5lIFFXZWJHcmFwaGljc0l0ZW1f aAorCisjaW5jbHVkZSAicXdlYmtpdGdsb2JhbC5oIgorI2luY2x1ZGUgPFF0L3FldmVudC5oPgor I2luY2x1ZGUgPFF0Q29yZS9xdXJsLmg+CisjaW5jbHVkZSA8UXRHdWkvcWdyYXBoaWNzd2lkZ2V0 Lmg+CisjaW5jbHVkZSA8UXRHdWkvcWljb24uaD4KKyNpbmNsdWRlIDxRdEd1aS9xcGFpbnRlci5o PgorI2luY2x1ZGUgPFF0TmV0d29yay9xbmV0d29ya2FjY2Vzc21hbmFnZXIuaD4KKworY2xhc3Mg UVdlYlBhZ2U7CitjbGFzcyBRV2ViSGlzdG9yeTsKK2NsYXNzIFFXZWJTZXR0aW5nczsKKworY2xh c3MgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU7CisKK2NsYXNzIFFXRUJLSVRfRVhQT1JUIFFXZWJH cmFwaGljc0l0ZW0gOiBwdWJsaWMgUUdyYXBoaWNzV2lkZ2V0IHsKKyAgICBRX09CSkVDVAorCisg ICAgUV9QUk9QRVJUWShRU3RyaW5nIHRpdGxlIFJFQUQgdGl0bGUgTk9USUZZIHRpdGxlQ2hhbmdl ZCkKKyAgICBRX1BST1BFUlRZKFFJY29uIGljb24gUkVBRCBpY29uIE5PVElGWSBpY29uQ2hhbmdl ZCkKKyAgICBRX1BST1BFUlRZKHFyZWFsIHpvb21GYWN0b3IgUkVBRCB6b29tRmFjdG9yIFdSSVRF IHNldFpvb21GYWN0b3IgTk9USUZZIHpvb21GYWN0b3JDaGFuZ2VkKQorICAgIFFfUFJPUEVSVFko UVN0cmluZyBzdGF0dXMgUkVBRCBzdGF0dXMgTk9USUZZIHN0YXR1c0NoYW5nZWQpCisKKyAgICBR X1BST1BFUlRZKFFTdHJpbmcgaHRtbCBSRUFEIHRvSHRtbCBXUklURSBzZXRIdG1sKQorICAgIFFf UFJPUEVSVFkoUVVybCB1cmwgUkVBRCB1cmwgV1JJVEUgc2V0VXJsIE5PVElGWSB1cmxDaGFuZ2Vk KQorICAgIFFfUFJPUEVSVFkocXJlYWwgcHJvZ3Jlc3MgUkVBRCBwcm9ncmVzcyBOT1RJRlkgcHJv Z3Jlc3NDaGFuZ2VkKQorCisgICAgUV9QUk9QRVJUWShib29sIGludGVyYWN0aXZlIFJFQUQgaW50 ZXJhY3RpdmUgV1JJVEUgc2V0SW50ZXJhY3RpdmUgTk9USUZZIGludGVyYWN0aXZlQ2hhbmdlZCkK KworcHVibGljOgorICAgIFFXZWJHcmFwaGljc0l0ZW0oUUdyYXBoaWNzSXRlbSogcGFyZW50ID0g MCk7CisgICAgflFXZWJHcmFwaGljc0l0ZW0oKTsKKworICAgIFFXZWJQYWdlKiBwYWdlKCkgY29u c3Q7CisgICAgdm9pZCBzZXRQYWdlKFFXZWJQYWdlKik7CisKKyAgICBRVXJsIHVybCgpIGNvbnN0 OworICAgIHZvaWQgc2V0VXJsKGNvbnN0IFFVcmwmKTsKKworICAgIFFTdHJpbmcgdGl0bGUoKSBj b25zdDsKKyAgICBRSWNvbiBpY29uKCkgY29uc3Q7CisKKyAgICBxcmVhbCB6b29tRmFjdG9yKCkg Y29uc3Q7CisgICAgdm9pZCBzZXRab29tRmFjdG9yKHFyZWFsKTsKKworICAgIGJvb2wgaW50ZXJh Y3RpdmUoKSBjb25zdDsKKyAgICB2b2lkIHNldEludGVyYWN0aXZlKGJvb2wpOworCisgICAgcXJl YWwgcHJvZ3Jlc3MoKSBjb25zdDsKKworICAgIHZvaWQgbG9hZChjb25zdCBRVXJsICZ1cmwpOwor ICAgIHZvaWQgbG9hZChjb25zdCBRTmV0d29ya1JlcXVlc3QmIHJlcXVlc3QsIFFOZXR3b3JrQWNj ZXNzTWFuYWdlcjo6T3BlcmF0aW9uIG9wZXJhdGlvbiA9IFFOZXR3b3JrQWNjZXNzTWFuYWdlcjo6 R2V0T3BlcmF0aW9uLCBjb25zdCBRQnl0ZUFycmF5JiBib2R5ID0gUUJ5dGVBcnJheSgpKTsKKwor ICAgIFFTdHJpbmcgdG9IdG1sKCkgY29uc3Q7CisgICAgdm9pZCBzZXRIdG1sKGNvbnN0IFFTdHJp bmcmIGh0bWwsIGNvbnN0IFFVcmwmIGJhc2VVcmwgPSBRVXJsKCkpOworICAgIC8vIEZJWE1FOiBD b25zaWRlciByZW5hbWUgdG8gc2V0SHRtbD8KKyAgICB2b2lkIHNldENvbnRlbnQoY29uc3QgUUJ5 dGVBcnJheSYgZGF0YSwgY29uc3QgUVN0cmluZyYgbWltZVR5cGUgPSBRU3RyaW5nKCksIGNvbnN0 IFFVcmwmIGJhc2VVcmwgPSBRVXJsKCkpOworCisgICAgUVdlYkhpc3RvcnkqIGhpc3RvcnkoKSBj b25zdDsKKyAgICBRV2ViU2V0dGluZ3MqIHNldHRpbmdzKCkgY29uc3Q7CisKKyAgICBRU3RyaW5n IHN0YXR1cygpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHNldEdlb21ldHJ5KGNvbnN0IFFS ZWN0RiYgcmVjdCk7CisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZUdlb21ldHJ5KCk7CisgICAgdmly dHVhbCB2b2lkIHBhaW50KFFQYWludGVyKiwgY29uc3QgUVN0eWxlT3B0aW9uR3JhcGhpY3NJdGVt KiBvcHRpb25zLCBRV2lkZ2V0KiB3aWRnZXQgPSAwKTsKKworcHVibGljIFFfU0xPVFM6CisgICAg dm9pZCBzdG9wKCk7CisgICAgdm9pZCBiYWNrKCk7CisgICAgdm9pZCBmb3J3YXJkKCk7CisgICAg dm9pZCByZWxvYWQoKTsKKworUV9TSUdOQUxTOgorICAgIHZvaWQgbG9hZFN0YXJ0ZWQoKTsKKyAg ICB2b2lkIGxvYWRGaW5pc2hlZCgpOworICAgIHZvaWQgbG9hZEZhaWxlZCgpOworCisgICAgdm9p ZCBwcm9ncmVzc0NoYW5nZWQocXJlYWwpOworICAgIHZvaWQgaW50ZXJhY3RpdmVDaGFuZ2VkKCk7 CisgICAgdm9pZCB1cmxDaGFuZ2VkKGNvbnN0IFFVcmwmKTsKKyAgICB2b2lkIHRpdGxlQ2hhbmdl ZChjb25zdCBRU3RyaW5nJik7CisgICAgdm9pZCBpY29uQ2hhbmdlZCgpOworICAgIHZvaWQgc3Rh dHVzQ2hhbmdlZCgpOworICAgIHZvaWQgem9vbUZhY3RvckNoYW5nZWQoKTsKKworcHJvdGVjdGVk OgorICAgIHZpcnR1YWwgdm9pZCBtb3VzZVByZXNzRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3VzZUV2 ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIG1vdXNlRG91YmxlQ2xpY2tFdmVudChRR3JhcGhpY3NT Y2VuZU1vdXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgbW91c2VSZWxlYXNlRXZlbnQoUUdy YXBoaWNzU2NlbmVNb3VzZUV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIG1vdXNlTW92ZUV2ZW50 KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBob3Zlck1vdmVF dmVudChRR3JhcGhpY3NTY2VuZUhvdmVyRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgaG92ZXJM ZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJFdmVudCopOworI2lmbmRlZiBRVF9OT19XSEVF TEVWRU5UCisgICAgdmlydHVhbCB2b2lkIHdoZWVsRXZlbnQoUUdyYXBoaWNzU2NlbmVXaGVlbEV2 ZW50Kik7CisjZW5kaWYKKyAgICB2aXJ0dWFsIHZvaWQga2V5UHJlc3NFdmVudChRS2V5RXZlbnQq KTsKKyAgICB2aXJ0dWFsIHZvaWQga2V5UmVsZWFzZUV2ZW50KFFLZXlFdmVudCopOworI2lmbmRl ZiBRVF9OT19DT05URVhUTUVOVQorICAgIHZpcnR1YWwgdm9pZCBjb250ZXh0TWVudUV2ZW50KFFD b250ZXh0TWVudUV2ZW50Kik7CisjZW5kaWYKKyAgICB2aXJ0dWFsIHZvaWQgZHJhZ0VudGVyRXZl bnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyYWdM ZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCopOworICAgIHZpcnR1YWwgdm9p ZCBkcmFnTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCopOworICAgIHZpcnR1 YWwgdm9pZCBkcm9wRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmly dHVhbCB2b2lkIGZvY3VzSW5FdmVudChRRm9jdXNFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBm b2N1c091dEV2ZW50KFFGb2N1c0V2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGlucHV0TWV0aG9k RXZlbnQoUUlucHV0TWV0aG9kRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgZm9jdXNOZXh0UHJl dkNoaWxkKGJvb2wgbmV4dCk7CisKK3ByaXZhdGU6CisgICAgUV9QUklWQVRFX1NMT1QoZCwgdm9p ZCBfcV9kb1Njcm9sbChpbnQgZHgsIGludCBkeSwgY29uc3QgUVJlY3QmKSkKKyAgICBRX1BSSVZB VEVfU0xPVChkLCB2b2lkIF9xX2RvTG9hZFByb2dyZXNzKGludCBwcm9ncmVzcykpCisgICAgUV9Q UklWQVRFX1NMT1QoZCwgdm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3MpKQorICAg IFFfUFJJVkFURV9TTE9UKGQsIHZvaWQgX3FfZG9VcGRhdGUoY29uc3QgUVJlY3QmIGRpcnR5UmVj dCkpCisgICAgUV9QUklWQVRFX1NMT1QoZCwgdm9pZCBfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNv bnN0IFFTdHJpbmcmIG1lc3NhZ2UpKQorCisgICAgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGUqIGNv bnN0IGQ7CisgICAgZnJpZW5kIGNsYXNzIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOworfTsKKwor I2VuZGlmIC8vIFFXZWJHcmFwaGljc0l0ZW1faApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9x d2ViZ3JhcGhpY3NpdGVtX3AuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbV9wLmgK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTkyZDQyZgotLS0gL2Rldi9udWxs CisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbV9wLmgKQEAgLTAsMCArMSw0MyBA QAorLyoKKyAgICBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0 cyBzdWJzaWRpYXJ5KC1pZXMpCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAgICBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgICB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICAgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5H LkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICAgIEJvc3RvbiwgTUEg MDIxMTAtMTMwMSwgVVNBLgorKi8KKworY2xhc3MgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGUgewor cHVibGljOgorICAgIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlKFFXZWJHcmFwaGljc0l0ZW0qIHBh cmVudCkKKyAgICAgICAgOiBxKHBhcmVudCkKKyAgICAgICAgLCBwYWdlKDApCisgICAgICAgICwg aW50ZXJhY3RpdmUodHJ1ZSkKKyAgICAgICAgLCBwcm9ncmVzcygxLjApCisgICAge30KKworICAg IHZvaWQgX3FfZG9TY3JvbGwoaW50IGR4LCBpbnQgZHksIGNvbnN0IFFSZWN0Jik7CisgICAgdm9p ZCBfcV9kb0xvYWRQcm9ncmVzcyhpbnQgcHJvZ3Jlc3MpOworICAgIHZvaWQgX3FfZG9Mb2FkRmlu aXNoZWQoYm9vbCBzdWNjZXNzKTsKKyAgICB2b2lkIF9xX2RvVXBkYXRlKGNvbnN0IFFSZWN0JiBk aXJ0eVJlY3QpOworICAgIHZvaWQgX3Ffc2V0U3RhdHVzQmFyTWVzc2FnZShjb25zdCBRU3RyaW5n JiBtZXNzYWdlKTsKKworICAgIFFXZWJHcmFwaGljc0l0ZW0qIHE7CisgICAgUVdlYlBhZ2UqIHBh Z2U7CisKKyAgICBRU3RyaW5nIHN0YXR1c0Jhck1lc3NhZ2U7CisgICAgYm9vbCBpbnRlcmFjdGl2 ZTsKKyAgICBxcmVhbCBwcm9ncmVzczsKK307CisKKwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0Fw aS9xd2VicGFnZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCmluZGV4IDI0NzQxYTEuLjEw Yzc5MzggMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaAorKysgYi9XZWJLaXQv cXQvQXBpL3F3ZWJwYWdlLmgKQEAgLTM1MSw2ICszNTEsNyBAQCBwcml2YXRlOgogICAgIGZyaWVu ZCBjbGFzcyBRV2ViRnJhbWU7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJQYWdlUHJpdmF0ZTsKICAg ICBmcmllbmQgY2xhc3MgUVdlYlZpZXc7CisgICAgZnJpZW5kIGNsYXNzIFFXZWJHcmFwaGljc0l0 ZW07CiAgICAgZnJpZW5kIGNsYXNzIFdlYkNvcmU6OkNocm9tZUNsaWVudFF0OwogICAgIGZyaWVu ZCBjbGFzcyBXZWJDb3JlOjpFZGl0b3JDbGllbnRRdDsKICAgICBmcmllbmQgY2xhc3MgV2ViQ29y ZTo6RnJhbWVMb2FkZXJDbGllbnRRdDsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cg Yi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IGJlZmU4MDcuLjM5MTBiMjMgMTAwNjQ0Ci0tLSBh L1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsx LDI1IEBACisyMDA5LTA5LTA0ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhA d2Via2l0Lm9yZz4sIEFudG9uaW8gR29tZXMgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEg bmV3IFFHcmFwaGljc1dpZGdldCBiYXNlZCB2ZXJzaW9uIG9mIHRoZSAiUVdlYlZpZXciCisgICAg ICAgIHVuZGVyIHRoZSBuYW1lICJRV2ViR3JhcGhpY3NJdGVtIi4KKworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKKworICAgICAgICBJbmNsdWRl cyBhbiBhbHRlcm5hdGl2ZSBRdCBsYXVuY2hlciB1c2luZyB0aGUgUUdyYXBoaWNzVmlldy4KKwor ICAgICAgICAqIEFwaS9oZWFkZXJzLnByaToKKyAgICAgICAgKiBBcGkvcXdlYmdyYXBoaWNzaXRl bS5jcHA6IEFkZGVkLgorICAgICAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtLmg6IEFkZGVkLgor ICAgICAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtX3AuaDogQWRkZWQuCisgICAgICAgICogQXBp L3F3ZWJwYWdlLmg6CisgICAgICAgICogUUdWTGF1bmNoZXIvUUdWTGF1bmNoZXIucHJvOiBDb3Bp ZWQgZnJvbSBXZWJLaXQvcXQvUXRMYXVuY2hlci9RdExhdW5jaGVyLnByby4KKyAgICAgICAgKiBR R1ZMYXVuY2hlci9tYWluLmNwcDogQWRkZWQuCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvQ2hy b21lQ2xpZW50UXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2hyb21lQ2xpZW50UXQ6OnJlcGFp bnQpOgorICAgICAgICAoV2ViQ29yZTo6Q2hyb21lQ2xpZW50UXQ6OnNjcm9sbCk6CisKIDIwMDkt MDktMDcgIEpha3ViIFdpZWN6b3JlayAgPGZhdzIxN0BnbWFpbC5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgU2ltb24gSGF1c21hbm4uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvUUdWTGF1bmNo ZXIvUUdWTGF1bmNoZXIucHJvIGIvV2ViS2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVyLnBy bwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iODgzYjUyCi0tLSAvZGV2L251 bGwKKysrIGIvV2ViS2l0L3F0L1FHVkxhdW5jaGVyL1FHVkxhdW5jaGVyLnBybwpAQCAtMCwwICsx LDEzIEBACitURU1QTEFURSA9IGFwcAorU09VUkNFUyArPSBtYWluLmNwcAorQ09ORklHIC09IGFw cF9idW5kbGUKK0NPTkZJRyArPSB1aXRvb2xzCitERVNURElSID0gLi4vLi4vLi4vYmluCisKK2lu Y2x1ZGUoLi4vLi4vLi4vV2ViS2l0LnByaSkKKworUVQgKz0gbmV0d29yaworbWFjeDpRVCs9eG1s CitRTUFLRV9SUEFUSERJUiA9ICQkT1VUUFVUX0RJUi9saWIgJCRRTUFLRV9SUEFUSERJUgorCitz eW1iaWFuOlRBUkdFVC5VSUQzID0gMHgyMDAyNjdEMApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1FH VkxhdW5jaGVyL21haW4uY3BwIGIvV2ViS2l0L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZlM2FiNDUKLS0tIC9kZXYvbnVsbAorKysg Yi9XZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAKQEAgLTAsMCArMSwzMDAgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRp YXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgR2VvcmdlIFN0YWlrb3MgPHN0YWlrb3NA a2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwNiBEaXJrIE11ZWxsZXIgPG11ZWxsZXJAa2Rl Lm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwNiBaYWNrIFJ1c2luIDx6YWNrQGtkZS5vcmc+Cisg KiBDb3B5cmlnaHQgKEMpIDIwMDYgU2ltb24gSGF1c21hbm4gPGhhdXNtYW5uQGtkZS5vcmc+Cisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgS2VubmV0aCBDaHJpc3RpYW5zZW4gPGtlbm5ldGhAd2Via2l0 Lm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBBbnRvbmlvIEdvbWVzIDxhbnRvbmlvLmdvbWVz QG9wZW5ib3NzYS5vcmc+CisgKgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBg QVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IK KyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5j bHVkZSA8cXdlYnBhZ2UuaD4KKyNpbmNsdWRlIDxxd2Vidmlldy5oPgorI2luY2x1ZGUgPHF3ZWJn cmFwaGljc2l0ZW0uaD4KKyNpbmNsdWRlIDxxd2ViZnJhbWUuaD4KKyNpbmNsdWRlIDxxd2Vic2V0 dGluZ3MuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVudC5oPgorCisjaW5jbHVkZSA8UU5ldHdvcmtS ZXF1ZXN0PgorI2luY2x1ZGUgPFFHcmFwaGljc1NjZW5lPgorI2luY2x1ZGUgPFFHcmFwaGljc1Zp ZXc+CisjaW5jbHVkZSA8UUdyYXBoaWNzV2lkZ2V0PgorCisjaW5jbHVkZSA8UXRHdWk+CisjaW5j bHVkZSA8UURlYnVnPgorI2luY2x1ZGUgPFF0TmV0d29yay9RTmV0d29ya1Byb3h5PgorCisjaW5j bHVkZSA8UVZlY3Rvcj4KKyNpbmNsdWRlIDxRVGV4dFN0cmVhbT4KKyNpbmNsdWRlIDxRRmlsZT4K KyNpbmNsdWRlIDxjc3RkaW8+CisKK2NsYXNzIFdlYlBhZ2UgOiBwdWJsaWMgUVdlYlBhZ2Ugewor ICAgIFFfT0JKRUNUCisKK3B1YmxpYzoKKyAgICBXZWJQYWdlKFFXaWRnZXQgKnBhcmVudCA9IDAp IDogUVdlYlBhZ2UocGFyZW50KQorICAgIHsKKyAgICAgICAgYXBwbHlQcm94eSgpOworICAgIH0K KyAgICB2aXJ0dWFsIFFXZWJQYWdlICpjcmVhdGVXaW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5 cGUpOworCitwcml2YXRlOgorICAgIHZvaWQgYXBwbHlQcm94eSgpOworfTsKKworY2xhc3MgTWFp blZpZXcgOiBwdWJsaWMgUUdyYXBoaWNzVmlldyB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgor ICAgIE1haW5WaWV3KFFXaWRnZXQqIHBhcmVudCkgOiBRR3JhcGhpY3NWaWV3KHBhcmVudCksIG1f bWFpbldpZGdldCgwKQorICAgIHsKKyAgICAgICAgc2V0SG9yaXpvbnRhbFNjcm9sbEJhclBvbGlj eShRdDo6U2Nyb2xsQmFyQWx3YXlzT2ZmKTsKKyAgICAgICAgc2V0VmVydGljYWxTY3JvbGxCYXJQ b2xpY3koUXQ6OlNjcm9sbEJhckFsd2F5c09mZik7CisgICAgfQorCisgICAgdm9pZCBzZXRNYWlu V2lkZ2V0KFFHcmFwaGljc1dpZGdldCogd2lkZ2V0KQorICAgIHsKKyAgICAgICAgUVJlY3RGIHJl Y3QoUVJlY3QoUVBvaW50KDAsIDApLCBzaXplKCkpKTsKKyAgICAgICAgd2lkZ2V0LT5zZXRHZW9t ZXRyeShyZWN0KTsKKyAgICAgICAgbV9tYWluV2lkZ2V0ID0gd2lkZ2V0OworICAgIH0KKworICAg IHZvaWQgcmVzaXplRXZlbnQoUVJlc2l6ZUV2ZW50KiBldmVudCkKKyAgICB7CisgICAgICAgIFFH cmFwaGljc1ZpZXc6OnJlc2l6ZUV2ZW50KGV2ZW50KTsKKyAgICAgICAgUVJlY3RGIHJlY3QoUVJl Y3QoUVBvaW50KDAsIDApLCBldmVudC0+c2l6ZSgpKSk7CisgICAgICAgIGlmICghbV9tYWluV2lk Z2V0KQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBtX21haW5XaWRnZXQtPnNldEdlb21l dHJ5KHJlY3QpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBRR3JhcGhpY3NXaWRnZXQqIG1fbWFp bldpZGdldDsKK307CisKK2NsYXNzIFNoYXJlZFNjZW5lIDogcHVibGljIFFTaGFyZWREYXRhIHsK K3B1YmxpYzoKKyAgICBTaGFyZWRTY2VuZSgpCisgICAgeworICAgICAgICBtX3NjZW5lID0gbmV3 IFFHcmFwaGljc1NjZW5lOworCisgICAgICAgIG1faXRlbSA9IG5ldyBRV2ViR3JhcGhpY3NJdGVt OworICAgICAgICBtX2l0ZW0tPnNldFBhZ2UobmV3IFdlYlBhZ2UoKSk7CisKKyAgICAgICAgbV9z Y2VuZS0+YWRkSXRlbShtX2l0ZW0pOworICAgICAgICBtX3NjZW5lLT5zZXRBY3RpdmVXaW5kb3co bV9pdGVtKTsKKyAgICB9CisKKyAgICB+U2hhcmVkU2NlbmUoKQorICAgIHsKKyAgICAgICAgZGVs ZXRlIG1faXRlbTsKKyAgICAgICAgZGVsZXRlIG1fc2NlbmU7CisgICAgfQorCisgICAgUUdyYXBo aWNzU2NlbmUqIHNjZW5lKCkgY29uc3QgeyByZXR1cm4gbV9zY2VuZTsgfQorICAgIFFXZWJHcmFw aGljc0l0ZW0qIHdlYkl0ZW0oKSBjb25zdCB7IHJldHVybiBtX2l0ZW07IH0KKworcHJpdmF0ZToK KyAgICBRR3JhcGhpY3NTY2VuZSogbV9zY2VuZTsKKyAgICBRV2ViR3JhcGhpY3NJdGVtKiBtX2l0 ZW07Cit9OworCisKK2NsYXNzIE1haW5XaW5kb3cgOiBwdWJsaWMgUU1haW5XaW5kb3cgeworICAg IFFfT0JKRUNUCisKK3B1YmxpYzoKKyAgICBNYWluV2luZG93KFFFeHBsaWNpdGx5U2hhcmVkRGF0 YVBvaW50ZXI8U2hhcmVkU2NlbmU+IG90aGVyKQorICAgICAgICA6IFFNYWluV2luZG93KCksIHZp ZXcobmV3IE1haW5WaWV3KHRoaXMpKSwgc2NlbmUob3RoZXIpCisgICAgeworICAgICAgICBpbml0 KCk7CisgICAgfQorCisgICAgTWFpbldpbmRvdygpCisgICAgICAgIDogUU1haW5XaW5kb3coKSwg dmlldyhuZXcgTWFpblZpZXcodGhpcykpLCBzY2VuZShuZXcgU2hhcmVkU2NlbmUoKSkKKyAgICB7 CisgICAgICAgIGluaXQoKTsKKyAgICB9CisKKyAgICB2b2lkIGluaXQoKQorICAgIHsKKyAgICAg ICAgc2V0QXR0cmlidXRlKFF0OjpXQV9EZWxldGVPbkNsb3NlKTsKKworICAgICAgICB2aWV3LT5z ZXRTY2VuZShzY2VuZS0+c2NlbmUoKSk7CisgICAgICAgIHZpZXctPnNldEZyYW1lU2hhcGUoUUZy YW1lOjpOb0ZyYW1lKTsKKyAgICAgICAgdmlldy0+c2V0U2l6ZVBvbGljeShRU2l6ZVBvbGljeTo6 RXhwYW5kaW5nLCBRU2l6ZVBvbGljeTo6RXhwYW5kaW5nKTsKKyAgICAgICAgc2V0Q2VudHJhbFdp ZGdldCh2aWV3KTsKKworICAgICAgICB2aWV3LT5zZXRNYWluV2lkZ2V0KHNjZW5lLT53ZWJJdGVt KCkpOworCisgICAgICAgIGNvbm5lY3Qoc2NlbmUtPndlYkl0ZW0oKSwgU0lHTkFMKGxvYWRGaW5p c2hlZCgpKSwgdGhpcywgU0xPVChsb2FkRmluaXNoZWQoKSkpOworICAgICAgICBjb25uZWN0KHNj ZW5lLT53ZWJJdGVtKCksIFNJR05BTCh0aXRsZUNoYW5nZWQoY29uc3QgUVN0cmluZyYpKSwgdGhp cywgU0xPVChzZXRXaW5kb3dUaXRsZShjb25zdCBRU3RyaW5nJikpKTsKKyAgICAgICAgY29ubmVj dChzY2VuZS0+d2ViSXRlbSgpLT5wYWdlKCksIFNJR05BTCh3aW5kb3dDbG9zZVJlcXVlc3RlZCgp KSwgdGhpcywgU0xPVChjbG9zZSgpKSk7CisKKyAgICAgICAgcmVzaXplKDY0MCwgNDgwKTsKKyAg ICAgICAgYnVpbGRVSSgpOworICAgIH0KKworICAgIHZvaWQgbG9hZChjb25zdCBRU3RyaW5nJiB1 cmwpCisgICAgeworICAgICAgICBRVXJsIGRlZHVjZWRVcmwgPSBndWVzc1VybEZyb21TdHJpbmco dXJsKTsKKyAgICAgICAgaWYgKCFkZWR1Y2VkVXJsLmlzVmFsaWQoKSkKKyAgICAgICAgICAgIGRl ZHVjZWRVcmwgPSBRVXJsKCJodHRwOi8vIiArIHVybCArICIvIik7CisKKyAgICAgICAgdXJsRWRp dC0+c2V0VGV4dChkZWR1Y2VkVXJsLnRvRW5jb2RlZCgpKTsKKyAgICAgICAgc2NlbmUtPndlYkl0 ZW0oKS0+bG9hZChkZWR1Y2VkVXJsKTsKKyAgICAgICAgc2NlbmUtPndlYkl0ZW0oKS0+c2V0Rm9j dXMoUXQ6Ok90aGVyRm9jdXNSZWFzb24pOworICAgIH0KKworICAgIFFVcmwgZ3Vlc3NVcmxGcm9t U3RyaW5nKGNvbnN0IFFTdHJpbmcmIHN0cmluZykKKyAgICB7CisgICAgICAgIFFTdHJpbmcgaW5w dXQoc3RyaW5nKTsKKyAgICAgICAgUUZpbGVJbmZvIGZpKGlucHV0KTsKKyAgICAgICAgaWYgKGZp LmV4aXN0cygpICYmIGZpLmlzUmVsYXRpdmUoKSkKKyAgICAgICAgICAgIGlucHV0ID0gZmkuYWJz b2x1dGVGaWxlUGF0aCgpOworCisgICAgICAgIHJldHVybiBRV2ViVmlldzo6Z3Vlc3NVcmxGcm9t U3RyaW5nKGlucHV0KTsKKyAgICB9CisKKyAgICBRV2ViUGFnZSogcGFnZSgpIGNvbnN0CisgICAg eworICAgICAgICByZXR1cm4gc2NlbmUtPndlYkl0ZW0oKS0+cGFnZSgpOworICAgIH0KKworcHJv dGVjdGVkIHNsb3RzOgorICAgIHZvaWQgY2hhbmdlTG9jYXRpb24oKQorICAgIHsKKyAgICAgICAg bG9hZCh1cmxFZGl0LT50ZXh0KCkpOworICAgIH0KKworICAgIHZvaWQgbG9hZEZpbmlzaGVkKCkK KyAgICB7CisgICAgICAgIFFVcmwgdXJsID0gc2NlbmUtPndlYkl0ZW0oKS0+dXJsKCk7CisgICAg ICAgIHVybEVkaXQtPnNldFRleHQodXJsLnRvU3RyaW5nKCkpOworCisgICAgICAgIFFVcmw6OkZv cm1hdHRpbmdPcHRpb25zIG9wdHM7CisgICAgICAgIG9wdHMgfD0gUVVybDo6UmVtb3ZlU2NoZW1l OworICAgICAgICBvcHRzIHw9IFFVcmw6OlJlbW92ZVVzZXJJbmZvOworICAgICAgICBvcHRzIHw9 IFFVcmw6OlN0cmlwVHJhaWxpbmdTbGFzaDsKKyAgICAgICAgUVN0cmluZyBzID0gdXJsLnRvU3Ry aW5nKG9wdHMpOworICAgICAgICBzID0gcy5taWQoMik7CisgICAgICAgIGlmIChzLmlzRW1wdHko KSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgLy9GSVhNRTogc29tZXRoaW5nIG1pc3Np bmcgaGVyZQorICAgIH0KKworcHVibGljIHNsb3RzOgorICAgIHZvaWQgbmV3V2luZG93KGNvbnN0 IFFTdHJpbmcgJnVybCA9IFFTdHJpbmcoKSkKKyAgICB7CisgICAgICAgIE1haW5XaW5kb3cgKm13 ID0gbmV3IE1haW5XaW5kb3coKTsKKyAgICAgICAgbXctPmxvYWQodXJsKTsKKyAgICAgICAgbXct PnNob3coKTsKKyAgICB9CisKKyAgICB2b2lkIGNsb25lKCkKKyAgICB7CisgICAgICAgIE1haW5X aW5kb3cgKm13ID0gbmV3IE1haW5XaW5kb3coc2NlbmUpOworICAgICAgICBtdy0+c2hvdygpOwor ICAgIH0KKworcHJpdmF0ZToKKyAgICB2b2lkIGJ1aWxkVUkoKQorICAgIHsKKyAgICAgICAgUVdl YlBhZ2UqIHBhZ2UgPSBzY2VuZS0+d2ViSXRlbSgpLT5wYWdlKCk7CisgICAgICAgIHVybEVkaXQg PSBuZXcgUUxpbmVFZGl0KHRoaXMpOworICAgICAgICB1cmxFZGl0LT5zZXRTaXplUG9saWN5KFFT aXplUG9saWN5OjpFeHBhbmRpbmcsIHVybEVkaXQtPnNpemVQb2xpY3koKS52ZXJ0aWNhbFBvbGlj eSgpKTsKKyAgICAgICAgY29ubmVjdCh1cmxFZGl0LCBTSUdOQUwocmV0dXJuUHJlc3NlZCgpKSwg U0xPVChjaGFuZ2VMb2NhdGlvbigpKSk7CisKKyAgICAgICAgUVRvb2xCYXIgKmJhciA9IGFkZFRv b2xCYXIoIk5hdmlnYXRpb24iKTsKKyAgICAgICAgYmFyLT5hZGRBY3Rpb24ocGFnZS0+YWN0aW9u KFFXZWJQYWdlOjpCYWNrKSk7CisgICAgICAgIGJhci0+YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihR V2ViUGFnZTo6Rm9yd2FyZCkpOworICAgICAgICBiYXItPmFkZEFjdGlvbihwYWdlLT5hY3Rpb24o UVdlYlBhZ2U6OlJlbG9hZCkpOworICAgICAgICBiYXItPmFkZEFjdGlvbihwYWdlLT5hY3Rpb24o UVdlYlBhZ2U6OlN0b3ApKTsKKyAgICAgICAgYmFyLT5hZGRXaWRnZXQodXJsRWRpdCk7CisKKyAg ICAgICAgUU1lbnUgKmZpbGVNZW51ID0gbWVudUJhcigpLT5hZGRNZW51KCImRmlsZSIpOworICAg ICAgICBRQWN0aW9uICpuZXdXaW5kb3cgPSBmaWxlTWVudS0+YWRkQWN0aW9uKCJOZXcgV2luZG93 IiwgdGhpcywgU0xPVChuZXdXaW5kb3coKSkpOworICAgICAgICBRQWN0aW9uICpjbG9uZVZpZXcg PSBmaWxlTWVudS0+YWRkQWN0aW9uKCJDbG9uZSB2aWV3IiwgdGhpcywgU0xPVChjbG9uZSgpKSk7 CisgICAgICAgIGZpbGVNZW51LT5hZGRBY3Rpb24oIkNsb3NlIiwgdGhpcywgU0xPVChjbG9zZSgp KSk7CisKKyAgICAgICAgUU1lbnUgKnZpZXdNZW51ID0gbWVudUJhcigpLT5hZGRNZW51KCImVmll dyIpOworICAgICAgICB2aWV3TWVudS0+YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6 U3RvcCkpOworICAgICAgICB2aWV3TWVudS0+YWRkQWN0aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFn ZTo6UmVsb2FkKSk7CisgICAgfQorCitwcml2YXRlOgorICAgIE1haW5WaWV3ICp2aWV3OworICAg IFFFeHBsaWNpdGx5U2hhcmVkRGF0YVBvaW50ZXI8U2hhcmVkU2NlbmU+IHNjZW5lOworCisgICAg UUxpbmVFZGl0ICp1cmxFZGl0OworfTsKKworUVdlYlBhZ2UgKldlYlBhZ2U6OmNyZWF0ZVdpbmRv dyhRV2ViUGFnZTo6V2ViV2luZG93VHlwZSkKK3sKKyAgICBNYWluV2luZG93ICptdyA9IG5ldyBN YWluV2luZG93OworICAgIG13LT5zaG93KCk7CisgICAgcmV0dXJuIG13LT5wYWdlKCk7Cit9CisK K3ZvaWQgV2ViUGFnZTo6YXBwbHlQcm94eSgpCit7CisgICAgUVVybCBwcm94eVVybCA9IFFXZWJW aWV3OjpndWVzc1VybEZyb21TdHJpbmcocWdldGVudigiaHR0cF9wcm94eSIpKTsKKworICAgIGlm IChwcm94eVVybC5pc1ZhbGlkKCkgJiYgIXByb3h5VXJsLmhvc3QoKS5pc0VtcHR5KCkpIHsKKyAg ICAgICAgaW50IHByb3h5UG9ydCA9IChwcm94eVVybC5wb3J0KCkgPiAwKSA/IHByb3h5VXJsLnBv cnQoKSA6IDgwODA7CisgICAgICAgIG5ldHdvcmtBY2Nlc3NNYW5hZ2VyKCktPnNldFByb3h5KFFO ZXR3b3JrUHJveHkoUU5ldHdvcmtQcm94eTo6SHR0cFByb3h5LCBwcm94eVVybC5ob3N0KCksIHBy b3h5UG9ydCkpOworICAgIH0KK30KKworI2luY2x1ZGUgIm1haW4ubW9jIgorCitpbnQgbWFpbihp bnQgYXJnYywgY2hhciAqKmFyZ3YpCit7CisgICAgUUFwcGxpY2F0aW9uIGFwcChhcmdjLCBhcmd2 KTsKKyAgICBRU3RyaW5nIHVybCA9IFFTdHJpbmcoImZpbGU6Ly8lMS8lMiIpLmFyZyhRRGlyOjpo b21lUGF0aCgpKS5hcmcoUUxhdGluMVN0cmluZygiaW5kZXguaHRtbCIpKTsKKworICAgIGFwcC5z ZXRBcHBsaWNhdGlvbk5hbWUoIkdRVkxhdW5jaGVyIik7CisKKyAgICBRV2ViU2V0dGluZ3M6OnNl dE9iamVjdENhY2hlQ2FwYWNpdGllcygoMTYqMTAyNCoxMDI0KSAvIDgsICgxNioxMDI0KjEwMjQp IC8gOCwgMTYqMTAyNCoxMDI0KTsKKyAgICBRV2ViU2V0dGluZ3M6OnNldE1heGltdW1QYWdlc0lu Q2FjaGUoNCk7CisgICAgUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpLT5zZXRBdHRyaWJ1 dGUoUVdlYlNldHRpbmdzOjpQbHVnaW5zRW5hYmxlZCwgdHJ1ZSk7CisgICAgUVdlYlNldHRpbmdz OjpnbG9iYWxTZXR0aW5ncygpLT5zZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpEZXZlbG9wZXJF eHRyYXNFbmFibGVkLCB0cnVlKTsKKyAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdzKCkt PnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OkxvY2FsU3RvcmFnZUVuYWJsZWQsIHRydWUpOwor CisgICAgY29uc3QgUVN0cmluZ0xpc3QgYXJncyA9IGFwcC5hcmd1bWVudHMoKTsKKyAgICBpZiAo YXJncy5jb3VudCgpID4gMSkKKyAgICAgICAgdXJsID0gYXJncy5hdCgxKTsKKworICAgIE1haW5X aW5kb3cqIHdpbmRvdyA9IG5ldyBNYWluV2luZG93OworICAgIHdpbmRvdy0+bG9hZCh1cmwpOwor CisgICAgZm9yIChpbnQgaSA9IDI7IGkgPCBhcmdzLmNvdW50KCk7IGkrKykKKyAgICAgICAgd2lu ZG93LT5uZXdXaW5kb3coYXJncy5hdChpKSk7CisKKyAgICB3aW5kb3ctPnNob3coKTsKKyAgICBy ZXR1cm4gYXBwLmV4ZWMoKTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9DaHJvbWVDbGllbnRRdC5jcHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xp ZW50UXQuY3BwCmluZGV4IGQ2NTk4MzMuLmU3OWFlNTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9X ZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcApAQCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUgInF3 ZWJmcmFtZV9wLmgiCiAjaW5jbHVkZSAicXdlYnNlY3VyaXR5b3JpZ2luLmgiCiAjaW5jbHVkZSAi cXdlYnNlY3VyaXR5b3JpZ2luX3AuaCIKKyNpbmNsdWRlICJxd2Vidmlldy5oIgogCiAjaW5jbHVk ZSA8cXRvb2x0aXAuaD4KICNpbmNsdWRlIDxxdGV4dGRvY3VtZW50Lmg+CkBAIC0zMDcsOCArMzA4 LDggQEAgdm9pZCBDaHJvbWVDbGllbnRRdDo6cmVwYWludChjb25zdCBJbnRSZWN0JiB3aW5kb3dS ZWN0LCBib29sIGNvbnRlbnRDaGFuZ2VkLCBib28KIHsKICAgICAvLyBObyBkb3VibGUgYnVmZmVy LCBzbyBvbmx5IHVwZGF0ZSB0aGUgUVdpZGdldCBpZiBjb250ZW50IGNoYW5nZWQuCiAgICAgaWYg KGNvbnRlbnRDaGFuZ2VkKSB7Ci0gICAgICAgIFFXaWRnZXQqIHZpZXcgPSBtX3dlYlBhZ2UtPnZp ZXcoKTsKLSAgICAgICAgaWYgKHZpZXcpIHsKKyAgICAgICAgLy8gT25seSBkbyBpbXBsaWNpdCBw YWludHMgZm9yIFFXZWJWaWV3J3MKKyAgICAgICAgaWYgKFFXZWJWaWV3KiB2aWV3ID0gcW9iamVj dF9jYXN0PFFXZWJWaWV3Kj4obV93ZWJQYWdlLT52aWV3KCkpKSB7CiAgICAgICAgICAgICBRUmVj dCByZWN0KHdpbmRvd1JlY3QpOwogICAgICAgICAgICAgcmVjdCA9IHJlY3QuaW50ZXJzZWN0ZWQo UVJlY3QoUVBvaW50KDAsIDApLCBtX3dlYlBhZ2UtPnZpZXdwb3J0U2l6ZSgpKSk7CiAgICAgICAg ICAgICBpZiAoIXJlY3QuaXNFbXB0eSgpKQpAQCAtMzIzLDggKzMyNCw4IEBAIHZvaWQgQ2hyb21l Q2xpZW50UXQ6OnJlcGFpbnQoY29uc3QgSW50UmVjdCYgd2luZG93UmVjdCwgYm9vbCBjb250ZW50 Q2hhbmdlZCwgYm9vCiAKIHZvaWQgQ2hyb21lQ2xpZW50UXQ6OnNjcm9sbChjb25zdCBJbnRTaXpl JiBkZWx0YSwgY29uc3QgSW50UmVjdCYgc2Nyb2xsVmlld1JlY3QsIGNvbnN0IEludFJlY3QmKQog ewotICAgIFFXaWRnZXQqIHZpZXcgPSBtX3dlYlBhZ2UtPnZpZXcoKTsKLSAgICBpZiAodmlldykK KyAgICAvLyBPbmx5IGRvIGltcGxpY2l0IHBhaW50cyBmb3IgUVdlYlZpZXcncworICAgIGlmIChR V2ViVmlldyogdmlldyA9IHFvYmplY3RfY2FzdDxRV2ViVmlldyo+KG1fd2ViUGFnZS0+dmlldygp KSkKICAgICAgICAgdmlldy0+c2Nyb2xsKGRlbHRhLndpZHRoKCksIGRlbHRhLmhlaWdodCgpLCBz Y3JvbGxWaWV3UmVjdCk7CiAgICAgZW1pdCBtX3dlYlBhZ2UtPnNjcm9sbFJlcXVlc3RlZChkZWx0 YS53aWR0aCgpLCBkZWx0YS5oZWlnaHQoKSwgc2Nyb2xsVmlld1JlY3QpOwogfQotLSAKMS42LjAu NAoK 39260 2009-09-09 04:06:16 -0700 2009-10-22 06:43:09 -0700 (landed in r48219) patch 1 - v0.3 - add QWebGraphicsItem to the API and QGVLauncher sample application ( 0001--.-Qt-Add-the-alternative-QtLauncher-based-on.patch text/plain 41288 tonikitoo RnJvbSBiNjgzYjYxYjIxNmQ0MjMxY2Y2NTZmYWZhODc4YTU4NmZjNmY1NmUwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBGcmksIDQgU2VwIDIwMDkgMTc6MjA6NDcgLTAzMDAKU3ViamVjdDog W1BBVENIXSAgICAgLjogW1F0XSBBZGQgdGhlIGFsdGVybmF0aXZlIFF0TGF1bmNoZXIgKGJhc2Vk IG9uIFFHcmFwaGljc1ZpZXcpIHRvIHRoZSBidWlsZC4KCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKCiAgICBXZWJLaXQvcXQ6IEFkZCBhIG5ldyBRR3Jh cGhpY3NXaWRnZXQgYmFzZWQgdmVyc2lvbiBvZiB0aGUgIlFXZWJWaWV3IgogICAgdW5kZXIgdGhl IG5hbWUgIlFXZWJHcmFwaGljc0l0ZW0iLgoKICAgIFBhdGNoIGJ5IEtlbm5ldGggUm9oZGUgQ2hy aXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPiwKICAgIAkgICAgIEFudG9uaW8gR29tZXMg PGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4gb24gMjAwOS0wOS0wOQogICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCgogICAgSW5jbHVkZXMgYW4gYWx0ZXJuYXRpdmUgUXQgbGF1bmNo ZXIgdXNpbmcgdGhlIFFHcmFwaGljc1ZpZXcuCiAgICAqIEFwaS9oZWFkZXJzLnByaToKICAgICog QXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwOiBBZGRlZC4KICAgICogQXBpL3F3ZWJncmFwaGljc2l0 ZW0uaDogQWRkZWQuCiAgICAqIEFwaS9xd2VicGFnZS5oOgogICAgKiBRR1ZMYXVuY2hlci9RR1ZM YXVuY2hlci5wcm86IENvcGllZCBmcm9tIFdlYktpdC9xdC9RdExhdW5jaGVyL1F0TGF1bmNoZXIu cHJvLgogICAgKiBRR1ZMYXVuY2hlci9tYWluLmNwcDogQWRkZWQuCiAgICAqIFdlYkNvcmVTdXBw b3J0L0Nocm9tZUNsaWVudFF0LmNwcDoKICAgIChXZWJDb3JlOjpDaHJvbWVDbGllbnRRdDo6cmVw YWludCk6CiAgICAoV2ViQ29yZTo6Q2hyb21lQ2xpZW50UXQ6OnNjcm9sbCk6CgogICAgV2ViS2l0 OiBBZGQgdGhlIFFHVkxhdW5jaGVyIHRoZSBidWlsZCBzeXN0ZW0uCiAgICAqIFdlYktpdC5wcm86 CgogICAgV2ViQ29yZTogQWRkIHRoZSBxd2ViZ3JhcGhpY3NpdGVtLmNwcCB0byB0aGUgYnVpbGQg c3lzdGVtLgogICAgKiBXZWJDb3JlLnBybzoKLS0tCiBDaGFuZ2VMb2cgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxMCArCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxMCArCiBXZWJDb3JlL1dlYkNvcmUucHJvICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMSArCiBXZWJLaXQucHJvICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAgMSArCiBXZWJLaXQvcXQvQXBpL2hlYWRlcnMucHJpICAgICAgICAgICAg ICAgICAgIHwgICAgMSArCiBXZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwICAgICAg ICAgIHwgIDc0MCArKysrKysrKysrKysrKysrKysrKysrKysrKysKIFdlYktpdC9xdC9BcGkvcXdl YmdyYXBoaWNzaXRlbS5oICAgICAgICAgICAgfCAgMTQzICsrKysrCiBXZWJLaXQvcXQvQXBpL3F3 ZWJwYWdlLmggICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJLaXQvcXQvQ2hhbmdlTG9n ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyMSArCiBXZWJLaXQvcXQvUUdWTGF1bmNoZXIv UUdWTGF1bmNoZXIucHJvICAgICAgIHwgICAxMyArCiBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFp bi5jcHAgICAgICAgICAgICAgIHwgIDMwMCArKysrKysrKysrKwogV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcCB8ICAgIDkgKy0KIDEyIGZpbGVzIGNoYW5nZWQsIDEy NDYgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJL aXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0 L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJLaXQvcXQv UUdWTGF1bmNoZXIvUUdWTGF1bmNoZXIucHJvCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L3F0 L1FHVkxhdW5jaGVyL21haW4uY3BwCgpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9n CmluZGV4IDEzMDVhMzcuLmU0Yjg0Y2MgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAwOS0wOS0wOSAgS2VubmV0aCBSb2hkZSBDaHJpc3Rp YW5zZW4gIDxrZW5uZXRoQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUGF0Y2ggYnkgS2VubmV0aCBS b2hkZSBDaHJpc3RpYW5zZW4gIDxrZW5uZXRoQHdlYmtpdC5vcmc+LAorCSAgICAgICAgIEFudG9u aW8gR29tZXMgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4gb24gMjAwOS0wOS0wOQorICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIEFkZCB0aGUg YWx0ZXJuYXRpdmUgUXRMYXVuY2hlciAoYmFzZWQgb24gUUdyYXBoaWNzVmlldykgdG8gdGhlIGJ1 aWxkLgorCisgICAgICAgICogV2ViS2l0LnBybzoKKwogMjAwOS0wOS0wNyAgWGFuIExvcGV6ICA8 eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgR3VzdGF2byBO b3JvbmhhLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCBjMTc0ODBlLi4zMWVhMjJhIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDA5LTA5LTA5ICBLZW5u ZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KKworICAgICAgICBQ YXRjaCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4s CisJICAgICAgICAgQW50b25pbyBHb21lcyA8YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPiBv biAyMDA5LTA5LTA5CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEFkZCB0aGUgcXdlYmdyYXBoaWNzaXRlbS5jcHAgdG8gdGhlIGJ1aWxkIHN5c3RlbS4KKwor ICAgICAgICAqIFdlYkNvcmUucHJvOgorCiAyMDA5LTA5LTA4ICBLZXZpbiBPbGxpdmllciAgPGtl dmlub0B0aGVvbGxpdmllcnMuY29tPgogCiAgICAgICAgIHd4IGJ1aWxkIGZpeCBmb3IgMi44Lgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5k ZXggMWY2NzY5YS4uNGZlMTM5MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysg Yi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0yMzc5LDYgKzIzNzksNyBAQCBTT1VSQ0VTICs9IFwK ICAgICAuLi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAg XAogICAgIC4uL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRRdC5jcHAg XAogICAgIC4uL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBcCisgICAgLi4vV2ViS2l0L3F0 L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcCBcCiAgICAgLi4vV2ViS2l0L3F0L0FwaS9xd2VicGFn ZS5jcHAgXAogICAgIC4uL1dlYktpdC9xdC9BcGkvcXdlYnZpZXcuY3BwIFwKICAgICAuLi9XZWJL aXQvcXQvQXBpL3F3ZWJlbGVtZW50LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJLaXQucHJvIGIvV2Vi S2l0LnBybwppbmRleCAwYmExNGU0Li44NjZiYjliIDEwMDY0NAotLS0gYS9XZWJLaXQucHJvCisr KyBiL1dlYktpdC5wcm8KQEAgLTUsNiArNSw3IEBAIFNVQkRJUlMgKz0gXAogICAgICAgICBXZWJD b3JlIFwKICAgICAgICAgSmF2YVNjcmlwdENvcmUvanNjLnBybyBcCiAgICAgICAgIFdlYktpdC9x dC9RdExhdW5jaGVyIFwKKyAgICAgICAgV2ViS2l0L3F0L1FHVkxhdW5jaGVyIFwKICAgICAgICAg V2ViS2l0L3F0L3Rlc3RzCiAKICF3aW4zMjohc3ltYmlhbiB7CmRpZmYgLS1naXQgYS9XZWJLaXQv cXQvQXBpL2hlYWRlcnMucHJpIGIvV2ViS2l0L3F0L0FwaS9oZWFkZXJzLnByaQppbmRleCA5MmEx MjBkLi4zMGEzNmVmIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL2hlYWRlcnMucHJpCisrKyBi L1dlYktpdC9xdC9BcGkvaGVhZGVycy5wcmkKQEAgLTEsNCArMSw1IEBACiBXRUJLSVRfQVBJX0hF QURFUlMgPSAkJFBXRC9xd2ViZnJhbWUuaCBcCisgICAgICAgICAgICAgICAgICAgICAkJFBXRC9x d2ViZ3JhcGhpY3NpdGVtLmggXAogICAgICAgICAgICAgICAgICAgICAgJCRQV0QvcXdlYmtpdGds b2JhbC5oIFwKICAgICAgICAgICAgICAgICAgICAgICQkUFdEL3F3ZWJwYWdlLmggXAogICAgICAg ICAgICAgICAgICAgICAgJCRQV0QvcXdlYnZpZXcuaCBcCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQv QXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVt LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xZmE1NjYxCi0tLSAvZGV2 L251bGwKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcApAQCAtMCwwICsx LDc0MCBAQAorLyoKKyAgICBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29ycG9yYXRpb24gYW5k L29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAgICBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAg ICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICAgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBD T1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICAgIEJvc3Rv biwgTUEgMDIxMTAtMTMwMSwgVVNBLgorKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgInF3ZWJncmFwaGljc2l0ZW0uaCIKKworI2luY2x1ZGUgInF3ZWJmcmFtZS5oIgorI2luY2x1 ZGUgInF3ZWJwYWdlLmgiCisjaW5jbHVkZSAicXdlYnBhZ2VfcC5oIgorI2luY2x1ZGUgPFF0L3Fz dHlsZW9wdGlvbi5oPgorI2luY2x1ZGUgPFF0R3VpL3FhcHBsaWNhdGlvbi5oPgorI2luY2x1ZGUg PFF0R3VpL3FncmFwaGljc3NjZW5lZXZlbnQuaD4KKyNpbmNsdWRlIDxRdEd1aS9RR3JhcGhpY3NT Y2VuZT4KKyNpbmNsdWRlIDxRdEd1aS9RR3JhcGhpY3NWaWV3PgorCitjbGFzcyBRV2ViR3JhcGhp Y3NJdGVtUHJpdmF0ZSB7CitwdWJsaWM6CisgICAgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGUoUVdl YkdyYXBoaWNzSXRlbSogcGFyZW50KQorICAgICAgICA6IHEocGFyZW50KQorICAgICAgICAsIHBh Z2UoMCkKKyAgICAgICAgLCBpbnRlcmFjdGl2ZSh0cnVlKQorICAgICAgICAsIHByb2dyZXNzKDEu MCkKKyAgICB7fQorCisgICAgdm9pZCBfcV9kb1Njcm9sbChpbnQgZHgsIGludCBkeSwgY29uc3Qg UVJlY3QmKTsKKyAgICB2b2lkIF9xX2RvTG9hZFByb2dyZXNzKGludCBwcm9ncmVzcyk7CisgICAg dm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3MpOworICAgIHZvaWQgX3FfZG9VcGRh dGUoY29uc3QgUVJlY3QmIGRpcnR5UmVjdCk7CisgICAgdm9pZCBfcV9zZXRTdGF0dXNCYXJNZXNz YWdlKGNvbnN0IFFTdHJpbmcmIG1lc3NhZ2UpOworCisgICAgUVdlYkdyYXBoaWNzSXRlbSogcTsK KyAgICBRV2ViUGFnZSogcGFnZTsKKworICAgIFFTdHJpbmcgc3RhdHVzQmFyTWVzc2FnZTsKKyAg ICBib29sIGludGVyYWN0aXZlOworICAgIHFyZWFsIHByb2dyZXNzOworfTsKKwordm9pZCBRV2Vi R3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9Mb2FkUHJvZ3Jlc3MoaW50IHByb2dyZXNzKQorewor ICAgIGlmIChxRnV6enlDb21wYXJlKHRoaXMtPnByb2dyZXNzLCBwcm9ncmVzcyAvIDEwMC4pKQor ICAgICAgICByZXR1cm47CisKKyAgICB0aGlzLT5wcm9ncmVzcyA9IHByb2dyZXNzIC8gMTAwLjsK KworICAgIGVtaXQgcS0+cHJvZ3Jlc3NDaGFuZ2VkKHRoaXMtPnByb2dyZXNzKTsKK30KKwordm9p ZCBRV2ViR3JhcGhpY3NJdGVtUHJpdmF0ZTo6X3FfZG9Mb2FkRmluaXNoZWQoYm9vbCBzdWNjZXNz KQoreworICAgIC8vIElmIHRoZSBwYWdlIGhhZCBubyB0aXRsZSwgc3RpbGwgbWFrZSBzdXJlIGl0 IGdldHMgdGhlIHNpZ25hbAorICAgIGlmIChxLT50aXRsZSgpLmlzRW1wdHkoKSkKKyAgICAgICAg ZW1pdCBxLT51cmxDaGFuZ2VkKHEtPnVybCgpKTsKKworICAgIGlmIChzdWNjZXNzKQorICAgICAg ICBlbWl0IHEtPmxvYWRGaW5pc2hlZCgpOworICAgIGVsc2UKKyAgICAgICAgZW1pdCBxLT5sb2Fk RmFpbGVkKCk7Cit9CisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGU6Ol9xX2RvU2Nyb2xs KGludCBkeCwgaW50IGR5LCBjb25zdCBRUmVjdCYgcmVjdFRvU2Nyb2xsKQoreworICAgIHEtPnNj cm9sbChxcmVhbChkeCksIHFyZWFsKGR5KSwgUVJlY3RGKHJlY3RUb1Njcm9sbCkpOworfQorCit2 b2lkIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9kb1VwZGF0ZShjb25zdCBRUmVjdCAmIGRp cnR5UmVjdCkKK3sKKyAgICBxLT51cGRhdGUoUVJlY3RGKGRpcnR5UmVjdCkpOworfQorCit2b2lk IFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOjpfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFT dHJpbmcmIHMpCit7CisgICAgc3RhdHVzQmFyTWVzc2FnZSA9IHM7CisgICAgcS0+ZW1pdCBzdGF0 dXNDaGFuZ2VkKCk7Cit9CisKKy8qIQorICAgIFxicmllZiBRV2ViR3JhaGljc0l0ZW0gYWxsb3dz IHdlYiBjb250ZW50IHRvIGJlIGFkZGVkIHRvIGEgY2FudmFzLgorICAgIFxpbmhlcml0cyBRR3Jh cGhpY3NXaWRnZXQuCisgICAgXHNpbmNlIDQuNgorCisgICAgQSBXZWJHcmFwaGljc0l0ZW0gcmVu ZGVycyB3ZWIgY29udGVudCBiYXNlZCBvbiBhIFVSTCBvciBzZXQgZGF0YS4KKworICAgIElmIHRo ZSB3aWR0aCBhbmQgaGVpZ2h0IG9mIHRoZSBpdGVtIGlzIG5vdCBzZXQsIHRoZXkgd2lsbAorICAg IGR5bmFtaWNhbGx5IGFkanVzdCB0byBhIHNpemUgYXBwcm9wcmlhdGUgZm9yIHRoZSBjb250ZW50 LgorICAgIFRoaXMgd2lkdGggbWF5IGJlIGxhcmdlIChlZy4gOTgwKSBmb3IgdHlwaWNhbCBvbmxp bmUgd2ViIHBhZ2VzLgorKi8KKworLyohCisgICAgQ29uc3RydWN0cyBhbiBlbXB0eSBRV2ViR3Jh cGhpY3NJdGVtIHdpdGggcGFyZW50IFxhIHBhcmVudC8KKworICAgIFxzYSBsb2FkKCkKKyovCitR V2ViR3JhcGhpY3NJdGVtOjpRV2ViR3JhcGhpY3NJdGVtKFFHcmFwaGljc0l0ZW0qIHBhcmVudCkK KyAgICA6IFFHcmFwaGljc1dpZGdldChwYXJlbnQpCisgICAgLCBkKG5ldyBRV2ViR3JhcGhpY3NJ dGVtUHJpdmF0ZSh0aGlzKSkKK3sKKyNpZiBRVF9WRVJTSU9OID49IDB4MDQwNjAwCisgICAgc2V0 RmxhZyhRR3JhcGhpY3NJdGVtOjpJdGVtVXNlc0V4dGVuZGVkU3R5bGVPcHRpb24sIHRydWUpOwor I2VuZGlmCisgICAgc2V0QWNjZXB0SG92ZXJFdmVudHModHJ1ZSk7CisgICAgc2V0Rm9jdXNQb2xp Y3koUXQ6OlN0cm9uZ0ZvY3VzKTsKK30KKworLyohCisgICAgRGVzdHJveXMgdGhlIHdlYiBncmFw aGljc2l0ZW0uCisqLworUVdlYkdyYXBoaWNzSXRlbTo6flFXZWJHcmFwaGljc0l0ZW0oKQorewor ICAgIGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5kLT52aWV3ID0gMDsKKworICAgIGlm IChkLT5wYWdlICYmIGQtPnBhZ2UtPnBhcmVudCgpID09IHRoaXMpCisgICAgICAgIGRlbGV0ZSBk LT5wYWdlOworCisgICAgZGVsZXRlIGQ7Cit9CisKKy8qIQorICAgIFJldHVybnMgYSBwb2ludGVy IHRvIHRoZSB1bmRlcmx5aW5nIHdlYiBwYWdlLgorCisgICAgXHNhIHNldFBhZ2UoKQorKi8KK1FX ZWJQYWdlKiBRV2ViR3JhcGhpY3NJdGVtOjpwYWdlKCkgY29uc3QKK3sKKyAgICBpZiAoIWQtPnBh Z2UpIHsKKyAgICAgICAgUVdlYkdyYXBoaWNzSXRlbSogdGhhdCA9IGNvbnN0X2Nhc3Q8UVdlYkdy YXBoaWNzSXRlbSo+KHRoaXMpOworICAgICAgICBRV2ViUGFnZSogcGFnZSA9IG5ldyBRV2ViUGFn ZSh0aGF0KTsKKworICAgICAgICAvLyBEZWZhdWx0IHRvIG5vdCBoYXZpbmcgYSBiYWNrZ3JvdW5k LCBpbiB0aGUgY2FzZQorICAgICAgICAvLyB0aGUgcGFnZSBkb2Vzbid0IHByb3ZpZGUgb25lLgor ICAgICAgICBRUGFsZXR0ZSBwYWxldHRlID0gUUFwcGxpY2F0aW9uOjpwYWxldHRlKCk7CisgICAg ICAgIHBhbGV0dGUuc2V0QnJ1c2goUVBhbGV0dGU6OkJhc2UsIFFDb2xvcjo6ZnJvbVJnYkYoMCwg MCwgMCwgMCkpOworICAgICAgICBwYWdlLT5zZXRQYWxldHRlKHBhbGV0dGUpOworCisgICAgICAg IHRoYXQtPnNldFBhZ2UocGFnZSk7CisgICAgfQorCisgICAgcmV0dXJuIGQtPnBhZ2U7Cit9CisK Ky8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnBhaW50KFFQYWludGVyKiBw YWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbiwgUVdpZGdldCop Cit7CisgICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPnJlbmRlcihwYWludGVyLCBvcHRpb24tPmV4 cG9zZWRSZWN0LnRvUmVjdCgpKTsKK30KKworLyohCisgICAgTWFrZXMgXGEgcGFnZSB0aGUgbmV3 IHdlYiBwYWdlIG9mIHRoZSB3ZWIgZ3JhcGhpY3NpdGVtLgorCisgICAgVGhlIHBhcmVudCBRT2Jq ZWN0IG9mIHRoZSBwcm92aWRlZCBwYWdlIHJlbWFpbnMgdGhlIG93bmVyCisgICAgb2YgdGhlIG9i amVjdC4gSWYgdGhlIGN1cnJlbnQgZG9jdW1lbnQgaXMgYSBjaGlsZCBvZiB0aGUgd2ViCisgICAg dmlldywgaXQgd2lsbCBiZSBkZWxldGVkLgorCisgICAgXHNhIHBhZ2UoKQorKi8KK3ZvaWQgUVdl YkdyYXBoaWNzSXRlbTo6c2V0UGFnZShRV2ViUGFnZSogcGFnZSkKK3sKKyAgICBpZiAoZC0+cGFn ZSA9PSBwYWdlKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoZC0+cGFnZSkgeworICAgICAg ICBpZiAoZC0+cGFnZS0+cGFyZW50KCkgPT0gdGhpcykKKyAgICAgICAgICAgIGRlbGV0ZSBkLT5w YWdlOworICAgICAgICBlbHNlCisgICAgICAgICAgICBkLT5wYWdlLT5kaXNjb25uZWN0KHRoaXMp OworICAgIH0KKworICAgIGQtPnBhZ2UgPSBwYWdlOworICAgIGlmICghZC0+cGFnZSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgUVNpemUgc2l6ZSA9IGdlb21ldHJ5KCkuc2l6ZSgpLnRvU2l6ZSgp OworICAgIHBhZ2UtPnNldFZpZXdwb3J0U2l6ZShzaXplKTsKKworICAgIFFXZWJGcmFtZSogbWFp bkZyYW1lID0gZC0+cGFnZS0+bWFpbkZyYW1lKCk7CisKKyAgICBjb25uZWN0KG1haW5GcmFtZSwg U0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3RyaW5nJikpLAorICAgICAgICAgICAgdGhpcywg U0lHTkFMKHRpdGxlQ2hhbmdlZChjb25zdCBRU3RyaW5nJikpKTsKKyAgICBjb25uZWN0KG1haW5G cmFtZSwgU0lHTkFMKGljb25DaGFuZ2VkKCkpLAorICAgICAgICAgICAgdGhpcywgU0lHTkFMKGlj b25DaGFuZ2VkKCkpKTsKKyAgICBjb25uZWN0KG1haW5GcmFtZSwgU0lHTkFMKHVybENoYW5nZWQo Y29uc3QgUVVybCYpKSwKKyAgICAgICAgICAgIHRoaXMsIFNJR05BTCh1cmxDaGFuZ2VkKGNvbnN0 IFFVcmwmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKGxvYWRTdGFydGVkKCkpLAor ICAgICAgICAgICAgdGhpcywgU0lHTkFMKGxvYWRTdGFydGVkKCkpKTsKKyAgICBjb25uZWN0KGQt PnBhZ2UsIFNJR05BTChsb2FkUHJvZ3Jlc3MoaW50KSksCisgICAgICAgICAgICB0aGlzLCBTTE9U KF9xX2RvTG9hZFByb2dyZXNzKGludCkpKTsKKyAgICBjb25uZWN0KGQtPnBhZ2UsIFNJR05BTChs b2FkRmluaXNoZWQoYm9vbCkpLAorICAgICAgICAgICAgdGhpcywgU0xPVChfcV9kb0xvYWRGaW5p c2hlZChib29sKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKHJlcGFpbnRSZXF1ZXN0 ZWQoUVJlY3QpKSwKKyAgICAgICAgICAgIHRoaXMsIFNMT1QoX3FfZG9VcGRhdGUoY29uc3QgUVJl Y3QmKSkpOworICAgIGNvbm5lY3QoZC0+cGFnZSwgU0lHTkFMKHNjcm9sbFJlcXVlc3RlZChpbnQs IGludCwgY29uc3QgUVJlY3QmKSksCisgICAgICAgICAgICB0aGlzLCBTTE9UKF9xX2RvU2Nyb2xs KGludCwgaW50LCBjb25zdCBRUmVjdCYpKSk7CisgICAgY29ubmVjdChkLT5wYWdlLCBTSUdOQUwo c3RhdHVzQmFyTWVzc2FnZShjb25zdCBRU3RyaW5nJikpLAorICAgICAgICAgICAgdGhpcywgU0xP VChfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNvbnN0IFFTdHJpbmcmKSkpOworfQorCisvKiEKKyAg ICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6dXJsCisgICAgXGJyaWVmIHRoZSB1cmwgb2Yg dGhlIHdlYiBwYWdlIGN1cnJlbnRseSB2aWV3ZWQKKworICAgIFNldHRpbmcgdGhpcyBwcm9wZXJ0 eSBjbGVhcnMgdGhlIHZpZXcgYW5kIGxvYWRzIHRoZSBVUkwuCisKKyAgICBCeSBkZWZhdWx0LCB0 aGlzIHByb3BlcnR5IGNvbnRhaW5zIGFuIGVtcHR5LCBpbnZhbGlkIFVSTC4KKworICAgIFxzYSBs b2FkKCksIHVybENoYW5nZWQoKQorKi8KKwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjpzZXRVcmwo Y29uc3QgUVVybCAmdXJsKQoreworICAgIGlmICghZC0+cGFnZSB8fCBkLT5wYWdlLT5tYWluRnJh bWUoKS0+dXJsKCkgPT0gdXJsKQorICAgICAgICByZXR1cm47CisKKyAgICBkLT5wYWdlLT5tYWlu RnJhbWUoKS0+c2V0VXJsKHVybCk7Cit9CisKK1FVcmwgUVdlYkdyYXBoaWNzSXRlbTo6dXJsKCkg Y29uc3QKK3sKKyAgICBpZiAoZC0+cGFnZSkKKyAgICAgICAgcmV0dXJuIGQtPnBhZ2UtPm1haW5G cmFtZSgpLT51cmwoKTsKKworICAgIHJldHVybiBRVXJsKCk7Cit9CisKKy8qIQorICAgIFxwcm9w ZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjp0aXRsZQorICAgIFxicmllZiB0aGUgdGl0bGUgb2YgdGhl IHdlYiBwYWdlIGN1cnJlbnRseSB2aWV3ZWQKKworICAgIEJ5IGRlZmF1bHQsIHRoaXMgcHJvcGVy dHkgY29udGFpbnMgYW4gZW1wdHkgc3RyaW5nLgorCisgICAgXHNhIHRpdGxlQ2hhbmdlZCgpCisq LworUVN0cmluZyBRV2ViR3JhcGhpY3NJdGVtOjp0aXRsZSgpIGNvbnN0Cit7CisgICAgaWYgKGQt PnBhZ2UpCisgICAgICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJhbWUoKS0+dGl0bGUoKTsKKwor ICAgIHJldHVybiBRU3RyaW5nKCk7Cit9CisKKy8qIQorICAgIFxwcm9wZXJ0eSBRV2ViR3JhcGhp Y3NJdGVtOjppY29uCisgICAgXGJyaWVmIHRoZSBpY29uIGFzc29jaWF0ZWQgd2l0aCB0aGUgd2Vi IHBhZ2UgY3VycmVudGx5IHZpZXdlZAorCisgICAgQnkgZGVmYXVsdCwgdGhpcyBwcm9wZXJ0eSBj b250YWlucyBhIG51bGwgaWNvbi4KKworICAgIFxzYSBpY29uQ2hhbmdlZCgpLCBRV2ViU2V0dGlu Z3M6Omljb25Gb3JVcmwoKQorKi8KK1FJY29uIFFXZWJHcmFwaGljc0l0ZW06Omljb24oKSBjb25z dAoreworICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJhbWUoKS0+aWNvbigpOworfQorCisvKiEK KyAgICBccHJvcGVydHkgUVdlYkdyYXBoaWNzSXRlbTo6em9vbUZhY3RvcgorICAgIFxzaW5jZSA0 LjUKKyAgICBcYnJpZWYgdGhlIHpvb20gZmFjdG9yIGZvciB0aGUgdmlldworKi8KKwordm9pZCBR V2ViR3JhcGhpY3NJdGVtOjpzZXRab29tRmFjdG9yKHFyZWFsIGZhY3RvcikKK3sKKyAgICBpZiAo ZmFjdG9yID09IGQtPnBhZ2UtPm1haW5GcmFtZSgpLT56b29tRmFjdG9yKCkpCisgICAgICAgIHJl dHVybjsKKworICAgIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT5zZXRab29tRmFjdG9yKGZhY3Rvcik7 CisKKyAgICBlbWl0IHpvb21GYWN0b3JDaGFuZ2VkKCk7Cit9CisKK3FyZWFsIFFXZWJHcmFwaGlj c0l0ZW06Onpvb21GYWN0b3IoKSBjb25zdAoreworICAgIHJldHVybiBkLT5wYWdlLT5tYWluRnJh bWUoKS0+em9vbUZhY3RvcigpOworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhp Y3NJdGVtOjp1cGRhdGVHZW9tZXRyeSgpCit7CisgICAgUUdyYXBoaWNzV2lkZ2V0Ojp1cGRhdGVH ZW9tZXRyeSgpOworICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUoKS50b1NpemUoKTsK KyAgICBkLT5wYWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7Cit9CisKKy8qISBccmVpbXAKKyov Cit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnNldEdlb21ldHJ5KGNvbnN0IFFSZWN0RiYgcmVjdCkK K3sKKyAgICBRR3JhcGhpY3NXaWRnZXQ6OnNldEdlb21ldHJ5KHJlY3QpOworICAgIC8vIE5PVEU6 IGNhbGwgZ2VvbWV0cnkoKSBhcyBzZXRHZW9tZXRyeSBlbnN1cmVzIHRoYXQKKyAgICAvLyB0aGUg Z2VvbWV0cnkgaXMgd2l0aGluIGxlZ2FsIGJvdW5kcyAobWluaW11bVNpemUsIG1heGltdW1TaXpl KQorICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUoKS50b1NpemUoKTsKKyAgICBkLT5w YWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7Cit9CisKKy8qIQorICAgIFxicmllZiBUaGUgbG9h ZCBzdGF0dXMgbWVzc2FnZSBhc3NvY2lhdGVkIHRvIHRoZSB3ZWIgZ3JhcGhpY3NpdGVtCisKKyAg ICBQcm92aWRlcyB0aGUgbGF0ZXN0IHN0YXR1cyBtZXNzYWdlIHNldCBkdXJpbmcgdGhlIGxvYWQg b2YgYSBVUkwuCisgICAgQ29tbW9ubHkgc2hvd24gYnkgU3RhdHVzIEJhciB3aWRnZXRzLgorCisg ICAgXHNhIHN0YXR1c0NoYW5nZWQoKQorKi8KKworUVN0cmluZyBRV2ViR3JhcGhpY3NJdGVtOjpz dGF0dXMoKSBjb25zdAoreworICAgIHJldHVybiBkLT5zdGF0dXNCYXJNZXNzYWdlOworfQorCisv KiEKKyAgICBDb252ZW5pZW5jZSBzbG90IHRoYXQgc3RvcHMgbG9hZGluZyB0aGUgZG9jdW1lbnQu CisKKyAgICBcc2EgcmVsb2FkKCksIHBhZ2VBY3Rpb24oKSwgbG9hZEZpbmlzaGVkKCkKKyovCit2 b2lkIFFXZWJHcmFwaGljc0l0ZW06OnN0b3AoKQoreworICAgIGlmIChkLT5wYWdlKQorICAgICAg ICBkLT5wYWdlLT50cmlnZ2VyQWN0aW9uKFFXZWJQYWdlOjpTdG9wKTsKK30KKworLyohCisgICAg Q29udmVuaWVuY2Ugc2xvdCB0aGF0IGxvYWRzIHRoZSBwcmV2aW91cyBkb2N1bWVudCBpbiB0aGUg bGlzdCBvZiBkb2N1bWVudHMKKyAgICBidWlsdCBieSBuYXZpZ2F0aW5nIGxpbmtzLiBEb2VzIG5v dGhpbmcgaWYgdGhlcmUgaXMgbm8gcHJldmlvdXMgZG9jdW1lbnQuCisKKyAgICBcc2EgZm9yd2Fy ZCgpLCBwYWdlQWN0aW9uKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmJhY2soKQorewor ICAgIGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT50cmlnZ2VyQWN0aW9uKFFXZWJQYWdl OjpCYWNrKTsKK30KKworLyohCisgICAgQ29udmVuaWVuY2Ugc2xvdCB0aGF0IGxvYWRzIHRoZSBu ZXh0IGRvY3VtZW50IGluIHRoZSBsaXN0IG9mIGRvY3VtZW50cworICAgIGJ1aWx0IGJ5IG5hdmln YXRpbmcgbGlua3MuIERvZXMgbm90aGluZyBpZiB0aGVyZSBpcyBubyBuZXh0IGRvY3VtZW50Lgor CisgICAgXHNhIGJhY2soKSwgcGFnZUFjdGlvbigpCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVt Ojpmb3J3YXJkKCkKK3sKKyAgICBpZiAoZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+dHJpZ2dl ckFjdGlvbihRV2ViUGFnZTo6Rm9yd2FyZCk7Cit9CisKKy8qIQorICAgIFJlbG9hZHMgdGhlIGN1 cnJlbnQgZG9jdW1lbnQuCisKKyAgICBcc2Egc3RvcCgpLCBwYWdlQWN0aW9uKCksIGxvYWRTdGFy dGVkKCkKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OnJlbG9hZCgpCit7CisgICAgaWYgKGQt PnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPnRyaWdnZXJBY3Rpb24oUVdlYlBhZ2U6OlJlbG9hZCk7 Cit9CisKKy8qIQorICAgIFxwcm9wZXJ0eSBRV2ViR3JhcGhpY3NJdGVtOjpwcm9ncmVzcworICAg IFxicmllZiB0aGUgcHJvZ3Jlc3Mgb2YgbG9hZGluZyB0aGUgY3VycmVudCBVUkwsIGZyb20gMCB0 byAxLgorKi8KK3FyZWFsIFFXZWJHcmFwaGljc0l0ZW06OnByb2dyZXNzKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gZC0+cHJvZ3Jlc3M7Cit9CisKKy8qIQorICAgIExvYWRzIHRoZSBzcGVjaWZpZWQg XGEgdXJsIGFuZCBkaXNwbGF5cyBpdC4KKworICAgIFxub3RlIFRoZSB2aWV3IHJlbWFpbnMgdGhl IHNhbWUgdW50aWwgZW5vdWdoIGRhdGEgaGFzIGFycml2ZWQgdG8gZGlzcGxheSB0aGUgbmV3IFxh IHVybC4KKworICAgIFxzYSBzZXRVcmwoKSwgdXJsKCksIHVybENoYW5nZWQoKQorKi8KK3ZvaWQg UVdlYkdyYXBoaWNzSXRlbTo6bG9hZChjb25zdCBRVXJsJiB1cmwpCit7CisgICAgZC0+cGFnZS0+ bWFpbkZyYW1lKCktPmxvYWQodXJsKTsKK30KKworLyohCisgICAgXGZuIHZvaWQgUVdlYkdyYXBo aWNzSXRlbTo6bG9hZChjb25zdCBRTmV0d29ya1JlcXVlc3QgJnJlcXVlc3QsIFFOZXR3b3JrQWNj ZXNzTWFuYWdlcjo6T3BlcmF0aW9uIG9wZXJhdGlvbiwgY29uc3QgUUJ5dGVBcnJheSAmYm9keSkK KworICAgIExvYWRzIGEgbmV0d29yayByZXF1ZXN0LCBcYSByZXF1ZXN0LCB1c2luZyB0aGUgbWV0 aG9kIHNwZWNpZmllZCBpbiBcYSBvcGVyYXRpb24uCisKKyAgICBcYSBib2R5IGlzIG9wdGlvbmFs IGFuZCBpcyBvbmx5IHVzZWQgZm9yIFBPU1Qgb3BlcmF0aW9ucy4KKworICAgIFxub3RlIFRoZSB2 aWV3IHJlbWFpbnMgdGhlIHNhbWUgdW50aWwgZW5vdWdoIGRhdGEgaGFzIGFycml2ZWQgdG8gZGlz cGxheSB0aGUgbmV3IHVybC4KKworICAgIFxzYSB1cmwoKSwgdXJsQ2hhbmdlZCgpCisqLworCit2 b2lkIFFXZWJHcmFwaGljc0l0ZW06OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0JiByZXF1ZXN0 LAorICAgICAgICAgICAgICAgICAgICBRTmV0d29ya0FjY2Vzc01hbmFnZXI6Ok9wZXJhdGlvbiBv cGVyYXRpb24sCisgICAgICAgICAgICAgICAgICAgIGNvbnN0IFFCeXRlQXJyYXkmIGJvZHkpCit7 CisgICAgZC0+cGFnZS0+bWFpbkZyYW1lKCktPmxvYWQocmVxdWVzdCwgb3BlcmF0aW9uLCBib2R5 KTsKK30KKworLyohCisgICAgU2V0cyB0aGUgY29udGVudCBvZiB0aGUgd2ViIGdyYXBoaWNzaXRl bSB0byB0aGUgc3BlY2lmaWVkIFxhIGh0bWwuCisKKyAgICBFeHRlcm5hbCBvYmplY3RzIHN1Y2gg YXMgc3R5bGVzaGVldHMgb3IgaW1hZ2VzIHJlZmVyZW5jZWQgaW4gdGhlIEhUTUwKKyAgICBkb2N1 bWVudCBhcmUgbG9jYXRlZCByZWxhdGl2ZSB0byBcYSBiYXNlVXJsLgorCisgICAgVGhlIFxhIGh0 bWwgaXMgbG9hZGVkIGltbWVkaWF0ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5 bmNocm9ub3VzbHkuCisKKyAgICBXaGVuIHVzaW5nIHRoaXMgbWV0aG9kLCBXZWJLaXQgYXNzdW1l cyB0aGF0IGV4dGVybmFsIHJlc291cmNlcyBzdWNoIGFzCisgICAgSmF2YVNjcmlwdCBwcm9ncmFt cyBvciBzdHlsZSBzaGVldHMgYXJlIGVuY29kZWQgaW4gVVRGLTggdW5sZXNzIG90aGVyd2lzZQor ICAgIHNwZWNpZmllZC4gRm9yIGV4YW1wbGUsIHRoZSBlbmNvZGluZyBvZiBhbiBleHRlcm5hbCBz Y3JpcHQgY2FuIGJlIHNwZWNpZmllZAorICAgIHRocm91Z2ggdGhlIGNoYXJzZXQgYXR0cmlidXRl IG9mIHRoZSBIVE1MIHNjcmlwdCB0YWcuIEFsdGVybmF0aXZlbHksIHRoZQorICAgIGVuY29kaW5n IGNhbiBhbHNvIGJlIHNwZWNpZmllZCBieSB0aGUgd2ViIHNlcnZlci4KKworICAgIFxzYSBsb2Fk KCksIHNldENvbnRlbnQoKSwgUVdlYkZyYW1lOjp0b0h0bWwoKQorKi8KK3ZvaWQgUVdlYkdyYXBo aWNzSXRlbTo6c2V0SHRtbChjb25zdCBRU3RyaW5nJiBodG1sLCBjb25zdCBRVXJsJiBiYXNlVXJs KQoreworICAgIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT5zZXRIdG1sKGh0bWwsIGJhc2VVcmwpOwor fQorCitRU3RyaW5nIFFXZWJHcmFwaGljc0l0ZW06OnRvSHRtbCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIGQtPnBhZ2UtPm1haW5GcmFtZSgpLT50b0h0bWwoKTsKK30KKworLyohCisgICAgU2V0cyB0 aGUgY29udGVudCBvZiB0aGUgd2ViIGdyYXBoaWNzaXRlbSB0byB0aGUgc3BlY2lmaWVkIGNvbnRl bnQgXGEgZGF0YS4gSWYgdGhlIFxhIG1pbWVUeXBlIGFyZ3VtZW50CisgICAgaXMgZW1wdHkgaXQg aXMgY3VycmVudGx5IGFzc3VtZWQgdGhhdCB0aGUgY29udGVudCBpcyBIVE1MIGJ1dCBpbiBmdXR1 cmUgdmVyc2lvbnMgd2UgbWF5IGludHJvZHVjZQorICAgIGF1dG8tZGV0ZWN0aW9uLgorCisgICAg RXh0ZXJuYWwgb2JqZWN0cyByZWZlcmVuY2VkIGluIHRoZSBjb250ZW50IGFyZSBsb2NhdGVkIHJl bGF0aXZlIHRvIFxhIGJhc2VVcmwuCisKKyAgICBUaGUgXGEgZGF0YSBpcyBsb2FkZWQgaW1tZWRp YXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25vdXNseS4KKworICAg IFxzYSBsb2FkKCksIHNldEh0bWwoKSwgUVdlYkZyYW1lOjp0b0h0bWwoKQorKi8KK3ZvaWQgUVdl YkdyYXBoaWNzSXRlbTo6c2V0Q29udGVudChjb25zdCBRQnl0ZUFycmF5JiBkYXRhLCBjb25zdCBR U3RyaW5nJiBtaW1lVHlwZSwgY29uc3QgUVVybCYgYmFzZVVybCkKK3sKKyAgICBkLT5wYWdlLT5t YWluRnJhbWUoKS0+c2V0Q29udGVudChkYXRhLCBtaW1lVHlwZSwgYmFzZVVybCk7Cit9CisKKy8q IQorICAgIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSB2aWV3J3MgaGlzdG9yeSBvZiBuYXZpZ2F0 ZWQgd2ViIHBhZ2VzLgorCisgICAgSXQgaXMgZXF1aXZhbGVudCB0bworCisgICAgXHNuaXBwZXQg d2Via2l0c25pcHBldHMvcXR3ZWJraXRfcXdlYnZpZXdfc25pcHBldC5jcHAgMAorKi8KK1FXZWJI aXN0b3J5KiBRV2ViR3JhcGhpY3NJdGVtOjpoaXN0b3J5KCkgY29uc3QKK3sKKyAgICByZXR1cm4g ZC0+cGFnZS0+aGlzdG9yeSgpOworfQorCisvKiEKKyAgXHByb3BlcnR5IFFXZWJHcmFwaGljc0l0 ZW06OmludGVyYWN0aXZlCisgIFxicmllZiBjb250cm9scyB3aGV0aGVyIHRoZSBpdGVtIHJlc3Bv bmRzIHRvIG1vdXNlIGFuZCBrZXkgZXZlbnRzLgorKi8KKworYm9vbCBRV2ViR3JhcGhpY3NJdGVt Ojppc0ludGVyYWN0aXZlKCkgY29uc3QKK3sKKyAgICByZXR1cm4gZC0+aW50ZXJhY3RpdmU7Cit9 CisKK3ZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6c2V0SW50ZXJhY3RpdmUoYm9vbCBhbGxvd2VkKQor eworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSA9PSBhbGxvd2VkKQorICAgICAgICByZXR1cm47CisK KyAgICBkLT5pbnRlcmFjdGl2ZSA9IGFsbG93ZWQ7CisgICAgZW1pdCBpbnRlcmFjdGl2aXR5Q2hh bmdlZCgpOworfQorCisvKiEKKyAgICBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgdmlldy9wYWdl IHNwZWNpZmljIHNldHRpbmdzIG9iamVjdC4KKworICAgIEl0IGlzIGVxdWl2YWxlbnQgdG8KKwor ICAgIFxzbmlwcGV0IHdlYmtpdHNuaXBwZXRzL3F0d2Via2l0X3F3ZWJ2aWV3X3NuaXBwZXQuY3Bw IDEKKworICAgIFxzYSBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdzKCkKKyovCitRV2ViU2V0 dGluZ3MqIFFXZWJHcmFwaGljc0l0ZW06OnNldHRpbmdzKCkgY29uc3QKK3sKKyAgICByZXR1cm4g ZC0+cGFnZS0+c2V0dGluZ3MoKTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBo aWNzSXRlbTo6aG92ZXJNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVIb3ZlckV2ZW50KiBldikKK3sK KyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29s IGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAgICAgICAgUU1vdXNlRXZlbnQgbWUgPSBR TW91c2VFdmVudChRRXZlbnQ6Ok1vdXNlTW92ZSwKKyAgICAgICAgICAgICAgICBldi0+cG9zKCku dG9Qb2ludCgpLCBRdDo6Tm9CdXR0b24sCisgICAgICAgICAgICAgICAgUXQ6Ok5vQnV0dG9uLCBR dDo6Tm9Nb2RpZmllcik7CisgICAgICAgIGQtPnBhZ2UtPnNldFZpZXcoZXYtPndpZGdldCgpKTsK KyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoJm1lKTsKKyAgICAgICAgZXYtPnNldEFjY2VwdGVkKGFj Y2VwdGVkKTsKKyAgICB9CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFH cmFwaGljc0l0ZW06OmhvdmVyTW92ZUV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAorKi8KK3Zv aWQgUVdlYkdyYXBoaWNzSXRlbTo6aG92ZXJMZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJF dmVudCogZXYpCit7CisgICAgUV9VTlVTRUQoZXYpOworfQorCisvKiEgXHJlaW1wCisqLwordm9p ZCBRV2ViR3JhcGhpY3NJdGVtOjptb3VzZU1vdmVFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZl bnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAg IGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdl LT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQor CisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3Vz ZU1vdmVFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0 ZW06Om1vdXNlUHJlc3NFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAg IGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNj ZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7Cisg ICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+ aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZVByZXNzRXZlbnQoZXYp OworfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjptb3VzZVJlbGVh c2VFdmVudChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRl cmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+ aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5z ZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgp KQorICAgICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZVJlbGVhc2VFdmVudChldik7Cit9CisKKy8q ISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06Om1vdXNlRG91YmxlQ2xpY2tFdmVu dChRR3JhcGhpY3NTY2VuZU1vdXNlRXZlbnQqIGV2KQoreworICAgIGlmIChkLT5pbnRlcmFjdGl2 ZSAmJiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2Nl cHRlZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2Nl cHRlZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAg ICAgICBRR3JhcGhpY3NJdGVtOjptb3VzZURvdWJsZUNsaWNrRXZlbnQoZXYpOworfQorCisvKiEg XHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJdGVtOjprZXlQcmVzc0V2ZW50KFFLZXlFdmVu dCogZXYpCit7CisgICAgaWYgKGQtPmludGVyYWN0aXZlICYmIGQtPnBhZ2UpCisgICAgICAgIGQt PnBhZ2UtPmV2ZW50KGV2KTsKKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAg UUdyYXBoaWNzSXRlbTo6a2V5UHJlc3NFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2 b2lkIFFXZWJHcmFwaGljc0l0ZW06OmtleVJlbGVhc2VFdmVudChRS2V5RXZlbnQqIGV2KQorewor ICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5ldmVu dChldik7CisKKyAgICBpZiAoIWV2LT5pc0FjY2VwdGVkKCkpCisgICAgICAgIFFHcmFwaGljc0l0 ZW06OmtleVJlbGVhc2VFdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJH cmFwaGljc0l0ZW06OmZvY3VzSW5FdmVudChRRm9jdXNFdmVudCogZXYpCit7CisgICAgaWYgKGQt PnBhZ2UpCisgICAgICAgIGQtPnBhZ2UtPmV2ZW50KGV2KTsKKyAgICBlbHNlCisgICAgICAgIFFH cmFwaGljc0l0ZW06OmZvY3VzSW5FdmVudChldik7Cit9CisKKy8qISBccmVpbXAKKyovCit2b2lk IFFXZWJHcmFwaGljc0l0ZW06OmZvY3VzT3V0RXZlbnQoUUZvY3VzRXZlbnQqIGV2KQoreworICAg IGlmIChkLT5wYWdlKQorICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgZWxzZQorICAg ICAgICBRR3JhcGhpY3NJdGVtOjpmb2N1c091dEV2ZW50KGV2KTsKK30KKworLyohIFxyZWltcAor Ki8KK2Jvb2wgUVdlYkdyYXBoaWNzSXRlbTo6Zm9jdXNOZXh0UHJldkNoaWxkKGJvb2wgbmV4dCkK K3sKKyAgICBpZiAoZC0+cGFnZSkKKyAgICAgICAgcmV0dXJuIGQtPnBhZ2UtPmZvY3VzTmV4dFBy ZXZDaGlsZChuZXh0KTsKKworICAgIHJldHVybiBRR3JhcGhpY3NXaWRnZXQ6OmZvY3VzTmV4dFBy ZXZDaGlsZChuZXh0KTsKK30KKworLyohIFxyZWltcAorKi8KK3ZvaWQgUVdlYkdyYXBoaWNzSXRl bTo6ZHJhZ0VudGVyRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyNp Zm5kZWYgUVRfTk9fRFJBR0FORERST1AKKyAgICAvL2lmIChkLT5wYWdlKQorICAgIC8vICAgIGQt PnBhZ2UtPmV2ZW50KGV2KTsKKyAgICAvL0p1c3QgcmVtb3ZlIHRoaXMgbGluZSBiZWxvdyB3aGVu IHRoZSBjb2RlIGFib3ZlIGlzIHdvcmtpbmcKKyAgICBRX1VOVVNFRChldik7CisjZWxzZQorICAg IFFfVU5VU0VEKGV2KTsKKyNlbmRpZgorfQorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3Jh cGhpY3NJdGVtOjpkcmFnTGVhdmVFdmVudChRR3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2 KQoreworI2lmbmRlZiBRVF9OT19EUkFHQU5ERFJPUAorICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAm JiBkLT5wYWdlKSB7CisgICAgICAgIGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRl ZCgpOworICAgICAgICBkLT5wYWdlLT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRl ZChhY2NlcHRlZCk7CisgICAgfQorCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAg ICBRR3JhcGhpY3NXaWRnZXQ6OmRyYWdMZWF2ZUV2ZW50KGV2KTsKKyNlbHNlCisgICAgUV9VTlVT RUQoZXYpOworI2VuZGlmCit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0 ZW06OmRyYWdNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50KiBldikKK3sKKyNp Zm5kZWYgUVRfTk9fRFJBR0FORERST1AKKyAgICBpZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFn ZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAg ICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0 ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNjZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBo aWNzV2lkZ2V0OjpkcmFnTW92ZUV2ZW50KGV2KTsKKyNlbHNlCisgICAgUV9VTlVTRUQoZXYpOwor I2VuZGlmCit9CisKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0ZW06OmRyb3BF dmVudChRR3JhcGhpY3NTY2VuZURyYWdEcm9wRXZlbnQqIGV2KQoreworI2lmbmRlZiBRVF9OT19E UkFHQU5ERFJPUAorICAgIGlmIChkLT5pbnRlcmFjdGl2ZSAmJiBkLT5wYWdlKSB7CisgICAgICAg IGNvbnN0IGJvb2wgYWNjZXB0ZWQgPSBldi0+aXNBY2NlcHRlZCgpOworICAgICAgICBkLT5wYWdl LT5ldmVudChldik7CisgICAgICAgIGV2LT5zZXRBY2NlcHRlZChhY2NlcHRlZCk7CisgICAgfQor CisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NXaWRnZXQ6OmRy b3BFdmVudChldik7CisjZWxzZQorICAgIFFfVU5VU0VEKGV2KTsKKyNlbmRpZgorfQorCisjaWZu ZGVmIFFUX05PX0NPTlRFWFRNRU5VCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhpY3NJ dGVtOjpjb250ZXh0TWVudUV2ZW50KFFDb250ZXh0TWVudUV2ZW50KiBldikKK3sKKyAgICBpZiAo ZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVkID0gZXYtPmlzQWNjZXB0ZWQo KTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAgICBldi0+c2V0QWNjZXB0ZWQo YWNjZXB0ZWQpOworICAgIH0KK30KKyNlbmRpZiAvLyBRVF9OT19DT05URVhUTUVOVQorCisjaWZu ZGVmIFFUX05PX1dIRUVMRVZFTlQKKy8qISBccmVpbXAKKyovCit2b2lkIFFXZWJHcmFwaGljc0l0 ZW06OndoZWVsRXZlbnQoUUdyYXBoaWNzU2NlbmVXaGVlbEV2ZW50KiBldikKK3sKKyAgICBpZiAo ZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkgeworICAgICAgICBjb25zdCBib29sIGFjY2VwdGVk ID0gZXYtPmlzQWNjZXB0ZWQoKTsKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYpOworICAgICAg ICBldi0+c2V0QWNjZXB0ZWQoYWNjZXB0ZWQpOworICAgIH0KKworICAgIGlmICghZXYtPmlzQWNj ZXB0ZWQoKSkKKyAgICAgICAgUUdyYXBoaWNzSXRlbTo6d2hlZWxFdmVudChldik7Cit9CisjZW5k aWYgLy8gUVRfTk9fV0hFRUxFVkVOVAorCisvKiEgXHJlaW1wCisqLwordm9pZCBRV2ViR3JhcGhp Y3NJdGVtOjppbnB1dE1ldGhvZEV2ZW50KFFJbnB1dE1ldGhvZEV2ZW50KiBldikKK3sKKyAgICBp ZiAoZC0+aW50ZXJhY3RpdmUgJiYgZC0+cGFnZSkKKyAgICAgICAgZC0+cGFnZS0+ZXZlbnQoZXYp OworCisgICAgaWYgKCFldi0+aXNBY2NlcHRlZCgpKQorICAgICAgICBRR3JhcGhpY3NJdGVtOjpp bnB1dE1ldGhvZEV2ZW50KGV2KTsKK30KKworI2luY2x1ZGUgIm1vY19xd2ViZ3JhcGhpY3NpdGVt LmNwcCIKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5oIGIvV2Vi S2l0L3F0L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZDQxZjU1MgotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmdy YXBoaWNzaXRlbS5oCkBAIC0wLDAgKzEsMTQzIEBACisvKgorICAgIENvcHlyaWdodCAoQykgMjAw OSBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKworICAgIFRo aXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IKKyAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlcgorICAgIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgIFRoaXMgbGlicmFyeSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgICBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICAg IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisqLworCisjaWZu ZGVmIFFXZWJHcmFwaGljc0l0ZW1faAorI2RlZmluZSBRV2ViR3JhcGhpY3NJdGVtX2gKKworI2lu Y2x1ZGUgInF3ZWJraXRnbG9iYWwuaCIKKyNpbmNsdWRlIDxRdC9xZXZlbnQuaD4KKyNpbmNsdWRl IDxRdENvcmUvcXVybC5oPgorI2luY2x1ZGUgPFF0R3VpL3FncmFwaGljc3dpZGdldC5oPgorI2lu Y2x1ZGUgPFF0R3VpL3FpY29uLmg+CisjaW5jbHVkZSA8UXRHdWkvcXBhaW50ZXIuaD4KKyNpbmNs dWRlIDxRdE5ldHdvcmsvcW5ldHdvcmthY2Nlc3NtYW5hZ2VyLmg+CisKK2NsYXNzIFFXZWJQYWdl OworY2xhc3MgUVdlYkhpc3Rvcnk7CitjbGFzcyBRV2ViU2V0dGluZ3M7CisKK2NsYXNzIFFXZWJH cmFwaGljc0l0ZW1Qcml2YXRlOworCitjbGFzcyBRV0VCS0lUX0VYUE9SVCBRV2ViR3JhcGhpY3NJ dGVtIDogcHVibGljIFFHcmFwaGljc1dpZGdldCB7CisgICAgUV9PQkpFQ1QKKworICAgIFFfUFJP UEVSVFkoUVN0cmluZyB0aXRsZSBSRUFEIHRpdGxlIE5PVElGWSB0aXRsZUNoYW5nZWQpCisgICAg UV9QUk9QRVJUWShRSWNvbiBpY29uIFJFQUQgaWNvbiBOT1RJRlkgaWNvbkNoYW5nZWQpCisgICAg UV9QUk9QRVJUWShxcmVhbCB6b29tRmFjdG9yIFJFQUQgem9vbUZhY3RvciBXUklURSBzZXRab29t RmFjdG9yIE5PVElGWSB6b29tRmFjdG9yQ2hhbmdlZCkKKyAgICBRX1BST1BFUlRZKFFTdHJpbmcg c3RhdHVzIFJFQUQgc3RhdHVzIE5PVElGWSBzdGF0dXNDaGFuZ2VkKQorCisgICAgUV9QUk9QRVJU WShRU3RyaW5nIGh0bWwgUkVBRCB0b0h0bWwgV1JJVEUgc2V0SHRtbCkKKyAgICBRX1BST1BFUlRZ KFFVcmwgdXJsIFJFQUQgdXJsIFdSSVRFIHNldFVybCBOT1RJRlkgdXJsQ2hhbmdlZCkKKyAgICBR X1BST1BFUlRZKHFyZWFsIHByb2dyZXNzIFJFQUQgcHJvZ3Jlc3MgTk9USUZZIHByb2dyZXNzQ2hh bmdlZCkKKworICAgIFFfUFJPUEVSVFkoYm9vbCBpbnRlcmFjdGl2ZSBSRUFEIGlzSW50ZXJhY3Rp dmUgV1JJVEUgc2V0SW50ZXJhY3RpdmUgTk9USUZZIGludGVyYWN0aXZpdHlDaGFuZ2VkKQorCitw dWJsaWM6CisgICAgUVdlYkdyYXBoaWNzSXRlbShRR3JhcGhpY3NJdGVtKiBwYXJlbnQgPSAwKTsK KyAgICB+UVdlYkdyYXBoaWNzSXRlbSgpOworCisgICAgUVdlYlBhZ2UqIHBhZ2UoKSBjb25zdDsK KyAgICB2b2lkIHNldFBhZ2UoUVdlYlBhZ2UqKTsKKworICAgIFFVcmwgdXJsKCkgY29uc3Q7Cisg ICAgdm9pZCBzZXRVcmwoY29uc3QgUVVybCYpOworCisgICAgUVN0cmluZyB0aXRsZSgpIGNvbnN0 OworICAgIFFJY29uIGljb24oKSBjb25zdDsKKworICAgIHFyZWFsIHpvb21GYWN0b3IoKSBjb25z dDsKKyAgICB2b2lkIHNldFpvb21GYWN0b3IocXJlYWwpOworCisgICAgYm9vbCBpc0ludGVyYWN0 aXZlKCkgY29uc3Q7CisgICAgdm9pZCBzZXRJbnRlcmFjdGl2ZShib29sKTsKKworICAgIHFyZWFs IHByb2dyZXNzKCkgY29uc3Q7CisKKyAgICB2b2lkIGxvYWQoY29uc3QgUVVybCAmdXJsKTsKKyAg ICB2b2lkIGxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0JiByZXF1ZXN0LCBRTmV0d29ya0FjY2Vz c01hbmFnZXI6Ok9wZXJhdGlvbiBvcGVyYXRpb24gPSBRTmV0d29ya0FjY2Vzc01hbmFnZXI6Okdl dE9wZXJhdGlvbiwgY29uc3QgUUJ5dGVBcnJheSYgYm9keSA9IFFCeXRlQXJyYXkoKSk7CisKKyAg ICBRU3RyaW5nIHRvSHRtbCgpIGNvbnN0OworICAgIHZvaWQgc2V0SHRtbChjb25zdCBRU3RyaW5n JiBodG1sLCBjb25zdCBRVXJsJiBiYXNlVXJsID0gUVVybCgpKTsKKyAgICAvLyBGSVhNRTogQ29u c2lkZXIgcmVuYW1lIHRvIHNldEh0bWw/CisgICAgdm9pZCBzZXRDb250ZW50KGNvbnN0IFFCeXRl QXJyYXkmIGRhdGEsIGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlID0gUVN0cmluZygpLCBjb25zdCBR VXJsJiBiYXNlVXJsID0gUVVybCgpKTsKKworICAgIFFXZWJIaXN0b3J5KiBoaXN0b3J5KCkgY29u c3Q7CisgICAgUVdlYlNldHRpbmdzKiBzZXR0aW5ncygpIGNvbnN0OworCisgICAgUVN0cmluZyBz dGF0dXMoKSBjb25zdDsKKworICAgIHZpcnR1YWwgdm9pZCBzZXRHZW9tZXRyeShjb25zdCBRUmVj dEYmIHJlY3QpOworICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVHZW9tZXRyeSgpOworICAgIHZpcnR1 YWwgdm9pZCBwYWludChRUGFpbnRlciosIGNvbnN0IFFTdHlsZU9wdGlvbkdyYXBoaWNzSXRlbSog b3B0aW9ucywgUVdpZGdldCogd2lkZ2V0ID0gMCk7CisKK3B1YmxpYyBRX1NMT1RTOgorICAgIHZv aWQgc3RvcCgpOworICAgIHZvaWQgYmFjaygpOworICAgIHZvaWQgZm9yd2FyZCgpOworICAgIHZv aWQgcmVsb2FkKCk7CisKK1FfU0lHTkFMUzoKKyAgICB2b2lkIGxvYWRTdGFydGVkKCk7CisgICAg dm9pZCBsb2FkRmluaXNoZWQoKTsKKyAgICB2b2lkIGxvYWRGYWlsZWQoKTsKKworICAgIHZvaWQg cHJvZ3Jlc3NDaGFuZ2VkKHFyZWFsKTsKKyAgICB2b2lkIGludGVyYWN0aXZpdHlDaGFuZ2VkKCk7 CisgICAgdm9pZCB1cmxDaGFuZ2VkKGNvbnN0IFFVcmwmKTsKKyAgICB2b2lkIHRpdGxlQ2hhbmdl ZChjb25zdCBRU3RyaW5nJik7CisgICAgdm9pZCBpY29uQ2hhbmdlZCgpOworICAgIHZvaWQgc3Rh dHVzQ2hhbmdlZCgpOworICAgIHZvaWQgem9vbUZhY3RvckNoYW5nZWQoKTsKKworcHJvdGVjdGVk OgorICAgIHZpcnR1YWwgdm9pZCBtb3VzZVByZXNzRXZlbnQoUUdyYXBoaWNzU2NlbmVNb3VzZUV2 ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIG1vdXNlRG91YmxlQ2xpY2tFdmVudChRR3JhcGhpY3NT Y2VuZU1vdXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgbW91c2VSZWxlYXNlRXZlbnQoUUdy YXBoaWNzU2NlbmVNb3VzZUV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIG1vdXNlTW92ZUV2ZW50 KFFHcmFwaGljc1NjZW5lTW91c2VFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBob3Zlck1vdmVF dmVudChRR3JhcGhpY3NTY2VuZUhvdmVyRXZlbnQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgaG92ZXJM ZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lSG92ZXJFdmVudCopOworI2lmbmRlZiBRVF9OT19XSEVF TEVWRU5UCisgICAgdmlydHVhbCB2b2lkIHdoZWVsRXZlbnQoUUdyYXBoaWNzU2NlbmVXaGVlbEV2 ZW50Kik7CisjZW5kaWYKKyAgICB2aXJ0dWFsIHZvaWQga2V5UHJlc3NFdmVudChRS2V5RXZlbnQq KTsKKyAgICB2aXJ0dWFsIHZvaWQga2V5UmVsZWFzZUV2ZW50KFFLZXlFdmVudCopOworI2lmbmRl ZiBRVF9OT19DT05URVhUTUVOVQorICAgIHZpcnR1YWwgdm9pZCBjb250ZXh0TWVudUV2ZW50KFFD b250ZXh0TWVudUV2ZW50Kik7CisjZW5kaWYKKyAgICB2aXJ0dWFsIHZvaWQgZHJhZ0VudGVyRXZl bnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGRyYWdM ZWF2ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCopOworICAgIHZpcnR1YWwgdm9p ZCBkcmFnTW92ZUV2ZW50KFFHcmFwaGljc1NjZW5lRHJhZ0Ryb3BFdmVudCopOworICAgIHZpcnR1 YWwgdm9pZCBkcm9wRXZlbnQoUUdyYXBoaWNzU2NlbmVEcmFnRHJvcEV2ZW50Kik7CisgICAgdmly dHVhbCB2b2lkIGZvY3VzSW5FdmVudChRRm9jdXNFdmVudCopOworICAgIHZpcnR1YWwgdm9pZCBm b2N1c091dEV2ZW50KFFGb2N1c0V2ZW50Kik7CisgICAgdmlydHVhbCB2b2lkIGlucHV0TWV0aG9k RXZlbnQoUUlucHV0TWV0aG9kRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgZm9jdXNOZXh0UHJl dkNoaWxkKGJvb2wgbmV4dCk7CisKK3ByaXZhdGU6CisgICAgUV9QUklWQVRFX1NMT1QoZCwgdm9p ZCBfcV9kb1Njcm9sbChpbnQgZHgsIGludCBkeSwgY29uc3QgUVJlY3QmKSkKKyAgICBRX1BSSVZB VEVfU0xPVChkLCB2b2lkIF9xX2RvTG9hZFByb2dyZXNzKGludCBwcm9ncmVzcykpCisgICAgUV9Q UklWQVRFX1NMT1QoZCwgdm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29sIHN1Y2Nlc3MpKQorICAg IFFfUFJJVkFURV9TTE9UKGQsIHZvaWQgX3FfZG9VcGRhdGUoY29uc3QgUVJlY3QmIGRpcnR5UmVj dCkpCisgICAgUV9QUklWQVRFX1NMT1QoZCwgdm9pZCBfcV9zZXRTdGF0dXNCYXJNZXNzYWdlKGNv bnN0IFFTdHJpbmcmIG1lc3NhZ2UpKQorCisgICAgUVdlYkdyYXBoaWNzSXRlbVByaXZhdGUqIGNv bnN0IGQ7CisgICAgZnJpZW5kIGNsYXNzIFFXZWJHcmFwaGljc0l0ZW1Qcml2YXRlOworfTsKKwor I2VuZGlmIC8vIFFXZWJHcmFwaGljc0l0ZW1faApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCmluZGV4IDI0NzQxYTEuLjEwYzc5 MzggMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaAorKysgYi9XZWJLaXQvcXQv QXBpL3F3ZWJwYWdlLmgKQEAgLTM1MSw2ICszNTEsNyBAQCBwcml2YXRlOgogICAgIGZyaWVuZCBj bGFzcyBRV2ViRnJhbWU7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJQYWdlUHJpdmF0ZTsKICAgICBm cmllbmQgY2xhc3MgUVdlYlZpZXc7CisgICAgZnJpZW5kIGNsYXNzIFFXZWJHcmFwaGljc0l0ZW07 CiAgICAgZnJpZW5kIGNsYXNzIFdlYkNvcmU6OkNocm9tZUNsaWVudFF0OwogICAgIGZyaWVuZCBj bGFzcyBXZWJDb3JlOjpFZGl0b3JDbGllbnRRdDsKICAgICBmcmllbmQgY2xhc3MgV2ViQ29yZTo6 RnJhbWVMb2FkZXJDbGllbnRRdDsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9X ZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IGQxMTkwN2YuLjVlMmVjYWEgMTAwNjQ0Ci0tLSBhL1dl YktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0 IEBACisyMDA5LTA5LTA5ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Vi a2l0Lm9yZz4sIEFudG9uaW8gR29tZXMgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgbmV3 IFFHcmFwaGljc1dpZGdldCBiYXNlZCB2ZXJzaW9uIG9mIHRoZSAiUVdlYlZpZXciCisgICAgICAg IHVuZGVyIHRoZSBuYW1lICJRV2ViR3JhcGhpY3NJdGVtIi4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjg4NjIKKworICAgICAgICBJbmNsdWRlcyBh biBhbHRlcm5hdGl2ZSBRdCBsYXVuY2hlciB1c2luZyB0aGUgUUdyYXBoaWNzVmlldy4KKworICAg ICAgICAqIEFwaS9oZWFkZXJzLnByaToKKyAgICAgICAgKiBBcGkvcXdlYmdyYXBoaWNzaXRlbS5j cHA6IEFkZGVkLgorICAgICAgICAqIEFwaS9xd2ViZ3JhcGhpY3NpdGVtLmg6IEFkZGVkLgorICAg ICAgICAqIEFwaS9xd2VicGFnZS5oOgorICAgICAgICAqIFFHVkxhdW5jaGVyL1FHVkxhdW5jaGVy LnBybzogQ29waWVkIGZyb20gV2ViS2l0L3F0L1F0TGF1bmNoZXIvUXRMYXVuY2hlci5wcm8uCisg ICAgICAgICogUUdWTGF1bmNoZXIvbWFpbi5jcHA6IEFkZGVkLgorICAgICAgICAqIFdlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNocm9tZUNsaWVu dFF0OjpyZXBhaW50KToKKyAgICAgICAgKFdlYkNvcmU6OkNocm9tZUNsaWVudFF0OjpzY3JvbGwp OgorCiAyMDA5LTA5LTA4ICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Vi a2l0Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIGJ1aWxkIGZpeC4KZGlmZiAtLWdpdCBhL1dl YktpdC9xdC9RR1ZMYXVuY2hlci9RR1ZMYXVuY2hlci5wcm8gYi9XZWJLaXQvcXQvUUdWTGF1bmNo ZXIvUUdWTGF1bmNoZXIucHJvCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI4 ODNiNTIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvcXQvUUdWTGF1bmNoZXIvUUdWTGF1bmNo ZXIucHJvCkBAIC0wLDAgKzEsMTMgQEAKK1RFTVBMQVRFID0gYXBwCitTT1VSQ0VTICs9IG1haW4u Y3BwCitDT05GSUcgLT0gYXBwX2J1bmRsZQorQ09ORklHICs9IHVpdG9vbHMKK0RFU1RESVIgPSAu Li8uLi8uLi9iaW4KKworaW5jbHVkZSguLi8uLi8uLi9XZWJLaXQucHJpKQorCitRVCArPSBuZXR3 b3JrCittYWN4OlFUKz14bWwKK1FNQUtFX1JQQVRIRElSID0gJCRPVVRQVVRfRElSL2xpYiAkJFFN QUtFX1JQQVRIRElSCisKK3N5bWJpYW46VEFSR0VULlVJRDMgPSAweDIwMDI2N0QwCmRpZmYgLS1n aXQgYS9XZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAgYi9XZWJLaXQvcXQvUUdWTGF1bmNo ZXIvbWFpbi5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmUzYWI0NQot LS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9xdC9RR1ZMYXVuY2hlci9tYWluLmNwcApAQCAtMCww ICsxLDMwMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBOb2tpYSBDb3Jwb3JhdGlvbiBh bmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAwNiBHZW9yZ2Ug U3RhaWtvcyA8c3RhaWtvc0BrZGUub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA2IERpcmsgTXVl bGxlciA8bXVlbGxlckBrZGUub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA2IFphY2sgUnVzaW4g PHphY2tAa2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwNiBTaW1vbiBIYXVzbWFubiA8aGF1 c21hbm5Aa2RlLm9yZz4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBLZW5uZXRoIENocmlzdGlhbnNl biA8a2VubmV0aEB3ZWJraXQub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFudG9uaW8gR29t ZXMgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KKyAqCisgKiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4g UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAg ICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUg ZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUg Q09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBD T01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpbmNsdWRlIDxxd2VicGFnZS5oPgorI2luY2x1ZGUgPHF3ZWJ2aWV3Lmg+ CisjaW5jbHVkZSA8cXdlYmdyYXBoaWNzaXRlbS5oPgorI2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgor I2luY2x1ZGUgPHF3ZWJzZXR0aW5ncy5oPgorI2luY2x1ZGUgPHF3ZWJlbGVtZW50Lmg+CisKKyNp bmNsdWRlIDxRTmV0d29ya1JlcXVlc3Q+CisjaW5jbHVkZSA8UUdyYXBoaWNzU2NlbmU+CisjaW5j bHVkZSA8UUdyYXBoaWNzVmlldz4KKyNpbmNsdWRlIDxRR3JhcGhpY3NXaWRnZXQ+CisKKyNpbmNs dWRlIDxRdEd1aT4KKyNpbmNsdWRlIDxRRGVidWc+CisjaW5jbHVkZSA8UXROZXR3b3JrL1FOZXR3 b3JrUHJveHk+CisKKyNpbmNsdWRlIDxRVmVjdG9yPgorI2luY2x1ZGUgPFFUZXh0U3RyZWFtPgor I2luY2x1ZGUgPFFGaWxlPgorI2luY2x1ZGUgPGNzdGRpbz4KKworY2xhc3MgV2ViUGFnZSA6IHB1 YmxpYyBRV2ViUGFnZSB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgorICAgIFdlYlBhZ2UoUVdp ZGdldCAqcGFyZW50ID0gMCkgOiBRV2ViUGFnZShwYXJlbnQpCisgICAgeworICAgICAgICBhcHBs eVByb3h5KCk7CisgICAgfQorICAgIHZpcnR1YWwgUVdlYlBhZ2UgKmNyZWF0ZVdpbmRvdyhRV2Vi UGFnZTo6V2ViV2luZG93VHlwZSk7CisKK3ByaXZhdGU6CisgICAgdm9pZCBhcHBseVByb3h5KCk7 Cit9OworCitjbGFzcyBNYWluVmlldyA6IHB1YmxpYyBRR3JhcGhpY3NWaWV3IHsKKyAgICBRX09C SkVDVAorCitwdWJsaWM6CisgICAgTWFpblZpZXcoUVdpZGdldCogcGFyZW50KSA6IFFHcmFwaGlj c1ZpZXcocGFyZW50KSwgbV9tYWluV2lkZ2V0KDApCisgICAgeworICAgICAgICBzZXRIb3Jpem9u dGFsU2Nyb2xsQmFyUG9saWN5KFF0OjpTY3JvbGxCYXJBbHdheXNPZmYpOworICAgICAgICBzZXRW ZXJ0aWNhbFNjcm9sbEJhclBvbGljeShRdDo6U2Nyb2xsQmFyQWx3YXlzT2ZmKTsKKyAgICB9CisK KyAgICB2b2lkIHNldE1haW5XaWRnZXQoUUdyYXBoaWNzV2lkZ2V0KiB3aWRnZXQpCisgICAgewor ICAgICAgICBRUmVjdEYgcmVjdChRUmVjdChRUG9pbnQoMCwgMCksIHNpemUoKSkpOworICAgICAg ICB3aWRnZXQtPnNldEdlb21ldHJ5KHJlY3QpOworICAgICAgICBtX21haW5XaWRnZXQgPSB3aWRn ZXQ7CisgICAgfQorCisgICAgdm9pZCByZXNpemVFdmVudChRUmVzaXplRXZlbnQqIGV2ZW50KQor ICAgIHsKKyAgICAgICAgUUdyYXBoaWNzVmlldzo6cmVzaXplRXZlbnQoZXZlbnQpOworICAgICAg ICBRUmVjdEYgcmVjdChRUmVjdChRUG9pbnQoMCwgMCksIGV2ZW50LT5zaXplKCkpKTsKKyAgICAg ICAgaWYgKCFtX21haW5XaWRnZXQpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIG1fbWFp bldpZGdldC0+c2V0R2VvbWV0cnkocmVjdCk7CisgICAgfQorCitwcml2YXRlOgorICAgIFFHcmFw aGljc1dpZGdldCogbV9tYWluV2lkZ2V0OworfTsKKworY2xhc3MgU2hhcmVkU2NlbmUgOiBwdWJs aWMgUVNoYXJlZERhdGEgeworcHVibGljOgorICAgIFNoYXJlZFNjZW5lKCkKKyAgICB7CisgICAg ICAgIG1fc2NlbmUgPSBuZXcgUUdyYXBoaWNzU2NlbmU7CisKKyAgICAgICAgbV9pdGVtID0gbmV3 IFFXZWJHcmFwaGljc0l0ZW07CisgICAgICAgIG1faXRlbS0+c2V0UGFnZShuZXcgV2ViUGFnZSgp KTsKKworICAgICAgICBtX3NjZW5lLT5hZGRJdGVtKG1faXRlbSk7CisgICAgICAgIG1fc2NlbmUt PnNldEFjdGl2ZVdpbmRvdyhtX2l0ZW0pOworICAgIH0KKworICAgIH5TaGFyZWRTY2VuZSgpCisg ICAgeworICAgICAgICBkZWxldGUgbV9pdGVtOworICAgICAgICBkZWxldGUgbV9zY2VuZTsKKyAg ICB9CisKKyAgICBRR3JhcGhpY3NTY2VuZSogc2NlbmUoKSBjb25zdCB7IHJldHVybiBtX3NjZW5l OyB9CisgICAgUVdlYkdyYXBoaWNzSXRlbSogd2ViSXRlbSgpIGNvbnN0IHsgcmV0dXJuIG1faXRl bTsgfQorCitwcml2YXRlOgorICAgIFFHcmFwaGljc1NjZW5lKiBtX3NjZW5lOworICAgIFFXZWJH cmFwaGljc0l0ZW0qIG1faXRlbTsKK307CisKKworY2xhc3MgTWFpbldpbmRvdyA6IHB1YmxpYyBR TWFpbldpbmRvdyB7CisgICAgUV9PQkpFQ1QKKworcHVibGljOgorICAgIE1haW5XaW5kb3coUUV4 cGxpY2l0bHlTaGFyZWREYXRhUG9pbnRlcjxTaGFyZWRTY2VuZT4gb3RoZXIpCisgICAgICAgIDog UU1haW5XaW5kb3coKSwgdmlldyhuZXcgTWFpblZpZXcodGhpcykpLCBzY2VuZShvdGhlcikKKyAg ICB7CisgICAgICAgIGluaXQoKTsKKyAgICB9CisKKyAgICBNYWluV2luZG93KCkKKyAgICAgICAg OiBRTWFpbldpbmRvdygpLCB2aWV3KG5ldyBNYWluVmlldyh0aGlzKSksIHNjZW5lKG5ldyBTaGFy ZWRTY2VuZSgpKQorICAgIHsKKyAgICAgICAgaW5pdCgpOworICAgIH0KKworICAgIHZvaWQgaW5p dCgpCisgICAgeworICAgICAgICBzZXRBdHRyaWJ1dGUoUXQ6OldBX0RlbGV0ZU9uQ2xvc2UpOwor CisgICAgICAgIHZpZXctPnNldFNjZW5lKHNjZW5lLT5zY2VuZSgpKTsKKyAgICAgICAgdmlldy0+ c2V0RnJhbWVTaGFwZShRRnJhbWU6Ok5vRnJhbWUpOworICAgICAgICB2aWV3LT5zZXRTaXplUG9s aWN5KFFTaXplUG9saWN5OjpFeHBhbmRpbmcsIFFTaXplUG9saWN5OjpFeHBhbmRpbmcpOworICAg ICAgICBzZXRDZW50cmFsV2lkZ2V0KHZpZXcpOworCisgICAgICAgIHZpZXctPnNldE1haW5XaWRn ZXQoc2NlbmUtPndlYkl0ZW0oKSk7CisKKyAgICAgICAgY29ubmVjdChzY2VuZS0+d2ViSXRlbSgp LCBTSUdOQUwobG9hZEZpbmlzaGVkKCkpLCB0aGlzLCBTTE9UKGxvYWRGaW5pc2hlZCgpKSk7Cisg ICAgICAgIGNvbm5lY3Qoc2NlbmUtPndlYkl0ZW0oKSwgU0lHTkFMKHRpdGxlQ2hhbmdlZChjb25z dCBRU3RyaW5nJikpLCB0aGlzLCBTTE9UKHNldFdpbmRvd1RpdGxlKGNvbnN0IFFTdHJpbmcmKSkp OworICAgICAgICBjb25uZWN0KHNjZW5lLT53ZWJJdGVtKCktPnBhZ2UoKSwgU0lHTkFMKHdpbmRv d0Nsb3NlUmVxdWVzdGVkKCkpLCB0aGlzLCBTTE9UKGNsb3NlKCkpKTsKKworICAgICAgICByZXNp emUoNjQwLCA0ODApOworICAgICAgICBidWlsZFVJKCk7CisgICAgfQorCisgICAgdm9pZCBsb2Fk KGNvbnN0IFFTdHJpbmcmIHVybCkKKyAgICB7CisgICAgICAgIFFVcmwgZGVkdWNlZFVybCA9IGd1 ZXNzVXJsRnJvbVN0cmluZyh1cmwpOworICAgICAgICBpZiAoIWRlZHVjZWRVcmwuaXNWYWxpZCgp KQorICAgICAgICAgICAgZGVkdWNlZFVybCA9IFFVcmwoImh0dHA6Ly8iICsgdXJsICsgIi8iKTsK KworICAgICAgICB1cmxFZGl0LT5zZXRUZXh0KGRlZHVjZWRVcmwudG9FbmNvZGVkKCkpOworICAg ICAgICBzY2VuZS0+d2ViSXRlbSgpLT5sb2FkKGRlZHVjZWRVcmwpOworICAgICAgICBzY2VuZS0+ d2ViSXRlbSgpLT5zZXRGb2N1cyhRdDo6T3RoZXJGb2N1c1JlYXNvbik7CisgICAgfQorCisgICAg UVVybCBndWVzc1VybEZyb21TdHJpbmcoY29uc3QgUVN0cmluZyYgc3RyaW5nKQorICAgIHsKKyAg ICAgICAgUVN0cmluZyBpbnB1dChzdHJpbmcpOworICAgICAgICBRRmlsZUluZm8gZmkoaW5wdXQp OworICAgICAgICBpZiAoZmkuZXhpc3RzKCkgJiYgZmkuaXNSZWxhdGl2ZSgpKQorICAgICAgICAg ICAgaW5wdXQgPSBmaS5hYnNvbHV0ZUZpbGVQYXRoKCk7CisKKyAgICAgICAgcmV0dXJuIFFXZWJW aWV3OjpndWVzc1VybEZyb21TdHJpbmcoaW5wdXQpOworICAgIH0KKworICAgIFFXZWJQYWdlKiBw YWdlKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBzY2VuZS0+d2ViSXRlbSgpLT5wYWdl KCk7CisgICAgfQorCitwcm90ZWN0ZWQgc2xvdHM6CisgICAgdm9pZCBjaGFuZ2VMb2NhdGlvbigp CisgICAgeworICAgICAgICBsb2FkKHVybEVkaXQtPnRleHQoKSk7CisgICAgfQorCisgICAgdm9p ZCBsb2FkRmluaXNoZWQoKQorICAgIHsKKyAgICAgICAgUVVybCB1cmwgPSBzY2VuZS0+d2ViSXRl bSgpLT51cmwoKTsKKyAgICAgICAgdXJsRWRpdC0+c2V0VGV4dCh1cmwudG9TdHJpbmcoKSk7CisK KyAgICAgICAgUVVybDo6Rm9ybWF0dGluZ09wdGlvbnMgb3B0czsKKyAgICAgICAgb3B0cyB8PSBR VXJsOjpSZW1vdmVTY2hlbWU7CisgICAgICAgIG9wdHMgfD0gUVVybDo6UmVtb3ZlVXNlckluZm87 CisgICAgICAgIG9wdHMgfD0gUVVybDo6U3RyaXBUcmFpbGluZ1NsYXNoOworICAgICAgICBRU3Ry aW5nIHMgPSB1cmwudG9TdHJpbmcob3B0cyk7CisgICAgICAgIHMgPSBzLm1pZCgyKTsKKyAgICAg ICAgaWYgKHMuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAvL0ZJWE1F OiBzb21ldGhpbmcgbWlzc2luZyBoZXJlCisgICAgfQorCitwdWJsaWMgc2xvdHM6CisgICAgdm9p ZCBuZXdXaW5kb3coY29uc3QgUVN0cmluZyAmdXJsID0gUVN0cmluZygpKQorICAgIHsKKyAgICAg ICAgTWFpbldpbmRvdyAqbXcgPSBuZXcgTWFpbldpbmRvdygpOworICAgICAgICBtdy0+bG9hZCh1 cmwpOworICAgICAgICBtdy0+c2hvdygpOworICAgIH0KKworICAgIHZvaWQgY2xvbmUoKQorICAg IHsKKyAgICAgICAgTWFpbldpbmRvdyAqbXcgPSBuZXcgTWFpbldpbmRvdyhzY2VuZSk7CisgICAg ICAgIG13LT5zaG93KCk7CisgICAgfQorCitwcml2YXRlOgorICAgIHZvaWQgYnVpbGRVSSgpCisg ICAgeworICAgICAgICBRV2ViUGFnZSogcGFnZSA9IHNjZW5lLT53ZWJJdGVtKCktPnBhZ2UoKTsK KyAgICAgICAgdXJsRWRpdCA9IG5ldyBRTGluZUVkaXQodGhpcyk7CisgICAgICAgIHVybEVkaXQt PnNldFNpemVQb2xpY3koUVNpemVQb2xpY3k6OkV4cGFuZGluZywgdXJsRWRpdC0+c2l6ZVBvbGlj eSgpLnZlcnRpY2FsUG9saWN5KCkpOworICAgICAgICBjb25uZWN0KHVybEVkaXQsIFNJR05BTChy ZXR1cm5QcmVzc2VkKCkpLCBTTE9UKGNoYW5nZUxvY2F0aW9uKCkpKTsKKworICAgICAgICBRVG9v bEJhciAqYmFyID0gYWRkVG9vbEJhcigiTmF2aWdhdGlvbiIpOworICAgICAgICBiYXItPmFkZEFj dGlvbihwYWdlLT5hY3Rpb24oUVdlYlBhZ2U6OkJhY2spKTsKKyAgICAgICAgYmFyLT5hZGRBY3Rp b24ocGFnZS0+YWN0aW9uKFFXZWJQYWdlOjpGb3J3YXJkKSk7CisgICAgICAgIGJhci0+YWRkQWN0 aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6UmVsb2FkKSk7CisgICAgICAgIGJhci0+YWRkQWN0 aW9uKHBhZ2UtPmFjdGlvbihRV2ViUGFnZTo6U3RvcCkpOworICAgICAgICBiYXItPmFkZFdpZGdl dCh1cmxFZGl0KTsKKworICAgICAgICBRTWVudSAqZmlsZU1lbnUgPSBtZW51QmFyKCktPmFkZE1l bnUoIiZGaWxlIik7CisgICAgICAgIFFBY3Rpb24gKm5ld1dpbmRvdyA9IGZpbGVNZW51LT5hZGRB Y3Rpb24oIk5ldyBXaW5kb3ciLCB0aGlzLCBTTE9UKG5ld1dpbmRvdygpKSk7CisgICAgICAgIFFB Y3Rpb24gKmNsb25lVmlldyA9IGZpbGVNZW51LT5hZGRBY3Rpb24oIkNsb25lIHZpZXciLCB0aGlz LCBTTE9UKGNsb25lKCkpKTsKKyAgICAgICAgZmlsZU1lbnUtPmFkZEFjdGlvbigiQ2xvc2UiLCB0 aGlzLCBTTE9UKGNsb3NlKCkpKTsKKworICAgICAgICBRTWVudSAqdmlld01lbnUgPSBtZW51QmFy KCktPmFkZE1lbnUoIiZWaWV3Iik7CisgICAgICAgIHZpZXdNZW51LT5hZGRBY3Rpb24ocGFnZS0+ YWN0aW9uKFFXZWJQYWdlOjpTdG9wKSk7CisgICAgICAgIHZpZXdNZW51LT5hZGRBY3Rpb24ocGFn ZS0+YWN0aW9uKFFXZWJQYWdlOjpSZWxvYWQpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTWFp blZpZXcgKnZpZXc7CisgICAgUUV4cGxpY2l0bHlTaGFyZWREYXRhUG9pbnRlcjxTaGFyZWRTY2Vu ZT4gc2NlbmU7CisKKyAgICBRTGluZUVkaXQgKnVybEVkaXQ7Cit9OworCitRV2ViUGFnZSAqV2Vi UGFnZTo6Y3JlYXRlV2luZG93KFFXZWJQYWdlOjpXZWJXaW5kb3dUeXBlKQoreworICAgIE1haW5X aW5kb3cgKm13ID0gbmV3IE1haW5XaW5kb3c7CisgICAgbXctPnNob3coKTsKKyAgICByZXR1cm4g bXctPnBhZ2UoKTsKK30KKwordm9pZCBXZWJQYWdlOjphcHBseVByb3h5KCkKK3sKKyAgICBRVXJs IHByb3h5VXJsID0gUVdlYlZpZXc6Omd1ZXNzVXJsRnJvbVN0cmluZyhxZ2V0ZW52KCJodHRwX3By b3h5IikpOworCisgICAgaWYgKHByb3h5VXJsLmlzVmFsaWQoKSAmJiAhcHJveHlVcmwuaG9zdCgp LmlzRW1wdHkoKSkgeworICAgICAgICBpbnQgcHJveHlQb3J0ID0gKHByb3h5VXJsLnBvcnQoKSA+ IDApID8gcHJveHlVcmwucG9ydCgpIDogODA4MDsKKyAgICAgICAgbmV0d29ya0FjY2Vzc01hbmFn ZXIoKS0+c2V0UHJveHkoUU5ldHdvcmtQcm94eShRTmV0d29ya1Byb3h5OjpIdHRwUHJveHksIHBy b3h5VXJsLmhvc3QoKSwgcHJveHlQb3J0KSk7CisgICAgfQorfQorCisjaW5jbHVkZSAibWFpbi5t b2MiCisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKK3sKKyAgICBRQXBwbGljYXRp b24gYXBwKGFyZ2MsIGFyZ3YpOworICAgIFFTdHJpbmcgdXJsID0gUVN0cmluZygiZmlsZTovLyUx LyUyIikuYXJnKFFEaXI6OmhvbWVQYXRoKCkpLmFyZyhRTGF0aW4xU3RyaW5nKCJpbmRleC5odG1s IikpOworCisgICAgYXBwLnNldEFwcGxpY2F0aW9uTmFtZSgiR1FWTGF1bmNoZXIiKTsKKworICAg IFFXZWJTZXR0aW5nczo6c2V0T2JqZWN0Q2FjaGVDYXBhY2l0aWVzKCgxNioxMDI0KjEwMjQpIC8g OCwgKDE2KjEwMjQqMTAyNCkgLyA4LCAxNioxMDI0KjEwMjQpOworICAgIFFXZWJTZXR0aW5nczo6 c2V0TWF4aW11bVBhZ2VzSW5DYWNoZSg0KTsKKyAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRp bmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OlBsdWdpbnNFbmFibGVkLCB0cnVlKTsK KyAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0 dGluZ3M6OkRldmVsb3BlckV4dHJhc0VuYWJsZWQsIHRydWUpOworICAgIFFXZWJTZXR0aW5nczo6 Z2xvYmFsU2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6TG9jYWxTdG9yYWdl RW5hYmxlZCwgdHJ1ZSk7CisKKyAgICBjb25zdCBRU3RyaW5nTGlzdCBhcmdzID0gYXBwLmFyZ3Vt ZW50cygpOworICAgIGlmIChhcmdzLmNvdW50KCkgPiAxKQorICAgICAgICB1cmwgPSBhcmdzLmF0 KDEpOworCisgICAgTWFpbldpbmRvdyogd2luZG93ID0gbmV3IE1haW5XaW5kb3c7CisgICAgd2lu ZG93LT5sb2FkKHVybCk7CisKKyAgICBmb3IgKGludCBpID0gMjsgaSA8IGFyZ3MuY291bnQoKTsg aSsrKQorICAgICAgICB3aW5kb3ctPm5ld1dpbmRvdyhhcmdzLmF0KGkpKTsKKworICAgIHdpbmRv dy0+c2hvdygpOworICAgIHJldHVybiBhcHAuZXhlYygpOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcCBiL1dlYktpdC9xdC9XZWJDb3Jl U3VwcG9ydC9DaHJvbWVDbGllbnRRdC5jcHAKaW5kZXggZDY1OTgzMy4uZTc5YWU1NSAxMDA2NDQK LS0tIGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudFF0LmNwcAorKysgYi9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50UXQuY3BwCkBAIC00NSw2ICs0NSw3 IEBACiAjaW5jbHVkZSAicXdlYmZyYW1lX3AuaCIKICNpbmNsdWRlICJxd2Vic2VjdXJpdHlvcmln aW4uaCIKICNpbmNsdWRlICJxd2Vic2VjdXJpdHlvcmlnaW5fcC5oIgorI2luY2x1ZGUgInF3ZWJ2 aWV3LmgiCiAKICNpbmNsdWRlIDxxdG9vbHRpcC5oPgogI2luY2x1ZGUgPHF0ZXh0ZG9jdW1lbnQu aD4KQEAgLTMwNyw4ICszMDgsOCBAQCB2b2lkIENocm9tZUNsaWVudFF0OjpyZXBhaW50KGNvbnN0 IEludFJlY3QmIHdpbmRvd1JlY3QsIGJvb2wgY29udGVudENoYW5nZWQsIGJvbwogewogICAgIC8v IE5vIGRvdWJsZSBidWZmZXIsIHNvIG9ubHkgdXBkYXRlIHRoZSBRV2lkZ2V0IGlmIGNvbnRlbnQg Y2hhbmdlZC4KICAgICBpZiAoY29udGVudENoYW5nZWQpIHsKLSAgICAgICAgUVdpZGdldCogdmll dyA9IG1fd2ViUGFnZS0+dmlldygpOwotICAgICAgICBpZiAodmlldykgeworICAgICAgICAvLyBP bmx5IGRvIGltcGxpY2l0IHBhaW50cyBmb3IgUVdlYlZpZXcncworICAgICAgICBpZiAoUVdlYlZp ZXcqIHZpZXcgPSBxb2JqZWN0X2Nhc3Q8UVdlYlZpZXcqPihtX3dlYlBhZ2UtPnZpZXcoKSkpIHsK ICAgICAgICAgICAgIFFSZWN0IHJlY3Qod2luZG93UmVjdCk7CiAgICAgICAgICAgICByZWN0ID0g cmVjdC5pbnRlcnNlY3RlZChRUmVjdChRUG9pbnQoMCwgMCksIG1fd2ViUGFnZS0+dmlld3BvcnRT aXplKCkpKTsKICAgICAgICAgICAgIGlmICghcmVjdC5pc0VtcHR5KCkpCkBAIC0zMjMsOCArMzI0 LDggQEAgdm9pZCBDaHJvbWVDbGllbnRRdDo6cmVwYWludChjb25zdCBJbnRSZWN0JiB3aW5kb3dS ZWN0LCBib29sIGNvbnRlbnRDaGFuZ2VkLCBib28KIAogdm9pZCBDaHJvbWVDbGllbnRRdDo6c2Ny b2xsKGNvbnN0IEludFNpemUmIGRlbHRhLCBjb25zdCBJbnRSZWN0JiBzY3JvbGxWaWV3UmVjdCwg Y29uc3QgSW50UmVjdCYpCiB7Ci0gICAgUVdpZGdldCogdmlldyA9IG1fd2ViUGFnZS0+dmlldygp OwotICAgIGlmICh2aWV3KQorICAgIC8vIE9ubHkgZG8gaW1wbGljaXQgcGFpbnRzIGZvciBRV2Vi VmlldydzCisgICAgaWYgKFFXZWJWaWV3KiB2aWV3ID0gcW9iamVjdF9jYXN0PFFXZWJWaWV3Kj4o bV93ZWJQYWdlLT52aWV3KCkpKQogICAgICAgICB2aWV3LT5zY3JvbGwoZGVsdGEud2lkdGgoKSwg ZGVsdGEuaGVpZ2h0KCksIHNjcm9sbFZpZXdSZWN0KTsKICAgICBlbWl0IG1fd2ViUGFnZS0+c2Ny b2xsUmVxdWVzdGVkKGRlbHRhLndpZHRoKCksIGRlbHRhLmhlaWdodCgpLCBzY3JvbGxWaWV3UmVj dCk7CiB9Ci0tIAoxLjYuMC40Cgo= 39299 2009-09-09 13:54:43 -0700 2009-10-22 06:43:26 -0700 Followup: Implement some virtual event methods so that we can fix event-related bugs in Qt patch releases 0001-Implement-some-virtual-event-methods-so-that-we-can.patch text/plain 3050 kenneth RnJvbSA1YzFmNGVjZGNmZDFlN2U1MjU5Y2ExMTYyNmViY2NiYTI2ZTgyNzVkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3 ZWJraXQub3JnPgpEYXRlOiBXZWQsIDkgU2VwIDIwMDkgMTc6NTA6MDggLTAzMDAKU3ViamVjdDog W1BBVENIXSBJbXBsZW1lbnQgc29tZSB2aXJ0dWFsIGV2ZW50IG1ldGhvZHMgc28gdGhhdCB3ZSBj YW4gZml4CiBldmVudC1yZWxhdGVkIGJ1Z3MgaW4gUXQgcGF0Y2ggcmVsZWFzZXMuCgpQYXRjaCBi eSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiA8a2VubmV0aEB3ZWJraXQub3JnPiBvbiAyMDA5 LTA5LTA5ClJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKKiBBcGkvcXdlYmdyYXBoaWNzaXRl bS5jcHA6CihRV2ViR3JhcGhpY3NJdGVtOjpzY2VuZUV2ZW50KToKKFFXZWJHcmFwaGljc0l0ZW06 OmV2ZW50KToKKiBBcGkvcXdlYmdyYXBoaWNzaXRlbS5oOgotLS0KIFdlYktpdC9xdC9BcGkvcXdl YmdyYXBoaWNzaXRlbS5jcHAgfCAgIDE2ICsrKysrKysrKysrKysrKysKIFdlYktpdC9xdC9BcGkv cXdlYmdyYXBoaWNzaXRlbS5oICAgfCAgICAzICsrKwogV2ViS2l0L3F0L0NoYW5nZUxvZyAgICAg ICAgICAgICAgICB8ICAgMTIgKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDMxIGluc2Vy dGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vi Z3JhcGhpY3NpdGVtLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAKaW5k ZXggMWY2MTY3My4uMzAyOGMwOCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZ3JhcGhp Y3NpdGVtLmNwcAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwCkBAIC0x NjIsNiArMTYyLDIyIEBAIHZvaWQgUVdlYkdyYXBoaWNzSXRlbTo6cGFpbnQoUVBhaW50ZXIqIHBh aW50ZXIsIGNvbnN0IFFTdHlsZU9wdGlvbkdyYXBoaWNzSXRlbSoKICAgICBkLT5wYWdlLT5tYWlu RnJhbWUoKS0+cmVuZGVyKHBhaW50ZXIsIG9wdGlvbi0+ZXhwb3NlZFJlY3QudG9SZWN0KCkpOwog fQogCisvKiEgXHJlaW1wCisqLworYm9vbCBRV2ViR3JhcGhpY3NJdGVtOjpzY2VuZUV2ZW50KFFF dmVudCogZXZlbnQpCit7CisgICAgLy8gU3dhbGxvdyByZWltcGxlbWVudGF0aW9uIGluIG9yZGVy IHRvIGFsbG93cyBmaXhpbmcgZXZlbnQtcmVsYXRlZCBidWdzIGluIHBhdGNoIHJlbGVhc2VzCisg ICAgcmV0dXJuIFFHcmFwaGljc1dpZGdldDo6c2NlbmVFdmVudChldmVudCk7Cit9CisKKy8qISBc cmVpbXAKKyovCitib29sIFFXZWJHcmFwaGljc0l0ZW06OmV2ZW50KFFFdmVudCogZXZlbnQpCit7 CisgICAgLy8gU3dhbGxvdyByZWltcGxlbWVudGF0aW9uIGluIG9yZGVyIHRvIGFsbG93cyBmaXhp bmcgZXZlbnQtcmVsYXRlZCBidWdzIGluIHBhdGNoIHJlbGVhc2VzCisgICAgcmV0dXJuIFFPYmpl Y3Q6OmV2ZW50KGV2ZW50KTsKK30KKwogLyohCiAgICAgTWFrZXMgXGEgcGFnZSB0aGUgbmV3IHdl YiBwYWdlIG9mIHRoZSB3ZWIgZ3JhcGhpY3NpdGVtLgogCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQv QXBpL3F3ZWJncmFwaGljc2l0ZW0uaCBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5o CmluZGV4IGQ0MWY1NTIuLjQxZDM0Y2QgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmdy YXBoaWNzaXRlbS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5oCkBAIC04 NSw2ICs4NSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0R2VvbWV0cnkoY29uc3Qg UVJlY3RGJiByZWN0KTsKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlR2VvbWV0cnkoKTsKICAgICB2 aXJ0dWFsIHZvaWQgcGFpbnQoUVBhaW50ZXIqLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0 ZW0qIG9wdGlvbnMsIFFXaWRnZXQqIHdpZGdldCA9IDApOworICAgIHZpcnR1YWwgYm9vbCBldmVu dChRRXZlbnQqKTsKIAogcHVibGljIFFfU0xPVFM6CiAgICAgdm9pZCBzdG9wKCk7CkBAIC0xMjks NiArMTMwLDggQEAgcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgdm9pZCBpbnB1dE1ldGhvZEV2ZW50 KFFJbnB1dE1ldGhvZEV2ZW50Kik7CiAgICAgdmlydHVhbCBib29sIGZvY3VzTmV4dFByZXZDaGls ZChib29sIG5leHQpOwogCisgICAgdmlydHVhbCBib29sIHNjZW5lRXZlbnQoUUV2ZW50Kik7CisK IHByaXZhdGU6CiAgICAgUV9QUklWQVRFX1NMT1QoZCwgdm9pZCBfcV9kb1Njcm9sbChpbnQgZHgs IGludCBkeSwgY29uc3QgUVJlY3QmKSkKICAgICBRX1BSSVZBVEVfU0xPVChkLCB2b2lkIF9xX2Rv TG9hZFByb2dyZXNzKGludCBwcm9ncmVzcykpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdl TG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCA5NzE3ZDk2Li43YTczYjE3IDEwMDY0NAot LS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAwOS0wOS0wOSAgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4gIDxrZW5u ZXRoQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgSW1wbGVtZW50IHNvbWUgdmlydHVhbCBldmVudCBtZXRob2RzIHNvIHRoYXQgd2Ug Y2FuIGZpeAorICAgICAgICBldmVudC1yZWxhdGVkIGJ1Z3MgaW4gUXQgcGF0Y2ggcmVsZWFzZXMu CisKKyAgICAgICAgKiBBcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHA6CisgICAgICAgIChRV2ViR3Jh cGhpY3NJdGVtOjpzY2VuZUV2ZW50KToKKyAgICAgICAgKFFXZWJHcmFwaGljc0l0ZW06OmV2ZW50 KToKKyAgICAgICAgKiBBcGkvcXdlYmdyYXBoaWNzaXRlbS5oOgorCiAyMDA5LTA5LTA5ICBLZW5u ZXRoIFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4sIEFudG9uaW8gR29t ZXMgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg U2ltb24gSGF1c21hbm4uCi0tIAoxLjYuMC40Cgo= 39302 2009-09-09 14:29:01 -0700 2009-09-09 23:58:19 -0700 Call the right base class function QGraphicsWidget::event() instead bug-28862-20090909232859.patch text/plain 1033 hausmann ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAgYi9XZWJLaXQv cXQvQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwCmluZGV4IDk2NjQ3N2IuLjU0MzEyNzYgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmdyYXBoaWNzaXRlbS5jcHAKKysrIGIvV2ViS2l0L3F0 L0FwaS9xd2ViZ3JhcGhpY3NpdGVtLmNwcApAQCAtMTc1LDcgKzE3NSw3IEBAIGJvb2wgUVdlYkdy YXBoaWNzSXRlbTo6c2NlbmVFdmVudChRRXZlbnQqIGV2ZW50KQogYm9vbCBRV2ViR3JhcGhpY3NJ dGVtOjpldmVudChRRXZlbnQqIGV2ZW50KQogewogICAgIC8vIFJlLWltcGxlbWVudGVkIGluIG9y ZGVyIHRvIGFsbG93cyBmaXhpbmcgZXZlbnQtcmVsYXRlZCBidWdzIGluIHBhdGNoIHJlbGVhc2Vz LgotICAgIHJldHVybiBRT2JqZWN0OjpldmVudChldmVudCk7CisgICAgcmV0dXJuIFFHcmFwaGlj c1dpZGdldDo6ZXZlbnQoZXZlbnQpOwogfQogCiAvKiEKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9D aGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDBiZjI1OGUuLjIwZTA0ZWIgMTAw NjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpA QCAtMSwzICsxLDEzIEBACisyMDA5LTA5LTA5ICBTaW1vbiBIYXVzbWFubiAgPGhhdXNtYW5uQHdl YmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgQ2FsbCB0aGUgcmlnaHQgYmFzZSBjbGFzcyBmdW5jdGlvbiBRR3JhcGhpY3NXaWRnZXQ6OmV2 ZW50KCkgaW5zdGVhZAorICAgICAgICBvZiBza2lwcGluZyBpdCBhbmQgdXNpbmcgUU9iamVjdDo6 ZXZlbnQoKSBpbnN0ZWFkLgorCisgICAgICAgICogQXBpL3F3ZWJncmFwaGljc2l0ZW0uY3BwOgor ICAgICAgICAoUVdlYkdyYXBoaWNzSXRlbTo6ZXZlbnQpOgorCiAyMDA5LTA5LTA5ICBLZW5uZXRo IFJvaGRlIENocmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBVbnJl dmlld2VkLg==