27349 2009-07-16 10:04:48 -0700 [WINCE] Add GraphicsContextWince implementation for WinCE. 2009-07-20 13:09:01 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 23154 1 manyoso webkit-unassigned aroben staikos yong.li.webkit oldest_to_newest 132290 0 manyoso 2009-07-16 10:04:48 -0700 The following patch adds the GraphicsContextWince implementation for WinCE. 132292 1 32884 manyoso 2009-07-16 10:19:52 -0700 Created attachment 32884 Adds GraphicsContextWince.cpp 132392 2 32884 aroben 2009-07-16 16:22:20 -0700 Comment on attachment 32884 Adds GraphicsContextWince.cpp I'm sorry I didn't get to this today. I will look at it tomorrow! Before I review this, could you run the code through the new cpplint.py script in WebKitTools/Scripts/modules? That should point out a number of style issues that it would be nice to fix before a real review happens. 132397 3 manyoso 2009-07-16 16:30:24 -0700 I've already run it through cpplint :) 132401 4 aroben 2009-07-16 16:40:35 -0700 (In reply to comment #3) > I've already run it through cpplint :) Excellent! 132836 5 32884 aroben 2009-07-17 19:59:26 -0700 Comment on attachment 32884 Adds GraphicsContextWince.cpp There are many comments below that apply to many parts of the code. I've marked these with "(applies elsewhere)" instead of repeating the comments in each case. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 3b18cab..a0708ac 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,115 @@ > +2009-07-16 Yong Li <yong.li@torchmobile.com> > + > + Reviewed by NOBODY (OOPS!). > + > + https://bugs.webkit.org/show_bug.cgi?id=27349 > + Add GraphicsContext implementation for the WinCE port. > + > + Written by Yong Li <yong.li@torchmobile.com> and George Staikos <george.staikos@torchmobile.com> > + with trivial style fixes by Adam Treat <adam.treat@torchmobile.com> > + > + * platform/graphics/wince/GraphicsContextWince.cpp: Added. > + (WebCore::isZero): > + (WebCore::Round): > + (WebCore::roundRect): > + (WebCore::RotationTransform::RotationTransform): > + (WebCore::RotationTransform::operator-): > + (WebCore::RotationTransform::map): > + (WebCore::mapPoint): > + (WebCore::mapRect): > + (WebCore::GraphicsContextPlatformPrivateData::GraphicsContextPlatformPrivateData): > + (WebCore::GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate): > + (WebCore::GraphicsContextPlatformPrivate::~GraphicsContextPlatformPrivate): > + (WebCore::GraphicsContextPlatformPrivate::origin): > + (WebCore::GraphicsContextPlatformPrivate::translate): > + (WebCore::GraphicsContextPlatformPrivate::scale): > + (WebCore::GraphicsContextPlatformPrivate::rotate): > + (WebCore::GraphicsContextPlatformPrivate::concatCTM): > + (WebCore::GraphicsContextPlatformPrivate::mapRect): > + (WebCore::GraphicsContextPlatformPrivate::mapPoint): > + (WebCore::GraphicsContextPlatformPrivate::mapSize): > + (WebCore::GraphicsContextPlatformPrivate::save): > + (WebCore::GraphicsContextPlatformPrivate::restore): > + (WebCore::GraphicsContextPlatformPrivate::getTransparentLayerBitmap): > + (WebCore::GraphicsContextPlatformPrivate::paintBackTransparentLayerBitmap): > + (WebCore::createPen): > + (WebCore::createBrush): > + (WebCore::rotateBitmap): > + (WebCore::TransparentLayerDC::TransparentLayerDC): > + (WebCore::TransparentLayerDC::~TransparentLayerDC): > + (WebCore::TransparentLayerDC::hdc): > + (WebCore::TransparentLayerDC::rect): > + (WebCore::TransparentLayerDC::toShift): > + (WebCore::ScopeDCProvider::ScopeDCProvider): > + (WebCore::ScopeDCProvider::~ScopeDCProvider): > + (WebCore::GraphicsContext::GraphicsContext): > + (WebCore::GraphicsContext::~GraphicsContext): > + (WebCore::GraphicsContext::setBitmap): > + (WebCore::GraphicsContext::getWindowsContext): > + (WebCore::GraphicsContext::releaseWindowsContext): > + (WebCore::GraphicsContext::savePlatformState): > + (WebCore::GraphicsContext::restorePlatformState): > + (WebCore::GraphicsContext::drawRect): > + (WebCore::GraphicsContext::drawLine): > + (WebCore::GraphicsContext::drawEllipse): > + (WebCore::getEllipsePointByAngle): > + (WebCore::getEllipseY): > + (WebCore::getEllipseX): > + (WebCore::GraphicsContext::strokeArc): > + (WebCore::GraphicsContext::drawConvexPolygon): > + (WebCore::fillRectWithAlpha): > + (WebCore::GraphicsContext::fillRect): > + (WebCore::GraphicsContext::clip): > + (WebCore::GraphicsContext::clipOut): > + (WebCore::GraphicsContext::drawFocusRing): > + (WebCore::GraphicsContext::drawLineForText): > + (WebCore::GraphicsContext::drawLineForMisspellingOrBadGrammar): > + (WebCore::GraphicsContext::setPlatformFillColor): > + (WebCore::GraphicsContext::setPlatformStrokeColor): > + (WebCore::GraphicsContext::setPlatformStrokeThickness): > + (WebCore::GraphicsContext::setURLForRect): > + (WebCore::GraphicsContext::addInnerRoundedRectClip): > + (WebCore::GraphicsContext::clearRect): > + (WebCore::GraphicsContext::strokeRect): > + (WebCore::GraphicsContext::beginTransparencyLayer): > + (WebCore::GraphicsContext::endTransparencyLayer): > + (WebCore::GraphicsContext::concatCTM): > + (WebCore::GraphicsContext::affineTransform): > + (WebCore::GraphicsContext::resetAffineTransform): > + (WebCore::GraphicsContext::translate): > + (WebCore::GraphicsContext::rotate): > + (WebCore::GraphicsContext::origin): > + (WebCore::GraphicsContext::scale): > + (WebCore::GraphicsContext::mapRect): > + (WebCore::GraphicsContext::mapPoint): > + (WebCore::GraphicsContext::mapSize): > + (WebCore::GraphicsContext::setLineCap): > + (WebCore::GraphicsContext::setLineJoin): > + (WebCore::GraphicsContext::setMiterLimit): > + (WebCore::GraphicsContext::setAlpha): > + (WebCore::GraphicsContext::setCompositeOperation): > + (WebCore::GraphicsContext::beginPath): > + (WebCore::GraphicsContext::addPath): > + (WebCore::GraphicsContext::clipOutEllipseInRect): > + (WebCore::GraphicsContext::fillRoundedRect): > + (WebCore::GraphicsContext::roundToDevicePixels): > + (WebCore::GraphicsContext::fillPath): > + (WebCore::GraphicsContext::strokePath): > + (WebCore::GraphicsContext::getCTM): > + (WebCore::GraphicsContext::clipToImageBuffer): > + (WebCore::GraphicsContext::setPlatformShadow): > + (WebCore::GraphicsContext::clearPlatformShadow): > + (WebCore::GraphicsContext::setImageInterpolationQuality): > + (WebCore::GraphicsContext::drawText): > + (WebCore::GraphicsContext::drawFrameControl): > + (WebCore::GraphicsContext::drawFocusRect): > + (WebCore::GraphicsContext::paintTextField): > + (WebCore::GraphicsContext::drawBitmap): > + (WebCore::GraphicsContext::drawBitmapPattern): > + (WebCore::GraphicsContext::setPlatformShouldAntialias): > + (WebCore::GraphicsContext::setLineDash): > + (WebCore::GraphicsContext::clipPath): It's probably better to omit the function list if you aren't adding comments about each function. > +#include "config.h" > +#include "GraphicsContext.h" > +#include "TransformationMatrix.h" > +#include "NotImplemented.h" > +#include "wince/MemoryManager.h" > +#include "OwnPtr.h" > +#include "SharedBitmap.h" > +#include "Path.h" > +#include "PlatformPathWince.h" > +#include "Gradient.h" > +#include "GraphicsContextPrivate.h" > +#include "SimpleFontData.h" > +#include "GlyphBuffer.h" > +#include "CharacterNames.h" > +#include <windows.h> These should be sorted in ASCII order. You should add a blank line after #include "GraphicsContext.h". "OwnPtr.h" should be <wtf/OwnPtr.h>. > +#define PI 3.14159265358979323846 wtf/MathExtras.h defines piFloat and piDouble. You should probably use those instead. > +#define RADIAN(a) ((a) * PI / 180.) > +#define DEGREE(a) ((a) * 180. / PI) wtf/MathExtras.h has deg2rad and rad2deg functions you can use instead. > +static inline int Round(double d) Function names start with a lowercase letter in WebKit. But you can probably just use lround from wtf/MathExtras.h instead. > +{ > + if (d > 0) > + return int(d + 0.5); We normally use C++ cast operators instead of function-style casts. So static_cast would be better here. (applies elsewhere) > + else { We don't write "else" after "return". (applies elsewhere) > +static inline IntRect roundRect(const FloatRect& r) > +{ > + return IntRect(Round(r.x()), Round(r.y()), Round(r.right()) - Round(r.x()), Round(r.bottom()) - Round(r.y())); > +} Are you sure you don't want to use enclosingIntRect instead? > +struct RotationTransform { // Origin (0, 0) > + double m_cosA; > + double m_sinA; > + int m_preShiftX; > + int m_preShiftY; > + int m_postShiftX; > + int m_postShiftY; We often omit the "m_" prefix on struct data members. (applies elsewhere) > + void map(double x1, double y1, double* x2, double* y2) const > + { > + x1 += m_preShiftX; > + y1 += m_preShiftY; > + *x2 = x1 * m_cosA + y1 * m_sinA + m_postShiftX; > + *y2 = y1 * m_cosA - x1 * m_sinA + m_postShiftY; > + } Maybe this would be better as: IntPoint map(const IntPoint&) const > + void map(int x1, int y1, int* x2, int* y2) const > + { > + x1 += m_preShiftX; > + y1 += m_preShiftY; > + *x2 = Round(x1 * m_cosA + y1 * m_sinA) + m_postShiftX; > + *y2 = Round(y1 * m_cosA - x1 * m_sinA) + m_postShiftY; > + } Maybe this would be better as: FloatPoint map(const FloatPoint&) const > +template<class T> static inline > +IntPoint mapPoint(const IntPoint& p, const T& t) I think we normally put the entire function declaration on a single line. (applies elsewhere) > +template<class Transform, class Rect, class Value> static inline > +Rect mapRect(const Rect& rect, const Transform& transform) If you switched the template parameter order to Value, Transform, Rect, then I think you could normally call the function like this: mapRect<Value>(...). The Transform and Rect parameters would be inferred from the parameter types. > +{ > + Value x[4], y[4]; > + Value l, t, r, b; It might be clearer to give these variables full-word names ("left", "top", etc.). We don't normally declare multiple variables on a single line. (applies elsewhere) > + GraphicsContextPlatformPrivateData() > + : m_transform() > + , m_opacity(1.0) > + {} Please put the braces on their own lines, or put the entire constructor on a single line (including the initializer list). > + GraphicsContextPlatformPrivate(HDC dc) > + : m_dc(dc) > + { > + HDC hScreenDC = ::GetDC(0); > + int rtn = ::GetDeviceCaps(hScreenDC, RASTERCAPS); > + ::ReleaseDC(0, hScreenDC); > + } What's the point of the three lines in the body of the constructor? They don't seem to do anything. Does calling GetDeviceCaps have some side-effect? > + IntPoint origin() > + { > + return IntPoint(Round(-m_transform.e()), > + Round(-m_transform.f())); > + } This could be a const member function. > + FloatSize mapSize(const FloatSize& size) > + { > + double w, h; > + m_transform.map(size.width(), size.height(), w, h); > + return FloatSize(w, h); > + } Earlier you used static_cast when passing doubles to the FloatSize constructor. It would be good to be consistent one way or the other. > + void restore() > + { > + if (m_backupData.isEmpty()) > + return; > + > + if (m_dc) > + RestoreDC(m_dc, -1); > + > + GraphicsContextPlatformPrivateData::operator=(m_backupData.last()); Does *this = m_backupData.last() not work? > + PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, bool uses16bit, RECT& bmpRect, bool checkClipBox, bool force) It seems strange to use a mix of IntRect and RECT in this declaration. (applies elsewhere) > + { > + if (m_opacity <= 0) > + return 0; > + else if (force || m_opacity < 1.) { You could negate this condition and use an early return. > +#if !defined(NO_ALPHABLEND) > + if (m_opacity < 1. || !use16bit) { > + const BLENDFUNCTION blend = { AC_SRC_OVER, 0 > + , m_opacity >= 1. ? 255 : (BYTE)(m_opacity * 255) > + , use16bit ? 0 : AC_SRC_ALPHA }; > + AlphaBlend > + (m_dc > + , origRect.x() > + , origRect.y() > + , origRect.width() > + , origRect.height() > + , hdc > + , 0 > + , 0 > + , bmpRect.right > + , bmpRect.bottom > + , blend > + ); I've never seen this one-parameter-per-line style anywhere else in WebKit. I'm not sure it's a good idea to introduce it here. (applies elsewhere) > +// Only for 16bit > +void rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform) This should be marked "static" so it gets internal linkage. (applies elsewhere) > +{ > + ASSERT(destBmp->is16bit() && sourceBmp->is16bit()); It would be better to use ASSERT_ARG. It would be better to separate this into two assertions. > + int destW = destBmp->width(); > + int destH = destBmp->height(); > + int sourceW = sourceBmp->width(); > + int sourceH = sourceBmp->height(); > + unsigned short* dest = (unsigned short*)destBmp->bytes(); > + const unsigned short* source = (const unsigned short*)sourceBmp->bytes(); > + int padding = destW & 1; > + int paddedSourceW = sourceW + (sourceW & 1); > + if (isZero(transform.m_sinA)) { > + int cosA = transform.m_cosA > 0 ? 1 : -1; > + for (int y = 0; y < destH; ++y) { > + for (int x = 0; x < destW; ++x) { > + int x1 = x + transform.m_preShiftX; > + int y1 = y + transform.m_preShiftY; > + int srcX = x1 * cosA + transform.m_postShiftX; > + int srcY = y1 * cosA - transform.m_postShiftY; > + if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH) > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > + else > + *dest++ |= 0xFF; > + } > + dest += padding; > + } > + } else if (isZero(transform.m_cosA)) { > + int sinA = transform.m_sinA > 0 ? 1 : -1; > + for (int y = 0; y < destH; ++y) { > + for (int x = 0; x < destW; ++x) { > + int x1 = x + transform.m_preShiftX; > + int y1 = y + transform.m_preShiftY; > + int srcX = y1 * sinA + transform.m_postShiftX; > + int srcY = -x1 * sinA + transform.m_postShiftY; > + if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH) > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > + else > + *dest++ |= 0xFF; > + } > + dest += padding; > + } > + } else { > + for (int y = 0; y < destH; ++y) { > + for (int x = 0; x < destW; ++x) { > + // FIXME: for best quality, we should get weighted sum of four neighbours, > + // but that will be too expensive > + int srcX, srcY; > + transform.map(x, y, &srcX, &srcY); > + if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH) > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > + else > + *dest++ |= 0xFF; > + } > + dest += padding; > + } > + } > +} It would be nice to have a little less duplication in this function. > + explicit TransparentLayerDC(GraphicsContextPlatformPrivate* data, > + IntRect& origRect, > + const IntRect* rectBeforeTransform = 0, > + int alpha = 255) "explicit" doesn't really add anything here, since this constructor requires more than one parameter. > + : m_data(data) > + , m_origRect(origRect) > + , m_oldOpacity(data->m_opacity) It seems error-prone to leave m_key1 and m_key2 uninitialized here. > +#if 1 > + FloatPoint topLeft = m_data->m_transform.mapPoint(FloatPoint(rectBeforeTransform->topLeft())); > + FloatPoint topRight(rectBeforeTransform->right() - 1, rectBeforeTransform->y()); > + topRight = m_data->m_transform.mapPoint(topRight); > + FloatPoint bottomLeft(rectBeforeTransform->x(), rectBeforeTransform->bottom() - 1); > + bottomLeft = m_data->m_transform.mapPoint(bottomLeft); > + FloatSize sideTop = topRight - topLeft; > + FloatSize sideLeft = bottomLeft - topLeft; > + float width = _hypot(sideTop.width() + 1, sideTop.height() + 1); > + float height = _hypot(sideLeft.width() + 1, sideLeft.height() + 1); > + > + origRect.inflateX(Round((width - origRect.width()) * 0.5)); > + origRect.inflateY(Round((height - origRect.height()) * 0.5)); > +#else > + FloatRect rotatedBeforeTransform = mapRect(FloatRect(*rectBeforeTransform), -m_rotation); > + double shrinkRateX = (1. - rectBeforeTransform->width() / (double)rotatedBeforeTransform.width()) * 0.5; > + double shrinkRateY = (1. - rectBeforeTransform->height() / (double)rotatedBeforeTransform.height()) * 0.5; > + origRect.inflateX(-Round(shrinkRateX * origRect.width())); > + origRect.inflateY(-Round(shrinkRateY * origRect.height())); > +#endif We don't like to check in commented-out code. (applies elsewhere) > + if (m_bitmap) > + m_memDc = m_bitmap->getDC(&m_key1, &m_key2); m_memDC would match our variable naming conventions better. > +HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap) > +{ > + // FIXME: the implementation is buggy. Currently the function seems not being used. Just make an assertion > + ASSERT(0); > + return 0; ASSERT_NOT_REACHED() would be better here. > +void GraphicsContext::drawRect(const IntRect& rect) > +{ > + if (!m_data->m_opacity || paintingDisabled() || rect.width() <= 0 || rect.height() <= 0) > + return; You can use rect.isEmpty() instead of the width() and height() checks. > + TransparentLayerDC transparentDc(m_data, trRect, &rect); transparentDC would match our variable naming conventions better. (applies elsewhere) > + if (fillColor().alpha()) { > + brush = createBrush(fillColor()); > + oldBrush = SelectObject(dc, brush); > + } else { > + SelectObject(dc, GetStockObject(NULL_BRUSH)); > + } We don't put braces around the bodies of single-line branches. > +void GraphicsContext::drawEllipse(const IntRect& rect) > +{ > + if (!m_data->m_opacity || paintingDisabled() || (!fillColor().alpha() && strokeStyle() == NoStroke)) > + return; Should you check that strokeColor().alpha() is non-zero, too? > + HGDIOBJ oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH)); > + Ellipse(dc, trRect.x(), trRect.y(), trRect.right(), trRect.bottom()); > + SelectObject(dc, oldBrush); > + > + if (newClip) > + SelectClipRgn(dc, 0); Why don't we need to select the old clip region back in in this case? > +void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias) > +{ > + if (!m_data->m_opacity || paintingDisabled() || npoints <= 1 || !points) > + return; > + > + ScopeDCProvider dcProvider(m_data); > + if (!m_data->m_dc) > + return; > + > + Vector<POINT, 20> winPoints; > + winPoints.resize(npoints); You can just pass npoints to the Vector constructor instead of calling resize. (applies elsewhere) > +void GraphicsContext::fillRect(const FloatRect& rect, const Color& color) > +{ > + if (paintingDisabled() || !m_data->m_opacity) > + return; > + > + if (int alpha = color.alpha()) { > + OwnPtr<HBRUSH> hbrush(CreateSolidBrush(RGB(color.red(), color.green(), color.blue()))); > + if (hbrush) { > + ScopeDCProvider dcProvider(m_data); > + if (m_data->m_dc) { > + IntRect intRect = enclosingIntRect(rect); > + TransparentLayerDC transparentDc(m_data, m_data->mapRect(intRect), &intRect); > + if (transparentDc.hdc()) > + if (alpha == 0xFF) > + FillRect(transparentDc.hdc(), &transparentDc.rect(), hbrush.get()); > + else > + fillRectWithAlpha(transparentDc.hdc(), &transparentDc.rect(), hbrush.get(), alpha); > + } > + } > + } > +} This function would benefit from reducing nesting by using early returns. > +void GraphicsContext::drawFocusRing(const Color& color) > +{ > + if (!m_data->m_opacity || paintingDisabled()) > + return; > + > + ScopeDCProvider dcProvider(m_data); > + if (!m_data->m_dc) > + return; > + > + int radius = (focusRingWidth() - 1) / 2; > + int offset = radius + focusRingOffset(); > + > + const Vector<IntRect>& rects = focusRingRects(); > + unsigned rectCount = rects.size(); > + IntRect finalFocusRect; > + for (unsigned i = 0; i < rectCount; i++) { > + IntRect focusRect = rects[i]; > + focusRect.inflate(offset); > + finalFocusRect.unite(focusRect); > + } > + > + RECT rect = { finalFocusRect.x(), finalFocusRect.y(), finalFocusRect.right(), finalFocusRect.bottom() }; There's an operator RECT() member of IntRect, so you shouldn't have to do this explicitly. > +void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness) > +{ > + notImplemented(); > + // FIX ME: > + clip(rect); Our style is "FIXME:". It would be good to add a slightly more descriptive comment. > +void GraphicsContext::fillPath() > +{ > + if (!fillColor().alpha() || !m_data->m_opacity) > + return; > + ScopeDCProvider dcProvider(m_data); > + if (!m_data->m_dc) > + return; > + > + if (m_data->m_opacity < 1.0f) { > + HGDIOBJ brush = createBrush(fillColor()); > + for (Vector<Path>::const_iterator i = m_data->m_paths.begin(); i != m_data->m_paths.end(); ++i) { > + IntRect trRect = roundRect(m_data->mapRect(i->boundingRect())); > + TransparentLayerDC transparentDc(m_data, trRect); > + HDC dc = transparentDc.hdc(); > + if (!dc) > + continue; > + > + TransformationMatrix tr = m_data->m_transform; > + tr.translate(transparentDc.toShift().width(), transparentDc.toShift().height()); > + > + SelectObject(dc, GetStockObject(NULL_PEN)); > + HGDIOBJ oldBrush = SelectObject(dc, brush); > + i->platformPath()->fillPath(dc, &tr); > + SelectObject(dc, oldBrush); Don't you need to restore the old pen, too? (Ditto for the other branch in this function.) > +void GraphicsContext::strokePath() > +{ > + if (!m_data->m_opacity) > + return; > + > + ScopeDCProvider dcProvider(m_data); > + if (!m_data->m_dc) > + return; > + > + if (m_data->m_opacity < 1.0f) { > + HGDIOBJ pen = createPen(strokeColor(), strokeThickness(), strokeStyle()); > + for (Vector<Path>::const_iterator i = m_data->m_paths.begin(); i != m_data->m_paths.end(); ++i) { > + IntRect trRect = roundRect(m_data->mapRect(i->boundingRect())); > + TransparentLayerDC transparentDc(m_data, trRect); > + HDC dc = transparentDc.hdc(); > + if (!dc) > + continue; > + > + TransformationMatrix tr = m_data->m_transform; > + tr.translate(transparentDc.toShift().width(), transparentDc.toShift().height()); > + > + SelectObject(dc, GetStockObject(NULL_BRUSH)); > + HGDIOBJ oldPen = SelectObject(dc, pen); > + i->platformPath()->strokePath(dc, &m_data->m_transform); > + SelectObject(dc, oldPen); Don't you need to restore the old brush? (Ditto for the other branch of this function.) > +void GraphicsContext::fillRect(const FloatRect& r, const Gradient* gradient) > +{ > + if (!m_data->m_opacity) > + return; > + > + const Vector<Gradient::ColorStop>& stops = gradient->getStops(); > + int numStops = stops.size(); > + if (numStops == 0) { > + } else if (numStops == 1) { I think this would be clearer as: if (stops.isEmpty()) return; size_t numStops = stops.size(); > +#define isCharVisible(c) ((c) && (c) != zeroWidthSpace) This would be better as an inline helper function. > +void GraphicsContext::drawText(const Font& font, const TextRun& run, const IntPoint& point, int from, int to) > +{ > + if (paintingDisabled() || fillColor().alpha() == 0 || !m_data->m_opacity) > + return; Please use !fillColor().alpha() instead of comparing to 0. (applies elsewhere) > + if (fillColor().alpha() == 0xFF && m_data->m_opacity >= 1.0) > + font.drawText(this, run, point, from, to); > + else { You should add an early return in the if case to reduce nesting. > + float oldOpacity = m_data->m_opacity; > + m_data->m_opacity *= fillColor().alpha() / 255.0; > + > + FloatRect textRect = font.selectionRectForText(run, point, font.height(), from, to); > + textRect.setY(textRect.y() - font.ascent()); > + IntRect trRect = enclosingIntRect(m_data->mapRect(textRect)); > + RECT bmpRect; > + RefPtr<SharedBitmap> bmp = m_data->getTransparentLayerBitmap(trRect, true, bmpRect, true, false); > + if (bmp) { You can declare the bmp variable inside the if condition: if (RefPtr<SharedBitmap> bmp = ...) { > + // TransparentLayerDC ... What does this comment mean? > + HFONT hFont = height > 1 > + ? fontData->platformData().getScaledFontHandle(height, scaleX == scaleY ? 0 : width) > + : 0; > + > + FloatPoint startPoint(point.x(), point.y() - fontData->ascent()); > + FloatPoint trPoint = m_data->mapPoint(startPoint); > + int y = Round(trPoint.y()); > + > + Color color = fillColor(); > + if (color.alpha() == 0) // hack > + return; > + > + COLORREF fontColor = RGB(color.red(), color.green(), color.blue()); > + > + if (hFont) { If you put the !hFont case first, you can add an early return at the end of it, and add early returns throughout the rest of the function to reduce nesting. i.e.,: if (!hFont) { ....the current else case goes here.... return; } ....the rest of the code goes here, hopefully with more early returns.... > + COLORREF shadowRgbColor; shadowRGBColor would match our variable naming conventions better. > + HGDIOBJ hOldFont = SelectObject(m_data->m_dc, hFont); > + // transparent always... > + int oldBkMode = GetBkMode(m_data->m_dc); What does this comment mean? > + if ((rectWin.right - rectWin.left) < boxWidthBest) { > + RefPtr<SharedBitmap> bmp1 = SharedBitmap::createInstance(true, boxWidthBest, boxHeightBest, true); > + SharedBitmap::DCHolder dc1(bmp1.get()); Is there a better way to name these variables than with a "1" suffix? > +void GraphicsContext::setPlatformShouldAntialias(bool should) > +{ > + (void)should; > + notImplemented(); > +} You can use the UNUSED_PARAM macro from wtf/UnusedParam.h here, or just omit the parameter name entirely. (applies elsewhere) I think there's enough style clean-up here that we should do another pass at this. Hopefully we can make cpplint.py catch more of these style issues! 132838 6 manyoso 2009-07-17 20:10:14 -0700 Thanks Adam for the thorough review! I'm going to let Yong and the others comment on the substantive parts as they are the original authors. > I think there's enough style clean-up here that we should do another pass at > this. Hopefully we can make cpplint.py catch more of these style issues! As part of this upstreaming process I'm using cpplint and adding improvements and enhancements to the tool as they appear. At least some of the things your review caught could be automated I think such as the include order and so on. Thanks again! 132918 7 yong.li.webkit 2009-07-18 09:24:06 -0700 (In reply to comment #5) Hi, Adam, Thanks a lot for your review. See my comments below. Best regards, -Yong > (From update of attachment 32884 [details]) > There are many comments below that apply to many parts of the code. I've marked > these with "(applies elsewhere)" instead of repeating the comments in each > case. > > > +#define PI 3.14159265358979323846 > > wtf/MathExtras.h defines piFloat and piDouble. You should probably use those > instead. > > > +#define RADIAN(a) ((a) * PI / 180.) > > +#define DEGREE(a) ((a) * 180. / PI) > > wtf/MathExtras.h has deg2rad and rad2deg functions you can use instead. Agree. At the time I created this file, they were not there. Now we should use them > > > +static inline int Round(double d) > > Function names start with a lowercase letter in WebKit. But you can probably > just use lround from wtf/MathExtras.h instead. I just reviewed lround(). It does the same thing, but it calls "ceil()" for negative values, which is probably not good in term of performance. > > > +{ > > + if (d > 0) > > + return int(d + 0.5); > > We normally use C++ cast operators instead of function-style casts. So > static_cast would be better here. (applies elsewhere) > Agree. > > > +static inline IntRect roundRect(const FloatRect& r) > > +{ > > + return IntRect(Round(r.x()), Round(r.y()), Round(r.right()) - Round(r.x()), Round(r.bottom()) - Round(r.y())); > > +} > > Are you sure you don't want to use enclosingIntRect instead? I'm sure. enclosingIntRect() can result more rendering problems when page is zoomed. > > + void map(double x1, double y1, double* x2, double* y2) const > > + { > > Maybe this would be better as: FloatPoint map(const FloatPoint&) const then I have to construct FloatPoint in many cases. another problem is that FloatPoint is float, but this function uses double. > > +template<class Transform, class Rect, class Value> static inline > > +Rect mapRect(const Rect& rect, const Transform& transform) > > If you switched the template parameter order to Value, Transform, Rect, then I > think you could normally call the function like this: mapRect<Value>(...). The > Transform and Rect parameters would be inferred from the parameter types. Good idea. > > > + GraphicsContextPlatformPrivate(HDC dc) > > + : m_dc(dc) > > + { > > + HDC hScreenDC = ::GetDC(0); > > + int rtn = ::GetDeviceCaps(hScreenDC, RASTERCAPS); > > + ::ReleaseDC(0, hScreenDC); > > + } > > What's the point of the three lines in the body of the constructor? They don't > seem to do anything. Does calling GetDeviceCaps have some side-effect? This is a piece of garbage. I thought I removed them... probably we lost a commit in this branch :( > > > + IntPoint origin() > > + { > > + return IntPoint(Round(-m_transform.e()), > > + Round(-m_transform.f())); > > + } > > This could be a const member function. right. > > > + FloatSize mapSize(const FloatSize& size) > > + { > > + double w, h; > > + m_transform.map(size.width(), size.height(), w, h); > > + return FloatSize(w, h); > > + } > > Earlier you used static_cast when passing doubles to the FloatSize constructor. > It would be good to be consistent one way or the other. how about static_cast<float>(w)? > > + > > + GraphicsContextPlatformPrivateData::operator=(m_backupData.last()); > > Does *this = m_backupData.last() not work? I usually like to use operator=() rather than *this =. Personal habit. > > > + PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, bool uses16bit, RECT& bmpRect, bool checkClipBox, bool force) > > It seems strange to use a mix of IntRect and RECT in this declaration. (applies > elsewhere) To avoid converting IntRect and RECT too frequently. > > > +#if !defined(NO_ALPHABLEND) > > + if (m_opacity < 1. || !use16bit) { > > + const BLENDFUNCTION blend = { AC_SRC_OVER, 0 > > + , m_opacity >= 1. ? 255 : (BYTE)(m_opacity * 255) > > + , use16bit ? 0 : AC_SRC_ALPHA }; > > + AlphaBlend > > + (m_dc > > + , origRect.x() > > + , origRect.y() > > + , origRect.width() > > + , origRect.height() > > + , hdc > > + , 0 > > + , 0 > > + , bmpRect.right > > + , bmpRect.bottom > > + , blend > > + ); > > I've never seen this one-parameter-per-line style anywhere else in WebKit. I'm > not sure it's a good idea to introduce it here. (applies elsewhere) It makes code much more readable when there are too many arguments. sourceH) > > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > > + else > > + *dest++ |= 0xFF; > > + } > > + dest += padding; > > + } > > + } > > +} > > It would be nice to have a little less duplication in this function. Performance vs code size... that's a fight. > > + : m_data(data) > > + , m_origRect(origRect) > > + , m_oldOpacity(data->m_opacity) > > It seems error-prone to leave m_key1 and m_key2 uninitialized here. m_key1 and m_key2 will be set up by ->getDC(). In many cases, they are not used at all. Performance consideration. > > > +#if 1 ... > > +#else ... > > +#endif > > We don't like to check in commented-out code. (applies elsewhere) > this piece garbage needs to be cleaned up > > + if (!m_data->m_opacity || paintingDisabled() || rect.width() <= 0 || rect.height() <= 0) > > + return; > > You can use rect.isEmpty() instead of the width() and height() checks. well, rect.isEmpty() cheated before. it was equivalent to rect.width() <= 0 && rect.height() <= 0. Seems it has been fixed in upstream. > > + if (fillColor().alpha()) { > > + brush = createBrush(fillColor()); > > + oldBrush = SelectObject(dc, brush); > > + } else { > > + SelectObject(dc, GetStockObject(NULL_BRUSH)); > > + } > > We don't put braces around the bodies of single-line branches. We will follow the rules if we have to. But I really don't like this rule. consider this: if () { 2 lines here } else one line code; else if { 2 lines here } It looks so terrible. Even this case if () { one line code; } I cannot see nothing wrong with it. > > > + HGDIOBJ oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH)); > > + Ellipse(dc, trRect.x(), trRect.y(), trRect.right(), trRect.bottom()); > > + SelectObject(dc, oldBrush); > > + > > + if (newClip) > > + SelectClipRgn(dc, 0); > > Why don't we need to select the old clip region back in in this case? no. newClip is set to true, only when there's no old clip region. > > > +void GraphicsContext::fillRect(const FloatRect& rect, const Color& color) > > +{ > > + if (paintingDisabled() || !m_data->m_opacity) > > + return; > > + > > + if (int alpha = color.alpha()) { > > + OwnPtr<HBRUSH> hbrush(CreateSolidBrush(RGB(color.red(), color.green(), color.blue()))); > > + if (hbrush) { > > + ScopeDCProvider dcProvider(m_data); > > + if (m_data->m_dc) { > > + IntRect intRect = enclosingIntRect(rect); > > + TransparentLayerDC transparentDc(m_data, m_data->mapRect(intRect), &intRect); > > + if (transparentDc.hdc()) > > + if (alpha == 0xFF) > > + FillRect(transparentDc.hdc(), &transparentDc.rect(), hbrush.get()); > > + else > > + fillRectWithAlpha(transparentDc.hdc(), &transparentDc.rect(), hbrush.get(), alpha); > > + } > > + } > > + } > > +} > > This function would benefit from reducing nesting by using early returns. By benefit, do you mean it runs faster? Personally, I don't like too many "return" in a function. it's just like "goto", which makes code more difficult to maintain & review. > > > + > > + SelectObject(dc, GetStockObject(NULL_PEN)); > > + HGDIOBJ oldBrush = SelectObject(dc, brush); > > + i->platformPath()->fillPath(dc, &tr); > > + SelectObject(dc, oldBrush); > > Don't you need to restore the old pen, too? (Ditto for the other branch in this > function.) No. Leaving NULL_PEN to dc is safe. > > + > > + SelectObject(dc, GetStockObject(NULL_BRUSH)); > > + HGDIOBJ oldPen = SelectObject(dc, pen); > > + i->platformPath()->strokePath(dc, &m_data->m_transform); > > + SelectObject(dc, oldPen); > > Don't you need to restore the old brush? (Ditto for the other branch of this > function.) No. Leaving NULL_BRUSH to dc is safe. > > +#define isCharVisible(c) ((c) && (c) != zeroWidthSpace) > > This would be better as an inline helper function. Only concern is inline function is not inline in debug version, and it makes debug version run much slower. > > + > > + if (hFont) { > > If you put the !hFont case first, you can add an early return at the end of it, > and add early returns throughout the rest of the function to reduce nesting. > i.e.,: > > if (!hFont) { > ....the current else case goes here.... > return; > } > > ....the rest of the code goes here, hopefully with more early returns.... Later, if we want to add more code at the end to clean up something, we have to make it nested again. > > > + COLORREF shadowRgbColor; > > shadowRGBColor would match our variable naming conventions better. > > > + HGDIOBJ hOldFont = SelectObject(m_data->m_dc, hFont); > > + // transparent always... > > + int oldBkMode = GetBkMode(m_data->m_dc); > > What does this comment mean? BkMode is always transparent. 132925 8 yong.li.webkit 2009-07-18 10:33:50 -0700 Oops: lround does different thing: inline long lround(double num) { return static_cast<long>(num > 0 ? num + 0.5 : ceil(num - 0.5)); } What we want in GraphicsContextWince.cpp is to round -0.5 to 0, as 0.5 is rounded to 1, so that the rendering behavior is consistent when offset varies. but lround(-0.5) will return -1. -Yong 133126 9 aroben 2009-07-20 06:53:13 -0700 (In reply to comment #6) > > I think there's enough style clean-up here that we should do another pass at > > this. Hopefully we can make cpplint.py catch more of these style issues! > > As part of this upstreaming process I'm using cpplint and adding improvements > and enhancements to the tool as they appear. At least some of the things your > review caught could be automated I think such as the include order and so on. > Thanks again! Yeah, that comment was definitely meant for you, since I see you've been working on cpplint (yay!). 133127 10 aroben 2009-07-20 07:05:58 -0700 (In reply to comment #7) > (In reply to comment #5) > > > +static inline int Round(double d) > > > > Function names start with a lowercase letter in WebKit. But you can probably > > just use lround from wtf/MathExtras.h instead. > > I just reviewed lround(). It does the same thing, but it calls "ceil()" for > negative values, which is probably not good in term of performance. If your version is better, shouldn't we change lround() in MathExtras.h so that everyone will benefit? > > > +static inline IntRect roundRect(const FloatRect& r) > > > +{ > > > + return IntRect(Round(r.x()), Round(r.y()), Round(r.right()) - Round(r.x()), Round(r.bottom()) - Round(r.y())); > > > +} > > > > Are you sure you don't want to use enclosingIntRect instead? > > I'm sure. enclosingIntRect() can result more rendering problems when page is > zoomed. OK. A comment explaining this would be good. > > > + FloatSize mapSize(const FloatSize& size) > > > + { > > > + double w, h; > > > + m_transform.map(size.width(), size.height(), w, h); > > > + return FloatSize(w, h); > > > + } > > > > Earlier you used static_cast when passing doubles to the FloatSize constructor. > > It would be good to be consistent one way or the other. > > how about static_cast<float>(w)? Sounds fine. > > > + PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, bool uses16bit, RECT& bmpRect, bool checkClipBox, bool force) > > > > It seems strange to use a mix of IntRect and RECT in this declaration. (applies > > elsewhere) > > To avoid converting IntRect and RECT too frequently. Have you noticed IntRect <-> RECT conversions showing up on performance profiles? It seems like it would be dwarfed by the actual painting calls. But I don't know the performance characteristics of your platform(s). > > > +#if !defined(NO_ALPHABLEND) > > > + if (m_opacity < 1. || !use16bit) { > > > + const BLENDFUNCTION blend = { AC_SRC_OVER, 0 > > > + , m_opacity >= 1. ? 255 : (BYTE)(m_opacity * 255) > > > + , use16bit ? 0 : AC_SRC_ALPHA }; > > > + AlphaBlend > > > + (m_dc > > > + , origRect.x() > > > + , origRect.y() > > > + , origRect.width() > > > + , origRect.height() > > > + , hdc > > > + , 0 > > > + , 0 > > > + , bmpRect.right > > > + , bmpRect.bottom > > > + , blend > > > + ); > > > > I've never seen this one-parameter-per-line style anywhere else in WebKit. I'm > > not sure it's a good idea to introduce it here. (applies elsewhere) > > It makes code much more readable when there are too many arguments. It makes it more readable if you're used to this style and if it's used elsewhere in the code. We try to maintain a consistent coding style in WebKit because we think it's a lot easier to read the code if the same style is used everywhere. I won't r- the patch just for this issue, but I strongly recommend that you format your code to match the WebKit coding style, so that WebKit's code can continue being consistent (and therefore easier to read as a whole). > > > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > > > + else > > > + *dest++ |= 0xFF; > > > + } > > > + dest += padding; > > > + } > > > + } > > > +} > > > > It would be nice to have a little less duplication in this function. > > Performance vs code size... that's a fight. Would an inline function really affect performance? > > > + : m_data(data) > > > + , m_origRect(origRect) > > > + , m_oldOpacity(data->m_opacity) > > > > It seems error-prone to leave m_key1 and m_key2 uninitialized here. > > m_key1 and m_key2 will be set up by ->getDC(). In many cases, they are not used > at all. Performance consideration. I saw that they get initialized in getDC. My concern was if someone were to add code to use these members elsewhere, and didn't realize they don't get initialized by the constructor. Have you seen evidence that initializing these members affects performance? It would surprise me if so, but again I don't know the details of your platform(s). > > > + if (fillColor().alpha()) { > > > + brush = createBrush(fillColor()); > > > + oldBrush = SelectObject(dc, brush); > > > + } else { > > > + SelectObject(dc, GetStockObject(NULL_BRUSH)); > > > + } > > > > We don't put braces around the bodies of single-line branches. > > We will follow the rules if we have to. But I really don't like this rule. > consider this: > > if () { > 2 lines here > } else > one line code; > else if { > 2 lines here > } > > It looks so terrible. Even this case > > if () { > one line code; > } > > I cannot see nothing wrong with it. I agree that there are some cases where omitting the braces looks funny/bad. But see my comments above about maintaining a consistent coding style throughout WebKit. > > > +void GraphicsContext::fillRect(const FloatRect& rect, const Color& color) > > > +{ > > > + if (paintingDisabled() || !m_data->m_opacity) > > > + return; > > > + > > > + if (int alpha = color.alpha()) { > > > + OwnPtr<HBRUSH> hbrush(CreateSolidBrush(RGB(color.red(), color.green(), color.blue()))); > > > + if (hbrush) { > > > + ScopeDCProvider dcProvider(m_data); > > > + if (m_data->m_dc) { > > > + IntRect intRect = enclosingIntRect(rect); > > > + TransparentLayerDC transparentDc(m_data, m_data->mapRect(intRect), &intRect); > > > + if (transparentDc.hdc()) > > > + if (alpha == 0xFF) > > > + FillRect(transparentDc.hdc(), &transparentDc.rect(), hbrush.get()); > > > + else > > > + fillRectWithAlpha(transparentDc.hdc(), &transparentDc.rect(), hbrush.get(), alpha); > > > + } > > > + } > > > + } > > > +} > > > > This function would benefit from reducing nesting by using early returns. > > By benefit, do you mean it runs faster? No, I meant that it would be more readable for someone who is accustomed to WebKit's coding style. > Personally, I don't like too many > "return" in a function. it's just like "goto", which makes code more difficult > to maintain & review. Early returns are an idiom we use throughout WebKit. One specific reason we use them is to avoid nesting and all the extra indentation it brings. > > > +#define isCharVisible(c) ((c) && (c) != zeroWidthSpace) > > > > This would be better as an inline helper function. > > Only concern is inline function is not inline in debug version, and it makes > debug version run much slower. One advantage of an function instead of a macro is that it gives you stronger type safety. > > > + > > > + if (hFont) { > > > > If you put the !hFont case first, you can add an early return at the end of it, > > and add early returns throughout the rest of the function to reduce nesting. > > i.e.,: > > > > if (!hFont) { > > ....the current else case goes here.... > > return; > > } > > > > ....the rest of the code goes here, hopefully with more early returns.... > > Later, if we want to add more code at the end to clean up something, we have to > make it nested again. Are you expecting to add something like that in the future? If not, it seems a bit premature to be structuring the code in ways that make certain unplanned future changes easier. > > > + HGDIOBJ hOldFont = SelectObject(m_data->m_dc, hFont); > > > + // transparent always... > > > + int oldBkMode = GetBkMode(m_data->m_dc); > > > > What does this comment mean? > > BkMode is always transparent. oldBkMode? Or the new one that you're setting? 133128 11 aroben 2009-07-20 07:06:50 -0700 (In reply to comment #8) > Oops: lround does different thing: > > inline long lround(double num) { return static_cast<long>(num > 0 ? num + 0.5 : > ceil(num - 0.5)); } > > What we want in GraphicsContextWince.cpp is to round -0.5 to 0, as 0.5 is > rounded to 1, so that the rendering behavior is consistent when offset varies. > > but lround(-0.5) will return -1. In that case I'd recommend giving your function a different name, so that its difference in behavior from the standard functions will be more clear. 133129 12 yong.li.webkit 2009-07-20 07:12:06 -0700 (In reply to comment #11) > (In reply to comment #8) > > Oops: lround does different thing: > > > > inline long lround(double num) { return static_cast<long>(num > 0 ? num + 0.5 : > > ceil(num - 0.5)); } > > > > What we want in GraphicsContextWince.cpp is to round -0.5 to 0, as 0.5 is > > rounded to 1, so that the rendering behavior is consistent when offset varies. > > > > but lround(-0.5) will return -1. > > In that case I'd recommend giving your function a different name, so that its > difference in behavior from the standard functions will be more clear. yes. I'm going to change it to safeRound() or something else 133130 13 yong.li.webkit 2009-07-20 07:13:30 -0700 (In reply to comment #10) I'm modifying it to match the webkit coding styles. Thanks a lot. 133137 14 yong.li.webkit 2009-07-20 07:52:12 -0700 (In reply to comment #9) > (In reply to comment #6) > > > > + PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, bool uses16bit, RECT& bmpRect, bool checkClipBox, bool force) > > > > > > It seems strange to use a mix of IntRect and RECT in this declaration. (applies > > > elsewhere) > > > > To avoid converting IntRect and RECT too frequently. > > Have you noticed IntRect <-> RECT conversions showing up on performance > profiles? It seems like it would be dwarfed by the actual painting calls. But I > don't know the performance characteristics of your platform(s). > IntRect contains x, y, width and height, where RECT contains top, left, right, bottom. Obviously every conversion involves "+" or "-" operations. > > > > + *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000; > > > > + else > > > > + *dest++ |= 0xFF; > > > > + } > > > > + dest += padding; > > > > + } > > > > + } > > > > +} > > > > > > It would be nice to have a little less duplication in this function. > > > > Performance vs code size... that's a fight. > > Would an inline function really affect performance? Those 2 blocks are not exactly same. If I want to make them share one piece of code, I have to introduce some Boolean variables and check them in every cycle (for every pixel). This has nothing to do with inline. > > > > > + : m_data(data) > > > > + , m_origRect(origRect) > > > > + , m_oldOpacity(data->m_opacity) > > > > > > It seems error-prone to leave m_key1 and m_key2 uninitialized here. > > > > m_key1 and m_key2 will be set up by ->getDC(). In many cases, they are not used > > at all. Performance consideration. > > I saw that they get initialized in getDC. My concern was if someone were to add > code to use these members elsewhere, and didn't realize they don't get > initialized by the constructor. Have you seen evidence that initializing these > members affects performance? It would surprise me if so, but again I don't know > the details of your platform(s). > They are supposed to be used only in special cases. I'll add some comments for that. 133160 15 33091 yong.li.webkit 2009-07-20 09:59:52 -0700 Created attachment 33091 coding style modifications and latest fixes modified to follow WEBKIT coding style rules 133174 16 33091 aroben 2009-07-20 11:17:32 -0700 Comment on attachment 33091 coding style modifications and latest fixes > +#include "wtf/OwnPtr.h" "wtf/OwnPtr.h" should be <wtf/OwnPtr.h> (with angle brackets instead of quotes). > +struct RotationTransform > +{ The opening brace for type declarations (struct, class, enum) should be on the same line as the type name. (Note that this differs from the rule for functions.) (applies elsewhere) > + IntPoint origin() This can be a const member function. > + IntRect mapRect(const IntRect& rect) > + { > + return m_transform.mapRect(rect); > + } > + > + FloatRect mapRect(const FloatRect& rect) > + { > + return m_transform.mapRect(rect); > + } > + > + IntPoint mapPoint(const IntPoint& point) > + { > + return m_transform.mapPoint(point); > + } > + > + FloatPoint mapPoint(const FloatPoint& point) > + { > + return m_transform.mapPoint(point); > + } > + > + FloatSize mapSize(const FloatSize& size) > + { > + double w, h; > + m_transform.map(size.width(), size.height(), w, h); > + return FloatSize(static_cast<float>(w), static_cast<float>(h)); > + } These can be const member functions. > + PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, AlphaPaintType alphaPaint, RECT& bmpRect, bool checkClipBox, bool force) > + { > + if (m_opacity <= 0) > + return 0; > + > + if (force || m_opacity < 1.) { > + if (checkClipBox) { > + RECT clipBox; > + int clipType = GetClipBox(m_dc, &clipBox); > + if (clipType == SIMPLEREGION || clipType == COMPLEXREGION) > + origRect.intersect(clipBox); > + if (origRect.isEmpty()) > + return 0; > + } > + > + RefPtr<SharedBitmap> bmp = SharedBitmap::createInstance(alphaPaint == AlphaPaintNone, origRect.width(), origRect.height(), false); > + SetRect(&bmpRect, 0, 0, origRect.width(), origRect.height()); > + if (bmp) { > + switch (alphaPaint) { > + case AlphaPaintNone: > + case AlphaPaintImage: > + { > + SharedBitmap::DCHolder dc(bmp.get()); > + if (dc.get()) { > + BitBlt(dc.get(), 0, 0, origRect.width(), origRect.height(), m_dc, origRect.x(), origRect.y(), SRCCOPY); > + if (bmp->is32bit() && (!m_bitmap || m_bitmap->is16bit())) { > + // Set alpha channel > + unsigned* pixels = (unsigned*)bmp->bytes(); Please use a C++-style cast here. > +template <typename PixelType, bool Is16bit> void _rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform) This can be marked "static" so it gets internal linkage. > +{ > + int destW = destBmp->width(); > + int destH = destBmp->height(); > + int sourceW = sourceBmp->width(); > + int sourceH = sourceBmp->height(); > + PixelType* dest = (PixelType*)destBmp->bytes(); > + const PixelType* source = (const PixelType*)sourceBmp->bytes(); Please use C++-style casts here. > +void rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform) This can be marked "static" so it gets internal linkage. > +void GraphicsContext::drawRect(const IntRect& rect) > +{ > + if (!m_data->m_opacity || paintingDisabled() || rect.width() <= 0 || rect.height() <= 0) > + return; I thought you were going to use rect.isEmpty() instead of the width() and height() checks? > +#define EQUAL_ANGLE(a, b) (fabs((a) - (b)) < 1e-5) An inline function would be nicer. > +void GraphicsContext::setPlatformShouldAntialias(bool should) > +{ > + (void)should; > + notImplemented(); > +} > + > +void GraphicsContext::setLineDash(const DashArray&, float dashOffset) > +{ > + (void)dashOffset; > + notImplemented(); > +} As I said before, you should either use UNUSED_PARAM from wtf/UnusedParam.h, or omit the parameter names entirely. This patch still has many instances of names like "transparentDc" instead of "transparentDC", and still has the single-parameter-per-line style for some function calls. Please fix those. 133180 17 yong.li.webkit 2009-07-20 11:42:34 -0700 (In reply to comment #16) > (From update of attachment 33091 [details]) > > > > + IntPoint origin() > > This can be a const member function. > Sorry, I forgot to check complete list in last update. I'm cleaning it up carefully now. BTW, in GraphicsContext.h class GraphicsContext { ... IntPoint origin(); ... Should origin() be "const" here? 133183 18 aroben 2009-07-20 11:47:50 -0700 (In reply to comment #17) > (In reply to comment #16) > > (From update of attachment 33091 [details] [details]) > > > > > > > + IntPoint origin() > > > > This can be a const member function. > > > > Sorry, I forgot to check complete list in last update. I'm cleaning it up > carefully now. Thanks! > BTW, in GraphicsContext.h > > class GraphicsContext { > ... > IntPoint origin(); > ... > > Should origin() be "const" here? Probably. It certainly seems like it should be "const". It could be that there's something preventing it from being const, or it could just be an oversight. 133191 19 33098 yong.li.webkit 2009-07-20 12:10:40 -0700 Created attachment 33098 more modifications for coding style more modifications for coding style 133201 20 33098 aroben 2009-07-20 12:46:16 -0700 Comment on attachment 33098 more modifications for coding style > +#include "wtf/OwnPtr.h" This should be <wtf/OwnPtr.h>, with angle brackets. r=me. Maybe the committer can fix the above before committing. 133206 21 manyoso 2009-07-20 13:09:01 -0700 Landed with r46129. 32884 2009-07-16 10:19:52 -0700 2009-07-17 19:59:26 -0700 Adds GraphicsContextWince.cpp 27349.patch text/plain 66068 manyoso ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg M2IxOGNhYi4uYTA3MDhhYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMTUgQEAKKzIwMDktMDctMTYgIFlvbmcgTGkgIDx5 b25nLmxpQHRvcmNobW9iaWxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjczNDkKKyAgICAgICAgQWRkIEdyYXBoaWNzQ29udGV4dCBpbXBsZW1lbnRhdGlvbiBmb3IgdGhl IFdpbkNFIHBvcnQuCisKKyAgICAgICAgV3JpdHRlbiBieSBZb25nIExpIDx5b25nLmxpQHRvcmNo bW9iaWxlLmNvbT4gYW5kIEdlb3JnZSBTdGFpa29zIDxnZW9yZ2Uuc3RhaWtvc0B0b3JjaG1vYmls ZS5jb20+CisgICAgICAgIHdpdGggdHJpdmlhbCBzdHlsZSBmaXhlcyBieSBBZGFtIFRyZWF0IDxh ZGFtLnRyZWF0QHRvcmNobW9iaWxlLmNvbT4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L3dpbmNlL0dyYXBoaWNzQ29udGV4dFdpbmNlLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3Jl Ojppc1plcm8pOgorICAgICAgICAoV2ViQ29yZTo6Um91bmQpOgorICAgICAgICAoV2ViQ29yZTo6 cm91bmRSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OlJvdGF0aW9uVHJhbnNmb3JtOjpSb3RhdGlv blRyYW5zZm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpSb3RhdGlvblRyYW5zZm9ybTo6b3BlcmF0 b3ItKToKKyAgICAgICAgKFdlYkNvcmU6OlJvdGF0aW9uVHJhbnNmb3JtOjptYXApOgorICAgICAg ICAoV2ViQ29yZTo6bWFwUG9pbnQpOgorICAgICAgICAoV2ViQ29yZTo6bWFwUmVjdCk6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGVEYXRhOjpHcmFwaGlj c0NvbnRleHRQbGF0Zm9ybVByaXZhdGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKToK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6fkdyYXBo aWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0Nv bnRleHRQbGF0Zm9ybVByaXZhdGU6Om9yaWdpbik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6OnRyYW5zbGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6OnNjYWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6cm90YXRlKToKKyAgICAgICAgKFdlYkNv cmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6Y29uY2F0Q1RNKToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6bWFwUmVjdCk6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6Om1hcFBvaW50KToK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZTo6bWFwU2l6 ZSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6OnNh dmUpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlOjpy ZXN0b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0 ZTo6Z2V0VHJhbnNwYXJlbnRMYXllckJpdG1hcCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6OnBhaW50QmFja1RyYW5zcGFyZW50TGF5ZXJCaXRtYXAp OgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlUGVuKToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUJydXNoKToKKyAgICAgICAgKFdlYkNvcmU6OnJvdGF0ZUJpdG1hcCk6CisgICAgICAgIChXZWJD b3JlOjpUcmFuc3BhcmVudExheWVyREM6OlRyYW5zcGFyZW50TGF5ZXJEQyk6CisgICAgICAgIChX ZWJDb3JlOjpUcmFuc3BhcmVudExheWVyREM6On5UcmFuc3BhcmVudExheWVyREMpOgorICAgICAg ICAoV2ViQ29yZTo6VHJhbnNwYXJlbnRMYXllckRDOjpoZGMpOgorICAgICAgICAoV2ViQ29yZTo6 VHJhbnNwYXJlbnRMYXllckRDOjpyZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OlRyYW5zcGFyZW50 TGF5ZXJEQzo6dG9TaGlmdCk6CisgICAgICAgIChXZWJDb3JlOjpTY29wZURDUHJvdmlkZXI6OlNj b3BlRENQcm92aWRlcik6CisgICAgICAgIChXZWJDb3JlOjpTY29wZURDUHJvdmlkZXI6On5TY29w ZURDUHJvdmlkZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpHcmFwaGlj c0NvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Ojp+R3JhcGhpY3ND b250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2V0Qml0bWFwKToK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6Z2V0V2luZG93c0NvbnRleHQpOgor ICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpyZWxlYXNlV2luZG93c0NvbnRleHQp OgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzYXZlUGxhdGZvcm1TdGF0ZSk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnJlc3RvcmVQbGF0Zm9ybVN0YXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6ZHJhd1JlY3QpOgorICAgICAg ICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpkcmF3TGluZSk6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQ6OmRyYXdFbGxpcHNlKToKKyAgICAgICAgKFdlYkNvcmU6OmdldEVs bGlwc2VQb2ludEJ5QW5nbGUpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RWxsaXBzZVkpOgorICAg ICAgICAoV2ViQ29yZTo6Z2V0RWxsaXBzZVgpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3ND b250ZXh0OjpzdHJva2VBcmMpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Ojpk cmF3Q29udmV4UG9seWdvbik6CisgICAgICAgIChXZWJDb3JlOjpmaWxsUmVjdFdpdGhBbHBoYSk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6Y2xpcCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFw aGljc0NvbnRleHQ6OmNsaXBPdXQpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0 OjpkcmF3Rm9jdXNSaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6ZHJh d0xpbmVGb3JUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6ZHJhd0xp bmVGb3JNaXNzcGVsbGluZ09yQmFkR3JhbW1hcik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHQ6OnNldFBsYXRmb3JtRmlsbENvbG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TdHJva2VDb2xvcik6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHQ6OnNldFBsYXRmb3JtU3Ryb2tlVGhpY2tuZXNzKToKKyAgICAgICAgKFdl YkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQ6OmFkZElubmVyUm91bmRlZFJlY3RDbGlwKToKKyAgICAgICAgKFdl YkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6Y2xlYXJSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dDo6c3Ryb2tlUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0Nv bnRleHQ6OmJlZ2luVHJhbnNwYXJlbmN5TGF5ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhp Y3NDb250ZXh0OjplbmRUcmFuc3BhcmVuY3lMYXllcik6CisgICAgICAgIChXZWJDb3JlOjpHcmFw aGljc0NvbnRleHQ6OmNvbmNhdENUTSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQ6OmFmZmluZVRyYW5zZm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6 OnJlc2V0QWZmaW5lVHJhbnNmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6dHJhbnNsYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6cm90YXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6b3JpZ2luKToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6R3Jh cGhpY3NDb250ZXh0OjptYXBSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6bWFwUG9pbnQpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjptYXBTaXpl KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2V0TGluZUNhcCk6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnNldExpbmVKb2luKToKKyAgICAgICAgKFdl YkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2V0TWl0ZXJMaW1pdCk6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQ6OnNldEFscGhhKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDo6c2V0Q29tcG9zaXRlT3BlcmF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDo6YmVnaW5QYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6YWRkUGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OmNsaXBPdXRF bGxpcHNlSW5SZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6ZmlsbFJv dW5kZWRSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6cm91bmRUb0Rl dmljZVBpeGVscyk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OmZpbGxQYXRo KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c3Ryb2tlUGF0aCk6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OmdldENUTSk6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQ6OmNsaXBUb0ltYWdlQnVmZmVyKToKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TaGFkb3cpOgorICAgICAgICAoV2ViQ29yZTo6 R3JhcGhpY3NDb250ZXh0OjpjbGVhclBsYXRmb3JtU2hhZG93KToKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDo6c2V0SW1hZ2VJbnRlcnBvbGF0aW9uUXVhbGl0eSk6CisgICAgICAg IChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OmRyYXdUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDo6ZHJhd0ZyYW1lQ29udHJvbCk6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHQ6OmRyYXdGb2N1c1JlY3QpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhp Y3NDb250ZXh0OjpwYWludFRleHRGaWVsZCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0Nv bnRleHQ6OmRyYXdCaXRtYXApOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Ojpk cmF3Qml0bWFwUGF0dGVybik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnNl dFBsYXRmb3JtU2hvdWxkQW50aWFsaWFzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDo6c2V0TGluZURhc2gpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Ojpj bGlwUGF0aCk6CisKIDIwMDktMDctMTUgIFNoaW5pY2hpcm8gSGFtYWppICA8aGFtYWppQGNocm9t aXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250ZXh0V2luY2UuY3Bw IGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRXaW5jZS5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGI0YWRiZQotLS0gL2Rldi9u dWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250ZXh0 V2luY2UuY3BwCkBAIC0wLDAgKzEsMTkwNiBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDct MjAwOSBUb3JjaCBNb2JpbGUgSW5jLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAq ICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAg WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZp bGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIlRyYW5zZm9ybWF0aW9u TWF0cml4LmgiCisjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRlICJ3aW5jZS9N ZW1vcnlNYW5hZ2VyLmgiCisjaW5jbHVkZSAiT3duUHRyLmgiCisjaW5jbHVkZSAiU2hhcmVkQml0 bWFwLmgiCisjaW5jbHVkZSAiUGF0aC5oIgorI2luY2x1ZGUgIlBsYXRmb3JtUGF0aFdpbmNlLmgi CisjaW5jbHVkZSAiR3JhZGllbnQuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHRQcml2YXRl LmgiCisjaW5jbHVkZSAiU2ltcGxlRm9udERhdGEuaCIKKyNpbmNsdWRlICJHbHlwaEJ1ZmZlci5o IgorI2luY2x1ZGUgIkNoYXJhY3Rlck5hbWVzLmgiCisjaW5jbHVkZSA8d2luZG93cy5oPgorCisj ZGVmaW5lIERSQVdfQVJDX0FMTF9QT0lOVFMgICAgICAgIDAKKyNkZWZpbmUgUEkgICAgICAgIDMu MTQxNTkyNjUzNTg5NzkzMjM4NDYKKyNkZWZpbmUgUkFESUFOKGEpICAgICgoYSkgKiBQSSAvIDE4 MC4pCisjZGVmaW5lIERFR1JFRShhKSAgICAoKGEpICogMTgwLiAvIFBJKQorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBpc1plcm8oZG91YmxlIGQpCit7CisgICAg cmV0dXJuIGQgPiAwID8gZCA8PSAxLkUtMTAgOiBkID49IC0xLkUtMTA7Cit9CisKK3N0YXRpYyBp bmxpbmUgaW50IFJvdW5kKGRvdWJsZSBkKQoreworICAgIGlmIChkID4gMCkKKyAgICAgICAgcmV0 dXJuIGludChkICsgMC41KTsKKyAgICBlbHNlIHsKKyAgICAgICAgaW50IGkgPSBpbnQoZCk7Cisg ICAgICAgIHJldHVybiBpIC0gZCA+IDAuNSA/IGkgLSAxIDogaTsKKyAgICB9Cit9CisKK3N0YXRp YyBpbmxpbmUgSW50UmVjdCByb3VuZFJlY3QoY29uc3QgRmxvYXRSZWN0JiByKQoreworICAgIHJl dHVybiBJbnRSZWN0KFJvdW5kKHIueCgpKSwgUm91bmQoci55KCkpLCBSb3VuZChyLnJpZ2h0KCkp IC0gUm91bmQoci54KCkpLCBSb3VuZChyLmJvdHRvbSgpKSAtIFJvdW5kKHIueSgpKSk7Cit9CisK Kworc3RydWN0IFJvdGF0aW9uVHJhbnNmb3JtIHsgLy8gT3JpZ2luICgwLCAwKQorICAgIGRvdWJs ZSBtX2Nvc0E7CisgICAgZG91YmxlIG1fc2luQTsKKyAgICBpbnQgbV9wcmVTaGlmdFg7CisgICAg aW50IG1fcHJlU2hpZnRZOworICAgIGludCBtX3Bvc3RTaGlmdFg7CisgICAgaW50IG1fcG9zdFNo aWZ0WTsKKyAgICBSb3RhdGlvblRyYW5zZm9ybSgpCisgICAgICAgIDogbV9jb3NBKDEuKQorICAg ICAgICAsIG1fc2luQSgwLikKKyAgICAgICAgLCBtX3ByZVNoaWZ0WCgwKQorICAgICAgICAsIG1f cHJlU2hpZnRZKDApCisgICAgICAgICwgbV9wb3N0U2hpZnRYKDApCisgICAgICAgICwgbV9wb3N0 U2hpZnRZKDApCisgICAgeworICAgIH0KKyAgICBSb3RhdGlvblRyYW5zZm9ybSBvcGVyYXRvci0o KSBjb25zdAorICAgIHsKKyAgICAgICAgUm90YXRpb25UcmFuc2Zvcm0gcnRuOworICAgICAgICBy dG4ubV9jb3NBID0gbV9jb3NBOworICAgICAgICBydG4ubV9zaW5BID0gLW1fc2luQTsKKyAgICAg ICAgcnRuLm1fcHJlU2hpZnRYID0gbV9wb3N0U2hpZnRYOworICAgICAgICBydG4ubV9wcmVTaGlm dFkgPSBtX3Bvc3RTaGlmdFk7CisgICAgICAgIHJ0bi5tX3Bvc3RTaGlmdFggPSBtX3ByZVNoaWZ0 WDsKKyAgICAgICAgcnRuLm1fcG9zdFNoaWZ0WSA9IG1fcHJlU2hpZnRZOworICAgICAgICByZXR1 cm4gcnRuOworICAgIH0KKyAgICB2b2lkIG1hcChkb3VibGUgeDEsIGRvdWJsZSB5MSwgZG91Ymxl KiB4MiwgZG91YmxlKiB5MikgY29uc3QKKyAgICB7CisgICAgICAgIHgxICs9IG1fcHJlU2hpZnRY OworICAgICAgICB5MSArPSBtX3ByZVNoaWZ0WTsKKyAgICAgICAgKngyID0geDEgKiBtX2Nvc0Eg KyB5MSAqIG1fc2luQSArIG1fcG9zdFNoaWZ0WDsKKyAgICAgICAgKnkyID0geTEgKiBtX2Nvc0Eg LSB4MSAqIG1fc2luQSArIG1fcG9zdFNoaWZ0WTsKKyAgICB9CisgICAgdm9pZCBtYXAoaW50IHgx LCBpbnQgeTEsIGludCogeDIsIGludCogeTIpIGNvbnN0CisgICAgeworICAgICAgICB4MSArPSBt X3ByZVNoaWZ0WDsKKyAgICAgICAgeTEgKz0gbV9wcmVTaGlmdFk7CisgICAgICAgICp4MiA9IFJv dW5kKHgxICogbV9jb3NBICsgeTEgKiBtX3NpbkEpICsgbV9wb3N0U2hpZnRYOworICAgICAgICAq eTIgPSBSb3VuZCh5MSAqIG1fY29zQSAtIHgxICogbV9zaW5BKSArIG1fcG9zdFNoaWZ0WTsKKyAg ICB9Cit9OworCit0ZW1wbGF0ZTxjbGFzcyBUPiBzdGF0aWMgaW5saW5lCitJbnRQb2ludCBtYXBQ b2ludChjb25zdCBJbnRQb2ludCYgcCwgY29uc3QgVCYgdCkKK3sKKyAgICBpbnQgeCwgeTsKKyAg ICB0Lm1hcChwLngoKSwgcC55KCksICZ4LCAmeSk7CisgICAgcmV0dXJuIEludFBvaW50KHgsIHkp OworfQordGVtcGxhdGU8Y2xhc3MgVD4gc3RhdGljIGlubGluZQorRmxvYXRQb2ludCBtYXBQb2lu dChjb25zdCBGbG9hdFBvaW50JiBwLCBjb25zdCBUJiB0KQoreworICAgIGRvdWJsZSB4LCB5Owor ICAgIHQubWFwKHAueCgpLCBwLnkoKSwgJngsICZ5KTsKKyAgICByZXR1cm4gRmxvYXRQb2ludChz dGF0aWNfY2FzdDxmbG9hdD4oeCksIHN0YXRpY19jYXN0PGZsb2F0Pih5KSk7Cit9CisKK3RlbXBs YXRlPGNsYXNzIFRyYW5zZm9ybSwgY2xhc3MgUmVjdCwgY2xhc3MgVmFsdWU+IHN0YXRpYyBpbmxp bmUKK1JlY3QgbWFwUmVjdChjb25zdCBSZWN0JiByZWN0LCBjb25zdCBUcmFuc2Zvcm0mIHRyYW5z Zm9ybSkKK3sKKyAgICBWYWx1ZSB4WzRdLCB5WzRdOworICAgIFZhbHVlIGwsIHQsIHIsIGI7Cisg ICAgciA9IHJlY3QucmlnaHQoKSAtIDE7CisgICAgYiA9IHJlY3QuYm90dG9tKCkgLSAxOworICAg IHRyYW5zZm9ybS5tYXAocmVjdC54KCksIHJlY3QueSgpLCB4LCB5KTsKKyAgICB0cmFuc2Zvcm0u bWFwKHJlY3QueCgpLCBiLCB4ICsgMSwgeSArIDEpOworICAgIHRyYW5zZm9ybS5tYXAociwgYiwg eCArIDIsIHkgKyAyKTsKKyAgICB0cmFuc2Zvcm0ubWFwKHIsIHJlY3QueSgpLCB4ICsgMywgeSAr IDMpOworICAgIGwgPSByID0geFszXTsKKyAgICB0ID0gYiA9IHlbM107CisgICAgZm9yIChpbnQg aSA9IDA7IGkgPCAzOyArK2kpIHsKKyAgICAgICAgaWYgKHhbaV0gPCBsKQorICAgICAgICAgICAg bCA9IHhbaV07CisgICAgICAgIGVsc2UgaWYgKHhbaV0gPiByKQorICAgICAgICAgICAgciA9IHhb aV07CisKKyAgICAgICAgaWYgKHlbaV0gPCB0KQorICAgICAgICAgICAgdCA9IHlbaV07CisgICAg ICAgIGVsc2UgaWYgKHlbaV0gPiBiKQorICAgICAgICAgICAgYiA9IHlbaV07CisgICAgfQorCisg ICAgcmV0dXJuIEludFJlY3QobCwgdCwgciAtIGwgKyAxLCBiIC0gdCArIDEpOworfQorCit0ZW1w bGF0ZTxjbGFzcyBUPiBzdGF0aWMgaW5saW5lCitJbnRSZWN0IG1hcFJlY3QoY29uc3QgSW50UmVj dCYgcmVjdCwgY29uc3QgVCYgdHJhbnNmb3JtKQoreworICAgIHJldHVybiBtYXBSZWN0PFQsIElu dFJlY3QsIGludD4ocmVjdCwgdHJhbnNmb3JtKTsKK30KKwordGVtcGxhdGU8Y2xhc3MgVD4gc3Rh dGljIGlubGluZQorRmxvYXRSZWN0IG1hcFJlY3QoY29uc3QgRmxvYXRSZWN0JiByZWN0LCBjb25z dCBUJiB0cmFuc2Zvcm0pCit7CisgICAgcmV0dXJuIG1hcFJlY3Q8VCwgRmxvYXRSZWN0LCBkb3Vi bGU+KHJlY3QsIHRyYW5zZm9ybSk7Cit9CisKK3N0cnVjdCBHcmFwaGljc0NvbnRleHRQbGF0Zm9y bVByaXZhdGVEYXRhIHsKKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBtX3RyYW5zZm9ybTsKKyAg ICBmbG9hdCBtX29wYWNpdHk7CisgICAgVmVjdG9yPFBhdGg+IG1fcGF0aHM7CisgICAgR3JhcGhp Y3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlRGF0YSgpCisgICAgICAgIDogbV90cmFuc2Zvcm0oKQor ICAgICAgICAsIG1fb3BhY2l0eSgxLjApCisgICAge30KK307CisKK2NsYXNzIEdyYXBoaWNzQ29u dGV4dFBsYXRmb3JtUHJpdmF0ZSA6IHB1YmxpYyBHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZh dGVEYXRhIHsKK3B1YmxpYzoKKyAgICBHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGUoSERD IGRjKQorICAgICAgICA6IG1fZGMoZGMpCisgICAgeworICAgICAgICBIREMgaFNjcmVlbkRDID0g OjpHZXREQygwKTsKKyAgICAgICAgaW50IHJ0biA9IDo6R2V0RGV2aWNlQ2FwcyhoU2NyZWVuREMs IFJBU1RFUkNBUFMpOworICAgICAgICA6OlJlbGVhc2VEQygwLCBoU2NyZWVuREMpOworICAgIH0K KyAgICB+R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKCkKKyAgICB7CisgICAgICAgIHdo aWxlICghbV9iYWNrdXBEYXRhLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlc3RvcmUoKTsKKyAg ICB9CisKKyAgICBJbnRQb2ludCBvcmlnaW4oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIEludFBv aW50KFJvdW5kKC1tX3RyYW5zZm9ybS5lKCkpLAorICAgICAgICAgICAgICAgIFJvdW5kKC1tX3Ry YW5zZm9ybS5mKCkpKTsKKyAgICB9CisKKyAgICAvLyBUZW1wb3Jhcnkgc29sdXRpb24KKyAgICB2 b2lkIHRyYW5zbGF0ZShmbG9hdCB4LCBmbG9hdCB5KQorICAgIHsKKyAgICAgICAgbV90cmFuc2Zv cm0udHJhbnNsYXRlKHgsIHkpOworICAgIH0KKworICAgIHZvaWQgc2NhbGUoY29uc3QgRmxvYXRT aXplJiBzaXplKQorICAgIHsKKyAgICAgICAgbV90cmFuc2Zvcm0uc2NhbGVOb25Vbmlmb3JtKHNp emUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSk7CisgICAgfQorCisgICAgdm9pZCByb3RhdGUoZmxv YXQgcmFkaWFucykKKyAgICB7CisgICAgICAgIG1fdHJhbnNmb3JtLnJvdGF0ZShERUdSRUUocmFk aWFucykpOworICAgIH0KKworICAgIHZvaWQgIGNvbmNhdENUTShjb25zdCBUcmFuc2Zvcm1hdGlv bk1hdHJpeCYgdHJhbnNmb3JtKQorICAgIHsKKyAgICAgICAgbV90cmFuc2Zvcm0gPSB0cmFuc2Zv cm0gKiBtX3RyYW5zZm9ybTsKKyAgICB9CisKKyAgICBJbnRSZWN0IG1hcFJlY3QoY29uc3QgSW50 UmVjdCYgcmVjdCkKKyAgICB7CisgICAgICAgIHJldHVybiBtX3RyYW5zZm9ybS5tYXBSZWN0KHJl Y3QpOworICAgIH0KKyAgICBGbG9hdFJlY3QgbWFwUmVjdChjb25zdCBGbG9hdFJlY3QmIHJlY3Qp CisgICAgeworICAgICAgICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUmVjdChyZWN0KTsKKyAgICB9 CisgICAgSW50UG9pbnQgbWFwUG9pbnQoY29uc3QgSW50UG9pbnQmIHBvaW50KQorICAgIHsKKyAg ICAgICAgcmV0dXJuIG1fdHJhbnNmb3JtLm1hcFBvaW50KHBvaW50KTsKKyAgICB9CisgICAgRmxv YXRQb2ludCBtYXBQb2ludChjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKKyAgICB7CisgICAgICAg IHJldHVybiBtX3RyYW5zZm9ybS5tYXBQb2ludChwb2ludCk7CisgICAgfQorICAgIEZsb2F0U2l6 ZSBtYXBTaXplKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkKKyAgICB7CisgICAgICAgIGRvdWJsZSB3 LCBoOworICAgICAgICBtX3RyYW5zZm9ybS5tYXAoc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgp LCB3LCBoKTsKKyAgICAgICAgcmV0dXJuIEZsb2F0U2l6ZSh3LCBoKTsKKyAgICB9CisKKyAgICB2 b2lkIHNhdmUoKQorICAgIHsKKyAgICAgICAgaWYgKG1fZGMpCisgICAgICAgICAgICBTYXZlREMo bV9kYyk7CisgICAgICAgIG1fYmFja3VwRGF0YS5hcHBlbmQoKnN0YXRpY19jYXN0PEdyYXBoaWNz Q29udGV4dFBsYXRmb3JtUHJpdmF0ZURhdGEqPih0aGlzKSk7CisgICAgfQorCisgICAgdm9pZCBy ZXN0b3JlKCkKKyAgICB7CisgICAgICAgIGlmIChtX2JhY2t1cERhdGEuaXNFbXB0eSgpKQorICAg ICAgICAgICAgcmV0dXJuOworCisgICAgICAgIGlmIChtX2RjKQorICAgICAgICAgICAgUmVzdG9y ZURDKG1fZGMsIC0xKTsKKworICAgICAgICBHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGVE YXRhOjpvcGVyYXRvcj0obV9iYWNrdXBEYXRhLmxhc3QoKSk7CisgICAgICAgIG1fYmFja3VwRGF0 YS5yZW1vdmVMYXN0KCk7CisgICAgfQorCisgICAgUGFzc1JlZlB0cjxTaGFyZWRCaXRtYXA+IGdl dFRyYW5zcGFyZW50TGF5ZXJCaXRtYXAoSW50UmVjdCYgb3JpZ1JlY3QsIGJvb2wgdXNlczE2Yml0 LCBSRUNUJiBibXBSZWN0LCBib29sIGNoZWNrQ2xpcEJveCwgYm9vbCBmb3JjZSkKKyAgICB7Cisg ICAgICAgIGlmIChtX29wYWNpdHkgPD0gMCkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAg ICBlbHNlIGlmIChmb3JjZSB8fCBtX29wYWNpdHkgPCAxLikgIHsKKyAgICAgICAgICAgIGlmIChj aGVja0NsaXBCb3gpIHsKKyAgICAgICAgICAgICAgICBSRUNUIGNsaXBCb3g7CisgICAgICAgICAg ICAgICAgaW50IGNsaXBUeXBlID0gR2V0Q2xpcEJveChtX2RjLCAmY2xpcEJveCk7CisgICAgICAg ICAgICAgICAgaWYgKGNsaXBUeXBlID09IFNJTVBMRVJFR0lPTiB8fCBjbGlwVHlwZSA9PSBDT01Q TEVYUkVHSU9OKQorICAgICAgICAgICAgICAgICAgICBvcmlnUmVjdC5pbnRlcnNlY3QoY2xpcEJv eCk7CisgICAgICAgICAgICAgICAgaWYgKG9yaWdSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBSZWZQdHI8U2hh cmVkQml0bWFwPiBibXAgPSBTaGFyZWRCaXRtYXA6OmNyZWF0ZUluc3RhbmNlKHVzZXMxNmJpdCwg b3JpZ1JlY3Qud2lkdGgoKSwgb3JpZ1JlY3QuaGVpZ2h0KCksIGZhbHNlKTsKKyAgICAgICAgICAg IGlmIChibXApIHsKKyAgICAgICAgICAgICAgICBTaGFyZWRCaXRtYXA6OkRDSG9sZGVyIGRjKGJt cC5nZXQoKSk7CisgICAgICAgICAgICAgICAgaWYgKGRjLmdldCgpKSB7CisgICAgICAgICAgICAg ICAgICAgIEJpdEJsdChkYy5nZXQoKSwgMCwgMCwgb3JpZ1JlY3Qud2lkdGgoKSwgb3JpZ1JlY3Qu aGVpZ2h0KCksIG1fZGMsIG9yaWdSZWN0LngoKSwgb3JpZ1JlY3QueSgpLCBTUkNDT1BZKTsKKyAg ICAgICAgICAgICAgICAgICAgU2V0UmVjdCgmYm1wUmVjdCwgMCwgMCwgb3JpZ1JlY3Qud2lkdGgo KSwgb3JpZ1JlY3QuaGVpZ2h0KCkpOworICAgICAgICAgICAgICAgICAgICByZXR1cm4gYm1wOwor ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIGJt cFJlY3QgPSBvcmlnUmVjdDsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgICAgdm9pZCBw YWludEJhY2tUcmFuc3BhcmVudExheWVyQml0bWFwKEhEQyBoZGMsIGNvbnN0IEludFJlY3QmIG9y aWdSZWN0LCBib29sIHVzZTE2Yml0LCBjb25zdCBSRUNUJiBibXBSZWN0KQorICAgIHsKKyAgICAg ICAgaWYgKGhkYyA9PSBtX2RjKQorICAgICAgICAgICAgcmV0dXJuOworCisjaWYgIWRlZmluZWQo Tk9fQUxQSEFCTEVORCkKKyAgICAgICAgaWYgKG1fb3BhY2l0eSA8IDEuIHx8ICF1c2UxNmJpdCkg eworICAgICAgICAgICAgY29uc3QgQkxFTkRGVU5DVElPTiBibGVuZCA9IHsgQUNfU1JDX09WRVIs IDAKKyAgICAgICAgICAgICAgICAsIG1fb3BhY2l0eSA+PSAxLiA/IDI1NSA6IChCWVRFKShtX29w YWNpdHkgKiAyNTUpCisgICAgICAgICAgICAgICAgLCB1c2UxNmJpdCA/IDAgOiBBQ19TUkNfQUxQ SEEgfTsKKyAgICAgICAgICAgIEFscGhhQmxlbmQKKyAgICAgICAgICAgICAgICAobV9kYworICAg ICAgICAgICAgICAgICwgb3JpZ1JlY3QueCgpCisgICAgICAgICAgICAgICAgLCBvcmlnUmVjdC55 KCkKKyAgICAgICAgICAgICAgICAsIG9yaWdSZWN0LndpZHRoKCkKKyAgICAgICAgICAgICAgICAs IG9yaWdSZWN0LmhlaWdodCgpCisgICAgICAgICAgICAgICAgLCBoZGMKKyAgICAgICAgICAgICAg ICAsIDAKKyAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAsIGJtcFJlY3Qucmln aHQKKyAgICAgICAgICAgICAgICAsIGJtcFJlY3QuYm90dG9tCisgICAgICAgICAgICAgICAgLCBi bGVuZAorICAgICAgICAgICAgICAgICk7CisgICAgICAgIH0gZWxzZQorI2VuZGlmCisgICAgICAg IHsKKyAgICAgICAgICAgIFN0cmV0Y2hCbHQKKyAgICAgICAgICAgICAgICAobV9kYworICAgICAg ICAgICAgICAgICwgb3JpZ1JlY3QueCgpCisgICAgICAgICAgICAgICAgLCBvcmlnUmVjdC55KCkK KyAgICAgICAgICAgICAgICAsIG9yaWdSZWN0LndpZHRoKCkKKyAgICAgICAgICAgICAgICAsIG9y aWdSZWN0LmhlaWdodCgpCisgICAgICAgICAgICAgICAgLCBoZGMKKyAgICAgICAgICAgICAgICAs IDAKKyAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAsIGJtcFJlY3QucmlnaHQK KyAgICAgICAgICAgICAgICAsIGJtcFJlY3QuYm90dG9tCisgICAgICAgICAgICAgICAgLCBTUkND T1BZCisgICAgICAgICAgICAgICAgKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIEhEQyBtX2Rj OworICAgIFJlZlB0cjxTaGFyZWRCaXRtYXA+IG1fYml0bWFwOworICAgIFZlY3RvcjxHcmFwaGlj c0NvbnRleHRQbGF0Zm9ybVByaXZhdGVEYXRhPiBtX2JhY2t1cERhdGE7Cit9OworCitzdGF0aWMg SFBFTiBjcmVhdGVQZW4oY29uc3QgQ29sb3ImIGNvbCwgZG91YmxlIGZXaWR0aCwgU3Ryb2tlU3R5 bGUgc3R5bGUpCit7CisgICAgaW50IHdpZHRoID0gUm91bmQoZldpZHRoKTsKKyAgICBpZiAod2lk dGggPCAxKQorICAgICAgICB3aWR0aCA9IDE7CisKKyAgICBpbnQgcGVuU3R5bGUgPSBQU19OVUxM OworICAgIHN3aXRjaCAoc3R5bGUpIHsKKyAgICAgICAgY2FzZSBTb2xpZFN0cm9rZToKKyAgICAg ICAgICAgIHBlblN0eWxlID0gUFNfU09MSUQ7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAg Y2FzZSBEb3R0ZWRTdHJva2U6ICAvLyBub3Qgc3VwcG9ydGVkIG9uIENFCisgICAgICAgIGNhc2Ug RGFzaGVkU3Ryb2tlOgorICAgICAgICAgICAgcGVuU3R5bGUgPSBQU19EQVNIOworICAgICAgICAg ICAgd2lkdGggPSAxOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGRlZmF1bHQ6CisgICAg ICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICByZXR1cm4gQ3JlYXRlUGVuCisgICAgICAgIChw ZW5TdHlsZQorICAgICAgICAsIHdpZHRoCisgICAgICAgICwgUkdCKGNvbC5yZWQoKSwgY29sLmdy ZWVuKCksIGNvbC5ibHVlKCkpCisgICAgICAgICk7Cit9CisKK3N0YXRpYyBpbmxpbmUgSEdESU9C SiBjcmVhdGVCcnVzaChjb25zdCBDb2xvciYgY29sKQoreworICAgIHJldHVybiBDcmVhdGVTb2xp ZEJydXNoKFJHQihjb2wucmVkKCksIGNvbC5ncmVlbigpLCBjb2wuYmx1ZSgpKSk7Cit9CisKKy8v IE9ubHkgZm9yIDE2Yml0Cit2b2lkIHJvdGF0ZUJpdG1hcChTaGFyZWRCaXRtYXAqIGRlc3RCbXAs IGNvbnN0IFNoYXJlZEJpdG1hcCogc291cmNlQm1wLCBjb25zdCBSb3RhdGlvblRyYW5zZm9ybSYg dHJhbnNmb3JtKQoreworICAgIEFTU0VSVChkZXN0Qm1wLT5pczE2Yml0KCkgJiYgc291cmNlQm1w LT5pczE2Yml0KCkpOworICAgIGludCBkZXN0VyA9IGRlc3RCbXAtPndpZHRoKCk7CisgICAgaW50 IGRlc3RIID0gZGVzdEJtcC0+aGVpZ2h0KCk7CisgICAgaW50IHNvdXJjZVcgPSBzb3VyY2VCbXAt PndpZHRoKCk7CisgICAgaW50IHNvdXJjZUggPSBzb3VyY2VCbXAtPmhlaWdodCgpOworICAgIHVu c2lnbmVkIHNob3J0KiBkZXN0ID0gKHVuc2lnbmVkIHNob3J0KilkZXN0Qm1wLT5ieXRlcygpOwor ICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0KiBzb3VyY2UgPSAoY29uc3QgdW5zaWduZWQgc2hvcnQq KXNvdXJjZUJtcC0+Ynl0ZXMoKTsKKyAgICBpbnQgcGFkZGluZyA9IGRlc3RXICYgMTsKKyAgICBp bnQgcGFkZGVkU291cmNlVyA9IHNvdXJjZVcgKyAoc291cmNlVyAmIDEpOworICAgIGlmIChpc1pl cm8odHJhbnNmb3JtLm1fc2luQSkpIHsKKyAgICAgICAgaW50IGNvc0EgPSB0cmFuc2Zvcm0ubV9j b3NBID4gMCA/IDEgOiAtMTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCBkZXN0SDsgKyt5 KSB7CisgICAgICAgICAgICBmb3IgKGludCB4ID0gMDsgeCA8IGRlc3RXOyArK3gpIHsKKyAgICAg ICAgICAgICAgICBpbnQgeDEgPSB4ICsgdHJhbnNmb3JtLm1fcHJlU2hpZnRYOworICAgICAgICAg ICAgICAgIGludCB5MSA9IHkgKyB0cmFuc2Zvcm0ubV9wcmVTaGlmdFk7CisgICAgICAgICAgICAg ICAgaW50IHNyY1ggPSB4MSAqIGNvc0EgKyB0cmFuc2Zvcm0ubV9wb3N0U2hpZnRYOworICAgICAg ICAgICAgICAgIGludCBzcmNZID0geTEgKiBjb3NBIC0gdHJhbnNmb3JtLm1fcG9zdFNoaWZ0WTsK KyAgICAgICAgICAgICAgICBpZiAoc3JjWCA+PSAwICYmIHNyY1ggPD0gc291cmNlVyAmJiBzcmNZ ID49IDAgJiYgc3JjWSA8PSBzb3VyY2VIKQorICAgICAgICAgICAgICAgICAgICAqZGVzdCsrID0g c291cmNlW3NyY1kgKiBwYWRkZWRTb3VyY2VXICsgc3JjWF0gfCAweEZGMDAwMDAwOworICAgICAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgKmRlc3QrKyB8PSAweEZGOworICAg ICAgICAgICAgfQorICAgICAgICAgICAgZGVzdCArPSBwYWRkaW5nOworICAgICAgICB9CisgICAg fSBlbHNlIGlmIChpc1plcm8odHJhbnNmb3JtLm1fY29zQSkpIHsKKyAgICAgICAgaW50IHNpbkEg PSB0cmFuc2Zvcm0ubV9zaW5BID4gMCA/IDEgOiAtMTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7 IHkgPCBkZXN0SDsgKyt5KSB7CisgICAgICAgICAgICBmb3IgKGludCB4ID0gMDsgeCA8IGRlc3RX OyArK3gpIHsKKyAgICAgICAgICAgICAgICBpbnQgeDEgPSB4ICsgdHJhbnNmb3JtLm1fcHJlU2hp ZnRYOworICAgICAgICAgICAgICAgIGludCB5MSA9IHkgKyB0cmFuc2Zvcm0ubV9wcmVTaGlmdFk7 CisgICAgICAgICAgICAgICAgaW50IHNyY1ggPSB5MSAqIHNpbkEgKyB0cmFuc2Zvcm0ubV9wb3N0 U2hpZnRYOworICAgICAgICAgICAgICAgIGludCBzcmNZID0gLXgxICogc2luQSArIHRyYW5zZm9y bS5tX3Bvc3RTaGlmdFk7CisgICAgICAgICAgICAgICAgaWYgKHNyY1ggPj0gMCAmJiBzcmNYIDw9 IHNvdXJjZVcgJiYgc3JjWSA+PSAwICYmIHNyY1kgPD0gc291cmNlSCkKKyAgICAgICAgICAgICAg ICAgICAgKmRlc3QrKyA9IHNvdXJjZVtzcmNZICogcGFkZGVkU291cmNlVyArIHNyY1hdIHwgMHhG RjAwMDAwMDsKKyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICpkZXN0 KysgfD0gMHhGRjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIGRlc3QgKz0gcGFkZGluZzsK KyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIGZvciAoaW50IHkgPSAwOyB5IDwgZGVz dEg7ICsreSkgeworICAgICAgICAgICAgZm9yIChpbnQgeCA9IDA7IHggPCBkZXN0VzsgKyt4KSB7 CisgICAgICAgICAgICAgICAgLy8gRklYTUU6IGZvciBiZXN0IHF1YWxpdHksIHdlIHNob3VsZCBn ZXQgd2VpZ2h0ZWQgc3VtIG9mIGZvdXIgbmVpZ2hib3VycywKKyAgICAgICAgICAgICAgICAvLyBi dXQgdGhhdCB3aWxsIGJlIHRvbyBleHBlbnNpdmUKKyAgICAgICAgICAgICAgICBpbnQgc3JjWCwg c3JjWTsKKyAgICAgICAgICAgICAgICB0cmFuc2Zvcm0ubWFwKHgsIHksICZzcmNYLCAmc3JjWSk7 CisgICAgICAgICAgICAgICAgaWYgKHNyY1ggPj0gMCAmJiBzcmNYIDw9IHNvdXJjZVcgJiYgc3Jj WSA+PSAwICYmIHNyY1kgPD0gc291cmNlSCkKKyAgICAgICAgICAgICAgICAgICAgKmRlc3QrKyA9 IHNvdXJjZVtzcmNZICogcGFkZGVkU291cmNlVyArIHNyY1hdIHwgMHhGRjAwMDAwMDsKKyAgICAg ICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICpkZXN0KysgfD0gMHhGRjsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgICAgIGRlc3QgKz0gcGFkZGluZzsKKyAgICAgICAgfQorICAg IH0KK30KKworY2xhc3MgVHJhbnNwYXJlbnRMYXllckRDIHsKK3B1YmxpYzoKKyAgICBleHBsaWNp dCBUcmFuc3BhcmVudExheWVyREMoR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKiBkYXRh LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbnRSZWN0JiBvcmlnUmVjdCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgSW50UmVjdCogcmVjdEJlZm9yZVRy YW5zZm9ybSA9IDAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCBhbHBoYSA9 IDI1NSkKKyAgICAgICAgOiBtX2RhdGEoZGF0YSkKKyAgICAgICAgLCBtX29yaWdSZWN0KG9yaWdS ZWN0KQorICAgICAgICAsIG1fb2xkT3BhY2l0eShkYXRhLT5tX29wYWNpdHkpCisgICAgeworICAg ICAgICBtX2RhdGEtPm1fb3BhY2l0eSAqPSBhbHBoYSAvIDI1NS47CisgICAgICAgIGlmIChyZWN0 QmVmb3JlVHJhbnNmb3JtICYmICFpc1plcm8obV9kYXRhLT5tX3RyYW5zZm9ybS5iKCkpKSB7Cisg ICAgICAgICAgICBtX3JvdGF0ZWRPcmlnUmVjdCA9IG9yaWdSZWN0OworICAgICAgICAgICAgbV9y b3RhdGVkQml0bWFwID0gbV9kYXRhLT5nZXRUcmFuc3BhcmVudExheWVyQml0bWFwKG1fcm90YXRl ZE9yaWdSZWN0LCB0cnVlLCBtX2JtcFJlY3QsIGZhbHNlLCB0cnVlKTsKKyAgICAgICAgICAgIGlm IChtX3JvdGF0ZWRCaXRtYXApIHsKKyAgICAgICAgICAgICAgICBkb3VibGUgYSA9IG1fZGF0YS0+ bV90cmFuc2Zvcm0uYSgpOworICAgICAgICAgICAgICAgIGRvdWJsZSBiID0gbV9kYXRhLT5tX3Ry YW5zZm9ybS5iKCk7CisgICAgICAgICAgICAgICAgZG91YmxlIGMgPSBfaHlwb3QoYSwgYik7Cisg ICAgICAgICAgICAgICAgbV9yb3RhdGlvbi5tX2Nvc0EgPSBhIC8gYzsKKyAgICAgICAgICAgICAg ICBtX3JvdGF0aW9uLm1fc2luQSA9IGIgLyBjOworCisgICAgICAgICAgICAgICAgaW50IGNlbnRl clggPSBvcmlnUmVjdC54KCkgKyBvcmlnUmVjdC53aWR0aCgpIC8gMjsKKyAgICAgICAgICAgICAg ICBpbnQgY2VudGVyWSA9IG9yaWdSZWN0LnkoKSArIG9yaWdSZWN0LmhlaWdodCgpIC8gMjsKKyAg ICAgICAgICAgICAgICBtX3JvdGF0aW9uLm1fcHJlU2hpZnRYID0gLWNlbnRlclg7CisgICAgICAg ICAgICAgICAgbV9yb3RhdGlvbi5tX3ByZVNoaWZ0WSA9IC1jZW50ZXJZOworICAgICAgICAgICAg ICAgIG1fcm90YXRpb24ubV9wb3N0U2hpZnRYID0gY2VudGVyWDsKKyAgICAgICAgICAgICAgICBt X3JvdGF0aW9uLm1fcG9zdFNoaWZ0WSA9IGNlbnRlclk7CisKKyAgICAgICAgICAgICAgICBtX29y aWdSZWN0ID0gbWFwUmVjdChtX3JvdGF0ZWRPcmlnUmVjdCwgbV9yb3RhdGlvbik7CisKKyAgICAg ICAgICAgICAgICBtX3JvdGF0aW9uLm1fcHJlU2hpZnRYICs9IG1fcm90YXRlZE9yaWdSZWN0Lngo KTsKKyAgICAgICAgICAgICAgICBtX3JvdGF0aW9uLm1fcHJlU2hpZnRZICs9IG1fcm90YXRlZE9y aWdSZWN0LnkoKTsKKyAgICAgICAgICAgICAgICBtX3JvdGF0aW9uLm1fcG9zdFNoaWZ0WCAtPSBt X29yaWdSZWN0LngoKTsKKyAgICAgICAgICAgICAgICBtX3JvdGF0aW9uLm1fcG9zdFNoaWZ0WSAt PSBtX29yaWdSZWN0LnkoKTsKKworI2lmIDEKKyAgICAgICAgICAgICAgICBGbG9hdFBvaW50IHRv cExlZnQgPSBtX2RhdGEtPm1fdHJhbnNmb3JtLm1hcFBvaW50KEZsb2F0UG9pbnQocmVjdEJlZm9y ZVRyYW5zZm9ybS0+dG9wTGVmdCgpKSk7CisgICAgICAgICAgICAgICAgRmxvYXRQb2ludCB0b3BS aWdodChyZWN0QmVmb3JlVHJhbnNmb3JtLT5yaWdodCgpIC0gMSwgcmVjdEJlZm9yZVRyYW5zZm9y bS0+eSgpKTsKKyAgICAgICAgICAgICAgICB0b3BSaWdodCA9IG1fZGF0YS0+bV90cmFuc2Zvcm0u bWFwUG9pbnQodG9wUmlnaHQpOworICAgICAgICAgICAgICAgIEZsb2F0UG9pbnQgYm90dG9tTGVm dChyZWN0QmVmb3JlVHJhbnNmb3JtLT54KCksIHJlY3RCZWZvcmVUcmFuc2Zvcm0tPmJvdHRvbSgp IC0gMSk7CisgICAgICAgICAgICAgICAgYm90dG9tTGVmdCA9IG1fZGF0YS0+bV90cmFuc2Zvcm0u bWFwUG9pbnQoYm90dG9tTGVmdCk7CisgICAgICAgICAgICAgICAgRmxvYXRTaXplIHNpZGVUb3Ag PSB0b3BSaWdodCAtIHRvcExlZnQ7CisgICAgICAgICAgICAgICAgRmxvYXRTaXplIHNpZGVMZWZ0 ID0gYm90dG9tTGVmdCAtIHRvcExlZnQ7CisgICAgICAgICAgICAgICAgZmxvYXQgd2lkdGggPSBf aHlwb3Qoc2lkZVRvcC53aWR0aCgpICsgMSwgc2lkZVRvcC5oZWlnaHQoKSArIDEpOworICAgICAg ICAgICAgICAgIGZsb2F0IGhlaWdodCA9IF9oeXBvdChzaWRlTGVmdC53aWR0aCgpICsgMSwgc2lk ZUxlZnQuaGVpZ2h0KCkgKyAxKTsKKworICAgICAgICAgICAgICAgIG9yaWdSZWN0LmluZmxhdGVY KFJvdW5kKCh3aWR0aCAtIG9yaWdSZWN0LndpZHRoKCkpICogMC41KSk7CisgICAgICAgICAgICAg ICAgb3JpZ1JlY3QuaW5mbGF0ZVkoUm91bmQoKGhlaWdodCAtIG9yaWdSZWN0LmhlaWdodCgpKSAq IDAuNSkpOworI2Vsc2UKKyAgICAgICAgICAgICAgICBGbG9hdFJlY3Qgcm90YXRlZEJlZm9yZVRy YW5zZm9ybSA9IG1hcFJlY3QoRmxvYXRSZWN0KCpyZWN0QmVmb3JlVHJhbnNmb3JtKSwgLW1fcm90 YXRpb24pOworICAgICAgICAgICAgICAgIGRvdWJsZSBzaHJpbmtSYXRlWCA9ICgxLiAtIHJlY3RC ZWZvcmVUcmFuc2Zvcm0tPndpZHRoKCkgLyAoZG91YmxlKXJvdGF0ZWRCZWZvcmVUcmFuc2Zvcm0u d2lkdGgoKSkgKiAwLjU7CisgICAgICAgICAgICAgICAgZG91YmxlIHNocmlua1JhdGVZID0gKDEu IC0gcmVjdEJlZm9yZVRyYW5zZm9ybS0+aGVpZ2h0KCkgLyAoZG91YmxlKXJvdGF0ZWRCZWZvcmVU cmFuc2Zvcm0uaGVpZ2h0KCkpICogMC41OworICAgICAgICAgICAgICAgIG9yaWdSZWN0LmluZmxh dGVYKC1Sb3VuZChzaHJpbmtSYXRlWCAqIG9yaWdSZWN0LndpZHRoKCkpKTsKKyAgICAgICAgICAg ICAgICBvcmlnUmVjdC5pbmZsYXRlWSgtUm91bmQoc2hyaW5rUmF0ZVkgKiBvcmlnUmVjdC5oZWln aHQoKSkpOworI2VuZGlmCisKKyAgICAgICAgICAgICAgICBtX2JpdG1hcCA9IFNoYXJlZEJpdG1h cDo6Y3JlYXRlSW5zdGFuY2UodHJ1ZSwgbV9vcmlnUmVjdC53aWR0aCgpLCBtX29yaWdSZWN0Lmhl aWdodCgpLCB0cnVlKTsKKyAgICAgICAgICAgICAgICBpZiAobV9iaXRtYXApCisgICAgICAgICAg ICAgICAgICAgIHJvdGF0ZUJpdG1hcChtX2JpdG1hcC5nZXQoKSwgbV9yb3RhdGVkQml0bWFwLmdl dCgpLCAtbV9yb3RhdGlvbik7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAg ICAgICBtX3JvdGF0ZWRCaXRtYXAgPSAwOworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UK KyAgICAgICAgICAgIG1fYml0bWFwID0gbV9kYXRhLT5nZXRUcmFuc3BhcmVudExheWVyQml0bWFw KG1fb3JpZ1JlY3QsIHRydWUsIG1fYm1wUmVjdCwgdHJ1ZSwgZmFsc2UpOworCisgICAgICAgIGlm IChtX2JpdG1hcCkKKyAgICAgICAgICAgIG1fbWVtRGMgPSBtX2JpdG1hcC0+Z2V0REMoJm1fa2V5 MSwgJm1fa2V5Mik7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIG1fbWVtRGMgPSBtX2RhdGEt Pm1fZGM7CisgICAgfQorICAgIH5UcmFuc3BhcmVudExheWVyREMoKQorICAgIHsKKyAgICAgICAg aWYgKG1fcm90YXRlZEJpdG1hcCkgeworICAgICAgICAgICAgbV9iaXRtYXAtPnJlbGVhc2VEQyht X21lbURjLCBtX2tleTEsIG1fa2V5Mik7CisgICAgICAgICAgICBtX2tleTEgPSBtX2tleTIgPSAw OworICAgICAgICAgICAgcm90YXRlQml0bWFwKG1fcm90YXRlZEJpdG1hcC5nZXQoKSwgbV9iaXRt YXAuZ2V0KCksIG1fcm90YXRpb24pOworICAgICAgICAgICAgbV9tZW1EYyA9IG1fcm90YXRlZEJp dG1hcC0+Z2V0REMoJm1fa2V5MSwgJm1fa2V5Mik7CisgICAgICAgICAgICBtX2RhdGEtPnBhaW50 QmFja1RyYW5zcGFyZW50TGF5ZXJCaXRtYXAobV9tZW1EYywgbV9yb3RhdGVkT3JpZ1JlY3QsIHRy dWUsIG1fYm1wUmVjdCk7CisgICAgICAgICAgICBtX3JvdGF0ZWRCaXRtYXAtPnJlbGVhc2VEQyht X21lbURjLCBtX2tleTEsIG1fa2V5Mik7CisgICAgICAgIH0gZWxzZSBpZiAobV9iaXRtYXApIHsK KyAgICAgICAgICAgIG1fZGF0YS0+cGFpbnRCYWNrVHJhbnNwYXJlbnRMYXllckJpdG1hcChtX21l bURjLCBtX29yaWdSZWN0LCB0cnVlLCBtX2JtcFJlY3QpOworICAgICAgICAgICAgbV9iaXRtYXAt PnJlbGVhc2VEQyhtX21lbURjLCBtX2tleTEsIG1fa2V5Mik7CisgICAgICAgIH0KKyAgICAgICAg bV9kYXRhLT5tX29wYWNpdHkgPSBtX29sZE9wYWNpdHk7CisgICAgfQorICAgIEhEQyBoZGMoKSBj b25zdCB7IHJldHVybiBtX21lbURjOyB9CisgICAgY29uc3QgUkVDVCYgcmVjdCgpIGNvbnN0IHsg cmV0dXJuIG1fYm1wUmVjdDsgfQorICAgIEludFNpemUgdG9TaGlmdCgpIGNvbnN0IHsgcmV0dXJu IEludFNpemUobV9ibXBSZWN0LmxlZnQgLSBtX29yaWdSZWN0LngoKSwgbV9ibXBSZWN0LnRvcCAt IG1fb3JpZ1JlY3QueSgpKTsgfQorCitwcml2YXRlOgorICAgIEdyYXBoaWNzQ29udGV4dFBsYXRm b3JtUHJpdmF0ZSogbV9kYXRhOworICAgIEludFJlY3QgbV9vcmlnUmVjdDsKKyAgICBJbnRSZWN0 IG1fcm90YXRlZE9yaWdSZWN0OworICAgIEhEQyBtX21lbURjOworICAgIFJlZlB0cjxTaGFyZWRC aXRtYXA+IG1fYml0bWFwOworICAgIFJlZlB0cjxTaGFyZWRCaXRtYXA+IG1fcm90YXRlZEJpdG1h cDsKKyAgICBSRUNUIG1fYm1wUmVjdDsKKyAgICB1bnNpZ25lZCBtX2tleTE7CisgICAgdW5zaWdu ZWQgbV9rZXkyOworICAgIFJvdGF0aW9uVHJhbnNmb3JtIG1fcm90YXRpb247CisgICAgZmxvYXQg bV9vbGRPcGFjaXR5OworfTsKKworY2xhc3MgU2NvcGVEQ1Byb3ZpZGVyIHsKK3B1YmxpYzoKKyAg ICBleHBsaWNpdCBTY29wZURDUHJvdmlkZXIoR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRl KiBkYXRhKQorICAgICAgICA6IG1fZGF0YShkYXRhKQorICAgIHsKKyAgICAgICAgaWYgKG1fZGF0 YS0+bV9iaXRtYXApCisgICAgICAgICAgICBtX2RhdGEtPm1fZGMgPSBtX2RhdGEtPm1fYml0bWFw LT5nZXREQygmbV9rZXkxLCAmbV9rZXkyKTsKKyAgICB9CisgICAgflNjb3BlRENQcm92aWRlcigp CisgICAgeworICAgICAgICBpZiAobV9kYXRhLT5tX2JpdG1hcCkgeworICAgICAgICAgICAgbV9k YXRhLT5tX2JpdG1hcC0+cmVsZWFzZURDKG1fZGF0YS0+bV9kYywgbV9rZXkxLCBtX2tleTIpOwor ICAgICAgICAgICAgbV9kYXRhLT5tX2RjID0gMDsKKyAgICAgICAgfQorICAgIH0KK3ByaXZhdGU6 CisgICAgR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKiBtX2RhdGE7CisgICAgdW5zaWdu ZWQgbV9rZXkxOworICAgIHVuc2lnbmVkIG1fa2V5MjsKK307CisKKworR3JhcGhpY3NDb250ZXh0 OjpHcmFwaGljc0NvbnRleHQoUGxhdGZvcm1HcmFwaGljc0NvbnRleHQqIGRjKQorICAgIDogbV9j b21tb24oY3JlYXRlR3JhcGhpY3NDb250ZXh0UHJpdmF0ZSgpKQorICAgICwgbV9kYXRhKG5ldyBH cmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGUoZGMpKQoreworfQorCitHcmFwaGljc0NvbnRl eHQ6On5HcmFwaGljc0NvbnRleHQoKQoreworICAgIGRlc3Ryb3lHcmFwaGljc0NvbnRleHRQcml2 YXRlKG1fY29tbW9uKTsKKyAgICBkZWxldGUgbV9kYXRhOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6c2V0Qml0bWFwKFBhc3NSZWZQdHI8U2hhcmVkQml0bWFwPiBibXApCit7CisgICAgQVNT RVJUKCFtX2RhdGEtPm1fZGMpOworICAgIG1fZGF0YS0+bV9iaXRtYXAgPSBibXA7Cit9CisKK0hE QyBHcmFwaGljc0NvbnRleHQ6OmdldFdpbmRvd3NDb250ZXh0KGNvbnN0IEludFJlY3QmIGRzdFJl Y3QsIGJvb2wgc3VwcG9ydEFscGhhQmxlbmQsIGJvb2wgbWF5Q3JlYXRlQml0bWFwKQoreworICAg IC8vIEZJWE1FOiB0aGUgaW1wbGVtZW50YXRpb24gaXMgYnVnZ3kuIEN1cnJlbnRseSB0aGUgZnVu Y3Rpb24gc2VlbXMgbm90IGJlaW5nIHVzZWQuIEp1c3QgbWFrZSBhbiBhc3NlcnRpb24KKyAgICBB U1NFUlQoMCk7CisgICAgcmV0dXJuIDA7CisjaWYgMAorICAgIG1fZGF0YS0+c2F2ZSgpOworICAg IGlmIChtX2RhdGEtPm1fb3BhY2l0eSA8IDEuIHx8ICFtX2RhdGEtPm1fZGMpIHsKKyAgICAgICAg U2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKworICAgICAgICAvLyBGSVhNRTog dGhlIGNhbGxlciBtYXkgZXhwZWN0IGEgbm9uLXNjYWxlZCBiaXRtYXAKKyAgICAgICAgSW50UmVj dCB0clJlY3QgPSBtX2RhdGEtPm1hcFJlY3QoZHN0UmVjdCk7CisKKyAgICAgICAgSEJJVE1BUCBi bXA7CisgICAgICAgIFJFQ1QgYm1wUmVjdDsKKyAgICAgICAgSERDIG1lbURjID0gbV9kYXRhLT5n ZXRUcmFuc3BhcmVudExheWVyREModHJSZWN0LCAhc3VwcG9ydEFscGhhQmxlbmQsIGJtcCwgYm1w UmVjdCwgZmFsc2UsIHRydWUpOworICAgICAgICByZXR1cm4gbWVtRGMgPT0gbV9kYXRhLT5tX2Rj ID8gMCA6IG1lbURjOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIEZJWE1FOiBuZWVkIHRvIHNl dCB0cmFuc2Zvcm1hdGlvbgorICAgICAgICByZXR1cm4gbV9kYXRhLT5tX2RjOworICAgIH0KKyNl bmRpZgorfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6cmVsZWFzZVdpbmRvd3NDb250ZXh0KEhE QyBoZGMsIGNvbnN0IEludFJlY3QmIGRzdFJlY3QsIGJvb2wgc3VwcG9ydEFscGhhQmxlbmQsIGJv b2wgbWF5Q3JlYXRlQml0bWFwKQoreworICAgIC8vIFNlZSBjb21tZW50cyBpbiBnZXRXaW5kb3dz Q29udGV4dCgpCisjaWYgMAorICAgIG1fZGF0YS0+cmVzdG9yZSgpOworICAgIGlmICghaGRjKSB7 CisgICAgfSBlbHNlIGlmIChoZGMgPT0gbV9kYXRhLT5tX2RjKSAgICB7CisgICAgfSBlbHNlIHsK KyAgICAgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKworICAgICAgICBI QklUTUFQIGJpdG1hcCA9IChIQklUTUFQKUdldEN1cnJlbnRPYmplY3QoaGRjLCBPQkpfQklUTUFQ KTsKKyAgICAgICAgQklUTUFQIGluZm87CisgICAgICAgIEdldE9iamVjdChiaXRtYXAsIHNpemVv ZihpbmZvKSwgJmluZm8pOworCisgICAgICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBS ZWN0KGRzdFJlY3QpOworICAgICAgICBSRUNUIGJtcFJlY3QgPSB7IDAsIDAsIGFicyhpbmZvLmJt V2lkdGgpLCBhYnMoaW5mby5ibUhlaWdodCkgfTsKKyAgICAgICAgbV9kYXRhLT5yZWxlYXNlVHJh bnNwYXJlbnRMYXllckRDKGhkYywgdHJSZWN0LCAhc3VwcG9ydEFscGhhQmxlbmQsIGJpdG1hcCwg Ym1wUmVjdCk7CisgICAgfQorI2VuZGlmCit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzYXZl UGxhdGZvcm1TdGF0ZSgpCit7CisgICAgbV9kYXRhLT5zYXZlKCk7Cit9CisKK3ZvaWQgR3JhcGhp Y3NDb250ZXh0OjpyZXN0b3JlUGxhdGZvcm1TdGF0ZSgpCit7CisgICAgbV9kYXRhLT5yZXN0b3Jl KCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3UmVjdChjb25zdCBJbnRSZWN0JiBy ZWN0KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkgfHwgcGFpbnRpbmdEaXNhYmxlZCgp IHx8IHJlY3Qud2lkdGgoKSA8PSAwIHx8IHJlY3QuaGVpZ2h0KCkgPD0gMCkKKyAgICAgICAgcmV0 dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAo IW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCB0clJlY3QgPSBt X2RhdGEtPm1hcFJlY3QocmVjdCk7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50 RGMobV9kYXRhLCB0clJlY3QsICZyZWN0KTsKKyAgICBIREMgZGMgPSB0cmFuc3BhcmVudERjLmhk YygpOworICAgIGlmICghZGMpCisgICAgICAgIHJldHVybjsKKyAgICB0clJlY3QubW92ZSh0cmFu c3BhcmVudERjLnRvU2hpZnQoKSk7CisKKyAgICBIR0RJT0JKIGJydXNoID0gMDsKKyAgICBIR0RJ T0JKIG9sZEJydXNoOworICAgIGlmIChmaWxsQ29sb3IoKS5hbHBoYSgpKSB7CisgICAgICAgIGJy dXNoID0gY3JlYXRlQnJ1c2goZmlsbENvbG9yKCkpOworICAgICAgICBvbGRCcnVzaCA9IFNlbGVj dE9iamVjdChkYywgYnJ1c2gpOworICAgIH0gZWxzZSB7CisgICAgICAgIFNlbGVjdE9iamVjdChk YywgR2V0U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkpOworICAgIH0KKworICAgIEhHRElPQkogcGVu ID0gMDsKKyAgICBIR0RJT0JKIG9sZFBlbjsKKyAgICBpZiAoc3Ryb2tlU3R5bGUoKSAhPSBOb1N0 cm9rZSkgeworICAgICAgICBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhp Y2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOworICAgICAgICBvbGRQZW4gPSBTZWxlY3RPYmplY3Qo ZGMsIHBlbik7CisgICAgfSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tP YmplY3QoTlVMTF9QRU4pKTsKKworICAgIGlmIChwZW4gfHwgYnJ1c2gpIHsKKyAgICAgICAgaWYg KHRyUmVjdC53aWR0aCgpIDw9IDApCisgICAgICAgICAgICB0clJlY3Quc2V0V2lkdGgoMSk7Cisg ICAgICAgIGlmICh0clJlY3QuaGVpZ2h0KCkgPD0gMCkKKyAgICAgICAgICAgIHRyUmVjdC5zZXRI ZWlnaHQoMSk7CisKKyAgICAgICAgUmVjdGFuZ2xlKGRjLCB0clJlY3QueCgpLCB0clJlY3QueSgp LCB0clJlY3QucmlnaHQoKSwgdHJSZWN0LmJvdHRvbSgpKTsKKworICAgICAgICBpZiAocGVuKSB7 CisgICAgICAgICAgICBTZWxlY3RPYmplY3QoZGMsIG9sZFBlbik7CisgICAgICAgICAgICBEZWxl dGVPYmplY3QocGVuKTsKKyAgICAgICAgfQorCisgICAgICAgIGlmIChicnVzaCkgeworICAgICAg ICAgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRCcnVzaCk7CisgICAgICAgICAgICBEZWxldGVPYmpl Y3QoYnJ1c2gpOworICAgICAgICB9CisgICAgfQorfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6 ZHJhd0xpbmUoY29uc3QgSW50UG9pbnQmIHBvaW50MSwgY29uc3QgSW50UG9pbnQmIHBvaW50MikK K3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5IHx8IHBhaW50aW5nRGlzYWJsZWQoKSB8fCBz dHJva2VTdHlsZSgpID09IE5vU3Ryb2tlIHx8ICFzdHJva2VDb2xvcigpLmFscGhhKCkpCisgICAg ICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7Cisg ICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFBvaW50IHRy UG9pbnQxID0gbV9kYXRhLT5tYXBQb2ludChwb2ludDEpOworICAgIEludFBvaW50IHRyUG9pbnQy ID0gbV9kYXRhLT5tYXBQb2ludChwb2ludDIpOworCisgICAgSW50UmVjdCBsaW5lUmVjdCh0clBv aW50MSwgdHJQb2ludDIgLSB0clBvaW50MSk7CisgICAgbGluZVJlY3Quc2V0SGVpZ2h0KGxpbmVS ZWN0LmhlaWdodCgpICsgc3Ryb2tlVGhpY2tuZXNzKCkpOworICAgIFRyYW5zcGFyZW50TGF5ZXJE QyB0cmFuc3BhcmVudERjKG1fZGF0YSwgbGluZVJlY3QsIDAsIHN0cm9rZUNvbG9yKCkuYWxwaGEo KSk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAg ICAgICByZXR1cm47CisgICAgdHJQb2ludDEgKz0gdHJhbnNwYXJlbnREYy50b1NoaWZ0KCk7Cisg ICAgdHJQb2ludDIgKz0gdHJhbnNwYXJlbnREYy50b1NoaWZ0KCk7CisKKyAgICBIR0RJT0JKIHBl biA9IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5 bGUoKSk7CisgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisKKyAg ICBNb3ZlVG9FeChkYywgdHJQb2ludDEueCgpLCB0clBvaW50MS55KCksIDApOworICAgIExpbmVU byhkYywgdHJQb2ludDIueCgpLCB0clBvaW50Mi55KCkpOworCisgICAgU2VsZWN0T2JqZWN0KGRj LCBvbGRQZW4pOworICAgIERlbGV0ZU9iamVjdChwZW4pOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6ZHJhd0VsbGlwc2UoY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAoIW1fZGF0 YS0+bV9vcGFjaXR5IHx8IHBhaW50aW5nRGlzYWJsZWQoKSB8fCAoIWZpbGxDb2xvcigpLmFscGhh KCkgJiYgc3Ryb2tlU3R5bGUoKSA9PSBOb1N0cm9rZSkpCisgICAgICAgIHJldHVybjsKKworICAg IFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1f ZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBS ZWN0KHJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0YSwg dHJSZWN0LCAmcmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBp ZiAoIWRjKQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50 b1NoaWZ0KCkpOworCisgICAgSEdESU9CSiBicnVzaCA9IDA7CisgICAgSEdESU9CSiBvbGRCcnVz aDsKKyAgICBpZiAoZmlsbENvbG9yKCkuYWxwaGEoKSkgeworICAgICAgICBicnVzaCA9IGNyZWF0 ZUJydXNoKGZpbGxDb2xvcigpKTsKKyAgICAgICAgb2xkQnJ1c2ggPSBTZWxlY3RPYmplY3QoZGMs IGJydXNoKTsKKyAgICB9IGVsc2UKKyAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9ja09i amVjdChOVUxMX0JSVVNIKSk7CisgICAgSEdESU9CSiBwZW4gPSAwOworICAgIEhHRElPQkogb2xk UGVuOworICAgIGlmIChzdHJva2VTdHlsZSgpICE9IE5vU3Ryb2tlKSB7CisgICAgICAgIHBlbiA9 IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUo KSk7CisgICAgICAgIG9sZFBlbiA9IFNlbGVjdE9iamVjdChkYywgcGVuKTsKKyAgICB9IGVsc2UK KyAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9ja09iamVjdChOVUxMX1BFTikpOworCisg ICAgRWxsaXBzZShkYywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJpZ2h0KCksIHRy UmVjdC5ib3R0b20oKSk7CisKKyAgICBpZiAocGVuKSB7CisgICAgICAgIFNlbGVjdE9iamVjdChk Yywgb2xkUGVuKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgfQorCisgICAgaWYg KGJydXNoKSB7CisgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOworICAgICAgICBE ZWxldGVPYmplY3QoYnJ1c2gpOworICAgIH0KK30KKworI2RlZmluZSBFUVVBTF9BTkdMRShhLCBi KSAoZmFicygoYSkgLSAoYikpIDwgMWUtNSkKK3ZvaWQgZ2V0RWxsaXBzZVBvaW50QnlBbmdsZShk b3VibGUgYW5nbGUsIGRvdWJsZSBhLCBkb3VibGUgYiwgZmxvYXQmIHgsIGZsb2F0JiB5KQorewor ICAgIC8vIGFuZ2xlICU9IDM2MDsKKyAgICB3aGlsZSAoYW5nbGUgPCAwKQorICAgICAgICBhbmds ZSArPSAyICogUEk7CisgICAgd2hpbGUgKGFuZ2xlID49IDIgKiBQSSkKKyAgICAgICAgYW5nbGUg LT0gMiAqIFBJOworCisgICAgaWYgKEVRVUFMX0FOR0xFKGFuZ2xlLCAwKSB8fCBFUVVBTF9BTkdM RShhbmdsZSwgMiAqIFBJKSkgeworICAgICAgICB4ID0gYTsKKyAgICAgICAgeSA9IDA7CisgICAg fSBlbHNlIGlmIChFUVVBTF9BTkdMRShhbmdsZSwgUEkpKSB7CisgICAgICAgIHggPSAtYTsKKyAg ICAgICAgeSA9IDA7CisgICAgfSBlbHNlIGlmIChFUVVBTF9BTkdMRShhbmdsZSwgLjUgKiBQSSkp IHsKKyAgICAgICAgeCA9IDA7CisgICAgICAgIHkgPSBiOworICAgIH0gZWxzZSBpZiAoRVFVQUxf QU5HTEUoYW5nbGUsIDEuNSAqIFBJKSkgeworICAgICAgICB4ID0gMDsKKyAgICAgICAgeSA9IC1i OworICAgIH0gZWxzZSB7CisgICAgICAgIGRvdWJsZSBrID0gdGFuKGFuZ2xlKTsKKyAgICAgICAg ZG91YmxlIHNxQSA9IGEgKiBhOworICAgICAgICBkb3VibGUgc3FCID0gYiAqIGI7CisgICAgICAg IGRvdWJsZSB0bXAgPSAxLiAvICgxLiAvIHNxQSArIChrICogaykgLyBzcUIpOworICAgICAgICB0 bXAgPSB0bXAgPD0gMCA/IDAgOiBzcXJ0KHRtcCk7CisgICAgICAgIGlmIChhbmdsZSA+IC41ICog UEkgJiYgYW5nbGUgPCAxLjUgKiBQSSkKKyAgICAgICAgICAgIHRtcCA9IC10bXA7CisgICAgICAg IHggPSB0bXA7CisKKyAgICAgICAgayA9IHRhbiguNSAqIFBJIC0gYW5nbGUpOworICAgICAgICB0 bXAgPSAxLiAvICgoayAqIGspIC8gc3FBICsgMSAvIHNxQik7CisgICAgICAgIHRtcCA9IHRtcCA8 PSAwID8gMCA6IHNxcnQodG1wKTsKKyAgICAgICAgaWYgKGFuZ2xlID4gUEkpCisgICAgICAgICAg ICB0bXAgPSAtdG1wOworICAgICAgICB5ID0gdG1wOworICAgIH0KK30KKworI2lmIERSQVdfQVJD X0FMTF9QT0lOVFMKK3N0YXRpYyBpbmxpbmUgaW50IGdldEVsbGlwc2VZKGludCB4LCBkb3VibGUg YSwgZG91YmxlIGIpCit7CisgICAgZG91YmxlIHQgPSB4IC8gYTsKKyAgICB0ID0gMS4gLSB0ICog dDsKKyAgICByZXR1cm4gUm91bmQodCA8PSAwID8gMCA6IHNxcnQodCkgKiBiKTsKK30KKworc3Rh dGljIGlubGluZSBpbnQgZ2V0RWxsaXBzZVgoaW50IHksIGRvdWJsZSBhLCBkb3VibGUgYikKK3sK KyAgICByZXR1cm4gZ2V0RWxsaXBzZVkoeSwgYiwgYSk7Cit9CisjZW5kaWYKKwordm9pZCBHcmFw aGljc0NvbnRleHQ6OnN0cm9rZUFyYyhjb25zdCBJbnRSZWN0JiByZWN0LCBpbnQgc3RhcnRBbmds ZSwgaW50IGFuZ2xlU3BhbikKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5IHx8IHBhaW50 aW5nRGlzYWJsZWQoKSB8fCBzdHJva2VTdHlsZSgpID09IE5vU3Ryb2tlIHx8IHJlY3QuaXNFbXB0 eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlciht X2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJ bnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExh eWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIHRyUmVjdCwgJnJlY3QpOworICAgIEhEQyBkYyA9 IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAg IHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50RGMudG9TaGlmdCgpKTsKKworICAgIEhHRElPQkogcGVu ID0gY3JlYXRlUGVuKHN0cm9rZUNvbG9yKCksIHN0cm9rZVRoaWNrbmVzcygpLCBzdHJva2VTdHls ZSgpKTsKKyAgICBIR0RJT0JKIG9sZFBlbiA9IFNlbGVjdE9iamVjdChkYywgcGVuKTsKKworICAg IGRvdWJsZSBhID0gdHJSZWN0LndpZHRoKCkgKiAwLjU7CisgICAgZG91YmxlIGIgPSB0clJlY3Qu aGVpZ2h0KCkgKiAwLjU7CisgICAgaW50IGNlbnRlclggPSBSb3VuZCh0clJlY3QueCgpICsgYSk7 CisgICAgaW50IGNlbnRlclkgPSBSb3VuZCh0clJlY3QueSgpICsgYik7CisgICAgZmxvYXQgZnN0 YXJ0WCwgZnN0YXJ0WSwgZmVuZFgsIGZlbmRZOworICAgIGludCBzdGFydFgsIHN0YXJ0WSwgZW5k WCwgZW5kWTsKKyAgICBnZXRFbGxpcHNlUG9pbnRCeUFuZ2xlKFJBRElBTihzdGFydEFuZ2xlKSwg YSwgYiwgZnN0YXJ0WCwgZnN0YXJ0WSk7CisgICAgZ2V0RWxsaXBzZVBvaW50QnlBbmdsZShSQURJ QU4oc3RhcnRBbmdsZSArIGFuZ2xlU3BhbiksIGEsIGIsIGZlbmRYLCBmZW5kWSk7CisgICAgc3Rh cnRYID0gUm91bmQoZnN0YXJ0WCk7CisgICAgc3RhcnRZID0gUm91bmQoZnN0YXJ0WSk7CisgICAg ZW5kWCA9IFJvdW5kKGZlbmRYKTsKKyAgICBlbmRZID0gUm91bmQoZmVuZFkpOworCisgICAgLy8g Q2FsbGluZyBMaW5lVG8gdG9vIG1hbnkgdGltZXMgcmVzdWx0cyBwcm9ibGVtLgorI2lmIERSQVdf QVJDX0FMTF9QT0lOVFMKKyAgICAvLyBTaG91bGQgdXNlIFBvbHlsaW5lIGxhdGVyCisgICAgTW92 ZVRvRXgoZGMsIHN0YXJ0WCArIGNlbnRlclgsIGNlbnRlclkgLSBzdGFydFksIDApOworCisgICAg d2hpbGUgKGFicyhzdGFydFggLSBlbmRYKSA+IDEgfHwgYWJzKHN0YXJ0WSAtIGVuZFkpID4gMSkg eworICAgICAgICBpbnQgbmV4dFggPSAoc3RhcnRZID09IDAgPyBzdGFydFggPiAwIDogc3RhcnRZ ID4gMCkgPyBzdGFydFggLSAxIDogc3RhcnRYICsgMTsKKyAgICAgICAgaW50IG5leHRZID0gZ2V0 RWxsaXBzZVkobmV4dFgsIGEsIGIpOworICAgICAgICBpZiAoYWJzKG5leHRZIC0gc3RhcnRZKSA+ IDEpIHsKKyAgICAgICAgICAgIG5leHRZID0gKHN0YXJ0WCA9PSAwID8gc3RhcnRZIDwgMCA6IHN0 YXJ0WCA+IDApID8gc3RhcnRZICsgMSA6IHN0YXJ0WSAtIDE7CisgICAgICAgICAgICBuZXh0WCA9 IGdldEVsbGlwc2VYKG5leHRZLCBhLCBiKTsKKyAgICAgICAgICAgIGlmIChzdGFydFggPCAwICYm IChzdGFydFkgPCAwID8gLW5leHRYID49IHN0YXJ0WCA6IC1uZXh0WCA8PSBzdGFydFgpKQorICAg ICAgICAgICAgICAgIG5leHRYID0gLW5leHRYOworICAgICAgICB9IGVsc2UgaWYgKHN0YXJ0WSA8 IDAgJiYgKHN0YXJ0WCA8IDAgPyAtbmV4dFkgPD0gc3RhcnRZIDogLW5leHRZID49IHN0YXJ0WSkp CisgICAgICAgICAgICBuZXh0WSA9IC1uZXh0WTsKKyAgICAgICAgc3RhcnRYID0gbmV4dFg7Cisg ICAgICAgIHN0YXJ0WSA9IG5leHRZOworICAgICAgICBMaW5lVG8oZGMsIHN0YXJ0WCArIGNlbnRl clgsIGNlbnRlclkgLSBzdGFydFkpOworICAgIH0KKyAgICBMaW5lVG8oZGMsIGVuZFggKyBjZW50 ZXJYLCBjZW50ZXJZIC0gZW5kWSk7CisjZWxzZQorCisgICAgc3RhcnRYICs9IGNlbnRlclg7Cisg ICAgc3RhcnRZID0gY2VudGVyWSAtIHN0YXJ0WTsKKyAgICBlbmRYICs9IGNlbnRlclg7CisgICAg ZW5kWSA9IGNlbnRlclkgLSBlbmRZOworICAgIFJFQ1QgY2xpcFJlY3Q7CisgICAgaWYgKHN0YXJ0 WCA8IGVuZFgpIHsKKyAgICAgICAgY2xpcFJlY3QubGVmdCA9IHN0YXJ0WDsKKyAgICAgICAgY2xp cFJlY3QucmlnaHQgPSBlbmRYOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsaXBSZWN0LmxlZnQg PSBlbmRYOworICAgICAgICBjbGlwUmVjdC5yaWdodCA9IHN0YXJ0WDsKKyAgICB9CisgICAgaWYg KHN0YXJ0WSA8IGVuZFkpIHsKKyAgICAgICAgY2xpcFJlY3QudG9wID0gc3RhcnRZOworICAgICAg ICBjbGlwUmVjdC5ib3R0b20gPSBlbmRZOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsaXBSZWN0 LnRvcCA9IGVuZFk7CisgICAgICAgIGNsaXBSZWN0LmJvdHRvbSA9IHN0YXJ0WTsKKyAgICB9CisK KyAgICBPd25QdHI8SFJHTj4gY2xpcFJnbihDcmVhdGVSZWN0UmduKDAsIDAsIDAsIDApKTsKKyAg ICBib29sIG5ld0NsaXA7CisgICAgaWYgKEdldENsaXBSZ24oZGMsIGNsaXBSZ24uZ2V0KCkpIDw9 IDApIHsKKyAgICAgICAgbmV3Q2xpcCA9IHRydWU7CisgICAgICAgIGNsaXBSZ24uc2V0KENyZWF0 ZVJlY3RSZ24oY2xpcFJlY3QubGVmdCwgY2xpcFJlY3QudG9wLCBjbGlwUmVjdC5yaWdodCwgY2xp cFJlY3QuYm90dG9tKSk7CisgICAgICAgIFNlbGVjdENsaXBSZ24oZGMsIGNsaXBSZ24uZ2V0KCkp OworICAgIH0gZWxzZSB7CisgICAgICAgIG5ld0NsaXAgPSBmYWxzZTsKKyAgICAgICAgSW50ZXJz ZWN0Q2xpcFJlY3QoZGMsIGNsaXBSZWN0LmxlZnQsIGNsaXBSZWN0LnRvcCwgY2xpcFJlY3Qucmln aHQsIGNsaXBSZWN0LmJvdHRvbSk7CisgICAgfQorCisgICAgSEdESU9CSiBvbGRCcnVzaCA9IFNl bGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkpOworICAgIEVsbGlwc2Uo ZGMsIHRyUmVjdC54KCksIHRyUmVjdC55KCksIHRyUmVjdC5yaWdodCgpLCB0clJlY3QuYm90dG9t KCkpOworICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOworCisgICAgaWYgKG5ld0NsaXAp CisgICAgICAgIFNlbGVjdENsaXBSZ24oZGMsIDApOworICAgIGVsc2UKKyAgICAgICAgU2VsZWN0 Q2xpcFJnbihkYywgY2xpcFJnbi5nZXQoKSk7CisKKyNlbmRpZgorCisgICAgU2VsZWN0T2JqZWN0 KGRjLCBvbGRQZW4pOworICAgIERlbGV0ZU9iamVjdChwZW4pOworfQorCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6ZHJhd0NvbnZleFBvbHlnb24oc2l6ZV90IG5wb2ludHMsIGNvbnN0IEZsb2F0UG9p bnQqIHBvaW50cywgYm9vbCBzaG91bGRBbnRpYWxpYXMpCit7CisgICAgaWYgKCFtX2RhdGEtPm1f b3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgbnBvaW50cyA8PSAxIHx8ICFwb2ludHMp CisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0 YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIFZlY3Rv cjxQT0lOVCwgMjA+IHdpblBvaW50czsKKyAgICB3aW5Qb2ludHMucmVzaXplKG5wb2ludHMpOwor ICAgIEZsb2F0UG9pbnQgdHJQb2ludCA9IG1fZGF0YS0+bWFwUG9pbnQocG9pbnRzWzBdKTsKKyAg ICB3aW5Qb2ludHNbMF0ueCA9IFJvdW5kKHRyUG9pbnQueCgpKTsKKyAgICB3aW5Qb2ludHNbMF0u eSA9IFJvdW5kKHRyUG9pbnQueSgpKTsKKyAgICBSRUNUIHJlY3QgPSB7IHdpblBvaW50c1swXS54 LCB3aW5Qb2ludHNbMF0ueSwgd2luUG9pbnRzWzBdLngsIHdpblBvaW50c1swXS55IH07CisgICAg Zm9yIChzaXplX3QgaSA9IDE7IGkgPCBucG9pbnRzOyArK2kpIHsKKyAgICAgICAgdHJQb2ludCA9 IG1fZGF0YS0+bWFwUG9pbnQocG9pbnRzW2ldKTsKKyAgICAgICAgd2luUG9pbnRzW2ldLnggPSBS b3VuZCh0clBvaW50LngoKSk7CisgICAgICAgIHdpblBvaW50c1tpXS55ID0gUm91bmQodHJQb2lu dC55KCkpOworICAgICAgICBpZiAocmVjdC5sZWZ0ID4gd2luUG9pbnRzW2ldLngpCisgICAgICAg ICAgICByZWN0LmxlZnQgPSB3aW5Qb2ludHNbaV0ueDsKKyAgICAgICAgZWxzZSBpZiAocmVjdC5y aWdodCA8IHdpblBvaW50c1tpXS54KQorICAgICAgICAgICAgcmVjdC5yaWdodCA9IHdpblBvaW50 c1tpXS54OworICAgICAgICBpZiAocmVjdC50b3AgPiB3aW5Qb2ludHNbaV0ueSkKKyAgICAgICAg ICAgIHJlY3QudG9wID0gd2luUG9pbnRzW2ldLnk7CisgICAgICAgIGVsc2UgaWYgKHJlY3QuYm90 dG9tIDwgd2luUG9pbnRzW2ldLnkpCisgICAgICAgICAgICByZWN0LmJvdHRvbSA9IHdpblBvaW50 c1tpXS55OworICAgIH0KKyAgICByZWN0LmJvdHRvbSArPSAxOworICAgIHJlY3QucmlnaHQgKz0g MTsKKworICAgIEludFJlY3QgaW50UmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMg dHJhbnNwYXJlbnREYyhtX2RhdGEsIGludFJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50 RGMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIGZvciAoc2l6ZV90 IGkgPSAwOyBpIDwgbnBvaW50czsgKytpKSB7CisgICAgICAgIHdpblBvaW50c1tpXS54ICs9IHRy YW5zcGFyZW50RGMudG9TaGlmdCgpLndpZHRoKCk7CisgICAgICAgIHdpblBvaW50c1tpXS55ICs9 IHRyYW5zcGFyZW50RGMudG9TaGlmdCgpLmhlaWdodCgpOworICAgIH0KKworICAgIEhHRElPQkog YnJ1c2ggPSAwOworICAgIEhHRElPQkogb2xkQnJ1c2g7CisgICAgaWYgKGZpbGxDb2xvcigpLmFs cGhhKCkpIHsKKyAgICAgICAgYnJ1c2ggPSBjcmVhdGVCcnVzaChmaWxsQ29sb3IoKSk7CisgICAg ICAgIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KGRjLCBicnVzaCk7CisgICAgfSBlbHNlCisgICAg ICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkpOworICAgIEhH RElPQkogcGVuID0gMDsKKyAgICBIR0RJT0JKIG9sZFBlbjsKKyAgICBpZiAoc3Ryb2tlU3R5bGUo KSAhPSBOb1N0cm9rZSkgeworICAgICAgICBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwg c3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOworICAgICAgICBvbGRQZW4gPSBTZWxl Y3RPYmplY3QoZGMsIHBlbik7CisgICAgfSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywg R2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKworICAgIGlmIChicnVzaCB8fCBwZW4pIHsKKyAg ICAgICAgUG9seWdvbihkYywgd2luUG9pbnRzLmRhdGEoKSwgbnBvaW50cyk7CisKKyAgICAgICAg aWYgKHBlbikgeworICAgICAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRQZW4pOworICAgICAg ICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgICAgIH0KKworICAgICAgICBpZiAoYnJ1c2gp IHsKKyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOworICAgICAgICAgICAg RGVsZXRlT2JqZWN0KGJydXNoKTsKKyAgICAgICAgfQorICAgIH0KK30KKworc3RhdGljIHZvaWQg ZmlsbFJlY3RXaXRoQWxwaGEoSERDIGhkYywgY29uc3QgUkVDVCogcmVjdCwgSEJSVVNIIGhicnVz aCwgaW50IGFscGhhKQoreworICAgIGludCB3aWR0aCA9IHJlY3QtPnJpZ2h0IC0gcmVjdC0+bGVm dDsKKyAgICBpbnQgaGVpZ2h0ID0gcmVjdC0+Ym90dG9tIC0gcmVjdC0+dG9wOworICAgIGlmICh3 aWR0aCA8PSAwIHx8IGhlaWdodCA8PSAwKQorICAgICAgICByZXR1cm47CisKKyAgICBSZWZQdHI8 U2hhcmVkQml0bWFwPiBibXAgPSBTaGFyZWRCaXRtYXA6OmNyZWF0ZUluc3RhbmNlKHRydWUsIHdp ZHRoLCBoZWlnaHQsIGZhbHNlKTsKKyAgICBpZiAoIWJtcCkKKyAgICAgICAgcmV0dXJuOworCisg ICAgU2hhcmVkQml0bWFwOjpEQ0hvbGRlciBtZW1EYyhibXAuZ2V0KCkpOworICAgIGlmICghbWVt RGMuZ2V0KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJFQ1QgZmlsbFJlY3QgPSB7IDAsIDAs IHdpZHRoLCBoZWlnaHQgfTsKKyAgICBGaWxsUmVjdChtZW1EYy5nZXQoKSwgJmZpbGxSZWN0LCBo YnJ1c2gpOworCisjaWYgIWRlZmluZWQoTk9fQUxQSEFCTEVORCkKKyAgICBjb25zdCBCTEVOREZV TkNUSU9OIGJsZW5kID0geyBBQ19TUkNfT1ZFUiwgMAorICAgICAgICAsIGFscGhhCisgICAgICAg ICwgMCB9OworICAgIEFscGhhQmxlbmQKKyAgICAgICAgKGhkYworICAgICAgICAsIHJlY3QtPmxl ZnQKKyAgICAgICAgLCByZWN0LT50b3AKKyAgICAgICAgLCB3aWR0aAorICAgICAgICAsIGhlaWdo dAorICAgICAgICAsIG1lbURjLmdldCgpCisgICAgICAgICwgMAorICAgICAgICAsIDAKKyAgICAg ICAgLCB3aWR0aAorICAgICAgICAsIGhlaWdodAorICAgICAgICAsIGJsZW5kCisgICAgICAgICk7 CisjZWxzZQorICAgIFRyYW5zcGFyZW50Qmx0CisgICAgICAgIChoZGMKKyAgICAgICAgLCByZWN0 LT5sZWZ0CisgICAgICAgICwgcmVjdC0+dG9wCisgICAgICAgICwgd2lkdGgKKyAgICAgICAgLCBo ZWlnaHQKKyAgICAgICAgLCBtZW1EYy5nZXQoKQorICAgICAgICAsIDAKKyAgICAgICAgLCAwCisg ICAgICAgICwgd2lkdGgKKyAgICAgICAgLCBoZWlnaHQKKyAgICAgICAgLCAwCisgICAgICAgICk7 CisjZW5kaWYKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0 UmVjdCYgcmVjdCwgY29uc3QgQ29sb3ImIGNvbG9yKQoreworICAgIGlmIChwYWludGluZ0Rpc2Fi bGVkKCkgfHwgIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAo aW50IGFscGhhID0gY29sb3IuYWxwaGEoKSkgeworICAgICAgICBPd25QdHI8SEJSVVNIPiBoYnJ1 c2goQ3JlYXRlU29saWRCcnVzaChSR0IoY29sb3IucmVkKCksIGNvbG9yLmdyZWVuKCksIGNvbG9y LmJsdWUoKSkpKTsKKyAgICAgICAgaWYgKGhicnVzaCkgeworICAgICAgICAgICAgU2NvcGVEQ1By b3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICAgICAgICAgIGlmIChtX2RhdGEtPm1fZGMp IHsKKyAgICAgICAgICAgICAgICBJbnRSZWN0IGludFJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KHJl Y3QpOworICAgICAgICAgICAgICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1f ZGF0YSwgbV9kYXRhLT5tYXBSZWN0KGludFJlY3QpLCAmaW50UmVjdCk7CisgICAgICAgICAgICAg ICAgaWYgKHRyYW5zcGFyZW50RGMuaGRjKCkpCisgICAgICAgICAgICAgICAgICAgIGlmIChhbHBo YSA9PSAweEZGKQorICAgICAgICAgICAgICAgICAgICAgICAgRmlsbFJlY3QodHJhbnNwYXJlbnRE Yy5oZGMoKSwgJnRyYW5zcGFyZW50RGMucmVjdCgpLCBoYnJ1c2guZ2V0KCkpOworICAgICAgICAg ICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICBmaWxsUmVjdFdpdGhBbHBo YSh0cmFuc3BhcmVudERjLmhkYygpLCAmdHJhbnNwYXJlbnREYy5yZWN0KCksIGhicnVzaC5nZXQo KSwgYWxwaGEpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6Y2xpcChjb25zdCBGbG9hdFJlY3QmIHJlY3QpCit7CisgICAgaWYgKHBh aW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2RhdGEtPm1f ZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0ID0gZW5jbG9zaW5nSW50 UmVjdChtX2RhdGEtPm1hcFJlY3QocmVjdCkpOworCisgICAgT3duUHRyPEhSR04+IGNsaXBSZ24o Q3JlYXRlUmVjdFJnbigwLCAwLCAwLCAwKSk7CisgICAgaWYgKEdldENsaXBSZ24obV9kYXRhLT5t X2RjLCBjbGlwUmduLmdldCgpKSA+IDApCisgICAgICAgIEludGVyc2VjdENsaXBSZWN0KG1fZGF0 YS0+bV9kYywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJpZ2h0KCksIHRyUmVjdC5i b3R0b20oKSk7CisgICAgZWxzZSB7CisgICAgICAgIGNsaXBSZ24uc2V0KENyZWF0ZVJlY3RSZ24o dHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJpZ2h0KCksIHRyUmVjdC5ib3R0b20oKSkp OworICAgICAgICBTZWxlY3RDbGlwUmduKG1fZGF0YS0+bV9kYywgY2xpcFJnbi5nZXQoKSk7Cisg ICAgfQorfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xpcE91dChjb25zdCBJbnRSZWN0JiBy ZWN0KQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKwor ICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRy UmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0KTsKKworICAgIEV4Y2x1ZGVDbGlwUmVjdChtX2Rh dGEtPm1fZGMsIHRyUmVjdC54KCksIHRyUmVjdC55KCksIHRyUmVjdC5yaWdodCgpLCB0clJlY3Qu Ym90dG9tKCkpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0ZvY3VzUmluZyhjb25z dCBDb2xvciYgY29sb3IpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGlu Z0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1By b3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsK KworICAgIGludCByYWRpdXMgPSAoZm9jdXNSaW5nV2lkdGgoKSAtIDEpIC8gMjsKKyAgICBpbnQg b2Zmc2V0ID0gcmFkaXVzICsgZm9jdXNSaW5nT2Zmc2V0KCk7CisKKyAgICBjb25zdCBWZWN0b3I8 SW50UmVjdD4mIHJlY3RzID0gZm9jdXNSaW5nUmVjdHMoKTsKKyAgICB1bnNpZ25lZCByZWN0Q291 bnQgPSByZWN0cy5zaXplKCk7CisgICAgSW50UmVjdCBmaW5hbEZvY3VzUmVjdDsKKyAgICBmb3Ig KHVuc2lnbmVkIGkgPSAwOyBpIDwgcmVjdENvdW50OyBpKyspIHsKKyAgICAgICAgSW50UmVjdCBm b2N1c1JlY3QgPSByZWN0c1tpXTsKKyAgICAgICAgZm9jdXNSZWN0LmluZmxhdGUob2Zmc2V0KTsK KyAgICAgICAgZmluYWxGb2N1c1JlY3QudW5pdGUoZm9jdXNSZWN0KTsKKyAgICB9CisKKyAgICBS RUNUIHJlY3QgPSB7IGZpbmFsRm9jdXNSZWN0LngoKSwgZmluYWxGb2N1c1JlY3QueSgpLCBmaW5h bEZvY3VzUmVjdC5yaWdodCgpLCBmaW5hbEZvY3VzUmVjdC5ib3R0b20oKSB9OworCisgICAgSW50 UmVjdCBpbnRSZWN0ID0gcmVjdDsKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVj dChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIHRy UmVjdCwgJmludFJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAg aWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50RGMu dG9TaGlmdCgpKTsKKworICAgIHJlY3QgPSB0clJlY3Q7CisgICAgRHJhd0ZvY3VzUmVjdChkYywg JnJlY3QpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0xpbmVGb3JUZXh0KGNvbnN0 IEludFBvaW50JiBvcmlnaW4sIGludCB3aWR0aCwgYm9vbCBwcmludGluZykKK3sKKyAgICBpZiAo cGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBTdHJva2VTdHlsZSBv bGRTdHlsZSA9IHN0cm9rZVN0eWxlKCk7CisgICAgc2V0U3Ryb2tlU3R5bGUoU29saWRTdHJva2Up OworICAgIGRyYXdMaW5lKG9yaWdpbiwgb3JpZ2luICsgSW50U2l6ZSh3aWR0aCwgMCkpOworICAg IHNldFN0cm9rZVN0eWxlKG9sZFN0eWxlKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRy YXdMaW5lRm9yTWlzc3BlbGxpbmdPckJhZEdyYW1tYXIoY29uc3QgSW50UG9pbnQmLCBpbnQgd2lk dGgsIGJvb2wgZ3JhbW1hcikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1GaWxsQ29sb3IoY29uc3QgQ29sb3ImIGNvbCkKK3sK KyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxh dGZvcm1TdHJva2VDb2xvcihjb25zdCBDb2xvciYgY29sKQoreworICAgIG5vdEltcGxlbWVudGVk KCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRQbGF0Zm9ybVN0cm9rZVRoaWNrbmVz cyhmbG9hdCBzdHJva2VUaGlja25lc3MpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldFVSTEZvclJlY3QoY29uc3QgS1VSTCYgbGluaywgY29u c3QgSW50UmVjdCYgZGVzdFJlY3QpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9p ZCBHcmFwaGljc0NvbnRleHQ6OmFkZElubmVyUm91bmRlZFJlY3RDbGlwKGNvbnN0IEludFJlY3Qm IHJlY3QsIGludCB0aGlja25lc3MpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICAvLyBG SVggTUU6CisgICAgY2xpcChyZWN0KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmNsZWFy UmVjdChjb25zdCBGbG9hdFJlY3QmIHJlY3QpCit7CisgICAgZmlsbFJlY3QocmVjdCwgQ29sb3I6 OndoaXRlKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnN0cm9rZVJlY3QoY29uc3QgRmxv YXRSZWN0JiByZWN0LCBmbG9hdCB3aWR0aCkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5 IHx8IHBhaW50aW5nRGlzYWJsZWQoKSB8fCBzdHJva2VTdHlsZSgpID09IE5vU3Ryb2tlKQorICAg ICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOwor ICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IGlu dFJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KHJlY3QpOworICAgIEludFJlY3QgdHJSZWN0ID0gbV9k YXRhLT5tYXBSZWN0KGludFJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVu dERjKG1fZGF0YSwgdHJSZWN0LCAmaW50UmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnRE Yy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUo dHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworCisgICAgSEdESU9CSiBwZW4gPSBjcmVhdGVQZW4o c3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOworICAgIEhH RElPQkogb2xkUGVuID0gU2VsZWN0T2JqZWN0KGRjLCBwZW4pOworCisgICAgaW50IHJpZ2h0ID0g dHJSZWN0LnJpZ2h0KCkgLSAxOworICAgIGludCBib3R0b20gPSB0clJlY3QuYm90dG9tKCkgLSAx OworICAgIGNvbnN0IFBPSU5UIGludFBvaW50c1s1XSA9CisgICAgeworICAgICAgICB7IHRyUmVj dC54KCksIHRyUmVjdC55KCkgfSwKKyAgICAgICAgeyByaWdodCwgdHJSZWN0LnkoKSB9LAorICAg ICAgICB7IHJpZ2h0LCBib3R0b20gfSwKKyAgICAgICAgeyB0clJlY3QueCgpLCBib3R0b20gfSwK KyAgICAgICAgeyB0clJlY3QueCgpLCB0clJlY3QueSgpIH0KKyAgICB9OworCisgICAgUG9seWxp bmUoZGMsIGludFBvaW50cywgNSk7CisKKyAgICBTZWxlY3RPYmplY3QoZGMsIG9sZFBlbik7Cisg ICAgRGVsZXRlT2JqZWN0KHBlbik7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpiZWdpblRy YW5zcGFyZW5jeUxheWVyKGZsb2F0IG9wYWNpdHkpCit7CisgICAgbV9kYXRhLT5zYXZlKCk7Cisg ICAgbV9kYXRhLT5tX29wYWNpdHkgKj0gb3BhY2l0eTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRl eHQ6OmVuZFRyYW5zcGFyZW5jeUxheWVyKCkKK3sKKyAgICBtX2RhdGEtPnJlc3RvcmUoKTsKK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmNvbmNhdENUTShjb25zdCBUcmFuc2Zvcm1hdGlvbk1h dHJpeCYgdHJhbnNmb3JtKQoreworICAgIG1fZGF0YS0+Y29uY2F0Q1RNKHRyYW5zZm9ybSk7Cit9 CisKK1RyYW5zZm9ybWF0aW9uTWF0cml4JiBHcmFwaGljc0NvbnRleHQ6OmFmZmluZVRyYW5zZm9y bSgpCit7CisgICAgcmV0dXJuIG1fZGF0YS0+bV90cmFuc2Zvcm07Cit9CisKK2NvbnN0IFRyYW5z Zm9ybWF0aW9uTWF0cml4JiBHcmFwaGljc0NvbnRleHQ6OmFmZmluZVRyYW5zZm9ybSgpIGNvbnN0 Cit7CisgICAgcmV0dXJuIG1fZGF0YS0+bV90cmFuc2Zvcm07Cit9CisKK3ZvaWQgR3JhcGhpY3ND b250ZXh0OjpyZXNldEFmZmluZVRyYW5zZm9ybSgpCit7CisgICAgbV9kYXRhLT5tX3RyYW5zZm9y bS5tYWtlSWRlbnRpdHkoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnRyYW5zbGF0ZShm bG9hdCB4LCBmbG9hdCB5KQoreworICAgIG1fZGF0YS0+dHJhbnNsYXRlKHgsIHkpOworfQorCit2 b2lkIEdyYXBoaWNzQ29udGV4dDo6cm90YXRlKGZsb2F0IHJhZGlhbnMpCit7CisgICAgbV9kYXRh LT5yb3RhdGUocmFkaWFucyk7Cit9CisKK0ludFBvaW50IEdyYXBoaWNzQ29udGV4dDo6b3JpZ2lu KCkKK3sKKyAgICByZXR1cm4gbV9kYXRhLT5vcmlnaW4oKTsKK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OnNjYWxlKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkKK3sKKyAgICBtX2RhdGEtPnNjYWxl KHNpemUpOworfQorCitGbG9hdFJlY3QgR3JhcGhpY3NDb250ZXh0OjptYXBSZWN0KGNvbnN0IEZs b2F0UmVjdCYgcmVjdCkKK3sKKyAgICByZXR1cm4gbV9kYXRhLT5tYXBSZWN0KHJlY3QpOworfQor CitJbnRSZWN0IEdyYXBoaWNzQ29udGV4dDo6bWFwUmVjdChjb25zdCBJbnRSZWN0JiByZWN0KQor eworICAgIHJldHVybiBtX2RhdGEtPm1hcFJlY3QocmVjdCk7Cit9CisKK0Zsb2F0UG9pbnQgR3Jh cGhpY3NDb250ZXh0OjptYXBQb2ludChjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3sKKyAgICBy ZXR1cm4gbV9kYXRhLT5tYXBQb2ludChwb2ludCk7Cit9CisKK0Zsb2F0U2l6ZSBHcmFwaGljc0Nv bnRleHQ6Om1hcFNpemUoY29uc3QgRmxvYXRTaXplJiBzaXplKQoreworICAgIHJldHVybiBtX2Rh dGEtPm1hcFNpemUoc2l6ZSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRMaW5lQ2Fw KExpbmVDYXAgbGluZUNhcCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6c2V0TGluZUpvaW4oTGluZUpvaW4gbGluZUpvaW4pCit7CisgICAgbm90 SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldE1pdGVyTGltaXQo ZmxvYXQgbWl0ZXIpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGlj c0NvbnRleHQ6OnNldEFscGhhKGZsb2F0IGFscGhhKQoreworICAgIG1fZGF0YS0+bV9vcGFjaXR5 ID0gYWxwaGE7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRDb21wb3NpdGVPcGVyYXRp b24oQ29tcG9zaXRlT3BlcmF0b3Igb3ApCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmJlZ2luUGF0aCgpCit7CisgICAgbV9kYXRhLT5tX3BhdGhz LmNsZWFyKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGRQYXRoKGNvbnN0IFBhdGgm IHBhdGgpCit7CisgICAgbV9kYXRhLT5tX3BhdGhzLmFwcGVuZChwYXRoKTsKK30KKwordm9pZCBH cmFwaGljc0NvbnRleHQ6OmNsaXAoY29uc3QgUGF0aCYgcGF0aCkKK3sKKyAgICBub3RJbXBsZW1l bnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xpcE91dChjb25zdCBQYXRoJikK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xp cE91dEVsbGlwc2VJblJlY3QoY29uc3QgSW50UmVjdCYpCit7CisgICAgbm90SW1wbGVtZW50ZWQo KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSb3VuZGVkUmVjdChjb25zdCBJbnRS ZWN0JiwgY29uc3QgSW50U2l6ZSYgdG9wTGVmdCwgY29uc3QgSW50U2l6ZSYgdG9wUmlnaHQsIGNv bnN0IEludFNpemUmIGJvdHRvbUxlZnQsIGNvbnN0IEludFNpemUmIGJvdHRvbVJpZ2h0LCBjb25z dCBDb2xvciYpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKworRmxvYXRSZWN0IEdyYXBo aWNzQ29udGV4dDo6cm91bmRUb0RldmljZVBpeGVscyhjb25zdCBGbG9hdFJlY3QmIGZyZWN0KQor eworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJuIGZyZWN0OworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6ZmlsbFBhdGgoKQoreworICAgIGlmICghZmlsbENvbG9yKCkuYWxwaGEo KSB8fCAhbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJldHVybjsKKyAgICBTY29wZURDUHJv dmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAg ICByZXR1cm47CisKKyAgICBpZiAobV9kYXRhLT5tX29wYWNpdHkgPCAxLjBmKSB7CisgICAgICAg IEhHRElPQkogYnJ1c2ggPSBjcmVhdGVCcnVzaChmaWxsQ29sb3IoKSk7CisgICAgICAgIGZvciAo VmVjdG9yPFBhdGg+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7 IGkgIT0gbV9kYXRhLT5tX3BhdGhzLmVuZCgpOyArK2kpIHsKKyAgICAgICAgICAgIEludFJlY3Qg dHJSZWN0ID0gcm91bmRSZWN0KG1fZGF0YS0+bWFwUmVjdChpLT5ib3VuZGluZ1JlY3QoKSkpOwor ICAgICAgICAgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50RGMobV9kYXRhLCB0clJl Y3QpOworICAgICAgICAgICAgSERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICAgICAg ICAgIGlmICghZGMpCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIFRy YW5zZm9ybWF0aW9uTWF0cml4IHRyID0gbV9kYXRhLT5tX3RyYW5zZm9ybTsKKyAgICAgICAgICAg IHRyLnRyYW5zbGF0ZSh0cmFuc3BhcmVudERjLnRvU2hpZnQoKS53aWR0aCgpLCB0cmFuc3BhcmVu dERjLnRvU2hpZnQoKS5oZWlnaHQoKSk7CisKKyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywg R2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKyAgICAgICAgICAgIEhHRElPQkogb2xkQnJ1c2gg PSBTZWxlY3RPYmplY3QoZGMsIGJydXNoKTsKKyAgICAgICAgICAgIGktPnBsYXRmb3JtUGF0aCgp LT5maWxsUGF0aChkYywgJnRyKTsKKyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1 c2gpOworICAgICAgICB9CisgICAgICAgIERlbGV0ZU9iamVjdChicnVzaCk7CisgICAgfSBlbHNl IHsKKyAgICAgICAgU2VsZWN0T2JqZWN0KG1fZGF0YS0+bV9kYywgR2V0U3RvY2tPYmplY3QoTlVM TF9QRU4pKTsKKyAgICAgICAgSEdESU9CSiBicnVzaCA9IGNyZWF0ZUJydXNoKGZpbGxDb2xvcigp KTsKKyAgICAgICAgSEdESU9CSiBvbGRCcnVzaCA9IFNlbGVjdE9iamVjdChtX2RhdGEtPm1fZGMs IGJydXNoKTsKKyAgICAgICAgZm9yIChWZWN0b3I8UGF0aD46OmNvbnN0X2l0ZXJhdG9yIGkgPSBt X2RhdGEtPm1fcGF0aHMuYmVnaW4oKTsgaSAhPSBtX2RhdGEtPm1fcGF0aHMuZW5kKCk7ICsraSkK KyAgICAgICAgICAgIGktPnBsYXRmb3JtUGF0aCgpLT5maWxsUGF0aChtX2RhdGEtPm1fZGMsICZt X2RhdGEtPm1fdHJhbnNmb3JtKTsKKyAgICAgICAgU2VsZWN0T2JqZWN0KG1fZGF0YS0+bV9kYywg b2xkQnJ1c2gpOworICAgICAgICBEZWxldGVPYmplY3QoYnJ1c2gpOworICAgIH0KK30KKworCit2 b2lkIEdyYXBoaWNzQ29udGV4dDo6c3Ryb2tlUGF0aCgpCit7CisgICAgaWYgKCFtX2RhdGEtPm1f b3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlk ZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisg ICAgaWYgKG1fZGF0YS0+bV9vcGFjaXR5IDwgMS4wZikgeworICAgICAgICBIR0RJT0JKIHBlbiA9 IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUo KSk7CisgICAgICAgIGZvciAoVmVjdG9yPFBhdGg+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9kYXRh LT5tX3BhdGhzLmJlZ2luKCk7IGkgIT0gbV9kYXRhLT5tX3BhdGhzLmVuZCgpOyArK2kpIHsKKyAg ICAgICAgICAgIEludFJlY3QgdHJSZWN0ID0gcm91bmRSZWN0KG1fZGF0YS0+bWFwUmVjdChpLT5i b3VuZGluZ1JlY3QoKSkpOworICAgICAgICAgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFy ZW50RGMobV9kYXRhLCB0clJlY3QpOworICAgICAgICAgICAgSERDIGRjID0gdHJhbnNwYXJlbnRE Yy5oZGMoKTsKKyAgICAgICAgICAgIGlmICghZGMpCisgICAgICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IHRyID0gbV9kYXRhLT5tX3RyYW5z Zm9ybTsKKyAgICAgICAgICAgIHRyLnRyYW5zbGF0ZSh0cmFuc3BhcmVudERjLnRvU2hpZnQoKS53 aWR0aCgpLCB0cmFuc3BhcmVudERjLnRvU2hpZnQoKS5oZWlnaHQoKSk7CisKKyAgICAgICAgICAg IFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkpOworICAgICAgICAg ICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisgICAgICAgICAgICBp LT5wbGF0Zm9ybVBhdGgoKS0+c3Ryb2tlUGF0aChkYywgJm1fZGF0YS0+bV90cmFuc2Zvcm0pOwor ICAgICAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRQZW4pOworICAgICAgICB9CisgICAgICAg IERlbGV0ZU9iamVjdChwZW4pOworICAgIH0gZWxzZSB7CisgICAgICAgIFNlbGVjdE9iamVjdCht X2RhdGEtPm1fZGMsIEdldFN0b2NrT2JqZWN0KE5VTExfQlJVU0gpKTsKKyAgICAgICAgSEdESU9C SiBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9r ZVN0eWxlKCkpOworICAgICAgICBIR0RJT0JKIG9sZFBlbiA9IFNlbGVjdE9iamVjdChtX2RhdGEt Pm1fZGMsIHBlbik7CisgICAgICAgIGZvciAoVmVjdG9yPFBhdGg+Ojpjb25zdF9pdGVyYXRvciBp ID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7IGkgIT0gbV9kYXRhLT5tX3BhdGhzLmVuZCgpOyAr K2kpCisgICAgICAgICAgICBpLT5wbGF0Zm9ybVBhdGgoKS0+c3Ryb2tlUGF0aChtX2RhdGEtPm1f ZGMsICZtX2RhdGEtPm1fdHJhbnNmb3JtKTsKKyAgICAgICAgU2VsZWN0T2JqZWN0KG1fZGF0YS0+ bV9kYywgb2xkUGVuKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgfQorfQorCit2 b2lkIEdyYXBoaWNzQ29udGV4dDo6ZmlsbFJlY3QoY29uc3QgRmxvYXRSZWN0JiByLCBjb25zdCBH cmFkaWVudCogZ3JhZGllbnQpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgY29uc3QgVmVjdG9yPEdyYWRpZW50OjpDb2xvclN0b3A+JiBzdG9w cyA9IGdyYWRpZW50LT5nZXRTdG9wcygpOworICAgIGludCBudW1TdG9wcyA9IHN0b3BzLnNpemUo KTsKKyAgICBpZiAobnVtU3RvcHMgPT0gMCkgeworICAgIH0gZWxzZSBpZiAobnVtU3RvcHMgPT0g MSkgeworICAgICAgICBjb25zdCBHcmFkaWVudDo6Q29sb3JTdG9wJiBzdG9wID0gc3RvcHMuZmly c3QoKTsKKyAgICAgICAgQ29sb3IgY29sb3Ioc3RvcC5yZWQgKiAyNTUsIHN0b3AuZ3JlZW4gKiAy NTUsIHN0b3AuYmx1ZSAqIDI1NSwgc3RvcC5hbHBoYSAqIDI1NSk7CisgICAgICAgIGZpbGxSZWN0 KHIsIGNvbG9yKTsKKyAgICB9IGVsc2UgeworICAgICAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92 aWRlcihtX2RhdGEpOworICAgICAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgICAgIHJl dHVybjsKKworICAgICAgICBJbnRSZWN0IGludFJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KHIpOwor ICAgICAgICBJbnRSZWN0IHJlY3QgPSBtX2RhdGEtPm1hcFJlY3QoaW50UmVjdCk7CisgICAgICAg IFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0YSwgcmVjdCwgJmludFJlY3Qp OworICAgICAgICBIREMgZGMgPSB0cmFuc3BhcmVudERjLmhkYygpOworICAgICAgICBpZiAoIWRj KQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICByZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50 b1NoaWZ0KCkpOworCisgICAgICAgIGludCBudW1SZWN0cyA9IChudW1TdG9wcyAtIDEpOworICAg ICAgICBWZWN0b3I8VFJJVkVSVEVYLCAyMD4gdHY7CisgICAgICAgIHR2LnJlc2l6ZShudW1SZWN0 cyAqIDIpOworICAgICAgICBWZWN0b3I8R1JBRElFTlRfUkVDVCwgMTA+IG1lc2g7CisgICAgICAg IG1lc2gucmVzaXplKG51bVJlY3RzKTsKKyAgICAgICAgaW50IHggPSByZWN0LngoKTsKKyAgICAg ICAgaW50IHkgPSByZWN0LnkoKTsKKyAgICAgICAgaW50IHdpZHRoID0gcmVjdC53aWR0aCgpOwor ICAgICAgICBpbnQgaGVpZ2h0ID0gcmVjdC5oZWlnaHQoKTsKKyAgICAgICAgRmxvYXRTaXplIGQg PSBncmFkaWVudC0+cDEoKSAtIGdyYWRpZW50LT5wMCgpOworICAgICAgICBib29sIHZlcnRpY2Fs ID0gYWJzKGQuaGVpZ2h0KCkpID4gYWJzKGQud2lkdGgoKSk7CisgICAgICAgIGZsb2F0IHJbMl0g PSB7IGdyYWRpZW50LT5yMCgpLCBncmFkaWVudC0+cjEoKSB9OworICAgICAgICBmbG9hdCBkZW5v bSA9IDEuIC8gKHJbMV0gLSByWzBdKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1T dG9wczsgKytpKSB7CisgICAgICAgICAgICBjb25zdCBHcmFkaWVudDo6Q29sb3JTdG9wJiBzdG9w ID0gc3RvcHNbaV07CisgICAgICAgICAgICBpbnQgaVR2ID0gaSA/IDIgKiBpIC0gMSA6IDA7Cisg ICAgICAgICAgICB0dltpVHZdLlJlZCA9IHN0b3AucmVkICogMHhGRkZGOworICAgICAgICAgICAg dHZbaVR2XS5HcmVlbiA9IHN0b3AuZ3JlZW4gKiAweEZGRkY7CisgICAgICAgICAgICB0dltpVHZd LkJsdWUgPSBzdG9wLmJsdWUgKiAweEZGRkY7CisgICAgICAgICAgICB0dltpVHZdLkFscGhhID0g c3RvcC5hbHBoYSAqIDB4RkZGRjsKKyAgICAgICAgICAgIGZsb2F0IHJhdGlvID0gKHN0b3Auc3Rv cCAtIHJbMF0pICogZGVub207CisgICAgICAgICAgICBpZiAoaSkgeworICAgICAgICAgICAgICAg IHR2W2lUdl0ueCA9IHZlcnRpY2FsID8geCArIHdpZHRoOiB4ICsgd2lkdGggKiByYXRpbzsKKyAg ICAgICAgICAgICAgICB0dltpVHZdLnkgPSB2ZXJ0aWNhbCA/IHkgKyBoZWlnaHQgKiByYXRpbyA6 IHkgKyBoZWlnaHQ7CisgICAgICAgICAgICAgICAgbWVzaFtpIC0gMV0uVXBwZXJMZWZ0ID0gaVR2 IC0gMTsKKyAgICAgICAgICAgICAgICBtZXNoW2kgLSAxXS5Mb3dlclJpZ2h0ID0gaVR2OworICAg ICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICB0dltpVHZdLnggPSB4OworICAgICAg ICAgICAgICAgIHR2W2lUdl0ueSA9IHk7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGlm IChpICYmIGkgPCBudW1SZWN0cykgeworICAgICAgICAgICAgICAgIHR2W2lUdiArIDFdID0gdHZb aVR2XTsKKyAgICAgICAgICAgICAgICBpZiAodmVydGljYWwpCisgICAgICAgICAgICAgICAgICAg IHR2W2lUdiArIDFdLnggPSB4OworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAg ICAgICAgdHZbaVR2ICsgMV0ueSA9IHk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAg ICAgR3JhZGllbnRGaWxsKGRjLCB0di5kYXRhKCksIG51bVN0b3BzLCBtZXNoLmRhdGEoKSwgbnVt U3RvcHMgLSAxLCB2ZXJ0aWNhbCA/IEdSQURJRU5UX0ZJTExfUkVDVF9WIDogR1JBRElFTlRfRklM TF9SRUNUX0gpOworICAgIH0KK30KKworVHJhbnNmb3JtYXRpb25NYXRyaXggR3JhcGhpY3NDb250 ZXh0OjpnZXRDVE0oKSBjb25zdAoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJu IFRyYW5zZm9ybWF0aW9uTWF0cml4KCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlw VG9JbWFnZUJ1ZmZlcihjb25zdCBGbG9hdFJlY3QmLCBjb25zdCBJbWFnZUJ1ZmZlciopCit7Cisg ICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0 KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAobV9jb21tb24tPnN0YXRlLmZpbGxD b2xvclNwYWNlID09IEdyYWRpZW50Q29sb3JTcGFjZSAmJiBtX2NvbW1vbi0+c3RhdGUuZmlsbEdy YWRpZW50KQorICAgICAgICBmaWxsUmVjdChyZWN0LCBtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRp ZW50LmdldCgpKTsKKyAgICBlbHNlCisgICAgICAgIGZpbGxSZWN0KHJlY3QsIGZpbGxDb2xvcigp KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldFBsYXRmb3JtU2hhZG93KGNvbnN0IElu dFNpemUmLCBpbnQsIGNvbnN0IENvbG9yJikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQor Cit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xlYXJQbGF0Zm9ybVNoYWRvdygpCit7CisgICAgbm90 SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldEltYWdlSW50ZXJw b2xhdGlvblF1YWxpdHkoSW50ZXJwb2xhdGlvblF1YWxpdHkpCit7CisgICAgbm90SW1wbGVtZW50 ZWQoKTsKK30KKworI2RlZmluZSBpc0NoYXJWaXNpYmxlKGMpICgoYykgJiYgKGMpICE9IHplcm9X aWR0aFNwYWNlKQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd1RleHQoY29uc3QgRm9udCYg Zm9udCwgY29uc3QgVGV4dFJ1biYgcnVuLCBjb25zdCBJbnRQb2ludCYgcG9pbnQsIGludCBmcm9t LCBpbnQgdG8pCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSB8fCBmaWxsQ29sb3IoKS5h bHBoYSgpID09IDAgfHwgIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAg ICBpZiAoZmlsbENvbG9yKCkuYWxwaGEoKSA9PSAweEZGICYmIG1fZGF0YS0+bV9vcGFjaXR5ID49 IDEuMCkKKyAgICAgICAgZm9udC5kcmF3VGV4dCh0aGlzLCBydW4sIHBvaW50LCBmcm9tLCB0byk7 CisgICAgZWxzZSB7CisgICAgICAgIGZsb2F0IG9sZE9wYWNpdHkgPSBtX2RhdGEtPm1fb3BhY2l0 eTsKKyAgICAgICAgbV9kYXRhLT5tX29wYWNpdHkgKj0gZmlsbENvbG9yKCkuYWxwaGEoKSAvIDI1 NS4wOworCisgICAgICAgIEZsb2F0UmVjdCB0ZXh0UmVjdCA9IGZvbnQuc2VsZWN0aW9uUmVjdEZv clRleHQocnVuLCBwb2ludCwgZm9udC5oZWlnaHQoKSwgZnJvbSwgdG8pOworICAgICAgICB0ZXh0 UmVjdC5zZXRZKHRleHRSZWN0LnkoKSAtIGZvbnQuYXNjZW50KCkpOworICAgICAgICBJbnRSZWN0 IHRyUmVjdCA9IGVuY2xvc2luZ0ludFJlY3QobV9kYXRhLT5tYXBSZWN0KHRleHRSZWN0KSk7Cisg ICAgICAgIFJFQ1QgYm1wUmVjdDsKKyAgICAgICAgUmVmUHRyPFNoYXJlZEJpdG1hcD4gYm1wID0g bV9kYXRhLT5nZXRUcmFuc3BhcmVudExheWVyQml0bWFwKHRyUmVjdCwgdHJ1ZSwgYm1wUmVjdCwg dHJ1ZSwgZmFsc2UpOworICAgICAgICBpZiAoYm1wKSB7CisgICAgICAgICAgICB7CisgICAgICAg ICAgICAgICAgR3JhcGhpY3NDb250ZXh0IGdjKDApOworICAgICAgICAgICAgICAgIGdjLnNldEJp dG1hcChibXApOworICAgICAgICAgICAgICAgIGdjLnNjYWxlKEZsb2F0U2l6ZShtX2RhdGEtPm1f dHJhbnNmb3JtLmEoKSwgbV9kYXRhLT5tX3RyYW5zZm9ybS5kKCkpKTsKKyAgICAgICAgICAgICAg ICBmb250LmRyYXdUZXh0KCZnYywgcnVuLCBJbnRQb2ludCgwLCBmb250LmFzY2VudCgpKSwgZnJv bSwgdG8pOworICAgICAgICAgICAgfQorICAgICAgICAgICAgdW5zaWduZWQga2V5MSwga2V5MjsK KyAgICAgICAgICAgIEhEQyBtZW1EYyA9IGJtcC0+Z2V0REMoJmtleTEsICZrZXkyKTsKKyAgICAg ICAgICAgIGlmIChtZW1EYykgeworICAgICAgICAgICAgICAgIG1fZGF0YS0+cGFpbnRCYWNrVHJh bnNwYXJlbnRMYXllckJpdG1hcChtZW1EYywgdHJSZWN0LCB0cnVlLCBibXBSZWN0KTsKKyAgICAg ICAgICAgICAgICBibXAtPnJlbGVhc2VEQyhtZW1EYywga2V5MSwga2V5Mik7CisgICAgICAgICAg ICB9CisgICAgICAgIH0KKworICAgICAgICBtX2RhdGEtPm1fb3BhY2l0eSA9IG9sZE9wYWNpdHk7 CisgICAgfQorfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd1RleHQoY29uc3QgU2ltcGxl Rm9udERhdGEqIGZvbnREYXRhLCBjb25zdCBHbHlwaEJ1ZmZlciYgZ2x5cGhCdWZmZXIsCisgICAg ICAgICAgICAgICAgICAgICAgaW50IGZyb20sIGludCBudW1HbHlwaHMsIGNvbnN0IEZsb2F0UG9p bnQmIHBvaW50KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJldHVy bjsKKworICAgIGZvciAoOzspIHsKKyAgICAgICAgaWYgKCFudW1HbHlwaHMpCisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIGlmIChpc0NoYXJWaXNpYmxlKCpnbHlwaEJ1ZmZlci5nbHlwaHMo ZnJvbSkpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICsrZnJvbTsKKyAgICAgICAgLS1u dW1HbHlwaHM7CisgICAgfQorCisgICAgZG91YmxlIHNjYWxlWCA9IG1fZGF0YS0+bV90cmFuc2Zv cm0uYSgpOworICAgIGRvdWJsZSBzY2FsZVkgPSBtX2RhdGEtPm1fdHJhbnNmb3JtLmQoKTsKKwor ICAgIGludCBoZWlnaHQgPSBmb250RGF0YS0+cGxhdGZvcm1EYXRhKCkuc2l6ZSgpICogc2NhbGVZ OworICAgIGludCB3aWR0aCA9IGZvbnREYXRhLT5wbGF0Zm9ybURhdGEoKS5hdmVyYWdlQ2hhcldp ZHRoKCkgKiBzY2FsZVg7CisKKyAgICBpZiAoIWhlaWdodCB8fCAhd2lkdGgpCisgICAgICAgIHJl dHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYg KCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIFRyYW5zcGFyZW50TGF5 ZXJEQyAuLi4KKworICAgIEhGT05UIGhGb250ID0gaGVpZ2h0ID4gMQorICAgICAgICA/IGZvbnRE YXRhLT5wbGF0Zm9ybURhdGEoKS5nZXRTY2FsZWRGb250SGFuZGxlKGhlaWdodCwgc2NhbGVYID09 IHNjYWxlWSA/IDAgOiB3aWR0aCkKKyAgICAgICAgOiAwOworCisgICAgRmxvYXRQb2ludCBzdGFy dFBvaW50KHBvaW50LngoKSwgcG9pbnQueSgpIC0gZm9udERhdGEtPmFzY2VudCgpKTsKKyAgICBG bG9hdFBvaW50IHRyUG9pbnQgPSBtX2RhdGEtPm1hcFBvaW50KHN0YXJ0UG9pbnQpOworICAgIGlu dCB5ID0gUm91bmQodHJQb2ludC55KCkpOworCisgICAgQ29sb3IgY29sb3IgPSBmaWxsQ29sb3Io KTsKKyAgICBpZiAoY29sb3IuYWxwaGEoKSA9PSAwKSAvLyBoYWNrCisgICAgICAgIHJldHVybjsK KworICAgIENPTE9SUkVGIGZvbnRDb2xvciA9IFJHQihjb2xvci5yZWQoKSwgY29sb3IuZ3JlZW4o KSwgY29sb3IuYmx1ZSgpKTsKKworICAgIGlmIChoRm9udCkgeworICAgICAgICBJbnRTaXplIHNo YWRvd1NpemU7CisgICAgICAgIGludCBzaGFkb3dCbHVyID0gMDsKKyAgICAgICAgQ29sb3Igc2hh ZG93Q29sb3I7CisgICAgICAgIGJvb2wgaGFzU2hhZG93ID0gdGV4dERyYXdpbmdNb2RlKCkgPT0g Y1RleHRGaWxsCisgICAgICAgICAgICAmJiBnZXRTaGFkb3coc2hhZG93U2l6ZSwgc2hhZG93Qmx1 ciwgc2hhZG93Q29sb3IpCisgICAgICAgICAgICAmJiBzaGFkb3dDb2xvci5hbHBoYSgpOworICAg ICAgICBDT0xPUlJFRiBzaGFkb3dSZ2JDb2xvcjsKKyAgICAgICAgRmxvYXRQb2ludCB0clNoYWRv d1BvaW50OworICAgICAgICBpZiAoaGFzU2hhZG93KSB7CisgICAgICAgICAgICBzaGFkb3dSZ2JD b2xvciA9IFJHQihzaGFkb3dDb2xvci5yZWQoKSwgc2hhZG93Q29sb3IuZ3JlZW4oKSwgc2hhZG93 Q29sb3IuYmx1ZSgpKTsKKyAgICAgICAgICAgIHRyU2hhZG93UG9pbnQgPSBtX2RhdGEtPm1hcFBv aW50KHN0YXJ0UG9pbnQgKyBzaGFkb3dTaXplKTsKKyAgICAgICAgfQorCisgICAgICAgIEhHRElP QkogaE9sZEZvbnQgPSBTZWxlY3RPYmplY3QobV9kYXRhLT5tX2RjLCBoRm9udCk7CisgICAgICAg IC8vIHRyYW5zcGFyZW50IGFsd2F5cy4uLgorICAgICAgICBpbnQgb2xkQmtNb2RlID0gR2V0QmtN b2RlKG1fZGF0YS0+bV9kYyk7CisgICAgICAgIENPTE9SUkVGIG9sZFRleHRDb2xvciA9IEdldFRl eHRDb2xvcihtX2RhdGEtPm1fZGMpOworICAgICAgICBpbnQgb2xkVGV4dEFsaWduID0gR2V0VGV4 dEFsaWduKG1fZGF0YS0+bV9kYyk7CisgICAgICAgIFNldFRleHRBbGlnbihtX2RhdGEtPm1fZGMs IDApOworICAgICAgICBTZXRCa01vZGUobV9kYXRhLT5tX2RjLCBUUkFOU1BBUkVOVCk7CisKKyAg ICAgICAgaWYgKG51bUdseXBocyA+IDEpIHsKKyAgICAgICAgICAgIGRvdWJsZSBvZmZzZXQgPSB0 clBvaW50LngoKTsKKyAgICAgICAgICAgIFZlY3RvcjxpbnQsIDI1Nj4gZ2x5cGhTcGFjZShudW1H bHlwaHMpOworICAgICAgICAgICAgVmVjdG9yPFVDaGFyLCAyNTY+IHRleHQobnVtR2x5cGhzKTsK KyAgICAgICAgICAgIGludCogY3VyU3BhY2UgPSBnbHlwaFNwYWNlLmRhdGEoKTsKKyAgICAgICAg ICAgIFVDaGFyKiBjdXJDaGFyID0gdGV4dC5kYXRhKCk7CisgICAgICAgICAgICBjb25zdCBVQ2hh ciogc3JjQ2hhciA9IGdseXBoQnVmZmVyLmdseXBocyhmcm9tKTsKKyAgICAgICAgICAgIGNvbnN0 IFVDaGFyKiBjb25zdCBzcmNDaGFyRW5kID0gc3JjQ2hhciArIG51bUdseXBoczsKKyAgICAgICAg ICAgICpjdXJDaGFyKysgPSAqc3JjQ2hhcisrOworICAgICAgICAgICAgaW50IGZpcnN0T2Zmc2V0 ID0gUm91bmQob2Zmc2V0KTsKKyAgICAgICAgICAgIGludCBsYXN0T2Zmc2V0ID0gZmlyc3RPZmZz ZXQ7CisgICAgICAgICAgICBjb25zdCBHbHlwaEJ1ZmZlckFkdmFuY2UqIGFkdmFuY2UgPSBnbHlw aEJ1ZmZlci5hZHZhbmNlRGF0YSgpICsgZnJvbTsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBFeHRU ZXh0T3V0KCkgY2FuIGZsaXAgb3ZlciBlYWNoIHdvcmQgZm9yIFJUTCBsYW5hdWdlcywgZXZlbiB3 aGVuIFRBX1JUTFJFQURJTkcgaXMgb2ZmLgorICAgICAgICAgICAgLy8gKHRoaXMgY2FuIGJlIEdE SSBidWcgb3IgZm9udCBkcml2ZXIgYnVnPykKKyAgICAgICAgICAgIC8vIFdlIGFyZSBub3QgY2xl YXIgaG93IGl0IHByb2Nlc3NlcyBjaGFyYWN0ZXJzIGFuZCBoYW5kbGVzIHNwZWNpZmllZCBzcGFj ZXMuIE9uIHRoZSBvdGhlciBzaWRlLAorICAgICAgICAgICAgLy8gb3VyIGdseXBoIGJ1ZmZlciBp cyBhbHJlYWR5IGluIHRoZSBjb3JyZWN0IG9yZGVyIGZvciByZW5kZXJpbmcuIFNvLCB0aGUgc29s dXRpb24gaXMgdGhhdCB3ZQorICAgICAgICAgICAgLy8gY2FsbCBFeHRUZXh0T3V0KCkgZm9yIGVh Y2ggc2luZ2xlIGNoYXJhY3RlciB3aGVuIHRoZSB0ZXh0IGNvbnRhaW5zIGFueSBSVEwgY2hhcmFj dGVyLgorICAgICAgICAgICAgLy8gVGhpcyBzb2x1dGlvbiBpcyBub3QgcGVyZmVjdCBhcyBpdCBp cyBzbG93ZXIgdGhhbiBjYWxsaW5nIEV4dFRleHRPdXQoKSBvbmUgdGltZSBmb3IgYWxsIGNoYXJh Y3RlcnMuCisgICAgICAgICAgICAvLyBEcmF3aW5nIGNoYXJhY3RlcnMgb25lIGJ5IG9uZSBtYXkg YmUgdG9vIHNsb3cuCisgICAgICAgICAgICBib29sIGRyYXdPbmVCeU9uZSA9IGZhbHNlOworICAg ICAgICAgICAgaWYgKHNjYWxlWCA9PSAxLikgeworICAgICAgICAgICAgICAgIGZvciAoOyBzcmND aGFyIDwgc3JjQ2hhckVuZDsgKytzcmNDaGFyKSB7CisgICAgICAgICAgICAgICAgICAgIG9mZnNl dCArPSAqYWR2YW5jZSsrOworICAgICAgICAgICAgICAgICAgICBpbnQgb2Zmc2V0SW50ID0gUm91 bmQob2Zmc2V0KTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGlzQ2hhclZpc2libGUoKnNyY0No YXIpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWRyYXdPbmVCeU9uZSAmJiBXVEY6 OlVuaWNvZGU6OmRpcmVjdGlvbigqc3JjQ2hhcikgPT0gV1RGOjpVbmljb2RlOjpSaWdodFRvTGVm dCkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBkcmF3T25lQnlPbmUgPSB0cnVlOworICAg ICAgICAgICAgICAgICAgICAgICAgKmN1ckNoYXIrKyA9ICpzcmNDaGFyOworICAgICAgICAgICAg ICAgICAgICAgICAgKmN1clNwYWNlKysgPSBvZmZzZXRJbnQgLSBsYXN0T2Zmc2V0OworICAgICAg ICAgICAgICAgICAgICAgICAgbGFzdE9mZnNldCA9IG9mZnNldEludDsKKyAgICAgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICAgICAgZm9yICg7IHNyY0NoYXIgPCBzcmNDaGFyRW5kOyArK3NyY0NoYXIpIHsKKyAgICAg ICAgICAgICAgICAgICAgb2Zmc2V0ICs9ICphZHZhbmNlKysgKiBzY2FsZVg7CisgICAgICAgICAg ICAgICAgICAgIGludCBvZmZzZXRJbnQgPSBSb3VuZChvZmZzZXQpOworICAgICAgICAgICAgICAg ICAgICBpZiAoaXNDaGFyVmlzaWJsZSgqc3JjQ2hhcikpIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgIGlmICghZHJhd09uZUJ5T25lICYmIFdURjo6VW5pY29kZTo6ZGlyZWN0aW9uKCpzcmNDaGFy KSA9PSBXVEY6OlVuaWNvZGU6OlJpZ2h0VG9MZWZ0KQorICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGRyYXdPbmVCeU9uZSA9IHRydWU7CisgICAgICAgICAgICAgICAgICAgICAgICAqY3VyQ2hh cisrID0gKnNyY0NoYXI7CisgICAgICAgICAgICAgICAgICAgICAgICAqY3VyU3BhY2UrKyA9IG9m ZnNldEludCAtIGxhc3RPZmZzZXQ7CisgICAgICAgICAgICAgICAgICAgICAgICBsYXN0T2Zmc2V0 ID0gb2Zmc2V0SW50OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgfQorICAgICAgICAgICAgbnVtR2x5cGhzID0gY3VyQ2hhciAtIHRleHQuZGF0 YSgpOworICAgICAgICAgICAgaWYgKGhhc1NoYWRvdykgeworICAgICAgICAgICAgICAgIFNldFRl eHRDb2xvcihtX2RhdGEtPm1fZGMsIHNoYWRvd1JnYkNvbG9yKTsKKyAgICAgICAgICAgICAgICBp ZiAoZHJhd09uZUJ5T25lKSB7CisgICAgICAgICAgICAgICAgICAgIGludCB4U2hhZG93ID0gZmly c3RPZmZzZXQgKyBSb3VuZCh0clNoYWRvd1BvaW50LngoKSAtIHRyUG9pbnQueCgpKTsKKyAgICAg ICAgICAgICAgICAgICAgaW50IHlTaGFkb3cgPSBSb3VuZCh0clNoYWRvd1BvaW50LnkoKSk7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtR2x5cGhzOyArK2kpIHsK KyAgICAgICAgICAgICAgICAgICAgICAgIEV4dFRleHRPdXQKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAobV9kYXRhLT5tX2RjCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgLCB4U2hh ZG93CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgLCB5U2hhZG93CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgLCAwCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgLCBOVUxMCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgLCB0ZXh0LmRhdGEoKSArIGkKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAsIDEKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAsIDApOwor ICAgICAgICAgICAgICAgICAgICAgICAgeFNoYWRvdyArPSBnbHlwaFNwYWNlW2ldOworICAgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAg ICAgICAgRXh0VGV4dE91dAorICAgICAgICAgICAgICAgICAgICAgICAgKG1fZGF0YS0+bV9kYwor ICAgICAgICAgICAgICAgICAgICAgICAgLCBmaXJzdE9mZnNldCArIFJvdW5kKHRyU2hhZG93UG9p bnQueCgpIC0gdHJQb2ludC54KCkpCisgICAgICAgICAgICAgICAgICAgICAgICAsIFJvdW5kKHRy U2hhZG93UG9pbnQueSgpKQorICAgICAgICAgICAgICAgICAgICAgICAgLCAwCisgICAgICAgICAg ICAgICAgICAgICAgICAsIE5VTEwKKyAgICAgICAgICAgICAgICAgICAgICAgICwgdGV4dC5kYXRh KCkKKyAgICAgICAgICAgICAgICAgICAgICAgICwgbnVtR2x5cGhzCisgICAgICAgICAgICAgICAg ICAgICAgICAsIGdseXBoU3BhY2UuZGF0YSgpKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICB9CisgICAgICAgICAgICBTZXRUZXh0Q29sb3IobV9kYXRhLT5tX2RjLCBmb250Q29sb3Ip OworICAgICAgICAgICAgaWYgKGRyYXdPbmVCeU9uZSkgeworICAgICAgICAgICAgICAgIGludCB4 ID0gZmlyc3RPZmZzZXQ7CisgICAgICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1H bHlwaHM7ICsraSkgeworICAgICAgICAgICAgICAgICAgICBFeHRUZXh0T3V0CisgICAgICAgICAg ICAgICAgICAgICAgICAobV9kYXRhLT5tX2RjCisgICAgICAgICAgICAgICAgICAgICAgICAsIHgK KyAgICAgICAgICAgICAgICAgICAgICAgICwgeQorICAgICAgICAgICAgICAgICAgICAgICAgLCAw CisgICAgICAgICAgICAgICAgICAgICAgICAsIE5VTEwKKyAgICAgICAgICAgICAgICAgICAgICAg ICwgdGV4dC5kYXRhKCkgKyBpCisgICAgICAgICAgICAgICAgICAgICAgICAsIDEKKyAgICAgICAg ICAgICAgICAgICAgICAgICwgMCk7CisgICAgICAgICAgICAgICAgICAgIHggKz0gZ2x5cGhTcGFj ZVtpXTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgICAgIEV4dFRleHRPdXQKKyAgICAgICAgICAgICAgICAgICAgKG1fZGF0YS0+bV9kYworICAg ICAgICAgICAgICAgICAgICAsIGZpcnN0T2Zmc2V0CisgICAgICAgICAgICAgICAgICAgICwgeQor ICAgICAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAgICAgLCBOVUxMCisgICAg ICAgICAgICAgICAgICAgICwgdGV4dC5kYXRhKCkKKyAgICAgICAgICAgICAgICAgICAgLCBudW1H bHlwaHMKKyAgICAgICAgICAgICAgICAgICAgLCBnbHlwaFNwYWNlLmRhdGEoKSk7CisgICAgICAg ICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBVQ2hhciBjID0gKmdseXBoQnVm ZmVyLmdseXBocyhmcm9tKTsKKyAgICAgICAgICAgIGlmIChoYXNTaGFkb3cpIHsKKyAgICAgICAg ICAgICAgICBTZXRUZXh0Q29sb3IobV9kYXRhLT5tX2RjLCBzaGFkb3dSZ2JDb2xvcik7CisgICAg ICAgICAgICAgICAgRXh0VGV4dE91dAorICAgICAgICAgICAgICAgICAgICAobV9kYXRhLT5tX2Rj CisgICAgICAgICAgICAgICAgICAgICwgUm91bmQodHJTaGFkb3dQb2ludC54KCkpCisgICAgICAg ICAgICAgICAgICAgICwgUm91bmQodHJTaGFkb3dQb2ludC55KCkpCisgICAgICAgICAgICAgICAg ICAgICwgMAorICAgICAgICAgICAgICAgICAgICAsIE5VTEwKKyAgICAgICAgICAgICAgICAgICAg LCAmYworICAgICAgICAgICAgICAgICAgICAsIDEKKyAgICAgICAgICAgICAgICAgICAgLCAwCisg ICAgICAgICAgICAgICAgICAgICk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBTZXRUZXh0 Q29sb3IobV9kYXRhLT5tX2RjLCBmb250Q29sb3IpOworICAgICAgICAgICAgRXh0VGV4dE91dAor ICAgICAgICAgICAgICAgIChtX2RhdGEtPm1fZGMKKyAgICAgICAgICAgICAgICAsIFJvdW5kKHRy UG9pbnQueCgpKQorICAgICAgICAgICAgICAgICwgeQorICAgICAgICAgICAgICAgICwgMAorICAg ICAgICAgICAgICAgICwgTlVMTAorICAgICAgICAgICAgICAgICwgJmMKKyAgICAgICAgICAgICAg ICAsIDEKKyAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICApOworICAgICAgICB9 CisKKyAgICAgICAgU2V0VGV4dEFsaWduKG1fZGF0YS0+bV9kYywgb2xkVGV4dEFsaWduKTsKKyAg ICAgICAgU2V0VGV4dENvbG9yKG1fZGF0YS0+bV9kYywgb2xkVGV4dENvbG9yKTsKKyAgICAgICAg U2V0QmtNb2RlKG1fZGF0YS0+bV9kYywgb2xkQmtNb2RlKTsKKyAgICAgICAgU2VsZWN0T2JqZWN0 KG1fZGF0YS0+bV9kYywgaE9sZEZvbnQpOworICAgIH0gZWxzZSB7CisgICAgICAgIGRvdWJsZSBv ZmZzZXQgPSB0clBvaW50LngoKTsKKyAgICAgICAgY29uc3QgR2x5cGhCdWZmZXJBZHZhbmNlKiBh ZHZhbmNlID0gZ2x5cGhCdWZmZXIuYWR2YW5jZURhdGEoKSArIGZyb207CisgICAgICAgIGlmIChz Y2FsZVggPT0gMS4pCisgICAgICAgICAgICBmb3IgKGludCBpID0gMTsgaSA8IG51bUdseXBoczsg KytpKQorICAgICAgICAgICAgICAgIG9mZnNldCArPSAqYWR2YW5jZSsrOworICAgICAgICBlbHNl CisgICAgICAgICAgICBmb3IgKGludCBpID0gMTsgaSA8IG51bUdseXBoczsgKytpKQorICAgICAg ICAgICAgICAgIG9mZnNldCArPSAqYWR2YW5jZSsrICogc2NhbGVYOworCisgICAgICAgIG9mZnNl dCArPSB3aWR0aDsKKworICAgICAgICBPd25QdHI8SFBFTj4gaFBlbihDcmVhdGVQZW4oUFNfREFT SCwgMSwgZm9udENvbG9yKSk7CisgICAgICAgIEhHRElPQkogb2xkUGVuID0gU2VsZWN0T2JqZWN0 KG1fZGF0YS0+bV9kYywgaFBlbi5nZXQoKSk7CisKKyAgICAgICAgTW92ZVRvRXgobV9kYXRhLT5t X2RjLCBSb3VuZCh0clBvaW50LngoKSksIHksIDApOworICAgICAgICBMaW5lVG8obV9kYXRhLT5t X2RjLCBSb3VuZChvZmZzZXQpLCB5KTsKKworICAgICAgICBTZWxlY3RPYmplY3QobV9kYXRhLT5t X2RjLCBvbGRQZW4pOworICAgIH0KK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdGcmFt ZUNvbnRyb2woY29uc3QgSW50UmVjdCYgcmVjdCwgdW5zaWduZWQgdHlwZSwgdW5zaWduZWQgc3Rh dGUpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgY29uc3QgaW50IGJveFdpZHRoQmVzdCA9IDg7CisgICAgY29uc3QgaW50IGJveEhlaWdodEJl c3QgPSA4OworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBp ZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCB0clJlY3Qg PSBtX2RhdGEtPm1hcFJlY3QocmVjdCk7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFy ZW50RGMobV9kYXRhLCB0clJlY3QsICZyZWN0KTsKKyAgICBIREMgZGMgPSB0cmFuc3BhcmVudERj LmhkYygpOworICAgIGlmICghZGMpCisgICAgICAgIHJldHVybjsKKyAgICB0clJlY3QubW92ZSh0 cmFuc3BhcmVudERjLnRvU2hpZnQoKSk7CisKKyAgICBSRUNUIHJlY3RXaW4gPSB0clJlY3Q7CisK KyAgICBpZiAoKHJlY3RXaW4ucmlnaHQgLSByZWN0V2luLmxlZnQpIDwgYm94V2lkdGhCZXN0KSB7 CisgICAgICAgIFJlZlB0cjxTaGFyZWRCaXRtYXA+IGJtcDEgPSBTaGFyZWRCaXRtYXA6OmNyZWF0 ZUluc3RhbmNlKHRydWUsIGJveFdpZHRoQmVzdCwgYm94SGVpZ2h0QmVzdCwgdHJ1ZSk7CisgICAg ICAgIFNoYXJlZEJpdG1hcDo6RENIb2xkZXIgZGMxKGJtcDEuZ2V0KCkpOworICAgICAgICBpZiAo ZGMxLmdldCgpKSB7CisgICAgICAgICAgICBSRUNUIHRlbXBSZWN0ID0gezAsIDAsIGJveFdpZHRo QmVzdCwgYm94SGVpZ2h0QmVzdH07CisgICAgICAgICAgICBEcmF3RnJhbWVDb250cm9sKGRjMS5n ZXQoKSwgJnRlbXBSZWN0LCB0eXBlLCBzdGF0ZSk7CisKKyAgICAgICAgICAgIDo6U3RyZXRjaEJs dChkYywgcmVjdFdpbi5sZWZ0LCByZWN0V2luLnRvcCwgcmVjdFdpbi5yaWdodCAtIHJlY3RXaW4u bGVmdCwgcmVjdFdpbi5ib3R0b20gLSByZWN0V2luLnRvcCwKKyAgICAgICAgICAgICAgICBkYzEu Z2V0KCksIDAsIDAsIGJveFdpZHRoQmVzdCwgYm94SGVpZ2h0QmVzdCwgU1JDQ09QWSk7CisgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBEcmF3RnJhbWVDb250cm9s KGRjLCAmcmVjdFdpbiwgdHlwZSwgc3RhdGUpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6 ZHJhd0ZvY3VzUmVjdChjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlmICghbV9kYXRhLT5t X29wYWNpdHkpCisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3Zp ZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKwor ICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KHJlY3QpOworICAgIFRyYW5zcGFy ZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0YSwgdHJSZWN0LCAmcmVjdCk7CisgICAgSERD IGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47 CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworCisgICAgUkVDVCBy ZWN0V2luID0gdHJSZWN0OworICAgIERyYXdGb2N1c1JlY3QoZGMsICZyZWN0V2luKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OnBhaW50VGV4dEZpZWxkKGNvbnN0IEludFJlY3QmIHJlY3Qs IHVuc2lnbmVkIHN0YXRlKQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAg IHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAg aWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0 ID0gbV9kYXRhLT5tYXBSZWN0KHJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3Bh cmVudERjKG1fZGF0YSwgdHJSZWN0LCAmcmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnRE Yy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUo dHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworCisgICAgUkVDVCByZWN0V2luID0gdHJSZWN0Owor ICAgIERyYXdFZGdlKGRjLCAmcmVjdFdpbiwgRURHRV9FVENIRUQsIEJGX1JFQ1QgfCBCRl9BREpV U1QpOworICAgIEZpbGxSZWN0KGRjLCAmcmVjdFdpbiwgcmVpbnRlcnByZXRfY2FzdDxIQlJVU0g+ KCgoc3RhdGUgJiBERkNTX0lOQUNUSVZFKSA/IENPTE9SX0JUTkZBQ0UgOiBDT0xPUl9XSU5ET1cp ICsgMSkpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0JpdG1hcChTaGFyZWRCaXRt YXAqIGJtcCwgY29uc3QgSW50UmVjdCYgZHN0UmVjdEluLCBjb25zdCBJbnRSZWN0JiBzcmNSZWN0 LCBDb21wb3NpdGVPcGVyYXRvciBjb21wb3NpdGVPcCkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9v cGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRl cihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAg ICBJbnRSZWN0IGRzdFJlY3QgPSBtX2RhdGEtPm1hcFJlY3QoZHN0UmVjdEluKTsKKyAgICBUcmFu c3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIGRzdFJlY3QsICZkc3RSZWN0SW4p OworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAg ICAgcmV0dXJuOworICAgIGRzdFJlY3QubW92ZSh0cmFuc3BhcmVudERjLnRvU2hpZnQoKSk7CisK KyAgICBibXAtPmRyYXcoZGMsIGRzdFJlY3QsIHNyY1JlY3QsIGNvbXBvc2l0ZU9wKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdCaXRtYXBQYXR0ZXJuKFNoYXJlZEJpdG1hcCogYm1w LCBjb25zdCBGbG9hdFJlY3QmIHRpbGVSZWN0SW4sIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4 JiBwYXR0ZXJuVHJhbnNmb3JtLAorICAgICAgICAgICAgICAgIGNvbnN0IEZsb2F0UG9pbnQmIHBo YXNlLCBDb21wb3NpdGVPcGVyYXRvciBvcCwgY29uc3QgRmxvYXRSZWN0JiBkZXN0UmVjdEluLCBj b25zdCBJbnRTaXplJiBvcmlnU291cmNlU2l6ZSkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFj aXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlciht X2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyNpZiAw CisgICAgLy8gRklYTUU6IG5vdCBmaW5pc2hlZAorICAgIEludFJlY3QgZGVzdFJlY3QgPSBtX2Rh dGEtPm1hcFJlY3QoZGVzdFJlY3RJbik7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFy ZW50RGMobV9kYXRhLCBkZXN0UmVjdCwgJmRlc3RSZWN0SW4pOworICAgIEhEQyBkYyA9IHRyYW5z cGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIGRlc3RS ZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworICAgIGJtcC0+ZHJhd1BhdHRlcm4o ZGMsIG1fZGF0YS0+bV90cmFuc2Zvcm0sIHRpbGVSZWN0SW4sIHBhdHRlcm5UcmFuc2Zvcm0sIHBo YXNlLCBvcCwgZGVzdFJlY3QsIG9yaWdTb3VyY2VTaXplKTsKKyNlbHNlCisgICAgYm1wLT5kcmF3 UGF0dGVybihtX2RhdGEtPm1fZGMsIG1fZGF0YS0+bV90cmFuc2Zvcm0sIHRpbGVSZWN0SW4sIHBh dHRlcm5UcmFuc2Zvcm0sIHBoYXNlLCBvcCwgZGVzdFJlY3RJbiwgb3JpZ1NvdXJjZVNpemUpOwor I2VuZGlmCit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRQbGF0Zm9ybVNob3VsZEFudGlh bGlhcyhib29sIHNob3VsZCkKK3sKKyAgICAodm9pZClzaG91bGQ7CisgICAgbm90SW1wbGVtZW50 ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldExpbmVEYXNoKGNvbnN0IERhc2hB cnJheSYsIGZsb2F0IGRhc2hPZmZzZXQpCit7CisgICAgKHZvaWQpZGFzaE9mZnNldDsKKyAgICBu b3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xpcFBhdGgoV2lu ZFJ1bGUpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQo= 33091 2009-07-20 09:59:52 -0700 2009-07-20 12:10:40 -0700 coding style modifications and latest fixes 27349.patch text/plain 62395 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODk4M2MzNS4uYmQxNjFiMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wNy0yMCAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y NzM0OQorICAgICAgICBBZGQgR3JhcGhpY3NDb250ZXh0IGltcGxlbWVudGF0aW9uIGZvciB0aGUg V2luQ0UgcG9ydC4KKworICAgICAgICBXcml0dGVuIGJ5IFlvbmcgTGkgPHlvbmcubGlAdG9yY2ht b2JpbGUuY29tPiwgR2VvcmdlIFN0YWlrb3MgPGdlb3JnZS5zdGFpa29zQHRvcmNobW9iaWxlLmNv bT4gYW5kIEx5b24gQ2hlbiA8bHlvbi5jaGVuQHRvcmNobW9iaWxlLmNvbT4KKyAgICAgICAgd2l0 aCB0cml2aWFsIHN0eWxlIGZpeGVzIGJ5IEFkYW0gVHJlYXQgPGFkYW0udHJlYXRAdG9yY2htb2Jp bGUuY29tPgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250 ZXh0V2luY2UuY3BwOiBBZGRlZC4gIAkKKwkJCiAyMDA5LTA3LTIwICBYYW4gTG9wZXogIDx4bG9w ZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBHdXN0YXZvIE5vcm9uaGEuCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBoaWNzQ29udGV4 dFdpbmNlLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250 ZXh0V2luY2UuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjExMzU3NDYK LS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBo aWNzQ29udGV4dFdpbmNlLmNwcApAQCAtMCwwICsxLDE5MTUgQEAKKy8qCisgKiAgQ29weXJpZ2h0 IChDKSAyMDA3LTIwMDkgVG9yY2ggTW9iaWxlIEluYy4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisg KiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKworI2luY2x1ZGUgIkNo YXJhY3Rlck5hbWVzLmgiCisjaW5jbHVkZSAiR2x5cGhCdWZmZXIuaCIKKyNpbmNsdWRlICJHcmFk aWVudC5oIgorI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dFByaXZhdGUuaCIKKyNpbmNsdWRlICJO b3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIlBhdGguaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVBh dGhXaW5jZS5oIgorI2luY2x1ZGUgIlNoYXJlZEJpdG1hcC5oIgorI2luY2x1ZGUgIlNpbXBsZUZv bnREYXRhLmgiCisjaW5jbHVkZSAiVHJhbnNmb3JtYXRpb25NYXRyaXguaCIKKyNpbmNsdWRlICJ3 dGYvT3duUHRyLmgiCisKKyNpbmNsdWRlIDx3aW5kb3dzLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKwordHlwZWRlZiB2b2lkICgqRnVuY0dyYWRpZW50RmlsbFJlY3RMaW5lYXIpKEhEQyBoZGMs IGNvbnN0IEludFJlY3QmIHIsIGNvbnN0IEludFBvaW50JiBwMCwgY29uc3QgSW50UG9pbnQmIHAx LCBjb25zdCBWZWN0b3I8R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzKTsKK3R5cGVkZWYgdm9p ZCAoKkZ1bmNHcmFkaWVudEZpbGxSZWN0UmFkaWFsKShIREMgaGRjLCBjb25zdCBJbnRSZWN0JiBy LCBjb25zdCBJbnRQb2ludCYgcDAsIGNvbnN0IEludFBvaW50JiBwMSwgZmxvYXQgcjAsIGZsb2F0 IHIxLCBjb25zdCBWZWN0b3I8R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzKTsKK0Z1bmNHcmFk aWVudEZpbGxSZWN0TGluZWFyIGdfbGluZWFyR3JhZGllbnRGaWxsZXIgPSAwOworRnVuY0dyYWRp ZW50RmlsbFJlY3RSYWRpYWwgZ19yYWRpYWxHcmFkaWVudEZpbGxlciA9IDA7CisKK3N0YXRpYyBp bmxpbmUgYm9vbCBpc1plcm8oZG91YmxlIGQpCit7CisgICAgcmV0dXJuIGQgPiAwID8gZCA8PSAx LkUtMTAgOiBkID49IC0xLkUtMTA7Cit9CisKKy8vIHN0YWJsZVJvdW5kIHJvdW5kcyAtMC41IHRv IDAsIHdoZXJlIGxyb3VuZCByb3VuZHMgLTAuNSB0byAtMS4KK3N0YXRpYyBpbmxpbmUgaW50IHN0 YWJsZVJvdW5kKGRvdWJsZSBkKQoreworICAgIGlmIChkID4gMCkKKyAgICAgICAgcmV0dXJuIHN0 YXRpY19jYXN0PGludD4oZCArIDAuNSk7CisKKyAgICBpbnQgaSA9IHN0YXRpY19jYXN0PGludD4o ZCk7CisgICAgcmV0dXJuIGkgLSBkID4gMC41ID8gaSAtIDEgOiBpOworfQorCisvLyBVbmxpa2Ug ZW5jbG9zaW5nSW50UmVjdCgpLCB0aGlzIGZ1bmN0aW9uIGRvZXMgc3RyaWN0IHJvdW5kaW5nLgor c3RhdGljIGlubGluZSBJbnRSZWN0IHJvdW5kUmVjdChjb25zdCBGbG9hdFJlY3QmIHIpCit7Cisg ICAgcmV0dXJuIEludFJlY3Qoc3RhYmxlUm91bmQoci54KCkpLCBzdGFibGVSb3VuZChyLnkoKSks IHN0YWJsZVJvdW5kKHIucmlnaHQoKSkgLSBzdGFibGVSb3VuZChyLngoKSksIHN0YWJsZVJvdW5k KHIuYm90dG9tKCkpIC0gc3RhYmxlUm91bmQoci55KCkpKTsKK30KKworLy8gUm90YXRpb24gdHJh bnNmb3JtYXRpb24KK3N0cnVjdCBSb3RhdGlvblRyYW5zZm9ybQoreworICAgIGRvdWJsZSBtX2Nv c0E7CisgICAgZG91YmxlIG1fc2luQTsKKyAgICBpbnQgbV9wcmVTaGlmdFg7CisgICAgaW50IG1f cHJlU2hpZnRZOworICAgIGludCBtX3Bvc3RTaGlmdFg7CisgICAgaW50IG1fcG9zdFNoaWZ0WTsK KyAgICBSb3RhdGlvblRyYW5zZm9ybSgpCisgICAgICAgIDogbV9jb3NBKDEuKQorICAgICAgICAs IG1fc2luQSgwLikKKyAgICAgICAgLCBtX3ByZVNoaWZ0WCgwKQorICAgICAgICAsIG1fcHJlU2hp ZnRZKDApCisgICAgICAgICwgbV9wb3N0U2hpZnRYKDApCisgICAgICAgICwgbV9wb3N0U2hpZnRZ KDApCisgICAgeworICAgIH0KKyAgICBSb3RhdGlvblRyYW5zZm9ybSBvcGVyYXRvci0oKSBjb25z dAorICAgIHsKKyAgICAgICAgUm90YXRpb25UcmFuc2Zvcm0gcnRuOworICAgICAgICBydG4ubV9j b3NBID0gbV9jb3NBOworICAgICAgICBydG4ubV9zaW5BID0gLW1fc2luQTsKKyAgICAgICAgcnRu Lm1fcHJlU2hpZnRYID0gbV9wb3N0U2hpZnRYOworICAgICAgICBydG4ubV9wcmVTaGlmdFkgPSBt X3Bvc3RTaGlmdFk7CisgICAgICAgIHJ0bi5tX3Bvc3RTaGlmdFggPSBtX3ByZVNoaWZ0WDsKKyAg ICAgICAgcnRuLm1fcG9zdFNoaWZ0WSA9IG1fcHJlU2hpZnRZOworICAgICAgICByZXR1cm4gcnRu OworICAgIH0KKyAgICB2b2lkIG1hcChkb3VibGUgeDEsIGRvdWJsZSB5MSwgZG91YmxlKiB4Miwg ZG91YmxlKiB5MikgY29uc3QKKyAgICB7CisgICAgICAgIHgxICs9IG1fcHJlU2hpZnRYOworICAg ICAgICB5MSArPSBtX3ByZVNoaWZ0WTsKKyAgICAgICAgKngyID0geDEgKiBtX2Nvc0EgKyB5MSAq IG1fc2luQSArIG1fcG9zdFNoaWZ0WDsKKyAgICAgICAgKnkyID0geTEgKiBtX2Nvc0EgLSB4MSAq IG1fc2luQSArIG1fcG9zdFNoaWZ0WTsKKyAgICB9CisgICAgdm9pZCBtYXAoaW50IHgxLCBpbnQg eTEsIGludCogeDIsIGludCogeTIpIGNvbnN0CisgICAgeworICAgICAgICB4MSArPSBtX3ByZVNo aWZ0WDsKKyAgICAgICAgeTEgKz0gbV9wcmVTaGlmdFk7CisgICAgICAgICp4MiA9IHN0YWJsZVJv dW5kKHgxICogbV9jb3NBICsgeTEgKiBtX3NpbkEpICsgbV9wb3N0U2hpZnRYOworICAgICAgICAq eTIgPSBzdGFibGVSb3VuZCh5MSAqIG1fY29zQSAtIHgxICogbV9zaW5BKSArIG1fcG9zdFNoaWZ0 WTsKKyAgICB9Cit9OworCit0ZW1wbGF0ZTxjbGFzcyBUPiBzdGF0aWMgaW5saW5lIEludFBvaW50 IG1hcFBvaW50KGNvbnN0IEludFBvaW50JiBwLCBjb25zdCBUJiB0KQoreworICAgIGludCB4LCB5 OworICAgIHQubWFwKHAueCgpLCBwLnkoKSwgJngsICZ5KTsKKyAgICByZXR1cm4gSW50UG9pbnQo eCwgeSk7Cit9CisKK3RlbXBsYXRlPGNsYXNzIFQ+IHN0YXRpYyBpbmxpbmUgRmxvYXRQb2ludCBt YXBQb2ludChjb25zdCBGbG9hdFBvaW50JiBwLCBjb25zdCBUJiB0KQoreworICAgIGRvdWJsZSB4 LCB5OworICAgIHQubWFwKHAueCgpLCBwLnkoKSwgJngsICZ5KTsKKyAgICByZXR1cm4gRmxvYXRQ b2ludChzdGF0aWNfY2FzdDxmbG9hdD4oeCksIHN0YXRpY19jYXN0PGZsb2F0Pih5KSk7Cit9CisK K3RlbXBsYXRlPGNsYXNzIFRyYW5zZm9ybSwgY2xhc3MgUmVjdCwgY2xhc3MgVmFsdWU+IHN0YXRp YyBpbmxpbmUgUmVjdCBtYXBSZWN0KGNvbnN0IFJlY3QmIHJlY3QsIGNvbnN0IFRyYW5zZm9ybSYg dHJhbnNmb3JtKQoreworICAgIFZhbHVlIHhbNF0sIHlbNF07CisgICAgVmFsdWUgbCwgdCwgciwg YjsKKyAgICByID0gcmVjdC5yaWdodCgpIC0gMTsKKyAgICBiID0gcmVjdC5ib3R0b20oKSAtIDE7 CisgICAgdHJhbnNmb3JtLm1hcChyZWN0LngoKSwgcmVjdC55KCksIHgsIHkpOworICAgIHRyYW5z Zm9ybS5tYXAocmVjdC54KCksIGIsIHggKyAxLCB5ICsgMSk7CisgICAgdHJhbnNmb3JtLm1hcChy LCBiLCB4ICsgMiwgeSArIDIpOworICAgIHRyYW5zZm9ybS5tYXAociwgcmVjdC55KCksIHggKyAz LCB5ICsgMyk7CisgICAgbCA9IHIgPSB4WzNdOworICAgIHQgPSBiID0geVszXTsKKyAgICBmb3Ig KGludCBpID0gMDsgaSA8IDM7ICsraSkgeworICAgICAgICBpZiAoeFtpXSA8IGwpCisgICAgICAg ICAgICBsID0geFtpXTsKKyAgICAgICAgZWxzZSBpZiAoeFtpXSA+IHIpCisgICAgICAgICAgICBy ID0geFtpXTsKKworICAgICAgICBpZiAoeVtpXSA8IHQpCisgICAgICAgICAgICB0ID0geVtpXTsK KyAgICAgICAgZWxzZSBpZiAoeVtpXSA+IGIpCisgICAgICAgICAgICBiID0geVtpXTsKKyAgICB9 CisKKyAgICByZXR1cm4gSW50UmVjdChsLCB0LCByIC0gbCArIDEsIGIgLSB0ICsgMSk7Cit9CisK K3RlbXBsYXRlPGNsYXNzIFQ+IHN0YXRpYyBpbmxpbmUKK0ludFJlY3QgbWFwUmVjdChjb25zdCBJ bnRSZWN0JiByZWN0LCBjb25zdCBUJiB0cmFuc2Zvcm0pCit7CisgICAgcmV0dXJuIG1hcFJlY3Q8 VCwgSW50UmVjdCwgaW50PihyZWN0LCB0cmFuc2Zvcm0pOworfQorCit0ZW1wbGF0ZTxjbGFzcyBU PiBzdGF0aWMgaW5saW5lCitGbG9hdFJlY3QgbWFwUmVjdChjb25zdCBGbG9hdFJlY3QmIHJlY3Qs IGNvbnN0IFQmIHRyYW5zZm9ybSkKK3sKKyAgICByZXR1cm4gbWFwUmVjdDxULCBGbG9hdFJlY3Qs IGRvdWJsZT4ocmVjdCwgdHJhbnNmb3JtKTsKK30KKworc3RydWN0IEdyYXBoaWNzQ29udGV4dFBs YXRmb3JtUHJpdmF0ZURhdGEKK3sKKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBtX3RyYW5zZm9y bTsKKyAgICBmbG9hdCBtX29wYWNpdHk7CisgICAgVmVjdG9yPFBhdGg+IG1fcGF0aHM7CisgICAg R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlRGF0YSgpCisgICAgICAgIDogbV90cmFuc2Zv cm0oKQorICAgICAgICAsIG1fb3BhY2l0eSgxLjApCisgICAgeworICAgIH0KK307CisKK2VudW0g QWxwaGFQYWludFR5cGUKK3sKKyAgICBBbHBoYVBhaW50Tm9uZSwKKyAgICBBbHBoYVBhaW50SW1h Z2UsCisgICAgQWxwaGFQYWludE90aGVyLAorfTsKKworY2xhc3MgR3JhcGhpY3NDb250ZXh0UGxh dGZvcm1Qcml2YXRlIDogcHVibGljIEdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZURhdGEg eworcHVibGljOgorICAgIEdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZShIREMgZGMpCisg ICAgICAgIDogbV9kYyhkYykKKyAgICB7CisgICAgfQorICAgIH5HcmFwaGljc0NvbnRleHRQbGF0 Zm9ybVByaXZhdGUoKQorICAgIHsKKyAgICAgICAgd2hpbGUgKCFtX2JhY2t1cERhdGEuaXNFbXB0 eSgpKQorICAgICAgICAgICAgcmVzdG9yZSgpOworICAgIH0KKworICAgIEludFBvaW50IG9yaWdp bigpCisgICAgeworICAgICAgICByZXR1cm4gSW50UG9pbnQoc3RhYmxlUm91bmQoLW1fdHJhbnNm b3JtLmUoKSksIHN0YWJsZVJvdW5kKC1tX3RyYW5zZm9ybS5mKCkpKTsKKyAgICB9CisKKyAgICB2 b2lkIHRyYW5zbGF0ZShmbG9hdCB4LCBmbG9hdCB5KQorICAgIHsKKyAgICAgICAgbV90cmFuc2Zv cm0udHJhbnNsYXRlKHgsIHkpOworICAgIH0KKworICAgIHZvaWQgc2NhbGUoY29uc3QgRmxvYXRT aXplJiBzaXplKQorICAgIHsKKyAgICAgICAgbV90cmFuc2Zvcm0uc2NhbGVOb25Vbmlmb3JtKHNp emUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSk7CisgICAgfQorCisgICAgdm9pZCByb3RhdGUoZmxv YXQgcmFkaWFucykKKyAgICB7CisgICAgICAgIG1fdHJhbnNmb3JtLnJvdGF0ZShyYWQyZGVnKHJh ZGlhbnMpKTsKKyAgICB9CisKKyAgICB2b2lkICBjb25jYXRDVE0oY29uc3QgVHJhbnNmb3JtYXRp b25NYXRyaXgmIHRyYW5zZm9ybSkKKyAgICB7CisgICAgICAgIG1fdHJhbnNmb3JtID0gdHJhbnNm b3JtICogbV90cmFuc2Zvcm07CisgICAgfQorCisgICAgSW50UmVjdCBtYXBSZWN0KGNvbnN0IElu dFJlY3QmIHJlY3QpCisgICAgeworICAgICAgICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUmVjdChy ZWN0KTsKKyAgICB9CisKKyAgICBGbG9hdFJlY3QgbWFwUmVjdChjb25zdCBGbG9hdFJlY3QmIHJl Y3QpCisgICAgeworICAgICAgICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUmVjdChyZWN0KTsKKyAg ICB9CisKKyAgICBJbnRQb2ludCBtYXBQb2ludChjb25zdCBJbnRQb2ludCYgcG9pbnQpCisgICAg eworICAgICAgICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUG9pbnQocG9pbnQpOworICAgIH0KKwor ICAgIEZsb2F0UG9pbnQgbWFwUG9pbnQoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCisgICAgewor ICAgICAgICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUG9pbnQocG9pbnQpOworICAgIH0KKworICAg IEZsb2F0U2l6ZSBtYXBTaXplKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkKKyAgICB7CisgICAgICAg IGRvdWJsZSB3LCBoOworICAgICAgICBtX3RyYW5zZm9ybS5tYXAoc2l6ZS53aWR0aCgpLCBzaXpl LmhlaWdodCgpLCB3LCBoKTsKKyAgICAgICAgcmV0dXJuIEZsb2F0U2l6ZShzdGF0aWNfY2FzdDxm bG9hdD4odyksIHN0YXRpY19jYXN0PGZsb2F0PihoKSk7CisgICAgfQorCisgICAgdm9pZCBzYXZl KCkKKyAgICB7CisgICAgICAgIGlmIChtX2RjKQorICAgICAgICAgICAgU2F2ZURDKG1fZGMpOwor CisgICAgICAgIG1fYmFja3VwRGF0YS5hcHBlbmQoKnN0YXRpY19jYXN0PEdyYXBoaWNzQ29udGV4 dFBsYXRmb3JtUHJpdmF0ZURhdGEqPih0aGlzKSk7CisgICAgfQorCisgICAgdm9pZCByZXN0b3Jl KCkKKyAgICB7CisgICAgICAgIGlmIChtX2JhY2t1cERhdGEuaXNFbXB0eSgpKQorICAgICAgICAg ICAgcmV0dXJuOworCisgICAgICAgIGlmIChtX2RjKQorICAgICAgICAgICAgUmVzdG9yZURDKG1f ZGMsIC0xKTsKKworICAgICAgICBHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGVEYXRhOjpv cGVyYXRvcj0obV9iYWNrdXBEYXRhLmxhc3QoKSk7CisgICAgICAgIG1fYmFja3VwRGF0YS5yZW1v dmVMYXN0KCk7CisgICAgfQorCisgICAgYm9vbCBoYXNBbHBoYSgpIGNvbnN0IHsgcmV0dXJuIG1f Yml0bWFwICYmIG1fYml0bWFwLT5oYXNBbHBoYSgpOyB9CisKKyAgICBQYXNzUmVmUHRyPFNoYXJl ZEJpdG1hcD4gZ2V0VHJhbnNwYXJlbnRMYXllckJpdG1hcChJbnRSZWN0JiBvcmlnUmVjdCwgQWxw aGFQYWludFR5cGUgYWxwaGFQYWludCwgUkVDVCYgYm1wUmVjdCwgYm9vbCBjaGVja0NsaXBCb3gs IGJvb2wgZm9yY2UpCisgICAgeworICAgICAgICBpZiAobV9vcGFjaXR5IDw9IDApCisgICAgICAg ICAgICByZXR1cm4gMDsKKworICAgICAgICBpZiAoZm9yY2UgfHwgbV9vcGFjaXR5IDwgMS4pICB7 CisgICAgICAgICAgICBpZiAoY2hlY2tDbGlwQm94KSB7CisgICAgICAgICAgICAgICAgUkVDVCBj bGlwQm94OworICAgICAgICAgICAgICAgIGludCBjbGlwVHlwZSA9IEdldENsaXBCb3gobV9kYywg JmNsaXBCb3gpOworICAgICAgICAgICAgICAgIGlmIChjbGlwVHlwZSA9PSBTSU1QTEVSRUdJT04g fHwgY2xpcFR5cGUgPT0gQ09NUExFWFJFR0lPTikKKyAgICAgICAgICAgICAgICAgICAgb3JpZ1Jl Y3QuaW50ZXJzZWN0KGNsaXBCb3gpOworICAgICAgICAgICAgICAgIGlmIChvcmlnUmVjdC5pc0Vt cHR5KCkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgfQorCisg ICAgICAgICAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBibXAgPSBTaGFyZWRCaXRtYXA6OmNyZWF0 ZUluc3RhbmNlKGFscGhhUGFpbnQgPT0gQWxwaGFQYWludE5vbmUsIG9yaWdSZWN0LndpZHRoKCks IG9yaWdSZWN0LmhlaWdodCgpLCBmYWxzZSk7CisgICAgICAgICAgICBTZXRSZWN0KCZibXBSZWN0 LCAwLCAwLCBvcmlnUmVjdC53aWR0aCgpLCBvcmlnUmVjdC5oZWlnaHQoKSk7CisgICAgICAgICAg ICBpZiAoYm1wKSB7CisgICAgICAgICAgICAgICAgc3dpdGNoIChhbHBoYVBhaW50KSB7CisgICAg ICAgICAgICAgICAgY2FzZSBBbHBoYVBhaW50Tm9uZToKKyAgICAgICAgICAgICAgICBjYXNlIEFs cGhhUGFpbnRJbWFnZToKKyAgICAgICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAg ICAgICAgU2hhcmVkQml0bWFwOjpEQ0hvbGRlciBkYyhibXAuZ2V0KCkpOworICAgICAgICAgICAg ICAgICAgICAgICAgaWYgKGRjLmdldCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg Qml0Qmx0KGRjLmdldCgpLCAwLCAwLCBvcmlnUmVjdC53aWR0aCgpLCBvcmlnUmVjdC5oZWlnaHQo KSwgbV9kYywgb3JpZ1JlY3QueCgpLCBvcmlnUmVjdC55KCksIFNSQ0NPUFkpOworICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGlmIChibXAtPmlzMzJiaXQoKSAmJiAoIW1fYml0bWFwIHx8IG1f Yml0bWFwLT5pczE2Yml0KCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8v IFNldCBhbHBoYSBjaGFubmVsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2ln bmVkKiBwaXhlbHMgPSAodW5zaWduZWQqKWJtcC0+Ynl0ZXMoKTsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgY29uc3QgdW5zaWduZWQqIGNvbnN0IHBpeGVsc0VuZCA9IHBpeGVscyAr IGJtcC0+Yml0bWFwSW5mbygpLm51bVBpeGVscygpOworICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB3aGlsZSAocGl4ZWxzIDwgcGl4ZWxzRW5kKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAqcGl4ZWxzIHw9IDB4RkYwMDAwMDA7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICArK3BpeGVsczsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gYm1wOworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAg ICAgIC8vY2FzZSBBbHBoYVBhaW50T3RoZXI6CisgICAgICAgICAgICAgICAgZGVmYXVsdDoKKyAg ICAgICAgICAgICAgICAgICAgbWVtc2V0KGJtcC0+Ynl0ZXMoKSwgMHhGRiwgYm1wLT5iaXRtYXBJ bmZvKCkubnVtUGl4ZWxzKCkgKiA0KTsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJtcDsK KyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgfQorICAgICAgICB9CisKKyAgICAgICAgYm1wUmVjdCA9IG9yaWdSZWN0OworICAgICAgICBy ZXR1cm4gMDsKKyAgICB9CisKKyAgICB2b2lkIHBhaW50QmFja1RyYW5zcGFyZW50TGF5ZXJCaXRt YXAoSERDIGhkYywgU2hhcmVkQml0bWFwKiBibXAsIGNvbnN0IEludFJlY3QmIG9yaWdSZWN0LCBB bHBoYVBhaW50VHlwZSBhbHBoYVBhaW50LCBjb25zdCBSRUNUJiBibXBSZWN0KQorICAgIHsKKyAg ICAgICAgaWYgKGhkYyA9PSBtX2RjKQorICAgICAgICAgICAgcmV0dXJuOworCisjaWYgIWRlZmlu ZWQoTk9fQUxQSEFCTEVORCkKKyAgICAgICAgaWYgKGFscGhhUGFpbnQgPT0gQWxwaGFQYWludE90 aGVyKSB7CisgICAgICAgICAgICBBU1NFUlQoYm1wICYmIGJtcC0+Ynl0ZXMoKSAmJiBibXAtPmlz MzJiaXQoKSk7CisgICAgICAgICAgICB1bnNpZ25lZCogcGl4ZWxzID0gKHVuc2lnbmVkKilibXAt PmJ5dGVzKCk7CisgICAgICAgICAgICBjb25zdCB1bnNpZ25lZCogY29uc3QgcGl4ZWxzRW5kID0g cGl4ZWxzICsgYm1wLT5iaXRtYXBJbmZvKCkubnVtUGl4ZWxzKCk7CisgICAgICAgICAgICB3aGls ZSAocGl4ZWxzIDwgcGl4ZWxzRW5kKSB7CisgICAgICAgICAgICAgICAgKnBpeGVscyBePSAweEZG MDAwMDAwOworICAgICAgICAgICAgICAgICsrcGl4ZWxzOworICAgICAgICAgICAgfQorICAgICAg ICB9CisgICAgICAgIGlmIChtX29wYWNpdHkgPCAxLiB8fCBhbHBoYVBhaW50ID09IEFscGhhUGFp bnRPdGhlcikgeworICAgICAgICAgICAgY29uc3QgQkxFTkRGVU5DVElPTiBibGVuZCA9IHsgQUNf U1JDX09WRVIsIDAKKyAgICAgICAgICAgICAgICAsIG1fb3BhY2l0eSA+PSAxLiA/IDI1NSA6IChC WVRFKShtX29wYWNpdHkgKiAyNTUpCisgICAgICAgICAgICAgICAgLCBhbHBoYVBhaW50ID09IEFs cGhhUGFpbnROb25lID8gMCA6IEFDX1NSQ19BTFBIQSB9OworICAgICAgICAgICAgQWxwaGFCbGVu ZChtX2RjLCBvcmlnUmVjdC54KCksIG9yaWdSZWN0LnkoKSwgb3JpZ1JlY3Qud2lkdGgoKSwgb3Jp Z1JlY3QuaGVpZ2h0KCksIGhkYywgMCwgMCwgYm1wUmVjdC5yaWdodCwgYm1wUmVjdC5ib3R0b20s IGJsZW5kKTsKKyAgICAgICAgfSBlbHNlCisjZW5kaWYKKyAgICAgICAgICAgIFN0cmV0Y2hCbHQo bV9kYywgb3JpZ1JlY3QueCgpLCBvcmlnUmVjdC55KCksIG9yaWdSZWN0LndpZHRoKCksIG9yaWdS ZWN0LmhlaWdodCgpLCBoZGMsIDAsIDAsIGJtcFJlY3QucmlnaHQsIGJtcFJlY3QuYm90dG9tLCBT UkNDT1BZKTsKKyAgICB9CisKKyAgICBIREMgbV9kYzsKKyAgICBSZWZQdHI8U2hhcmVkQml0bWFw PiBtX2JpdG1hcDsKKyAgICBWZWN0b3I8R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlRGF0 YT4gbV9iYWNrdXBEYXRhOworfTsKKworc3RhdGljIEhQRU4gY3JlYXRlUGVuKGNvbnN0IENvbG9y JiBjb2wsIGRvdWJsZSBmV2lkdGgsIFN0cm9rZVN0eWxlIHN0eWxlKQoreworICAgIGludCB3aWR0 aCA9IHN0YWJsZVJvdW5kKGZXaWR0aCk7CisgICAgaWYgKHdpZHRoIDwgMSkKKyAgICAgICAgd2lk dGggPSAxOworCisgICAgaW50IHBlblN0eWxlID0gUFNfTlVMTDsKKyAgICBzd2l0Y2ggKHN0eWxl KSB7CisgICAgICAgIGNhc2UgU29saWRTdHJva2U6CisgICAgICAgICAgICBwZW5TdHlsZSA9IFBT X1NPTElEOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgRG90dGVkU3Ryb2tlOiAg Ly8gbm90IHN1cHBvcnRlZCBvbiBXaW5kb3dzIENFCisgICAgICAgIGNhc2UgRGFzaGVkU3Ryb2tl OgorICAgICAgICAgICAgcGVuU3R5bGUgPSBQU19EQVNIOworICAgICAgICAgICAgd2lkdGggPSAx OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBicmVh azsKKyAgICB9CisKKyAgICByZXR1cm4gQ3JlYXRlUGVuKHBlblN0eWxlLCB3aWR0aCwgUkdCKGNv bC5yZWQoKSwgY29sLmdyZWVuKCksIGNvbC5ibHVlKCkpKTsKK30KKworc3RhdGljIGlubGluZSBI R0RJT0JKIGNyZWF0ZUJydXNoKGNvbnN0IENvbG9yJiBjb2wpCit7CisgICAgcmV0dXJuIENyZWF0 ZVNvbGlkQnJ1c2goUkdCKGNvbC5yZWQoKSwgY29sLmdyZWVuKCksIGNvbC5ibHVlKCkpKTsKK30K KwordGVtcGxhdGUgPHR5cGVuYW1lIFBpeGVsVHlwZSwgYm9vbCBJczE2Yml0PiB2b2lkIF9yb3Rh dGVCaXRtYXAoU2hhcmVkQml0bWFwKiBkZXN0Qm1wLCBjb25zdCBTaGFyZWRCaXRtYXAqIHNvdXJj ZUJtcCwgY29uc3QgUm90YXRpb25UcmFuc2Zvcm0mIHRyYW5zZm9ybSkKK3sKKyAgICBpbnQgZGVz dFcgPSBkZXN0Qm1wLT53aWR0aCgpOworICAgIGludCBkZXN0SCA9IGRlc3RCbXAtPmhlaWdodCgp OworICAgIGludCBzb3VyY2VXID0gc291cmNlQm1wLT53aWR0aCgpOworICAgIGludCBzb3VyY2VI ID0gc291cmNlQm1wLT5oZWlnaHQoKTsKKyAgICBQaXhlbFR5cGUqIGRlc3QgPSAoUGl4ZWxUeXBl KilkZXN0Qm1wLT5ieXRlcygpOworICAgIGNvbnN0IFBpeGVsVHlwZSogc291cmNlID0gKGNvbnN0 IFBpeGVsVHlwZSopc291cmNlQm1wLT5ieXRlcygpOworICAgIGludCBwYWRkaW5nOworICAgIGlu dCBwYWRkZWRTb3VyY2VXOworICAgIGlmIChJczE2Yml0KSB7CisgICAgICAgIHBhZGRpbmcgPSBk ZXN0VyAmIDE7CisgICAgICAgIHBhZGRlZFNvdXJjZVcgPSBzb3VyY2VXICsgKHNvdXJjZVcgJiAx KTsKKyAgICB9IGVsc2UgeworICAgICAgICBwYWRkaW5nID0gMDsKKyAgICAgICAgcGFkZGVkU291 cmNlVyA9IHNvdXJjZVc7CisgICAgfQorICAgIGlmIChpc1plcm8odHJhbnNmb3JtLm1fc2luQSkp IHsKKyAgICAgICAgaW50IGNvc0EgPSB0cmFuc2Zvcm0ubV9jb3NBID4gMCA/IDEgOiAtMTsKKyAg ICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCBkZXN0SDsgKyt5KSB7CisgICAgICAgICAgICBmb3Ig KGludCB4ID0gMDsgeCA8IGRlc3RXOyArK3gpIHsKKyAgICAgICAgICAgICAgICBpbnQgeDEgPSB4 ICsgdHJhbnNmb3JtLm1fcHJlU2hpZnRYOworICAgICAgICAgICAgICAgIGludCB5MSA9IHkgKyB0 cmFuc2Zvcm0ubV9wcmVTaGlmdFk7CisgICAgICAgICAgICAgICAgaW50IHNyY1ggPSB4MSAqIGNv c0EgKyB0cmFuc2Zvcm0ubV9wb3N0U2hpZnRYOworICAgICAgICAgICAgICAgIGludCBzcmNZID0g eTEgKiBjb3NBIC0gdHJhbnNmb3JtLm1fcG9zdFNoaWZ0WTsKKyAgICAgICAgICAgICAgICBpZiAo c3JjWCA+PSAwICYmIHNyY1ggPD0gc291cmNlVyAmJiBzcmNZID49IDAgJiYgc3JjWSA8PSBzb3Vy Y2VIKQorICAgICAgICAgICAgICAgICAgICAqZGVzdCsrID0gc291cmNlW3NyY1kgKiBwYWRkZWRT b3VyY2VXICsgc3JjWF0gfCAweEZGMDAwMDAwOworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICAgICAgKmRlc3QrKyB8PSAweEZGOworICAgICAgICAgICAgfQorICAgICAgICAg ICAgZGVzdCArPSBwYWRkaW5nOworICAgICAgICB9CisgICAgfSBlbHNlIGlmIChpc1plcm8odHJh bnNmb3JtLm1fY29zQSkpIHsKKyAgICAgICAgaW50IHNpbkEgPSB0cmFuc2Zvcm0ubV9zaW5BID4g MCA/IDEgOiAtMTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCBkZXN0SDsgKyt5KSB7Cisg ICAgICAgICAgICBmb3IgKGludCB4ID0gMDsgeCA8IGRlc3RXOyArK3gpIHsKKyAgICAgICAgICAg ICAgICBpbnQgeDEgPSB4ICsgdHJhbnNmb3JtLm1fcHJlU2hpZnRYOworICAgICAgICAgICAgICAg IGludCB5MSA9IHkgKyB0cmFuc2Zvcm0ubV9wcmVTaGlmdFk7CisgICAgICAgICAgICAgICAgaW50 IHNyY1ggPSB5MSAqIHNpbkEgKyB0cmFuc2Zvcm0ubV9wb3N0U2hpZnRYOworICAgICAgICAgICAg ICAgIGludCBzcmNZID0gLXgxICogc2luQSArIHRyYW5zZm9ybS5tX3Bvc3RTaGlmdFk7CisgICAg ICAgICAgICAgICAgaWYgKHNyY1ggPj0gMCAmJiBzcmNYIDw9IHNvdXJjZVcgJiYgc3JjWSA+PSAw ICYmIHNyY1kgPD0gc291cmNlSCkKKyAgICAgICAgICAgICAgICAgICAgKmRlc3QrKyA9IHNvdXJj ZVtzcmNZICogcGFkZGVkU291cmNlVyArIHNyY1hdOworICAgICAgICAgICAgfQorICAgICAgICAg ICAgZGVzdCArPSBwYWRkaW5nOworICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgZm9y IChpbnQgeSA9IDA7IHkgPCBkZXN0SDsgKyt5KSB7CisgICAgICAgICAgICBmb3IgKGludCB4ID0g MDsgeCA8IGRlc3RXOyArK3gpIHsKKyAgICAgICAgICAgICAgICAvLyBGSVhNRTogZm9yIGJlc3Qg cXVhbGl0eSwgd2Ugc2hvdWxkIGdldCB3ZWlnaHRlZCBzdW0gb2YgZm91ciBuZWlnaGJvdXJzLAor ICAgICAgICAgICAgICAgIC8vIGJ1dCB0aGF0IHdpbGwgYmUgdG9vIGV4cGVuc2l2ZQorICAgICAg ICAgICAgICAgIGludCBzcmNYLCBzcmNZOworICAgICAgICAgICAgICAgIHRyYW5zZm9ybS5tYXAo eCwgeSwgJnNyY1gsICZzcmNZKTsKKyAgICAgICAgICAgICAgICBpZiAoc3JjWCA+PSAwICYmIHNy Y1ggPD0gc291cmNlVyAmJiBzcmNZID49IDAgJiYgc3JjWSA8PSBzb3VyY2VIKQorICAgICAgICAg ICAgICAgICAgICAqZGVzdCsrID0gc291cmNlW3NyY1kgKiBwYWRkZWRTb3VyY2VXICsgc3JjWF07 CisgICAgICAgICAgICB9CisgICAgICAgICAgICBkZXN0ICs9IHBhZGRpbmc7CisgICAgICAgIH0K KyAgICB9Cit9CisKK3ZvaWQgcm90YXRlQml0bWFwKFNoYXJlZEJpdG1hcCogZGVzdEJtcCwgY29u c3QgU2hhcmVkQml0bWFwKiBzb3VyY2VCbXAsIGNvbnN0IFJvdGF0aW9uVHJhbnNmb3JtJiB0cmFu c2Zvcm0pCit7CisgICAgQVNTRVJUKGRlc3RCbXAtPmlzMTZiaXQoKSA9PSBzb3VyY2VCbXAtPmlz MTZiaXQoKSk7CisgICAgaWYgKGRlc3RCbXAtPmlzMTZiaXQoKSkKKyAgICAgICAgX3JvdGF0ZUJp dG1hcDx1bnNpZ25lZCBzaG9ydCwgdHJ1ZT4oZGVzdEJtcCwgc291cmNlQm1wLCB0cmFuc2Zvcm0p OworICAgIGVsc2UKKyAgICAgICAgX3JvdGF0ZUJpdG1hcDx1bnNpZ25lZCwgZmFsc2U+KGRlc3RC bXAsIHNvdXJjZUJtcCwgdHJhbnNmb3JtKTsKK30KKworY2xhc3MgVHJhbnNwYXJlbnRMYXllckRD Cit7CitwdWJsaWM6CisgICAgZXhwbGljaXQgVHJhbnNwYXJlbnRMYXllckRDKEdyYXBoaWNzQ29u dGV4dFBsYXRmb3JtUHJpdmF0ZSogZGF0YQorICAgICAgICAsIEludFJlY3QmIG9yaWdSZWN0Cisg ICAgICAgICwgY29uc3QgSW50UmVjdCogcmVjdEJlZm9yZVRyYW5zZm9ybSA9IDAKKyAgICAgICAg LCBpbnQgYWxwaGEgPSAyNTUKKyAgICAgICAgLCBib29sIHBhaW50SW1hZ2UgPSBmYWxzZSkKKyAg ICAgICAgOiBtX2RhdGEoZGF0YSkKKyAgICAgICAgLCBtX29yaWdSZWN0KG9yaWdSZWN0KQorICAg ICAgICAsIG1fb2xkT3BhY2l0eShkYXRhLT5tX29wYWNpdHkpCisgICAgICAgIC8vIG1fa2V5MSBh bmQgbV9rZXkyIGFyZSBub3QgaW5pdGFsaXplZCBoZXJlLiBUaGV5IGFyZSB1c2VkIG9ubHkgaW4g dGhlIGNhc2UgdGhhdAorICAgICAgICAvLyBTaGFyZWRCaXRtYXA6OmdldERDKCkgaXMgY2FsbGVk LCBJLkUuLCB3aGVuIG1fYml0bWFwIGlzIG5vdCBudWxsLgorICAgIHsKKyAgICAgICAgbV9kYXRh LT5tX29wYWNpdHkgKj0gYWxwaGEgLyAyNTUuOworICAgICAgICBib29sIG11c3RDcmVhdGVMYXll cjsKKyAgICAgICAgaWYgKCFtX2RhdGEtPmhhc0FscGhhKCkpIHsKKyAgICAgICAgICAgIG11c3RD cmVhdGVMYXllciA9IGZhbHNlOworICAgICAgICAgICAgbV9hbHBoYVBhaW50VHlwZSA9IEFscGhh UGFpbnROb25lOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgbXVzdENyZWF0ZUxheWVy ID0gdHJ1ZTsKKyAgICAgICAgICAgIGlmIChwYWludEltYWdlKSB7CisgICAgICAgICAgICAgICAg bV9hbHBoYVBhaW50VHlwZSA9IEFscGhhUGFpbnRJbWFnZTsKKyAgICAgICAgICAgIH0gZWxzZSB7 CisgICAgICAgICAgICAgICAgbV9hbHBoYVBhaW50VHlwZSA9IEFscGhhUGFpbnRPdGhlcjsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBpZiAocmVjdEJlZm9yZVRyYW5zZm9ybSAm JiAhaXNaZXJvKG1fZGF0YS0+bV90cmFuc2Zvcm0uYigpKSkgeworICAgICAgICAgICAgbV9yb3Rh dGVkT3JpZ1JlY3QgPSBvcmlnUmVjdDsKKyAgICAgICAgICAgIG1fcm90YXRlZEJpdG1hcCA9IG1f ZGF0YS0+Z2V0VHJhbnNwYXJlbnRMYXllckJpdG1hcChtX3JvdGF0ZWRPcmlnUmVjdCwgbV9hbHBo YVBhaW50VHlwZSwgbV9ibXBSZWN0LCBmYWxzZSwgdHJ1ZSk7CisgICAgICAgICAgICBpZiAobV9y b3RhdGVkQml0bWFwKSB7CisgICAgICAgICAgICAgICAgZG91YmxlIGEgPSBtX2RhdGEtPm1fdHJh bnNmb3JtLmEoKTsKKyAgICAgICAgICAgICAgICBkb3VibGUgYiA9IG1fZGF0YS0+bV90cmFuc2Zv cm0uYigpOworICAgICAgICAgICAgICAgIGRvdWJsZSBjID0gX2h5cG90KGEsIGIpOworICAgICAg ICAgICAgICAgIG1fcm90YXRpb24ubV9jb3NBID0gYSAvIGM7CisgICAgICAgICAgICAgICAgbV9y b3RhdGlvbi5tX3NpbkEgPSBiIC8gYzsKKworICAgICAgICAgICAgICAgIGludCBjZW50ZXJYID0g b3JpZ1JlY3QueCgpICsgb3JpZ1JlY3Qud2lkdGgoKSAvIDI7CisgICAgICAgICAgICAgICAgaW50 IGNlbnRlclkgPSBvcmlnUmVjdC55KCkgKyBvcmlnUmVjdC5oZWlnaHQoKSAvIDI7CisgICAgICAg ICAgICAgICAgbV9yb3RhdGlvbi5tX3ByZVNoaWZ0WCA9IC1jZW50ZXJYOworICAgICAgICAgICAg ICAgIG1fcm90YXRpb24ubV9wcmVTaGlmdFkgPSAtY2VudGVyWTsKKyAgICAgICAgICAgICAgICBt X3JvdGF0aW9uLm1fcG9zdFNoaWZ0WCA9IGNlbnRlclg7CisgICAgICAgICAgICAgICAgbV9yb3Rh dGlvbi5tX3Bvc3RTaGlmdFkgPSBjZW50ZXJZOworCisgICAgICAgICAgICAgICAgbV9vcmlnUmVj dCA9IG1hcFJlY3QobV9yb3RhdGVkT3JpZ1JlY3QsIG1fcm90YXRpb24pOworCisgICAgICAgICAg ICAgICAgbV9yb3RhdGlvbi5tX3ByZVNoaWZ0WCArPSBtX3JvdGF0ZWRPcmlnUmVjdC54KCk7Cisg ICAgICAgICAgICAgICAgbV9yb3RhdGlvbi5tX3ByZVNoaWZ0WSArPSBtX3JvdGF0ZWRPcmlnUmVj dC55KCk7CisgICAgICAgICAgICAgICAgbV9yb3RhdGlvbi5tX3Bvc3RTaGlmdFggLT0gbV9vcmln UmVjdC54KCk7CisgICAgICAgICAgICAgICAgbV9yb3RhdGlvbi5tX3Bvc3RTaGlmdFkgLT0gbV9v cmlnUmVjdC55KCk7CisKKyAgICAgICAgICAgICAgICBGbG9hdFBvaW50IHRvcExlZnQgPSBtX2Rh dGEtPm1fdHJhbnNmb3JtLm1hcFBvaW50KEZsb2F0UG9pbnQocmVjdEJlZm9yZVRyYW5zZm9ybS0+ dG9wTGVmdCgpKSk7CisgICAgICAgICAgICAgICAgRmxvYXRQb2ludCB0b3BSaWdodChyZWN0QmVm b3JlVHJhbnNmb3JtLT5yaWdodCgpIC0gMSwgcmVjdEJlZm9yZVRyYW5zZm9ybS0+eSgpKTsKKyAg ICAgICAgICAgICAgICB0b3BSaWdodCA9IG1fZGF0YS0+bV90cmFuc2Zvcm0ubWFwUG9pbnQodG9w UmlnaHQpOworICAgICAgICAgICAgICAgIEZsb2F0UG9pbnQgYm90dG9tTGVmdChyZWN0QmVmb3Jl VHJhbnNmb3JtLT54KCksIHJlY3RCZWZvcmVUcmFuc2Zvcm0tPmJvdHRvbSgpIC0gMSk7CisgICAg ICAgICAgICAgICAgYm90dG9tTGVmdCA9IG1fZGF0YS0+bV90cmFuc2Zvcm0ubWFwUG9pbnQoYm90 dG9tTGVmdCk7CisgICAgICAgICAgICAgICAgRmxvYXRTaXplIHNpZGVUb3AgPSB0b3BSaWdodCAt IHRvcExlZnQ7CisgICAgICAgICAgICAgICAgRmxvYXRTaXplIHNpZGVMZWZ0ID0gYm90dG9tTGVm dCAtIHRvcExlZnQ7CisgICAgICAgICAgICAgICAgZmxvYXQgd2lkdGggPSBfaHlwb3Qoc2lkZVRv cC53aWR0aCgpICsgMSwgc2lkZVRvcC5oZWlnaHQoKSArIDEpOworICAgICAgICAgICAgICAgIGZs b2F0IGhlaWdodCA9IF9oeXBvdChzaWRlTGVmdC53aWR0aCgpICsgMSwgc2lkZUxlZnQuaGVpZ2h0 KCkgKyAxKTsKKworICAgICAgICAgICAgICAgIG9yaWdSZWN0LmluZmxhdGVYKHN0YWJsZVJvdW5k KCh3aWR0aCAtIG9yaWdSZWN0LndpZHRoKCkpICogMC41KSk7CisgICAgICAgICAgICAgICAgb3Jp Z1JlY3QuaW5mbGF0ZVkoc3RhYmxlUm91bmQoKGhlaWdodCAtIG9yaWdSZWN0LmhlaWdodCgpKSAq IDAuNSkpOworCisgICAgICAgICAgICAgICAgbV9iaXRtYXAgPSBTaGFyZWRCaXRtYXA6OmNyZWF0 ZUluc3RhbmNlKG1fcm90YXRlZEJpdG1hcC0+aXMxNmJpdCgpLCBtX29yaWdSZWN0LndpZHRoKCks IG1fb3JpZ1JlY3QuaGVpZ2h0KCksIHRydWUpOworICAgICAgICAgICAgICAgIGlmIChtX2JpdG1h cCkKKyAgICAgICAgICAgICAgICAgICAgcm90YXRlQml0bWFwKG1fYml0bWFwLmdldCgpLCBtX3Jv dGF0ZWRCaXRtYXAuZ2V0KCksIC1tX3JvdGF0aW9uKTsKKyAgICAgICAgICAgICAgICBlbHNlCisg ICAgICAgICAgICAgICAgICAgIG1fcm90YXRlZEJpdG1hcCA9IDA7CisgICAgICAgICAgICB9Cisg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgbV9iaXRtYXAgPSBtX2RhdGEtPmdldFRyYW5zcGFy ZW50TGF5ZXJCaXRtYXAobV9vcmlnUmVjdCwgbV9hbHBoYVBhaW50VHlwZSwgbV9ibXBSZWN0LCB0 cnVlLCBtdXN0Q3JlYXRlTGF5ZXIpOworICAgICAgICBpZiAobV9iaXRtYXApCisgICAgICAgICAg ICBtX21lbURjID0gbV9iaXRtYXAtPmdldERDKCZtX2tleTEsICZtX2tleTIpOworICAgICAgICBl bHNlCisgICAgICAgICAgICBtX21lbURjID0gbV9kYXRhLT5tX2RjOworICAgIH0KKyAgICB+VHJh bnNwYXJlbnRMYXllckRDKCkKKyAgICB7CisgICAgICAgIGlmIChtX3JvdGF0ZWRCaXRtYXApIHsK KyAgICAgICAgICAgIG1fYml0bWFwLT5yZWxlYXNlREMobV9tZW1EYywgbV9rZXkxLCBtX2tleTIp OworICAgICAgICAgICAgbV9rZXkxID0gbV9rZXkyID0gMDsKKyAgICAgICAgICAgIHJvdGF0ZUJp dG1hcChtX3JvdGF0ZWRCaXRtYXAuZ2V0KCksIG1fYml0bWFwLmdldCgpLCBtX3JvdGF0aW9uKTsK KyAgICAgICAgICAgIG1fbWVtRGMgPSBtX3JvdGF0ZWRCaXRtYXAtPmdldERDKCZtX2tleTEsICZt X2tleTIpOworICAgICAgICAgICAgbV9kYXRhLT5wYWludEJhY2tUcmFuc3BhcmVudExheWVyQml0 bWFwKG1fbWVtRGMsIG1fcm90YXRlZEJpdG1hcC5nZXQoKSwgbV9yb3RhdGVkT3JpZ1JlY3QsIG1f YWxwaGFQYWludFR5cGUsIG1fYm1wUmVjdCk7CisgICAgICAgICAgICBtX3JvdGF0ZWRCaXRtYXAt PnJlbGVhc2VEQyhtX21lbURjLCBtX2tleTEsIG1fa2V5Mik7CisgICAgICAgIH0gZWxzZSBpZiAo bV9iaXRtYXApIHsKKyAgICAgICAgICAgIG1fZGF0YS0+cGFpbnRCYWNrVHJhbnNwYXJlbnRMYXll ckJpdG1hcChtX21lbURjLCBtX2JpdG1hcC5nZXQoKSwgbV9vcmlnUmVjdCwgbV9hbHBoYVBhaW50 VHlwZSwgbV9ibXBSZWN0KTsKKyAgICAgICAgICAgIG1fYml0bWFwLT5yZWxlYXNlREMobV9tZW1E YywgbV9rZXkxLCBtX2tleTIpOworICAgICAgICB9CisgICAgICAgIG1fZGF0YS0+bV9vcGFjaXR5 ID0gbV9vbGRPcGFjaXR5OworICAgIH0KKyAgICBIREMgaGRjKCkgY29uc3QgeyByZXR1cm4gbV9t ZW1EYzsgfQorICAgIGNvbnN0IFJFQ1QmIHJlY3QoKSBjb25zdCB7IHJldHVybiBtX2JtcFJlY3Q7 IH0KKyAgICBJbnRTaXplIHRvU2hpZnQoKSBjb25zdCB7IHJldHVybiBJbnRTaXplKG1fYm1wUmVj dC5sZWZ0IC0gbV9vcmlnUmVjdC54KCksIG1fYm1wUmVjdC50b3AgLSBtX29yaWdSZWN0LnkoKSk7 IH0KKyAgICB2b2lkIGZpbGxBbHBoYUNoYW5uZWwoKQorICAgIHsKKyAgICAgICAgaWYgKG1fYml0 bWFwICYmIG1fYml0bWFwLT5pczMyYml0KCkpIHsKKyAgICAgICAgICAgIHVuc2lnbmVkKiBwaXhl bHMgPSAodW5zaWduZWQqKW1fYml0bWFwLT5ieXRlcygpOworICAgICAgICAgICAgY29uc3QgdW5z aWduZWQqIGNvbnN0IHBpeGVsc0VuZCA9IHBpeGVscyArIG1fYml0bWFwLT5iaXRtYXBJbmZvKCku bnVtUGl4ZWxzKCk7CisgICAgICAgICAgICB3aGlsZSAocGl4ZWxzIDwgcGl4ZWxzRW5kKSB7Cisg ICAgICAgICAgICAgICAgKnBpeGVscyB8PSAweEZGMDAwMDAwOworICAgICAgICAgICAgICAgICsr cGl4ZWxzOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorcHJpdmF0ZToKKyAgICBH cmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGUqIG1fZGF0YTsKKyAgICBJbnRSZWN0IG1fb3Jp Z1JlY3Q7CisgICAgSW50UmVjdCBtX3JvdGF0ZWRPcmlnUmVjdDsKKyAgICBIREMgbV9tZW1EYzsK KyAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBtX2JpdG1hcDsKKyAgICBSZWZQdHI8U2hhcmVkQml0 bWFwPiBtX3JvdGF0ZWRCaXRtYXA7CisgICAgUkVDVCBtX2JtcFJlY3Q7CisgICAgdW5zaWduZWQg bV9rZXkxOworICAgIHVuc2lnbmVkIG1fa2V5MjsKKyAgICBSb3RhdGlvblRyYW5zZm9ybSBtX3Jv dGF0aW9uOworICAgIGZsb2F0IG1fb2xkT3BhY2l0eTsKKyAgICBBbHBoYVBhaW50VHlwZSBtX2Fs cGhhUGFpbnRUeXBlOworfTsKKworY2xhc3MgU2NvcGVEQ1Byb3ZpZGVyIHsKK3B1YmxpYzoKKyAg ICBleHBsaWNpdCBTY29wZURDUHJvdmlkZXIoR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRl KiBkYXRhKQorICAgICAgICA6IG1fZGF0YShkYXRhKQorICAgIHsKKyAgICAgICAgaWYgKG1fZGF0 YS0+bV9iaXRtYXApCisgICAgICAgICAgICBtX2RhdGEtPm1fZGMgPSBtX2RhdGEtPm1fYml0bWFw LT5nZXREQygmbV9rZXkxLCAmbV9rZXkyKTsKKyAgICB9CisgICAgflNjb3BlRENQcm92aWRlcigp CisgICAgeworICAgICAgICBpZiAobV9kYXRhLT5tX2JpdG1hcCkgeworICAgICAgICAgICAgbV9k YXRhLT5tX2JpdG1hcC0+cmVsZWFzZURDKG1fZGF0YS0+bV9kYywgbV9rZXkxLCBtX2tleTIpOwor ICAgICAgICAgICAgbV9kYXRhLT5tX2RjID0gMDsKKyAgICAgICAgfQorICAgIH0KK3ByaXZhdGU6 CisgICAgR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKiBtX2RhdGE7CisgICAgdW5zaWdu ZWQgbV9rZXkxOworICAgIHVuc2lnbmVkIG1fa2V5MjsKK307CisKKworR3JhcGhpY3NDb250ZXh0 OjpHcmFwaGljc0NvbnRleHQoUGxhdGZvcm1HcmFwaGljc0NvbnRleHQqIGRjKQorICAgIDogbV9j b21tb24oY3JlYXRlR3JhcGhpY3NDb250ZXh0UHJpdmF0ZSgpKQorICAgICwgbV9kYXRhKG5ldyBH cmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGUoZGMpKQoreworfQorCitHcmFwaGljc0NvbnRl eHQ6On5HcmFwaGljc0NvbnRleHQoKQoreworICAgIGRlc3Ryb3lHcmFwaGljc0NvbnRleHRQcml2 YXRlKG1fY29tbW9uKTsKKyAgICBkZWxldGUgbV9kYXRhOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6c2V0Qml0bWFwKFBhc3NSZWZQdHI8U2hhcmVkQml0bWFwPiBibXApCit7CisgICAgQVNT RVJUKCFtX2RhdGEtPm1fZGMpOworICAgIG1fZGF0YS0+bV9iaXRtYXAgPSBibXA7Cit9CisKK0hE QyBHcmFwaGljc0NvbnRleHQ6OmdldFdpbmRvd3NDb250ZXh0KGNvbnN0IEludFJlY3QmIGRzdFJl Y3QsIGJvb2wgc3VwcG9ydEFscGhhQmxlbmQsIGJvb2wgbWF5Q3JlYXRlQml0bWFwKQoreworICAg IG5vdEltcGxlbWVudGVkKCk7CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJu IDA7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpyZWxlYXNlV2luZG93c0NvbnRleHQoSERD IGhkYywgY29uc3QgSW50UmVjdCYgZHN0UmVjdCwgYm9vbCBzdXBwb3J0QWxwaGFCbGVuZCwgYm9v bCBtYXlDcmVhdGVCaXRtYXApCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNhdmVQbGF0Zm9ybVN0 YXRlKCkKK3sKKyAgICBtX2RhdGEtPnNhdmUoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6 OnJlc3RvcmVQbGF0Zm9ybVN0YXRlKCkKK3sKKyAgICBtX2RhdGEtPnJlc3RvcmUoKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdSZWN0KGNvbnN0IEludFJlY3QmIHJlY3QpCit7Cisg ICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgcmVjdC53 aWR0aCgpIDw9IDAgfHwgcmVjdC5oZWlnaHQoKSA8PSAwKQorICAgICAgICByZXR1cm47CisKKyAg ICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5t X2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFw UmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEs IHRyUmVjdCwgJnJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAg aWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50RGMu dG9TaGlmdCgpKTsKKworICAgIEhHRElPQkogYnJ1c2ggPSAwOworICAgIEhHRElPQkogb2xkQnJ1 c2g7CisgICAgaWYgKGZpbGxDb2xvcigpLmFscGhhKCkpIHsKKyAgICAgICAgYnJ1c2ggPSBjcmVh dGVCcnVzaChmaWxsQ29sb3IoKSk7CisgICAgICAgIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KGRj LCBicnVzaCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9j a09iamVjdChOVUxMX0JSVVNIKSk7CisgICAgfQorCisgICAgSEdESU9CSiBwZW4gPSAwOworICAg IEhHRElPQkogb2xkUGVuOworICAgIGlmIChzdHJva2VTdHlsZSgpICE9IE5vU3Ryb2tlKSB7Cisg ICAgICAgIHBlbiA9IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwg c3Ryb2tlU3R5bGUoKSk7CisgICAgICAgIG9sZFBlbiA9IFNlbGVjdE9iamVjdChkYywgcGVuKTsK KyAgICB9IGVsc2UKKyAgICAgICAgU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9ja09iamVjdChOVUxM X1BFTikpOworCisgICAgaWYgKCFicnVzaCAmJiAhcGVuKQorICAgICAgICByZXR1cm47CisKKyAg ICBpZiAodHJSZWN0LndpZHRoKCkgPD0gMCkKKyAgICAgICAgdHJSZWN0LnNldFdpZHRoKDEpOwor ICAgIGlmICh0clJlY3QuaGVpZ2h0KCkgPD0gMCkKKyAgICAgICAgdHJSZWN0LnNldEhlaWdodCgx KTsKKworICAgIFJlY3RhbmdsZShkYywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJp Z2h0KCksIHRyUmVjdC5ib3R0b20oKSk7CisKKyAgICBpZiAocGVuKSB7CisgICAgICAgIFNlbGVj dE9iamVjdChkYywgb2xkUGVuKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgfQor CisgICAgaWYgKGJydXNoKSB7CisgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOwor ICAgICAgICBEZWxldGVPYmplY3QoYnJ1c2gpOworICAgIH0KK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OmRyYXdMaW5lKGNvbnN0IEludFBvaW50JiBwb2ludDEsIGNvbnN0IEludFBvaW50JiBw b2ludDIpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVk KCkgfHwgc3Ryb2tlU3R5bGUoKSA9PSBOb1N0cm9rZSB8fCAhc3Ryb2tlQ29sb3IoKS5hbHBoYSgp KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2Rh dGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRQ b2ludCB0clBvaW50MSA9IG1fZGF0YS0+bWFwUG9pbnQocG9pbnQxKTsKKyAgICBJbnRQb2ludCB0 clBvaW50MiA9IG1fZGF0YS0+bWFwUG9pbnQocG9pbnQyKTsKKworICAgIEludFJlY3QgbGluZVJl Y3QodHJQb2ludDEsIHRyUG9pbnQyIC0gdHJQb2ludDEpOworICAgIGxpbmVSZWN0LnNldEhlaWdo dChsaW5lUmVjdC5oZWlnaHQoKSArIHN0cm9rZVRoaWNrbmVzcygpKTsKKyAgICBUcmFuc3BhcmVu dExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIGxpbmVSZWN0LCAwLCBzdHJva2VDb2xvcigp LmFscGhhKCkpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFk YykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUG9pbnQxICs9IHRyYW5zcGFyZW50RGMudG9TaGlm dCgpOworICAgIHRyUG9pbnQyICs9IHRyYW5zcGFyZW50RGMudG9TaGlmdCgpOworCisgICAgSEdE SU9CSiBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0 cm9rZVN0eWxlKCkpOworICAgIEhHRElPQkogb2xkUGVuID0gU2VsZWN0T2JqZWN0KGRjLCBwZW4p OworCisgICAgTW92ZVRvRXgoZGMsIHRyUG9pbnQxLngoKSwgdHJQb2ludDEueSgpLCAwKTsKKyAg ICBMaW5lVG8oZGMsIHRyUG9pbnQyLngoKSwgdHJQb2ludDIueSgpKTsKKworICAgIFNlbGVjdE9i amVjdChkYywgb2xkUGVuKTsKKyAgICBEZWxldGVPYmplY3QocGVuKTsKK30KKwordm9pZCBHcmFw aGljc0NvbnRleHQ6OmRyYXdFbGxpcHNlKGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgaWYg KCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgKCFmaWxsQ29sb3Io KS5hbHBoYSgpICYmIHN0cm9rZVN0eWxlKCkgPT0gTm9TdHJva2UpKQorICAgICAgICByZXR1cm47 CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9k YXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0 YS0+bWFwUmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyht X2RhdGEsIHRyUmVjdCwgJnJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7 CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFy ZW50RGMudG9TaGlmdCgpKTsKKworICAgIEhHRElPQkogYnJ1c2ggPSAwOworICAgIEhHRElPQkog b2xkQnJ1c2g7CisgICAgaWYgKGZpbGxDb2xvcigpLmFscGhhKCkpIHsKKyAgICAgICAgYnJ1c2gg PSBjcmVhdGVCcnVzaChmaWxsQ29sb3IoKSk7CisgICAgICAgIG9sZEJydXNoID0gU2VsZWN0T2Jq ZWN0KGRjLCBicnVzaCk7CisgICAgfSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0 U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkpOworICAgIEhHRElPQkogcGVuID0gMDsKKyAgICBIR0RJ T0JKIG9sZFBlbjsKKyAgICBpZiAoc3Ryb2tlU3R5bGUoKSAhPSBOb1N0cm9rZSkgeworICAgICAg ICBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9r ZVN0eWxlKCkpOworICAgICAgICBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisgICAg fSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4p KTsKKworICAgIEVsbGlwc2UoZGMsIHRyUmVjdC54KCksIHRyUmVjdC55KCksIHRyUmVjdC5yaWdo dCgpLCB0clJlY3QuYm90dG9tKCkpOworCisgICAgaWYgKHBlbikgeworICAgICAgICBTZWxlY3RP YmplY3QoZGMsIG9sZFBlbik7CisgICAgICAgIERlbGV0ZU9iamVjdChwZW4pOworICAgIH0KKwor ICAgIGlmIChicnVzaCkgeworICAgICAgICBTZWxlY3RPYmplY3QoZGMsIG9sZEJydXNoKTsKKyAg ICAgICAgRGVsZXRlT2JqZWN0KGJydXNoKTsKKyAgICB9Cit9CisKKyNkZWZpbmUgRVFVQUxfQU5H TEUoYSwgYikgKGZhYnMoKGEpIC0gKGIpKSA8IDFlLTUpCit2b2lkIGdldEVsbGlwc2VQb2ludEJ5 QW5nbGUoZG91YmxlIGFuZ2xlLCBkb3VibGUgYSwgZG91YmxlIGIsIGZsb2F0JiB4LCBmbG9hdCYg eSkKK3sKKyAgICAvLyBhbmdsZSAlPSAzNjA7CisgICAgd2hpbGUgKGFuZ2xlIDwgMCkKKyAgICAg ICAgYW5nbGUgKz0gMiAqIHBpRG91YmxlOworICAgIHdoaWxlIChhbmdsZSA+PSAyICogcGlEb3Vi bGUpCisgICAgICAgIGFuZ2xlIC09IDIgKiBwaURvdWJsZTsKKworICAgIGlmIChFUVVBTF9BTkdM RShhbmdsZSwgMCkgfHwgRVFVQUxfQU5HTEUoYW5nbGUsIDIgKiBwaURvdWJsZSkpIHsKKyAgICAg ICAgeCA9IGE7CisgICAgICAgIHkgPSAwOworICAgIH0gZWxzZSBpZiAoRVFVQUxfQU5HTEUoYW5n bGUsIHBpRG91YmxlKSkgeworICAgICAgICB4ID0gLWE7CisgICAgICAgIHkgPSAwOworICAgIH0g ZWxzZSBpZiAoRVFVQUxfQU5HTEUoYW5nbGUsIC41ICogcGlEb3VibGUpKSB7CisgICAgICAgIHgg PSAwOworICAgICAgICB5ID0gYjsKKyAgICB9IGVsc2UgaWYgKEVRVUFMX0FOR0xFKGFuZ2xlLCAx LjUgKiBwaURvdWJsZSkpIHsKKyAgICAgICAgeCA9IDA7CisgICAgICAgIHkgPSAtYjsKKyAgICB9 IGVsc2UgeworICAgICAgICBkb3VibGUgayA9IHRhbihhbmdsZSk7CisgICAgICAgIGRvdWJsZSBz cUEgPSBhICogYTsKKyAgICAgICAgZG91YmxlIHNxQiA9IGIgKiBiOworICAgICAgICBkb3VibGUg dG1wID0gMS4gLyAoMS4gLyBzcUEgKyAoayAqIGspIC8gc3FCKTsKKyAgICAgICAgdG1wID0gdG1w IDw9IDAgPyAwIDogc3FydCh0bXApOworICAgICAgICBpZiAoYW5nbGUgPiAuNSAqIHBpRG91Ymxl ICYmIGFuZ2xlIDwgMS41ICogcGlEb3VibGUpCisgICAgICAgICAgICB0bXAgPSAtdG1wOworICAg ICAgICB4ID0gdG1wOworCisgICAgICAgIGsgPSB0YW4oLjUgKiBwaURvdWJsZSAtIGFuZ2xlKTsK KyAgICAgICAgdG1wID0gMS4gLyAoKGsgKiBrKSAvIHNxQSArIDEgLyBzcUIpOworICAgICAgICB0 bXAgPSB0bXAgPD0gMCA/IDAgOiBzcXJ0KHRtcCk7CisgICAgICAgIGlmIChhbmdsZSA+IHBpRG91 YmxlKQorICAgICAgICAgICAgdG1wID0gLXRtcDsKKyAgICAgICAgeSA9IHRtcDsKKyAgICB9Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzdHJva2VBcmMoY29uc3QgSW50UmVjdCYgcmVjdCwg aW50IHN0YXJ0QW5nbGUsIGludCBhbmdsZVNwYW4pCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3Bh Y2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgc3Ryb2tlU3R5bGUoKSA9PSBOb1N0cm9rZSB8 fCByZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVy IGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0 dXJuOworCisgICAgSW50UmVjdCB0clJlY3QgPSBtX2RhdGEtPm1hcFJlY3QocmVjdCk7CisgICAg VHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50RGMobV9kYXRhLCB0clJlY3QsICZyZWN0KTsK KyAgICBIREMgZGMgPSB0cmFuc3BhcmVudERjLmhkYygpOworICAgIGlmICghZGMpCisgICAgICAg IHJldHVybjsKKyAgICB0clJlY3QubW92ZSh0cmFuc3BhcmVudERjLnRvU2hpZnQoKSk7CisKKyAg ICBIR0RJT0JKIHBlbiA9IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3Mo KSwgc3Ryb2tlU3R5bGUoKSk7CisgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMs IHBlbik7CisKKyAgICBkb3VibGUgYSA9IHRyUmVjdC53aWR0aCgpICogMC41OworICAgIGRvdWJs ZSBiID0gdHJSZWN0LmhlaWdodCgpICogMC41OworICAgIGludCBjZW50ZXJYID0gc3RhYmxlUm91 bmQodHJSZWN0LngoKSArIGEpOworICAgIGludCBjZW50ZXJZID0gc3RhYmxlUm91bmQodHJSZWN0 LnkoKSArIGIpOworICAgIGZsb2F0IGZzdGFydFgsIGZzdGFydFksIGZlbmRYLCBmZW5kWTsKKyAg ICBpbnQgc3RhcnRYLCBzdGFydFksIGVuZFgsIGVuZFk7CisgICAgZ2V0RWxsaXBzZVBvaW50QnlB bmdsZShkZWcycmFkKChkb3VibGUpc3RhcnRBbmdsZSksIGEsIGIsIGZzdGFydFgsIGZzdGFydFkp OworICAgIGdldEVsbGlwc2VQb2ludEJ5QW5nbGUoZGVnMnJhZCgoZG91YmxlKXN0YXJ0QW5nbGUg KyBhbmdsZVNwYW4pLCBhLCBiLCBmZW5kWCwgZmVuZFkpOworICAgIHN0YXJ0WCA9IHN0YWJsZVJv dW5kKGZzdGFydFgpOworICAgIHN0YXJ0WSA9IHN0YWJsZVJvdW5kKGZzdGFydFkpOworICAgIGVu ZFggPSBzdGFibGVSb3VuZChmZW5kWCk7CisgICAgZW5kWSA9IHN0YWJsZVJvdW5kKGZlbmRZKTsK KworICAgIHN0YXJ0WCArPSBjZW50ZXJYOworICAgIHN0YXJ0WSA9IGNlbnRlclkgLSBzdGFydFk7 CisgICAgZW5kWCArPSBjZW50ZXJYOworICAgIGVuZFkgPSBjZW50ZXJZIC0gZW5kWTsKKyAgICBS RUNUIGNsaXBSZWN0OworICAgIGlmIChzdGFydFggPCBlbmRYKSB7CisgICAgICAgIGNsaXBSZWN0 LmxlZnQgPSBzdGFydFg7CisgICAgICAgIGNsaXBSZWN0LnJpZ2h0ID0gZW5kWDsKKyAgICB9IGVs c2UgeworICAgICAgICBjbGlwUmVjdC5sZWZ0ID0gZW5kWDsKKyAgICAgICAgY2xpcFJlY3Qucmln aHQgPSBzdGFydFg7CisgICAgfQorICAgIGlmIChzdGFydFkgPCBlbmRZKSB7CisgICAgICAgIGNs aXBSZWN0LnRvcCA9IHN0YXJ0WTsKKyAgICAgICAgY2xpcFJlY3QuYm90dG9tID0gZW5kWTsKKyAg ICB9IGVsc2UgeworICAgICAgICBjbGlwUmVjdC50b3AgPSBlbmRZOworICAgICAgICBjbGlwUmVj dC5ib3R0b20gPSBzdGFydFk7CisgICAgfQorCisgICAgT3duUHRyPEhSR04+IGNsaXBSZ24oQ3Jl YXRlUmVjdFJnbigwLCAwLCAwLCAwKSk7CisgICAgYm9vbCBuZXdDbGlwOworICAgIGlmIChHZXRD bGlwUmduKGRjLCBjbGlwUmduLmdldCgpKSA8PSAwKSB7CisgICAgICAgIG5ld0NsaXAgPSB0cnVl OworICAgICAgICBjbGlwUmduLnNldChDcmVhdGVSZWN0UmduKGNsaXBSZWN0LmxlZnQsIGNsaXBS ZWN0LnRvcCwgY2xpcFJlY3QucmlnaHQsIGNsaXBSZWN0LmJvdHRvbSkpOworICAgICAgICBTZWxl Y3RDbGlwUmduKGRjLCBjbGlwUmduLmdldCgpKTsKKyAgICB9IGVsc2UgeworICAgICAgICBuZXdD bGlwID0gZmFsc2U7CisgICAgICAgIEludGVyc2VjdENsaXBSZWN0KGRjLCBjbGlwUmVjdC5sZWZ0 LCBjbGlwUmVjdC50b3AsIGNsaXBSZWN0LnJpZ2h0LCBjbGlwUmVjdC5ib3R0b20pOworICAgIH0K KworICAgIEhHRElPQkogb2xkQnJ1c2ggPSBTZWxlY3RPYmplY3QoZGMsIEdldFN0b2NrT2JqZWN0 KE5VTExfQlJVU0gpKTsKKyAgICBFbGxpcHNlKGRjLCB0clJlY3QueCgpLCB0clJlY3QueSgpLCB0 clJlY3QucmlnaHQoKSwgdHJSZWN0LmJvdHRvbSgpKTsKKyAgICBTZWxlY3RPYmplY3QoZGMsIG9s ZEJydXNoKTsKKworICAgIGlmIChuZXdDbGlwKQorICAgICAgICBTZWxlY3RDbGlwUmduKGRjLCAw KTsKKyAgICBlbHNlCisgICAgICAgIFNlbGVjdENsaXBSZ24oZGMsIGNsaXBSZ24uZ2V0KCkpOwor CisgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRQZW4pOworICAgIERlbGV0ZU9iamVjdChwZW4pOwor fQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0NvbnZleFBvbHlnb24oc2l6ZV90IG5wb2lu dHMsIGNvbnN0IEZsb2F0UG9pbnQqIHBvaW50cywgYm9vbCBzaG91bGRBbnRpYWxpYXMpCit7Cisg ICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgbnBvaW50 cyA8PSAxIHx8ICFwb2ludHMpCisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRl ciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJl dHVybjsKKworICAgIFZlY3RvcjxQT0lOVCwgMjA+IHdpblBvaW50czsKKyAgICB3aW5Qb2ludHMu cmVzaXplKG5wb2ludHMpOworICAgIEZsb2F0UG9pbnQgdHJQb2ludCA9IG1fZGF0YS0+bWFwUG9p bnQocG9pbnRzWzBdKTsKKyAgICB3aW5Qb2ludHNbMF0ueCA9IHN0YWJsZVJvdW5kKHRyUG9pbnQu eCgpKTsKKyAgICB3aW5Qb2ludHNbMF0ueSA9IHN0YWJsZVJvdW5kKHRyUG9pbnQueSgpKTsKKyAg ICBSRUNUIHJlY3QgPSB7IHdpblBvaW50c1swXS54LCB3aW5Qb2ludHNbMF0ueSwgd2luUG9pbnRz WzBdLngsIHdpblBvaW50c1swXS55IH07CisgICAgZm9yIChzaXplX3QgaSA9IDE7IGkgPCBucG9p bnRzOyArK2kpIHsKKyAgICAgICAgdHJQb2ludCA9IG1fZGF0YS0+bWFwUG9pbnQocG9pbnRzW2ld KTsKKyAgICAgICAgd2luUG9pbnRzW2ldLnggPSBzdGFibGVSb3VuZCh0clBvaW50LngoKSk7Cisg ICAgICAgIHdpblBvaW50c1tpXS55ID0gc3RhYmxlUm91bmQodHJQb2ludC55KCkpOworICAgICAg ICBpZiAocmVjdC5sZWZ0ID4gd2luUG9pbnRzW2ldLngpCisgICAgICAgICAgICByZWN0LmxlZnQg PSB3aW5Qb2ludHNbaV0ueDsKKyAgICAgICAgZWxzZSBpZiAocmVjdC5yaWdodCA8IHdpblBvaW50 c1tpXS54KQorICAgICAgICAgICAgcmVjdC5yaWdodCA9IHdpblBvaW50c1tpXS54OworICAgICAg ICBpZiAocmVjdC50b3AgPiB3aW5Qb2ludHNbaV0ueSkKKyAgICAgICAgICAgIHJlY3QudG9wID0g d2luUG9pbnRzW2ldLnk7CisgICAgICAgIGVsc2UgaWYgKHJlY3QuYm90dG9tIDwgd2luUG9pbnRz W2ldLnkpCisgICAgICAgICAgICByZWN0LmJvdHRvbSA9IHdpblBvaW50c1tpXS55OworICAgIH0K KyAgICByZWN0LmJvdHRvbSArPSAxOworICAgIHJlY3QucmlnaHQgKz0gMTsKKworICAgIEludFJl Y3QgaW50UmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyht X2RhdGEsIGludFJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAg aWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBu cG9pbnRzOyArK2kpIHsKKyAgICAgICAgd2luUG9pbnRzW2ldLnggKz0gdHJhbnNwYXJlbnREYy50 b1NoaWZ0KCkud2lkdGgoKTsKKyAgICAgICAgd2luUG9pbnRzW2ldLnkgKz0gdHJhbnNwYXJlbnRE Yy50b1NoaWZ0KCkuaGVpZ2h0KCk7CisgICAgfQorCisgICAgSEdESU9CSiBicnVzaCA9IDA7Cisg ICAgSEdESU9CSiBvbGRCcnVzaDsKKyAgICBpZiAoZmlsbENvbG9yKCkuYWxwaGEoKSkgeworICAg ICAgICBicnVzaCA9IGNyZWF0ZUJydXNoKGZpbGxDb2xvcigpKTsKKyAgICAgICAgb2xkQnJ1c2gg PSBTZWxlY3RPYmplY3QoZGMsIGJydXNoKTsKKyAgICB9IGVsc2UKKyAgICAgICAgU2VsZWN0T2Jq ZWN0KGRjLCBHZXRTdG9ja09iamVjdChOVUxMX0JSVVNIKSk7CisKKyAgICBIR0RJT0JKIHBlbiA9 IDA7CisgICAgSEdESU9CSiBvbGRQZW47CisgICAgaWYgKHN0cm9rZVN0eWxlKCkgIT0gTm9TdHJv a2UpIHsKKyAgICAgICAgcGVuID0gY3JlYXRlUGVuKHN0cm9rZUNvbG9yKCksIHN0cm9rZVRoaWNr bmVzcygpLCBzdHJva2VTdHlsZSgpKTsKKyAgICAgICAgb2xkUGVuID0gU2VsZWN0T2JqZWN0KGRj LCBwZW4pOworICAgIH0gZWxzZQorICAgICAgICBTZWxlY3RPYmplY3QoZGMsIEdldFN0b2NrT2Jq ZWN0KE5VTExfUEVOKSk7CisKKyAgICBpZiAoIWJydXNoICYmICFwZW4pCisgICAgICAgIHJldHVy bjsKKworICAgIFBvbHlnb24oZGMsIHdpblBvaW50cy5kYXRhKCksIG5wb2ludHMpOworCisgICAg aWYgKHBlbikgeworICAgICAgICBTZWxlY3RPYmplY3QoZGMsIG9sZFBlbik7CisgICAgICAgIERl bGV0ZU9iamVjdChwZW4pOworICAgIH0KKworICAgIGlmIChicnVzaCkgeworICAgICAgICBTZWxl Y3RPYmplY3QoZGMsIG9sZEJydXNoKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KGJydXNoKTsKKyAg ICB9Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpmaWxsUmVjdChjb25zdCBGbG9hdFJlY3Qm IHJlY3QsIGNvbnN0IENvbG9yJiBjb2xvcikKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgp IHx8ICFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaW50IGFscGhh ID0gY29sb3IuYWxwaGEoKTsKKyAgICBpZiAoIWFscGhhKQorICAgICAgICByZXR1cm47CisKKyAg ICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5t X2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IGludFJlY3QgPSBlbmNsb3NpbmdJ bnRSZWN0KHJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0 YSwgbV9kYXRhLT5tYXBSZWN0KGludFJlY3QpLCAmaW50UmVjdCwgYWxwaGEpOworCisgICAgaWYg KCF0cmFuc3BhcmVudERjLmhkYygpKQorICAgICAgICByZXR1cm47CisKKyAgICBPd25QdHI8SEJS VVNIPiBoYnJ1c2goQ3JlYXRlU29saWRCcnVzaChSR0IoY29sb3IucmVkKCksIGNvbG9yLmdyZWVu KCksIGNvbG9yLmJsdWUoKSkpKTsKKyAgICBGaWxsUmVjdCh0cmFuc3BhcmVudERjLmhkYygpLCAm dHJhbnNwYXJlbnREYy5yZWN0KCksIGhicnVzaC5nZXQoKSk7Cit9CisKK3ZvaWQgR3JhcGhpY3ND b250ZXh0OjpjbGlwKGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdE aXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAg ICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCB0clJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KG1f ZGF0YS0+bWFwUmVjdChyZWN0KSk7CisKKyAgICBPd25QdHI8SFJHTj4gY2xpcFJnbihDcmVhdGVS ZWN0UmduKDAsIDAsIDAsIDApKTsKKyAgICBpZiAoR2V0Q2xpcFJnbihtX2RhdGEtPm1fZGMsIGNs aXBSZ24uZ2V0KCkpID4gMCkKKyAgICAgICAgSW50ZXJzZWN0Q2xpcFJlY3QobV9kYXRhLT5tX2Rj LCB0clJlY3QueCgpLCB0clJlY3QueSgpLCB0clJlY3QucmlnaHQoKSwgdHJSZWN0LmJvdHRvbSgp KTsKKyAgICBlbHNlIHsKKyAgICAgICAgY2xpcFJnbi5zZXQoQ3JlYXRlUmVjdFJnbih0clJlY3Qu eCgpLCB0clJlY3QueSgpLCB0clJlY3QucmlnaHQoKSwgdHJSZWN0LmJvdHRvbSgpKSk7CisgICAg ICAgIFNlbGVjdENsaXBSZ24obV9kYXRhLT5tX2RjLCBjbGlwUmduLmdldCgpKTsKKyAgICB9Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwT3V0KGNvbnN0IEludFJlY3QmIHJlY3QpCit7 CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYg KCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0ID0g bV9kYXRhLT5tYXBSZWN0KHJlY3QpOworCisgICAgRXhjbHVkZUNsaXBSZWN0KG1fZGF0YS0+bV9k YywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJpZ2h0KCksIHRyUmVjdC5ib3R0b20o KSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3Rm9jdXNSaW5nKGNvbnN0IENvbG9y JiBjb2xvcikKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5IHx8IHBhaW50aW5nRGlzYWJs ZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIo bV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisgICAg aW50IHJhZGl1cyA9IChmb2N1c1JpbmdXaWR0aCgpIC0gMSkgLyAyOworICAgIGludCBvZmZzZXQg PSByYWRpdXMgKyBmb2N1c1JpbmdPZmZzZXQoKTsKKworICAgIGNvbnN0IFZlY3RvcjxJbnRSZWN0 PiYgcmVjdHMgPSBmb2N1c1JpbmdSZWN0cygpOworICAgIHVuc2lnbmVkIHJlY3RDb3VudCA9IHJl Y3RzLnNpemUoKTsKKyAgICBJbnRSZWN0IGZpbmFsRm9jdXNSZWN0OworICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCByZWN0Q291bnQ7IGkrKykgeworICAgICAgICBJbnRSZWN0IGZvY3VzUmVj dCA9IHJlY3RzW2ldOworICAgICAgICBmb2N1c1JlY3QuaW5mbGF0ZShvZmZzZXQpOworICAgICAg ICBmaW5hbEZvY3VzUmVjdC51bml0ZShmb2N1c1JlY3QpOworICAgIH0KKworICAgIFJFQ1QgcmVj dCA9IHsgZmluYWxGb2N1c1JlY3QueCgpLCBmaW5hbEZvY3VzUmVjdC55KCksIGZpbmFsRm9jdXNS ZWN0LnJpZ2h0KCksIGZpbmFsRm9jdXNSZWN0LmJvdHRvbSgpIH07CisKKyAgICBJbnRSZWN0IGlu dFJlY3QgPSByZWN0OworICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KHJlY3Qp OworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0YSwgdHJSZWN0LCAm aW50UmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRj KQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0 KCkpOworCisgICAgcmVjdCA9IHRyUmVjdDsKKyAgICBEcmF3Rm9jdXNSZWN0KGRjLCAmcmVjdCk7 Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3TGluZUZvclRleHQoY29uc3QgSW50UG9p bnQmIG9yaWdpbiwgaW50IHdpZHRoLCBib29sIHByaW50aW5nKQoreworICAgIGlmIChwYWludGlu Z0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFN0cm9rZVN0eWxlIG9sZFN0eWxl ID0gc3Ryb2tlU3R5bGUoKTsKKyAgICBzZXRTdHJva2VTdHlsZShTb2xpZFN0cm9rZSk7CisgICAg ZHJhd0xpbmUob3JpZ2luLCBvcmlnaW4gKyBJbnRTaXplKHdpZHRoLCAwKSk7CisgICAgc2V0U3Ry b2tlU3R5bGUob2xkU3R5bGUpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0xpbmVG b3JNaXNzcGVsbGluZ09yQmFkR3JhbW1hcihjb25zdCBJbnRQb2ludCYsIGludCB3aWR0aCwgYm9v bCBncmFtbWFyKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3ND b250ZXh0OjpzZXRQbGF0Zm9ybUZpbGxDb2xvcihjb25zdCBDb2xvciYgY29sKQoreworICAgIG5v dEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRQbGF0Zm9ybVN0 cm9rZUNvbG9yKGNvbnN0IENvbG9yJiBjb2wpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldFBsYXRmb3JtU3Ryb2tlVGhpY2tuZXNzKGZsb2F0 IHN0cm9rZVRoaWNrbmVzcykKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChjb25zdCBLVVJMJiBsaW5rLCBjb25zdCBJbnRS ZWN0JiBkZXN0UmVjdCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBo aWNzQ29udGV4dDo6YWRkSW5uZXJSb3VuZGVkUmVjdENsaXAoY29uc3QgSW50UmVjdCYgcmVjdCwg aW50IHRoaWNrbmVzcykKK3sKKyAgICAvLyBXZSBjYW4gb25seSBjbGlwIHJlY3RhbmdsZXMgb24g V0lOQ0UKKyAgICBjbGlwKHJlY3QpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xlYXJS ZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgp KQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAobV9kYXRhLT5oYXNBbHBoYSgpKSB7CisgICAg ICAgIEludFJlY3QgdHJSZWN0ID0gZW5jbG9zaW5nSW50UmVjdChtX2RhdGEtPm1hcFJlY3QocmVj dCkpOworICAgICAgICBtX2RhdGEtPm1fYml0bWFwLT5jbGVhclBpeGVscyh0clJlY3QpOworICAg ICAgICByZXR1cm47CisgICAgfSAKKworICAgIGZpbGxSZWN0KHJlY3QsIENvbG9yKENvbG9yOjp3 aGl0ZSkpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c3Ryb2tlUmVjdChjb25zdCBGbG9h dFJlY3QmIHJlY3QsIGZsb2F0IHdpZHRoKQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkg fHwgcGFpbnRpbmdEaXNhYmxlZCgpIHx8IHN0cm9rZVN0eWxlKCkgPT0gTm9TdHJva2UpCisgICAg ICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7Cisg ICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgaW50 UmVjdCA9IGVuY2xvc2luZ0ludFJlY3QocmVjdCk7CisgICAgSW50UmVjdCB0clJlY3QgPSBtX2Rh dGEtPm1hcFJlY3QoaW50UmVjdCk7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50 RGMobV9kYXRhLCB0clJlY3QsICZpbnRSZWN0KTsKKyAgICBIREMgZGMgPSB0cmFuc3BhcmVudERj LmhkYygpOworICAgIGlmICghZGMpCisgICAgICAgIHJldHVybjsKKyAgICB0clJlY3QubW92ZSh0 cmFuc3BhcmVudERjLnRvU2hpZnQoKSk7CisKKyAgICBIR0RJT0JKIHBlbiA9IGNyZWF0ZVBlbihz dHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUoKSk7CisgICAgSEdE SU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisKKyAgICBpbnQgcmlnaHQgPSB0 clJlY3QucmlnaHQoKSAtIDE7CisgICAgaW50IGJvdHRvbSA9IHRyUmVjdC5ib3R0b20oKSAtIDE7 CisgICAgY29uc3QgUE9JTlQgaW50UG9pbnRzWzVdID0KKyAgICB7CisgICAgICAgIHsgdHJSZWN0 LngoKSwgdHJSZWN0LnkoKSB9LAorICAgICAgICB7IHJpZ2h0LCB0clJlY3QueSgpIH0sCisgICAg ICAgIHsgcmlnaHQsIGJvdHRvbSB9LAorICAgICAgICB7IHRyUmVjdC54KCksIGJvdHRvbSB9LAor ICAgICAgICB7IHRyUmVjdC54KCksIHRyUmVjdC55KCkgfQorICAgIH07CisKKyAgICBQb2x5bGlu ZShkYywgaW50UG9pbnRzLCA1KTsKKworICAgIFNlbGVjdE9iamVjdChkYywgb2xkUGVuKTsKKyAg ICBEZWxldGVPYmplY3QocGVuKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmJlZ2luVHJh bnNwYXJlbmN5TGF5ZXIoZmxvYXQgb3BhY2l0eSkKK3sKKyAgICBtX2RhdGEtPnNhdmUoKTsKKyAg ICBtX2RhdGEtPm1fb3BhY2l0eSAqPSBvcGFjaXR5OworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4 dDo6ZW5kVHJhbnNwYXJlbmN5TGF5ZXIoKQoreworICAgIG1fZGF0YS0+cmVzdG9yZSgpOworfQor Cit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y29uY2F0Q1RNKGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0 cml4JiB0cmFuc2Zvcm0pCit7CisgICAgbV9kYXRhLT5jb25jYXRDVE0odHJhbnNmb3JtKTsKK30K KworVHJhbnNmb3JtYXRpb25NYXRyaXgmIEdyYXBoaWNzQ29udGV4dDo6YWZmaW5lVHJhbnNmb3Jt KCkKK3sKKyAgICByZXR1cm4gbV9kYXRhLT5tX3RyYW5zZm9ybTsKK30KKworY29uc3QgVHJhbnNm b3JtYXRpb25NYXRyaXgmIEdyYXBoaWNzQ29udGV4dDo6YWZmaW5lVHJhbnNmb3JtKCkgY29uc3QK K3sKKyAgICByZXR1cm4gbV9kYXRhLT5tX3RyYW5zZm9ybTsKK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OnJlc2V0QWZmaW5lVHJhbnNmb3JtKCkKK3sKKyAgICBtX2RhdGEtPm1fdHJhbnNmb3Jt Lm1ha2VJZGVudGl0eSgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6dHJhbnNsYXRlKGZs b2F0IHgsIGZsb2F0IHkpCit7CisgICAgbV9kYXRhLT50cmFuc2xhdGUoeCwgeSk7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0Ojpyb3RhdGUoZmxvYXQgcmFkaWFucykKK3sKKyAgICBtX2RhdGEt PnJvdGF0ZShyYWRpYW5zKTsKK30KKworSW50UG9pbnQgR3JhcGhpY3NDb250ZXh0OjpvcmlnaW4o KQoreworICAgIHJldHVybiBtX2RhdGEtPm9yaWdpbigpOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6c2NhbGUoY29uc3QgRmxvYXRTaXplJiBzaXplKQoreworICAgIG1fZGF0YS0+c2NhbGUo c2l6ZSk7Cit9CisKK0Zsb2F0UmVjdCBHcmFwaGljc0NvbnRleHQ6Om1hcFJlY3QoY29uc3QgRmxv YXRSZWN0JiByZWN0KQoreworICAgIHJldHVybiBtX2RhdGEtPm1hcFJlY3QocmVjdCk7Cit9CisK K0ludFJlY3QgR3JhcGhpY3NDb250ZXh0OjptYXBSZWN0KGNvbnN0IEludFJlY3QmIHJlY3QpCit7 CisgICAgcmV0dXJuIG1fZGF0YS0+bWFwUmVjdChyZWN0KTsKK30KKworRmxvYXRQb2ludCBHcmFw aGljc0NvbnRleHQ6Om1hcFBvaW50KGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQoreworICAgIHJl dHVybiBtX2RhdGEtPm1hcFBvaW50KHBvaW50KTsKK30KKworRmxvYXRTaXplIEdyYXBoaWNzQ29u dGV4dDo6bWFwU2l6ZShjb25zdCBGbG9hdFNpemUmIHNpemUpCit7CisgICAgcmV0dXJuIG1fZGF0 YS0+bWFwU2l6ZShzaXplKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldExpbmVDYXAo TGluZUNhcCBsaW5lQ2FwKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3Jh cGhpY3NDb250ZXh0OjpzZXRMaW5lSm9pbihMaW5lSm9pbiBsaW5lSm9pbikKK3sKKyAgICBub3RJ bXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0TWl0ZXJMaW1pdChm bG9hdCBtaXRlcikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6c2V0QWxwaGEoZmxvYXQgYWxwaGEpCit7CisgICAgbV9kYXRhLT5tX29wYWNpdHkg PSBhbHBoYTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldENvbXBvc2l0ZU9wZXJhdGlv bihDb21wb3NpdGVPcGVyYXRvciBvcCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2 b2lkIEdyYXBoaWNzQ29udGV4dDo6YmVnaW5QYXRoKCkKK3sKKyAgICBtX2RhdGEtPm1fcGF0aHMu Y2xlYXIoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZFBhdGgoY29uc3QgUGF0aCYg cGF0aCkKK3sKKyAgICBtX2RhdGEtPm1fcGF0aHMuYXBwZW5kKHBhdGgpOworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6Y2xpcChjb25zdCBQYXRoJiBwYXRoKQoreworICAgIG5vdEltcGxlbWVu dGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwT3V0KGNvbnN0IFBhdGgmKQor eworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlw T3V0RWxsaXBzZUluUmVjdChjb25zdCBJbnRSZWN0JikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgp OworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZmlsbFJvdW5kZWRSZWN0KGNvbnN0IEludFJl Y3QmLCBjb25zdCBJbnRTaXplJiB0b3BMZWZ0LCBjb25zdCBJbnRTaXplJiB0b3BSaWdodCwgY29u c3QgSW50U2l6ZSYgYm90dG9tTGVmdCwgY29uc3QgSW50U2l6ZSYgYm90dG9tUmlnaHQsIGNvbnN0 IENvbG9yJikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCitGbG9hdFJlY3QgR3JhcGhp Y3NDb250ZXh0Ojpyb3VuZFRvRGV2aWNlUGl4ZWxzKGNvbnN0IEZsb2F0UmVjdCYgZnJlY3QpCit7 CisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICByZXR1cm4gZnJlY3Q7Cit9CisKK0NvbG9yIGdy YWRpZW50QXZlcmFnZUNvbG9yKGNvbnN0IEdyYWRpZW50KiBncmFkaWVudCkKK3sKKyAgICBjb25z dCBWZWN0b3I8R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzID0gZ3JhZGllbnQtPmdldFN0b3Bz KCk7CisgICAgaWYgKHN0b3BzLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIENvbG9yKCk7CisK KyAgICBjb25zdCBHcmFkaWVudDo6Q29sb3JTdG9wJiBzdG9wID0gc3RvcHMuZmlyc3QoKTsKKyAg ICBpZiAoc3RvcHMuc2l6ZSgpID09IDEpCisgICAgICAgIHJldHVybiBDb2xvcihzdG9wLnJlZCwg c3RvcC5ncmVlbiwgc3RvcC5ibHVlLCBzdG9wLmFscGhhKTsKKworICAgIGNvbnN0IEdyYWRpZW50 OjpDb2xvclN0b3AmIGxhc3RTdG9wID0gc3RvcHMubGFzdCgpOworICAgIHJldHVybiBDb2xvcigo c3RvcC5yZWQgKyBsYXN0U3RvcC5yZWQpICogMC41ZgorICAgICAgICAsIChzdG9wLmdyZWVuICsg bGFzdFN0b3AuZ3JlZW4pICogMC41ZgorICAgICAgICAsIChzdG9wLmJsdWUgKyBsYXN0U3RvcC5i bHVlKSAqIDAuNWYKKyAgICAgICAgLCAoc3RvcC5hbHBoYSArIGxhc3RTdG9wLmFscGhhKSAqIDAu NWYpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZmlsbFBhdGgoKQoreworICAgIENvbG9y IGMgPSBtX2NvbW1vbi0+c3RhdGUuZmlsbENvbG9yU3BhY2UgPT0gR3JhZGllbnRDb2xvclNwYWNl ICYmIG1fY29tbW9uLT5zdGF0ZS5maWxsR3JhZGllbnQKKyAgICAgICAgPyBncmFkaWVudEF2ZXJh Z2VDb2xvcihtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50LmdldCgpKQorICAgICAgICA6IGZp bGxDb2xvcigpOworCisgICAgaWYgKCFjLmFscGhhKCkgfHwgIW1fZGF0YS0+bV9vcGFjaXR5KQor ICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEp OworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAobV9k YXRhLT5tX29wYWNpdHkgPCAxLjBmIHx8IG1fZGF0YS0+aGFzQWxwaGEoKSkgeworICAgICAgICBI R0RJT0JKIGJydXNoID0gY3JlYXRlQnJ1c2goYyk7CisgICAgICAgIGZvciAoVmVjdG9yPFBhdGg+ Ojpjb25zdF9pdGVyYXRvciBpID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7IGkgIT0gbV9kYXRh LT5tX3BhdGhzLmVuZCgpOyArK2kpIHsKKyAgICAgICAgICAgIEludFJlY3QgdHJSZWN0ID0gZW5j bG9zaW5nSW50UmVjdChtX2RhdGEtPm1hcFJlY3QoaS0+Ym91bmRpbmdSZWN0KCkpKTsKKyAgICAg ICAgICAgIHRyUmVjdC5pbmZsYXRlKDEpOworICAgICAgICAgICAgVHJhbnNwYXJlbnRMYXllckRD IHRyYW5zcGFyZW50RGMobV9kYXRhLCB0clJlY3QpOworICAgICAgICAgICAgSERDIGRjID0gdHJh bnNwYXJlbnREYy5oZGMoKTsKKyAgICAgICAgICAgIGlmICghZGMpCisgICAgICAgICAgICAgICAg Y29udGludWU7CisKKyAgICAgICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IHRyID0gbV9kYXRh LT5tX3RyYW5zZm9ybTsKKyAgICAgICAgICAgIHRyLnRyYW5zbGF0ZSh0cmFuc3BhcmVudERjLnRv U2hpZnQoKS53aWR0aCgpLCB0cmFuc3BhcmVudERjLnRvU2hpZnQoKS5oZWlnaHQoKSk7CisKKyAg ICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKyAg ICAgICAgICAgIEhHRElPQkogb2xkQnJ1c2ggPSBTZWxlY3RPYmplY3QoZGMsIGJydXNoKTsKKyAg ICAgICAgICAgIGktPnBsYXRmb3JtUGF0aCgpLT5maWxsUGF0aChkYywgJnRyKTsKKyAgICAgICAg ICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOworICAgICAgICB9CisgICAgICAgIERlbGV0 ZU9iamVjdChicnVzaCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgU2VsZWN0T2JqZWN0KG1fZGF0 YS0+bV9kYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKyAgICAgICAgSEdESU9CSiBicnVz aCA9IGNyZWF0ZUJydXNoKGMpOworICAgICAgICBIR0RJT0JKIG9sZEJydXNoID0gU2VsZWN0T2Jq ZWN0KG1fZGF0YS0+bV9kYywgYnJ1c2gpOworICAgICAgICBmb3IgKFZlY3RvcjxQYXRoPjo6Y29u c3RfaXRlcmF0b3IgaSA9IG1fZGF0YS0+bV9wYXRocy5iZWdpbigpOyBpICE9IG1fZGF0YS0+bV9w YXRocy5lbmQoKTsgKytpKQorICAgICAgICAgICAgaS0+cGxhdGZvcm1QYXRoKCktPmZpbGxQYXRo KG1fZGF0YS0+bV9kYywgJm1fZGF0YS0+bV90cmFuc2Zvcm0pOworICAgICAgICBTZWxlY3RPYmpl Y3QobV9kYXRhLT5tX2RjLCBvbGRCcnVzaCk7CisgICAgICAgIERlbGV0ZU9iamVjdChicnVzaCk7 CisgICAgfQorfQorCisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzdHJva2VQYXRoKCkKK3sKKyAg ICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURD UHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAg ICAgICByZXR1cm47CisKKyAgICBpZiAobV9kYXRhLT5tX29wYWNpdHkgPCAxLjBmIHx8IG1fZGF0 YS0+aGFzQWxwaGEoKSkgeworICAgICAgICBIR0RJT0JKIHBlbiA9IGNyZWF0ZVBlbihzdHJva2VD b2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUoKSk7CisgICAgICAgIGZvciAo VmVjdG9yPFBhdGg+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7 IGkgIT0gbV9kYXRhLT5tX3BhdGhzLmVuZCgpOyArK2kpIHsKKyAgICAgICAgICAgIEludFJlY3Qg dHJSZWN0ID0gZW5jbG9zaW5nSW50UmVjdChtX2RhdGEtPm1hcFJlY3QoaS0+Ym91bmRpbmdSZWN0 KCkpKTsKKyAgICAgICAgICAgIHRyUmVjdC5pbmZsYXRlKDEpOworICAgICAgICAgICAgVHJhbnNw YXJlbnRMYXllckRDIHRyYW5zcGFyZW50RGMobV9kYXRhLCB0clJlY3QpOworICAgICAgICAgICAg SERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICAgICAgICAgIGlmICghZGMpCisgICAg ICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4 IHRyID0gbV9kYXRhLT5tX3RyYW5zZm9ybTsKKyAgICAgICAgICAgIHRyLnRyYW5zbGF0ZSh0cmFu c3BhcmVudERjLnRvU2hpZnQoKS53aWR0aCgpLCB0cmFuc3BhcmVudERjLnRvU2hpZnQoKS5oZWln aHQoKSk7CisKKyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVM TF9CUlVTSCkpOworICAgICAgICAgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMs IHBlbik7CisgICAgICAgICAgICBpLT5wbGF0Zm9ybVBhdGgoKS0+c3Ryb2tlUGF0aChkYywgJnRy KTsKKyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkUGVuKTsKKyAgICAgICAgfQorICAg ICAgICBEZWxldGVPYmplY3QocGVuKTsKKyAgICB9IGVsc2UgeworICAgICAgICBTZWxlY3RPYmpl Y3QobV9kYXRhLT5tX2RjLCBHZXRTdG9ja09iamVjdChOVUxMX0JSVVNIKSk7CisgICAgICAgIEhH RElPQkogcGVuID0gY3JlYXRlUGVuKHN0cm9rZUNvbG9yKCksIHN0cm9rZVRoaWNrbmVzcygpLCBz dHJva2VTdHlsZSgpKTsKKyAgICAgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QobV9k YXRhLT5tX2RjLCBwZW4pOworICAgICAgICBmb3IgKFZlY3RvcjxQYXRoPjo6Y29uc3RfaXRlcmF0 b3IgaSA9IG1fZGF0YS0+bV9wYXRocy5iZWdpbigpOyBpICE9IG1fZGF0YS0+bV9wYXRocy5lbmQo KTsgKytpKQorICAgICAgICAgICAgaS0+cGxhdGZvcm1QYXRoKCktPnN0cm9rZVBhdGgobV9kYXRh LT5tX2RjLCAmbV9kYXRhLT5tX3RyYW5zZm9ybSk7CisgICAgICAgIFNlbGVjdE9iamVjdChtX2Rh dGEtPm1fZGMsIG9sZFBlbik7CisgICAgICAgIERlbGV0ZU9iamVjdChwZW4pOworICAgIH0KK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0UmVjdCYgciwgY29u c3QgR3JhZGllbnQqIGdyYWRpZW50KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisg ICAgICAgIHJldHVybjsKKworICAgIGNvbnN0IFZlY3RvcjxHcmFkaWVudDo6Q29sb3JTdG9wPiYg c3RvcHMgPSBncmFkaWVudC0+Z2V0U3RvcHMoKTsKKyAgICBpZiAoc3RvcHMuaXNFbXB0eSgpKQor ICAgICAgICByZXR1cm47CisKKyAgICBpbnQgbnVtU3RvcHMgPSBzdG9wcy5zaXplKCk7CisgICAg aWYgKG51bVN0b3BzID09IDEpIHsKKyAgICAgICAgY29uc3QgR3JhZGllbnQ6OkNvbG9yU3RvcCYg c3RvcCA9IHN0b3BzLmZpcnN0KCk7CisgICAgICAgIENvbG9yIGNvbG9yKHN0b3AucmVkLCBzdG9w LmdyZWVuLCBzdG9wLmJsdWUsIHN0b3AuYWxwaGEpOworICAgICAgICBmaWxsUmVjdChyLCBjb2xv cik7CisgICAgICAgIHJldHVybjsKKyAgICB9IAorICAgIAorICAgIFNjb3BlRENQcm92aWRlciBk Y1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVy bjsKKworICAgIEludFJlY3QgaW50UmVjdCA9IGVuY2xvc2luZ0ludFJlY3Qocik7CisgICAgSW50 UmVjdCByZWN0ID0gbV9kYXRhLT5tYXBSZWN0KGludFJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5 ZXJEQyB0cmFuc3BhcmVudERjKG1fZGF0YSwgcmVjdCwgJmludFJlY3QsIDI1NSwgdHJ1ZSk7Cisg ICAgSERDIGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICBy ZXR1cm47CisKKyAgICByZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworICAgIEZs b2F0UG9pbnQgZnAwID0gbV9kYXRhLT5tYXBQb2ludChncmFkaWVudC0+cDAoKSk7CisgICAgRmxv YXRQb2ludCBmcDEgPSBtX2RhdGEtPm1hcFBvaW50KGdyYWRpZW50LT5wMSgpKTsKKyAgICBJbnRQ b2ludCBwMChzdGFibGVSb3VuZChmcDAueCgpKSwgc3RhYmxlUm91bmQoZnAwLnkoKSkpOworICAg IEludFBvaW50IHAxKHN0YWJsZVJvdW5kKGZwMS54KCkpLCBzdGFibGVSb3VuZChmcDEueSgpKSk7 CisgICAgcDAgKz0gdHJhbnNwYXJlbnREYy50b1NoaWZ0KCk7CisgICAgcDEgKz0gdHJhbnNwYXJl bnREYy50b1NoaWZ0KCk7CisKKyAgICBpZiAoZ3JhZGllbnQtPmlzUmFkaWFsKCkpIHsKKyAgICAg ICAgaWYgKGdfcmFkaWFsR3JhZGllbnRGaWxsZXIpIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBk b24ndCBzdXBwb3J0IDJEIHNjYWxpbmcgYXQgdGhpcyB0aW1lCisgICAgICAgICAgICBkb3VibGUg c2NhbGUgPSAobV9kYXRhLT5tX3RyYW5zZm9ybS5hKCkgKyBtX2RhdGEtPm1fdHJhbnNmb3JtLmQo KSkgKiAwLjU7CisgICAgICAgICAgICBmbG9hdCByMCA9IGdyYWRpZW50LT5yMCgpICogc2NhbGU7 CisgICAgICAgICAgICBmbG9hdCByMSA9IGdyYWRpZW50LT5yMSgpICogc2NhbGU7CisgICAgICAg ICAgICBnX3JhZGlhbEdyYWRpZW50RmlsbGVyKGRjLCByZWN0LCBwMCwgcDEsIHIwLCByMSwgZ3Jh ZGllbnQtPmdldFN0b3BzKCkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAg fSBlbHNlIGlmIChnX2xpbmVhckdyYWRpZW50RmlsbGVyKSB7CisgICAgICAgIGdfbGluZWFyR3Jh ZGllbnRGaWxsZXIoZGMsIHJlY3QsIHAwLCBwMSwgZ3JhZGllbnQtPmdldFN0b3BzKCkpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gU2ltcGxlIDFEIGxpbmVhciBzb2x1dGlvbiB0 aGF0IGFzc3VtZXMgcDAgaXMgb24gdGhlIHRvcCBvciBsZWZ0IHNpZGUsIGFuZCBwMSBpcyBvbiB0 aGUgcmlnaHQgb3IgYm90dG9tIHNpZGUKKyAgICBpbnQgbnVtUmVjdHMgPSAobnVtU3RvcHMgLSAx KTsKKyAgICBWZWN0b3I8VFJJVkVSVEVYLCAyMD4gdHY7CisgICAgdHYucmVzaXplKG51bVJlY3Rz ICogMik7CisgICAgVmVjdG9yPEdSQURJRU5UX1JFQ1QsIDEwPiBtZXNoOworICAgIG1lc2gucmVz aXplKG51bVJlY3RzKTsKKyAgICBpbnQgeCA9IHJlY3QueCgpOworICAgIGludCB5ID0gcmVjdC55 KCk7CisgICAgaW50IHdpZHRoID0gcmVjdC53aWR0aCgpOworICAgIGludCBoZWlnaHQgPSByZWN0 LmhlaWdodCgpOworICAgIEZsb2F0U2l6ZSBkID0gZ3JhZGllbnQtPnAxKCkgLSBncmFkaWVudC0+ cDAoKTsKKyAgICBib29sIHZlcnRpY2FsID0gYWJzKGQuaGVpZ2h0KCkpID4gYWJzKGQud2lkdGgo KSk7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1TdG9wczsgKytpKSB7CisgICAgICAgIGNv bnN0IEdyYWRpZW50OjpDb2xvclN0b3AmIHN0b3AgPSBzdG9wc1tpXTsKKyAgICAgICAgaW50IGlU diA9IGkgPyAyICogaSAtIDEgOiAwOworICAgICAgICB0dltpVHZdLlJlZCA9IHN0b3AucmVkICog MHhGRkZGOworICAgICAgICB0dltpVHZdLkdyZWVuID0gc3RvcC5ncmVlbiAqIDB4RkZGRjsKKyAg ICAgICAgdHZbaVR2XS5CbHVlID0gc3RvcC5ibHVlICogMHhGRkZGOworICAgICAgICB0dltpVHZd LkFscGhhID0gc3RvcC5hbHBoYSAqIDB4RkZGRjsKKyAgICAgICAgaWYgKGkpIHsKKyAgICAgICAg ICAgIHR2W2lUdl0ueCA9IHZlcnRpY2FsID8geCArIHdpZHRoOiB4ICsgd2lkdGggKiBzdG9wLnN0 b3A7CisgICAgICAgICAgICB0dltpVHZdLnkgPSB2ZXJ0aWNhbCA/IHkgKyBoZWlnaHQgKiBzdG9w LnN0b3AgOiB5ICsgaGVpZ2h0OworICAgICAgICAgICAgbWVzaFtpIC0gMV0uVXBwZXJMZWZ0ID0g aVR2IC0gMTsKKyAgICAgICAgICAgIG1lc2hbaSAtIDFdLkxvd2VyUmlnaHQgPSBpVHY7CisgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICB0dltpVHZdLnggPSB4OworICAgICAgICAgICAgdHZb aVR2XS55ID0geTsKKyAgICAgICAgfQorCisgICAgICAgIGlmIChpICYmIGkgPCBudW1SZWN0cykg eworICAgICAgICAgICAgdHZbaVR2ICsgMV0gPSB0dltpVHZdOworICAgICAgICAgICAgaWYgKHZl cnRpY2FsKQorICAgICAgICAgICAgICAgIHR2W2lUdiArIDFdLnggPSB4OworICAgICAgICAgICAg ZWxzZQorICAgICAgICAgICAgICAgIHR2W2lUdiArIDFdLnkgPSB5OworICAgICAgICB9CisgICAg fQorCisgICAgR3JhZGllbnRGaWxsKGRjLCB0di5kYXRhKCksIHR2LnNpemUoKSwgbWVzaC5kYXRh KCksIG1lc2guc2l6ZSgpLCB2ZXJ0aWNhbCA/IEdSQURJRU5UX0ZJTExfUkVDVF9WIDogR1JBRElF TlRfRklMTF9SRUNUX0gpOworfQorCitUcmFuc2Zvcm1hdGlvbk1hdHJpeCBHcmFwaGljc0NvbnRl eHQ6OmdldENUTSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fZGF0YS0+bV90cmFuc2Zvcm07Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwVG9JbWFnZUJ1ZmZlcihjb25zdCBGbG9hdFJl Y3QmLCBjb25zdCBJbWFnZUJ1ZmZlciopCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKK3sK KyAgICBpZiAobV9jb21tb24tPnN0YXRlLmZpbGxDb2xvclNwYWNlID09IEdyYWRpZW50Q29sb3JT cGFjZSAmJiBtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50KQorICAgICAgICBmaWxsUmVjdChy ZWN0LCBtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50LmdldCgpKTsKKyAgICBlbHNlCisgICAg ICAgIGZpbGxSZWN0KHJlY3QsIGZpbGxDb2xvcigpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRl eHQ6OnNldFBsYXRmb3JtU2hhZG93KGNvbnN0IEludFNpemUmLCBpbnQsIGNvbnN0IENvbG9yJikK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xl YXJQbGF0Zm9ybVNoYWRvdygpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBH cmFwaGljc0NvbnRleHQ6OnNldEltYWdlSW50ZXJwb2xhdGlvblF1YWxpdHkoSW50ZXJwb2xhdGlv blF1YWxpdHkpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKworI2RlZmluZSBpc0NoYXJW aXNpYmxlKGMpICgoYykgJiYgKGMpICE9IHplcm9XaWR0aFNwYWNlKQorCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6ZHJhd1RleHQoY29uc3QgRm9udCYgZm9udCwgY29uc3QgVGV4dFJ1biYgcnVuLCBj b25zdCBJbnRQb2ludCYgcG9pbnQsIGludCBmcm9tLCBpbnQgdG8pCit7CisgICAgaWYgKHBhaW50 aW5nRGlzYWJsZWQoKSB8fCBmaWxsQ29sb3IoKS5hbHBoYSgpID09IDAgfHwgIW1fZGF0YS0+bV9v cGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIG11c3RTdXBwb3J0QWxwaGEgPSBt X2RhdGEtPmhhc0FscGhhKCk7CisKKyAgICBpZiAoIW11c3RTdXBwb3J0QWxwaGEgJiYgZmlsbENv bG9yKCkuYWxwaGEoKSA9PSAweEZGICYmIG1fZGF0YS0+bV9vcGFjaXR5ID49IDEuMCkgeworICAg ICAgICBmb250LmRyYXdUZXh0KHRoaXMsIHJ1biwgcG9pbnQsIGZyb20sIHRvKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGZsb2F0IG9sZE9wYWNpdHkgPSBtX2RhdGEtPm1fb3BhY2l0 eTsKKyAgICBtX2RhdGEtPm1fb3BhY2l0eSAqPSBmaWxsQ29sb3IoKS5hbHBoYSgpIC8gMjU1LjA7 CisKKyAgICBGbG9hdFJlY3QgdGV4dFJlY3QgPSBmb250LnNlbGVjdGlvblJlY3RGb3JUZXh0KHJ1 biwgcG9pbnQsIGZvbnQuaGVpZ2h0KCksIGZyb20sIHRvKTsKKyAgICB0ZXh0UmVjdC5zZXRZKHRl eHRSZWN0LnkoKSAtIGZvbnQuYXNjZW50KCkpOworICAgIEludFJlY3QgdHJSZWN0ID0gZW5jbG9z aW5nSW50UmVjdChtX2RhdGEtPm1hcFJlY3QodGV4dFJlY3QpKTsKKyAgICBSRUNUIGJtcFJlY3Q7 CisgICAgQWxwaGFQYWludFR5cGUgYWxwaGFQYWludFR5cGUgPSBtdXN0U3VwcG9ydEFscGhhID8g QWxwaGFQYWludE90aGVyIDogQWxwaGFQYWludE5vbmU7CisgICAgUmVmUHRyPFNoYXJlZEJpdG1h cD4gYm1wID0gbV9kYXRhLT5nZXRUcmFuc3BhcmVudExheWVyQml0bWFwKHRyUmVjdCwgYWxwaGFQ YWludFR5cGUsIGJtcFJlY3QsIHRydWUsIG11c3RTdXBwb3J0QWxwaGEpOworICAgIGlmIChibXAp IHsKKyAgICAgICAgeworICAgICAgICAgICAgR3JhcGhpY3NDb250ZXh0IGdjKDApOworICAgICAg ICAgICAgZ2Muc2V0Qml0bWFwKGJtcCk7CisgICAgICAgICAgICBnYy5zY2FsZShGbG9hdFNpemUo bV9kYXRhLT5tX3RyYW5zZm9ybS5hKCksIG1fZGF0YS0+bV90cmFuc2Zvcm0uZCgpKSk7CisgICAg ICAgICAgICBmb250LmRyYXdUZXh0KCZnYywgcnVuLCBJbnRQb2ludCgwLCBmb250LmFzY2VudCgp KSwgZnJvbSwgdG8pOworICAgICAgICB9CisgICAgICAgIHVuc2lnbmVkIGtleTEsIGtleTI7Cisg ICAgICAgIEhEQyBtZW1EYyA9IGJtcC0+Z2V0REMoJmtleTEsICZrZXkyKTsKKyAgICAgICAgaWYg KG1lbURjKSB7CisgICAgICAgICAgICBtX2RhdGEtPnBhaW50QmFja1RyYW5zcGFyZW50TGF5ZXJC aXRtYXAobWVtRGMsIGJtcC5nZXQoKSwgdHJSZWN0LCBhbHBoYVBhaW50VHlwZSwgYm1wUmVjdCk7 CisgICAgICAgICAgICBibXAtPnJlbGVhc2VEQyhtZW1EYywga2V5MSwga2V5Mik7CisgICAgICAg IH0KKyAgICB9CisKKyAgICBtX2RhdGEtPm1fb3BhY2l0eSA9IG9sZE9wYWNpdHk7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3VGV4dChjb25zdCBTaW1wbGVGb250RGF0YSogZm9udERh dGEsIGNvbnN0IEdseXBoQnVmZmVyJiBnbHlwaEJ1ZmZlciwKKyAgICAgICAgICAgICAgICAgICAg ICBpbnQgZnJvbSwgaW50IG51bUdseXBocywgY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCit7Cisg ICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yICg7 OykgeworICAgICAgICBpZiAoIW51bUdseXBocykKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAg ICAgaWYgKGlzQ2hhclZpc2libGUoKmdseXBoQnVmZmVyLmdseXBocyhmcm9tKSkpCisgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgKytmcm9tOworICAgICAgICAtLW51bUdseXBoczsKKyAgICB9 CisKKyAgICBkb3VibGUgc2NhbGVYID0gbV9kYXRhLT5tX3RyYW5zZm9ybS5hKCk7CisgICAgZG91 YmxlIHNjYWxlWSA9IG1fZGF0YS0+bV90cmFuc2Zvcm0uZCgpOworCisgICAgaW50IGhlaWdodCA9 IGZvbnREYXRhLT5wbGF0Zm9ybURhdGEoKS5zaXplKCkgKiBzY2FsZVk7CisgICAgaW50IHdpZHRo ID0gZm9udERhdGEtPnBsYXRmb3JtRGF0YSgpLmF2ZXJhZ2VDaGFyV2lkdGgoKSAqIHNjYWxlWDsK KworICAgIGlmICghaGVpZ2h0IHx8ICF3aWR0aCkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2Nv cGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykK KyAgICAgICAgcmV0dXJuOworCisgICAgLy8gVHJhbnNwYXJlbnRMYXllckRDIC4uLgorCisgICAg SEZPTlQgaEZvbnQgPSBoZWlnaHQgPiAxCisgICAgICAgID8gZm9udERhdGEtPnBsYXRmb3JtRGF0 YSgpLmdldFNjYWxlZEZvbnRIYW5kbGUoaGVpZ2h0LCBzY2FsZVggPT0gc2NhbGVZID8gMCA6IHdp ZHRoKQorICAgICAgICA6IDA7CisKKyAgICBGbG9hdFBvaW50IHN0YXJ0UG9pbnQocG9pbnQueCgp LCBwb2ludC55KCkgLSBmb250RGF0YS0+YXNjZW50KCkpOworICAgIEZsb2F0UG9pbnQgdHJQb2lu dCA9IG1fZGF0YS0+bWFwUG9pbnQoc3RhcnRQb2ludCk7CisgICAgaW50IHkgPSBzdGFibGVSb3Vu ZCh0clBvaW50LnkoKSk7CisKKyAgICBDb2xvciBjb2xvciA9IGZpbGxDb2xvcigpOworICAgIGlm IChjb2xvci5hbHBoYSgpID09IDApIC8vIGhhY2sKKyAgICAgICAgcmV0dXJuOworCisgICAgQ09M T1JSRUYgZm9udENvbG9yID0gUkdCKGNvbG9yLnJlZCgpLCBjb2xvci5ncmVlbigpLCBjb2xvci5i bHVlKCkpOworCisgICAgaWYgKGhGb250KSB7CisgICAgICAgIEludFNpemUgc2hhZG93U2l6ZTsK KyAgICAgICAgaW50IHNoYWRvd0JsdXIgPSAwOworICAgICAgICBDb2xvciBzaGFkb3dDb2xvcjsK KyAgICAgICAgYm9vbCBoYXNTaGFkb3cgPSB0ZXh0RHJhd2luZ01vZGUoKSA9PSBjVGV4dEZpbGwK KyAgICAgICAgICAgICYmIGdldFNoYWRvdyhzaGFkb3dTaXplLCBzaGFkb3dCbHVyLCBzaGFkb3dD b2xvcikKKyAgICAgICAgICAgICYmIHNoYWRvd0NvbG9yLmFscGhhKCk7CisgICAgICAgIENPTE9S UkVGIHNoYWRvd1JnYkNvbG9yOworICAgICAgICBGbG9hdFBvaW50IHRyU2hhZG93UG9pbnQ7Cisg ICAgICAgIGlmIChoYXNTaGFkb3cpIHsKKyAgICAgICAgICAgIHNoYWRvd1JnYkNvbG9yID0gUkdC KHNoYWRvd0NvbG9yLnJlZCgpLCBzaGFkb3dDb2xvci5ncmVlbigpLCBzaGFkb3dDb2xvci5ibHVl KCkpOworICAgICAgICAgICAgdHJTaGFkb3dQb2ludCA9IG1fZGF0YS0+bWFwUG9pbnQoc3RhcnRQ b2ludCArIHNoYWRvd1NpemUpOworICAgICAgICB9CisKKyAgICAgICAgSEdESU9CSiBoT2xkRm9u dCA9IFNlbGVjdE9iamVjdChtX2RhdGEtPm1fZGMsIGhGb250KTsKKyAgICAgICAgLy8gdHJhbnNw YXJlbnQgYWx3YXlzLi4uCisgICAgICAgIGludCBvbGRCa01vZGUgPSBHZXRCa01vZGUobV9kYXRh LT5tX2RjKTsKKyAgICAgICAgQ09MT1JSRUYgb2xkVGV4dENvbG9yID0gR2V0VGV4dENvbG9yKG1f ZGF0YS0+bV9kYyk7CisgICAgICAgIGludCBvbGRUZXh0QWxpZ24gPSBHZXRUZXh0QWxpZ24obV9k YXRhLT5tX2RjKTsKKyAgICAgICAgU2V0VGV4dEFsaWduKG1fZGF0YS0+bV9kYywgMCk7CisgICAg ICAgIFNldEJrTW9kZShtX2RhdGEtPm1fZGMsIFRSQU5TUEFSRU5UKTsKKworICAgICAgICBpZiAo bnVtR2x5cGhzID4gMSkgeworICAgICAgICAgICAgZG91YmxlIG9mZnNldCA9IHRyUG9pbnQueCgp OworICAgICAgICAgICAgVmVjdG9yPGludCwgMjU2PiBnbHlwaFNwYWNlKG51bUdseXBocyk7Cisg ICAgICAgICAgICBWZWN0b3I8VUNoYXIsIDI1Nj4gdGV4dChudW1HbHlwaHMpOworICAgICAgICAg ICAgaW50KiBjdXJTcGFjZSA9IGdseXBoU3BhY2UuZGF0YSgpOworICAgICAgICAgICAgVUNoYXIq IGN1ckNoYXIgPSB0ZXh0LmRhdGEoKTsKKyAgICAgICAgICAgIGNvbnN0IFVDaGFyKiBzcmNDaGFy ID0gZ2x5cGhCdWZmZXIuZ2x5cGhzKGZyb20pOworICAgICAgICAgICAgY29uc3QgVUNoYXIqIGNv bnN0IHNyY0NoYXJFbmQgPSBzcmNDaGFyICsgbnVtR2x5cGhzOworICAgICAgICAgICAgKmN1ckNo YXIrKyA9ICpzcmNDaGFyKys7CisgICAgICAgICAgICBpbnQgZmlyc3RPZmZzZXQgPSBzdGFibGVS b3VuZChvZmZzZXQpOworICAgICAgICAgICAgaW50IGxhc3RPZmZzZXQgPSBmaXJzdE9mZnNldDsK KyAgICAgICAgICAgIGNvbnN0IEdseXBoQnVmZmVyQWR2YW5jZSogYWR2YW5jZSA9IGdseXBoQnVm ZmVyLmFkdmFuY2VEYXRhKCkgKyBmcm9tOworICAgICAgICAgICAgLy8gRklYTUU6IEV4dFRleHRP dXQoKSBjYW4gZmxpcCBvdmVyIGVhY2ggd29yZCBmb3IgUlRMIGxhbmF1Z2VzLCBldmVuIHdoZW4g VEFfUlRMUkVBRElORyBpcyBvZmYuCisgICAgICAgICAgICAvLyAodGhpcyBjYW4gYmUgR0RJIGJ1 ZyBvciBmb250IGRyaXZlciBidWc/KQorICAgICAgICAgICAgLy8gV2UgYXJlIG5vdCBjbGVhciBo b3cgaXQgcHJvY2Vzc2VzIGNoYXJhY3RlcnMgYW5kIGhhbmRsZXMgc3BlY2lmaWVkIHNwYWNlcy4g T24gdGhlIG90aGVyIHNpZGUsCisgICAgICAgICAgICAvLyBvdXIgZ2x5cGggYnVmZmVyIGlzIGFs cmVhZHkgaW4gdGhlIGNvcnJlY3Qgb3JkZXIgZm9yIHJlbmRlcmluZy4gU28sIHRoZSBzb2x1dGlv biBpcyB0aGF0IHdlCisgICAgICAgICAgICAvLyBjYWxsIEV4dFRleHRPdXQoKSBmb3IgZWFjaCBz aW5nbGUgY2hhcmFjdGVyIHdoZW4gdGhlIHRleHQgY29udGFpbnMgYW55IFJUTCBjaGFyYWN0ZXIu CisgICAgICAgICAgICAvLyBUaGlzIHNvbHV0aW9uIGlzIG5vdCBwZXJmZWN0IGFzIGl0IGlzIHNs b3dlciB0aGFuIGNhbGxpbmcgRXh0VGV4dE91dCgpIG9uZSB0aW1lIGZvciBhbGwgY2hhcmFjdGVy cy4KKyAgICAgICAgICAgIC8vIERyYXdpbmcgY2hhcmFjdGVycyBvbmUgYnkgb25lIG1heSBiZSB0 b28gc2xvdy4KKyAgICAgICAgICAgIGJvb2wgZHJhd09uZUJ5T25lID0gZmFsc2U7CisgICAgICAg ICAgICBpZiAoc2NhbGVYID09IDEuKSB7CisgICAgICAgICAgICAgICAgZm9yICg7IHNyY0NoYXIg PCBzcmNDaGFyRW5kOyArK3NyY0NoYXIpIHsKKyAgICAgICAgICAgICAgICAgICAgb2Zmc2V0ICs9 ICphZHZhbmNlKys7CisgICAgICAgICAgICAgICAgICAgIGludCBvZmZzZXRJbnQgPSBzdGFibGVS b3VuZChvZmZzZXQpOworICAgICAgICAgICAgICAgICAgICBpZiAoaXNDaGFyVmlzaWJsZSgqc3Jj Q2hhcikpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmICghZHJhd09uZUJ5T25lICYmIFdU Rjo6VW5pY29kZTo6ZGlyZWN0aW9uKCpzcmNDaGFyKSA9PSBXVEY6OlVuaWNvZGU6OlJpZ2h0VG9M ZWZ0KQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRyYXdPbmVCeU9uZSA9IHRydWU7Cisg ICAgICAgICAgICAgICAgICAgICAgICAqY3VyQ2hhcisrID0gKnNyY0NoYXI7CisgICAgICAgICAg ICAgICAgICAgICAgICAqY3VyU3BhY2UrKyA9IG9mZnNldEludCAtIGxhc3RPZmZzZXQ7CisgICAg ICAgICAgICAgICAgICAgICAgICBsYXN0T2Zmc2V0ID0gb2Zmc2V0SW50OworICAgICAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgICAgICBmb3IgKDsgc3JjQ2hhciA8IHNyY0NoYXJFbmQ7ICsrc3JjQ2hhcikgeworICAg ICAgICAgICAgICAgICAgICBvZmZzZXQgKz0gKmFkdmFuY2UrKyAqIHNjYWxlWDsKKyAgICAgICAg ICAgICAgICAgICAgaW50IG9mZnNldEludCA9IHN0YWJsZVJvdW5kKG9mZnNldCk7CisgICAgICAg ICAgICAgICAgICAgIGlmIChpc0NoYXJWaXNpYmxlKCpzcmNDaGFyKSkgeworICAgICAgICAgICAg ICAgICAgICAgICAgaWYgKCFkcmF3T25lQnlPbmUgJiYgV1RGOjpVbmljb2RlOjpkaXJlY3Rpb24o KnNyY0NoYXIpID09IFdURjo6VW5pY29kZTo6UmlnaHRUb0xlZnQpCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZHJhd09uZUJ5T25lID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgICAg ICpjdXJDaGFyKysgPSAqc3JjQ2hhcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICpjdXJTcGFj ZSsrID0gb2Zmc2V0SW50IC0gbGFzdE9mZnNldDsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxh c3RPZmZzZXQgPSBvZmZzZXRJbnQ7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgICAgICBudW1HbHlwaHMgPSBjdXJDaGFyIC0g dGV4dC5kYXRhKCk7CisgICAgICAgICAgICBpZiAoaGFzU2hhZG93KSB7CisgICAgICAgICAgICAg ICAgU2V0VGV4dENvbG9yKG1fZGF0YS0+bV9kYywgc2hhZG93UmdiQ29sb3IpOworICAgICAgICAg ICAgICAgIGlmIChkcmF3T25lQnlPbmUpIHsKKyAgICAgICAgICAgICAgICAgICAgaW50IHhTaGFk b3cgPSBmaXJzdE9mZnNldCArIHN0YWJsZVJvdW5kKHRyU2hhZG93UG9pbnQueCgpIC0gdHJQb2lu dC54KCkpOworICAgICAgICAgICAgICAgICAgICBpbnQgeVNoYWRvdyA9IHN0YWJsZVJvdW5kKHRy U2hhZG93UG9pbnQueSgpKTsKKyAgICAgICAgICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkg PCBudW1HbHlwaHM7ICsraSkgeworICAgICAgICAgICAgICAgICAgICAgICAgRXh0VGV4dE91dAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIChtX2RhdGEtPm1fZGMKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAsIHhTaGFkb3cKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAsIHlT aGFkb3cKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAsIE5VTEwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAsIHRleHQuZGF0 YSgpICsgaQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICwgMQorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICwgMCk7CisgICAgICAgICAgICAgICAgICAgICAgICB4U2hhZG93ICs9IGds eXBoU3BhY2VbaV07CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9IGVs c2UgeworICAgICAgICAgICAgICAgICAgICBFeHRUZXh0T3V0CisgICAgICAgICAgICAgICAgICAg ICAgICAobV9kYXRhLT5tX2RjCisgICAgICAgICAgICAgICAgICAgICAgICAsIGZpcnN0T2Zmc2V0 ICsgc3RhYmxlUm91bmQodHJTaGFkb3dQb2ludC54KCkgLSB0clBvaW50LngoKSkKKyAgICAgICAg ICAgICAgICAgICAgICAgICwgc3RhYmxlUm91bmQodHJTaGFkb3dQb2ludC55KCkpCisgICAgICAg ICAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAgICAgICAgICwgTlVMTAorICAg ICAgICAgICAgICAgICAgICAgICAgLCB0ZXh0LmRhdGEoKQorICAgICAgICAgICAgICAgICAgICAg ICAgLCBudW1HbHlwaHMKKyAgICAgICAgICAgICAgICAgICAgICAgICwgZ2x5cGhTcGFjZS5kYXRh KCkpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIFNldFRl eHRDb2xvcihtX2RhdGEtPm1fZGMsIGZvbnRDb2xvcik7CisgICAgICAgICAgICBpZiAoZHJhd09u ZUJ5T25lKSB7CisgICAgICAgICAgICAgICAgaW50IHggPSBmaXJzdE9mZnNldDsKKyAgICAgICAg ICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IG51bUdseXBoczsgKytpKSB7CisgICAgICAgICAg ICAgICAgICAgIEV4dFRleHRPdXQKKyAgICAgICAgICAgICAgICAgICAgICAgIChtX2RhdGEtPm1f ZGMKKyAgICAgICAgICAgICAgICAgICAgICAgICwgeAorICAgICAgICAgICAgICAgICAgICAgICAg LCB5CisgICAgICAgICAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAgICAgICAgICAg ICwgTlVMTAorICAgICAgICAgICAgICAgICAgICAgICAgLCB0ZXh0LmRhdGEoKSArIGkKKyAgICAg ICAgICAgICAgICAgICAgICAgICwgMQorICAgICAgICAgICAgICAgICAgICAgICAgLCAwKTsKKyAg ICAgICAgICAgICAgICAgICAgeCArPSBnbHlwaFNwYWNlW2ldOworICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgRXh0VGV4dE91dAorICAgICAg ICAgICAgICAgICAgICAobV9kYXRhLT5tX2RjCisgICAgICAgICAgICAgICAgICAgICwgZmlyc3RP ZmZzZXQKKyAgICAgICAgICAgICAgICAgICAgLCB5CisgICAgICAgICAgICAgICAgICAgICwgMAor ICAgICAgICAgICAgICAgICAgICAsIE5VTEwKKyAgICAgICAgICAgICAgICAgICAgLCB0ZXh0LmRh dGEoKQorICAgICAgICAgICAgICAgICAgICAsIG51bUdseXBocworICAgICAgICAgICAgICAgICAg ICAsIGdseXBoU3BhY2UuZGF0YSgpKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgIFVDaGFyIGMgPSAqZ2x5cGhCdWZmZXIuZ2x5cGhzKGZyb20pOworICAgICAg ICAgICAgaWYgKGhhc1NoYWRvdykgeworICAgICAgICAgICAgICAgIFNldFRleHRDb2xvcihtX2Rh dGEtPm1fZGMsIHNoYWRvd1JnYkNvbG9yKTsKKyAgICAgICAgICAgICAgICBFeHRUZXh0T3V0Cisg ICAgICAgICAgICAgICAgICAgIChtX2RhdGEtPm1fZGMKKyAgICAgICAgICAgICAgICAgICAgLCBz dGFibGVSb3VuZCh0clNoYWRvd1BvaW50LngoKSkKKyAgICAgICAgICAgICAgICAgICAgLCBzdGFi bGVSb3VuZCh0clNoYWRvd1BvaW50LnkoKSkKKyAgICAgICAgICAgICAgICAgICAgLCAwCisgICAg ICAgICAgICAgICAgICAgICwgTlVMTAorICAgICAgICAgICAgICAgICAgICAsICZjCisgICAgICAg ICAgICAgICAgICAgICwgMQorICAgICAgICAgICAgICAgICAgICAsIDAKKyAgICAgICAgICAgICAg ICAgICAgKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIFNldFRleHRDb2xvcihtX2RhdGEt Pm1fZGMsIGZvbnRDb2xvcik7CisgICAgICAgICAgICBFeHRUZXh0T3V0CisgICAgICAgICAgICAg ICAgKG1fZGF0YS0+bV9kYworICAgICAgICAgICAgICAgICwgc3RhYmxlUm91bmQodHJQb2ludC54 KCkpCisgICAgICAgICAgICAgICAgLCB5CisgICAgICAgICAgICAgICAgLCAwCisgICAgICAgICAg ICAgICAgLCBOVUxMCisgICAgICAgICAgICAgICAgLCAmYworICAgICAgICAgICAgICAgICwgMQor ICAgICAgICAgICAgICAgICwgMAorICAgICAgICAgICAgICAgICk7CisgICAgICAgIH0KKworICAg ICAgICBTZXRUZXh0QWxpZ24obV9kYXRhLT5tX2RjLCBvbGRUZXh0QWxpZ24pOworICAgICAgICBT ZXRUZXh0Q29sb3IobV9kYXRhLT5tX2RjLCBvbGRUZXh0Q29sb3IpOworICAgICAgICBTZXRCa01v ZGUobV9kYXRhLT5tX2RjLCBvbGRCa01vZGUpOworICAgICAgICBTZWxlY3RPYmplY3QobV9kYXRh LT5tX2RjLCBoT2xkRm9udCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgZG91YmxlIG9mZnNldCA9 IHRyUG9pbnQueCgpOworICAgICAgICBjb25zdCBHbHlwaEJ1ZmZlckFkdmFuY2UqIGFkdmFuY2Ug PSBnbHlwaEJ1ZmZlci5hZHZhbmNlRGF0YSgpICsgZnJvbTsKKyAgICAgICAgaWYgKHNjYWxlWCA9 PSAxLikKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSAxOyBpIDwgbnVtR2x5cGhzOyArK2kpCisg ICAgICAgICAgICAgICAgb2Zmc2V0ICs9ICphZHZhbmNlKys7CisgICAgICAgIGVsc2UKKyAgICAg ICAgICAgIGZvciAoaW50IGkgPSAxOyBpIDwgbnVtR2x5cGhzOyArK2kpCisgICAgICAgICAgICAg ICAgb2Zmc2V0ICs9ICphZHZhbmNlKysgKiBzY2FsZVg7CisKKyAgICAgICAgb2Zmc2V0ICs9IHdp ZHRoOworCisgICAgICAgIE93blB0cjxIUEVOPiBoUGVuKENyZWF0ZVBlbihQU19EQVNILCAxLCBm b250Q29sb3IpKTsKKyAgICAgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QobV9kYXRh LT5tX2RjLCBoUGVuLmdldCgpKTsKKworICAgICAgICBNb3ZlVG9FeChtX2RhdGEtPm1fZGMsIHN0 YWJsZVJvdW5kKHRyUG9pbnQueCgpKSwgeSwgMCk7CisgICAgICAgIExpbmVUbyhtX2RhdGEtPm1f ZGMsIHN0YWJsZVJvdW5kKG9mZnNldCksIHkpOworCisgICAgICAgIFNlbGVjdE9iamVjdChtX2Rh dGEtPm1fZGMsIG9sZFBlbik7CisgICAgfQorfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJh d0ZyYW1lQ29udHJvbChjb25zdCBJbnRSZWN0JiByZWN0LCB1bnNpZ25lZCB0eXBlLCB1bnNpZ25l ZCBzdGF0ZSkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47 CisKKyAgICBjb25zdCBpbnQgYm94V2lkdGhCZXN0ID0gODsKKyAgICBjb25zdCBpbnQgYm94SGVp Z2h0QmVzdCA9IDg7CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOwor ICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRy UmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJh bnNwYXJlbnREYyhtX2RhdGEsIHRyUmVjdCwgJnJlY3QsIDI1NSwgdHJ1ZSk7CisgICAgSERDIGRj ID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47Cisg ICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworCisgICAgUkVDVCByZWN0 V2luID0gdHJSZWN0OworCisgICAgaWYgKChyZWN0V2luLnJpZ2h0IC0gcmVjdFdpbi5sZWZ0KSA8 IGJveFdpZHRoQmVzdCkgeworICAgICAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBibXAxID0gU2hh cmVkQml0bWFwOjpjcmVhdGVJbnN0YW5jZSh0cnVlLCBib3hXaWR0aEJlc3QsIGJveEhlaWdodEJl c3QsIHRydWUpOworICAgICAgICBTaGFyZWRCaXRtYXA6OkRDSG9sZGVyIGRjMShibXAxLmdldCgp KTsKKyAgICAgICAgaWYgKGRjMS5nZXQoKSkgeworICAgICAgICAgICAgUkVDVCB0ZW1wUmVjdCA9 IHswLCAwLCBib3hXaWR0aEJlc3QsIGJveEhlaWdodEJlc3R9OworICAgICAgICAgICAgRHJhd0Zy YW1lQ29udHJvbChkYzEuZ2V0KCksICZ0ZW1wUmVjdCwgdHlwZSwgc3RhdGUpOworCisgICAgICAg ICAgICA6OlN0cmV0Y2hCbHQoZGMsIHJlY3RXaW4ubGVmdCwgcmVjdFdpbi50b3AsIHJlY3RXaW4u cmlnaHQgLSByZWN0V2luLmxlZnQsIHJlY3RXaW4uYm90dG9tIC0gcmVjdFdpbi50b3AsCisgICAg ICAgICAgICAgICAgZGMxLmdldCgpLCAwLCAwLCBib3hXaWR0aEJlc3QsIGJveEhlaWdodEJlc3Qs IFNSQ0NPUFkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAg RHJhd0ZyYW1lQ29udHJvbChkYywgJnJlY3RXaW4sIHR5cGUsIHN0YXRlKTsKK30KKwordm9pZCBH cmFwaGljc0NvbnRleHQ6OmRyYXdGb2N1c1JlY3QoY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAg ICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURD UHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAg ICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0 KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIHRyUmVjdCwg JnJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFkYykK KyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50RGMudG9TaGlmdCgp KTsKKworICAgIFJFQ1QgcmVjdFdpbiA9IHRyUmVjdDsKKyAgICBEcmF3Rm9jdXNSZWN0KGRjLCAm cmVjdFdpbik7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpwYWludFRleHRGaWVsZChjb25z dCBJbnRSZWN0JiByZWN0LCB1bnNpZ25lZCBzdGF0ZSkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9v cGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRl cihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAg ICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0KTsKKyAgICBUcmFuc3BhcmVu dExheWVyREMgdHJhbnNwYXJlbnREYyhtX2RhdGEsIHRyUmVjdCwgJnJlY3QpOworICAgIEhEQyBk YyA9IHRyYW5zcGFyZW50RGMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOwor ICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50RGMudG9TaGlmdCgpKTsKKworICAgIFJFQ1QgcmVj dFdpbiA9IHRyUmVjdDsKKyAgICBEcmF3RWRnZShkYywgJnJlY3RXaW4sIEVER0VfRVRDSEVELCBC Rl9SRUNUIHwgQkZfQURKVVNUKTsKKyAgICBGaWxsUmVjdChkYywgJnJlY3RXaW4sIHJlaW50ZXJw cmV0X2Nhc3Q8SEJSVVNIPigoKHN0YXRlICYgREZDU19JTkFDVElWRSkgPyBDT0xPUl9CVE5GQUNF IDogQ09MT1JfV0lORE9XKSArIDEpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdC aXRtYXAoU2hhcmVkQml0bWFwKiBibXAsIGNvbnN0IEludFJlY3QmIGRzdFJlY3RJbiwgY29uc3Qg SW50UmVjdCYgc3JjUmVjdCwgQ29tcG9zaXRlT3BlcmF0b3IgY29tcG9zaXRlT3ApCit7CisgICAg aWYgKCFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1By b3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAg ICAgcmV0dXJuOworCisgICAgSW50UmVjdCBkc3RSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KGRzdFJl Y3RJbik7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50RGMobV9kYXRhLCBkc3RS ZWN0LCAmZHN0UmVjdEluLCAyNTUsIHRydWUpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50RGMu aGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIGRzdFJlY3QubW92ZSh0 cmFuc3BhcmVudERjLnRvU2hpZnQoKSk7CisKKyAgICBibXAtPmRyYXcoZGMsIGRzdFJlY3QsIHNy Y1JlY3QsIGNvbXBvc2l0ZU9wKTsKKworICAgIGlmIChibXAtPmlzMTZiaXQoKSkKKyAgICAgICAg dHJhbnNwYXJlbnREYy5maWxsQWxwaGFDaGFubmVsKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250 ZXh0OjpkcmF3Qml0bWFwUGF0dGVybihTaGFyZWRCaXRtYXAqIGJtcCwgY29uc3QgRmxvYXRSZWN0 JiB0aWxlUmVjdEluLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGF0dGVyblRyYW5zZm9y bSwKKyAgICAgICAgICAgICAgICBjb25zdCBGbG9hdFBvaW50JiBwaGFzZSwgQ29tcG9zaXRlT3Bl cmF0b3Igb3AsIGNvbnN0IEZsb2F0UmVjdCYgZGVzdFJlY3RJbiwgY29uc3QgSW50U2l6ZSYgb3Jp Z1NvdXJjZVNpemUpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAo IW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCBpbnREc3RSZWN0 ID0gZW5jbG9zaW5nSW50UmVjdChkZXN0UmVjdEluKTsKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1f ZGF0YS0+bWFwUmVjdChpbnREc3RSZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNw YXJlbnREYyhtX2RhdGEsIHRyUmVjdCwgJmludERzdFJlY3QsIDI1NSwgdHJ1ZSk7CisgICAgSERD IGRjID0gdHJhbnNwYXJlbnREYy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47 CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworICAgIEZsb2F0UmVj dCBtb3ZlZERzdFJlY3QgPSBtX2RhdGEtPm1fdHJhbnNmb3JtLmludmVyc2UoKS5tYXBSZWN0KEZs b2F0UmVjdCh0clJlY3QpKTsKKyAgICBGbG9hdFNpemUgbW92ZWQobW92ZWREc3RSZWN0LmxvY2F0 aW9uKCkgLSBkZXN0UmVjdEluLmxvY2F0aW9uKCkpOworICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4 IHRyYW5zZm9ybSA9IG1fZGF0YS0+bV90cmFuc2Zvcm07CisgICAgdHJhbnNmb3JtLnRyYW5zbGF0 ZShtb3ZlZC53aWR0aCgpLCBtb3ZlZC5oZWlnaHQoKSk7CisKKyAgICBibXAtPmRyYXdQYXR0ZXJu KGRjLCB0cmFuc2Zvcm0sIHRpbGVSZWN0SW4sIHBhdHRlcm5UcmFuc2Zvcm0sIHBoYXNlLCBvcCwg ZGVzdFJlY3RJbiwgb3JpZ1NvdXJjZVNpemUpOworCisgICAgaWYgKCFibXAtPmhhc0FscGhhKCkp CisgICAgICAgIHRyYW5zcGFyZW50RGMuZmlsbEFscGhhQ2hhbm5lbCgpOworfQorCit2b2lkIEdy YXBoaWNzQ29udGV4dDo6ZHJhd0ljb24oSElDT04gaWNvbiwgY29uc3QgSW50UmVjdCYgZHN0UmVj dEluLCBVSU5UIGZsYWdzKQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAg IHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAg aWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgZHN0UmVj dCA9IG1fZGF0YS0+bWFwUmVjdChkc3RSZWN0SW4pOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0 cmFuc3BhcmVudERjKG1fZGF0YSwgZHN0UmVjdCwgJmRzdFJlY3RJbiwgMjU1LCB0cnVlKTsKKyAg ICBIREMgZGMgPSB0cmFuc3BhcmVudERjLmhkYygpOworICAgIGlmICghZGMpCisgICAgICAgIHJl dHVybjsKKyAgICBkc3RSZWN0Lm1vdmUodHJhbnNwYXJlbnREYy50b1NoaWZ0KCkpOworCisJRHJh d0ljb25FeChkYywgZHN0UmVjdC54KCksIGRzdFJlY3QueSgpLCBpY29uLCBkc3RSZWN0LndpZHRo KCksIGRzdFJlY3QuaGVpZ2h0KCksIDAsIE5VTEwsIGZsYWdzKTsKK30KKwordm9pZCBHcmFwaGlj c0NvbnRleHQ6OnNldFBsYXRmb3JtU2hvdWxkQW50aWFsaWFzKGJvb2wgc2hvdWxkKQoreworICAg ICh2b2lkKXNob3VsZDsKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6c2V0TGluZURhc2goY29uc3QgRGFzaEFycmF5JiwgZmxvYXQgZGFzaE9mZnNldCkK K3sKKyAgICAodm9pZClkYXNoT2Zmc2V0OworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwUGF0aChXaW5kUnVsZSkKK3sKKyAgICBub3RJbXBsZW1l bnRlZCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCg== 33098 2009-07-20 12:10:40 -0700 2009-07-20 12:46:16 -0700 more modifications for coding style 27349.patch text/plain 59964 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg OWUwYTJiZC4uYzA1NDhmNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wNy0yMCAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y NzM0OQorICAgICAgICBBZGQgR3JhcGhpY3NDb250ZXh0IGltcGxlbWVudGF0aW9uIGZvciB0aGUg V2luQ0UgcG9ydC4KKworICAgICAgICBXcml0dGVuIGJ5IFlvbmcgTGkgPHlvbmcubGlAdG9yY2ht b2JpbGUuY29tPiwgR2VvcmdlIFN0YWlrb3MgPGdlb3JnZS5zdGFpa29zQHRvcmNobW9iaWxlLmNv bT4gYW5kIEx5b24gQ2hlbiA8bHlvbi5jaGVuQHRvcmNobW9iaWxlLmNvbT4KKyAgICAgICAgd2l0 aCB0cml2aWFsIHN0eWxlIGZpeGVzIGJ5IEFkYW0gVHJlYXQgPGFkYW0udHJlYXRAdG9yY2htb2Jp bGUuY29tPgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250 ZXh0V2luY2UuY3BwOiBBZGRlZC4gCisKIDIwMDktMDctMjAgIER1bWl0cnUgRGFuaWxpdWMgIDxk dW1pQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEaW1pdHJpIEdsYXprb3Yu CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBoaWNzQ29u dGV4dFdpbmNlLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3ND b250ZXh0V2luY2UuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQzYTNl MzAKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dy YXBoaWNzQ29udGV4dFdpbmNlLmNwcApAQCAtMCwwICsxLDE4MzkgQEAKKy8qCisgKiAgQ29weXJp Z2h0IChDKSAyMDA3LTIwMDkgVG9yY2ggTW9iaWxlIEluYy4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj CisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv bjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRp b24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGgg Rmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKworI2luY2x1ZGUg IkNoYXJhY3Rlck5hbWVzLmgiCisjaW5jbHVkZSAiR2x5cGhCdWZmZXIuaCIKKyNpbmNsdWRlICJH cmFkaWVudC5oIgorI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dFByaXZhdGUuaCIKKyNpbmNsdWRl ICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIlBhdGguaCIKKyNpbmNsdWRlICJQbGF0Zm9y bVBhdGhXaW5jZS5oIgorI2luY2x1ZGUgIlNoYXJlZEJpdG1hcC5oIgorI2luY2x1ZGUgIlNpbXBs ZUZvbnREYXRhLmgiCisjaW5jbHVkZSAiVHJhbnNmb3JtYXRpb25NYXRyaXguaCIKKyNpbmNsdWRl ICJ3dGYvT3duUHRyLmgiCisKKyNpbmNsdWRlIDx3aW5kb3dzLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKwordHlwZWRlZiB2b2lkICgqRnVuY0dyYWRpZW50RmlsbFJlY3RMaW5lYXIpKEhEQyBo ZGMsIGNvbnN0IEludFJlY3QmIHIsIGNvbnN0IEludFBvaW50JiBwMCwgY29uc3QgSW50UG9pbnQm IHAxLCBjb25zdCBWZWN0b3I8R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzKTsKK3R5cGVkZWYg dm9pZCAoKkZ1bmNHcmFkaWVudEZpbGxSZWN0UmFkaWFsKShIREMgaGRjLCBjb25zdCBJbnRSZWN0 JiByLCBjb25zdCBJbnRQb2ludCYgcDAsIGNvbnN0IEludFBvaW50JiBwMSwgZmxvYXQgcjAsIGZs b2F0IHIxLCBjb25zdCBWZWN0b3I8R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzKTsKK0Z1bmNH cmFkaWVudEZpbGxSZWN0TGluZWFyIGdfbGluZWFyR3JhZGllbnRGaWxsZXIgPSAwOworRnVuY0dy YWRpZW50RmlsbFJlY3RSYWRpYWwgZ19yYWRpYWxHcmFkaWVudEZpbGxlciA9IDA7CisKK3N0YXRp YyBpbmxpbmUgYm9vbCBpc1plcm8oZG91YmxlIGQpCit7CisgICAgcmV0dXJuIGQgPiAwID8gZCA8 PSAxLkUtMTAgOiBkID49IC0xLkUtMTA7Cit9CisKKy8vIHN0YWJsZVJvdW5kIHJvdW5kcyAtMC41 IHRvIDAsIHdoZXJlIGxyb3VuZCByb3VuZHMgLTAuNSB0byAtMS4KK3N0YXRpYyBpbmxpbmUgaW50 IHN0YWJsZVJvdW5kKGRvdWJsZSBkKQoreworICAgIGlmIChkID4gMCkKKyAgICAgICAgcmV0dXJu IHN0YXRpY19jYXN0PGludD4oZCArIDAuNSk7CisKKyAgICBpbnQgaSA9IHN0YXRpY19jYXN0PGlu dD4oZCk7CisgICAgcmV0dXJuIGkgLSBkID4gMC41ID8gaSAtIDEgOiBpOworfQorCisvLyBVbmxp a2UgZW5jbG9zaW5nSW50UmVjdCgpLCB0aGlzIGZ1bmN0aW9uIGRvZXMgc3RyaWN0IHJvdW5kaW5n Lgorc3RhdGljIGlubGluZSBJbnRSZWN0IHJvdW5kUmVjdChjb25zdCBGbG9hdFJlY3QmIHIpCit7 CisgICAgcmV0dXJuIEludFJlY3Qoc3RhYmxlUm91bmQoci54KCkpLCBzdGFibGVSb3VuZChyLnko KSksIHN0YWJsZVJvdW5kKHIucmlnaHQoKSkgLSBzdGFibGVSb3VuZChyLngoKSksIHN0YWJsZVJv dW5kKHIuYm90dG9tKCkpIC0gc3RhYmxlUm91bmQoci55KCkpKTsKK30KKworLy8gUm90YXRpb24g dHJhbnNmb3JtYXRpb24KK2NsYXNzIFJvdGF0aW9uVHJhbnNmb3JtIHsKK3B1YmxpYzoKKyAgICBS b3RhdGlvblRyYW5zZm9ybSgpCisgICAgICAgIDogbV9jb3NBKDEuKQorICAgICAgICAsIG1fc2lu QSgwLikKKyAgICAgICAgLCBtX3ByZVNoaWZ0WCgwKQorICAgICAgICAsIG1fcHJlU2hpZnRZKDAp CisgICAgICAgICwgbV9wb3N0U2hpZnRYKDApCisgICAgICAgICwgbV9wb3N0U2hpZnRZKDApCisg ICAgeworICAgIH0KKyAgICBSb3RhdGlvblRyYW5zZm9ybSBvcGVyYXRvci0oKSBjb25zdAorICAg IHsKKyAgICAgICAgUm90YXRpb25UcmFuc2Zvcm0gcnRuOworICAgICAgICBydG4ubV9jb3NBID0g bV9jb3NBOworICAgICAgICBydG4ubV9zaW5BID0gLW1fc2luQTsKKyAgICAgICAgcnRuLm1fcHJl U2hpZnRYID0gbV9wb3N0U2hpZnRYOworICAgICAgICBydG4ubV9wcmVTaGlmdFkgPSBtX3Bvc3RT aGlmdFk7CisgICAgICAgIHJ0bi5tX3Bvc3RTaGlmdFggPSBtX3ByZVNoaWZ0WDsKKyAgICAgICAg cnRuLm1fcG9zdFNoaWZ0WSA9IG1fcHJlU2hpZnRZOworICAgICAgICByZXR1cm4gcnRuOworICAg IH0KKyAgICB2b2lkIG1hcChkb3VibGUgeDEsIGRvdWJsZSB5MSwgZG91YmxlKiB4MiwgZG91Ymxl KiB5MikgY29uc3QKKyAgICB7CisgICAgICAgIHgxICs9IG1fcHJlU2hpZnRYOworICAgICAgICB5 MSArPSBtX3ByZVNoaWZ0WTsKKyAgICAgICAgKngyID0geDEgKiBtX2Nvc0EgKyB5MSAqIG1fc2lu QSArIG1fcG9zdFNoaWZ0WDsKKyAgICAgICAgKnkyID0geTEgKiBtX2Nvc0EgLSB4MSAqIG1fc2lu QSArIG1fcG9zdFNoaWZ0WTsKKyAgICB9CisgICAgdm9pZCBtYXAoaW50IHgxLCBpbnQgeTEsIGlu dCogeDIsIGludCogeTIpIGNvbnN0CisgICAgeworICAgICAgICB4MSArPSBtX3ByZVNoaWZ0WDsK KyAgICAgICAgeTEgKz0gbV9wcmVTaGlmdFk7CisgICAgICAgICp4MiA9IHN0YWJsZVJvdW5kKHgx ICogbV9jb3NBICsgeTEgKiBtX3NpbkEpICsgbV9wb3N0U2hpZnRYOworICAgICAgICAqeTIgPSBz dGFibGVSb3VuZCh5MSAqIG1fY29zQSAtIHgxICogbV9zaW5BKSArIG1fcG9zdFNoaWZ0WTsKKyAg ICB9CisKKyAgICBkb3VibGUgbV9jb3NBOworICAgIGRvdWJsZSBtX3NpbkE7CisgICAgaW50IG1f cHJlU2hpZnRYOworICAgIGludCBtX3ByZVNoaWZ0WTsKKyAgICBpbnQgbV9wb3N0U2hpZnRYOwor ICAgIGludCBtX3Bvc3RTaGlmdFk7Cit9OworCit0ZW1wbGF0ZTxjbGFzcyBUPiBzdGF0aWMgaW5s aW5lIEludFBvaW50IG1hcFBvaW50KGNvbnN0IEludFBvaW50JiBwLCBjb25zdCBUJiB0KQorewor ICAgIGludCB4LCB5OworICAgIHQubWFwKHAueCgpLCBwLnkoKSwgJngsICZ5KTsKKyAgICByZXR1 cm4gSW50UG9pbnQoeCwgeSk7Cit9CisKK3RlbXBsYXRlPGNsYXNzIFQ+IHN0YXRpYyBpbmxpbmUg RmxvYXRQb2ludCBtYXBQb2ludChjb25zdCBGbG9hdFBvaW50JiBwLCBjb25zdCBUJiB0KQorewor ICAgIGRvdWJsZSB4LCB5OworICAgIHQubWFwKHAueCgpLCBwLnkoKSwgJngsICZ5KTsKKyAgICBy ZXR1cm4gRmxvYXRQb2ludChzdGF0aWNfY2FzdDxmbG9hdD4oeCksIHN0YXRpY19jYXN0PGZsb2F0 Pih5KSk7Cit9CisKK3RlbXBsYXRlPGNsYXNzIFRyYW5zZm9ybSwgY2xhc3MgUmVjdCwgY2xhc3Mg VmFsdWU+IHN0YXRpYyBpbmxpbmUgUmVjdCBtYXBSZWN0KGNvbnN0IFJlY3QmIHJlY3QsIGNvbnN0 IFRyYW5zZm9ybSYgdHJhbnNmb3JtKQoreworICAgIFZhbHVlIHhbNF0sIHlbNF07CisgICAgVmFs dWUgbCwgdCwgciwgYjsKKyAgICByID0gcmVjdC5yaWdodCgpIC0gMTsKKyAgICBiID0gcmVjdC5i b3R0b20oKSAtIDE7CisgICAgdHJhbnNmb3JtLm1hcChyZWN0LngoKSwgcmVjdC55KCksIHgsIHkp OworICAgIHRyYW5zZm9ybS5tYXAocmVjdC54KCksIGIsIHggKyAxLCB5ICsgMSk7CisgICAgdHJh bnNmb3JtLm1hcChyLCBiLCB4ICsgMiwgeSArIDIpOworICAgIHRyYW5zZm9ybS5tYXAociwgcmVj dC55KCksIHggKyAzLCB5ICsgMyk7CisgICAgbCA9IHIgPSB4WzNdOworICAgIHQgPSBiID0geVsz XTsKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IDM7ICsraSkgeworICAgICAgICBpZiAoeFtpXSA8 IGwpCisgICAgICAgICAgICBsID0geFtpXTsKKyAgICAgICAgZWxzZSBpZiAoeFtpXSA+IHIpCisg ICAgICAgICAgICByID0geFtpXTsKKworICAgICAgICBpZiAoeVtpXSA8IHQpCisgICAgICAgICAg ICB0ID0geVtpXTsKKyAgICAgICAgZWxzZSBpZiAoeVtpXSA+IGIpCisgICAgICAgICAgICBiID0g eVtpXTsKKyAgICB9CisKKyAgICByZXR1cm4gSW50UmVjdChsLCB0LCByIC0gbCArIDEsIGIgLSB0 ICsgMSk7Cit9CisKK3RlbXBsYXRlPGNsYXNzIFQ+IHN0YXRpYyBpbmxpbmUgSW50UmVjdCBtYXBS ZWN0KGNvbnN0IEludFJlY3QmIHJlY3QsIGNvbnN0IFQmIHRyYW5zZm9ybSkKK3sKKyAgICByZXR1 cm4gbWFwUmVjdDxULCBJbnRSZWN0LCBpbnQ+KHJlY3QsIHRyYW5zZm9ybSk7Cit9CisKK3RlbXBs YXRlPGNsYXNzIFQ+IHN0YXRpYyBpbmxpbmUgRmxvYXRSZWN0IG1hcFJlY3QoY29uc3QgRmxvYXRS ZWN0JiByZWN0LCBjb25zdCBUJiB0cmFuc2Zvcm0pCit7CisgICAgcmV0dXJuIG1hcFJlY3Q8VCwg RmxvYXRSZWN0LCBkb3VibGU+KHJlY3QsIHRyYW5zZm9ybSk7Cit9CisKK2NsYXNzIEdyYXBoaWNz Q29udGV4dFBsYXRmb3JtUHJpdmF0ZURhdGEgeworcHVibGljOgorICAgIEdyYXBoaWNzQ29udGV4 dFBsYXRmb3JtUHJpdmF0ZURhdGEoKQorICAgICAgICA6IG1fdHJhbnNmb3JtKCkKKyAgICAgICAg LCBtX29wYWNpdHkoMS4wKQorICAgIHsKKyAgICB9CisKKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJp eCBtX3RyYW5zZm9ybTsKKyAgICBmbG9hdCBtX29wYWNpdHk7CisgICAgVmVjdG9yPFBhdGg+IG1f cGF0aHM7Cit9OworCitlbnVtIEFscGhhUGFpbnRUeXBlIHsKKyAgICBBbHBoYVBhaW50Tm9uZSwK KyAgICBBbHBoYVBhaW50SW1hZ2UsCisgICAgQWxwaGFQYWludE90aGVyLAorfTsKKworY2xhc3Mg R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlIDogcHVibGljIEdyYXBoaWNzQ29udGV4dFBs YXRmb3JtUHJpdmF0ZURhdGEgeworcHVibGljOgorICAgIEdyYXBoaWNzQ29udGV4dFBsYXRmb3Jt UHJpdmF0ZShIREMgZGMpCisgICAgICAgIDogbV9kYyhkYykKKyAgICB7CisgICAgfQorICAgIH5H cmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGUoKQorICAgIHsKKyAgICAgICAgd2hpbGUgKCFt X2JhY2t1cERhdGEuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmVzdG9yZSgpOworICAgIH0KKwor ICAgIEludFBvaW50IG9yaWdpbigpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gSW50UG9p bnQoc3RhYmxlUm91bmQoLW1fdHJhbnNmb3JtLmUoKSksIHN0YWJsZVJvdW5kKC1tX3RyYW5zZm9y bS5mKCkpKTsKKyAgICB9CisKKyAgICB2b2lkIHRyYW5zbGF0ZShmbG9hdCB4LCBmbG9hdCB5KQor ICAgIHsKKyAgICAgICAgbV90cmFuc2Zvcm0udHJhbnNsYXRlKHgsIHkpOworICAgIH0KKworICAg IHZvaWQgc2NhbGUoY29uc3QgRmxvYXRTaXplJiBzaXplKQorICAgIHsKKyAgICAgICAgbV90cmFu c2Zvcm0uc2NhbGVOb25Vbmlmb3JtKHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSk7CisgICAg fQorCisgICAgdm9pZCByb3RhdGUoZmxvYXQgcmFkaWFucykKKyAgICB7CisgICAgICAgIG1fdHJh bnNmb3JtLnJvdGF0ZShyYWQyZGVnKHJhZGlhbnMpKTsKKyAgICB9CisKKyAgICB2b2lkICBjb25j YXRDVE0oY29uc3QgVHJhbnNmb3JtYXRpb25NYXRyaXgmIHRyYW5zZm9ybSkKKyAgICB7CisgICAg ICAgIG1fdHJhbnNmb3JtID0gdHJhbnNmb3JtICogbV90cmFuc2Zvcm07CisgICAgfQorCisgICAg SW50UmVjdCBtYXBSZWN0KGNvbnN0IEludFJlY3QmIHJlY3QpIGNvbnN0CisgICAgeworICAgICAg ICByZXR1cm4gbV90cmFuc2Zvcm0ubWFwUmVjdChyZWN0KTsKKyAgICB9CisKKyAgICBGbG9hdFJl Y3QgbWFwUmVjdChjb25zdCBGbG9hdFJlY3QmIHJlY3QpIGNvbnN0CisgICAgeworICAgICAgICBy ZXR1cm4gbV90cmFuc2Zvcm0ubWFwUmVjdChyZWN0KTsKKyAgICB9CisKKyAgICBJbnRQb2ludCBt YXBQb2ludChjb25zdCBJbnRQb2ludCYgcG9pbnQpIGNvbnN0CisgICAgeworICAgICAgICByZXR1 cm4gbV90cmFuc2Zvcm0ubWFwUG9pbnQocG9pbnQpOworICAgIH0KKworICAgIEZsb2F0UG9pbnQg bWFwUG9pbnQoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpIGNvbnN0CisgICAgeworICAgICAgICBy ZXR1cm4gbV90cmFuc2Zvcm0ubWFwUG9pbnQocG9pbnQpOworICAgIH0KKworICAgIEZsb2F0U2l6 ZSBtYXBTaXplKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkgY29uc3QKKyAgICB7CisgICAgICAgIGRv dWJsZSB3LCBoOworICAgICAgICBtX3RyYW5zZm9ybS5tYXAoc2l6ZS53aWR0aCgpLCBzaXplLmhl aWdodCgpLCB3LCBoKTsKKyAgICAgICAgcmV0dXJuIEZsb2F0U2l6ZShzdGF0aWNfY2FzdDxmbG9h dD4odyksIHN0YXRpY19jYXN0PGZsb2F0PihoKSk7CisgICAgfQorCisgICAgdm9pZCBzYXZlKCkK KyAgICB7CisgICAgICAgIGlmIChtX2RjKQorICAgICAgICAgICAgU2F2ZURDKG1fZGMpOworCisg ICAgICAgIG1fYmFja3VwRGF0YS5hcHBlbmQoKnN0YXRpY19jYXN0PEdyYXBoaWNzQ29udGV4dFBs YXRmb3JtUHJpdmF0ZURhdGEqPih0aGlzKSk7CisgICAgfQorCisgICAgdm9pZCByZXN0b3JlKCkK KyAgICB7CisgICAgICAgIGlmIChtX2JhY2t1cERhdGEuaXNFbXB0eSgpKQorICAgICAgICAgICAg cmV0dXJuOworCisgICAgICAgIGlmIChtX2RjKQorICAgICAgICAgICAgUmVzdG9yZURDKG1fZGMs IC0xKTsKKworICAgICAgICBHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGVEYXRhOjpvcGVy YXRvcj0obV9iYWNrdXBEYXRhLmxhc3QoKSk7CisgICAgICAgIG1fYmFja3VwRGF0YS5yZW1vdmVM YXN0KCk7CisgICAgfQorCisgICAgYm9vbCBoYXNBbHBoYSgpIGNvbnN0IHsgcmV0dXJuIG1fYml0 bWFwICYmIG1fYml0bWFwLT5oYXNBbHBoYSgpOyB9CisKKyAgICBQYXNzUmVmUHRyPFNoYXJlZEJp dG1hcD4gZ2V0VHJhbnNwYXJlbnRMYXllckJpdG1hcChJbnRSZWN0JiBvcmlnUmVjdCwgQWxwaGFQ YWludFR5cGUgYWxwaGFQYWludCwgUkVDVCYgYm1wUmVjdCwgYm9vbCBjaGVja0NsaXBCb3gsIGJv b2wgZm9yY2UpIGNvbnN0CisgICAgeworICAgICAgICBpZiAobV9vcGFjaXR5IDw9IDApCisgICAg ICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBpZiAoZm9yY2UgfHwgbV9vcGFjaXR5IDwgMS4p ICB7CisgICAgICAgICAgICBpZiAoY2hlY2tDbGlwQm94KSB7CisgICAgICAgICAgICAgICAgUkVD VCBjbGlwQm94OworICAgICAgICAgICAgICAgIGludCBjbGlwVHlwZSA9IEdldENsaXBCb3gobV9k YywgJmNsaXBCb3gpOworICAgICAgICAgICAgICAgIGlmIChjbGlwVHlwZSA9PSBTSU1QTEVSRUdJ T04gfHwgY2xpcFR5cGUgPT0gQ09NUExFWFJFR0lPTikKKyAgICAgICAgICAgICAgICAgICAgb3Jp Z1JlY3QuaW50ZXJzZWN0KGNsaXBCb3gpOworICAgICAgICAgICAgICAgIGlmIChvcmlnUmVjdC5p c0VtcHR5KCkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgfQor CisgICAgICAgICAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBibXAgPSBTaGFyZWRCaXRtYXA6OmNy ZWF0ZUluc3RhbmNlKGFscGhhUGFpbnQgPT0gQWxwaGFQYWludE5vbmUsIG9yaWdSZWN0LndpZHRo KCksIG9yaWdSZWN0LmhlaWdodCgpLCBmYWxzZSk7CisgICAgICAgICAgICBTZXRSZWN0KCZibXBS ZWN0LCAwLCAwLCBvcmlnUmVjdC53aWR0aCgpLCBvcmlnUmVjdC5oZWlnaHQoKSk7CisgICAgICAg ICAgICBpZiAoYm1wKSB7CisgICAgICAgICAgICAgICAgc3dpdGNoIChhbHBoYVBhaW50KSB7Cisg ICAgICAgICAgICAgICAgY2FzZSBBbHBoYVBhaW50Tm9uZToKKyAgICAgICAgICAgICAgICBjYXNl IEFscGhhUGFpbnRJbWFnZToKKyAgICAgICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAg ICAgICAgICAgU2hhcmVkQml0bWFwOjpEQ0hvbGRlciBkYyhibXAuZ2V0KCkpOworICAgICAgICAg ICAgICAgICAgICAgICAgaWYgKGRjLmdldCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgQml0Qmx0KGRjLmdldCgpLCAwLCAwLCBvcmlnUmVjdC53aWR0aCgpLCBvcmlnUmVjdC5oZWln aHQoKSwgbV9kYywgb3JpZ1JlY3QueCgpLCBvcmlnUmVjdC55KCksIFNSQ0NPUFkpOworICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGlmIChibXAtPmlzMzJiaXQoKSAmJiAoIW1fYml0bWFwIHx8 IG1fYml0bWFwLT5pczE2Yml0KCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC8vIFNldCBhbHBoYSBjaGFubmVsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVu c2lnbmVkKiBwaXhlbHMgPSAodW5zaWduZWQqKWJtcC0+Ynl0ZXMoKTsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgY29uc3QgdW5zaWduZWQqIGNvbnN0IHBpeGVsc0VuZCA9IHBpeGVs cyArIGJtcC0+Yml0bWFwSW5mbygpLm51bVBpeGVscygpOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB3aGlsZSAocGl4ZWxzIDwgcGl4ZWxzRW5kKSB7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAqcGl4ZWxzIHw9IDB4RkYwMDAwMDA7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICArK3BpeGVsczsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gYm1wOworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAg ICAgICAgIC8vY2FzZSBBbHBoYVBhaW50T3RoZXI6CisgICAgICAgICAgICAgICAgZGVmYXVsdDoK KyAgICAgICAgICAgICAgICAgICAgbWVtc2V0KGJtcC0+Ynl0ZXMoKSwgMHhGRiwgYm1wLT5iaXRt YXBJbmZvKCkubnVtUGl4ZWxzKCkgKiA0KTsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJt cDsKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAg ICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgYm1wUmVjdCA9IG9yaWdSZWN0OworICAgICAg ICByZXR1cm4gMDsKKyAgICB9CisKKyAgICB2b2lkIHBhaW50QmFja1RyYW5zcGFyZW50TGF5ZXJC aXRtYXAoSERDIGhkYywgU2hhcmVkQml0bWFwKiBibXAsIGNvbnN0IEludFJlY3QmIG9yaWdSZWN0 LCBBbHBoYVBhaW50VHlwZSBhbHBoYVBhaW50LCBjb25zdCBSRUNUJiBibXBSZWN0KQorICAgIHsK KyAgICAgICAgaWYgKGhkYyA9PSBtX2RjKQorICAgICAgICAgICAgcmV0dXJuOworCisjaWYgIWRl ZmluZWQoTk9fQUxQSEFCTEVORCkKKyAgICAgICAgaWYgKGFscGhhUGFpbnQgPT0gQWxwaGFQYWlu dE90aGVyKSB7CisgICAgICAgICAgICBBU1NFUlQoYm1wICYmIGJtcC0+Ynl0ZXMoKSAmJiBibXAt PmlzMzJiaXQoKSk7CisgICAgICAgICAgICB1bnNpZ25lZCogcGl4ZWxzID0gKHVuc2lnbmVkKili bXAtPmJ5dGVzKCk7CisgICAgICAgICAgICBjb25zdCB1bnNpZ25lZCogY29uc3QgcGl4ZWxzRW5k ID0gcGl4ZWxzICsgYm1wLT5iaXRtYXBJbmZvKCkubnVtUGl4ZWxzKCk7CisgICAgICAgICAgICB3 aGlsZSAocGl4ZWxzIDwgcGl4ZWxzRW5kKSB7CisgICAgICAgICAgICAgICAgKnBpeGVscyBePSAw eEZGMDAwMDAwOworICAgICAgICAgICAgICAgICsrcGl4ZWxzOworICAgICAgICAgICAgfQorICAg ICAgICB9CisgICAgICAgIGlmIChtX29wYWNpdHkgPCAxLiB8fCBhbHBoYVBhaW50ID09IEFscGhh UGFpbnRPdGhlcikgeworICAgICAgICAgICAgY29uc3QgQkxFTkRGVU5DVElPTiBibGVuZCA9IHsg QUNfU1JDX09WRVIsIDAKKyAgICAgICAgICAgICAgICAsIG1fb3BhY2l0eSA+PSAxLiA/IDI1NSA6 IChCWVRFKShtX29wYWNpdHkgKiAyNTUpCisgICAgICAgICAgICAgICAgLCBhbHBoYVBhaW50ID09 IEFscGhhUGFpbnROb25lID8gMCA6IEFDX1NSQ19BTFBIQSB9OworICAgICAgICAgICAgQWxwaGFC bGVuZChtX2RjLCBvcmlnUmVjdC54KCksIG9yaWdSZWN0LnkoKSwgb3JpZ1JlY3Qud2lkdGgoKSwg b3JpZ1JlY3QuaGVpZ2h0KCksIGhkYywgMCwgMCwgYm1wUmVjdC5yaWdodCwgYm1wUmVjdC5ib3R0 b20sIGJsZW5kKTsKKyAgICAgICAgfSBlbHNlCisjZW5kaWYKKyAgICAgICAgICAgIFN0cmV0Y2hC bHQobV9kYywgb3JpZ1JlY3QueCgpLCBvcmlnUmVjdC55KCksIG9yaWdSZWN0LndpZHRoKCksIG9y aWdSZWN0LmhlaWdodCgpLCBoZGMsIDAsIDAsIGJtcFJlY3QucmlnaHQsIGJtcFJlY3QuYm90dG9t LCBTUkNDT1BZKTsKKyAgICB9CisKKyAgICBIREMgbV9kYzsKKyAgICBSZWZQdHI8U2hhcmVkQml0 bWFwPiBtX2JpdG1hcDsKKyAgICBWZWN0b3I8R3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRl RGF0YT4gbV9iYWNrdXBEYXRhOworfTsKKworc3RhdGljIEhQRU4gY3JlYXRlUGVuKGNvbnN0IENv bG9yJiBjb2wsIGRvdWJsZSBmV2lkdGgsIFN0cm9rZVN0eWxlIHN0eWxlKQoreworICAgIGludCB3 aWR0aCA9IHN0YWJsZVJvdW5kKGZXaWR0aCk7CisgICAgaWYgKHdpZHRoIDwgMSkKKyAgICAgICAg d2lkdGggPSAxOworCisgICAgaW50IHBlblN0eWxlID0gUFNfTlVMTDsKKyAgICBzd2l0Y2ggKHN0 eWxlKSB7CisgICAgICAgIGNhc2UgU29saWRTdHJva2U6CisgICAgICAgICAgICBwZW5TdHlsZSA9 IFBTX1NPTElEOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgRG90dGVkU3Ryb2tl OiAgLy8gbm90IHN1cHBvcnRlZCBvbiBXaW5kb3dzIENFCisgICAgICAgIGNhc2UgRGFzaGVkU3Ry b2tlOgorICAgICAgICAgICAgcGVuU3R5bGUgPSBQU19EQVNIOworICAgICAgICAgICAgd2lkdGgg PSAxOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBi cmVhazsKKyAgICB9CisKKyAgICByZXR1cm4gQ3JlYXRlUGVuKHBlblN0eWxlLCB3aWR0aCwgUkdC KGNvbC5yZWQoKSwgY29sLmdyZWVuKCksIGNvbC5ibHVlKCkpKTsKK30KKworc3RhdGljIGlubGlu ZSBIR0RJT0JKIGNyZWF0ZUJydXNoKGNvbnN0IENvbG9yJiBjb2wpCit7CisgICAgcmV0dXJuIENy ZWF0ZVNvbGlkQnJ1c2goUkdCKGNvbC5yZWQoKSwgY29sLmdyZWVuKCksIGNvbC5ibHVlKCkpKTsK K30KKwordGVtcGxhdGUgPHR5cGVuYW1lIFBpeGVsVHlwZSwgYm9vbCBJczE2Yml0PiBzdGF0aWMg dm9pZCBfcm90YXRlQml0bWFwKFNoYXJlZEJpdG1hcCogZGVzdEJtcCwgY29uc3QgU2hhcmVkQml0 bWFwKiBzb3VyY2VCbXAsIGNvbnN0IFJvdGF0aW9uVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCit7Cisg ICAgaW50IGRlc3RXID0gZGVzdEJtcC0+d2lkdGgoKTsKKyAgICBpbnQgZGVzdEggPSBkZXN0Qm1w LT5oZWlnaHQoKTsKKyAgICBpbnQgc291cmNlVyA9IHNvdXJjZUJtcC0+d2lkdGgoKTsKKyAgICBp bnQgc291cmNlSCA9IHNvdXJjZUJtcC0+aGVpZ2h0KCk7CisgICAgUGl4ZWxUeXBlKiBkZXN0ID0g KFBpeGVsVHlwZSopZGVzdEJtcC0+Ynl0ZXMoKTsKKyAgICBjb25zdCBQaXhlbFR5cGUqIHNvdXJj ZSA9IChjb25zdCBQaXhlbFR5cGUqKXNvdXJjZUJtcC0+Ynl0ZXMoKTsKKyAgICBpbnQgcGFkZGlu ZzsKKyAgICBpbnQgcGFkZGVkU291cmNlVzsKKyAgICBpZiAoSXMxNmJpdCkgeworICAgICAgICBw YWRkaW5nID0gZGVzdFcgJiAxOworICAgICAgICBwYWRkZWRTb3VyY2VXID0gc291cmNlVyArIChz b3VyY2VXICYgMSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgcGFkZGluZyA9IDA7CisgICAgICAg IHBhZGRlZFNvdXJjZVcgPSBzb3VyY2VXOworICAgIH0KKyAgICBpZiAoaXNaZXJvKHRyYW5zZm9y bS5tX3NpbkEpKSB7CisgICAgICAgIGludCBjb3NBID0gdHJhbnNmb3JtLm1fY29zQSA+IDAgPyAx IDogLTE7CisgICAgICAgIGZvciAoaW50IHkgPSAwOyB5IDwgZGVzdEg7ICsreSkgeworICAgICAg ICAgICAgZm9yIChpbnQgeCA9IDA7IHggPCBkZXN0VzsgKyt4KSB7CisgICAgICAgICAgICAgICAg aW50IHgxID0geCArIHRyYW5zZm9ybS5tX3ByZVNoaWZ0WDsKKyAgICAgICAgICAgICAgICBpbnQg eTEgPSB5ICsgdHJhbnNmb3JtLm1fcHJlU2hpZnRZOworICAgICAgICAgICAgICAgIGludCBzcmNY ID0geDEgKiBjb3NBICsgdHJhbnNmb3JtLm1fcG9zdFNoaWZ0WDsKKyAgICAgICAgICAgICAgICBp bnQgc3JjWSA9IHkxICogY29zQSAtIHRyYW5zZm9ybS5tX3Bvc3RTaGlmdFk7CisgICAgICAgICAg ICAgICAgaWYgKHNyY1ggPj0gMCAmJiBzcmNYIDw9IHNvdXJjZVcgJiYgc3JjWSA+PSAwICYmIHNy Y1kgPD0gc291cmNlSCkKKyAgICAgICAgICAgICAgICAgICAgKmRlc3QrKyA9IHNvdXJjZVtzcmNZ ICogcGFkZGVkU291cmNlVyArIHNyY1hdIHwgMHhGRjAwMDAwMDsKKyAgICAgICAgICAgICAgICBl bHNlCisgICAgICAgICAgICAgICAgICAgICpkZXN0KysgfD0gMHhGRjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgICAgIGRlc3QgKz0gcGFkZGluZzsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAo aXNaZXJvKHRyYW5zZm9ybS5tX2Nvc0EpKSB7CisgICAgICAgIGludCBzaW5BID0gdHJhbnNmb3Jt Lm1fc2luQSA+IDAgPyAxIDogLTE7CisgICAgICAgIGZvciAoaW50IHkgPSAwOyB5IDwgZGVzdEg7 ICsreSkgeworICAgICAgICAgICAgZm9yIChpbnQgeCA9IDA7IHggPCBkZXN0VzsgKyt4KSB7Cisg ICAgICAgICAgICAgICAgaW50IHgxID0geCArIHRyYW5zZm9ybS5tX3ByZVNoaWZ0WDsKKyAgICAg ICAgICAgICAgICBpbnQgeTEgPSB5ICsgdHJhbnNmb3JtLm1fcHJlU2hpZnRZOworICAgICAgICAg ICAgICAgIGludCBzcmNYID0geTEgKiBzaW5BICsgdHJhbnNmb3JtLm1fcG9zdFNoaWZ0WDsKKyAg ICAgICAgICAgICAgICBpbnQgc3JjWSA9IC14MSAqIHNpbkEgKyB0cmFuc2Zvcm0ubV9wb3N0U2hp ZnRZOworICAgICAgICAgICAgICAgIGlmIChzcmNYID49IDAgJiYgc3JjWCA8PSBzb3VyY2VXICYm IHNyY1kgPj0gMCAmJiBzcmNZIDw9IHNvdXJjZUgpCisgICAgICAgICAgICAgICAgICAgICpkZXN0 KysgPSBzb3VyY2Vbc3JjWSAqIHBhZGRlZFNvdXJjZVcgKyBzcmNYXTsKKyAgICAgICAgICAgIH0K KyAgICAgICAgICAgIGRlc3QgKz0gcGFkZGluZzsKKyAgICAgICAgfQorICAgIH0gZWxzZSB7Cisg ICAgICAgIGZvciAoaW50IHkgPSAwOyB5IDwgZGVzdEg7ICsreSkgeworICAgICAgICAgICAgZm9y IChpbnQgeCA9IDA7IHggPCBkZXN0VzsgKyt4KSB7CisgICAgICAgICAgICAgICAgLy8gRklYTUU6 IGZvciBiZXN0IHF1YWxpdHksIHdlIHNob3VsZCBnZXQgd2VpZ2h0ZWQgc3VtIG9mIGZvdXIgbmVp Z2hib3VycywKKyAgICAgICAgICAgICAgICAvLyBidXQgdGhhdCB3aWxsIGJlIHRvbyBleHBlbnNp dmUKKyAgICAgICAgICAgICAgICBpbnQgc3JjWCwgc3JjWTsKKyAgICAgICAgICAgICAgICB0cmFu c2Zvcm0ubWFwKHgsIHksICZzcmNYLCAmc3JjWSk7CisgICAgICAgICAgICAgICAgaWYgKHNyY1gg Pj0gMCAmJiBzcmNYIDw9IHNvdXJjZVcgJiYgc3JjWSA+PSAwICYmIHNyY1kgPD0gc291cmNlSCkK KyAgICAgICAgICAgICAgICAgICAgKmRlc3QrKyA9IHNvdXJjZVtzcmNZICogcGFkZGVkU291cmNl VyArIHNyY1hdOworICAgICAgICAgICAgfQorICAgICAgICAgICAgZGVzdCArPSBwYWRkaW5nOwor ICAgICAgICB9CisgICAgfQorfQorCitzdGF0aWMgdm9pZCByb3RhdGVCaXRtYXAoU2hhcmVkQml0 bWFwKiBkZXN0Qm1wLCBjb25zdCBTaGFyZWRCaXRtYXAqIHNvdXJjZUJtcCwgY29uc3QgUm90YXRp b25UcmFuc2Zvcm0mIHRyYW5zZm9ybSkKK3sKKyAgICBBU1NFUlQoZGVzdEJtcC0+aXMxNmJpdCgp ID09IHNvdXJjZUJtcC0+aXMxNmJpdCgpKTsKKyAgICBpZiAoZGVzdEJtcC0+aXMxNmJpdCgpKQor ICAgICAgICBfcm90YXRlQml0bWFwPHVuc2lnbmVkIHNob3J0LCB0cnVlPihkZXN0Qm1wLCBzb3Vy Y2VCbXAsIHRyYW5zZm9ybSk7CisgICAgZWxzZQorICAgICAgICBfcm90YXRlQml0bWFwPHVuc2ln bmVkLCBmYWxzZT4oZGVzdEJtcCwgc291cmNlQm1wLCB0cmFuc2Zvcm0pOworfQorCitjbGFzcyBU cmFuc3BhcmVudExheWVyREMgOiBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAgVHJhbnNwYXJl bnRMYXllckRDKEdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJpdmF0ZSogZGF0YSwgSW50UmVjdCYg b3JpZ1JlY3QsIGNvbnN0IEludFJlY3QqIHJlY3RCZWZvcmVUcmFuc2Zvcm0gPSAwLCBpbnQgYWxw aGEgPSAyNTUsIGJvb2wgcGFpbnRJbWFnZSA9IGZhbHNlKTsKKyAgICB+VHJhbnNwYXJlbnRMYXll ckRDKCk7CisKKyAgICBIREMgaGRjKCkgY29uc3QgeyByZXR1cm4gbV9tZW1EYzsgfQorICAgIGNv bnN0IFJFQ1QmIHJlY3QoKSBjb25zdCB7IHJldHVybiBtX2JtcFJlY3Q7IH0KKyAgICBJbnRTaXpl IHRvU2hpZnQoKSBjb25zdCB7IHJldHVybiBJbnRTaXplKG1fYm1wUmVjdC5sZWZ0IC0gbV9vcmln UmVjdC54KCksIG1fYm1wUmVjdC50b3AgLSBtX29yaWdSZWN0LnkoKSk7IH0KKyAgICB2b2lkIGZp bGxBbHBoYUNoYW5uZWwoKTsKKworcHJpdmF0ZToKKyAgICBHcmFwaGljc0NvbnRleHRQbGF0Zm9y bVByaXZhdGUqIG1fZGF0YTsKKyAgICBJbnRSZWN0IG1fb3JpZ1JlY3Q7CisgICAgSW50UmVjdCBt X3JvdGF0ZWRPcmlnUmVjdDsKKyAgICBIREMgbV9tZW1EYzsKKyAgICBSZWZQdHI8U2hhcmVkQml0 bWFwPiBtX2JpdG1hcDsKKyAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBtX3JvdGF0ZWRCaXRtYXA7 CisgICAgUkVDVCBtX2JtcFJlY3Q7CisgICAgdW5zaWduZWQgbV9rZXkxOworICAgIHVuc2lnbmVk IG1fa2V5MjsKKyAgICBSb3RhdGlvblRyYW5zZm9ybSBtX3JvdGF0aW9uOworICAgIGZsb2F0IG1f b2xkT3BhY2l0eTsKKyAgICBBbHBoYVBhaW50VHlwZSBtX2FscGhhUGFpbnRUeXBlOworfTsKKwor VHJhbnNwYXJlbnRMYXllckRDOjpUcmFuc3BhcmVudExheWVyREMoR3JhcGhpY3NDb250ZXh0UGxh dGZvcm1Qcml2YXRlKiBkYXRhLCBJbnRSZWN0JiBvcmlnUmVjdCwgY29uc3QgSW50UmVjdCogcmVj dEJlZm9yZVRyYW5zZm9ybSwgaW50IGFscGhhLCBib29sIHBhaW50SW1hZ2UpCis6IG1fZGF0YShk YXRhKQorLCBtX29yaWdSZWN0KG9yaWdSZWN0KQorLCBtX29sZE9wYWNpdHkoZGF0YS0+bV9vcGFj aXR5KQorLy8gbV9rZXkxIGFuZCBtX2tleTIgYXJlIG5vdCBpbml0YWxpemVkIGhlcmUuIFRoZXkg YXJlIHVzZWQgb25seSBpbiB0aGUgY2FzZSB0aGF0CisvLyBTaGFyZWRCaXRtYXA6OmdldERDKCkg aXMgY2FsbGVkLCBJLkUuLCB3aGVuIG1fYml0bWFwIGlzIG5vdCBudWxsLgoreworICAgIG1fZGF0 YS0+bV9vcGFjaXR5ICo9IGFscGhhIC8gMjU1LjsKKyAgICBib29sIG11c3RDcmVhdGVMYXllcjsK KyAgICBpZiAoIW1fZGF0YS0+aGFzQWxwaGEoKSkgeworICAgICAgICBtdXN0Q3JlYXRlTGF5ZXIg PSBmYWxzZTsKKyAgICAgICAgbV9hbHBoYVBhaW50VHlwZSA9IEFscGhhUGFpbnROb25lOworICAg IH0gZWxzZSB7CisgICAgICAgIG11c3RDcmVhdGVMYXllciA9IHRydWU7CisgICAgICAgIG1fYWxw aGFQYWludFR5cGUgPSBwYWludEltYWdlID8gQWxwaGFQYWludEltYWdlIDogQWxwaGFQYWludE90 aGVyOworICAgIH0KKyAgICBpZiAocmVjdEJlZm9yZVRyYW5zZm9ybSAmJiAhaXNaZXJvKG1fZGF0 YS0+bV90cmFuc2Zvcm0uYigpKSkgeworICAgICAgICBtX3JvdGF0ZWRPcmlnUmVjdCA9IG9yaWdS ZWN0OworICAgICAgICBtX3JvdGF0ZWRCaXRtYXAgPSBtX2RhdGEtPmdldFRyYW5zcGFyZW50TGF5 ZXJCaXRtYXAobV9yb3RhdGVkT3JpZ1JlY3QsIG1fYWxwaGFQYWludFR5cGUsIG1fYm1wUmVjdCwg ZmFsc2UsIHRydWUpOworICAgICAgICBpZiAobV9yb3RhdGVkQml0bWFwKSB7CisgICAgICAgICAg ICBkb3VibGUgYSA9IG1fZGF0YS0+bV90cmFuc2Zvcm0uYSgpOworICAgICAgICAgICAgZG91Ymxl IGIgPSBtX2RhdGEtPm1fdHJhbnNmb3JtLmIoKTsKKyAgICAgICAgICAgIGRvdWJsZSBjID0gX2h5 cG90KGEsIGIpOworICAgICAgICAgICAgbV9yb3RhdGlvbi5tX2Nvc0EgPSBhIC8gYzsKKyAgICAg ICAgICAgIG1fcm90YXRpb24ubV9zaW5BID0gYiAvIGM7CisKKyAgICAgICAgICAgIGludCBjZW50 ZXJYID0gb3JpZ1JlY3QueCgpICsgb3JpZ1JlY3Qud2lkdGgoKSAvIDI7CisgICAgICAgICAgICBp bnQgY2VudGVyWSA9IG9yaWdSZWN0LnkoKSArIG9yaWdSZWN0LmhlaWdodCgpIC8gMjsKKyAgICAg ICAgICAgIG1fcm90YXRpb24ubV9wcmVTaGlmdFggPSAtY2VudGVyWDsKKyAgICAgICAgICAgIG1f cm90YXRpb24ubV9wcmVTaGlmdFkgPSAtY2VudGVyWTsKKyAgICAgICAgICAgIG1fcm90YXRpb24u bV9wb3N0U2hpZnRYID0gY2VudGVyWDsKKyAgICAgICAgICAgIG1fcm90YXRpb24ubV9wb3N0U2hp ZnRZID0gY2VudGVyWTsKKworICAgICAgICAgICAgbV9vcmlnUmVjdCA9IG1hcFJlY3QobV9yb3Rh dGVkT3JpZ1JlY3QsIG1fcm90YXRpb24pOworCisgICAgICAgICAgICBtX3JvdGF0aW9uLm1fcHJl U2hpZnRYICs9IG1fcm90YXRlZE9yaWdSZWN0LngoKTsKKyAgICAgICAgICAgIG1fcm90YXRpb24u bV9wcmVTaGlmdFkgKz0gbV9yb3RhdGVkT3JpZ1JlY3QueSgpOworICAgICAgICAgICAgbV9yb3Rh dGlvbi5tX3Bvc3RTaGlmdFggLT0gbV9vcmlnUmVjdC54KCk7CisgICAgICAgICAgICBtX3JvdGF0 aW9uLm1fcG9zdFNoaWZ0WSAtPSBtX29yaWdSZWN0LnkoKTsKKworICAgICAgICAgICAgRmxvYXRQ b2ludCB0b3BMZWZ0ID0gbV9kYXRhLT5tX3RyYW5zZm9ybS5tYXBQb2ludChGbG9hdFBvaW50KHJl Y3RCZWZvcmVUcmFuc2Zvcm0tPnRvcExlZnQoKSkpOworICAgICAgICAgICAgRmxvYXRQb2ludCB0 b3BSaWdodChyZWN0QmVmb3JlVHJhbnNmb3JtLT5yaWdodCgpIC0gMSwgcmVjdEJlZm9yZVRyYW5z Zm9ybS0+eSgpKTsKKyAgICAgICAgICAgIHRvcFJpZ2h0ID0gbV9kYXRhLT5tX3RyYW5zZm9ybS5t YXBQb2ludCh0b3BSaWdodCk7CisgICAgICAgICAgICBGbG9hdFBvaW50IGJvdHRvbUxlZnQocmVj dEJlZm9yZVRyYW5zZm9ybS0+eCgpLCByZWN0QmVmb3JlVHJhbnNmb3JtLT5ib3R0b20oKSAtIDEp OworICAgICAgICAgICAgYm90dG9tTGVmdCA9IG1fZGF0YS0+bV90cmFuc2Zvcm0ubWFwUG9pbnQo Ym90dG9tTGVmdCk7CisgICAgICAgICAgICBGbG9hdFNpemUgc2lkZVRvcCA9IHRvcFJpZ2h0IC0g dG9wTGVmdDsKKyAgICAgICAgICAgIEZsb2F0U2l6ZSBzaWRlTGVmdCA9IGJvdHRvbUxlZnQgLSB0 b3BMZWZ0OworICAgICAgICAgICAgZmxvYXQgd2lkdGggPSBfaHlwb3Qoc2lkZVRvcC53aWR0aCgp ICsgMSwgc2lkZVRvcC5oZWlnaHQoKSArIDEpOworICAgICAgICAgICAgZmxvYXQgaGVpZ2h0ID0g X2h5cG90KHNpZGVMZWZ0LndpZHRoKCkgKyAxLCBzaWRlTGVmdC5oZWlnaHQoKSArIDEpOworCisg ICAgICAgICAgICBvcmlnUmVjdC5pbmZsYXRlWChzdGFibGVSb3VuZCgod2lkdGggLSBvcmlnUmVj dC53aWR0aCgpKSAqIDAuNSkpOworICAgICAgICAgICAgb3JpZ1JlY3QuaW5mbGF0ZVkoc3RhYmxl Um91bmQoKGhlaWdodCAtIG9yaWdSZWN0LmhlaWdodCgpKSAqIDAuNSkpOworCisgICAgICAgICAg ICBtX2JpdG1hcCA9IFNoYXJlZEJpdG1hcDo6Y3JlYXRlSW5zdGFuY2UobV9yb3RhdGVkQml0bWFw LT5pczE2Yml0KCksIG1fb3JpZ1JlY3Qud2lkdGgoKSwgbV9vcmlnUmVjdC5oZWlnaHQoKSwgdHJ1 ZSk7CisgICAgICAgICAgICBpZiAobV9iaXRtYXApCisgICAgICAgICAgICAgICAgcm90YXRlQml0 bWFwKG1fYml0bWFwLmdldCgpLCBtX3JvdGF0ZWRCaXRtYXAuZ2V0KCksIC1tX3JvdGF0aW9uKTsK KyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBtX3JvdGF0ZWRCaXRtYXAgPSAwOwor ICAgICAgICB9CisgICAgfSBlbHNlCisgICAgICAgIG1fYml0bWFwID0gbV9kYXRhLT5nZXRUcmFu c3BhcmVudExheWVyQml0bWFwKG1fb3JpZ1JlY3QsIG1fYWxwaGFQYWludFR5cGUsIG1fYm1wUmVj dCwgdHJ1ZSwgbXVzdENyZWF0ZUxheWVyKTsKKyAgICBpZiAobV9iaXRtYXApCisgICAgICAgIG1f bWVtRGMgPSBtX2JpdG1hcC0+Z2V0REMoJm1fa2V5MSwgJm1fa2V5Mik7CisgICAgZWxzZQorICAg ICAgICBtX21lbURjID0gbV9kYXRhLT5tX2RjOworfQorCitUcmFuc3BhcmVudExheWVyREM6On5U cmFuc3BhcmVudExheWVyREMoKQoreworICAgIGlmIChtX3JvdGF0ZWRCaXRtYXApIHsKKyAgICAg ICAgbV9iaXRtYXAtPnJlbGVhc2VEQyhtX21lbURjLCBtX2tleTEsIG1fa2V5Mik7CisgICAgICAg IG1fa2V5MSA9IG1fa2V5MiA9IDA7CisgICAgICAgIHJvdGF0ZUJpdG1hcChtX3JvdGF0ZWRCaXRt YXAuZ2V0KCksIG1fYml0bWFwLmdldCgpLCBtX3JvdGF0aW9uKTsKKyAgICAgICAgbV9tZW1EYyA9 IG1fcm90YXRlZEJpdG1hcC0+Z2V0REMoJm1fa2V5MSwgJm1fa2V5Mik7CisgICAgICAgIG1fZGF0 YS0+cGFpbnRCYWNrVHJhbnNwYXJlbnRMYXllckJpdG1hcChtX21lbURjLCBtX3JvdGF0ZWRCaXRt YXAuZ2V0KCksIG1fcm90YXRlZE9yaWdSZWN0LCBtX2FscGhhUGFpbnRUeXBlLCBtX2JtcFJlY3Qp OworICAgICAgICBtX3JvdGF0ZWRCaXRtYXAtPnJlbGVhc2VEQyhtX21lbURjLCBtX2tleTEsIG1f a2V5Mik7CisgICAgfSBlbHNlIGlmIChtX2JpdG1hcCkgeworICAgICAgICBtX2RhdGEtPnBhaW50 QmFja1RyYW5zcGFyZW50TGF5ZXJCaXRtYXAobV9tZW1EYywgbV9iaXRtYXAuZ2V0KCksIG1fb3Jp Z1JlY3QsIG1fYWxwaGFQYWludFR5cGUsIG1fYm1wUmVjdCk7CisgICAgICAgIG1fYml0bWFwLT5y ZWxlYXNlREMobV9tZW1EYywgbV9rZXkxLCBtX2tleTIpOworICAgIH0KKyAgICBtX2RhdGEtPm1f b3BhY2l0eSA9IG1fb2xkT3BhY2l0eTsKK30KKwordm9pZCBUcmFuc3BhcmVudExheWVyREM6OmZp bGxBbHBoYUNoYW5uZWwoKQoreworICAgIGlmICghbV9iaXRtYXAgfHwgIW1fYml0bWFwLT5pczMy Yml0KCkpCisgICAgICAgIHJldHVybjsKKworICAgIHVuc2lnbmVkKiBwaXhlbHMgPSAodW5zaWdu ZWQqKW1fYml0bWFwLT5ieXRlcygpOworICAgIGNvbnN0IHVuc2lnbmVkKiBjb25zdCBwaXhlbHNF bmQgPSBwaXhlbHMgKyBtX2JpdG1hcC0+Yml0bWFwSW5mbygpLm51bVBpeGVscygpOworICAgIHdo aWxlIChwaXhlbHMgPCBwaXhlbHNFbmQpIHsKKyAgICAgICAgKnBpeGVscyB8PSAweEZGMDAwMDAw OworICAgICAgICArK3BpeGVsczsKKyAgICB9Cit9CisKK2NsYXNzIFNjb3BlRENQcm92aWRlciA6 IE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBTY29wZURDUHJvdmlkZXIoR3Jh cGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKiBkYXRhKQorICAgICAgICA6IG1fZGF0YShkYXRh KQorICAgIHsKKyAgICAgICAgaWYgKG1fZGF0YS0+bV9iaXRtYXApCisgICAgICAgICAgICBtX2Rh dGEtPm1fZGMgPSBtX2RhdGEtPm1fYml0bWFwLT5nZXREQygmbV9rZXkxLCAmbV9rZXkyKTsKKyAg ICB9CisgICAgflNjb3BlRENQcm92aWRlcigpCisgICAgeworICAgICAgICBpZiAobV9kYXRhLT5t X2JpdG1hcCkgeworICAgICAgICAgICAgbV9kYXRhLT5tX2JpdG1hcC0+cmVsZWFzZURDKG1fZGF0 YS0+bV9kYywgbV9rZXkxLCBtX2tleTIpOworICAgICAgICAgICAgbV9kYXRhLT5tX2RjID0gMDsK KyAgICAgICAgfQorICAgIH0KK3ByaXZhdGU6CisgICAgR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Q cml2YXRlKiBtX2RhdGE7CisgICAgdW5zaWduZWQgbV9rZXkxOworICAgIHVuc2lnbmVkIG1fa2V5 MjsKK307CisKKworR3JhcGhpY3NDb250ZXh0OjpHcmFwaGljc0NvbnRleHQoUGxhdGZvcm1HcmFw aGljc0NvbnRleHQqIGRjKQorOiBtX2NvbW1vbihjcmVhdGVHcmFwaGljc0NvbnRleHRQcml2YXRl KCkpCissIG1fZGF0YShuZXcgR3JhcGhpY3NDb250ZXh0UGxhdGZvcm1Qcml2YXRlKGRjKSkKK3sK K30KKworR3JhcGhpY3NDb250ZXh0Ojp+R3JhcGhpY3NDb250ZXh0KCkKK3sKKyAgICBkZXN0cm95 R3JhcGhpY3NDb250ZXh0UHJpdmF0ZShtX2NvbW1vbik7CisgICAgZGVsZXRlIG1fZGF0YTsKK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldEJpdG1hcChQYXNzUmVmUHRyPFNoYXJlZEJpdG1h cD4gYm1wKQoreworICAgIEFTU0VSVCghbV9kYXRhLT5tX2RjKTsKKyAgICBtX2RhdGEtPm1fYml0 bWFwID0gYm1wOworfQorCitIREMgR3JhcGhpY3NDb250ZXh0OjpnZXRXaW5kb3dzQ29udGV4dChj b25zdCBJbnRSZWN0JiBkc3RSZWN0LCBib29sIHN1cHBvcnRBbHBoYUJsZW5kLCBib29sIG1heUNy ZWF0ZUJpdG1hcCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgIHJldHVybiAwOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6cmVsZWFz ZVdpbmRvd3NDb250ZXh0KEhEQyBoZGMsIGNvbnN0IEludFJlY3QmIGRzdFJlY3QsIGJvb2wgc3Vw cG9ydEFscGhhQmxlbmQsIGJvb2wgbWF5Q3JlYXRlQml0bWFwKQoreworICAgIG5vdEltcGxlbWVu dGVkKCk7CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250 ZXh0OjpzYXZlUGxhdGZvcm1TdGF0ZSgpCit7CisgICAgbV9kYXRhLT5zYXZlKCk7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0OjpyZXN0b3JlUGxhdGZvcm1TdGF0ZSgpCit7CisgICAgbV9kYXRh LT5yZXN0b3JlKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3UmVjdChjb25zdCBJ bnRSZWN0JiByZWN0KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkgfHwgcGFpbnRpbmdE aXNhYmxlZCgpIHx8IHJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBTY29w ZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQor ICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVjdChy ZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREQyhtX2RhdGEsIHRyUmVj dCwgJnJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50REMuaGRjKCk7CisgICAgaWYgKCFk YykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50REMudG9TaGlm dCgpKTsKKworICAgIEhHRElPQkogYnJ1c2ggPSAwOworICAgIEhHRElPQkogb2xkQnJ1c2g7Cisg ICAgaWYgKGZpbGxDb2xvcigpLmFscGhhKCkpIHsKKyAgICAgICAgYnJ1c2ggPSBjcmVhdGVCcnVz aChmaWxsQ29sb3IoKSk7CisgICAgICAgIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KGRjLCBicnVz aCk7CisgICAgfSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3Qo TlVMTF9CUlVTSCkpOworCisgICAgSEdESU9CSiBwZW4gPSAwOworICAgIEhHRElPQkogb2xkUGVu OworICAgIGlmIChzdHJva2VTdHlsZSgpICE9IE5vU3Ryb2tlKSB7CisgICAgICAgIHBlbiA9IGNy ZWF0ZVBlbihzdHJva2VDb2xvcigpLCBzdHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUoKSk7 CisgICAgICAgIG9sZFBlbiA9IFNlbGVjdE9iamVjdChkYywgcGVuKTsKKyAgICB9IGVsc2UKKyAg ICAgICAgU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9ja09iamVjdChOVUxMX1BFTikpOworCisgICAg aWYgKCFicnVzaCAmJiAhcGVuKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAodHJSZWN0Lndp ZHRoKCkgPD0gMCkKKyAgICAgICAgdHJSZWN0LnNldFdpZHRoKDEpOworICAgIGlmICh0clJlY3Qu aGVpZ2h0KCkgPD0gMCkKKyAgICAgICAgdHJSZWN0LnNldEhlaWdodCgxKTsKKworICAgIFJlY3Rh bmdsZShkYywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJSZWN0LnJpZ2h0KCksIHRyUmVjdC5i b3R0b20oKSk7CisKKyAgICBpZiAocGVuKSB7CisgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xk UGVuKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgfQorCisgICAgaWYgKGJydXNo KSB7CisgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOworICAgICAgICBEZWxldGVP YmplY3QoYnJ1c2gpOworICAgIH0KK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdMaW5l KGNvbnN0IEludFBvaW50JiBwb2ludDEsIGNvbnN0IEludFBvaW50JiBwb2ludDIpCit7CisgICAg aWYgKCFtX2RhdGEtPm1fb3BhY2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgc3Ryb2tlU3R5 bGUoKSA9PSBOb1N0cm9rZSB8fCAhc3Ryb2tlQ29sb3IoKS5hbHBoYSgpKQorICAgICAgICByZXR1 cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICgh bV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRQb2ludCB0clBvaW50MSA9 IG1fZGF0YS0+bWFwUG9pbnQocG9pbnQxKTsKKyAgICBJbnRQb2ludCB0clBvaW50MiA9IG1fZGF0 YS0+bWFwUG9pbnQocG9pbnQyKTsKKworICAgIEludFJlY3QgbGluZVJlY3QodHJQb2ludDEsIHRy UG9pbnQyIC0gdHJQb2ludDEpOworICAgIGxpbmVSZWN0LnNldEhlaWdodChsaW5lUmVjdC5oZWln aHQoKSArIHN0cm9rZVRoaWNrbmVzcygpKTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNw YXJlbnREQyhtX2RhdGEsIGxpbmVSZWN0LCAwLCBzdHJva2VDb2xvcigpLmFscGhhKCkpOworICAg IEhEQyBkYyA9IHRyYW5zcGFyZW50REMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0 dXJuOworICAgIHRyUG9pbnQxICs9IHRyYW5zcGFyZW50REMudG9TaGlmdCgpOworICAgIHRyUG9p bnQyICs9IHRyYW5zcGFyZW50REMudG9TaGlmdCgpOworCisgICAgSEdESU9CSiBwZW4gPSBjcmVh dGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOwor ICAgIEhHRElPQkogb2xkUGVuID0gU2VsZWN0T2JqZWN0KGRjLCBwZW4pOworCisgICAgTW92ZVRv RXgoZGMsIHRyUG9pbnQxLngoKSwgdHJQb2ludDEueSgpLCAwKTsKKyAgICBMaW5lVG8oZGMsIHRy UG9pbnQyLngoKSwgdHJQb2ludDIueSgpKTsKKworICAgIFNlbGVjdE9iamVjdChkYywgb2xkUGVu KTsKKyAgICBEZWxldGVPYmplY3QocGVuKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRy YXdFbGxpcHNlKGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3Bh Y2l0eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgKCFmaWxsQ29sb3IoKS5hbHBoYSgpICYmIHN0 cm9rZVN0eWxlKCkgPT0gTm9TdHJva2UpKQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURD UHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAg ICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1fZGF0YS0+bWFwUmVjdChyZWN0 KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJlbnREQyhtX2RhdGEsIHRyUmVjdCwg JnJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50REMuaGRjKCk7CisgICAgaWYgKCFkYykK KyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFyZW50REMudG9TaGlmdCgp KTsKKworICAgIEhHRElPQkogYnJ1c2ggPSAwOworICAgIEhHRElPQkogb2xkQnJ1c2g7CisgICAg aWYgKGZpbGxDb2xvcigpLmFscGhhKCkpIHsKKyAgICAgICAgYnJ1c2ggPSBjcmVhdGVCcnVzaChm aWxsQ29sb3IoKSk7CisgICAgICAgIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KGRjLCBicnVzaCk7 CisgICAgfSBlbHNlCisgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVM TF9CUlVTSCkpOworICAgIEhHRElPQkogcGVuID0gMDsKKyAgICBIR0RJT0JKIG9sZFBlbjsKKyAg ICBpZiAoc3Ryb2tlU3R5bGUoKSAhPSBOb1N0cm9rZSkgeworICAgICAgICBwZW4gPSBjcmVhdGVQ ZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOworICAg ICAgICBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisgICAgfSBlbHNlCisgICAgICAg IFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKworICAgIEVsbGlw c2UoZGMsIHRyUmVjdC54KCksIHRyUmVjdC55KCksIHRyUmVjdC5yaWdodCgpLCB0clJlY3QuYm90 dG9tKCkpOworCisgICAgaWYgKHBlbikgeworICAgICAgICBTZWxlY3RPYmplY3QoZGMsIG9sZFBl bik7CisgICAgICAgIERlbGV0ZU9iamVjdChwZW4pOworICAgIH0KKworICAgIGlmIChicnVzaCkg eworICAgICAgICBTZWxlY3RPYmplY3QoZGMsIG9sZEJydXNoKTsKKyAgICAgICAgRGVsZXRlT2Jq ZWN0KGJydXNoKTsKKyAgICB9Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBlcXVhbEFuZ2xlKGRv dWJsZSBhLCBkb3VibGUgYikgCit7CisgICAgcmV0dXJuIGZhYnMoYSAtIGIpIDwgMUUtNTsKK30K Kwordm9pZCBnZXRFbGxpcHNlUG9pbnRCeUFuZ2xlKGRvdWJsZSBhbmdsZSwgZG91YmxlIGEsIGRv dWJsZSBiLCBmbG9hdCYgeCwgZmxvYXQmIHkpCit7CisgICAgd2hpbGUgKGFuZ2xlIDwgMCkKKyAg ICAgICAgYW5nbGUgKz0gMiAqIHBpRG91YmxlOworICAgIHdoaWxlIChhbmdsZSA+PSAyICogcGlE b3VibGUpCisgICAgICAgIGFuZ2xlIC09IDIgKiBwaURvdWJsZTsKKworICAgIGlmIChlcXVhbEFu Z2xlKGFuZ2xlLCAwKSB8fCBlcXVhbEFuZ2xlKGFuZ2xlLCAyICogcGlEb3VibGUpKSB7CisgICAg ICAgIHggPSBhOworICAgICAgICB5ID0gMDsKKyAgICB9IGVsc2UgaWYgKGVxdWFsQW5nbGUoYW5n bGUsIHBpRG91YmxlKSkgeworICAgICAgICB4ID0gLWE7CisgICAgICAgIHkgPSAwOworICAgIH0g ZWxzZSBpZiAoZXF1YWxBbmdsZShhbmdsZSwgLjUgKiBwaURvdWJsZSkpIHsKKyAgICAgICAgeCA9 IDA7CisgICAgICAgIHkgPSBiOworICAgIH0gZWxzZSBpZiAoZXF1YWxBbmdsZShhbmdsZSwgMS41 ICogcGlEb3VibGUpKSB7CisgICAgICAgIHggPSAwOworICAgICAgICB5ID0gLWI7CisgICAgfSBl bHNlIHsKKyAgICAgICAgZG91YmxlIGsgPSB0YW4oYW5nbGUpOworICAgICAgICBkb3VibGUgc3FB ID0gYSAqIGE7CisgICAgICAgIGRvdWJsZSBzcUIgPSBiICogYjsKKyAgICAgICAgZG91YmxlIHRt cCA9IDEuIC8gKDEuIC8gc3FBICsgKGsgKiBrKSAvIHNxQik7CisgICAgICAgIHRtcCA9IHRtcCA8 PSAwID8gMCA6IHNxcnQodG1wKTsKKyAgICAgICAgaWYgKGFuZ2xlID4gLjUgKiBwaURvdWJsZSAm JiBhbmdsZSA8IDEuNSAqIHBpRG91YmxlKQorICAgICAgICAgICAgdG1wID0gLXRtcDsKKyAgICAg ICAgeCA9IHRtcDsKKworICAgICAgICBrID0gdGFuKC41ICogcGlEb3VibGUgLSBhbmdsZSk7Cisg ICAgICAgIHRtcCA9IDEuIC8gKChrICogaykgLyBzcUEgKyAxIC8gc3FCKTsKKyAgICAgICAgdG1w ID0gdG1wIDw9IDAgPyAwIDogc3FydCh0bXApOworICAgICAgICBpZiAoYW5nbGUgPiBwaURvdWJs ZSkKKyAgICAgICAgICAgIHRtcCA9IC10bXA7CisgICAgICAgIHkgPSB0bXA7CisgICAgfQorfQor Cit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c3Ryb2tlQXJjKGNvbnN0IEludFJlY3QmIHJlY3QsIGlu dCBzdGFydEFuZ2xlLCBpbnQgYW5nbGVTcGFuKQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNp dHkgfHwgcGFpbnRpbmdEaXNhYmxlZCgpIHx8IHN0cm9rZVN0eWxlKCkgPT0gTm9TdHJva2UgfHwg cmVjdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBk Y1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVy bjsKKworICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KHJlY3QpOworICAgIFRy YW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERDKG1fZGF0YSwgdHJSZWN0LCAmcmVjdCk7Cisg ICAgSERDIGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICBy ZXR1cm47CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREQy50b1NoaWZ0KCkpOworCisgICAg SEdESU9CSiBwZW4gPSBjcmVhdGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCks IHN0cm9rZVN0eWxlKCkpOworICAgIEhHRElPQkogb2xkUGVuID0gU2VsZWN0T2JqZWN0KGRjLCBw ZW4pOworCisgICAgZG91YmxlIGEgPSB0clJlY3Qud2lkdGgoKSAqIDAuNTsKKyAgICBkb3VibGUg YiA9IHRyUmVjdC5oZWlnaHQoKSAqIDAuNTsKKyAgICBpbnQgY2VudGVyWCA9IHN0YWJsZVJvdW5k KHRyUmVjdC54KCkgKyBhKTsKKyAgICBpbnQgY2VudGVyWSA9IHN0YWJsZVJvdW5kKHRyUmVjdC55 KCkgKyBiKTsKKyAgICBmbG9hdCBmc3RhcnRYLCBmc3RhcnRZLCBmZW5kWCwgZmVuZFk7CisgICAg aW50IHN0YXJ0WCwgc3RhcnRZLCBlbmRYLCBlbmRZOworICAgIGdldEVsbGlwc2VQb2ludEJ5QW5n bGUoZGVnMnJhZCgoZG91YmxlKXN0YXJ0QW5nbGUpLCBhLCBiLCBmc3RhcnRYLCBmc3RhcnRZKTsK KyAgICBnZXRFbGxpcHNlUG9pbnRCeUFuZ2xlKGRlZzJyYWQoKGRvdWJsZSlzdGFydEFuZ2xlICsg YW5nbGVTcGFuKSwgYSwgYiwgZmVuZFgsIGZlbmRZKTsKKyAgICBzdGFydFggPSBzdGFibGVSb3Vu ZChmc3RhcnRYKTsKKyAgICBzdGFydFkgPSBzdGFibGVSb3VuZChmc3RhcnRZKTsKKyAgICBlbmRY ID0gc3RhYmxlUm91bmQoZmVuZFgpOworICAgIGVuZFkgPSBzdGFibGVSb3VuZChmZW5kWSk7CisK KyAgICBzdGFydFggKz0gY2VudGVyWDsKKyAgICBzdGFydFkgPSBjZW50ZXJZIC0gc3RhcnRZOwor ICAgIGVuZFggKz0gY2VudGVyWDsKKyAgICBlbmRZID0gY2VudGVyWSAtIGVuZFk7CisgICAgUkVD VCBjbGlwUmVjdDsKKyAgICBpZiAoc3RhcnRYIDwgZW5kWCkgeworICAgICAgICBjbGlwUmVjdC5s ZWZ0ID0gc3RhcnRYOworICAgICAgICBjbGlwUmVjdC5yaWdodCA9IGVuZFg7CisgICAgfSBlbHNl IHsKKyAgICAgICAgY2xpcFJlY3QubGVmdCA9IGVuZFg7CisgICAgICAgIGNsaXBSZWN0LnJpZ2h0 ID0gc3RhcnRYOworICAgIH0KKyAgICBpZiAoc3RhcnRZIDwgZW5kWSkgeworICAgICAgICBjbGlw UmVjdC50b3AgPSBzdGFydFk7CisgICAgICAgIGNsaXBSZWN0LmJvdHRvbSA9IGVuZFk7CisgICAg fSBlbHNlIHsKKyAgICAgICAgY2xpcFJlY3QudG9wID0gZW5kWTsKKyAgICAgICAgY2xpcFJlY3Qu Ym90dG9tID0gc3RhcnRZOworICAgIH0KKworICAgIE93blB0cjxIUkdOPiBjbGlwUmduKENyZWF0 ZVJlY3RSZ24oMCwgMCwgMCwgMCkpOworICAgIGJvb2wgbmV3Q2xpcDsKKyAgICBpZiAoR2V0Q2xp cFJnbihkYywgY2xpcFJnbi5nZXQoKSkgPD0gMCkgeworICAgICAgICBuZXdDbGlwID0gdHJ1ZTsK KyAgICAgICAgY2xpcFJnbi5zZXQoQ3JlYXRlUmVjdFJnbihjbGlwUmVjdC5sZWZ0LCBjbGlwUmVj dC50b3AsIGNsaXBSZWN0LnJpZ2h0LCBjbGlwUmVjdC5ib3R0b20pKTsKKyAgICAgICAgU2VsZWN0 Q2xpcFJnbihkYywgY2xpcFJnbi5nZXQoKSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgbmV3Q2xp cCA9IGZhbHNlOworICAgICAgICBJbnRlcnNlY3RDbGlwUmVjdChkYywgY2xpcFJlY3QubGVmdCwg Y2xpcFJlY3QudG9wLCBjbGlwUmVjdC5yaWdodCwgY2xpcFJlY3QuYm90dG9tKTsKKyAgICB9CisK KyAgICBIR0RJT0JKIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KGRjLCBHZXRTdG9ja09iamVjdChO VUxMX0JSVVNIKSk7CisgICAgRWxsaXBzZShkYywgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSwgdHJS ZWN0LnJpZ2h0KCksIHRyUmVjdC5ib3R0b20oKSk7CisgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRC cnVzaCk7CisKKyAgICBpZiAobmV3Q2xpcCkKKyAgICAgICAgU2VsZWN0Q2xpcFJnbihkYywgMCk7 CisgICAgZWxzZQorICAgICAgICBTZWxlY3RDbGlwUmduKGRjLCBjbGlwUmduLmdldCgpKTsKKwor ICAgIFNlbGVjdE9iamVjdChkYywgb2xkUGVuKTsKKyAgICBEZWxldGVPYmplY3QocGVuKTsKK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdDb252ZXhQb2x5Z29uKHNpemVfdCBucG9pbnRz LCBjb25zdCBGbG9hdFBvaW50KiBwb2ludHMsIGJvb2wgc2hvdWxkQW50aWFsaWFzKQoreworICAg IGlmICghbV9kYXRhLT5tX29wYWNpdHkgfHwgcGFpbnRpbmdEaXNhYmxlZCgpIHx8IG5wb2ludHMg PD0gMSB8fCAhcG9pbnRzKQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIg ZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1 cm47CisKKyAgICBWZWN0b3I8UE9JTlQsIDIwPiB3aW5Qb2ludHMobnBvaW50cyk7CisgICAgRmxv YXRQb2ludCB0clBvaW50ID0gbV9kYXRhLT5tYXBQb2ludChwb2ludHNbMF0pOworICAgIHdpblBv aW50c1swXS54ID0gc3RhYmxlUm91bmQodHJQb2ludC54KCkpOworICAgIHdpblBvaW50c1swXS55 ID0gc3RhYmxlUm91bmQodHJQb2ludC55KCkpOworICAgIFJFQ1QgcmVjdCA9IHsgd2luUG9pbnRz WzBdLngsIHdpblBvaW50c1swXS55LCB3aW5Qb2ludHNbMF0ueCwgd2luUG9pbnRzWzBdLnkgfTsK KyAgICBmb3IgKHNpemVfdCBpID0gMTsgaSA8IG5wb2ludHM7ICsraSkgeworICAgICAgICB0clBv aW50ID0gbV9kYXRhLT5tYXBQb2ludChwb2ludHNbaV0pOworICAgICAgICB3aW5Qb2ludHNbaV0u eCA9IHN0YWJsZVJvdW5kKHRyUG9pbnQueCgpKTsKKyAgICAgICAgd2luUG9pbnRzW2ldLnkgPSBz dGFibGVSb3VuZCh0clBvaW50LnkoKSk7CisgICAgICAgIGlmIChyZWN0LmxlZnQgPiB3aW5Qb2lu dHNbaV0ueCkKKyAgICAgICAgICAgIHJlY3QubGVmdCA9IHdpblBvaW50c1tpXS54OworICAgICAg ICBlbHNlIGlmIChyZWN0LnJpZ2h0IDwgd2luUG9pbnRzW2ldLngpCisgICAgICAgICAgICByZWN0 LnJpZ2h0ID0gd2luUG9pbnRzW2ldLng7CisgICAgICAgIGlmIChyZWN0LnRvcCA+IHdpblBvaW50 c1tpXS55KQorICAgICAgICAgICAgcmVjdC50b3AgPSB3aW5Qb2ludHNbaV0ueTsKKyAgICAgICAg ZWxzZSBpZiAocmVjdC5ib3R0b20gPCB3aW5Qb2ludHNbaV0ueSkKKyAgICAgICAgICAgIHJlY3Qu Ym90dG9tID0gd2luUG9pbnRzW2ldLnk7CisgICAgfQorICAgIHJlY3QuYm90dG9tICs9IDE7Cisg ICAgcmVjdC5yaWdodCArPSAxOworCisgICAgSW50UmVjdCBpbnRSZWN0KHJlY3QpOworICAgIFRy YW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERDKG1fZGF0YSwgaW50UmVjdCk7CisgICAgSERD IGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47 CisKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG5wb2ludHM7ICsraSkgeworICAgICAgICB3 aW5Qb2ludHNbaV0ueCArPSB0cmFuc3BhcmVudERDLnRvU2hpZnQoKS53aWR0aCgpOworICAgICAg ICB3aW5Qb2ludHNbaV0ueSArPSB0cmFuc3BhcmVudERDLnRvU2hpZnQoKS5oZWlnaHQoKTsKKyAg ICB9CisKKyAgICBIR0RJT0JKIGJydXNoID0gMDsKKyAgICBIR0RJT0JKIG9sZEJydXNoOworICAg IGlmIChmaWxsQ29sb3IoKS5hbHBoYSgpKSB7CisgICAgICAgIGJydXNoID0gY3JlYXRlQnJ1c2go ZmlsbENvbG9yKCkpOworICAgICAgICBvbGRCcnVzaCA9IFNlbGVjdE9iamVjdChkYywgYnJ1c2gp OworICAgIH0gZWxzZQorICAgICAgICBTZWxlY3RPYmplY3QoZGMsIEdldFN0b2NrT2JqZWN0KE5V TExfQlJVU0gpKTsKKworICAgIEhHRElPQkogcGVuID0gMDsKKyAgICBIR0RJT0JKIG9sZFBlbjsK KyAgICBpZiAoc3Ryb2tlU3R5bGUoKSAhPSBOb1N0cm9rZSkgeworICAgICAgICBwZW4gPSBjcmVh dGVQZW4oc3Ryb2tlQ29sb3IoKSwgc3Ryb2tlVGhpY2tuZXNzKCksIHN0cm9rZVN0eWxlKCkpOwor ICAgICAgICBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7CisgICAgfSBlbHNlCisgICAg ICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKworICAgIGlm ICghYnJ1c2ggJiYgIXBlbikKKyAgICAgICAgcmV0dXJuOworCisgICAgUG9seWdvbihkYywgd2lu UG9pbnRzLmRhdGEoKSwgbnBvaW50cyk7CisKKyAgICBpZiAocGVuKSB7CisgICAgICAgIFNlbGVj dE9iamVjdChkYywgb2xkUGVuKTsKKyAgICAgICAgRGVsZXRlT2JqZWN0KHBlbik7CisgICAgfQor CisgICAgaWYgKGJydXNoKSB7CisgICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkQnJ1c2gpOwor ICAgICAgICBEZWxldGVPYmplY3QoYnJ1c2gpOworICAgIH0KK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCwgY29uc3QgQ29sb3ImIGNvbG9y KQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVkKCkgfHwgIW1fZGF0YS0+bV9vcGFjaXR5KQor ICAgICAgICByZXR1cm47CisKKyAgICBpbnQgYWxwaGEgPSBjb2xvci5hbHBoYSgpOworICAgIGlm ICghYWxwaGEpCisgICAgICAgIHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3Zp ZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKwor ICAgIEludFJlY3QgaW50UmVjdCA9IGVuY2xvc2luZ0ludFJlY3QocmVjdCk7CisgICAgVHJhbnNw YXJlbnRMYXllckRDIHRyYW5zcGFyZW50REMobV9kYXRhLCBtX2RhdGEtPm1hcFJlY3QoaW50UmVj dCksICZpbnRSZWN0LCBhbHBoYSk7CisKKyAgICBpZiAoIXRyYW5zcGFyZW50REMuaGRjKCkpCisg ICAgICAgIHJldHVybjsKKworICAgIE93blB0cjxIQlJVU0g+IGhicnVzaChDcmVhdGVTb2xpZEJy dXNoKFJHQihjb2xvci5yZWQoKSwgY29sb3IuZ3JlZW4oKSwgY29sb3IuYmx1ZSgpKSkpOworICAg IEZpbGxSZWN0KHRyYW5zcGFyZW50REMuaGRjKCksICZ0cmFuc3BhcmVudERDLnJlY3QoKSwgaGJy dXNoLmdldCgpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmNsaXAoY29uc3QgRmxvYXRS ZWN0JiByZWN0KQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVy bjsKKworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRS ZWN0IHRyUmVjdCA9IGVuY2xvc2luZ0ludFJlY3QobV9kYXRhLT5tYXBSZWN0KHJlY3QpKTsKKwor ICAgIE93blB0cjxIUkdOPiBjbGlwUmduKENyZWF0ZVJlY3RSZ24oMCwgMCwgMCwgMCkpOworICAg IGlmIChHZXRDbGlwUmduKG1fZGF0YS0+bV9kYywgY2xpcFJnbi5nZXQoKSkgPiAwKQorICAgICAg ICBJbnRlcnNlY3RDbGlwUmVjdChtX2RhdGEtPm1fZGMsIHRyUmVjdC54KCksIHRyUmVjdC55KCks IHRyUmVjdC5yaWdodCgpLCB0clJlY3QuYm90dG9tKCkpOworICAgIGVsc2UgeworICAgICAgICBj bGlwUmduLnNldChDcmVhdGVSZWN0UmduKHRyUmVjdC54KCksIHRyUmVjdC55KCksIHRyUmVjdC5y aWdodCgpLCB0clJlY3QuYm90dG9tKCkpKTsKKyAgICAgICAgU2VsZWN0Q2xpcFJnbihtX2RhdGEt Pm1fZGMsIGNsaXBSZ24uZ2V0KCkpOworICAgIH0KK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6 OmNsaXBPdXQoY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxl ZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAg cmV0dXJuOworCisgICAgSW50UmVjdCB0clJlY3QgPSBtX2RhdGEtPm1hcFJlY3QocmVjdCk7CisK KyAgICBFeGNsdWRlQ2xpcFJlY3QobV9kYXRhLT5tX2RjLCB0clJlY3QueCgpLCB0clJlY3QueSgp LCB0clJlY3QucmlnaHQoKSwgdHJSZWN0LmJvdHRvbSgpKTsKK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OmRyYXdGb2N1c1JpbmcoY29uc3QgQ29sb3ImIGNvbG9yKQoreworICAgIGlmICghbV9k YXRhLT5tX29wYWNpdHkgfHwgcGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisK KyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRh LT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBpbnQgcmFkaXVzID0gKGZvY3VzUmluZ1dp ZHRoKCkgLSAxKSAvIDI7CisgICAgaW50IG9mZnNldCA9IHJhZGl1cyArIGZvY3VzUmluZ09mZnNl dCgpOworCisgICAgY29uc3QgVmVjdG9yPEludFJlY3Q+JiByZWN0cyA9IGZvY3VzUmluZ1JlY3Rz KCk7CisgICAgdW5zaWduZWQgcmVjdENvdW50ID0gcmVjdHMuc2l6ZSgpOworICAgIEludFJlY3Qg ZmluYWxGb2N1c1JlY3Q7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHJlY3RDb3VudDsg aSsrKSB7CisgICAgICAgIEludFJlY3QgZm9jdXNSZWN0ID0gcmVjdHNbaV07CisgICAgICAgIGZv Y3VzUmVjdC5pbmZsYXRlKG9mZnNldCk7CisgICAgICAgIGZpbmFsRm9jdXNSZWN0LnVuaXRlKGZv Y3VzUmVjdCk7CisgICAgfQorCisgICAgSW50UmVjdCBpbnRSZWN0ID0gZmluYWxGb2N1c1JlY3Q7 CisgICAgSW50UmVjdCB0clJlY3QgPSBtX2RhdGEtPm1hcFJlY3QoZmluYWxGb2N1c1JlY3QpOwor ICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERDKG1fZGF0YSwgdHJSZWN0LCAmaW50 UmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAoIWRjKQor ICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREQy50b1NoaWZ0KCkp OworCisgICAgUkVDVCByZWN0ID0gdHJSZWN0OworICAgIERyYXdGb2N1c1JlY3QoZGMsICZyZWN0 KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdMaW5lRm9yVGV4dChjb25zdCBJbnRQ b2ludCYgb3JpZ2luLCBpbnQgd2lkdGgsIGJvb2wgcHJpbnRpbmcpCit7CisgICAgaWYgKHBhaW50 aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU3Ryb2tlU3R5bGUgb2xkU3R5 bGUgPSBzdHJva2VTdHlsZSgpOworICAgIHNldFN0cm9rZVN0eWxlKFNvbGlkU3Ryb2tlKTsKKyAg ICBkcmF3TGluZShvcmlnaW4sIG9yaWdpbiArIEludFNpemUod2lkdGgsIDApKTsKKyAgICBzZXRT dHJva2VTdHlsZShvbGRTdHlsZSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3TGlu ZUZvck1pc3NwZWxsaW5nT3JCYWRHcmFtbWFyKGNvbnN0IEludFBvaW50JiwgaW50IHdpZHRoLCBi b29sIGdyYW1tYXIpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGlj c0NvbnRleHQ6OnNldFBsYXRmb3JtRmlsbENvbG9yKGNvbnN0IENvbG9yJiBjb2wpCit7CisgICAg bm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldFBsYXRmb3Jt U3Ryb2tlQ29sb3IoY29uc3QgQ29sb3ImIGNvbCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOwor fQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TdHJva2VUaGlja25lc3MoZmxv YXQgc3Ryb2tlVGhpY2tuZXNzKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQg R3JhcGhpY3NDb250ZXh0OjpzZXRVUkxGb3JSZWN0KGNvbnN0IEtVUkwmIGxpbmssIGNvbnN0IElu dFJlY3QmIGRlc3RSZWN0KQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3Jh cGhpY3NDb250ZXh0OjphZGRJbm5lclJvdW5kZWRSZWN0Q2xpcChjb25zdCBJbnRSZWN0JiByZWN0 LCBpbnQgdGhpY2tuZXNzKQoreworICAgIC8vIFdlIGNhbiBvbmx5IGNsaXAgcmVjdGFuZ2xlcyBv biBXSU5DRQorICAgIGNsaXAocmVjdCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGVh clJlY3QoY29uc3QgRmxvYXRSZWN0JiByZWN0KQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVk KCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX2RhdGEtPmhhc0FscGhhKCkpIHsKKyAg ICAgICAgSW50UmVjdCB0clJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KG1fZGF0YS0+bWFwUmVjdChy ZWN0KSk7CisgICAgICAgIG1fZGF0YS0+bV9iaXRtYXAtPmNsZWFyUGl4ZWxzKHRyUmVjdCk7Cisg ICAgICAgIHJldHVybjsKKyAgICB9IAorCisgICAgZmlsbFJlY3QocmVjdCwgQ29sb3IoQ29sb3I6 OndoaXRlKSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzdHJva2VSZWN0KGNvbnN0IEZs b2F0UmVjdCYgcmVjdCwgZmxvYXQgd2lkdGgpCit7CisgICAgaWYgKCFtX2RhdGEtPm1fb3BhY2l0 eSB8fCBwYWludGluZ0Rpc2FibGVkKCkgfHwgc3Ryb2tlU3R5bGUoKSA9PSBOb1N0cm9rZSkKKyAg ICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsK KyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCBp bnRSZWN0ID0gZW5jbG9zaW5nSW50UmVjdChyZWN0KTsKKyAgICBJbnRSZWN0IHRyUmVjdCA9IG1f ZGF0YS0+bWFwUmVjdChpbnRSZWN0KTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJhbnNwYXJl bnREQyhtX2RhdGEsIHRyUmVjdCwgJmludFJlY3QpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50 REMuaGRjKCk7CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3Zl KHRyYW5zcGFyZW50REMudG9TaGlmdCgpKTsKKworICAgIEhHRElPQkogcGVuID0gY3JlYXRlUGVu KHN0cm9rZUNvbG9yKCksIHN0cm9rZVRoaWNrbmVzcygpLCBzdHJva2VTdHlsZSgpKTsKKyAgICBI R0RJT0JKIG9sZFBlbiA9IFNlbGVjdE9iamVjdChkYywgcGVuKTsKKworICAgIGludCByaWdodCA9 IHRyUmVjdC5yaWdodCgpIC0gMTsKKyAgICBpbnQgYm90dG9tID0gdHJSZWN0LmJvdHRvbSgpIC0g MTsKKyAgICBjb25zdCBQT0lOVCBpbnRQb2ludHNbNV0gPQorICAgIHsKKyAgICAgICAgeyB0clJl Y3QueCgpLCB0clJlY3QueSgpIH0sCisgICAgICAgIHsgcmlnaHQsIHRyUmVjdC55KCkgfSwKKyAg ICAgICAgeyByaWdodCwgYm90dG9tIH0sCisgICAgICAgIHsgdHJSZWN0LngoKSwgYm90dG9tIH0s CisgICAgICAgIHsgdHJSZWN0LngoKSwgdHJSZWN0LnkoKSB9CisgICAgfTsKKworICAgIFBvbHls aW5lKGRjLCBpbnRQb2ludHMsIDUpOworCisgICAgU2VsZWN0T2JqZWN0KGRjLCBvbGRQZW4pOwor ICAgIERlbGV0ZU9iamVjdChwZW4pOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6YmVnaW5U cmFuc3BhcmVuY3lMYXllcihmbG9hdCBvcGFjaXR5KQoreworICAgIG1fZGF0YS0+c2F2ZSgpOwor ICAgIG1fZGF0YS0+bV9vcGFjaXR5ICo9IG9wYWNpdHk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250 ZXh0OjplbmRUcmFuc3BhcmVuY3lMYXllcigpCit7CisgICAgbV9kYXRhLT5yZXN0b3JlKCk7Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0Ojpjb25jYXRDVE0oY29uc3QgVHJhbnNmb3JtYXRpb25N YXRyaXgmIHRyYW5zZm9ybSkKK3sKKyAgICBtX2RhdGEtPmNvbmNhdENUTSh0cmFuc2Zvcm0pOwor fQorCitUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgR3JhcGhpY3NDb250ZXh0OjphZmZpbmVUcmFuc2Zv cm0oKQoreworICAgIHJldHVybiBtX2RhdGEtPm1fdHJhbnNmb3JtOworfQorCitjb25zdCBUcmFu c2Zvcm1hdGlvbk1hdHJpeCYgR3JhcGhpY3NDb250ZXh0OjphZmZpbmVUcmFuc2Zvcm0oKSBjb25z dAoreworICAgIHJldHVybiBtX2RhdGEtPm1fdHJhbnNmb3JtOworfQorCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6cmVzZXRBZmZpbmVUcmFuc2Zvcm0oKQoreworICAgIG1fZGF0YS0+bV90cmFuc2Zv cm0ubWFrZUlkZW50aXR5KCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0Ojp0cmFuc2xhdGUo ZmxvYXQgeCwgZmxvYXQgeSkKK3sKKyAgICBtX2RhdGEtPnRyYW5zbGF0ZSh4LCB5KTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OnJvdGF0ZShmbG9hdCByYWRpYW5zKQoreworICAgIG1fZGF0 YS0+cm90YXRlKHJhZGlhbnMpOworfQorCitJbnRQb2ludCBHcmFwaGljc0NvbnRleHQ6Om9yaWdp bigpCit7CisgICAgcmV0dXJuIG1fZGF0YS0+b3JpZ2luKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3ND b250ZXh0OjpzY2FsZShjb25zdCBGbG9hdFNpemUmIHNpemUpCit7CisgICAgbV9kYXRhLT5zY2Fs ZShzaXplKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldExpbmVDYXAoTGluZUNhcCBs aW5lQ2FwKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250 ZXh0OjpzZXRMaW5lSm9pbihMaW5lSm9pbiBsaW5lSm9pbikKK3sKKyAgICBub3RJbXBsZW1lbnRl ZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0TWl0ZXJMaW1pdChmbG9hdCBtaXRl cikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6 c2V0QWxwaGEoZmxvYXQgYWxwaGEpCit7CisgICAgbV9kYXRhLT5tX29wYWNpdHkgPSBhbHBoYTsK K30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldENvbXBvc2l0ZU9wZXJhdGlvbihDb21wb3Np dGVPcGVyYXRvciBvcCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBo aWNzQ29udGV4dDo6YmVnaW5QYXRoKCkKK3sKKyAgICBtX2RhdGEtPm1fcGF0aHMuY2xlYXIoKTsK K30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZFBhdGgoY29uc3QgUGF0aCYgcGF0aCkKK3sK KyAgICBtX2RhdGEtPm1fcGF0aHMuYXBwZW5kKHBhdGgpOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6Y2xpcChjb25zdCBQYXRoJiBwYXRoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwT3V0KGNvbnN0IFBhdGgmKQoreworICAgIG5v dEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwT3V0RWxsaXBz ZUluUmVjdChjb25zdCBJbnRSZWN0JikKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2 b2lkIEdyYXBoaWNzQ29udGV4dDo6ZmlsbFJvdW5kZWRSZWN0KGNvbnN0IEludFJlY3QmLCBjb25z dCBJbnRTaXplJiB0b3BMZWZ0LCBjb25zdCBJbnRTaXplJiB0b3BSaWdodCwgY29uc3QgSW50U2l6 ZSYgYm90dG9tTGVmdCwgY29uc3QgSW50U2l6ZSYgYm90dG9tUmlnaHQsIGNvbnN0IENvbG9yJikK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCitGbG9hdFJlY3QgR3JhcGhpY3NDb250ZXh0 Ojpyb3VuZFRvRGV2aWNlUGl4ZWxzKGNvbnN0IEZsb2F0UmVjdCYgZnJlY3QpCit7CisgICAgbm90 SW1wbGVtZW50ZWQoKTsKKyAgICByZXR1cm4gZnJlY3Q7Cit9CisKK0NvbG9yIGdyYWRpZW50QXZl cmFnZUNvbG9yKGNvbnN0IEdyYWRpZW50KiBncmFkaWVudCkKK3sKKyAgICBjb25zdCBWZWN0b3I8 R3JhZGllbnQ6OkNvbG9yU3RvcD4mIHN0b3BzID0gZ3JhZGllbnQtPmdldFN0b3BzKCk7CisgICAg aWYgKHN0b3BzLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIENvbG9yKCk7CisKKyAgICBjb25z dCBHcmFkaWVudDo6Q29sb3JTdG9wJiBzdG9wID0gc3RvcHMuZmlyc3QoKTsKKyAgICBpZiAoc3Rv cHMuc2l6ZSgpID09IDEpCisgICAgICAgIHJldHVybiBDb2xvcihzdG9wLnJlZCwgc3RvcC5ncmVl biwgc3RvcC5ibHVlLCBzdG9wLmFscGhhKTsKKworICAgIGNvbnN0IEdyYWRpZW50OjpDb2xvclN0 b3AmIGxhc3RTdG9wID0gc3RvcHMubGFzdCgpOworICAgIHJldHVybiBDb2xvcigoc3RvcC5yZWQg KyBsYXN0U3RvcC5yZWQpICogMC41ZgorICAgICAgICAsIChzdG9wLmdyZWVuICsgbGFzdFN0b3Au Z3JlZW4pICogMC41ZgorICAgICAgICAsIChzdG9wLmJsdWUgKyBsYXN0U3RvcC5ibHVlKSAqIDAu NWYKKyAgICAgICAgLCAoc3RvcC5hbHBoYSArIGxhc3RTdG9wLmFscGhhKSAqIDAuNWYpOworfQor Cit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZmlsbFBhdGgoKQoreworICAgIENvbG9yIGMgPSBtX2Nv bW1vbi0+c3RhdGUuZmlsbENvbG9yU3BhY2UgPT0gR3JhZGllbnRDb2xvclNwYWNlICYmIG1fY29t bW9uLT5zdGF0ZS5maWxsR3JhZGllbnQKKyAgICAgICAgPyBncmFkaWVudEF2ZXJhZ2VDb2xvciht X2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50LmdldCgpKQorICAgICAgICA6IGZpbGxDb2xvcigp OworCisgICAgaWYgKCFjLmFscGhhKCkgfHwgIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICBy ZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlm ICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAobV9kYXRhLT5tX29w YWNpdHkgPCAxLjBmIHx8IG1fZGF0YS0+aGFzQWxwaGEoKSkgeworICAgICAgICBIR0RJT0JKIGJy dXNoID0gY3JlYXRlQnJ1c2goYyk7CisgICAgICAgIGZvciAoVmVjdG9yPFBhdGg+Ojpjb25zdF9p dGVyYXRvciBpID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7IGkgIT0gbV9kYXRhLT5tX3BhdGhz LmVuZCgpOyArK2kpIHsKKyAgICAgICAgICAgIEludFJlY3QgdHJSZWN0ID0gZW5jbG9zaW5nSW50 UmVjdChtX2RhdGEtPm1hcFJlY3QoaS0+Ym91bmRpbmdSZWN0KCkpKTsKKyAgICAgICAgICAgIHRy UmVjdC5pbmZsYXRlKDEpOworICAgICAgICAgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFy ZW50REMobV9kYXRhLCB0clJlY3QpOworICAgICAgICAgICAgSERDIGRjID0gdHJhbnNwYXJlbnRE Qy5oZGMoKTsKKyAgICAgICAgICAgIGlmICghZGMpCisgICAgICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IHRyID0gbV9kYXRhLT5tX3RyYW5z Zm9ybTsKKyAgICAgICAgICAgIHRyLnRyYW5zbGF0ZSh0cmFuc3BhcmVudERDLnRvU2hpZnQoKS53 aWR0aCgpLCB0cmFuc3BhcmVudERDLnRvU2hpZnQoKS5oZWlnaHQoKSk7CisKKyAgICAgICAgICAg IFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKyAgICAgICAgICAg IEhHRElPQkogb2xkQnJ1c2ggPSBTZWxlY3RPYmplY3QoZGMsIGJydXNoKTsKKyAgICAgICAgICAg IGktPnBsYXRmb3JtUGF0aCgpLT5maWxsUGF0aChkYywgJnRyKTsKKyAgICAgICAgICAgIFNlbGVj dE9iamVjdChkYywgb2xkQnJ1c2gpOworICAgICAgICB9CisgICAgICAgIERlbGV0ZU9iamVjdChi cnVzaCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgU2VsZWN0T2JqZWN0KG1fZGF0YS0+bV9kYywg R2V0U3RvY2tPYmplY3QoTlVMTF9QRU4pKTsKKyAgICAgICAgSEdESU9CSiBicnVzaCA9IGNyZWF0 ZUJydXNoKGMpOworICAgICAgICBIR0RJT0JKIG9sZEJydXNoID0gU2VsZWN0T2JqZWN0KG1fZGF0 YS0+bV9kYywgYnJ1c2gpOworICAgICAgICBmb3IgKFZlY3RvcjxQYXRoPjo6Y29uc3RfaXRlcmF0 b3IgaSA9IG1fZGF0YS0+bV9wYXRocy5iZWdpbigpOyBpICE9IG1fZGF0YS0+bV9wYXRocy5lbmQo KTsgKytpKQorICAgICAgICAgICAgaS0+cGxhdGZvcm1QYXRoKCktPmZpbGxQYXRoKG1fZGF0YS0+ bV9kYywgJm1fZGF0YS0+bV90cmFuc2Zvcm0pOworICAgICAgICBTZWxlY3RPYmplY3QobV9kYXRh LT5tX2RjLCBvbGRCcnVzaCk7CisgICAgICAgIERlbGV0ZU9iamVjdChicnVzaCk7CisgICAgfQor fQorCisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzdHJva2VQYXRoKCkKK3sKKyAgICBpZiAoIW1f ZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIg ZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1 cm47CisKKyAgICBpZiAobV9kYXRhLT5tX29wYWNpdHkgPCAxLjBmIHx8IG1fZGF0YS0+aGFzQWxw aGEoKSkgeworICAgICAgICBIR0RJT0JKIHBlbiA9IGNyZWF0ZVBlbihzdHJva2VDb2xvcigpLCBz dHJva2VUaGlja25lc3MoKSwgc3Ryb2tlU3R5bGUoKSk7CisgICAgICAgIGZvciAoVmVjdG9yPFBh dGg+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9kYXRhLT5tX3BhdGhzLmJlZ2luKCk7IGkgIT0gbV9k YXRhLT5tX3BhdGhzLmVuZCgpOyArK2kpIHsKKyAgICAgICAgICAgIEludFJlY3QgdHJSZWN0ID0g ZW5jbG9zaW5nSW50UmVjdChtX2RhdGEtPm1hcFJlY3QoaS0+Ym91bmRpbmdSZWN0KCkpKTsKKyAg ICAgICAgICAgIHRyUmVjdC5pbmZsYXRlKDEpOworICAgICAgICAgICAgVHJhbnNwYXJlbnRMYXll ckRDIHRyYW5zcGFyZW50REMobV9kYXRhLCB0clJlY3QpOworICAgICAgICAgICAgSERDIGRjID0g dHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICAgICAgICAgIGlmICghZGMpCisgICAgICAgICAgICAg ICAgY29udGludWU7CisKKyAgICAgICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IHRyID0gbV9k YXRhLT5tX3RyYW5zZm9ybTsKKyAgICAgICAgICAgIHRyLnRyYW5zbGF0ZSh0cmFuc3BhcmVudERD LnRvU2hpZnQoKS53aWR0aCgpLCB0cmFuc3BhcmVudERDLnRvU2hpZnQoKS5oZWlnaHQoKSk7CisK KyAgICAgICAgICAgIFNlbGVjdE9iamVjdChkYywgR2V0U3RvY2tPYmplY3QoTlVMTF9CUlVTSCkp OworICAgICAgICAgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QoZGMsIHBlbik7Cisg ICAgICAgICAgICBpLT5wbGF0Zm9ybVBhdGgoKS0+c3Ryb2tlUGF0aChkYywgJnRyKTsKKyAgICAg ICAgICAgIFNlbGVjdE9iamVjdChkYywgb2xkUGVuKTsKKyAgICAgICAgfQorICAgICAgICBEZWxl dGVPYmplY3QocGVuKTsKKyAgICB9IGVsc2UgeworICAgICAgICBTZWxlY3RPYmplY3QobV9kYXRh LT5tX2RjLCBHZXRTdG9ja09iamVjdChOVUxMX0JSVVNIKSk7CisgICAgICAgIEhHRElPQkogcGVu ID0gY3JlYXRlUGVuKHN0cm9rZUNvbG9yKCksIHN0cm9rZVRoaWNrbmVzcygpLCBzdHJva2VTdHls ZSgpKTsKKyAgICAgICAgSEdESU9CSiBvbGRQZW4gPSBTZWxlY3RPYmplY3QobV9kYXRhLT5tX2Rj LCBwZW4pOworICAgICAgICBmb3IgKFZlY3RvcjxQYXRoPjo6Y29uc3RfaXRlcmF0b3IgaSA9IG1f ZGF0YS0+bV9wYXRocy5iZWdpbigpOyBpICE9IG1fZGF0YS0+bV9wYXRocy5lbmQoKTsgKytpKQor ICAgICAgICAgICAgaS0+cGxhdGZvcm1QYXRoKCktPnN0cm9rZVBhdGgobV9kYXRhLT5tX2RjLCAm bV9kYXRhLT5tX3RyYW5zZm9ybSk7CisgICAgICAgIFNlbGVjdE9iamVjdChtX2RhdGEtPm1fZGMs IG9sZFBlbik7CisgICAgICAgIERlbGV0ZU9iamVjdChwZW4pOworICAgIH0KK30KKwordm9pZCBH cmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0UmVjdCYgciwgY29uc3QgR3JhZGll bnQqIGdyYWRpZW50KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJl dHVybjsKKworICAgIGNvbnN0IFZlY3RvcjxHcmFkaWVudDo6Q29sb3JTdG9wPiYgc3RvcHMgPSBn cmFkaWVudC0+Z2V0U3RvcHMoKTsKKyAgICBpZiAoc3RvcHMuaXNFbXB0eSgpKQorICAgICAgICBy ZXR1cm47CisKKyAgICBzaXplX3QgbnVtU3RvcHMgPSBzdG9wcy5zaXplKCk7CisgICAgaWYgKG51 bVN0b3BzID09IDEpIHsKKyAgICAgICAgY29uc3QgR3JhZGllbnQ6OkNvbG9yU3RvcCYgc3RvcCA9 IHN0b3BzLmZpcnN0KCk7CisgICAgICAgIENvbG9yIGNvbG9yKHN0b3AucmVkLCBzdG9wLmdyZWVu LCBzdG9wLmJsdWUsIHN0b3AuYWxwaGEpOworICAgICAgICBmaWxsUmVjdChyLCBjb2xvcik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9IAorICAgIAorICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3Zp ZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKwor ICAgIEludFJlY3QgaW50UmVjdCA9IGVuY2xvc2luZ0ludFJlY3Qocik7CisgICAgSW50UmVjdCBy ZWN0ID0gbV9kYXRhLT5tYXBSZWN0KGludFJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0 cmFuc3BhcmVudERDKG1fZGF0YSwgcmVjdCwgJmludFJlY3QsIDI1NSwgdHJ1ZSk7CisgICAgSERD IGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47 CisKKyAgICByZWN0Lm1vdmUodHJhbnNwYXJlbnREQy50b1NoaWZ0KCkpOworICAgIEZsb2F0UG9p bnQgZnAwID0gbV9kYXRhLT5tYXBQb2ludChncmFkaWVudC0+cDAoKSk7CisgICAgRmxvYXRQb2lu dCBmcDEgPSBtX2RhdGEtPm1hcFBvaW50KGdyYWRpZW50LT5wMSgpKTsKKyAgICBJbnRQb2ludCBw MChzdGFibGVSb3VuZChmcDAueCgpKSwgc3RhYmxlUm91bmQoZnAwLnkoKSkpOworICAgIEludFBv aW50IHAxKHN0YWJsZVJvdW5kKGZwMS54KCkpLCBzdGFibGVSb3VuZChmcDEueSgpKSk7CisgICAg cDAgKz0gdHJhbnNwYXJlbnREQy50b1NoaWZ0KCk7CisgICAgcDEgKz0gdHJhbnNwYXJlbnREQy50 b1NoaWZ0KCk7CisKKyAgICBpZiAoZ3JhZGllbnQtPmlzUmFkaWFsKCkpIHsKKyAgICAgICAgaWYg KGdfcmFkaWFsR3JhZGllbnRGaWxsZXIpIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBkb24ndCBz dXBwb3J0IDJEIHNjYWxpbmcgYXQgdGhpcyB0aW1lCisgICAgICAgICAgICBkb3VibGUgc2NhbGUg PSAobV9kYXRhLT5tX3RyYW5zZm9ybS5hKCkgKyBtX2RhdGEtPm1fdHJhbnNmb3JtLmQoKSkgKiAw LjU7CisgICAgICAgICAgICBmbG9hdCByMCA9IGdyYWRpZW50LT5yMCgpICogc2NhbGU7CisgICAg ICAgICAgICBmbG9hdCByMSA9IGdyYWRpZW50LT5yMSgpICogc2NhbGU7CisgICAgICAgICAgICBn X3JhZGlhbEdyYWRpZW50RmlsbGVyKGRjLCByZWN0LCBwMCwgcDEsIHIwLCByMSwgZ3JhZGllbnQt PmdldFN0b3BzKCkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfSBlbHNl IGlmIChnX2xpbmVhckdyYWRpZW50RmlsbGVyKSB7CisgICAgICAgIGdfbGluZWFyR3JhZGllbnRG aWxsZXIoZGMsIHJlY3QsIHAwLCBwMSwgZ3JhZGllbnQtPmdldFN0b3BzKCkpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgLy8gU2ltcGxlIDFEIGxpbmVhciBzb2x1dGlvbiB0aGF0IGFz c3VtZXMgcDAgaXMgb24gdGhlIHRvcCBvciBsZWZ0IHNpZGUsIGFuZCBwMSBpcyBvbiB0aGUgcmln aHQgb3IgYm90dG9tIHNpZGUKKyAgICBzaXplX3QgbnVtUmVjdHMgPSAobnVtU3RvcHMgLSAxKTsK KyAgICBWZWN0b3I8VFJJVkVSVEVYLCAyMD4gdHY7CisgICAgdHYucmVzaXplKG51bVJlY3RzICog Mik7CisgICAgVmVjdG9yPEdSQURJRU5UX1JFQ1QsIDEwPiBtZXNoOworICAgIG1lc2gucmVzaXpl KG51bVJlY3RzKTsKKyAgICBpbnQgeCA9IHJlY3QueCgpOworICAgIGludCB5ID0gcmVjdC55KCk7 CisgICAgaW50IHdpZHRoID0gcmVjdC53aWR0aCgpOworICAgIGludCBoZWlnaHQgPSByZWN0Lmhl aWdodCgpOworICAgIEZsb2F0U2l6ZSBkID0gZ3JhZGllbnQtPnAxKCkgLSBncmFkaWVudC0+cDAo KTsKKyAgICBib29sIHZlcnRpY2FsID0gYWJzKGQuaGVpZ2h0KCkpID4gYWJzKGQud2lkdGgoKSk7 CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBudW1TdG9wczsgKytpKSB7CisgICAgICAgIGNv bnN0IEdyYWRpZW50OjpDb2xvclN0b3AmIHN0b3AgPSBzdG9wc1tpXTsKKyAgICAgICAgaW50IGlU diA9IGkgPyAyICogaSAtIDEgOiAwOworICAgICAgICB0dltpVHZdLlJlZCA9IHN0b3AucmVkICog MHhGRkZGOworICAgICAgICB0dltpVHZdLkdyZWVuID0gc3RvcC5ncmVlbiAqIDB4RkZGRjsKKyAg ICAgICAgdHZbaVR2XS5CbHVlID0gc3RvcC5ibHVlICogMHhGRkZGOworICAgICAgICB0dltpVHZd LkFscGhhID0gc3RvcC5hbHBoYSAqIDB4RkZGRjsKKyAgICAgICAgaWYgKGkpIHsKKyAgICAgICAg ICAgIHR2W2lUdl0ueCA9IHZlcnRpY2FsID8geCArIHdpZHRoOiB4ICsgd2lkdGggKiBzdG9wLnN0 b3A7CisgICAgICAgICAgICB0dltpVHZdLnkgPSB2ZXJ0aWNhbCA/IHkgKyBoZWlnaHQgKiBzdG9w LnN0b3AgOiB5ICsgaGVpZ2h0OworICAgICAgICAgICAgbWVzaFtpIC0gMV0uVXBwZXJMZWZ0ID0g aVR2IC0gMTsKKyAgICAgICAgICAgIG1lc2hbaSAtIDFdLkxvd2VyUmlnaHQgPSBpVHY7CisgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICB0dltpVHZdLnggPSB4OworICAgICAgICAgICAgdHZb aVR2XS55ID0geTsKKyAgICAgICAgfQorCisgICAgICAgIGlmIChpICYmIGkgPCBudW1SZWN0cykg eworICAgICAgICAgICAgdHZbaVR2ICsgMV0gPSB0dltpVHZdOworICAgICAgICAgICAgaWYgKHZl cnRpY2FsKQorICAgICAgICAgICAgICAgIHR2W2lUdiArIDFdLnggPSB4OworICAgICAgICAgICAg ZWxzZQorICAgICAgICAgICAgICAgIHR2W2lUdiArIDFdLnkgPSB5OworICAgICAgICB9CisgICAg fQorCisgICAgR3JhZGllbnRGaWxsKGRjLCB0di5kYXRhKCksIHR2LnNpemUoKSwgbWVzaC5kYXRh KCksIG1lc2guc2l6ZSgpLCB2ZXJ0aWNhbCA/IEdSQURJRU5UX0ZJTExfUkVDVF9WIDogR1JBRElF TlRfRklMTF9SRUNUX0gpOworfQorCitUcmFuc2Zvcm1hdGlvbk1hdHJpeCBHcmFwaGljc0NvbnRl eHQ6OmdldENUTSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fZGF0YS0+bV90cmFuc2Zvcm07Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpjbGlwVG9JbWFnZUJ1ZmZlcihjb25zdCBGbG9hdFJl Y3QmLCBjb25zdCBJbWFnZUJ1ZmZlciopCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmZpbGxSZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKK3sK KyAgICBpZiAobV9jb21tb24tPnN0YXRlLmZpbGxDb2xvclNwYWNlID09IEdyYWRpZW50Q29sb3JT cGFjZSAmJiBtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50KQorICAgICAgICBmaWxsUmVjdChy ZWN0LCBtX2NvbW1vbi0+c3RhdGUuZmlsbEdyYWRpZW50LmdldCgpKTsKKyAgICBlbHNlCisgICAg ICAgIGZpbGxSZWN0KHJlY3QsIGZpbGxDb2xvcigpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRl eHQ6OnNldFBsYXRmb3JtU2hhZG93KGNvbnN0IEludFNpemUmLCBpbnQsIGNvbnN0IENvbG9yJikK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6Y2xl YXJQbGF0Zm9ybVNoYWRvdygpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBH cmFwaGljc0NvbnRleHQ6OnNldEltYWdlSW50ZXJwb2xhdGlvblF1YWxpdHkoSW50ZXJwb2xhdGlv blF1YWxpdHkpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKworc3RhdGljIGlubGluZSBi b29sIGlzQ2hhclZpc2libGUoVUNoYXIgYykKK3sKKyAgICByZXR1cm4gYyAmJiBjICE9IHplcm9X aWR0aFNwYWNlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd1RleHQoY29uc3QgRm9u dCYgZm9udCwgY29uc3QgVGV4dFJ1biYgcnVuLCBjb25zdCBJbnRQb2ludCYgcG9pbnQsIGludCBm cm9tLCBpbnQgdG8pCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSB8fCAhZmlsbENvbG9y KCkuYWxwaGEoKSB8fCAhbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJldHVybjsKKworICAg IGJvb2wgbXVzdFN1cHBvcnRBbHBoYSA9IG1fZGF0YS0+aGFzQWxwaGEoKTsKKworICAgIGlmICgh bXVzdFN1cHBvcnRBbHBoYSAmJiBmaWxsQ29sb3IoKS5hbHBoYSgpID09IDB4RkYgJiYgbV9kYXRh LT5tX29wYWNpdHkgPj0gMS4wKSB7CisgICAgICAgIGZvbnQuZHJhd1RleHQodGhpcywgcnVuLCBw b2ludCwgZnJvbSwgdG8pOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZmxvYXQgb2xk T3BhY2l0eSA9IG1fZGF0YS0+bV9vcGFjaXR5OworICAgIG1fZGF0YS0+bV9vcGFjaXR5ICo9IGZp bGxDb2xvcigpLmFscGhhKCkgLyAyNTUuMDsKKworICAgIEZsb2F0UmVjdCB0ZXh0UmVjdCA9IGZv bnQuc2VsZWN0aW9uUmVjdEZvclRleHQocnVuLCBwb2ludCwgZm9udC5oZWlnaHQoKSwgZnJvbSwg dG8pOworICAgIHRleHRSZWN0LnNldFkodGV4dFJlY3QueSgpIC0gZm9udC5hc2NlbnQoKSk7Cisg ICAgSW50UmVjdCB0clJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KG1fZGF0YS0+bWFwUmVjdCh0ZXh0 UmVjdCkpOworICAgIFJFQ1QgYm1wUmVjdDsKKyAgICBBbHBoYVBhaW50VHlwZSBhbHBoYVBhaW50 VHlwZSA9IG11c3RTdXBwb3J0QWxwaGEgPyBBbHBoYVBhaW50T3RoZXIgOiBBbHBoYVBhaW50Tm9u ZTsKKyAgICBpZiAoUmVmUHRyPFNoYXJlZEJpdG1hcD4gYm1wID0gbV9kYXRhLT5nZXRUcmFuc3Bh cmVudExheWVyQml0bWFwKHRyUmVjdCwgYWxwaGFQYWludFR5cGUsIGJtcFJlY3QsIHRydWUsIG11 c3RTdXBwb3J0QWxwaGEpKSB7CisgICAgICAgIHsKKyAgICAgICAgICAgIEdyYXBoaWNzQ29udGV4 dCBnYygwKTsKKyAgICAgICAgICAgIGdjLnNldEJpdG1hcChibXApOworICAgICAgICAgICAgZ2Mu c2NhbGUoRmxvYXRTaXplKG1fZGF0YS0+bV90cmFuc2Zvcm0uYSgpLCBtX2RhdGEtPm1fdHJhbnNm b3JtLmQoKSkpOworICAgICAgICAgICAgZm9udC5kcmF3VGV4dCgmZ2MsIHJ1biwgSW50UG9pbnQo MCwgZm9udC5hc2NlbnQoKSksIGZyb20sIHRvKTsKKyAgICAgICAgfQorICAgICAgICB1bnNpZ25l ZCBrZXkxLCBrZXkyOworICAgICAgICBIREMgbWVtREMgPSBibXAtPmdldERDKCZrZXkxLCAma2V5 Mik7CisgICAgICAgIGlmIChtZW1EQykgeworICAgICAgICAgICAgbV9kYXRhLT5wYWludEJhY2tU cmFuc3BhcmVudExheWVyQml0bWFwKG1lbURDLCBibXAuZ2V0KCksIHRyUmVjdCwgYWxwaGFQYWlu dFR5cGUsIGJtcFJlY3QpOworICAgICAgICAgICAgYm1wLT5yZWxlYXNlREMobWVtREMsIGtleTEs IGtleTIpOworICAgICAgICB9CisgICAgfQorCisgICAgbV9kYXRhLT5tX29wYWNpdHkgPSBvbGRP cGFjaXR5OworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd1RleHQoY29uc3QgU2ltcGxl Rm9udERhdGEqIGZvbnREYXRhLCBjb25zdCBHbHlwaEJ1ZmZlciYgZ2x5cGhCdWZmZXIsCisgICAg ICAgICAgICAgICAgICAgICAgaW50IGZyb20sIGludCBudW1HbHlwaHMsIGNvbnN0IEZsb2F0UG9p bnQmIHBvaW50KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJldHVy bjsKKworICAgIGZvciAoOzspIHsKKyAgICAgICAgaWYgKCFudW1HbHlwaHMpCisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIGlmIChpc0NoYXJWaXNpYmxlKCpnbHlwaEJ1ZmZlci5nbHlwaHMo ZnJvbSkpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICsrZnJvbTsKKyAgICAgICAgLS1u dW1HbHlwaHM7CisgICAgfQorCisgICAgZG91YmxlIHNjYWxlWCA9IG1fZGF0YS0+bV90cmFuc2Zv cm0uYSgpOworICAgIGRvdWJsZSBzY2FsZVkgPSBtX2RhdGEtPm1fdHJhbnNmb3JtLmQoKTsKKwor ICAgIGludCBoZWlnaHQgPSBmb250RGF0YS0+cGxhdGZvcm1EYXRhKCkuc2l6ZSgpICogc2NhbGVZ OworICAgIGludCB3aWR0aCA9IGZvbnREYXRhLT5wbGF0Zm9ybURhdGEoKS5hdmVyYWdlQ2hhcldp ZHRoKCkgKiBzY2FsZVg7CisKKyAgICBpZiAoIWhlaWdodCB8fCAhd2lkdGgpCisgICAgICAgIHJl dHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYg KCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEhGT05UIGhGb250ID0gaGVp Z2h0ID4gMQorICAgICAgICA/IGZvbnREYXRhLT5wbGF0Zm9ybURhdGEoKS5nZXRTY2FsZWRGb250 SGFuZGxlKGhlaWdodCwgc2NhbGVYID09IHNjYWxlWSA/IDAgOiB3aWR0aCkKKyAgICAgICAgOiAw OworCisgICAgRmxvYXRQb2ludCBzdGFydFBvaW50KHBvaW50LngoKSwgcG9pbnQueSgpIC0gZm9u dERhdGEtPmFzY2VudCgpKTsKKyAgICBGbG9hdFBvaW50IHRyUG9pbnQgPSBtX2RhdGEtPm1hcFBv aW50KHN0YXJ0UG9pbnQpOworICAgIGludCB5ID0gc3RhYmxlUm91bmQodHJQb2ludC55KCkpOwor CisgICAgQ29sb3IgY29sb3IgPSBmaWxsQ29sb3IoKTsKKyAgICBpZiAoIWNvbG9yLmFscGhhKCkp CisgICAgICAgIHJldHVybjsKKworICAgIENPTE9SUkVGIGZvbnRDb2xvciA9IFJHQihjb2xvci5y ZWQoKSwgY29sb3IuZ3JlZW4oKSwgY29sb3IuYmx1ZSgpKTsKKworICAgIGlmICghaEZvbnQpIHsK KyAgICAgICAgZG91YmxlIG9mZnNldCA9IHRyUG9pbnQueCgpOworICAgICAgICBjb25zdCBHbHlw aEJ1ZmZlckFkdmFuY2UqIGFkdmFuY2UgPSBnbHlwaEJ1ZmZlci5hZHZhbmNlRGF0YSgpICsgZnJv bTsKKyAgICAgICAgaWYgKHNjYWxlWCA9PSAxLikKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSAx OyBpIDwgbnVtR2x5cGhzOyArK2kpCisgICAgICAgICAgICAgICAgb2Zmc2V0ICs9ICphZHZhbmNl Kys7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSAxOyBpIDwgbnVtR2x5 cGhzOyArK2kpCisgICAgICAgICAgICAgICAgb2Zmc2V0ICs9ICphZHZhbmNlKysgKiBzY2FsZVg7 CisKKyAgICAgICAgb2Zmc2V0ICs9IHdpZHRoOworCisgICAgICAgIE93blB0cjxIUEVOPiBoUGVu KENyZWF0ZVBlbihQU19EQVNILCAxLCBmb250Q29sb3IpKTsKKyAgICAgICAgSEdESU9CSiBvbGRQ ZW4gPSBTZWxlY3RPYmplY3QobV9kYXRhLT5tX2RjLCBoUGVuLmdldCgpKTsKKworICAgICAgICBN b3ZlVG9FeChtX2RhdGEtPm1fZGMsIHN0YWJsZVJvdW5kKHRyUG9pbnQueCgpKSwgeSwgMCk7Cisg ICAgICAgIExpbmVUbyhtX2RhdGEtPm1fZGMsIHN0YWJsZVJvdW5kKG9mZnNldCksIHkpOworCisg ICAgICAgIFNlbGVjdE9iamVjdChtX2RhdGEtPm1fZGMsIG9sZFBlbik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBJbnRTaXplIHNoYWRvd1NpemU7CisgICAgaW50IHNoYWRvd0JsdXIg PSAwOworICAgIENvbG9yIHNoYWRvd0NvbG9yOworICAgIGJvb2wgaGFzU2hhZG93ID0gdGV4dERy YXdpbmdNb2RlKCkgPT0gY1RleHRGaWxsCisgICAgICAgICYmIGdldFNoYWRvdyhzaGFkb3dTaXpl LCBzaGFkb3dCbHVyLCBzaGFkb3dDb2xvcikKKyAgICAgICAgJiYgc2hhZG93Q29sb3IuYWxwaGEo KTsKKyAgICBDT0xPUlJFRiBzaGFkb3dSR0JDb2xvcjsKKyAgICBGbG9hdFBvaW50IHRyU2hhZG93 UG9pbnQ7CisgICAgaWYgKGhhc1NoYWRvdykgeworICAgICAgICBzaGFkb3dSR0JDb2xvciA9IFJH QihzaGFkb3dDb2xvci5yZWQoKSwgc2hhZG93Q29sb3IuZ3JlZW4oKSwgc2hhZG93Q29sb3IuYmx1 ZSgpKTsKKyAgICAgICAgdHJTaGFkb3dQb2ludCA9IG1fZGF0YS0+bWFwUG9pbnQoc3RhcnRQb2lu dCArIHNoYWRvd1NpemUpOworICAgIH0KKworICAgIEhHRElPQkogaE9sZEZvbnQgPSBTZWxlY3RP YmplY3QobV9kYXRhLT5tX2RjLCBoRm9udCk7CisgICAgQ09MT1JSRUYgb2xkVGV4dENvbG9yID0g R2V0VGV4dENvbG9yKG1fZGF0YS0+bV9kYyk7CisgICAgaW50IG9sZFRleHRBbGlnbiA9IEdldFRl eHRBbGlnbihtX2RhdGEtPm1fZGMpOworICAgIFNldFRleHRBbGlnbihtX2RhdGEtPm1fZGMsIDAp OworCisgICAgaW50IG9sZEJrTW9kZSA9IEdldEJrTW9kZShtX2RhdGEtPm1fZGMpOworICAgIFNl dEJrTW9kZShtX2RhdGEtPm1fZGMsIFRSQU5TUEFSRU5UKTsKKworICAgIGlmIChudW1HbHlwaHMg PiAxKSB7CisgICAgICAgIGRvdWJsZSBvZmZzZXQgPSB0clBvaW50LngoKTsKKyAgICAgICAgVmVj dG9yPGludCwgMjU2PiBnbHlwaFNwYWNlKG51bUdseXBocyk7CisgICAgICAgIFZlY3RvcjxVQ2hh ciwgMjU2PiB0ZXh0KG51bUdseXBocyk7CisgICAgICAgIGludCogY3VyU3BhY2UgPSBnbHlwaFNw YWNlLmRhdGEoKTsKKyAgICAgICAgVUNoYXIqIGN1ckNoYXIgPSB0ZXh0LmRhdGEoKTsKKyAgICAg ICAgY29uc3QgVUNoYXIqIHNyY0NoYXIgPSBnbHlwaEJ1ZmZlci5nbHlwaHMoZnJvbSk7CisgICAg ICAgIGNvbnN0IFVDaGFyKiBjb25zdCBzcmNDaGFyRW5kID0gc3JjQ2hhciArIG51bUdseXBoczsK KyAgICAgICAgKmN1ckNoYXIrKyA9ICpzcmNDaGFyKys7CisgICAgICAgIGludCBmaXJzdE9mZnNl dCA9IHN0YWJsZVJvdW5kKG9mZnNldCk7CisgICAgICAgIGludCBsYXN0T2Zmc2V0ID0gZmlyc3RP ZmZzZXQ7CisgICAgICAgIGNvbnN0IEdseXBoQnVmZmVyQWR2YW5jZSogYWR2YW5jZSA9IGdseXBo QnVmZmVyLmFkdmFuY2VEYXRhKCkgKyBmcm9tOworICAgICAgICAvLyBGSVhNRTogRXh0VGV4dE91 dCgpIGNhbiBmbGlwIG92ZXIgZWFjaCB3b3JkIGZvciBSVEwgbGFuZ3VhZ2VzLCBldmVuIHdoZW4g VEFfUlRMUkVBRElORyBpcyBvZmYuCisgICAgICAgIC8vICh0aGlzIGNhbiBiZSBHREkgYnVnIG9y IGZvbnQgZHJpdmVyIGJ1Zz8pCisgICAgICAgIC8vIFdlIGFyZSBub3QgY2xlYXIgaG93IGl0IHBy b2Nlc3NlcyBjaGFyYWN0ZXJzIGFuZCBoYW5kbGVzIHNwZWNpZmllZCBzcGFjZXMuIE9uIHRoZSBv dGhlciBzaWRlLAorICAgICAgICAvLyBvdXIgZ2x5cGggYnVmZmVyIGlzIGFscmVhZHkgaW4gdGhl IGNvcnJlY3Qgb3JkZXIgZm9yIHJlbmRlcmluZy4gU28sIHRoZSBzb2x1dGlvbiBpcyB0aGF0IHdl CisgICAgICAgIC8vIGNhbGwgRXh0VGV4dE91dCgpIGZvciBlYWNoIHNpbmdsZSBjaGFyYWN0ZXIg d2hlbiB0aGUgdGV4dCBjb250YWlucyBhbnkgUlRMIGNoYXJhY3Rlci4KKyAgICAgICAgLy8gVGhp cyBzb2x1dGlvbiBpcyBub3QgcGVyZmVjdCBhcyBpdCBpcyBzbG93ZXIgdGhhbiBjYWxsaW5nIEV4 dFRleHRPdXQoKSBvbmUgdGltZSBmb3IgYWxsIGNoYXJhY3RlcnMuCisgICAgICAgIC8vIERyYXdp bmcgY2hhcmFjdGVycyBvbmUgYnkgb25lIG1heSBiZSB0b28gc2xvdy4KKyAgICAgICAgYm9vbCBk cmF3T25lQnlPbmUgPSBmYWxzZTsKKyAgICAgICAgaWYgKHNjYWxlWCA9PSAxLikgeworICAgICAg ICAgICAgZm9yICg7IHNyY0NoYXIgPCBzcmNDaGFyRW5kOyArK3NyY0NoYXIpIHsKKyAgICAgICAg ICAgICAgICBvZmZzZXQgKz0gKmFkdmFuY2UrKzsKKyAgICAgICAgICAgICAgICBpbnQgb2Zmc2V0 SW50ID0gc3RhYmxlUm91bmQob2Zmc2V0KTsKKyAgICAgICAgICAgICAgICBpZiAoaXNDaGFyVmlz aWJsZSgqc3JjQ2hhcikpIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKCFkcmF3T25lQnlPbmUg JiYgV1RGOjpVbmljb2RlOjpkaXJlY3Rpb24oKnNyY0NoYXIpID09IFdURjo6VW5pY29kZTo6Umln aHRUb0xlZnQpCisgICAgICAgICAgICAgICAgICAgICAgICBkcmF3T25lQnlPbmUgPSB0cnVlOwor ICAgICAgICAgICAgICAgICAgICAqY3VyQ2hhcisrID0gKnNyY0NoYXI7CisgICAgICAgICAgICAg ICAgICAgICpjdXJTcGFjZSsrID0gb2Zmc2V0SW50IC0gbGFzdE9mZnNldDsKKyAgICAgICAgICAg ICAgICAgICAgbGFzdE9mZnNldCA9IG9mZnNldEludDsKKyAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBmb3IgKDsgc3JjQ2hhciA8 IHNyY0NoYXJFbmQ7ICsrc3JjQ2hhcikgeworICAgICAgICAgICAgICAgIG9mZnNldCArPSAqYWR2 YW5jZSsrICogc2NhbGVYOworICAgICAgICAgICAgICAgIGludCBvZmZzZXRJbnQgPSBzdGFibGVS b3VuZChvZmZzZXQpOworICAgICAgICAgICAgICAgIGlmIChpc0NoYXJWaXNpYmxlKCpzcmNDaGFy KSkgeworICAgICAgICAgICAgICAgICAgICBpZiAoIWRyYXdPbmVCeU9uZSAmJiBXVEY6OlVuaWNv ZGU6OmRpcmVjdGlvbigqc3JjQ2hhcikgPT0gV1RGOjpVbmljb2RlOjpSaWdodFRvTGVmdCkKKyAg ICAgICAgICAgICAgICAgICAgICAgIGRyYXdPbmVCeU9uZSA9IHRydWU7CisgICAgICAgICAgICAg ICAgICAgICpjdXJDaGFyKysgPSAqc3JjQ2hhcjsKKyAgICAgICAgICAgICAgICAgICAgKmN1clNw YWNlKysgPSBvZmZzZXRJbnQgLSBsYXN0T2Zmc2V0OworICAgICAgICAgICAgICAgICAgICBsYXN0 T2Zmc2V0ID0gb2Zmc2V0SW50OworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorICAgICAgICBudW1HbHlwaHMgPSBjdXJDaGFyIC0gdGV4dC5kYXRhKCk7CisgICAg ICAgIGlmIChoYXNTaGFkb3cpIHsKKyAgICAgICAgICAgIFNldFRleHRDb2xvcihtX2RhdGEtPm1f ZGMsIHNoYWRvd1JHQkNvbG9yKTsKKyAgICAgICAgICAgIGlmIChkcmF3T25lQnlPbmUpIHsKKyAg ICAgICAgICAgICAgICBpbnQgeFNoYWRvdyA9IGZpcnN0T2Zmc2V0ICsgc3RhYmxlUm91bmQodHJT aGFkb3dQb2ludC54KCkgLSB0clBvaW50LngoKSk7CisgICAgICAgICAgICAgICAgaW50IHlTaGFk b3cgPSBzdGFibGVSb3VuZCh0clNoYWRvd1BvaW50LnkoKSk7CisgICAgICAgICAgICAgICAgZm9y IChpbnQgaSA9IDA7IGkgPCBudW1HbHlwaHM7ICsraSkgeworICAgICAgICAgICAgICAgICAgICBF eHRUZXh0T3V0KG1fZGF0YS0+bV9kYywgeFNoYWRvdywgeVNoYWRvdywgMCwgTlVMTCwgdGV4dC5k YXRhKCkgKyBpLCAxLCAwKTsKKyAgICAgICAgICAgICAgICAgICAgeFNoYWRvdyArPSBnbHlwaFNw YWNlW2ldOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZQorICAgICAgICAg ICAgICAgIEV4dFRleHRPdXQobV9kYXRhLT5tX2RjLCBmaXJzdE9mZnNldCArIHN0YWJsZVJvdW5k KHRyU2hhZG93UG9pbnQueCgpIC0gdHJQb2ludC54KCkpLCBzdGFibGVSb3VuZCh0clNoYWRvd1Bv aW50LnkoKSksIDAsIE5VTEwsIHRleHQuZGF0YSgpLCBudW1HbHlwaHMsIGdseXBoU3BhY2UuZGF0 YSgpKTsKKyAgICAgICAgfQorICAgICAgICBTZXRUZXh0Q29sb3IobV9kYXRhLT5tX2RjLCBmb250 Q29sb3IpOworICAgICAgICBpZiAoZHJhd09uZUJ5T25lKSB7CisgICAgICAgICAgICBpbnQgeCA9 IGZpcnN0T2Zmc2V0OworICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1HbHlwaHM7 ICsraSkgeworICAgICAgICAgICAgICAgIEV4dFRleHRPdXQobV9kYXRhLT5tX2RjLCB4LCB5LCAw LCBOVUxMLCB0ZXh0LmRhdGEoKSArIGksIDEsIDApOworICAgICAgICAgICAgICAgIHggKz0gZ2x5 cGhTcGFjZVtpXTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBF eHRUZXh0T3V0KG1fZGF0YS0+bV9kYywgZmlyc3RPZmZzZXQsIHksIDAsIE5VTEwsIHRleHQuZGF0 YSgpLCBudW1HbHlwaHMsIGdseXBoU3BhY2UuZGF0YSgpKTsKKyAgICB9IGVsc2UgeworICAgICAg ICBVQ2hhciBjID0gKmdseXBoQnVmZmVyLmdseXBocyhmcm9tKTsKKyAgICAgICAgaWYgKGhhc1No YWRvdykgeworICAgICAgICAgICAgU2V0VGV4dENvbG9yKG1fZGF0YS0+bV9kYywgc2hhZG93UkdC Q29sb3IpOworICAgICAgICAgICAgRXh0VGV4dE91dChtX2RhdGEtPm1fZGMsIHN0YWJsZVJvdW5k KHRyU2hhZG93UG9pbnQueCgpKSwgc3RhYmxlUm91bmQodHJTaGFkb3dQb2ludC55KCkpLCAwLCBO VUxMLCAmYywgMSwgMCk7CisgICAgICAgIH0KKyAgICAgICAgU2V0VGV4dENvbG9yKG1fZGF0YS0+ bV9kYywgZm9udENvbG9yKTsKKyAgICAgICAgRXh0VGV4dE91dChtX2RhdGEtPm1fZGMsIHN0YWJs ZVJvdW5kKHRyUG9pbnQueCgpKSwgeSwgMCwgTlVMTCwgJmMsIDEsIDApOworICAgIH0KKworICAg IFNldFRleHRBbGlnbihtX2RhdGEtPm1fZGMsIG9sZFRleHRBbGlnbik7CisgICAgU2V0VGV4dENv bG9yKG1fZGF0YS0+bV9kYywgb2xkVGV4dENvbG9yKTsKKyAgICBTZXRCa01vZGUobV9kYXRhLT5t X2RjLCBvbGRCa01vZGUpOworICAgIFNlbGVjdE9iamVjdChtX2RhdGEtPm1fZGMsIGhPbGRGb250 KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdGcmFtZUNvbnRyb2woY29uc3QgSW50 UmVjdCYgcmVjdCwgdW5zaWduZWQgdHlwZSwgdW5zaWduZWQgc3RhdGUpCit7CisgICAgaWYgKCFt X2RhdGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgY29uc3QgaW50IGJveFdp ZHRoQmVzdCA9IDg7CisgICAgY29uc3QgaW50IGJveEhlaWdodEJlc3QgPSA4OworCisgICAgU2Nv cGVEQ1Byb3ZpZGVyIGRjUHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykK KyAgICAgICAgcmV0dXJuOworCisgICAgSW50UmVjdCB0clJlY3QgPSBtX2RhdGEtPm1hcFJlY3Qo cmVjdCk7CisgICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50REMobV9kYXRhLCB0clJl Y3QsICZyZWN0LCAyNTUsIHRydWUpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50REMuaGRjKCk7 CisgICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIHRyUmVjdC5tb3ZlKHRyYW5zcGFy ZW50REMudG9TaGlmdCgpKTsKKworICAgIFJFQ1QgcmVjdFdpbiA9IHRyUmVjdDsKKworICAgIGlm ICgocmVjdFdpbi5yaWdodCAtIHJlY3RXaW4ubGVmdCkgPCBib3hXaWR0aEJlc3QpIHsKKyAgICAg ICAgUmVmUHRyPFNoYXJlZEJpdG1hcD4gYm1wID0gU2hhcmVkQml0bWFwOjpjcmVhdGVJbnN0YW5j ZSh0cnVlLCBib3hXaWR0aEJlc3QsIGJveEhlaWdodEJlc3QsIHRydWUpOworICAgICAgICBTaGFy ZWRCaXRtYXA6OkRDSG9sZGVyIG1lbURDKGJtcC5nZXQoKSk7CisgICAgICAgIGlmIChtZW1EQy5n ZXQoKSkgeworICAgICAgICAgICAgUkVDVCB0ZW1wUmVjdCA9IHswLCAwLCBib3hXaWR0aEJlc3Qs IGJveEhlaWdodEJlc3R9OworICAgICAgICAgICAgRHJhd0ZyYW1lQ29udHJvbChtZW1EQy5nZXQo KSwgJnRlbXBSZWN0LCB0eXBlLCBzdGF0ZSk7CisKKyAgICAgICAgICAgIDo6U3RyZXRjaEJsdChk YywgcmVjdFdpbi5sZWZ0LCByZWN0V2luLnRvcCwgcmVjdFdpbi5yaWdodCAtIHJlY3RXaW4ubGVm dCwgcmVjdFdpbi5ib3R0b20gLSByZWN0V2luLnRvcCwgbWVtREMuZ2V0KCksIDAsIDAsIGJveFdp ZHRoQmVzdCwgYm94SGVpZ2h0QmVzdCwgU1JDQ09QWSk7CisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICBEcmF3RnJhbWVDb250cm9sKGRjLCAmcmVjdFdpbiwgdHlw ZSwgc3RhdGUpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0ZvY3VzUmVjdChjb25z dCBJbnRSZWN0JiByZWN0KQoreworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAg IHJldHVybjsKKworICAgIFNjb3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAg aWYgKCFtX2RhdGEtPm1fZGMpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0 ID0gbV9kYXRhLT5tYXBSZWN0KHJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3Bh cmVudERDKG1fZGF0YSwgdHJSZWN0LCAmcmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnRE Qy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUo dHJhbnNwYXJlbnREQy50b1NoaWZ0KCkpOworCisgICAgUkVDVCByZWN0V2luID0gdHJSZWN0Owor ICAgIERyYXdGb2N1c1JlY3QoZGMsICZyZWN0V2luKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRl eHQ6OnBhaW50VGV4dEZpZWxkKGNvbnN0IEludFJlY3QmIHJlY3QsIHVuc2lnbmVkIHN0YXRlKQor eworICAgIGlmICghbV9kYXRhLT5tX29wYWNpdHkpCisgICAgICAgIHJldHVybjsKKworICAgIFNj b3BlRENQcm92aWRlciBkY1Byb3ZpZGVyKG1fZGF0YSk7CisgICAgaWYgKCFtX2RhdGEtPm1fZGMp CisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBSZWN0 KHJlY3QpOworICAgIFRyYW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERDKG1fZGF0YSwgdHJS ZWN0LCAmcmVjdCk7CisgICAgSERDIGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAo IWRjKQorICAgICAgICByZXR1cm47CisgICAgdHJSZWN0Lm1vdmUodHJhbnNwYXJlbnREQy50b1No aWZ0KCkpOworCisgICAgUkVDVCByZWN0V2luID0gdHJSZWN0OworICAgIERyYXdFZGdlKGRjLCAm cmVjdFdpbiwgRURHRV9FVENIRUQsIEJGX1JFQ1QgfCBCRl9BREpVU1QpOworICAgIEZpbGxSZWN0 KGRjLCAmcmVjdFdpbiwgcmVpbnRlcnByZXRfY2FzdDxIQlJVU0g+KCgoc3RhdGUgJiBERkNTX0lO QUNUSVZFKSA/IENPTE9SX0JUTkZBQ0UgOiBDT0xPUl9XSU5ET1cpICsgMSkpOworfQorCit2b2lk IEdyYXBoaWNzQ29udGV4dDo6ZHJhd0JpdG1hcChTaGFyZWRCaXRtYXAqIGJtcCwgY29uc3QgSW50 UmVjdCYgZHN0UmVjdEluLCBjb25zdCBJbnRSZWN0JiBzcmNSZWN0LCBDb21wb3NpdGVPcGVyYXRv ciBjb21wb3NpdGVPcCkKK3sKKyAgICBpZiAoIW1fZGF0YS0+bV9vcGFjaXR5KQorICAgICAgICBy ZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92aWRlcihtX2RhdGEpOworICAgIGlm ICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisKKyAgICBJbnRSZWN0IGRzdFJlY3Qg PSBtX2RhdGEtPm1hcFJlY3QoZHN0UmVjdEluKTsKKyAgICBUcmFuc3BhcmVudExheWVyREMgdHJh bnNwYXJlbnREQyhtX2RhdGEsIGRzdFJlY3QsICZkc3RSZWN0SW4sIDI1NSwgdHJ1ZSk7CisgICAg SERDIGRjID0gdHJhbnNwYXJlbnREQy5oZGMoKTsKKyAgICBpZiAoIWRjKQorICAgICAgICByZXR1 cm47CisgICAgZHN0UmVjdC5tb3ZlKHRyYW5zcGFyZW50REMudG9TaGlmdCgpKTsKKworICAgIGJt cC0+ZHJhdyhkYywgZHN0UmVjdCwgc3JjUmVjdCwgY29tcG9zaXRlT3ApOworCisgICAgaWYgKGJt cC0+aXMxNmJpdCgpKQorICAgICAgICB0cmFuc3BhcmVudERDLmZpbGxBbHBoYUNoYW5uZWwoKTsK K30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmRyYXdCaXRtYXBQYXR0ZXJuKFNoYXJlZEJpdG1h cCogYm1wLCBjb25zdCBGbG9hdFJlY3QmIHRpbGVSZWN0SW4sIGNvbnN0IFRyYW5zZm9ybWF0aW9u TWF0cml4JiBwYXR0ZXJuVHJhbnNmb3JtLAorICAgICAgICAgICAgICAgIGNvbnN0IEZsb2F0UG9p bnQmIHBoYXNlLCBDb21wb3NpdGVPcGVyYXRvciBvcCwgY29uc3QgRmxvYXRSZWN0JiBkZXN0UmVj dEluLCBjb25zdCBJbnRTaXplJiBvcmlnU291cmNlU2l6ZSkKK3sKKyAgICBpZiAoIW1fZGF0YS0+ bV9vcGFjaXR5KQorICAgICAgICByZXR1cm47CisKKyAgICBTY29wZURDUHJvdmlkZXIgZGNQcm92 aWRlcihtX2RhdGEpOworICAgIGlmICghbV9kYXRhLT5tX2RjKQorICAgICAgICByZXR1cm47CisK KyAgICBJbnRSZWN0IGludERzdFJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KGRlc3RSZWN0SW4pOwor ICAgIEludFJlY3QgdHJSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KGludERzdFJlY3QpOworICAgIFRy YW5zcGFyZW50TGF5ZXJEQyB0cmFuc3BhcmVudERDKG1fZGF0YSwgdHJSZWN0LCAmaW50RHN0UmVj dCwgMjU1LCB0cnVlKTsKKyAgICBIREMgZGMgPSB0cmFuc3BhcmVudERDLmhkYygpOworICAgIGlm ICghZGMpCisgICAgICAgIHJldHVybjsKKyAgICB0clJlY3QubW92ZSh0cmFuc3BhcmVudERDLnRv U2hpZnQoKSk7CisgICAgRmxvYXRSZWN0IG1vdmVkRHN0UmVjdCA9IG1fZGF0YS0+bV90cmFuc2Zv cm0uaW52ZXJzZSgpLm1hcFJlY3QoRmxvYXRSZWN0KHRyUmVjdCkpOworICAgIEZsb2F0U2l6ZSBt b3ZlZChtb3ZlZERzdFJlY3QubG9jYXRpb24oKSAtIGRlc3RSZWN0SW4ubG9jYXRpb24oKSk7Cisg ICAgVHJhbnNmb3JtYXRpb25NYXRyaXggdHJhbnNmb3JtID0gbV9kYXRhLT5tX3RyYW5zZm9ybTsK KyAgICB0cmFuc2Zvcm0udHJhbnNsYXRlKG1vdmVkLndpZHRoKCksIG1vdmVkLmhlaWdodCgpKTsK KworICAgIGJtcC0+ZHJhd1BhdHRlcm4oZGMsIHRyYW5zZm9ybSwgdGlsZVJlY3RJbiwgcGF0dGVy blRyYW5zZm9ybSwgcGhhc2UsIG9wLCBkZXN0UmVjdEluLCBvcmlnU291cmNlU2l6ZSk7CisKKyAg ICBpZiAoIWJtcC0+aGFzQWxwaGEoKSkKKyAgICAgICAgdHJhbnNwYXJlbnREQy5maWxsQWxwaGFD aGFubmVsKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3SWNvbihISUNPTiBpY29u LCBjb25zdCBJbnRSZWN0JiBkc3RSZWN0SW4sIFVJTlQgZmxhZ3MpCit7CisgICAgaWYgKCFtX2Rh dGEtPm1fb3BhY2l0eSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NvcGVEQ1Byb3ZpZGVyIGRj UHJvdmlkZXIobV9kYXRhKTsKKyAgICBpZiAoIW1fZGF0YS0+bV9kYykKKyAgICAgICAgcmV0dXJu OworCisgICAgSW50UmVjdCBkc3RSZWN0ID0gbV9kYXRhLT5tYXBSZWN0KGRzdFJlY3RJbik7Cisg ICAgVHJhbnNwYXJlbnRMYXllckRDIHRyYW5zcGFyZW50REMobV9kYXRhLCBkc3RSZWN0LCAmZHN0 UmVjdEluLCAyNTUsIHRydWUpOworICAgIEhEQyBkYyA9IHRyYW5zcGFyZW50REMuaGRjKCk7Cisg ICAgaWYgKCFkYykKKyAgICAgICAgcmV0dXJuOworICAgIGRzdFJlY3QubW92ZSh0cmFuc3BhcmVu dERDLnRvU2hpZnQoKSk7CisKKwlEcmF3SWNvbkV4KGRjLCBkc3RSZWN0LngoKSwgZHN0UmVjdC55 KCksIGljb24sIGRzdFJlY3Qud2lkdGgoKSwgZHN0UmVjdC5oZWlnaHQoKSwgMCwgTlVMTCwgZmxh Z3MpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TaG91bGRBbnRpYWxp YXMoYm9vbCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6c2V0TGluZURhc2goY29uc3QgRGFzaEFycmF5JiwgZmxvYXQpCit7CisgICAgbm90SW1w bGVtZW50ZWQoKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmNsaXBQYXRoKFdpbmRSdWxl KQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK