35146 2010-02-19 04:34:03 -0800 Support tiled backing store 2010-09-08 16:58:38 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) All OS X 10.5 CLOSED FIXED Qt P3 Normal --- 35784 45423 1 koivisto webkit-unassigned benjamin hausmann hyatt kenneth laszlo.gombos manyoso rakuco simon.fraser skyul webkit.review.bot xan.lopez zherczeg zwarich oldest_to_newest 191865 0 koivisto 2010-02-19 04:34:03 -0800 To speed up scrolling and other painting related operations, the content of the web page are cached to bitmaps. These bitmap are created and deleted on-demand as the viewport moves over the document. 191867 1 49067 koivisto 2010-02-19 04:37:27 -0800 Created attachment 49067 Preliminary patch This patch adds WebCore level tiled backing store. Most of the implementation is in Qt specific file atm but parts of it could be generalized, depending on needs of other graphics systems. TiledBackingStore interface is platform independent. 191870 2 49067 kenneth 2010-02-19 04:59:31 -0800 Comment on attachment 49067 Preliminary patch > +void Frame::setTiledBackingStoreEnabled(bool enabled) > +{ > + if (!enabled) { > + m_tiledBackingStore.clear(); > + return; > + } > + if (m_tiledBackingStore) > + return; > + m_tiledBackingStore.set(new TiledBackingStore(this)); > +} Where are you freeing this? > +void Frame::tiledBackingStorePaintBegin() > +{ > + if (!m_view) > + return; > + m_view->layoutIfNeededRecursive(); > + m_view->flushDeferredRepaints(); > +} I don't like these names very much, they don't seem to be only dealing with the tiled backing store. > +void Frame::tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) So when you are finished painting, you have to inform where you painted? Maybe the API should reflect that? > +IntRect Frame::tiledBackingStoreContentRect() IS there a difference between the contents rect and the actual rect of the backing store? > + OwnPtr<TiledBackingStore> m_tiledBackingStore; > }; Ah, now I see :-) > + void viewportChanged(const IntRect& viewportRect); Frame uses setFrameRect, maybe setViewportRect? > + > + float scale() { return m_scale; } > + void setScale(float); scale, zoom? so this actually scales the widgets? > + > + void invalidate(const IntRect& dirtyRect); > + void paint(GraphicsContext*, const IntRect&); > + > + enum State { > + StateNormal, > + StateNoTileCreation > + }; Shouldn't you put State as a suffix instead of as a prefix? Also, State doesn't say much, coudl we find a better name? What is StateNormal? Let's use a better name > + void dropOverhangingTiles(); What is overhanging? > + void dropTilesOutsideRect(const IntRect&); > + > + struct TileCoordinate { Why can't you use IntPoint? and maybe you should consider TilePoint? > + public: > + TileCoordinate(unsigned x, unsigned y) : m_x(x), m_y(y) { } > + > + PassRefPtr<Tile> tile(const TileCoordinate&) const; > + void setTile(const TileCoordinate& coordinate, PassRefPtr<Tile> tile); > + void removeTile(const TileCoordinate& coordinate); > + > + IntRect rectToDocument(const IntRect&) const; > + IntRect rectFromDocument(const IntRect&) const; > + > + IntRect contentRect() const; contentsRect ? More comments to follow, but I have a meeting now! 191880 3 koivisto 2010-02-19 05:50:20 -0800 > > +void Frame::tiledBackingStorePaintBegin() > > +{ > > + if (!m_view) > > + return; > > + m_view->layoutIfNeededRecursive(); > > + m_view->flushDeferredRepaints(); > > +} > > I don't like these names very much, they don't seem to be only dealing with the > tiled backing store. > > > +void Frame::tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) > > So when you are finished painting, you have to inform where you painted? Maybe > the API should reflect that? > > > > +IntRect Frame::tiledBackingStoreContentRect() > > IS there a difference between the contents rect and the actual rect of the > backing store? These methods are part of the abstract TiledBackingStoreClient interface and are called by the TiledBackingStore. They need to be implemented by any class that wants to be backed by the tiled backing store. This is needed for proper layering as TiledBackingStore is a platform class can't know about FrameView. In this context I don't understand your comments. (for example GraphicsLayers for accelerated compositing could use tiling too far large layers). > > + void viewportChanged(const IntRect& viewportRect); > > Frame uses setFrameRect, maybe setViewportRect? Yeah. > > > + > > + float scale() { return m_scale; } > > + void setScale(float); > > scale, zoom? so this actually scales the widgets? Concept of zooming is already taken in WebKit. It is about zooming page by changing the element sizes and relayouting. This is a different concept than paint time transform based zooming here. QPainter and graphics terminology in general uses "scale" for this. > Shouldn't you put State as a suffix instead of as a prefix? Also, State doesn't > say much, coudl we find a better name? What is StateNormal? Let's use a better > name Yep. > > + void dropOverhangingTiles(); > > What is overhanging? Tiles that are at least partially outside the current document size (since document got smaller). > Why can't you use IntPoint? and maybe you should consider TilePoint? One could argue that it is not really a point. The original reason was to have a place to hang the hash function. > More comments to follow, but I have a meeting now! Have fun! 191952 4 49067 kenneth 2010-02-19 09:58:42 -0800 Comment on attachment 49067 Preliminary patch > + IntRect tileRectForCoordinate(const TileCoordinate&) const; or AtCoordinate? > + TiledBackingStore::TileCoordinate tileCoordinateForPoint(const IntPoint&) const; > + double tileDistance(const IntRect& viewport, const TiledBackingStore::TileCoordinate&); What kind of distance? to the closest point on the tile? distance to the tile from the view when the tile is outside the view? Maybe we could improve the name a bit to make this a bit more clear. > + void paintCheckerPattern(QPainter* painter, const IntRect& rect, TileCoordinate coordinate); You paint this per tile? QPainter here? that seems wrong. Shouldn't you use PaintContext? > +#if ENABLE(ENGINE_THREAD) > + Mutex m_tileMutex; > + Mutex m_paintMutex; > +#endif Shouldn't this be part of the next patch? > + // Don't use WebKit timers to avoid interfering with the engine. // Avoid using default WebKit timers ... paint engine > +static const int tileSize = 512; > +static const int checkerSize = 16; > +static const unsigned checkerColor1 = 0xff555555; > +static const unsigned checkerColor2 = 0xffaaaaaa; I think Darin once told me to prefix globals with g, like gTileSize. > +class TileTimer : public QObject { Maybe call it TileTimerQt and typedef it to TileTimer ? just wondering... > + Q_OBJECT > +public: > + TileTimer(TiledBackingStore*, void (TiledBackingStore::*f)()); > + void destroy(); > + void startOneShot(double time); singleShot? > +void TileTimer::timerEvent(QTimerEvent* ev) > +{ > +#if ENABLE(ENGINE_THREAD) > + bool needsLock = EngineThread::isCurrent(); > + if (needsLock) > + EngineThread::lock(); > +#endif > + m_timer.stop(); > + if (m_backingStore) > + (m_backingStore->*m_timerFunction)(); > +#if ENABLE(ENGINE_THREAD) > + if (needsLock) > + EngineThread::unlock(); > +#endif > +} This doesn't really seem that Qt specific. Could it be separated out so that others more easy can implement their TileTimer ? > +class Tile : public ThreadSafeShared<Tile> > +{ > +public: > + static PassRefPtr<Tile> create(TiledBackingStore* backingStore, const TiledBackingStore::TileCoordinate& tileCoordinate) { return adoptRef(new Tile(backingStore, tileCoordinate)); } > + ~Tile(); > + > + bool isDirty() const { return !m_dirtyRegion.isEmpty(); } > + const QRegion& dirtyRegion() const { return m_dirtyRegion; } Do you have a max for dirty regions? > + if (!m_backBuffer) { > + // Copy the current buffer if this is not a full tile update (or a new tile Missing ) > + if (!m_buffer) > + m_backBuffer = new QImage(m_backingStore->m_tileSize.width(), m_backingStore->m_tileSize.height(), QImage::Format_RGB16); Hardcoded 16 bit :-) > +void TiledBackingStore::updateTiles() dirty tiles, all tiles? sorry for nitpicking! :-) > + // FIXME: should not request system repaint for the full tile. > + fullDirtyRegion += it->second->rect(); > + //fullDirtyRegion += it->second->dirtyRegion(); Does it really make sense to update regions of the tiles and not just always taking the bounding rect of the dirty regions? > + paintedArea.append(rectToDocument(qrects[n])); I was told that in Qt .at(index) is faster than [index] > + QTransform nt(1., t.m12(), t.m13(), > + t.m21(), 1., t.m23(), > + t.m31(), t.m32(), t.m33()); > + painter->setWorldTransform(nt); > + nt? new transform? > + // Manhattan distance, biased so that vertical distances are shorter. > + const double horizontalBias = 1.3; > + return abs(centerCoordinate.y() - tileCoordinate.y()) + horizontalBias * abs(centerCoordinate.x() - tileCoordinate.x()); heh :-) > +void TiledBackingStore::createTiles() > +{ > + if (m_state != StateNormal) > + return; > + > + if (m_viewport.isEmpty()) > + return; > + > + dropOverhangingTiles(); > + > + // FIXME: Make adapt to memory. Make adaptable to memory constrains? or Adapt to ... > + IntRect keepRect = m_viewport; > + keepRect.inflateX(m_viewport.width()); > + keepRect.inflateY(3 * m_viewport.height()); Why 3? can you use a constant instead? > + keepRect.intersect(contentRect()); > + > + dropTilesOutsideRect(keepRect); Ah smart. > + // Paint the content of the newly created tiles > + if (tilesToCreateCount) newTilesRequiredCount? > + // Restart the timers. There might be pending invalidations that > + // were not painted or created because tiles are not created or > + // paintied when in StateNoTileCreation painted! when in the ... state > > +QRectF QGraphicsWebViewPrivate::visibleRect() const > +{ > + if (!q->scene()) > + return QRectF(); > + QList<QGraphicsView*> views = q->scene()->views(); > + if (views.size() > 1) { > + qDebug() << "QGraphicsWebView is in more than one graphics views, unable to compute the visible rect"; > + return QRectF(); > + } It still works when in more views? > + case ItemCursorHasChanged: { > + QEvent event(QEvent::CursorChange); > + QApplication::sendEvent(this, &event); > + return value; > + } Is the identation right here? > +float QGraphicsWebView::tiledBackingStoreScaleFactor() const Would it be better to just sue the zoomFactor() API. Noone are going to use both zoom factor and scale together, so we could just document that when using a tiled backing store, it will not scale the html forms + plugins as well. Simon? > + value = attributes.value(QWebSettings::TiledBackingStoreEnabled, > + global->attributes.value(QWebSettings::TiledBackingStoreEnabled)); > + settings->setTiledBackingStoreEnabled(value); Would be good with documentation explaining when it makes sense to not use this :-) otherwise it should probably just be default. How does this affect rotation of the qgraphicswebview? scrollbars (from the code I guess that doesn't work :-)) > Index: WebKit/qt/QGVLauncher/main.cpp QGVLauncher is going to die soonish, please add this support to QtLauncher :-) > + qDebug() << "Warning: at the moment --tiledBackingStore should always be used together with --resizesToContents"; > + QWebSettings::globalSettings()->setAttribute(QWebSettings::TiledBackingStoreEnabled, true); I guess that makes sense as well. 193733 5 49491 koivisto 2010-02-25 08:26:12 -0800 Created attachment 49491 updated patch Split to platform independs/dependent files. Lots of cleanups. 193793 6 49491 kenneth 2010-02-25 10:14:39 -0800 Comment on attachment 49491 updated patch Ah nice, it is getting there! So what is missing before you are ready to put this up for review? Some quick comments. > + const IntRect rectToContents() const; Is this a mapping function? what about mapToContents? > + > + // FIXME: In single threaded case, tile backbuffers could be updated asynchrnously Spelling issue :-) > +PassRefPtr<Tile> TiledBackingStore::tile(const Tile::Coordinate& coordinate) const > +{ tileAt? > +IntRect TiledBackingStore::rectToContents(const IntRect& rect) const mapRectToContents? mapToContents? > +bool QGraphicsWebView::tiledBackingStoreFrozen() const Could you add documentation with \since 4.6 to these public methods? Also, add a 'is' in front. isTiledBackingStoreFrozen() > Index: WebKit/qt/QGVLauncher/main.cpp QGVLauncher was removed as far as I know. You should add the code to QtLauncher instead. 194069 7 49578 koivisto 2010-02-26 06:07:16 -0800 Created attachment 49578 more updates - Updated to curent ToT - Moved the feature behind flag ENABLE(TILED_BACKING_STORE) - Removed zooming related Qt API. I wasn't happy with the API and that is anyway better done separately. - Removed QGVLauncher portion, QtLauncher patch coming separately. - Implemented some of Kenneths comments - Various fixes, cleanups 194070 8 webkit.review.bot 2010-02-26 06:09:15 -0800 Attachment 49578 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 Ignoring "WebKit/qt/Api/qwebsettings.cpp": this file is exempt from the style guide. WebCore/platform/graphics/TiledBackingStoreClient.h:27: This { should be at the end of the previous line [whitespace/braces] [4] WebCore/platform/graphics/TiledBackingStore.h:26: Alphabetical sorting problem. [build/include_order] [4] WebCore/platform/graphics/TiledBackingStore.h:28: Alphabetical sorting problem. [build/include_order] [4] WebCore/platform/graphics/TiledBackingStore.h:40: This { should be at the end of the previous line [whitespace/braces] [4] Ignoring "WebKit/qt/Api/qwebsettings.h": this file is exempt from the style guide. Ignoring "WebKit/qt/Api/qwebframe.cpp": this file is exempt from the style guide. Ignoring "WebKit/qt/Api/qwebframe.h": this file is exempt from the style guide. WebCore/platform/graphics/Tile.h:41: This { should be at the end of the previous line [whitespace/braces] [4] WebCore/platform/graphics/Tile.h:49: Place brace on its own line for function definitions. [whitespace/braces] [4] Total errors found: 6 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 194080 9 manyoso 2010-02-26 07:19:32 -0800 // FIXME: In single threaded case, tile back buffers could be updated asynchronously // one by one and then swapped to front in one go. This would minimize the time spent // blocking on tile updates. Is there a multi-threaded case? It seems that this patch implements a single threaded tiled backingstore. 194092 10 49582 koivisto 2010-02-26 07:41:50 -0800 Created attachment 49582 added back some forgotten QGraphicsWebView code 194093 11 koivisto 2010-02-26 07:42:56 -0800 > Is there a multi-threaded case? It seems that this patch implements a single > threaded tiled backingstore. Yes, but not in this patch :) 194100 12 49582 yongjun.zhang 2010-02-26 08:07:52 -0800 Comment on attachment 49582 added back some forgotten QGraphicsWebView code + const Tile::Coordinate coordinate() const { return m_coordinate; } Antti, would it be better to return const Tile::Coordinate& here? 194650 13 webkit.review.bot 2010-03-01 01:46:29 -0800 Attachment 49582 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 Ignoring "WebKit/qt/Api/qwebsettings.cpp": this file is exempt from the style guide. WebCore/platform/graphics/TiledBackingStoreClient.h:27: This { should be at the end of the previous line [whitespace/braces] [4] Ignoring "WebKit/qt/Api/qwebsettings.h": this file is exempt from the style guide. WebCore/platform/graphics/TiledBackingStore.h:26: Alphabetical sorting problem. [build/include_order] [4] WebCore/platform/graphics/TiledBackingStore.h:28: Alphabetical sorting problem. [build/include_order] [4] WebCore/platform/graphics/TiledBackingStore.h:40: This { should be at the end of the previous line [whitespace/braces] [4] Ignoring "WebKit/qt/Api/qgraphicswebview.cpp": this file is exempt from the style guide. Ignoring "WebKit/qt/Api/qwebframe.cpp": this file is exempt from the style guide. Ignoring "WebKit/qt/Api/qwebframe.h": this file is exempt from the style guide. WebCore/platform/graphics/Tile.h:41: This { should be at the end of the previous line [whitespace/braces] [4] WebCore/platform/graphics/Tile.h:49: Place brace on its own line for function definitions. [whitespace/braces] [4] Total errors found: 6 in 18 files If any of these errors are false positives, please file a bug against check-webkit-style. 195031 14 zherczeg 2010-03-02 05:37:09 -0800 Antti, are you sure you want to use a GPL license here? Do you have a written permission from Apple? I think only LGPL 2 and BSD is allowed to commit. 195032 15 zherczeg 2010-03-02 05:42:18 -0800 (In reply to comment #14) > Antti, are you sure you want to use a GPL license here? Do you have a written > permission from Apple? I think only LGPL 2 and BSD is allowed to commit. Sorry. I see the Library now. Forget about this comment. 195033 16 koivisto 2010-03-02 05:42:44 -0800 (In reply to comment #14) > Antti, are you sure you want to use a GPL license here? Do you have a written > permission from Apple? I think only LGPL 2 and BSD is allowed to commit. Huh? It is LGPL. 195424 17 49582 xan.lopez 2010-03-03 02:36:54 -0800 Comment on attachment 49582 added back some forgotten QGraphicsWebView code >+public: >+ class Coordinate { >+ public: >+ Coordinate(unsigned x, unsigned y) : m_x(x), m_y(y) { } >+ bool operator==(const Coordinate& o) const { return m_x == o.m_x && m_y == o.m_y; } >+ unsigned x() const { return m_x; } >+ unsigned y() const { return m_y; } >+ unsigned hash() const { >+ unsigned hash = WTF::intHash(static_cast<uint64_t>(m_x) << 32 | m_y); >+ // avoid empty and deleted value >+ return hash | (!(hash + 1) << 31); >+ } >+ private: >+ unsigned m_x; >+ unsigned m_y; >+ }; As commented elsewhere I think it makes sense to use IntPoint here and make it hashable. IIRC you were worried there could be confusion about the coordinate space, but we could make a typedef to a better name instead of creating a new class. >+void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect) >+{ >+ IntRect dirtyRect(mapFromContents(contentsDirtyRect)); >+ >+ Tile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.topLeft()); >+ Tile::Coordinate bottomRight = tileCoordinateForPoint(dirtyRect.bottomRight()); >+ >+ for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) { >+ for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) { >+ RefPtr<Tile> currentTile = tileAt(Tile::Coordinate(xCoordinate, yCoordinate)); >+ if (!currentTile) >+ continue; >+ currentTile->invalidate(dirtyRect); Seems like it would be faster to just iterate through the tiles (which should be a lot less than the total amount of individual coordinates) and just check if they intersect dirtyRect? or is tileAt + hashing faster than that? :) This also applies to a couple other places fwiw... >+ if (distance > shortestDistance) >+ continue; >+ if (distance < shortestDistance) { else if? Also I think a short comment about the rationale of tile creation and the use of distances would be useful. >+ unsigned tilesToCreateCount = tilesToCreate.size(); >+ if (tilesToCreateCount) { >+ for (unsigned n = 0; n < tilesToCreateCount; ++n) { >+ Tile::Coordinate coordinate = tilesToCreate[n]; >+ setTile(coordinate, Tile::create(this, coordinate)); >+ } >+ requiredTileCount -= tilesToCreateCount; >+ } nitpick, but you can just do the for loop and requiredTileCount-- on each iteration. >@@ -521,10 +556,11 @@ QVariant QGraphicsWebView::itemChange(Gr > // fire 'CursorChange'. > case ItemCursorChange: > return value; >- case ItemCursorHasChanged: >- QEvent event(QEvent::CursorChange); >- QApplication::sendEvent(this, &event); >- return value; >+ case ItemCursorHasChanged: { >+ QEvent event(QEvent::CursorChange); >+ QApplication::sendEvent(this, &event); >+ return value; >+ } Unrelated? And the indent is wrong. 195549 18 koivisto 2010-03-03 07:13:01 -0800 > As commented elsewhere I think it makes sense to use IntPoint here and make it > hashable. IIRC you were worried there could be confusion about the coordinate > space, but we could make a typedef to a better name instead of creating a new > class. Yep. I added hashing support for IntPoint in bug 35586. > Seems like it would be faster to just iterate through the tiles (which should > be a lot less than the total amount of individual coordinates) and just check > if they intersect dirtyRect? or is tileAt + hashing faster than that? :) This > also applies to a couple other places fwiw... This is most efficient for small updates (like say animated gifs). What you suggest would be more efficient for large updates. Anyway, this can be optimized later if needed. > >+ if (distance > shortestDistance) > >+ continue; > >+ if (distance < shortestDistance) { > > else if? Unnecessary after continue (and against coding style too). > nitpick, but you can just do the for loop and requiredTileCount-- on each > iteration. Sure but why? It would be slower. Please limit nitpicking to stuff that makes sense. :) 195567 19 xan.lopez 2010-03-03 07:28:55 -0800 (In reply to comment #18) > Unnecessary after continue (and against coding style too). The style guide only mentions return, FWIW, but I guess continue adheres to the spirit of it. > > > nitpick, but you can just do the for loop and requiredTileCount-- on each > > iteration. > > Sure but why? It would be slower. Please limit nitpicking to stuff that makes > sense. :) The point was that protecting the for loop with an if seems redundant since the code works exactly the same way without it. I suggested subtracting one on each iteration to get rid of the variable declaration and avoid the weird looking requiredTileCount -= tilesToCreateCount; when tilesToCreateCount is 0, and surely whatever difference in performance is caused by this is totally irrelevant. But it was just a detail, so shrug. 195767 20 49950 koivisto 2010-03-03 14:35:38 -0800 Created attachment 49950 updated patch - switched to IntPoint typedef for tile coordinates, IntPointHash - implemented bunch of review comments - fixed a checker painting bug - various cleanups 196106 21 50031 koivisto 2010-03-04 09:52:25 -0800 Created attachment 50031 WebCore patch Separate WebCore and QtWebKit patches. 196107 22 50032 koivisto 2010-03-04 09:53:23 -0800 Created attachment 50032 QtWebKit patch Now with QtLauncher support 196118 23 50032 kenneth 2010-03-04 10:20:57 -0800 Comment on attachment 50032 QtWebKit patch > + int h = views[0]->horizontalScrollBar()->value(); > + int v = views[0]->verticalScrollBar()->value(); These return the size? or ? > +#if ENABLE(TILED_BACKING_STORE) > + if (!frame->tiledBackingStore()) > +#endif > + view->layoutIfNeededRecursive(); I prefer adding an #else in this case #if ENABLE(TILED_BACKING_STORE) if (!frame->tiledBackingStore()) view->layoutIfNeededRecursive(); #else view->layoutIfNeededRecursive(); #endif > +#if ENABLE(TILED_BACKING_STORE) > + if (frame->tiledBackingStore()) > + frame->tiledBackingStore()->paint(context, clipRect); > + else > +#endif > + view->paintContents(context, clipRect); Same here. > Index: WebKit/qt/QGVLauncher/main.cpp QGVLauncher was removed from trunk! > + toggleResizesToContents->setCheckable(true); > + toggleResizesToContents->setChecked(false); > + toggleResizesToContents->setEnabled(false); I guess here is should check the setting to find out if it is actually enabled or not. Such a change was done to the other toggles by Jesus. I was told that that change had gone in. 196469 24 koivisto 2010-03-05 09:03:16 -0800 (In reply to comment #23) > (From update of attachment 50032 [details]) > > + int h = views[0]->horizontalScrollBar()->value(); > > + int v = views[0]->verticalScrollBar()->value(); > These return the size? or ? They return the current scroll position, in pixels. Yeah, it is a bad API but it is documented for QAbstractScollArea. > QGVLauncher was removed from trunk! Seems I have a local copy in conflict. 196471 25 koivisto 2010-03-05 09:05:54 -0800 Dropping [Qt] from title since most of this is generic code. 197102 26 50032 hausmann 2010-03-08 02:58:18 -0800 Comment on attachment 50032 QtWebKit patch > +QRectF QGraphicsWebViewPrivate::visibleRect() const > +{ > + if (!q->scene()) > + return QRectF(); > + QList<QGraphicsView*> views = q->scene()->views(); > + if (views.size() > 1) { > + qDebug() << "QGraphicsWebView is in more than one graphics views, unable to compute the visible rect"; > + return QRectF(); > + } > + if (views.size() < 1) > + return QRectF(); > + > + int h = views[0]->horizontalScrollBar()->value(); > + int v = views[0]->verticalScrollBar()->value(); I suggest to use views.at(0) instead of [] or make the views variable const. With the current code the compiler will choose the non-const [] operator. As the returned views is an implicitly shared copy of the list in QGraphicsScene, the code will end up detaching the entire list. > + TiledBackingStoreEnabled, It would be good to document this enum value in qwebsettings.cpp and mention the default. > @@ -724,6 +753,8 @@ void LauncherApplication::handleUserOpti > << "[-show-fps]" > << "[-r list]" > << "[-inspector-url location]" > + << "[-tiled-backing-store]" > + << "[-resizes-to-contents]" > << "URLs"; > appQuit(0); > } > @@ -746,6 +777,16 @@ void LauncherApplication::handleUserOpti > gCacheWebView = true; > } > > + if (args.contains("-tiled-backing-store")) { > + requiresGraphicsView("-tiled-backing-store"); > + gUseTiledBackingStore = true; > + } > + > + if (args.contains("-resizes-to-contents")) { > + requiresGraphicsView("-resizes-to-contents"); > + gResizesToContents = true; > + } > + > QString arg1("-viewport-update-mode"); > int modeIndex = args.indexOf(arg1); > if (modeIndex != -1) { Are the command line options really worth it? The launcher code might be simplier if we support the options only in the menu. Just a thought though :) > +void WebViewGraphicsBased::setResizesToContents(bool b) > +{ > + m_resizesToContents = b; > + m_item->setResizesToContents(m_resizesToContents); > + if (m_resizesToContents) { > + setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); > + setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); > + } else { > + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); > + setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); > + } Hmm, why is this needed? Should setResizesToContents automatically do this? Or perhaps the docs of the resizesToContents property should explain that this may also be a good thing to do. Why are the scrollbars turned _off_ if m_resizesToContents is false? Shouldn't it be the other way around? 197103 27 50031 hausmann 2010-03-08 03:01:38 -0800 Comment on attachment 50031 WebCore patch > +#if PLATFORM(QT) > + QPixmap* m_buffer; > + QPixmap* m_backBuffer; > + QRegion* m_dirtyRegion; > +#endif I think it would be more efficient (less mallocs, less indirections) to store the pixmaps and regions by value. QPixmap itself holds only a pointer to the private as member variable. The same applies to QRegion. 197112 28 koivisto 2010-03-08 03:52:16 -0800 (In reply to comment #27) > (From update of attachment 50031 [details]) > > > +#if PLATFORM(QT) > > + QPixmap* m_buffer; > > + QPixmap* m_backBuffer; > > + QRegion* m_dirtyRegion; > > +#endif > > I think it would be more efficient (less mallocs, less indirections) to store > the pixmaps and regions by value. QPixmap itself holds only a pointer to the > private as member variable. The same applies to QRegion. I prefer doing it this way since I can forward declare the classes and avoid Qt-specific includes. The overhead from the extra allocations and indirection is minimal. 197113 29 koivisto 2010-03-08 04:04:31 -0800 (In reply to comment #26) > Are the command line options really worth it? The launcher code might be > simplier if we support the options only in the menu. Just a thought though :) Perhaps we might want to have non-interactive functionality in QtLauncher in the future (for performance testing for example)? But I'll remove these, they don't currently even work correctly. > Hmm, why is this needed? Should setResizesToContents automatically do this? Or > perhaps the docs of the resizesToContents property should explain that this may > also be a good thing to do. Without this the view content is not pannable in resizesToContent mode. Easiest way to make it scrollable again is to enable QGraphicsView scrollbars. This is not the only or necessarily the best way to do this (see yberbrowser which implements panning by manipulating graphics items and does not enable QGraphicsView scrollbars). > Why are the scrollbars turned _off_ if m_resizesToContents is false? Shouldn't > it be the other way around? When resizesToContents is false (the normal behavior) QWebGraphicsView is responsible of drawing the scrollbars itself. QGraphicsView scrollbars are redundant in this case. 197176 30 hausmann 2010-03-08 08:15:18 -0800 *** Bug 32122 has been marked as a duplicate of this bug. *** 197218 31 benjamin 2010-03-08 10:19:27 -0800 From a quick look of the webcore patch: > #include <QDebug>, #include <QThread> I guess you can skip those, they probably come from an implementation with threads. > #include <QImage> Shouldn't that be <QPixmap>? QImage is not used in this patch, the tiles are stored as Pixmaps. > #if PLATFORM(QT) > QPixmap* m_buffer; > QPixmap* m_backBuffer; > QRegion* m_dirtyRegion; > #endif Those are implicitly shared, any particular reason to use pointers? > typedef IntPoint Coordinate; Why redefine IntPoint? It is regularly used as such for coordinates. Good luck to the reviewer, this patch is not trivial :) 197502 32 koivisto 2010-03-09 01:56:16 -0800 > Those are implicitly shared, any particular reason to use pointers? See above. > Why redefine IntPoint? It is regularly used as such for coordinates. See above. 198504 33 50032 hausmann 2010-03-10 23:33:24 -0800 Comment on attachment 50032 QtWebKit patch > + WebCore::TiledBackingStore* backingStore = QWebFramePrivate::core(page()->mainFrame())->tiledBackingStore();; A catastrophic error: Two trailing semicolons :) The rest of the patch looks good to me, only minor things that we can fix after landing (for example docs). 198505 34 hausmann 2010-03-10 23:50:11 -0800 (In reply to comment #29) > > Why are the scrollbars turned _off_ if m_resizesToContents is false? Shouldn't > > it be the other way around? > > When resizesToContents is false (the normal behavior) QWebGraphicsView is > responsible of drawing the scrollbars itself. QGraphicsView scrollbars are > redundant in this case. Ohh, right, I confused the two scrollbars, thought you were disabling WebKit's scrollbars. 198569 35 50031 hausmann 2010-03-11 05:40:56 -0800 Comment on attachment 50031 WebCore patch After going through this patch I believe it is a great start and ready for initial landing. The previous rounds of review resulted in good improvements and I think the remaining issues can be fixed incrementally on top. 199190 36 manyoso 2010-03-12 13:25:55 -0800 I do not think this going into WebCore is a good idea. I know that all the existing clients that have a tiled backingstore do it in completely different (potentially incompatible) ways. I think it would make more sense for this to be implemented in the Qt specific WebKit layer rather than WebCore unless/until other ports decided to use the same. 199192 37 manyoso 2010-03-12 13:30:40 -0800 (In reply to comment #36) > I do not think this going into WebCore is a good idea. I know that all the > existing clients that have a tiled backingstore do it in completely different > (potentially incompatible) ways. I think it would make more sense for this to > be implemented in the Qt specific WebKit layer rather than WebCore unless/until > other ports decided to use the same. To be clear, I'm not speaking up to override Simon's r+. Just making my opinion known. 199268 38 koivisto 2010-03-12 17:38:15 -0800 (In reply to comment #36) > I do not think this going into WebCore is a good idea. I know that all the > existing clients that have a tiled backingstore do it in completely different > (potentially incompatible) ways. I think it would make more sense for this to > be implemented in the Qt specific WebKit layer rather than WebCore unless/until > other ports decided to use the same. Do you have technical arguments why this should not be shared code? What do you mean by "doing it completely different ways"? If you have a better way if doing this, why have you chosen not to contribute it? 199517 39 koivisto 2010-03-14 16:41:58 -0700 Sending WebCore/ChangeLog Sending WebCore/WebCore.pri Sending WebCore/WebCore.pro Sending WebCore/page/Frame.cpp Sending WebCore/page/Frame.h Sending WebCore/page/FrameView.cpp Sending WebCore/page/Settings.cpp Sending WebCore/page/Settings.h Adding WebCore/platform/graphics/Tile.h Adding WebCore/platform/graphics/TiledBackingStore.cpp Adding WebCore/platform/graphics/TiledBackingStore.h Adding WebCore/platform/graphics/TiledBackingStoreClient.h Adding WebCore/platform/graphics/qt/TileQt.cpp Transmitting file data ............. Committed revision 55976. 199519 40 koivisto 2010-03-14 17:52:18 -0700 Sending WebKit/qt/Api/qgraphicswebview.cpp Sending WebKit/qt/Api/qwebframe.cpp Sending WebKit/qt/Api/qwebframe.h Sending WebKit/qt/Api/qwebsettings.cpp Sending WebKit/qt/Api/qwebsettings.h Sending WebKit/qt/ChangeLog Transmitting file data ...... Committed revision 55978. 199520 41 koivisto 2010-03-14 17:53:36 -0700 Sending WebKitTools/ChangeLog Sending WebKitTools/QtLauncher/main.cpp Sending WebKitTools/QtLauncher/webview.cpp Sending WebKitTools/QtLauncher/webview.h Sending WebKitTools/Scripts/build-webkit Transmitting file data ..... Committed revision 55979. 199522 42 koivisto 2010-03-14 17:57:18 -0700 Followup for Qt scaling control API in bug 36102 199683 43 koivisto 2010-03-15 09:06:39 -0700 Followup for making WebKit scrollbars work with tiling in bug 36121 200235 44 manyoso 2010-03-16 09:12:36 -0700 (In reply to comment #38) > (In reply to comment #36) > > I do not think this going into WebCore is a good idea. I know that all the > > existing clients that have a tiled backingstore do it in completely different > > (potentially incompatible) ways. I think it would make more sense for this to > > be implemented in the Qt specific WebKit layer rather than WebCore unless/until > > other ports decided to use the same. > > Do you have technical arguments why this should not be shared code? What do you > mean by "doing it completely different ways"? If you have a better way if doing > this, why have you chosen not to contribute it? FWIW, the argument is that this has been handled by WebKit clients and not WebKit code in all existing cases that I am aware of. Moreover, WebCore/platform has not ever contained a backingstore class. I don't see why this should be implemented in WebCore if only one port is using it. That's all. Kind of moot at this point though. 200256 45 koivisto 2010-03-16 09:40:06 -0700 > FWIW, the argument is that this has been handled by WebKit clients and not > WebKit code in all existing cases that I am aware of. Moreover, > WebCore/platform has not ever contained a backingstore class. I don't see why > this should be implemented in WebCore if only one port is using it. That's > all. Kind of moot at this point though. Some more interesting tiling features will only be possible if tiling is done inside WebKit. Examples include tiled compositing layers, tiled subframes and tile painting from a secondary thread. Putting more of the code to the Qt layer (with hooks) would of course be possible but generally the idea is to avoid that in the project. Hopefully this will be useful for others as well in the future. 200270 46 manyoso 2010-03-16 10:01:13 -0700 (In reply to comment #45) > > FWIW, the argument is that this has been handled by WebKit clients and not > > WebKit code in all existing cases that I am aware of. Moreover, > > WebCore/platform has not ever contained a backingstore class. I don't see why > > this should be implemented in WebCore if only one port is using it. That's > > all. Kind of moot at this point though. > > Some more interesting tiling features will only be possible if tiling is done > inside WebKit. Examples include tiled compositing layers, tiled subframes and > tile painting from a secondary thread. Putting more of the code to the Qt layer > (with hooks) would of course be possible but generally the idea is to avoid > that in the project. Hopefully this will be useful for others as well in the > future. Interesting. Can you elaborate on why tiled subframes and tile painting from another thread would require this class in WebCore vs another layer? I've thought about the former case and came to a different conclusion. I have no idea about the latter and would be very interested to hear your thoughts on why that is necessary. 49067 2010-02-19 04:37:27 -0800 2010-02-25 08:27:02 -0800 Preliminary patch tiled-backing-store-4.patch text/plain 43474 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xNTc2LDYgKzE1NzYsNyBAQCBIRUFERVJTICs9IFwKICAgICBwbGF0Zm9ybS90ZXh0 L1VuaWNvZGVSYW5nZS5oIFwKICAgICBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmggXAogICAg IHBsYXRmb3JtL1RocmVhZFRpbWVycy5oIFwKKyAgICBwbGF0Zm9ybS9UaWxlZEJhY2tpbmdTdG9y ZS5oIFwgICAgCiAgICAgcGxhdGZvcm0vVGltZXIuaCBcCiAgICAgcGxhdGZvcm0vV2lkZ2V0Lmgg XAogICAgIHBsdWdpbnMvTWltZVR5cGVBcnJheS5oIFwKQEAgLTIwMjMsNiArMjAyNCw3IEBAIFNP VVJDRVMgKz0gXAogICAgIHBsYXRmb3JtL3F0L1NlYXJjaFBvcHVwTWVudVF0LmNwcCBcCiAgICAg cGxhdGZvcm0vcXQvU2hhcmVkVGltZXJRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L1NvdW5kUXQu Y3BwIFwKKyAgICBwbGF0Zm9ybS9xdC9UaWxlZEJhY2tpbmdTdG9yZVF0LmNwcCBcCiAgICAgcGxh dGZvcm0vcXQvTG9nZ2luZ1F0LmNwcCBcCiAgICAgcGxhdGZvcm0vdGV4dC9xdC9TdHJpbmdRdC5j cHAgXAogICAgIHBsYXRmb3JtL3F0L1RlbXBvcmFyeUxpbmtTdHVicy5jcHAgXApJbmRleDogV2Vi Q29yZS9wYWdlL0ZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRnJhbWUuY3Bw CShyZXZpc2lvbiA1NDc3NCkKKysrIFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTE3MSw5ICsxNzEsMTEgQEAgRnJhbWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFt ZU93bmVyRQogICAgIFhNTE5TTmFtZXM6OmluaXQoKTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwog Ci0gICAgaWYgKCFvd25lckVsZW1lbnQpCisgICAgaWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAg ICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMpOwotICAgIGVsc2UgeworICAgICAgICAvLyBUb3Ag bGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAgICAgICBzZXRUaWxlZEJhY2tpbmdTdG9yZUVu YWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkpOworICAg IH0gZWxzZSB7CiAgICAgICAgIHBhZ2UtPmluY3JlbWVudEZyYW1lQ291bnQoKTsKICAgICAgICAg Ly8gTWFrZSBzdXJlIHdlIHdpbGwgbm90IGVuZCB1cCB3aXRoIHR3byBmcmFtZXMgcmVmZXJlbmNp bmcgdGhlIHNhbWUgb3duZXIgZWxlbWVudC4KICAgICAgICAgQVNTRVJUKCghKG93bmVyRWxlbWVu dC0+bV9jb250ZW50RnJhbWUpKSB8fCAob3duZXJFbGVtZW50LT5tX2NvbnRlbnRGcmFtZS0+b3du ZXJFbGVtZW50KCkgIT0gb3duZXJFbGVtZW50KSk7CkBAIC0xODA4LDQgKzE4MTAsNDcgQEAgdm9p ZCBGcmFtZTo6Y3JlYXRlVmlldyhjb25zdCBJbnRTaXplJiB2aQogICAgICAgICB2aWV3KCktPnNl dENhbkhhdmVTY3JvbGxiYXJzKG93bmVyLT5zY3JvbGxpbmdNb2RlKCkgIT0gU2Nyb2xsYmFyQWx3 YXlzT2ZmKTsKIH0KIAordm9pZCBGcmFtZTo6c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJv b2wgZW5hYmxlZCkKK3sKKyAgICBpZiAoIWVuYWJsZWQpIHsKKyAgICAgICAgbV90aWxlZEJhY2tp bmdTdG9yZS5jbGVhcigpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlmIChtX3RpbGVk QmFja2luZ1N0b3JlKQorICAgICAgICByZXR1cm47CisgICAgbV90aWxlZEJhY2tpbmdTdG9yZS5z ZXQobmV3IFRpbGVkQmFja2luZ1N0b3JlKHRoaXMpKTsKK30KKwordm9pZCBGcmFtZTo6dGlsZWRC YWNraW5nU3RvcmVQYWludEJlZ2luKCkKK3sKKyAgICBpZiAoIW1fdmlldykKKyAgICAgICAgcmV0 dXJuOworICAgIG1fdmlldy0+bGF5b3V0SWZOZWVkZWRSZWN1cnNpdmUoKTsKKyAgICBtX3ZpZXct PmZsdXNoRGVmZXJyZWRSZXBhaW50cygpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdT dG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgcmVjdCkK K3sKKyAgICBpZiAoIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIG1fdmlldy0+cGFpbnRD b250ZW50cyhjb250ZXh0LCByZWN0KTsKK30KKwordm9pZCBGcmFtZTo6dGlsZWRCYWNraW5nU3Rv cmVQYWludEVuZChjb25zdCBWZWN0b3I8SW50UmVjdD4mIHBhaW50ZWRBcmVhKQoreworICAgIGlm ICghbV9wYWdlIHx8ICFtX3ZpZXcpCisgICAgICAgIHJldHVybjsKKyAgICB1bnNpZ25lZCBzaXpl ID0gcGFpbnRlZEFyZWEuc2l6ZSgpOworICAgIC8vIFJlcXVlc3QgcmVwYWludCBmcm9tIHRoZSBz eXN0ZW0KKyAgICBmb3IgKGludCBuID0gMDsgbiA8IHNpemU7ICsrbikKKyAgICAgICAgbV9wYWdl LT5jaHJvbWUoKS0+cmVwYWludChtX3ZpZXctPmNvbnZlcnRUb0NvbnRhaW5pbmdXaW5kb3cocGFp bnRlZEFyZWFbbl0pLCB0cnVlKTsKK30KKworSW50UmVjdCBGcmFtZTo6dGlsZWRCYWNraW5nU3Rv cmVDb250ZW50UmVjdCgpCit7CisgICAgaWYgKCFtX3ZpZXcpCisgICAgICAgIHJldHVybiBJbnRS ZWN0KCk7CisgICAgcmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbV92aWV3LT5jb250ZW50c1Np emUoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGFnZS9G cmFtZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9GcmFtZS5oCShyZXZpc2lvbiA1NDc3 NCkKKysrIFdlYkNvcmUvcGFnZS9GcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNyw2ICszNyw3 IEBACiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNjcm9sbEJlaGF2 aW9yLmgiCiAjaW5jbHVkZSAiU2VsZWN0aW9uQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIlRpbGVk QmFja2luZ1N0b3JlLmgiCiAjaW5jbHVkZSAiVXNlclNjcmlwdFR5cGVzLmgiCiAKICNpZiBQTEFU Rk9STShXSU4pCkBAIC02Myw3ICs2NCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFz cyBIVE1MVGFibGVDZWxsRWxlbWVudDsKICAgICBjbGFzcyBSZWd1bGFyRXhwcmVzc2lvbjsKIAot ICAgIGNsYXNzIEZyYW1lIDogcHVibGljIFJlZkNvdW50ZWQ8RnJhbWU+IHsKKyAgICBjbGFzcyBG cmFtZSA6IHB1YmxpYyBSZWZDb3VudGVkPEZyYW1lPiwgcHVibGljIFRpbGVkQmFja2luZ1N0b3Jl Q2xpZW50IHsKICAgICBwdWJsaWM6CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEZyYW1lPiBj cmVhdGUoUGFnZSogcGFnZSwgSFRNTEZyYW1lT3duZXJFbGVtZW50KiBvd25lckVsZW1lbnQsIEZy YW1lTG9hZGVyQ2xpZW50KiBjbGllbnQpCiAgICAgICAgIHsKQEAgLTE2MSw2ICsxNjIsOSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICByZXR1cm4gZG9jdW1lbnQoKSA/IGRvY3Vt ZW50KCktPmRpc3BsYXlTdHJpbmdNb2RpZmllZEJ5RW5jb2Rpbmcoc3RyKSA6IHN0cjsKICAgICAg ICAgfQogCisgICAgICAgIFRpbGVkQmFja2luZ1N0b3JlKiB0aWxlZEJhY2tpbmdTdG9yZSgpIGNv bnN0IHsgcmV0dXJuIG1fdGlsZWRCYWNraW5nU3RvcmUuZ2V0KCk7IH0KKyAgICAgICAgdm9pZCBz ZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisKICAgICBwcml2YXRlOgogICAgICAg ICB2b2lkIGxpZmVTdXBwb3J0VGltZXJGaXJlZChUaW1lcjxGcmFtZT4qKTsKIApAQCAtMjY2LDYg KzI3MCwxMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgVmlzaWJsZVBvc2l0aW9u IHZpc2libGVQb3NpdGlvbkZvclBvaW50KGNvbnN0IEludFBvaW50JiBmcmFtZVBvaW50KTsKICAg ICAgICAgRG9jdW1lbnQqIGRvY3VtZW50QXRQb2ludChjb25zdCBJbnRQb2ludCYgd2luZG93UG9p bnQpOworICAgICAgICAKKyAgICBwcml2YXRlOgorICAgICAgICAvLyBUaWxlZEJhY2tpbmdTdG9y ZUNsaWVudCBpbnRlcmZhY2UKKyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3Jl UGFpbnRCZWdpbigpOworICAgICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWlu dChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9p ZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50RW5kKGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRl ZEFyZWEpOworICAgICAgICB2aXJ0dWFsIEludFJlY3QgdGlsZWRCYWNraW5nU3RvcmVDb250ZW50 UmVjdCgpOwogCiAgICAgI2lmIFBMQVRGT1JNKE1BQykKIApAQCAtMjg2LDYgKzI5Nyw3IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIHByaXZhdGU6CiAgICAgICAgIE5TSW1hZ2UqIGltYWdl RnJvbVJlY3QoTlNSZWN0KSBjb25zdDsKKyAgICAgICAgCiAKICAgICAvLyA9PT0gdG8gYmUgbW92 ZWQgaW50byBFZGl0b3IKIApAQCAtMzQ0LDYgKzM1Niw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgYm9vbCBtX25lZWRzUmVhcHBseVN0eWxlczsKICAgICAgICAgYm9vbCBtX2lzRGlz Y29ubmVjdGVkOwogICAgICAgICBib29sIG1fZXhjbHVkZUZyb21UZXh0U2VhcmNoOworICAgICAg ICAKKyAgICAgICAgT3duUHRyPFRpbGVkQmFja2luZ1N0b3JlPiBtX3RpbGVkQmFja2luZ1N0b3Jl OwogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGFnZS9G cmFtZVZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCShy ZXZpc2lvbiA1NDc3NCkKKysrIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC01NCw2ICs1NCw3IEBACiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUg IlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dFJlc291cmNlRGVjb2Rlci5oIgorI2luY2x1ZGUg IlRpbGVkQmFja2luZ1N0b3JlLmgiCiAjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAKICNp ZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCkBAIC05OTcsOCArOTk4LDExIEBAIHZvaWQg RnJhbWVWaWV3OjpyZXBhaW50Q29udGVudFJlY3RhbmdsZSgKICAgICAKICAgICBpZiAoIWltbWVk aWF0ZSAmJiBpc09mZnNjcmVlbigpICYmICFzaG91bGRVcGRhdGVXaGlsZU9mZnNjcmVlbigpKQog ICAgICAgICByZXR1cm47Ci0KLSAgICBTY3JvbGxWaWV3OjpyZXBhaW50Q29udGVudFJlY3Rhbmds ZShyLCBpbW1lZGlhdGUpOworICAgIAorICAgIGlmIChmcmFtZSgpLT50aWxlZEJhY2tpbmdTdG9y ZSgpKQorICAgICAgICBmcmFtZSgpLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5pbnZhbGlkYXRlKHIp OworICAgIGVsc2UgICAgICAgIAorICAgICAgICBTY3JvbGxWaWV3OjpyZXBhaW50Q29udGVudFJl Y3RhbmdsZShyLCBpbW1lZGlhdGUpOwogfQogCiB2b2lkIEZyYW1lVmlldzo6dmlzaWJsZUNvbnRl bnRzUmVzaXplZCgpCkBAIC0xMDY5LDggKzEwNzMsMTIgQEAgdm9pZCBGcmFtZVZpZXc6OmRvRGVm ZXJyZWRSZXBhaW50cygpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAgICAgdW5zaWduZWQgc2l6 ZSA9IG1fcmVwYWludFJlY3RzLnNpemUoKTsKLSAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwg c2l6ZTsgaSsrKQotICAgICAgICBTY3JvbGxWaWV3OjpyZXBhaW50Q29udGVudFJlY3RhbmdsZSht X3JlcGFpbnRSZWN0c1tpXSwgZmFsc2UpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBz aXplOyBpKyspIHsKKyAgICAgICAgaWYgKGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCkpCisg ICAgICAgICAgICBmcmFtZSgpLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5pbnZhbGlkYXRlKG1fcmVw YWludFJlY3RzW2ldKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgU2Nyb2xsVmlldzo6cmVw YWludENvbnRlbnRSZWN0YW5nbGUobV9yZXBhaW50UmVjdHNbaV0sIGZhbHNlKTsKKyAgICB9CiAg ICAgbV9yZXBhaW50UmVjdHMuY2xlYXIoKTsKICAgICBtX3JlcGFpbnRDb3VudCA9IDA7CiAgICAg CkluZGV4OiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cGFnZS9TZXR0aW5ncy5jcHAJKHJldmlzaW9uIDU0Nzc0KQorKysgV2ViQ29yZS9wYWdlL1NldHRp bmdzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTI0LDYgKzEyNCw3IEBAIFNldHRpbmdzOjpTZXR0 aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV93ZWJHTEVuYWJsZWQoZmFsc2UpCiAgICAgLCBtX2dl b2xvY2F0aW9uRW5hYmxlZCh0cnVlKQogICAgICwgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCh0cnVl KQorICAgICwgbV90aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoZmFsc2UpCiB7CiAgICAgLy8gQSBG cmFtZSBtYXkgbm90IGhhdmUgYmVlbiBjcmVhdGVkIHlldCwgc28gd2UgaW5pdGlhbGl6ZSB0aGUg QXRvbWljU3RyaW5nIAogICAgIC8vIGhhc2ggYmVmb3JlIHRyeWluZyB0byB1c2UgaXQuCkBAIC01 NjgsNCArNTY5LDExIEBAIHZvaWQgU2V0dGluZ3M6OnNldExvYWREZWZlcnJpbmdFbmFibGVkKGIK ICAgICBtX2xvYWREZWZlcnJpbmdFbmFibGVkID0gZW5hYmxlZDsKIH0KIAordm9pZCBTZXR0aW5n czo6c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wgZW5hYmxlZCkKK3sKKyAgICBtX3Rp bGVkQmFja2luZ1N0b3JlRW5hYmxlZCA9IGVuYWJsZWQ7CisgICAgaWYgKG1fcGFnZS0+bWFpbkZy YW1lKCkpCisgICAgICAgIG1fcGFnZS0+bWFpbkZyYW1lKCktPnNldFRpbGVkQmFja2luZ1N0b3Jl RW5hYmxlZChlbmFibGVkKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL1NldHRpbmdz LmgJKHJldmlzaW9uIDU0Nzc0KQorKysgV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgJKHdvcmtpbmcg Y29weSkKQEAgLTI4Niw2ICsyODYsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAg dm9pZCBzZXRMb2FkRGVmZXJyaW5nRW5hYmxlZChib29sKTsKICAgICAgICAgYm9vbCBsb2FkRGVm ZXJyaW5nRW5hYmxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9hZERlZmVycmluZ0VuYWJsZWQ7IH0K KyAgICAgICAgCisgICAgICAgIHZvaWQgc2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wp OworICAgICAgICBib29sIHRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCgpIGNvbnN0IHsgcmV0dXJu IG1fdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkOyB9CiAKICAgICBwcml2YXRlOgogICAgICAgICBQ YWdlKiBtX3BhZ2U7CkBAIC0zNjAsNiArMzYzLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICBib29sIG1fd2ViR0xFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX2dlb2xvY2F0aW9u RW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCA6IDE7Cisg ICAgICAgIGJvb2wgbV90aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQgOiAxOwogCiAjaWYgVVNFKFNB RkFSSV9USEVNRSkKICAgICAgICAgc3RhdGljIGJvb2wgZ1Nob3VsZFBhaW50TmF0aXZlQ29udHJv bHM7CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL1RpbGVkQmFja2luZ1N0b3JlLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQor KysgV2ViQ29yZS9wbGF0Zm9ybS9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDEzNiBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29ycG9yYXRpb24g YW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u LgorIAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQsIEZpZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisK KyNpZm5kZWYgVGlsZWRCYWNraW5nU3RvcmVfaAorI2RlZmluZSBUaWxlZEJhY2tpbmdTdG9yZV9o CisKKyNpbmNsdWRlICJJbnRSZWN0LmgiCisjaW5jbHVkZSAiRmxvYXRTaXplLmgiCisjaW5jbHVk ZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQ dHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGlsZTsKK2NsYXNzIFRpbGVUaW1lcjsK KworY2xhc3MgVGlsZWRCYWNraW5nU3RvcmVDbGllbnQKK3sKK3B1YmxpYzoKKyAgICB2aXJ0dWFs IHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCkgPSAwOworICAgIHZpcnR1YWwgdm9p ZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3Qm KSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQoY29uc3Qg VmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSkgPSAwOworICAgIHZpcnR1YWwgSW50UmVjdCB0 aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRSZWN0KCkgPSAwOworfTsKKworY2xhc3MgVGlsZWRCYWNr aW5nU3RvcmUgOiBwdWJsaWMgTm9uY29weWFibGUKK3sKK3B1YmxpYzoKKyAgICBUaWxlZEJhY2tp bmdTdG9yZShUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCopOworICAgIH5UaWxlZEJhY2tpbmdTdG9y ZSgpOworCisgICAgdm9pZCB2aWV3cG9ydENoYW5nZWQoY29uc3QgSW50UmVjdCYgdmlld3BvcnRS ZWN0KTsKKyAgICAKKyAgICBmbG9hdCBzY2FsZSgpIHsgcmV0dXJuIG1fc2NhbGU7IH0KKyAgICB2 b2lkIHNldFNjYWxlKGZsb2F0KTsKKworICAgIHZvaWQgaW52YWxpZGF0ZShjb25zdCBJbnRSZWN0 JiBkaXJ0eVJlY3QpOworICAgIHZvaWQgcGFpbnQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50 UmVjdCYpOworCisgICAgZW51bSBTdGF0ZSB7CisgICAgICAgIFN0YXRlTm9ybWFsLAorICAgICAg ICBTdGF0ZU5vVGlsZUNyZWF0aW9uCisgICAgfTsKKworICAgIFN0YXRlIHN0YXRlKCkgY29uc3Qg eyByZXR1cm4gbV9zdGF0ZTsgfQorICAgIHZvaWQgc2V0U3RhdGUoU3RhdGUpOworCitwcml2YXRl OgorICAgIHZvaWQgc3RhcnRUaWxlVXBkYXRlVGltZXIoKTsKKyAgICB2b2lkIHN0YXJ0VGlsZUNy ZWF0aW9uVGltZXIoKTsKKworICAgIHZvaWQgdGlsZVVwZGF0ZVRpbWVyRmlyZWQoKTsKKyAgICB2 b2lkIHRpbGVDcmVhdGlvblRpbWVyRmlyZWQoKTsKKyAgICAKKyAgICB2b2lkIHVwZGF0ZVRpbGVz KCk7CisgICAgdm9pZCBjcmVhdGVUaWxlcygpOworICAgIHZvaWQgZHJvcE92ZXJoYW5naW5nVGls ZXMoKTsKKyAgICB2b2lkIGRyb3BUaWxlc091dHNpZGVSZWN0KGNvbnN0IEludFJlY3QmKTsKKyAg ICAKKyAgICBzdHJ1Y3QgVGlsZUNvb3JkaW5hdGUgeworICAgIHB1YmxpYzoKKyAgICAgICAgVGls ZUNvb3JkaW5hdGUodW5zaWduZWQgeCwgdW5zaWduZWQgeSkgOiBtX3goeCksIG1feSh5KSB7IH0K KyAgICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFRpbGVkQmFja2luZ1N0b3JlOjpUaWxlQ29v cmRpbmF0ZSYgbykgY29uc3QgeyByZXR1cm4gbV94ID09IG8ubV94ICYmIG1feSA9PSBvLm1feTsg fQorICAgICAgICB1bnNpZ25lZCB4KCkgY29uc3QgeyByZXR1cm4gbV94OyB9CisgICAgICAgIHVu c2lnbmVkIHkoKSBjb25zdCB7IHJldHVybiBtX3k7IH0KKyAgICAgICAgdW5zaWduZWQgaGFzaCgp IGNvbnN0IHsKKyAgICAgICAgICAgIHVuc2lnbmVkIGhhc2ggPSBXVEY6OmludEhhc2goc3RhdGlj X2Nhc3Q8dWludDY0X3Q+KG1feCkgPDwgMzIgfCBtX3kpOworICAgICAgICAgICAgLy8gYXZvaWQg ZW1wdHkgYW5kIGRlbGV0ZWQgdmFsdWUKKyAgICAgICAgICAgIHJldHVybiBoYXNoIHwgKCEoaGFz aCArIDEpIDw8IDMxKTsKKyAgICAgICAgfQorICAgIHByaXZhdGU6CisgICAgICAgIHVuc2lnbmVk IG1feDsKKyAgICAgICAgdW5zaWduZWQgbV95OworICAgIH07CisgICAgCisgICAgUGFzc1JlZlB0 cjxUaWxlPiB0aWxlKGNvbnN0IFRpbGVDb29yZGluYXRlJikgY29uc3Q7CisgICAgdm9pZCBzZXRU aWxlKGNvbnN0IFRpbGVDb29yZGluYXRlJiBjb29yZGluYXRlLCBQYXNzUmVmUHRyPFRpbGU+IHRp bGUpOworICAgIHZvaWQgcmVtb3ZlVGlsZShjb25zdCBUaWxlQ29vcmRpbmF0ZSYgY29vcmRpbmF0 ZSk7CisKKyAgICBJbnRSZWN0IHJlY3RUb0RvY3VtZW50KGNvbnN0IEludFJlY3QmKSBjb25zdDsK KyAgICBJbnRSZWN0IHJlY3RGcm9tRG9jdW1lbnQoY29uc3QgSW50UmVjdCYpIGNvbnN0OworICAg IAorICAgIEludFJlY3QgY29udGVudFJlY3QoKSBjb25zdDsKKyAgICAKKyAgICBJbnRSZWN0IHRp bGVSZWN0Rm9yQ29vcmRpbmF0ZShjb25zdCBUaWxlQ29vcmRpbmF0ZSYpIGNvbnN0OworICAgIFRp bGVkQmFja2luZ1N0b3JlOjpUaWxlQ29vcmRpbmF0ZSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNv bnN0IEludFBvaW50JikgY29uc3Q7CisgICAgZG91YmxlIHRpbGVEaXN0YW5jZShjb25zdCBJbnRS ZWN0JiB2aWV3cG9ydCwgY29uc3QgVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVDb29yZGluYXRlJik7 CisgICAgCisgICAgdm9pZCBwYWludENoZWNrZXJQYXR0ZXJuKFFQYWludGVyKiBwYWludGVyLCBj b25zdCBJbnRSZWN0JiByZWN0LCBUaWxlQ29vcmRpbmF0ZSBjb29yZGluYXRlKTsKKworICAgIFRp bGVkQmFja2luZ1N0b3JlQ2xpZW50KiBtX2NsaWVudDsKKworICAgIHR5cGVkZWYgSGFzaE1hcDx1 bnNpZ25lZCwgUmVmUHRyPFRpbGU+ID4gVGlsZU1hcDsKKyAgICBUaWxlTWFwIG1fdGlsZXM7Cisg ICAgCisjaWYgRU5BQkxFKEVOR0lORV9USFJFQUQpCisgICAgTXV0ZXggbV90aWxlTXV0ZXg7Cisg ICAgTXV0ZXggbV9wYWludE11dGV4OworI2VuZGlmCisKKyAgICAvLyBEb24ndCB1c2UgV2ViS2l0 IHRpbWVycyB0byBhdm9pZCBpbnRlcmZlcmluZyB3aXRoIHRoZSBlbmdpbmUuCisgICAgVGlsZVRp bWVyKiBtX3RpbGVVcGRhdGVUaW1lcjsKKyAgICBUaWxlVGltZXIqIG1fdGlsZUNyZWF0aW9uVGlt ZXI7CisKKyAgICBJbnRTaXplIG1fdGlsZVNpemU7CisgICAgCisgICAgSW50UmVjdCBtX3ZpZXdw b3J0OworICAgIGZsb2F0IG1fc2NhbGU7CisKKyAgICBTdGF0ZSBtX3N0YXRlOworCisgICAgZnJp ZW5kIGNsYXNzIFRpbGU7Cit9OworCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9y bS9xdC9UaWxlZEJhY2tpbmdTdG9yZVF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRm b3JtL3F0L1RpbGVkQmFja2luZ1N0b3JlUXQuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9xdC9UaWxlZEJhY2tpbmdTdG9yZVF0LmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSw2NTAgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDA5IE5va2lhIENvcnBvcmF0aW9uIGFuZC9v ciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAK KyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKKworI2luY2x1 ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgPFFBcHBsaWNhdGlvbj4KKyNpbmNsdWRl IDxRQmFzaWNUaW1lcj4KKyNpbmNsdWRlIDxRRGVidWc+CisjaW5jbHVkZSA8UUltYWdlPgorI2lu Y2x1ZGUgPFFPYmplY3Q+CisjaW5jbHVkZSA8UVBhaW50ZXI+CisjaW5jbHVkZSA8UVRocmVhZD4K KworI2lmIEVOQUJMRShFTkdJTkVfVEhSRUFEKQorI2luY2x1ZGUgIkVuZ2luZVRocmVhZC5oIgor I2VuZGlmCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK3N0YXRpYyBjb25zdCBpbnQgdGls ZVNpemUgPSA1MTI7CitzdGF0aWMgY29uc3QgaW50IGNoZWNrZXJTaXplID0gMTY7CitzdGF0aWMg Y29uc3QgdW5zaWduZWQgY2hlY2tlckNvbG9yMSA9IDB4ZmY1NTU1NTU7CitzdGF0aWMgY29uc3Qg dW5zaWduZWQgY2hlY2tlckNvbG9yMiA9IDB4ZmZhYWFhYWE7CisgICAgCitzdGF0aWMgUVBpeG1h cCYgY2hlY2tlcmVkUGl4bWFwKCkKK3sKKyAgICBzdGF0aWMgUVBpeG1hcCogcGl4bWFwOworICAg IGlmICghcGl4bWFwKSB7CisgICAgICAgIGludCBjaGVja2VyUGl4bWFwU2l6ZSA9IHRpbGVTaXpl ICsgY2hlY2tlclNpemU7CisgICAgICAgIHBpeG1hcCA9IG5ldyBRUGl4bWFwKGNoZWNrZXJQaXht YXBTaXplLCBjaGVja2VyUGl4bWFwU2l6ZSk7CisgICAgICAgIFFQYWludGVyIHBhaW50ZXIocGl4 bWFwKTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCBjaGVja2VyUGl4bWFwU2l6ZTsgeSAr PSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAgIGJvb2wgYWx0ZXJuYXRlID0geSAlIGNo ZWNrZXJTaXplOworICAgICAgICAgICAgZm9yIChpbnQgeCA9IDA7IHggPCBjaGVja2VyUGl4bWFw U2l6ZTsgeCArPSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAgICAgICBRQ29sb3IgY29s b3IoYWx0ZXJuYXRlID8gY2hlY2tlckNvbG9yMSA6IGNoZWNrZXJDb2xvcjIpOworICAgICAgICAg ICAgICAgIHBhaW50ZXIuZmlsbFJlY3QoeCwgeSwgY2hlY2tlclNpemUgLyAyLCBjaGVja2VyU2l6 ZSAvIDIsIGNvbG9yKTsKKyAgICAgICAgICAgICAgICBhbHRlcm5hdGUgPSAhYWx0ZXJuYXRlOwor ICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorICAgIHJldHVybiAqcGl4bWFwOworfQor ICAgIAorY2xhc3MgVGlsZVRpbWVyIDogcHVibGljIFFPYmplY3QgeworICAgIFFfT0JKRUNUICAg IAorcHVibGljOgorICAgIFRpbGVUaW1lcihUaWxlZEJhY2tpbmdTdG9yZSosIHZvaWQgKFRpbGVk QmFja2luZ1N0b3JlOjoqZikoKSk7CisgICAgdm9pZCBkZXN0cm95KCk7CisgICAgdm9pZCBzdGFy dE9uZVNob3QoZG91YmxlIHRpbWUpOworICAgIGJvb2wgaXNBY3RpdmUoKSB7IHJldHVybiBtX3Rp bWVyLmlzQWN0aXZlKCk7IH0KKworcHVibGljIFFfU0xPVFM6CisgICAgdm9pZCBzdGFydChkb3Vi bGUpOworCitwcm90ZWN0ZWQ6CisgICAgdm9pZCB0aW1lckV2ZW50KFFUaW1lckV2ZW50KiBldik7 CisgICAgCitwcml2YXRlOgorICAgIHZvaWQgbW92ZVRvRW5naW5lVGhyZWFkKCk7CisKKyAgICBR QmFzaWNUaW1lciBtX3RpbWVyOworICAgIFRpbGVkQmFja2luZ1N0b3JlKiBtX2JhY2tpbmdTdG9y ZTsKKyAgICB2b2lkIChUaWxlZEJhY2tpbmdTdG9yZTo6Km1fdGltZXJGdW5jdGlvbikoKTsKKyAg ICBib29sIG1faW5FbmdpbmVUaHJlYWQ7Cit9OworCitUaWxlVGltZXI6OlRpbGVUaW1lcihUaWxl ZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlLCB2b2lkIChUaWxlZEJhY2tpbmdTdG9yZTo6KmYp KCkpCisgICAgOiBtX2JhY2tpbmdTdG9yZShiYWNraW5nU3RvcmUpCisgICAgLCBtX3RpbWVyRnVu Y3Rpb24oZikKKyAgICAsIG1faW5FbmdpbmVUaHJlYWQoZmFsc2UpCit7CisjaWYgRU5BQkxFKEVO R0lORV9USFJFQUQpCisgICAgbW92ZVRvRW5naW5lVGhyZWFkKCk7CisjZW5kaWYKK30KKwordm9p ZCBUaWxlVGltZXI6Om1vdmVUb0VuZ2luZVRocmVhZCgpCit7CisjaWYgRU5BQkxFKEVOR0lORV9U SFJFQUQpCisgICAgaWYgKG1faW5FbmdpbmVUaHJlYWQpCisgICAgICAgIHJldHVybjsKKyAgICBp ZiAodGhyZWFkKCkgPT0gRW5naW5lVGhyZWFkOjpxVGhyZWFkKCkpIHsKKyAgICAgICAgbV9pbkVu Z2luZVRocmVhZCA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKCFFbmdp bmVUaHJlYWQ6OmlzU3RhcnRlZCgpIHx8IFFUaHJlYWQ6OmN1cnJlbnRUaHJlYWQoKSAhPSB0aHJl YWQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIG1vdmVUb1RocmVhZChFbmdpbmVUaHJlYWQ6OnFU aHJlYWQoKSk7CisgICAgbV9pbkVuZ2luZVRocmVhZCA9IHRydWU7CisjZW5kaWYKK30KKwordm9p ZCBUaWxlVGltZXI6OnN0YXJ0T25lU2hvdChkb3VibGUgdGltZSkKK3sKKyNpZiBFTkFCTEUoRU5H SU5FX1RIUkVBRCkKKyAgICBtb3ZlVG9FbmdpbmVUaHJlYWQoKTsKKworICAgIGlmIChFbmdpbmVU aHJlYWQ6OmlzQ3VycmVudCgpICYmIG1faW5FbmdpbmVUaHJlYWQpCisgICAgICAgIHN0YXJ0KHRp bWUpOworICAgIGVsc2UKKyAgICAgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0aGlzLCAi c3RhcnQiLCBRdDo6QXV0b0Nvbm5lY3Rpb24sIFFfQVJHKGRvdWJsZSwgdGltZSkpOyAKKyNlbHNl CisgICAgc3RhcnQodGltZSk7CisjZW5kaWYKK30KKwordm9pZCBUaWxlVGltZXI6OnN0YXJ0KGRv dWJsZSB0aW1lKQoreworICAgIG1fdGltZXIuc3RhcnQodGltZSAqIDEwMDAsIHRoaXMpOworfQor Cit2b2lkIFRpbGVUaW1lcjo6dGltZXJFdmVudChRVGltZXJFdmVudCogZXYpCit7CisjaWYgRU5B QkxFKEVOR0lORV9USFJFQUQpCisgICAgYm9vbCBuZWVkc0xvY2sgPSBFbmdpbmVUaHJlYWQ6Omlz Q3VycmVudCgpOworICAgIGlmIChuZWVkc0xvY2spCisgICAgICAgIEVuZ2luZVRocmVhZDo6bG9j aygpOworI2VuZGlmCisgICAgbV90aW1lci5zdG9wKCk7CisgICAgaWYgKG1fYmFja2luZ1N0b3Jl KQorICAgICAgICAobV9iYWNraW5nU3RvcmUtPiptX3RpbWVyRnVuY3Rpb24pKCk7CisjaWYgRU5B QkxFKEVOR0lORV9USFJFQUQpCisgICAgaWYgKG5lZWRzTG9jaykKKyAgICAgICAgRW5naW5lVGhy ZWFkOjp1bmxvY2soKTsKKyNlbmRpZgorfQorICAgIAordm9pZCBUaWxlVGltZXI6OmRlc3Ryb3ko KQoreworICAgIG1fYmFja2luZ1N0b3JlID0gMDsKKyAgICBRTWV0YU9iamVjdDo6aW52b2tlTWV0 aG9kKHRoaXMsICJkZWxldGVMYXRlciIsIFF0OjpBdXRvQ29ubmVjdGlvbik7Cit9CisKK2NsYXNz IFRpbGUgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxUaWxlPgoreworcHVibGljOgorICAgIHN0 YXRpYyBQYXNzUmVmUHRyPFRpbGU+IGNyZWF0ZShUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0 b3JlLCBjb25zdCBUaWxlZEJhY2tpbmdTdG9yZTo6VGlsZUNvb3JkaW5hdGUmIHRpbGVDb29yZGlu YXRlKSB7IHJldHVybiBhZG9wdFJlZihuZXcgVGlsZShiYWNraW5nU3RvcmUsIHRpbGVDb29yZGlu YXRlKSk7IH0KKyAgICB+VGlsZSgpOworICAgIAorICAgIGJvb2wgaXNEaXJ0eSgpIGNvbnN0IHsg cmV0dXJuICFtX2RpcnR5UmVnaW9uLmlzRW1wdHkoKTsgfQorICAgIGNvbnN0IFFSZWdpb24mIGRp cnR5UmVnaW9uKCkgY29uc3QgeyByZXR1cm4gbV9kaXJ0eVJlZ2lvbjsgfQorICAgIHZvaWQgaW52 YWxpZGF0ZShjb25zdCBJbnRSZWN0Jik7CisgICAgdm9pZCB1cGRhdGVCdWZmZXIoKTsKKyAgICB2 b2lkIHN3YXBCdWZmZXIoKTsKKyAgICBib29sIGlzUmVhZHlUb1BhaW50KCkgY29uc3QgeyByZXR1 cm4gbV9idWZmZXI7IH0KKyAgICB2b2lkIHBhaW50KFFQYWludGVyKiBwYWludGVyLCBjb25zdCBJ bnRSZWN0JiByZWN0KTsKKyAgICAKKyAgICBjb25zdCBUaWxlZEJhY2tpbmdTdG9yZTo6VGlsZUNv b3JkaW5hdGUgY29vcmRpbmF0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdGlsZUNvb3JkaW5hdGU7IH0K KyAgICBjb25zdCBJbnRSZWN0JiByZWN0KCkgY29uc3QgeyByZXR1cm4gbV90aWxlUmVjdDsgfQor ICAgIGNvbnN0IEludFJlY3QgcmVjdFRvRG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBtX2JhY2tp bmdTdG9yZS0+cmVjdFRvRG9jdW1lbnQobV90aWxlUmVjdCk7IH0KKworcHJpdmF0ZToKKyAgICBU aWxlKFRpbGVkQmFja2luZ1N0b3JlKiwgY29uc3QgVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVDb29y ZGluYXRlJik7CisgICAgCisgICAgVGlsZWRCYWNraW5nU3RvcmUqIG1fYmFja2luZ1N0b3JlOwor ICAgIFRpbGVkQmFja2luZ1N0b3JlOjpUaWxlQ29vcmRpbmF0ZSBtX3RpbGVDb29yZGluYXRlOwor ICAgIEludFJlY3QgbV90aWxlUmVjdDsKKyAgICBRSW1hZ2UqIG1fYnVmZmVyOworICAgIFFJbWFn ZSogbV9iYWNrQnVmZmVyOworICAgIFFSZWdpb24gbV9kaXJ0eVJlZ2lvbjsKKyNpZiBFTkFCTEUo RU5HSU5FX1RIUkVBRCkKKyAgICBNdXRleCBtX2J1ZmZlck11dGV4OworICAgIE11dGV4IG1fZGly dHlSZWdpb25NdXRleDsKKyNlbmRpZgorfTsKKyAgICAKK1RpbGU6OlRpbGUoVGlsZWRCYWNraW5n U3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVDb29yZGlu YXRlJiB0aWxlQ29vcmRpbmF0ZSkKKyAgICA6IG1fYmFja2luZ1N0b3JlKGJhY2tpbmdTdG9yZSkK KyAgICAsIG1fdGlsZUNvb3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpCisgICAgLCBtX3RpbGVSZWN0 KG1fYmFja2luZ1N0b3JlLT50aWxlUmVjdEZvckNvb3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpKQor ICAgICwgbV9idWZmZXIoMCkKKyAgICAsIG1fYmFja0J1ZmZlcigwKQorICAgICwgbV9kaXJ0eVJl Z2lvbihtX3RpbGVSZWN0KQoreworfQorICAgIAorVGlsZTo6flRpbGUoKQoreworICAgIGRlbGV0 ZSBtX2J1ZmZlcjsKKyAgICBkZWxldGUgbV9iYWNrQnVmZmVyOworfQorCit2b2lkIFRpbGU6Omlu dmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZGlydHlSZWN0KQoreworICAgIEludFJlY3QgdGlsZURp cnR5UmVjdCA9IGludGVyc2VjdGlvbihkaXJ0eVJlY3QsIG1fdGlsZVJlY3QpOworICAgIGlmICh0 aWxlRGlydHlSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworI2lmIEVOQUJMRShFTkdJ TkVfVEhSRUFEKQorICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX2RpcnR5UmVnaW9uTXV0ZXgpOwor I2VuZGlmCisgICAgbV9kaXJ0eVJlZ2lvbiArPSB0aWxlRGlydHlSZWN0OworfQorICAgIAordm9p ZCBUaWxlOjp1cGRhdGVCdWZmZXIoKQoreworICAgIGlmIChtX2J1ZmZlciAmJiBtX2RpcnR5UmVn aW9uLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2JhY2tCdWZmZXIp IHsKKyAgICAgICAgLy8gQ29weSB0aGUgY3VycmVudCBidWZmZXIgaWYgdGhpcyBpcyBub3QgYSBm dWxsIHRpbGUgdXBkYXRlIChvciBhIG5ldyB0aWxlCisgICAgICAgIGlmICghbV9idWZmZXIpCisg ICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBuZXcgUUltYWdlKG1fYmFja2luZ1N0b3JlLT5tX3Rp bGVTaXplLndpZHRoKCksIG1fYmFja2luZ1N0b3JlLT5tX3RpbGVTaXplLmhlaWdodCgpLCBRSW1h Z2U6OkZvcm1hdF9SR0IxNik7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIG1fYmFja0J1ZmZl ciA9IG5ldyBRSW1hZ2UobV9idWZmZXItPmNvcHkoKSk7CisgICAgfQorCisgICAgUVZlY3RvcjxR UmVjdD4gZGlydHlSZWN0czsKKyAgICBkaXJ0eVJlY3RzLnNldFNoYXJhYmxlKGZhbHNlKTsKKyAg ICB7CisjaWYgRU5BQkxFKEVOR0lORV9USFJFQUQpCisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tl cihtX2RpcnR5UmVnaW9uTXV0ZXgpOworI2VuZGlmCisgICAgICAgIGRpcnR5UmVjdHMgPSBtX2Rp cnR5UmVnaW9uLnJlY3RzKCk7CisgICAgICAgIG1fZGlydHlSZWdpb24gPSBRUmVnaW9uKCk7Cisg ICAgfQorICAgIAorICAgIC8vIFBhaW50IHRvIGJhY2tidWZmZXIsIG5vIGxvY2tzIGhlbGQuCisg ICAgUVBhaW50ZXIgcGFpbnRlcihtX2JhY2tCdWZmZXIpOworICAgIEdyYXBoaWNzQ29udGV4dCBj b250ZXh0KCZwYWludGVyKTsKKyAgICBjb250ZXh0LnRyYW5zbGF0ZSgtbV90aWxlUmVjdC54KCks IC1tX3RpbGVSZWN0LnkoKSk7CisKKyAgICBpbnQgc2l6ZSA9IGRpcnR5UmVjdHMuc2l6ZSgpOwor ICAgIGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKSAgeworICAgICAgICBjb250ZXh0LnNh dmUoKTsKKyAgICAgICAgSW50UmVjdCByZWN0ID0gZGlydHlSZWN0c1tuXTsKKyAgICAgICAgY29u dGV4dC5jbGlwKEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgIGNvbnRleHQuc2NhbGUoRmxvYXRT aXplKG1fYmFja2luZ1N0b3JlLT5tX3NjYWxlLCBtX2JhY2tpbmdTdG9yZS0+bV9zY2FsZSkpOwor ICAgICAgICBtX2JhY2tpbmdTdG9yZS0+bV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnQo JmNvbnRleHQsIG1fYmFja2luZ1N0b3JlLT5yZWN0VG9Eb2N1bWVudChyZWN0KSk7CisgICAgICAg IGNvbnRleHQucmVzdG9yZSgpOworICAgIH0KK30KKwordm9pZCBUaWxlOjpzd2FwQnVmZmVyKCkK K3sKKyAgICBpZiAoIW1fYmFja0J1ZmZlcikKKyAgICAgICAgcmV0dXJuOworICAgIGRlbGV0ZSBt X2J1ZmZlcjsKKyAgICBtX2J1ZmZlciA9IG1fYmFja0J1ZmZlcjsKKyAgICBtX2JhY2tCdWZmZXIg PSAwOworfQorCit2b2lkIFRpbGU6OnBhaW50KFFQYWludGVyKiBwYWludGVyLCBjb25zdCBJbnRS ZWN0JiByZWN0KQoreworICAgIGlmICghbV9idWZmZXIpCisgICAgICAgIHJldHVybjsKKyAgICAK KyAgICBJbnRSZWN0IHRhcmdldCA9IGludGVyc2VjdGlvbihyZWN0LCBtX3RpbGVSZWN0KTsKKyAg ICBJbnRSZWN0IHNvdXJjZSgodGFyZ2V0LngoKSAtIG1fdGlsZVJlY3QueCgpKSwKKyAgICAgICAg ICAgICAgICAgICAodGFyZ2V0LnkoKSAtIG1fdGlsZVJlY3QueSgpKSwKKyAgICAgICAgICAgICAg ICAgICB0YXJnZXQud2lkdGgoKSwKKyAgICAgICAgICAgICAgICAgICB0YXJnZXQuaGVpZ2h0KCkp OworICAgIAorICAgIHBhaW50ZXItPmRyYXdJbWFnZSh0YXJnZXQsICptX2J1ZmZlciwgc291cmNl KTsKK30KKworVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVkQmFja2luZ1N0b3JlKFRpbGVkQmFja2lu Z1N0b3JlQ2xpZW50KiBjbGllbnQpCisgICAgOiBtX2NsaWVudChjbGllbnQpCisgICAgLCBtX3Rp bGVVcGRhdGVUaW1lcihuZXcgVGlsZVRpbWVyKHRoaXMsICZUaWxlZEJhY2tpbmdTdG9yZTo6dGls ZVVwZGF0ZVRpbWVyRmlyZWQpKQorICAgICwgbV90aWxlQ3JlYXRpb25UaW1lcihuZXcgVGlsZVRp bWVyKHRoaXMsICZUaWxlZEJhY2tpbmdTdG9yZTo6dGlsZUNyZWF0aW9uVGltZXJGaXJlZCkpCisg ICAgLCBtX3RpbGVTaXplKFdlYkNvcmU6OnRpbGVTaXplLCBXZWJDb3JlOjp0aWxlU2l6ZSkKKyAg ICAsIG1fc2NhbGUoMS5mKQoreworfQorCitUaWxlZEJhY2tpbmdTdG9yZTo6flRpbGVkQmFja2lu Z1N0b3JlKCkKK3sKKyAgICBtX3RpbGVVcGRhdGVUaW1lci0+ZGVzdHJveSgpOworICAgIG1fdGls ZVVwZGF0ZVRpbWVyID0gMDsKKyAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5kZXN0cm95KCk7Cisg ICAgbV90aWxlQ3JlYXRpb25UaW1lciA9IDA7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6 OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZG9jdW1lbnREaXJ0eVJlY3QpCit7CisgICAgSW50 UmVjdCBkaXJ0eVJlY3QocmVjdEZyb21Eb2N1bWVudChkb2N1bWVudERpcnR5UmVjdCkpOworICAg IAorICAgIFRpbGVDb29yZGluYXRlIHRvcExlZnQgPSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGRp cnR5UmVjdC50b3BMZWZ0KCkpOworICAgIFRpbGVDb29yZGluYXRlIGJvdHRvbVJpZ2h0ID0gdGls ZUNvb3JkaW5hdGVGb3JQb2ludChkaXJ0eVJlY3QuYm90dG9tUmlnaHQoKSk7CisgICAgCisgICAg Zm9yICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBi b3R0b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4 Q29vcmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7 ICsreENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxlPiBjdXJyZW50VGlsZSA9 IHRpbGUoVGlsZUNvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKSk7CisgICAgICAg ICAgICBpZiAoIWN1cnJlbnRUaWxlKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgY3VycmVudFRpbGUtPmludmFsaWRhdGUoZGlydHlSZWN0KTsKKyAgICAgICAgfQorICAg IH0KKworICAgIHN0YXJ0VGlsZVVwZGF0ZVRpbWVyKCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5n U3RvcmU6OnVwZGF0ZVRpbGVzKCkKK3sKKyAgICBpZiAobV9zdGF0ZSAhPSBTdGF0ZU5vcm1hbCkK KyAgICAgICAgcmV0dXJuOworICAgIAorICAgIFFSZWdpb24gZnVsbERpcnR5UmVnaW9uOworICAg IFZlY3RvcjxSZWZQdHI8VGlsZT4gPiBtX2RpcnR5VGlsZXM7CisgICAgVGlsZU1hcDo6aXRlcmF0 b3IgZW5kID0gbV90aWxlcy5lbmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0g bV90aWxlcy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgaWYgKCFpdC0+c2Vj b25kLT5pc0RpcnR5KCkpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgbV9kaXJ0eVRp bGVzLmFwcGVuZChpdC0+c2Vjb25kKTsKKyAgICAgICAgLy8gRklYTUU6IHNob3VsZCBub3QgcmVx dWVzdCBzeXN0ZW0gcmVwYWludCBmb3IgdGhlIGZ1bGwgdGlsZS4KKyAgICAgICAgZnVsbERpcnR5 UmVnaW9uICs9IGl0LT5zZWNvbmQtPnJlY3QoKTsKKyAgICAgICAgLy9mdWxsRGlydHlSZWdpb24g Kz0gaXQtPnNlY29uZC0+ZGlydHlSZWdpb24oKTsKKyAgICB9CisgICAgCisgICAgaWYgKG1fZGly dHlUaWxlcy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBtX2NsaWVudC0+ dGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCk7CisKKyAgICB1bnNpZ25lZCBzaXplID0gbV9k aXJ0eVRpbGVzLnNpemUoKTsKKyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgc2l6ZTsgKytu KQorICAgICAgICBtX2RpcnR5VGlsZXNbbl0tPnVwZGF0ZUJ1ZmZlcigpOworCisgICAgeworICAg ICAgICAvLyBTd2FwIHRoZSBidWZmZXJzIGF0b21pY2FsbHkKKyNpZiBFTkFCTEUoRU5HSU5FX1RI UkVBRCkKKyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fcGFpbnRNdXRleCk7CisjZW5kaWYK KyAgICAgICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IHNpemU7ICsrbikKKyAgICAgICAgICAg IG1fZGlydHlUaWxlc1tuXS0+c3dhcEJ1ZmZlcigpOworICAgIH0KKworICAgIFFWZWN0b3I8UVJl Y3Q+IHFyZWN0cyA9IGZ1bGxEaXJ0eVJlZ2lvbi5yZWN0cygpOworICAgIFZlY3RvcjxJbnRSZWN0 PiBwYWludGVkQXJlYTsKKyAgICB1bnNpZ25lZCByZWN0Q291bnQgPSBxcmVjdHMuc2l6ZSgpOwor ICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCByZWN0Q291bnQ7ICsrbikKKyAgICAgICAgcGFp bnRlZEFyZWEuYXBwZW5kKHJlY3RUb0RvY3VtZW50KHFyZWN0c1tuXSkpOworCisgICAgbV9jbGll bnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQocGFpbnRlZEFyZWEpOworfQorCit2b2lkIFRp bGVkQmFja2luZ1N0b3JlOjpwYWludENoZWNrZXJQYXR0ZXJuKFFQYWludGVyKiBwYWludGVyLCBj b25zdCBJbnRSZWN0JiByZWN0LCBUaWxlQ29vcmRpbmF0ZSBjb29yZGluYXRlKQoreworICAgIEZs b2F0UmVjdCB0aWxlUmVjdCA9IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZShjb29yZGluYXRlKTsKKyAg ICBGbG9hdFJlY3QgdGFyZ2V0ID0gaW50ZXJzZWN0aW9uKHRpbGVSZWN0LCBGbG9hdFJlY3QocmVj dCkpOworCisgICAgUVRyYW5zZm9ybSB0ID0gcGFpbnRlci0+d29ybGRUcmFuc2Zvcm0oKTsKKyAg ICBxcmVhbCBzY2FsZXggPSB0Lm0xMSgpOworICAgIHFyZWFsIHNjYWxleSA9IHQubTIyKCk7CisK KworICAgIFFSZWN0IHRhcmdldFZpZXdSZWN0ID0gUVJlY3RGKHRhcmdldC54KCkgKiBzY2FsZXgs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LnkoKSAqIHNjYWxleSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0YXJnZXQud2lkdGgoKSAqIHNjYWxl eCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0YXJnZXQuaGVpZ2h0KCkgKiBz Y2FsZXkpLnRvQWxpZ25lZFJlY3QoKTsKKworICAgIFFUcmFuc2Zvcm0gbnQoMS4sIHQubTEyKCks IHQubTEzKCksCisgICAgICAgICAgICAgICAgdC5tMjEoKSwgMS4sIHQubTIzKCksCisgICAgICAg ICAgICAgICAgdC5tMzEoKSwgdC5tMzIoKSwgdC5tMzMoKSk7CisgICAgcGFpbnRlci0+c2V0V29y bGRUcmFuc2Zvcm0obnQpOworCisgICAgcGFpbnRlci0+ZmlsbFJlY3QodGFyZ2V0Vmlld1JlY3Qs IFF0OjpyZWQpOworCisgICAgcGFpbnRlci0+ZHJhd1RpbGVkUGl4bWFwKHRhcmdldFZpZXdSZWN0 LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGVja2VyZWRQaXhtYXAoKSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgUVBvaW50KHRhcmdldFZpZXdSZWN0LmxlZnQoKSAlIGNo ZWNrZXJTaXplLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldFZp ZXdSZWN0LnRvcCgpICUgY2hlY2tlclNpemUpKTsKKworICAgIHBhaW50ZXItPnNldFdvcmxkVHJh bnNmb3JtKHQpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpwYWludChHcmFwaGljc0Nv bnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisjaWYgRU5BQkxFKEVOR0lO RV9USFJFQUQpCisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fcGFpbnRNdXRleCk7CisjZW5kaWYK KyAgICBRUGFpbnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOworCisg ICAgcGFpbnRlci0+c2F2ZSgpOworICAgIAorICAgIGlmIChtX3N0YXRlID09IFN0YXRlTm9UaWxl Q3JlYXRpb24pIHsKKyAgICAgICAgcGFpbnRlci0+c2NhbGUoMS5mIC8gbV9zY2FsZSwgMS5mIC8g bV9zY2FsZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgUVRyYW5zZm9ybSB0ID0gcGFpbnRlci0+ d29ybGRUcmFuc2Zvcm0oKTsgICAgCisgICAgICAgIFFUcmFuc2Zvcm0gbnQoMS4sIHQubTEyKCks IHQubTEzKCksCisgICAgICAgICAgICAgICAgICAgICAgdC5tMjEoKSwgMS4sIHQubTIzKCksCisg ICAgICAgICAgICAgICAgICAgICAgdC5tMzEoKSwgdC5tMzIoKSwgdC5tMzMoKSk7CisgICAgICAg IHBhaW50ZXItPnNldFdvcmxkVHJhbnNmb3JtKG50KTsKKyAgICB9CisgICAgCisgICAgSW50UmVj dCBkaXJ0eVJlY3QgPSByZWN0RnJvbURvY3VtZW50KHJlY3QpOworICAgIAorICAgIFRpbGVDb29y ZGluYXRlIHRvcExlZnQgPSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGRpcnR5UmVjdC50b3BMZWZ0 KCkpOworICAgIFRpbGVDb29yZGluYXRlIGJvdHRvbVJpZ2h0ID0gdGlsZUNvb3JkaW5hdGVGb3JQ b2ludChkaXJ0eVJlY3QuYm90dG9tUmlnaHQoKSk7CisKKyAgICBmb3IgKHVuc2lnbmVkIHlDb29y ZGluYXRlID0gdG9wTGVmdC55KCk7IHlDb29yZGluYXRlIDw9IGJvdHRvbVJpZ2h0LnkoKTsgKyt5 Q29vcmRpbmF0ZSkgeworICAgICAgICBmb3IgKHVuc2lnbmVkIHhDb29yZGluYXRlID0gdG9wTGVm dC54KCk7IHhDb29yZGluYXRlIDw9IGJvdHRvbVJpZ2h0LngoKTsgKyt4Q29vcmRpbmF0ZSkgewor ICAgICAgICAgICAgVGlsZUNvb3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENvb3JkaW5hdGUs IHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxlPiBjdXJyZW50VGlsZSA9IHRp bGUoY3VycmVudENvb3JkaW5hdGUpOworICAgICAgICAgICAgaWYgKGN1cnJlbnRUaWxlICYmIGN1 cnJlbnRUaWxlLT5pc1JlYWR5VG9QYWludCgpKQorICAgICAgICAgICAgICAgIGN1cnJlbnRUaWxl LT5wYWludChwYWludGVyLCBkaXJ0eVJlY3QpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAg ICAgICAgIHBhaW50Q2hlY2tlclBhdHRlcm4ocGFpbnRlciwgZGlydHlSZWN0LCBjdXJyZW50Q29v cmRpbmF0ZSk7CisgICAgICAgIH0KKyAgICB9CisgICAgcGFpbnRlci0+cmVzdG9yZSgpOworfQor Cit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp2aWV3cG9ydENoYW5nZWQoY29uc3QgSW50UmVjdCYg ZG9jVmlld3BvcnQpCit7CisgICAgSW50UmVjdCB2aWV3cG9ydCA9IHJlY3RGcm9tRG9jdW1lbnQo ZG9jVmlld3BvcnQpOworICAgIGlmIChtX3ZpZXdwb3J0ID09IHZpZXdwb3J0KQorICAgICAgICBy ZXR1cm47CisKKyAgICBtX3ZpZXdwb3J0ID0gdmlld3BvcnQ7CisKKyAgICBzdGFydFRpbGVDcmVh dGlvblRpbWVyKCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnNldFNjYWxlKGZsb2F0 IHNjYWxlKQoreworICAgIGlmIChtX3NjYWxlID09IHNjYWxlKQorICAgICAgICByZXR1cm47Cisg ICAgbV9zY2FsZSA9IHNjYWxlOworCisgICAgaW52YWxpZGF0ZShtX2NsaWVudC0+dGlsZWRCYWNr aW5nU3RvcmVDb250ZW50UmVjdCgpKTsKK30KKyAgICAKK2RvdWJsZSBUaWxlZEJhY2tpbmdTdG9y ZTo6dGlsZURpc3RhbmNlKGNvbnN0IEludFJlY3QmIHZpZXdwb3J0LCBjb25zdCBUaWxlZEJhY2tp bmdTdG9yZTo6VGlsZUNvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQoreworICAgIGlmICh2aWV3 cG9ydC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpKQor ICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQb2ludCB2aWV3Q2VudGVyID0gdmlld3Bv cnQubG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQud2lkdGgoKSAvIDIsIHZpZXdwb3J0Lmhl aWdodCgpIC8gMik7CisgICAgVGlsZUNvb3JkaW5hdGUgY2VudGVyQ29vcmRpbmF0ZSA9IHRpbGVD b29yZGluYXRlRm9yUG9pbnQodmlld0NlbnRlcik7CisgICAgCisgICAgLy8gTWFuaGF0dGFuIGRp c3RhbmNlLCBiaWFzZWQgc28gdGhhdCB2ZXJ0aWNhbCBkaXN0YW5jZXMgYXJlIHNob3J0ZXIuCisg ICAgY29uc3QgZG91YmxlIGhvcml6b250YWxCaWFzID0gMS4zOworICAgIHJldHVybiBhYnMoY2Vu dGVyQ29vcmRpbmF0ZS55KCkgLSB0aWxlQ29vcmRpbmF0ZS55KCkpICsgaG9yaXpvbnRhbEJpYXMg KiBhYnMoY2VudGVyQ29vcmRpbmF0ZS54KCkgLSB0aWxlQ29vcmRpbmF0ZS54KCkpOworfQorCit2 b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpjcmVhdGVUaWxlcygpCit7CisgICAgaWYgKG1fc3RhdGUg IT0gU3RhdGVOb3JtYWwpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX3ZpZXdwb3J0Lmlz RW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZHJvcE92ZXJoYW5naW5nVGlsZXMoKTsK KworICAgIC8vIEZJWE1FOiBNYWtlIGFkYXB0IHRvIG1lbW9yeS4KKyAgICBJbnRSZWN0IGtlZXBS ZWN0ID0gbV92aWV3cG9ydDsKKyAgICBrZWVwUmVjdC5pbmZsYXRlWChtX3ZpZXdwb3J0LndpZHRo KCkpOworICAgIGtlZXBSZWN0LmluZmxhdGVZKDMgKiBtX3ZpZXdwb3J0LmhlaWdodCgpKTsKKyAg ICBrZWVwUmVjdC5pbnRlcnNlY3QoY29udGVudFJlY3QoKSk7CisgICAgCisgICAgZHJvcFRpbGVz T3V0c2lkZVJlY3Qoa2VlcFJlY3QpOworICAgIAorICAgIEludFJlY3QgY292ZXJSZWN0ID0gbV92 aWV3cG9ydDsKKyAgICBjb3ZlclJlY3QuaW5mbGF0ZVgobV92aWV3cG9ydC53aWR0aCgpIC8gMik7 CisgICAgY292ZXJSZWN0LmluZmxhdGVZKDIgKiBtX3ZpZXdwb3J0LmhlaWdodCgpKTsKKyAgICBj b3ZlclJlY3QuaW50ZXJzZWN0KGNvbnRlbnRSZWN0KCkpOworICAgIAorICAgIGRvdWJsZSBzaG9y dGVzdERpc3RhbmNlID0gc3RkOjpudW1lcmljX2xpbWl0czxkb3VibGU+OjppbmZpbml0eSgpOwor ICAgIFZlY3RvcjxUaWxlQ29vcmRpbmF0ZT4gdGlsZXNUb0NyZWF0ZTsKKyAgICB1bnNpZ25lZCBy ZXF1aXJlZFRpbGVDb3VudCA9IDA7CisgICAgCisgICAgVGlsZUNvb3JkaW5hdGUgdG9wTGVmdCA9 IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY292ZXJSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZUNv b3JkaW5hdGUgYm90dG9tUmlnaHQgPSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNvdmVyUmVjdC5i b3R0b21SaWdodCgpKTsKKyAgICBmb3IgKHVuc2lnbmVkIHlDb29yZGluYXRlID0gdG9wTGVmdC55 KCk7IHlDb29yZGluYXRlIDw9IGJvdHRvbVJpZ2h0LnkoKTsgKyt5Q29vcmRpbmF0ZSkgeworICAg ICAgICBmb3IgKHVuc2lnbmVkIHhDb29yZGluYXRlID0gdG9wTGVmdC54KCk7IHhDb29yZGluYXRl IDw9IGJvdHRvbVJpZ2h0LngoKTsgKyt4Q29vcmRpbmF0ZSkgeworICAgICAgICAgICAgVGlsZUNv b3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAg ICAgICAgICAgIGlmICh0aWxlKGN1cnJlbnRDb29yZGluYXRlKSkKKyAgICAgICAgICAgICAgICBj b250aW51ZTsKKyAgICAgICAgICAgICsrcmVxdWlyZWRUaWxlQ291bnQ7CisgICAgICAgICAgICAv LyAwIGRpc3RhbmNlIGZvciBjdXJyZW50bHkgdmlzaWJsZSB0aWxlcy4KKyAgICAgICAgICAgIGRv dWJsZSBkaXN0YW5jZSA9IHRpbGVEaXN0YW5jZShtX3ZpZXdwb3J0LCBjdXJyZW50Q29vcmRpbmF0 ZSk7CisgICAgICAgICAgICBpZiAoZGlzdGFuY2UgPiBzaG9ydGVzdERpc3RhbmNlKQorICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgaWYgKGRpc3RhbmNlIDwgc2hvcnRlc3RE aXN0YW5jZSkgeworICAgICAgICAgICAgICAgIHRpbGVzVG9DcmVhdGUuY2xlYXIoKTsKKyAgICAg ICAgICAgICAgICBzaG9ydGVzdERpc3RhbmNlID0gZGlzdGFuY2U7CisgICAgICAgICAgICB9Cisg ICAgICAgICAgICB0aWxlc1RvQ3JlYXRlLmFwcGVuZChjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAg ICAgIH0KKyAgICB9CisgICAgCisgICAgdW5zaWduZWQgdGlsZXNUb0NyZWF0ZUNvdW50ID0gdGls ZXNUb0NyZWF0ZS5zaXplKCk7CisgICAgaWYgKHRpbGVzVG9DcmVhdGVDb3VudCkgeworICAgICAg ICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgdGlsZXNUb0NyZWF0ZUNvdW50OyArK24pIHsKKyAg ICAgICAgICAgIFRpbGVDb29yZGluYXRlIGNvb3JkaW5hdGUgPSB0aWxlc1RvQ3JlYXRlW25dOwor ICAgICAgICAgICAgc2V0VGlsZShjb29yZGluYXRlLCBUaWxlOjpjcmVhdGUodGhpcywgY29vcmRp bmF0ZSkpOworICAgICAgICB9CisgICAgICAgIHJlcXVpcmVkVGlsZUNvdW50IC09IHRpbGVzVG9D cmVhdGVDb3VudDsKKyAgICB9CisgICAgCisgICAgLy8gUGFpbnQgdGhlIGNvbnRlbnQgb2YgdGhl IG5ld2x5IGNyZWF0ZWQgdGlsZXMKKyAgICBpZiAodGlsZXNUb0NyZWF0ZUNvdW50KQorICAgICAg ICB1cGRhdGVUaWxlcygpOworCisgICAgLy8gS2VlcCBjcmVhdGluZyB0aWxlcyB1bnRpbCB0aGUg d2hvbGUgY292ZXJSZWN0IGlzIGNvdmVyZWQuCisgICAgaWYgKHJlcXVpcmVkVGlsZUNvdW50KQor ICAgICAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQg VGlsZWRCYWNraW5nU3RvcmU6OmRyb3BPdmVyaGFuZ2luZ1RpbGVzKCkKK3sgICAgCisgICAgSW50 UmVjdCBjb250ZW50UmVjdCA9IHRoaXMtPmNvbnRlbnRSZWN0KCk7CisKKyAgICBWZWN0b3I8VGls ZUNvb3JkaW5hdGU+IHRpbGVzVG9SZW1vdmU7CisgICAgVGlsZU1hcDo6aXRlcmF0b3IgZW5kID0g bV90aWxlcy5lbmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0gbV90aWxlcy5i ZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgVGlsZUNvb3JkaW5hdGUgdGlsZUNv b3JkaW5hdGUgPSBpdC0+c2Vjb25kLT5jb29yZGluYXRlKCk7CisgICAgICAgIEludFJlY3QgdGls ZVJlY3QgPSBpdC0+c2Vjb25kLT5yZWN0KCk7CisgICAgICAgIEludFJlY3QgZXhwZWN0ZWRUaWxl UmVjdCA9IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSk7CisgICAgICAgIGlm IChleHBlY3RlZFRpbGVSZWN0ICE9IHRpbGVSZWN0IHx8ICFjb250ZW50UmVjdC5jb250YWlucyh0 aWxlUmVjdCkpCisgICAgICAgICAgICB0aWxlc1RvUmVtb3ZlLmFwcGVuZCh0aWxlQ29vcmRpbmF0 ZSk7CisgICAgfQorICAgIHVuc2lnbmVkIHJlbW92ZUNvdW50ID0gdGlsZXNUb1JlbW92ZS5zaXpl KCk7CisgICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IHJlbW92ZUNvdW50OyArK24pCisgICAg ICAgIHJlbW92ZVRpbGUodGlsZXNUb1JlbW92ZVtuXSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5n U3RvcmU6OmRyb3BUaWxlc091dHNpZGVSZWN0KGNvbnN0IEludFJlY3QmIGtlZXBSZWN0KQorewor ICAgIEZsb2F0UmVjdCBrZWVwUmVjdEYgPSBrZWVwUmVjdDsKKworICAgIFZlY3RvcjxUaWxlQ29v cmRpbmF0ZT4gdG9SZW1vdmU7CisgICAgVGlsZU1hcDo6aXRlcmF0b3IgZW5kID0gbV90aWxlcy5l bmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0gbV90aWxlcy5iZWdpbigpOyBp dCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgVGlsZUNvb3JkaW5hdGUgY29vcmRpbmF0ZSA9IGl0 LT5zZWNvbmQtPmNvb3JkaW5hdGUoKTsKKyAgICAgICAgRmxvYXRSZWN0IHRpbGVSZWN0ID0gaXQt PnNlY29uZC0+cmVjdCgpOworICAgICAgICBpZiAoIXRpbGVSZWN0LmludGVyc2VjdHMoa2VlcFJl Y3RGKSkKKyAgICAgICAgICAgIHRvUmVtb3ZlLmFwcGVuZChjb29yZGluYXRlKTsKKyAgICB9Cisg ICAgdW5zaWduZWQgcmVtb3ZlQ291bnQgPSB0b1JlbW92ZS5zaXplKCk7CisgICAgZm9yICh1bnNp Z25lZCBuID0gMDsgbiA8IHJlbW92ZUNvdW50OyArK24pCisgICAgICAgIHJlbW92ZVRpbGUodG9S ZW1vdmVbbl0pOworfQorCitQYXNzUmVmUHRyPFRpbGU+IFRpbGVkQmFja2luZ1N0b3JlOjp0aWxl KGNvbnN0IFRpbGVDb29yZGluYXRlJiBjb29yZGluYXRlKSBjb25zdAoreworICAgIHJldHVybiBt X3RpbGVzLmdldChjb29yZGluYXRlLmhhc2goKSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3Rv cmU6OnNldFRpbGUoY29uc3QgVGlsZUNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NSZWZQdHI8 VGlsZT4gdGlsZSkKK3sKKyAgICBtX3RpbGVzLnNldChjb29yZGluYXRlLmhhc2goKSwgdGlsZSk7 Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnJlbW92ZVRpbGUoY29uc3QgVGlsZUNvb3Jk aW5hdGUmIGNvb3JkaW5hdGUpCit7CisgICAgbV90aWxlcy5yZW1vdmUoY29vcmRpbmF0ZS5oYXNo KCkpOworfQorCitJbnRSZWN0IFRpbGVkQmFja2luZ1N0b3JlOjpyZWN0VG9Eb2N1bWVudChjb25z dCBJbnRSZWN0JiByZWN0KSBjb25zdAoreworICAgIHJldHVybiBlbmNsb3NpbmdJbnRSZWN0KEZs b2F0UmVjdChyZWN0LngoKSAvIG1fc2NhbGUsCisgICAgICAgICAgICAgICAgICAgcmVjdC55KCkg LyBtX3NjYWxlLAorICAgICAgICAgICAgICAgICAgIHJlY3Qud2lkdGgoKSAvIG1fc2NhbGUsCisg ICAgICAgICAgICAgICAgICAgcmVjdC5oZWlnaHQoKSAvIG1fc2NhbGUpKTsKK30KKworSW50UmVj dCBUaWxlZEJhY2tpbmdTdG9yZTo6cmVjdEZyb21Eb2N1bWVudChjb25zdCBJbnRSZWN0JiByZWN0 KSBjb25zdAoreworICAgIHJldHVybiBlbmNsb3NpbmdJbnRSZWN0KEZsb2F0UmVjdChyZWN0Lngo KSAqIG1fc2NhbGUsCisgICAgICAgICAgICAgICAgICAgICByZWN0LnkoKSAqIG1fc2NhbGUsCisg ICAgICAgICAgICAgICAgICAgICByZWN0LndpZHRoKCkgKiBtX3NjYWxlLAorICAgICAgICAgICAg ICAgICAgICAgcmVjdC5oZWlnaHQoKSAqIG1fc2NhbGUpKTsKK30KKworSW50UmVjdCBUaWxlZEJh Y2tpbmdTdG9yZTo6Y29udGVudFJlY3QoKSBjb25zdAoreworICAgIHJldHVybiByZWN0RnJvbURv Y3VtZW50KG1fY2xpZW50LT50aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRSZWN0KCkpOworfQorCitJ bnRSZWN0IFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlUmVjdEZvckNvb3JkaW5hdGUoY29uc3QgVGls ZUNvb3JkaW5hdGUmIGNvb3JkaW5hdGUpIGNvbnN0Cit7CisgICAgSW50UmVjdCByZWN0KGNvb3Jk aW5hdGUueCgpICogbV90aWxlU2l6ZS53aWR0aCgpLAorICAgICAgICAgICAgICAgICBjb29yZGlu YXRlLnkoKSAqIG1fdGlsZVNpemUuaGVpZ2h0KCksCisgICAgICAgICAgICAgICAgIG1fdGlsZVNp emUud2lkdGgoKSwKKyAgICAgICAgICAgICAgICAgbV90aWxlU2l6ZS5oZWlnaHQoKSk7CisKKyAg ICByZWN0LmludGVyc2VjdChjb250ZW50UmVjdCgpKTsKKyAgICByZXR1cm4gcmVjdDsKK30KKyAg ICAKK1RpbGVkQmFja2luZ1N0b3JlOjpUaWxlQ29vcmRpbmF0ZSBUaWxlZEJhY2tpbmdTdG9yZTo6 dGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb25zdCBJbnRQb2ludCYgcG9pbnQpIGNvbnN0Cit7Cisg ICAgaW50IHggPSBwb2ludC54KCkgLyBtX3RpbGVTaXplLndpZHRoKCk7CisgICAgaW50IHkgPSBw b2ludC55KCkgLyBtX3RpbGVTaXplLmhlaWdodCgpOworICAgIHJldHVybiBUaWxlQ29vcmRpbmF0 ZShzdGQ6Om1heCh4LCAwKSwgc3RkOjptYXgoeSwgMCkpOworfQorCisKK3ZvaWQgVGlsZWRCYWNr aW5nU3RvcmU6OnN0YXJ0VGlsZVVwZGF0ZVRpbWVyKCkKK3sKKyAgICBpZiAoIW1fdGlsZVVwZGF0 ZVRpbWVyLT5pc0FjdGl2ZSgpICYmIG1fc3RhdGUgPT0gU3RhdGVOb3JtYWwpCisgICAgICAgIG1f dGlsZVVwZGF0ZVRpbWVyLT5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5n U3RvcmU6OnRpbGVVcGRhdGVUaW1lckZpcmVkKCkKK3sKKyAgICB1cGRhdGVUaWxlcygpOworfQor Cit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzdGFydFRpbGVDcmVhdGlvblRpbWVyKCkKK3sKKyAg ICBpZiAoIW1fdGlsZUNyZWF0aW9uVGltZXItPmlzQWN0aXZlKCkgJiYgbV9zdGF0ZSA9PSBTdGF0 ZU5vcm1hbCkKKyAgICAgICAgbV90aWxlQ3JlYXRpb25UaW1lci0+c3RhcnRPbmVTaG90KDApOwor fQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3JlYXRpb25UaW1lckZpcmVkKCkKK3sK KyAgICBjcmVhdGVUaWxlcygpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzZXRTdGF0 ZShTdGF0ZSBzdGF0ZSkKK3sKKyAgICBpZiAobV9zdGF0ZSA9PSBzdGF0ZSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgbV9zdGF0ZSA9IHN0YXRlOworCisgICAgLy8gUmVzdGFydCB0aGUgdGltZXJz LiBUaGVyZSBtaWdodCBiZSBwZW5kaW5nIGludmFsaWRhdGlvbnMgdGhhdAorICAgIC8vIHdlcmUg bm90IHBhaW50ZWQgb3IgY3JlYXRlZCBiZWNhdXNlIHRpbGVzIGFyZSBub3QgY3JlYXRlZCBvcgor ICAgIC8vIHBhaW50aWVkIHdoZW4gaW4gU3RhdGVOb1RpbGVDcmVhdGlvbgorICAgIGlmIChtX3N0 YXRlID09IFN0YXRlTm9ybWFsKSB7CisgICAgICAgIHN0YXJ0VGlsZUNyZWF0aW9uVGltZXIoKTsK KyAgICAgICAgc3RhcnRUaWxlVXBkYXRlVGltZXIoKTsKKyAgICB9CisgICAgLy8gc3RvcHBpbmcg aXMgaGFuZGxlZCB3aGVuIHRoZSB0aW1lcnMgZmlyZQorfQorCit9CisKKyNpbmNsdWRlICJUaWxl ZEJhY2tpbmdTdG9yZVF0Lm1vYyIKSW5kZXg6IFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmll dy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xZ3JhcGhpY3N3ZWJ2aWV3LmNwcAko cmV2aXNpb24gNTQ3NzQpCisrKyBXZWJLaXQvcXQvQXBpL3FncmFwaGljc3dlYnZpZXcuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0yNiw3ICsyNiwxMCBAQAogI2luY2x1ZGUgInF3ZWJwYWdlLmgiCiAj aW5jbHVkZSAicXdlYnBhZ2VfcC5oIgogI2luY2x1ZGUgIlFXZWJQYWdlQ2xpZW50LmgiCi0jaW5j bHVkZSA8RnJhbWVWaWV3Lmg+CisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiR3Jh cGhpY3NDb250ZXh0LmgiCisjaW5jbHVkZSAiSW50UmVjdC5oIgorI2luY2x1ZGUgIlRpbGVkQmFj a2luZ1N0b3JlLmgiCiAjaW5jbHVkZSA8UXRDb3JlL3FtZXRhb2JqZWN0Lmg+CiAjaW5jbHVkZSA8 UXRDb3JlL3FzaGFyZWRwb2ludGVyLmg+CiAjaW5jbHVkZSA8UXRDb3JlL3F0aW1lci5oPgpAQCAt MzUsNiArMzgsNyBAQAogI2luY2x1ZGUgPFF0R3VpL3FncmFwaGljc3NjZW5lZXZlbnQuaD4KICNp bmNsdWRlIDxRdEd1aS9xZ3JhcGhpY3N2aWV3Lmg+CiAjaW5jbHVkZSA8UXRHdWkvcXBpeG1hcGNh Y2hlLmg+CisjaW5jbHVkZSA8UXRHdWkvcXNjcm9sbGJhci5oPgogI2luY2x1ZGUgPFF0R3VpL3Fz dHlsZW9wdGlvbi5oPgogI2lmIGRlZmluZWQoUV9XU19YMTEpCiAjaW5jbHVkZSA8UVgxMUluZm8+ CkBAIC0xMjAsNiArMTI0LDcgQEAgcHVibGljOgogI2VuZGlmCiAgICAgCiAgICAgdm9pZCB1cGRh dGVSZXNpemVzVG9Db250ZW50c0ZvclBhZ2UoKTsKKyAgICBRUmVjdEYgdmlzaWJsZVJlY3QoKSBj b25zdDsKIAogICAgIHZvaWQgc3luY0xheWVycygpOwogICAgIHZvaWQgX3FfZG9Mb2FkRmluaXNo ZWQoYm9vbCBzdWNjZXNzKTsKQEAgLTMzNSw2ICszNDAsMjMgQEAgdm9pZCBRR3JhcGhpY3NXZWJW aWV3UHJpdmF0ZTo6X3FfY29udGVudAogICAgIHEtPnNldEdlb21ldHJ5KFFSZWN0RihxLT5nZW9t ZXRyeSgpLnRvcExlZnQoKSwgc2l6ZSkpOwogfQogCitRUmVjdEYgUUdyYXBoaWNzV2ViVmlld1By aXZhdGU6OnZpc2libGVSZWN0KCkgY29uc3QKK3sKKyAgICBpZiAoIXEtPnNjZW5lKCkpCisgICAg ICAgIHJldHVybiBRUmVjdEYoKTsKKyAgICBRTGlzdDxRR3JhcGhpY3NWaWV3Kj4gdmlld3MgPSBx LT5zY2VuZSgpLT52aWV3cygpOworICAgIGlmICh2aWV3cy5zaXplKCkgPiAxKSB7CisgICAgICAg IHFEZWJ1ZygpIDw8ICJRR3JhcGhpY3NXZWJWaWV3IGlzIGluIG1vcmUgdGhhbiBvbmUgZ3JhcGhp Y3Mgdmlld3MsIHVuYWJsZSB0byBjb21wdXRlIHRoZSB2aXNpYmxlIHJlY3QiOworICAgICAgICBy ZXR1cm4gUVJlY3RGKCk7CisgICAgfQorICAgIGlmICh2aWV3cy5zaXplKCkgPCAxKQorICAgICAg ICByZXR1cm4gUVJlY3RGKCk7CisKKyAgICBpbnQgaCA9IHZpZXdzWzBdLT5ob3Jpem9udGFsU2Ny b2xsQmFyKCktPnZhbHVlKCk7CisgICAgaW50IHYgPSB2aWV3c1swXS0+dmVydGljYWxTY3JvbGxC YXIoKS0+dmFsdWUoKTsKKyAgICByZXR1cm4gcS0+bWFwUmVjdEZyb21TY2VuZShRUmVjdEYoUVBv aW50KGgsIHYpLCB2aWV3c1swXS0+dmlld3BvcnQoKS0+c2l6ZSgpKSk7Cit9CisKIC8qIQogICAg IFxjbGFzcyBRR3JhcGhpY3NXZWJWaWV3CiAgICAgXGJyaWVmIFRoZSBRR3JhcGhpY3NXZWJWaWV3 IGNsYXNzIGFsbG93cyBXZWIgY29udGVudCB0byBiZSBhZGRlZCB0byBhIEdyYXBoaWNzVmlldy4K QEAgLTQyOCw2ICs0NTAsNyBAQCBRR3JhcGhpY3NXZWJWaWV3OjpRR3JhcGhpY3NXZWJWaWV3KFFH cmFwCiAjZW5kaWYKICAgICBzZXRGb2N1c1BvbGljeShRdDo6U3Ryb25nRm9jdXMpOwogICAgIHNl dEZsYWcoUUdyYXBoaWNzSXRlbTo6SXRlbUNsaXBzQ2hpbGRyZW5Ub1NoYXBlLCB0cnVlKTsKKyAg ICBzZXRGbGFnKFFHcmFwaGljc0l0ZW06Okl0ZW1TZW5kc0dlb21ldHJ5Q2hhbmdlcywgdHJ1ZSk7 CiB9CiAKIC8qIQpAQCAtNDc3LDExICs1MDAsMjAgQEAgUVdlYlBhZ2UqIFFHcmFwaGljc1dlYlZp ZXc6OnBhZ2UoKSBjb25zdAogKi8KIHZvaWQgUUdyYXBoaWNzV2ViVmlldzo6cGFpbnQoUVBhaW50 ZXIqIHBhaW50ZXIsIGNvbnN0IFFTdHlsZU9wdGlvbkdyYXBoaWNzSXRlbSogb3B0aW9uLCBRV2lk Z2V0KikKIHsKKyAgICAvLyBGSVhNRTogU2Nyb2xsYmFycyBjb3VsZCBiZSBkcmF3biB3aXRoIHRo ZSBvdmVybGF5IGxheWVyIHdoZW4gdXNpbmcgdGlsaW5nLgorICAgIFdlYkNvcmU6OlRpbGVkQmFj a2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBRV2ViRnJhbWVQcml2YXRlOjpjb3JlKHBhZ2UoKS0+ bWFpbkZyYW1lKCkpLT50aWxlZEJhY2tpbmdTdG9yZSgpOzsKKyAgICBpZiAoYmFja2luZ1N0b3Jl KSB7CisgICAgICAgIGJhY2tpbmdTdG9yZS0+dmlld3BvcnRDaGFuZ2VkKFdlYkNvcmU6OkludFJl Y3QoZC0+dmlzaWJsZVJlY3QoKSkpOworICAgICAgICAvLyBRV2ViRnJhbWU6OnJlbmRlciBpcyBh IHB1YmxpYyBBUEksIGJ5cGFzcyBpdCBmb3IgdGlsZWQgcmVuZGVyaW5nIHNvIGJlaGF2aW9yIGRv ZXMgbm90IG5lZWQgdG8gY2hhbmdlLgorICAgICAgICBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQg Y29udGV4dChwYWludGVyKTsgCisgICAgICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPmQtPnJlbmRl ckNvbnRlbnRzTGF5ZXJBYnNvbHV0ZUNvb3JkcygmY29udGV4dCwgb3B0aW9uLT5leHBvc2VkUmVj dC50b0FsaWduZWRSZWN0KCkpOworICAgIH0gZWxzZSB7CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NP TVBPU0lUSU5HKQotICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPnJlbmRlcihwYWludGVyLCBkLT5v dmVybGF5ID8gUVdlYkZyYW1lOjpDb250ZW50c0xheWVyIDogUVdlYkZyYW1lOjpBbGxMYXllcnMs IG9wdGlvbi0+ZXhwb3NlZFJlY3QudG9BbGlnbmVkUmVjdCgpKTsKKyAgICAgICAgcGFnZSgpLT5t YWluRnJhbWUoKS0+cmVuZGVyKHBhaW50ZXIsIGQtPm92ZXJsYXkgPyBRV2ViRnJhbWU6OkNvbnRl bnRzTGF5ZXIgOiBRV2ViRnJhbWU6OkFsbExheWVycywgb3B0aW9uLT5leHBvc2VkUmVjdC50b0Fs aWduZWRSZWN0KCkpOwogI2Vsc2UKLSAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5yZW5kZXIocGFp bnRlciwgUVdlYkZyYW1lOjpBbGxMYXllcnMsIG9wdGlvbi0+ZXhwb3NlZFJlY3QudG9SZWN0KCkp OworICAgICAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5yZW5kZXIocGFpbnRlciwgUVdlYkZyYW1l OjpBbGxMYXllcnMsIG9wdGlvbi0+ZXhwb3NlZFJlY3QudG9SZWN0KCkpOwogI2VuZGlmCisgICAg fQogfQogCiAvKiEgXHJlaW1wCkBAIC01MTYsMTAgKzU0OCwxNSBAQCBRVmFyaWFudCBRR3JhcGhp Y3NXZWJWaWV3OjppdGVtQ2hhbmdlKEdyCiAgICAgLy8gZmlyZSAnQ3Vyc29yQ2hhbmdlJy4KICAg ICBjYXNlIEl0ZW1DdXJzb3JDaGFuZ2U6CiAgICAgICAgIHJldHVybiB2YWx1ZTsKLSAgICBjYXNl IEl0ZW1DdXJzb3JIYXNDaGFuZ2VkOgotICAgICAgICBRRXZlbnQgZXZlbnQoUUV2ZW50OjpDdXJz b3JDaGFuZ2UpOwotICAgICAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCh0aGlzLCAmZXZlbnQp OwotICAgICAgICByZXR1cm4gdmFsdWU7CisgICAgY2FzZSBJdGVtQ3Vyc29ySGFzQ2hhbmdlZDog eworICAgICAgICAgICAgUUV2ZW50IGV2ZW50KFFFdmVudDo6Q3Vyc29yQ2hhbmdlKTsKKyAgICAg ICAgICAgIFFBcHBsaWNhdGlvbjo6c2VuZEV2ZW50KHRoaXMsICZldmVudCk7CisgICAgICAgICAg ICByZXR1cm4gdmFsdWU7CisgICAgICAgIH0KKyAgICBjYXNlIEl0ZW1Qb3NpdGlvbkhhc0NoYW5n ZWQ6CisgICAgY2FzZSBJdGVtVHJhbnNmb3JtSGFzQ2hhbmdlZDoKKyAgICAgICAgaWYgKFdlYkNv cmU6OlRpbGVkQmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBRV2ViRnJhbWVQcml2YXRlOjpj b3JlKHBhZ2UoKS0+bWFpbkZyYW1lKCkpLT50aWxlZEJhY2tpbmdTdG9yZSgpKQorICAgICAgICAg ICAgYmFja2luZ1N0b3JlLT52aWV3cG9ydENoYW5nZWQoV2ViQ29yZTo6SW50UmVjdChkLT52aXNp YmxlUmVjdCgpKSk7CiAgICAgfQogCiAgICAgcmV0dXJuIFFHcmFwaGljc1dpZGdldDo6aXRlbUNo YW5nZShjaGFuZ2UsIHZhbHVlKTsKQEAgLTczMiw2ICs3NjksOSBAQCB2b2lkIFFHcmFwaGljc1dl YlZpZXc6OnVwZGF0ZUdlb21ldHJ5KCkKIAogICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNp emUoKS50b1NpemUoKTsKICAgICBkLT5wYWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7CisgICAg CisgICAgaWYgKFdlYkNvcmU6OlRpbGVkQmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBRV2Vi RnJhbWVQcml2YXRlOjpjb3JlKHBhZ2UoKS0+bWFpbkZyYW1lKCkpLT50aWxlZEJhY2tpbmdTdG9y ZSgpKQorICAgICAgICBiYWNraW5nU3RvcmUtPnZpZXdwb3J0Q2hhbmdlZChXZWJDb3JlOjpJbnRS ZWN0KGQtPnZpc2libGVSZWN0KCkpKTsKIH0KIAogLyohIFxyZWltcApAQCAtNzUyLDYgKzc5Miw5 IEBAIHZvaWQgUUdyYXBoaWNzV2ViVmlldzo6c2V0R2VvbWV0cnkoY29uc3QKICAgICAvLyB0aGUg Z2VvbWV0cnkgaXMgd2l0aGluIGxlZ2FsIGJvdW5kcyAobWluaW11bVNpemUsIG1heGltdW1TaXpl KQogICAgIFFTaXplIHNpemUgPSBnZW9tZXRyeSgpLnNpemUoKS50b1NpemUoKTsKICAgICBkLT5w YWdlLT5zZXRWaWV3cG9ydFNpemUoc2l6ZSk7CisgICAgCisgICAgaWYgKFdlYkNvcmU6OlRpbGVk QmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBRV2ViRnJhbWVQcml2YXRlOjpjb3JlKHBhZ2Uo KS0+bWFpbkZyYW1lKCkpLT50aWxlZEJhY2tpbmdTdG9yZSgpKQorICAgICAgICBiYWNraW5nU3Rv cmUtPnZpZXdwb3J0Q2hhbmdlZChXZWJDb3JlOjpJbnRSZWN0KGQtPnZpc2libGVSZWN0KCkpKTsK IH0KIAogLyohCkBAIC05ODAsNiArMTAyMywyNyBAQCBib29sIFFHcmFwaGljc1dlYlZpZXc6OnJl c2l6ZXNUb0NvbnRlbnRzCiAgICAgcmV0dXJuIGQtPnJlc2l6ZXNUb0NvbnRlbnRzOwogfQogCitm bG9hdCBRR3JhcGhpY3NXZWJWaWV3Ojp0aWxlZEJhY2tpbmdTdG9yZVNjYWxlRmFjdG9yKCkgY29u c3QKK3sKKyAgICBpZiAoIXBhZ2UoKSkKKyAgICAgICAgcmV0dXJuIDEuZjsKKyAgICBXZWJDb3Jl OjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29y ZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5nU3RvcmUoKTsKKyAgICBpZiAoIWJh Y2tpbmdTdG9yZSkKKyAgICAgICAgcmV0dXJuIDEuZjsKKyAgICByZXR1cm4gYmFja2luZ1N0b3Jl LT5zY2FsZSgpOworfQorCit2b2lkIFFHcmFwaGljc1dlYlZpZXc6OnNldFRpbGVkQmFja2luZ1N0 b3JlU2NhbGVGYWN0b3IoZmxvYXQgc2NhbGVGYWN0b3IpCit7CisgICAgLy8gRklYTUU6IHNob3Vs ZCBwcm9iYWJseSBhbGxvdyBzZXR0aW5nIHRoZSBzY2FsZSBpbmRlcGVuZGVudCBvZiBhbHJlYWR5 IGhhdmluZyB0aGUgYmFja2luZyBzdG9yZQorICAgIGlmICghcGFnZSgpKQorICAgICAgICByZXR1 cm47CisgICAgV2ViQ29yZTo6VGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSA9IFFXZWJG cmFtZVByaXZhdGU6OmNvcmUocGFnZSgpLT5tYWluRnJhbWUoKSktPnRpbGVkQmFja2luZ1N0b3Jl KCk7CisgICAgaWYgKCFiYWNraW5nU3RvcmUpCisgICAgICAgIHJldHVybjsKKyAgICBiYWNraW5n U3RvcmUtPnNldFNjYWxlKHNjYWxlRmFjdG9yKTsKK30KKwogLyohIFxyZWltcAogKi8KIHZvaWQg UUdyYXBoaWNzV2ViVmlldzo6aG92ZXJNb3ZlRXZlbnQoUUdyYXBoaWNzU2NlbmVIb3ZlckV2ZW50 KiBldikKSW5kZXg6IFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCShyZXZpc2lvbiA1NDc3NCkKKysr IFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCSh3b3JraW5nIGNvcHkpCkBAIC04Miw2 ICs4Miw5IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgcmVzaXplc1RvQ29udGVudHMoKSBjb25zdDsK ICAgICB2b2lkIHNldFJlc2l6ZXNUb0NvbnRlbnRzKGJvb2wgZW5hYmxlZCk7CisgICAgCisgICAg ZmxvYXQgdGlsZWRCYWNraW5nU3RvcmVTY2FsZUZhY3RvcigpIGNvbnN0OworICAgIHZvaWQgc2V0 VGlsZWRCYWNraW5nU3RvcmVTY2FsZUZhY3RvcihmbG9hdCBzY2FsZUZhY3Rvcik7CiAKICAgICB2 aXJ0dWFsIHZvaWQgc2V0R2VvbWV0cnkoY29uc3QgUVJlY3RGJiByZWN0KTsKICAgICB2aXJ0dWFs IHZvaWQgdXBkYXRlR2VvbWV0cnkoKTsKSW5kZXg6IFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAJKHJldmlzaW9uIDU0 Nzc0KQorKysgV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0z MDgsNyArMzA4LDkgQEAgdm9pZCBRV2ViRnJhbWVQcml2YXRlOjpyZW5kZXJDb250ZW50c0xheQog ICAgIFFQYWludGVyKiBwYWludGVyID0gY29udGV4dC0+cGxhdGZvcm1Db250ZXh0KCk7CiAKICAg ICBXZWJDb3JlOjpGcmFtZVZpZXcqIHZpZXcgPSBmcmFtZS0+dmlldygpOwotICAgIHZpZXctPmxh eW91dElmTmVlZGVkUmVjdXJzaXZlKCk7CisgICAgCisgICAgaWYgKCFmcmFtZS0+dGlsZWRCYWNr aW5nU3RvcmUoKSkKKyAgICAgICAgdmlldy0+bGF5b3V0SWZOZWVkZWRSZWN1cnNpdmUoKTsKIAog ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgdmVjdG9yLnNpemUoKTsgKytpKSB7CiAgICAgICAgIGNv bnN0IFFSZWN0JiBjbGlwUmVjdCA9IHZlY3Rvci5hdChpKTsKQEAgLTMxNyw3ICszMTksMTAgQEAg dm9pZCBRV2ViRnJhbWVQcml2YXRlOjpyZW5kZXJDb250ZW50c0xheQogICAgICAgICBwYWludGVy LT5zZXRDbGlwUmVjdChjbGlwUmVjdCwgUXQ6OkludGVyc2VjdENsaXApOwogCiAgICAgICAgIGNv bnRleHQtPnNhdmUoKTsKLSAgICAgICAgdmlldy0+cGFpbnRDb250ZW50cyhjb250ZXh0LCBjbGlw UmVjdCk7CisgICAgICAgIGlmIChmcmFtZS0+dGlsZWRCYWNraW5nU3RvcmUoKSkKKyAgICAgICAg ICAgIGZyYW1lLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5wYWludChjb250ZXh0LCBjbGlwUmVjdCk7 CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHZpZXctPnBhaW50Q29udGVudHMoY29udGV4dCwg Y2xpcFJlY3QpOwogICAgICAgICBjb250ZXh0LT5yZXN0b3JlKCk7CiAKICAgICAgICAgcGFpbnRl ci0+cmVzdG9yZSgpOwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCShyZXZpc2lvbiA1NDc3NCkKKysrIFdlYktp dC9xdC9BcGkvcXdlYmZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTIxOCw2ICsyMTgsNyBAQCBR X1NJR05BTFM6CiAgICAgdm9pZCBsb2FkRmluaXNoZWQoYm9vbCBvayk7CiAKIHByaXZhdGU6Cisg ICAgZnJpZW5kIGNsYXNzIFFHcmFwaGljc1dlYlZpZXc7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJQ YWdlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViUGFnZVByaXZhdGU7CiAgICAgZnJpZW5kIGNsYXNz IFFXZWJGcmFtZVByaXZhdGU7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCShyZXZpc2lvbiA1 NDc3NCkKKysrIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAkod29ya2luZyBjb3B5KQpA QCAtMjE4LDYgKzIxOCwxMCBAQCB2b2lkIFFXZWJTZXR0aW5nc1ByaXZhdGU6OmFwcGx5KCkKICAg ICAgICAgdmFsdWUgPSBhdHRyaWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5nczo6WFNTQXVkaXRvckVu YWJsZWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsb2JhbC0+YXR0 cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlhTU0F1ZGl0b3JFbmFibGVkKSk7CiAgICAgICAg IHNldHRpbmdzLT5zZXRYU1NBdWRpdG9yRW5hYmxlZCh2YWx1ZSk7CisgICAgICAgIAorICAgICAg ICB2YWx1ZSA9IGF0dHJpYnV0ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9y ZUVuYWJsZWQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsb2JhbC0+ YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCkp OworICAgICAgICBzZXR0aW5ncy0+c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKHZhbHVlKTsK IAogICAgICAgICBzZXR0aW5ncy0+c2V0VXNlc1BhZ2VDYWNoZShXZWJDb3JlOjpwYWdlQ2FjaGUo KS0+Y2FwYWNpdHkoKSk7CiAgICAgfSBlbHNlIHsKSW5kZXg6IFdlYktpdC9xdC9BcGkvcXdlYnNl dHRpbmdzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAkocmV2 aXNpb24gNTQ3NzQpCisrKyBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5oCSh3b3JraW5nIGNv cHkpCkBAIC02OSw3ICs2OSw4IEBAIHB1YmxpYzoKICAgICAgICAgTG9jYWxDb250ZW50Q2FuQWNj ZXNzUmVtb3RlVXJscywKICAgICAgICAgRG5zUHJlZmV0Y2hFbmFibGVkLAogICAgICAgICBYU1NB dWRpdG9yRW5hYmxlZCwKLSAgICAgICAgQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQKKyAg ICAgICAgQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQsCisgICAgICAgIFRpbGVkQmFja2lu Z1N0b3JlRW5hYmxlZAogICAgIH07CiAgICAgZW51bSBXZWJHcmFwaGljIHsKICAgICAgICAgTWlz c2luZ0ltYWdlR3JhcGhpYywKSW5kZXg6IFdlYktpdC9xdC9RR1ZMYXVuY2hlci9tYWluLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAJKHJldmlzaW9uIDU0 Nzc0KQorKysgV2ViS2l0L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC01MDAsNyArNTAwLDcgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQogewogICAg IFFBcHBsaWNhdGlvbiBhcHAoYXJnYywgYXJndik7CiAgICAgaWYgKGFwcC5hcmd1bWVudHMoKS5j b250YWlucygiLS1oZWxwIikpIHsKLSAgICAgICAgcURlYnVnKCkgPDwgIlVzYWdlOiBRR1ZMYXVu Y2hlciBbLS11cmwgdXJsXSBbLS1jb21wb3NpdGluZ10gWy0tdXBkYXRlTW9kZSBGdWxsfE1pbmlt YWx8U21hcnR8Tm98Qm91bmRpbmdSZWN0XSBbLS1jYWNoZVdlYlZpZXddIFstLXJlc2l6ZXNUb0Nv bnRlbnRzXVxuIjsKKyAgICAgICAgcURlYnVnKCkgPDwgIlVzYWdlOiBRR1ZMYXVuY2hlciBbLS11 cmwgdXJsXSBbLS1jb21wb3NpdGluZ10gWy0tdXBkYXRlTW9kZSBGdWxsfE1pbmltYWx8U21hcnR8 Tm98Qm91bmRpbmdSZWN0XSBbLS1jYWNoZVdlYlZpZXddIFstLXJlc2l6ZXNUb0NvbnRlbnRzXSBb LS10aWxlZEJhY2tpbmdTdG9yZV1cbiI7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KICAgICBR U3RyaW5nIHVybCA9IFFTdHJpbmcoImZpbGU6Ly8lMS8lMiIpLmFyZyhRRGlyOjpob21lUGF0aCgp KS5hcmcoUUxhdGluMVN0cmluZygiaW5kZXguaHRtbCIpKTsKQEAgLTUyMSw2ICs1MjEsMTEgQEAg aW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQogICAgICAgICB1cmwgPSBhcmdzLmF0KDEp OwogICAgIGlmIChhcmdzLmNvbnRhaW5zKCItLWNvbXBvc2l0aW5nIikpCiAgICAgICAgIFFXZWJT ZXR0aW5nczo6Z2xvYmFsU2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6QWNj ZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQsIHRydWUpOworICAgIGlmIChhcmdzLmNvbnRhaW5z KCItLXRpbGVkQmFja2luZ1N0b3JlIikpIHsKKyAgICAgICAgaWYgKCFhcmdzLmNvbnRhaW5zKCIt LXJlc2l6ZXNUb0NvbnRlbnRzIikpCisgICAgICAgICAgICBxRGVidWcoKSA8PCAiV2FybmluZzog YXQgdGhlIG1vbWVudCAtLXRpbGVkQmFja2luZ1N0b3JlIHNob3VsZCBhbHdheXMgYmUgdXNlZCB0 b2dldGhlciB3aXRoIC0tcmVzaXplc1RvQ29udGVudHMiOworICAgICAgICBRV2ViU2V0dGluZ3M6 Omdsb2JhbFNldHRpbmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OlRpbGVkQmFja2lu Z1N0b3JlRW5hYmxlZCwgdHJ1ZSk7CisgICAgfQogCiAgICAgTWFpbldpbmRvdyogd2luZG93ID0g bmV3IE1haW5XaW5kb3c7CiAgICAgd2luZG93LT5sb2FkKHVybCk7Cg== 49491 2010-02-25 08:26:12 -0800 2010-02-26 06:07:16 -0800 updated patch tiled-backing-store-6.patch text/plain 46703 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC04MDgsNiArODA4LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGxhdGZvcm0vZ3JhcGhp Y3MvUGVuLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU2VnbWVudGVkRm9udERhdGEuY3Bw IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5jcHAgXAorICAgIHBsYXRm b3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhp Y3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGlj cy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcCBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9NYXRyaXhUcmFuc2Zvcm1PcGVyYXRpb24uY3BwIFwKQEAgLTE1MTMs NiArMTUxNCw5IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3F0L1N0aWxs SW1hZ2VRdC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TZWdtZW50ZWRGb250RGF0YS5oIFwK ICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5oIFwKKyAgICBwbGF0Zm9ybS9n cmFwaGljcy9UaWxlLmggXAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3Jl LmggXCAgICAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZUNsaWVudC5o IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL01hdHJpeDNEVHJhbnNmb3JtT3Bl cmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvTWF0cml4VHJhbnNm b3JtT3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvUGVyc3Bl Y3RpdmVUcmFuc2Zvcm1PcGVyYXRpb24uaCBcCkBAIC0yMDA1LDYgKzIwMDksNyBAQCBTT1VSQ0VT ICs9IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9Gb250Q3VzdG9tUGxhdGZvcm1EYXRhUXQu Y3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HbHlwaFBhZ2VUcmVlTm9kZVF0LmNwcCBc CiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvcXQvU2ltcGxlRm9udERhdGFRdC5jcHAgXAorICAgIHBs YXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0tVUkxRdC5j cHAgXAogICAgIHBsYXRmb3JtL3F0L0xvY2FsaXphdGlvbnMuY3BwIFwKICAgICBwbGF0Zm9ybS9x dC9NSU1FVHlwZVJlZ2lzdHJ5UXQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNTQ3NzQpCisr KyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3IEBA CiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNpbmNs dWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUu aCIKICNpbmNsdWRlICJVc2VyQ29udGVudFVSTFBhdHRlcm4uaCIKICNpbmNsdWRlICJYTUxOU05h bWVzLmgiCiAjaW5jbHVkZSAiWE1MTmFtZXMuaCIKQEAgLTE3MSw5ICsxNzIsMTEgQEAgRnJhbWU6 OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRQogICAgIFhNTE5TTmFtZXM6OmluaXQo KTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwogCi0gICAgaWYgKCFvd25lckVsZW1lbnQpCisgICAg aWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAgICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMpOwot ICAgIGVsc2UgeworICAgICAgICAvLyBUb3AgbGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAg ICAgICBzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRC YWNraW5nU3RvcmVFbmFibGVkKCkpOworICAgIH0gZWxzZSB7CiAgICAgICAgIHBhZ2UtPmluY3Jl bWVudEZyYW1lQ291bnQoKTsKICAgICAgICAgLy8gTWFrZSBzdXJlIHdlIHdpbGwgbm90IGVuZCB1 cCB3aXRoIHR3byBmcmFtZXMgcmVmZXJlbmNpbmcgdGhlIHNhbWUgb3duZXIgZWxlbWVudC4KICAg ICAgICAgQVNTRVJUKCghKG93bmVyRWxlbWVudC0+bV9jb250ZW50RnJhbWUpKSB8fCAob3duZXJF bGVtZW50LT5tX2NvbnRlbnRGcmFtZS0+b3duZXJFbGVtZW50KCkgIT0gb3duZXJFbGVtZW50KSk7 CkBAIC0xODA4LDQgKzE4MTEsNDcgQEAgdm9pZCBGcmFtZTo6Y3JlYXRlVmlldyhjb25zdCBJbnRT aXplJiB2aQogICAgICAgICB2aWV3KCktPnNldENhbkhhdmVTY3JvbGxiYXJzKG93bmVyLT5zY3Jv bGxpbmdNb2RlKCkgIT0gU2Nyb2xsYmFyQWx3YXlzT2ZmKTsKIH0KIAordm9pZCBGcmFtZTo6c2V0 VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wgZW5hYmxlZCkKK3sKKyAgICBpZiAoIWVuYWJs ZWQpIHsKKyAgICAgICAgbV90aWxlZEJhY2tpbmdTdG9yZS5jbGVhcigpOworICAgICAgICByZXR1 cm47CisgICAgfQorICAgIGlmIChtX3RpbGVkQmFja2luZ1N0b3JlKQorICAgICAgICByZXR1cm47 CisgICAgbV90aWxlZEJhY2tpbmdTdG9yZS5zZXQobmV3IFRpbGVkQmFja2luZ1N0b3JlKHRoaXMp KTsKK30KKwordm9pZCBGcmFtZTo6dGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCkKK3sKKyAg ICBpZiAoIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIG1fdmlldy0+bGF5b3V0SWZOZWVk ZWRSZWN1cnNpdmUoKTsKKyAgICBtX3ZpZXctPmZsdXNoRGVmZXJyZWRSZXBhaW50cygpOworfQor Cit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCogY29u dGV4dCwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAoIW1fdmlldykKKyAgICAgICAg cmV0dXJuOworICAgIG1fdmlldy0+cGFpbnRDb250ZW50cyhjb250ZXh0LCByZWN0KTsKK30KKwor dm9pZCBGcmFtZTo6dGlsZWRCYWNraW5nU3RvcmVQYWludEVuZChjb25zdCBWZWN0b3I8SW50UmVj dD4mIHBhaW50ZWRBcmVhKQoreworICAgIGlmICghbV9wYWdlIHx8ICFtX3ZpZXcpCisgICAgICAg IHJldHVybjsKKyAgICB1bnNpZ25lZCBzaXplID0gcGFpbnRlZEFyZWEuc2l6ZSgpOworICAgIC8v IFJlcXVlc3QgcmVwYWludCBmcm9tIHRoZSBzeXN0ZW0KKyAgICBmb3IgKGludCBuID0gMDsgbiA8 IHNpemU7ICsrbikKKyAgICAgICAgbV9wYWdlLT5jaHJvbWUoKS0+cmVwYWludChtX3ZpZXctPmNv bnZlcnRUb0NvbnRhaW5pbmdXaW5kb3cocGFpbnRlZEFyZWFbbl0pLCB0cnVlKTsKK30KKworSW50 UmVjdCBGcmFtZTo6dGlsZWRCYWNraW5nU3RvcmVDb250ZW50c1JlY3QoKQoreworICAgIGlmICgh bV92aWV3KQorICAgICAgICByZXR1cm4gSW50UmVjdCgpOworICAgIHJldHVybiBJbnRSZWN0KElu dFBvaW50KCksIG1fdmlldy0+Y29udGVudHNTaXplKCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BhZ2UvRnJhbWUuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BhZ2UvRnJhbWUuaAkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJDb3JlL3BhZ2UvRnJhbWUuaAko d29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlNjcmlwdENvbnRyb2xs ZXIuaCIKICNpbmNsdWRlICJTY3JvbGxCZWhhdmlvci5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNv bnRyb2xsZXIuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZUNsaWVudC5oIgogI2luY2x1 ZGUgIlVzZXJTY3JpcHRUeXBlcy5oIgogCiAjaWYgUExBVEZPUk0oV0lOKQpAQCAtNjIsOCArNjMs OSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgQ1NTTXV0YWJsZVN0eWxlRGVjbGFy YXRpb247CiAgICAgY2xhc3MgSFRNTFRhYmxlQ2VsbEVsZW1lbnQ7CiAgICAgY2xhc3MgUmVndWxh ckV4cHJlc3Npb247CisgICAgY2xhc3MgVGlsZWRCYWNraW5nU3RvcmU7CiAKLSAgICBjbGFzcyBG cmFtZSA6IHB1YmxpYyBSZWZDb3VudGVkPEZyYW1lPiB7CisgICAgY2xhc3MgRnJhbWUgOiBwdWJs aWMgUmVmQ291bnRlZDxGcmFtZT4sIHB1YmxpYyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCB7CiAg ICAgcHVibGljOgogICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxGcmFtZT4gY3JlYXRlKFBhZ2Uq IHBhZ2UsIEhUTUxGcmFtZU93bmVyRWxlbWVudCogb3duZXJFbGVtZW50LCBGcmFtZUxvYWRlckNs aWVudCogY2xpZW50KQogICAgICAgICB7CkBAIC0xNjEsNiArMTYzLDkgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICAgICAgcmV0dXJuIGRvY3VtZW50KCkgPyBkb2N1bWVudCgpLT5kaXNw bGF5U3RyaW5nTW9kaWZpZWRCeUVuY29kaW5nKHN0cikgOiBzdHI7CiAgICAgICAgIH0KIAorICAg ICAgICBUaWxlZEJhY2tpbmdTdG9yZSogdGlsZWRCYWNraW5nU3RvcmUoKSBjb25zdCB7IHJldHVy biBtX3RpbGVkQmFja2luZ1N0b3JlLmdldCgpOyB9CisgICAgICAgIHZvaWQgc2V0VGlsZWRCYWNr aW5nU3RvcmVFbmFibGVkKGJvb2wpOworCiAgICAgcHJpdmF0ZToKICAgICAgICAgdm9pZCBsaWZl U3VwcG9ydFRpbWVyRmlyZWQoVGltZXI8RnJhbWU+Kik7CiAKQEAgLTI2Niw2ICsyNzEsMTMgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxlUG9z aXRpb25Gb3JQb2ludChjb25zdCBJbnRQb2ludCYgZnJhbWVQb2ludCk7CiAgICAgICAgIERvY3Vt ZW50KiBkb2N1bWVudEF0UG9pbnQoY29uc3QgSW50UG9pbnQmIHdpbmRvd1BvaW50KTsKKyAgICAg ICAgCisgICAgcHJpdmF0ZToKKyAgICAgICAgLy8gVGlsZWRCYWNraW5nU3RvcmVDbGllbnQgaW50 ZXJmYWNlCisgICAgICAgIHZpcnR1YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50QmVnaW4o KTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnQoR3JhcGhpY3ND b250ZXh0KiwgY29uc3QgSW50UmVjdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNr aW5nU3RvcmVQYWludEVuZChjb25zdCBWZWN0b3I8SW50UmVjdD4mIHBhaW50ZWRBcmVhKTsKKyAg ICAgICAgdmlydHVhbCBJbnRSZWN0IHRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNSZWN0KCk7CiAK ICAgICAjaWYgUExBVEZPUk0oTUFDKQogCkBAIC0yODYsNiArMjk4LDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogCiAgICAgcHJpdmF0ZToKICAgICAgICAgTlNJbWFnZSogaW1hZ2VGcm9tUmVjdChO U1JlY3QpIGNvbnN0OworICAgICAgICAKIAogICAgIC8vID09PSB0byBiZSBtb3ZlZCBpbnRvIEVk aXRvcgogCkBAIC0zNDQsNiArMzU3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBi b29sIG1fbmVlZHNSZWFwcGx5U3R5bGVzOwogICAgICAgICBib29sIG1faXNEaXNjb25uZWN0ZWQ7 CiAgICAgICAgIGJvb2wgbV9leGNsdWRlRnJvbVRleHRTZWFyY2g7CisgICAgICAgIAorICAgICAg ICBPd25QdHI8VGlsZWRCYWNraW5nU3RvcmU+IG1fdGlsZWRCYWNraW5nU3RvcmU7CiAgICAgfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHJldmlzaW9uIDU0 Nzc0KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU0 LDYgKzU0LDcgQEAKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiU2V0dGluZ3Mu aCIKICNpbmNsdWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNr aW5nU3RvcmUuaCIKICNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KIAogI2lmIFVTRShBQ0NF TEVSQVRFRF9DT01QT1NJVElORykKQEAgLTk5Nyw4ICs5OTgsMTEgQEAgdm9pZCBGcmFtZVZpZXc6 OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKAogICAgIAogICAgIGlmICghaW1tZWRpYXRlICYmIGlz T2Zmc2NyZWVuKCkgJiYgIXNob3VsZFVwZGF0ZVdoaWxlT2Zmc2NyZWVuKCkpCiAgICAgICAgIHJl dHVybjsKLQotICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKHIsIGltbWVk aWF0ZSk7CisgICAgCisgICAgaWYgKGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCkpCisgICAg ICAgIGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCktPmludmFsaWRhdGUocik7CisgICAgZWxz ZSAgICAgICAgCisgICAgICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKHIs IGltbWVkaWF0ZSk7CiB9CiAKIHZvaWQgRnJhbWVWaWV3Ojp2aXNpYmxlQ29udGVudHNSZXNpemVk KCkKQEAgLTEwNjksOCArMTA3MywxMiBAQCB2b2lkIEZyYW1lVmlldzo6ZG9EZWZlcnJlZFJlcGFp bnRzKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICB1bnNpZ25lZCBzaXplID0gbV9yZXBh aW50UmVjdHMuc2l6ZSgpOwotICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBzaXplOyBpKysp Ci0gICAgICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKG1fcmVwYWludFJl Y3RzW2ldLCBmYWxzZSk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemU7IGkrKykg eworICAgICAgICBpZiAoZnJhbWUoKS0+dGlsZWRCYWNraW5nU3RvcmUoKSkKKyAgICAgICAgICAg IGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCktPmludmFsaWRhdGUobV9yZXBhaW50UmVjdHNb aV0pOworICAgICAgICBlbHNlCisgICAgICAgICAgICBTY3JvbGxWaWV3OjpyZXBhaW50Q29udGVu dFJlY3RhbmdsZShtX3JlcGFpbnRSZWN0c1tpXSwgZmFsc2UpOworICAgIH0KICAgICBtX3JlcGFp bnRSZWN0cy5jbGVhcigpOwogICAgIG1fcmVwYWludENvdW50ID0gMDsKICAgICAKSW5kZXg6IFdl YkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL1NldHRp bmdzLmNwcAkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0xMjQsNiArMTI0LDcgQEAgU2V0dGluZ3M6OlNldHRpbmdzKFBhZ2Uq IHBhZ2UpCiAgICAgLCBtX3dlYkdMRW5hYmxlZChmYWxzZSkKICAgICAsIG1fZ2VvbG9jYXRpb25F bmFibGVkKHRydWUpCiAgICAgLCBtX2xvYWREZWZlcnJpbmdFbmFibGVkKHRydWUpCisgICAgLCBt X3RpbGVkQmFja2luZ1N0b3JlRW5hYmxlZChmYWxzZSkKIHsKICAgICAvLyBBIEZyYW1lIG1heSBu b3QgaGF2ZSBiZWVuIGNyZWF0ZWQgeWV0LCBzbyB3ZSBpbml0aWFsaXplIHRoZSBBdG9taWNTdHJp bmcgCiAgICAgLy8gaGFzaCBiZWZvcmUgdHJ5aW5nIHRvIHVzZSBpdC4KQEAgLTU2OCw0ICs1Njks MTEgQEAgdm9pZCBTZXR0aW5nczo6c2V0TG9hZERlZmVycmluZ0VuYWJsZWQoYgogICAgIG1fbG9h ZERlZmVycmluZ0VuYWJsZWQgPSBlbmFibGVkOwogfQogCit2b2lkIFNldHRpbmdzOjpzZXRUaWxl ZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCBlbmFibGVkKQoreworICAgIG1fdGlsZWRCYWNraW5n U3RvcmVFbmFibGVkID0gZW5hYmxlZDsKKyAgICBpZiAobV9wYWdlLT5tYWluRnJhbWUoKSkKKyAg ICAgICAgbV9wYWdlLT5tYWluRnJhbWUoKS0+c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGVu YWJsZWQpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkocmV2aXNp b24gNTQ3NzQpCisrKyBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAt Mjg2LDYgKzI4Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2b2lkIHNldExv YWREZWZlcnJpbmdFbmFibGVkKGJvb2wpOwogICAgICAgICBib29sIGxvYWREZWZlcnJpbmdFbmFi bGVkKCkgY29uc3QgeyByZXR1cm4gbV9sb2FkRGVmZXJyaW5nRW5hYmxlZDsgfQorICAgICAgICAK KyAgICAgICAgdm9pZCBzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisgICAgICAg IGJvb2wgdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV90aWxlZEJh Y2tpbmdTdG9yZUVuYWJsZWQ7IH0KIAogICAgIHByaXZhdGU6CiAgICAgICAgIFBhZ2UqIG1fcGFn ZTsKQEAgLTM2MCw2ICszNjMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGJvb2wg bV93ZWJHTEVuYWJsZWQgOiAxOwogICAgICAgICBib29sIG1fZ2VvbG9jYXRpb25FbmFibGVkIDog MTsKICAgICAgICAgYm9vbCBtX2xvYWREZWZlcnJpbmdFbmFibGVkIDogMTsKKyAgICAgICAgYm9v bCBtX3RpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCA6IDE7CiAKICNpZiBVU0UoU0FGQVJJX1RIRU1F KQogICAgICAgICBzdGF0aWMgYm9vbCBnU2hvdWxkUGFpbnROYXRpdmVDb250cm9sczsKSW5kZXg6 IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsODkgQEAKKy8qCisgQ29w eXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgt aWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUg dGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFRpbGVfaAorI2RlZmlu ZSBUaWxlX2gKKworI2luY2x1ZGUgIkludFJlY3QuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaEZ1bmN0 aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KKworI2lmIFBMQVRGT1JNKFFUKQorY2xhc3MgUVBpeG1hcDsKK2NsYXNzIFFSZWdp b247CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYkNvcmUgeworICAgIAorY2xhc3MgR3JhcGhpY3ND b250ZXh0OworY2xhc3MgVGlsZWRCYWNraW5nU3RvcmU7CisKK2NsYXNzIFRpbGUgOiBwdWJsaWMg UmVmQ291bnRlZDxUaWxlPgoreworcHVibGljOgorICAgIGNsYXNzIENvb3JkaW5hdGUgeworICAg IHB1YmxpYzoKKyAgICAgICAgQ29vcmRpbmF0ZSh1bnNpZ25lZCB4LCB1bnNpZ25lZCB5KSA6IG1f eCh4KSwgbV95KHkpIHsgfQorICAgICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQ29vcmRpbmF0 ZSYgbykgY29uc3QgeyByZXR1cm4gbV94ID09IG8ubV94ICYmIG1feSA9PSBvLm1feTsgfQorICAg ICAgICB1bnNpZ25lZCB4KCkgY29uc3QgeyByZXR1cm4gbV94OyB9CisgICAgICAgIHVuc2lnbmVk IHkoKSBjb25zdCB7IHJldHVybiBtX3k7IH0KKyAgICAgICAgdW5zaWduZWQgaGFzaCgpIGNvbnN0 IHsKKyAgICAgICAgICAgIHVuc2lnbmVkIGhhc2ggPSBXVEY6OmludEhhc2goc3RhdGljX2Nhc3Q8 dWludDY0X3Q+KG1feCkgPDwgMzIgfCBtX3kpOworICAgICAgICAgICAgLy8gYXZvaWQgZW1wdHkg YW5kIGRlbGV0ZWQgdmFsdWUKKyAgICAgICAgICAgIHJldHVybiBoYXNoIHwgKCEoaGFzaCArIDEp IDw8IDMxKTsKKyAgICAgICAgfQorICAgIHByaXZhdGU6CisgICAgICAgIHVuc2lnbmVkIG1feDsK KyAgICAgICAgdW5zaWduZWQgbV95OworICAgIH07CisKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxU aWxlPiBjcmVhdGUoVGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRp bmF0ZSYgdGlsZUNvb3JkaW5hdGUpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBUaWxlKGJhY2tpbmdT dG9yZSwgdGlsZUNvb3JkaW5hdGUpKTsgfQorICAgIH5UaWxlKCk7CisgICAgCisgICAgYm9vbCBp c0RpcnR5KCkgY29uc3Q7CisgICAgdm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmKTsKKyAg ICB2b2lkIHVwZGF0ZUJhY2tCdWZmZXIoKTsKKyAgICB2b2lkIHN3YXBCYWNrQnVmZmVyVG9Gcm9u dCgpOworICAgIGJvb2wgaXNSZWFkeVRvUGFpbnQoKSBjb25zdDsKKyAgICB2b2lkIHBhaW50KEdy YXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsKKworICAgIGNvbnN0IFRpbGU6OkNvb3Jk aW5hdGUgY29vcmRpbmF0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fY29vcmRpbmF0ZTsgfQorICAgIGNv bnN0IEludFJlY3QmIHJlY3QoKSBjb25zdCB7IHJldHVybiBtX3JlY3Q7IH0KKyAgICBjb25zdCBJ bnRSZWN0IHJlY3RUb0NvbnRlbnRzKCkgY29uc3Q7CisgICAgCisgICAgc3RhdGljIHZvaWQgcGFp bnRDaGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqLCBjb25zdCBGbG9hdFJlY3QmKTsKKwor cHJpdmF0ZToKKyAgICBUaWxlKFRpbGVkQmFja2luZ1N0b3JlKiwgY29uc3QgQ29vcmRpbmF0ZSYp OworICAgIAorICAgIFRpbGVkQmFja2luZ1N0b3JlKiBtX2JhY2tpbmdTdG9yZTsKKyAgICBDb29y ZGluYXRlIG1fY29vcmRpbmF0ZTsKKyAgICBJbnRSZWN0IG1fcmVjdDsKKworI2lmIFBMQVRGT1JN KFFUKQorICAgIFFQaXhtYXAqIG1fYnVmZmVyOworICAgIFFQaXhtYXAqIG1fYmFja0J1ZmZlcjsK KyAgICBRUmVnaW9uKiBtX2RpcnR5UmVnaW9uOworI2VuZGlmCit9OworCit9CisKKyNlbmRpZgpc IE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvVGlsZWRCYWNraW5nU3RvcmUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5jcHAJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMzU4IEBACisvKgorIENvcHlyaWdodCAoQykgMjAwOSBOb2tpYSBDb3Jwb3JhdGlvbiBh bmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAKKyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgCisgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIAorIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0 cmVldCwgRmlmdGggRmxvb3IsCisgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCisKKyNp bmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZUNs aWVudC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitzdGF0aWMgY29uc3QgaW50IGRl ZmF1bHRUaWxlV2lkdGggPSA1MTI7CitzdGF0aWMgY29uc3QgaW50IGRlZmF1bHRUaWxlSGVpZ2h0 ID0gNTEyOworCitUaWxlZEJhY2tpbmdTdG9yZTo6VGlsZWRCYWNraW5nU3RvcmUoVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQqIGNsaWVudCkKKyAgICA6IG1fY2xpZW50KGNsaWVudCkKKyAgICAsIG1f dGlsZVVwZGF0ZVRpbWVyKG5ldyBUaWxlVGltZXIodGhpcywgJlRpbGVkQmFja2luZ1N0b3JlOjp0 aWxlVXBkYXRlVGltZXJGaXJlZCkpCisgICAgLCBtX3RpbGVDcmVhdGlvblRpbWVyKG5ldyBUaWxl VGltZXIodGhpcywgJlRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3JlYXRpb25UaW1lckZpcmVkKSkK KyAgICAsIG1fdGlsZVNpemUoZGVmYXVsdFRpbGVXaWR0aCwgZGVmYXVsdFRpbGVIZWlnaHQpCisg ICAgLCBtX2NvbnRlbnRzU2NhbGUoMS5mKQoreworfQorCitUaWxlZEJhY2tpbmdTdG9yZTo6flRp bGVkQmFja2luZ1N0b3JlKCkKK3sKKyAgICBkZWxldGUgbV90aWxlVXBkYXRlVGltZXI7CisgICAg ZGVsZXRlIG1fdGlsZUNyZWF0aW9uVGltZXI7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6 OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgY29udGVudHNEaXJ0eVJlY3QpCit7CisgICAgSW50 UmVjdCBkaXJ0eVJlY3QocmVjdEZyb21Db250ZW50cyhjb250ZW50c0RpcnR5UmVjdCkpOworICAg IAorICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQo ZGlydHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9 IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIAor ICAgIGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUgPSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUg PD0gYm90dG9tUmlnaHQueSgpOyArK3lDb29yZGluYXRlKSB7CisgICAgICAgIGZvciAodW5zaWdu ZWQgeENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsgeENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQu eCgpOyArK3hDb29yZGluYXRlKSB7CisgICAgICAgICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRp bGUgPSB0aWxlKFRpbGU6OkNvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKSk7Cisg ICAgICAgICAgICBpZiAoIWN1cnJlbnRUaWxlKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICAgICAgY3VycmVudFRpbGUtPmludmFsaWRhdGUoZGlydHlSZWN0KTsKKyAgICAgICAg fQorICAgIH0KKworICAgIHN0YXJ0VGlsZVVwZGF0ZVRpbWVyKCk7Cit9CisKK3ZvaWQgVGlsZWRC YWNraW5nU3RvcmU6OnVwZGF0ZVRpbGVzKCkKK3sKKyAgICBpZiAobV9jb250ZW50c0Zyb3plbikK KyAgICAgICAgcmV0dXJuOworICAgIAorICAgIFZlY3RvcjxJbnRSZWN0PiBwYWludGVkQXJlYTsK KyAgICBWZWN0b3I8UmVmUHRyPFRpbGU+ID4gZGlydHlUaWxlczsKKyAgICBUaWxlTWFwOjppdGVy YXRvciBlbmQgPSBtX3RpbGVzLmVuZCgpOworICAgIGZvciAoVGlsZU1hcDo6aXRlcmF0b3IgaXQg PSBtX3RpbGVzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkgeworICAgICAgICBpZiAoIWl0LT5z ZWNvbmQtPmlzRGlydHkoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBkaXJ0eVRp bGVzLmFwcGVuZChpdC0+c2Vjb25kKTsKKyAgICAgICAgLy8gRklYTUU6IHNob3VsZCBub3QgcmVx dWVzdCBzeXN0ZW0gcmVwYWludCBmb3IgdGhlIGZ1bGwgdGlsZS4KKyAgICAgICAgcGFpbnRlZEFy ZWEuYXBwZW5kKHJlY3RUb0NvbnRlbnRzKGl0LT5zZWNvbmQtPnJlY3QoKSkpOworICAgIH0KKyAg ICAKKyAgICBpZiAoZGlydHlUaWxlcy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKyAgICAK KyAgICBtX2NsaWVudC0+dGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCk7CisKKyAgICAvLyBG SVhNRTogSW4gc2luZ2xlIHRocmVhZGVkIGNhc2UsIHRpbGUgYmFja2J1ZmZlcnMgY291bGQgYmUg dXBkYXRlZCBhc3luY2hybm91c2x5IAorICAgIC8vIG9uZSBieSBvbmUgYW5kIHRoZW4gc3dhcHBl ZCB0byBmcm9udCBpbiBvbmUgZ28uIFRoaXMgd291bGQgbWluaW1pemUgdGhlIHRpbWUgc3BlbnQK KyAgICAvLyBibG9ja2luZyBvbiB0aWxlIHVwZGF0ZXMuCisgICAgdW5zaWduZWQgc2l6ZSA9IGRp cnR5VGlsZXMuc2l6ZSgpOworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24p CisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnVwZGF0ZUJhY2tCdWZmZXIoKTsKKworICAgIGZvciAo dW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnN3 YXBCYWNrQnVmZmVyVG9Gcm9udCgpOworCisgICAgbV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3Jl UGFpbnRFbmQocGFpbnRlZEFyZWEpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpwYWlu dChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAg Y29udGV4dC0+c2F2ZSgpOworICAgIAorICAgIC8vIEFzc3VtZXMgdGhlIGJhY2tpbmcgc3RvcmUg aXMgcGFpbnRlZCB3aXRoIHRoZSBzY2FsZSB0cmFuc2Zvcm0gYXBwbGllZC4KKyAgICAvLyBTaW5j ZSB0aWxlIGNvbnRlbnQgaXMgYWxyZWFkeSBzY2FsZWQsIGZpcnN0IHJldmVydCB0aGUgc2NhbGlu ZyBmcm9tIHRoZSBwYWludGVyLgorICAgIGNvbnRleHQtPnNjYWxlKEZsb2F0U2l6ZSgxLmYgLyBt X2NvbnRlbnRzU2NhbGUsIDEuZiAvIG1fY29udGVudHNTY2FsZSkpOworICAgIAorICAgIEludFJl Y3QgZGlydHlSZWN0ID0gcmVjdEZyb21Db250ZW50cyhyZWN0KTsKKyAgICAKKyAgICBUaWxlOjpD b29yZGluYXRlIHRvcExlZnQgPSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGRpcnR5UmVjdC50b3BM ZWZ0KCkpOworICAgIFRpbGU6OkNvb3JkaW5hdGUgYm90dG9tUmlnaHQgPSB0aWxlQ29vcmRpbmF0 ZUZvclBvaW50KGRpcnR5UmVjdC5ib3R0b21SaWdodCgpKTsKKworICAgIGZvciAodW5zaWduZWQg eUNvb3JkaW5hdGUgPSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueSgp OyArK3lDb29yZGluYXRlKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgeENvb3JkaW5hdGUgPSB0 b3BMZWZ0LngoKTsgeENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgpOyArK3hDb29yZGluYXRl KSB7CisgICAgICAgICAgICBUaWxlOjpDb29yZGluYXRlIGN1cnJlbnRDb29yZGluYXRlKHhDb29y ZGluYXRlLCB5Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRp bGUgPSB0aWxlKGN1cnJlbnRDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmIChjdXJyZW50VGls ZSAmJiBjdXJyZW50VGlsZS0+aXNSZWFkeVRvUGFpbnQoKSkKKyAgICAgICAgICAgICAgICBjdXJy ZW50VGlsZS0+cGFpbnQoY29udGV4dCwgZGlydHlSZWN0KTsKKyAgICAgICAgICAgIGVsc2Ugewor ICAgICAgICAgICAgICAgIEZsb2F0UmVjdCB0aWxlUmVjdCA9IHRpbGVSZWN0Rm9yQ29vcmRpbmF0 ZShjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICAgICAgRmxvYXRSZWN0IHRhcmdldCA9 IGludGVyc2VjdGlvbih0aWxlUmVjdCwgRmxvYXRSZWN0KHJlY3QpKTsKKyAgICAgICAgICAgICAg ICBUaWxlOjpwYWludENoZWNrZXJQYXR0ZXJuKGNvbnRleHQsIHRhcmdldCk7CisgICAgICAgICAg ICB9CisgICAgICAgIH0KKyAgICB9CisgICAgY29udGV4dC0+cmVzdG9yZSgpOworfQorCit2b2lk IFRpbGVkQmFja2luZ1N0b3JlOjp2aWV3cG9ydENoYW5nZWQoY29uc3QgSW50UmVjdCYgY29udGVu dHNWaWV3cG9ydCkKK3sKKyAgICBJbnRSZWN0IHZpZXdwb3J0ID0gcmVjdEZyb21Db250ZW50cyhj b250ZW50c1ZpZXdwb3J0KTsKKyAgICBpZiAobV92aWV3cG9ydCA9PSB2aWV3cG9ydCkKKyAgICAg ICAgcmV0dXJuOworCisgICAgbV92aWV3cG9ydCA9IHZpZXdwb3J0OworCisgICAgc3RhcnRUaWxl Q3JlYXRpb25UaW1lcigpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzZXRDb250ZW50 c1NjYWxlKGZsb2F0IHNjYWxlKQoreworICAgIGlmIChtX2NvbnRlbnRzU2NhbGUgPT0gc2NhbGUp CisgICAgICAgIHJldHVybjsKKyAgICBtX2NvbnRlbnRzU2NhbGUgPSBzY2FsZTsKKworICAgIGlu dmFsaWRhdGUobV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNSZWN0KCkpOworfQor ICAgIAorZG91YmxlIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlRGlzdGFuY2UoY29uc3QgSW50UmVj dCYgdmlld3BvcnQsIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQorewor ICAgIGlmICh2aWV3cG9ydC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29v cmRpbmF0ZSkpKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQb2ludCB2aWV3Q2Vu dGVyID0gdmlld3BvcnQubG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQud2lkdGgoKSAvIDIs IHZpZXdwb3J0LmhlaWdodCgpIC8gMik7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBjZW50ZXJDb29y ZGluYXRlID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludCh2aWV3Q2VudGVyKTsKKyAgICAKKyAgICAv LyBNYW5oYXR0YW4gZGlzdGFuY2UsIGJpYXNlZCBzbyB0aGF0IHZlcnRpY2FsIGRpc3RhbmNlcyBh cmUgc2hvcnRlci4KKyAgICBjb25zdCBkb3VibGUgaG9yaXpvbnRhbEJpYXMgPSAxLjM7CisgICAg cmV0dXJuIGFicyhjZW50ZXJDb29yZGluYXRlLnkoKSAtIHRpbGVDb29yZGluYXRlLnkoKSkgKyBo b3Jpem9udGFsQmlhcyAqIGFicyhjZW50ZXJDb29yZGluYXRlLngoKSAtIHRpbGVDb29yZGluYXRl LngoKSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OmNyZWF0ZVRpbGVzKCkKK3sKKyAg ICBpZiAobV9jb250ZW50c0Zyb3plbikKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG1fdmll d3BvcnQuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBSZW1vdmUgdGlsZXMg dGhhdCBleHRlbmQgb3V0c2lkZSB0aGUgY3VycmVudCBjb250ZW50cyByZWN0LgorICAgIGRyb3BP dmVyaGFuZ2luZ1RpbGVzKCk7CisKKyAgICAvLyBGSVhNRTogTWFrZSBjb25maWd1cmFibGUvYWRh cHQgdG8gbWVtb3J5LgorICAgIEludFJlY3Qga2VlcFJlY3QgPSBtX3ZpZXdwb3J0OworICAgIGtl ZXBSZWN0LmluZmxhdGVYKG1fdmlld3BvcnQud2lkdGgoKSk7CisgICAga2VlcFJlY3QuaW5mbGF0 ZVkoMyAqIG1fdmlld3BvcnQuaGVpZ2h0KCkpOworICAgIGtlZXBSZWN0LmludGVyc2VjdChjb250 ZW50c1JlY3QoKSk7CisgICAgCisgICAgZHJvcFRpbGVzT3V0c2lkZVJlY3Qoa2VlcFJlY3QpOwor ICAgIAorICAgIEludFJlY3QgY292ZXJSZWN0ID0gbV92aWV3cG9ydDsKKyAgICBjb3ZlclJlY3Qu aW5mbGF0ZVgobV92aWV3cG9ydC53aWR0aCgpIC8gMik7CisgICAgY292ZXJSZWN0LmluZmxhdGVZ KDIgKiBtX3ZpZXdwb3J0LmhlaWdodCgpKTsKKyAgICBjb3ZlclJlY3QuaW50ZXJzZWN0KGNvbnRl bnRzUmVjdCgpKTsKKyAgICAKKyAgICBkb3VibGUgc2hvcnRlc3REaXN0YW5jZSA9IHN0ZDo6bnVt ZXJpY19saW1pdHM8ZG91YmxlPjo6aW5maW5pdHkoKTsKKyAgICBWZWN0b3I8VGlsZTo6Q29vcmRp bmF0ZT4gdGlsZXNUb0NyZWF0ZTsKKyAgICB1bnNpZ25lZCByZXF1aXJlZFRpbGVDb3VudCA9IDA7 CisgICAgCisgICAgVGlsZTo6Q29vcmRpbmF0ZSB0b3BMZWZ0ID0gdGlsZUNvb3JkaW5hdGVGb3JQ b2ludChjb3ZlclJlY3QudG9wTGVmdCgpKTsKKyAgICBUaWxlOjpDb29yZGluYXRlIGJvdHRvbVJp Z2h0ID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb3ZlclJlY3QuYm90dG9tUmlnaHQoKSk7Cisg ICAgZm9yICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8 PSBib3R0b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25l ZCB4Q29vcmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54 KCk7ICsreENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY3VycmVu dENvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmICh0 aWxlKGN1cnJlbnRDb29yZGluYXRlKSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgICAgICsrcmVxdWlyZWRUaWxlQ291bnQ7CisgICAgICAgICAgICAvLyAwIGRpc3RhbmNlIGZv ciBjdXJyZW50bHkgdmlzaWJsZSB0aWxlcy4KKyAgICAgICAgICAgIGRvdWJsZSBkaXN0YW5jZSA9 IHRpbGVEaXN0YW5jZShtX3ZpZXdwb3J0LCBjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAg ICBpZiAoZGlzdGFuY2UgPiBzaG9ydGVzdERpc3RhbmNlKQorICAgICAgICAgICAgICAgIGNvbnRp bnVlOworICAgICAgICAgICAgaWYgKGRpc3RhbmNlIDwgc2hvcnRlc3REaXN0YW5jZSkgeworICAg ICAgICAgICAgICAgIHRpbGVzVG9DcmVhdGUuY2xlYXIoKTsKKyAgICAgICAgICAgICAgICBzaG9y dGVzdERpc3RhbmNlID0gZGlzdGFuY2U7CisgICAgICAgICAgICB9CisgICAgICAgICAgICB0aWxl c1RvQ3JlYXRlLmFwcGVuZChjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAgICAgIH0KKyAgICB9Cisg ICAgCisgICAgdW5zaWduZWQgdGlsZXNUb0NyZWF0ZUNvdW50ID0gdGlsZXNUb0NyZWF0ZS5zaXpl KCk7CisgICAgaWYgKHRpbGVzVG9DcmVhdGVDb3VudCkgeworICAgICAgICBmb3IgKHVuc2lnbmVk IG4gPSAwOyBuIDwgdGlsZXNUb0NyZWF0ZUNvdW50OyArK24pIHsKKyAgICAgICAgICAgIFRpbGU6 OkNvb3JkaW5hdGUgY29vcmRpbmF0ZSA9IHRpbGVzVG9DcmVhdGVbbl07CisgICAgICAgICAgICBz ZXRUaWxlKGNvb3JkaW5hdGUsIFRpbGU6OmNyZWF0ZSh0aGlzLCBjb29yZGluYXRlKSk7CisgICAg ICAgIH0KKyAgICAgICAgcmVxdWlyZWRUaWxlQ291bnQgLT0gdGlsZXNUb0NyZWF0ZUNvdW50Owor ICAgIH0KKyAgICAKKyAgICAvLyBQYWludCB0aGUgY29udGVudCBvZiB0aGUgbmV3bHkgY3JlYXRl ZCB0aWxlcworICAgIGlmICh0aWxlc1RvQ3JlYXRlQ291bnQpCisgICAgICAgIHVwZGF0ZVRpbGVz KCk7CisKKyAgICAvLyBLZWVwIGNyZWF0aW5nIHRpbGVzIHVudGlsIHRoZSB3aG9sZSBjb3ZlclJl Y3QgaXMgY292ZXJlZC4KKyAgICBpZiAocmVxdWlyZWRUaWxlQ291bnQpCisgICAgICAgIG1fdGls ZUNyZWF0aW9uVGltZXItPnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdT dG9yZTo6ZHJvcE92ZXJoYW5naW5nVGlsZXMoKQoreyAgICAKKyAgICBJbnRSZWN0IGNvbnRlbnRz UmVjdCA9IHRoaXMtPmNvbnRlbnRzUmVjdCgpOworCisgICAgVmVjdG9yPFRpbGU6OkNvb3JkaW5h dGU+IHRpbGVzVG9SZW1vdmU7CisgICAgVGlsZU1hcDo6aXRlcmF0b3IgZW5kID0gbV90aWxlcy5l bmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0gbV90aWxlcy5iZWdpbigpOyBp dCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSB0aWxlQ29vcmRpbmF0 ZSA9IGl0LT5zZWNvbmQtPmNvb3JkaW5hdGUoKTsKKyAgICAgICAgSW50UmVjdCB0aWxlUmVjdCA9 IGl0LT5zZWNvbmQtPnJlY3QoKTsKKyAgICAgICAgSW50UmVjdCBleHBlY3RlZFRpbGVSZWN0ID0g dGlsZVJlY3RGb3JDb29yZGluYXRlKHRpbGVDb29yZGluYXRlKTsKKyAgICAgICAgaWYgKGV4cGVj dGVkVGlsZVJlY3QgIT0gdGlsZVJlY3QgfHwgIWNvbnRlbnRzUmVjdC5jb250YWlucyh0aWxlUmVj dCkpCisgICAgICAgICAgICB0aWxlc1RvUmVtb3ZlLmFwcGVuZCh0aWxlQ29vcmRpbmF0ZSk7Cisg ICAgfQorICAgIHVuc2lnbmVkIHJlbW92ZUNvdW50ID0gdGlsZXNUb1JlbW92ZS5zaXplKCk7Cisg ICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IHJlbW92ZUNvdW50OyArK24pCisgICAgICAgIHJl bW92ZVRpbGUodGlsZXNUb1JlbW92ZVtuXSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6 OmRyb3BUaWxlc091dHNpZGVSZWN0KGNvbnN0IEludFJlY3QmIGtlZXBSZWN0KQoreworICAgIEZs b2F0UmVjdCBrZWVwUmVjdEYgPSBrZWVwUmVjdDsKKworICAgIFZlY3RvcjxUaWxlOjpDb29yZGlu YXRlPiB0b1JlbW92ZTsKKyAgICBUaWxlTWFwOjppdGVyYXRvciBlbmQgPSBtX3RpbGVzLmVuZCgp OworICAgIGZvciAoVGlsZU1hcDo6aXRlcmF0b3IgaXQgPSBtX3RpbGVzLmJlZ2luKCk7IGl0ICE9 IGVuZDsgKytpdCkgeworICAgICAgICBUaWxlOjpDb29yZGluYXRlIGNvb3JkaW5hdGUgPSBpdC0+ c2Vjb25kLT5jb29yZGluYXRlKCk7CisgICAgICAgIEZsb2F0UmVjdCB0aWxlUmVjdCA9IGl0LT5z ZWNvbmQtPnJlY3QoKTsKKyAgICAgICAgaWYgKCF0aWxlUmVjdC5pbnRlcnNlY3RzKGtlZXBSZWN0 RikpCisgICAgICAgICAgICB0b1JlbW92ZS5hcHBlbmQoY29vcmRpbmF0ZSk7CisgICAgfQorICAg IHVuc2lnbmVkIHJlbW92ZUNvdW50ID0gdG9SZW1vdmUuc2l6ZSgpOworICAgIGZvciAodW5zaWdu ZWQgbiA9IDA7IG4gPCByZW1vdmVDb3VudDsgKytuKQorICAgICAgICByZW1vdmVUaWxlKHRvUmVt b3ZlW25dKTsKK30KKworUGFzc1JlZlB0cjxUaWxlPiBUaWxlZEJhY2tpbmdTdG9yZTo6dGlsZShj b25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRlKSBjb25zdAoreworICAgIHJldHVybiBt X3RpbGVzLmdldChjb29yZGluYXRlLmhhc2goKSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3Rv cmU6OnNldFRpbGUoY29uc3QgVGlsZTo6Q29vcmRpbmF0ZSYgY29vcmRpbmF0ZSwgUGFzc1JlZlB0 cjxUaWxlPiB0aWxlKQoreworICAgIG1fdGlsZXMuc2V0KGNvb3JkaW5hdGUuaGFzaCgpLCB0aWxl KTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6cmVtb3ZlVGlsZShjb25zdCBUaWxlOjpD b29yZGluYXRlJiBjb29yZGluYXRlKQoreworICAgIG1fdGlsZXMucmVtb3ZlKGNvb3JkaW5hdGUu aGFzaCgpKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9yZTo6cmVjdFRvQ29udGVudHMo Y29uc3QgSW50UmVjdCYgcmVjdCkgY29uc3QKK3sKKyAgICByZXR1cm4gZW5jbG9zaW5nSW50UmVj dChGbG9hdFJlY3QocmVjdC54KCkgLyBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgICAgICAgICAg ICAgcmVjdC55KCkgLyBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgICAgICAgICAgICAgcmVjdC53 aWR0aCgpIC8gbV9jb250ZW50c1NjYWxlLAorICAgICAgICAgICAgICAgICAgIHJlY3QuaGVpZ2h0 KCkgLyBtX2NvbnRlbnRzU2NhbGUpKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9yZTo6 cmVjdEZyb21Db250ZW50cyhjb25zdCBJbnRSZWN0JiByZWN0KSBjb25zdAoreworICAgIHJldHVy biBlbmNsb3NpbmdJbnRSZWN0KEZsb2F0UmVjdChyZWN0LngoKSAqIG1fY29udGVudHNTY2FsZSwK KyAgICAgICAgICAgICAgICAgICAgIHJlY3QueSgpICogbV9jb250ZW50c1NjYWxlLAorICAgICAg ICAgICAgICAgICAgICAgcmVjdC53aWR0aCgpICogbV9jb250ZW50c1NjYWxlLAorICAgICAgICAg ICAgICAgICAgICAgcmVjdC5oZWlnaHQoKSAqIG1fY29udGVudHNTY2FsZSkpOworfQorCitJbnRS ZWN0IFRpbGVkQmFja2luZ1N0b3JlOjpjb250ZW50c1JlY3QoKSBjb25zdAoreworICAgIHJldHVy biByZWN0RnJvbUNvbnRlbnRzKG1fY2xpZW50LT50aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVj dCgpKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9yZTo6dGlsZVJlY3RGb3JDb29yZGlu YXRlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUpIGNvbnN0Cit7CisgICAgSW50 UmVjdCByZWN0KGNvb3JkaW5hdGUueCgpICogbV90aWxlU2l6ZS53aWR0aCgpLAorICAgICAgICAg ICAgICAgICBjb29yZGluYXRlLnkoKSAqIG1fdGlsZVNpemUuaGVpZ2h0KCksCisgICAgICAgICAg ICAgICAgIG1fdGlsZVNpemUud2lkdGgoKSwKKyAgICAgICAgICAgICAgICAgbV90aWxlU2l6ZS5o ZWlnaHQoKSk7CisKKyAgICByZWN0LmludGVyc2VjdChjb250ZW50c1JlY3QoKSk7CisgICAgcmV0 dXJuIHJlY3Q7Cit9CisgICAgCitUaWxlOjpDb29yZGluYXRlIFRpbGVkQmFja2luZ1N0b3JlOjp0 aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNvbnN0IEludFBvaW50JiBwb2ludCkgY29uc3QKK3sKKyAg ICBpbnQgeCA9IHBvaW50LngoKSAvIG1fdGlsZVNpemUud2lkdGgoKTsKKyAgICBpbnQgeSA9IHBv aW50LnkoKSAvIG1fdGlsZVNpemUuaGVpZ2h0KCk7CisgICAgcmV0dXJuIFRpbGU6OkNvb3JkaW5h dGUoc3RkOjptYXgoeCwgMCksIHN0ZDo6bWF4KHksIDApKTsKK30KKworCit2b2lkIFRpbGVkQmFj a2luZ1N0b3JlOjpzdGFydFRpbGVVcGRhdGVUaW1lcigpCit7CisgICAgaWYgKG1fdGlsZVVwZGF0 ZVRpbWVyLT5pc0FjdGl2ZSgpIHx8IG1fY29udGVudHNGcm96ZW4pCisgICAgICAgIHJldHVybjsK KyAgICBtX3RpbGVVcGRhdGVUaW1lci0+c3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIFRpbGVk QmFja2luZ1N0b3JlOjp0aWxlVXBkYXRlVGltZXJGaXJlZChUaWxlVGltZXIqKQoreworICAgIHVw ZGF0ZVRpbGVzKCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnN0YXJ0VGlsZUNyZWF0 aW9uVGltZXIoKQoreworICAgIGlmIChtX3RpbGVDcmVhdGlvblRpbWVyLT5pc0FjdGl2ZSgpIHx8 IG1fY29udGVudHNGcm96ZW4pCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVDcmVhdGlvblRp bWVyLT5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnRpbGVD cmVhdGlvblRpbWVyRmlyZWQoVGlsZVRpbWVyKikKK3sKKyAgICBjcmVhdGVUaWxlcygpOworfQor Cit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzZXRDb250ZW50c0Zyb3plbihib29sIGZyZWV6ZSkK K3sKKyAgICBpZiAobV9jb250ZW50c0Zyb3plbiA9PSBmcmVlemUpCisgICAgICAgIHJldHVybjsK KworICAgIG1fY29udGVudHNGcm96ZW4gPSBmcmVlemU7CisKKyAgICAvLyBSZXN0YXJ0IHRoZSB0 aW1lcnMuIFRoZXJlIG1pZ2h0IGJlIHBlbmRpbmcgaW52YWxpZGF0aW9ucyB0aGF0CisgICAgLy8g d2VyZSBub3QgcGFpbnRlZCBvciBjcmVhdGVkIGJlY2F1c2UgdGlsZXMgYXJlIG5vdCBjcmVhdGVk IG9yCisgICAgLy8gcGFpbnRlZCB3aGVuIGluIGZyb3plbiBzdGF0ZS4KKyAgICBpZiAoIW1fY29u dGVudHNGcm96ZW4pIHsKKyAgICAgICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgICAg ICBzdGFydFRpbGVVcGRhdGVUaW1lcigpOworICAgIH0KKyAgICAvLyBzdG9wcGluZyBpcyBoYW5k bGVkIHdoZW4gdGhlIHRpbWVycyBmaXJlCit9CisKK30KSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmgJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMTAyIEBACisvKgorIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBh bmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAKKyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgCisgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIAorIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0 cmVldCwgRmlmdGggRmxvb3IsCisgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKwor I2lmbmRlZiBUaWxlZEJhY2tpbmdTdG9yZV9oCisjZGVmaW5lIFRpbGVkQmFja2luZ1N0b3JlX2gK KworI2luY2x1ZGUgIkludFJlY3QuaCIKKyNpbmNsdWRlICJGbG9hdFNpemUuaCIKKyNpbmNsdWRl ICJUaW1lci5oIgorI2luY2x1ZGUgIlRpbGUuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgor I2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGlsZWRC YWNraW5nU3RvcmVDbGllbnQ7CisKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlIDogcHVibGljIE5v bmNvcHlhYmxlCit7CitwdWJsaWM6CisgICAgVGlsZWRCYWNraW5nU3RvcmUoVGlsZWRCYWNraW5n U3RvcmVDbGllbnQqKTsKKyAgICB+VGlsZWRCYWNraW5nU3RvcmUoKTsKKworICAgIHZvaWQgdmll d3BvcnRDaGFuZ2VkKGNvbnN0IEludFJlY3QmIHZpZXdwb3J0UmVjdCk7CisgICAgCisgICAgZmxv YXQgY29udGVudHNTY2FsZSgpIHsgcmV0dXJuIG1fY29udGVudHNTY2FsZTsgfQorICAgIHZvaWQg c2V0Q29udGVudHNTY2FsZShmbG9hdCk7CisgICAgCisgICAgYm9vbCBjb250ZW50c0Zyb3plbigp IGNvbnN0IHsgcmV0dXJuIG1fY29udGVudHNGcm96ZW47IH0KKyAgICB2b2lkIHNldENvbnRlbnRz RnJvemVuKGJvb2wpOworCisgICAgdm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGRpcnR5 UmVjdCk7CisgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0Jik7 CisKK3ByaXZhdGU6CisgICAgdm9pZCBzdGFydFRpbGVVcGRhdGVUaW1lcigpOworICAgIHZvaWQg c3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgIAorICAgIHR5cGVkZWYgVGltZXI8VGlsZWRC YWNraW5nU3RvcmU+IFRpbGVUaW1lcjsKKworICAgIHZvaWQgdGlsZVVwZGF0ZVRpbWVyRmlyZWQo VGlsZVRpbWVyKik7CisgICAgdm9pZCB0aWxlQ3JlYXRpb25UaW1lckZpcmVkKFRpbGVUaW1lciop OworICAgIAorICAgIHZvaWQgdXBkYXRlVGlsZXMoKTsKKyAgICB2b2lkIGNyZWF0ZVRpbGVzKCk7 CisgICAgdm9pZCBkcm9wT3ZlcmhhbmdpbmdUaWxlcygpOworICAgIHZvaWQgZHJvcFRpbGVzT3V0 c2lkZVJlY3QoY29uc3QgSW50UmVjdCYpOworICAgIAorICAgIFBhc3NSZWZQdHI8VGlsZT4gdGls ZShjb25zdCBUaWxlOjpDb29yZGluYXRlJikgY29uc3Q7CisgICAgdm9pZCBzZXRUaWxlKGNvbnN0 IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NSZWZQdHI8VGlsZT4gdGlsZSk7Cisg ICAgdm9pZCByZW1vdmVUaWxlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUpOwor CisgICAgSW50UmVjdCByZWN0VG9Db250ZW50cyhjb25zdCBJbnRSZWN0JikgY29uc3Q7CisgICAg SW50UmVjdCByZWN0RnJvbUNvbnRlbnRzKGNvbnN0IEludFJlY3QmKSBjb25zdDsKKyAgICAKKyAg ICBJbnRSZWN0IGNvbnRlbnRzUmVjdCgpIGNvbnN0OworICAgIAorICAgIEludFJlY3QgdGlsZVJl Y3RGb3JDb29yZGluYXRlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmKSBjb25zdDsKKyAgICBUaWxl OjpDb29yZGluYXRlIHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY29uc3QgSW50UG9pbnQmKSBjb25z dDsKKyAgICBkb3VibGUgdGlsZURpc3RhbmNlKGNvbnN0IEludFJlY3QmIHZpZXdwb3J0LCBjb25z dCBUaWxlOjpDb29yZGluYXRlJik7CisgICAgCisgICAgdm9pZCBwYWludENoZWNrZXJQYXR0ZXJu KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmLCBjb25zdCBUaWxlOjpDb29yZGluYXRl Jik7CisKKyAgICBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCogbV9jbGllbnQ7CisKKyAgICB0eXBl ZGVmIEhhc2hNYXA8dW5zaWduZWQsIFJlZlB0cjxUaWxlPiA+IFRpbGVNYXA7CisgICAgVGlsZU1h cCBtX3RpbGVzOworCisgICAgVGlsZVRpbWVyKiBtX3RpbGVVcGRhdGVUaW1lcjsKKyAgICBUaWxl VGltZXIqIG1fdGlsZUNyZWF0aW9uVGltZXI7CisKKyAgICBJbnRTaXplIG1fdGlsZVNpemU7Cisg ICAgCisgICAgSW50UmVjdCBtX3ZpZXdwb3J0OworICAgIGZsb2F0IG1fY29udGVudHNTY2FsZTsK KworICAgIGJvb2wgbV9jb250ZW50c0Zyb3plbjsKKworICAgIGZyaWVuZCBjbGFzcyBUaWxlOwor fTsKKworfQorCisjZW5kaWYKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZWRC YWNraW5nU3RvcmVDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsMzggQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9u IGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLwor CisjaWZuZGVmIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50X2gKKyNkZWZpbmUgVGlsZWRCYWNraW5n U3RvcmVDbGllbnRfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEdyYXBoaWNzQ29u dGV4dDsKKworY2xhc3MgVGlsZWRCYWNraW5nU3RvcmVDbGllbnQKK3sKK3B1YmxpYzoKKyAgICB2 aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCkgPSAwOworICAgIHZpcnR1 YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IElu dFJlY3QmKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQo Y29uc3QgVmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSkgPSAwOworICAgIHZpcnR1YWwgSW50 UmVjdCB0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpID0gMDsKK307CisKK30KKworI2Vu ZGlmCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDE4MyBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMDkgTm9raWEgQ29y cG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorIAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl CisgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBG cmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNB LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJUaWxlLmgiCisKKyNpbmNs dWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgor I2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgiCisjaW5jbHVkZSA8UUFwcGxpY2F0 aW9uPgorI2luY2x1ZGUgPFFCYXNpY1RpbWVyPgorI2luY2x1ZGUgPFFEZWJ1Zz4KKyNpbmNsdWRl IDxRSW1hZ2U+CisjaW5jbHVkZSA8UU9iamVjdD4KKyNpbmNsdWRlIDxRUGFpbnRlcj4KKyNpbmNs dWRlIDxRUmVnaW9uPgorI2luY2x1ZGUgPFFUaHJlYWQ+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KyAgICAKK3N0YXRpYyBjb25zdCBpbnQgY2hlY2tlclNpemUgPSAxNjsKK3N0YXRpYyBjb25zdCB1 bnNpZ25lZCBjaGVja2VyQ29sb3IxID0gMHhmZjU1NTU1NTsKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBjaGVja2VyQ29sb3IyID0gMHhmZmFhYWFhYTsKKyAgICAKK3N0YXRpYyBRUGl4bWFwJiBjaGVj a2VyZWRQaXhtYXAoKQoreworICAgIHN0YXRpYyBRUGl4bWFwKiBwaXhtYXA7CisgICAgaWYgKCFw aXhtYXApIHsKKyAgICAgICAgcGl4bWFwID0gbmV3IFFQaXhtYXAoNCAqIGNoZWNrZXJTaXplLCA0 ICogY2hlY2tlclNpemUpOworICAgICAgICBRUGFpbnRlciBwYWludGVyKHBpeG1hcCk7CisgICAg ICAgIFFDb2xvciBjb2xvcjEoY2hlY2tlckNvbG9yMSk7CisgICAgICAgIFFDb2xvciBjb2xvcjIo Y2hlY2tlckNvbG9yMik7CisgICAgICAgIGZvciAoaW50IHkgPSAwOyB5IDwgY2hlY2tlclNpemU7 IHkgKz0gY2hlY2tlclNpemUgLyAyKSB7CisgICAgICAgICAgICBib29sIGFsdGVybmF0ZSA9IHkg JSBjaGVja2VyU2l6ZTsKKyAgICAgICAgICAgIGZvciAoaW50IHggPSAwOyB4IDwgY2hlY2tlclNp emU7IHggKz0gY2hlY2tlclNpemUgLyAyKSB7CisgICAgICAgICAgICAgICAgcGFpbnRlci5maWxs UmVjdCh4LCB5LCBjaGVja2VyU2l6ZSAvIDIsIGNoZWNrZXJTaXplIC8gMiwgYWx0ZXJuYXRlID8g Y29sb3IxIDogY29sb3IyKTsKKyAgICAgICAgICAgICAgICBhbHRlcm5hdGUgPSAhYWx0ZXJuYXRl OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorICAgIHJldHVybiAqcGl4bWFwOwor fQorICAgIAorVGlsZTo6VGlsZShUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlLCBjb25z dCBDb29yZGluYXRlJiB0aWxlQ29vcmRpbmF0ZSkKKyAgICA6IG1fYmFja2luZ1N0b3JlKGJhY2tp bmdTdG9yZSkKKyAgICAsIG1fY29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkKKyAgICAsIG1fcmVj dChtX2JhY2tpbmdTdG9yZS0+dGlsZVJlY3RGb3JDb29yZGluYXRlKHRpbGVDb29yZGluYXRlKSkK KyAgICAsIG1fYnVmZmVyKDApCisgICAgLCBtX2JhY2tCdWZmZXIoMCkKKyAgICAsIG1fZGlydHlS ZWdpb24obmV3IFFSZWdpb24obV9yZWN0KSkKK3sKK30KKworVGlsZTo6flRpbGUoKQoreworICAg IGRlbGV0ZSBtX2J1ZmZlcjsKKyAgICBkZWxldGUgbV9iYWNrQnVmZmVyOworfQorCitib29sIFRp bGU6OmlzRGlydHkoKSBjb25zdCAKK3sgCisgICAgcmV0dXJuICFtX2RpcnR5UmVnaW9uLT5pc0Vt cHR5KCk7IAorfQorCitib29sIFRpbGU6OmlzUmVhZHlUb1BhaW50KCkgY29uc3QKK3sgCisgICAg cmV0dXJuIG1fYnVmZmVyOyAKK30KKyAgICAKK2NvbnN0IEludFJlY3QgVGlsZTo6cmVjdFRvQ29u dGVudHMoKSBjb25zdAoreyAKKyAgICByZXR1cm4gbV9iYWNraW5nU3RvcmUtPnJlY3RUb0NvbnRl bnRzKG1fcmVjdCk7IAorfQorCit2b2lkIFRpbGU6OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYg ZGlydHlSZWN0KQoreworICAgIEludFJlY3QgdGlsZURpcnR5UmVjdCA9IGludGVyc2VjdGlvbihk aXJ0eVJlY3QsIG1fcmVjdCk7CisgICAgaWYgKHRpbGVEaXJ0eVJlY3QuaXNFbXB0eSgpKQorICAg ICAgICByZXR1cm47CisKKyAgICAqbV9kaXJ0eVJlZ2lvbiArPSB0aWxlRGlydHlSZWN0OworfQor ICAgIAordm9pZCBUaWxlOjp1cGRhdGVCYWNrQnVmZmVyKCkKK3sKKyAgICBpZiAobV9idWZmZXIg JiYgIWlzRGlydHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2JhY2tCdWZmZXIp IHsKKyAgICAgICAgLy8gQ29weSB0aGUgY3VycmVudCBidWZmZXIgaWYgdGhpcyBpcyBub3QgYSBm dWxsIHRpbGUgdXBkYXRlIChvciBhIG5ldyB0aWxlCisgICAgICAgIGlmICghbV9idWZmZXIpCisg ICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBuZXcgUVBpeG1hcChtX2JhY2tpbmdTdG9yZS0+bV90 aWxlU2l6ZS53aWR0aCgpLCBtX2JhY2tpbmdTdG9yZS0+bV90aWxlU2l6ZS5oZWlnaHQoKSk7Cisg ICAgICAgIGVsc2UgeworICAgICAgICAgICAgLy8gQ3VycmVudGx5IGFsbCBidWZmZXJzIGFyZSB1 cGRhdGVkIHN5bmNocm9ub3VzbHkgYXQgdGhlIHNhbWUgdGltZSBzbyB0aGVyZSBpcyBubyByZWFs IG5lZWQKKyAgICAgICAgICAgIC8vIHRvIGhhdmUgc2VwYXJhdGUgYmFjayBhbmQgZnJvbnQgYnVm ZmVycy4gSnVzdCB1c2UgdGhlIGV4aXN0aW5nIGJ1ZmZlci4KKyAgICAgICAgICAgIG1fYmFja0J1 ZmZlciA9IG1fYnVmZmVyOworICAgICAgICAgICAgbV9idWZmZXIgPSAwOworICAgICAgICB9Cisg ICAgfQorCisgICAgUVZlY3RvcjxRUmVjdD4gZGlydHlSZWN0cyA9IG1fZGlydHlSZWdpb24tPnJl Y3RzKCk7CisgICAgKm1fZGlydHlSZWdpb24gPSBRUmVnaW9uKCk7CisgICAgCisgICAgUVBhaW50 ZXIgcGFpbnRlcihtX2JhY2tCdWZmZXIpOworICAgIEdyYXBoaWNzQ29udGV4dCBjb250ZXh0KCZw YWludGVyKTsKKyAgICBjb250ZXh0LnRyYW5zbGF0ZSgtbV9yZWN0LngoKSwgLW1fcmVjdC55KCkp OworCisgICAgaW50IHNpemUgPSBkaXJ0eVJlY3RzLnNpemUoKTsKKyAgICBmb3IgKGludCBuID0g MDsgbiA8IHNpemU7ICsrbikgIHsKKyAgICAgICAgY29udGV4dC5zYXZlKCk7CisgICAgICAgIElu dFJlY3QgcmVjdCA9IGRpcnR5UmVjdHNbbl07CisgICAgICAgIGNvbnRleHQuY2xpcChGbG9hdFJl Y3QocmVjdCkpOworICAgICAgICBjb250ZXh0LnNjYWxlKEZsb2F0U2l6ZShtX2JhY2tpbmdTdG9y ZS0+bV9jb250ZW50c1NjYWxlLCBtX2JhY2tpbmdTdG9yZS0+bV9jb250ZW50c1NjYWxlKSk7Cisg ICAgICAgIG1fYmFja2luZ1N0b3JlLT5tX2NsaWVudC0+dGlsZWRCYWNraW5nU3RvcmVQYWludCgm Y29udGV4dCwgbV9iYWNraW5nU3RvcmUtPnJlY3RUb0NvbnRlbnRzKHJlY3QpKTsKKyAgICAgICAg Y29udGV4dC5yZXN0b3JlKCk7CisgICAgfQorfQorCit2b2lkIFRpbGU6OnN3YXBCYWNrQnVmZmVy VG9Gcm9udCgpCit7CisgICAgaWYgKCFtX2JhY2tCdWZmZXIpCisgICAgICAgIHJldHVybjsKKyAg ICBkZWxldGUgbV9idWZmZXI7CisgICAgbV9idWZmZXIgPSBtX2JhY2tCdWZmZXI7CisgICAgbV9i YWNrQnVmZmVyID0gMDsKK30KKwordm9pZCBUaWxlOjpwYWludChHcmFwaGljc0NvbnRleHQqIGNv bnRleHQsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgaWYgKCFtX2J1ZmZlcikKKyAgICAg ICAgcmV0dXJuOworICAgIAorICAgIEludFJlY3QgdGFyZ2V0ID0gaW50ZXJzZWN0aW9uKHJlY3Qs IG1fcmVjdCk7CisgICAgSW50UmVjdCBzb3VyY2UoKHRhcmdldC54KCkgLSBtX3JlY3QueCgpKSwK KyAgICAgICAgICAgICAgICAgICAodGFyZ2V0LnkoKSAtIG1fcmVjdC55KCkpLAorICAgICAgICAg ICAgICAgICAgIHRhcmdldC53aWR0aCgpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC5oZWln aHQoKSk7CisgICAgCisgICAgY29udGV4dC0+cGxhdGZvcm1Db250ZXh0KCktPmRyYXdQaXhtYXAo dGFyZ2V0LCAqbV9idWZmZXIsIHNvdXJjZSk7Cit9CisgICAgCit2b2lkIFRpbGU6OnBhaW50Q2hl Y2tlclBhdHRlcm4oR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBGbG9hdFJlY3QmIHRh cmdldCkKK3sKKyAgICBRUGFpbnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4 dCgpOworICAgIFFUcmFuc2Zvcm0gdCA9IHBhaW50ZXItPndvcmxkVHJhbnNmb3JtKCk7CisgICAg cXJlYWwgc2NhbGV4ID0gdC5tMTEoKTsKKyAgICBxcmVhbCBzY2FsZXkgPSB0Lm0yMigpOworICAg IAorICAgIFFSZWN0IHRhcmdldFZpZXdSZWN0ID0gUVJlY3RGKHRhcmdldC54KCkgKiBzY2FsZXgs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LnkoKSAqIHNjYWxleSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0YXJnZXQud2lkdGgoKSAqIHNjYWxl eCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0YXJnZXQuaGVpZ2h0KCkgKiBz Y2FsZXkpLnRvQWxpZ25lZFJlY3QoKTsKKyAgICAKKyAgICBRVHJhbnNmb3JtIG50KDEuLCB0Lm0x MigpLCB0Lm0xMygpLAorICAgICAgICAgICAgICAgICAgdC5tMjEoKSwgMS4sIHQubTIzKCksCisg ICAgICAgICAgICAgICAgICB0Lm0zMSgpLCB0Lm0zMigpLCB0Lm0zMygpKTsKKyAgICBwYWludGVy LT5zZXRXb3JsZFRyYW5zZm9ybShudCk7CisgICAgCisgICAgcGFpbnRlci0+ZHJhd1RpbGVkUGl4 bWFwKHRhcmdldFZpZXdSZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGVja2Vy ZWRQaXhtYXAoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUVBvaW50KHRhcmdldFZp ZXdSZWN0LmxlZnQoKSAlIGNoZWNrZXJTaXplLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdGFyZ2V0Vmlld1JlY3QudG9wKCkgJSBjaGVja2VyU2l6ZSkpOworICAgIAorICAg IHBhaW50ZXItPnNldFdvcmxkVHJhbnNmb3JtKHQpOworfQorCit9CkluZGV4OiBXZWJLaXQvcXQv QXBpL3FncmFwaGljc3dlYnZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcWdy YXBoaWNzd2Vidmlldy5jcHAJKHJldmlzaW9uIDU0Nzc0KQorKysgV2ViS2l0L3F0L0FwaS9xZ3Jh cGhpY3N3ZWJ2aWV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjYsNyArMjYsMTAgQEAKICNpbmNs dWRlICJxd2VicGFnZS5oIgogI2luY2x1ZGUgInF3ZWJwYWdlX3AuaCIKICNpbmNsdWRlICJRV2Vi UGFnZUNsaWVudC5oIgotI2luY2x1ZGUgPEZyYW1lVmlldy5oPgorI2luY2x1ZGUgIkZyYW1lVmll dy5oIgorI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIkludFJlY3QuaCIK KyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgogI2luY2x1ZGUgPFF0Q29yZS9xbWV0YW9i amVjdC5oPgogI2luY2x1ZGUgPFF0Q29yZS9xc2hhcmVkcG9pbnRlci5oPgogI2luY2x1ZGUgPFF0 Q29yZS9xdGltZXIuaD4KQEAgLTM1LDYgKzM4LDcgQEAKICNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhp Y3NzY2VuZWV2ZW50Lmg+CiAjaW5jbHVkZSA8UXRHdWkvcWdyYXBoaWNzdmlldy5oPgogI2luY2x1 ZGUgPFF0R3VpL3FwaXhtYXBjYWNoZS5oPgorI2luY2x1ZGUgPFF0R3VpL3FzY3JvbGxiYXIuaD4K ICNpbmNsdWRlIDxRdEd1aS9xc3R5bGVvcHRpb24uaD4KICNpZiBkZWZpbmVkKFFfV1NfWDExKQog I2luY2x1ZGUgPFFYMTFJbmZvPgpAQCAtMTIwLDYgKzEyNCw3IEBAIHB1YmxpYzoKICNlbmRpZgog ICAgIAogICAgIHZvaWQgdXBkYXRlUmVzaXplc1RvQ29udGVudHNGb3JQYWdlKCk7CisgICAgUVJl Y3RGIHZpc2libGVSZWN0KCkgY29uc3Q7CiAKICAgICB2b2lkIHN5bmNMYXllcnMoKTsKICAgICB2 b2lkIF9xX2RvTG9hZEZpbmlzaGVkKGJvb2wgc3VjY2Vzcyk7CkBAIC0zMzUsNiArMzQwLDIzIEBA IHZvaWQgUUdyYXBoaWNzV2ViVmlld1ByaXZhdGU6Ol9xX2NvbnRlbnQKICAgICBxLT5zZXRHZW9t ZXRyeShRUmVjdEYocS0+Z2VvbWV0cnkoKS50b3BMZWZ0KCksIHNpemUpKTsKIH0KIAorUVJlY3RG IFFHcmFwaGljc1dlYlZpZXdQcml2YXRlOjp2aXNpYmxlUmVjdCgpIGNvbnN0Cit7CisgICAgaWYg KCFxLT5zY2VuZSgpKQorICAgICAgICByZXR1cm4gUVJlY3RGKCk7CisgICAgUUxpc3Q8UUdyYXBo aWNzVmlldyo+IHZpZXdzID0gcS0+c2NlbmUoKS0+dmlld3MoKTsKKyAgICBpZiAodmlld3Muc2l6 ZSgpID4gMSkgeworICAgICAgICBxRGVidWcoKSA8PCAiUUdyYXBoaWNzV2ViVmlldyBpcyBpbiBt b3JlIHRoYW4gb25lIGdyYXBoaWNzIHZpZXdzLCB1bmFibGUgdG8gY29tcHV0ZSB0aGUgdmlzaWJs ZSByZWN0IjsKKyAgICAgICAgcmV0dXJuIFFSZWN0RigpOworICAgIH0KKyAgICBpZiAodmlld3Mu c2l6ZSgpIDwgMSkKKyAgICAgICAgcmV0dXJuIFFSZWN0RigpOworCisgICAgaW50IGggPSB2aWV3 c1swXS0+aG9yaXpvbnRhbFNjcm9sbEJhcigpLT52YWx1ZSgpOworICAgIGludCB2ID0gdmlld3Nb MF0tPnZlcnRpY2FsU2Nyb2xsQmFyKCktPnZhbHVlKCk7CisgICAgcmV0dXJuIHEtPm1hcFJlY3RG cm9tU2NlbmUoUVJlY3RGKFFQb2ludChoLCB2KSwgdmlld3NbMF0tPnZpZXdwb3J0KCktPnNpemUo KSkpOworfQorCiAvKiEKICAgICBcY2xhc3MgUUdyYXBoaWNzV2ViVmlldwogICAgIFxicmllZiBU aGUgUUdyYXBoaWNzV2ViVmlldyBjbGFzcyBhbGxvd3MgV2ViIGNvbnRlbnQgdG8gYmUgYWRkZWQg dG8gYSBHcmFwaGljc1ZpZXcuCkBAIC00MjgsNiArNDUwLDcgQEAgUUdyYXBoaWNzV2ViVmlldzo6 UUdyYXBoaWNzV2ViVmlldyhRR3JhcAogI2VuZGlmCiAgICAgc2V0Rm9jdXNQb2xpY3koUXQ6OlN0 cm9uZ0ZvY3VzKTsKICAgICBzZXRGbGFnKFFHcmFwaGljc0l0ZW06Okl0ZW1DbGlwc0NoaWxkcmVu VG9TaGFwZSwgdHJ1ZSk7CisgICAgc2V0RmxhZyhRR3JhcGhpY3NJdGVtOjpJdGVtU2VuZHNHZW9t ZXRyeUNoYW5nZXMsIHRydWUpOwogfQogCiAvKiEKQEAgLTQ3NywxMSArNTAwLDIwIEBAIFFXZWJQ YWdlKiBRR3JhcGhpY3NXZWJWaWV3OjpwYWdlKCkgY29uc3QKICovCiB2b2lkIFFHcmFwaGljc1dl YlZpZXc6OnBhaW50KFFQYWludGVyKiBwYWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGlj c0l0ZW0qIG9wdGlvbiwgUVdpZGdldCopCiB7CisgICAgLy8gRklYTUU6IFNjcm9sbGJhcnMgY291 bGQgYmUgZHJhd24gd2l0aCB0aGUgb3ZlcmxheSBsYXllciB3aGVuIHVzaW5nIHRpbGluZy4KKyAg ICBXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0gUVdlYkZyYW1lUHJp dmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5nU3RvcmUoKTs7Cisg ICAgaWYgKGJhY2tpbmdTdG9yZSkgeworICAgICAgICBiYWNraW5nU3RvcmUtPnZpZXdwb3J0Q2hh bmdlZChXZWJDb3JlOjpJbnRSZWN0KGQtPnZpc2libGVSZWN0KCkpKTsKKyAgICAgICAgLy8gUVdl YkZyYW1lOjpyZW5kZXIgaXMgYSBwdWJsaWMgQVBJLCBieXBhc3MgaXQgZm9yIHRpbGVkIHJlbmRl cmluZyBzbyBiZWhhdmlvciBkb2VzIG5vdCBuZWVkIHRvIGNoYW5nZS4KKyAgICAgICAgV2ViQ29y ZTo6R3JhcGhpY3NDb250ZXh0IGNvbnRleHQocGFpbnRlcik7IAorICAgICAgICBwYWdlKCktPm1h aW5GcmFtZSgpLT5kLT5yZW5kZXJDb250ZW50c0xheWVyQWJzb2x1dGVDb29yZHMoJmNvbnRleHQs IG9wdGlvbi0+ZXhwb3NlZFJlY3QudG9BbGlnbmVkUmVjdCgpKTsKKyAgICB9IGVsc2UgewogI2lm IFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKLSAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5y ZW5kZXIocGFpbnRlciwgZC0+b3ZlcmxheSA/IFFXZWJGcmFtZTo6Q29udGVudHNMYXllciA6IFFX ZWJGcmFtZTo6QWxsTGF5ZXJzLCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvQWxpZ25lZFJlY3QoKSk7 CisgICAgICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPnJlbmRlcihwYWludGVyLCBkLT5vdmVybGF5 ID8gUVdlYkZyYW1lOjpDb250ZW50c0xheWVyIDogUVdlYkZyYW1lOjpBbGxMYXllcnMsIG9wdGlv bi0+ZXhwb3NlZFJlY3QudG9BbGlnbmVkUmVjdCgpKTsKICNlbHNlCi0gICAgcGFnZSgpLT5tYWlu RnJhbWUoKS0+cmVuZGVyKHBhaW50ZXIsIFFXZWJGcmFtZTo6QWxsTGF5ZXJzLCBvcHRpb24tPmV4 cG9zZWRSZWN0LnRvUmVjdCgpKTsKKyAgICAgICAgcGFnZSgpLT5tYWluRnJhbWUoKS0+cmVuZGVy KHBhaW50ZXIsIFFXZWJGcmFtZTo6QWxsTGF5ZXJzLCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvUmVj dCgpKTsKICNlbmRpZgorICAgIH0KIH0KIAogLyohIFxyZWltcApAQCAtNTE2LDEwICs1NDgsMTUg QEAgUVZhcmlhbnQgUUdyYXBoaWNzV2ViVmlldzo6aXRlbUNoYW5nZShHcgogICAgIC8vIGZpcmUg J0N1cnNvckNoYW5nZScuCiAgICAgY2FzZSBJdGVtQ3Vyc29yQ2hhbmdlOgogICAgICAgICByZXR1 cm4gdmFsdWU7Ci0gICAgY2FzZSBJdGVtQ3Vyc29ySGFzQ2hhbmdlZDoKLSAgICAgICAgUUV2ZW50 IGV2ZW50KFFFdmVudDo6Q3Vyc29yQ2hhbmdlKTsKLSAgICAgICAgUUFwcGxpY2F0aW9uOjpzZW5k RXZlbnQodGhpcywgJmV2ZW50KTsKLSAgICAgICAgcmV0dXJuIHZhbHVlOworICAgIGNhc2UgSXRl bUN1cnNvckhhc0NoYW5nZWQ6IHsKKyAgICAgICAgICAgIFFFdmVudCBldmVudChRRXZlbnQ6OkN1 cnNvckNoYW5nZSk7CisgICAgICAgICAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCh0aGlzLCAm ZXZlbnQpOworICAgICAgICAgICAgcmV0dXJuIHZhbHVlOworICAgICAgICB9CisgICAgY2FzZSBJ dGVtUG9zaXRpb25IYXNDaGFuZ2VkOgorICAgIGNhc2UgSXRlbVRyYW5zZm9ybUhhc0NoYW5nZWQ6 CisgICAgICAgIGlmIChXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0g UVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5n U3RvcmUoKSkKKyAgICAgICAgICAgIGJhY2tpbmdTdG9yZS0+dmlld3BvcnRDaGFuZ2VkKFdlYkNv cmU6OkludFJlY3QoZC0+dmlzaWJsZVJlY3QoKSkpOwogICAgIH0KIAogICAgIHJldHVybiBRR3Jh cGhpY3NXaWRnZXQ6Oml0ZW1DaGFuZ2UoY2hhbmdlLCB2YWx1ZSk7CkBAIC03MzIsNiArNzY5LDkg QEAgdm9pZCBRR3JhcGhpY3NXZWJWaWV3Ojp1cGRhdGVHZW9tZXRyeSgpCiAKICAgICBRU2l6ZSBz aXplID0gZ2VvbWV0cnkoKS5zaXplKCkudG9TaXplKCk7CiAgICAgZC0+cGFnZS0+c2V0Vmlld3Bv cnRTaXplKHNpemUpOworICAgIAorICAgIGlmIChXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSog YmFja2luZ1N0b3JlID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgp KS0+dGlsZWRCYWNraW5nU3RvcmUoKSkKKyAgICAgICAgYmFja2luZ1N0b3JlLT52aWV3cG9ydENo YW5nZWQoV2ViQ29yZTo6SW50UmVjdChkLT52aXNpYmxlUmVjdCgpKSk7CiB9CiAKIC8qISBccmVp bXAKQEAgLTc1Miw2ICs3OTIsOSBAQCB2b2lkIFFHcmFwaGljc1dlYlZpZXc6OnNldEdlb21ldHJ5 KGNvbnN0CiAgICAgLy8gdGhlIGdlb21ldHJ5IGlzIHdpdGhpbiBsZWdhbCBib3VuZHMgKG1pbmlt dW1TaXplLCBtYXhpbXVtU2l6ZSkKICAgICBRU2l6ZSBzaXplID0gZ2VvbWV0cnkoKS5zaXplKCku dG9TaXplKCk7CiAgICAgZC0+cGFnZS0+c2V0Vmlld3BvcnRTaXplKHNpemUpOworICAgIAorICAg IGlmIChXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0gUVdlYkZyYW1l UHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5nU3RvcmUoKSkK KyAgICAgICAgYmFja2luZ1N0b3JlLT52aWV3cG9ydENoYW5nZWQoV2ViQ29yZTo6SW50UmVjdChk LT52aXNpYmxlUmVjdCgpKSk7CiB9CiAKIC8qIQpAQCAtOTgwLDYgKzEwMjMsNDggQEAgYm9vbCBR R3JhcGhpY3NXZWJWaWV3OjpyZXNpemVzVG9Db250ZW50cwogICAgIHJldHVybiBkLT5yZXNpemVz VG9Db250ZW50czsKIH0KIAorZmxvYXQgUUdyYXBoaWNzV2ViVmlldzo6dGlsZWRCYWNraW5nU3Rv cmVTY2FsZUZhY3RvcigpIGNvbnN0Cit7CisgICAgaWYgKCFwYWdlKCkpCisgICAgICAgIHJldHVy biAxLmY7CisgICAgV2ViQ29yZTo6VGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSA9IFFX ZWJGcmFtZVByaXZhdGU6OmNvcmUocGFnZSgpLT5tYWluRnJhbWUoKSktPnRpbGVkQmFja2luZ1N0 b3JlKCk7CisgICAgaWYgKCFiYWNraW5nU3RvcmUpCisgICAgICAgIHJldHVybiAxLmY7CisgICAg cmV0dXJuIGJhY2tpbmdTdG9yZS0+Y29udGVudHNTY2FsZSgpOworfQorCit2b2lkIFFHcmFwaGlj c1dlYlZpZXc6OnNldFRpbGVkQmFja2luZ1N0b3JlU2NhbGVGYWN0b3IoZmxvYXQgc2NhbGVGYWN0 b3IpCit7CisgICAgLy8gRklYTUU6IHNob3VsZCBwcm9iYWJseSBhbGxvdyBzZXR0aW5nIHRoZSBz Y2FsZSBpbmRlcGVuZGVudCBvZiBhbHJlYWR5IGhhdmluZyB0aGUgYmFja2luZyBzdG9yZQorICAg IGlmICghcGFnZSgpKQorICAgICAgICByZXR1cm47CisgICAgV2ViQ29yZTo6VGlsZWRCYWNraW5n U3RvcmUqIGJhY2tpbmdTdG9yZSA9IFFXZWJGcmFtZVByaXZhdGU6OmNvcmUocGFnZSgpLT5tYWlu RnJhbWUoKSktPnRpbGVkQmFja2luZ1N0b3JlKCk7CisgICAgaWYgKCFiYWNraW5nU3RvcmUpCisg ICAgICAgIHJldHVybjsKKyAgICBiYWNraW5nU3RvcmUtPnNldENvbnRlbnRzU2NhbGUoc2NhbGVG YWN0b3IpOworfQorCitib29sIFFHcmFwaGljc1dlYlZpZXc6OnRpbGVkQmFja2luZ1N0b3JlRnJv emVuKCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTogc2hvdWxkIHByb2JhYmx5IGFsbG93IHNldHRp bmcgdGhlIHNjYWxlIGluZGVwZW5kZW50IG9mIGFscmVhZHkgaGF2aW5nIHRoZSBiYWNraW5nIHN0 b3JlCisgICAgaWYgKCFwYWdlKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBXZWJDb3Jl OjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29y ZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5nU3RvcmUoKTsKKyAgICBpZiAoIWJh Y2tpbmdTdG9yZSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBiYWNraW5nU3Rv cmUtPmNvbnRlbnRzRnJvemVuKCk7Cit9CisKK3ZvaWQgUUdyYXBoaWNzV2ViVmlldzo6c2V0VGls ZWRCYWNraW5nU3RvcmVGcm96ZW4oYm9vbCBmcm96ZW4pCit7CisgICAgaWYgKCFwYWdlKCkpCisg ICAgICAgIHJldHVybjsKKyAgICBXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0 b3JlID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRC YWNraW5nU3RvcmUoKTsKKyAgICBpZiAoIWJhY2tpbmdTdG9yZSkKKyAgICAgICAgcmV0dXJuOwor ICAgIGJhY2tpbmdTdG9yZS0+c2V0Q29udGVudHNGcm96ZW4oZnJvemVuKTsKK30KKwogLyohIFxy ZWltcAogKi8KIHZvaWQgUUdyYXBoaWNzV2ViVmlldzo6aG92ZXJNb3ZlRXZlbnQoUUdyYXBoaWNz U2NlbmVIb3ZlckV2ZW50KiBldikKSW5kZXg6IFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmll dy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCShyZXZp c2lvbiA1NDc3NCkKKysrIFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCSh3b3JraW5n IGNvcHkpCkBAIC04Myw2ICs4MywxMiBAQCBwdWJsaWM6CiAgICAgYm9vbCByZXNpemVzVG9Db250 ZW50cygpIGNvbnN0OwogICAgIHZvaWQgc2V0UmVzaXplc1RvQ29udGVudHMoYm9vbCBlbmFibGVk KTsKIAorICAgIGJvb2wgdGlsZWRCYWNraW5nU3RvcmVGcm96ZW4oKSBjb25zdDsKKyAgICB2b2lk IHNldFRpbGVkQmFja2luZ1N0b3JlRnJvemVuKGJvb2wgZnJvemVuKTsKKyAgICAKKyAgICBmbG9h dCB0aWxlZEJhY2tpbmdTdG9yZVNjYWxlRmFjdG9yKCkgY29uc3Q7CisgICAgdm9pZCBzZXRUaWxl ZEJhY2tpbmdTdG9yZVNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlRmFjdG9yKTsKKwogICAgIHZpcnR1 YWwgdm9pZCBzZXRHZW9tZXRyeShjb25zdCBRUmVjdEYmIHJlY3QpOwogICAgIHZpcnR1YWwgdm9p ZCB1cGRhdGVHZW9tZXRyeSgpOwogICAgIHZpcnR1YWwgdm9pZCBwYWludChRUGFpbnRlciosIGNv bnN0IFFTdHlsZU9wdGlvbkdyYXBoaWNzSXRlbSogb3B0aW9ucywgUVdpZGdldCogd2lkZ2V0ID0g MCk7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCShyZXZpc2lvbiA1NDc3NCkKKysrIFdlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzA4LDcgKzMwOCw5IEBAIHZvaWQg UVdlYkZyYW1lUHJpdmF0ZTo6cmVuZGVyQ29udGVudHNMYXkKICAgICBRUGFpbnRlciogcGFpbnRl ciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOwogCiAgICAgV2ViQ29yZTo6RnJhbWVWaWV3 KiB2aWV3ID0gZnJhbWUtPnZpZXcoKTsKLSAgICB2aWV3LT5sYXlvdXRJZk5lZWRlZFJlY3Vyc2l2 ZSgpOworICAgIAorICAgIGlmICghZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCkpCisgICAgICAg IHZpZXctPmxheW91dElmTmVlZGVkUmVjdXJzaXZlKCk7CiAKICAgICBmb3IgKGludCBpID0gMDsg aSA8IHZlY3Rvci5zaXplKCk7ICsraSkgewogICAgICAgICBjb25zdCBRUmVjdCYgY2xpcFJlY3Qg PSB2ZWN0b3IuYXQoaSk7CkBAIC0zMTcsNyArMzE5LDEwIEBAIHZvaWQgUVdlYkZyYW1lUHJpdmF0 ZTo6cmVuZGVyQ29udGVudHNMYXkKICAgICAgICAgcGFpbnRlci0+c2V0Q2xpcFJlY3QoY2xpcFJl Y3QsIFF0OjpJbnRlcnNlY3RDbGlwKTsKIAogICAgICAgICBjb250ZXh0LT5zYXZlKCk7Ci0gICAg ICAgIHZpZXctPnBhaW50Q29udGVudHMoY29udGV4dCwgY2xpcFJlY3QpOworICAgICAgICBpZiAo ZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCkpCisgICAgICAgICAgICBmcmFtZS0+dGlsZWRCYWNr aW5nU3RvcmUoKS0+cGFpbnQoY29udGV4dCwgY2xpcFJlY3QpOworICAgICAgICBlbHNlCisgICAg ICAgICAgICB2aWV3LT5wYWludENvbnRlbnRzKGNvbnRleHQsIGNsaXBSZWN0KTsKICAgICAgICAg Y29udGV4dC0+cmVzdG9yZSgpOwogCiAgICAgICAgIHBhaW50ZXItPnJlc3RvcmUoKTsKSW5kZXg6 IFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9x d2ViZnJhbWUuaAkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5o CSh3b3JraW5nIGNvcHkpCkBAIC0yMTgsNiArMjE4LDcgQEAgUV9TSUdOQUxTOgogICAgIHZvaWQg bG9hZEZpbmlzaGVkKGJvb2wgb2spOwogCiBwcml2YXRlOgorICAgIGZyaWVuZCBjbGFzcyBRR3Jh cGhpY3NXZWJWaWV3OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViUGFnZTsKICAgICBmcmllbmQgY2xh c3MgUVdlYlBhZ2VQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJhbWVQcml2YXRlOwpJ bmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJLaXQvcXQv QXBpL3F3ZWJzZXR0aW5ncy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIxOCw2ICsyMTgsMTAgQEAg dm9pZCBRV2ViU2V0dGluZ3NQcml2YXRlOjphcHBseSgpCiAgICAgICAgIHZhbHVlID0gYXR0cmli dXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlhTU0F1ZGl0b3JFbmFibGVkLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJpYnV0ZXMudmFsdWUoUVdlYlNl dHRpbmdzOjpYU1NBdWRpdG9yRW5hYmxlZCkpOwogICAgICAgICBzZXR0aW5ncy0+c2V0WFNTQXVk aXRvckVuYWJsZWQodmFsdWUpOworICAgICAgICAKKyAgICAgICAgdmFsdWUgPSBhdHRyaWJ1dGVz LnZhbHVlKFFXZWJTZXR0aW5nczo6VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJpYnV0ZXMudmFsdWUoUVdl YlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQpKTsKKyAgICAgICAgc2V0dGluZ3Mt PnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCh2YWx1ZSk7CiAKICAgICAgICAgc2V0dGluZ3Mt PnNldFVzZXNQYWdlQ2FjaGUoV2ViQ29yZTo6cGFnZUNhY2hlKCktPmNhcGFjaXR5KCkpOwogICAg IH0gZWxzZSB7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmgJKHJldmlzaW9uIDU0Nzc0KQorKysgV2Vi S2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAtNjksNyArNjksOCBA QCBwdWJsaWM6CiAgICAgICAgIExvY2FsQ29udGVudENhbkFjY2Vzc1JlbW90ZVVybHMsCiAgICAg ICAgIERuc1ByZWZldGNoRW5hYmxlZCwKICAgICAgICAgWFNTQXVkaXRvckVuYWJsZWQsCi0gICAg ICAgIEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkCisgICAgICAgIEFjY2VsZXJhdGVkQ29t cG9zaXRpbmdFbmFibGVkLAorICAgICAgICBUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQKICAgICB9 OwogICAgIGVudW0gV2ViR3JhcGhpYyB7CiAgICAgICAgIE1pc3NpbmdJbWFnZUdyYXBoaWMsCklu ZGV4OiBXZWJLaXQvcXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwCShyZXZpc2lvbiA1NDc3NCkKKysrIFdlYktpdC9xdC9R R1ZMYXVuY2hlci9tYWluLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTAwLDcgKzUwMCw3IEBAIGlu dCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJndikKIHsKICAgICBRQXBwbGljYXRpb24gYXBwKGFy Z2MsIGFyZ3YpOwogICAgIGlmIChhcHAuYXJndW1lbnRzKCkuY29udGFpbnMoIi0taGVscCIpKSB7 Ci0gICAgICAgIHFEZWJ1ZygpIDw8ICJVc2FnZTogUUdWTGF1bmNoZXIgWy0tdXJsIHVybF0gWy0t Y29tcG9zaXRpbmddIFstLXVwZGF0ZU1vZGUgRnVsbHxNaW5pbWFsfFNtYXJ0fE5vfEJvdW5kaW5n UmVjdF0gWy0tY2FjaGVXZWJWaWV3XSBbLS1yZXNpemVzVG9Db250ZW50c11cbiI7CisgICAgICAg IHFEZWJ1ZygpIDw8ICJVc2FnZTogUUdWTGF1bmNoZXIgWy0tdXJsIHVybF0gWy0tY29tcG9zaXRp bmddIFstLXVwZGF0ZU1vZGUgRnVsbHxNaW5pbWFsfFNtYXJ0fE5vfEJvdW5kaW5nUmVjdF0gWy0t Y2FjaGVXZWJWaWV3XSBbLS1yZXNpemVzVG9Db250ZW50c10gWy0tdGlsZWRCYWNraW5nU3RvcmVd XG4iOwogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAgICAgUVN0cmluZyB1cmwgPSBRU3RyaW5n KCJmaWxlOi8vJTEvJTIiKS5hcmcoUURpcjo6aG9tZVBhdGgoKSkuYXJnKFFMYXRpbjFTdHJpbmco ImluZGV4Lmh0bWwiKSk7CkBAIC01MjEsNiArNTIxLDExIEBAIGludCBtYWluKGludCBhcmdjLCBj aGFyKiogYXJndikKICAgICAgICAgdXJsID0gYXJncy5hdCgxKTsKICAgICBpZiAoYXJncy5jb250 YWlucygiLS1jb21wb3NpdGluZyIpKQogICAgICAgICBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRp bmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OkFjY2VsZXJhdGVkQ29tcG9zaXRpbmdF bmFibGVkLCB0cnVlKTsKKyAgICBpZiAoYXJncy5jb250YWlucygiLS10aWxlZEJhY2tpbmdTdG9y ZSIpKSB7CisgICAgICAgIGlmICghYXJncy5jb250YWlucygiLS1yZXNpemVzVG9Db250ZW50cyIp KQorICAgICAgICAgICAgcURlYnVnKCkgPDwgIldhcm5pbmc6IGF0IHRoZSBtb21lbnQgLS10aWxl ZEJhY2tpbmdTdG9yZSBzaG91bGQgYWx3YXlzIGJlIHVzZWQgdG9nZXRoZXIgd2l0aCAtLXJlc2l6 ZXNUb0NvbnRlbnRzIjsKKyAgICAgICAgUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpLT5z ZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQsIHRydWUp OworICAgIH0KIAogICAgIE1haW5XaW5kb3cqIHdpbmRvdyA9IG5ldyBNYWluV2luZG93OwogICAg IHdpbmRvdy0+bG9hZCh1cmwpOwo= 49578 2010-02-26 06:07:16 -0800 2010-02-26 07:41:50 -0800 more updates tiled-backing-store-7.patch text/plain 40909 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcmkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnByaQkocmV2aXNpb24gNTUyNzkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJpCSh3b3JraW5nIGNv cHkpCkBAIC03Nyw2ICs3Nyw5IEBAIGdyZWF0ZXJUaGFuKFFUX01JTk9SX1ZFUlNJT04sIDUpIHsK ICMgSFRNTDUgZGF0YWxpc3Qgc3VwcG9ydAogIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9EQVRB TElTVD0uKTogREVGSU5FUyArPSBFTkFCTEVfREFUQUxJU1Q9MQogCisjIFRpbGVkIEJhY2tpbmcg U3RvcmUgc3VwcG9ydAorIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9USUxFRF9CQUNLSU5HX1NU T1JFPS4pOiBERUZJTkVTICs9IEVOQUJMRV9USUxFRF9CQUNLSU5HX1NUT1JFPTEKKwogIyBOZXNj YXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkpCiAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05F VFNDQVBFX1BMVUdJTl9BUEk9LikgewogICAgIHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNl KjogewpAQCAtMTQ3LDYgKzE1MCw3IEBAIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9KQVZBU0NS SVBUX0RFQlUKIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9PRkZMSU5FX1dFQl9BUFBMSUNBVElP TlM9MSk6IEZFQVRVUkVfREVGSU5FU19KQVZBU0NSSVBUICs9IEVOQUJMRV9PRkZMSU5FX1dFQl9B UFBMSUNBVElPTlM9MQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQl9TT0NLRVRTPTEpOiBG RUFUVVJFX0RFRklORVNfSkFWQVNDUklQVCArPSBFTkFCTEVfV0VCX1NPQ0tFVFM9MQogY29udGFp bnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFT Q1JJUFQgKz0gRU5BQkxFX1RPVUNIX0VWRU5UUz0xCitjb250YWlucyhERUZJTkVTLCBFTkFCTEVf VElMRURfQkFDS0lOR19TVE9SRT0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFTQ1JJUFQgKz0gRU5B QkxFX1RJTEVEX0JBQ0tJTkdfU1RPUkU9MQogCiAKICMjIERlcml2ZWQgc291cmNlIGdlbmVyYXRv cnMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJD b3JlLnBybwkocmV2aXNpb24gNTUyNzkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5n IGNvcHkpCkBAIC04MjYsNiArODI2LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvUGVuLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU2VnbWVudGVkRm9udERhdGEu Y3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5jcHAgXAorICAgIHBs YXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcCBcCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9NYXRyaXhUcmFuc2Zvcm1PcGVyYXRpb24uY3BwIFwKQEAgLTE1 MzIsNiArMTUzMyw5IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3F0L1N0 aWxsSW1hZ2VRdC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TZWdtZW50ZWRGb250RGF0YS5o IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5oIFwKKyAgICBwbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmggXAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0 b3JlLmggXCAgICAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZUNsaWVu dC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL01hdHJpeDNEVHJhbnNmb3Jt T3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvTWF0cml4VHJh bnNmb3JtT3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvUGVy c3BlY3RpdmVUcmFuc2Zvcm1PcGVyYXRpb24uaCBcCkBAIC0yMDI1LDYgKzIwMjksNyBAQCBTT1VS Q0VTICs9IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9Gb250Q3VzdG9tUGxhdGZvcm1EYXRh UXQuY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HbHlwaFBhZ2VUcmVlTm9kZVF0LmNw cCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvcXQvU2ltcGxlRm9udERhdGFRdC5jcHAgXAorICAg IHBsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0tVUkxR dC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0xvY2FsaXphdGlvbnMuY3BwIFwKICAgICBwbGF0Zm9y bS9xdC9NSU1FVHlwZVJlZ2lzdHJ5UXQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNTUyNzkp CisrKyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3 IEBACiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNp bmNsdWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3Rv cmUuaCIKICNpbmNsdWRlICJVc2VyQ29udGVudFVSTFBhdHRlcm4uaCIKICNpbmNsdWRlICJYTUxO U05hbWVzLmgiCiAjaW5jbHVkZSAiWE1MTmFtZXMuaCIKQEAgLTE3MSw5ICsxNzIsMTMgQEAgRnJh bWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRQogICAgIFhNTE5TTmFtZXM6Omlu aXQoKTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwogCi0gICAgaWYgKCFvd25lckVsZW1lbnQpCisg ICAgaWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAgICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMp OwotICAgIGVsc2UgeworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICAv LyBUb3AgbGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAgICAgICBzZXRUaWxlZEJhY2tpbmdT dG9yZUVuYWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkp OworI2VuZGlmCisgICAgfSBlbHNlIHsKICAgICAgICAgcGFnZS0+aW5jcmVtZW50RnJhbWVDb3Vu dCgpOwogICAgICAgICAvLyBNYWtlIHN1cmUgd2Ugd2lsbCBub3QgZW5kIHVwIHdpdGggdHdvIGZy YW1lcyByZWZlcmVuY2luZyB0aGUgc2FtZSBvd25lciBlbGVtZW50LgogICAgICAgICBBU1NFUlQo KCEob3duZXJFbGVtZW50LT5tX2NvbnRlbnRGcmFtZSkpIHx8IChvd25lckVsZW1lbnQtPm1fY29u dGVudEZyYW1lLT5vd25lckVsZW1lbnQoKSAhPSBvd25lckVsZW1lbnQpKTsKQEAgLTE4NDUsNCAr MTg1MCw0OSBAQCB2b2lkIEZyYW1lOjpjcmVhdGVWaWV3KGNvbnN0IEludFNpemUmIHZpCiAgICAg ICAgIHZpZXcoKS0+c2V0Q2FuSGF2ZVNjcm9sbGJhcnMob3duZXItPnNjcm9sbGluZ01vZGUoKSAh PSBTY3JvbGxiYXJBbHdheXNPZmYpOwogfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RP UkUpCit2b2lkIEZyYW1lOjpzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCBlbmFibGVk KQoreworICAgIGlmICghZW5hYmxlZCkgeworICAgICAgICBtX3RpbGVkQmFja2luZ1N0b3JlLmNs ZWFyKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKG1fdGlsZWRCYWNraW5nU3Rv cmUpCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVkQmFja2luZ1N0b3JlLnNldChuZXcgVGls ZWRCYWNraW5nU3RvcmUodGhpcykpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9y ZVBhaW50QmVnaW4oKQoreworICAgIGlmICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAg bV92aWV3LT5sYXlvdXRJZk5lZWRlZFJlY3Vyc2l2ZSgpOworICAgIG1fdmlldy0+Zmx1c2hEZWZl cnJlZFJlcGFpbnRzKCk7Cit9CisKK3ZvaWQgRnJhbWU6OnRpbGVkQmFja2luZ1N0b3JlUGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAgbV92aWV3LT5wYWludENvbnRlbnRzKGNv bnRleHQsIHJlY3QpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZVBhaW50RW5k KGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpCit7CisgICAgaWYgKCFtX3BhZ2Ug fHwgIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIHVuc2lnbmVkIHNpemUgPSBwYWludGVk QXJlYS5zaXplKCk7CisgICAgLy8gUmVxdWVzdCByZXBhaW50IGZyb20gdGhlIHN5c3RlbQorICAg IGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKQorICAgICAgICBtX3BhZ2UtPmNocm9tZSgp LT5yZXBhaW50KG1fdmlldy0+Y29udmVydFRvQ29udGFpbmluZ1dpbmRvdyhwYWludGVkQXJlYVtu XSksIHRydWUpOworfQorCitJbnRSZWN0IEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRz UmVjdCgpCit7CisgICAgaWYgKCFtX3ZpZXcpCisgICAgICAgIHJldHVybiBJbnRSZWN0KCk7Cisg ICAgcmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbV92aWV3LT5jb250ZW50c1NpemUoKSk7Cit9 CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0Zy YW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDU1Mjc5 KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTM3LDYgKzM3LDcg QEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU2Nyb2xsQmVoYXZp b3IuaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiVGlsZWRC YWNraW5nU3RvcmVDbGllbnQuaCIKICNpbmNsdWRlICJVc2VyU2NyaXB0VHlwZXMuaCIKIAogI2lm IFBMQVRGT1JNKFdJTikKQEAgLTYyLDggKzYzLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg IGNsYXNzIENTU011dGFibGVTdHlsZURlY2xhcmF0aW9uOwogICAgIGNsYXNzIEhUTUxUYWJsZUNl bGxFbGVtZW50OwogICAgIGNsYXNzIFJlZ3VsYXJFeHByZXNzaW9uOworICAgIGNsYXNzIFRpbGVk QmFja2luZ1N0b3JlOwogCi0gICAgY2xhc3MgRnJhbWUgOiBwdWJsaWMgUmVmQ291bnRlZDxGcmFt ZT4geworICAgIGNsYXNzIEZyYW1lIDogcHVibGljIFJlZkNvdW50ZWQ8RnJhbWU+LCBwdWJsaWMg VGlsZWRCYWNraW5nU3RvcmVDbGllbnQgewogICAgIHB1YmxpYzoKICAgICAgICAgc3RhdGljIFBh c3NSZWZQdHI8RnJhbWU+IGNyZWF0ZShQYWdlKiBwYWdlLCBIVE1MRnJhbWVPd25lckVsZW1lbnQq IG93bmVyRWxlbWVudCwgRnJhbWVMb2FkZXJDbGllbnQqIGNsaWVudCkKICAgICAgICAgewpAQCAt MTYzLDYgKzE2NSwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICByZXR1cm4g ZG9jdW1lbnQoKSA/IGRvY3VtZW50KCktPmRpc3BsYXlTdHJpbmdNb2RpZmllZEJ5RW5jb2Rpbmco c3RyKSA6IHN0cjsKICAgICAgICAgfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUp CisgICAgICAgIFRpbGVkQmFja2luZ1N0b3JlKiB0aWxlZEJhY2tpbmdTdG9yZSgpIGNvbnN0IHsg cmV0dXJuIG1fdGlsZWRCYWNraW5nU3RvcmUuZ2V0KCk7IH0KKyAgICAgICAgdm9pZCBzZXRUaWxl ZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisjZW5kaWYKKwogICAgIHByaXZhdGU6CiAgICAg ICAgIHZvaWQgbGlmZVN1cHBvcnRUaW1lckZpcmVkKFRpbWVyPEZyYW1lPiopOwogCkBAIC0yNjgs NiArMjc1LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICBWaXNpYmxlUG9zaXRp b24gdmlzaWJsZVBvc2l0aW9uRm9yUG9pbnQoY29uc3QgSW50UG9pbnQmIGZyYW1lUG9pbnQpOwog ICAgICAgICBEb2N1bWVudCogZG9jdW1lbnRBdFBvaW50KGNvbnN0IEludFBvaW50JiB3aW5kb3dQ b2ludCk7CisgICAgICAgIAorICAgIHByaXZhdGU6CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdf U1RPUkUpCisgICAgICAgIC8vIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IGludGVyZmFjZQorICAg ICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCk7CisgICAgICAg IHZpcnR1YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNv bnN0IEludFJlY3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFp bnRFbmQoY29uc3QgVmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSk7CisgICAgICAgIHZpcnR1 YWwgSW50UmVjdCB0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpOworI2VuZGlmCiAKICAg ICAjaWYgUExBVEZPUk0oTUFDKQogCkBAIC0zNDYsNiArMzYyLDEwIEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgYm9vbCBtX25lZWRzUmVhcHBseVN0eWxlczsKICAgICAgICAgYm9vbCBt X2lzRGlzY29ubmVjdGVkOwogICAgICAgICBib29sIG1fZXhjbHVkZUZyb21UZXh0U2VhcmNoOwor CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpICAgICAgICAKKyAgICAgICAgT3duUHRy PFRpbGVkQmFja2luZ1N0b3JlPiBtX3RpbGVkQmFja2luZ1N0b3JlOworI2VuZGlmCiAgICAgfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHJldmlzaW9uIDU1 Mjc5KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTcw LDYgKzcwLDkgQEAKICNpbmNsdWRlICJTVkdWaWV3U3BlYy5oIgogI2VuZGlmCiAKKyNpZiBFTkFC TEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgor I2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtMTAxMSw2ICsxMDE0LDEyIEBAIHZv aWQgRnJhbWVWaWV3OjpyZXBhaW50Q29udGVudFJlY3RhbmdsZSgKICAgICBpZiAoIWltbWVkaWF0 ZSAmJiBpc09mZnNjcmVlbigpICYmICFzaG91bGRVcGRhdGVXaGlsZU9mZnNjcmVlbigpKQogICAg ICAgICByZXR1cm47CiAKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyAgICBpZiAo ZnJhbWUoKS0+dGlsZWRCYWNraW5nU3RvcmUoKSkgeworICAgICAgICBmcmFtZSgpLT50aWxlZEJh Y2tpbmdTdG9yZSgpLT5pbnZhbGlkYXRlKHIpOworICAgICAgICByZXR1cm47CisgICAgfQorI2Vu ZGlmCiAgICAgU2Nyb2xsVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5nbGUociwgaW1tZWRpYXRl KTsKIH0KIApAQCAtMTA4Miw4ICsxMDkxLDE1IEBAIHZvaWQgRnJhbWVWaWV3Ojpkb0RlZmVycmVk UmVwYWludHMoKQogICAgICAgICByZXR1cm47CiAgICAgfQogICAgIHVuc2lnbmVkIHNpemUgPSBt X3JlcGFpbnRSZWN0cy5zaXplKCk7Ci0gICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemU7 IGkrKykKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7CisjaWYgRU5B QkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgICAgIGlmIChmcmFtZSgpLT50aWxlZEJhY2tp bmdTdG9yZSgpKSB7CisgICAgICAgICAgICBmcmFtZSgpLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5p bnZhbGlkYXRlKG1fcmVwYWludFJlY3RzW2ldKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAg ICAgICB9CisjZW5kaWYKICAgICAgICAgU2Nyb2xsVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5n bGUobV9yZXBhaW50UmVjdHNbaV0sIGZhbHNlKTsKKyAgICB9CiAgICAgbV9yZXBhaW50UmVjdHMu Y2xlYXIoKTsKICAgICBtX3JlcGFpbnRDb3VudCA9IDA7CiAgICAgCkluZGV4OiBXZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAJ KHJldmlzaW9uIDU1Mjc5KQorKysgV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAkod29ya2luZyBj b3B5KQpAQCAtMTI0LDYgKzEyNCw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQog ICAgICwgbV9leHBlcmltZW50YWxOb3RpZmljYXRpb25zRW5hYmxlZChmYWxzZSkKICAgICAsIG1f d2ViR0xFbmFibGVkKGZhbHNlKQogICAgICwgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCh0cnVlKQor ICAgICwgbV90aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoZmFsc2UpCiB7CiAgICAgLy8gQSBGcmFt ZSBtYXkgbm90IGhhdmUgYmVlbiBjcmVhdGVkIHlldCwgc28gd2UgaW5pdGlhbGl6ZSB0aGUgQXRv bWljU3RyaW5nIAogICAgIC8vIGhhc2ggYmVmb3JlIHRyeWluZyB0byB1c2UgaXQuCkBAIC01Njgs NCArNTY5LDEzIEBAIHZvaWQgU2V0dGluZ3M6OnNldExvYWREZWZlcnJpbmdFbmFibGVkKGIKICAg ICBtX2xvYWREZWZlcnJpbmdFbmFibGVkID0gZW5hYmxlZDsKIH0KIAordm9pZCBTZXR0aW5nczo6 c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wgZW5hYmxlZCkKK3sKKyAgICBtX3RpbGVk QmFja2luZ1N0b3JlRW5hYmxlZCA9IGVuYWJsZWQ7CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdf U1RPUkUpCisgICAgaWYgKG1fcGFnZS0+bWFpbkZyYW1lKCkpCisgICAgICAgIG1fcGFnZS0+bWFp bkZyYW1lKCktPnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZChlbmFibGVkKTsKKyNlbmRpZgor fQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkocmV2aXNpb24gNTUyNzkp CisrKyBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAtMjg2LDYgKzI4 Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2b2lkIHNldExvYWREZWZlcnJp bmdFbmFibGVkKGJvb2wpOwogICAgICAgICBib29sIGxvYWREZWZlcnJpbmdFbmFibGVkKCkgY29u c3QgeyByZXR1cm4gbV9sb2FkRGVmZXJyaW5nRW5hYmxlZDsgfQorICAgICAgICAKKyAgICAgICAg dm9pZCBzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisgICAgICAgIGJvb2wgdGls ZWRCYWNraW5nU3RvcmVFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV90aWxlZEJhY2tpbmdTdG9y ZUVuYWJsZWQ7IH0KIAogICAgIHByaXZhdGU6CiAgICAgICAgIFBhZ2UqIG1fcGFnZTsKQEAgLTM2 MCw2ICszNjMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGJvb2wgbV9leHBlcmlt ZW50YWxOb3RpZmljYXRpb25zRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV93ZWJHTEVuYWJs ZWQgOiAxOwogICAgICAgICBib29sIG1fbG9hZERlZmVycmluZ0VuYWJsZWQgOiAxOworICAgICAg ICBib29sIG1fdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkIDogMTsKIAogI2lmIFVTRShTQUZBUklf VEhFTUUpCiAgICAgICAgIHN0YXRpYyBib29sIGdTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzOwpJ bmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1RpbGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5MCBAQAorLyoK KyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRp YXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgVGlsZV9oCisj ZGVmaW5lIFRpbGVfaAorCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNs dWRlICJJbnRSZWN0LmgiCisjaW5jbHVkZSA8d3RmL0hhc2hGdW5jdGlvbnMuaD4KKyNpbmNsdWRl IDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisKKyNpZiBQ TEFURk9STShRVCkKK2NsYXNzIFFQaXhtYXA7CitjbGFzcyBRUmVnaW9uOworI2VuZGlmCisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDsKK2NsYXNzIFRp bGVkQmFja2luZ1N0b3JlOworCitjbGFzcyBUaWxlIDogcHVibGljIFJlZkNvdW50ZWQ8VGlsZT4K K3sKK3B1YmxpYzoKKyAgICBjbGFzcyBDb29yZGluYXRlIHsKKyAgICBwdWJsaWM6CisgICAgICAg IENvb3JkaW5hdGUodW5zaWduZWQgeCwgdW5zaWduZWQgeSkgOiBtX3goeCksIG1feSh5KSB7IH0K KyAgICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IENvb3JkaW5hdGUmIG8pIGNvbnN0IHsgcmV0 dXJuIG1feCA9PSBvLm1feCAmJiBtX3kgPT0gby5tX3k7IH0KKyAgICAgICAgdW5zaWduZWQgeCgp IGNvbnN0IHsgcmV0dXJuIG1feDsgfQorICAgICAgICB1bnNpZ25lZCB5KCkgY29uc3QgeyByZXR1 cm4gbV95OyB9CisgICAgICAgIHVuc2lnbmVkIGhhc2goKSBjb25zdCB7CisgICAgICAgICAgICB1 bnNpZ25lZCBoYXNoID0gV1RGOjppbnRIYXNoKHN0YXRpY19jYXN0PHVpbnQ2NF90PihtX3gpIDw8 IDMyIHwgbV95KTsKKyAgICAgICAgICAgIC8vIGF2b2lkIGVtcHR5IGFuZCBkZWxldGVkIHZhbHVl CisgICAgICAgICAgICByZXR1cm4gaGFzaCB8ICghKGhhc2ggKyAxKSA8PCAzMSk7CisgICAgICAg IH0KKyAgICBwcml2YXRlOgorICAgICAgICB1bnNpZ25lZCBtX3g7CisgICAgICAgIHVuc2lnbmVk IG1feTsKKyAgICB9OworCisgICAgc3RhdGljIFBhc3NSZWZQdHI8VGlsZT4gY3JlYXRlKFRpbGVk QmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUsIGNvbnN0IENvb3JkaW5hdGUmIHRpbGVDb29yZGlu YXRlKSB7IHJldHVybiBhZG9wdFJlZihuZXcgVGlsZShiYWNraW5nU3RvcmUsIHRpbGVDb29yZGlu YXRlKSk7IH0KKyAgICB+VGlsZSgpOworICAgIAorICAgIGJvb2wgaXNEaXJ0eSgpIGNvbnN0Owor ICAgIHZvaWQgaW52YWxpZGF0ZShjb25zdCBJbnRSZWN0Jik7CisgICAgdm9pZCB1cGRhdGVCYWNr QnVmZmVyKCk7CisgICAgdm9pZCBzd2FwQmFja0J1ZmZlclRvRnJvbnQoKTsKKyAgICBib29sIGlz UmVhZHlUb1BhaW50KCkgY29uc3Q7CisgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBj b25zdCBJbnRSZWN0Jik7CisKKyAgICBjb25zdCBUaWxlOjpDb29yZGluYXRlIGNvb3JkaW5hdGUo KSBjb25zdCB7IHJldHVybiBtX2Nvb3JkaW5hdGU7IH0KKyAgICBjb25zdCBJbnRSZWN0JiByZWN0 KCkgY29uc3QgeyByZXR1cm4gbV9yZWN0OyB9CisgICAgCisgICAgc3RhdGljIHZvaWQgcGFpbnRD aGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqLCBjb25zdCBGbG9hdFJlY3QmKTsKKworcHJp dmF0ZToKKyAgICBUaWxlKFRpbGVkQmFja2luZ1N0b3JlKiwgY29uc3QgQ29vcmRpbmF0ZSYpOwor ICAgIAorICAgIFRpbGVkQmFja2luZ1N0b3JlKiBtX2JhY2tpbmdTdG9yZTsKKyAgICBDb29yZGlu YXRlIG1fY29vcmRpbmF0ZTsKKyAgICBJbnRSZWN0IG1fcmVjdDsKKworI2lmIFBMQVRGT1JNKFFU KQorICAgIFFQaXhtYXAqIG1fYnVmZmVyOworICAgIFFQaXhtYXAqIG1fYmFja0J1ZmZlcjsKKyAg ICBRUmVnaW9uKiBtX2RpcnR5UmVnaW9uOworI2VuZGlmCit9OworCit9CisjZW5kaWYKKyNlbmRp ZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9y ZS5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFj a2luZ1N0b3JlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNjIgQEAKKy8qCisgQ29weXJp Z2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVz KQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBCb3N0 b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NU T1JFKQorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCisjaW5jbHVkZSAiVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworICAgIAorc3RhdGljIGNv bnN0IGludCBkZWZhdWx0VGlsZVdpZHRoID0gNTEyOworc3RhdGljIGNvbnN0IGludCBkZWZhdWx0 VGlsZUhlaWdodCA9IDUxMjsKKworVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVkQmFja2luZ1N0b3Jl KFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50KiBjbGllbnQpCisgICAgOiBtX2NsaWVudChjbGllbnQp CisgICAgLCBtX3RpbGVCdWZmZXJVcGRhdGVUaW1lcihuZXcgVGlsZVRpbWVyKHRoaXMsICZUaWxl ZEJhY2tpbmdTdG9yZTo6dGlsZUJ1ZmZlclVwZGF0ZVRpbWVyRmlyZWQpKQorICAgICwgbV90aWxl Q3JlYXRpb25UaW1lcihuZXcgVGlsZVRpbWVyKHRoaXMsICZUaWxlZEJhY2tpbmdTdG9yZTo6dGls ZUNyZWF0aW9uVGltZXJGaXJlZCkpCisgICAgLCBtX3RpbGVTaXplKGRlZmF1bHRUaWxlV2lkdGgs IGRlZmF1bHRUaWxlSGVpZ2h0KQorICAgICwgbV9jb250ZW50c1NjYWxlKDEuZikKK3sKK30KKwor VGlsZWRCYWNraW5nU3RvcmU6On5UaWxlZEJhY2tpbmdTdG9yZSgpCit7CisgICAgZGVsZXRlIG1f dGlsZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIGRlbGV0ZSBtX3RpbGVDcmVhdGlvblRpbWVyOwor fQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjppbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGNv bnRlbnRzRGlydHlSZWN0KQoreworICAgIEludFJlY3QgZGlydHlSZWN0KG1hcEZyb21Db250ZW50 cyhjb250ZW50c0RpcnR5UmVjdCkpOworICAgIAorICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVm dCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGls ZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlS ZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIAorICAgIGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUg PSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueSgpOyArK3lDb29yZGlu YXRlKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgeENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsg eENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgpOyArK3hDb29yZGluYXRlKSB7CisgICAgICAg ICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRpbGUgPSB0aWxlQXQoVGlsZTo6Q29vcmRpbmF0ZSh4 Q29vcmRpbmF0ZSwgeUNvb3JkaW5hdGUpKTsKKyAgICAgICAgICAgIGlmICghY3VycmVudFRpbGUp CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBjdXJyZW50VGlsZS0+aW52 YWxpZGF0ZShkaXJ0eVJlY3QpOworICAgICAgICB9CisgICAgfQorCisgICAgc3RhcnRUaWxlQnVm ZmVyVXBkYXRlVGltZXIoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dXBkYXRlVGls ZUJ1ZmZlcnMoKQoreworICAgIGlmIChtX2NvbnRlbnRzRnJvemVuKQorICAgICAgICByZXR1cm47 CisgICAgCisgICAgVmVjdG9yPEludFJlY3Q+IHBhaW50ZWRBcmVhOworICAgIFZlY3RvcjxSZWZQ dHI8VGlsZT4gPiBkaXJ0eVRpbGVzOworICAgIFRpbGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGls ZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4o KTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIGlmICghaXQtPnNlY29uZC0+aXNEaXJ0eSgp KQorICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIGRpcnR5VGlsZXMuYXBwZW5kKGl0LT5z ZWNvbmQpOworICAgICAgICAvLyBGSVhNRTogc2hvdWxkIG5vdCByZXF1ZXN0IHN5c3RlbSByZXBh aW50IGZvciB0aGUgZnVsbCB0aWxlLgorICAgICAgICBwYWludGVkQXJlYS5hcHBlbmQobWFwVG9D b250ZW50cyhpdC0+c2Vjb25kLT5yZWN0KCkpKTsKKyAgICB9CisgICAgCisgICAgaWYgKGRpcnR5 VGlsZXMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgbV9jbGllbnQtPnRp bGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOworCisgICAgLy8gRklYTUU6IEluIHNpbmdsZSB0 aHJlYWRlZCBjYXNlLCB0aWxlIGJhY2sgYnVmZmVycyBjb3VsZCBiZSB1cGRhdGVkIGFzeW5jaHJv bm91c2x5IAorICAgIC8vIG9uZSBieSBvbmUgYW5kIHRoZW4gc3dhcHBlZCB0byBmcm9udCBpbiBv bmUgZ28uIFRoaXMgd291bGQgbWluaW1pemUgdGhlIHRpbWUgc3BlbnQKKyAgICAvLyBibG9ja2lu ZyBvbiB0aWxlIHVwZGF0ZXMuCisgICAgdW5zaWduZWQgc2l6ZSA9IGRpcnR5VGlsZXMuc2l6ZSgp OworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5 VGlsZXNbbl0tPnVwZGF0ZUJhY2tCdWZmZXIoKTsKKworICAgIGZvciAodW5zaWduZWQgbiA9IDA7 IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnN3YXBCYWNrQnVmZmVyVG9G cm9udCgpOworCisgICAgbV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQocGFpbnRl ZEFyZWEpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpwYWludChHcmFwaGljc0NvbnRl eHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgY29udGV4dC0+c2F2ZSgp OworICAgIAorICAgIC8vIEFzc3VtZXMgdGhlIGJhY2tpbmcgc3RvcmUgaXMgcGFpbnRlZCB3aXRo IHRoZSBzY2FsZSB0cmFuc2Zvcm0gYXBwbGllZC4KKyAgICAvLyBTaW5jZSB0aWxlIGNvbnRlbnQg aXMgYWxyZWFkeSBzY2FsZWQsIGZpcnN0IHJldmVydCB0aGUgc2NhbGluZyBmcm9tIHRoZSBwYWlu dGVyLgorICAgIGNvbnRleHQtPnNjYWxlKEZsb2F0U2l6ZSgxLmYgLyBtX2NvbnRlbnRzU2NhbGUs IDEuZiAvIG1fY29udGVudHNTY2FsZSkpOworICAgIAorICAgIEludFJlY3QgZGlydHlSZWN0ID0g bWFwRnJvbUNvbnRlbnRzKHJlY3QpOworICAgIAorICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVm dCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGls ZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlS ZWN0LmJvdHRvbVJpZ2h0KCkpOworCisgICAgZm9yICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRv cExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUp IHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29vcmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29v cmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsreENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAg IFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGlu YXRlKTsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxlPiBjdXJyZW50VGlsZSA9IHRpbGVBdChjdXJy ZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICBpZiAoY3VycmVudFRpbGUgJiYgY3VycmVudFRp bGUtPmlzUmVhZHlUb1BhaW50KCkpCisgICAgICAgICAgICAgICAgY3VycmVudFRpbGUtPnBhaW50 KGNvbnRleHQsIGRpcnR5UmVjdCk7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgICAg ICBGbG9hdFJlY3QgdGlsZVJlY3QgPSB0aWxlUmVjdEZvckNvb3JkaW5hdGUoY3VycmVudENvb3Jk aW5hdGUpOworICAgICAgICAgICAgICAgIEZsb2F0UmVjdCB0YXJnZXQgPSBpbnRlcnNlY3Rpb24o dGlsZVJlY3QsIEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgICAgICAgICAgVGlsZTo6cGFpbnRD aGVja2VyUGF0dGVybihjb250ZXh0LCB0YXJnZXQpOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgfQorICAgIGNvbnRleHQtPnJlc3RvcmUoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdT dG9yZTo6dmlld3BvcnRDaGFuZ2VkKGNvbnN0IEludFJlY3QmIGNvbnRlbnRzVmlld3BvcnQpCit7 CisgICAgSW50UmVjdCB2aWV3cG9ydCA9IG1hcEZyb21Db250ZW50cyhjb250ZW50c1ZpZXdwb3J0 KTsKKyAgICBpZiAobV92aWV3cG9ydCA9PSB2aWV3cG9ydCkKKyAgICAgICAgcmV0dXJuOworCisg ICAgbV92aWV3cG9ydCA9IHZpZXdwb3J0OworCisgICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigp OworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzZXRDb250ZW50c1NjYWxlKGZsb2F0IHNj YWxlKQoreworICAgIGlmIChtX2NvbnRlbnRzU2NhbGUgPT0gc2NhbGUpCisgICAgICAgIHJldHVy bjsKKyAgICBtX2NvbnRlbnRzU2NhbGUgPSBzY2FsZTsKKworICAgIGludmFsaWRhdGUobV9jbGll bnQtPnRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNSZWN0KCkpOworfQorICAgIAorZG91YmxlIFRp bGVkQmFja2luZ1N0b3JlOjp0aWxlRGlzdGFuY2UoY29uc3QgSW50UmVjdCYgdmlld3BvcnQsIGNv bnN0IFRpbGU6OkNvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQoreworICAgIGlmICh2aWV3cG9y dC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpKQorICAg ICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQb2ludCB2aWV3Q2VudGVyID0gdmlld3BvcnQu bG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQud2lkdGgoKSAvIDIsIHZpZXdwb3J0LmhlaWdo dCgpIC8gMik7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBjZW50ZXJDb29yZGluYXRlID0gdGlsZUNv b3JkaW5hdGVGb3JQb2ludCh2aWV3Q2VudGVyKTsKKyAgICAKKyAgICAvLyBNYW5oYXR0YW4gZGlz dGFuY2UsIGJpYXNlZCBzbyB0aGF0IHZlcnRpY2FsIGRpc3RhbmNlcyBhcmUgc2hvcnRlci4KKyAg ICBjb25zdCBkb3VibGUgaG9yaXpvbnRhbEJpYXMgPSAxLjM7CisgICAgcmV0dXJuIGFicyhjZW50 ZXJDb29yZGluYXRlLnkoKSAtIHRpbGVDb29yZGluYXRlLnkoKSkgKyBob3Jpem9udGFsQmlhcyAq IGFicyhjZW50ZXJDb29yZGluYXRlLngoKSAtIHRpbGVDb29yZGluYXRlLngoKSk7Cit9CisKK3Zv aWQgVGlsZWRCYWNraW5nU3RvcmU6OmNyZWF0ZVRpbGVzKCkKK3sKKyAgICBpZiAobV9jb250ZW50 c0Zyb3plbikKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG1fdmlld3BvcnQuaXNFbXB0eSgp KQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBSZW1vdmUgdGlsZXMgdGhhdCBleHRlbmQgb3V0 c2lkZSB0aGUgY3VycmVudCBjb250ZW50cyByZWN0LgorICAgIGRyb3BPdmVyaGFuZ2luZ1RpbGVz KCk7CisKKyAgICAvLyBGSVhNRTogTWFrZSBjb25maWd1cmFibGUvYWRhcHQgdG8gbWVtb3J5Lgor ICAgIEludFJlY3Qga2VlcFJlY3QgPSBtX3ZpZXdwb3J0OworICAgIGtlZXBSZWN0LmluZmxhdGVY KG1fdmlld3BvcnQud2lkdGgoKSk7CisgICAga2VlcFJlY3QuaW5mbGF0ZVkoMyAqIG1fdmlld3Bv cnQuaGVpZ2h0KCkpOworICAgIGtlZXBSZWN0LmludGVyc2VjdChjb250ZW50c1JlY3QoKSk7Cisg ICAgCisgICAgZHJvcFRpbGVzT3V0c2lkZVJlY3Qoa2VlcFJlY3QpOworICAgIAorICAgIEludFJl Y3QgY292ZXJSZWN0ID0gbV92aWV3cG9ydDsKKyAgICBjb3ZlclJlY3QuaW5mbGF0ZVgobV92aWV3 cG9ydC53aWR0aCgpIC8gMik7CisgICAgY292ZXJSZWN0LmluZmxhdGVZKDIgKiBtX3ZpZXdwb3J0 LmhlaWdodCgpKTsKKyAgICBjb3ZlclJlY3QuaW50ZXJzZWN0KGNvbnRlbnRzUmVjdCgpKTsKKyAg ICAKKyAgICBkb3VibGUgc2hvcnRlc3REaXN0YW5jZSA9IHN0ZDo6bnVtZXJpY19saW1pdHM8ZG91 YmxlPjo6aW5maW5pdHkoKTsKKyAgICBWZWN0b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdGlsZXNUb0Ny ZWF0ZTsKKyAgICB1bnNpZ25lZCByZXF1aXJlZFRpbGVDb3VudCA9IDA7CisgICAgCisgICAgVGls ZTo6Q29vcmRpbmF0ZSB0b3BMZWZ0ID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb3ZlclJlY3Qu dG9wTGVmdCgpKTsKKyAgICBUaWxlOjpDb29yZGluYXRlIGJvdHRvbVJpZ2h0ID0gdGlsZUNvb3Jk aW5hdGVGb3JQb2ludChjb3ZlclJlY3QuYm90dG9tUmlnaHQoKSk7CisgICAgZm9yICh1bnNpZ25l ZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC55 KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29vcmRpbmF0ZSA9 IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsreENvb3JkaW5h dGUpIHsKKyAgICAgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENv b3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmICh0aWxlQXQoY3VycmVudENv b3JkaW5hdGUpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgKytyZXF1 aXJlZFRpbGVDb3VudDsKKyAgICAgICAgICAgIC8vIDAgZGlzdGFuY2UgZm9yIGN1cnJlbnRseSB2 aXNpYmxlIHRpbGVzLgorICAgICAgICAgICAgZG91YmxlIGRpc3RhbmNlID0gdGlsZURpc3RhbmNl KG1fdmlld3BvcnQsIGN1cnJlbnRDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmIChkaXN0YW5j ZSA+IHNob3J0ZXN0RGlzdGFuY2UpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICBpZiAoZGlzdGFuY2UgPCBzaG9ydGVzdERpc3RhbmNlKSB7CisgICAgICAgICAgICAgICAg dGlsZXNUb0NyZWF0ZS5jbGVhcigpOworICAgICAgICAgICAgICAgIHNob3J0ZXN0RGlzdGFuY2Ug PSBkaXN0YW5jZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHRpbGVzVG9DcmVhdGUuYXBw ZW5kKGN1cnJlbnRDb29yZGluYXRlKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICB1bnNp Z25lZCB0aWxlc1RvQ3JlYXRlQ291bnQgPSB0aWxlc1RvQ3JlYXRlLnNpemUoKTsKKyAgICBpZiAo dGlsZXNUb0NyZWF0ZUNvdW50KSB7CisgICAgICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCB0 aWxlc1RvQ3JlYXRlQ291bnQ7ICsrbikgeworICAgICAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBj b29yZGluYXRlID0gdGlsZXNUb0NyZWF0ZVtuXTsKKyAgICAgICAgICAgIHNldFRpbGUoY29vcmRp bmF0ZSwgVGlsZTo6Y3JlYXRlKHRoaXMsIGNvb3JkaW5hdGUpKTsKKyAgICAgICAgfQorICAgICAg ICByZXF1aXJlZFRpbGVDb3VudCAtPSB0aWxlc1RvQ3JlYXRlQ291bnQ7CisgICAgfQorICAgIAor ICAgIC8vIFBhaW50IHRoZSBjb250ZW50IG9mIHRoZSBuZXdseSBjcmVhdGVkIHRpbGVzCisgICAg aWYgKHRpbGVzVG9DcmVhdGVDb3VudCkKKyAgICAgICAgdXBkYXRlVGlsZUJ1ZmZlcnMoKTsKKwor ICAgIC8vIEtlZXAgY3JlYXRpbmcgdGlsZXMgdW50aWwgdGhlIHdob2xlIGNvdmVyUmVjdCBpcyBj b3ZlcmVkLgorICAgIGlmIChyZXF1aXJlZFRpbGVDb3VudCkKKyAgICAgICAgbV90aWxlQ3JlYXRp b25UaW1lci0+c3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpk cm9wT3ZlcmhhbmdpbmdUaWxlcygpCit7ICAgIAorICAgIEludFJlY3QgY29udGVudHNSZWN0ID0g dGhpcy0+Y29udGVudHNSZWN0KCk7CisKKyAgICBWZWN0b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdGls ZXNUb1JlbW92ZTsKKyAgICBUaWxlTWFwOjppdGVyYXRvciBlbmQgPSBtX3RpbGVzLmVuZCgpOwor ICAgIGZvciAoVGlsZU1hcDo6aXRlcmF0b3IgaXQgPSBtX3RpbGVzLmJlZ2luKCk7IGl0ICE9IGVu ZDsgKytpdCkgeworICAgICAgICBUaWxlOjpDb29yZGluYXRlIHRpbGVDb29yZGluYXRlID0gaXQt PnNlY29uZC0+Y29vcmRpbmF0ZSgpOworICAgICAgICBJbnRSZWN0IHRpbGVSZWN0ID0gaXQtPnNl Y29uZC0+cmVjdCgpOworICAgICAgICBJbnRSZWN0IGV4cGVjdGVkVGlsZVJlY3QgPSB0aWxlUmVj dEZvckNvb3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpOworICAgICAgICBpZiAoZXhwZWN0ZWRUaWxl UmVjdCAhPSB0aWxlUmVjdCB8fCAhY29udGVudHNSZWN0LmNvbnRhaW5zKHRpbGVSZWN0KSkKKyAg ICAgICAgICAgIHRpbGVzVG9SZW1vdmUuYXBwZW5kKHRpbGVDb29yZGluYXRlKTsKKyAgICB9Cisg ICAgdW5zaWduZWQgcmVtb3ZlQ291bnQgPSB0aWxlc1RvUmVtb3ZlLnNpemUoKTsKKyAgICBmb3Ig KHVuc2lnbmVkIG4gPSAwOyBuIDwgcmVtb3ZlQ291bnQ7ICsrbikKKyAgICAgICAgcmVtb3ZlVGls ZSh0aWxlc1RvUmVtb3ZlW25dKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6ZHJvcFRp bGVzT3V0c2lkZVJlY3QoY29uc3QgSW50UmVjdCYga2VlcFJlY3QpCit7CisgICAgRmxvYXRSZWN0 IGtlZXBSZWN0RiA9IGtlZXBSZWN0OworCisgICAgVmVjdG9yPFRpbGU6OkNvb3JkaW5hdGU+IHRv UmVtb3ZlOworICAgIFRpbGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAg Zm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyAr K2l0KSB7CisgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY29vcmRpbmF0ZSA9IGl0LT5zZWNvbmQt PmNvb3JkaW5hdGUoKTsKKyAgICAgICAgRmxvYXRSZWN0IHRpbGVSZWN0ID0gaXQtPnNlY29uZC0+ cmVjdCgpOworICAgICAgICBpZiAoIXRpbGVSZWN0LmludGVyc2VjdHMoa2VlcFJlY3RGKSkKKyAg ICAgICAgICAgIHRvUmVtb3ZlLmFwcGVuZChjb29yZGluYXRlKTsKKyAgICB9CisgICAgdW5zaWdu ZWQgcmVtb3ZlQ291bnQgPSB0b1JlbW92ZS5zaXplKCk7CisgICAgZm9yICh1bnNpZ25lZCBuID0g MDsgbiA8IHJlbW92ZUNvdW50OyArK24pCisgICAgICAgIHJlbW92ZVRpbGUodG9SZW1vdmVbbl0p OworfQorCitQYXNzUmVmUHRyPFRpbGU+IFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQXQoY29uc3Qg VGlsZTo6Q29vcmRpbmF0ZSYgY29vcmRpbmF0ZSkgY29uc3QKK3sKKyAgICByZXR1cm4gbV90aWxl cy5nZXQoY29vcmRpbmF0ZS5oYXNoKCkpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpz ZXRUaWxlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NSZWZQdHI8VGls ZT4gdGlsZSkKK3sKKyAgICBtX3RpbGVzLnNldChjb29yZGluYXRlLmhhc2goKSwgdGlsZSk7Cit9 CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnJlbW92ZVRpbGUoY29uc3QgVGlsZTo6Q29vcmRp bmF0ZSYgY29vcmRpbmF0ZSkKK3sKKyAgICBtX3RpbGVzLnJlbW92ZShjb29yZGluYXRlLmhhc2go KSk7Cit9CisKK0ludFJlY3QgVGlsZWRCYWNraW5nU3RvcmU6Om1hcFRvQ29udGVudHMoY29uc3Qg SW50UmVjdCYgcmVjdCkgY29uc3QKK3sKKyAgICByZXR1cm4gZW5jbG9zaW5nSW50UmVjdChGbG9h dFJlY3QocmVjdC54KCkgLyBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QueSgpIC8gbV9j b250ZW50c1NjYWxlLAorICAgICAgICByZWN0LndpZHRoKCkgLyBtX2NvbnRlbnRzU2NhbGUsCisg ICAgICAgIHJlY3QuaGVpZ2h0KCkgLyBtX2NvbnRlbnRzU2NhbGUpKTsKK30KKworSW50UmVjdCBU aWxlZEJhY2tpbmdTdG9yZTo6bWFwRnJvbUNvbnRlbnRzKGNvbnN0IEludFJlY3QmIHJlY3QpIGNv bnN0Cit7CisgICAgcmV0dXJuIGVuY2xvc2luZ0ludFJlY3QoRmxvYXRSZWN0KHJlY3QueCgpICog bV9jb250ZW50c1NjYWxlLAorICAgICAgICByZWN0LnkoKSAqIG1fY29udGVudHNTY2FsZSwKKyAg ICAgICAgcmVjdC53aWR0aCgpICogbV9jb250ZW50c1NjYWxlLAorICAgICAgICByZWN0LmhlaWdo dCgpICogbV9jb250ZW50c1NjYWxlKSk7Cit9CisKK0ludFJlY3QgVGlsZWRCYWNraW5nU3RvcmU6 OmNvbnRlbnRzUmVjdCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1hcEZyb21Db250ZW50cyhtX2Ns aWVudC0+dGlsZWRCYWNraW5nU3RvcmVDb250ZW50c1JlY3QoKSk7Cit9CisKK0ludFJlY3QgVGls ZWRCYWNraW5nU3RvcmU6OnRpbGVSZWN0Rm9yQ29vcmRpbmF0ZShjb25zdCBUaWxlOjpDb29yZGlu YXRlJiBjb29yZGluYXRlKSBjb25zdAoreworICAgIEludFJlY3QgcmVjdChjb29yZGluYXRlLngo KSAqIG1fdGlsZVNpemUud2lkdGgoKSwKKyAgICAgICAgY29vcmRpbmF0ZS55KCkgKiBtX3RpbGVT aXplLmhlaWdodCgpLAorICAgICAgICBtX3RpbGVTaXplLndpZHRoKCksCisgICAgICAgIG1fdGls ZVNpemUuaGVpZ2h0KCkpOworCisgICAgcmVjdC5pbnRlcnNlY3QoY29udGVudHNSZWN0KCkpOwor ICAgIHJldHVybiByZWN0OworfQorICAgIAorVGlsZTo6Q29vcmRpbmF0ZSBUaWxlZEJhY2tpbmdT dG9yZTo6dGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb25zdCBJbnRQb2ludCYgcG9pbnQpIGNvbnN0 Cit7CisgICAgaW50IHggPSBwb2ludC54KCkgLyBtX3RpbGVTaXplLndpZHRoKCk7CisgICAgaW50 IHkgPSBwb2ludC55KCkgLyBtX3RpbGVTaXplLmhlaWdodCgpOworICAgIHJldHVybiBUaWxlOjpD b29yZGluYXRlKHN0ZDo6bWF4KHgsIDApLCBzdGQ6Om1heCh5LCAwKSk7Cit9CisKKwordm9pZCBU aWxlZEJhY2tpbmdTdG9yZTo6c3RhcnRUaWxlQnVmZmVyVXBkYXRlVGltZXIoKQoreworICAgIGlm IChtX3RpbGVCdWZmZXJVcGRhdGVUaW1lci0+aXNBY3RpdmUoKSB8fCBtX2NvbnRlbnRzRnJvemVu KQorICAgICAgICByZXR1cm47CisgICAgbV90aWxlQnVmZmVyVXBkYXRlVGltZXItPnN0YXJ0T25l U2hvdCgwKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dGlsZUJ1ZmZlclVwZGF0ZVRp bWVyRmlyZWQoVGlsZVRpbWVyKikKK3sKKyAgICB1cGRhdGVUaWxlQnVmZmVycygpOworfQorCit2 b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzdGFydFRpbGVDcmVhdGlvblRpbWVyKCkKK3sKKyAgICBp ZiAobV90aWxlQ3JlYXRpb25UaW1lci0+aXNBY3RpdmUoKSB8fCBtX2NvbnRlbnRzRnJvemVuKQor ICAgICAgICByZXR1cm47CisgICAgbV90aWxlQ3JlYXRpb25UaW1lci0+c3RhcnRPbmVTaG90KDAp OworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3JlYXRpb25UaW1lckZpcmVkKFRp bGVUaW1lciopCit7CisgICAgY3JlYXRlVGlsZXMoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdT dG9yZTo6c2V0Q29udGVudHNGcm96ZW4oYm9vbCBmcmVlemUpCit7CisgICAgaWYgKG1fY29udGVu dHNGcm96ZW4gPT0gZnJlZXplKQorICAgICAgICByZXR1cm47CisKKyAgICBtX2NvbnRlbnRzRnJv emVuID0gZnJlZXplOworCisgICAgLy8gUmVzdGFydCB0aGUgdGltZXJzLiBUaGVyZSBtaWdodCBi ZSBwZW5kaW5nIGludmFsaWRhdGlvbnMgdGhhdAorICAgIC8vIHdlcmUgbm90IHBhaW50ZWQgb3Ig Y3JlYXRlZCBiZWNhdXNlIHRpbGVzIGFyZSBub3QgY3JlYXRlZCBvcgorICAgIC8vIHBhaW50ZWQg d2hlbiBpbiBmcm96ZW4gc3RhdGUuCisgICAgaWYgKCFtX2NvbnRlbnRzRnJvemVuKSB7CisgICAg ICAgIHN0YXJ0VGlsZUNyZWF0aW9uVGltZXIoKTsKKyAgICAgICAgc3RhcnRUaWxlQnVmZmVyVXBk YXRlVGltZXIoKTsKKyAgICB9CisgICAgLy8gc3RvcHBpbmcgaXMgaGFuZGxlZCB3aGVuIHRoZSB0 aW1lcnMgZmlyZQorfQorCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSwxMDcgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9v ciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAK KyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZu ZGVmIFRpbGVkQmFja2luZ1N0b3JlX2gKKyNkZWZpbmUgVGlsZWRCYWNraW5nU3RvcmVfaAorCisj aWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNsdWRlICJJbnRSZWN0LmgiCisj aW5jbHVkZSAiRmxvYXRTaXplLmgiCisjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlICJUaWxl LmgiCisjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5o PgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGls ZWRCYWNraW5nU3RvcmVDbGllbnQ7CisKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlIDogcHVibGlj IE5vbmNvcHlhYmxlCit7CitwdWJsaWM6CisgICAgVGlsZWRCYWNraW5nU3RvcmUoVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQqKTsKKyAgICB+VGlsZWRCYWNraW5nU3RvcmUoKTsKKworICAgIHZvaWQg dmlld3BvcnRDaGFuZ2VkKGNvbnN0IEludFJlY3QmIHZpZXdwb3J0UmVjdCk7CisgICAgCisgICAg ZmxvYXQgY29udGVudHNTY2FsZSgpIHsgcmV0dXJuIG1fY29udGVudHNTY2FsZTsgfQorICAgIHZv aWQgc2V0Q29udGVudHNTY2FsZShmbG9hdCk7CisgICAgCisgICAgYm9vbCBjb250ZW50c0Zyb3pl bigpIGNvbnN0IHsgcmV0dXJuIG1fY29udGVudHNGcm96ZW47IH0KKyAgICB2b2lkIHNldENvbnRl bnRzRnJvemVuKGJvb2wpOworCisgICAgdm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGRp cnR5UmVjdCk7CisgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0 Jik7CisKK3ByaXZhdGU6CisgICAgdm9pZCBzdGFydFRpbGVCdWZmZXJVcGRhdGVUaW1lcigpOwor ICAgIHZvaWQgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgIAorICAgIHR5cGVkZWYgVGlt ZXI8VGlsZWRCYWNraW5nU3RvcmU+IFRpbGVUaW1lcjsKKworICAgIHZvaWQgdGlsZUJ1ZmZlclVw ZGF0ZVRpbWVyRmlyZWQoVGlsZVRpbWVyKik7CisgICAgdm9pZCB0aWxlQ3JlYXRpb25UaW1lckZp cmVkKFRpbGVUaW1lciopOworICAgIAorICAgIHZvaWQgdXBkYXRlVGlsZUJ1ZmZlcnMoKTsKKyAg ICB2b2lkIGNyZWF0ZVRpbGVzKCk7CisKKyAgICB2b2lkIGRyb3BPdmVyaGFuZ2luZ1RpbGVzKCk7 CisgICAgdm9pZCBkcm9wVGlsZXNPdXRzaWRlUmVjdChjb25zdCBJbnRSZWN0Jik7CisgICAgCisg ICAgUGFzc1JlZlB0cjxUaWxlPiB0aWxlQXQoY29uc3QgVGlsZTo6Q29vcmRpbmF0ZSYpIGNvbnN0 OworICAgIHZvaWQgc2V0VGlsZShjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRlLCBQ YXNzUmVmUHRyPFRpbGU+IHRpbGUpOworICAgIHZvaWQgcmVtb3ZlVGlsZShjb25zdCBUaWxlOjpD b29yZGluYXRlJiBjb29yZGluYXRlKTsKKworICAgIEludFJlY3QgbWFwVG9Db250ZW50cyhjb25z dCBJbnRSZWN0JikgY29uc3Q7CisgICAgSW50UmVjdCBtYXBGcm9tQ29udGVudHMoY29uc3QgSW50 UmVjdCYpIGNvbnN0OworICAgIAorICAgIEludFJlY3QgY29udGVudHNSZWN0KCkgY29uc3Q7Cisg ICAgCisgICAgSW50UmVjdCB0aWxlUmVjdEZvckNvb3JkaW5hdGUoY29uc3QgVGlsZTo6Q29vcmRp bmF0ZSYpIGNvbnN0OworICAgIFRpbGU6OkNvb3JkaW5hdGUgdGlsZUNvb3JkaW5hdGVGb3JQb2lu dChjb25zdCBJbnRQb2ludCYpIGNvbnN0OworICAgIGRvdWJsZSB0aWxlRGlzdGFuY2UoY29uc3Qg SW50UmVjdCYgdmlld3BvcnQsIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmKTsKKyAgICAKKyAgICB2 b2lkIHBhaW50Q2hlY2tlclBhdHRlcm4oR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYs IGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmKTsKKworICAgIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50 KiBtX2NsaWVudDsKKworICAgIHR5cGVkZWYgSGFzaE1hcDx1bnNpZ25lZCwgUmVmUHRyPFRpbGU+ ID4gVGlsZU1hcDsKKyAgICBUaWxlTWFwIG1fdGlsZXM7CisKKyAgICBUaWxlVGltZXIqIG1fdGls ZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIFRpbGVUaW1lciogbV90aWxlQ3JlYXRpb25UaW1lcjsK KworICAgIEludFNpemUgbV90aWxlU2l6ZTsKKyAgICAKKyAgICBJbnRSZWN0IG1fdmlld3BvcnQ7 CisgICAgZmxvYXQgbV9jb250ZW50c1NjYWxlOworCisgICAgYm9vbCBtX2NvbnRlbnRzRnJvemVu OworCisgICAgZnJpZW5kIGNsYXNzIFRpbGU7Cit9OworCit9CisKKyNlbmRpZgorI2VuZGlmCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9y ZUNsaWVudC5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxl ZEJhY2tpbmdTdG9yZUNsaWVudC5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQxIEBACisvKgor IENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlh cnkoLWllcykKKyAKKyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgCisgVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgorIAorIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CisgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBUaWxlZEJhY2tp bmdTdG9yZUNsaWVudF9oCisjZGVmaW5lIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50X2gKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCitjbGFz cyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudAoreworcHVibGljOgorICAgIHZpcnR1YWwgdm9pZCB0 aWxlZEJhY2tpbmdTdG9yZVBhaW50QmVnaW4oKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVk QmFja2luZ1N0b3JlUGFpbnQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYpID0gMDsK KyAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEVuZChjb25zdCBWZWN0b3I8 SW50UmVjdD4mIHBhaW50ZWRBcmVhKSA9IDA7CisgICAgdmlydHVhbCBJbnRSZWN0IHRpbGVkQmFj a2luZ1N0b3JlQ29udGVudHNSZWN0KCkgPSAwOworfTsKKworI2Vsc2UKK2NsYXNzIFRpbGVkQmFj a2luZ1N0b3JlQ2xpZW50IHt9OworI2VuZGlmCisKK30KKworI2VuZGlmCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4 MiBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0 cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJUaWxlLmgiCisKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lO R19TVE9SRSkKKworI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIlRpbGVk QmFja2luZ1N0b3JlLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmVDbGllbnQuaCIKKyNp bmNsdWRlIDxRQXBwbGljYXRpb24+CisjaW5jbHVkZSA8UUJhc2ljVGltZXI+CisjaW5jbHVkZSA8 UURlYnVnPgorI2luY2x1ZGUgPFFJbWFnZT4KKyNpbmNsdWRlIDxRT2JqZWN0PgorI2luY2x1ZGUg PFFQYWludGVyPgorI2luY2x1ZGUgPFFSZWdpb24+CisjaW5jbHVkZSA8UVRocmVhZD4KKworbmFt ZXNwYWNlIFdlYkNvcmUgeworICAgIAorc3RhdGljIGNvbnN0IGludCBjaGVja2VyU2l6ZSA9IDE2 Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjEgPSAweGZmNTU1NTU1Oworc3Rh dGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjIgPSAweGZmYWFhYWFhOworICAgIAorc3Rh dGljIFFQaXhtYXAmIGNoZWNrZXJlZFBpeG1hcCgpCit7CisgICAgc3RhdGljIFFQaXhtYXAqIHBp eG1hcDsKKyAgICBpZiAoIXBpeG1hcCkgeworICAgICAgICBwaXhtYXAgPSBuZXcgUVBpeG1hcCg0 ICogY2hlY2tlclNpemUsIDQgKiBjaGVja2VyU2l6ZSk7CisgICAgICAgIFFQYWludGVyIHBhaW50 ZXIocGl4bWFwKTsKKyAgICAgICAgUUNvbG9yIGNvbG9yMShjaGVja2VyQ29sb3IxKTsKKyAgICAg ICAgUUNvbG9yIGNvbG9yMihjaGVja2VyQ29sb3IyKTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7 IHkgPCBjaGVja2VyU2l6ZTsgeSArPSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAgIGJv b2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJTaXplOworICAgICAgICAgICAgZm9yIChpbnQgeCA9 IDA7IHggPCBjaGVja2VyU2l6ZTsgeCArPSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAg ICAgICBwYWludGVyLmZpbGxSZWN0KHgsIHksIGNoZWNrZXJTaXplIC8gMiwgY2hlY2tlclNpemUg LyAyLCBhbHRlcm5hdGUgPyBjb2xvcjEgOiBjb2xvcjIpOworICAgICAgICAgICAgICAgIGFsdGVy bmF0ZSA9ICFhbHRlcm5hdGU7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisgICAg cmV0dXJuICpwaXhtYXA7Cit9CisgICAgCitUaWxlOjpUaWxlKFRpbGVkQmFja2luZ1N0b3JlKiBi YWNraW5nU3RvcmUsIGNvbnN0IENvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQorICAgIDogbV9i YWNraW5nU3RvcmUoYmFja2luZ1N0b3JlKQorICAgICwgbV9jb29yZGluYXRlKHRpbGVDb29yZGlu YXRlKQorICAgICwgbV9yZWN0KG1fYmFja2luZ1N0b3JlLT50aWxlUmVjdEZvckNvb3JkaW5hdGUo dGlsZUNvb3JkaW5hdGUpKQorICAgICwgbV9idWZmZXIoMCkKKyAgICAsIG1fYmFja0J1ZmZlcigw KQorICAgICwgbV9kaXJ0eVJlZ2lvbihuZXcgUVJlZ2lvbihtX3JlY3QpKQoreworfQorCitUaWxl Ojp+VGlsZSgpCit7CisgICAgZGVsZXRlIG1fYnVmZmVyOworICAgIGRlbGV0ZSBtX2JhY2tCdWZm ZXI7CisgICAgZGVsZXRlIG1fZGlydHlSZWdpb247Cit9CisKK2Jvb2wgVGlsZTo6aXNEaXJ0eSgp IGNvbnN0IAoreyAKKyAgICByZXR1cm4gIW1fZGlydHlSZWdpb24tPmlzRW1wdHkoKTsgCit9CisK K2Jvb2wgVGlsZTo6aXNSZWFkeVRvUGFpbnQoKSBjb25zdAoreyAKKyAgICByZXR1cm4gbV9idWZm ZXI7IAorfQorCit2b2lkIFRpbGU6OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZGlydHlSZWN0 KQoreworICAgIEludFJlY3QgdGlsZURpcnR5UmVjdCA9IGludGVyc2VjdGlvbihkaXJ0eVJlY3Qs IG1fcmVjdCk7CisgICAgaWYgKHRpbGVEaXJ0eVJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm47CisKKyAgICAqbV9kaXJ0eVJlZ2lvbiArPSB0aWxlRGlydHlSZWN0OworfQorICAgIAordm9p ZCBUaWxlOjp1cGRhdGVCYWNrQnVmZmVyKCkKK3sKKyAgICBpZiAobV9idWZmZXIgJiYgIWlzRGly dHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2JhY2tCdWZmZXIpIHsKKyAgICAg ICAgaWYgKCFtX2J1ZmZlcikKKyAgICAgICAgICAgIG1fYmFja0J1ZmZlciA9IG5ldyBRUGl4bWFw KG1fYmFja2luZ1N0b3JlLT5tX3RpbGVTaXplLndpZHRoKCksIG1fYmFja2luZ1N0b3JlLT5tX3Rp bGVTaXplLmhlaWdodCgpKTsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAvLyBDdXJyZW50 bHkgYWxsIGJ1ZmZlcnMgYXJlIHVwZGF0ZWQgc3luY2hyb25vdXNseSBhdCB0aGUgc2FtZSB0aW1l IHNvIHRoZXJlIGlzIG5vIHJlYWwgbmVlZAorICAgICAgICAgICAgLy8gdG8gaGF2ZSBzZXBhcmF0 ZSBiYWNrIGFuZCBmcm9udCBidWZmZXJzLiBKdXN0IHVzZSB0aGUgZXhpc3RpbmcgYnVmZmVyLgor ICAgICAgICAgICAgbV9iYWNrQnVmZmVyID0gbV9idWZmZXI7CisgICAgICAgICAgICBtX2J1ZmZl ciA9IDA7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBRVmVjdG9yPFFSZWN0PiBkaXJ0eVJlY3Rz ID0gbV9kaXJ0eVJlZ2lvbi0+cmVjdHMoKTsKKyAgICAqbV9kaXJ0eVJlZ2lvbiA9IFFSZWdpb24o KTsKKyAgICAKKyAgICBRUGFpbnRlciBwYWludGVyKG1fYmFja0J1ZmZlcik7CisgICAgR3JhcGhp Y3NDb250ZXh0IGNvbnRleHQoJnBhaW50ZXIpOworICAgIGNvbnRleHQudHJhbnNsYXRlKC1tX3Jl Y3QueCgpLCAtbV9yZWN0LnkoKSk7CisKKyAgICBpbnQgc2l6ZSA9IGRpcnR5UmVjdHMuc2l6ZSgp OworICAgIGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKSAgeworICAgICAgICBjb250ZXh0 LnNhdmUoKTsKKyAgICAgICAgSW50UmVjdCByZWN0ID0gZGlydHlSZWN0c1tuXTsKKyAgICAgICAg Y29udGV4dC5jbGlwKEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgIGNvbnRleHQuc2NhbGUoRmxv YXRTaXplKG1fYmFja2luZ1N0b3JlLT5tX2NvbnRlbnRzU2NhbGUsIG1fYmFja2luZ1N0b3JlLT5t X2NvbnRlbnRzU2NhbGUpKTsKKyAgICAgICAgbV9iYWNraW5nU3RvcmUtPm1fY2xpZW50LT50aWxl ZEJhY2tpbmdTdG9yZVBhaW50KCZjb250ZXh0LCBtX2JhY2tpbmdTdG9yZS0+bWFwVG9Db250ZW50 cyhyZWN0KSk7CisgICAgICAgIGNvbnRleHQucmVzdG9yZSgpOworICAgIH0KK30KKwordm9pZCBU aWxlOjpzd2FwQmFja0J1ZmZlclRvRnJvbnQoKQoreworICAgIGlmICghbV9iYWNrQnVmZmVyKQor ICAgICAgICByZXR1cm47CisgICAgZGVsZXRlIG1fYnVmZmVyOworICAgIG1fYnVmZmVyID0gbV9i YWNrQnVmZmVyOworICAgIG1fYmFja0J1ZmZlciA9IDA7Cit9CisKK3ZvaWQgVGlsZTo6cGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV9idWZmZXIpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBJbnRSZWN0IHRhcmdldCA9 IGludGVyc2VjdGlvbihyZWN0LCBtX3JlY3QpOworICAgIEludFJlY3Qgc291cmNlKCh0YXJnZXQu eCgpIC0gbV9yZWN0LngoKSksCisgICAgICAgICAgICAgICAgICAgKHRhcmdldC55KCkgLSBtX3Jl Y3QueSgpKSwKKyAgICAgICAgICAgICAgICAgICB0YXJnZXQud2lkdGgoKSwKKyAgICAgICAgICAg ICAgICAgICB0YXJnZXQuaGVpZ2h0KCkpOworICAgIAorICAgIGNvbnRleHQtPnBsYXRmb3JtQ29u dGV4dCgpLT5kcmF3UGl4bWFwKHRhcmdldCwgKm1fYnVmZmVyLCBzb3VyY2UpOworfQorICAgIAor dm9pZCBUaWxlOjpwYWludENoZWNrZXJQYXR0ZXJuKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwg Y29uc3QgRmxvYXRSZWN0JiB0YXJnZXQpCit7CisgICAgUVBhaW50ZXIqIHBhaW50ZXIgPSBjb250 ZXh0LT5wbGF0Zm9ybUNvbnRleHQoKTsKKyAgICBRVHJhbnNmb3JtIHdvcmxkVHJhbnNmb3JtID0g cGFpbnRlci0+d29ybGRUcmFuc2Zvcm0oKTsKKyAgICBxcmVhbCBzY2FsZVggPSB3b3JsZFRyYW5z Zm9ybS5tMTEoKTsKKyAgICBxcmVhbCBzY2FsZVkgPSB3b3JsZFRyYW5zZm9ybS5tMjIoKTsKKyAg ICAKKyAgICBRUmVjdCB0YXJnZXRWaWV3UmVjdCA9IFFSZWN0Rih0YXJnZXQueCgpICogc2NhbGVY LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldC55KCkgKiBzY2FsZVks CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LndpZHRoKCkgKiBzY2Fs ZVgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LmhlaWdodCgpICog c2NhbGVZKS50b0FsaWduZWRSZWN0KCk7CisgICAgCisgICAgUVRyYW5zZm9ybSBhZGp1c3RlZFRy YW5zZm9ybSgxLiwgd29ybGRUcmFuc2Zvcm0ubTEyKCksIHdvcmxkVHJhbnNmb3JtLm0xMygpLAor ICAgICAgICAgICAgICAgICAgd29ybGRUcmFuc2Zvcm0ubTIxKCksIDEuLCB3b3JsZFRyYW5zZm9y bS5tMjMoKSwKKyAgICAgICAgICAgICAgICAgIHdvcmxkVHJhbnNmb3JtLm0zMSgpLCB3b3JsZFRy YW5zZm9ybS5tMzIoKSwgd29ybGRUcmFuc2Zvcm0ubTMzKCkpOworICAgIHBhaW50ZXItPnNldFdv cmxkVHJhbnNmb3JtKGFkanVzdGVkVHJhbnNmb3JtKTsKKyAgICAKKyAgICBwYWludGVyLT5kcmF3 VGlsZWRQaXhtYXAodGFyZ2V0Vmlld1JlY3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGNoZWNrZXJlZFBpeG1hcCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBRUG9pbnQo dGFyZ2V0Vmlld1JlY3QubGVmdCgpICUgY2hlY2tlclNpemUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB0YXJnZXRWaWV3UmVjdC50b3AoKSAlIGNoZWNrZXJTaXplKSk7Cisg ICAgCisgICAgcGFpbnRlci0+c2V0V29ybGRUcmFuc2Zvcm0od29ybGRUcmFuc2Zvcm0pOworfQor Cit9CisKKyNlbmRpZgpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAkocmV2aXNpb24gNTUyNzkpCisrKyBX ZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU4LDYgKzU4LDcg QEAKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU3Vic3RpdHV0 ZURhdGEuaCIKICNpbmNsdWRlICJTVkdTTUlMRWxlbWVudC5oIgorI2luY2x1ZGUgIlRpbGVkQmFj a2luZ1N0b3JlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJtYXJrdXAu aCIKICNpbmNsdWRlICJxdF9pbnN0YW5jZS5oIgpAQCAtMzM5LDcgKzM0MCwxMSBAQCB2b2lkIFFX ZWJGcmFtZVByaXZhdGU6OnJlbmRlckNvbnRlbnRzTGF5CiAgICAgUVBhaW50ZXIqIHBhaW50ZXIg PSBjb250ZXh0LT5wbGF0Zm9ybUNvbnRleHQoKTsKIAogICAgIFdlYkNvcmU6OkZyYW1lVmlldyog dmlldyA9IGZyYW1lLT52aWV3KCk7Ci0gICAgdmlldy0+bGF5b3V0SWZOZWVkZWRSZWN1cnNpdmUo KTsKKyAgICAKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyAgICBpZiAoIWZyYW1l LT50aWxlZEJhY2tpbmdTdG9yZSgpKQorI2VuZGlmCisgICAgICAgIHZpZXctPmxheW91dElmTmVl ZGVkUmVjdXJzaXZlKCk7CiAKICAgICBmb3IgKGludCBpID0gMDsgaSA8IHZlY3Rvci5zaXplKCk7 ICsraSkgewogICAgICAgICBjb25zdCBRUmVjdCYgY2xpcFJlY3QgPSB2ZWN0b3IuYXQoaSk7CkBA IC0zNDgsNyArMzUzLDEyIEBAIHZvaWQgUVdlYkZyYW1lUHJpdmF0ZTo6cmVuZGVyQ29udGVudHNM YXkKICAgICAgICAgcGFpbnRlci0+c2V0Q2xpcFJlY3QoY2xpcFJlY3QsIFF0OjpJbnRlcnNlY3RD bGlwKTsKIAogICAgICAgICBjb250ZXh0LT5zYXZlKCk7Ci0gICAgICAgIHZpZXctPnBhaW50Q29u dGVudHMoY29udGV4dCwgY2xpcFJlY3QpOworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JF KQorICAgICAgICBpZiAoZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCkpCisgICAgICAgICAgICBm cmFtZS0+dGlsZWRCYWNraW5nU3RvcmUoKS0+cGFpbnQoY29udGV4dCwgY2xpcFJlY3QpOworICAg ICAgICBlbHNlCisjZW5kaWYKKyAgICAgICAgICAgIHZpZXctPnBhaW50Q29udGVudHMoY29udGV4 dCwgY2xpcFJlY3QpOwogICAgICAgICBjb250ZXh0LT5yZXN0b3JlKCk7CiAKICAgICAgICAgcGFp bnRlci0+cmVzdG9yZSgpOwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCShyZXZpc2lvbiA1NTI3OSkKKysrIFdl YktpdC9xdC9BcGkvcXdlYmZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyMiw2ICsyMjIsNyBA QCBRX1NJR05BTFM6CiAgICAgdm9pZCBwYWdlQ2hhbmdlZCgpOwogCiBwcml2YXRlOgorICAgIGZy aWVuZCBjbGFzcyBRR3JhcGhpY3NXZWJWaWV3OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViUGFnZTsK ICAgICBmcmllbmQgY2xhc3MgUVdlYlBhZ2VQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2Vi RnJhbWVQcml2YXRlOwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAkocmV2aXNpb24gNTUyNzkp CisrKyBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIz MCw2ICsyMzAsMTAgQEAgdm9pZCBRV2ViU2V0dGluZ3NQcml2YXRlOjphcHBseSgpCiAgICAgICAg IHZhbHVlID0gYXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlhTU0F1ZGl0b3JFbmFibGVk LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJpYnV0 ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpYU1NBdWRpdG9yRW5hYmxlZCkpOwogICAgICAgICBzZXR0 aW5ncy0+c2V0WFNTQXVkaXRvckVuYWJsZWQodmFsdWUpOworICAgICAgICAKKyAgICAgICAgdmFs dWUgPSBhdHRyaWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5nczo6VGlsZWRCYWNraW5nU3RvcmVFbmFi bGVkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJp YnV0ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQpKTsKKyAg ICAgICAgc2V0dGluZ3MtPnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCh2YWx1ZSk7CiAKICAg ICAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoV2ViQ29yZTo6cGFnZUNhY2hlKCktPmNh cGFjaXR5KCkpOwogICAgIH0gZWxzZSB7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5n cy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmgJKHJldmlzaW9u IDU1Mjc5KQorKysgV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpA QCAtNzEsNiArNzEsNyBAQCBwdWJsaWM6CiAgICAgICAgIERuc1ByZWZldGNoRW5hYmxlZCwKICAg ICAgICAgWFNTQXVkaXRvckVuYWJsZWQsCiAgICAgICAgIEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdF bmFibGVkLAorICAgICAgICBUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQsCiAgICAgICAgIFdlYkdM RW5hYmxlZAogICAgIH07CiAgICAgZW51bSBXZWJHcmFwaGljIHsKSW5kZXg6IFdlYktpdFRvb2xz L1NjcmlwdHMvYnVpbGQtd2Via2l0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL1NjcmlwdHMv YnVpbGQtd2Via2l0CShyZXZpc2lvbiA1NTI3OSkKKysrIFdlYktpdFRvb2xzL1NjcmlwdHMvYnVp bGQtd2Via2l0CSh3b3JraW5nIGNvcHkpCkBAIC01Niw3ICs1Niw3IEBAIG15ICgkdGhyZWVEQ2Fu dmFzU3VwcG9ydCwgJHRocmVlRFJlbmRlcmkKICAgICAkamF2YVNjcmlwdERlYnVnZ2VyU3VwcG9y dCwgJG1hdGhtbFN1cHBvcnQsICRvZmZsaW5lV2ViQXBwbGljYXRpb25TdXBwb3J0LCAkcnVieVN1 cHBvcnQsICRzYW5kYm94U3VwcG9ydCwgJHNoYXJlZFdvcmtlcnNTdXBwb3J0LAogICAgICRzdmdT dXBwb3J0LCAkc3ZnQW5pbWF0aW9uU3VwcG9ydCwgJHN2Z0FzSW1hZ2VTdXBwb3J0LCAkc3ZnRE9N T2JqQ0JpbmRpbmdzU3VwcG9ydCwgJHN2Z0ZvbnRzU3VwcG9ydCwKICAgICAkc3ZnRm9yZWlnbk9i amVjdFN1cHBvcnQsICRzdmdVc2VTdXBwb3J0LCAkdmlkZW9TdXBwb3J0LCAkd2ViU29ja2V0c1N1 cHBvcnQsICR3bWxTdXBwb3J0LCAkd2Nzc1N1cHBvcnQsICR4aHRtbG1wU3VwcG9ydCwgJHdvcmtl cnNTdXBwb3J0LAotICAgICR4cGF0aFN1cHBvcnQsICR4c2x0U3VwcG9ydCwgJGNvdmVyYWdlU3Vw cG9ydCwgJG5vdGlmaWNhdGlvbnNTdXBwb3J0KTsKKyAgICAkeHBhdGhTdXBwb3J0LCAkeHNsdFN1 cHBvcnQsICRjb3ZlcmFnZVN1cHBvcnQsICRub3RpZmljYXRpb25zU3VwcG9ydCwgJHRpbGVkQmFj a2luZ1N0b3JlU3VwcG9ydCk7CiAKIG15IEBmZWF0dXJlcyA9ICgKICAgICB7IG9wdGlvbiA9PiAi M2QtY2FudmFzIiwgZGVzYyA9PiAiVG9nZ2xlIDNEIGNhbnZhcyBzdXBwb3J0IiwKQEAgLTE0Myw2 ICsxNDMsOSBAQCBteSBAZmVhdHVyZXMgPSAoCiAgICAgeyBvcHRpb24gPT4gInN2Zy11c2UiLCBk ZXNjID0+ICJUb2dnbGUgU1ZHIHVzZSBlbGVtZW50IHN1cHBvcnQgKGltcGxpZXMgU1ZHIHN1cHBv cnQpIiwKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX1NWR19VU0UiLCBkZWZhdWx0ID0+IDEsIHZh bHVlID0+IFwkc3ZnVXNlU3VwcG9ydCB9LAogCisgICAgeyBvcHRpb24gPT4gInRpbGVkLWJhY2tp bmctc3RvcmUiLCBkZXNjID0+ICJUb2dnbGUgVGlsZWQgQmFja2luZyBTdG9yZSBzdXBwb3J0IiwK KyAgICAgIGRlZmluZSA9PiAiRU5BQkxFX1RJTEVEX0JBQ0tJTkdfU1RPUkUiLCBkZWZhdWx0ID0+ IGlzUXQoKSwgdmFsdWUgPT4gXCR0aWxlZEJhY2tpbmdTdG9yZVN1cHBvcnQgfSwKKwogICAgIHsg b3B0aW9uID0+ICJ2aWRlbyIsIGRlc2MgPT4gIlRvZ2dsZSBWaWRlbyBzdXBwb3J0IiwKICAgICAg IGRlZmluZSA9PiAiRU5BQkxFX1ZJREVPIiwgZGVmYXVsdCA9PiAoaXNBcHBsZVdlYktpdCgpIHx8 IGlzR3RrKCkpLCB2YWx1ZSA9PiBcJHZpZGVvU3VwcG9ydCB9LAogCg== 49582 2010-02-26 07:41:50 -0800 2010-03-03 14:35:38 -0800 added back some forgotten QGraphicsWebView code tiled-backing-store-8.patch text/plain 44561 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcmkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnByaQkocmV2aXNpb24gNTUyNzkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJpCSh3b3JraW5nIGNv cHkpCkBAIC03Nyw2ICs3Nyw5IEBAIGdyZWF0ZXJUaGFuKFFUX01JTk9SX1ZFUlNJT04sIDUpIHsK ICMgSFRNTDUgZGF0YWxpc3Qgc3VwcG9ydAogIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9EQVRB TElTVD0uKTogREVGSU5FUyArPSBFTkFCTEVfREFUQUxJU1Q9MQogCisjIFRpbGVkIEJhY2tpbmcg U3RvcmUgc3VwcG9ydAorIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9USUxFRF9CQUNLSU5HX1NU T1JFPS4pOiBERUZJTkVTICs9IEVOQUJMRV9USUxFRF9CQUNLSU5HX1NUT1JFPTEKKwogIyBOZXNj YXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkpCiAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05F VFNDQVBFX1BMVUdJTl9BUEk9LikgewogICAgIHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNl KjogewpAQCAtMTQ3LDYgKzE1MCw3IEBAIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9KQVZBU0NS SVBUX0RFQlUKIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9PRkZMSU5FX1dFQl9BUFBMSUNBVElP TlM9MSk6IEZFQVRVUkVfREVGSU5FU19KQVZBU0NSSVBUICs9IEVOQUJMRV9PRkZMSU5FX1dFQl9B UFBMSUNBVElPTlM9MQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQl9TT0NLRVRTPTEpOiBG RUFUVVJFX0RFRklORVNfSkFWQVNDUklQVCArPSBFTkFCTEVfV0VCX1NPQ0tFVFM9MQogY29udGFp bnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFT Q1JJUFQgKz0gRU5BQkxFX1RPVUNIX0VWRU5UUz0xCitjb250YWlucyhERUZJTkVTLCBFTkFCTEVf VElMRURfQkFDS0lOR19TVE9SRT0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFTQ1JJUFQgKz0gRU5B QkxFX1RJTEVEX0JBQ0tJTkdfU1RPUkU9MQogCiAKICMjIERlcml2ZWQgc291cmNlIGdlbmVyYXRv cnMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJD b3JlLnBybwkocmV2aXNpb24gNTUyNzkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5n IGNvcHkpCkBAIC04MjYsNiArODI2LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvUGVuLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU2VnbWVudGVkRm9udERhdGEu Y3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5jcHAgXAorICAgIHBs YXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcCBcCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9NYXRyaXhUcmFuc2Zvcm1PcGVyYXRpb24uY3BwIFwKQEAgLTE1 MzIsNiArMTUzMyw5IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3F0L1N0 aWxsSW1hZ2VRdC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TZWdtZW50ZWRGb250RGF0YS5o IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5oIFwKKyAgICBwbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmggXAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0 b3JlLmggXCAgICAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZUNsaWVu dC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL01hdHJpeDNEVHJhbnNmb3Jt T3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvTWF0cml4VHJh bnNmb3JtT3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvUGVy c3BlY3RpdmVUcmFuc2Zvcm1PcGVyYXRpb24uaCBcCkBAIC0yMDI1LDYgKzIwMjksNyBAQCBTT1VS Q0VTICs9IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9Gb250Q3VzdG9tUGxhdGZvcm1EYXRh UXQuY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HbHlwaFBhZ2VUcmVlTm9kZVF0LmNw cCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvcXQvU2ltcGxlRm9udERhdGFRdC5jcHAgXAorICAg IHBsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0tVUkxR dC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0xvY2FsaXphdGlvbnMuY3BwIFwKICAgICBwbGF0Zm9y bS9xdC9NSU1FVHlwZVJlZ2lzdHJ5UXQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNTUyNzkp CisrKyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3 IEBACiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNp bmNsdWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3Rv cmUuaCIKICNpbmNsdWRlICJVc2VyQ29udGVudFVSTFBhdHRlcm4uaCIKICNpbmNsdWRlICJYTUxO U05hbWVzLmgiCiAjaW5jbHVkZSAiWE1MTmFtZXMuaCIKQEAgLTE3MSw5ICsxNzIsMTMgQEAgRnJh bWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRQogICAgIFhNTE5TTmFtZXM6Omlu aXQoKTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwogCi0gICAgaWYgKCFvd25lckVsZW1lbnQpCisg ICAgaWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAgICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMp OwotICAgIGVsc2UgeworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICAv LyBUb3AgbGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAgICAgICBzZXRUaWxlZEJhY2tpbmdT dG9yZUVuYWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkp OworI2VuZGlmCisgICAgfSBlbHNlIHsKICAgICAgICAgcGFnZS0+aW5jcmVtZW50RnJhbWVDb3Vu dCgpOwogICAgICAgICAvLyBNYWtlIHN1cmUgd2Ugd2lsbCBub3QgZW5kIHVwIHdpdGggdHdvIGZy YW1lcyByZWZlcmVuY2luZyB0aGUgc2FtZSBvd25lciBlbGVtZW50LgogICAgICAgICBBU1NFUlQo KCEob3duZXJFbGVtZW50LT5tX2NvbnRlbnRGcmFtZSkpIHx8IChvd25lckVsZW1lbnQtPm1fY29u dGVudEZyYW1lLT5vd25lckVsZW1lbnQoKSAhPSBvd25lckVsZW1lbnQpKTsKQEAgLTE4NDUsNCAr MTg1MCw0OSBAQCB2b2lkIEZyYW1lOjpjcmVhdGVWaWV3KGNvbnN0IEludFNpemUmIHZpCiAgICAg ICAgIHZpZXcoKS0+c2V0Q2FuSGF2ZVNjcm9sbGJhcnMob3duZXItPnNjcm9sbGluZ01vZGUoKSAh PSBTY3JvbGxiYXJBbHdheXNPZmYpOwogfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RP UkUpCit2b2lkIEZyYW1lOjpzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCBlbmFibGVk KQoreworICAgIGlmICghZW5hYmxlZCkgeworICAgICAgICBtX3RpbGVkQmFja2luZ1N0b3JlLmNs ZWFyKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKG1fdGlsZWRCYWNraW5nU3Rv cmUpCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVkQmFja2luZ1N0b3JlLnNldChuZXcgVGls ZWRCYWNraW5nU3RvcmUodGhpcykpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9y ZVBhaW50QmVnaW4oKQoreworICAgIGlmICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAg bV92aWV3LT5sYXlvdXRJZk5lZWRlZFJlY3Vyc2l2ZSgpOworICAgIG1fdmlldy0+Zmx1c2hEZWZl cnJlZFJlcGFpbnRzKCk7Cit9CisKK3ZvaWQgRnJhbWU6OnRpbGVkQmFja2luZ1N0b3JlUGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAgbV92aWV3LT5wYWludENvbnRlbnRzKGNv bnRleHQsIHJlY3QpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZVBhaW50RW5k KGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpCit7CisgICAgaWYgKCFtX3BhZ2Ug fHwgIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIHVuc2lnbmVkIHNpemUgPSBwYWludGVk QXJlYS5zaXplKCk7CisgICAgLy8gUmVxdWVzdCByZXBhaW50IGZyb20gdGhlIHN5c3RlbQorICAg IGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKQorICAgICAgICBtX3BhZ2UtPmNocm9tZSgp LT5yZXBhaW50KG1fdmlldy0+Y29udmVydFRvQ29udGFpbmluZ1dpbmRvdyhwYWludGVkQXJlYVtu XSksIHRydWUpOworfQorCitJbnRSZWN0IEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRz UmVjdCgpCit7CisgICAgaWYgKCFtX3ZpZXcpCisgICAgICAgIHJldHVybiBJbnRSZWN0KCk7Cisg ICAgcmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbV92aWV3LT5jb250ZW50c1NpemUoKSk7Cit9 CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0Zy YW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDU1Mjc5 KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTM3LDYgKzM3LDcg QEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU2Nyb2xsQmVoYXZp b3IuaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiVGlsZWRC YWNraW5nU3RvcmVDbGllbnQuaCIKICNpbmNsdWRlICJVc2VyU2NyaXB0VHlwZXMuaCIKIAogI2lm IFBMQVRGT1JNKFdJTikKQEAgLTYyLDggKzYzLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg IGNsYXNzIENTU011dGFibGVTdHlsZURlY2xhcmF0aW9uOwogICAgIGNsYXNzIEhUTUxUYWJsZUNl bGxFbGVtZW50OwogICAgIGNsYXNzIFJlZ3VsYXJFeHByZXNzaW9uOworICAgIGNsYXNzIFRpbGVk QmFja2luZ1N0b3JlOwogCi0gICAgY2xhc3MgRnJhbWUgOiBwdWJsaWMgUmVmQ291bnRlZDxGcmFt ZT4geworICAgIGNsYXNzIEZyYW1lIDogcHVibGljIFJlZkNvdW50ZWQ8RnJhbWU+LCBwdWJsaWMg VGlsZWRCYWNraW5nU3RvcmVDbGllbnQgewogICAgIHB1YmxpYzoKICAgICAgICAgc3RhdGljIFBh c3NSZWZQdHI8RnJhbWU+IGNyZWF0ZShQYWdlKiBwYWdlLCBIVE1MRnJhbWVPd25lckVsZW1lbnQq IG93bmVyRWxlbWVudCwgRnJhbWVMb2FkZXJDbGllbnQqIGNsaWVudCkKICAgICAgICAgewpAQCAt MTYzLDYgKzE2NSwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICByZXR1cm4g ZG9jdW1lbnQoKSA/IGRvY3VtZW50KCktPmRpc3BsYXlTdHJpbmdNb2RpZmllZEJ5RW5jb2Rpbmco c3RyKSA6IHN0cjsKICAgICAgICAgfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUp CisgICAgICAgIFRpbGVkQmFja2luZ1N0b3JlKiB0aWxlZEJhY2tpbmdTdG9yZSgpIGNvbnN0IHsg cmV0dXJuIG1fdGlsZWRCYWNraW5nU3RvcmUuZ2V0KCk7IH0KKyAgICAgICAgdm9pZCBzZXRUaWxl ZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisjZW5kaWYKKwogICAgIHByaXZhdGU6CiAgICAg ICAgIHZvaWQgbGlmZVN1cHBvcnRUaW1lckZpcmVkKFRpbWVyPEZyYW1lPiopOwogCkBAIC0yNjgs NiArMjc1LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICBWaXNpYmxlUG9zaXRp b24gdmlzaWJsZVBvc2l0aW9uRm9yUG9pbnQoY29uc3QgSW50UG9pbnQmIGZyYW1lUG9pbnQpOwog ICAgICAgICBEb2N1bWVudCogZG9jdW1lbnRBdFBvaW50KGNvbnN0IEludFBvaW50JiB3aW5kb3dQ b2ludCk7CisgICAgICAgIAorICAgIHByaXZhdGU6CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdf U1RPUkUpCisgICAgICAgIC8vIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IGludGVyZmFjZQorICAg ICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCk7CisgICAgICAg IHZpcnR1YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNv bnN0IEludFJlY3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFp bnRFbmQoY29uc3QgVmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSk7CisgICAgICAgIHZpcnR1 YWwgSW50UmVjdCB0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpOworI2VuZGlmCiAKICAg ICAjaWYgUExBVEZPUk0oTUFDKQogCkBAIC0zNDYsNiArMzYyLDEwIEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgYm9vbCBtX25lZWRzUmVhcHBseVN0eWxlczsKICAgICAgICAgYm9vbCBt X2lzRGlzY29ubmVjdGVkOwogICAgICAgICBib29sIG1fZXhjbHVkZUZyb21UZXh0U2VhcmNoOwor CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpICAgICAgICAKKyAgICAgICAgT3duUHRy PFRpbGVkQmFja2luZ1N0b3JlPiBtX3RpbGVkQmFja2luZ1N0b3JlOworI2VuZGlmCiAgICAgfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHJldmlzaW9uIDU1 Mjc5KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTcw LDYgKzcwLDkgQEAKICNpbmNsdWRlICJTVkdWaWV3U3BlYy5oIgogI2VuZGlmCiAKKyNpZiBFTkFC TEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgor I2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtMTAxMSw2ICsxMDE0LDEyIEBAIHZv aWQgRnJhbWVWaWV3OjpyZXBhaW50Q29udGVudFJlY3RhbmdsZSgKICAgICBpZiAoIWltbWVkaWF0 ZSAmJiBpc09mZnNjcmVlbigpICYmICFzaG91bGRVcGRhdGVXaGlsZU9mZnNjcmVlbigpKQogICAg ICAgICByZXR1cm47CiAKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyAgICBpZiAo ZnJhbWUoKS0+dGlsZWRCYWNraW5nU3RvcmUoKSkgeworICAgICAgICBmcmFtZSgpLT50aWxlZEJh Y2tpbmdTdG9yZSgpLT5pbnZhbGlkYXRlKHIpOworICAgICAgICByZXR1cm47CisgICAgfQorI2Vu ZGlmCiAgICAgU2Nyb2xsVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5nbGUociwgaW1tZWRpYXRl KTsKIH0KIApAQCAtMTA4Miw4ICsxMDkxLDE1IEBAIHZvaWQgRnJhbWVWaWV3Ojpkb0RlZmVycmVk UmVwYWludHMoKQogICAgICAgICByZXR1cm47CiAgICAgfQogICAgIHVuc2lnbmVkIHNpemUgPSBt X3JlcGFpbnRSZWN0cy5zaXplKCk7Ci0gICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemU7 IGkrKykKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7CisjaWYgRU5B QkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgICAgIGlmIChmcmFtZSgpLT50aWxlZEJhY2tp bmdTdG9yZSgpKSB7CisgICAgICAgICAgICBmcmFtZSgpLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5p bnZhbGlkYXRlKG1fcmVwYWludFJlY3RzW2ldKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAg ICAgICB9CisjZW5kaWYKICAgICAgICAgU2Nyb2xsVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5n bGUobV9yZXBhaW50UmVjdHNbaV0sIGZhbHNlKTsKKyAgICB9CiAgICAgbV9yZXBhaW50UmVjdHMu Y2xlYXIoKTsKICAgICBtX3JlcGFpbnRDb3VudCA9IDA7CiAgICAgCkluZGV4OiBXZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAJ KHJldmlzaW9uIDU1Mjc5KQorKysgV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAkod29ya2luZyBj b3B5KQpAQCAtMTI0LDYgKzEyNCw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQog ICAgICwgbV9leHBlcmltZW50YWxOb3RpZmljYXRpb25zRW5hYmxlZChmYWxzZSkKICAgICAsIG1f d2ViR0xFbmFibGVkKGZhbHNlKQogICAgICwgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCh0cnVlKQor ICAgICwgbV90aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoZmFsc2UpCiB7CiAgICAgLy8gQSBGcmFt ZSBtYXkgbm90IGhhdmUgYmVlbiBjcmVhdGVkIHlldCwgc28gd2UgaW5pdGlhbGl6ZSB0aGUgQXRv bWljU3RyaW5nIAogICAgIC8vIGhhc2ggYmVmb3JlIHRyeWluZyB0byB1c2UgaXQuCkBAIC01Njgs NCArNTY5LDEzIEBAIHZvaWQgU2V0dGluZ3M6OnNldExvYWREZWZlcnJpbmdFbmFibGVkKGIKICAg ICBtX2xvYWREZWZlcnJpbmdFbmFibGVkID0gZW5hYmxlZDsKIH0KIAordm9pZCBTZXR0aW5nczo6 c2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wgZW5hYmxlZCkKK3sKKyAgICBtX3RpbGVk QmFja2luZ1N0b3JlRW5hYmxlZCA9IGVuYWJsZWQ7CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdf U1RPUkUpCisgICAgaWYgKG1fcGFnZS0+bWFpbkZyYW1lKCkpCisgICAgICAgIG1fcGFnZS0+bWFp bkZyYW1lKCktPnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZChlbmFibGVkKTsKKyNlbmRpZgor fQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkocmV2aXNpb24gNTUyNzkp CisrKyBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAtMjg2LDYgKzI4 Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2b2lkIHNldExvYWREZWZlcnJp bmdFbmFibGVkKGJvb2wpOwogICAgICAgICBib29sIGxvYWREZWZlcnJpbmdFbmFibGVkKCkgY29u c3QgeyByZXR1cm4gbV9sb2FkRGVmZXJyaW5nRW5hYmxlZDsgfQorICAgICAgICAKKyAgICAgICAg dm9pZCBzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCk7CisgICAgICAgIGJvb2wgdGls ZWRCYWNraW5nU3RvcmVFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV90aWxlZEJhY2tpbmdTdG9y ZUVuYWJsZWQ7IH0KIAogICAgIHByaXZhdGU6CiAgICAgICAgIFBhZ2UqIG1fcGFnZTsKQEAgLTM2 MCw2ICszNjMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGJvb2wgbV9leHBlcmlt ZW50YWxOb3RpZmljYXRpb25zRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV93ZWJHTEVuYWJs ZWQgOiAxOwogICAgICAgICBib29sIG1fbG9hZERlZmVycmluZ0VuYWJsZWQgOiAxOworICAgICAg ICBib29sIG1fdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkIDogMTsKIAogI2lmIFVTRShTQUZBUklf VEhFTUUpCiAgICAgICAgIHN0YXRpYyBib29sIGdTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzOwpJ bmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1RpbGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5MCBAQAorLyoK KyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRp YXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgVGlsZV9oCisj ZGVmaW5lIFRpbGVfaAorCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNs dWRlICJJbnRSZWN0LmgiCisjaW5jbHVkZSA8d3RmL0hhc2hGdW5jdGlvbnMuaD4KKyNpbmNsdWRl IDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisKKyNpZiBQ TEFURk9STShRVCkKK2NsYXNzIFFQaXhtYXA7CitjbGFzcyBRUmVnaW9uOworI2VuZGlmCisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDsKK2NsYXNzIFRp bGVkQmFja2luZ1N0b3JlOworCitjbGFzcyBUaWxlIDogcHVibGljIFJlZkNvdW50ZWQ8VGlsZT4K K3sKK3B1YmxpYzoKKyAgICBjbGFzcyBDb29yZGluYXRlIHsKKyAgICBwdWJsaWM6CisgICAgICAg IENvb3JkaW5hdGUodW5zaWduZWQgeCwgdW5zaWduZWQgeSkgOiBtX3goeCksIG1feSh5KSB7IH0K KyAgICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IENvb3JkaW5hdGUmIG8pIGNvbnN0IHsgcmV0 dXJuIG1feCA9PSBvLm1feCAmJiBtX3kgPT0gby5tX3k7IH0KKyAgICAgICAgdW5zaWduZWQgeCgp IGNvbnN0IHsgcmV0dXJuIG1feDsgfQorICAgICAgICB1bnNpZ25lZCB5KCkgY29uc3QgeyByZXR1 cm4gbV95OyB9CisgICAgICAgIHVuc2lnbmVkIGhhc2goKSBjb25zdCB7CisgICAgICAgICAgICB1 bnNpZ25lZCBoYXNoID0gV1RGOjppbnRIYXNoKHN0YXRpY19jYXN0PHVpbnQ2NF90PihtX3gpIDw8 IDMyIHwgbV95KTsKKyAgICAgICAgICAgIC8vIGF2b2lkIGVtcHR5IGFuZCBkZWxldGVkIHZhbHVl CisgICAgICAgICAgICByZXR1cm4gaGFzaCB8ICghKGhhc2ggKyAxKSA8PCAzMSk7CisgICAgICAg IH0KKyAgICBwcml2YXRlOgorICAgICAgICB1bnNpZ25lZCBtX3g7CisgICAgICAgIHVuc2lnbmVk IG1feTsKKyAgICB9OworCisgICAgc3RhdGljIFBhc3NSZWZQdHI8VGlsZT4gY3JlYXRlKFRpbGVk QmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUsIGNvbnN0IENvb3JkaW5hdGUmIHRpbGVDb29yZGlu YXRlKSB7IHJldHVybiBhZG9wdFJlZihuZXcgVGlsZShiYWNraW5nU3RvcmUsIHRpbGVDb29yZGlu YXRlKSk7IH0KKyAgICB+VGlsZSgpOworICAgIAorICAgIGJvb2wgaXNEaXJ0eSgpIGNvbnN0Owor ICAgIHZvaWQgaW52YWxpZGF0ZShjb25zdCBJbnRSZWN0Jik7CisgICAgdm9pZCB1cGRhdGVCYWNr QnVmZmVyKCk7CisgICAgdm9pZCBzd2FwQmFja0J1ZmZlclRvRnJvbnQoKTsKKyAgICBib29sIGlz UmVhZHlUb1BhaW50KCkgY29uc3Q7CisgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBj b25zdCBJbnRSZWN0Jik7CisKKyAgICBjb25zdCBUaWxlOjpDb29yZGluYXRlIGNvb3JkaW5hdGUo KSBjb25zdCB7IHJldHVybiBtX2Nvb3JkaW5hdGU7IH0KKyAgICBjb25zdCBJbnRSZWN0JiByZWN0 KCkgY29uc3QgeyByZXR1cm4gbV9yZWN0OyB9CisgICAgCisgICAgc3RhdGljIHZvaWQgcGFpbnRD aGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqLCBjb25zdCBGbG9hdFJlY3QmKTsKKworcHJp dmF0ZToKKyAgICBUaWxlKFRpbGVkQmFja2luZ1N0b3JlKiwgY29uc3QgQ29vcmRpbmF0ZSYpOwor ICAgIAorICAgIFRpbGVkQmFja2luZ1N0b3JlKiBtX2JhY2tpbmdTdG9yZTsKKyAgICBDb29yZGlu YXRlIG1fY29vcmRpbmF0ZTsKKyAgICBJbnRSZWN0IG1fcmVjdDsKKworI2lmIFBMQVRGT1JNKFFU KQorICAgIFFQaXhtYXAqIG1fYnVmZmVyOworICAgIFFQaXhtYXAqIG1fYmFja0J1ZmZlcjsKKyAg ICBRUmVnaW9uKiBtX2RpcnR5UmVnaW9uOworI2VuZGlmCit9OworCit9CisjZW5kaWYKKyNlbmRp ZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9y ZS5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFj a2luZ1N0b3JlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNjIgQEAKKy8qCisgQ29weXJp Z2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVz KQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBCb3N0 b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NU T1JFKQorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCisjaW5jbHVkZSAiVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworICAgIAorc3RhdGljIGNv bnN0IGludCBkZWZhdWx0VGlsZVdpZHRoID0gNTEyOworc3RhdGljIGNvbnN0IGludCBkZWZhdWx0 VGlsZUhlaWdodCA9IDUxMjsKKworVGlsZWRCYWNraW5nU3RvcmU6OlRpbGVkQmFja2luZ1N0b3Jl KFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50KiBjbGllbnQpCisgICAgOiBtX2NsaWVudChjbGllbnQp CisgICAgLCBtX3RpbGVCdWZmZXJVcGRhdGVUaW1lcihuZXcgVGlsZVRpbWVyKHRoaXMsICZUaWxl ZEJhY2tpbmdTdG9yZTo6dGlsZUJ1ZmZlclVwZGF0ZVRpbWVyRmlyZWQpKQorICAgICwgbV90aWxl Q3JlYXRpb25UaW1lcihuZXcgVGlsZVRpbWVyKHRoaXMsICZUaWxlZEJhY2tpbmdTdG9yZTo6dGls ZUNyZWF0aW9uVGltZXJGaXJlZCkpCisgICAgLCBtX3RpbGVTaXplKGRlZmF1bHRUaWxlV2lkdGgs IGRlZmF1bHRUaWxlSGVpZ2h0KQorICAgICwgbV9jb250ZW50c1NjYWxlKDEuZikKK3sKK30KKwor VGlsZWRCYWNraW5nU3RvcmU6On5UaWxlZEJhY2tpbmdTdG9yZSgpCit7CisgICAgZGVsZXRlIG1f dGlsZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIGRlbGV0ZSBtX3RpbGVDcmVhdGlvblRpbWVyOwor fQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjppbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGNv bnRlbnRzRGlydHlSZWN0KQoreworICAgIEludFJlY3QgZGlydHlSZWN0KG1hcEZyb21Db250ZW50 cyhjb250ZW50c0RpcnR5UmVjdCkpOworICAgIAorICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVm dCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGls ZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlS ZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIAorICAgIGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUg PSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueSgpOyArK3lDb29yZGlu YXRlKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgeENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsg eENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgpOyArK3hDb29yZGluYXRlKSB7CisgICAgICAg ICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRpbGUgPSB0aWxlQXQoVGlsZTo6Q29vcmRpbmF0ZSh4 Q29vcmRpbmF0ZSwgeUNvb3JkaW5hdGUpKTsKKyAgICAgICAgICAgIGlmICghY3VycmVudFRpbGUp CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBjdXJyZW50VGlsZS0+aW52 YWxpZGF0ZShkaXJ0eVJlY3QpOworICAgICAgICB9CisgICAgfQorCisgICAgc3RhcnRUaWxlQnVm ZmVyVXBkYXRlVGltZXIoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dXBkYXRlVGls ZUJ1ZmZlcnMoKQoreworICAgIGlmIChtX2NvbnRlbnRzRnJvemVuKQorICAgICAgICByZXR1cm47 CisgICAgCisgICAgVmVjdG9yPEludFJlY3Q+IHBhaW50ZWRBcmVhOworICAgIFZlY3RvcjxSZWZQ dHI8VGlsZT4gPiBkaXJ0eVRpbGVzOworICAgIFRpbGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGls ZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4o KTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIGlmICghaXQtPnNlY29uZC0+aXNEaXJ0eSgp KQorICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIGRpcnR5VGlsZXMuYXBwZW5kKGl0LT5z ZWNvbmQpOworICAgICAgICAvLyBGSVhNRTogc2hvdWxkIG5vdCByZXF1ZXN0IHN5c3RlbSByZXBh aW50IGZvciB0aGUgZnVsbCB0aWxlLgorICAgICAgICBwYWludGVkQXJlYS5hcHBlbmQobWFwVG9D b250ZW50cyhpdC0+c2Vjb25kLT5yZWN0KCkpKTsKKyAgICB9CisgICAgCisgICAgaWYgKGRpcnR5 VGlsZXMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgbV9jbGllbnQtPnRp bGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOworCisgICAgLy8gRklYTUU6IEluIHNpbmdsZSB0 aHJlYWRlZCBjYXNlLCB0aWxlIGJhY2sgYnVmZmVycyBjb3VsZCBiZSB1cGRhdGVkIGFzeW5jaHJv bm91c2x5IAorICAgIC8vIG9uZSBieSBvbmUgYW5kIHRoZW4gc3dhcHBlZCB0byBmcm9udCBpbiBv bmUgZ28uIFRoaXMgd291bGQgbWluaW1pemUgdGhlIHRpbWUgc3BlbnQKKyAgICAvLyBibG9ja2lu ZyBvbiB0aWxlIHVwZGF0ZXMuCisgICAgdW5zaWduZWQgc2l6ZSA9IGRpcnR5VGlsZXMuc2l6ZSgp OworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5 VGlsZXNbbl0tPnVwZGF0ZUJhY2tCdWZmZXIoKTsKKworICAgIGZvciAodW5zaWduZWQgbiA9IDA7 IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnN3YXBCYWNrQnVmZmVyVG9G cm9udCgpOworCisgICAgbV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQocGFpbnRl ZEFyZWEpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpwYWludChHcmFwaGljc0NvbnRl eHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgY29udGV4dC0+c2F2ZSgp OworICAgIAorICAgIC8vIEFzc3VtZXMgdGhlIGJhY2tpbmcgc3RvcmUgaXMgcGFpbnRlZCB3aXRo IHRoZSBzY2FsZSB0cmFuc2Zvcm0gYXBwbGllZC4KKyAgICAvLyBTaW5jZSB0aWxlIGNvbnRlbnQg aXMgYWxyZWFkeSBzY2FsZWQsIGZpcnN0IHJldmVydCB0aGUgc2NhbGluZyBmcm9tIHRoZSBwYWlu dGVyLgorICAgIGNvbnRleHQtPnNjYWxlKEZsb2F0U2l6ZSgxLmYgLyBtX2NvbnRlbnRzU2NhbGUs IDEuZiAvIG1fY29udGVudHNTY2FsZSkpOworICAgIAorICAgIEludFJlY3QgZGlydHlSZWN0ID0g bWFwRnJvbUNvbnRlbnRzKHJlY3QpOworICAgIAorICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVm dCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGls ZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlS ZWN0LmJvdHRvbVJpZ2h0KCkpOworCisgICAgZm9yICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRv cExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUp IHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29vcmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29v cmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsreENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAg IFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGlu YXRlKTsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxlPiBjdXJyZW50VGlsZSA9IHRpbGVBdChjdXJy ZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICBpZiAoY3VycmVudFRpbGUgJiYgY3VycmVudFRp bGUtPmlzUmVhZHlUb1BhaW50KCkpCisgICAgICAgICAgICAgICAgY3VycmVudFRpbGUtPnBhaW50 KGNvbnRleHQsIGRpcnR5UmVjdCk7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgICAg ICBGbG9hdFJlY3QgdGlsZVJlY3QgPSB0aWxlUmVjdEZvckNvb3JkaW5hdGUoY3VycmVudENvb3Jk aW5hdGUpOworICAgICAgICAgICAgICAgIEZsb2F0UmVjdCB0YXJnZXQgPSBpbnRlcnNlY3Rpb24o dGlsZVJlY3QsIEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgICAgICAgICAgVGlsZTo6cGFpbnRD aGVja2VyUGF0dGVybihjb250ZXh0LCB0YXJnZXQpOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgfQorICAgIGNvbnRleHQtPnJlc3RvcmUoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdT dG9yZTo6dmlld3BvcnRDaGFuZ2VkKGNvbnN0IEludFJlY3QmIGNvbnRlbnRzVmlld3BvcnQpCit7 CisgICAgSW50UmVjdCB2aWV3cG9ydCA9IG1hcEZyb21Db250ZW50cyhjb250ZW50c1ZpZXdwb3J0 KTsKKyAgICBpZiAobV92aWV3cG9ydCA9PSB2aWV3cG9ydCkKKyAgICAgICAgcmV0dXJuOworCisg ICAgbV92aWV3cG9ydCA9IHZpZXdwb3J0OworCisgICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigp OworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzZXRDb250ZW50c1NjYWxlKGZsb2F0IHNj YWxlKQoreworICAgIGlmIChtX2NvbnRlbnRzU2NhbGUgPT0gc2NhbGUpCisgICAgICAgIHJldHVy bjsKKyAgICBtX2NvbnRlbnRzU2NhbGUgPSBzY2FsZTsKKworICAgIGludmFsaWRhdGUobV9jbGll bnQtPnRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNSZWN0KCkpOworfQorICAgIAorZG91YmxlIFRp bGVkQmFja2luZ1N0b3JlOjp0aWxlRGlzdGFuY2UoY29uc3QgSW50UmVjdCYgdmlld3BvcnQsIGNv bnN0IFRpbGU6OkNvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQoreworICAgIGlmICh2aWV3cG9y dC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpKQorICAg ICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQb2ludCB2aWV3Q2VudGVyID0gdmlld3BvcnQu bG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQud2lkdGgoKSAvIDIsIHZpZXdwb3J0LmhlaWdo dCgpIC8gMik7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBjZW50ZXJDb29yZGluYXRlID0gdGlsZUNv b3JkaW5hdGVGb3JQb2ludCh2aWV3Q2VudGVyKTsKKyAgICAKKyAgICAvLyBNYW5oYXR0YW4gZGlz dGFuY2UsIGJpYXNlZCBzbyB0aGF0IHZlcnRpY2FsIGRpc3RhbmNlcyBhcmUgc2hvcnRlci4KKyAg ICBjb25zdCBkb3VibGUgaG9yaXpvbnRhbEJpYXMgPSAxLjM7CisgICAgcmV0dXJuIGFicyhjZW50 ZXJDb29yZGluYXRlLnkoKSAtIHRpbGVDb29yZGluYXRlLnkoKSkgKyBob3Jpem9udGFsQmlhcyAq IGFicyhjZW50ZXJDb29yZGluYXRlLngoKSAtIHRpbGVDb29yZGluYXRlLngoKSk7Cit9CisKK3Zv aWQgVGlsZWRCYWNraW5nU3RvcmU6OmNyZWF0ZVRpbGVzKCkKK3sKKyAgICBpZiAobV9jb250ZW50 c0Zyb3plbikKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG1fdmlld3BvcnQuaXNFbXB0eSgp KQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBSZW1vdmUgdGlsZXMgdGhhdCBleHRlbmQgb3V0 c2lkZSB0aGUgY3VycmVudCBjb250ZW50cyByZWN0LgorICAgIGRyb3BPdmVyaGFuZ2luZ1RpbGVz KCk7CisKKyAgICAvLyBGSVhNRTogTWFrZSBjb25maWd1cmFibGUvYWRhcHQgdG8gbWVtb3J5Lgor ICAgIEludFJlY3Qga2VlcFJlY3QgPSBtX3ZpZXdwb3J0OworICAgIGtlZXBSZWN0LmluZmxhdGVY KG1fdmlld3BvcnQud2lkdGgoKSk7CisgICAga2VlcFJlY3QuaW5mbGF0ZVkoMyAqIG1fdmlld3Bv cnQuaGVpZ2h0KCkpOworICAgIGtlZXBSZWN0LmludGVyc2VjdChjb250ZW50c1JlY3QoKSk7Cisg ICAgCisgICAgZHJvcFRpbGVzT3V0c2lkZVJlY3Qoa2VlcFJlY3QpOworICAgIAorICAgIEludFJl Y3QgY292ZXJSZWN0ID0gbV92aWV3cG9ydDsKKyAgICBjb3ZlclJlY3QuaW5mbGF0ZVgobV92aWV3 cG9ydC53aWR0aCgpIC8gMik7CisgICAgY292ZXJSZWN0LmluZmxhdGVZKDIgKiBtX3ZpZXdwb3J0 LmhlaWdodCgpKTsKKyAgICBjb3ZlclJlY3QuaW50ZXJzZWN0KGNvbnRlbnRzUmVjdCgpKTsKKyAg ICAKKyAgICBkb3VibGUgc2hvcnRlc3REaXN0YW5jZSA9IHN0ZDo6bnVtZXJpY19saW1pdHM8ZG91 YmxlPjo6aW5maW5pdHkoKTsKKyAgICBWZWN0b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdGlsZXNUb0Ny ZWF0ZTsKKyAgICB1bnNpZ25lZCByZXF1aXJlZFRpbGVDb3VudCA9IDA7CisgICAgCisgICAgVGls ZTo6Q29vcmRpbmF0ZSB0b3BMZWZ0ID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb3ZlclJlY3Qu dG9wTGVmdCgpKTsKKyAgICBUaWxlOjpDb29yZGluYXRlIGJvdHRvbVJpZ2h0ID0gdGlsZUNvb3Jk aW5hdGVGb3JQb2ludChjb3ZlclJlY3QuYm90dG9tUmlnaHQoKSk7CisgICAgZm9yICh1bnNpZ25l ZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC55 KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29vcmRpbmF0ZSA9 IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsreENvb3JkaW5h dGUpIHsKKyAgICAgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3JkaW5hdGUoeENv b3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmICh0aWxlQXQoY3VycmVudENv b3JkaW5hdGUpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgKytyZXF1 aXJlZFRpbGVDb3VudDsKKyAgICAgICAgICAgIC8vIDAgZGlzdGFuY2UgZm9yIGN1cnJlbnRseSB2 aXNpYmxlIHRpbGVzLgorICAgICAgICAgICAgZG91YmxlIGRpc3RhbmNlID0gdGlsZURpc3RhbmNl KG1fdmlld3BvcnQsIGN1cnJlbnRDb29yZGluYXRlKTsKKyAgICAgICAgICAgIGlmIChkaXN0YW5j ZSA+IHNob3J0ZXN0RGlzdGFuY2UpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICBpZiAoZGlzdGFuY2UgPCBzaG9ydGVzdERpc3RhbmNlKSB7CisgICAgICAgICAgICAgICAg dGlsZXNUb0NyZWF0ZS5jbGVhcigpOworICAgICAgICAgICAgICAgIHNob3J0ZXN0RGlzdGFuY2Ug PSBkaXN0YW5jZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHRpbGVzVG9DcmVhdGUuYXBw ZW5kKGN1cnJlbnRDb29yZGluYXRlKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICB1bnNp Z25lZCB0aWxlc1RvQ3JlYXRlQ291bnQgPSB0aWxlc1RvQ3JlYXRlLnNpemUoKTsKKyAgICBpZiAo dGlsZXNUb0NyZWF0ZUNvdW50KSB7CisgICAgICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCB0 aWxlc1RvQ3JlYXRlQ291bnQ7ICsrbikgeworICAgICAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBj b29yZGluYXRlID0gdGlsZXNUb0NyZWF0ZVtuXTsKKyAgICAgICAgICAgIHNldFRpbGUoY29vcmRp bmF0ZSwgVGlsZTo6Y3JlYXRlKHRoaXMsIGNvb3JkaW5hdGUpKTsKKyAgICAgICAgfQorICAgICAg ICByZXF1aXJlZFRpbGVDb3VudCAtPSB0aWxlc1RvQ3JlYXRlQ291bnQ7CisgICAgfQorICAgIAor ICAgIC8vIFBhaW50IHRoZSBjb250ZW50IG9mIHRoZSBuZXdseSBjcmVhdGVkIHRpbGVzCisgICAg aWYgKHRpbGVzVG9DcmVhdGVDb3VudCkKKyAgICAgICAgdXBkYXRlVGlsZUJ1ZmZlcnMoKTsKKwor ICAgIC8vIEtlZXAgY3JlYXRpbmcgdGlsZXMgdW50aWwgdGhlIHdob2xlIGNvdmVyUmVjdCBpcyBj b3ZlcmVkLgorICAgIGlmIChyZXF1aXJlZFRpbGVDb3VudCkKKyAgICAgICAgbV90aWxlQ3JlYXRp b25UaW1lci0+c3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpk cm9wT3ZlcmhhbmdpbmdUaWxlcygpCit7ICAgIAorICAgIEludFJlY3QgY29udGVudHNSZWN0ID0g dGhpcy0+Y29udGVudHNSZWN0KCk7CisKKyAgICBWZWN0b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdGls ZXNUb1JlbW92ZTsKKyAgICBUaWxlTWFwOjppdGVyYXRvciBlbmQgPSBtX3RpbGVzLmVuZCgpOwor ICAgIGZvciAoVGlsZU1hcDo6aXRlcmF0b3IgaXQgPSBtX3RpbGVzLmJlZ2luKCk7IGl0ICE9IGVu ZDsgKytpdCkgeworICAgICAgICBUaWxlOjpDb29yZGluYXRlIHRpbGVDb29yZGluYXRlID0gaXQt PnNlY29uZC0+Y29vcmRpbmF0ZSgpOworICAgICAgICBJbnRSZWN0IHRpbGVSZWN0ID0gaXQtPnNl Y29uZC0+cmVjdCgpOworICAgICAgICBJbnRSZWN0IGV4cGVjdGVkVGlsZVJlY3QgPSB0aWxlUmVj dEZvckNvb3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpOworICAgICAgICBpZiAoZXhwZWN0ZWRUaWxl UmVjdCAhPSB0aWxlUmVjdCB8fCAhY29udGVudHNSZWN0LmNvbnRhaW5zKHRpbGVSZWN0KSkKKyAg ICAgICAgICAgIHRpbGVzVG9SZW1vdmUuYXBwZW5kKHRpbGVDb29yZGluYXRlKTsKKyAgICB9Cisg ICAgdW5zaWduZWQgcmVtb3ZlQ291bnQgPSB0aWxlc1RvUmVtb3ZlLnNpemUoKTsKKyAgICBmb3Ig KHVuc2lnbmVkIG4gPSAwOyBuIDwgcmVtb3ZlQ291bnQ7ICsrbikKKyAgICAgICAgcmVtb3ZlVGls ZSh0aWxlc1RvUmVtb3ZlW25dKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6ZHJvcFRp bGVzT3V0c2lkZVJlY3QoY29uc3QgSW50UmVjdCYga2VlcFJlY3QpCit7CisgICAgRmxvYXRSZWN0 IGtlZXBSZWN0RiA9IGtlZXBSZWN0OworCisgICAgVmVjdG9yPFRpbGU6OkNvb3JkaW5hdGU+IHRv UmVtb3ZlOworICAgIFRpbGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAg Zm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyAr K2l0KSB7CisgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY29vcmRpbmF0ZSA9IGl0LT5zZWNvbmQt PmNvb3JkaW5hdGUoKTsKKyAgICAgICAgRmxvYXRSZWN0IHRpbGVSZWN0ID0gaXQtPnNlY29uZC0+ cmVjdCgpOworICAgICAgICBpZiAoIXRpbGVSZWN0LmludGVyc2VjdHMoa2VlcFJlY3RGKSkKKyAg ICAgICAgICAgIHRvUmVtb3ZlLmFwcGVuZChjb29yZGluYXRlKTsKKyAgICB9CisgICAgdW5zaWdu ZWQgcmVtb3ZlQ291bnQgPSB0b1JlbW92ZS5zaXplKCk7CisgICAgZm9yICh1bnNpZ25lZCBuID0g MDsgbiA8IHJlbW92ZUNvdW50OyArK24pCisgICAgICAgIHJlbW92ZVRpbGUodG9SZW1vdmVbbl0p OworfQorCitQYXNzUmVmUHRyPFRpbGU+IFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQXQoY29uc3Qg VGlsZTo6Q29vcmRpbmF0ZSYgY29vcmRpbmF0ZSkgY29uc3QKK3sKKyAgICByZXR1cm4gbV90aWxl cy5nZXQoY29vcmRpbmF0ZS5oYXNoKCkpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpz ZXRUaWxlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NSZWZQdHI8VGls ZT4gdGlsZSkKK3sKKyAgICBtX3RpbGVzLnNldChjb29yZGluYXRlLmhhc2goKSwgdGlsZSk7Cit9 CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnJlbW92ZVRpbGUoY29uc3QgVGlsZTo6Q29vcmRp bmF0ZSYgY29vcmRpbmF0ZSkKK3sKKyAgICBtX3RpbGVzLnJlbW92ZShjb29yZGluYXRlLmhhc2go KSk7Cit9CisKK0ludFJlY3QgVGlsZWRCYWNraW5nU3RvcmU6Om1hcFRvQ29udGVudHMoY29uc3Qg SW50UmVjdCYgcmVjdCkgY29uc3QKK3sKKyAgICByZXR1cm4gZW5jbG9zaW5nSW50UmVjdChGbG9h dFJlY3QocmVjdC54KCkgLyBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QueSgpIC8gbV9j b250ZW50c1NjYWxlLAorICAgICAgICByZWN0LndpZHRoKCkgLyBtX2NvbnRlbnRzU2NhbGUsCisg ICAgICAgIHJlY3QuaGVpZ2h0KCkgLyBtX2NvbnRlbnRzU2NhbGUpKTsKK30KKworSW50UmVjdCBU aWxlZEJhY2tpbmdTdG9yZTo6bWFwRnJvbUNvbnRlbnRzKGNvbnN0IEludFJlY3QmIHJlY3QpIGNv bnN0Cit7CisgICAgcmV0dXJuIGVuY2xvc2luZ0ludFJlY3QoRmxvYXRSZWN0KHJlY3QueCgpICog bV9jb250ZW50c1NjYWxlLAorICAgICAgICByZWN0LnkoKSAqIG1fY29udGVudHNTY2FsZSwKKyAg ICAgICAgcmVjdC53aWR0aCgpICogbV9jb250ZW50c1NjYWxlLAorICAgICAgICByZWN0LmhlaWdo dCgpICogbV9jb250ZW50c1NjYWxlKSk7Cit9CisKK0ludFJlY3QgVGlsZWRCYWNraW5nU3RvcmU6 OmNvbnRlbnRzUmVjdCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1hcEZyb21Db250ZW50cyhtX2Ns aWVudC0+dGlsZWRCYWNraW5nU3RvcmVDb250ZW50c1JlY3QoKSk7Cit9CisKK0ludFJlY3QgVGls ZWRCYWNraW5nU3RvcmU6OnRpbGVSZWN0Rm9yQ29vcmRpbmF0ZShjb25zdCBUaWxlOjpDb29yZGlu YXRlJiBjb29yZGluYXRlKSBjb25zdAoreworICAgIEludFJlY3QgcmVjdChjb29yZGluYXRlLngo KSAqIG1fdGlsZVNpemUud2lkdGgoKSwKKyAgICAgICAgY29vcmRpbmF0ZS55KCkgKiBtX3RpbGVT aXplLmhlaWdodCgpLAorICAgICAgICBtX3RpbGVTaXplLndpZHRoKCksCisgICAgICAgIG1fdGls ZVNpemUuaGVpZ2h0KCkpOworCisgICAgcmVjdC5pbnRlcnNlY3QoY29udGVudHNSZWN0KCkpOwor ICAgIHJldHVybiByZWN0OworfQorICAgIAorVGlsZTo6Q29vcmRpbmF0ZSBUaWxlZEJhY2tpbmdT dG9yZTo6dGlsZUNvb3JkaW5hdGVGb3JQb2ludChjb25zdCBJbnRQb2ludCYgcG9pbnQpIGNvbnN0 Cit7CisgICAgaW50IHggPSBwb2ludC54KCkgLyBtX3RpbGVTaXplLndpZHRoKCk7CisgICAgaW50 IHkgPSBwb2ludC55KCkgLyBtX3RpbGVTaXplLmhlaWdodCgpOworICAgIHJldHVybiBUaWxlOjpD b29yZGluYXRlKHN0ZDo6bWF4KHgsIDApLCBzdGQ6Om1heCh5LCAwKSk7Cit9CisKKwordm9pZCBU aWxlZEJhY2tpbmdTdG9yZTo6c3RhcnRUaWxlQnVmZmVyVXBkYXRlVGltZXIoKQoreworICAgIGlm IChtX3RpbGVCdWZmZXJVcGRhdGVUaW1lci0+aXNBY3RpdmUoKSB8fCBtX2NvbnRlbnRzRnJvemVu KQorICAgICAgICByZXR1cm47CisgICAgbV90aWxlQnVmZmVyVXBkYXRlVGltZXItPnN0YXJ0T25l U2hvdCgwKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dGlsZUJ1ZmZlclVwZGF0ZVRp bWVyRmlyZWQoVGlsZVRpbWVyKikKK3sKKyAgICB1cGRhdGVUaWxlQnVmZmVycygpOworfQorCit2 b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpzdGFydFRpbGVDcmVhdGlvblRpbWVyKCkKK3sKKyAgICBp ZiAobV90aWxlQ3JlYXRpb25UaW1lci0+aXNBY3RpdmUoKSB8fCBtX2NvbnRlbnRzRnJvemVuKQor ICAgICAgICByZXR1cm47CisgICAgbV90aWxlQ3JlYXRpb25UaW1lci0+c3RhcnRPbmVTaG90KDAp OworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3JlYXRpb25UaW1lckZpcmVkKFRp bGVUaW1lciopCit7CisgICAgY3JlYXRlVGlsZXMoKTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdT dG9yZTo6c2V0Q29udGVudHNGcm96ZW4oYm9vbCBmcmVlemUpCit7CisgICAgaWYgKG1fY29udGVu dHNGcm96ZW4gPT0gZnJlZXplKQorICAgICAgICByZXR1cm47CisKKyAgICBtX2NvbnRlbnRzRnJv emVuID0gZnJlZXplOworCisgICAgLy8gUmVzdGFydCB0aGUgdGltZXJzLiBUaGVyZSBtaWdodCBi ZSBwZW5kaW5nIGludmFsaWRhdGlvbnMgdGhhdAorICAgIC8vIHdlcmUgbm90IHBhaW50ZWQgb3Ig Y3JlYXRlZCBiZWNhdXNlIHRpbGVzIGFyZSBub3QgY3JlYXRlZCBvcgorICAgIC8vIHBhaW50ZWQg d2hlbiBpbiBmcm96ZW4gc3RhdGUuCisgICAgaWYgKCFtX2NvbnRlbnRzRnJvemVuKSB7CisgICAg ICAgIHN0YXJ0VGlsZUNyZWF0aW9uVGltZXIoKTsKKyAgICAgICAgc3RhcnRUaWxlQnVmZmVyVXBk YXRlVGltZXIoKTsKKyAgICB9CisgICAgLy8gc3RvcHBpbmcgaXMgaGFuZGxlZCB3aGVuIHRoZSB0 aW1lcnMgZmlyZQorfQorCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5nU3RvcmUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSwxMDcgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9v ciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAK KyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZu ZGVmIFRpbGVkQmFja2luZ1N0b3JlX2gKKyNkZWZpbmUgVGlsZWRCYWNraW5nU3RvcmVfaAorCisj aWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNsdWRlICJJbnRSZWN0LmgiCisj aW5jbHVkZSAiRmxvYXRTaXplLmgiCisjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlICJUaWxl LmgiCisjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5o PgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGls ZWRCYWNraW5nU3RvcmVDbGllbnQ7CisKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlIDogcHVibGlj IE5vbmNvcHlhYmxlCit7CitwdWJsaWM6CisgICAgVGlsZWRCYWNraW5nU3RvcmUoVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQqKTsKKyAgICB+VGlsZWRCYWNraW5nU3RvcmUoKTsKKworICAgIHZvaWQg dmlld3BvcnRDaGFuZ2VkKGNvbnN0IEludFJlY3QmIHZpZXdwb3J0UmVjdCk7CisgICAgCisgICAg ZmxvYXQgY29udGVudHNTY2FsZSgpIHsgcmV0dXJuIG1fY29udGVudHNTY2FsZTsgfQorICAgIHZv aWQgc2V0Q29udGVudHNTY2FsZShmbG9hdCk7CisgICAgCisgICAgYm9vbCBjb250ZW50c0Zyb3pl bigpIGNvbnN0IHsgcmV0dXJuIG1fY29udGVudHNGcm96ZW47IH0KKyAgICB2b2lkIHNldENvbnRl bnRzRnJvemVuKGJvb2wpOworCisgICAgdm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGRp cnR5UmVjdCk7CisgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0 Jik7CisKK3ByaXZhdGU6CisgICAgdm9pZCBzdGFydFRpbGVCdWZmZXJVcGRhdGVUaW1lcigpOwor ICAgIHZvaWQgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgIAorICAgIHR5cGVkZWYgVGlt ZXI8VGlsZWRCYWNraW5nU3RvcmU+IFRpbGVUaW1lcjsKKworICAgIHZvaWQgdGlsZUJ1ZmZlclVw ZGF0ZVRpbWVyRmlyZWQoVGlsZVRpbWVyKik7CisgICAgdm9pZCB0aWxlQ3JlYXRpb25UaW1lckZp cmVkKFRpbGVUaW1lciopOworICAgIAorICAgIHZvaWQgdXBkYXRlVGlsZUJ1ZmZlcnMoKTsKKyAg ICB2b2lkIGNyZWF0ZVRpbGVzKCk7CisKKyAgICB2b2lkIGRyb3BPdmVyaGFuZ2luZ1RpbGVzKCk7 CisgICAgdm9pZCBkcm9wVGlsZXNPdXRzaWRlUmVjdChjb25zdCBJbnRSZWN0Jik7CisgICAgCisg ICAgUGFzc1JlZlB0cjxUaWxlPiB0aWxlQXQoY29uc3QgVGlsZTo6Q29vcmRpbmF0ZSYpIGNvbnN0 OworICAgIHZvaWQgc2V0VGlsZShjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRlLCBQ YXNzUmVmUHRyPFRpbGU+IHRpbGUpOworICAgIHZvaWQgcmVtb3ZlVGlsZShjb25zdCBUaWxlOjpD b29yZGluYXRlJiBjb29yZGluYXRlKTsKKworICAgIEludFJlY3QgbWFwVG9Db250ZW50cyhjb25z dCBJbnRSZWN0JikgY29uc3Q7CisgICAgSW50UmVjdCBtYXBGcm9tQ29udGVudHMoY29uc3QgSW50 UmVjdCYpIGNvbnN0OworICAgIAorICAgIEludFJlY3QgY29udGVudHNSZWN0KCkgY29uc3Q7Cisg ICAgCisgICAgSW50UmVjdCB0aWxlUmVjdEZvckNvb3JkaW5hdGUoY29uc3QgVGlsZTo6Q29vcmRp bmF0ZSYpIGNvbnN0OworICAgIFRpbGU6OkNvb3JkaW5hdGUgdGlsZUNvb3JkaW5hdGVGb3JQb2lu dChjb25zdCBJbnRQb2ludCYpIGNvbnN0OworICAgIGRvdWJsZSB0aWxlRGlzdGFuY2UoY29uc3Qg SW50UmVjdCYgdmlld3BvcnQsIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmKTsKKyAgICAKKyAgICB2 b2lkIHBhaW50Q2hlY2tlclBhdHRlcm4oR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYs IGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmKTsKKworICAgIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50 KiBtX2NsaWVudDsKKworICAgIHR5cGVkZWYgSGFzaE1hcDx1bnNpZ25lZCwgUmVmUHRyPFRpbGU+ ID4gVGlsZU1hcDsKKyAgICBUaWxlTWFwIG1fdGlsZXM7CisKKyAgICBUaWxlVGltZXIqIG1fdGls ZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIFRpbGVUaW1lciogbV90aWxlQ3JlYXRpb25UaW1lcjsK KworICAgIEludFNpemUgbV90aWxlU2l6ZTsKKyAgICAKKyAgICBJbnRSZWN0IG1fdmlld3BvcnQ7 CisgICAgZmxvYXQgbV9jb250ZW50c1NjYWxlOworCisgICAgYm9vbCBtX2NvbnRlbnRzRnJvemVu OworCisgICAgZnJpZW5kIGNsYXNzIFRpbGU7Cit9OworCit9CisKKyNlbmRpZgorI2VuZGlmCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9y ZUNsaWVudC5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxl ZEJhY2tpbmdTdG9yZUNsaWVudC5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQxIEBACisvKgor IENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlh cnkoLWllcykKKyAKKyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgCisgVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgorIAorIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CisgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBUaWxlZEJhY2tp bmdTdG9yZUNsaWVudF9oCisjZGVmaW5lIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50X2gKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCitjbGFz cyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudAoreworcHVibGljOgorICAgIHZpcnR1YWwgdm9pZCB0 aWxlZEJhY2tpbmdTdG9yZVBhaW50QmVnaW4oKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVk QmFja2luZ1N0b3JlUGFpbnQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYpID0gMDsK KyAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEVuZChjb25zdCBWZWN0b3I8 SW50UmVjdD4mIHBhaW50ZWRBcmVhKSA9IDA7CisgICAgdmlydHVhbCBJbnRSZWN0IHRpbGVkQmFj a2luZ1N0b3JlQ29udGVudHNSZWN0KCkgPSAwOworfTsKKworI2Vsc2UKK2NsYXNzIFRpbGVkQmFj a2luZ1N0b3JlQ2xpZW50IHt9OworI2VuZGlmCisKK30KKworI2VuZGlmCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4 MiBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0 cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJUaWxlLmgiCisKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lO R19TVE9SRSkKKworI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIlRpbGVk QmFja2luZ1N0b3JlLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmVDbGllbnQuaCIKKyNp bmNsdWRlIDxRQXBwbGljYXRpb24+CisjaW5jbHVkZSA8UUJhc2ljVGltZXI+CisjaW5jbHVkZSA8 UURlYnVnPgorI2luY2x1ZGUgPFFJbWFnZT4KKyNpbmNsdWRlIDxRT2JqZWN0PgorI2luY2x1ZGUg PFFQYWludGVyPgorI2luY2x1ZGUgPFFSZWdpb24+CisjaW5jbHVkZSA8UVRocmVhZD4KKworbmFt ZXNwYWNlIFdlYkNvcmUgeworICAgIAorc3RhdGljIGNvbnN0IGludCBjaGVja2VyU2l6ZSA9IDE2 Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjEgPSAweGZmNTU1NTU1Oworc3Rh dGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjIgPSAweGZmYWFhYWFhOworICAgIAorc3Rh dGljIFFQaXhtYXAmIGNoZWNrZXJlZFBpeG1hcCgpCit7CisgICAgc3RhdGljIFFQaXhtYXAqIHBp eG1hcDsKKyAgICBpZiAoIXBpeG1hcCkgeworICAgICAgICBwaXhtYXAgPSBuZXcgUVBpeG1hcCg0 ICogY2hlY2tlclNpemUsIDQgKiBjaGVja2VyU2l6ZSk7CisgICAgICAgIFFQYWludGVyIHBhaW50 ZXIocGl4bWFwKTsKKyAgICAgICAgUUNvbG9yIGNvbG9yMShjaGVja2VyQ29sb3IxKTsKKyAgICAg ICAgUUNvbG9yIGNvbG9yMihjaGVja2VyQ29sb3IyKTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7 IHkgPCBjaGVja2VyU2l6ZTsgeSArPSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAgIGJv b2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJTaXplOworICAgICAgICAgICAgZm9yIChpbnQgeCA9 IDA7IHggPCBjaGVja2VyU2l6ZTsgeCArPSBjaGVja2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAg ICAgICBwYWludGVyLmZpbGxSZWN0KHgsIHksIGNoZWNrZXJTaXplIC8gMiwgY2hlY2tlclNpemUg LyAyLCBhbHRlcm5hdGUgPyBjb2xvcjEgOiBjb2xvcjIpOworICAgICAgICAgICAgICAgIGFsdGVy bmF0ZSA9ICFhbHRlcm5hdGU7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisgICAg cmV0dXJuICpwaXhtYXA7Cit9CisgICAgCitUaWxlOjpUaWxlKFRpbGVkQmFja2luZ1N0b3JlKiBi YWNraW5nU3RvcmUsIGNvbnN0IENvb3JkaW5hdGUmIHRpbGVDb29yZGluYXRlKQorICAgIDogbV9i YWNraW5nU3RvcmUoYmFja2luZ1N0b3JlKQorICAgICwgbV9jb29yZGluYXRlKHRpbGVDb29yZGlu YXRlKQorICAgICwgbV9yZWN0KG1fYmFja2luZ1N0b3JlLT50aWxlUmVjdEZvckNvb3JkaW5hdGUo dGlsZUNvb3JkaW5hdGUpKQorICAgICwgbV9idWZmZXIoMCkKKyAgICAsIG1fYmFja0J1ZmZlcigw KQorICAgICwgbV9kaXJ0eVJlZ2lvbihuZXcgUVJlZ2lvbihtX3JlY3QpKQoreworfQorCitUaWxl Ojp+VGlsZSgpCit7CisgICAgZGVsZXRlIG1fYnVmZmVyOworICAgIGRlbGV0ZSBtX2JhY2tCdWZm ZXI7CisgICAgZGVsZXRlIG1fZGlydHlSZWdpb247Cit9CisKK2Jvb2wgVGlsZTo6aXNEaXJ0eSgp IGNvbnN0IAoreyAKKyAgICByZXR1cm4gIW1fZGlydHlSZWdpb24tPmlzRW1wdHkoKTsgCit9CisK K2Jvb2wgVGlsZTo6aXNSZWFkeVRvUGFpbnQoKSBjb25zdAoreyAKKyAgICByZXR1cm4gbV9idWZm ZXI7IAorfQorCit2b2lkIFRpbGU6OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZGlydHlSZWN0 KQoreworICAgIEludFJlY3QgdGlsZURpcnR5UmVjdCA9IGludGVyc2VjdGlvbihkaXJ0eVJlY3Qs IG1fcmVjdCk7CisgICAgaWYgKHRpbGVEaXJ0eVJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm47CisKKyAgICAqbV9kaXJ0eVJlZ2lvbiArPSB0aWxlRGlydHlSZWN0OworfQorICAgIAordm9p ZCBUaWxlOjp1cGRhdGVCYWNrQnVmZmVyKCkKK3sKKyAgICBpZiAobV9idWZmZXIgJiYgIWlzRGly dHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2JhY2tCdWZmZXIpIHsKKyAgICAg ICAgaWYgKCFtX2J1ZmZlcikKKyAgICAgICAgICAgIG1fYmFja0J1ZmZlciA9IG5ldyBRUGl4bWFw KG1fYmFja2luZ1N0b3JlLT5tX3RpbGVTaXplLndpZHRoKCksIG1fYmFja2luZ1N0b3JlLT5tX3Rp bGVTaXplLmhlaWdodCgpKTsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAvLyBDdXJyZW50 bHkgYWxsIGJ1ZmZlcnMgYXJlIHVwZGF0ZWQgc3luY2hyb25vdXNseSBhdCB0aGUgc2FtZSB0aW1l IHNvIHRoZXJlIGlzIG5vIHJlYWwgbmVlZAorICAgICAgICAgICAgLy8gdG8gaGF2ZSBzZXBhcmF0 ZSBiYWNrIGFuZCBmcm9udCBidWZmZXJzLiBKdXN0IHVzZSB0aGUgZXhpc3RpbmcgYnVmZmVyLgor ICAgICAgICAgICAgbV9iYWNrQnVmZmVyID0gbV9idWZmZXI7CisgICAgICAgICAgICBtX2J1ZmZl ciA9IDA7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBRVmVjdG9yPFFSZWN0PiBkaXJ0eVJlY3Rz ID0gbV9kaXJ0eVJlZ2lvbi0+cmVjdHMoKTsKKyAgICAqbV9kaXJ0eVJlZ2lvbiA9IFFSZWdpb24o KTsKKyAgICAKKyAgICBRUGFpbnRlciBwYWludGVyKG1fYmFja0J1ZmZlcik7CisgICAgR3JhcGhp Y3NDb250ZXh0IGNvbnRleHQoJnBhaW50ZXIpOworICAgIGNvbnRleHQudHJhbnNsYXRlKC1tX3Jl Y3QueCgpLCAtbV9yZWN0LnkoKSk7CisKKyAgICBpbnQgc2l6ZSA9IGRpcnR5UmVjdHMuc2l6ZSgp OworICAgIGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKSAgeworICAgICAgICBjb250ZXh0 LnNhdmUoKTsKKyAgICAgICAgSW50UmVjdCByZWN0ID0gZGlydHlSZWN0c1tuXTsKKyAgICAgICAg Y29udGV4dC5jbGlwKEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgIGNvbnRleHQuc2NhbGUoRmxv YXRTaXplKG1fYmFja2luZ1N0b3JlLT5tX2NvbnRlbnRzU2NhbGUsIG1fYmFja2luZ1N0b3JlLT5t X2NvbnRlbnRzU2NhbGUpKTsKKyAgICAgICAgbV9iYWNraW5nU3RvcmUtPm1fY2xpZW50LT50aWxl ZEJhY2tpbmdTdG9yZVBhaW50KCZjb250ZXh0LCBtX2JhY2tpbmdTdG9yZS0+bWFwVG9Db250ZW50 cyhyZWN0KSk7CisgICAgICAgIGNvbnRleHQucmVzdG9yZSgpOworICAgIH0KK30KKwordm9pZCBU aWxlOjpzd2FwQmFja0J1ZmZlclRvRnJvbnQoKQoreworICAgIGlmICghbV9iYWNrQnVmZmVyKQor ICAgICAgICByZXR1cm47CisgICAgZGVsZXRlIG1fYnVmZmVyOworICAgIG1fYnVmZmVyID0gbV9i YWNrQnVmZmVyOworICAgIG1fYmFja0J1ZmZlciA9IDA7Cit9CisKK3ZvaWQgVGlsZTo6cGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV9idWZmZXIpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBJbnRSZWN0IHRhcmdldCA9 IGludGVyc2VjdGlvbihyZWN0LCBtX3JlY3QpOworICAgIEludFJlY3Qgc291cmNlKCh0YXJnZXQu eCgpIC0gbV9yZWN0LngoKSksCisgICAgICAgICAgICAgICAgICAgKHRhcmdldC55KCkgLSBtX3Jl Y3QueSgpKSwKKyAgICAgICAgICAgICAgICAgICB0YXJnZXQud2lkdGgoKSwKKyAgICAgICAgICAg ICAgICAgICB0YXJnZXQuaGVpZ2h0KCkpOworICAgIAorICAgIGNvbnRleHQtPnBsYXRmb3JtQ29u dGV4dCgpLT5kcmF3UGl4bWFwKHRhcmdldCwgKm1fYnVmZmVyLCBzb3VyY2UpOworfQorICAgIAor dm9pZCBUaWxlOjpwYWludENoZWNrZXJQYXR0ZXJuKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwg Y29uc3QgRmxvYXRSZWN0JiB0YXJnZXQpCit7CisgICAgUVBhaW50ZXIqIHBhaW50ZXIgPSBjb250 ZXh0LT5wbGF0Zm9ybUNvbnRleHQoKTsKKyAgICBRVHJhbnNmb3JtIHdvcmxkVHJhbnNmb3JtID0g cGFpbnRlci0+d29ybGRUcmFuc2Zvcm0oKTsKKyAgICBxcmVhbCBzY2FsZVggPSB3b3JsZFRyYW5z Zm9ybS5tMTEoKTsKKyAgICBxcmVhbCBzY2FsZVkgPSB3b3JsZFRyYW5zZm9ybS5tMjIoKTsKKyAg ICAKKyAgICBRUmVjdCB0YXJnZXRWaWV3UmVjdCA9IFFSZWN0Rih0YXJnZXQueCgpICogc2NhbGVY LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldC55KCkgKiBzY2FsZVks CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LndpZHRoKCkgKiBzY2Fs ZVgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LmhlaWdodCgpICog c2NhbGVZKS50b0FsaWduZWRSZWN0KCk7CisgICAgCisgICAgUVRyYW5zZm9ybSBhZGp1c3RlZFRy YW5zZm9ybSgxLiwgd29ybGRUcmFuc2Zvcm0ubTEyKCksIHdvcmxkVHJhbnNmb3JtLm0xMygpLAor ICAgICAgICAgICAgICAgICAgd29ybGRUcmFuc2Zvcm0ubTIxKCksIDEuLCB3b3JsZFRyYW5zZm9y bS5tMjMoKSwKKyAgICAgICAgICAgICAgICAgIHdvcmxkVHJhbnNmb3JtLm0zMSgpLCB3b3JsZFRy YW5zZm9ybS5tMzIoKSwgd29ybGRUcmFuc2Zvcm0ubTMzKCkpOworICAgIHBhaW50ZXItPnNldFdv cmxkVHJhbnNmb3JtKGFkanVzdGVkVHJhbnNmb3JtKTsKKyAgICAKKyAgICBwYWludGVyLT5kcmF3 VGlsZWRQaXhtYXAodGFyZ2V0Vmlld1JlY3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGNoZWNrZXJlZFBpeG1hcCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBRUG9pbnQo dGFyZ2V0Vmlld1JlY3QubGVmdCgpICUgY2hlY2tlclNpemUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB0YXJnZXRWaWV3UmVjdC50b3AoKSAlIGNoZWNrZXJTaXplKSk7Cisg ICAgCisgICAgcGFpbnRlci0+c2V0V29ybGRUcmFuc2Zvcm0od29ybGRUcmFuc2Zvcm0pOworfQor Cit9CisKKyNlbmRpZgpJbmRleDogV2ViS2l0L3F0L0FwaS9xZ3JhcGhpY3N3ZWJ2aWV3LmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3FncmFwaGljc3dlYnZpZXcuY3BwCShyZXZpc2lv biA1NTI3OSkKKysrIFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTI2LDcgKzI2LDEwIEBACiAjaW5jbHVkZSAicXdlYnBhZ2UuaCIKICNpbmNsdWRl ICJxd2VicGFnZV9wLmgiCiAjaW5jbHVkZSAiUVdlYlBhZ2VDbGllbnQuaCIKLSNpbmNsdWRlIDxG cmFtZVZpZXcuaD4KKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKKyNpbmNsdWRlICJHcmFwaGljc0Nv bnRleHQuaCIKKyNpbmNsdWRlICJJbnRSZWN0LmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3Rv cmUuaCIKICNpbmNsdWRlIDxRdENvcmUvcW1ldGFvYmplY3QuaD4KICNpbmNsdWRlIDxRdENvcmUv cXNoYXJlZHBvaW50ZXIuaD4KICNpbmNsdWRlIDxRdENvcmUvcXRpbWVyLmg+CkBAIC0zNSw2ICsz OCw3IEBACiAjaW5jbHVkZSA8UXRHdWkvcWdyYXBoaWNzc2NlbmVldmVudC5oPgogI2luY2x1ZGUg PFF0R3VpL3FncmFwaGljc3ZpZXcuaD4KICNpbmNsdWRlIDxRdEd1aS9xcGl4bWFwY2FjaGUuaD4K KyNpbmNsdWRlIDxRdEd1aS9xc2Nyb2xsYmFyLmg+CiAjaW5jbHVkZSA8UXRHdWkvcXN0eWxlb3B0 aW9uLmg+CiAjaWYgZGVmaW5lZChRX1dTX1gxMSkKICNpbmNsdWRlIDxRWDExSW5mbz4KQEAgLTEy MCw2ICsxMjQsNyBAQCBwdWJsaWM6CiAjZW5kaWYKICAgICAKICAgICB2b2lkIHVwZGF0ZVJlc2l6 ZXNUb0NvbnRlbnRzRm9yUGFnZSgpOworICAgIFFSZWN0RiB2aXNpYmxlUmVjdCgpIGNvbnN0Owog CiAgICAgdm9pZCBzeW5jTGF5ZXJzKCk7CiAgICAgdm9pZCBfcV9kb0xvYWRGaW5pc2hlZChib29s IHN1Y2Nlc3MpOwpAQCAtMzQwLDYgKzM0NSwyMyBAQCB2b2lkIFFHcmFwaGljc1dlYlZpZXdQcml2 YXRlOjpfcV9jb250ZW50CiAgICAgcS0+c2V0R2VvbWV0cnkoUVJlY3RGKHEtPmdlb21ldHJ5KCku dG9wTGVmdCgpLCBzaXplKSk7CiB9CiAKK1FSZWN0RiBRR3JhcGhpY3NXZWJWaWV3UHJpdmF0ZTo6 dmlzaWJsZVJlY3QoKSBjb25zdAoreworICAgIGlmICghcS0+c2NlbmUoKSkKKyAgICAgICAgcmV0 dXJuIFFSZWN0RigpOworICAgIFFMaXN0PFFHcmFwaGljc1ZpZXcqPiB2aWV3cyA9IHEtPnNjZW5l KCktPnZpZXdzKCk7CisgICAgaWYgKHZpZXdzLnNpemUoKSA+IDEpIHsKKyAgICAgICAgcURlYnVn KCkgPDwgIlFHcmFwaGljc1dlYlZpZXcgaXMgaW4gbW9yZSB0aGFuIG9uZSBncmFwaGljcyB2aWV3 cywgdW5hYmxlIHRvIGNvbXB1dGUgdGhlIHZpc2libGUgcmVjdCI7CisgICAgICAgIHJldHVybiBR UmVjdEYoKTsKKyAgICB9CisgICAgaWYgKHZpZXdzLnNpemUoKSA8IDEpCisgICAgICAgIHJldHVy biBRUmVjdEYoKTsKKworICAgIGludCBoID0gdmlld3NbMF0tPmhvcml6b250YWxTY3JvbGxCYXIo KS0+dmFsdWUoKTsKKyAgICBpbnQgdiA9IHZpZXdzWzBdLT52ZXJ0aWNhbFNjcm9sbEJhcigpLT52 YWx1ZSgpOworICAgIHJldHVybiBxLT5tYXBSZWN0RnJvbVNjZW5lKFFSZWN0RihRUG9pbnQoaCwg diksIHZpZXdzWzBdLT52aWV3cG9ydCgpLT5zaXplKCkpKTsKK30KKwogLyohCiAgICAgXGNsYXNz IFFHcmFwaGljc1dlYlZpZXcKICAgICBcYnJpZWYgVGhlIFFHcmFwaGljc1dlYlZpZXcgY2xhc3Mg YWxsb3dzIFdlYiBjb250ZW50IHRvIGJlIGFkZGVkIHRvIGEgR3JhcGhpY3NWaWV3LgpAQCAtNDMz LDYgKzQ1NSw3IEBAIFFHcmFwaGljc1dlYlZpZXc6OlFHcmFwaGljc1dlYlZpZXcoUUdyYXAKICNl bmRpZgogICAgIHNldEZvY3VzUG9saWN5KFF0OjpTdHJvbmdGb2N1cyk7CiAgICAgc2V0RmxhZyhR R3JhcGhpY3NJdGVtOjpJdGVtQ2xpcHNDaGlsZHJlblRvU2hhcGUsIHRydWUpOworICAgIHNldEZs YWcoUUdyYXBoaWNzSXRlbTo6SXRlbVNlbmRzR2VvbWV0cnlDaGFuZ2VzLCB0cnVlKTsKIH0KIAog LyohCkBAIC00ODIsNiArNTA1LDE4IEBAIFFXZWJQYWdlKiBRR3JhcGhpY3NXZWJWaWV3OjpwYWdl KCkgY29uc3QKICovCiB2b2lkIFFHcmFwaGljc1dlYlZpZXc6OnBhaW50KFFQYWludGVyKiBwYWlu dGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbiwgUVdpZGdldCopCiB7 CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgLy8gRklYTUU6IFNjcm9sbGJh cnMgY291bGQgYmUgZHJhd24gd2l0aCB0aGUgb3ZlcmxheSBsYXllciB3aGVuIHVzaW5nIHRpbGlu Zy4KKyAgICBXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlID0gUVdlYkZy YW1lUHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNraW5nU3RvcmUo KTs7CisgICAgaWYgKGJhY2tpbmdTdG9yZSkgeworICAgICAgICAvLyBGSVhNRTogV2Ugc2hvdWxk IHNldCB0aGUgYmFja2luZyBzdG9yZSB2aWV3cGFydCBlYXJsaWVyIHRoYW4gaW4gcGFpbnQuCisg ICAgICAgIGJhY2tpbmdTdG9yZS0+dmlld3BvcnRDaGFuZ2VkKFdlYkNvcmU6OkludFJlY3QoZC0+ dmlzaWJsZVJlY3QoKSkpOworICAgICAgICAvLyBRV2ViRnJhbWU6OnJlbmRlciBpcyBhIHB1Ymxp YyBBUEksIGJ5cGFzcyBpdCBmb3IgdGlsZWQgcmVuZGVyaW5nIHNvIGJlaGF2aW9yIGRvZXMgbm90 IG5lZWQgdG8gY2hhbmdlLgorICAgICAgICBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQgY29udGV4 dChwYWludGVyKTsgCisgICAgICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPmQtPnJlbmRlckNvbnRl bnRzTGF5ZXJBYnNvbHV0ZUNvb3JkcygmY29udGV4dCwgb3B0aW9uLT5leHBvc2VkUmVjdC50b0Fs aWduZWRSZWN0KCkpOworICAgICAgICByZXR1cm47CisgICAgfSAKKyNlbmRpZgogI2lmIFVTRShB Q0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICBwYWdlKCktPm1haW5GcmFtZSgpLT5yZW5kZXIo cGFpbnRlciwgZC0+b3ZlcmxheSA/IFFXZWJGcmFtZTo6Q29udGVudHNMYXllciA6IFFXZWJGcmFt ZTo6QWxsTGF5ZXJzLCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvQWxpZ25lZFJlY3QoKSk7CiAjZWxz ZQpAQCAtNTIxLDEwICs1NTYsMTEgQEAgUVZhcmlhbnQgUUdyYXBoaWNzV2ViVmlldzo6aXRlbUNo YW5nZShHcgogICAgIC8vIGZpcmUgJ0N1cnNvckNoYW5nZScuCiAgICAgY2FzZSBJdGVtQ3Vyc29y Q2hhbmdlOgogICAgICAgICByZXR1cm4gdmFsdWU7Ci0gICAgY2FzZSBJdGVtQ3Vyc29ySGFzQ2hh bmdlZDoKLSAgICAgICAgUUV2ZW50IGV2ZW50KFFFdmVudDo6Q3Vyc29yQ2hhbmdlKTsKLSAgICAg ICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQodGhpcywgJmV2ZW50KTsKLSAgICAgICAgcmV0dXJu IHZhbHVlOworICAgIGNhc2UgSXRlbUN1cnNvckhhc0NoYW5nZWQ6IHsKKyAgICAgICAgICAgIFFF dmVudCBldmVudChRRXZlbnQ6OkN1cnNvckNoYW5nZSk7CisgICAgICAgICAgICBRQXBwbGljYXRp b246OnNlbmRFdmVudCh0aGlzLCAmZXZlbnQpOworICAgICAgICAgICAgcmV0dXJuIHZhbHVlOwor ICAgICAgICB9CiAgICAgfQogCiAgICAgcmV0dXJuIFFHcmFwaGljc1dpZGdldDo6aXRlbUNoYW5n ZShjaGFuZ2UsIHZhbHVlKTsKSW5kZXg6IFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAJKHJldmlzaW9uIDU1Mjc5KQor KysgV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01OCw2ICs1 OCw3IEBACiAjaW5jbHVkZSAiU2VsZWN0aW9uQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIlN1YnN0 aXR1dGVEYXRhLmgiCiAjaW5jbHVkZSAiU1ZHU01JTEVsZW1lbnQuaCIKKyNpbmNsdWRlICJUaWxl ZEJhY2tpbmdTdG9yZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAibWFy a3VwLmgiCiAjaW5jbHVkZSAicXRfaW5zdGFuY2UuaCIKQEAgLTMzOSw3ICszNDAsMTEgQEAgdm9p ZCBRV2ViRnJhbWVQcml2YXRlOjpyZW5kZXJDb250ZW50c0xheQogICAgIFFQYWludGVyKiBwYWlu dGVyID0gY29udGV4dC0+cGxhdGZvcm1Db250ZXh0KCk7CiAKICAgICBXZWJDb3JlOjpGcmFtZVZp ZXcqIHZpZXcgPSBmcmFtZS0+dmlldygpOwotICAgIHZpZXctPmxheW91dElmTmVlZGVkUmVjdXJz aXZlKCk7CisgICAgCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgaWYgKCFm cmFtZS0+dGlsZWRCYWNraW5nU3RvcmUoKSkKKyNlbmRpZgorICAgICAgICB2aWV3LT5sYXlvdXRJ Zk5lZWRlZFJlY3Vyc2l2ZSgpOwogCiAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCB2ZWN0b3Iuc2l6 ZSgpOyArK2kpIHsKICAgICAgICAgY29uc3QgUVJlY3QmIGNsaXBSZWN0ID0gdmVjdG9yLmF0KGkp OwpAQCAtMzQ4LDcgKzM1MywxMiBAQCB2b2lkIFFXZWJGcmFtZVByaXZhdGU6OnJlbmRlckNvbnRl bnRzTGF5CiAgICAgICAgIHBhaW50ZXItPnNldENsaXBSZWN0KGNsaXBSZWN0LCBRdDo6SW50ZXJz ZWN0Q2xpcCk7CiAKICAgICAgICAgY29udGV4dC0+c2F2ZSgpOwotICAgICAgICB2aWV3LT5wYWlu dENvbnRlbnRzKGNvbnRleHQsIGNsaXBSZWN0KTsKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19T VE9SRSkKKyAgICAgICAgaWYgKGZyYW1lLT50aWxlZEJhY2tpbmdTdG9yZSgpKQorICAgICAgICAg ICAgZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCktPnBhaW50KGNvbnRleHQsIGNsaXBSZWN0KTsK KyAgICAgICAgZWxzZQorI2VuZGlmCisgICAgICAgICAgICB2aWV3LT5wYWludENvbnRlbnRzKGNv bnRleHQsIGNsaXBSZWN0KTsKICAgICAgICAgY29udGV4dC0+cmVzdG9yZSgpOwogCiAgICAgICAg IHBhaW50ZXItPnJlc3RvcmUoKTsKSW5kZXg6IFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAkocmV2aXNpb24gNTUyNzkpCisr KyBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMjIsNiArMjIy LDcgQEAgUV9TSUdOQUxTOgogICAgIHZvaWQgcGFnZUNoYW5nZWQoKTsKIAogcHJpdmF0ZToKKyAg ICBmcmllbmQgY2xhc3MgUUdyYXBoaWNzV2ViVmlldzsKICAgICBmcmllbmQgY2xhc3MgUVdlYlBh Z2U7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJQYWdlUHJpdmF0ZTsKICAgICBmcmllbmQgY2xhc3Mg UVdlYkZyYW1lUHJpdmF0ZTsKSW5kZXg6IFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAJKHJldmlzaW9uIDU1 Mjc5KQorKysgV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0yMzAsNiArMjMwLDEwIEBAIHZvaWQgUVdlYlNldHRpbmdzUHJpdmF0ZTo6YXBwbHkoKQogICAg ICAgICB2YWx1ZSA9IGF0dHJpYnV0ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpYU1NBdWRpdG9yRW5h YmxlZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xvYmFsLT5hdHRy aWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5nczo6WFNTQXVkaXRvckVuYWJsZWQpKTsKICAgICAgICAg c2V0dGluZ3MtPnNldFhTU0F1ZGl0b3JFbmFibGVkKHZhbHVlKTsKKyAgICAgICAgCisgICAgICAg IHZhbHVlID0gYXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlRpbGVkQmFja2luZ1N0b3Jl RW5hYmxlZCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2xvYmFsLT5h dHRyaWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5nczo6VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKSk7 CisgICAgICAgIHNldHRpbmdzLT5zZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQodmFsdWUpOwog CiAgICAgICAgIHNldHRpbmdzLT5zZXRVc2VzUGFnZUNhY2hlKFdlYkNvcmU6OnBhZ2VDYWNoZSgp LT5jYXBhY2l0eSgpKTsKICAgICB9IGVsc2UgewpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2V0 dGluZ3MuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5oCShyZXZp c2lvbiA1NTI3OSkKKysrIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmgJKHdvcmtpbmcgY29w eSkKQEAgLTcxLDYgKzcxLDcgQEAgcHVibGljOgogICAgICAgICBEbnNQcmVmZXRjaEVuYWJsZWQs CiAgICAgICAgIFhTU0F1ZGl0b3JFbmFibGVkLAogICAgICAgICBBY2NlbGVyYXRlZENvbXBvc2l0 aW5nRW5hYmxlZCwKKyAgICAgICAgVGlsZWRCYWNraW5nU3RvcmVFbmFibGVkLAogICAgICAgICBX ZWJHTEVuYWJsZWQKICAgICB9OwogICAgIGVudW0gV2ViR3JhcGhpYyB7CkluZGV4OiBXZWJLaXRU b29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9TY3Jp cHRzL2J1aWxkLXdlYmtpdAkocmV2aXNpb24gNTUyNzkpCisrKyBXZWJLaXRUb29scy9TY3JpcHRz L2J1aWxkLXdlYmtpdAkod29ya2luZyBjb3B5KQpAQCAtNTYsNyArNTYsNyBAQCBteSAoJHRocmVl RENhbnZhc1N1cHBvcnQsICR0aHJlZURSZW5kZXJpCiAgICAgJGphdmFTY3JpcHREZWJ1Z2dlclN1 cHBvcnQsICRtYXRobWxTdXBwb3J0LCAkb2ZmbGluZVdlYkFwcGxpY2F0aW9uU3VwcG9ydCwgJHJ1 YnlTdXBwb3J0LCAkc2FuZGJveFN1cHBvcnQsICRzaGFyZWRXb3JrZXJzU3VwcG9ydCwKICAgICAk c3ZnU3VwcG9ydCwgJHN2Z0FuaW1hdGlvblN1cHBvcnQsICRzdmdBc0ltYWdlU3VwcG9ydCwgJHN2 Z0RPTU9iakNCaW5kaW5nc1N1cHBvcnQsICRzdmdGb250c1N1cHBvcnQsCiAgICAgJHN2Z0ZvcmVp Z25PYmplY3RTdXBwb3J0LCAkc3ZnVXNlU3VwcG9ydCwgJHZpZGVvU3VwcG9ydCwgJHdlYlNvY2tl dHNTdXBwb3J0LCAkd21sU3VwcG9ydCwgJHdjc3NTdXBwb3J0LCAkeGh0bWxtcFN1cHBvcnQsICR3 b3JrZXJzU3VwcG9ydCwKLSAgICAkeHBhdGhTdXBwb3J0LCAkeHNsdFN1cHBvcnQsICRjb3ZlcmFn ZVN1cHBvcnQsICRub3RpZmljYXRpb25zU3VwcG9ydCk7CisgICAgJHhwYXRoU3VwcG9ydCwgJHhz bHRTdXBwb3J0LCAkY292ZXJhZ2VTdXBwb3J0LCAkbm90aWZpY2F0aW9uc1N1cHBvcnQsICR0aWxl ZEJhY2tpbmdTdG9yZVN1cHBvcnQpOwogCiBteSBAZmVhdHVyZXMgPSAoCiAgICAgeyBvcHRpb24g PT4gIjNkLWNhbnZhcyIsIGRlc2MgPT4gIlRvZ2dsZSAzRCBjYW52YXMgc3VwcG9ydCIsCkBAIC0x NDMsNiArMTQzLDkgQEAgbXkgQGZlYXR1cmVzID0gKAogICAgIHsgb3B0aW9uID0+ICJzdmctdXNl IiwgZGVzYyA9PiAiVG9nZ2xlIFNWRyB1c2UgZWxlbWVudCBzdXBwb3J0IChpbXBsaWVzIFNWRyBz dXBwb3J0KSIsCiAgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9TVkdfVVNFIiwgZGVmYXVsdCA9PiAx LCB2YWx1ZSA9PiBcJHN2Z1VzZVN1cHBvcnQgfSwKIAorICAgIHsgb3B0aW9uID0+ICJ0aWxlZC1i YWNraW5nLXN0b3JlIiwgZGVzYyA9PiAiVG9nZ2xlIFRpbGVkIEJhY2tpbmcgU3RvcmUgc3VwcG9y dCIsCisgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9USUxFRF9CQUNLSU5HX1NUT1JFIiwgZGVmYXVs dCA9PiBpc1F0KCksIHZhbHVlID0+IFwkdGlsZWRCYWNraW5nU3RvcmVTdXBwb3J0IH0sCisKICAg ICB7IG9wdGlvbiA9PiAidmlkZW8iLCBkZXNjID0+ICJUb2dnbGUgVmlkZW8gc3VwcG9ydCIsCiAg ICAgICBkZWZpbmUgPT4gIkVOQUJMRV9WSURFTyIsIGRlZmF1bHQgPT4gKGlzQXBwbGVXZWJLaXQo KSB8fCBpc0d0aygpKSwgdmFsdWUgPT4gXCR2aWRlb1N1cHBvcnQgfSwKIAo= 49950 2010-03-03 14:35:38 -0800 2010-03-04 09:52:25 -0800 updated patch tiled-backing-store-9.patch text/plain 41988 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcmkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnByaQkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJpCSh3b3JraW5nIGNv cHkpCkBAIC03Nyw2ICs3Nyw5IEBAIGdyZWF0ZXJUaGFuKFFUX01JTk9SX1ZFUlNJT04sIDUpIHsK ICMgSFRNTDUgZGF0YWxpc3Qgc3VwcG9ydAogIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9EQVRB TElTVD0uKTogREVGSU5FUyArPSBFTkFCTEVfREFUQUxJU1Q9MQogCisjIFRpbGVkIEJhY2tpbmcg U3RvcmUgc3VwcG9ydAorIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9USUxFRF9CQUNLSU5HX1NU T1JFPS4pOiBERUZJTkVTICs9IEVOQUJMRV9USUxFRF9CQUNLSU5HX1NUT1JFPTEKKwogIyBOZXNj YXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkpCiAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05F VFNDQVBFX1BMVUdJTl9BUEk9LikgewogICAgIHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNl KjogewpAQCAtMTQ3LDYgKzE1MCw3IEBAIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9KQVZBU0NS SVBUX0RFQlUKIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9PRkZMSU5FX1dFQl9BUFBMSUNBVElP TlM9MSk6IEZFQVRVUkVfREVGSU5FU19KQVZBU0NSSVBUICs9IEVOQUJMRV9PRkZMSU5FX1dFQl9B UFBMSUNBVElPTlM9MQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQl9TT0NLRVRTPTEpOiBG RUFUVVJFX0RFRklORVNfSkFWQVNDUklQVCArPSBFTkFCTEVfV0VCX1NPQ0tFVFM9MQogY29udGFp bnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFT Q1JJUFQgKz0gRU5BQkxFX1RPVUNIX0VWRU5UUz0xCitjb250YWlucyhERUZJTkVTLCBFTkFCTEVf VElMRURfQkFDS0lOR19TVE9SRT0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFTQ1JJUFQgKz0gRU5B QkxFX1RJTEVEX0JBQ0tJTkdfU1RPUkU9MQogCiAKICMjIERlcml2ZWQgc291cmNlIGdlbmVyYXRv cnMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJD b3JlLnBybwkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5n IGNvcHkpCkBAIC04MjYsNiArODI2LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvUGVuLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU2VnbWVudGVkRm9udERhdGEu Y3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5jcHAgXAorICAgIHBs YXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcCBcCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9NYXRyaXhUcmFuc2Zvcm1PcGVyYXRpb24uY3BwIFwKQEAgLTE1 MzUsNiArMTUzNiw5IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3F0L1N0 aWxsSW1hZ2VRdC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TZWdtZW50ZWRGb250RGF0YS5o IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5oIFwKKyAgICBwbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmggXAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0 b3JlLmggXCAgICAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZUNsaWVu dC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL01hdHJpeDNEVHJhbnNmb3Jt T3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvTWF0cml4VHJh bnNmb3JtT3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvUGVy c3BlY3RpdmVUcmFuc2Zvcm1PcGVyYXRpb24uaCBcCkBAIC0yMDI4LDYgKzIwMzIsNyBAQCBTT1VS Q0VTICs9IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9Gb250Q3VzdG9tUGxhdGZvcm1EYXRh UXQuY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HbHlwaFBhZ2VUcmVlTm9kZVF0LmNw cCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvcXQvU2ltcGxlRm9udERhdGFRdC5jcHAgXAorICAg IHBsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0tVUkxR dC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0xvY2FsaXphdGlvbnMuY3BwIFwKICAgICBwbGF0Zm9y bS9xdC9NSU1FVHlwZVJlZ2lzdHJ5UXQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNTU0NTkp CisrKyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3 IEBACiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNp bmNsdWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3Rv cmUuaCIKICNpbmNsdWRlICJVc2VyQ29udGVudFVSTFBhdHRlcm4uaCIKICNpbmNsdWRlICJYTUxO U05hbWVzLmgiCiAjaW5jbHVkZSAiWE1MTmFtZXMuaCIKQEAgLTE3MSw5ICsxNzIsMTMgQEAgRnJh bWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRQogICAgIFhNTE5TTmFtZXM6Omlu aXQoKTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwogCi0gICAgaWYgKCFvd25lckVsZW1lbnQpCisg ICAgaWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAgICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMp OwotICAgIGVsc2UgeworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICAv LyBUb3AgbGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAgICAgICBzZXRUaWxlZEJhY2tpbmdT dG9yZUVuYWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkp OworI2VuZGlmCisgICAgfSBlbHNlIHsKICAgICAgICAgcGFnZS0+aW5jcmVtZW50RnJhbWVDb3Vu dCgpOwogICAgICAgICAvLyBNYWtlIHN1cmUgd2Ugd2lsbCBub3QgZW5kIHVwIHdpdGggdHdvIGZy YW1lcyByZWZlcmVuY2luZyB0aGUgc2FtZSBvd25lciBlbGVtZW50LgogICAgICAgICBBU1NFUlQo KCEob3duZXJFbGVtZW50LT5tX2NvbnRlbnRGcmFtZSkpIHx8IChvd25lckVsZW1lbnQtPm1fY29u dGVudEZyYW1lLT5vd25lckVsZW1lbnQoKSAhPSBvd25lckVsZW1lbnQpKTsKQEAgLTE4NDEsNCAr MTg0Niw0OSBAQCB2b2lkIEZyYW1lOjpjcmVhdGVWaWV3KGNvbnN0IEludFNpemUmIHZpCiAgICAg ICAgIHZpZXcoKS0+c2V0Q2FuSGF2ZVNjcm9sbGJhcnMob3duZXItPnNjcm9sbGluZ01vZGUoKSAh PSBTY3JvbGxiYXJBbHdheXNPZmYpOwogfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RP UkUpCit2b2lkIEZyYW1lOjpzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCBlbmFibGVk KQoreworICAgIGlmICghZW5hYmxlZCkgeworICAgICAgICBtX3RpbGVkQmFja2luZ1N0b3JlLmNs ZWFyKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKG1fdGlsZWRCYWNraW5nU3Rv cmUpCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVkQmFja2luZ1N0b3JlLnNldChuZXcgVGls ZWRCYWNraW5nU3RvcmUodGhpcykpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9y ZVBhaW50QmVnaW4oKQoreworICAgIGlmICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAg bV92aWV3LT5sYXlvdXRJZk5lZWRlZFJlY3Vyc2l2ZSgpOworICAgIG1fdmlldy0+Zmx1c2hEZWZl cnJlZFJlcGFpbnRzKCk7Cit9CisKK3ZvaWQgRnJhbWU6OnRpbGVkQmFja2luZ1N0b3JlUGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAgbV92aWV3LT5wYWludENvbnRlbnRzKGNv bnRleHQsIHJlY3QpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZVBhaW50RW5k KGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpCit7CisgICAgaWYgKCFtX3BhZ2Ug fHwgIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIHVuc2lnbmVkIHNpemUgPSBwYWludGVk QXJlYS5zaXplKCk7CisgICAgLy8gUmVxdWVzdCByZXBhaW50IGZyb20gdGhlIHN5c3RlbQorICAg IGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKQorICAgICAgICBtX3BhZ2UtPmNocm9tZSgp LT5yZXBhaW50KG1fdmlldy0+Y29udmVydFRvQ29udGFpbmluZ1dpbmRvdyhwYWludGVkQXJlYVtu XSksIHRydWUpOworfQorCitJbnRSZWN0IEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRz UmVjdCgpCit7CisgICAgaWYgKCFtX3ZpZXcpCisgICAgICAgIHJldHVybiBJbnRSZWN0KCk7Cisg ICAgcmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbV92aWV3LT5jb250ZW50c1NpemUoKSk7Cit9 CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0Zy YW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDU1NDU5 KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTM3LDYgKzM3LDcg QEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU2Nyb2xsQmVoYXZp b3IuaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiVGlsZWRC YWNraW5nU3RvcmVDbGllbnQuaCIKICNpbmNsdWRlICJVc2VyU2NyaXB0VHlwZXMuaCIKICNpbmNs dWRlICJab29tTW9kZS5oIgogCkBAIC02Myw4ICs2NCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICBjbGFzcyBDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbjsKICAgICBjbGFzcyBIVE1MVGFi bGVDZWxsRWxlbWVudDsKICAgICBjbGFzcyBSZWd1bGFyRXhwcmVzc2lvbjsKKyAgICBjbGFzcyBU aWxlZEJhY2tpbmdTdG9yZTsKIAotICAgIGNsYXNzIEZyYW1lIDogcHVibGljIFJlZkNvdW50ZWQ8 RnJhbWU+IHsKKyAgICBjbGFzcyBGcmFtZSA6IHB1YmxpYyBSZWZDb3VudGVkPEZyYW1lPiwgcHVi bGljIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IHsKICAgICBwdWJsaWM6CiAgICAgICAgIHN0YXRp YyBQYXNzUmVmUHRyPEZyYW1lPiBjcmVhdGUoUGFnZSogcGFnZSwgSFRNTEZyYW1lT3duZXJFbGVt ZW50KiBvd25lckVsZW1lbnQsIEZyYW1lTG9hZGVyQ2xpZW50KiBjbGllbnQpCiAgICAgICAgIHsK QEAgLTE2NCw2ICsxNjYsMTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAgICAgcmV0 dXJuIGRvY3VtZW50KCkgPyBkb2N1bWVudCgpLT5kaXNwbGF5U3RyaW5nTW9kaWZpZWRCeUVuY29k aW5nKHN0cikgOiBzdHI7CiAgICAgICAgIH0KIAorI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NU T1JFKQorICAgICAgICBUaWxlZEJhY2tpbmdTdG9yZSogdGlsZWRCYWNraW5nU3RvcmUoKSBjb25z dCB7IHJldHVybiBtX3RpbGVkQmFja2luZ1N0b3JlLmdldCgpOyB9CisgICAgICAgIHZvaWQgc2V0 VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wpOworI2VuZGlmCisKICAgICBwcml2YXRlOgog ICAgICAgICB2b2lkIGxpZmVTdXBwb3J0VGltZXJGaXJlZChUaW1lcjxGcmFtZT4qKTsKIApAQCAt MjY5LDYgKzI3NiwxNSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgVmlzaWJsZVBv c2l0aW9uIHZpc2libGVQb3NpdGlvbkZvclBvaW50KGNvbnN0IEludFBvaW50JiBmcmFtZVBvaW50 KTsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50QXRQb2ludChjb25zdCBJbnRQb2ludCYgd2lu ZG93UG9pbnQpOworICAgICAgICAKKyAgICBwcml2YXRlOgorI2lmIEVOQUJMRShUSUxFRF9CQUNL SU5HX1NUT1JFKQorICAgICAgICAvLyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCBpbnRlcmZhY2UK KyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOworICAg ICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludChHcmFwaGljc0NvbnRleHQq LCBjb25zdCBJbnRSZWN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9y ZVBhaW50RW5kKGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpOworICAgICAgICB2 aXJ0dWFsIEludFJlY3QgdGlsZWRCYWNraW5nU3RvcmVDb250ZW50c1JlY3QoKTsKKyNlbmRpZgog CiAgICAgI2lmIFBMQVRGT1JNKE1BQykKIApAQCAtMzQ3LDYgKzM2MywxMCBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIGJvb2wgbV9uZWVkc1JlYXBwbHlTdHlsZXM7CiAgICAgICAgIGJv b2wgbV9pc0Rpc2Nvbm5lY3RlZDsKICAgICAgICAgYm9vbCBtX2V4Y2x1ZGVGcm9tVGV4dFNlYXJj aDsKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKSAgICAgICAgCisgICAgICAgIE93 blB0cjxUaWxlZEJhY2tpbmdTdG9yZT4gbV90aWxlZEJhY2tpbmdTdG9yZTsKKyNlbmRpZgogICAg IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZVZp ZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCShyZXZpc2lv biA1NTQ1OSkKKysrIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03MCw2ICs3MCw5IEBACiAjaW5jbHVkZSAiU1ZHVmlld1NwZWMuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUu aCIKKyNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTEwMTEsNiArMTAxNCwxMiBA QCB2b2lkIEZyYW1lVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5nbGUoCiAgICAgaWYgKCFpbW1l ZGlhdGUgJiYgaXNPZmZzY3JlZW4oKSAmJiAhc2hvdWxkVXBkYXRlV2hpbGVPZmZzY3JlZW4oKSkK ICAgICAgICAgcmV0dXJuOwogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAg aWYgKGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCkpIHsKKyAgICAgICAgZnJhbWUoKS0+dGls ZWRCYWNraW5nU3RvcmUoKS0+aW52YWxpZGF0ZShyKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KyNlbmRpZgogICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKHIsIGltbWVk aWF0ZSk7CiB9CiAKQEAgLTEwODIsOCArMTA5MSwxNSBAQCB2b2lkIEZyYW1lVmlldzo6ZG9EZWZl cnJlZFJlcGFpbnRzKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICB1bnNpZ25lZCBzaXpl ID0gbV9yZXBhaW50UmVjdHMuc2l6ZSgpOwotICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBz aXplOyBpKyspCisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemU7IGkrKykgeworI2lm IEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICBpZiAoZnJhbWUoKS0+dGlsZWRC YWNraW5nU3RvcmUoKSkgeworICAgICAgICAgICAgZnJhbWUoKS0+dGlsZWRCYWNraW5nU3RvcmUo KS0+aW52YWxpZGF0ZShtX3JlcGFpbnRSZWN0c1tpXSk7CisgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgfQorI2VuZGlmCiAgICAgICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVj dGFuZ2xlKG1fcmVwYWludFJlY3RzW2ldLCBmYWxzZSk7CisgICAgfQogICAgIG1fcmVwYWludFJl Y3RzLmNsZWFyKCk7CiAgICAgbV9yZXBhaW50Q291bnQgPSAwOwogICAgIApJbmRleDogV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu Y3BwCShyZXZpc2lvbiA1NTQ1OSkKKysrIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEyNSw2ICsxMjUsNyBAQCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSogcGFn ZSkKICAgICAsIG1fZXhwZXJpbWVudGFsTm90aWZpY2F0aW9uc0VuYWJsZWQoZmFsc2UpCiAgICAg LCBtX3dlYkdMRW5hYmxlZChmYWxzZSkKICAgICAsIG1fbG9hZERlZmVycmluZ0VuYWJsZWQodHJ1 ZSkKKyAgICAsIG1fdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGZhbHNlKQogewogICAgIC8vIEEg RnJhbWUgbWF5IG5vdCBoYXZlIGJlZW4gY3JlYXRlZCB5ZXQsIHNvIHdlIGluaXRpYWxpemUgdGhl IEF0b21pY1N0cmluZyAKICAgICAvLyBoYXNoIGJlZm9yZSB0cnlpbmcgdG8gdXNlIGl0LgpAQCAt NTc0LDQgKzU3NSwxMyBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2FkRGVmZXJyaW5nRW5hYmxlZChi CiAgICAgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCA9IGVuYWJsZWQ7CiB9CiAKK3ZvaWQgU2V0dGlu Z3M6OnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZChib29sIGVuYWJsZWQpCit7CisgICAgbV90 aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQgPSBlbmFibGVkOworI2lmIEVOQUJMRShUSUxFRF9CQUNL SU5HX1NUT1JFKQorICAgIGlmIChtX3BhZ2UtPm1haW5GcmFtZSgpKQorICAgICAgICBtX3BhZ2Ut Pm1haW5GcmFtZSgpLT5zZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoZW5hYmxlZCk7CisjZW5k aWYKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgJKHJldmlzaW9uIDU1 NDU5KQorKysgV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgJKHdvcmtpbmcgY29weSkKQEAgLTI4Nyw2 ICsyODcsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRMb2FkRGVm ZXJyaW5nRW5hYmxlZChib29sKTsKICAgICAgICAgYm9vbCBsb2FkRGVmZXJyaW5nRW5hYmxlZCgp IGNvbnN0IHsgcmV0dXJuIG1fbG9hZERlZmVycmluZ0VuYWJsZWQ7IH0KKyAgICAgICAgCisgICAg ICAgIHZvaWQgc2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wpOworICAgICAgICBib29s IHRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGlsZWRCYWNraW5n U3RvcmVFbmFibGVkOyB9CiAKICAgICBwcml2YXRlOgogICAgICAgICBQYWdlKiBtX3BhZ2U7CkBA IC0zNjEsNiArMzY0LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZXhw ZXJpbWVudGFsTm90aWZpY2F0aW9uc0VuYWJsZWQgOiAxOwogICAgICAgICBib29sIG1fd2ViR0xF bmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX2xvYWREZWZlcnJpbmdFbmFibGVkIDogMTsKKyAg ICAgICAgYm9vbCBtX3RpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCA6IDE7CiAKICNpZiBVU0UoU0FG QVJJX1RIRU1FKQogICAgICAgICBzdGF0aWMgYm9vbCBnU2hvdWxkUGFpbnROYXRpdmVDb250cm9s czsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzYgQEAK Ky8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vi c2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBG bG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFRpbGVf aAorI2RlZmluZSBUaWxlX2gKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorCisj aW5jbHVkZSAiSW50UG9pbnQuaCIKKyNpbmNsdWRlICJJbnRQb2ludEhhc2guaCIKKyNpbmNsdWRl ICJJbnRSZWN0LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYv UmVmQ291bnRlZC5oPgorCisjaWYgUExBVEZPUk0oUVQpCitjbGFzcyBRUGl4bWFwOworY2xhc3Mg UVJlZ2lvbjsKKyNlbmRpZgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitjbGFzcyBHcmFw aGljc0NvbnRleHQ7CitjbGFzcyBUaWxlZEJhY2tpbmdTdG9yZTsKKworY2xhc3MgVGlsZSA6IHB1 YmxpYyBSZWZDb3VudGVkPFRpbGU+IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEludFBvaW50IENv b3JkaW5hdGU7CisKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUaWxlPiBjcmVhdGUoVGlsZWRCYWNr aW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRpbmF0ZSYgdGlsZUNvb3JkaW5hdGUp IHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBUaWxlKGJhY2tpbmdTdG9yZSwgdGlsZUNvb3JkaW5hdGUp KTsgfQorICAgIH5UaWxlKCk7CisgICAgCisgICAgYm9vbCBpc0RpcnR5KCkgY29uc3Q7CisgICAg dm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmKTsKKyAgICB2b2lkIHVwZGF0ZUJhY2tCdWZm ZXIoKTsKKyAgICB2b2lkIHN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpOworICAgIGJvb2wgaXNSZWFk eVRvUGFpbnQoKSBjb25zdDsKKyAgICB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0 IEludFJlY3QmKTsKKworICAgIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUgY29vcmRpbmF0ZSgpIGNv bnN0IHsgcmV0dXJuIG1fY29vcmRpbmF0ZTsgfQorICAgIGNvbnN0IEludFJlY3QmIHJlY3QoKSBj b25zdCB7IHJldHVybiBtX3JlY3Q7IH0KKyAgICAKKyAgICBzdGF0aWMgdm9pZCBwYWludENoZWNr ZXJQYXR0ZXJuKEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEZsb2F0UmVjdCYpOworCitwcml2YXRl OgorICAgIFRpbGUoVGlsZWRCYWNraW5nU3RvcmUqLCBjb25zdCBDb29yZGluYXRlJik7CisgICAg CisgICAgVGlsZWRCYWNraW5nU3RvcmUqIG1fYmFja2luZ1N0b3JlOworICAgIENvb3JkaW5hdGUg bV9jb29yZGluYXRlOworICAgIEludFJlY3QgbV9yZWN0OworCisjaWYgUExBVEZPUk0oUVQpCisg ICAgUVBpeG1hcCogbV9idWZmZXI7CisgICAgUVBpeG1hcCogbV9iYWNrQnVmZmVyOworICAgIFFS ZWdpb24qIG1fZGlydHlSZWdpb247CisjZW5kaWYKK307CisKK30KKyNlbmRpZgorI2VuZGlmCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNw cAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5n U3RvcmUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM2MyBAQAorLyoKKyBDb3B5cmlnaHQg KEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisg CisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAK KyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmls ZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJUaWxlZEJhY2tpbmdTdG9yZS5oIgorCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUp CisKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdT dG9yZUNsaWVudC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitzdGF0aWMgY29uc3Qg aW50IGRlZmF1bHRUaWxlV2lkdGggPSA1MTI7CitzdGF0aWMgY29uc3QgaW50IGRlZmF1bHRUaWxl SGVpZ2h0ID0gNTEyOworCitUaWxlZEJhY2tpbmdTdG9yZTo6VGlsZWRCYWNraW5nU3RvcmUoVGls ZWRCYWNraW5nU3RvcmVDbGllbnQqIGNsaWVudCkKKyAgICA6IG1fY2xpZW50KGNsaWVudCkKKyAg ICAsIG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyKG5ldyBUaWxlVGltZXIodGhpcywgJlRpbGVkQmFj a2luZ1N0b3JlOjp0aWxlQnVmZmVyVXBkYXRlVGltZXJGaXJlZCkpCisgICAgLCBtX3RpbGVDcmVh dGlvblRpbWVyKG5ldyBUaWxlVGltZXIodGhpcywgJlRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3Jl YXRpb25UaW1lckZpcmVkKSkKKyAgICAsIG1fdGlsZVNpemUoZGVmYXVsdFRpbGVXaWR0aCwgZGVm YXVsdFRpbGVIZWlnaHQpCisgICAgLCBtX2NvbnRlbnRzU2NhbGUoMS5mKQorICAgICwgbV9jb250 ZW50c0Zyb3plbihmYWxzZSkKK3sKK30KKworVGlsZWRCYWNraW5nU3RvcmU6On5UaWxlZEJhY2tp bmdTdG9yZSgpCit7CisgICAgZGVsZXRlIG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIGRl bGV0ZSBtX3RpbGVDcmVhdGlvblRpbWVyOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpp bnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRzRGlydHlSZWN0KQoreworICAgIEludFJl Y3QgZGlydHlSZWN0KG1hcEZyb21Db250ZW50cyhjb250ZW50c0RpcnR5UmVjdCkpOworICAgIAor ICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGly dHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRp bGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIAorICAg IGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUgPSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0g Ym90dG9tUmlnaHQueSgpOyArK3lDb29yZGluYXRlKSB7CisgICAgICAgIGZvciAodW5zaWduZWQg eENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsgeENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgp OyArK3hDb29yZGluYXRlKSB7CisgICAgICAgICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRpbGUg PSB0aWxlQXQoVGlsZTo6Q29vcmRpbmF0ZSh4Q29vcmRpbmF0ZSwgeUNvb3JkaW5hdGUpKTsKKyAg ICAgICAgICAgIGlmICghY3VycmVudFRpbGUpCisgICAgICAgICAgICAgICAgY29udGludWU7Cisg ICAgICAgICAgICBjdXJyZW50VGlsZS0+aW52YWxpZGF0ZShkaXJ0eVJlY3QpOworICAgICAgICB9 CisgICAgfQorCisgICAgc3RhcnRUaWxlQnVmZmVyVXBkYXRlVGltZXIoKTsKK30KKwordm9pZCBU aWxlZEJhY2tpbmdTdG9yZTo6dXBkYXRlVGlsZUJ1ZmZlcnMoKQoreworICAgIGlmIChtX2NvbnRl bnRzRnJvemVuKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgVmVjdG9yPEludFJlY3Q+IHBh aW50ZWRBcmVhOworICAgIFZlY3RvcjxSZWZQdHI8VGlsZT4gPiBkaXJ0eVRpbGVzOworICAgIFRp bGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjpp dGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAg IGlmICghaXQtPnNlY29uZC0+aXNEaXJ0eSgpKQorICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIGRpcnR5VGlsZXMuYXBwZW5kKGl0LT5zZWNvbmQpOworICAgICAgICAvLyBGSVhNRTogc2hv dWxkIG5vdCByZXF1ZXN0IHN5c3RlbSByZXBhaW50IGZvciB0aGUgZnVsbCB0aWxlLgorICAgICAg ICBwYWludGVkQXJlYS5hcHBlbmQobWFwVG9Db250ZW50cyhpdC0+c2Vjb25kLT5yZWN0KCkpKTsK KyAgICB9CisgICAgCisgICAgaWYgKGRpcnR5VGlsZXMuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm47CisgICAgCisgICAgbV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOwor CisgICAgLy8gRklYTUU6IEluIHNpbmdsZSB0aHJlYWRlZCBjYXNlLCB0aWxlIGJhY2sgYnVmZmVy cyBjb3VsZCBiZSB1cGRhdGVkIGFzeW5jaHJvbm91c2x5IAorICAgIC8vIG9uZSBieSBvbmUgYW5k IHRoZW4gc3dhcHBlZCB0byBmcm9udCBpbiBvbmUgZ28uIFRoaXMgd291bGQgbWluaW1pemUgdGhl IHRpbWUgc3BlbnQKKyAgICAvLyBibG9ja2luZyBvbiB0aWxlIHVwZGF0ZXMuCisgICAgdW5zaWdu ZWQgc2l6ZSA9IGRpcnR5VGlsZXMuc2l6ZSgpOworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4g PCBzaXplOyArK24pCisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnVwZGF0ZUJhY2tCdWZmZXIoKTsK KworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5 VGlsZXNbbl0tPnN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpOworCisgICAgbV9jbGllbnQtPnRpbGVk QmFja2luZ1N0b3JlUGFpbnRFbmQocGFpbnRlZEFyZWEpOworfQorCit2b2lkIFRpbGVkQmFja2lu Z1N0b3JlOjpwYWludChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJl Y3QpCit7CisgICAgY29udGV4dC0+c2F2ZSgpOworICAgIAorICAgIC8vIEFzc3VtZXMgdGhlIGJh Y2tpbmcgc3RvcmUgaXMgcGFpbnRlZCB3aXRoIHRoZSBzY2FsZSB0cmFuc2Zvcm0gYXBwbGllZC4K KyAgICAvLyBTaW5jZSB0aWxlIGNvbnRlbnQgaXMgYWxyZWFkeSBzY2FsZWQsIGZpcnN0IHJldmVy dCB0aGUgc2NhbGluZyBmcm9tIHRoZSBwYWludGVyLgorICAgIGNvbnRleHQtPnNjYWxlKEZsb2F0 U2l6ZSgxLmYgLyBtX2NvbnRlbnRzU2NhbGUsIDEuZiAvIG1fY29udGVudHNTY2FsZSkpOworICAg IAorICAgIEludFJlY3QgZGlydHlSZWN0ID0gbWFwRnJvbUNvbnRlbnRzKHJlY3QpOworICAgIAor ICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGly dHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRp bGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LmJvdHRvbVJpZ2h0KCkpOworCisgICAgZm9y ICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0 b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29v cmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsr eENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3Jk aW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxl PiBjdXJyZW50VGlsZSA9IHRpbGVBdChjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICBp ZiAoY3VycmVudFRpbGUgJiYgY3VycmVudFRpbGUtPmlzUmVhZHlUb1BhaW50KCkpCisgICAgICAg ICAgICAgICAgY3VycmVudFRpbGUtPnBhaW50KGNvbnRleHQsIGRpcnR5UmVjdCk7CisgICAgICAg ICAgICBlbHNlIHsKKyAgICAgICAgICAgICAgICBGbG9hdFJlY3QgdGlsZVJlY3QgPSB0aWxlUmVj dEZvckNvb3JkaW5hdGUoY3VycmVudENvb3JkaW5hdGUpOworICAgICAgICAgICAgICAgIEZsb2F0 UmVjdCB0YXJnZXQgPSBpbnRlcnNlY3Rpb24odGlsZVJlY3QsIEZsb2F0UmVjdChyZWN0KSk7Cisg ICAgICAgICAgICAgICAgVGlsZTo6cGFpbnRDaGVja2VyUGF0dGVybihjb250ZXh0LCB0YXJnZXQp OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorICAgIGNvbnRleHQtPnJlc3RvcmUo KTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dmlld3BvcnRDaGFuZ2VkKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRzVmlld3BvcnQpCit7CisgICAgSW50UmVjdCB2aWV3cG9ydCA9IG1hcEZy b21Db250ZW50cyhjb250ZW50c1ZpZXdwb3J0KTsKKyAgICBpZiAobV92aWV3cG9ydCA9PSB2aWV3 cG9ydCkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV92aWV3cG9ydCA9IHZpZXdwb3J0OworCisg ICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3Jl OjpzZXRDb250ZW50c1NjYWxlKGZsb2F0IHNjYWxlKQoreworICAgIGlmIChtX2NvbnRlbnRzU2Nh bGUgPT0gc2NhbGUpCisgICAgICAgIHJldHVybjsKKyAgICBtX2NvbnRlbnRzU2NhbGUgPSBzY2Fs ZTsKKworICAgIGludmFsaWRhdGUobV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNS ZWN0KCkpOworfQorICAgIAorZG91YmxlIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlRGlzdGFuY2Uo Y29uc3QgSW50UmVjdCYgdmlld3BvcnQsIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIHRpbGVDb29y ZGluYXRlKQoreworICAgIGlmICh2aWV3cG9ydC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRp bmF0ZSh0aWxlQ29vcmRpbmF0ZSkpKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQ b2ludCB2aWV3Q2VudGVyID0gdmlld3BvcnQubG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQu d2lkdGgoKSAvIDIsIHZpZXdwb3J0LmhlaWdodCgpIC8gMik7CisgICAgVGlsZTo6Q29vcmRpbmF0 ZSBjZW50ZXJDb29yZGluYXRlID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludCh2aWV3Q2VudGVyKTsK KyAgICAKKyAgICAvLyBNYW5oYXR0YW4gZGlzdGFuY2UsIGJpYXNlZCBzbyB0aGF0IHZlcnRpY2Fs IGRpc3RhbmNlcyBhcmUgc2hvcnRlci4KKyAgICBjb25zdCBkb3VibGUgaG9yaXpvbnRhbEJpYXMg PSAxLjM7CisgICAgcmV0dXJuIGFicyhjZW50ZXJDb29yZGluYXRlLnkoKSAtIHRpbGVDb29yZGlu YXRlLnkoKSkgKyBob3Jpem9udGFsQmlhcyAqIGFicyhjZW50ZXJDb29yZGluYXRlLngoKSAtIHRp bGVDb29yZGluYXRlLngoKSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OmNyZWF0ZVRp bGVzKCkKK3sKKyAgICBpZiAobV9jb250ZW50c0Zyb3plbikKKyAgICAgICAgcmV0dXJuOworCisg ICAgaWYgKG1fdmlld3BvcnQuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBS ZW1vdmUgdGlsZXMgdGhhdCBleHRlbmQgb3V0c2lkZSB0aGUgY3VycmVudCBjb250ZW50cyByZWN0 LgorICAgIGRyb3BPdmVyaGFuZ2luZ1RpbGVzKCk7CisKKyAgICAvLyBGSVhNRTogTWFrZSBjb25m aWd1cmFibGUvYWRhcHQgdG8gbWVtb3J5LgorICAgIEludFJlY3Qga2VlcFJlY3QgPSBtX3ZpZXdw b3J0OworICAgIGtlZXBSZWN0LmluZmxhdGVYKG1fdmlld3BvcnQud2lkdGgoKSk7CisgICAga2Vl cFJlY3QuaW5mbGF0ZVkoMyAqIG1fdmlld3BvcnQuaGVpZ2h0KCkpOworICAgIGtlZXBSZWN0Lmlu dGVyc2VjdChjb250ZW50c1JlY3QoKSk7CisgICAgCisgICAgZHJvcFRpbGVzT3V0c2lkZVJlY3Qo a2VlcFJlY3QpOworICAgIAorICAgIEludFJlY3QgY292ZXJSZWN0ID0gbV92aWV3cG9ydDsKKyAg ICBjb3ZlclJlY3QuaW5mbGF0ZVgobV92aWV3cG9ydC53aWR0aCgpIC8gMik7CisgICAgY292ZXJS ZWN0LmluZmxhdGVZKDIgKiBtX3ZpZXdwb3J0LmhlaWdodCgpKTsKKyAgICBjb3ZlclJlY3QuaW50 ZXJzZWN0KGNvbnRlbnRzUmVjdCgpKTsKKyAgICAKKyAgICAvLyBTZWFyY2ggZm9yIHRoZSB0aWxl IHBvc2l0aW9uIGNsb3Nlc3QgdG8gdGhlIHZpZXdwb3J0IGNlbnRlciB0aGF0IGRvZXMgbm90IHll dCBjb250YWluIGEgdGlsZS4gCisgICAgLy8gV2hpY2ggcG9zaXRpb24gaXMgY29uc2lkZXJlZCB0 aGUgY2xvc2VzdCBkZXBlbmRzIG9uIHRoZSB0aWxlRGlzdGFuY2UgZnVuY3Rpb24uCisgICAgZG91 YmxlIHNob3J0ZXN0RGlzdGFuY2UgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGRvdWJsZT46OmluZmlu aXR5KCk7CisgICAgVmVjdG9yPFRpbGU6OkNvb3JkaW5hdGU+IHRpbGVzVG9DcmVhdGU7CisgICAg dW5zaWduZWQgcmVxdWlyZWRUaWxlQ291bnQgPSAwOworICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9w TGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY292ZXJSZWN0LnRvcExlZnQoKSk7CisgICAg VGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY292 ZXJSZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUgPSB0 b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueSgpOyArK3lDb29yZGluYXRl KSB7CisgICAgICAgIGZvciAodW5zaWduZWQgeENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsgeENv b3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgpOyArK3hDb29yZGluYXRlKSB7CisgICAgICAgICAg ICBUaWxlOjpDb29yZGluYXRlIGN1cnJlbnRDb29yZGluYXRlKHhDb29yZGluYXRlLCB5Q29vcmRp bmF0ZSk7CisgICAgICAgICAgICBpZiAodGlsZUF0KGN1cnJlbnRDb29yZGluYXRlKSkKKyAgICAg ICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICsrcmVxdWlyZWRUaWxlQ291bnQ7Cisg ICAgICAgICAgICAvLyBEaXN0YW5jZSBpcyAwIGZvciBhbGwgY3VycmVudGx5IHZpc2libGUgdGls ZXMuCisgICAgICAgICAgICBkb3VibGUgZGlzdGFuY2UgPSB0aWxlRGlzdGFuY2UobV92aWV3cG9y dCwgY3VycmVudENvb3JkaW5hdGUpOworICAgICAgICAgICAgaWYgKGRpc3RhbmNlID4gc2hvcnRl c3REaXN0YW5jZSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlmIChk aXN0YW5jZSA8IHNob3J0ZXN0RGlzdGFuY2UpIHsKKyAgICAgICAgICAgICAgICB0aWxlc1RvQ3Jl YXRlLmNsZWFyKCk7CisgICAgICAgICAgICAgICAgc2hvcnRlc3REaXN0YW5jZSA9IGRpc3RhbmNl OworICAgICAgICAgICAgfQorICAgICAgICAgICAgdGlsZXNUb0NyZWF0ZS5hcHBlbmQoY3VycmVu dENvb3JkaW5hdGUpOworICAgICAgICB9CisgICAgfQorICAgIAorICAgIC8vIE5vdyBjb25zdHJ1 Y3QgdGhlIHRpbGUocykKKyAgICB1bnNpZ25lZCB0aWxlc1RvQ3JlYXRlQ291bnQgPSB0aWxlc1Rv Q3JlYXRlLnNpemUoKTsKKyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgdGlsZXNUb0NyZWF0 ZUNvdW50OyArK24pIHsKKyAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBjb29yZGluYXRlID0gdGls ZXNUb0NyZWF0ZVtuXTsKKyAgICAgICAgc2V0VGlsZShjb29yZGluYXRlLCBUaWxlOjpjcmVhdGUo dGhpcywgY29vcmRpbmF0ZSkpOworICAgIH0KKyAgICByZXF1aXJlZFRpbGVDb3VudCAtPSB0aWxl c1RvQ3JlYXRlQ291bnQ7CisgICAgCisgICAgLy8gUGFpbnQgdGhlIGNvbnRlbnQgb2YgdGhlIG5l d2x5IGNyZWF0ZWQgdGlsZXMKKyAgICBpZiAodGlsZXNUb0NyZWF0ZUNvdW50KQorICAgICAgICB1 cGRhdGVUaWxlQnVmZmVycygpOworCisgICAgLy8gS2VlcCBjcmVhdGluZyB0aWxlcyB1bnRpbCB0 aGUgd2hvbGUgY292ZXJSZWN0IGlzIGNvdmVyZWQuCisgICAgaWYgKHJlcXVpcmVkVGlsZUNvdW50 KQorICAgICAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5zdGFydE9uZVNob3QoMCk7Cit9CisKK3Zv aWQgVGlsZWRCYWNraW5nU3RvcmU6OmRyb3BPdmVyaGFuZ2luZ1RpbGVzKCkKK3sgICAgCisgICAg SW50UmVjdCBjb250ZW50c1JlY3QgPSB0aGlzLT5jb250ZW50c1JlY3QoKTsKKworICAgIFZlY3Rv cjxUaWxlOjpDb29yZGluYXRlPiB0aWxlc1RvUmVtb3ZlOworICAgIFRpbGVNYXA6Oml0ZXJhdG9y IGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1f dGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIFRpbGU6OkNvb3JkaW5h dGUgdGlsZUNvb3JkaW5hdGUgPSBpdC0+c2Vjb25kLT5jb29yZGluYXRlKCk7CisgICAgICAgIElu dFJlY3QgdGlsZVJlY3QgPSBpdC0+c2Vjb25kLT5yZWN0KCk7CisgICAgICAgIEludFJlY3QgZXhw ZWN0ZWRUaWxlUmVjdCA9IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSk7Cisg ICAgICAgIGlmIChleHBlY3RlZFRpbGVSZWN0ICE9IHRpbGVSZWN0IHx8ICFjb250ZW50c1JlY3Qu Y29udGFpbnModGlsZVJlY3QpKQorICAgICAgICAgICAgdGlsZXNUb1JlbW92ZS5hcHBlbmQodGls ZUNvb3JkaW5hdGUpOworICAgIH0KKyAgICB1bnNpZ25lZCByZW1vdmVDb3VudCA9IHRpbGVzVG9S ZW1vdmUuc2l6ZSgpOworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCByZW1vdmVDb3VudDsg KytuKQorICAgICAgICByZW1vdmVUaWxlKHRpbGVzVG9SZW1vdmVbbl0pOworfQorCit2b2lkIFRp bGVkQmFja2luZ1N0b3JlOjpkcm9wVGlsZXNPdXRzaWRlUmVjdChjb25zdCBJbnRSZWN0JiBrZWVw UmVjdCkKK3sKKyAgICBGbG9hdFJlY3Qga2VlcFJlY3RGID0ga2VlcFJlY3Q7CisKKyAgICBWZWN0 b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdG9SZW1vdmU7CisgICAgVGlsZU1hcDo6aXRlcmF0b3IgZW5k ID0gbV90aWxlcy5lbmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0gbV90aWxl cy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBj b29yZGluYXRlID0gaXQtPnNlY29uZC0+Y29vcmRpbmF0ZSgpOworICAgICAgICBGbG9hdFJlY3Qg dGlsZVJlY3QgPSBpdC0+c2Vjb25kLT5yZWN0KCk7CisgICAgICAgIGlmICghdGlsZVJlY3QuaW50 ZXJzZWN0cyhrZWVwUmVjdEYpKQorICAgICAgICAgICAgdG9SZW1vdmUuYXBwZW5kKGNvb3JkaW5h dGUpOworICAgIH0KKyAgICB1bnNpZ25lZCByZW1vdmVDb3VudCA9IHRvUmVtb3ZlLnNpemUoKTsK KyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgcmVtb3ZlQ291bnQ7ICsrbikKKyAgICAgICAg cmVtb3ZlVGlsZSh0b1JlbW92ZVtuXSk7Cit9CisKK1Bhc3NSZWZQdHI8VGlsZT4gVGlsZWRCYWNr aW5nU3RvcmU6OnRpbGVBdChjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRlKSBjb25z dAoreworICAgIHJldHVybiBtX3RpbGVzLmdldChjb29yZGluYXRlKTsKK30KKwordm9pZCBUaWxl ZEJhY2tpbmdTdG9yZTo6c2V0VGlsZShjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRl LCBQYXNzUmVmUHRyPFRpbGU+IHRpbGUpCit7CisgICAgbV90aWxlcy5zZXQoY29vcmRpbmF0ZSwg dGlsZSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnJlbW92ZVRpbGUoY29uc3QgVGls ZTo6Q29vcmRpbmF0ZSYgY29vcmRpbmF0ZSkKK3sKKyAgICBtX3RpbGVzLnJlbW92ZShjb29yZGlu YXRlKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9yZTo6bWFwVG9Db250ZW50cyhjb25z dCBJbnRSZWN0JiByZWN0KSBjb25zdAoreworICAgIHJldHVybiBlbmNsb3NpbmdJbnRSZWN0KEZs b2F0UmVjdChyZWN0LngoKSAvIG1fY29udGVudHNTY2FsZSwKKyAgICAgICAgcmVjdC55KCkgLyBt X2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3Qud2lkdGgoKSAvIG1fY29udGVudHNTY2FsZSwK KyAgICAgICAgcmVjdC5oZWlnaHQoKSAvIG1fY29udGVudHNTY2FsZSkpOworfQorCitJbnRSZWN0 IFRpbGVkQmFja2luZ1N0b3JlOjptYXBGcm9tQ29udGVudHMoY29uc3QgSW50UmVjdCYgcmVjdCkg Y29uc3QKK3sKKyAgICByZXR1cm4gZW5jbG9zaW5nSW50UmVjdChGbG9hdFJlY3QocmVjdC54KCkg KiBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QueSgpICogbV9jb250ZW50c1NjYWxlLAor ICAgICAgICByZWN0LndpZHRoKCkgKiBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QuaGVp Z2h0KCkgKiBtX2NvbnRlbnRzU2NhbGUpKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9y ZTo6Y29udGVudHNSZWN0KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbWFwRnJvbUNvbnRlbnRzKG1f Y2xpZW50LT50aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpKTsKK30KKworSW50UmVjdCBU aWxlZEJhY2tpbmdTdG9yZTo6dGlsZVJlY3RGb3JDb29yZGluYXRlKGNvbnN0IFRpbGU6OkNvb3Jk aW5hdGUmIGNvb3JkaW5hdGUpIGNvbnN0Cit7CisgICAgSW50UmVjdCByZWN0KGNvb3JkaW5hdGUu eCgpICogbV90aWxlU2l6ZS53aWR0aCgpLAorICAgICAgICBjb29yZGluYXRlLnkoKSAqIG1fdGls ZVNpemUuaGVpZ2h0KCksCisgICAgICAgIG1fdGlsZVNpemUud2lkdGgoKSwKKyAgICAgICAgbV90 aWxlU2l6ZS5oZWlnaHQoKSk7CisKKyAgICByZWN0LmludGVyc2VjdChjb250ZW50c1JlY3QoKSk7 CisgICAgcmV0dXJuIHJlY3Q7Cit9CisgICAgCitUaWxlOjpDb29yZGluYXRlIFRpbGVkQmFja2lu Z1N0b3JlOjp0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNvbnN0IEludFBvaW50JiBwb2ludCkgY29u c3QKK3sKKyAgICBpbnQgeCA9IHBvaW50LngoKSAvIG1fdGlsZVNpemUud2lkdGgoKTsKKyAgICBp bnQgeSA9IHBvaW50LnkoKSAvIG1fdGlsZVNpemUuaGVpZ2h0KCk7CisgICAgcmV0dXJuIFRpbGU6 OkNvb3JkaW5hdGUoc3RkOjptYXgoeCwgMCksIHN0ZDo6bWF4KHksIDApKTsKK30KKworCit2b2lk IFRpbGVkQmFja2luZ1N0b3JlOjpzdGFydFRpbGVCdWZmZXJVcGRhdGVUaW1lcigpCit7CisgICAg aWYgKG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyLT5pc0FjdGl2ZSgpIHx8IG1fY29udGVudHNGcm96 ZW4pCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVCdWZmZXJVcGRhdGVUaW1lci0+c3RhcnRP bmVTaG90KDApOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQnVmZmVyVXBkYXRl VGltZXJGaXJlZChUaWxlVGltZXIqKQoreworICAgIHVwZGF0ZVRpbGVCdWZmZXJzKCk7Cit9CisK K3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnN0YXJ0VGlsZUNyZWF0aW9uVGltZXIoKQoreworICAg IGlmIChtX3RpbGVDcmVhdGlvblRpbWVyLT5pc0FjdGl2ZSgpIHx8IG1fY29udGVudHNGcm96ZW4p CisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5zdGFydE9uZVNob3Qo MCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnRpbGVDcmVhdGlvblRpbWVyRmlyZWQo VGlsZVRpbWVyKikKK3sKKyAgICBjcmVhdGVUaWxlcygpOworfQorCit2b2lkIFRpbGVkQmFja2lu Z1N0b3JlOjpzZXRDb250ZW50c0Zyb3plbihib29sIGZyZWV6ZSkKK3sKKyAgICBpZiAobV9jb250 ZW50c0Zyb3plbiA9PSBmcmVlemUpCisgICAgICAgIHJldHVybjsKKworICAgIG1fY29udGVudHNG cm96ZW4gPSBmcmVlemU7CisKKyAgICAvLyBSZXN0YXJ0IHRoZSB0aW1lcnMuIFRoZXJlIG1pZ2h0 IGJlIHBlbmRpbmcgaW52YWxpZGF0aW9ucyB0aGF0CisgICAgLy8gd2VyZSBub3QgcGFpbnRlZCBv ciBjcmVhdGVkIGJlY2F1c2UgdGlsZXMgYXJlIG5vdCBjcmVhdGVkIG9yCisgICAgLy8gcGFpbnRl ZCB3aGVuIGluIGZyb3plbiBzdGF0ZS4KKyAgICBpZiAoIW1fY29udGVudHNGcm96ZW4pIHsKKyAg ICAgICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgICAgICBzdGFydFRpbGVCdWZmZXJV cGRhdGVUaW1lcigpOworICAgIH0KKyAgICAvLyBzdG9wcGluZyBpcyBoYW5kbGVkIHdoZW4gdGhl IHRpbWVycyBmaXJlCit9CisKK30KKworI2VuZGlmCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDEwNyBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5k L29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor IAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUg dG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNp Zm5kZWYgVGlsZWRCYWNraW5nU3RvcmVfaAorI2RlZmluZSBUaWxlZEJhY2tpbmdTdG9yZV9oCisK KyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKworI2luY2x1ZGUgIkZsb2F0U2l6ZS5o IgorI2luY2x1ZGUgIkludFBvaW50LmgiCisjaW5jbHVkZSAiSW50UmVjdC5oIgorI2luY2x1ZGUg IlRpbGUuaCIKKyNpbmNsdWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+ CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGlsZWRC YWNraW5nU3RvcmVDbGllbnQ7CisKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlIDogcHVibGljIE5v bmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBUaWxlZEJhY2tpbmdTdG9yZShUaWxlZEJhY2tpbmdT dG9yZUNsaWVudCopOworICAgIH5UaWxlZEJhY2tpbmdTdG9yZSgpOworCisgICAgdm9pZCB2aWV3 cG9ydENoYW5nZWQoY29uc3QgSW50UmVjdCYgdmlld3BvcnRSZWN0KTsKKyAgICAKKyAgICBmbG9h dCBjb250ZW50c1NjYWxlKCkgeyByZXR1cm4gbV9jb250ZW50c1NjYWxlOyB9CisgICAgdm9pZCBz ZXRDb250ZW50c1NjYWxlKGZsb2F0KTsKKyAgICAKKyAgICBib29sIGNvbnRlbnRzRnJvemVuKCkg Y29uc3QgeyByZXR1cm4gbV9jb250ZW50c0Zyb3plbjsgfQorICAgIHZvaWQgc2V0Q29udGVudHNG cm96ZW4oYm9vbCk7CisKKyAgICB2b2lkIGludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZGlydHlS ZWN0KTsKKyAgICB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsK KworcHJpdmF0ZToKKyAgICB2b2lkIHN0YXJ0VGlsZUJ1ZmZlclVwZGF0ZVRpbWVyKCk7CisgICAg dm9pZCBzdGFydFRpbGVDcmVhdGlvblRpbWVyKCk7CisgICAgCisgICAgdHlwZWRlZiBUaW1lcjxU aWxlZEJhY2tpbmdTdG9yZT4gVGlsZVRpbWVyOworCisgICAgdm9pZCB0aWxlQnVmZmVyVXBkYXRl VGltZXJGaXJlZChUaWxlVGltZXIqKTsKKyAgICB2b2lkIHRpbGVDcmVhdGlvblRpbWVyRmlyZWQo VGlsZVRpbWVyKik7CisgICAgCisgICAgdm9pZCB1cGRhdGVUaWxlQnVmZmVycygpOworICAgIHZv aWQgY3JlYXRlVGlsZXMoKTsKKworICAgIHZvaWQgZHJvcE92ZXJoYW5naW5nVGlsZXMoKTsKKyAg ICB2b2lkIGRyb3BUaWxlc091dHNpZGVSZWN0KGNvbnN0IEludFJlY3QmKTsKKyAgICAKKyAgICBQ YXNzUmVmUHRyPFRpbGU+IHRpbGVBdChjb25zdCBUaWxlOjpDb29yZGluYXRlJikgY29uc3Q7Cisg ICAgdm9pZCBzZXRUaWxlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NS ZWZQdHI8VGlsZT4gdGlsZSk7CisgICAgdm9pZCByZW1vdmVUaWxlKGNvbnN0IFRpbGU6OkNvb3Jk aW5hdGUmIGNvb3JkaW5hdGUpOworCisgICAgSW50UmVjdCBtYXBUb0NvbnRlbnRzKGNvbnN0IElu dFJlY3QmKSBjb25zdDsKKyAgICBJbnRSZWN0IG1hcEZyb21Db250ZW50cyhjb25zdCBJbnRSZWN0 JikgY29uc3Q7CisgICAgCisgICAgSW50UmVjdCBjb250ZW50c1JlY3QoKSBjb25zdDsKKyAgICAK KyAgICBJbnRSZWN0IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZShjb25zdCBUaWxlOjpDb29yZGluYXRl JikgY29uc3Q7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNv bnN0IEludFBvaW50JikgY29uc3Q7CisgICAgZG91YmxlIHRpbGVEaXN0YW5jZShjb25zdCBJbnRS ZWN0JiB2aWV3cG9ydCwgY29uc3QgVGlsZTo6Q29vcmRpbmF0ZSYpOworICAgIAorICAgIHZvaWQg cGFpbnRDaGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0JiwgY29u c3QgVGlsZTo6Q29vcmRpbmF0ZSYpOworCitwcml2YXRlOgorICAgIFRpbGVkQmFja2luZ1N0b3Jl Q2xpZW50KiBtX2NsaWVudDsKKworICAgIHR5cGVkZWYgSGFzaE1hcDxUaWxlOjpDb29yZGluYXRl LCBSZWZQdHI8VGlsZT4gPiBUaWxlTWFwOworICAgIFRpbGVNYXAgbV90aWxlczsKKworICAgIFRp bGVUaW1lciogbV90aWxlQnVmZmVyVXBkYXRlVGltZXI7CisgICAgVGlsZVRpbWVyKiBtX3RpbGVD cmVhdGlvblRpbWVyOworCisgICAgSW50U2l6ZSBtX3RpbGVTaXplOworICAgIAorICAgIEludFJl Y3QgbV92aWV3cG9ydDsKKyAgICBmbG9hdCBtX2NvbnRlbnRzU2NhbGU7CisKKyAgICBib29sIG1f Y29udGVudHNGcm96ZW47CisKKyAgICBmcmllbmQgY2xhc3MgVGlsZTsKK307CisKK30KKworI2Vu ZGlmCisjZW5kaWYKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5n U3RvcmVDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Rp bGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNDAgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9v ciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAK KyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZu ZGVmIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50X2gKKyNkZWZpbmUgVGlsZWRCYWNraW5nU3RvcmVD bGllbnRfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lO R19TVE9SRSkKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IHsKK3B1YmxpYzoKKyAgICB2 aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCkgPSAwOworICAgIHZpcnR1 YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IElu dFJlY3QmKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQo Y29uc3QgVmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSkgPSAwOworICAgIHZpcnR1YWwgSW50 UmVjdCB0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpID0gMDsKK307CisKKyNlbHNlCitj bGFzcyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCB7fTsKKyNlbmRpZgorCit9CisKKyNlbmRpZgpJ bmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvcXQvVGlsZVF0LmNwcAkocmV2aXNpb24gMCkK KysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvcXQvVGlsZVF0LmNwcAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwxODIgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0 aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVGlsZS5oIgorCisjaWYgRU5BQkxF KFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNp bmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3Jl Q2xpZW50LmgiCisjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgorI2luY2x1ZGUgPFFCYXNpY1RpbWVy PgorI2luY2x1ZGUgPFFEZWJ1Zz4KKyNpbmNsdWRlIDxRSW1hZ2U+CisjaW5jbHVkZSA8UU9iamVj dD4KKyNpbmNsdWRlIDxRUGFpbnRlcj4KKyNpbmNsdWRlIDxRUmVnaW9uPgorI2luY2x1ZGUgPFFU aHJlYWQ+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBjaGVja2VyU2l6ZSA9IDE2Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjEg PSAweGZmNTU1NTU1Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjIgPSAweGZm YWFhYWFhOworICAgIAorc3RhdGljIFFQaXhtYXAmIGNoZWNrZXJlZFBpeG1hcCgpCit7CisgICAg c3RhdGljIFFQaXhtYXAqIHBpeG1hcDsKKyAgICBpZiAoIXBpeG1hcCkgeworICAgICAgICBwaXht YXAgPSBuZXcgUVBpeG1hcChjaGVja2VyU2l6ZSwgY2hlY2tlclNpemUpOworICAgICAgICBRUGFp bnRlciBwYWludGVyKHBpeG1hcCk7CisgICAgICAgIFFDb2xvciBjb2xvcjEoY2hlY2tlckNvbG9y MSk7CisgICAgICAgIFFDb2xvciBjb2xvcjIoY2hlY2tlckNvbG9yMik7CisgICAgICAgIGZvciAo dW5zaWduZWQgeSA9IDA7IHkgPCBjaGVja2VyU2l6ZTsgeSArPSBjaGVja2VyU2l6ZSAvIDIpIHsK KyAgICAgICAgICAgIGJvb2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJTaXplOworICAgICAgICAg ICAgZm9yICh1bnNpZ25lZCB4ID0gMDsgeCA8IGNoZWNrZXJTaXplOyB4ICs9IGNoZWNrZXJTaXpl IC8gMikgeworICAgICAgICAgICAgICAgIHBhaW50ZXIuZmlsbFJlY3QoeCwgeSwgY2hlY2tlclNp emUgLyAyLCBjaGVja2VyU2l6ZSAvIDIsIGFsdGVybmF0ZSA/IGNvbG9yMSA6IGNvbG9yMik7Cisg ICAgICAgICAgICAgICAgYWx0ZXJuYXRlID0gIWFsdGVybmF0ZTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorICAgIH0KKyAgICByZXR1cm4gKnBpeG1hcDsKK30KKyAgICAKK1RpbGU6OlRpbGUo VGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRpbmF0ZSYgdGlsZUNv b3JkaW5hdGUpCisgICAgOiBtX2JhY2tpbmdTdG9yZShiYWNraW5nU3RvcmUpCisgICAgLCBtX2Nv b3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpCisgICAgLCBtX3JlY3QobV9iYWNraW5nU3RvcmUtPnRp bGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpCisgICAgLCBtX2J1ZmZlcigwKQor ICAgICwgbV9iYWNrQnVmZmVyKDApCisgICAgLCBtX2RpcnR5UmVnaW9uKG5ldyBRUmVnaW9uKG1f cmVjdCkpCit7Cit9CisKK1RpbGU6On5UaWxlKCkKK3sKKyAgICBkZWxldGUgbV9idWZmZXI7Cisg ICAgZGVsZXRlIG1fYmFja0J1ZmZlcjsKKyAgICBkZWxldGUgbV9kaXJ0eVJlZ2lvbjsKK30KKwor Ym9vbCBUaWxlOjppc0RpcnR5KCkgY29uc3QgCit7IAorICAgIHJldHVybiAhbV9kaXJ0eVJlZ2lv bi0+aXNFbXB0eSgpOyAKK30KKworYm9vbCBUaWxlOjppc1JlYWR5VG9QYWludCgpIGNvbnN0Cit7 IAorICAgIHJldHVybiBtX2J1ZmZlcjsgCit9CisKK3ZvaWQgVGlsZTo6aW52YWxpZGF0ZShjb25z dCBJbnRSZWN0JiBkaXJ0eVJlY3QpCit7CisgICAgSW50UmVjdCB0aWxlRGlydHlSZWN0ID0gaW50 ZXJzZWN0aW9uKGRpcnR5UmVjdCwgbV9yZWN0KTsKKyAgICBpZiAodGlsZURpcnR5UmVjdC5pc0Vt cHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgICptX2RpcnR5UmVnaW9uICs9IHRpbGVEaXJ0 eVJlY3Q7Cit9CisgICAgCit2b2lkIFRpbGU6OnVwZGF0ZUJhY2tCdWZmZXIoKQoreworICAgIGlm IChtX2J1ZmZlciAmJiAhaXNEaXJ0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1f YmFja0J1ZmZlcikgeworICAgICAgICBpZiAoIW1fYnVmZmVyKQorICAgICAgICAgICAgbV9iYWNr QnVmZmVyID0gbmV3IFFQaXhtYXAobV9iYWNraW5nU3RvcmUtPm1fdGlsZVNpemUud2lkdGgoKSwg bV9iYWNraW5nU3RvcmUtPm1fdGlsZVNpemUuaGVpZ2h0KCkpOworICAgICAgICBlbHNlIHsKKyAg ICAgICAgICAgIC8vIEN1cnJlbnRseSBhbGwgYnVmZmVycyBhcmUgdXBkYXRlZCBzeW5jaHJvbm91 c2x5IGF0IHRoZSBzYW1lIHRpbWUgc28gdGhlcmUgaXMgbm8gcmVhbCBuZWVkCisgICAgICAgICAg ICAvLyB0byBoYXZlIHNlcGFyYXRlIGJhY2sgYW5kIGZyb250IGJ1ZmZlcnMuIEp1c3QgdXNlIHRo ZSBleGlzdGluZyBidWZmZXIuCisgICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBtX2J1ZmZlcjsK KyAgICAgICAgICAgIG1fYnVmZmVyID0gMDsKKyAgICAgICAgfQorICAgIH0KKworICAgIFFWZWN0 b3I8UVJlY3Q+IGRpcnR5UmVjdHMgPSBtX2RpcnR5UmVnaW9uLT5yZWN0cygpOworICAgICptX2Rp cnR5UmVnaW9uID0gUVJlZ2lvbigpOworICAgIAorICAgIFFQYWludGVyIHBhaW50ZXIobV9iYWNr QnVmZmVyKTsKKyAgICBHcmFwaGljc0NvbnRleHQgY29udGV4dCgmcGFpbnRlcik7CisgICAgY29u dGV4dC50cmFuc2xhdGUoLW1fcmVjdC54KCksIC1tX3JlY3QueSgpKTsKKworICAgIGludCBzaXpl ID0gZGlydHlSZWN0cy5zaXplKCk7CisgICAgZm9yIChpbnQgbiA9IDA7IG4gPCBzaXplOyArK24p ICB7CisgICAgICAgIGNvbnRleHQuc2F2ZSgpOworICAgICAgICBJbnRSZWN0IHJlY3QgPSBkaXJ0 eVJlY3RzW25dOworICAgICAgICBjb250ZXh0LmNsaXAoRmxvYXRSZWN0KHJlY3QpKTsKKyAgICAg ICAgY29udGV4dC5zY2FsZShGbG9hdFNpemUobV9iYWNraW5nU3RvcmUtPm1fY29udGVudHNTY2Fs ZSwgbV9iYWNraW5nU3RvcmUtPm1fY29udGVudHNTY2FsZSkpOworICAgICAgICBtX2JhY2tpbmdT dG9yZS0+bV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnQoJmNvbnRleHQsIG1fYmFja2lu Z1N0b3JlLT5tYXBUb0NvbnRlbnRzKHJlY3QpKTsKKyAgICAgICAgY29udGV4dC5yZXN0b3JlKCk7 CisgICAgfQorfQorCit2b2lkIFRpbGU6OnN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpCit7CisgICAg aWYgKCFtX2JhY2tCdWZmZXIpCisgICAgICAgIHJldHVybjsKKyAgICBkZWxldGUgbV9idWZmZXI7 CisgICAgbV9idWZmZXIgPSBtX2JhY2tCdWZmZXI7CisgICAgbV9iYWNrQnVmZmVyID0gMDsKK30K Kwordm9pZCBUaWxlOjpwYWludChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJl Y3QmIHJlY3QpCit7CisgICAgaWYgKCFtX2J1ZmZlcikKKyAgICAgICAgcmV0dXJuOworICAgIAor ICAgIEludFJlY3QgdGFyZ2V0ID0gaW50ZXJzZWN0aW9uKHJlY3QsIG1fcmVjdCk7CisgICAgSW50 UmVjdCBzb3VyY2UoKHRhcmdldC54KCkgLSBtX3JlY3QueCgpKSwKKyAgICAgICAgICAgICAgICAg ICAodGFyZ2V0LnkoKSAtIG1fcmVjdC55KCkpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC53 aWR0aCgpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC5oZWlnaHQoKSk7CisgICAgCisgICAg Y29udGV4dC0+cGxhdGZvcm1Db250ZXh0KCktPmRyYXdQaXhtYXAodGFyZ2V0LCAqbV9idWZmZXIs IHNvdXJjZSk7Cit9CisgICAgCit2b2lkIFRpbGU6OnBhaW50Q2hlY2tlclBhdHRlcm4oR3JhcGhp Y3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBGbG9hdFJlY3QmIHRhcmdldCkKK3sKKyAgICBRUGFp bnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOworICAgIFFUcmFuc2Zv cm0gd29ybGRUcmFuc2Zvcm0gPSBwYWludGVyLT53b3JsZFRyYW5zZm9ybSgpOworICAgIHFyZWFs IHNjYWxlWCA9IHdvcmxkVHJhbnNmb3JtLm0xMSgpOworICAgIHFyZWFsIHNjYWxlWSA9IHdvcmxk VHJhbnNmb3JtLm0yMigpOworICAgIAorICAgIFFSZWN0IHRhcmdldFZpZXdSZWN0ID0gUVJlY3RG KHRhcmdldC54KCkgKiBzY2FsZVgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg dGFyZ2V0LnkoKSAqIHNjYWxlWSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0 YXJnZXQud2lkdGgoKSAqIHNjYWxlWCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0YXJnZXQuaGVpZ2h0KCkgKiBzY2FsZVkpLnRvQWxpZ25lZFJlY3QoKTsKKyAgICAKKyAgICBR VHJhbnNmb3JtIGFkanVzdGVkVHJhbnNmb3JtKDEuLCB3b3JsZFRyYW5zZm9ybS5tMTIoKSwgd29y bGRUcmFuc2Zvcm0ubTEzKCksCisgICAgICAgICAgICAgICAgICB3b3JsZFRyYW5zZm9ybS5tMjEo KSwgMS4sIHdvcmxkVHJhbnNmb3JtLm0yMygpLAorICAgICAgICAgICAgICAgICAgd29ybGRUcmFu c2Zvcm0ubTMxKCksIHdvcmxkVHJhbnNmb3JtLm0zMigpLCB3b3JsZFRyYW5zZm9ybS5tMzMoKSk7 CisgICAgcGFpbnRlci0+c2V0V29ybGRUcmFuc2Zvcm0oYWRqdXN0ZWRUcmFuc2Zvcm0pOworICAg IAorICAgIHBhaW50ZXItPmRyYXdUaWxlZFBpeG1hcCh0YXJnZXRWaWV3UmVjdCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY2hlY2tlcmVkUGl4bWFwKCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFFQb2ludCh0YXJnZXRWaWV3UmVjdC5sZWZ0KCkgJSBjaGVja2VyU2l6ZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldFZpZXdSZWN0LnRvcCgp ICUgY2hlY2tlclNpemUpKTsKKyAgICAKKyAgICBwYWludGVyLT5zZXRXb3JsZFRyYW5zZm9ybSh3 b3JsZFRyYW5zZm9ybSk7Cit9CisKK30KKworI2VuZGlmCkluZGV4OiBXZWJLaXQvcXQvQXBpL3Fn cmFwaGljc3dlYnZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcWdyYXBoaWNz d2Vidmlldy5jcHAJKHJldmlzaW9uIDU1NDU5KQorKysgV2ViS2l0L3F0L0FwaS9xZ3JhcGhpY3N3 ZWJ2aWV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjYsNyArMjYsMTAgQEAKICNpbmNsdWRlICJx d2VicGFnZS5oIgogI2luY2x1ZGUgInF3ZWJwYWdlX3AuaCIKICNpbmNsdWRlICJRV2ViUGFnZUNs aWVudC5oIgotI2luY2x1ZGUgPEZyYW1lVmlldy5oPgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgor I2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIkludFJlY3QuaCIKKyNpbmNs dWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgogI2luY2x1ZGUgPFF0Q29yZS9xbWV0YW9iamVjdC5o PgogI2luY2x1ZGUgPFF0Q29yZS9xc2hhcmVkcG9pbnRlci5oPgogI2luY2x1ZGUgPFF0Q29yZS9x dGltZXIuaD4KQEAgLTM1LDYgKzM4LDcgQEAKICNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhpY3NzY2Vu ZWV2ZW50Lmg+CiAjaW5jbHVkZSA8UXRHdWkvcWdyYXBoaWNzdmlldy5oPgogI2luY2x1ZGUgPFF0 R3VpL3FwaXhtYXBjYWNoZS5oPgorI2luY2x1ZGUgPFF0R3VpL3FzY3JvbGxiYXIuaD4KICNpbmNs dWRlIDxRdEd1aS9xc3R5bGVvcHRpb24uaD4KICNpZiBkZWZpbmVkKFFfV1NfWDExKQogI2luY2x1 ZGUgPFFYMTFJbmZvPgpAQCAtMTIwLDYgKzEyNCw3IEBAIHB1YmxpYzoKICNlbmRpZgogICAgIAog ICAgIHZvaWQgdXBkYXRlUmVzaXplc1RvQ29udGVudHNGb3JQYWdlKCk7CisgICAgUVJlY3RGIHZp c2libGVSZWN0KCkgY29uc3Q7CiAKICAgICB2b2lkIHN5bmNMYXllcnMoKTsKICAgICB2b2lkIF9x X2RvTG9hZEZpbmlzaGVkKGJvb2wgc3VjY2Vzcyk7CkBAIC0zNDAsNiArMzQ1LDIzIEBAIHZvaWQg UUdyYXBoaWNzV2ViVmlld1ByaXZhdGU6Ol9xX2NvbnRlbnQKICAgICBxLT5zZXRHZW9tZXRyeShR UmVjdEYocS0+Z2VvbWV0cnkoKS50b3BMZWZ0KCksIHNpemUpKTsKIH0KIAorUVJlY3RGIFFHcmFw aGljc1dlYlZpZXdQcml2YXRlOjp2aXNpYmxlUmVjdCgpIGNvbnN0Cit7CisgICAgaWYgKCFxLT5z Y2VuZSgpKQorICAgICAgICByZXR1cm4gUVJlY3RGKCk7CisgICAgUUxpc3Q8UUdyYXBoaWNzVmll dyo+IHZpZXdzID0gcS0+c2NlbmUoKS0+dmlld3MoKTsKKyAgICBpZiAodmlld3Muc2l6ZSgpID4g MSkgeworICAgICAgICBxRGVidWcoKSA8PCAiUUdyYXBoaWNzV2ViVmlldyBpcyBpbiBtb3JlIHRo YW4gb25lIGdyYXBoaWNzIHZpZXdzLCB1bmFibGUgdG8gY29tcHV0ZSB0aGUgdmlzaWJsZSByZWN0 IjsKKyAgICAgICAgcmV0dXJuIFFSZWN0RigpOworICAgIH0KKyAgICBpZiAodmlld3Muc2l6ZSgp IDwgMSkKKyAgICAgICAgcmV0dXJuIFFSZWN0RigpOworCisgICAgaW50IGggPSB2aWV3c1swXS0+ aG9yaXpvbnRhbFNjcm9sbEJhcigpLT52YWx1ZSgpOworICAgIGludCB2ID0gdmlld3NbMF0tPnZl cnRpY2FsU2Nyb2xsQmFyKCktPnZhbHVlKCk7CisgICAgcmV0dXJuIHEtPm1hcFJlY3RGcm9tU2Nl bmUoUVJlY3RGKFFQb2ludChoLCB2KSwgdmlld3NbMF0tPnZpZXdwb3J0KCktPnNpemUoKSkpOwor fQorCiAvKiEKICAgICBcY2xhc3MgUUdyYXBoaWNzV2ViVmlldwogICAgIFxicmllZiBUaGUgUUdy YXBoaWNzV2ViVmlldyBjbGFzcyBhbGxvd3MgV2ViIGNvbnRlbnQgdG8gYmUgYWRkZWQgdG8gYSBH cmFwaGljc1ZpZXcuCkBAIC00ODIsNiArNTA0LDE4IEBAIFFXZWJQYWdlKiBRR3JhcGhpY3NXZWJW aWV3OjpwYWdlKCkgY29uc3QKICovCiB2b2lkIFFHcmFwaGljc1dlYlZpZXc6OnBhaW50KFFQYWlu dGVyKiBwYWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbiwgUVdp ZGdldCopCiB7CisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgLy8gRklYTUU6 IFNjcm9sbGJhcnMgY291bGQgYmUgZHJhd24gd2l0aCB0aGUgb3ZlcmxheSBsYXllciB3aGVuIHVz aW5nIHRpbGluZy4KKyAgICBXZWJDb3JlOjpUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3Jl ID0gUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShwYWdlKCktPm1haW5GcmFtZSgpKS0+dGlsZWRCYWNr aW5nU3RvcmUoKTs7CisgICAgaWYgKGJhY2tpbmdTdG9yZSkgeworICAgICAgICAvLyBGSVhNRTog V2Ugc2hvdWxkIHNldCB0aGUgYmFja2luZyBzdG9yZSB2aWV3cGFydCBlYXJsaWVyIHRoYW4gaW4g cGFpbnQuCisgICAgICAgIGJhY2tpbmdTdG9yZS0+dmlld3BvcnRDaGFuZ2VkKFdlYkNvcmU6Oklu dFJlY3QoZC0+dmlzaWJsZVJlY3QoKSkpOworICAgICAgICAvLyBRV2ViRnJhbWU6OnJlbmRlciBp cyBhIHB1YmxpYyBBUEksIGJ5cGFzcyBpdCBmb3IgdGlsZWQgcmVuZGVyaW5nIHNvIGJlaGF2aW9y IGRvZXMgbm90IG5lZWQgdG8gY2hhbmdlLgorICAgICAgICBXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQgY29udGV4dChwYWludGVyKTsgCisgICAgICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPmQtPnJl bmRlckNvbnRlbnRzTGF5ZXJBYnNvbHV0ZUNvb3JkcygmY29udGV4dCwgb3B0aW9uLT5leHBvc2Vk UmVjdC50b0FsaWduZWRSZWN0KCkpOworICAgICAgICByZXR1cm47CisgICAgfSAKKyNlbmRpZgog I2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICBwYWdlKCktPm1haW5GcmFtZSgp LT5yZW5kZXIocGFpbnRlciwgZC0+b3ZlcmxheSA/IFFXZWJGcmFtZTo6Q29udGVudHNMYXllciA6 IFFXZWJGcmFtZTo6QWxsTGF5ZXJzLCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvQWxpZ25lZFJlY3Qo KSk7CiAjZWxzZQpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJL aXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU4LDYgKzU4LDcgQEAK ICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU3Vic3RpdHV0ZURh dGEuaCIKICNpbmNsdWRlICJTVkdTTUlMRWxlbWVudC5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2lu Z1N0b3JlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJtYXJrdXAuaCIK ICNpbmNsdWRlICJxdF9pbnN0YW5jZS5oIgpAQCAtMzM5LDcgKzM0MCwxMSBAQCB2b2lkIFFXZWJG cmFtZVByaXZhdGU6OnJlbmRlckNvbnRlbnRzTGF5CiAgICAgUVBhaW50ZXIqIHBhaW50ZXIgPSBj b250ZXh0LT5wbGF0Zm9ybUNvbnRleHQoKTsKIAogICAgIFdlYkNvcmU6OkZyYW1lVmlldyogdmll dyA9IGZyYW1lLT52aWV3KCk7Ci0gICAgdmlldy0+bGF5b3V0SWZOZWVkZWRSZWN1cnNpdmUoKTsK KyAgICAKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKyAgICBpZiAoIWZyYW1lLT50 aWxlZEJhY2tpbmdTdG9yZSgpKQorI2VuZGlmCisgICAgICAgIHZpZXctPmxheW91dElmTmVlZGVk UmVjdXJzaXZlKCk7CiAKICAgICBmb3IgKGludCBpID0gMDsgaSA8IHZlY3Rvci5zaXplKCk7ICsr aSkgewogICAgICAgICBjb25zdCBRUmVjdCYgY2xpcFJlY3QgPSB2ZWN0b3IuYXQoaSk7CkBAIC0z NDgsNyArMzUzLDEyIEBAIHZvaWQgUVdlYkZyYW1lUHJpdmF0ZTo6cmVuZGVyQ29udGVudHNMYXkK ICAgICAgICAgcGFpbnRlci0+c2V0Q2xpcFJlY3QoY2xpcFJlY3QsIFF0OjpJbnRlcnNlY3RDbGlw KTsKIAogICAgICAgICBjb250ZXh0LT5zYXZlKCk7Ci0gICAgICAgIHZpZXctPnBhaW50Q29udGVu dHMoY29udGV4dCwgY2xpcFJlY3QpOworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQor ICAgICAgICBpZiAoZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCkpCisgICAgICAgICAgICBmcmFt ZS0+dGlsZWRCYWNraW5nU3RvcmUoKS0+cGFpbnQoY29udGV4dCwgY2xpcFJlY3QpOworICAgICAg ICBlbHNlCisjZW5kaWYKKyAgICAgICAgICAgIHZpZXctPnBhaW50Q29udGVudHMoY29udGV4dCwg Y2xpcFJlY3QpOwogICAgICAgICBjb250ZXh0LT5yZXN0b3JlKCk7CiAKICAgICAgICAgcGFpbnRl ci0+cmVzdG9yZSgpOwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCShyZXZpc2lvbiA1NTQ1OSkKKysrIFdlYktp dC9xdC9BcGkvcXdlYmZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyMiw2ICsyMjIsNyBAQCBR X1NJR05BTFM6CiAgICAgdm9pZCBwYWdlQ2hhbmdlZCgpOwogCiBwcml2YXRlOgorICAgIGZyaWVu ZCBjbGFzcyBRR3JhcGhpY3NXZWJWaWV3OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViUGFnZTsKICAg ICBmcmllbmQgY2xhc3MgUVdlYlBhZ2VQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJh bWVQcml2YXRlOwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAkocmV2aXNpb24gNTU0NTkpCisr KyBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIzNCw2 ICsyMzQsMTAgQEAgdm9pZCBRV2ViU2V0dGluZ3NQcml2YXRlOjphcHBseSgpCiAgICAgICAgIHZh bHVlID0gYXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlhTU0F1ZGl0b3JFbmFibGVkLAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJpYnV0ZXMu dmFsdWUoUVdlYlNldHRpbmdzOjpYU1NBdWRpdG9yRW5hYmxlZCkpOwogICAgICAgICBzZXR0aW5n cy0+c2V0WFNTQXVkaXRvckVuYWJsZWQodmFsdWUpOworICAgICAgICAKKyAgICAgICAgdmFsdWUg PSBhdHRyaWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5nczo6VGlsZWRCYWNraW5nU3RvcmVFbmFibGVk LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbG9iYWwtPmF0dHJpYnV0 ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQpKTsKKyAgICAg ICAgc2V0dGluZ3MtPnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCh2YWx1ZSk7CiAKICAgICAg ICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoV2ViQ29yZTo6cGFnZUNhY2hlKCktPmNhcGFj aXR5KCkpOwogICAgIH0gZWxzZSB7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmgJKHJldmlzaW9uIDU1 NDU5KQorKysgV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAt NzEsNiArNzEsNyBAQCBwdWJsaWM6CiAgICAgICAgIERuc1ByZWZldGNoRW5hYmxlZCwKICAgICAg ICAgWFNTQXVkaXRvckVuYWJsZWQsCiAgICAgICAgIEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFi bGVkLAorICAgICAgICBUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQsCiAgICAgICAgIFdlYkdMRW5h YmxlZAogICAgIH07CiAgICAgZW51bSBXZWJHcmFwaGljIHsK 50031 2010-03-04 09:52:25 -0800 2010-03-11 05:40:56 -0800 WebCore patch tiled-backing-store-webcore-10.patch text/plain 36172 koivisto SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcmkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnByaQkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJpCSh3b3JraW5nIGNv cHkpCkBAIC03Nyw2ICs3Nyw5IEBAIGdyZWF0ZXJUaGFuKFFUX01JTk9SX1ZFUlNJT04sIDUpIHsK ICMgSFRNTDUgZGF0YWxpc3Qgc3VwcG9ydAogIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9EQVRB TElTVD0uKTogREVGSU5FUyArPSBFTkFCTEVfREFUQUxJU1Q9MQogCisjIFRpbGVkIEJhY2tpbmcg U3RvcmUgc3VwcG9ydAorIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9USUxFRF9CQUNLSU5HX1NU T1JFPS4pOiBERUZJTkVTICs9IEVOQUJMRV9USUxFRF9CQUNLSU5HX1NUT1JFPTEKKwogIyBOZXNj YXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkpCiAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05F VFNDQVBFX1BMVUdJTl9BUEk9LikgewogICAgIHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNl KjogewpAQCAtMTQ3LDYgKzE1MCw3IEBAIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9KQVZBU0NS SVBUX0RFQlUKIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9PRkZMSU5FX1dFQl9BUFBMSUNBVElP TlM9MSk6IEZFQVRVUkVfREVGSU5FU19KQVZBU0NSSVBUICs9IEVOQUJMRV9PRkZMSU5FX1dFQl9B UFBMSUNBVElPTlM9MQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQl9TT0NLRVRTPTEpOiBG RUFUVVJFX0RFRklORVNfSkFWQVNDUklQVCArPSBFTkFCTEVfV0VCX1NPQ0tFVFM9MQogY29udGFp bnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFT Q1JJUFQgKz0gRU5BQkxFX1RPVUNIX0VWRU5UUz0xCitjb250YWlucyhERUZJTkVTLCBFTkFCTEVf VElMRURfQkFDS0lOR19TVE9SRT0xKTogRkVBVFVSRV9ERUZJTkVTX0pBVkFTQ1JJUFQgKz0gRU5B QkxFX1RJTEVEX0JBQ0tJTkdfU1RPUkU9MQogCiAKICMjIERlcml2ZWQgc291cmNlIGdlbmVyYXRv cnMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJD b3JlLnBybwkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5n IGNvcHkpCkBAIC04MjYsNiArODI2LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvUGVuLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU2VnbWVudGVkRm9udERhdGEu Y3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5jcHAgXAorICAgIHBs YXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcCBcCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcCBcCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9NYXRyaXhUcmFuc2Zvcm1PcGVyYXRpb24uY3BwIFwKQEAgLTE1 MzUsNiArMTUzNiw5IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3F0L1N0 aWxsSW1hZ2VRdC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TZWdtZW50ZWRGb250RGF0YS5o IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9TaW1wbGVGb250RGF0YS5oIFwKKyAgICBwbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmggXAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0 b3JlLmggXCAgICAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZUNsaWVu dC5oIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL01hdHJpeDNEVHJhbnNmb3Jt T3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvTWF0cml4VHJh bnNmb3JtT3BlcmF0aW9uLmggXAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvUGVy c3BlY3RpdmVUcmFuc2Zvcm1PcGVyYXRpb24uaCBcCkBAIC0yMDI4LDYgKzIwMzIsNyBAQCBTT1VS Q0VTICs9IFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9Gb250Q3VzdG9tUGxhdGZvcm1EYXRh UXQuY3BwIFwKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HbHlwaFBhZ2VUcmVlTm9kZVF0LmNw cCBcCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvcXQvU2ltcGxlRm9udERhdGFRdC5jcHAgXAorICAg IHBsYXRmb3JtL2dyYXBoaWNzL3F0L1RpbGVRdC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0tVUkxR dC5jcHAgXAogICAgIHBsYXRmb3JtL3F0L0xvY2FsaXphdGlvbnMuY3BwIFwKICAgICBwbGF0Zm9y bS9xdC9NSU1FVHlwZVJlZ2lzdHJ5UXQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNTU0NTkp CisrKyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3 IEBACiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNp bmNsdWRlICJUZXh0UmVzb3VyY2VEZWNvZGVyLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3Rv cmUuaCIKICNpbmNsdWRlICJVc2VyQ29udGVudFVSTFBhdHRlcm4uaCIKICNpbmNsdWRlICJYTUxO U05hbWVzLmgiCiAjaW5jbHVkZSAiWE1MTmFtZXMuaCIKQEAgLTE3MSw5ICsxNzIsMTMgQEAgRnJh bWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRQogICAgIFhNTE5TTmFtZXM6Omlu aXQoKTsKICAgICBYTUxOYW1lczo6aW5pdCgpOwogCi0gICAgaWYgKCFvd25lckVsZW1lbnQpCisg ICAgaWYgKCFvd25lckVsZW1lbnQpIHsKICAgICAgICAgcGFnZS0+c2V0TWFpbkZyYW1lKHRoaXMp OwotICAgIGVsc2UgeworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICAv LyBUb3AgbGV2ZWwgZnJhbWUgb25seSBmb3Igbm93LgorICAgICAgICBzZXRUaWxlZEJhY2tpbmdT dG9yZUVuYWJsZWQocGFnZS0+c2V0dGluZ3MoKS0+dGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKCkp OworI2VuZGlmCisgICAgfSBlbHNlIHsKICAgICAgICAgcGFnZS0+aW5jcmVtZW50RnJhbWVDb3Vu dCgpOwogICAgICAgICAvLyBNYWtlIHN1cmUgd2Ugd2lsbCBub3QgZW5kIHVwIHdpdGggdHdvIGZy YW1lcyByZWZlcmVuY2luZyB0aGUgc2FtZSBvd25lciBlbGVtZW50LgogICAgICAgICBBU1NFUlQo KCEob3duZXJFbGVtZW50LT5tX2NvbnRlbnRGcmFtZSkpIHx8IChvd25lckVsZW1lbnQtPm1fY29u dGVudEZyYW1lLT5vd25lckVsZW1lbnQoKSAhPSBvd25lckVsZW1lbnQpKTsKQEAgLTE4NDEsNCAr MTg0Niw0OSBAQCB2b2lkIEZyYW1lOjpjcmVhdGVWaWV3KGNvbnN0IEludFNpemUmIHZpCiAgICAg ICAgIHZpZXcoKS0+c2V0Q2FuSGF2ZVNjcm9sbGJhcnMob3duZXItPnNjcm9sbGluZ01vZGUoKSAh PSBTY3JvbGxiYXJBbHdheXNPZmYpOwogfQogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RP UkUpCit2b2lkIEZyYW1lOjpzZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoYm9vbCBlbmFibGVk KQoreworICAgIGlmICghZW5hYmxlZCkgeworICAgICAgICBtX3RpbGVkQmFja2luZ1N0b3JlLmNs ZWFyKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKG1fdGlsZWRCYWNraW5nU3Rv cmUpCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVkQmFja2luZ1N0b3JlLnNldChuZXcgVGls ZWRCYWNraW5nU3RvcmUodGhpcykpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9y ZVBhaW50QmVnaW4oKQoreworICAgIGlmICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAg bV92aWV3LT5sYXlvdXRJZk5lZWRlZFJlY3Vyc2l2ZSgpOworICAgIG1fdmlldy0+Zmx1c2hEZWZl cnJlZFJlcGFpbnRzKCk7Cit9CisKK3ZvaWQgRnJhbWU6OnRpbGVkQmFja2luZ1N0b3JlUGFpbnQo R3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm ICghbV92aWV3KQorICAgICAgICByZXR1cm47CisgICAgbV92aWV3LT5wYWludENvbnRlbnRzKGNv bnRleHQsIHJlY3QpOworfQorCit2b2lkIEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZVBhaW50RW5k KGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpCit7CisgICAgaWYgKCFtX3BhZ2Ug fHwgIW1fdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIHVuc2lnbmVkIHNpemUgPSBwYWludGVk QXJlYS5zaXplKCk7CisgICAgLy8gUmVxdWVzdCByZXBhaW50IGZyb20gdGhlIHN5c3RlbQorICAg IGZvciAoaW50IG4gPSAwOyBuIDwgc2l6ZTsgKytuKQorICAgICAgICBtX3BhZ2UtPmNocm9tZSgp LT5yZXBhaW50KG1fdmlldy0+Y29udmVydFRvQ29udGFpbmluZ1dpbmRvdyhwYWludGVkQXJlYVtu XSksIHRydWUpOworfQorCitJbnRSZWN0IEZyYW1lOjp0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRz UmVjdCgpCit7CisgICAgaWYgKCFtX3ZpZXcpCisgICAgICAgIHJldHVybiBJbnRSZWN0KCk7Cisg ICAgcmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbV92aWV3LT5jb250ZW50c1NpemUoKSk7Cit9 CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0Zy YW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDU1NDU5 KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTM3LDYgKzM3LDcg QEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiU2Nyb2xsQmVoYXZp b3IuaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiVGlsZWRC YWNraW5nU3RvcmVDbGllbnQuaCIKICNpbmNsdWRlICJVc2VyU2NyaXB0VHlwZXMuaCIKICNpbmNs dWRlICJab29tTW9kZS5oIgogCkBAIC02Myw4ICs2NCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICBjbGFzcyBDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbjsKICAgICBjbGFzcyBIVE1MVGFi bGVDZWxsRWxlbWVudDsKICAgICBjbGFzcyBSZWd1bGFyRXhwcmVzc2lvbjsKKyAgICBjbGFzcyBU aWxlZEJhY2tpbmdTdG9yZTsKIAotICAgIGNsYXNzIEZyYW1lIDogcHVibGljIFJlZkNvdW50ZWQ8 RnJhbWU+IHsKKyAgICBjbGFzcyBGcmFtZSA6IHB1YmxpYyBSZWZDb3VudGVkPEZyYW1lPiwgcHVi bGljIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IHsKICAgICBwdWJsaWM6CiAgICAgICAgIHN0YXRp YyBQYXNzUmVmUHRyPEZyYW1lPiBjcmVhdGUoUGFnZSogcGFnZSwgSFRNTEZyYW1lT3duZXJFbGVt ZW50KiBvd25lckVsZW1lbnQsIEZyYW1lTG9hZGVyQ2xpZW50KiBjbGllbnQpCiAgICAgICAgIHsK QEAgLTE2NCw2ICsxNjYsMTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAgICAgcmV0 dXJuIGRvY3VtZW50KCkgPyBkb2N1bWVudCgpLT5kaXNwbGF5U3RyaW5nTW9kaWZpZWRCeUVuY29k aW5nKHN0cikgOiBzdHI7CiAgICAgICAgIH0KIAorI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NU T1JFKQorICAgICAgICBUaWxlZEJhY2tpbmdTdG9yZSogdGlsZWRCYWNraW5nU3RvcmUoKSBjb25z dCB7IHJldHVybiBtX3RpbGVkQmFja2luZ1N0b3JlLmdldCgpOyB9CisgICAgICAgIHZvaWQgc2V0 VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wpOworI2VuZGlmCisKICAgICBwcml2YXRlOgog ICAgICAgICB2b2lkIGxpZmVTdXBwb3J0VGltZXJGaXJlZChUaW1lcjxGcmFtZT4qKTsKIApAQCAt MjY5LDYgKzI3NiwxNSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgVmlzaWJsZVBv c2l0aW9uIHZpc2libGVQb3NpdGlvbkZvclBvaW50KGNvbnN0IEludFBvaW50JiBmcmFtZVBvaW50 KTsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50QXRQb2ludChjb25zdCBJbnRQb2ludCYgd2lu ZG93UG9pbnQpOworICAgICAgICAKKyAgICBwcml2YXRlOgorI2lmIEVOQUJMRShUSUxFRF9CQUNL SU5HX1NUT1JFKQorICAgICAgICAvLyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCBpbnRlcmZhY2UK KyAgICAgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOworICAg ICAgICB2aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludChHcmFwaGljc0NvbnRleHQq LCBjb25zdCBJbnRSZWN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9y ZVBhaW50RW5kKGNvbnN0IFZlY3RvcjxJbnRSZWN0PiYgcGFpbnRlZEFyZWEpOworICAgICAgICB2 aXJ0dWFsIEludFJlY3QgdGlsZWRCYWNraW5nU3RvcmVDb250ZW50c1JlY3QoKTsKKyNlbmRpZgog CiAgICAgI2lmIFBMQVRGT1JNKE1BQykKIApAQCAtMzQ3LDYgKzM2MywxMCBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIGJvb2wgbV9uZWVkc1JlYXBwbHlTdHlsZXM7CiAgICAgICAgIGJv b2wgbV9pc0Rpc2Nvbm5lY3RlZDsKICAgICAgICAgYm9vbCBtX2V4Y2x1ZGVGcm9tVGV4dFNlYXJj aDsKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKSAgICAgICAgCisgICAgICAgIE93 blB0cjxUaWxlZEJhY2tpbmdTdG9yZT4gbV90aWxlZEJhY2tpbmdTdG9yZTsKKyNlbmRpZgogICAg IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZVZp ZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCShyZXZpc2lv biA1NTQ1OSkKKysrIFdlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03MCw2ICs3MCw5IEBACiAjaW5jbHVkZSAiU1ZHVmlld1NwZWMuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUu aCIKKyNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTEwMTEsNiArMTAxNCwxMiBA QCB2b2lkIEZyYW1lVmlldzo6cmVwYWludENvbnRlbnRSZWN0YW5nbGUoCiAgICAgaWYgKCFpbW1l ZGlhdGUgJiYgaXNPZmZzY3JlZW4oKSAmJiAhc2hvdWxkVXBkYXRlV2hpbGVPZmZzY3JlZW4oKSkK ICAgICAgICAgcmV0dXJuOwogCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAg aWYgKGZyYW1lKCktPnRpbGVkQmFja2luZ1N0b3JlKCkpIHsKKyAgICAgICAgZnJhbWUoKS0+dGls ZWRCYWNraW5nU3RvcmUoKS0+aW52YWxpZGF0ZShyKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KyNlbmRpZgogICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVjdGFuZ2xlKHIsIGltbWVk aWF0ZSk7CiB9CiAKQEAgLTEwODIsOCArMTA5MSwxNSBAQCB2b2lkIEZyYW1lVmlldzo6ZG9EZWZl cnJlZFJlcGFpbnRzKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICB1bnNpZ25lZCBzaXpl ID0gbV9yZXBhaW50UmVjdHMuc2l6ZSgpOwotICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBz aXplOyBpKyspCisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHNpemU7IGkrKykgeworI2lm IEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAgICBpZiAoZnJhbWUoKS0+dGlsZWRC YWNraW5nU3RvcmUoKSkgeworICAgICAgICAgICAgZnJhbWUoKS0+dGlsZWRCYWNraW5nU3RvcmUo KS0+aW52YWxpZGF0ZShtX3JlcGFpbnRSZWN0c1tpXSk7CisgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgfQorI2VuZGlmCiAgICAgICAgIFNjcm9sbFZpZXc6OnJlcGFpbnRDb250ZW50UmVj dGFuZ2xlKG1fcmVwYWludFJlY3RzW2ldLCBmYWxzZSk7CisgICAgfQogICAgIG1fcmVwYWludFJl Y3RzLmNsZWFyKCk7CiAgICAgbV9yZXBhaW50Q291bnQgPSAwOwogICAgIApJbmRleDogV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu Y3BwCShyZXZpc2lvbiA1NTQ1OSkKKysrIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEyNSw2ICsxMjUsNyBAQCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSogcGFn ZSkKICAgICAsIG1fZXhwZXJpbWVudGFsTm90aWZpY2F0aW9uc0VuYWJsZWQoZmFsc2UpCiAgICAg LCBtX3dlYkdMRW5hYmxlZChmYWxzZSkKICAgICAsIG1fbG9hZERlZmVycmluZ0VuYWJsZWQodHJ1 ZSkKKyAgICAsIG1fdGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGZhbHNlKQogewogICAgIC8vIEEg RnJhbWUgbWF5IG5vdCBoYXZlIGJlZW4gY3JlYXRlZCB5ZXQsIHNvIHdlIGluaXRpYWxpemUgdGhl IEF0b21pY1N0cmluZyAKICAgICAvLyBoYXNoIGJlZm9yZSB0cnlpbmcgdG8gdXNlIGl0LgpAQCAt NTc0LDQgKzU3NSwxMyBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2FkRGVmZXJyaW5nRW5hYmxlZChi CiAgICAgbV9sb2FkRGVmZXJyaW5nRW5hYmxlZCA9IGVuYWJsZWQ7CiB9CiAKK3ZvaWQgU2V0dGlu Z3M6OnNldFRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZChib29sIGVuYWJsZWQpCit7CisgICAgbV90 aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQgPSBlbmFibGVkOworI2lmIEVOQUJMRShUSUxFRF9CQUNL SU5HX1NUT1JFKQorICAgIGlmIChtX3BhZ2UtPm1haW5GcmFtZSgpKQorICAgICAgICBtX3BhZ2Ut Pm1haW5GcmFtZSgpLT5zZXRUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQoZW5hYmxlZCk7CisjZW5k aWYKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgJKHJldmlzaW9uIDU1 NDU5KQorKysgV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgJKHdvcmtpbmcgY29weSkKQEAgLTI4Nyw2 ICsyODcsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRMb2FkRGVm ZXJyaW5nRW5hYmxlZChib29sKTsKICAgICAgICAgYm9vbCBsb2FkRGVmZXJyaW5nRW5hYmxlZCgp IGNvbnN0IHsgcmV0dXJuIG1fbG9hZERlZmVycmluZ0VuYWJsZWQ7IH0KKyAgICAgICAgCisgICAg ICAgIHZvaWQgc2V0VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkKGJvb2wpOworICAgICAgICBib29s IHRpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGlsZWRCYWNraW5n U3RvcmVFbmFibGVkOyB9CiAKICAgICBwcml2YXRlOgogICAgICAgICBQYWdlKiBtX3BhZ2U7CkBA IC0zNjEsNiArMzY0LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZXhw ZXJpbWVudGFsTm90aWZpY2F0aW9uc0VuYWJsZWQgOiAxOwogICAgICAgICBib29sIG1fd2ViR0xF bmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX2xvYWREZWZlcnJpbmdFbmFibGVkIDogMTsKKyAg ICAgICAgYm9vbCBtX3RpbGVkQmFja2luZ1N0b3JlRW5hYmxlZCA6IDE7CiAKICNpZiBVU0UoU0FG QVJJX1RIRU1FKQogICAgICAgICBzdGF0aWMgYm9vbCBnU2hvdWxkUGFpbnROYXRpdmVDb250cm9s czsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzYgQEAK Ky8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vi c2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBG bG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFRpbGVf aAorI2RlZmluZSBUaWxlX2gKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorCisj aW5jbHVkZSAiSW50UG9pbnQuaCIKKyNpbmNsdWRlICJJbnRQb2ludEhhc2guaCIKKyNpbmNsdWRl ICJJbnRSZWN0LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYv UmVmQ291bnRlZC5oPgorCisjaWYgUExBVEZPUk0oUVQpCitjbGFzcyBRUGl4bWFwOworY2xhc3Mg UVJlZ2lvbjsKKyNlbmRpZgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitjbGFzcyBHcmFw aGljc0NvbnRleHQ7CitjbGFzcyBUaWxlZEJhY2tpbmdTdG9yZTsKKworY2xhc3MgVGlsZSA6IHB1 YmxpYyBSZWZDb3VudGVkPFRpbGU+IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEludFBvaW50IENv b3JkaW5hdGU7CisKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUaWxlPiBjcmVhdGUoVGlsZWRCYWNr aW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRpbmF0ZSYgdGlsZUNvb3JkaW5hdGUp IHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBUaWxlKGJhY2tpbmdTdG9yZSwgdGlsZUNvb3JkaW5hdGUp KTsgfQorICAgIH5UaWxlKCk7CisgICAgCisgICAgYm9vbCBpc0RpcnR5KCkgY29uc3Q7CisgICAg dm9pZCBpbnZhbGlkYXRlKGNvbnN0IEludFJlY3QmKTsKKyAgICB2b2lkIHVwZGF0ZUJhY2tCdWZm ZXIoKTsKKyAgICB2b2lkIHN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpOworICAgIGJvb2wgaXNSZWFk eVRvUGFpbnQoKSBjb25zdDsKKyAgICB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0 IEludFJlY3QmKTsKKworICAgIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUgY29vcmRpbmF0ZSgpIGNv bnN0IHsgcmV0dXJuIG1fY29vcmRpbmF0ZTsgfQorICAgIGNvbnN0IEludFJlY3QmIHJlY3QoKSBj b25zdCB7IHJldHVybiBtX3JlY3Q7IH0KKyAgICAKKyAgICBzdGF0aWMgdm9pZCBwYWludENoZWNr ZXJQYXR0ZXJuKEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEZsb2F0UmVjdCYpOworCitwcml2YXRl OgorICAgIFRpbGUoVGlsZWRCYWNraW5nU3RvcmUqLCBjb25zdCBDb29yZGluYXRlJik7CisgICAg CisgICAgVGlsZWRCYWNraW5nU3RvcmUqIG1fYmFja2luZ1N0b3JlOworICAgIENvb3JkaW5hdGUg bV9jb29yZGluYXRlOworICAgIEludFJlY3QgbV9yZWN0OworCisjaWYgUExBVEZPUk0oUVQpCisg ICAgUVBpeG1hcCogbV9idWZmZXI7CisgICAgUVBpeG1hcCogbV9iYWNrQnVmZmVyOworICAgIFFS ZWdpb24qIG1fZGlydHlSZWdpb247CisjZW5kaWYKK307CisKK30KKyNlbmRpZgorI2VuZGlmCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmNw cAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5n U3RvcmUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM2MyBAQAorLyoKKyBDb3B5cmlnaHQg KEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisg CisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAK KyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmls ZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJUaWxlZEJhY2tpbmdTdG9yZS5oIgorCisjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJTkdfU1RPUkUp CisKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdT dG9yZUNsaWVudC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitzdGF0aWMgY29uc3Qg aW50IGRlZmF1bHRUaWxlV2lkdGggPSA1MTI7CitzdGF0aWMgY29uc3QgaW50IGRlZmF1bHRUaWxl SGVpZ2h0ID0gNTEyOworCitUaWxlZEJhY2tpbmdTdG9yZTo6VGlsZWRCYWNraW5nU3RvcmUoVGls ZWRCYWNraW5nU3RvcmVDbGllbnQqIGNsaWVudCkKKyAgICA6IG1fY2xpZW50KGNsaWVudCkKKyAg ICAsIG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyKG5ldyBUaWxlVGltZXIodGhpcywgJlRpbGVkQmFj a2luZ1N0b3JlOjp0aWxlQnVmZmVyVXBkYXRlVGltZXJGaXJlZCkpCisgICAgLCBtX3RpbGVDcmVh dGlvblRpbWVyKG5ldyBUaWxlVGltZXIodGhpcywgJlRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQ3Jl YXRpb25UaW1lckZpcmVkKSkKKyAgICAsIG1fdGlsZVNpemUoZGVmYXVsdFRpbGVXaWR0aCwgZGVm YXVsdFRpbGVIZWlnaHQpCisgICAgLCBtX2NvbnRlbnRzU2NhbGUoMS5mKQorICAgICwgbV9jb250 ZW50c0Zyb3plbihmYWxzZSkKK3sKK30KKworVGlsZWRCYWNraW5nU3RvcmU6On5UaWxlZEJhY2tp bmdTdG9yZSgpCit7CisgICAgZGVsZXRlIG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyOworICAgIGRl bGV0ZSBtX3RpbGVDcmVhdGlvblRpbWVyOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjpp bnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRzRGlydHlSZWN0KQoreworICAgIEludFJl Y3QgZGlydHlSZWN0KG1hcEZyb21Db250ZW50cyhjb250ZW50c0RpcnR5UmVjdCkpOworICAgIAor ICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGly dHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRp bGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIAorICAg IGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUgPSB0b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0g Ym90dG9tUmlnaHQueSgpOyArK3lDb29yZGluYXRlKSB7CisgICAgICAgIGZvciAodW5zaWduZWQg eENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsgeENvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgp OyArK3hDb29yZGluYXRlKSB7CisgICAgICAgICAgICBSZWZQdHI8VGlsZT4gY3VycmVudFRpbGUg PSB0aWxlQXQoVGlsZTo6Q29vcmRpbmF0ZSh4Q29vcmRpbmF0ZSwgeUNvb3JkaW5hdGUpKTsKKyAg ICAgICAgICAgIGlmICghY3VycmVudFRpbGUpCisgICAgICAgICAgICAgICAgY29udGludWU7Cisg ICAgICAgICAgICBjdXJyZW50VGlsZS0+aW52YWxpZGF0ZShkaXJ0eVJlY3QpOworICAgICAgICB9 CisgICAgfQorCisgICAgc3RhcnRUaWxlQnVmZmVyVXBkYXRlVGltZXIoKTsKK30KKwordm9pZCBU aWxlZEJhY2tpbmdTdG9yZTo6dXBkYXRlVGlsZUJ1ZmZlcnMoKQoreworICAgIGlmIChtX2NvbnRl bnRzRnJvemVuKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgVmVjdG9yPEludFJlY3Q+IHBh aW50ZWRBcmVhOworICAgIFZlY3RvcjxSZWZQdHI8VGlsZT4gPiBkaXJ0eVRpbGVzOworICAgIFRp bGVNYXA6Oml0ZXJhdG9yIGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjpp dGVyYXRvciBpdCA9IG1fdGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAg IGlmICghaXQtPnNlY29uZC0+aXNEaXJ0eSgpKQorICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIGRpcnR5VGlsZXMuYXBwZW5kKGl0LT5zZWNvbmQpOworICAgICAgICAvLyBGSVhNRTogc2hv dWxkIG5vdCByZXF1ZXN0IHN5c3RlbSByZXBhaW50IGZvciB0aGUgZnVsbCB0aWxlLgorICAgICAg ICBwYWludGVkQXJlYS5hcHBlbmQobWFwVG9Db250ZW50cyhpdC0+c2Vjb25kLT5yZWN0KCkpKTsK KyAgICB9CisgICAgCisgICAgaWYgKGRpcnR5VGlsZXMuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm47CisgICAgCisgICAgbV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnRCZWdpbigpOwor CisgICAgLy8gRklYTUU6IEluIHNpbmdsZSB0aHJlYWRlZCBjYXNlLCB0aWxlIGJhY2sgYnVmZmVy cyBjb3VsZCBiZSB1cGRhdGVkIGFzeW5jaHJvbm91c2x5IAorICAgIC8vIG9uZSBieSBvbmUgYW5k IHRoZW4gc3dhcHBlZCB0byBmcm9udCBpbiBvbmUgZ28uIFRoaXMgd291bGQgbWluaW1pemUgdGhl IHRpbWUgc3BlbnQKKyAgICAvLyBibG9ja2luZyBvbiB0aWxlIHVwZGF0ZXMuCisgICAgdW5zaWdu ZWQgc2l6ZSA9IGRpcnR5VGlsZXMuc2l6ZSgpOworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4g PCBzaXplOyArK24pCisgICAgICAgIGRpcnR5VGlsZXNbbl0tPnVwZGF0ZUJhY2tCdWZmZXIoKTsK KworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCBzaXplOyArK24pCisgICAgICAgIGRpcnR5 VGlsZXNbbl0tPnN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpOworCisgICAgbV9jbGllbnQtPnRpbGVk QmFja2luZ1N0b3JlUGFpbnRFbmQocGFpbnRlZEFyZWEpOworfQorCit2b2lkIFRpbGVkQmFja2lu Z1N0b3JlOjpwYWludChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIHJl Y3QpCit7CisgICAgY29udGV4dC0+c2F2ZSgpOworICAgIAorICAgIC8vIEFzc3VtZXMgdGhlIGJh Y2tpbmcgc3RvcmUgaXMgcGFpbnRlZCB3aXRoIHRoZSBzY2FsZSB0cmFuc2Zvcm0gYXBwbGllZC4K KyAgICAvLyBTaW5jZSB0aWxlIGNvbnRlbnQgaXMgYWxyZWFkeSBzY2FsZWQsIGZpcnN0IHJldmVy dCB0aGUgc2NhbGluZyBmcm9tIHRoZSBwYWludGVyLgorICAgIGNvbnRleHQtPnNjYWxlKEZsb2F0 U2l6ZSgxLmYgLyBtX2NvbnRlbnRzU2NhbGUsIDEuZiAvIG1fY29udGVudHNTY2FsZSkpOworICAg IAorICAgIEludFJlY3QgZGlydHlSZWN0ID0gbWFwRnJvbUNvbnRlbnRzKHJlY3QpOworICAgIAor ICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9wTGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoZGly dHlSZWN0LnRvcExlZnQoKSk7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRp bGVDb29yZGluYXRlRm9yUG9pbnQoZGlydHlSZWN0LmJvdHRvbVJpZ2h0KCkpOworCisgICAgZm9y ICh1bnNpZ25lZCB5Q29vcmRpbmF0ZSA9IHRvcExlZnQueSgpOyB5Q29vcmRpbmF0ZSA8PSBib3R0 b21SaWdodC55KCk7ICsreUNvb3JkaW5hdGUpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4Q29v cmRpbmF0ZSA9IHRvcExlZnQueCgpOyB4Q29vcmRpbmF0ZSA8PSBib3R0b21SaWdodC54KCk7ICsr eENvb3JkaW5hdGUpIHsKKyAgICAgICAgICAgIFRpbGU6OkNvb3JkaW5hdGUgY3VycmVudENvb3Jk aW5hdGUoeENvb3JkaW5hdGUsIHlDb29yZGluYXRlKTsKKyAgICAgICAgICAgIFJlZlB0cjxUaWxl PiBjdXJyZW50VGlsZSA9IHRpbGVBdChjdXJyZW50Q29vcmRpbmF0ZSk7CisgICAgICAgICAgICBp ZiAoY3VycmVudFRpbGUgJiYgY3VycmVudFRpbGUtPmlzUmVhZHlUb1BhaW50KCkpCisgICAgICAg ICAgICAgICAgY3VycmVudFRpbGUtPnBhaW50KGNvbnRleHQsIGRpcnR5UmVjdCk7CisgICAgICAg ICAgICBlbHNlIHsKKyAgICAgICAgICAgICAgICBGbG9hdFJlY3QgdGlsZVJlY3QgPSB0aWxlUmVj dEZvckNvb3JkaW5hdGUoY3VycmVudENvb3JkaW5hdGUpOworICAgICAgICAgICAgICAgIEZsb2F0 UmVjdCB0YXJnZXQgPSBpbnRlcnNlY3Rpb24odGlsZVJlY3QsIEZsb2F0UmVjdChyZWN0KSk7Cisg ICAgICAgICAgICAgICAgVGlsZTo6cGFpbnRDaGVja2VyUGF0dGVybihjb250ZXh0LCB0YXJnZXQp OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorICAgIGNvbnRleHQtPnJlc3RvcmUo KTsKK30KKwordm9pZCBUaWxlZEJhY2tpbmdTdG9yZTo6dmlld3BvcnRDaGFuZ2VkKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRzVmlld3BvcnQpCit7CisgICAgSW50UmVjdCB2aWV3cG9ydCA9IG1hcEZy b21Db250ZW50cyhjb250ZW50c1ZpZXdwb3J0KTsKKyAgICBpZiAobV92aWV3cG9ydCA9PSB2aWV3 cG9ydCkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV92aWV3cG9ydCA9IHZpZXdwb3J0OworCisg ICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3Jl OjpzZXRDb250ZW50c1NjYWxlKGZsb2F0IHNjYWxlKQoreworICAgIGlmIChtX2NvbnRlbnRzU2Nh bGUgPT0gc2NhbGUpCisgICAgICAgIHJldHVybjsKKyAgICBtX2NvbnRlbnRzU2NhbGUgPSBzY2Fs ZTsKKworICAgIGludmFsaWRhdGUobV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlQ29udGVudHNS ZWN0KCkpOworfQorICAgIAorZG91YmxlIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlRGlzdGFuY2Uo Y29uc3QgSW50UmVjdCYgdmlld3BvcnQsIGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIHRpbGVDb29y ZGluYXRlKQoreworICAgIGlmICh2aWV3cG9ydC5pbnRlcnNlY3RzKHRpbGVSZWN0Rm9yQ29vcmRp bmF0ZSh0aWxlQ29vcmRpbmF0ZSkpKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBJbnRQ b2ludCB2aWV3Q2VudGVyID0gdmlld3BvcnQubG9jYXRpb24oKSArIEludFNpemUodmlld3BvcnQu d2lkdGgoKSAvIDIsIHZpZXdwb3J0LmhlaWdodCgpIC8gMik7CisgICAgVGlsZTo6Q29vcmRpbmF0 ZSBjZW50ZXJDb29yZGluYXRlID0gdGlsZUNvb3JkaW5hdGVGb3JQb2ludCh2aWV3Q2VudGVyKTsK KyAgICAKKyAgICAvLyBNYW5oYXR0YW4gZGlzdGFuY2UsIGJpYXNlZCBzbyB0aGF0IHZlcnRpY2Fs IGRpc3RhbmNlcyBhcmUgc2hvcnRlci4KKyAgICBjb25zdCBkb3VibGUgaG9yaXpvbnRhbEJpYXMg PSAxLjM7CisgICAgcmV0dXJuIGFicyhjZW50ZXJDb29yZGluYXRlLnkoKSAtIHRpbGVDb29yZGlu YXRlLnkoKSkgKyBob3Jpem9udGFsQmlhcyAqIGFicyhjZW50ZXJDb29yZGluYXRlLngoKSAtIHRp bGVDb29yZGluYXRlLngoKSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OmNyZWF0ZVRp bGVzKCkKK3sKKyAgICBpZiAobV9jb250ZW50c0Zyb3plbikKKyAgICAgICAgcmV0dXJuOworCisg ICAgaWYgKG1fdmlld3BvcnQuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBS ZW1vdmUgdGlsZXMgdGhhdCBleHRlbmQgb3V0c2lkZSB0aGUgY3VycmVudCBjb250ZW50cyByZWN0 LgorICAgIGRyb3BPdmVyaGFuZ2luZ1RpbGVzKCk7CisKKyAgICAvLyBGSVhNRTogTWFrZSBjb25m aWd1cmFibGUvYWRhcHQgdG8gbWVtb3J5LgorICAgIEludFJlY3Qga2VlcFJlY3QgPSBtX3ZpZXdw b3J0OworICAgIGtlZXBSZWN0LmluZmxhdGVYKG1fdmlld3BvcnQud2lkdGgoKSk7CisgICAga2Vl cFJlY3QuaW5mbGF0ZVkoMyAqIG1fdmlld3BvcnQuaGVpZ2h0KCkpOworICAgIGtlZXBSZWN0Lmlu dGVyc2VjdChjb250ZW50c1JlY3QoKSk7CisgICAgCisgICAgZHJvcFRpbGVzT3V0c2lkZVJlY3Qo a2VlcFJlY3QpOworICAgIAorICAgIEludFJlY3QgY292ZXJSZWN0ID0gbV92aWV3cG9ydDsKKyAg ICBjb3ZlclJlY3QuaW5mbGF0ZVgobV92aWV3cG9ydC53aWR0aCgpIC8gMik7CisgICAgY292ZXJS ZWN0LmluZmxhdGVZKDIgKiBtX3ZpZXdwb3J0LmhlaWdodCgpKTsKKyAgICBjb3ZlclJlY3QuaW50 ZXJzZWN0KGNvbnRlbnRzUmVjdCgpKTsKKyAgICAKKyAgICAvLyBTZWFyY2ggZm9yIHRoZSB0aWxl IHBvc2l0aW9uIGNsb3Nlc3QgdG8gdGhlIHZpZXdwb3J0IGNlbnRlciB0aGF0IGRvZXMgbm90IHll dCBjb250YWluIGEgdGlsZS4gCisgICAgLy8gV2hpY2ggcG9zaXRpb24gaXMgY29uc2lkZXJlZCB0 aGUgY2xvc2VzdCBkZXBlbmRzIG9uIHRoZSB0aWxlRGlzdGFuY2UgZnVuY3Rpb24uCisgICAgZG91 YmxlIHNob3J0ZXN0RGlzdGFuY2UgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGRvdWJsZT46OmluZmlu aXR5KCk7CisgICAgVmVjdG9yPFRpbGU6OkNvb3JkaW5hdGU+IHRpbGVzVG9DcmVhdGU7CisgICAg dW5zaWduZWQgcmVxdWlyZWRUaWxlQ291bnQgPSAwOworICAgIFRpbGU6OkNvb3JkaW5hdGUgdG9w TGVmdCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY292ZXJSZWN0LnRvcExlZnQoKSk7CisgICAg VGlsZTo6Q29vcmRpbmF0ZSBib3R0b21SaWdodCA9IHRpbGVDb29yZGluYXRlRm9yUG9pbnQoY292 ZXJSZWN0LmJvdHRvbVJpZ2h0KCkpOworICAgIGZvciAodW5zaWduZWQgeUNvb3JkaW5hdGUgPSB0 b3BMZWZ0LnkoKTsgeUNvb3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueSgpOyArK3lDb29yZGluYXRl KSB7CisgICAgICAgIGZvciAodW5zaWduZWQgeENvb3JkaW5hdGUgPSB0b3BMZWZ0LngoKTsgeENv b3JkaW5hdGUgPD0gYm90dG9tUmlnaHQueCgpOyArK3hDb29yZGluYXRlKSB7CisgICAgICAgICAg ICBUaWxlOjpDb29yZGluYXRlIGN1cnJlbnRDb29yZGluYXRlKHhDb29yZGluYXRlLCB5Q29vcmRp bmF0ZSk7CisgICAgICAgICAgICBpZiAodGlsZUF0KGN1cnJlbnRDb29yZGluYXRlKSkKKyAgICAg ICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICsrcmVxdWlyZWRUaWxlQ291bnQ7Cisg ICAgICAgICAgICAvLyBEaXN0YW5jZSBpcyAwIGZvciBhbGwgY3VycmVudGx5IHZpc2libGUgdGls ZXMuCisgICAgICAgICAgICBkb3VibGUgZGlzdGFuY2UgPSB0aWxlRGlzdGFuY2UobV92aWV3cG9y dCwgY3VycmVudENvb3JkaW5hdGUpOworICAgICAgICAgICAgaWYgKGRpc3RhbmNlID4gc2hvcnRl c3REaXN0YW5jZSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlmIChk aXN0YW5jZSA8IHNob3J0ZXN0RGlzdGFuY2UpIHsKKyAgICAgICAgICAgICAgICB0aWxlc1RvQ3Jl YXRlLmNsZWFyKCk7CisgICAgICAgICAgICAgICAgc2hvcnRlc3REaXN0YW5jZSA9IGRpc3RhbmNl OworICAgICAgICAgICAgfQorICAgICAgICAgICAgdGlsZXNUb0NyZWF0ZS5hcHBlbmQoY3VycmVu dENvb3JkaW5hdGUpOworICAgICAgICB9CisgICAgfQorICAgIAorICAgIC8vIE5vdyBjb25zdHJ1 Y3QgdGhlIHRpbGUocykKKyAgICB1bnNpZ25lZCB0aWxlc1RvQ3JlYXRlQ291bnQgPSB0aWxlc1Rv Q3JlYXRlLnNpemUoKTsKKyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgdGlsZXNUb0NyZWF0 ZUNvdW50OyArK24pIHsKKyAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBjb29yZGluYXRlID0gdGls ZXNUb0NyZWF0ZVtuXTsKKyAgICAgICAgc2V0VGlsZShjb29yZGluYXRlLCBUaWxlOjpjcmVhdGUo dGhpcywgY29vcmRpbmF0ZSkpOworICAgIH0KKyAgICByZXF1aXJlZFRpbGVDb3VudCAtPSB0aWxl c1RvQ3JlYXRlQ291bnQ7CisgICAgCisgICAgLy8gUGFpbnQgdGhlIGNvbnRlbnQgb2YgdGhlIG5l d2x5IGNyZWF0ZWQgdGlsZXMKKyAgICBpZiAodGlsZXNUb0NyZWF0ZUNvdW50KQorICAgICAgICB1 cGRhdGVUaWxlQnVmZmVycygpOworCisgICAgLy8gS2VlcCBjcmVhdGluZyB0aWxlcyB1bnRpbCB0 aGUgd2hvbGUgY292ZXJSZWN0IGlzIGNvdmVyZWQuCisgICAgaWYgKHJlcXVpcmVkVGlsZUNvdW50 KQorICAgICAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5zdGFydE9uZVNob3QoMCk7Cit9CisKK3Zv aWQgVGlsZWRCYWNraW5nU3RvcmU6OmRyb3BPdmVyaGFuZ2luZ1RpbGVzKCkKK3sgICAgCisgICAg SW50UmVjdCBjb250ZW50c1JlY3QgPSB0aGlzLT5jb250ZW50c1JlY3QoKTsKKworICAgIFZlY3Rv cjxUaWxlOjpDb29yZGluYXRlPiB0aWxlc1RvUmVtb3ZlOworICAgIFRpbGVNYXA6Oml0ZXJhdG9y IGVuZCA9IG1fdGlsZXMuZW5kKCk7CisgICAgZm9yIChUaWxlTWFwOjppdGVyYXRvciBpdCA9IG1f dGlsZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIFRpbGU6OkNvb3JkaW5h dGUgdGlsZUNvb3JkaW5hdGUgPSBpdC0+c2Vjb25kLT5jb29yZGluYXRlKCk7CisgICAgICAgIElu dFJlY3QgdGlsZVJlY3QgPSBpdC0+c2Vjb25kLT5yZWN0KCk7CisgICAgICAgIEludFJlY3QgZXhw ZWN0ZWRUaWxlUmVjdCA9IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSk7Cisg ICAgICAgIGlmIChleHBlY3RlZFRpbGVSZWN0ICE9IHRpbGVSZWN0IHx8ICFjb250ZW50c1JlY3Qu Y29udGFpbnModGlsZVJlY3QpKQorICAgICAgICAgICAgdGlsZXNUb1JlbW92ZS5hcHBlbmQodGls ZUNvb3JkaW5hdGUpOworICAgIH0KKyAgICB1bnNpZ25lZCByZW1vdmVDb3VudCA9IHRpbGVzVG9S ZW1vdmUuc2l6ZSgpOworICAgIGZvciAodW5zaWduZWQgbiA9IDA7IG4gPCByZW1vdmVDb3VudDsg KytuKQorICAgICAgICByZW1vdmVUaWxlKHRpbGVzVG9SZW1vdmVbbl0pOworfQorCit2b2lkIFRp bGVkQmFja2luZ1N0b3JlOjpkcm9wVGlsZXNPdXRzaWRlUmVjdChjb25zdCBJbnRSZWN0JiBrZWVw UmVjdCkKK3sKKyAgICBGbG9hdFJlY3Qga2VlcFJlY3RGID0ga2VlcFJlY3Q7CisKKyAgICBWZWN0 b3I8VGlsZTo6Q29vcmRpbmF0ZT4gdG9SZW1vdmU7CisgICAgVGlsZU1hcDo6aXRlcmF0b3IgZW5k ID0gbV90aWxlcy5lbmQoKTsKKyAgICBmb3IgKFRpbGVNYXA6Oml0ZXJhdG9yIGl0ID0gbV90aWxl cy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgVGlsZTo6Q29vcmRpbmF0ZSBj b29yZGluYXRlID0gaXQtPnNlY29uZC0+Y29vcmRpbmF0ZSgpOworICAgICAgICBGbG9hdFJlY3Qg dGlsZVJlY3QgPSBpdC0+c2Vjb25kLT5yZWN0KCk7CisgICAgICAgIGlmICghdGlsZVJlY3QuaW50 ZXJzZWN0cyhrZWVwUmVjdEYpKQorICAgICAgICAgICAgdG9SZW1vdmUuYXBwZW5kKGNvb3JkaW5h dGUpOworICAgIH0KKyAgICB1bnNpZ25lZCByZW1vdmVDb3VudCA9IHRvUmVtb3ZlLnNpemUoKTsK KyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgcmVtb3ZlQ291bnQ7ICsrbikKKyAgICAgICAg cmVtb3ZlVGlsZSh0b1JlbW92ZVtuXSk7Cit9CisKK1Bhc3NSZWZQdHI8VGlsZT4gVGlsZWRCYWNr aW5nU3RvcmU6OnRpbGVBdChjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRlKSBjb25z dAoreworICAgIHJldHVybiBtX3RpbGVzLmdldChjb29yZGluYXRlKTsKK30KKwordm9pZCBUaWxl ZEJhY2tpbmdTdG9yZTo6c2V0VGlsZShjb25zdCBUaWxlOjpDb29yZGluYXRlJiBjb29yZGluYXRl LCBQYXNzUmVmUHRyPFRpbGU+IHRpbGUpCit7CisgICAgbV90aWxlcy5zZXQoY29vcmRpbmF0ZSwg dGlsZSk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnJlbW92ZVRpbGUoY29uc3QgVGls ZTo6Q29vcmRpbmF0ZSYgY29vcmRpbmF0ZSkKK3sKKyAgICBtX3RpbGVzLnJlbW92ZShjb29yZGlu YXRlKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9yZTo6bWFwVG9Db250ZW50cyhjb25z dCBJbnRSZWN0JiByZWN0KSBjb25zdAoreworICAgIHJldHVybiBlbmNsb3NpbmdJbnRSZWN0KEZs b2F0UmVjdChyZWN0LngoKSAvIG1fY29udGVudHNTY2FsZSwKKyAgICAgICAgcmVjdC55KCkgLyBt X2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3Qud2lkdGgoKSAvIG1fY29udGVudHNTY2FsZSwK KyAgICAgICAgcmVjdC5oZWlnaHQoKSAvIG1fY29udGVudHNTY2FsZSkpOworfQorCitJbnRSZWN0 IFRpbGVkQmFja2luZ1N0b3JlOjptYXBGcm9tQ29udGVudHMoY29uc3QgSW50UmVjdCYgcmVjdCkg Y29uc3QKK3sKKyAgICByZXR1cm4gZW5jbG9zaW5nSW50UmVjdChGbG9hdFJlY3QocmVjdC54KCkg KiBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QueSgpICogbV9jb250ZW50c1NjYWxlLAor ICAgICAgICByZWN0LndpZHRoKCkgKiBtX2NvbnRlbnRzU2NhbGUsCisgICAgICAgIHJlY3QuaGVp Z2h0KCkgKiBtX2NvbnRlbnRzU2NhbGUpKTsKK30KKworSW50UmVjdCBUaWxlZEJhY2tpbmdTdG9y ZTo6Y29udGVudHNSZWN0KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbWFwRnJvbUNvbnRlbnRzKG1f Y2xpZW50LT50aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpKTsKK30KKworSW50UmVjdCBU aWxlZEJhY2tpbmdTdG9yZTo6dGlsZVJlY3RGb3JDb29yZGluYXRlKGNvbnN0IFRpbGU6OkNvb3Jk aW5hdGUmIGNvb3JkaW5hdGUpIGNvbnN0Cit7CisgICAgSW50UmVjdCByZWN0KGNvb3JkaW5hdGUu eCgpICogbV90aWxlU2l6ZS53aWR0aCgpLAorICAgICAgICBjb29yZGluYXRlLnkoKSAqIG1fdGls ZVNpemUuaGVpZ2h0KCksCisgICAgICAgIG1fdGlsZVNpemUud2lkdGgoKSwKKyAgICAgICAgbV90 aWxlU2l6ZS5oZWlnaHQoKSk7CisKKyAgICByZWN0LmludGVyc2VjdChjb250ZW50c1JlY3QoKSk7 CisgICAgcmV0dXJuIHJlY3Q7Cit9CisgICAgCitUaWxlOjpDb29yZGluYXRlIFRpbGVkQmFja2lu Z1N0b3JlOjp0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNvbnN0IEludFBvaW50JiBwb2ludCkgY29u c3QKK3sKKyAgICBpbnQgeCA9IHBvaW50LngoKSAvIG1fdGlsZVNpemUud2lkdGgoKTsKKyAgICBp bnQgeSA9IHBvaW50LnkoKSAvIG1fdGlsZVNpemUuaGVpZ2h0KCk7CisgICAgcmV0dXJuIFRpbGU6 OkNvb3JkaW5hdGUoc3RkOjptYXgoeCwgMCksIHN0ZDo6bWF4KHksIDApKTsKK30KKworCit2b2lk IFRpbGVkQmFja2luZ1N0b3JlOjpzdGFydFRpbGVCdWZmZXJVcGRhdGVUaW1lcigpCit7CisgICAg aWYgKG1fdGlsZUJ1ZmZlclVwZGF0ZVRpbWVyLT5pc0FjdGl2ZSgpIHx8IG1fY29udGVudHNGcm96 ZW4pCisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVCdWZmZXJVcGRhdGVUaW1lci0+c3RhcnRP bmVTaG90KDApOworfQorCit2b2lkIFRpbGVkQmFja2luZ1N0b3JlOjp0aWxlQnVmZmVyVXBkYXRl VGltZXJGaXJlZChUaWxlVGltZXIqKQoreworICAgIHVwZGF0ZVRpbGVCdWZmZXJzKCk7Cit9CisK K3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnN0YXJ0VGlsZUNyZWF0aW9uVGltZXIoKQoreworICAg IGlmIChtX3RpbGVDcmVhdGlvblRpbWVyLT5pc0FjdGl2ZSgpIHx8IG1fY29udGVudHNGcm96ZW4p CisgICAgICAgIHJldHVybjsKKyAgICBtX3RpbGVDcmVhdGlvblRpbWVyLT5zdGFydE9uZVNob3Qo MCk7Cit9CisKK3ZvaWQgVGlsZWRCYWNraW5nU3RvcmU6OnRpbGVDcmVhdGlvblRpbWVyRmlyZWQo VGlsZVRpbWVyKikKK3sKKyAgICBjcmVhdGVUaWxlcygpOworfQorCit2b2lkIFRpbGVkQmFja2lu Z1N0b3JlOjpzZXRDb250ZW50c0Zyb3plbihib29sIGZyZWV6ZSkKK3sKKyAgICBpZiAobV9jb250 ZW50c0Zyb3plbiA9PSBmcmVlemUpCisgICAgICAgIHJldHVybjsKKworICAgIG1fY29udGVudHNG cm96ZW4gPSBmcmVlemU7CisKKyAgICAvLyBSZXN0YXJ0IHRoZSB0aW1lcnMuIFRoZXJlIG1pZ2h0 IGJlIHBlbmRpbmcgaW52YWxpZGF0aW9ucyB0aGF0CisgICAgLy8gd2VyZSBub3QgcGFpbnRlZCBv ciBjcmVhdGVkIGJlY2F1c2UgdGlsZXMgYXJlIG5vdCBjcmVhdGVkIG9yCisgICAgLy8gcGFpbnRl ZCB3aGVuIGluIGZyb3plbiBzdGF0ZS4KKyAgICBpZiAoIW1fY29udGVudHNGcm96ZW4pIHsKKyAg ICAgICAgc3RhcnRUaWxlQ3JlYXRpb25UaW1lcigpOworICAgICAgICBzdGFydFRpbGVCdWZmZXJV cGRhdGVUaW1lcigpOworICAgIH0KKyAgICAvLyBzdG9wcGluZyBpcyBoYW5kbGVkIHdoZW4gdGhl IHRpbWVycyBmaXJlCit9CisKK30KKworI2VuZGlmCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9UaWxlZEJhY2tpbmdTdG9yZS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDEwNyBAQAorLyoKKyBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5k L29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgCisgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor IAorIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAKKyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUg dG8KKyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLAorIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNp Zm5kZWYgVGlsZWRCYWNraW5nU3RvcmVfaAorI2RlZmluZSBUaWxlZEJhY2tpbmdTdG9yZV9oCisK KyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKKworI2luY2x1ZGUgIkZsb2F0U2l6ZS5o IgorI2luY2x1ZGUgIkludFBvaW50LmgiCisjaW5jbHVkZSAiSW50UmVjdC5oIgorI2luY2x1ZGUg IlRpbGUuaCIKKyNpbmNsdWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+ CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgVGlsZWRC YWNraW5nU3RvcmVDbGllbnQ7CisKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlIDogcHVibGljIE5v bmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBUaWxlZEJhY2tpbmdTdG9yZShUaWxlZEJhY2tpbmdT dG9yZUNsaWVudCopOworICAgIH5UaWxlZEJhY2tpbmdTdG9yZSgpOworCisgICAgdm9pZCB2aWV3 cG9ydENoYW5nZWQoY29uc3QgSW50UmVjdCYgdmlld3BvcnRSZWN0KTsKKyAgICAKKyAgICBmbG9h dCBjb250ZW50c1NjYWxlKCkgeyByZXR1cm4gbV9jb250ZW50c1NjYWxlOyB9CisgICAgdm9pZCBz ZXRDb250ZW50c1NjYWxlKGZsb2F0KTsKKyAgICAKKyAgICBib29sIGNvbnRlbnRzRnJvemVuKCkg Y29uc3QgeyByZXR1cm4gbV9jb250ZW50c0Zyb3plbjsgfQorICAgIHZvaWQgc2V0Q29udGVudHNG cm96ZW4oYm9vbCk7CisKKyAgICB2b2lkIGludmFsaWRhdGUoY29uc3QgSW50UmVjdCYgZGlydHlS ZWN0KTsKKyAgICB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsK KworcHJpdmF0ZToKKyAgICB2b2lkIHN0YXJ0VGlsZUJ1ZmZlclVwZGF0ZVRpbWVyKCk7CisgICAg dm9pZCBzdGFydFRpbGVDcmVhdGlvblRpbWVyKCk7CisgICAgCisgICAgdHlwZWRlZiBUaW1lcjxU aWxlZEJhY2tpbmdTdG9yZT4gVGlsZVRpbWVyOworCisgICAgdm9pZCB0aWxlQnVmZmVyVXBkYXRl VGltZXJGaXJlZChUaWxlVGltZXIqKTsKKyAgICB2b2lkIHRpbGVDcmVhdGlvblRpbWVyRmlyZWQo VGlsZVRpbWVyKik7CisgICAgCisgICAgdm9pZCB1cGRhdGVUaWxlQnVmZmVycygpOworICAgIHZv aWQgY3JlYXRlVGlsZXMoKTsKKworICAgIHZvaWQgZHJvcE92ZXJoYW5naW5nVGlsZXMoKTsKKyAg ICB2b2lkIGRyb3BUaWxlc091dHNpZGVSZWN0KGNvbnN0IEludFJlY3QmKTsKKyAgICAKKyAgICBQ YXNzUmVmUHRyPFRpbGU+IHRpbGVBdChjb25zdCBUaWxlOjpDb29yZGluYXRlJikgY29uc3Q7Cisg ICAgdm9pZCBzZXRUaWxlKGNvbnN0IFRpbGU6OkNvb3JkaW5hdGUmIGNvb3JkaW5hdGUsIFBhc3NS ZWZQdHI8VGlsZT4gdGlsZSk7CisgICAgdm9pZCByZW1vdmVUaWxlKGNvbnN0IFRpbGU6OkNvb3Jk aW5hdGUmIGNvb3JkaW5hdGUpOworCisgICAgSW50UmVjdCBtYXBUb0NvbnRlbnRzKGNvbnN0IElu dFJlY3QmKSBjb25zdDsKKyAgICBJbnRSZWN0IG1hcEZyb21Db250ZW50cyhjb25zdCBJbnRSZWN0 JikgY29uc3Q7CisgICAgCisgICAgSW50UmVjdCBjb250ZW50c1JlY3QoKSBjb25zdDsKKyAgICAK KyAgICBJbnRSZWN0IHRpbGVSZWN0Rm9yQ29vcmRpbmF0ZShjb25zdCBUaWxlOjpDb29yZGluYXRl JikgY29uc3Q7CisgICAgVGlsZTo6Q29vcmRpbmF0ZSB0aWxlQ29vcmRpbmF0ZUZvclBvaW50KGNv bnN0IEludFBvaW50JikgY29uc3Q7CisgICAgZG91YmxlIHRpbGVEaXN0YW5jZShjb25zdCBJbnRS ZWN0JiB2aWV3cG9ydCwgY29uc3QgVGlsZTo6Q29vcmRpbmF0ZSYpOworICAgIAorICAgIHZvaWQg cGFpbnRDaGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0JiwgY29u c3QgVGlsZTo6Q29vcmRpbmF0ZSYpOworCitwcml2YXRlOgorICAgIFRpbGVkQmFja2luZ1N0b3Jl Q2xpZW50KiBtX2NsaWVudDsKKworICAgIHR5cGVkZWYgSGFzaE1hcDxUaWxlOjpDb29yZGluYXRl LCBSZWZQdHI8VGlsZT4gPiBUaWxlTWFwOworICAgIFRpbGVNYXAgbV90aWxlczsKKworICAgIFRp bGVUaW1lciogbV90aWxlQnVmZmVyVXBkYXRlVGltZXI7CisgICAgVGlsZVRpbWVyKiBtX3RpbGVD cmVhdGlvblRpbWVyOworCisgICAgSW50U2l6ZSBtX3RpbGVTaXplOworICAgIAorICAgIEludFJl Y3QgbV92aWV3cG9ydDsKKyAgICBmbG9hdCBtX2NvbnRlbnRzU2NhbGU7CisKKyAgICBib29sIG1f Y29udGVudHNGcm96ZW47CisKKyAgICBmcmllbmQgY2xhc3MgVGlsZTsKK307CisKK30KKworI2Vu ZGlmCisjZW5kaWYKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvVGlsZWRCYWNraW5n U3RvcmVDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Rp bGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1RpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNDAgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9v ciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAK KyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZu ZGVmIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50X2gKKyNkZWZpbmUgVGlsZWRCYWNraW5nU3RvcmVD bGllbnRfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lO R19TVE9SRSkKK2NsYXNzIFRpbGVkQmFja2luZ1N0b3JlQ2xpZW50IHsKK3B1YmxpYzoKKyAgICB2 aXJ0dWFsIHZvaWQgdGlsZWRCYWNraW5nU3RvcmVQYWludEJlZ2luKCkgPSAwOworICAgIHZpcnR1 YWwgdm9pZCB0aWxlZEJhY2tpbmdTdG9yZVBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IElu dFJlY3QmKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHRpbGVkQmFja2luZ1N0b3JlUGFpbnRFbmQo Y29uc3QgVmVjdG9yPEludFJlY3Q+JiBwYWludGVkQXJlYSkgPSAwOworICAgIHZpcnR1YWwgSW50 UmVjdCB0aWxlZEJhY2tpbmdTdG9yZUNvbnRlbnRzUmVjdCgpID0gMDsKK307CisKKyNlbHNlCitj bGFzcyBUaWxlZEJhY2tpbmdTdG9yZUNsaWVudCB7fTsKKyNlbmRpZgorCit9CisKKyNlbmRpZgpJ bmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9xdC9UaWxlUXQuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvcXQvVGlsZVF0LmNwcAkocmV2aXNpb24gMCkK KysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvcXQvVGlsZVF0LmNwcAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwxODIgQEAKKy8qCisgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0 aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIAorIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyBtb2RpZnkgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAKKyBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVGlsZS5oIgorCisjaWYgRU5BQkxF KFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNp bmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3Jl Q2xpZW50LmgiCisjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgorI2luY2x1ZGUgPFFCYXNpY1RpbWVy PgorI2luY2x1ZGUgPFFEZWJ1Zz4KKyNpbmNsdWRlIDxRSW1hZ2U+CisjaW5jbHVkZSA8UU9iamVj dD4KKyNpbmNsdWRlIDxRUGFpbnRlcj4KKyNpbmNsdWRlIDxRUmVnaW9uPgorI2luY2x1ZGUgPFFU aHJlYWQ+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBjaGVja2VyU2l6ZSA9IDE2Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjEg PSAweGZmNTU1NTU1Oworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoZWNrZXJDb2xvcjIgPSAweGZm YWFhYWFhOworICAgIAorc3RhdGljIFFQaXhtYXAmIGNoZWNrZXJlZFBpeG1hcCgpCit7CisgICAg c3RhdGljIFFQaXhtYXAqIHBpeG1hcDsKKyAgICBpZiAoIXBpeG1hcCkgeworICAgICAgICBwaXht YXAgPSBuZXcgUVBpeG1hcChjaGVja2VyU2l6ZSwgY2hlY2tlclNpemUpOworICAgICAgICBRUGFp bnRlciBwYWludGVyKHBpeG1hcCk7CisgICAgICAgIFFDb2xvciBjb2xvcjEoY2hlY2tlckNvbG9y MSk7CisgICAgICAgIFFDb2xvciBjb2xvcjIoY2hlY2tlckNvbG9yMik7CisgICAgICAgIGZvciAo dW5zaWduZWQgeSA9IDA7IHkgPCBjaGVja2VyU2l6ZTsgeSArPSBjaGVja2VyU2l6ZSAvIDIpIHsK KyAgICAgICAgICAgIGJvb2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJTaXplOworICAgICAgICAg ICAgZm9yICh1bnNpZ25lZCB4ID0gMDsgeCA8IGNoZWNrZXJTaXplOyB4ICs9IGNoZWNrZXJTaXpl IC8gMikgeworICAgICAgICAgICAgICAgIHBhaW50ZXIuZmlsbFJlY3QoeCwgeSwgY2hlY2tlclNp emUgLyAyLCBjaGVja2VyU2l6ZSAvIDIsIGFsdGVybmF0ZSA/IGNvbG9yMSA6IGNvbG9yMik7Cisg ICAgICAgICAgICAgICAgYWx0ZXJuYXRlID0gIWFsdGVybmF0ZTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorICAgIH0KKyAgICByZXR1cm4gKnBpeG1hcDsKK30KKyAgICAKK1RpbGU6OlRpbGUo VGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRpbmF0ZSYgdGlsZUNv b3JkaW5hdGUpCisgICAgOiBtX2JhY2tpbmdTdG9yZShiYWNraW5nU3RvcmUpCisgICAgLCBtX2Nv b3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpCisgICAgLCBtX3JlY3QobV9iYWNraW5nU3RvcmUtPnRp bGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpCisgICAgLCBtX2J1ZmZlcigwKQor ICAgICwgbV9iYWNrQnVmZmVyKDApCisgICAgLCBtX2RpcnR5UmVnaW9uKG5ldyBRUmVnaW9uKG1f cmVjdCkpCit7Cit9CisKK1RpbGU6On5UaWxlKCkKK3sKKyAgICBkZWxldGUgbV9idWZmZXI7Cisg ICAgZGVsZXRlIG1fYmFja0J1ZmZlcjsKKyAgICBkZWxldGUgbV9kaXJ0eVJlZ2lvbjsKK30KKwor Ym9vbCBUaWxlOjppc0RpcnR5KCkgY29uc3QgCit7IAorICAgIHJldHVybiAhbV9kaXJ0eVJlZ2lv bi0+aXNFbXB0eSgpOyAKK30KKworYm9vbCBUaWxlOjppc1JlYWR5VG9QYWludCgpIGNvbnN0Cit7 IAorICAgIHJldHVybiBtX2J1ZmZlcjsgCit9CisKK3ZvaWQgVGlsZTo6aW52YWxpZGF0ZShjb25z dCBJbnRSZWN0JiBkaXJ0eVJlY3QpCit7CisgICAgSW50UmVjdCB0aWxlRGlydHlSZWN0ID0gaW50 ZXJzZWN0aW9uKGRpcnR5UmVjdCwgbV9yZWN0KTsKKyAgICBpZiAodGlsZURpcnR5UmVjdC5pc0Vt cHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgICptX2RpcnR5UmVnaW9uICs9IHRpbGVEaXJ0 eVJlY3Q7Cit9CisgICAgCit2b2lkIFRpbGU6OnVwZGF0ZUJhY2tCdWZmZXIoKQoreworICAgIGlm IChtX2J1ZmZlciAmJiAhaXNEaXJ0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1f YmFja0J1ZmZlcikgeworICAgICAgICBpZiAoIW1fYnVmZmVyKQorICAgICAgICAgICAgbV9iYWNr QnVmZmVyID0gbmV3IFFQaXhtYXAobV9iYWNraW5nU3RvcmUtPm1fdGlsZVNpemUud2lkdGgoKSwg bV9iYWNraW5nU3RvcmUtPm1fdGlsZVNpemUuaGVpZ2h0KCkpOworICAgICAgICBlbHNlIHsKKyAg ICAgICAgICAgIC8vIEN1cnJlbnRseSBhbGwgYnVmZmVycyBhcmUgdXBkYXRlZCBzeW5jaHJvbm91 c2x5IGF0IHRoZSBzYW1lIHRpbWUgc28gdGhlcmUgaXMgbm8gcmVhbCBuZWVkCisgICAgICAgICAg ICAvLyB0byBoYXZlIHNlcGFyYXRlIGJhY2sgYW5kIGZyb250IGJ1ZmZlcnMuIEp1c3QgdXNlIHRo ZSBleGlzdGluZyBidWZmZXIuCisgICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBtX2J1ZmZlcjsK KyAgICAgICAgICAgIG1fYnVmZmVyID0gMDsKKyAgICAgICAgfQorICAgIH0KKworICAgIFFWZWN0 b3I8UVJlY3Q+IGRpcnR5UmVjdHMgPSBtX2RpcnR5UmVnaW9uLT5yZWN0cygpOworICAgICptX2Rp cnR5UmVnaW9uID0gUVJlZ2lvbigpOworICAgIAorICAgIFFQYWludGVyIHBhaW50ZXIobV9iYWNr QnVmZmVyKTsKKyAgICBHcmFwaGljc0NvbnRleHQgY29udGV4dCgmcGFpbnRlcik7CisgICAgY29u dGV4dC50cmFuc2xhdGUoLW1fcmVjdC54KCksIC1tX3JlY3QueSgpKTsKKworICAgIGludCBzaXpl ID0gZGlydHlSZWN0cy5zaXplKCk7CisgICAgZm9yIChpbnQgbiA9IDA7IG4gPCBzaXplOyArK24p ICB7CisgICAgICAgIGNvbnRleHQuc2F2ZSgpOworICAgICAgICBJbnRSZWN0IHJlY3QgPSBkaXJ0 eVJlY3RzW25dOworICAgICAgICBjb250ZXh0LmNsaXAoRmxvYXRSZWN0KHJlY3QpKTsKKyAgICAg ICAgY29udGV4dC5zY2FsZShGbG9hdFNpemUobV9iYWNraW5nU3RvcmUtPm1fY29udGVudHNTY2Fs ZSwgbV9iYWNraW5nU3RvcmUtPm1fY29udGVudHNTY2FsZSkpOworICAgICAgICBtX2JhY2tpbmdT dG9yZS0+bV9jbGllbnQtPnRpbGVkQmFja2luZ1N0b3JlUGFpbnQoJmNvbnRleHQsIG1fYmFja2lu Z1N0b3JlLT5tYXBUb0NvbnRlbnRzKHJlY3QpKTsKKyAgICAgICAgY29udGV4dC5yZXN0b3JlKCk7 CisgICAgfQorfQorCit2b2lkIFRpbGU6OnN3YXBCYWNrQnVmZmVyVG9Gcm9udCgpCit7CisgICAg aWYgKCFtX2JhY2tCdWZmZXIpCisgICAgICAgIHJldHVybjsKKyAgICBkZWxldGUgbV9idWZmZXI7 CisgICAgbV9idWZmZXIgPSBtX2JhY2tCdWZmZXI7CisgICAgbV9iYWNrQnVmZmVyID0gMDsKK30K Kwordm9pZCBUaWxlOjpwYWludChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJl Y3QmIHJlY3QpCit7CisgICAgaWYgKCFtX2J1ZmZlcikKKyAgICAgICAgcmV0dXJuOworICAgIAor ICAgIEludFJlY3QgdGFyZ2V0ID0gaW50ZXJzZWN0aW9uKHJlY3QsIG1fcmVjdCk7CisgICAgSW50 UmVjdCBzb3VyY2UoKHRhcmdldC54KCkgLSBtX3JlY3QueCgpKSwKKyAgICAgICAgICAgICAgICAg ICAodGFyZ2V0LnkoKSAtIG1fcmVjdC55KCkpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC53 aWR0aCgpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC5oZWlnaHQoKSk7CisgICAgCisgICAg Y29udGV4dC0+cGxhdGZvcm1Db250ZXh0KCktPmRyYXdQaXhtYXAodGFyZ2V0LCAqbV9idWZmZXIs IHNvdXJjZSk7Cit9CisgICAgCit2b2lkIFRpbGU6OnBhaW50Q2hlY2tlclBhdHRlcm4oR3JhcGhp Y3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBGbG9hdFJlY3QmIHRhcmdldCkKK3sKKyAgICBRUGFp bnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOworICAgIFFUcmFuc2Zv cm0gd29ybGRUcmFuc2Zvcm0gPSBwYWludGVyLT53b3JsZFRyYW5zZm9ybSgpOworICAgIHFyZWFs IHNjYWxlWCA9IHdvcmxkVHJhbnNmb3JtLm0xMSgpOworICAgIHFyZWFsIHNjYWxlWSA9IHdvcmxk VHJhbnNmb3JtLm0yMigpOworICAgIAorICAgIFFSZWN0IHRhcmdldFZpZXdSZWN0ID0gUVJlY3RG KHRhcmdldC54KCkgKiBzY2FsZVgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg dGFyZ2V0LnkoKSAqIHNjYWxlWSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0 YXJnZXQud2lkdGgoKSAqIHNjYWxlWCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0YXJnZXQuaGVpZ2h0KCkgKiBzY2FsZVkpLnRvQWxpZ25lZFJlY3QoKTsKKyAgICAKKyAgICBR VHJhbnNmb3JtIGFkanVzdGVkVHJhbnNmb3JtKDEuLCB3b3JsZFRyYW5zZm9ybS5tMTIoKSwgd29y bGRUcmFuc2Zvcm0ubTEzKCksCisgICAgICAgICAgICAgICAgICB3b3JsZFRyYW5zZm9ybS5tMjEo KSwgMS4sIHdvcmxkVHJhbnNmb3JtLm0yMygpLAorICAgICAgICAgICAgICAgICAgd29ybGRUcmFu c2Zvcm0ubTMxKCksIHdvcmxkVHJhbnNmb3JtLm0zMigpLCB3b3JsZFRyYW5zZm9ybS5tMzMoKSk7 CisgICAgcGFpbnRlci0+c2V0V29ybGRUcmFuc2Zvcm0oYWRqdXN0ZWRUcmFuc2Zvcm0pOworICAg IAorICAgIHBhaW50ZXItPmRyYXdUaWxlZFBpeG1hcCh0YXJnZXRWaWV3UmVjdCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY2hlY2tlcmVkUGl4bWFwKCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFFQb2ludCh0YXJnZXRWaWV3UmVjdC5sZWZ0KCkgJSBjaGVja2VyU2l6ZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldFZpZXdSZWN0LnRvcCgp ICUgY2hlY2tlclNpemUpKTsKKyAgICAKKyAgICBwYWludGVyLT5zZXRXb3JsZFRyYW5zZm9ybSh3 b3JsZFRyYW5zZm9ybSk7Cit9CisKK30KKworI2VuZGlmCg== 50032 2010-03-04 09:53:23 -0800 2010-03-10 23:33:24 -0800 QtWebKit patch tiled-backing-store-qtwebit-10.patch text/plain 14711 koivisto SW5kZXg6IFdlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L3F0L0FwaS9xZ3JhcGhpY3N3ZWJ2aWV3LmNwcAkocmV2aXNpb24gNTU0NTkpCisrKyBX ZWJLaXQvcXQvQXBpL3FncmFwaGljc3dlYnZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw3 ICsyNiwxMCBAQAogI2luY2x1ZGUgInF3ZWJwYWdlLmgiCiAjaW5jbHVkZSAicXdlYnBhZ2VfcC5o IgogI2luY2x1ZGUgIlFXZWJQYWdlQ2xpZW50LmgiCi0jaW5jbHVkZSA8RnJhbWVWaWV3Lmg+Cisj aW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCisjaW5j bHVkZSAiSW50UmVjdC5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCiAjaW5jbHVk ZSA8UXRDb3JlL3FtZXRhb2JqZWN0Lmg+CiAjaW5jbHVkZSA8UXRDb3JlL3FzaGFyZWRwb2ludGVy Lmg+CiAjaW5jbHVkZSA8UXRDb3JlL3F0aW1lci5oPgpAQCAtMzUsNiArMzgsNyBAQAogI2luY2x1 ZGUgPFF0R3VpL3FncmFwaGljc3NjZW5lZXZlbnQuaD4KICNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhp Y3N2aWV3Lmg+CiAjaW5jbHVkZSA8UXRHdWkvcXBpeG1hcGNhY2hlLmg+CisjaW5jbHVkZSA8UXRH dWkvcXNjcm9sbGJhci5oPgogI2luY2x1ZGUgPFF0R3VpL3FzdHlsZW9wdGlvbi5oPgogI2lmIGRl ZmluZWQoUV9XU19YMTEpCiAjaW5jbHVkZSA8UVgxMUluZm8+CkBAIC0xMjAsNiArMTI0LDcgQEAg cHVibGljOgogI2VuZGlmCiAgICAgCiAgICAgdm9pZCB1cGRhdGVSZXNpemVzVG9Db250ZW50c0Zv clBhZ2UoKTsKKyAgICBRUmVjdEYgdmlzaWJsZVJlY3QoKSBjb25zdDsKIAogICAgIHZvaWQgc3lu Y0xheWVycygpOwogICAgIHZvaWQgX3FfZG9Mb2FkRmluaXNoZWQoYm9vbCBzdWNjZXNzKTsKQEAg LTM0MCw2ICszNDUsMjMgQEAgdm9pZCBRR3JhcGhpY3NXZWJWaWV3UHJpdmF0ZTo6X3FfY29udGVu dAogICAgIHEtPnNldEdlb21ldHJ5KFFSZWN0RihxLT5nZW9tZXRyeSgpLnRvcExlZnQoKSwgc2l6 ZSkpOwogfQogCitRUmVjdEYgUUdyYXBoaWNzV2ViVmlld1ByaXZhdGU6OnZpc2libGVSZWN0KCkg Y29uc3QKK3sKKyAgICBpZiAoIXEtPnNjZW5lKCkpCisgICAgICAgIHJldHVybiBRUmVjdEYoKTsK KyAgICBRTGlzdDxRR3JhcGhpY3NWaWV3Kj4gdmlld3MgPSBxLT5zY2VuZSgpLT52aWV3cygpOwor ICAgIGlmICh2aWV3cy5zaXplKCkgPiAxKSB7CisgICAgICAgIHFEZWJ1ZygpIDw8ICJRR3JhcGhp Y3NXZWJWaWV3IGlzIGluIG1vcmUgdGhhbiBvbmUgZ3JhcGhpY3Mgdmlld3MsIHVuYWJsZSB0byBj b21wdXRlIHRoZSB2aXNpYmxlIHJlY3QiOworICAgICAgICByZXR1cm4gUVJlY3RGKCk7CisgICAg fQorICAgIGlmICh2aWV3cy5zaXplKCkgPCAxKQorICAgICAgICByZXR1cm4gUVJlY3RGKCk7CisK KyAgICBpbnQgaCA9IHZpZXdzWzBdLT5ob3Jpem9udGFsU2Nyb2xsQmFyKCktPnZhbHVlKCk7Cisg ICAgaW50IHYgPSB2aWV3c1swXS0+dmVydGljYWxTY3JvbGxCYXIoKS0+dmFsdWUoKTsKKyAgICBy ZXR1cm4gcS0+bWFwUmVjdEZyb21TY2VuZShRUmVjdEYoUVBvaW50KGgsIHYpLCB2aWV3c1swXS0+ dmlld3BvcnQoKS0+c2l6ZSgpKSk7Cit9CisKIC8qIQogICAgIFxjbGFzcyBRR3JhcGhpY3NXZWJW aWV3CiAgICAgXGJyaWVmIFRoZSBRR3JhcGhpY3NXZWJWaWV3IGNsYXNzIGFsbG93cyBXZWIgY29u dGVudCB0byBiZSBhZGRlZCB0byBhIEdyYXBoaWNzVmlldy4KQEAgLTQ4Miw2ICs1MDQsMTggQEAg UVdlYlBhZ2UqIFFHcmFwaGljc1dlYlZpZXc6OnBhZ2UoKSBjb25zdAogKi8KIHZvaWQgUUdyYXBo aWNzV2ViVmlldzo6cGFpbnQoUVBhaW50ZXIqIHBhaW50ZXIsIGNvbnN0IFFTdHlsZU9wdGlvbkdy YXBoaWNzSXRlbSogb3B0aW9uLCBRV2lkZ2V0KikKIHsKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lO R19TVE9SRSkKKyAgICAvLyBGSVhNRTogU2Nyb2xsYmFycyBjb3VsZCBiZSBkcmF3biB3aXRoIHRo ZSBvdmVybGF5IGxheWVyIHdoZW4gdXNpbmcgdGlsaW5nLgorICAgIFdlYkNvcmU6OlRpbGVkQmFj a2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBRV2ViRnJhbWVQcml2YXRlOjpjb3JlKHBhZ2UoKS0+ bWFpbkZyYW1lKCkpLT50aWxlZEJhY2tpbmdTdG9yZSgpOzsKKyAgICBpZiAoYmFja2luZ1N0b3Jl KSB7CisgICAgICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgc2V0IHRoZSBiYWNraW5nIHN0b3JlIHZp ZXdwYXJ0IGVhcmxpZXIgdGhhbiBpbiBwYWludC4KKyAgICAgICAgYmFja2luZ1N0b3JlLT52aWV3 cG9ydENoYW5nZWQoV2ViQ29yZTo6SW50UmVjdChkLT52aXNpYmxlUmVjdCgpKSk7CisgICAgICAg IC8vIFFXZWJGcmFtZTo6cmVuZGVyIGlzIGEgcHVibGljIEFQSSwgYnlwYXNzIGl0IGZvciB0aWxl ZCByZW5kZXJpbmcgc28gYmVoYXZpb3IgZG9lcyBub3QgbmVlZCB0byBjaGFuZ2UuCisgICAgICAg IFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dCBjb250ZXh0KHBhaW50ZXIpOyAKKyAgICAgICAgcGFn ZSgpLT5tYWluRnJhbWUoKS0+ZC0+cmVuZGVyQ29udGVudHNMYXllckFic29sdXRlQ29vcmRzKCZj b250ZXh0LCBvcHRpb24tPmV4cG9zZWRSZWN0LnRvQWxpZ25lZFJlY3QoKSk7CisgICAgICAgIHJl dHVybjsKKyAgICB9IAorI2VuZGlmCiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQog ICAgIHBhZ2UoKS0+bWFpbkZyYW1lKCktPnJlbmRlcihwYWludGVyLCBkLT5vdmVybGF5ID8gUVdl YkZyYW1lOjpDb250ZW50c0xheWVyIDogUVdlYkZyYW1lOjpBbGxMYXllcnMsIG9wdGlvbi0+ZXhw b3NlZFJlY3QudG9BbGlnbmVkUmVjdCgpKTsKICNlbHNlCkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3 ZWJmcmFtZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCShy ZXZpc2lvbiA1NTQ1OSkKKysrIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNTgsNiArNTgsNyBAQAogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIK ICNpbmNsdWRlICJTdWJzdGl0dXRlRGF0YS5oIgogI2luY2x1ZGUgIlNWR1NNSUxFbGVtZW50Lmgi CisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5o IgogI2luY2x1ZGUgIm1hcmt1cC5oIgogI2luY2x1ZGUgInF0X2luc3RhbmNlLmgiCkBAIC0zMzks NyArMzQwLDExIEBAIHZvaWQgUVdlYkZyYW1lUHJpdmF0ZTo6cmVuZGVyQ29udGVudHNMYXkKICAg ICBRUGFpbnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOwogCiAgICAg V2ViQ29yZTo6RnJhbWVWaWV3KiB2aWV3ID0gZnJhbWUtPnZpZXcoKTsKLSAgICB2aWV3LT5sYXlv dXRJZk5lZWRlZFJlY3Vyc2l2ZSgpOworICAgIAorI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NU T1JFKQorICAgIGlmICghZnJhbWUtPnRpbGVkQmFja2luZ1N0b3JlKCkpCisjZW5kaWYKKyAgICAg ICAgdmlldy0+bGF5b3V0SWZOZWVkZWRSZWN1cnNpdmUoKTsKIAogICAgIGZvciAoaW50IGkgPSAw OyBpIDwgdmVjdG9yLnNpemUoKTsgKytpKSB7CiAgICAgICAgIGNvbnN0IFFSZWN0JiBjbGlwUmVj dCA9IHZlY3Rvci5hdChpKTsKQEAgLTM0OCw3ICszNTMsMTIgQEAgdm9pZCBRV2ViRnJhbWVQcml2 YXRlOjpyZW5kZXJDb250ZW50c0xheQogICAgICAgICBwYWludGVyLT5zZXRDbGlwUmVjdChjbGlw UmVjdCwgUXQ6OkludGVyc2VjdENsaXApOwogCiAgICAgICAgIGNvbnRleHQtPnNhdmUoKTsKLSAg ICAgICAgdmlldy0+cGFpbnRDb250ZW50cyhjb250ZXh0LCBjbGlwUmVjdCk7CisjaWYgRU5BQkxF KFRJTEVEX0JBQ0tJTkdfU1RPUkUpCisgICAgICAgIGlmIChmcmFtZS0+dGlsZWRCYWNraW5nU3Rv cmUoKSkKKyAgICAgICAgICAgIGZyYW1lLT50aWxlZEJhY2tpbmdTdG9yZSgpLT5wYWludChjb250 ZXh0LCBjbGlwUmVjdCk7CisgICAgICAgIGVsc2UKKyNlbmRpZgorICAgICAgICAgICAgdmlldy0+ cGFpbnRDb250ZW50cyhjb250ZXh0LCBjbGlwUmVjdCk7CiAgICAgICAgIGNvbnRleHQtPnJlc3Rv cmUoKTsKIAogICAgICAgICBwYWludGVyLT5yZXN0b3JlKCk7CkluZGV4OiBXZWJLaXQvcXQvQXBp L3F3ZWJmcmFtZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgJKHJl dmlzaW9uIDU1NDU5KQorKysgV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAkod29ya2luZyBjb3B5 KQpAQCAtMjIyLDYgKzIyMiw3IEBAIFFfU0lHTkFMUzoKICAgICB2b2lkIHBhZ2VDaGFuZ2VkKCk7 CiAKIHByaXZhdGU6CisgICAgZnJpZW5kIGNsYXNzIFFHcmFwaGljc1dlYlZpZXc7CiAgICAgZnJp ZW5kIGNsYXNzIFFXZWJQYWdlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViUGFnZVByaXZhdGU7CiAg ICAgZnJpZW5kIGNsYXNzIFFXZWJGcmFtZVByaXZhdGU7CkluZGV4OiBXZWJLaXQvcXQvQXBpL3F3 ZWJzZXR0aW5ncy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3Mu Y3BwCShyZXZpc2lvbiA1NTQ1OSkKKysrIFdlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMjM0LDYgKzIzNCwxMCBAQCB2b2lkIFFXZWJTZXR0aW5nc1ByaXZh dGU6OmFwcGx5KCkKICAgICAgICAgdmFsdWUgPSBhdHRyaWJ1dGVzLnZhbHVlKFFXZWJTZXR0aW5n czo6WFNTQXVkaXRvckVuYWJsZWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGdsb2JhbC0+YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlhTU0F1ZGl0b3JFbmFi bGVkKSk7CiAgICAgICAgIHNldHRpbmdzLT5zZXRYU1NBdWRpdG9yRW5hYmxlZCh2YWx1ZSk7Cisg ICAgICAgIAorICAgICAgICB2YWx1ZSA9IGF0dHJpYnV0ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpU aWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGdsb2JhbC0+YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlRpbGVkQmFja2lu Z1N0b3JlRW5hYmxlZCkpOworICAgICAgICBzZXR0aW5ncy0+c2V0VGlsZWRCYWNraW5nU3RvcmVF bmFibGVkKHZhbHVlKTsKIAogICAgICAgICBzZXR0aW5ncy0+c2V0VXNlc1BhZ2VDYWNoZShXZWJD b3JlOjpwYWdlQ2FjaGUoKS0+Y2FwYWNpdHkoKSk7CiAgICAgfSBlbHNlIHsKSW5kZXg6IFdlYktp dC9xdC9BcGkvcXdlYnNldHRpbmdzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0FwaS9xd2Vi c2V0dGluZ3MuaAkocmV2aXNpb24gNTU0NTkpCisrKyBXZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5n cy5oCSh3b3JraW5nIGNvcHkpCkBAIC03MSw2ICs3MSw3IEBAIHB1YmxpYzoKICAgICAgICAgRG5z UHJlZmV0Y2hFbmFibGVkLAogICAgICAgICBYU1NBdWRpdG9yRW5hYmxlZCwKICAgICAgICAgQWNj ZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQsCisgICAgICAgIFRpbGVkQmFja2luZ1N0b3JlRW5h YmxlZCwKICAgICAgICAgV2ViR0xFbmFibGVkCiAgICAgfTsKICAgICBlbnVtIFdlYkdyYXBoaWMg ewpJbmRleDogV2ViS2l0L3F0L1FHVkxhdW5jaGVyL21haW4uY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdC9xdC9RR1ZMYXVuY2hlci9tYWluLmNwcAkocmV2aXNpb24gNTQ3NzQpCisrKyBXZWJLaXQv cXQvUUdWTGF1bmNoZXIvbWFpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUwMCw3ICs1MDAsNyBA QCBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCiB7CiAgICAgUUFwcGxpY2F0aW9uIGFw cChhcmdjLCBhcmd2KTsKICAgICBpZiAoYXBwLmFyZ3VtZW50cygpLmNvbnRhaW5zKCItLWhlbHAi KSkgewotICAgICAgICBxRGVidWcoKSA8PCAiVXNhZ2U6IFFHVkxhdW5jaGVyIFstLXVybCB1cmxd IFstLWNvbXBvc2l0aW5nXSBbLS11cGRhdGVNb2RlIEZ1bGx8TWluaW1hbHxTbWFydHxOb3xCb3Vu ZGluZ1JlY3RdIFstLWNhY2hlV2ViVmlld10gWy0tcmVzaXplc1RvQ29udGVudHNdXG4iOworICAg ICAgICBxRGVidWcoKSA8PCAiVXNhZ2U6IFFHVkxhdW5jaGVyIFstLXVybCB1cmxdIFstLWNvbXBv c2l0aW5nXSBbLS11cGRhdGVNb2RlIEZ1bGx8TWluaW1hbHxTbWFydHxOb3xCb3VuZGluZ1JlY3Rd IFstLWNhY2hlV2ViVmlld10gWy0tcmVzaXplc1RvQ29udGVudHNdIFstLXRpbGVkQmFja2luZ1N0 b3JlXVxuIjsKICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogICAgIFFTdHJpbmcgdXJsID0gUVN0 cmluZygiZmlsZTovLyUxLyUyIikuYXJnKFFEaXI6OmhvbWVQYXRoKCkpLmFyZyhRTGF0aW4xU3Ry aW5nKCJpbmRleC5odG1sIikpOwpAQCAtNTIxLDYgKzUyMSwxMSBAQCBpbnQgbWFpbihpbnQgYXJn YywgY2hhcioqIGFyZ3YpCiAgICAgICAgIHVybCA9IGFyZ3MuYXQoMSk7CiAgICAgaWYgKGFyZ3Mu Y29udGFpbnMoIi0tY29tcG9zaXRpbmciKSkKICAgICAgICAgUVdlYlNldHRpbmdzOjpnbG9iYWxT ZXR0aW5ncygpLT5zZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpBY2NlbGVyYXRlZENvbXBvc2l0 aW5nRW5hYmxlZCwgdHJ1ZSk7CisgICAgaWYgKGFyZ3MuY29udGFpbnMoIi0tdGlsZWRCYWNraW5n U3RvcmUiKSkgeworICAgICAgICBpZiAoIWFyZ3MuY29udGFpbnMoIi0tcmVzaXplc1RvQ29udGVu dHMiKSkKKyAgICAgICAgICAgIHFEZWJ1ZygpIDw8ICJXYXJuaW5nOiBhdCB0aGUgbW9tZW50IC0t dGlsZWRCYWNraW5nU3RvcmUgc2hvdWxkIGFsd2F5cyBiZSB1c2VkIHRvZ2V0aGVyIHdpdGggLS1y ZXNpemVzVG9Db250ZW50cyI7CisgICAgICAgIFFXZWJTZXR0aW5nczo6Z2xvYmFsU2V0dGluZ3Mo KS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkLCB0 cnVlKTsKKyAgICB9CiAKICAgICBNYWluV2luZG93KiB3aW5kb3cgPSBuZXcgTWFpbldpbmRvdzsK ICAgICB3aW5kb3ctPmxvYWQodXJsKTsKSW5kZXg6IFdlYktpdFRvb2xzL1F0TGF1bmNoZXIvbWFp bi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvUXRMYXVuY2hlci9tYWluLmNwcAkocmV2 aXNpb24gNTU0NTkpCisrKyBXZWJLaXRUb29scy9RdExhdW5jaGVyL21haW4uY3BwCSh3b3JraW5n IGNvcHkpCkBAIC03Nyw2ICs3Nyw4IEBAIHN0YXRpYyBib29sIGdDYWNoZVdlYlZpZXcgPSBmYWxz ZTsKIHN0YXRpYyBib29sIGdTaG93RnJhbWVSYXRlID0gZmFsc2U7CiBzdGF0aWMgUUdyYXBoaWNz Vmlldzo6Vmlld3BvcnRVcGRhdGVNb2RlIGdWaWV3cG9ydFVwZGF0ZU1vZGUgPSBRR3JhcGhpY3NW aWV3OjpNaW5pbWFsVmlld3BvcnRVcGRhdGU7CiBzdGF0aWMgUVVybCBnSW5zcGVjdG9yVXJsOwor c3RhdGljIGJvb2wgZ1Jlc2l6ZXNUb0NvbnRlbnRzID0gZmFsc2U7CitzdGF0aWMgYm9vbCBnVXNl VGlsZWRCYWNraW5nU3RvcmUgPSBmYWxzZTsKIAogY2xhc3MgTGF1bmNoZXJXaW5kb3cgOiBwdWJs aWMgTWFpbldpbmRvdyB7CiAgICAgUV9PQkpFQ1QKQEAgLTExNyw2ICsxMTksOSBAQCBwcm90ZWN0 ZWQgc2xvdHM6CiAKICAgICB2b2lkIHNldFRvdWNoTW9ja2luZyhib29sIG9uKTsKICAgICB2b2lk IHRvZ2dsZUFjY2VsZXJhdGVkQ29tcG9zaXRpbmcoYm9vbCB0b2dnbGUpOworICAgIHZvaWQgdG9n Z2xlVGlsZWRCYWNraW5nU3RvcmUoYm9vbCB0b2dnbGUpOworICAgIHZvaWQgdG9nZ2xlUmVzaXpl c1RvQ29udGVudHMoYm9vbCB0b2dnbGUpOworICAgIAogICAgIHZvaWQgdG9nZ2xlV2ViR0woYm9v bCB0b2dnbGUpOwogICAgIHZvaWQgaW5pdGlhbGl6ZVZpZXcoYm9vbCB1c2VHcmFwaGljc1ZpZXcg PSBmYWxzZSk7CiAKQEAgLTQ2Nyw2ICs0NzIsMTYgQEAgdm9pZCBMYXVuY2hlcldpbmRvdzo6dG9n Z2xlQWNjZWxlcmF0ZWRDbwogICAgIHBhZ2UoKS0+c2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFX ZWJTZXR0aW5nczo6QWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQsIHRvZ2dsZSk7CiB9CiAK K3ZvaWQgTGF1bmNoZXJXaW5kb3c6OnRvZ2dsZVRpbGVkQmFja2luZ1N0b3JlKGJvb2wgdG9nZ2xl KQoreworICAgIHBhZ2UoKS0+c2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6 VGlsZWRCYWNraW5nU3RvcmVFbmFibGVkLCB0b2dnbGUpOworfQorCit2b2lkIExhdW5jaGVyV2lu ZG93Ojp0b2dnbGVSZXNpemVzVG9Db250ZW50cyhib29sIHRvZ2dsZSkKK3sKKyAgICBzdGF0aWNf Y2FzdDxXZWJWaWV3R3JhcGhpY3NCYXNlZCo+KG1fdmlldyktPnNldFJlc2l6ZXNUb0NvbnRlbnRz KHRvZ2dsZSk7Cit9CisKIHZvaWQgTGF1bmNoZXJXaW5kb3c6OnRvZ2dsZVdlYkdMKGJvb2wgdG9n Z2xlKQogewogICAgIHBhZ2UoKS0+c2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5n czo6V2ViR0xFbmFibGVkLCB0b2dnbGUpOwpAQCAtNDg3LDkgKzUwMiwxMSBAQCB2b2lkIExhdW5j aGVyV2luZG93Ojppbml0aWFsaXplVmlldyhib29sCiAgICAgICAgIHZpZXctPnNldFBhZ2UocGFn ZSgpKTsKICAgICAgICAgdmlldy0+c2V0Vmlld3BvcnRVcGRhdGVNb2RlKGdWaWV3cG9ydFVwZGF0 ZU1vZGUpOwogICAgICAgICB2aWV3LT5zZXRJdGVtQ2FjaGVNb2RlKGdDYWNoZVdlYlZpZXcgPyBR R3JhcGhpY3NJdGVtOjpEZXZpY2VDb29yZGluYXRlQ2FjaGUgOiBRR3JhcGhpY3NJdGVtOjpOb0Nh Y2hlKTsKKyAgICAgICAgdmlldy0+c2V0UmVzaXplc1RvQ29udGVudHMoZ1Jlc2l6ZXNUb0NvbnRl bnRzKTsKICAgICAgICAgaWYgKGdTaG93RnJhbWVSYXRlKQogICAgICAgICAgICAgdmlldy0+ZW5h YmxlRnJhbWVSYXRlTWVhc3VyZW1lbnQoKTsKICAgICAgICAgcGFnZSgpLT5zZXR0aW5ncygpLT5z ZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpBY2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZCwg Z1VzZUNvbXBvc2l0aW5nKTsKKyAgICAgICAgcGFnZSgpLT5zZXR0aW5ncygpLT5zZXRBdHRyaWJ1 dGUoUVdlYlNldHRpbmdzOjpUaWxlZEJhY2tpbmdTdG9yZUVuYWJsZWQsIGdVc2VUaWxlZEJhY2tp bmdTdG9yZSk7OwogCiAgICAgICAgIGlmIChmbGlwQW5pbWF0ZWQpCiAgICAgICAgICAgICBjb25u ZWN0KGZsaXBBbmltYXRlZCwgU0lHTkFMKHRyaWdnZXJlZCgpKSwgdmlldywgU0xPVChhbmltYXRl ZEZsaXAoKSkpOwpAQCAtNTk4LDYgKzYxNSwxOCBAQCB2b2lkIExhdW5jaGVyV2luZG93OjpzZXR1 cFVJKCkKICAgICB0b2dnbGVBY2NlbGVyYXRlZENvbXBvc2l0aW5nLT5zZXRDaGVja2VkKGZhbHNl KTsKICAgICB0b2dnbGVBY2NlbGVyYXRlZENvbXBvc2l0aW5nLT5zZXRFbmFibGVkKGZhbHNlKTsK ICAgICB0b2dnbGVBY2NlbGVyYXRlZENvbXBvc2l0aW5nLT5jb25uZWN0KHRvZ2dsZUdyYXBoaWNz VmlldywgU0lHTkFMKHRvZ2dsZWQoYm9vbCkpLCBTTE9UKHNldEVuYWJsZWQoYm9vbCkpKTsKKyAg ICAKKyAgICBRQWN0aW9uKiB0b2dnbGVSZXNpemVzVG9Db250ZW50cyA9IGdyYXBoaWNzVmlld01l bnUtPmFkZEFjdGlvbigiVG9nZ2xlIFJlc2l6ZXMgVG8gQ29udGVudHMgTW9kZSIsIHRoaXMsIFNM T1QodG9nZ2xlUmVzaXplc1RvQ29udGVudHMoYm9vbCkpKTsKKyAgICB0b2dnbGVSZXNpemVzVG9D b250ZW50cy0+c2V0Q2hlY2thYmxlKHRydWUpOworICAgIHRvZ2dsZVJlc2l6ZXNUb0NvbnRlbnRz LT5zZXRDaGVja2VkKGZhbHNlKTsKKyAgICB0b2dnbGVSZXNpemVzVG9Db250ZW50cy0+c2V0RW5h YmxlZChmYWxzZSk7CisgICAgdG9nZ2xlUmVzaXplc1RvQ29udGVudHMtPmNvbm5lY3QodG9nZ2xl R3JhcGhpY3NWaWV3LCBTSUdOQUwodG9nZ2xlZChib29sKSksIFNMT1Qoc2V0RW5hYmxlZChib29s KSkpOworICAgIAorICAgIFFBY3Rpb24qIHRvZ2dsZVRpbGVkQmFja2luZ1N0b3JlID0gZ3JhcGhp Y3NWaWV3TWVudS0+YWRkQWN0aW9uKCJUb2dnbGUgVGlsZWQgQmFja2luZyBTdG9yZSIsIHRoaXMs IFNMT1QodG9nZ2xlVGlsZWRCYWNraW5nU3RvcmUoYm9vbCkpKTsKKyAgICB0b2dnbGVUaWxlZEJh Y2tpbmdTdG9yZS0+c2V0Q2hlY2thYmxlKHRydWUpOworICAgIHRvZ2dsZVRpbGVkQmFja2luZ1N0 b3JlLT5zZXRDaGVja2VkKGZhbHNlKTsKKyAgICB0b2dnbGVUaWxlZEJhY2tpbmdTdG9yZS0+c2V0 RW5hYmxlZChmYWxzZSk7CisgICAgdG9nZ2xlVGlsZWRCYWNraW5nU3RvcmUtPmNvbm5lY3QodG9n Z2xlR3JhcGhpY3NWaWV3LCBTSUdOQUwodG9nZ2xlZChib29sKSksIFNMT1Qoc2V0RW5hYmxlZChi b29sKSkpOwogCiAgICAgZ3JhcGhpY3NWaWV3TWVudS0+YWRkU2VwYXJhdG9yKCk7CiAKQEAgLTcy NCw2ICs3NTMsOCBAQCB2b2lkIExhdW5jaGVyQXBwbGljYXRpb246OmhhbmRsZVVzZXJPcHRpCiAg ICAgICAgICAgICAgPDwgIlstc2hvdy1mcHNdIgogICAgICAgICAgICAgIDw8ICJbLXIgbGlzdF0i CiAgICAgICAgICAgICAgPDwgIlstaW5zcGVjdG9yLXVybCBsb2NhdGlvbl0iCisgICAgICAgICAg ICAgPDwgIlstdGlsZWQtYmFja2luZy1zdG9yZV0iCisgICAgICAgICAgICAgPDwgIlstcmVzaXpl cy10by1jb250ZW50c10iCiAgICAgICAgICAgICAgPDwgIlVSTHMiOwogICAgICAgICBhcHBRdWl0 KDApOwogICAgIH0KQEAgLTc0Niw2ICs3NzcsMTYgQEAgdm9pZCBMYXVuY2hlckFwcGxpY2F0aW9u OjpoYW5kbGVVc2VyT3B0aQogICAgICAgICBnQ2FjaGVXZWJWaWV3ID0gdHJ1ZTsKICAgICB9CiAK KyAgICBpZiAoYXJncy5jb250YWlucygiLXRpbGVkLWJhY2tpbmctc3RvcmUiKSkgeworICAgICAg ICByZXF1aXJlc0dyYXBoaWNzVmlldygiLXRpbGVkLWJhY2tpbmctc3RvcmUiKTsKKyAgICAgICAg Z1VzZVRpbGVkQmFja2luZ1N0b3JlID0gdHJ1ZTsKKyAgICB9CisKKyAgICBpZiAoYXJncy5jb250 YWlucygiLXJlc2l6ZXMtdG8tY29udGVudHMiKSkgeworICAgICAgICByZXF1aXJlc0dyYXBoaWNz VmlldygiLXJlc2l6ZXMtdG8tY29udGVudHMiKTsKKyAgICAgICAgZ1Jlc2l6ZXNUb0NvbnRlbnRz ID0gdHJ1ZTsKKyAgICB9CisKICAgICBRU3RyaW5nIGFyZzEoIi12aWV3cG9ydC11cGRhdGUtbW9k ZSIpOwogICAgIGludCBtb2RlSW5kZXggPSBhcmdzLmluZGV4T2YoYXJnMSk7CiAgICAgaWYgKG1v ZGVJbmRleCAhPSAtMSkgewpJbmRleDogV2ViS2l0VG9vbHMvUXRMYXVuY2hlci93ZWJ2aWV3LmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9RdExhdW5jaGVyL3dlYnZpZXcuY3BwCShyZXZp c2lvbiA1NTQ1OSkKKysrIFdlYktpdFRvb2xzL1F0TGF1bmNoZXIvd2Vidmlldy5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTQxLDYgKzQxLDcgQEAgV2ViVmlld0dyYXBoaWNzQmFzZWQ6OldlYlZpZXdH cmFwaGljc0JhcwogICAgICwgbV9udW1QYWludHNUb3RhbCgwKQogICAgICwgbV9udW1QYWludHNT aW5jZUxhc3RNZWFzdXJlKDApCiAgICAgLCBtX21lYXN1cmVGcHMoZmFsc2UpCisgICAgLCBtX3Jl c2l6ZXNUb0NvbnRlbnRzKGZhbHNlKQogewogICAgIHNldFNjZW5lKG5ldyBRR3JhcGhpY3NTY2Vu ZSh0aGlzKSk7CiAgICAgc2NlbmUoKS0+YWRkSXRlbShtX2l0ZW0pOwpAQCAtNzQsOSArNzUsMjQg QEAgV2ViVmlld0dyYXBoaWNzQmFzZWQ6OldlYlZpZXdHcmFwaGljc0JhcwogI2VuZGlmCiB9CiAK K3ZvaWQgV2ViVmlld0dyYXBoaWNzQmFzZWQ6OnNldFJlc2l6ZXNUb0NvbnRlbnRzKGJvb2wgYikK K3sKKyAgICBtX3Jlc2l6ZXNUb0NvbnRlbnRzID0gYjsKKyAgICBtX2l0ZW0tPnNldFJlc2l6ZXNU b0NvbnRlbnRzKG1fcmVzaXplc1RvQ29udGVudHMpOworICAgIGlmIChtX3Jlc2l6ZXNUb0NvbnRl bnRzKSB7CisgICAgICAgIHNldEhvcml6b250YWxTY3JvbGxCYXJQb2xpY3koUXQ6OlNjcm9sbEJh ckFzTmVlZGVkKTsKKyAgICAgICAgc2V0VmVydGljYWxTY3JvbGxCYXJQb2xpY3koUXQ6OlNjcm9s bEJhckFzTmVlZGVkKTsKKyAgICB9IGVsc2UgeworICAgICAgICBzZXRIb3Jpem9udGFsU2Nyb2xs QmFyUG9saWN5KFF0OjpTY3JvbGxCYXJBbHdheXNPZmYpOworICAgICAgICBzZXRWZXJ0aWNhbFNj cm9sbEJhclBvbGljeShRdDo6U2Nyb2xsQmFyQWx3YXlzT2ZmKTsKKyAgICB9Cit9CisKIHZvaWQg V2ViVmlld0dyYXBoaWNzQmFzZWQ6OnJlc2l6ZUV2ZW50KFFSZXNpemVFdmVudCogZXZlbnQpCiB7 CiAgICAgUUdyYXBoaWNzVmlldzo6cmVzaXplRXZlbnQoZXZlbnQpOworICAgIGlmIChtX3Jlc2l6 ZXNUb0NvbnRlbnRzKQorICAgICAgICByZXR1cm47CiAgICAgUVJlY3RGIHJlY3QoUVBvaW50KDAs IDApLCBldmVudC0+c2l6ZSgpKTsKICAgICBtX2l0ZW0tPnNldEdlb21ldHJ5KHJlY3QpOwogfQpJ bmRleDogV2ViS2l0VG9vbHMvUXRMYXVuY2hlci93ZWJ2aWV3LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0VG9vbHMvUXRMYXVuY2hlci93ZWJ2aWV3LmgJKHJldmlzaW9uIDU1NDU5KQorKysgV2ViS2l0 VG9vbHMvUXRMYXVuY2hlci93ZWJ2aWV3LmgJKHdvcmtpbmcgY29weSkKQEAgLTc2LDYgKzc2LDgg QEAgcHVibGljOgogCiAgICAgdm9pZCBlbmFibGVGcmFtZVJhdGVNZWFzdXJlbWVudCgpOwogICAg IHZpcnR1YWwgdm9pZCBwYWludEV2ZW50KFFQYWludEV2ZW50KiBldmVudCk7CisgICAgCisgICAg dm9pZCBzZXRSZXNpemVzVG9Db250ZW50cyhib29sIGIpOwogCiAgICAgdm9pZCBzZXRZUm90YXRp b24ocXJlYWwgYW5nbGUpCiAgICAgewpAQCAtMTA5LDYgKzExMSw3IEBAIHByaXZhdGU6CiAgICAg UVRpbWUgbV9sYXN0Q29uc3VsdFRpbWU7CiAgICAgYm9vbCBtX21lYXN1cmVGcHM7CiAgICAgcXJl YWwgbV95Um90YXRpb247CisgICAgYm9vbCBtX3Jlc2l6ZXNUb0NvbnRlbnRzOwogfTsKIAogI2Vu ZGlmCkluZGV4OiBXZWJLaXRUb29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXRUb29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAkocmV2aXNpb24gNTU0NTkpCisrKyBX ZWJLaXRUb29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAkod29ya2luZyBjb3B5KQpAQCAtNTYsNyAr NTYsNyBAQCBteSAoJHRocmVlRENhbnZhc1N1cHBvcnQsICR0aHJlZURSZW5kZXJpCiAgICAgJGph dmFTY3JpcHREZWJ1Z2dlclN1cHBvcnQsICRtYXRobWxTdXBwb3J0LCAkb2ZmbGluZVdlYkFwcGxp Y2F0aW9uU3VwcG9ydCwgJHJ1YnlTdXBwb3J0LCAkc2FuZGJveFN1cHBvcnQsICRzaGFyZWRXb3Jr ZXJzU3VwcG9ydCwKICAgICAkc3ZnU3VwcG9ydCwgJHN2Z0FuaW1hdGlvblN1cHBvcnQsICRzdmdB c0ltYWdlU3VwcG9ydCwgJHN2Z0RPTU9iakNCaW5kaW5nc1N1cHBvcnQsICRzdmdGb250c1N1cHBv cnQsCiAgICAgJHN2Z0ZvcmVpZ25PYmplY3RTdXBwb3J0LCAkc3ZnVXNlU3VwcG9ydCwgJHZpZGVv U3VwcG9ydCwgJHdlYlNvY2tldHNTdXBwb3J0LCAkd21sU3VwcG9ydCwgJHdjc3NTdXBwb3J0LCAk eGh0bWxtcFN1cHBvcnQsICR3b3JrZXJzU3VwcG9ydCwKLSAgICAkeHBhdGhTdXBwb3J0LCAkeHNs dFN1cHBvcnQsICRjb3ZlcmFnZVN1cHBvcnQsICRub3RpZmljYXRpb25zU3VwcG9ydCk7CisgICAg JHhwYXRoU3VwcG9ydCwgJHhzbHRTdXBwb3J0LCAkY292ZXJhZ2VTdXBwb3J0LCAkbm90aWZpY2F0 aW9uc1N1cHBvcnQsICR0aWxlZEJhY2tpbmdTdG9yZVN1cHBvcnQpOwogCiBteSBAZmVhdHVyZXMg PSAoCiAgICAgeyBvcHRpb24gPT4gIjNkLWNhbnZhcyIsIGRlc2MgPT4gIlRvZ2dsZSAzRCBjYW52 YXMgc3VwcG9ydCIsCkBAIC0xNDMsNiArMTQzLDkgQEAgbXkgQGZlYXR1cmVzID0gKAogICAgIHsg b3B0aW9uID0+ICJzdmctdXNlIiwgZGVzYyA9PiAiVG9nZ2xlIFNWRyB1c2UgZWxlbWVudCBzdXBw b3J0IChpbXBsaWVzIFNWRyBzdXBwb3J0KSIsCiAgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9TVkdf VVNFIiwgZGVmYXVsdCA9PiAxLCB2YWx1ZSA9PiBcJHN2Z1VzZVN1cHBvcnQgfSwKIAorICAgIHsg b3B0aW9uID0+ICJ0aWxlZC1iYWNraW5nLXN0b3JlIiwgZGVzYyA9PiAiVG9nZ2xlIFRpbGVkIEJh Y2tpbmcgU3RvcmUgc3VwcG9ydCIsCisgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9USUxFRF9CQUNL SU5HX1NUT1JFIiwgZGVmYXVsdCA9PiBpc1F0KCksIHZhbHVlID0+IFwkdGlsZWRCYWNraW5nU3Rv cmVTdXBwb3J0IH0sCisKICAgICB7IG9wdGlvbiA9PiAidmlkZW8iLCBkZXNjID0+ICJUb2dnbGUg VmlkZW8gc3VwcG9ydCIsCiAgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9WSURFTyIsIGRlZmF1bHQg PT4gKGlzQXBwbGVXZWJLaXQoKSB8fCBpc0d0aygpKSwgdmFsdWUgPT4gXCR2aWRlb1N1cHBvcnQg fSwKIAo=