39735 2010-05-26 07:25:21 -0700 Implement CSS Paged Media Module Level3's Page Breaks (master bug) 2020-04-22 05:13:45 -0700 1 1 1 Unclassified WebKit Printing 528+ (Nightly build) PC OS X 10.5 UNCONFIRMED http://dev.w3.org/csswg/css3-page/#page-breaks P2 Normal --- 34155 39732 39733 39734 9410 0 hayato webkit-unassigned benwells douglas hamaji hayato hyatt innovimax itshustletime laszlo.gombos mikelawther m.kurz+webkitbugs niels.giesen norman.jonas peter schenney syoichi t.bussmann webkit.org yuzo oldest_to_newest 230701 0 hayato 2010-05-26 07:25:21 -0700 This is a master bug to track the landing of initial implementation of CSS Paged Media Module Level3's Page Breaks. See http://dev.w3.org/csswg/css3-page/#page-breaks The target of this master bug includes: 9. Page Breaks 9.1. Break before/after elements: ‘page-break-before’, ‘page-break-after’, ‘page-break-inside’ 9.2. Using named pages: ‘page’ 9.3. Breaks inside elements: ‘orphans’, ‘widows’ 9.4. Allowed page breaks 9.5. Forced page breaks 9.6. "Best" page breaks 231204 1 57215 hayato 2010-05-27 03:23:21 -0700 Created attachment 57215 paged-media-page-breaks 231209 2 hayato 2010-05-27 03:48:12 -0700 This is an initial effort to implement CSS3 Paged Media's Page Breaks. I tried to make this patch as small as possible, but it was difficult to split this patch to small pieces because this change would solve/implement the bugs/features at once. I think there are rooms to be improved in the patch. I continue to improve the patch and, if possible, split the patch so that it can be reviewed more easily. I'll update this master bug when the patch is ready for the review. Comments are welcome at this time. 231259 3 57215 hamaji 2010-05-27 06:12:17 -0700 Comment on attachment 57215 paged-media-page-breaks I didn't look at this patch closely yet, but I'd like to put some comments and questions. WebCore/page/PrintContext.cpp:254 + // TODO: Check whether there is a gap between parent and child. We use FIXME instead of TODO. WebCore/page/PageBreak.h:37 + Unnecessary blank line? LayoutTests/printing/script-tests/page-break-after-avoid.js:7 + createBlockWithRatioToPageHeight("page2-1", 0.3).style.pageBreakAfter = "avoid";; s/;;/;/ WebCore/page/PrintContext.cpp:118 + root->setPrintContext(this); Cannot we call setPrintContext in PrintContext::begin and PrintContext::end ? WebCore/page/PrintContext.cpp:420 + score -= 2; Maybe it would be better to add a constant for this 2. WebCore/rendering/RenderView.h:213 + PrintContext* m_printContext; Cannot we remove Document::m_printing by adding this member? WebCore/rendering/RenderLineBoxList.cpp:190 + int lineTotal = 0; Why don't you put lineTotal calculation below line 198 ? 234756 4 57215 yuzo 2010-06-07 03:14:25 -0700 Comment on attachment 57215 paged-media-page-breaks [Informal review] -- I'm not a WebKit reviewer. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 92c00e2b95fa0558850f5fc3a3d088dd7c52b867..846b46970dde842d147bda306ca8ea1e67557ad8 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,64 @@ > +2010-05-27 Hayato Ito <hayato@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Implement CSS3 Peged Media - Page Breaks. > + https://bugs.webkit.org/show_bug.cgi?id=39735 > + > + Rewrite page break determination code. I think the overview of the new algorithm should be given here. > + > + Add supports for the following CSS properties: > + - page-break-{before,after}: avoid > + https://bugs.webkit.org/show_bug.cgi?id=34155 > + - orphans and widows > + https://bugs.webkit.org/show_bug.cgi?id=9410 > + > + The change happened to fix the following bugs as a result: > + - A margin-{top,bottom} should be collapsed when printing. > + https://bugs.webkit.org/show_bug.cgi?id=39732 > + - Printing code should break a page only at allowed page breake positions s/breake/break/ > + https://bugs.webkit.org/show_bug.cgi?id=39733 > + > + Spec link: > + http://dev.w3.org/csswg/css3-page/#page-breaks > + > + Test: existing and new printing/*.html > + > + * WebCore.gypi: > + * WebCore.xcodeproj/project.pbxproj: > + * page/PageBreak.h: Added. > + (WebCore::PageBreak::): > + (WebCore::PageBreak::PageBreak): > + * page/PrintContext.cpp: > + (WebCore::PrintContext::PrintContext): > + (WebCore::PrintContext::~PrintContext): > + (WebCore::PrintContext::computePageRectsWithPageSizeInternal): > + (WebCore::PrintContext::visitRenderBlockBefore): > + (WebCore::PrintContext::visitRenderBlockAfter): > + (WebCore::PrintContext::visitFirstChildBlockBox): > + (WebCore::PrintContext::visitLastChildBlockBox): > + (WebCore::PrintContext::visitBetweenBlockBoxes): > + (WebCore::PrintContext::visitBetweenLineBoxes): > + (WebCore::PrintContext::addPageBreakCandidate): > + (WebCore::PrintContext::addPseudoPageBreak): > + (WebCore::PrintContext::fillLargeGapWithPageBreaks): > + (WebCore::PrintContext::createBridgePageBreak): > + (WebCore::comparePageBreak): > + (WebCore::PrintContext::sortPageBreakCandidates): > + (WebCore::PrintContext::determineBestPageBreaks): > + (WebCore::PrintContext::evaluateScoreOfPageBreak): > + * page/PrintContext.h: > + * rendering/RenderBlock.cpp: > + (WebCore::RenderBlock::paint): > + (WebCore::RenderBlock::paintChildren): > + * rendering/RenderLineBoxList.cpp: > + (WebCore::RenderLineBoxList::paint): > + * rendering/RenderView.cpp: > + (WebCore::RenderView::RenderView): > + * rendering/RenderView.h: > + (WebCore::RenderView::setPrintContext): > + (WebCore::RenderView::printContext): > + > 2010-05-19 Vangelis Kokkevis <vangelis@chromium.org> > > Reviewed by Darin Fisher. > diff --git a/WebCore/WebCore.gypi b/WebCore/WebCore.gypi > index 87bee7a1c9195bc41dcea630595c5faafe4dea23..8a2d6e0eef1ba90c21836e8075f680e538b0e425 100644 > --- a/WebCore/WebCore.gypi > +++ b/WebCore/WebCore.gypi > @@ -1932,6 +1932,7 @@ > 'page/OriginAccessEntry.h', > 'page/Page.cpp', > 'page/Page.h', > + 'page/PageBreak.h', > 'page/PageGroup.cpp', > 'page/PageGroup.h', > 'page/PageGroupLoadDeferrer.cpp', > @@ -1943,6 +1944,7 @@ > 'page/PositionError.h', > 'page/PositionErrorCallback.h', > 'page/PositionOptions.h', > + 'page/PrintContext.h', This should be placed below PrintContext.cpp. (Sort alphabetically) > 'page/PrintContext.cpp', > 'page/PrintContext.h', > 'page/Screen.cpp', > diff --git a/WebCore/WebCore.xcodeproj/project.pbxproj b/WebCore/WebCore.xcodeproj/project.pbxproj > index cab1475ddb9af65d9ebdc1c907657a9316ca2e6a..304a3c8a7a5b42cc000754417be4baee7cb9862b 100644 > --- a/WebCore/WebCore.xcodeproj/project.pbxproj > +++ b/WebCore/WebCore.xcodeproj/project.pbxproj > @@ -1253,6 +1253,7 @@ > 659DDC8209E198BA001BF3C6 /* JSDocument.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 659DDC8009E198BA001BF3C6 /* JSDocument.cpp */; }; > 659DDC8309E198BA001BF3C6 /* JSDocument.h in Headers */ = {isa = PBXBuildFile; fileRef = 659DDC8109E198BA001BF3C6 /* JSDocument.h */; }; > 65A21468097A329100B9050A /* Page.h in Headers */ = {isa = PBXBuildFile; fileRef = 65A21467097A329100B9050A /* Page.h */; settings = {ATTRIBUTES = (Private, ); }; }; > + 4ABF810E113D5227004937D5 /* PageBreak.h in Headers */ = {isa = PBXBuildFile; fileRef = 4ABF810C113D5227004937D5 /* PageBreak.h */; settings = {ATTRIBUTES = (Private, ); }; }; > 65A21484097A3F5300B9050A /* FrameTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 65A21482097A3F5300B9050A /* FrameTree.cpp */; }; > 65A21485097A3F5300B9050A /* FrameTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 65A21483097A3F5300B9050A /* FrameTree.h */; settings = {ATTRIBUTES = (Private, ); }; }; > 65AA6BAF0D974A00000541AE /* DOMSVGAltGlyphElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 65AA6BAC0D974A00000541AE /* DOMSVGAltGlyphElement.h */; }; > @@ -6865,6 +6866,7 @@ > 659DDC8009E198BA001BF3C6 /* JSDocument.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSDocument.cpp; sourceTree = "<group>"; }; > 659DDC8109E198BA001BF3C6 /* JSDocument.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSDocument.h; sourceTree = "<group>"; }; > 65A21467097A329100B9050A /* Page.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = Page.h; sourceTree = "<group>"; }; > + 4ABF810C113D5227004937D5 /* PageBreak.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageBreak.h; sourceTree = "<group>"; }; > 65A21482097A3F5300B9050A /* FrameTree.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FrameTree.cpp; sourceTree = "<group>"; }; > 65A21483097A3F5300B9050A /* FrameTree.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FrameTree.h; sourceTree = "<group>"; }; > 65A640F00533BB1F0085E777 /* BlockExceptions.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = BlockExceptions.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; }; > @@ -11986,6 +11988,7 @@ > 00146289103CD1DE000B20DB /* OriginAccessEntry.h */, > 65FEA86809833ADE00BED4AB /* Page.cpp */, > 65A21467097A329100B9050A /* Page.h */, > + 4ABF810C113D5227004937D5 /* PageBreak.h */, > 9302B0BC0D79F82900C7EE83 /* PageGroup.cpp */, > 9302B0BE0D79F82C00C7EE83 /* PageGroup.h */, > 7A674BD90F9EBF4E006CF099 /* PageGroupLoadDeferrer.cpp */, > @@ -18492,6 +18495,7 @@ > 1A0D57370A5C77FE007EDD4C /* OverflowEvent.h in Headers */, > 3774ABA50FA21EB400AD7DE9 /* OverlapTestRequestClient.h in Headers */, > 65A21468097A329100B9050A /* Page.h in Headers */, > + 4ABF810E113D5227004937D5 /* PageBreak.h in Headers */, > 1477E7770BF4134A00152872 /* PageCache.h in Headers */, > 9302B0BF0D79F82C00C7EE83 /* PageGroup.h in Headers */, > 7A674BDC0F9EBF4E006CF099 /* PageGroupLoadDeferrer.h in Headers */, > diff --git a/WebCore/page/PageBreak.h b/WebCore/page/PageBreak.h > new file mode 100644 > index 0000000000000000000000000000000000000000..2c0e07b0b45bf96ff4f2e68bfec3cd4d9cb4d834 > --- /dev/null > +++ b/WebCore/page/PageBreak.h > @@ -0,0 +1,74 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions are > + * met: > + * > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above > + * copyright notice, this list of conditions and the following disclaimer > + * in the documentation and/or other materials provided with the > + * distribution. > + * * Neither the name of Google Inc. nor the names of its > + * contributors may be used to endorse or promote products derived from > + * this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef PageBreak_h > +#define PageBreak_h > + > +namespace WebCore { > + > +struct PageBreak { > + > + enum PageBreakType { > + BetweenBlockBoxes, // In the vertical margin between sibling bloxes. See CSS3 Paged Media 9.4 - Allowed page breaks 1. > + BetweenLineBoxes, // Between line boxes inside a block box. See CSS3 Paged Media 9.4. - Allowed page breaks 2. > + BetweenBlockBoxAndChild, // Between the content edge of a block box and the child. See CSS3: 9.4. Allowed page breaks - 3. > + Bridge, // An inserted page break in a large blank area where there is no allowd page break. s/allowd/allowed/ > + Pseudo, // Other pseudo page break. For example, the start or the end of document. "Other pseudo page break" connotes that at least one of the above 4 is pseudo. That is not the case, I believe? I don't get the concept of "pseudo page break" either. What does it mean? > + }; > + > + PageBreak() > + : pageBreakType(Pseudo) > + , top(-1) > + , bottom(-1) > + , isAlways(false) > + , isAvoid(false) > + , isVioletingOrphansOrWidowsRule(false) s/Violeting/Violating/ > + { > + } > + > + PageBreakType pageBreakType; > + > + // Absolute Y position where page break occurs. > + int top; > + int bottom; > + > + // Used by CSS3 Paged Media 9.4 - Rule A. Forced page break. > + bool isAlways; > + > + // Used by CSS3 Paged Media 9.4 - Rule B and Rule D. Page break should be avoided here if true. > + bool isAvoid; Using enum instead of two bool's should make sense here, because only one of them can be true. > + > + // Used by CSS3 Pagad Media 9.4 - Rule C. Whether page break violates the rule of orphans and widows or not. > + bool isVioletingOrphansOrWidowsRule; s/Violeting/Violating/ > +}; > + > +} // namespace WebCore > + > +#endif // PageBreak_h > diff --git a/WebCore/page/PrintContext.cpp b/WebCore/page/PrintContext.cpp > index ffde0beb1e3c0be44d7e522977b3ab536286c1d0..a89e81cededc7250e38e39786d9c29e613b1af23 100644 > --- a/WebCore/page/PrintContext.cpp > +++ b/WebCore/page/PrintContext.cpp > @@ -21,11 +21,17 @@ > #include "config.h" > #include "PrintContext.h" > > -#include "GraphicsContext.h" > #include "Frame.h" > -#include "FrameView.h" > +#include "GraphicsContext.h" > +#include "InlineFlowBox.h" > +#include "RenderBlock.h" > +#include "RenderBox.h" > +#include "RenderBoxModelObject.h" > +#include "RenderStyle.h" > #include "RenderView.h" > > +#include <limits> > + > using namespace WebCore; > > namespace WebCore { > @@ -33,6 +39,8 @@ namespace WebCore { > PrintContext::PrintContext(Frame* frame) > : m_frame(frame) > , m_isPrinting(false) > + , m_pageBreakCandidates() Do we need to initialize this explicitly? > + , m_ancestorBlockWithPageBreakInsideAvoid(0) > { > } > > @@ -41,6 +49,7 @@ PrintContext::~PrintContext() > if (m_isPrinting) > end(); > m_pageRects.clear(); > + m_pageBreakCandidates.clear(); > } > > int PrintContext::pageCount() const > @@ -96,25 +105,42 @@ void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSiz > RenderView* root = toRenderView(m_frame->document()->renderer()); > > const float pageWidth = pageSizeInPixels.width(); > + const float pageHeight = pageSizeInPixels.height(); > + > const float docWidth = root->layer()->width(); > const float docHeight = root->layer()->height(); > - float currPageHeight = pageSizeInPixels.height(); > - > - // always return at least one page, since empty files should print a blank page > - float printedPagesHeight = 0; > - do { > - float proposedBottom = std::min(docHeight, printedPagesHeight + pageSizeInPixels.height()); > - m_frame->view()->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight); > - currPageHeight = max(1.0f, proposedBottom - printedPagesHeight); > + > + GraphicsContext context((PlatformGraphicsContext*)0); > + IntRect dirtyRect(0, 0, root->rightLayoutOverflow(), (int)ceilf(docHeight)); How about defining intDocHeight and use it here and below? That'll guarantee consistency. > + > + // Collect allowed page breaks in document. > + ASSERT(!root->printContext()); > + root->setPrintContext(this); > + root->layer()->paint(&context, dirtyRect); > + root->setPrintContext(0); > + > + // Add other psuedo page breaks. > + addPseudoPageBreak(0); > + addPseudoPageBreak((int)ceilf(docHeight)); > + fillLargeGapWithPageBreaks(pageHeight); > + > + Vector<int> bestPageBreakPosition; s/Position/Positions/ ? > + determineBestPageBreaks(pageHeight, &bestPageBreakPosition); > + > + int previousYPosition = 0; > + const int size = bestPageBreakPosition.size(); > + for (int i = 0; i < size; ++i) { > + int yPosition = bestPageBreakPosition[i]; > if (allowHorizontalMultiPages) { > for (float curWidth = 0; curWidth < docWidth; curWidth += pageWidth) > - m_pageRects.append(IntRect(curWidth, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight)); > + m_pageRects.append(IntRect(curWidth, previousYPosition, (int)pageWidth, yPosition - previousYPosition)); > } else > - m_pageRects.append(IntRect(0, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight)); > - printedPagesHeight += currPageHeight; > - } while (printedPagesHeight < docHeight); > + m_pageRects.append(IntRect(0, previousYPosition, (int)pageWidth, yPosition - previousYPosition)); > + previousYPosition = yPosition; > + } > } > > + > void PrintContext::begin(float width) > { > ASSERT(!m_isPrinting); > @@ -209,4 +235,198 @@ int PrintContext::numberOfPages(Frame* frame, const FloatSize& pageSizeInPixels) > return printContext.pageCount(); > } > > +void PrintContext::visitRenderBlockBefore(const RenderBlock* renderBlock) > +{ > + if (!m_ancestorBlockWithPageBreakInsideAvoid && renderBlock->style()->pageBreakInside() == PBAVOID) > + m_ancestorBlockWithPageBreakInsideAvoid = renderBlock; > +} > + > +void PrintContext::visitRenderBlockAfter(const RenderBlock* renderBlock) > +{ > + if (m_ancestorBlockWithPageBreakInsideAvoid == renderBlock) > + m_ancestorBlockWithPageBreakInsideAvoid = 0; > +} > + > +void PrintContext::visitFirstChildBlockBox(int y, const RenderBox* firstChildBox) > +{ > + if (firstChildBox->isFloatingOrPositioned()) > + return; > + // TODO: Check whether there is a gap between parent and child. > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::BetweenBlockBoxAndChild; > + pageBreak.isAlways = firstChildBox->style()->pageBreakBefore() == PBALWAYS; > + pageBreak.top = y + firstChildBox->y(); > + pageBreak.bottom = pageBreak.top; > + pageBreak.isAvoid = m_ancestorBlockWithPageBreakInsideAvoid > + || firstChildBox->style()->pageBreakBefore() == PBAVOID; pageBreak.isAvoid is true if an ancestor is PBAVOID even if the frist child box's is PBALWAYS (Put differently, pageBreak.isAvoid and pagebreak.isAlways can be both true at the same time.) Is this expected? If this is, isn't it confusing? > + addPageBreakCandidate(pageBreak); > +} > + > +void PrintContext::visitLastChildBlockBox(int y, const RenderBox* lastChildBox) > +{ > + if (lastChildBox->isFloatingOrPositioned()) > + return; > + // TODO: Check whether there is a gap between parent and child. > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::BetweenBlockBoxAndChild; > + pageBreak.isAlways = lastChildBox->style()->pageBreakAfter() == PBALWAYS; > + pageBreak.top = y + lastChildBox->y() + lastChildBox->height(); > + pageBreak.bottom = pageBreak.top; > + pageBreak.isAvoid = m_ancestorBlockWithPageBreakInsideAvoid > + || lastChildBox->style()->pageBreakAfter() == PBAVOID; > + addPageBreakCandidate(pageBreak); > +} > + > + > +void PrintContext::visitBetweenBlockBoxes(int y, const RenderBox* precedingBox, const RenderBox* followingBox) I guess visitMiddleBlockBoxes sounds more natural. > +{ > + if (precedingBox->isFloatingOrPositioned() || followingBox->isFloatingOrPositioned()) > + return; > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::BetweenBlockBoxes; > + pageBreak.top = y + precedingBox->y() + precedingBox->height(); > + pageBreak.bottom = y + followingBox->y(); > + pageBreak.isAlways = precedingBox->style()->pageBreakAfter() == PBALWAYS || followingBox->style()->pageBreakBefore() == PBALWAYS; > + pageBreak.isAvoid = m_ancestorBlockWithPageBreakInsideAvoid || precedingBox->style()->pageBreakAfter() == PBAVOID || followingBox->style()->pageBreakBefore() == PBAVOID; > + addPageBreakCandidate(pageBreak); > +} > + > +void PrintContext::visitBetweenLineBoxes(int y, const RenderBoxModelObject* parentRenderBox, const InlineFlowBox* precedingInlineFlowBox, const InlineFlowBox* followingInlineFlowBox, int linesBefore, int linesAfter) s/Between/Middle/ as above. > +{ > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::BetweenLineBoxes; > + pageBreak.top = y + precedingInlineFlowBox->root()->bottomVisibleOverflow(); > + pageBreak.bottom = y + followingInlineFlowBox->root()->topVisibleOverflow(); > + pageBreak.isAvoid = m_ancestorBlockWithPageBreakInsideAvoid; > + pageBreak.isVioletingOrphansOrWidowsRule = linesBefore < parentRenderBox->style()->orphans() || linesAfter < parentRenderBox->style()->widows(); > + addPageBreakCandidate(pageBreak); > } > + > +void PrintContext::addPageBreakCandidate(const PageBreak& pageBreak) > +{ > + if (pageBreak.bottom >= 0 && pageBreak.top <= pageBreak.bottom) > + m_pageBreakCandidates.append(pageBreak); > +} > + > +void PrintContext::addPseudoPageBreak(int y) > +{ > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::Pseudo; > + pageBreak.top = y; > + pageBreak.bottom = y; > + addPageBreakCandidate(pageBreak); > +} > + > +void PrintContext::fillLargeGapWithPageBreaks(int printHeight) > +{ > + sortPageBreakCandidates(); > + PageBreakCandidates bridges; > + const unsigned int candidatesSize = m_pageBreakCandidates.size(); > + for (unsigned int candidateIndex = 0; candidateIndex + 1 < candidatesSize; ++candidateIndex) { > + const int gapStart = m_pageBreakCandidates[candidateIndex].bottom; > + const int gapEnd = m_pageBreakCandidates[candidateIndex + 1].top; > + const int gap = gapEnd - gapStart; > + if (gap <= printHeight) > + continue; > + // We found a 'gap' whose height is larger than printHeight between allowed page breaks. > + // We must fill the area with pseudo page breaks, called 'bridge'. > + for (int previousIndex = candidateIndex; previousIndex >= 0; --previousIndex) { > + int currentY = m_pageBreakCandidates[previousIndex].bottom + printHeight; > + if (currentY <= gapStart) > + break; > + while (currentY < gapEnd) { > + bridges.append(createBridgePageBreak(currentY)); > + currentY += printHeight; > + } > + } > + } > + m_pageBreakCandidates.appendRange(bridges.begin(), bridges.end()); > + sortPageBreakCandidates(); > +} > + > +PageBreak PrintContext::createBridgePageBreak(int y) > +{ > + PageBreak pageBreak; > + pageBreak.pageBreakType = PageBreak::Bridge; > + pageBreak.top = y; > + pageBreak.bottom = y; > + return pageBreak; > +} > + > +static bool comparePageBreak(const PageBreak& a, const PageBreak& b) > +{ > + return a.bottom < b.bottom || (a.bottom == b.bottom && a.top < b.top); > +} > + > +void PrintContext::sortPageBreakCandidates() > +{ > + std::sort(m_pageBreakCandidates.begin(), m_pageBreakCandidates.end(), comparePageBreak); > +} > + > +void PrintContext::determineBestPageBreaks(int printHeight, Vector<int>* bestPageBreakPosition) const > +{ > + const unsigned int candidatesSize = m_pageBreakCandidates.size(); > + ASSERT(candidatesSize > 0); > + ASSERT(!m_pageBreakCandidates[0].bottom); Is this true for an empty document? > + ASSERT(bestPageBreakPosition && bestPageBreakPosition->isEmpty()); How about clearing the vector instead of requiring its emptiness? > + Vector<int> score(candidatesSize, std::numeric_limits<int>::min()); > + Vector<int> pageNumber(candidatesSize, 0); > + Vector<int> previousIndex(candidatesSize, -1); I think these vectors should have plural names, e.g., scores? > + score[0] = 0; > + > + for (unsigned int current = 1; current < candidatesSize; ++current) { > + const PageBreak& currentPageBreak = m_pageBreakCandidates[current]; > + int bestIndex = -1; > + int bestScore = std::numeric_limits<int>::min(); > + int bestPageNumber = std::numeric_limits<int>::max(); > + > + for (int previous = current - 1; previous >= 0; --previous) { > + const PageBreak& previousPageBreak = m_pageBreakCandidates[previous]; > + const int pageHeight = currentPageBreak.top - previousPageBreak.bottom; > + if (pageHeight < 0) > + continue; > + if (pageHeight > printHeight) > + break; > + > + if (bestScore < score[previous] || bestScore == score[previous] && bestPageNumber > pageNumber[previous]) { > + bestIndex = previous; > + bestScore = score[previous]; > + bestPageNumber = pageNumber[previous]; > + } > + } > + > + ASSERT(bestIndex != -1); > + pageNumber[current] = bestPageNumber + 1; > + previousIndex[current] = bestIndex; > + score[current] = bestScore + evaluateScoreOfPageBreak(currentPageBreak); > + } > + > + int selectedPageBreakIndex = candidatesSize - 1; > + int previousPageBreakPosition = -1; > + while (selectedPageBreakIndex > 0) { > + const int pageBreakPosition = m_pageBreakCandidates[selectedPageBreakIndex].bottom; > + if (pageBreakPosition != previousPageBreakPosition) > + bestPageBreakPosition->append(pageBreakPosition); > + previousPageBreakPosition = pageBreakPosition; > + selectedPageBreakIndex = previousIndex[selectedPageBreakIndex]; > + } > + std::reverse(bestPageBreakPosition->begin(), bestPageBreakPosition->end()); > +} > + > +int PrintContext::evaluateScoreOfPageBreak(const PageBreak& pageBreak) > +{ > + int score = 0; > + if (pageBreak.pageBreakType == PageBreak::Bridge) > + score -= 2; > + else if (pageBreak.isAlways) > + score += 2; As commented above, pageBreak.isAlways and pageBreak.isAvoid can be both true at the same time. That's why isAlways is checked first here. I don't think it is a robust way of coding. (At least it is confusing for the code reader.) > + else { > + if (pageBreak.isAvoid) > + score -= 2; > + if (pageBreak.isVioletingOrphansOrWidowsRule) > + --score; > + } > + return score; > +} > + > +} // namespace WebCore 235112 5 hayato 2010-06-07 20:23:01 -0700 Thank you for the review. I am addressing your comments. I'll update the patch in a few days. I also think it would be better that Hyatt could review this patch at an early stage to avoid possible duplicated works. I'll ask him to review. 237035 6 hyatt 2010-06-11 14:29:51 -0700 Ok, so the major architectural problem I have with this patch is that you put all this code in PrintContext. Remember that CSS3 multi-column has the same features, so piling a bunch of page-only code into PrintContext is not the right way to build this. You need to make sure breaking code is shared by columns and pages and not limited just to pages. My additional concern is that all this code is being piled on top of the broken paginate-during-painting model. I'd prefer that we hold off on adding new page breaking features until the new model is in place. WWDC and the launch of Safari 5 has delayed my starting on this, but it is the next task I'll be working on. 237037 7 57215 hyatt 2010-06-11 14:31:03 -0700 Comment on attachment 57215 paged-media-page-breaks r-. See previous comment. 237675 8 hayato 2010-06-13 19:59:53 -0700 Hi Dave, Thank you for the comment. That makes sense. I have the exactly same concern because I heard your plan to re-architecture current paging code. As for layout tests includes in the patch, I'll extract them as an independent patch because they might be usuful. I am still in curious how you are to determine page breaks in your re-architecture. I am using 'scoring' method this time. It is simple and most effective way between the methods I've tried. I guess the idea itself and some piece of code might be useful in your future works. Thanks. 359645 9 hayato 2011-02-28 21:01:45 -0800 I have a plan to resume my work in a few weeks. I'll try to update this bug entry. 383873 10 hayato 2011-04-12 01:23:53 -0700 I don't have a plan to resume my work for the near future. I tried to re-apply my patch to the new paging model, but it turns out that it might take some non-trivial efforts. (In reply to comment #9) > I have a plan to resume my work in a few weeks. I'll try to update this bug entry. 408721 11 hayato 2011-05-24 01:30:29 -0700 I've received several inquiries about the status of this issue recently in personal. So let me update the status: - Nothing has changed since I posted the last message on this entry. I've not spent any time on this issue since then and I don't have a plan to resume. - I am not sure whether this issue is on anyone's rader. I have no ideas that the problem will be addressed in the not-to-distant future by someone. - Patches are always welcome and that should not be based on my previous patches, I guess. I recommend you to update this issue before starting tackling this issue to avoid duplications of works. (In reply to comment #10) > I don't have a plan to resume my work for the near future. I tried to re-apply my patch to the new paging model, but it turns out that it might take some non-trivial efforts. > > (In reply to comment #9) > > I have a plan to resume my work in a few weeks. I'll try to update this bug entry. 409210 12 94690 schenney 2011-05-24 14:34:29 -0700 Created attachment 94690 Test case for missing footers. I am currently investigating this, although not yet ready to claim ownership. Attached is an example of a potentially related problem: footers are not appearing on all but the last page. 414216 13 schenney 2011-06-02 09:59:14 -0700 The footer problem has its own bug: https://bugs.webkit.org/show_bug.cgi?id=6790. I am now looking into fixing this. 57215 2010-05-27 03:23:21 -0700 2010-06-11 16:16:44 -0700 paged-media-page-breaks bug-39735-20100527192318.patch text/plain 99694 hayato ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1MWY5N2Q0YWE2YjdkZmRiZDRlZmU2NGQxNmZhMzI1M2UzOGZlNGZkLi43MTdhYjUx Yzk2NWFhNzI1MzFjZDNiZDA1NTZmNzVjNmU3NTc3YzU3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsOTcgQEAK KzIwMTAtMDUtMjcgIEhheWF0byBJdG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltcGxlbWVudCBDU1MzIFBl Z2VkIE1lZGlhIC0gUGFnZSBCcmVha3MuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0zOTczNQorCisgICAgICAgIFJld3JpdGUgcGFnZSBicmVhayBkZXRl cm1pbmF0aW9uIGNvZGUuCisKKyAgICAgICAgQWRkIHN1cHBvcnRzIGZvciB0aGUgZm9sbG93aW5n IENTUyBwcm9wZXJ0aWVzOgorICAgICAgICAgIC0gcGFnZS1icmVhay17YmVmb3JlLGFmdGVyfTog YXZvaWQKKyAgICAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zNDE1NQorICAgICAgICAgIC0gb3JwaGFucyBhbmQgd2lkb3dzCisgICAgICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTQxMAorCisgICAgICAgIFRoZSBj aGFuZ2UgaGFwcGVuZWQgdG8gZml4IHRoZSBmb2xsb3dpbmcgYnVncyBhcyBhIHJlc3VsdDoKKyAg ICAgICAgICAtIEEgbWFyZ2luLXt0b3AsYm90dG9tfSBzaG91bGQgYmUgY29sbGFwc2VkIHdoZW4g cHJpbnRpbmcuCisgICAgICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9Mzk3MzIKKyAgICAgICAgICAtIFByaW50aW5nIGNvZGUgc2hvdWxkIGJyZWFrIGEgcGFn ZSBvbmx5IGF0IGFsbG93ZWQgcGFnZSBicmVha2UgcG9zaXRpb25zCisgICAgICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk3MzMKKworICAgICAgICBTcGVj IGxpbms6CisgICAgICAgIGh0dHA6Ly9kZXYudzMub3JnL2Nzc3dnL2NzczMtcGFnZS8jcGFnZS1i cmVha3MKKworICAgICAgICAqIHByaW50aW5nL2FsbG93ZWQtcGFnZS1icmVha3MtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBwcmludGluZy9hbGxvd2VkLXBhZ2UtYnJlYWtzLmh0bWw6 IEFkZGVkLgorICAgICAgICAqIHByaW50aW5nL25vLWNvbnRlbnQtZW1wdHktcGFnZXMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwcmludGluZy9uby1jb250ZW50LWVtcHR5LXBhZ2Vz Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIHByaW50aW5nL251bWJlck9mUGFnZXMtZXhwZWN0ZWQu dHh0OgorICAgICAgICAqIHByaW50aW5nL251bWJlck9mUGFnZXMuaHRtbDoKKyAgICAgICAgKiBw cmludGluZy9wYWdlLWJyZWFrLWFmdGVyLWF2b2lkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogcHJpbnRpbmcvcGFnZS1icmVhay1hZnRlci1hdm9pZC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy1leHBlY3RlZC50eHQ6CisgICAgICAgICog cHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMtZm9yLW92ZXJmbG93LWV4cGVjdGVkLnR4dDoKKyAg ICAgICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy1mb3Itb3ZlcmZsb3cuaHRtbDoKKyAg ICAgICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy5odG1sOgorICAgICAgICAqIHByaW50 aW5nL3BhZ2UtYnJlYWstYXZvaWQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwcmlu dGluZy9wYWdlLWJyZWFrLWF2b2lkLmh0bWw6IEFkZGVkLgorICAgICAgICAqIHByaW50aW5nL3Bh Z2UtYnJlYWstYmVmb3JlLWF2b2lkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcHJp bnRpbmcvcGFnZS1icmVhay1iZWZvcmUtYXZvaWQuaHRtbDogQWRkZWQuCisgICAgICAgICogcHJp bnRpbmcvcGFnZS1icmVhay1kaXNwbGF5LW5vbmUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWRpc3BsYXktbm9uZS5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS1hdm9pZC1leHBlY3RlZC50eHQ6IEFkZGVk LgorICAgICAgICAqIHByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLWF2b2lkLmh0bWw6IEFkZGVk LgorICAgICAgICAqIHByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLWV4cGVjdGVkLnR4dDogUmVt b3ZlZC4KKyAgICAgICAgKiBwcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1sOiBSZW1vdmVk LgorICAgICAgICAqIHByaW50aW5nL3BhZ2UtYnJlYWstb3JwaGFucy1hbmQtd2lkb3dzLWV4cGVj dGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcHJpbnRpbmcvcGFnZS1icmVhay1vcnBoYW5zLWFu ZC13aWRvd3MuaHRtbDogQWRkZWQuCisgICAgICAgICogcHJpbnRpbmcvcGFnZS1icmVhay1vcnBo YW5zLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcHJpbnRpbmcvcGFnZS1icmVhay1v cnBoYW5zLmh0bWw6IEFkZGVkLgorICAgICAgICAqIHByaW50aW5nL3BhZ2UtYnJlYWstd2lkb3dz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcHJpbnRpbmcvcGFnZS1icmVhay13aWRv d3MuaHRtbDogQWRkZWQuCisgICAgICAgICogcHJpbnRpbmcvcGFnZU51bWVyRm9yRWxlbWVudEJ5 SWQtZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHByaW50aW5nL3BhZ2VOdW1lckZvckVsZW1lbnRC eUlkLmh0bWw6CisgICAgICAgICogcHJpbnRpbmcvcmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3Qt dXRpbHMuanM6CisgICAgICAgIChudW1iZXJPZlBhZ2VzU2hvdWxkQmUpOgorICAgICAgICAocmF0 aW9Ub1BhZ2VIZWlnaHRUb1BpeGVscyk6CisgICAgICAgIChjcmVhdGVCbG9ja1dpdGhSYXRpb1Rv UGFnZUhlaWdodCk6CisgICAgICAgIChjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKToKKyAg ICAgICAgKiBwcmludGluZy9yZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3M6IEFkZGVkLgor ICAgICAgICAoYm9keSk6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL1RFTVBMQVRF Lmh0bWw6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL2FsbG93ZWQtcGFnZS1icmVh a3MuanM6IEFkZGVkLgorICAgICAgICAodGVzdCk6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0 LXRlc3RzL25vLWNvbnRlbnQtZW1wdHktcGFnZXMuanM6IEFkZGVkLgorICAgICAgICAodGVzdCk6 CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL251bWJlck9mUGFnZXMuanM6CisgICAg ICAgICh0ZXN0KToKKyAgICAgICAgKiBwcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1h ZnRlci1hdm9pZC5qczogQWRkZWQuCisgICAgICAgICh0ZXN0KToKKyAgICAgICAgKiBwcmludGlu Zy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1hbHdheXMtZm9yLW92ZXJmbG93LmpzOgorICAgICAg ICAodGVzdCk6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYWx3 YXlzLmpzOgorICAgICAgICAodGVzdCk6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3Rz L3BhZ2UtYnJlYWstYXZvaWQuanM6IEFkZGVkLgorICAgICAgICAodGVzdCk6CisgICAgICAgICog cHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYmVmb3JlLWF2b2lkLmpzOiBBZGRlZC4K KyAgICAgICAgKHRlc3QpOgorICAgICAgICAqIHByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJy ZWFrLWRpc3BsYXktbm9uZS5qczogQWRkZWQuCisgICAgICAgICh0ZXN0KToKKyAgICAgICAgKiBw cmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNpZGUtYXZvaWQuanM6IEFkZGVkLgor ICAgICAgICAodGVzdCk6CisgICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJl YWstaW5zaWRlLmpzOiBSZW1vdmVkLgorICAgICAgICAqIHByaW50aW5nL3NjcmlwdC10ZXN0cy9w YWdlLWJyZWFrLW1lcmdpbi1jb2xsYXBzZWQuanM6IEFkZGVkLgorICAgICAgICAodGVzdCk6Cisg ICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstb3JwaGFucy1hbmQtd2lk b3dzLmpzOiBBZGRlZC4KKyAgICAgICAgKHRlc3QpOgorICAgICAgICAqIHByaW50aW5nL3Njcmlw dC10ZXN0cy9wYWdlLWJyZWFrLW9ycGhhbnMuanM6IEFkZGVkLgorICAgICAgICAodGVzdCk6Cisg ICAgICAgICogcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstd2lkb3dzLmpzOiBBZGRl ZC4KKyAgICAgICAgKHRlc3QpOgorICAgICAgICAqIHByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdl TnVtZXJGb3JFbGVtZW50QnlJZC5qczoKKyAgICAgICAgKHRlc3QpOgorCiAyMDEwLTA1LTE5ICBN YXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL2Fs bG93ZWQtcGFnZS1icmVha3MtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvYWxs b3dlZC1wYWdlLWJyZWFrcy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODk0ZDRlMmM0ZDU0ODdl YzAxNWJhNTY1YzI3OWVlN2VjNzgwMGEwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L3ByaW50aW5nL2FsbG93ZWQtcGFnZS1icmVha3MtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTQg QEAKK1Rlc3QgZm9yIGFsbG93ZWQgcGFnZSBicmVha3MKKworT24gc3VjY2VzcywgeW91IHdpbGwg c2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExF VEUiLgorCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTEiIGlzIDEKK1BBU1M6IHBhZ2UgbnVtYmVy IG9mICJwYWdlMiIgaXMgMgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UzLTEiIGlzIDMKK1BB U1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMy0yIiBpcyAzCitBbGwgdGVzdHMgcGFzc2VkCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1sIGIvTGF5 b3V0VGVzdHMvcHJpbnRpbmcvYWxsb3dlZC1wYWdlLWJyZWFrcy5odG1sCnNpbWlsYXJpdHkgaW5k ZXggNjElCmNvcHkgZnJvbSBMYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5o dG1sCmNvcHkgdG8gTGF5b3V0VGVzdHMvcHJpbnRpbmcvYWxsb3dlZC1wYWdlLWJyZWFrcy5odG1s CmluZGV4IGFlZWM2YWY5OTQ2NWVmMmQ0Yzc5MGU4MTVlMzYyY2E3ZTlhMTI3NDIuLjEyOGNlMjBi NTk1MDY2MmUzOWE2MzRmYjQzMjE2YzhiOGY3OWMzOGQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRp bmcvYWxsb3dlZC1wYWdlLWJyZWFrcy5odG1sCkBAIC0zLDEyICszLDE0IEBACiA8aGVhZD4KIDxs aW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiPgogPHNjcmlwdCBzcmM9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC11 dGlscy5qcyI+PC9zY3JpcHQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9InJlc291cmNl cy9wYWdlZC1tZWRpYS10ZXN0LmNzcyI+CiA8L2hlYWQ+Ci08Ym9keT4KKzxib2R5IG9ubG9hZD0i cnVuUHJpbnRpbmdUZXN0KHRlc3QpIj4KIDxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgogPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CiA8ZGl2IGlkPSJzYW5kYm94Ij48L2Rpdj4KLTxzY3JpcHQgc3Jj PSJzY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNpZGUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBz cmM9InNjcmlwdC10ZXN0cy9hbGxvd2VkLXBhZ2UtYnJlYWtzLmpzIj48L3NjcmlwdD4KIDxzY3Jp cHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0Pgog PC9ib2R5PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvbm8tY29u dGVudC1lbXB0eS1wYWdlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wcmludGluZy9uby1j b250ZW50LWVtcHR5LXBhZ2VzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44OTM3MjEyZDdiZGE1 YjRlOTY1M2YyYzNkYTQ2YjI4NTc0MmYwZGUwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvcHJpbnRpbmcvbm8tY29udGVudC1lbXB0eS1wYWdlcy1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSwxMiBAQAorVGVzdCBmb3Igbm8tY29udGVudCBlbXB0eSBwYWdlcworCitPbiBzdWNjZXNzLCB5 b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVT VCBDT01QTEVURSIuCisKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNU IENPTVBMRVRFCisKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMS0xIiBpcyAxCitQQVNTOiBw YWdlIG51bWJlciBvZiAicGFnZTEtbGFzdCIgaXMgMQorQWxsIHRlc3RzIHBhc3NlZApkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbCBiL0xheW91 dFRlc3RzL3ByaW50aW5nL25vLWNvbnRlbnQtZW1wdHktcGFnZXMuaHRtbApzaW1pbGFyaXR5IGlu ZGV4IDYxJQpjb3B5IGZyb20gTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUu aHRtbApjb3B5IHRvIExheW91dFRlc3RzL3ByaW50aW5nL25vLWNvbnRlbnQtZW1wdHktcGFnZXMu aHRtbAppbmRleCBhZWVjNmFmOTk0NjVlZjJkNGM3OTBlODE1ZTM2MmNhN2U5YTEyNzQyLi43Mzcx NDk5OWJmYmViZTliNjU3NDE5MTdhNzViZTdlYTg3Nzk2MjIxIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3By aW50aW5nL25vLWNvbnRlbnQtZW1wdHktcGFnZXMuaHRtbApAQCAtMywxMiArMywxNCBAQAogPGhl YWQ+CiA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pz LXRlc3Qtc3R5bGUuY3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10 ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3BhZ2VkLW1lZGlh LXRlc3QtdXRpbHMuanMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJy ZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFkPgotPGJvZHk+Cis8Ym9keSBv bmxvYWQ9InJ1blByaW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K IDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2FuZGJveCI+PC9kaXY+Ci08c2Ny aXB0IHNyYz0ic2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstaW5zaWRlLmpzIj48L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSJzY3JpcHQtdGVzdHMvbm8tY29udGVudC1lbXB0eS1wYWdlcy5qcyI+PC9zY3Jp cHQ+CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48 L3NjcmlwdD4KIDwvYm9keT4KIDwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50 aW5nL251bWJlck9mUGFnZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvbnVt YmVyT2ZQYWdlcy1leHBlY3RlZC50eHQKaW5kZXggOGFkYjZiZTMyZDlmMDViZjY5MDUwMDE5MTk4 ZWFkMDJiZGU1YjA3NS4uZTI3YmExMTJlOTUxNWUwNTIwZDgzYTE3MWI1MjAzMDNkZDFhNDRlNyAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvbnVtYmVyT2ZQYWdlcy1leHBlY3RlZC50 eHQKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvbnVtYmVyT2ZQYWdlcy1leHBlY3RlZC50eHQK QEAgLTMsOSArMywxMCBAQCBUZXN0IGZvciBsYXlvdXRUZXN0Q29udHJvbGxlci5udW1iZXJPZlBh Z2VzKCkKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KIAogCi1QQVNTIGxheW91dFRlc3RDb250 cm9sbGVyLm51bWJlck9mUGFnZXMoMTAwMCwgMTAwMCkgaXMgMgotUEFTUyBsYXlvdXRUZXN0Q29u dHJvbGxlci5udW1iZXJPZlBhZ2VzKDEwMDAwLCAxMDAwMCkgaXMgMQogUEFTUyBzdWNjZXNzZnVs bHlQYXJzZWQgaXMgdHJ1ZQogCiBURVNUIENPTVBMRVRFCiAKK1BBU1M6IG51bWJlciBvZiBwYWdl cyBpcyAyCitQQVNTOiBudW1iZXIgb2YgcGFnZXMgaXMgMQorQWxsIHRlc3RzIHBhc3NlZApkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvbnVtYmVyT2ZQYWdlcy5odG1sIGIvTGF5b3V0 VGVzdHMvcHJpbnRpbmcvbnVtYmVyT2ZQYWdlcy5odG1sCmluZGV4IDUwNjY4MjExMDU4MjMxYjBh ZWEyM2JkNGVhOTA2YTk0MGM4YjkxY2QuLjc5YjdlYTE0NDQ0ZjdiYTQxMzYzMDBjYmQ2ZjFkMmMx OGE3NTkwYjggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3ByaW50aW5nL251bWJlck9mUGFnZXMu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9udW1iZXJPZlBhZ2VzLmh0bWwKQEAgLTMs OCArMywxMCBAQAogPGhlYWQ+CiA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3Qv anMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pz L3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3Vy Y2VzL3BhZ2VkLW1lZGlhLXRlc3QtdXRpbHMuanMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHls ZXNoZWV0IiBocmVmPSJyZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFkPgot PGJvZHk+Cis8Ym9keSBvbmxvYWQ9InJ1blByaW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVz Y3JpcHRpb24iPjwvcD4KIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2FuZGJv eCI+PC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWFm dGVyLWF2b2lkLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWst YWZ0ZXItYXZvaWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmM0NGFjZGVhMGE2Mjg3ZmE0MDMx ZDhkMzZmZWEzZTQ0YjY3NDUwZWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmlu dGluZy9wYWdlLWJyZWFrLWFmdGVyLWF2b2lkLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE5IEBA CitUZXN0IGZvciBwYWdlLWJyZWFrLWFmdGVyOmF2b2lkCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExF VEUKKworUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UxIiBpcyAxCitQQVNTOiBwYWdlIG51bWJl ciBvZiAicGFnZTItMSIgaXMgMgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UyLTIiIGlzIDIK K1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMy0xIiBpcyAzCitQQVNTOiBwYWdlIG51bWJlciBv ZiAicGFnZTMtMiIgaXMgMworUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UzLTMiIGlzIDMKK1BB U1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlNSIgaXMgNQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBh Z2U2LTEiIGlzIDYKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlNi03IiBpcyA2CitBbGwgdGVz dHMgcGFzc2VkCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWlu c2lkZS5odG1sIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hZnRlci1hdm9pZC5o dG1sCnNpbWlsYXJpdHkgaW5kZXggNjElCmNvcHkgZnJvbSBMYXlvdXRUZXN0cy9wcmludGluZy9w YWdlLWJyZWFrLWluc2lkZS5odG1sCmNvcHkgdG8gTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1i cmVhay1hZnRlci1hdm9pZC5odG1sCmluZGV4IGFlZWM2YWY5OTQ2NWVmMmQ0Yzc5MGU4MTVlMzYy Y2E3ZTlhMTI3NDIuLjY4NmE0ZmFjNTZmYzNhMGU1N2JiNDI1MmJhMDA2MGE4NjQ3MzA0ZDMgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwKKysr IGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hZnRlci1hdm9pZC5odG1sCkBAIC0z LDEyICszLDE0IEBACiA8aGVhZD4KIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vZmFz dC9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgogPHNjcmlwdCBzcmM9Ii4uL2Zhc3Qv anMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNv dXJjZXMvcGFnZWQtbWVkaWEtdGVzdC11dGlscy5qcyI+PC9zY3JpcHQ+Cis8bGluayByZWw9InN0 eWxlc2hlZXQiIGhyZWY9InJlc291cmNlcy9wYWdlZC1tZWRpYS10ZXN0LmNzcyI+CiA8L2hlYWQ+ Ci08Ym9keT4KKzxib2R5IG9ubG9hZD0icnVuUHJpbnRpbmdUZXN0KHRlc3QpIj4KIDxwIGlkPSJk ZXNjcmlwdGlvbiI+PC9wPgogPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CiA8ZGl2IGlkPSJzYW5k Ym94Ij48L2Rpdj4KLTxzY3JpcHQgc3JjPSJzY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNpZGUu anMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWFmdGVy LWF2b2lkLmpzIj48L3NjcmlwdD4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9q cy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMtZXhwZWN0ZWQudHh0CmluZGV4IDc5 MWEzNTljMzgzYjM2MjVjN2U1MzBmMTdjMTJlYmM4OGNiMTUwNTkuLjIzYWI2ODFlNzZjNTM0NTVl NzRhOGI0OWVmZTEwYTUxZTRmMjFmY2EgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3ByaW50aW5n L3BhZ2UtYnJlYWstYWx3YXlzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wcmludGlu Zy9wYWdlLWJyZWFrLWFsd2F5cy1leHBlY3RlZC50eHQKQEAgLTMsMTEgKzMsMTIgQEAgVGVzdCBm b3IgcGFnZS1icmVhay1iZWZvcmU6YWx3YXlzIGFuZCBwYWdlLWJyZWFrLWFmdGVyOmFsd2F5cwog T24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9s bG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCiAKLVBBU1MgbGF5b3V0VGVzdENvbnRyb2xsZXIu cGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCdmaXJzdFBhZ2UnKSBpcyAwCi1QQVNTIGxheW91dFRl c3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgnc2Vjb25kUGFnZTEnKSBpcyAx Ci1QQVNTIGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgnc2Vj b25kUGFnZTInKSBpcyAxCi1QQVNTIGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JF bGVtZW50QnlJZCgndGhpcmRQYWdlJykgaXMgMgogUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQogCiBURVNUIENPTVBMRVRFCiAKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJmaXJzdFBhZ2Ui IGlzIDAKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJzZWNvbmRQYWdlMSIgaXMgMQorUEFTUzogcGFn ZSBudW1iZXIgb2YgInNlY29uZFBhZ2UyIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBvZiAidGhp cmRQYWdlIiBpcyAyCitBbGwgdGVzdHMgcGFzc2VkCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9w cmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy1mb3Itb3ZlcmZsb3ctZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMtZm9yLW92ZXJmbG93LWV4cGVjdGVk LnR4dAppbmRleCA5N2VmYWQyNjk1ZTc4MzZmMTAyMjJhM2Y2Y2Y2NGQzNWM2ZjNhYjI5Li45ODJl OWY2M2Y5ODhkMDU1NDQ4ZDEzYjg1MTI0MjQ3NjhjMTRiZTlhIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy1mb3Itb3ZlcmZsb3ctZXhwZWN0ZWQudHh0 CisrKyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstYWx3YXlzLWZvci1vdmVyZmxv dy1leHBlY3RlZC50eHQKQEAgLTMsMTYgKzMsMTcgQEAgVGVzdCBwYWdlLWJyZWFrLXtiZWZvcmUs YWZ0ZXJ9OmFsd2F5cyBmb3Igb3ZlcmZsb3c6e3Zpc2libGUsaGlkZGVuLHNjcm9sbCxhdXRvfQog T24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9s bG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCiAKLVBBU1MgbGF5b3V0VGVzdENvbnRyb2xsZXIu cGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCd0ZXN0LXBhZ2UtYnJlYWstYmVmb3JlOmFsd2F5cy1m b3Itb3ZlcmZsb3c6dmlzaWJsZScpIGlzIDEKLVBBU1MgbGF5b3V0VGVzdENvbnRyb2xsZXIucGFn ZU51bWJlckZvckVsZW1lbnRCeUlkKCd0ZXN0LXBhZ2UtYnJlYWstYmVmb3JlOmFsd2F5cy1mb3It b3ZlcmZsb3c6aGlkZGVuJykgaXMgMgotUEFTUyBsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVt YmVyRm9yRWxlbWVudEJ5SWQoJ3Rlc3QtcGFnZS1icmVhay1iZWZvcmU6YWx3YXlzLWZvci1vdmVy ZmxvdzpzY3JvbGwnKSBpcyAzCi1QQVNTIGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJG b3JFbGVtZW50QnlJZCgndGVzdC1wYWdlLWJyZWFrLWJlZm9yZTphbHdheXMtZm9yLW92ZXJmbG93 OmF1dG8nKSBpcyA0Ci1QQVNTIGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVt ZW50QnlJZCgndGVzdC1wYWdlLWJyZWFrLWFmdGVyOmFsd2F5cy1mb3Itb3ZlcmZsb3c6dmlzaWJs ZScpIGlzIDQKLVBBU1MgbGF5b3V0VGVzdENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRC eUlkKCd0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzpoaWRkZW4nKSBp cyA1Ci1QQVNTIGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgn dGVzdC1wYWdlLWJyZWFrLWFmdGVyOmFsd2F5cy1mb3Itb3ZlcmZsb3c6c2Nyb2xsJykgaXMgNgot UEFTUyBsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoJ3Rlc3Qt cGFnZS1icmVhay1hZnRlcjphbHdheXMtZm9yLW92ZXJmbG93OmF1dG8nKSBpcyA3Ci1QQVNTIGxh eW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgndGVzdC1sYXN0LXBh Z2UnKSBpcyA4CiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExF VEUKIAorUEFTUzogcGFnZSBudW1iZXIgb2YgInRlc3QtcGFnZS1icmVhay1iZWZvcmU6YWx3YXlz LWZvci1vdmVyZmxvdzp2aXNpYmxlIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBvZiAidGVzdC1w YWdlLWJyZWFrLWJlZm9yZTphbHdheXMtZm9yLW92ZXJmbG93OmhpZGRlbiIgaXMgMgorUEFTUzog cGFnZSBudW1iZXIgb2YgInRlc3QtcGFnZS1icmVhay1iZWZvcmU6YWx3YXlzLWZvci1vdmVyZmxv dzpzY3JvbGwiIGlzIDMKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJ0ZXN0LXBhZ2UtYnJlYWstYmVm b3JlOmFsd2F5cy1mb3Itb3ZlcmZsb3c6YXV0byIgaXMgNAorUEFTUzogcGFnZSBudW1iZXIgb2Yg InRlc3QtcGFnZS1icmVhay1hZnRlcjphbHdheXMtZm9yLW92ZXJmbG93OnZpc2libGUiIGlzIDQK K1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJ0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1v dmVyZmxvdzpoaWRkZW4iIGlzIDUKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJ0ZXN0LXBhZ2UtYnJl YWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzpzY3JvbGwiIGlzIDYKK1BBU1M6IHBhZ2UgbnVt YmVyIG9mICJ0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzphdXRvIiBp cyA3CitQQVNTOiBwYWdlIG51bWJlciBvZiAidGVzdC1sYXN0LXBhZ2UiIGlzIDgKK0FsbCB0ZXN0 cyBwYXNzZWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstYWx3 YXlzLWZvci1vdmVyZmxvdy5odG1sIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1h bHdheXMtZm9yLW92ZXJmbG93Lmh0bWwKaW5kZXggZWVhYjZlZmUwMTc5MDdiZTY1NzJlOTQ4NWFh ZDI0YmVlMTEwMDk1ZS4uMmY2YWFjMTcxMWQyMTdkZTRkZTk1ZDlkZGQyN2ZjZjdlOGNjNmVjMCAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMtZm9yLW92 ZXJmbG93Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1hbHdheXMt Zm9yLW92ZXJmbG93Lmh0bWwKQEAgLTMsOCArMywxMCBAQAogPGhlYWQ+CiA8bGluayByZWw9InN0 eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4K IDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QtdXRpbHMuanMiPjwv c2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJyZXNvdXJjZXMvcGFnZWQtbWVk aWEtdGVzdC5jc3MiPgogPC9oZWFkPgotPGJvZHk+Cis8Ym9keSBvbmxvYWQ9InJ1blByaW50aW5n VGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgogPGRpdiBpZD0ic2FuZGJveCI+PC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9wcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy5odG1sIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcv cGFnZS1icmVhay1hbHdheXMuaHRtbAppbmRleCBmY2Q5YWEzYmViZDRlNTg3MzZlMzE4ZmNiZjZl ZGJiZjA2M2QyZGZjLi4yOTAyMzI5ZmQzY2YxMTI0MTkzMjViNTk1YmUyODJmOTA1OTMxNjNjIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWFsd2F5cy5odG1sCisr KyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstYWx3YXlzLmh0bWwKQEAgLTMsOCAr MywxMCBAQAogPGhlYWQ+CiA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3QvanMv cmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2Vz L3BhZ2VkLW1lZGlhLXRlc3QtdXRpbHMuanMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSJyZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFkPgotPGJv ZHk+Cis8Ym9keSBvbmxvYWQ9InJ1blByaW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVzY3Jp cHRpb24iPjwvcD4KIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2FuZGJveCI+ PC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWF2b2lk LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstYXZvaWQtZXhw ZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjMxNTYzNDYxZDUyNGM0YjA2YTc3ODVlMjg2ZjkzODA1OTJl ZjgyNzkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFr LWF2b2lkLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEzIEBACitUZXN0IGZvciBwYWdlLWJyZWFr LXtiZWZvcmUsYWZ0ZXIsaW5zaWRlfTphdm9pZAorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUg YSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIu CisKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisK K1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMS0xIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBv ZiAicGFnZTItMSIgaXMgMgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UyLTgiIGlzIDIKK0Fs bCB0ZXN0cyBwYXNzZWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJl YWstaW5zaWRlLmh0bWwgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWF2b2lkLmh0 bWwKc2ltaWxhcml0eSBpbmRleCA2MSUKY29weSBmcm9tIExheW91dFRlc3RzL3ByaW50aW5nL3Bh Z2UtYnJlYWstaW5zaWRlLmh0bWwKY29weSB0byBMYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJy ZWFrLWF2b2lkLmh0bWwKaW5kZXggYWVlYzZhZjk5NDY1ZWYyZDRjNzkwZTgxNWUzNjJjYTdlOWEx Mjc0Mi4uNzExYTcxYmU3OTJiNGFkMjEyMGFjOTBmZDJiNTJjZDAzNjMyODk2MiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbAorKysgYi9MYXlv dXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWF2b2lkLmh0bWwKQEAgLTMsMTIgKzMsMTQgQEAK IDxoZWFkPgogPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9mYXN0L2pzL3Jlc291cmNl cy9qcy10ZXN0LXN0eWxlLmNzcyI+CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJjZXMv anMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9wYWdlZC1t ZWRpYS10ZXN0LXV0aWxzLmpzIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJl Zj0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QuY3NzIj4KIDwvaGVhZD4KLTxib2R5PgorPGJv ZHkgb25sb2FkPSJydW5QcmludGluZ1Rlc3QodGVzdCkiPgogPHAgaWQ9ImRlc2NyaXB0aW9uIj48 L3A+CiA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KIDxkaXYgaWQ9InNhbmRib3giPjwvZGl2Pgot PHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS5qcyI+PC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0ic2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYXZvaWQuanMiPjwvc2NyaXB0 PgogPHNjcmlwdCBzcmM9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9z Y3JpcHQ+CiA8L2JvZHk+CiA8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGlu Zy9wYWdlLWJyZWFrLWJlZm9yZS1hdm9pZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wcmlu dGluZy9wYWdlLWJyZWFrLWJlZm9yZS1hdm9pZC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWRh NzY1ZjQ4MTczZDFhODlkZGYzYWI5Njk2N2JjY2NkZjY3OTNiYgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstYmVmb3JlLWF2b2lkLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDIxIEBACitUZXN0IGZvciBwYWdlLWJyZWFrLWJlZm9yZTphdm9pZAorCitP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCisKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMSIgaXMg MQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UyLTEiIGlzIDIKK1BBU1M6IHBhZ2UgbnVtYmVy IG9mICJwYWdlMi0yIiBpcyAyCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTMtMSIgaXMgMwor UEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UzLTIiIGlzIDMKK1BBU1M6IHBhZ2UgbnVtYmVyIG9m ICJwYWdlMy0zIiBpcyAzCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTUiIGlzIDUKK1BBU1M6 IHBhZ2UgbnVtYmVyIG9mICJwYWdlNi0xIiBpcyA2CitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFn ZTYtNyIgaXMgNgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2U3IiBpcyA3CitQQVNTOiBwYWdl IG51bWJlciBvZiAicGFnZTEwIiBpcyAxMAorQWxsIHRlc3RzIHBhc3NlZApkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbCBiL0xheW91dFRlc3Rz L3ByaW50aW5nL3BhZ2UtYnJlYWstYmVmb3JlLWF2b2lkLmh0bWwKc2ltaWxhcml0eSBpbmRleCA2 MSUKY29weSBmcm9tIExheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwK Y29weSB0byBMYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWJlZm9yZS1hdm9pZC5odG1s CmluZGV4IGFlZWM2YWY5OTQ2NWVmMmQ0Yzc5MGU4MTVlMzYyY2E3ZTlhMTI3NDIuLmJlYWIxNTI3 MTNiOGM0Zjc1NDE1MGU3ZWZmNDdjYmYzYmRmZDRkOGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRp bmcvcGFnZS1icmVhay1iZWZvcmUtYXZvaWQuaHRtbApAQCAtMywxMiArMywxNCBAQAogPGhlYWQ+ CiA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRl c3Qtc3R5bGUuY3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0 LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRl c3QtdXRpbHMuanMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJyZXNv dXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFkPgotPGJvZHk+Cis8Ym9keSBvbmxv YWQ9InJ1blByaW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KIDxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2FuZGJveCI+PC9kaXY+Ci08c2NyaXB0 IHNyYz0ic2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstaW5zaWRlLmpzIj48L3NjcmlwdD4KKzxzY3Jp cHQgc3JjPSJzY3JpcHQtdGVzdHMvcGFnZS1icmVhay1iZWZvcmUtYXZvaWQuanMiPjwvc2NyaXB0 PgogPHNjcmlwdCBzcmM9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9z Y3JpcHQ+CiA8L2JvZHk+CiA8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGlu Zy9wYWdlLWJyZWFrLWRpc3BsYXktbm9uZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wcmlu dGluZy9wYWdlLWJyZWFrLWRpc3BsYXktbm9uZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzQw ZWNjMmRkYWQzMDA1ZTk0NTAwOWQ3MmFmMDI3ZTg1NDkwOWFmYQotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstZGlzcGxheS1ub25lLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDEzIEBACitUZXN0IGZvciBwYWdlLWJyZWFrIHdpdGggJ2Rpc3BsYXk6bm9u ZScKKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdl cywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFy c2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFn ZTEtMSIgaXMgMQorUEFTUzogcGFnZSBudW1iZXIgb2YgImRpc3BsYXlub25lIiBpcyAtMQorUEFT UzogcGFnZSBudW1iZXIgb2YgInBhZ2UxLTIiIGlzIDEKK0FsbCB0ZXN0cyBwYXNzZWQKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwgYi9MYXlv dXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWRpc3BsYXktbm9uZS5odG1sCnNpbWlsYXJpdHkg aW5kZXggNjElCmNvcHkgZnJvbSBMYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lk ZS5odG1sCmNvcHkgdG8gTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1kaXNwbGF5LW5v bmUuaHRtbAppbmRleCBhZWVjNmFmOTk0NjVlZjJkNGM3OTBlODE1ZTM2MmNhN2U5YTEyNzQyLi4y YjA0ODBjN2U5NmU3Yzg4YzEzZDNjNTEyZDA4YjI1ZTRjMGJhZmNjIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1sCisrKyBiL0xheW91dFRlc3Rz L3ByaW50aW5nL3BhZ2UtYnJlYWstZGlzcGxheS1ub25lLmh0bWwKQEAgLTMsMTIgKzMsMTQgQEAK IDxoZWFkPgogPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9mYXN0L2pzL3Jlc291cmNl cy9qcy10ZXN0LXN0eWxlLmNzcyI+CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJjZXMv anMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9wYWdlZC1t ZWRpYS10ZXN0LXV0aWxzLmpzIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJl Zj0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QuY3NzIj4KIDwvaGVhZD4KLTxib2R5PgorPGJv ZHkgb25sb2FkPSJydW5QcmludGluZ1Rlc3QodGVzdCkiPgogPHAgaWQ9ImRlc2NyaXB0aW9uIj48 L3A+CiA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KIDxkaXYgaWQ9InNhbmRib3giPjwvZGl2Pgot PHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS5qcyI+PC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0ic2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstZGlzcGxheS1ub25lLmpzIj48 L3NjcmlwdD4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3Qu anMiPjwvc2NyaXB0PgogPC9ib2R5PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv cHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUtYXZvaWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUtYXZvaWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmQ2ZTE1NDNmMjllODZiZjU1YTNlOWVmNGMyMjEwMzA2NmM1OWE1YjAKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS1hdm9pZC1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSwyMCBAQAorVGVzdCBmb3IgcGFnZS1icmVhay1pbnNpZGU6YXZv aWQKKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdl cywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFy c2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFn ZTEtMSIgaXMgMQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UxLTIiIGlzIDEKK1BBU1M6IHBh Z2UgbnVtYmVyIG9mICJwYWdlMiIgaXMgMgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UzIiBp cyAzCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTQiIGlzIDQKK1BBU1M6IHBhZ2UgbnVtYmVy IG9mICJwYWdlNSIgaXMgNQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2U4IiBpcyA4CitQQVNT OiBwYWdlIG51bWJlciBvZiAicGFnZTktMSIgaXMgOQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBh Z2U5LTIiIGlzIDkKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMTAiIGlzIDEwCitBbGwgdGVz dHMgcGFzc2VkCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWlu c2lkZS5odG1sIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUtYXZvaWQu aHRtbApzaW1pbGFyaXR5IGluZGV4IDYxJQpjb3B5IGZyb20gTGF5b3V0VGVzdHMvcHJpbnRpbmcv cGFnZS1icmVhay1pbnNpZGUuaHRtbApjb3B5IHRvIExheW91dFRlc3RzL3ByaW50aW5nL3BhZ2Ut YnJlYWstaW5zaWRlLWF2b2lkLmh0bWwKaW5kZXggYWVlYzZhZjk5NDY1ZWYyZDRjNzkwZTgxNWUz NjJjYTdlOWExMjc0Mi4uZDEzMzcyMjlmODdmNmQ3NmY2ZjhjMTg4NDA4MzVkMGU3ZGM0Y2Y5NyAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS1hdm9pZC5odG1sCkBA IC0zLDEyICszLDE0IEBACiA8aGVhZD4KIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4v ZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgogPHNjcmlwdCBzcmM9Ii4uL2Zh c3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJy ZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC11dGlscy5qcyI+PC9zY3JpcHQ+Cis8bGluayByZWw9 InN0eWxlc2hlZXQiIGhyZWY9InJlc291cmNlcy9wYWdlZC1tZWRpYS10ZXN0LmNzcyI+CiA8L2hl YWQ+Ci08Ym9keT4KKzxib2R5IG9ubG9hZD0icnVuUHJpbnRpbmdUZXN0KHRlc3QpIj4KIDxwIGlk PSJkZXNjcmlwdGlvbiI+PC9wPgogPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CiA8ZGl2IGlkPSJz YW5kYm94Ij48L2Rpdj4KLTxzY3JpcHQgc3JjPSJzY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNp ZGUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWlu c2lkZS1hdm9pZC5qcyI+PC9zY3JpcHQ+CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KIDwvYm9keT4KIDwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLWV4cGVjdGVkLnR4dApkZWxl dGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGRjNTYxZjJhM2YyNGRjNDNhMmZiNzg1NDdhN2Zh OTFjOTRkZmQ0MS4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0g YS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS1leHBlY3RlZC50eHQKKysr IC9kZXYvbnVsbApAQCAtMSwyMSArMCwwIEBACi1UZXN0IGZvciBwYWdlLWJyZWFrLWluc2lkZTph dm9pZAotCi1PbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3Nh Z2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCi0KLQotUEFTUyBwYWdlTnVtYmVyKCdw YWdlMScpIGlzIDEKLVBBU1MgcGFnZU51bWJlcigncGFnZTInKSBpcyAyCi1QQVNTIHBhZ2VOdW1i ZXIoJ3BhZ2UzLTEnKSBpcyAzCi1QQVNTIHBhZ2VOdW1iZXIoJ3BhZ2UzLTInKSBpcyAzCi1QQVNT IHBhZ2VOdW1iZXIoJ3BhZ2U0JykgaXMgNAotUEFTUyBwYWdlTnVtYmVyKCdwYWdlNScpIGlzIDUK LVBBU1MgcGFnZU51bWJlcigncGFnZTYnKSBpcyA2Ci1QQVNTIHBhZ2VOdW1iZXIoJ3BhZ2U3Jykg aXMgNwotUEFTUyBwYWdlTnVtYmVyKCdwYWdlOScpIGlzIDkKLVBBU1MgcGFnZU51bWJlcigncGFn ZTEwLTEnKSBpcyAxMAotUEFTUyBwYWdlTnVtYmVyKCdwYWdlMTAtMicpIGlzIDEwCi1QQVNTIHBh Z2VOdW1iZXIoJ3BhZ2UxMScpIGlzIDExCi1QQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl Ci0KLVRFU1QgQ09NUExFVEUKLQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFn ZS1icmVhay1vcnBoYW5zLWFuZC13aWRvd3MtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcHJp bnRpbmcvcGFnZS1icmVhay1vcnBoYW5zLWFuZC13aWRvd3MtZXhwZWN0ZWQudHh0Cm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjQ5YTU0MmM1Y2I2NjMzY2JmMzg4MDRhODIzMWJhZGE2MWVjNzlmMTQKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLW9ycGhhbnMtYW5kLXdpZG93 cy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwyMiBAQAorVGVzdCBmb3Igd2lkb3dzCisKK09uIHN1 Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2Vk IGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CisKK1RFU1QgQ09NUExFVEUKKworUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UxLTEiIGlzIDEK K1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMS0yIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBv ZiAicGFnZTEtMyIgaXMgMQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UyIiBpcyAyCitQQVNT OiBwYWdlIG51bWJlciBvZiAicGFnZTMiIGlzIDMKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdl NCIgaXMgNAorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2U1IiBpcyA1CitQQVNTOiBwYWdlIG51 bWJlciBvZiAicGFnZTYtMSIgaXMgNgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2U2LTIiIGlz IDYKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlNyIgaXMgNworUEFTUzogcGFnZSBudW1iZXIg b2YgInBhZ2U4IiBpcyA4CitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTkiIGlzIDkKK0FsbCB0 ZXN0cyBwYXNzZWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWst aW5zaWRlLmh0bWwgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLW9ycGhhbnMtYW5k LXdpZG93cy5odG1sCnNpbWlsYXJpdHkgaW5kZXggNjAlCmNvcHkgZnJvbSBMYXlvdXRUZXN0cy9w cmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1sCmNvcHkgdG8gTGF5b3V0VGVzdHMvcHJpbnRp bmcvcGFnZS1icmVhay1vcnBoYW5zLWFuZC13aWRvd3MuaHRtbAppbmRleCBhZWVjNmFmOTk0NjVl ZjJkNGM3OTBlODE1ZTM2MmNhN2U5YTEyNzQyLi5iZjQ4M2IwMTY5YTJhNTA3ODA1NmQwMTQyNjAz NDJkZTdhY2UxMGJjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFr LWluc2lkZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstb3JwaGFu cy1hbmQtd2lkb3dzLmh0bWwKQEAgLTMsMTIgKzMsMTQgQEAKIDxoZWFkPgogPGxpbmsgcmVsPSJz dHlsZXNoZWV0IiBocmVmPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+ CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9wYWdlZC1tZWRpYS10ZXN0LXV0aWxzLmpzIj48 L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0icmVzb3VyY2VzL3BhZ2VkLW1l ZGlhLXRlc3QuY3NzIj4KIDwvaGVhZD4KLTxib2R5PgorPGJvZHkgb25sb2FkPSJydW5QcmludGlu Z1Rlc3QodGVzdCkiPgogPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+CiA8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KIDxkaXYgaWQ9InNhbmRib3giPjwvZGl2PgotPHNjcmlwdCBzcmM9InNjcmlwdC10 ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0ic2NyaXB0 LXRlc3RzL3BhZ2UtYnJlYWstb3JwaGFucy1hbmQtd2lkb3dzLmpzIj48L3NjcmlwdD4KIDxzY3Jp cHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0Pgog PC9ib2R5PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1i cmVhay1vcnBoYW5zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJl YWstb3JwaGFucy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDk5ZjJkZWM4OWUxZDQ5ZDU1MzQz NjdmMTYwMzQxMjk2MmEyYmFiYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3ByaW50 aW5nL3BhZ2UtYnJlYWstb3JwaGFucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNiBAQAorVGVz dCBmb3Igb3JwaGFucworCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBzdWNj ZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKK1BBU1M6IHBhZ2UgbnVt YmVyIG9mICJwYWdlMS0xIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTEtMiIgaXMg MQorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2UzIiBpcyAzCitQQVNTOiBwYWdlIG51bWJlciBv ZiAicGFnZTQiIGlzIDQKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlNS0xIiBpcyA1CitQQVNT OiBwYWdlIG51bWJlciBvZiAicGFnZTUtMiIgaXMgNQorQWxsIHRlc3RzIHBhc3NlZApkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbCBiL0xheW91 dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstb3JwaGFucy5odG1sCnNpbWlsYXJpdHkgaW5kZXgg NjElCmNvcHkgZnJvbSBMYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLWluc2lkZS5odG1s CmNvcHkgdG8gTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1vcnBoYW5zLmh0bWwKaW5k ZXggYWVlYzZhZjk5NDY1ZWYyZDRjNzkwZTgxNWUzNjJjYTdlOWExMjc0Mi4uOWQxNzZiNzQ0MjMx OGQ4NDBjNjBhODExYTBlOTMyZDNjYjdmMDg2OCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJp bnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9w YWdlLWJyZWFrLW9ycGhhbnMuaHRtbApAQCAtMywxMiArMywxNCBAQAogPGhlYWQ+CiA8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUu Y3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+ PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QtdXRpbHMu anMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJyZXNvdXJjZXMvcGFn ZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFkPgotPGJvZHk+Cis8Ym9keSBvbmxvYWQ9InJ1blBy aW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KIDxkaXYgaWQ9ImNv bnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2FuZGJveCI+PC9kaXY+Ci08c2NyaXB0IHNyYz0ic2Ny aXB0LXRlc3RzL3BhZ2UtYnJlYWstaW5zaWRlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJz Y3JpcHQtdGVzdHMvcGFnZS1icmVhay1vcnBoYW5zLmpzIj48L3NjcmlwdD4KIDxzY3JpcHQgc3Jj PSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5 PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay13 aWRvd3MtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay13aWRv d3MtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU2YzQ2Y2EyZDUzYmM1ZjE0MzEzYjdkODhjZWE2 NWRjNWQwZTY5ZjQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdl LWJyZWFrLXdpZG93cy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxOCBAQAorVGVzdCBmb3Igd2lk b3dzCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIHN1Y2Nlc3NmdWxseVBh cnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworUEFTUzogcGFnZSBudW1iZXIgb2YgInBh Z2UxLTEiIGlzIDEKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMS0yIiBpcyAxCitQQVNTOiBw YWdlIG51bWJlciBvZiAicGFnZTItMSIgaXMgMgorUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2Uy LTIiIGlzIDIKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJwYWdlMy0xIiBpcyAzCitQQVNTOiBwYWdl IG51bWJlciBvZiAicGFnZTMtMiIgaXMgMworUEFTUzogcGFnZSBudW1iZXIgb2YgInBhZ2U0IiBp cyA0CitQQVNTOiBwYWdlIG51bWJlciBvZiAicGFnZTUiIGlzIDUKK0FsbCB0ZXN0cyBwYXNzZWQK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5zaWRlLmh0bWwg Yi9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlLWJyZWFrLXdpZG93cy5odG1sCnNpbWlsYXJpdHkg aW5kZXggNjElCnJlbmFtZSBmcm9tIExheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstaW5z aWRlLmh0bWwKcmVuYW1lIHRvIExheW91dFRlc3RzL3ByaW50aW5nL3BhZ2UtYnJlYWstd2lkb3dz Lmh0bWwKaW5kZXggYWVlYzZhZjk5NDY1ZWYyZDRjNzkwZTgxNWUzNjJjYTdlOWExMjc0Mi4uZDQz NzNhMTUwOThjNzI4MGU5MmJmNTIzMDkwMjI3NWQzNmY4YTFlYyAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvcHJpbnRpbmcvcGFnZS1icmVhay1pbnNpZGUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9w cmludGluZy9wYWdlLWJyZWFrLXdpZG93cy5odG1sCkBAIC0zLDEyICszLDE0IEBACiA8aGVhZD4K IDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgogPHNjcmlwdCBzcmM9Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qt cHJlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVz dC11dGlscy5qcyI+PC9zY3JpcHQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9InJlc291 cmNlcy9wYWdlZC1tZWRpYS10ZXN0LmNzcyI+CiA8L2hlYWQ+Ci08Ym9keT4KKzxib2R5IG9ubG9h ZD0icnVuUHJpbnRpbmdUZXN0KHRlc3QpIj4KIDxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgogPGRp diBpZD0iY29uc29sZSI+PC9kaXY+CiA8ZGl2IGlkPSJzYW5kYm94Ij48L2Rpdj4KLTxzY3JpcHQg c3JjPSJzY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNpZGUuanMiPjwvc2NyaXB0PgorPHNjcmlw dCBzcmM9InNjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLXdpZG93cy5qcyI+PC9zY3JpcHQ+CiA8c2Ny aXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4K IDwvYm9keT4KIDwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2VO dW1lckZvckVsZW1lbnRCeUlkLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3ByaW50aW5nL3Bh Z2VOdW1lckZvckVsZW1lbnRCeUlkLWV4cGVjdGVkLnR4dAppbmRleCAxYTEzODFiMzViMTEyZGZh MGRhMWMwMTc1MjUxN2E2ZDI0Mzc1M2Q2Li5lODIyN2M2OGU2NzAxMjQ2NmVmYTdjZTJlMzYxMmMz YWE4OTU1YzEzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wcmludGluZy9wYWdlTnVtZXJGb3JF bGVtZW50QnlJZC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZU51 bWVyRm9yRWxlbWVudEJ5SWQtZXhwZWN0ZWQudHh0CkBAIC0zLDExICszLDEyIEBAIFRlc3QgZm9y IGxheW91dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgpCiBPbiBzdWNj ZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBi eSAiVEVTVCBDT01QTEVURSIuCiAKIAotUEFTUyBsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVt YmVyRm9yRWxlbWVudEJ5SWQoJ2ZpcnN0UGFnZScsIDEwMDAsIDEwMDApIGlzIDAKLVBBU1MgbGF5 b3V0VGVzdENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCdzZWNvbmRQYWdlJywg MTAwMCwgMTAwMCkgaXMgMQotUEFTUyBsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVtYmVyRm9y RWxlbWVudEJ5SWQoJ3RoaXJkUGFnZScsIDEwMDAsIDEwMDApIGlzIDIKLVBBU1MgbGF5b3V0VGVz dENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCd0aGlyZFBhZ2UyJywgMTAwMCwg MTAwMCkgaXMgMgogUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQogCiBURVNUIENPTVBM RVRFCiAKK1BBU1M6IHBhZ2UgbnVtYmVyIG9mICJmaXJzdFBhZ2UiIGlzIDAKK1BBU1M6IHBhZ2Ug bnVtYmVyIG9mICJzZWNvbmRQYWdlIiBpcyAxCitQQVNTOiBwYWdlIG51bWJlciBvZiAidGhpcmRQ YWdlIiBpcyAyCitQQVNTOiBwYWdlIG51bWJlciBvZiAidGhpcmRQYWdlMiIgaXMgMgorQWxsIHRl c3RzIHBhc3NlZApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZU51bWVyRm9y RWxlbWVudEJ5SWQuaHRtbCBiL0xheW91dFRlc3RzL3ByaW50aW5nL3BhZ2VOdW1lckZvckVsZW1l bnRCeUlkLmh0bWwKaW5kZXggMGRhZTk4ZTVmYjNiYjE4ODJlZmI5MWU5MmRlZGJhYTIyNjJiMGRm My4uNmE5ZGZlMDIxZGI1MDgxZTRmN2YzNzM5YjhjNGZmYTIyNmNkZDJhNSAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvcHJpbnRpbmcvcGFnZU51bWVyRm9yRWxlbWVudEJ5SWQuaHRtbAorKysgYi9M YXlvdXRUZXN0cy9wcmludGluZy9wYWdlTnVtZXJGb3JFbGVtZW50QnlJZC5odG1sCkBAIC0zLDgg KzMsMTAgQEAKIDxoZWFkPgogPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9mYXN0L2pz L3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+CiA8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNl cy9wYWdlZC1tZWRpYS10ZXN0LXV0aWxzLmpzIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVz aGVldCIgaHJlZj0icmVzb3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QuY3NzIj4KIDwvaGVhZD4KLTxi b2R5PgorPGJvZHkgb25sb2FkPSJydW5QcmludGluZ1Rlc3QodGVzdCkiPgogPHAgaWQ9ImRlc2Ny aXB0aW9uIj48L3A+CiA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KIDxkaXYgaWQ9InNhbmRib3gi PjwvZGl2PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvcmVzb3VyY2VzL3BhZ2Vk LW1lZGlhLXRlc3QtdXRpbHMuanMgYi9MYXlvdXRUZXN0cy9wcmludGluZy9yZXNvdXJjZXMvcGFn ZWQtbWVkaWEtdGVzdC11dGlscy5qcwppbmRleCAxNjE5Mjk4MjU0MzNiOWU4NjA0OWYyZmUxNzY0 NzBjZjhiMmFlYjM3Li4wNTM5Mzg2MTUwY2UyY2U4Y2FkZjE0Y2M1M2ViYmI0NGQ2MjhkMTY4IDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wcmludGluZy9yZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVz dC11dGlscy5qcworKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9yZXNvdXJjZXMvcGFnZWQtbWVk aWEtdGVzdC11dGlscy5qcwpAQCAtMjEsOSArMjEsMTUgQEAgZnVuY3Rpb24gcGFnZU51bWJlckZv ckVsZW1lbnRTaG91bGRCZShpZCwgZXhwZWN0ZWRQYWdlTnVtYmVyKQogICAgIH0KIH0KIAotZnVu Y3Rpb24gbnVtYmVyT2ZQYWdlc1Nob3VsZEJlKGV4cGVjdGVkTnVtYmVyT2ZQYWdlcykKK2Z1bmN0 aW9uIG51bWJlck9mUGFnZXNTaG91bGRCZShleHBlY3RlZE51bWJlck9mUGFnZXMsIHBhZ2VXaWR0 aEluUGl4ZWxzLCBwYWdlSGVpZ2h0SW5QaXhlbHMpCiB7Ci0gICAgdmFyIGFjdHVhbE51bWJlck9m UGFnZXMgPSBsYXlvdXRUZXN0Q29udHJvbGxlci5udW1iZXJPZlBhZ2VzKCk7CisgICAgLy8gcGFn ZVdpZHRoSW5QaXhlbHMgYW5kIHBhZ2VIZWlnaHRJblBpeGVscyBjYW4gYmUgb21pdHRlZC4gSWYg b21pdHRlZCwgODAweDYwMCBpcyB1c2VkLgorICAgIHZhciBhY3R1YWxOdW1iZXJPZlBhZ2VzOwor ICAgIGlmIChwYWdlV2lkdGhJblBpeGVscyAmJiBwYWdlSGVpZ2h0SW5QaXhlbHMpCisgICAgICAg IGFjdHVhbE51bWJlck9mUGFnZXMgPSBsYXlvdXRUZXN0Q29udHJvbGxlci5udW1iZXJPZlBhZ2Vz KHBhZ2VXaWR0aEluUGl4ZWxzLCBwYWdlSGVpZ2h0SW5QaXhlbHMpOworICAgIGVsc2UKKyAgICAg ICAgYWN0dWFsTnVtYmVyT2ZQYWdlcyA9IGxheW91dFRlc3RDb250cm9sbGVyLm51bWJlck9mUGFn ZXMoKTsKKwogICAgIGlmIChhY3R1YWxOdW1iZXJPZlBhZ2VzID09IGV4cGVjdGVkTnVtYmVyT2ZQ YWdlcykKICAgICAgICAgYXBwZW5kUmVzdWx0KCdQQVNTOiBudW1iZXIgb2YgcGFnZXMgaXMgJyAr IGFjdHVhbE51bWJlck9mUGFnZXMpOwogICAgIGVsc2UgewpAQCAtNTIsMyArNTgsMzIgQEAgZnVu Y3Rpb24gcnVuUHJpbnRpbmdUZXN0KHRlc3RGdW5jdGlvbikKICAgICByZXN1bHRFbGVtZW50Lmlu bmVySFRNTCA9IF9yZXN1bHRzOwogICAgIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQocmVzdWx0 RWxlbWVudCk7CiB9CisKK2Z1bmN0aW9uIHJhdGlvVG9QYWdlSGVpZ2h0VG9QaXhlbHMoaGVpZ2h0 SW5SYXRpb1RvUGFnZUhlaWdodCkKK3sKKyAgdmFyIHBhZ2VIZWlnaHRJblBpeGVscyA9IDYwMDsK KyAgcmV0dXJuIE1hdGguZmxvb3IocGFnZUhlaWdodEluUGl4ZWxzICogaGVpZ2h0SW5SYXRpb1Rv UGFnZUhlaWdodCk7Cit9CisKK2Z1bmN0aW9uIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVp Z2h0KGlkLCBoZWlnaHRJblJhdGlvVG9QYWdlSGVpZ2h0KQoreworICAgIHZhciBlbGVtZW50ID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgZWxlbWVudC5pZCA9IGlkOworICAg IGVsZW1lbnQuc3R5bGUuaGVpZ2h0ID0gcmF0aW9Ub1BhZ2VIZWlnaHRUb1BpeGVscyhoZWlnaHRJ blJhdGlvVG9QYWdlSGVpZ2h0KSArICJweCI7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InNhbmRib3giKS5hcHBlbmRDaGlsZChlbGVtZW50KTsKKyAgICByZXR1cm4gZWxlbWVudDsKK30K KworZnVuY3Rpb24gY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcyhpZCwgY2hpbGRMaW5lcykK K3sKKyAgICB2YXIgZWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOworICAg IGVsZW1lbnQuaWQgPSBpZDsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGNoaWxkTGluZXM7ICsr aSkgeworICAgICAgICBlbGVtZW50LmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2Rl KCJsaW5lIiArIGkpKTsKKyAgICAgICAgZWxlbWVudC5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVh dGVFbGVtZW50KCJiciIpKTsKKyAgICB9CisgICAgLy8gTWFrZSBzdXJlIHRoYXQgb25lIHBhZ2Ug aGFzIGFib3V0IDIwIGxpbmVzLgorICAgIGVsZW1lbnQuc3R5bGUubGluZUhlaWdodCA9IHJhdGlv VG9QYWdlSGVpZ2h0VG9QaXhlbHMoMC4wNSkgKyAicHgiOworICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJzYW5kYm94IikuYXBwZW5kQ2hpbGQoZWxlbWVudCk7CisgICAgcmV0dXJuIGVsZW1l bnQ7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9yZXNvdXJjZXMvcGFnZWQt bWVkaWEtdGVzdC5jc3MgYi9MYXlvdXRUZXN0cy9wcmludGluZy9yZXNvdXJjZXMvcGFnZWQtbWVk aWEtdGVzdC5jc3MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZThhYWRlY2I2NDdiZTU1YTM2ZmQ2MWEzYjFhYjFiMzVh MTI1ZGIwOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3Jlc291cmNl cy9wYWdlZC1tZWRpYS10ZXN0LmNzcwpAQCAtMCwwICsxLDQgQEAKK2JvZHkgeworICAgIG9ycGhh bnM6MDsKKyAgICB3aWRvd3M6MDsKK30KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5n L3NjcmlwdC10ZXN0cy9URU1QTEFURS5odG1sIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0 LXRlc3RzL1RFTVBMQVRFLmh0bWwKaW5kZXggNzljYWFjNDYzYWNhNTJjMjk1MmZhMWYxMTFhYWY4 ZDlmOTcwMjg0MC4uYjNkZDA4MzU0OTFlOTU0Yzk5MzRiMmE0M2YxY2MxYzJmM2Q5NmI3ZSAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL1RFTVBMQVRFLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL1RFTVBMQVRFLmh0bWwKQEAg LTMsOCArMywxMCBAQAogPGhlYWQ+CiA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zh c3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KIDxzY3JpcHQgc3JjPSIuLi9mYXN0 L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVz b3VyY2VzL3BhZ2VkLW1lZGlhLXRlc3QtdXRpbHMuanMiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJz dHlsZXNoZWV0IiBocmVmPSJyZXNvdXJjZXMvcGFnZWQtbWVkaWEtdGVzdC5jc3MiPgogPC9oZWFk PgotPGJvZHk+Cis8Ym9keSBvbmxvYWQ9InJ1blByaW50aW5nVGVzdCh0ZXN0KSI+CiA8cCBpZD0i ZGVzY3JpcHRpb24iPjwvcD4KIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgogPGRpdiBpZD0ic2Fu ZGJveCI+PC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVz dHMvYWxsb3dlZC1wYWdlLWJyZWFrcy5qcyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10 ZXN0cy9hbGxvd2VkLXBhZ2UtYnJlYWtzLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA2YzBjMTQwOTAzMzM2OTcz NzQzMDk4MThkYzI2MmZlNzZjZjcwYjAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9w cmludGluZy9zY3JpcHQtdGVzdHMvYWxsb3dlZC1wYWdlLWJyZWFrcy5qcwpAQCAtMCwwICsxLDI2 IEBACitkZXNjcmlwdGlvbigiVGVzdCBmb3IgYWxsb3dlZCBwYWdlIGJyZWFrcyIpOworCitmdW5j dGlvbiB0ZXN0KCkKK3sKKyAgICAvLyBTZWUgQ1NTMzogUGFnZWQgTWVkaWEgOS40LiBBbGxvd2Vk IHBhZ2UgYnJlYWtzLgorICAgIC8vIGh0dHA6Ly9kZXYudzMub3JnL2Nzc3dnL2NzczMtcGFnZS8j YWxsb3dlZC1wZy1icmsKKworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJw YWdlMSIsIDAuOCkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImFsd2F5cyI7CisgICAgLy8gV2Ug c2hvdWQgYnJlYWsgYSBwYWdlIGJldHdlZW4gYmxvY2sgJ3BhZ2UxJyBhbmQgYmxvY2sgJ3BhZ2Uy JyBpbnN0ZWFkIG9mIGJyZWFraW5nIGluc2lkZSBibG9jayAncGFnZTInIGJlY2F1c2UgdGhlcmUg aXMgbm8gYWxsb3dlZCBwYWdlIGJyZWFrIHBvaW50cyBpbnNpZGUgYmxvY2sgJ3BhZ2UyJy4KKyAg ICAvLyBCcmVha2luZyBhdCBub24tYWxsb3dlZCBwb3NpdGlvbiBzaG91bGQgYmUgYSBsYXN0IHJl c29ydC4KKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTIiLCAwLjgp LnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOworCisgICAgY3JlYXRlQmxvY2tXaXRo UmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2UzLTEiLCAwLjgpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9 ICJhbHdheXMiOworICAgIC8vIFdlIGNhbiBicmVhayBpbnNpZGUgYmxvY2sgJ3BhZ2UzLTInIGJl Y2F1c2UgcGFnZSBicmVha3MgbWF5IG9jY3VyIGJldHdlZW4gbGluZSBib3hlcyBpbnNpZGUgYSBi bG9jayBib3guCisgICAgY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygicGFnZTMtMiIsIDIw KTsKKworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTEnLCAxKTsKKyAg ICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMicsIDIpOworICAgIHBhZ2VOdW1i ZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UzLTEnLCAzKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxl bWVudFNob3VsZEJlKCdwYWdlMy0yJywgMyk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNo aWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2YXIgc3VjY2Vz c2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3Nj cmlwdC10ZXN0cy9uby1jb250ZW50LWVtcHR5LXBhZ2VzLmpzIGIvTGF5b3V0VGVzdHMvcHJpbnRp bmcvc2NyaXB0LXRlc3RzL25vLWNvbnRlbnQtZW1wdHktcGFnZXMuanMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGYz YzIyYjMxMDZhMjY5ZjAwMDM1YjFmOGY2NmEyODgzZjk2YWMxYgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0cy9uby1jb250ZW50LWVtcHR5LXBhZ2Vz LmpzCkBAIC0wLDAgKzEsMTcgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGZvciBuby1jb250ZW50IGVt cHR5IHBhZ2VzIik7CisKK2Z1bmN0aW9uIHRlc3QoKQoreworICAgIC8vIFBhZ2UgYnJlYWsgc2hv dWxkIGhhcHBlbiBvbmx5IG9uY2UgYXQgdGhlIHNhbWUgcG9zaXRpb24uCisgICAgY3JlYXRlQmxv Y2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoJ3BhZ2UxLTEnLCAwKS5zdHlsZS5wYWdlQnJlYWtCZWZv cmUgPSAnYWx3YXlzJzsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgncGFn ZTEtMicsIDApLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICdhbHdheXMnOworICAgIGNyZWF0ZUJs b2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCdwYWdlMS0zJywgMCkuc3R5bGUucGFnZUJyZWFrQmVm b3JlID0gJ2Fsd2F5cyc7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoJ3Bh Z2UxLWxhc3QnLCAwLjEpOworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFn ZTEtMScsIDEpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxLWxhc3Qn LCAxKTsKKworICAgIGRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInNhbmRib3giKSk7Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL251bWJlck9mUGFn ZXMuanMgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvbnVtYmVyT2ZQYWdlcy5q cwppbmRleCBjYTY0OTAzMDQxMDYxMThlNTc0NDUwMzBmMzQzYjNiZGZlNTRlZDg1Li5lNDFhYWM0 ZGU4ZmFhNDJjOWZhMWM2NzMzOGU2ZTRhYjIyYzJmZjZmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9wcmludGluZy9zY3JpcHQtdGVzdHMvbnVtYmVyT2ZQYWdlcy5qcworKysgYi9MYXlvdXRUZXN0 cy9wcmludGluZy9zY3JpcHQtdGVzdHMvbnVtYmVyT2ZQYWdlcy5qcwpAQCAtMSwyMyArMSwxNCBA QAogZGVzY3JpcHRpb24oIlRlc3QgZm9yIGxheW91dFRlc3RDb250cm9sbGVyLm51bWJlck9mUGFn ZXMoKSIpOwogCi1mdW5jdGlvbiBjcmVhdGVQYXJhZ3JhcGgoaWQpCitmdW5jdGlvbiB0ZXN0KCkK IHsKLSAgICB2YXIgZWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOwotICAg IGVsZW1lbnQuaWQgPSBpZDsKLSAgICBlbGVtZW50LndpZHRoID0gMTAwOwotICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikuYXBwZW5kQ2hpbGQoZWxlbWVudCk7Ci0gICAgcmV0 dXJuIGVsZW1lbnQ7Ci19Ci0KLXZhciBmaXJzdFBhZ2UgPSBjcmVhdGVQYXJhZ3JhcGgoImZpcnN0 UGFnZSIpOwotZmlyc3RQYWdlLnN0eWxlLmhlaWdodCA9IDcwMDsKKyAgICBjcmVhdGVCbG9ja1dp dGhSYXRpb1RvUGFnZUhlaWdodCgiZmlyc3RQYWdlIiwgMC42KTsKKyAgICBjcmVhdGVCbG9ja1dp dGhSYXRpb1RvUGFnZUhlaWdodCgic2Vjb25kUGFnZSIsIDAuNik7CiAKLXZhciBzZWNvbmRQYWdl ID0gY3JlYXRlUGFyYWdyYXBoKCJzZWNvbmRQYWdlIik7Ci1zZWNvbmRQYWdlLnN0eWxlLmhlaWdo dCA9IDcwMDsKKyAgICBudW1iZXJPZlBhZ2VzU2hvdWxkQmUoMik7CisgICAgbnVtYmVyT2ZQYWdl c1Nob3VsZEJlKDEsIDEwMDAsIDEwMDAwKTsKIAotc2hvdWxkQmUoImxheW91dFRlc3RDb250cm9s bGVyLm51bWJlck9mUGFnZXMoMTAwMCwgMTAwMCkiLCAiMiIpOwotc2hvdWxkQmUoImxheW91dFRl c3RDb250cm9sbGVyLm51bWJlck9mUGFnZXMoMTAwMDAsIDEwMDAwKSIsICIxIik7Ci0KLWRvY3Vt ZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3giKSk7 CisgICAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi c2FuZGJveCIpKTsKK30KIAogdmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1hZnRlci1h dm9pZC5qcyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWFm dGVyLWF2b2lkLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU4ZGIwODdmZmI4ZTg1Y2ZlYTUxMmRkNGFmNzUyOGU2 MTFlZWVkNGEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQt dGVzdHMvcGFnZS1icmVhay1hZnRlci1hdm9pZC5qcwpAQCAtMCwwICsxLDQyIEBACitkZXNjcmlw dGlvbigiVGVzdCBmb3IgcGFnZS1icmVhay1hZnRlcjphdm9pZCIpOworCitmdW5jdGlvbiB0ZXN0 KCkKK3sKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTEiLCAwLjUp LnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOworICAgIC8vIGJsb2NrICdwYWdlMi0x JyBtdXN0IG1vdmUgdG8gdGhlIG5leHQgcGFnZSBiZWNhdXNlIGl0IGhhcyAncGFnZS1icmVhay1h ZnRlcjphdm9pZCcgYW5kIHRoaXMgYW5kIHRoZSBmb2xsb3dpbmcgYmxvY2sgY2Fubm90IGJlIHBs YWNlZCBpbiB0aGUgY3VycmVudCBwYWdlIGF0IHRoZSBzYW1lIHRpbWUuCisgICAgY3JlYXRlQmxv Y2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2UyLTEiLCAwLjMpLnN0eWxlLnBhZ2VCcmVha0Fm dGVyID0gImF2b2lkIjs7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBh Z2UyLTIiLCAwLjMpOworCisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBh Z2UzLTEiLCAwLjUpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOworICAgIC8vIEEg cGFnZSBicmVhayBjYW4gb2NjdXIgaW5zaWRlIG9mICdwYWdlMy0zJyBibG9jayBiZWNhdXNlIGl0 IGhhcyBjaGlsZCBlbGVtZW50cy4KKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdo dCgicGFnZTMtMiIsIDAuMykuc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAiYXZvaWQiOzsKKyAgICBj cmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdlMy0zIiwgMTApOworCisgICAgY3JlYXRl QmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U1IiwgMC41KS5zdHlsZS5wYWdlQnJlYWtC ZWZvcmUgPSAiYWx3YXlzIjsKKyAgICAvLyBJdCBzZWVtcyB1bnJlYWxpc3RpYywgYnV0IGJsb2Nr ICdwYWdlNi0xJyBtdXN0IG1vdmUgdG8gdGhlIG5leHQgcGFnZS4KKyAgICBjcmVhdGVCbG9ja1dp dGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTYtMSIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQWZ0ZXIg PSAiYXZvaWQiOzsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTYt MiIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAiYXZvaWQiOzsKKyAgICBjcmVhdGVCbG9j a1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTYtMyIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQWZ0 ZXIgPSAiYXZvaWQiOzsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFn ZTYtNCIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAiYXZvaWQiOzsKKyAgICBjcmVhdGVC bG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTYtNSIsIDAuMSkuc3R5bGUucGFnZUJyZWFr QWZ0ZXIgPSAiYXZvaWQiOzsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgi cGFnZTYtNiIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAiYXZvaWQiOzsKKyAgICBjcmVh dGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTYtNyIsIDAuMSk7CisKKworICAgIHBh Z2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxJywgMSk7CisgICAgcGFnZU51bWJlckZv ckVsZW1lbnRTaG91bGRCZSgncGFnZTItMScsIDIpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50 U2hvdWxkQmUoJ3BhZ2UyLTInLCAyKTsKKworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxk QmUoJ3BhZ2UzLTEnLCAzKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdl My0yJywgMyk7CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTMtMycsIDMp OworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTUnLCA1KTsKKyAgICBw YWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlNi0xJywgNik7CisgICAgLy8gT21pdCB0 ZXN0cyBmb3IgaW50ZXJtZWRpYXRlIGJsb2Nrcy4KKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNo b3VsZEJlKCdwYWdlNi03JywgNik7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2YXIgc3VjY2Vzc2Z1bGx5 UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10 ZXN0cy9wYWdlLWJyZWFrLWFsd2F5cy1mb3Itb3ZlcmZsb3cuanMgYi9MYXlvdXRUZXN0cy9wcmlu dGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1hbHdheXMtZm9yLW92ZXJmbG93LmpzCmluZGV4 IGRhMTBhNDRiOWFmZWQ1ZjcxZjdhMTE0NDMzOGM4YTBjM2YxOTg3NDcuLjdlMzkxMzI0OGI1Zjlj ZDcwZDA5YTNiMzFkOTQzMWQzYTAwYTA0ZGQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3ByaW50 aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWFsd2F5cy1mb3Itb3ZlcmZsb3cuanMKKysrIGIv TGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYWx3YXlzLWZvci1v dmVyZmxvdy5qcwpAQCAtMSwzOSArMSwzOSBAQAogZGVzY3JpcHRpb24oIlRlc3QgcGFnZS1icmVh ay17YmVmb3JlLGFmdGVyfTphbHdheXMgZm9yIG92ZXJmbG93Ont2aXNpYmxlLGhpZGRlbixzY3Jv bGwsYXV0b30gZWxlbWVudHMuIik7CiAKLXZhciBvdmVyZmxvd1ZhbHVlcyA9IFsidmlzaWJsZSIs ICJoaWRkZW4iLCAic2Nyb2xsIiwgImF1dG8iXTsKLXZhciBwYWdlQnJlYWtQb3NpdGlvbnMgPSBb InBhZ2UtYnJlYWstYmVmb3JlIiwgInBhZ2UtYnJlYWstYWZ0ZXIiXTsKK2Z1bmN0aW9uIHRlc3Qo KQoreworICAgIHZhciBvdmVyZmxvd1ZhbHVlcyA9IFsidmlzaWJsZSIsICJoaWRkZW4iLCAic2Ny b2xsIiwgImF1dG8iXTsKKyAgICB2YXIgcGFnZUJyZWFrUG9zaXRpb25zID0gWyJwYWdlLWJyZWFr LWJlZm9yZSIsICJwYWdlLWJyZWFrLWFmdGVyIl07CiAKLXZhciB0ZXN0SHRtbCA9ICIiOwotZm9y ICh2YXIgcG9zaXRpb24gPSAwOyBwb3NpdGlvbiA8IHBhZ2VCcmVha1Bvc2l0aW9ucy5sZW5ndGg7 IHBvc2l0aW9uKyspIHsKLSAgICBmb3IgKHZhciB2YWx1ZSA9IDA7IHZhbHVlIDwgb3ZlcmZsb3dW YWx1ZXMubGVuZ3RoOyB2YWx1ZSsrKSB7Ci0gICAgICAgIHZhciBvdmVyZmxvd1N0eWxlID0gIm92 ZXJmbG93OiIgKyBvdmVyZmxvd1ZhbHVlc1t2YWx1ZV07Ci0gICAgICAgIHZhciBwYWdlQnJlYWtT dHlsZSA9IHBhZ2VCcmVha1Bvc2l0aW9uc1twb3NpdGlvbl0gKyAiOmFsd2F5cyI7Ci0gICAgICAg IHZhciB0ZXN0SWQgPSAndGVzdC0nICsgcGFnZUJyZWFrU3R5bGUgKyAnLWZvci0nICsgb3ZlcmZs b3dTdHlsZTsKLSAgICAgICAgdGVzdEh0bWwgKz0gJzxkaXYgc3R5bGU9IicgKyBvdmVyZmxvd1N0 eWxlICsgJyI+PHAgaWQ9IicgKyB0ZXN0SWQgKyAnIiBzdHlsZT0iJyArIHBhZ2VCcmVha1N0eWxl ICsgJyI+JyArIG92ZXJmbG93U3R5bGUgKyAnLCAnICsgcGFnZUJyZWFrU3R5bGUgKyAnPC9wPjwv ZGl2PlxuJzsKKyAgICB2YXIgdGVzdEh0bWwgPSAiIjsKKyAgICBmb3IgKHZhciBwb3NpdGlvbiA9 IDA7IHBvc2l0aW9uIDwgcGFnZUJyZWFrUG9zaXRpb25zLmxlbmd0aDsgcG9zaXRpb24rKykgewor ICAgICAgICBmb3IgKHZhciB2YWx1ZSA9IDA7IHZhbHVlIDwgb3ZlcmZsb3dWYWx1ZXMubGVuZ3Ro OyB2YWx1ZSsrKSB7CisgICAgICAgICAgICB2YXIgb3ZlcmZsb3dTdHlsZSA9ICJvdmVyZmxvdzoi ICsgb3ZlcmZsb3dWYWx1ZXNbdmFsdWVdOworICAgICAgICAgICAgdmFyIHBhZ2VCcmVha1N0eWxl ID0gcGFnZUJyZWFrUG9zaXRpb25zW3Bvc2l0aW9uXSArICI6YWx3YXlzIjsKKyAgICAgICAgICAg IHZhciB0ZXN0SWQgPSAndGVzdC0nICsgcGFnZUJyZWFrU3R5bGUgKyAnLWZvci0nICsgb3ZlcmZs b3dTdHlsZTsKKyAgICAgICAgICAgIHRlc3RIdG1sICs9ICc8ZGl2IHN0eWxlPSInICsgb3ZlcmZs b3dTdHlsZSArICciPjxwIGlkPSInICsgdGVzdElkICsgJyIgc3R5bGU9IicgKyBwYWdlQnJlYWtT dHlsZSArICciPicgKyBvdmVyZmxvd1N0eWxlICsgJywgJyArIHBhZ2VCcmVha1N0eWxlICsgJzwv cD48L2Rpdj5cbic7CisgICAgICAgIH0KICAgICB9Ci19Ci10ZXN0SHRtbCArPSAnPHAgaWQ9InRl c3QtbGFzdC1wYWdlIj5lbmQ8L3A+JzsKLWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94 IikuaW5uZXJIVE1MID0gdGVzdEh0bWw7CisgICAgdGVzdEh0bWwgKz0gJzxwIGlkPSJ0ZXN0LWxh c3QtcGFnZSI+ZW5kPC9wPic7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3gi KS5pbm5lckhUTUwgPSB0ZXN0SHRtbDsKIAotdmFyIGV4cGVjdGVkVmFsdWVzID0gWwotICAgIC8v IHBhZ2UtYnJlYWste2JlZm9yZSxhZnRlcn06YWx3YXlzIHNob3VsZCB0YWtlIGVmZmVjdCByZWdh cmRsZXNzIG9mIG92ZXJmbG93IHZhbHVlLgotICAgIFsndGVzdC1wYWdlLWJyZWFrLWJlZm9yZTph bHdheXMtZm9yLW92ZXJmbG93OnZpc2libGUnLCAxXSwKLSAgICBbJ3Rlc3QtcGFnZS1icmVhay1i ZWZvcmU6YWx3YXlzLWZvci1vdmVyZmxvdzpoaWRkZW4nLCAyXSwKLSAgICBbJ3Rlc3QtcGFnZS1i cmVhay1iZWZvcmU6YWx3YXlzLWZvci1vdmVyZmxvdzpzY3JvbGwnLCAzXSwKLSAgICBbJ3Rlc3Qt cGFnZS1icmVhay1iZWZvcmU6YWx3YXlzLWZvci1vdmVyZmxvdzphdXRvJywgNF0sCi0gICAgWyd0 ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzp2aXNpYmxlJywgNF0sCi0g ICAgWyd0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzpoaWRkZW4nLCA1 XSwKLSAgICBbJ3Rlc3QtcGFnZS1icmVhay1hZnRlcjphbHdheXMtZm9yLW92ZXJmbG93OnNjcm9s bCcsIDZdLAotICAgIFsndGVzdC1wYWdlLWJyZWFrLWFmdGVyOmFsd2F5cy1mb3Itb3ZlcmZsb3c6 YXV0bycsIDddLAotICAgIFsndGVzdC1sYXN0LXBhZ2UnLCA4XQotXTsKKyAgICB2YXIgZXhwZWN0 ZWRWYWx1ZXMgPSBbCisgICAgICAgIC8vIHBhZ2UtYnJlYWste2JlZm9yZSxhZnRlcn06YWx3YXlz IHNob3VsZCB0YWtlIGVmZmVjdCByZWdhcmRsZXNzIG9mIG92ZXJmbG93IHZhbHVlLgorICAgICAg ICBbJ3Rlc3QtcGFnZS1icmVhay1iZWZvcmU6YWx3YXlzLWZvci1vdmVyZmxvdzp2aXNpYmxlJywg MV0sCisgICAgICAgIFsndGVzdC1wYWdlLWJyZWFrLWJlZm9yZTphbHdheXMtZm9yLW92ZXJmbG93 OmhpZGRlbicsIDJdLAorICAgICAgICBbJ3Rlc3QtcGFnZS1icmVhay1iZWZvcmU6YWx3YXlzLWZv ci1vdmVyZmxvdzpzY3JvbGwnLCAzXSwKKyAgICAgICAgWyd0ZXN0LXBhZ2UtYnJlYWstYmVmb3Jl OmFsd2F5cy1mb3Itb3ZlcmZsb3c6YXV0bycsIDRdLAorICAgICAgICBbJ3Rlc3QtcGFnZS1icmVh ay1hZnRlcjphbHdheXMtZm9yLW92ZXJmbG93OnZpc2libGUnLCA0XSwKKyAgICAgICAgWyd0ZXN0 LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzpoaWRkZW4nLCA1XSwKKyAgICAg ICAgWyd0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzpzY3JvbGwnLCA2 XSwKKyAgICAgICAgWyd0ZXN0LXBhZ2UtYnJlYWstYWZ0ZXI6YWx3YXlzLWZvci1vdmVyZmxvdzph dXRvJywgN10sCisgICAgICAgIFsndGVzdC1sYXN0LXBhZ2UnLCA4XQorICAgIF07CiAKLWlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKLSAgICBmb3IgKHZhciBpID0gMDsgaSA8IGV4 cGVjdGVkVmFsdWVzLmxlbmd0aDsgaSsrKSB7Ci0gICAgICAgIHNob3VsZEJlKCJsYXlvdXRUZXN0 Q29udHJvbGxlci5wYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoJyIgKyBleHBlY3RlZFZhbHVlc1tp XVswXSArICInKSIsICIiICsgZXhwZWN0ZWRWYWx1ZXNbaV1bMV0pOwotICAgIH0KLX0KKyAgICBm b3IgKHZhciBpID0gMDsgaSA8IGV4cGVjdGVkVmFsdWVzLmxlbmd0aDsgaSsrKQorICAgICAgICBw YWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKGV4cGVjdGVkVmFsdWVzW2ldWzBdLCBleHBlY3Rl ZFZhbHVlc1tpXVsxXSk7CiAKLWRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInNhbmRib3giKSk7CisgICAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2FuZGJveCIpKTsKK30KIAogdmFyIHN1Y2Nlc3NmdWxs eVBhcnNlZCA9IHRydWU7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQt dGVzdHMvcGFnZS1icmVhay1hbHdheXMuanMgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQt dGVzdHMvcGFnZS1icmVhay1hbHdheXMuanMKaW5kZXggMWM2ZTVkODQ2YmI3ZjdlMGRiMTA5Y2Yx OGM5YzIzNGQ0MmYzN2ZhNS4uZjdhNWJiNGE5YzkxYmVkNWEyMGZlNTZiNTY3MzVmZTZiYmIzMTNh MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJl YWstYWx3YXlzLmpzCisrKyBiL0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdl LWJyZWFrLWFsd2F5cy5qcwpAQCAtMSwyNCArMSwxOSBAQAogZGVzY3JpcHRpb24oIlRlc3QgZm9y IHBhZ2UtYnJlYWstYmVmb3JlOmFsd2F5cyBhbmQgcGFnZS1icmVhay1hZnRlcjphbHdheXMiKTsK IAotZnVuY3Rpb24gY3JlYXRlUGFyYWdyYXBoKGlkKQorZnVuY3Rpb24gdGVzdCgpCiB7Ci0gICAg dmFyIGVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJwIik7Ci0gICAgZWxlbWVudC5p ZCA9IGlkOwotICAgIGVsZW1lbnQuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUo ImZvb2JhciIpKTsKLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2FuZGJveCIpLmFwcGVu ZENoaWxkKGVsZW1lbnQpOwotICAgIHJldHVybiBlbGVtZW50OwotfQotCi1jcmVhdGVQYXJhZ3Jh cGgoImZpcnN0UGFnZSIpOwotY3JlYXRlUGFyYWdyYXBoKCJzZWNvbmRQYWdlMSIpLnN0eWxlLnBh Z2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOwotY3JlYXRlUGFyYWdyYXBoKCJzZWNvbmRQYWdlMiIp LnN0eWxlLnBhZ2VCcmVha0FmdGVyID0gImFsd2F5cyI7Ci1jcmVhdGVQYXJhZ3JhcGgoInRoaXJk UGFnZSIpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOworICAgIGNyZWF0ZUJsb2Nr V2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJmaXJzdFBhZ2UiLCAwLjEpOworICAgIGNyZWF0ZUJsb2Nr V2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJzZWNvbmRQYWdlMSIsIDAuMSkuc3R5bGUucGFnZUJyZWFr QmVmb3JlID0gImFsd2F5cyI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQo InNlY29uZFBhZ2UyIiwgMC4xKS5zdHlsZS5wYWdlQnJlYWtBZnRlciA9ICJhbHdheXMiOworICAg IGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJ0aGlyZFBhZ2UiLCAwLjEpLnN0eWxl LnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOwogCi1zaG91bGRCZSgibGF5b3V0VGVzdENvbnRy b2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCdmaXJzdFBhZ2UnKSIsICIwIik7Ci1zaG91 bGRCZSgibGF5b3V0VGVzdENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCdzZWNv bmRQYWdlMScpIiwgIjEiKTsKLXNob3VsZEJlKCJsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVt YmVyRm9yRWxlbWVudEJ5SWQoJ3NlY29uZFBhZ2UyJykiLCAiMSIpOwotc2hvdWxkQmUoImxheW91 dFRlc3RDb250cm9sbGVyLnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZCgndGhpcmRQYWdlJykiLCAi MiIpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ2ZpcnN0UGFnZScsIDApOwor ICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3NlY29uZFBhZ2UxJywgMSk7CisgICAg cGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgnc2Vjb25kUGFnZTInLCAxKTsKKyAgICAvLyBU aGVyZSBtdXN0IGJlIG9ubHkgb25lIHBhZ2UgYnJlYWsgYmV0d2VlbiAncGFnZS1icmVhay1hZnRl cjogYWx3YXlzJyBhbmQgJ3BhZ2UtYnJlYWstYmVmb3JlOiBhbHdheXMnCisgICAgcGFnZU51bWJl ckZvckVsZW1lbnRTaG91bGRCZSgndGhpcmRQYWdlJywgMik7CiAKLWRvY3VtZW50LmJvZHkucmVt b3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3giKSk7CisgICAgZG9jdW1l bnQuYm9keS5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2FuZGJveCIpKTsK K30KIAogdmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1hdm9pZC5qcyBiL0xheW91dFRl c3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWF2b2lkLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjYwMWU4YjMxMTczYzY5NjI1MzNiNTliMTcxMTJmNzA0OGY4ZGViNTcKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1hdm9pZC5q cwpAQCAtMCwwICsxLDM1IEBACitkZXNjcmlwdGlvbigiVGVzdCBmb3IgcGFnZS1icmVhay17YmVm b3JlLGFmdGVyLGluc2lkZX06YXZvaWQiKTsKKworZnVuY3Rpb24gdGVzdCgpCit7CisgICAgdmFy IGJsb2NrOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJwYWdlMS0xIiwg MC40KS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAiYWx3YXlzIjsKKyAgICAvLyBibG9jayAncGFn ZTItMScgbXVzdCBtb3ZlIHRvIHRoZSBuZXh0IHBhZ2UgYmVjYXVzZSB3ZSBjYW5ub3QgZmluZCBh bnkgYWxsb3dlZCBwYWdlIGJyZWFrcyB0aWxsIHRoZSBlbmQgb2YgYmxvY2sgcGFnZTItOC4KKyAg ICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTItMSIsIDAuMSkuc3R5bGUu cGFnZUJyZWFrQWZ0ZXIgPSAiYXZvaWQiOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdl SGVpZ2h0KCJwYWdlMi0yIiwgMC4xKTsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhl aWdodCgicGFnZTItMyIsIDAuMSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImF2b2lkIjsKKyAg ICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTItNCIsIDAuMSkuc3R5bGUu cGFnZUJyZWFrQmVmb3JlID0gImF2b2lkIjsKKworICAgIGJsb2NrID0gY3JlYXRlQmxvY2tXaXRo UmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2UyLTUiLCAwLjEpOworICAgIGJsb2NrLnN0eWxlLnBhZ2VC cmVha0JlZm9yZSA9ICJhdm9pZCI7CisgICAgYmxvY2suc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAi YXZvaWQiOworCisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2UyLTYi LCAwLjEpOworCisgICAgYmxvY2sgPSBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdl Mi03IiwgNCk7CisgICAgYmxvY2suc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImF2b2lkIjsKKyAg ICBibG9jay5zdHlsZS5wYWdlQnJlYWtBZnRlciA9ICJhdm9pZCI7CisgICAgYmxvY2suc3R5bGUu cGFnZUJyZWFrSW5zaWRlID0gImF2b2lkIjsKKworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9Q YWdlSGVpZ2h0KCJwYWdlMi04IiwgMC4xKS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAiYXZvaWQi OworCisKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMS0xJywgMSk7Cisg ICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTItMScsIDIpOworICAgIC8vIE9t aXQgZm9yIHRlc3RzIGZvciBpbnRlcm1lZGlhdGUgYmxvY2tzLgorICAgIHBhZ2VOdW1iZXJGb3JF bGVtZW50U2hvdWxkQmUoJ3BhZ2UyLTgnLCAyKTsKKworICAgIGRvY3VtZW50LmJvZHkucmVtb3Zl Q2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3giKSk7Cit9CisKK3ZhciBzdWNj ZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcv c2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYmVmb3JlLWF2b2lkLmpzIGIvTGF5b3V0VGVzdHMvcHJp bnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstYmVmb3JlLWF2b2lkLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjMxMDg5NzdlMzNjNDEzODdjOTM3MTgxMzUxZTQzYTk5NDkzY2EzN2MKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1iZWZvcmUt YXZvaWQuanMKQEAgLTAsMCArMSw1MSBAQAorZGVzY3JpcHRpb24oIlRlc3QgZm9yIHBhZ2UtYnJl YWstYmVmb3JlOmF2b2lkIik7CisKK2Z1bmN0aW9uIHRlc3QoKQoreworICAgIGNyZWF0ZUJsb2Nr V2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJwYWdlMSIsIDAuNSkuc3R5bGUucGFnZUJyZWFrQmVmb3Jl ID0gImFsd2F5cyI7CisgICAgLy8gYmxvY2sgJ3BhZ2UyLTEnIG11c3QgbW92ZSB0byB0aGUgbmV4 dCBwYWdlIGJlY2F1c2UgdGhlIGZvbGxvd2luZyBibG9jayAncGFnZTItMicgaGFzICdwYWdlLWJy ZWFrLWJlZm9yZTphdm9pZCcgYW5kIGJvdGggYmxvY2tzIGNhbm5vdCBiZSBwbGFjZWQgaW4gdGhl IGN1cnJlbnQgcGFnZSBhdCB0aGUgc2FtZSB0aW1lLgorICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlv VG9QYWdlSGVpZ2h0KCJwYWdlMi0xIiwgMC4zKTsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1Rv UGFnZUhlaWdodCgicGFnZTItMiIsIDAuMykuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImF2b2lk Ijs7CisKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTMtMSIsIDAu NSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImFsd2F5cyI7CisgICAgLy8gQSBwYWdlIGJyZWFr IGNhbiBvY2N1ciBpbnNpZGUgb2YgJ3BhZ2UzLTMnIGJsb2NrIGJlY2F1c2UgaXQgaGFzIGNoaWxk IGVsZW1lbnRzLgorICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJwYWdlMy0y IiwgMC4zKTsKKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdlMy0zIiwgMTAp LnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7OworCisgICAgY3JlYXRlQmxvY2tXaXRo UmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U1IiwgMC41KS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAi YWx3YXlzIjsKKyAgICAvLyBJdCBzZWVtcyB1bnJlYWxpc3RpYywgYnV0IGJsb2NrICdwYWdlNi0x JyBtdXN0IG1vdmUgdG8gdGhlIG5leHQgcGFnZS4KKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1Rv UGFnZUhlaWdodCgicGFnZTYtMSIsIDAuMSk7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1Bh Z2VIZWlnaHQoInBhZ2U2LTIiLCAwLjEpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7 CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U2LTMiLCAwLjEpLnN0 eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9U b1BhZ2VIZWlnaHQoInBhZ2U2LTQiLCAwLjEpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9p ZCI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U2LTUiLCAwLjEp LnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0 aW9Ub1BhZ2VIZWlnaHQoInBhZ2U2LTYiLCAwLjEpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJh dm9pZCI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U2LTciLCAw LjEpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7CisKKyAgICAvLyBXZSBkb24ndCBk ZWZpbmUgd2hlcmUgYmxvY2sgJ3BhZ2U3b3I4LTEnIGlzIHBsYWNlZC4KKyAgICBjcmVhdGVCbG9j a1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTciLCAwLjUpLnN0eWxlLnBhZ2VCcmVha0JlZm9y ZSA9ICJhbHdheXMiOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJwYWdl N29yOC0xIiwgMC4xKTsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFn ZTdvcjgtMiIsIDMpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhdm9pZCI7CisgICAgY3JlYXRl QmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2UxMCIsIDAuMSk7CisKKworICAgIHBhZ2VO dW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxJywgMSk7CisgICAgcGFnZU51bWJlckZvckVs ZW1lbnRTaG91bGRCZSgncGFnZTItMScsIDIpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hv dWxkQmUoJ3BhZ2UyLTInLCAyKTsKKworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUo J3BhZ2UzLTEnLCAzKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMy0y JywgMyk7CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTMtMycsIDMpOwor CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTUnLCA1KTsKKyAgICBwYWdl TnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlNi0xJywgNik7CisgICAgLy8gT21pdCB0ZXN0 cyBmb3IgaW50ZXJtZWRpYXRlIGJsb2Nrcy4KKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3Vs ZEJlKCdwYWdlNi03JywgNik7CisKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdw YWdlNycsIDcpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxMCcsIDEw KTsKKworICAgIGRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInNhbmRib3giKSk7Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstZGlz cGxheS1ub25lLmpzIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJl YWstZGlzcGxheS1ub25lLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmMxMjE3OGI5YTI3ZDVhOTA0Y2FjMThhYzJm NGYzNzgwYzAxZDNmOGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9z Y3JpcHQtdGVzdHMvcGFnZS1icmVhay1kaXNwbGF5LW5vbmUuanMKQEAgLTAsMCArMSwyMSBAQAor ZGVzY3JpcHRpb24oIlRlc3QgZm9yIHBhZ2UtYnJlYWsgd2l0aCAnZGlzcGxheTpub25lJyIpOwor CitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdo dCgncGFnZTEtMScsIDAuMSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gJ2Fsd2F5cyc7CisKKyAg ICAvLyBpZiAnZGlzcGxheScgaXMgJ25vbmUnLCBwYWdlIGJyZWFrIHByb3BlcnR5IHNob3VsZCBu b3QgaGF2ZSBhbnkgZWZmZWN0LgorICAgIHZhciBibG9jayA9IGNyZWF0ZUJsb2NrV2l0aFJhdGlv VG9QYWdlSGVpZ2h0KCdkaXNwbGF5bm9uZScsIDAuMSk7CisgICAgYmxvY2suc3R5bGUucGFnZUJy ZWFrQmVmb3JlID0gJ2Fsd2F5cyc7CisgICAgYmxvY2suc3R5bGUuZGlzcGxheSA9ICdub25lJzsK KworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCdwYWdlMS0yJywgMC4xKTsK KworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxLTEnLCAxKTsKKyAgICBw YWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdkaXNwbGF5bm9uZScsIC0xKTsKKyAgICBwYWdl TnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMS0yJywgMSk7CisKKyAgICBkb2N1bWVudC5i b2R5LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQor Cit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L3ByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS1hdm9pZC5qcyBiL0xheW91 dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS1hdm9pZC5qcwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5kYzIzOTBhNWYzMDEyNzM1MGViMjQ2OWNjMWUyNTk5NGIwYjFkZTdmCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJl YWstaW5zaWRlLWF2b2lkLmpzCkBAIC0wLDAgKzEsNDIgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGZv ciBwYWdlLWJyZWFrLWluc2lkZTphdm9pZCIpOworCitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBj cmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTEtMSIsIDAuNSkuc3R5bGUucGFn ZUJyZWFrQmVmb3JlID0gImFsd2F5cyI7CisgICAgLy8gYmxvY2sgJ3BhZ2UxLTInIHNob3VsZCBi ZSBzcGxpdHRlZC4KKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdlMS0yIiwg MjApOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJwYWdlMiIsIDAuMSk7 CisKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTMiLCAwLjUpLnN0 eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICJhbHdheXMiOworICAgIC8vIFdlIHNob3VsZCBwbGFjZSBi bG9jayAncGFnZTQnIGluIHRoZSBuZXh0IHBhZ2UgYmVjYXVzZSBvZiAncGFnZS1icmVhay1pbnNp ZGU6IGF2b2lkJy4KKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdlNCIsIDIw KS5zdHlsZS5wYWdlQnJlYWtJbnNpZGUgPSAiYXZvaWQiOworCisgICAgY3JlYXRlQmxvY2tXaXRo UmF0aW9Ub1BhZ2VIZWlnaHQoInBhZ2U1IiwgMC41KS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAi YWx3YXlzIjsKKyAgICAvLyBibG9jayAncGFnZTUtMicgaXMgYSB2ZXJ5IGxhcmdlIGJsb2NrLCBv Y2N1cHlpbmcgbW9yZSB0aGFuIDMgcGFnZXMuCisgICAgLy8gV2UgZG9uJ3QgZGVmaW5lIGZyb20g d2hlcmUgdGhpcyBsYXJnZSBibG9jayBzdGFydHMuIE1heWJlIGZyb20gdGhlIG5leHQgcGFnZS4K KyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCJwYWdlNW9yNiIsIDIwICogMyArIDEp LnN0eWxlLnBhZ2VCcmVha0luc2lkZSA9ICJhdm9pZCI7CisgICAgY3JlYXRlQmxvY2tXaXRoUmF0 aW9Ub1BhZ2VIZWlnaHQoInBhZ2U4IiwgMC4xKTsKKworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlv VG9QYWdlSGVpZ2h0KCJwYWdlOS0xIiwgMC4xKS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAiYWx3 YXlzIjsKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdodCgicGFnZTktMiIsIDAu MSkuc3R5bGUucGFnZUJyZWFrQWZ0ZXIgPSAiYWx3YXlzIjsKKyAgICAvLyBNYWtlIHN1cmUgcGFn ZS1icmVhayBvbmx5IGhhcHBlbnMgb25jZSwgbm90IHR3aWNlLgorICAgIGNyZWF0ZUJsb2NrV2l0 aE51bWJlck9mTGluZXMoInBhZ2UxMCIsIDIwKS5zdHlsZS5wYWdlQnJlYWtJbnNpZGUgPSAiYXZv aWQiOworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTEtMScsIDEpOwor ICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxLTInLCAxKTsKKyAgICBwYWdl TnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMicsIDIpOworCisgICAgcGFnZU51bWJlckZv ckVsZW1lbnRTaG91bGRCZSgncGFnZTMnLCAzKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNo b3VsZEJlKCdwYWdlNCcsIDQpOworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgn cGFnZTUnLCA1KTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlOCcsIDgp OworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTktMScsIDkpOworICAg IHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2U5LTInLCA5KTsKKyAgICBwYWdlTnVt YmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMTAnLCAxMCk7CisKKyAgICBkb2N1bWVudC5ib2R5 LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2 YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3By aW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS5qcyBiL0xheW91dFRlc3RzL3By aW50aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLWluc2lkZS5qcwpkZWxldGVkIGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMjhhODE4MTU3NTMwNDU4N2JhNDUwOWI5OWI2ZjQ0MDU1ODc1ODMwOC4u MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9MYXlvdXRUZXN0 cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1pbnNpZGUuanMKKysrIC9kZXYvbnVs bApAQCAtMSw2MiArMCwwIEBACi1kZXNjcmlwdGlvbigiVGVzdCBmb3IgcGFnZS1icmVhay1pbnNp ZGU6YXZvaWQiKTsKLQotZnVuY3Rpb24gY3JlYXRlUGFyYWdyYXBoKGlkLCBoZWlnaHQpCi17Ci0g ICAgdmFyIGVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJkaXYiKTsKLSAgICBlbGVt ZW50LmlkID0gaWQ7Ci0gICAgZWxlbWVudC5zdHlsZS5oZWlnaHQgPSBoZWlnaHQ7Ci0gICAgZWxl bWVudC5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSgiZm9vYmFyIikpOwotICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikuYXBwZW5kQ2hpbGQoZWxlbWVudCk7 Ci0gICAgcmV0dXJuIGVsZW1lbnQ7Ci19Ci0KLXZhciBwYWdlSGVpZ2h0SW5QaXhlbHMgPSAxMDAw OwotCi1mdW5jdGlvbiBwYWdlTnVtYmVyKGlkKSB7Ci0gIHJldHVybiBsYXlvdXRUZXN0Q29udHJv bGxlci5wYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoaWQsIDEwMDAsIHBhZ2VIZWlnaHRJblBpeGVs cyk7Ci19Ci0KLWNyZWF0ZVBhcmFncmFwaCgicGFnZTEiLCA5MDApLnN0eWxlLnBhZ2VCcmVha0Jl Zm9yZSA9ICJhbHdheXMiOwotY3JlYXRlUGFyYWdyYXBoKCJwYWdlMiIsIDkwMCkuc3R5bGUucGFn ZUJyZWFrSW5zaWRlID0gImF2b2lkIjsKLQotY3JlYXRlUGFyYWdyYXBoKCJwYWdlMy0xIiwgOTAw KS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAiYWx3YXlzIjsKLWNyZWF0ZVBhcmFncmFwaCgicGFn ZTMtMiIsIDEwMCkuc3R5bGUucGFnZUJyZWFrSW5zaWRlID0gImF2b2lkIjsKLQotY3JlYXRlUGFy YWdyYXBoKCJwYWdlNCIsIDkwMCkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gImFsd2F5cyI7Ci1j cmVhdGVQYXJhZ3JhcGgoInBhZ2U1IiwgMTAxKS5zdHlsZS5wYWdlQnJlYWtJbnNpZGUgPSAiYXZv aWQiOwotCi1jcmVhdGVQYXJhZ3JhcGgoInBhZ2U2IiwgMTAwKS5zdHlsZS5wYWdlQnJlYWtCZWZv cmUgPSAiYWx3YXlzIjsKLWNyZWF0ZVBhcmFncmFwaCgicGFnZTciLCAyMTAwKS5zdHlsZS5wYWdl QnJlYWtJbnNpZGUgPSAiYXZvaWQiOwotY3JlYXRlUGFyYWdyYXBoKCJwYWdlOSIsIDEwMCk7Ci0K LWNyZWF0ZVBhcmFncmFwaCgicGFnZTEwLTEiLCAxMDApLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9 ICJhbHdheXMiOwotY3JlYXRlUGFyYWdyYXBoKCJwYWdlMTAtMiIsIDEwMCkuc3R5bGUucGFnZUJy ZWFrQWZ0ZXIgPSAiYWx3YXlzIjsKLS8vIE1ha2Ugc3VyZSBwYWdlLWJyZWFrIG9ubHkgaGFwcGVu cyBvbmNlLCBub3QgdHdpY2UuCi1jcmVhdGVQYXJhZ3JhcGgoInBhZ2UxMSIsIDkwMCkuc3R5bGUu cGFnZUJyZWFrSW5zaWRlID0gImF2b2lkIjsKLQotLy8gQmVmb3JlIGNhbGxpbmcgInNob3VsZEJl IiB0ZXN0cywgc2V0cyAiZGlzcGxheTogbm9uZSIgc3R5bGUgdG8gfGNvbnNvbGV8IGVsZW1lbnQg c28gdGhhdCB0aGUgcmVzdWx0cyBvZiBwYWdlTnVtYmVyIHNob3VsZCBub3QgYmUgYWZmZWN0ZWQu Ci0vLyBGSVhNRTogVXNlIGZ1bmN0aW9ucyBkZWZpbmVkIGluIHByaW50aW5nL3Jlc291cmNlcy9w YWdlZC1tZWRpYS10ZXN0LXV0aWxzLmpzIGluc3RlYWQgb2YgdGhpcyBoYWNrLgotZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5zdHlsZS5kaXNwbGF5ID0gJ25vbmUnOwotCi1zaG91 bGRCZSgicGFnZU51bWJlcigncGFnZTEnKSIsICIxIik7Ci1zaG91bGRCZSgicGFnZU51bWJlcign cGFnZTInKSIsICIyIik7Ci0KLXNob3VsZEJlKCJwYWdlTnVtYmVyKCdwYWdlMy0xJykiLCAiMyIp Owotc2hvdWxkQmUoInBhZ2VOdW1iZXIoJ3BhZ2UzLTInKSIsICIzIik7Ci0KLXNob3VsZEJlKCJw YWdlTnVtYmVyKCdwYWdlNCcpIiwgIjQiKTsKLXNob3VsZEJlKCJwYWdlTnVtYmVyKCdwYWdlNScp IiwgIjUiKTsKLQotc2hvdWxkQmUoInBhZ2VOdW1iZXIoJ3BhZ2U2JykiLCAiNiIpOwotc2hvdWxk QmUoInBhZ2VOdW1iZXIoJ3BhZ2U3JykiLCAiNyIpOwotc2hvdWxkQmUoInBhZ2VOdW1iZXIoJ3Bh Z2U5JykiLCAiOSIpOwotCi1zaG91bGRCZSgicGFnZU51bWJlcigncGFnZTEwLTEnKSIsICIxMCIp Owotc2hvdWxkQmUoInBhZ2VOdW1iZXIoJ3BhZ2UxMC0yJykiLCAiMTAiKTsKLXNob3VsZEJlKCJw YWdlTnVtYmVyKCdwYWdlMTEnKSIsICIxMSIpOwotCi1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi Y29uc29sZSIpLnN0eWxlLmRpc3BsYXkgPSAnYmxvY2snOwotCi1kb2N1bWVudC5ib2R5LnJlbW92 ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOwotCi12YXIgc3VjY2Vz c2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3Nj cmlwdC10ZXN0cy9wYWdlLWJyZWFrLW1lcmdpbi1jb2xsYXBzZWQuanMgYi9MYXlvdXRUZXN0cy9w cmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1tZXJnaW4tY29sbGFwc2VkLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjE5MTU5YWUxNDkwMWYxNTZjZDVmOWNiMWJkZWQxMjExMTZhNTAzYzQKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1t ZXJnaW4tY29sbGFwc2VkLmpzCkBAIC0wLDAgKzEsMTUgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGZv ciBiaWcgbWFyZ2luLiIpOworCitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBjcmVhdGVCbG9ja1dp dGhSYXRpb1RvUGFnZUhlaWdodCgncGFnZTEnLCAwLjEpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9 ICdhbHdheXMnOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCdwYWdlMics IDAuMSkuc3R5bGUubWFyZ2luVG9wID0gIjEwMDAwMHB4IjsKKworICAgIHBhZ2VOdW1iZXJGb3JF bGVtZW50U2hvdWxkQmUoJ3BhZ2UxJywgMSk7CisgICAgLy8gSW5zdGVhZCBvZiBwbGFjaW5nIGJs b2NrICdwYWdlMicgYXQgcGFnZSAxMDA/LCB3ZSBzaG91bGQgcGxhY2UgaXQgb24gdGhlIG5leHQg cGFnZSwgY29sbGFwc2luZyB0aGUgbWFyZ2luLgorICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hv dWxkQmUoJ3BhZ2UyJywgMik7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2YXIgc3VjY2Vzc2Z1bGx5UGFy c2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3NjcmlwdC10ZXN0 cy9wYWdlLWJyZWFrLW9ycGhhbnMtYW5kLXdpZG93cy5qcyBiL0xheW91dFRlc3RzL3ByaW50aW5n L3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLW9ycGhhbnMtYW5kLXdpZG93cy5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5iOTA4MmU0ZDcxYTE3ZjllZjBkNWIwZDJkNTgxM2VlNDU0NTA1MGJmCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstb3JwaGFu cy1hbmQtd2lkb3dzLmpzCkBAIC0wLDAgKzEsNjQgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGZvciB3 aWRvd3MiKTsKKworZnVuY3Rpb24gdGVzdCgpCit7CisgICAgdmFyIGJsb2NrOworICAgIGNyZWF0 ZUJsb2NrV2l0aE51bWJlck9mTGluZXMoJ3BhZ2UxLTEnLCAxMCkuc3R5bGUucGFnZUJyZWFrQmVm b3JlID0gJ2Fsd2F5cyc7CisgICAgLy8gMTAgbGluZXMgbGluZXMgYXJlIGF2YWlsYWJsZSBpbiB0 aGUgY3VycmVudCBwYWdlLgorICAgIGJsb2NrID0gY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5l cygncGFnZTEtMicsIDkpOworICAgIGJsb2NrLnN0eWxlLm9ycGhhbnMgPSAxMDsKKyAgICBibG9j ay5zdHlsZS53aWRvd3MgPSAyMDsKKyAgICAvLyBibG9jayAncGFnZTEtMicgY2FuIGJlIHBsYWNl ZCBvbiB0aGUgY3VycmVudCBwYWdlLgorICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVp Z2h0KCdwYWdlMS0zJywgMC4wMSk7CisKKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVz KCdwYWdlMicsIDEwKS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAnYWx3YXlzJzsKKyAgICAvLyAx MCBsaW5lcyBsaW5lcyBhcmUgYXZhaWxhYmxlIGluIHRoZSBjdXJyZW50IHBhZ2UuCisgICAgYmxv Y2sgPSBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCdwYWdlMycsIDEyKTsKKyAgICBibG9j ay5zdHlsZS5vcnBoYW5zID0gMTU7CisgICAgYmxvY2suc3R5bGUud2lkb3dzID0gMjsKKyAgICAv LyBibG9jayAncGFnZTMnIG11c3QgbW92ZSBhcyBhIGJsb2NrIHRvIHRoZSBuZXh0IHBhZ2UgYmVj YXVzZSBvZiAnb3JwaGFucycuCisKKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCdw YWdlNCcsIDEwKS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAnYWx3YXlzJzsKKyAgICAvLyAxMCBs aW5lcyBsaW5lcyBhcmUgYXZhaWxhYmxlIGluIHRoZSBjdXJyZW50IHBhZ2UuCisgICAgYmxvY2sg PSBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCdwYWdlNScsIDEyKTsKKyAgICBibG9jay5z dHlsZS5vcnBoYW5zID0gMjsKKyAgICBibG9jay5zdHlsZS53aWRvd3MgPSAxNTsKKyAgICAvLyBi bG9jayAncGFnZTUnIG11c3QgbW92ZSBhcyBhIGJsb2NrIHRvIHRoZSBuZXh0IHBhZ2UgYmVjYXVz ZSBvZiAnd2lkb3dzJy4KKworICAgIGNyZWF0ZUJsb2NrV2l0aE51bWJlck9mTGluZXMoJ3BhZ2U2 LTEnLCAxMCkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gJ2Fsd2F5cyc7CisgICAgLy8gMTAgbGlu ZXMgbGluZXMgYXJlIGF2YWlsYWJsZSBpbiB0aGUgY3VycmVudCBwYWdlLgorICAgIGJsb2NrID0g Y3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygncGFnZTYtMicsIDEyKTsKKyAgICBibG9jay5z dHlsZS5vcnBoYW5zID0gNjsKKyAgICBibG9jay5zdHlsZS53aWRvd3MgPSA2OworICAgIC8vIGJs b2NrICdwYWdlNicgbXVzdCBiZSBzcGxpdHRlZC4KKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1Rv UGFnZUhlaWdodCgncGFnZTcnLCAwLjAxKTsKKworICAgIGNyZWF0ZUJsb2NrV2l0aE51bWJlck9m TGluZXMoJ3BhZ2U4JywgMTApLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICdhbHdheXMnOworICAg IC8vIDEwIGxpbmVzIGxpbmVzIGFyZSBhdmFpbGFibGUgaW4gdGhlIGN1cnJlbnQgcGFnZS4KKyAg ICBibG9jayA9IGNyZWF0ZUJsb2NrV2l0aE51bWJlck9mTGluZXMoJ3BhZ2U5JywgMTIpOworICAg IGJsb2NrLnN0eWxlLm9ycGhhbnMgPSAxMDsKKyAgICBibG9jay5zdHlsZS53aWRvd3MgPSAxMDsK KyAgICAvLyBibG9jayAncGFnZTknIG11c3QgbW92ZSBhcyBhIGJsb2NrIHRvIHRoZSBuZXh0IHBh Z2UgYmVjYXVzZSB3ZSBjYW5ub3Qgc2F0aXNmeSBib3RoICdvcnBoYW5zJyBhbmQgJ3dpZG93cycg YXQgdGhlIHNhbWUgdGltZS4KKworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgn cGFnZTEtMScsIDEpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UxLTIn LCAxKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMS0zJywgMSk7CisK KyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlMicsIDIpOworICAgIHBhZ2VO dW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UzJywgMyk7CisKKyAgICBwYWdlTnVtYmVyRm9y RWxlbWVudFNob3VsZEJlKCdwYWdlNCcsIDQpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hv dWxkQmUoJ3BhZ2U1JywgNSk7CisKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdw YWdlNi0xJywgNik7CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTYtMics IDYpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2U3JywgNyk7CisKKyAg ICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlOCcsIDgpOworICAgIHBhZ2VOdW1i ZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2U5JywgOSk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJl bW92ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2YXIg c3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50 aW5nL3NjcmlwdC10ZXN0cy9wYWdlLWJyZWFrLW9ycGhhbnMuanMgYi9MYXlvdXRUZXN0cy9wcmlu dGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1vcnBoYW5zLmpzCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjk1NGMz YjdhNTkxY2I1Y2UxMTNmYmRjM2E1MDI4N2UwNTNhOGU1MzIKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay1vcnBoYW5zLmpzCkBA IC0wLDAgKzEsMjkgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGZvciBvcnBoYW5zIik7CisKK2Z1bmN0 aW9uIHRlc3QoKQoreworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCdwYWdl MS0xJywgMC41KS5zdHlsZS5wYWdlQnJlYWtCZWZvcmUgPSAnYWx3YXlzJyA7OworICAgIC8vIEhl cmUgYWJvdXQgMTAgbGluZXMgYXJlIGF2YWxpYWJsZSBhdCB0aGUgYm90dG9tIG9mIHRoZSBjdXJy ZW50IHBhZ2UuCisgICAgY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygncGFnZTEtMicsIDE1 KS5zdHlsZS5vcnBoYW5zID0gODsKKworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVp Z2h0KCdwYWdlMycsIDAuNSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gJ2Fsd2F5cycgOworICAg IC8vIHdlIHNob3VsZCBwdXQgJ3BhZ2U0JyBibG9jayBpbiB0aGUgbmV4dCBwYWdlIGJlY2F1c2Ug b2Ygb3JwaGFucy4KKyAgICBjcmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCdwYWdlNCcsIDE1 KS5zdHlsZS5vcnBoYW5zID0gMTI7CisKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhl aWdodCgncGFnZTUtMScsIDAuNSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gJ2Fsd2F5cycgOwor ICAgIC8vICctMScgaXMgYWNjZXB0YWJsZSBhcyBhIHZhbHVlIG9mIG9ycGhhbnMuIEJ1dCBpdCBz aG91bGQgaGF2ZSBubyBlZmZlY3QuCisgICAgY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygn cGFnZTUtMicsIDIwKS5zdHlsZS5vcnBoYW5zID0gLTE7CisKKyAgICBwYWdlTnVtYmVyRm9yRWxl bWVudFNob3VsZEJlKCdwYWdlMS0xJywgMSk7CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91 bGRCZSgncGFnZTEtMicsIDEpOworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgn cGFnZTMnLCAzKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlNCcsIDQp OworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTUtMScsIDUpOworICAg IHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2U1LTInLCA1KTsKKworICAgIGRvY3Vt ZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3giKSk7 Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstd2lkb3dzLmpzIGIvTGF5b3V0 VGVzdHMvcHJpbnRpbmcvc2NyaXB0LXRlc3RzL3BhZ2UtYnJlYWstd2lkb3dzLmpzCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjBhZTIzODY5NTNkZDc1YmZkNjRiMGZmZTMxZjgyODY0YmIyNDFlMTYKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQtdGVzdHMvcGFnZS1icmVhay13aWRv d3MuanMKQEAgLTAsMCArMSwzNSBAQAorZGVzY3JpcHRpb24oIlRlc3QgZm9yIHdpZG93cyIpOwor CitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBjcmVhdGVCbG9ja1dpdGhSYXRpb1RvUGFnZUhlaWdo dCgncGFnZTEtMScsIDAuNSkuc3R5bGUucGFnZUJyZWFrQmVmb3JlID0gJ2Fsd2F5cycgOzsKKyAg ICAvLyBIZXJlIGFib3V0IDEwIGxpbmVzIGFyZSBhdmFsaWFibGUgYXQgdGhlIGJvdHRvbSBvZiB0 aGUgY3VycmVudCBwYWdlLgorICAgIC8vIFdlIGNhbiBsZWF2ZSBhYm91dCA1IGxpbmVzIGluIHRo ZSBuZXh0IHBhZ2UuIEl0IGRvZXNuJ3QgdmlvbGF0ZSB3aWRvd3MgcmVzdHJpY3Rpb24uCisgICAg Y3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygncGFnZTEtMicsIDE1KS5zdHlsZS53aWRvd3Mg PSAyOworICAgIC8vIEhlcmUgYWJvdXQgMTUgbGluZXMgbGluZXMgc2hvdWxkIGJlIGF2YWlsYWJs ZSBpbiB0aGUgY3VycmVudCBwYWdlLgorICAgIGNyZWF0ZUJsb2NrV2l0aE51bWJlck9mTGluZXMo J3BhZ2UyLTEnLCAxMCk7CisgICAgY3JlYXRlQmxvY2tXaXRoTnVtYmVyT2ZMaW5lcygncGFnZTIt MicsIDIpOworCisgICAgY3JlYXRlQmxvY2tXaXRoUmF0aW9Ub1BhZ2VIZWlnaHQoJ3BhZ2UzLTEn LCAwLjUpLnN0eWxlLnBhZ2VCcmVha0JlZm9yZSA9ICdhbHdheXMnIDsKKyAgICAvLyBUaGUgc2Vj b25kIHBhcnQgb2YgJ3BhZ2UzLTInIGJsb2NrIG11c3QgY29udGFpbiBhdCBsZWFzdCAxMiBsaW5l cyBpbiB0aGUgbmV4dCBwYWdlLgorICAgIC8vIFNvIHRoZSBibG9jayBtdXN0IGJlIHNlcGFyYXRl ZCBpbiBlYXJsaWVyIHBvc2l0aW9uLgorICAgIGNyZWF0ZUJsb2NrV2l0aE51bWJlck9mTGluZXMo J3BhZ2UzLTInLCAxNSkuc3R5bGUud2lkb3dzID0gMTI7CisgICAgLy8gSGVyZSBhdCBtb3N0IDgg KD0gMjAgLSAxMikgbGluZXMgc2hvdWxkIGJlIGF2YWlsYWJsZSBpbiB0aGUgbmV4dCBwYWdlLgor ICAgIC8vIFRoZXJlZm9yZSAncGFnZTYnIGJsb2NrIHNob3VsZCBiZSBpbiBwYWdlNi4KKyAgICBj cmVhdGVCbG9ja1dpdGhOdW1iZXJPZkxpbmVzKCdwYWdlNCcsIDEwKTsKKyAgICBjcmVhdGVCbG9j a1dpdGhOdW1iZXJPZkxpbmVzKCdwYWdlNScsIDIpOworCisgICAgcGFnZU51bWJlckZvckVsZW1l bnRTaG91bGRCZSgncGFnZTEtMScsIDEpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxk QmUoJ3BhZ2UxLTInLCAxKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdl Mi0xJywgMik7CisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTItMicsIDIp OworCisgICAgcGFnZU51bWJlckZvckVsZW1lbnRTaG91bGRCZSgncGFnZTMtMScsIDMpOworICAg IHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3BhZ2UzLTInLCAzKTsKKyAgICBwYWdlTnVt YmVyRm9yRWxlbWVudFNob3VsZEJlKCdwYWdlNCcsIDQpOworICAgIHBhZ2VOdW1iZXJGb3JFbGVt ZW50U2hvdWxkQmUoJ3BhZ2U1JywgNSk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxk KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworfQorCit2YXIgc3VjY2Vzc2Z1 bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3ByaW50aW5nL3Njcmlw dC10ZXN0cy9wYWdlTnVtZXJGb3JFbGVtZW50QnlJZC5qcyBiL0xheW91dFRlc3RzL3ByaW50aW5n L3NjcmlwdC10ZXN0cy9wYWdlTnVtZXJGb3JFbGVtZW50QnlJZC5qcwppbmRleCA4N2Q4OGVjNmE0 N2RmZDZlMWFiOTRmNWRkZGYwZTcwZmE0ZTU3NjdhLi42MmNjMTM0Mzc2Nzc1Zjc3ZTI2MTRiODY3 YWFjMmM2N2Q2YjYzYjg4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wcmludGluZy9zY3JpcHQt dGVzdHMvcGFnZU51bWVyRm9yRWxlbWVudEJ5SWQuanMKKysrIGIvTGF5b3V0VGVzdHMvcHJpbnRp bmcvc2NyaXB0LXRlc3RzL3BhZ2VOdW1lckZvckVsZW1lbnRCeUlkLmpzCkBAIC0xLDMxICsxLDE5 IEBACiBkZXNjcmlwdGlvbigiVGVzdCBmb3IgbGF5b3V0VGVzdENvbnRyb2xsZXIucGFnZU51bWJl ckZvckVsZW1lbnRCeUlkKCkiKTsKIAotZnVuY3Rpb24gY3JlYXRlUGFyYWdyYXBoKGlkKQorZnVu Y3Rpb24gdGVzdCgpCiB7Ci0gICAgdmFyIGVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJkaXYiKTsKLSAgICBlbGVtZW50LmlkID0gaWQ7Ci0gICAgZWxlbWVudC53aWR0aCA9IDEwMDsK LSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2FuZGJveCIpLmFwcGVuZENoaWxkKGVsZW1l bnQpOwotICAgIHJldHVybiBlbGVtZW50OwotfQotCi12YXIgZmlyc3RQYWdlID0gY3JlYXRlUGFy YWdyYXBoKCJmaXJzdFBhZ2UiKTsKLWZpcnN0UGFnZS5zdHlsZS5oZWlnaHQgPSAxMDAwOwotCi12 YXIgc2Vjb25kUGFnZSA9IGNyZWF0ZVBhcmFncmFwaCgic2Vjb25kUGFnZSIpOwotc2Vjb25kUGFn ZS5zdHlsZS5oZWlnaHQgPSAxMDAwOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVp Z2h0KCJmaXJzdFBhZ2UiLCAwLjYpOworICAgIGNyZWF0ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVp Z2h0KCJzZWNvbmRQYWdlIiwgMC45KTsKIAotdmFyIHRoaXJkUGFnZSA9IGNyZWF0ZVBhcmFncmFw aCgidGhpcmRQYWdlIik7Ci10aGlyZFBhZ2Uuc3R5bGUuaGVpZ2h0ID0gMTAwOworICAgIGNyZWF0 ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJ0aGlyZFBhZ2UiLCAwLjMpOworICAgIGNyZWF0 ZUJsb2NrV2l0aFJhdGlvVG9QYWdlSGVpZ2h0KCJ0aGlyZFBhZ2UyIiwgMC4zKTsKIAotdmFyIHRo aXJkUGFnZTIgPSBjcmVhdGVQYXJhZ3JhcGgoInRoaXJkUGFnZTIiKTsKLXRoaXJkUGFnZTIuc3R5 bGUuaGVpZ2h0ID0gNzAwOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ2ZpcnN0 UGFnZScsIDApOworICAgIHBhZ2VOdW1iZXJGb3JFbGVtZW50U2hvdWxkQmUoJ3NlY29uZFBhZ2Un LCAxKTsKKyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCd0aGlyZFBhZ2UnLCAyKTsK KyAgICBwYWdlTnVtYmVyRm9yRWxlbWVudFNob3VsZEJlKCd0aGlyZFBhZ2UyJywgMik7CiAKLXNo b3VsZEJlKCJsYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoJ2Zp cnN0UGFnZScsIDEwMDAsIDEwMDApIiwgIjAiKTsKLXNob3VsZEJlKCJsYXlvdXRUZXN0Q29udHJv bGxlci5wYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoJ3NlY29uZFBhZ2UnLCAxMDAwLCAxMDAwKSIs ICIxIik7Ci1zaG91bGRCZSgibGF5b3V0VGVzdENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1l bnRCeUlkKCd0aGlyZFBhZ2UnLCAxMDAwLCAxMDAwKSIsICIyIik7Ci1zaG91bGRCZSgibGF5b3V0 VGVzdENvbnRyb2xsZXIucGFnZU51bWJlckZvckVsZW1lbnRCeUlkKCd0aGlyZFBhZ2UyJywgMTAw MCwgMTAwMCkiLCAiMiIpOwotCi1kb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJzYW5kYm94IikpOworICAgIGRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQo ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNhbmRib3giKSk7Cit9CiAKIHZhciBzdWNjZXNzZnVs bHlQYXJzZWQgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCA5MmMwMGUyYjk1ZmEwNTU4ODUwZjVmYzNhM2QwODhkZDdjNTJiODY3 Li44NDZiNDY5NzBkZGU4NDJkMTQ3YmRhMzA2Y2E4ZWExZTY3NTU3YWQ4IDEwMDY0NAotLS0gYS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY0IEBA CisyMDEwLTA1LTI3ICBIYXlhdG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbXBsZW1lbnQgQ1NTMyBQ ZWdlZCBNZWRpYSAtIFBhZ2UgQnJlYWtzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9Mzk3MzUKKworICAgICAgICBSZXdyaXRlIHBhZ2UgYnJlYWsgZGV0 ZXJtaW5hdGlvbiBjb2RlLgorCisgICAgICAgIEFkZCBzdXBwb3J0cyBmb3IgdGhlIGZvbGxvd2lu ZyBDU1MgcHJvcGVydGllczoKKyAgICAgICAgICAtIHBhZ2UtYnJlYWste2JlZm9yZSxhZnRlcn06 IGF2b2lkCisgICAgICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzQxNTUKKyAgICAgICAgICAtIG9ycGhhbnMgYW5kIHdpZG93cworICAgICAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk0MTAKKworICAgICAgICBUaGUg Y2hhbmdlIGhhcHBlbmVkIHRvIGZpeCB0aGUgZm9sbG93aW5nIGJ1Z3MgYXMgYSByZXN1bHQ6Cisg ICAgICAgICAgLSBBIG1hcmdpbi17dG9wLGJvdHRvbX0gc2hvdWxkIGJlIGNvbGxhcHNlZCB3aGVu IHByaW50aW5nLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTM5NzMyCisgICAgICAgICAgLSBQcmludGluZyBjb2RlIHNob3VsZCBicmVhayBhIHBh Z2Ugb25seSBhdCBhbGxvd2VkIHBhZ2UgYnJlYWtlIHBvc2l0aW9ucworICAgICAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5NzMzCisKKyAgICAgICAgU3Bl YyBsaW5rOgorICAgICAgICBodHRwOi8vZGV2LnczLm9yZy9jc3N3Zy9jc3MzLXBhZ2UvI3BhZ2Ut YnJlYWtzCisKKyAgICAgICAgVGVzdDogZXhpc3RpbmcgYW5kIG5ldyBwcmludGluZy8qLmh0bWwK KworICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2o6CisgICAgICAgICogcGFnZS9QYWdlQnJlYWsuaDogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpQYWdlQnJlYWs6Oik6CisgICAgICAgIChXZWJDb3JlOjpQYWdlQnJlYWs6 OlBhZ2VCcmVhayk6CisgICAgICAgICogcGFnZS9QcmludENvbnRleHQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6UHJpbnRDb250ZXh0OjpQcmludENvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6 UHJpbnRDb250ZXh0Ojp+UHJpbnRDb250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlByaW50Q29u dGV4dDo6Y29tcHV0ZVBhZ2VSZWN0c1dpdGhQYWdlU2l6ZUludGVybmFsKToKKyAgICAgICAgKFdl YkNvcmU6OlByaW50Q29udGV4dDo6dmlzaXRSZW5kZXJCbG9ja0JlZm9yZSk6CisgICAgICAgIChX ZWJDb3JlOjpQcmludENvbnRleHQ6OnZpc2l0UmVuZGVyQmxvY2tBZnRlcik6CisgICAgICAgIChX ZWJDb3JlOjpQcmludENvbnRleHQ6OnZpc2l0Rmlyc3RDaGlsZEJsb2NrQm94KToKKyAgICAgICAg KFdlYkNvcmU6OlByaW50Q29udGV4dDo6dmlzaXRMYXN0Q2hpbGRCbG9ja0JveCk6CisgICAgICAg IChXZWJDb3JlOjpQcmludENvbnRleHQ6OnZpc2l0QmV0d2VlbkJsb2NrQm94ZXMpOgorICAgICAg ICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0Ojp2aXNpdEJldHdlZW5MaW5lQm94ZXMpOgorICAgICAg ICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjphZGRQYWdlQnJlYWtDYW5kaWRhdGUpOgorICAgICAg ICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjphZGRQc2V1ZG9QYWdlQnJlYWspOgorICAgICAgICAo V2ViQ29yZTo6UHJpbnRDb250ZXh0OjpmaWxsTGFyZ2VHYXBXaXRoUGFnZUJyZWFrcyk6CisgICAg ICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmNyZWF0ZUJyaWRnZVBhZ2VCcmVhayk6CisgICAg ICAgIChXZWJDb3JlOjpjb21wYXJlUGFnZUJyZWFrKToKKyAgICAgICAgKFdlYkNvcmU6OlByaW50 Q29udGV4dDo6c29ydFBhZ2VCcmVha0NhbmRpZGF0ZXMpOgorICAgICAgICAoV2ViQ29yZTo6UHJp bnRDb250ZXh0OjpkZXRlcm1pbmVCZXN0UGFnZUJyZWFrcyk6CisgICAgICAgIChXZWJDb3JlOjpQ cmludENvbnRleHQ6OmV2YWx1YXRlU2NvcmVPZlBhZ2VCcmVhayk6CisgICAgICAgICogcGFnZS9Q cmludENvbnRleHQuaDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwOgorICAg ICAgICAoV2ViQ29yZTo6UmVuZGVyQmxvY2s6OnBhaW50KToKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlckJsb2NrOjpwYWludENoaWxkcmVuKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGlu ZUJveExpc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGluZUJveExpc3Q6OnBhaW50 KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmlldy5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJWaWV3OjpSZW5kZXJWaWV3KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmll dy5oOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVmlldzo6c2V0UHJpbnRDb250ZXh0KToKKyAg ICAgICAgKFdlYkNvcmU6OlJlbmRlclZpZXc6OnByaW50Q29udGV4dCk6CisKIDIwMTAtMDUtMTkg IFZhbmdlbGlzIEtva2tldmlzICA8dmFuZ2VsaXNAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5neXBp IGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggODdiZWU3YTFjOTE5NWJjNDFkY2VhNjMwNTk1 YzVmYWFmZTRkZWEyMy4uOGEyZDZlMGVlZjFiYTkwYzIxODM2ZTgwNzVmNjgwZTUzOGIwZTQyNSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvV2ViQ29yZS9XZWJDb3JlLmd5 cGkKQEAgLTE5MzIsNiArMTkzMiw3IEBACiAgICAgICAgICAgICAncGFnZS9PcmlnaW5BY2Nlc3NF bnRyeS5oJywKICAgICAgICAgICAgICdwYWdlL1BhZ2UuY3BwJywKICAgICAgICAgICAgICdwYWdl L1BhZ2UuaCcsCisgICAgICAgICAgICAncGFnZS9QYWdlQnJlYWsuaCcsCiAgICAgICAgICAgICAn cGFnZS9QYWdlR3JvdXAuY3BwJywKICAgICAgICAgICAgICdwYWdlL1BhZ2VHcm91cC5oJywKICAg ICAgICAgICAgICdwYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAnLApAQCAtMTk0Myw2ICsx OTQ0LDcgQEAKICAgICAgICAgICAgICdwYWdlL1Bvc2l0aW9uRXJyb3IuaCcsCiAgICAgICAgICAg ICAncGFnZS9Qb3NpdGlvbkVycm9yQ2FsbGJhY2suaCcsCiAgICAgICAgICAgICAncGFnZS9Qb3Np dGlvbk9wdGlvbnMuaCcsCisgICAgICAgICAgICAncGFnZS9QcmludENvbnRleHQuaCcsCiAgICAg ICAgICAgICAncGFnZS9QcmludENvbnRleHQuY3BwJywKICAgICAgICAgICAgICdwYWdlL1ByaW50 Q29udGV4dC5oJywKICAgICAgICAgICAgICdwYWdlL1NjcmVlbi5jcHAnLApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBjYWIxNDc1ZGRiOWFmNjVkOWViZGMx YzkwNzY1N2E5MzE2Y2EyZTZhLi4zMDRhM2M4YTdhNWI0MmNjMDAwNzU0NDE3YmU0YmFlZTdjYjk4 NjJiIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTI1 Myw2ICsxMjUzLDcgQEAKIAkJNjU5RERDODIwOUUxOThCQTAwMUJGM0M2IC8qIEpTRG9jdW1lbnQu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjU5RERD ODAwOUUxOThCQTAwMUJGM0M2IC8qIEpTRG9jdW1lbnQuY3BwICovOyB9OwogCQk2NTlEREM4MzA5 RTE5OEJBMDAxQkYzQzYgLyogSlNEb2N1bWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNjU5RERDODEwOUUxOThCQTAwMUJGM0M2IC8qIEpTRG9jdW1l bnQuaCAqLzsgfTsKIAkJNjVBMjE0NjgwOTdBMzI5MTAwQjkwNTBBIC8qIFBhZ2UuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDY1QTIxNDY3MDk3QTMyOTEw MEI5MDUwQSAvKiBQYWdlLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwg KTsgfTsgfTsKKwkJNEFCRjgxMEUxMTNENTIyNzAwNDkzN0Q1IC8qIFBhZ2VCcmVhay5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEFCRjgxMEMxMTNENTIy NzAwNDkzN0Q1IC8qIFBhZ2VCcmVhay5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCTY1QTIxNDg0MDk3QTNGNTMwMEI5MDUwQSAvKiBGcmFtZVRyZWUu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjVBMjE0 ODIwOTdBM0Y1MzAwQjkwNTBBIC8qIEZyYW1lVHJlZS5jcHAgKi87IH07CiAJCTY1QTIxNDg1MDk3 QTNGNTMwMEI5MDUwQSAvKiBGcmFtZVRyZWUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDY1QTIxNDgzMDk3QTNGNTMwMEI5MDUwQSAvKiBGcmFtZVRyZWUu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk2NUFB NkJBRjBEOTc0QTAwMDAwNTQxQUUgLyogRE9NU1ZHQWx0R2x5cGhFbGVtZW50LmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA2NUFBNkJBQzBEOTc0QTAwMDAw NTQxQUUgLyogRE9NU1ZHQWx0R2x5cGhFbGVtZW50LmggKi87IH07CkBAIC02ODY1LDYgKzY4NjYs NyBAQAogCQk2NTlEREM4MDA5RTE5OEJBMDAxQkYzQzYgLyogSlNEb2N1bWVudC5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSlNEb2N1bWVudC5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1OUREQzgxMDlFMTk4QkEwMDFCRjNDNiAvKiBKU0RvY3Vt ZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU0RvY3VtZW50Lmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1QTIxNDY3MDk3QTMyOTEwMEI5MDUwQSAvKiBQ YWdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBQYWdlLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTRBQkY4MTBDMTEzRDUyMjcwMDQ5MzdENSAvKiBQYWdlQnJl YWsuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGFnZUJyZWFrLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1QTIxNDgyMDk3QTNGNTMwMEI5MDUwQSAvKiBGcmFt ZVRyZWUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMw OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZyYW1lVHJl ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1QTIxNDgzMDk3QTNGNTMwMEI5 MDUwQSAvKiBGcmFtZVRyZWUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZy YW1lVHJlZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk2NUE2NDBGMDA1MzNCQjFG MDA4NUU3NzcgLyogQmxvY2tFeGNlcHRpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gMzA7IGluZGVudFdpZHRoID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEJsb2NrRXhjZXB0aW9ucy5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB0YWJXaWR0aCA9IDg7IHVzZXNUYWJzID0gMDsgfTsKQEAgLTExOTg2LDYgKzEx OTg4LDcgQEAKIAkJCQkwMDE0NjI4OTEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50 cnkuaCAqLywKIAkJCQk2NUZFQTg2ODA5ODMzQURFMDBCRUQ0QUIgLyogUGFnZS5jcHAgKi8sCiAJ CQkJNjVBMjE0NjcwOTdBMzI5MTAwQjkwNTBBIC8qIFBhZ2UuaCAqLywKKwkJCQk0QUJGODEwQzEx M0Q1MjI3MDA0OTM3RDUgLyogUGFnZUJyZWFrLmggKi8sCiAJCQkJOTMwMkIwQkMwRDc5RjgyOTAw QzdFRTgzIC8qIFBhZ2VHcm91cC5jcHAgKi8sCiAJCQkJOTMwMkIwQkUwRDc5RjgyQzAwQzdFRTgz IC8qIFBhZ2VHcm91cC5oICovLAogCQkJCTdBNjc0QkQ5MEY5RUJGNEUwMDZDRjA5OSAvKiBQYWdl R3JvdXBMb2FkRGVmZXJyZXIuY3BwICovLApAQCAtMTg0OTIsNiArMTg0OTUsNyBAQAogCQkJCTFB MEQ1NzM3MEE1Qzc3RkUwMDdFREQ0QyAvKiBPdmVyZmxvd0V2ZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQkzNzc0QUJBNTBGQTIxRUI0MDBBRDdERTkgLyogT3ZlcmxhcFRlc3RSZXF1ZXN0Q2xpZW50 LmggaW4gSGVhZGVycyAqLywKIAkJCQk2NUEyMTQ2ODA5N0EzMjkxMDBCOTA1MEEgLyogUGFnZS5o IGluIEhlYWRlcnMgKi8sCisJCQkJNEFCRjgxMEUxMTNENTIyNzAwNDkzN0Q1IC8qIFBhZ2VCcmVh ay5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQ3N0U3NzcwQkY0MTM0QTAwMTUyODcyIC8qIFBhZ2VD YWNoZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTMwMkIwQkYwRDc5RjgyQzAwQzdFRTgzIC8qIFBh Z2VHcm91cC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJN0E2NzRCREMwRjlFQkY0RTAwNkNGMDk5IC8q IFBhZ2VHcm91cExvYWREZWZlcnJlci5oIGluIEhlYWRlcnMgKi8sCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvUGFnZUJyZWFrLmggYi9XZWJDb3JlL3BhZ2UvUGFnZUJyZWFrLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uMmMwZTA3YjBiNDViZjk2ZmY0ZjJlNjhiZmVjM2NkNGQ5Y2I0ZDgzNAotLS0gL2Rldi9udWxs CisrKyBiL1dlYkNvcmUvcGFnZS9QYWdlQnJlYWsuaApAQCAtMCwwICsxLDc0IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3Ry aWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRo ZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9y IHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQg c3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAq ICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBQ YWdlQnJlYWtfaAorI2RlZmluZSBQYWdlQnJlYWtfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K3N0cnVjdCBQYWdlQnJlYWsgeworCisgICAgZW51bSBQYWdlQnJlYWtUeXBlIHsKKyAgICAgICAg QmV0d2VlbkJsb2NrQm94ZXMsIC8vIEluIHRoZSB2ZXJ0aWNhbCBtYXJnaW4gYmV0d2VlbiBzaWJs aW5nIGJsb3hlcy4gU2VlIENTUzMgUGFnZWQgTWVkaWEgOS40IC0gQWxsb3dlZCBwYWdlIGJyZWFr cyAxLgorICAgICAgICBCZXR3ZWVuTGluZUJveGVzLCAvLyBCZXR3ZWVuIGxpbmUgYm94ZXMgaW5z aWRlIGEgYmxvY2sgYm94LiBTZWUgQ1NTMyBQYWdlZCBNZWRpYSA5LjQuIC0gQWxsb3dlZCBwYWdl IGJyZWFrcyAyLgorICAgICAgICBCZXR3ZWVuQmxvY2tCb3hBbmRDaGlsZCwgLy8gQmV0d2VlbiB0 aGUgY29udGVudCBlZGdlIG9mIGEgYmxvY2sgYm94IGFuZCB0aGUgY2hpbGQuIFNlZSBDU1MzOiA5 LjQuIEFsbG93ZWQgcGFnZSBicmVha3MgLSAzLgorICAgICAgICBCcmlkZ2UsIC8vIEFuIGluc2Vy dGVkIHBhZ2UgYnJlYWsgaW4gYSBsYXJnZSBibGFuayBhcmVhIHdoZXJlIHRoZXJlIGlzIG5vIGFs bG93ZCBwYWdlIGJyZWFrLgorICAgICAgICBQc2V1ZG8sIC8vIE90aGVyIHBzZXVkbyBwYWdlIGJy ZWFrLiBGb3IgZXhhbXBsZSwgdGhlIHN0YXJ0IG9yIHRoZSBlbmQgb2YgZG9jdW1lbnQuCisgICAg fTsKKworICAgIFBhZ2VCcmVhaygpCisgICAgICAgICAgICA6IHBhZ2VCcmVha1R5cGUoUHNldWRv KQorICAgICAgICAgICAgLCB0b3AoLTEpCisgICAgICAgICAgICAsIGJvdHRvbSgtMSkKKyAgICAg ICAgICAgICwgaXNBbHdheXMoZmFsc2UpCisgICAgICAgICAgICAsIGlzQXZvaWQoZmFsc2UpCisg ICAgICAgICAgICAsIGlzVmlvbGV0aW5nT3JwaGFuc09yV2lkb3dzUnVsZShmYWxzZSkKKyAgICB7 CisgICAgfQorCisgICAgUGFnZUJyZWFrVHlwZSBwYWdlQnJlYWtUeXBlOworCisgICAgLy8gQWJz b2x1dGUgWSBwb3NpdGlvbiB3aGVyZSBwYWdlIGJyZWFrIG9jY3Vycy4KKyAgICBpbnQgdG9wOwor ICAgIGludCBib3R0b207CisKKyAgICAvLyBVc2VkIGJ5IENTUzMgUGFnZWQgTWVkaWEgOS40IC0g UnVsZSBBLiBGb3JjZWQgcGFnZSBicmVhay4KKyAgICBib29sIGlzQWx3YXlzOworCisgICAgLy8g VXNlZCBieSBDU1MzIFBhZ2VkIE1lZGlhIDkuNCAtIFJ1bGUgQiBhbmQgUnVsZSBELiBQYWdlIGJy ZWFrIHNob3VsZCBiZSBhdm9pZGVkIGhlcmUgaWYgdHJ1ZS4KKyAgICBib29sIGlzQXZvaWQ7CisK KyAgICAvLyBVc2VkIGJ5IENTUzMgUGFnYWQgTWVkaWEgOS40IC0gUnVsZSBDLiBXaGV0aGVyIHBh Z2UgYnJlYWsgdmlvbGF0ZXMgdGhlIHJ1bGUgb2Ygb3JwaGFucyBhbmQgd2lkb3dzIG9yIG5vdC4K KyAgICBib29sIGlzVmlvbGV0aW5nT3JwaGFuc09yV2lkb3dzUnVsZTsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFBhZ2VCcmVha19oCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvUHJpbnRDb250ZXh0LmNwcCBiL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3Bw CmluZGV4IGZmZGUwYmViMWUzYzBiZTQ0ZDdlNTIyOTc3YjNhYjUzNjI4NmMxZDAuLmE4OWU4MWNl ZGVkYzcyNTBlMzhlMzk3ODZkOWMyOWU2MTNiMWFmMjMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFn ZS9QcmludENvbnRleHQuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCkBA IC0yMSwxMSArMjEsMTcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJQcmludENv bnRleHQuaCIKIAotI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2luY2x1ZGUgIkZyYW1l LmgiCi0jaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0Lmgi CisjaW5jbHVkZSAiSW5saW5lRmxvd0JveC5oIgorI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCisj aW5jbHVkZSAiUmVuZGVyQm94LmgiCisjaW5jbHVkZSAiUmVuZGVyQm94TW9kZWxPYmplY3QuaCIK KyNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKIAorI2lu Y2x1ZGUgPGxpbWl0cz4KKwogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKQEAgLTMzLDYgKzM5LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogUHJpbnRDb250 ZXh0OjpQcmludENvbnRleHQoRnJhbWUqIGZyYW1lKQogICAgIDogbV9mcmFtZShmcmFtZSkKICAg ICAsIG1faXNQcmludGluZyhmYWxzZSkKKyAgICAsIG1fcGFnZUJyZWFrQ2FuZGlkYXRlcygpCisg ICAgLCBtX2FuY2VzdG9yQmxvY2tXaXRoUGFnZUJyZWFrSW5zaWRlQXZvaWQoMCkKIHsKIH0KIApA QCAtNDEsNiArNDksNyBAQCBQcmludENvbnRleHQ6On5QcmludENvbnRleHQoKQogICAgIGlmICht X2lzUHJpbnRpbmcpCiAgICAgICAgIGVuZCgpOwogICAgIG1fcGFnZVJlY3RzLmNsZWFyKCk7Cisg ICAgbV9wYWdlQnJlYWtDYW5kaWRhdGVzLmNsZWFyKCk7CiB9CiAKIGludCBQcmludENvbnRleHQ6 OnBhZ2VDb3VudCgpIGNvbnN0CkBAIC05NiwyNSArMTA1LDQyIEBAIHZvaWQgUHJpbnRDb250ZXh0 Ojpjb21wdXRlUGFnZVJlY3RzV2l0aFBhZ2VTaXplSW50ZXJuYWwoY29uc3QgRmxvYXRTaXplJiBw YWdlU2l6CiAgICAgUmVuZGVyVmlldyogcm9vdCA9IHRvUmVuZGVyVmlldyhtX2ZyYW1lLT5kb2N1 bWVudCgpLT5yZW5kZXJlcigpKTsKIAogICAgIGNvbnN0IGZsb2F0IHBhZ2VXaWR0aCA9IHBhZ2VT aXplSW5QaXhlbHMud2lkdGgoKTsKKyAgICBjb25zdCBmbG9hdCBwYWdlSGVpZ2h0ID0gcGFnZVNp emVJblBpeGVscy5oZWlnaHQoKTsKKwogICAgIGNvbnN0IGZsb2F0IGRvY1dpZHRoID0gcm9vdC0+ bGF5ZXIoKS0+d2lkdGgoKTsKICAgICBjb25zdCBmbG9hdCBkb2NIZWlnaHQgPSByb290LT5sYXll cigpLT5oZWlnaHQoKTsKLSAgICBmbG9hdCBjdXJyUGFnZUhlaWdodCA9IHBhZ2VTaXplSW5QaXhl bHMuaGVpZ2h0KCk7Ci0KLSAgICAvLyBhbHdheXMgcmV0dXJuIGF0IGxlYXN0IG9uZSBwYWdlLCBz aW5jZSBlbXB0eSBmaWxlcyBzaG91bGQgcHJpbnQgYSBibGFuayBwYWdlCi0gICAgZmxvYXQgcHJp bnRlZFBhZ2VzSGVpZ2h0ID0gMDsKLSAgICBkbyB7Ci0gICAgICAgIGZsb2F0IHByb3Bvc2VkQm90 dG9tID0gc3RkOjptaW4oZG9jSGVpZ2h0LCBwcmludGVkUGFnZXNIZWlnaHQgKyBwYWdlU2l6ZUlu UGl4ZWxzLmhlaWdodCgpKTsKLSAgICAgICAgbV9mcmFtZS0+dmlldygpLT5hZGp1c3RQYWdlSGVp Z2h0KCZwcm9wb3NlZEJvdHRvbSwgcHJpbnRlZFBhZ2VzSGVpZ2h0LCBwcm9wb3NlZEJvdHRvbSwg cHJpbnRlZFBhZ2VzSGVpZ2h0KTsKLSAgICAgICAgY3VyclBhZ2VIZWlnaHQgPSBtYXgoMS4wZiwg cHJvcG9zZWRCb3R0b20gLSBwcmludGVkUGFnZXNIZWlnaHQpOworCisgICAgR3JhcGhpY3NDb250 ZXh0IGNvbnRleHQoKFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0KikwKTsKKyAgICBJbnRSZWN0IGRp cnR5UmVjdCgwLCAwLCByb290LT5yaWdodExheW91dE92ZXJmbG93KCksIChpbnQpY2VpbGYoZG9j SGVpZ2h0KSk7CisKKyAgICAvLyBDb2xsZWN0IGFsbG93ZWQgcGFnZSBicmVha3MgaW4gZG9jdW1l bnQuCisgICAgQVNTRVJUKCFyb290LT5wcmludENvbnRleHQoKSk7CisgICAgcm9vdC0+c2V0UHJp bnRDb250ZXh0KHRoaXMpOworICAgIHJvb3QtPmxheWVyKCktPnBhaW50KCZjb250ZXh0LCBkaXJ0 eVJlY3QpOworICAgIHJvb3QtPnNldFByaW50Q29udGV4dCgwKTsKKworICAgIC8vIEFkZCBvdGhl ciBwc3VlZG8gcGFnZSBicmVha3MuCisgICAgYWRkUHNldWRvUGFnZUJyZWFrKDApOworICAgIGFk ZFBzZXVkb1BhZ2VCcmVhaygoaW50KWNlaWxmKGRvY0hlaWdodCkpOworICAgIGZpbGxMYXJnZUdh cFdpdGhQYWdlQnJlYWtzKHBhZ2VIZWlnaHQpOworCisgICAgVmVjdG9yPGludD4gYmVzdFBhZ2VC cmVha1Bvc2l0aW9uOworICAgIGRldGVybWluZUJlc3RQYWdlQnJlYWtzKHBhZ2VIZWlnaHQsICZi ZXN0UGFnZUJyZWFrUG9zaXRpb24pOworCisgICAgaW50IHByZXZpb3VzWVBvc2l0aW9uID0gMDsK KyAgICBjb25zdCBpbnQgc2l6ZSA9IGJlc3RQYWdlQnJlYWtQb3NpdGlvbi5zaXplKCk7CisgICAg Zm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgaW50IHlQb3NpdGlvbiA9 IGJlc3RQYWdlQnJlYWtQb3NpdGlvbltpXTsKICAgICAgICAgaWYgKGFsbG93SG9yaXpvbnRhbE11 bHRpUGFnZXMpIHsKICAgICAgICAgICAgIGZvciAoZmxvYXQgY3VyV2lkdGggPSAwOyBjdXJXaWR0 aCA8IGRvY1dpZHRoOyBjdXJXaWR0aCArPSBwYWdlV2lkdGgpCi0gICAgICAgICAgICAgICAgbV9w YWdlUmVjdHMuYXBwZW5kKEludFJlY3QoY3VyV2lkdGgsIChpbnQpcHJpbnRlZFBhZ2VzSGVpZ2h0 LCAoaW50KXBhZ2VXaWR0aCwgKGludCljdXJyUGFnZUhlaWdodCkpOworICAgICAgICAgICAgICAg IG1fcGFnZVJlY3RzLmFwcGVuZChJbnRSZWN0KGN1cldpZHRoLCBwcmV2aW91c1lQb3NpdGlvbiwg KGludClwYWdlV2lkdGgsIHlQb3NpdGlvbiAtIHByZXZpb3VzWVBvc2l0aW9uKSk7CiAgICAgICAg IH0gZWxzZQotICAgICAgICAgICAgbV9wYWdlUmVjdHMuYXBwZW5kKEludFJlY3QoMCwgKGludClw cmludGVkUGFnZXNIZWlnaHQsIChpbnQpcGFnZVdpZHRoLCAoaW50KWN1cnJQYWdlSGVpZ2h0KSk7 Ci0gICAgICAgIHByaW50ZWRQYWdlc0hlaWdodCArPSBjdXJyUGFnZUhlaWdodDsKLSAgICB9IHdo aWxlIChwcmludGVkUGFnZXNIZWlnaHQgPCBkb2NIZWlnaHQpOworICAgICAgICAgICAgbV9wYWdl UmVjdHMuYXBwZW5kKEludFJlY3QoMCwgcHJldmlvdXNZUG9zaXRpb24sIChpbnQpcGFnZVdpZHRo LCB5UG9zaXRpb24gLSBwcmV2aW91c1lQb3NpdGlvbikpOworICAgICAgICBwcmV2aW91c1lQb3Np dGlvbiA9IHlQb3NpdGlvbjsKKyAgICB9CiB9CiAKKwogdm9pZCBQcmludENvbnRleHQ6OmJlZ2lu KGZsb2F0IHdpZHRoKQogewogICAgIEFTU0VSVCghbV9pc1ByaW50aW5nKTsKQEAgLTIwOSw0ICsy MzUsMTk4IEBAIGludCBQcmludENvbnRleHQ6Om51bWJlck9mUGFnZXMoRnJhbWUqIGZyYW1lLCBj b25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMpCiAgICAgcmV0dXJuIHByaW50Q29udGV4 dC5wYWdlQ291bnQoKTsKIH0KIAordm9pZCBQcmludENvbnRleHQ6OnZpc2l0UmVuZGVyQmxvY2tC ZWZvcmUoY29uc3QgUmVuZGVyQmxvY2sqIHJlbmRlckJsb2NrKQoreworICAgIGlmICghbV9hbmNl c3RvckJsb2NrV2l0aFBhZ2VCcmVha0luc2lkZUF2b2lkICYmIHJlbmRlckJsb2NrLT5zdHlsZSgp LT5wYWdlQnJlYWtJbnNpZGUoKSA9PSBQQkFWT0lEKQorICAgICAgICBtX2FuY2VzdG9yQmxvY2tX aXRoUGFnZUJyZWFrSW5zaWRlQXZvaWQgPSByZW5kZXJCbG9jazsKK30KKwordm9pZCBQcmludENv bnRleHQ6OnZpc2l0UmVuZGVyQmxvY2tBZnRlcihjb25zdCBSZW5kZXJCbG9jayogcmVuZGVyQmxv Y2spCit7CisgICAgaWYgKG1fYW5jZXN0b3JCbG9ja1dpdGhQYWdlQnJlYWtJbnNpZGVBdm9pZCA9 PSByZW5kZXJCbG9jaykKKyAgICAgICAgbV9hbmNlc3RvckJsb2NrV2l0aFBhZ2VCcmVha0luc2lk ZUF2b2lkID0gMDsKK30KKwordm9pZCBQcmludENvbnRleHQ6OnZpc2l0Rmlyc3RDaGlsZEJsb2Nr Qm94KGludCB5LCBjb25zdCBSZW5kZXJCb3gqIGZpcnN0Q2hpbGRCb3gpCit7CisgICAgaWYgKGZp cnN0Q2hpbGRCb3gtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQoKSkKKyAgICAgICAgcmV0dXJuOwor ICAgIC8vIFRPRE86IENoZWNrIHdoZXRoZXIgdGhlcmUgaXMgYSBnYXAgYmV0d2VlbiBwYXJlbnQg YW5kIGNoaWxkLgorICAgIFBhZ2VCcmVhayBwYWdlQnJlYWs7CisgICAgcGFnZUJyZWFrLnBhZ2VC cmVha1R5cGUgPSBQYWdlQnJlYWs6OkJldHdlZW5CbG9ja0JveEFuZENoaWxkOworICAgIHBhZ2VC cmVhay5pc0Fsd2F5cyA9IGZpcnN0Q2hpbGRCb3gtPnN0eWxlKCktPnBhZ2VCcmVha0JlZm9yZSgp ID09IFBCQUxXQVlTOworICAgIHBhZ2VCcmVhay50b3AgPSB5ICsgZmlyc3RDaGlsZEJveC0+eSgp OworICAgIHBhZ2VCcmVhay5ib3R0b20gPSBwYWdlQnJlYWsudG9wOworICAgIHBhZ2VCcmVhay5p c0F2b2lkID0gbV9hbmNlc3RvckJsb2NrV2l0aFBhZ2VCcmVha0luc2lkZUF2b2lkCisgICAgICAg ICAgICB8fCBmaXJzdENoaWxkQm94LT5zdHlsZSgpLT5wYWdlQnJlYWtCZWZvcmUoKSA9PSBQQkFW T0lEOworICAgIGFkZFBhZ2VCcmVha0NhbmRpZGF0ZShwYWdlQnJlYWspOworfQorCit2b2lkIFBy aW50Q29udGV4dDo6dmlzaXRMYXN0Q2hpbGRCbG9ja0JveChpbnQgeSwgY29uc3QgUmVuZGVyQm94 KiBsYXN0Q2hpbGRCb3gpCit7CisgICAgaWYgKGxhc3RDaGlsZEJveC0+aXNGbG9hdGluZ09yUG9z aXRpb25lZCgpKQorICAgICAgICByZXR1cm47CisgICAgLy8gVE9ETzogQ2hlY2sgd2hldGhlciB0 aGVyZSBpcyBhIGdhcCBiZXR3ZWVuIHBhcmVudCBhbmQgY2hpbGQuCisgICAgUGFnZUJyZWFrIHBh Z2VCcmVhazsKKyAgICBwYWdlQnJlYWsucGFnZUJyZWFrVHlwZSA9IFBhZ2VCcmVhazo6QmV0d2Vl bkJsb2NrQm94QW5kQ2hpbGQ7CisgICAgcGFnZUJyZWFrLmlzQWx3YXlzID0gbGFzdENoaWxkQm94 LT5zdHlsZSgpLT5wYWdlQnJlYWtBZnRlcigpID09IFBCQUxXQVlTOworICAgIHBhZ2VCcmVhay50 b3AgPSB5ICsgbGFzdENoaWxkQm94LT55KCkgKyBsYXN0Q2hpbGRCb3gtPmhlaWdodCgpOworICAg IHBhZ2VCcmVhay5ib3R0b20gPSBwYWdlQnJlYWsudG9wOworICAgIHBhZ2VCcmVhay5pc0F2b2lk ID0gbV9hbmNlc3RvckJsb2NrV2l0aFBhZ2VCcmVha0luc2lkZUF2b2lkCisgICAgICAgICAgICB8 fCBsYXN0Q2hpbGRCb3gtPnN0eWxlKCktPnBhZ2VCcmVha0FmdGVyKCkgPT0gUEJBVk9JRDsKKyAg ICBhZGRQYWdlQnJlYWtDYW5kaWRhdGUocGFnZUJyZWFrKTsKK30KKworCit2b2lkIFByaW50Q29u dGV4dDo6dmlzaXRCZXR3ZWVuQmxvY2tCb3hlcyhpbnQgeSwgY29uc3QgUmVuZGVyQm94KiBwcmVj ZWRpbmdCb3gsIGNvbnN0IFJlbmRlckJveCogZm9sbG93aW5nQm94KQoreworICAgIGlmIChwcmVj ZWRpbmdCb3gtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQoKSB8fCBmb2xsb3dpbmdCb3gtPmlzRmxv YXRpbmdPclBvc2l0aW9uZWQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIFBhZ2VCcmVhayBwYWdl QnJlYWs7CisgICAgcGFnZUJyZWFrLnBhZ2VCcmVha1R5cGUgPSBQYWdlQnJlYWs6OkJldHdlZW5C bG9ja0JveGVzOworICAgIHBhZ2VCcmVhay50b3AgPSB5ICsgcHJlY2VkaW5nQm94LT55KCkgKyBw cmVjZWRpbmdCb3gtPmhlaWdodCgpOworICAgIHBhZ2VCcmVhay5ib3R0b20gPSB5ICsgZm9sbG93 aW5nQm94LT55KCk7CisgICAgcGFnZUJyZWFrLmlzQWx3YXlzID0gcHJlY2VkaW5nQm94LT5zdHls ZSgpLT5wYWdlQnJlYWtBZnRlcigpID09IFBCQUxXQVlTIHx8IGZvbGxvd2luZ0JveC0+c3R5bGUo KS0+cGFnZUJyZWFrQmVmb3JlKCkgPT0gUEJBTFdBWVM7CisgICAgcGFnZUJyZWFrLmlzQXZvaWQg PSBtX2FuY2VzdG9yQmxvY2tXaXRoUGFnZUJyZWFrSW5zaWRlQXZvaWQgfHwgcHJlY2VkaW5nQm94 LT5zdHlsZSgpLT5wYWdlQnJlYWtBZnRlcigpID09IFBCQVZPSUQgfHwgZm9sbG93aW5nQm94LT5z dHlsZSgpLT5wYWdlQnJlYWtCZWZvcmUoKSA9PSBQQkFWT0lEOworICAgIGFkZFBhZ2VCcmVha0Nh bmRpZGF0ZShwYWdlQnJlYWspOworfQorCit2b2lkIFByaW50Q29udGV4dDo6dmlzaXRCZXR3ZWVu TGluZUJveGVzKGludCB5LCBjb25zdCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcGFyZW50UmVuZGVy Qm94LCBjb25zdCBJbmxpbmVGbG93Qm94KiBwcmVjZWRpbmdJbmxpbmVGbG93Qm94LCAgY29uc3Qg SW5saW5lRmxvd0JveCogZm9sbG93aW5nSW5saW5lRmxvd0JveCwgaW50IGxpbmVzQmVmb3JlLCBp bnQgbGluZXNBZnRlcikKK3sKKyAgICBQYWdlQnJlYWsgcGFnZUJyZWFrOworICAgIHBhZ2VCcmVh ay5wYWdlQnJlYWtUeXBlID0gUGFnZUJyZWFrOjpCZXR3ZWVuTGluZUJveGVzOworICAgIHBhZ2VC cmVhay50b3AgPSB5ICsgcHJlY2VkaW5nSW5saW5lRmxvd0JveC0+cm9vdCgpLT5ib3R0b21WaXNp YmxlT3ZlcmZsb3coKTsKKyAgICBwYWdlQnJlYWsuYm90dG9tID0geSArIGZvbGxvd2luZ0lubGlu ZUZsb3dCb3gtPnJvb3QoKS0+dG9wVmlzaWJsZU92ZXJmbG93KCk7CisgICAgcGFnZUJyZWFrLmlz QXZvaWQgPSBtX2FuY2VzdG9yQmxvY2tXaXRoUGFnZUJyZWFrSW5zaWRlQXZvaWQ7CisgICAgcGFn ZUJyZWFrLmlzVmlvbGV0aW5nT3JwaGFuc09yV2lkb3dzUnVsZSA9IGxpbmVzQmVmb3JlIDwgcGFy ZW50UmVuZGVyQm94LT5zdHlsZSgpLT5vcnBoYW5zKCkgfHwgbGluZXNBZnRlciA8IHBhcmVudFJl bmRlckJveC0+c3R5bGUoKS0+d2lkb3dzKCk7CisgICAgYWRkUGFnZUJyZWFrQ2FuZGlkYXRlKHBh Z2VCcmVhayk7CiB9CisKK3ZvaWQgUHJpbnRDb250ZXh0OjphZGRQYWdlQnJlYWtDYW5kaWRhdGUo Y29uc3QgUGFnZUJyZWFrJiBwYWdlQnJlYWspCit7CisgICAgaWYgKHBhZ2VCcmVhay5ib3R0b20g Pj0gMCAmJiBwYWdlQnJlYWsudG9wIDw9IHBhZ2VCcmVhay5ib3R0b20pCisgICAgICAgIG1fcGFn ZUJyZWFrQ2FuZGlkYXRlcy5hcHBlbmQocGFnZUJyZWFrKTsKK30KKwordm9pZCBQcmludENvbnRl eHQ6OmFkZFBzZXVkb1BhZ2VCcmVhayhpbnQgeSkKK3sKKyAgICBQYWdlQnJlYWsgcGFnZUJyZWFr OworICAgIHBhZ2VCcmVhay5wYWdlQnJlYWtUeXBlID0gUGFnZUJyZWFrOjpQc2V1ZG87CisgICAg cGFnZUJyZWFrLnRvcCA9IHk7CisgICAgcGFnZUJyZWFrLmJvdHRvbSA9IHk7CisgICAgYWRkUGFn ZUJyZWFrQ2FuZGlkYXRlKHBhZ2VCcmVhayk7Cit9CisKK3ZvaWQgUHJpbnRDb250ZXh0OjpmaWxs TGFyZ2VHYXBXaXRoUGFnZUJyZWFrcyhpbnQgcHJpbnRIZWlnaHQpCit7CisgICAgc29ydFBhZ2VC cmVha0NhbmRpZGF0ZXMoKTsKKyAgICBQYWdlQnJlYWtDYW5kaWRhdGVzIGJyaWRnZXM7CisgICAg Y29uc3QgdW5zaWduZWQgaW50IGNhbmRpZGF0ZXNTaXplID0gbV9wYWdlQnJlYWtDYW5kaWRhdGVz LnNpemUoKTsKKyAgICBmb3IgKHVuc2lnbmVkIGludCBjYW5kaWRhdGVJbmRleCA9IDA7IGNhbmRp ZGF0ZUluZGV4ICsgMSA8IGNhbmRpZGF0ZXNTaXplOyArK2NhbmRpZGF0ZUluZGV4KSB7CisgICAg ICAgIGNvbnN0IGludCBnYXBTdGFydCA9IG1fcGFnZUJyZWFrQ2FuZGlkYXRlc1tjYW5kaWRhdGVJ bmRleF0uYm90dG9tOworICAgICAgICBjb25zdCBpbnQgZ2FwRW5kID0gbV9wYWdlQnJlYWtDYW5k aWRhdGVzW2NhbmRpZGF0ZUluZGV4ICsgMV0udG9wOworICAgICAgICBjb25zdCBpbnQgZ2FwID0g Z2FwRW5kIC0gZ2FwU3RhcnQ7CisgICAgICAgIGlmIChnYXAgPD0gcHJpbnRIZWlnaHQpCisgICAg ICAgICAgICBjb250aW51ZTsKKyAgICAgICAgLy8gV2UgZm91bmQgYSAnZ2FwJyB3aG9zZSBoZWln aHQgaXMgbGFyZ2VyIHRoYW4gcHJpbnRIZWlnaHQgYmV0d2VlbiBhbGxvd2VkIHBhZ2UgYnJlYWtz LgorICAgICAgICAvLyBXZSBtdXN0IGZpbGwgdGhlIGFyZWEgd2l0aCBwc2V1ZG8gcGFnZSBicmVh a3MsIGNhbGxlZCAnYnJpZGdlJy4KKyAgICAgICAgZm9yIChpbnQgcHJldmlvdXNJbmRleCA9IGNh bmRpZGF0ZUluZGV4OyBwcmV2aW91c0luZGV4ID49IDA7IC0tcHJldmlvdXNJbmRleCkgeworICAg ICAgICAgICAgaW50IGN1cnJlbnRZID0gbV9wYWdlQnJlYWtDYW5kaWRhdGVzW3ByZXZpb3VzSW5k ZXhdLmJvdHRvbSArIHByaW50SGVpZ2h0OworICAgICAgICAgICAgaWYgKGN1cnJlbnRZIDw9IGdh cFN0YXJ0KQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgd2hpbGUgKGN1cnJl bnRZIDwgZ2FwRW5kKSB7CisgICAgICAgICAgICAgICAgYnJpZGdlcy5hcHBlbmQoY3JlYXRlQnJp ZGdlUGFnZUJyZWFrKGN1cnJlbnRZKSk7CisgICAgICAgICAgICAgICAgY3VycmVudFkgKz0gcHJp bnRIZWlnaHQ7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisgICAgbV9wYWdlQnJl YWtDYW5kaWRhdGVzLmFwcGVuZFJhbmdlKGJyaWRnZXMuYmVnaW4oKSwgYnJpZGdlcy5lbmQoKSk7 CisgICAgc29ydFBhZ2VCcmVha0NhbmRpZGF0ZXMoKTsKK30KKworUGFnZUJyZWFrIFByaW50Q29u dGV4dDo6Y3JlYXRlQnJpZGdlUGFnZUJyZWFrKGludCB5KQoreworICAgIFBhZ2VCcmVhayBwYWdl QnJlYWs7CisgICAgcGFnZUJyZWFrLnBhZ2VCcmVha1R5cGUgPSBQYWdlQnJlYWs6OkJyaWRnZTsK KyAgICBwYWdlQnJlYWsudG9wID0geTsKKyAgICBwYWdlQnJlYWsuYm90dG9tID0geTsKKyAgICBy ZXR1cm4gcGFnZUJyZWFrOworfQorCitzdGF0aWMgYm9vbCBjb21wYXJlUGFnZUJyZWFrKGNvbnN0 IFBhZ2VCcmVhayYgYSwgY29uc3QgUGFnZUJyZWFrJiBiKQoreworICAgIHJldHVybiBhLmJvdHRv bSA8IGIuYm90dG9tIHx8IChhLmJvdHRvbSA9PSBiLmJvdHRvbSAmJiBhLnRvcCA8IGIudG9wKTsK K30KKwordm9pZCBQcmludENvbnRleHQ6OnNvcnRQYWdlQnJlYWtDYW5kaWRhdGVzKCkKK3sKKyAg ICBzdGQ6OnNvcnQobV9wYWdlQnJlYWtDYW5kaWRhdGVzLmJlZ2luKCksIG1fcGFnZUJyZWFrQ2Fu ZGlkYXRlcy5lbmQoKSwgY29tcGFyZVBhZ2VCcmVhayk7Cit9CisKK3ZvaWQgUHJpbnRDb250ZXh0 OjpkZXRlcm1pbmVCZXN0UGFnZUJyZWFrcyhpbnQgcHJpbnRIZWlnaHQsIFZlY3RvcjxpbnQ+KiBi ZXN0UGFnZUJyZWFrUG9zaXRpb24pIGNvbnN0Cit7CisgICAgY29uc3QgdW5zaWduZWQgaW50IGNh bmRpZGF0ZXNTaXplID0gbV9wYWdlQnJlYWtDYW5kaWRhdGVzLnNpemUoKTsKKyAgICBBU1NFUlQo Y2FuZGlkYXRlc1NpemUgPiAwKTsKKyAgICBBU1NFUlQoIW1fcGFnZUJyZWFrQ2FuZGlkYXRlc1sw XS5ib3R0b20pOworICAgIEFTU0VSVChiZXN0UGFnZUJyZWFrUG9zaXRpb24gJiYgYmVzdFBhZ2VC cmVha1Bvc2l0aW9uLT5pc0VtcHR5KCkpOworICAgIFZlY3RvcjxpbnQ+IHNjb3JlKGNhbmRpZGF0 ZXNTaXplLCBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1pbigpKTsKKyAgICBWZWN0b3I8aW50 PiBwYWdlTnVtYmVyKGNhbmRpZGF0ZXNTaXplLCAwKTsKKyAgICBWZWN0b3I8aW50PiBwcmV2aW91 c0luZGV4KGNhbmRpZGF0ZXNTaXplLCAtMSk7CisgICAgc2NvcmVbMF0gPSAwOworCisgICAgZm9y ICh1bnNpZ25lZCBpbnQgY3VycmVudCA9IDE7IGN1cnJlbnQgPCBjYW5kaWRhdGVzU2l6ZTsgKytj dXJyZW50KSB7CisgICAgICAgIGNvbnN0IFBhZ2VCcmVhayYgY3VycmVudFBhZ2VCcmVhayA9IG1f cGFnZUJyZWFrQ2FuZGlkYXRlc1tjdXJyZW50XTsKKyAgICAgICAgaW50IGJlc3RJbmRleCA9IC0x OworICAgICAgICBpbnQgYmVzdFNjb3JlID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptaW4o KTsKKyAgICAgICAgaW50IGJlc3RQYWdlTnVtYmVyID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+ OjptYXgoKTsKKworICAgICAgICBmb3IgKGludCBwcmV2aW91cyA9IGN1cnJlbnQgLSAxOyBwcmV2 aW91cyA+PSAwOyAtLXByZXZpb3VzKSB7CisgICAgICAgICAgICBjb25zdCBQYWdlQnJlYWsmIHBy ZXZpb3VzUGFnZUJyZWFrID0gbV9wYWdlQnJlYWtDYW5kaWRhdGVzW3ByZXZpb3VzXTsKKyAgICAg ICAgICAgIGNvbnN0IGludCBwYWdlSGVpZ2h0ID0gY3VycmVudFBhZ2VCcmVhay50b3AgLSBwcmV2 aW91c1BhZ2VCcmVhay5ib3R0b207CisgICAgICAgICAgICBpZiAocGFnZUhlaWdodCA8IDApCisg ICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBpZiAocGFnZUhlaWdodCA+IHBy aW50SGVpZ2h0KQorICAgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBpZiAoYmVz dFNjb3JlIDwgc2NvcmVbcHJldmlvdXNdIHx8IGJlc3RTY29yZSA9PSBzY29yZVtwcmV2aW91c10g JiYgYmVzdFBhZ2VOdW1iZXIgPiBwYWdlTnVtYmVyW3ByZXZpb3VzXSkgeworICAgICAgICAgICAg ICAgIGJlc3RJbmRleCA9IHByZXZpb3VzOworICAgICAgICAgICAgICAgIGJlc3RTY29yZSA9IHNj b3JlW3ByZXZpb3VzXTsKKyAgICAgICAgICAgICAgICBiZXN0UGFnZU51bWJlciA9IHBhZ2VOdW1i ZXJbcHJldmlvdXNdOworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgQVNTRVJU KGJlc3RJbmRleCAhPSAtMSk7CisgICAgICAgIHBhZ2VOdW1iZXJbY3VycmVudF0gPSBiZXN0UGFn ZU51bWJlciArIDE7CisgICAgICAgIHByZXZpb3VzSW5kZXhbY3VycmVudF0gPSBiZXN0SW5kZXg7 CisgICAgICAgIHNjb3JlW2N1cnJlbnRdID0gYmVzdFNjb3JlICsgZXZhbHVhdGVTY29yZU9mUGFn ZUJyZWFrKGN1cnJlbnRQYWdlQnJlYWspOworICAgIH0KKworICAgIGludCBzZWxlY3RlZFBhZ2VC cmVha0luZGV4ID0gY2FuZGlkYXRlc1NpemUgLSAxOworICAgIGludCBwcmV2aW91c1BhZ2VCcmVh a1Bvc2l0aW9uID0gLTE7CisgICAgd2hpbGUgKHNlbGVjdGVkUGFnZUJyZWFrSW5kZXggPiAwKSB7 CisgICAgICAgIGNvbnN0IGludCBwYWdlQnJlYWtQb3NpdGlvbiA9IG1fcGFnZUJyZWFrQ2FuZGlk YXRlc1tzZWxlY3RlZFBhZ2VCcmVha0luZGV4XS5ib3R0b207CisgICAgICAgIGlmIChwYWdlQnJl YWtQb3NpdGlvbiAhPSBwcmV2aW91c1BhZ2VCcmVha1Bvc2l0aW9uKQorICAgICAgICAgICAgYmVz dFBhZ2VCcmVha1Bvc2l0aW9uLT5hcHBlbmQocGFnZUJyZWFrUG9zaXRpb24pOworICAgICAgICBw cmV2aW91c1BhZ2VCcmVha1Bvc2l0aW9uID0gcGFnZUJyZWFrUG9zaXRpb247CisgICAgICAgIHNl bGVjdGVkUGFnZUJyZWFrSW5kZXggPSBwcmV2aW91c0luZGV4W3NlbGVjdGVkUGFnZUJyZWFrSW5k ZXhdOworICAgIH0KKyAgICBzdGQ6OnJldmVyc2UoYmVzdFBhZ2VCcmVha1Bvc2l0aW9uLT5iZWdp bigpLCBiZXN0UGFnZUJyZWFrUG9zaXRpb24tPmVuZCgpKTsKK30KKworaW50IFByaW50Q29udGV4 dDo6ZXZhbHVhdGVTY29yZU9mUGFnZUJyZWFrKGNvbnN0IFBhZ2VCcmVhayYgcGFnZUJyZWFrKQor eworICAgIGludCBzY29yZSA9IDA7CisgICAgaWYgKHBhZ2VCcmVhay5wYWdlQnJlYWtUeXBlID09 IFBhZ2VCcmVhazo6QnJpZGdlKQorICAgICAgICBzY29yZSAtPSAyOworICAgIGVsc2UgaWYgKHBh Z2VCcmVhay5pc0Fsd2F5cykKKyAgICAgICAgc2NvcmUgKz0gMjsKKyAgICBlbHNlIHsKKyAgICAg ICAgaWYgKHBhZ2VCcmVhay5pc0F2b2lkKQorICAgICAgICAgICAgc2NvcmUgLT0gMjsKKyAgICAg ICAgaWYgKHBhZ2VCcmVhay5pc1Zpb2xldGluZ09ycGhhbnNPcldpZG93c1J1bGUpCisgICAgICAg ICAgICAtLXNjb3JlOworICAgIH0KKyAgICByZXR1cm4gc2NvcmU7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuaCBiL1dl YkNvcmUvcGFnZS9QcmludENvbnRleHQuaAppbmRleCAxODkxMTQ0Zjk0MmQzOWFmN2ExMmQwMDdh NDFkZWYzMGRlNTRkODQwLi4yMjU5ZTgxYzAzMjEwZDYxM2I4YWE5NDQ0MWI1YzRjNTJiMGRmMDU2 IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgKKysrIGIvV2ViQ29yZS9w YWdlL1ByaW50Q29udGV4dC5oCkBAIC0yMSw2ICsyMSw4IEBACiAjaWZuZGVmIFByaW50Q29udGV4 dF9oCiAjZGVmaW5lIFByaW50Q29udGV4dF9oCiAKKyNpbmNsdWRlICJQYWdlQnJlYWsuaCIKKwog I2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzAsNyAr MzIsMTEgQEAgY2xhc3MgRnJhbWU7CiBjbGFzcyBGbG9hdFJlY3Q7CiBjbGFzcyBGbG9hdFNpemU7 CiBjbGFzcyBHcmFwaGljc0NvbnRleHQ7CitjbGFzcyBJbmxpbmVGbG93Qm94OwogY2xhc3MgSW50 UmVjdDsKK2NsYXNzIFJlbmRlckJsb2NrOworY2xhc3MgUmVuZGVyQm94OworY2xhc3MgUmVuZGVy Qm94TW9kZWxPYmplY3Q7CiAKIGNsYXNzIFByaW50Q29udGV4dCB7CiBwdWJsaWM6CkBAIC01Niw2 ICs2MiwxNCBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGludCBwYWdlTnVtYmVyRm9yRWxlbWVudChF bGVtZW50KiwgY29uc3QgRmxvYXRTaXplJiBwYWdlU2l6ZUluUGl4ZWxzKTsKICAgICBzdGF0aWMg aW50IG51bWJlck9mUGFnZXMoRnJhbWUqLCBjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhl bHMpOwogCisgICAgLy8gVXNlZCB0byBjb2xsZWN0IGFsbG93ZWQgcGFnZSBicmVha3MuCisgICAg dm9pZCB2aXNpdEZpcnN0Q2hpbGRCbG9ja0JveChpbnQgeSwgY29uc3QgUmVuZGVyQm94KiBmaXJz dENoaWxkQm94KTsKKyAgICB2b2lkIHZpc2l0TGFzdENoaWxkQmxvY2tCb3goaW50IHksIGNvbnN0 IFJlbmRlckJveCogbGFzdENoaWxkQm94KTsKKyAgICB2b2lkIHZpc2l0UmVuZGVyQmxvY2tCZWZv cmUoY29uc3QgUmVuZGVyQmxvY2sqIHJlbmRlckJsb2NrKTsKKyAgICB2b2lkIHZpc2l0UmVuZGVy QmxvY2tBZnRlcihjb25zdCBSZW5kZXJCbG9jayogcmVuZGVyQmxvY2spOworICAgIHZvaWQgdmlz aXRCZXR3ZWVuQmxvY2tCb3hlcyhpbnQgeSwgY29uc3QgUmVuZGVyQm94KiBwcmVjZWRpbmdCb3gs IGNvbnN0IFJlbmRlckJveCogZm9sbG93aW5nQm94KTsKKyAgICB2b2lkIHZpc2l0QmV0d2Vlbkxp bmVCb3hlcyhpbnQgeSwgY29uc3QgUmVuZGVyQm94TW9kZWxPYmplY3QqIHBhcmVudFJlbmRlckJv eCwgY29uc3QgSW5saW5lRmxvd0JveCogcHJlY2VkaW5nSW5saW5lRmxvd0JveCwgY29uc3QgSW5s aW5lRmxvd0JveCogZm9sbG93aW5nSW5saW5lRmxvd0JveCwgaW50IGxpbmVzQmVmb3JlLCBpbnQg bGluZXNBZnRlcik7CisKIHByb3RlY3RlZDoKICAgICBGcmFtZSogbV9mcmFtZTsKICAgICBWZWN0 b3I8SW50UmVjdD4gbV9wYWdlUmVjdHM7CkBAIC02MywxMCArNzcsMjggQEAgcHJvdGVjdGVkOgog cHJpdmF0ZToKICAgICB2b2lkIGNvbXB1dGVQYWdlUmVjdHNXaXRoUGFnZVNpemVJbnRlcm5hbChj b25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMsIGJvb2wgYWxsb3dIb3Jpem9udGFsTXVs dGlQYWdlcyk7CiAKKyAgICAvLyBVc2VkIHRvIGNvbGxlY3QgcGFnZSBicmVhayBjYW5kaWRhdGVz LgorICAgIHZvaWQgYWRkUGFnZUJyZWFrQ2FuZGlkYXRlKGNvbnN0IFBhZ2VCcmVhayYpOworICAg IHZvaWQgYWRkUHNldWRvUGFnZUJyZWFrKGludCB5KTsKKyAgICB2b2lkIGZpbGxMYXJnZUdhcFdp dGhQYWdlQnJlYWtzKGludCBwcmludEhlaWdodCk7CisgICAgc3RhdGljIFBhZ2VCcmVhayBjcmVh dGVCcmlkZ2VQYWdlQnJlYWsoaW50IHkpOworICAgIHZvaWQgc29ydFBhZ2VCcmVha0NhbmRpZGF0 ZXMoKTsKKworICAgIC8vIFVzZWQgdG8gZGV0ZXJtaW5lIGJlc3QgcGFnZSBicmVha3MuCisgICAg dm9pZCBkZXRlcm1pbmVCZXN0UGFnZUJyZWFrcyhpbnQgcHJpbnRIZWlnaHQsIFZlY3RvcjxpbnQ+ KiBiZXN0UGFnZUJyZWFrUG9zaXRpb24pIGNvbnN0OworICAgIHN0YXRpYyBpbnQgZXZhbHVhdGVT Y29yZU9mUGFnZUJyZWFrKGNvbnN0IFBhZ2VCcmVhayYpOworCiAgICAgLy8gVXNlZCB0byBwcmV2 ZW50IG1pc3VzZXMgb2YgYmVnaW4oKSBhbmQgZW5kKCkgKGUuZy4sIGNhbGwgZW5kIHdpdGhvdXQg YmVnaW4pLgogICAgIGJvb2wgbV9pc1ByaW50aW5nOworCisgICAgLy8gVGhlIGNhbmRpZGF0ZSBv ZiBwYWdlIGJyZWFrcy4KKyAgICB0eXBlZGVmIFZlY3RvcjxQYWdlQnJlYWs+IFBhZ2VCcmVha0Nh bmRpZGF0ZXM7CisgICAgUGFnZUJyZWFrQ2FuZGlkYXRlcyBtX3BhZ2VCcmVha0NhbmRpZGF0ZXM7 CisKKyAgICAvLyBVc2VkIHRvIGtub3cgd2hldGhlciB0aGVyZSBpcyBhIGNvbW1hbiBhbmNlc3Rv ciB3aGljaCBoYXMgJ3BhZ2UtYnJlYWstaW5zaWRlOiBhdm9pZCcgcHJvcGVydHkuCisgICAgY29u c3QgUmVuZGVyQmxvY2sqIG1fYW5jZXN0b3JCbG9ja1dpdGhQYWdlQnJlYWtJbnNpZGVBdm9pZDsK IH07CiAKIH0KIAotI2VuZGlmCisjZW5kaWYgLy8gUHJpbnRDb250ZXh0X2gKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckJsb2NrLmNwcAppbmRleCA2MGNmMGM1YTU2NzEwZTA1NzY0Mzc3MTI5ZDg1YmQ3ODA0NjEz OWQ5Li5mYjZmMzU3ZTAwZjE1NjJhOTRlMzZkZWM2ZWIzMmE0MTAzMzI3NmI3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQmxvY2suY3BwCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCiAjaW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIklubGluZVRleHRCb3gu aCIKKyNpbmNsdWRlICJQcmludENvbnRleHQuaCIKICNpbmNsdWRlICJSZW5kZXJGbGV4aWJsZUJv eC5oIgogI2luY2x1ZGUgIlJlbmRlckltYWdlLmgiCiAjaW5jbHVkZSAiUmVuZGVySW5saW5lLmgi CkBAIC0xNTM1LDExICsxNTM2LDE4IEBAIHZvaWQgUmVuZGVyQmxvY2s6OnBhaW50KFBhaW50SW5m byYgcGFpbnRJbmZvLCBpbnQgdHgsIGludCB0eSkKICAgICAgICAgICAgIHJldHVybjsKICAgICB9 CiAKKyAgICBib29sIHNob3VsZE5vdGlmeVBhZ2VCcmVha0xpc3RuZXIgPSB2aWV3KCktPnByaW50 Q29udGV4dCgpOworICAgIGlmIChzaG91bGROb3RpZnlQYWdlQnJlYWtMaXN0bmVyKQorICAgICAg ICB2aWV3KCktPnByaW50Q29udGV4dCgpLT52aXNpdFJlbmRlckJsb2NrQmVmb3JlKHRoaXMpOwor CiAgICAgYm9vbCBwdXNoZWRDbGlwID0gcHVzaENvbnRlbnRzQ2xpcChwYWludEluZm8sIHR4LCB0 eSk7CiAgICAgcGFpbnRPYmplY3QocGFpbnRJbmZvLCB0eCwgdHkpOwogICAgIGlmIChwdXNoZWRD bGlwKQogICAgICAgICBwb3BDb250ZW50c0NsaXAocGFpbnRJbmZvLCBwaGFzZSwgdHgsIHR5KTsK IAorICAgIGlmIChzaG91bGROb3RpZnlQYWdlQnJlYWtMaXN0bmVyKQorICAgICAgICB2aWV3KCkt PnByaW50Q29udGV4dCgpLT52aXNpdFJlbmRlckJsb2NrQWZ0ZXIodGhpcyk7CisKICAgICAvLyBP dXIgc2Nyb2xsYmFyIHdpZGdldHMgcGFpbnQgZXhhY3RseSB3aGVuIHdlIHRlbGwgdGhlbSB0bywg c28gdGhhdCB0aGV5IHdvcmsgcHJvcGVybHkgd2l0aAogICAgIC8vIHotaW5kZXguICBXZSBwYWlu dCBhZnRlciB3ZSBwYWludGVkIHRoZSBiYWNrZ3JvdW5kL2JvcmRlciwgc28gdGhhdCB0aGUgc2Ny b2xsYmFycyB3aWxsCiAgICAgLy8gc2l0IGFib3ZlIHRoZSBiYWNrZ3JvdW5kL2JvcmRlci4KQEAg LTE2NTksMzYgKzE2NjcsMTggQEAgdm9pZCBSZW5kZXJCbG9jazo6cGFpbnRDaGlsZHJlbihQYWlu dEluZm8mIHBhaW50SW5mbywgaW50IHR4LCBpbnQgdHkpCiAgICAgUGFpbnRJbmZvIGluZm8ocGFp bnRJbmZvKTsKICAgICBpbmZvLnBoYXNlID0gbmV3UGhhc2U7CiAgICAgaW5mby5wYWludGluZ1Jv b3QgPSBwYWludGluZ1Jvb3RGb3JDaGlsZHJlbihwYWludEluZm8pOwotICAgIGJvb2wgaXNQcmlu dGluZyA9IGRvY3VtZW50KCktPnByaW50aW5nKCk7Ci0KLSAgICBmb3IgKFJlbmRlckJveCogY2hp bGQgPSBmaXJzdENoaWxkQm94KCk7IGNoaWxkOyBjaGlsZCA9IGNoaWxkLT5uZXh0U2libGluZ0Jv eCgpKSB7ICAgICAgICAKLSAgICAgICAgLy8gQ2hlY2sgZm9yIHBhZ2UtYnJlYWstYmVmb3JlOiBh bHdheXMsIGFuZCBpZiBpdCdzIHNldCwgYnJlYWsgYW5kIGJhaWwuCi0gICAgICAgIGlmIChpc1By aW50aW5nICYmICFjaGlsZHJlbklubGluZSgpICYmIGNoaWxkLT5zdHlsZSgpLT5wYWdlQnJlYWtC ZWZvcmUoKSA9PSBQQkFMV0FZUwotICAgICAgICAgICAgJiYgKHR5ICsgY2hpbGQtPnkoKSkgPiBw YWludEluZm8ucmVjdC55KCkKLSAgICAgICAgICAgICYmICh0eSArIGNoaWxkLT55KCkpIDwgcGFp bnRJbmZvLnJlY3QuYm90dG9tKCkpIHsKLSAgICAgICAgICAgIHZpZXcoKS0+c2V0QmVzdFRydW5j YXRlZEF0KHR5ICsgY2hpbGQtPnkoKSwgdGhpcywgdHJ1ZSk7Ci0gICAgICAgICAgICByZXR1cm47 Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBDaGVjayBmb3IgcGFnZS1icmVhay1pbnNpZGU6IGF2 b2lkLCBhbmQgaXQgaXQncyBzZXQsIGJyZWFrIGFuZCBiYWlsLgotICAgICAgICBpZiAoaXNQcmlu dGluZyAmJiAhY2hpbGRyZW5JbmxpbmUoKSAmJiBjaGlsZC0+c3R5bGUoKS0+cGFnZUJyZWFrSW5z aWRlKCkgPT0gUEJBVk9JRAotICAgICAgICAgICAgJiYgdHkgKyBjaGlsZC0+eSgpID4gcGFpbnRJ bmZvLnJlY3QueSgpCi0gICAgICAgICAgICAmJiB0eSArIGNoaWxkLT55KCkgPCBwYWludEluZm8u cmVjdC5ib3R0b20oKQotICAgICAgICAgICAgJiYgdHkgKyBjaGlsZC0+eSgpICsgY2hpbGQtPmhl aWdodCgpID4gcGFpbnRJbmZvLnJlY3QuYm90dG9tKCkpIHsKLSAgICAgICAgICAgIHZpZXcoKS0+ c2V0QmVzdFRydW5jYXRlZEF0KHR5ICsgY2hpbGQtPnkoKSwgdGhpcywgdHJ1ZSk7Ci0gICAgICAg ICAgICByZXR1cm47CisgICAgYm9vbCBzaG91bGROb3RpZnlQYWdlQnJlYWtMaXN0bmVyID0gZG9j dW1lbnQoKS0+cHJpbnRpbmcoKSAmJiB2aWV3KCktPnByaW50Q29udGV4dCgpICYmICFjaGlsZHJl bklubGluZSgpICYmIHBhaW50SW5mby5waGFzZSA9PSBQYWludFBoYXNlRm9yZWdyb3VuZDsKKyAg ICBmb3IgKFJlbmRlckJveCogY2hpbGQgPSBmaXJzdENoaWxkQm94KCk7IGNoaWxkOyBjaGlsZCA9 IGNoaWxkLT5uZXh0U2libGluZ0JveCgpKSB7CisgICAgICAgIGlmIChzaG91bGROb3RpZnlQYWdl QnJlYWtMaXN0bmVyKSB7CisgICAgICAgICAgICBpZiAoY2hpbGQgPT0gZmlyc3RDaGlsZEJveCgp KQorICAgICAgICAgICAgICAgIHZpZXcoKS0+cHJpbnRDb250ZXh0KCktPnZpc2l0Rmlyc3RDaGls ZEJsb2NrQm94KHR5LCBjaGlsZCk7CisgICAgICAgICAgICBpZiAoY2hpbGQtPm5leHRTaWJsaW5n Qm94KCkpCisgICAgICAgICAgICAgICAgdmlldygpLT5wcmludENvbnRleHQoKS0+dmlzaXRCZXR3 ZWVuQmxvY2tCb3hlcyh0eSwgY2hpbGQsIGNoaWxkLT5uZXh0U2libGluZ0JveCgpKTsKKyAgICAg ICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB2aWV3KCktPnByaW50Q29udGV4dCgpLT52aXNp dExhc3RDaGlsZEJsb2NrQm94KHR5LCBjaGlsZCk7CiAgICAgICAgIH0KLQogICAgICAgICBpZiAo IWNoaWxkLT5oYXNTZWxmUGFpbnRpbmdMYXllcigpICYmICFjaGlsZC0+aXNGbG9hdGluZygpKQog ICAgICAgICAgICAgY2hpbGQtPnBhaW50KGluZm8sIHR4LCB0eSk7Ci0KLSAgICAgICAgLy8gQ2hl Y2sgZm9yIHBhZ2UtYnJlYWstYWZ0ZXI6IGFsd2F5cywgYW5kIGlmIGl0J3Mgc2V0LCBicmVhayBh bmQgYmFpbC4KLSAgICAgICAgaWYgKGlzUHJpbnRpbmcgJiYgIWNoaWxkcmVuSW5saW5lKCkgJiYg Y2hpbGQtPnN0eWxlKCktPnBhZ2VCcmVha0FmdGVyKCkgPT0gUEJBTFdBWVMKLSAgICAgICAgICAg ICYmICh0eSArIGNoaWxkLT55KCkgKyBjaGlsZC0+aGVpZ2h0KCkpID4gcGFpbnRJbmZvLnJlY3Qu eSgpCi0gICAgICAgICAgICAmJiAodHkgKyBjaGlsZC0+eSgpICsgY2hpbGQtPmhlaWdodCgpKSA8 IHBhaW50SW5mby5yZWN0LmJvdHRvbSgpKSB7Ci0gICAgICAgICAgICB2aWV3KCktPnNldEJlc3RU cnVuY2F0ZWRBdCh0eSArIGNoaWxkLT55KCkgKyBjaGlsZC0+aGVpZ2h0KCkgKyBtYXgoMCwgY2hp bGQtPmNvbGxhcHNlZE1hcmdpbkJvdHRvbSgpKSwgdGhpcywgdHJ1ZSk7Ci0gICAgICAgICAgICBy ZXR1cm47Ci0gICAgICAgIH0KICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckxpbmVCb3hMaXN0LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpbmVC b3hMaXN0LmNwcAppbmRleCAwZDRmNWE4YTZiM2IyYjg0OTRjNGNkZjI3MGFiMTBkNDc2OTczZGI3 Li5mMzQwMDI1MDAwNzMzNzY5MzQzOWQyYzk4YTNhMjEwNzM3YmRmYjVmIDEwMDY0NAotLS0gYS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaW5lQm94TGlzdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyTGluZUJveExpc3QuY3BwCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAi UmVuZGVyTGluZUJveExpc3QuaCIKIAogI2luY2x1ZGUgIklubGluZVRleHRCb3guaCIKKyNpbmNs dWRlICJQcmludENvbnRleHQuaCIKICNpbmNsdWRlICJSZW5kZXJBcmVuYS5oIgogI2luY2x1ZGUg IlJlbmRlcklubGluZS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKQEAgLTE4NCw4ICsxODUs MjIgQEAgdm9pZCBSZW5kZXJMaW5lQm94TGlzdDo6cGFpbnQoUmVuZGVyQm94TW9kZWxPYmplY3Qq IHJlbmRlcmVyLCBSZW5kZXJPYmplY3Q6OlBhaW4KICAgICAvLyBTZWUgaWYgb3VyIHJvb3QgbGlu ZXMgaW50ZXJzZWN0IHdpdGggdGhlIGRpcnR5IHJlY3QuICBJZiBzbywgdGhlbiB3ZSBwYWludAog ICAgIC8vIHRoZW0uICBOb3RlIHRoYXQgYm94ZXMgY2FuIGVhc2lseSBvdmVybGFwLCBzbyB3ZSBj YW4ndCBtYWtlIGFueSBhc3N1bXB0aW9ucwogICAgIC8vIGJhc2VkIG9mZiBwb3NpdGlvbnMgb2Yg b3VyIGZpcnN0IGxpbmUgYm94IG9yIG91ciBsYXN0IGxpbmUgYm94LgorCisgICAgYm9vbCBzaG91 bGROb3RpZnlQYWdlQnJlYWtMaXN0bmVyID0gdXNlUHJpbnRSZWN0ICYmIHYtPnByaW50Q29udGV4 dCgpICYmIHBhaW50SW5mby5waGFzZSA9PSBQYWludFBoYXNlRm9yZWdyb3VuZDsKKyAgICBpbnQg bGluZVRvdGFsID0gMDsKKyAgICBpZiAoc2hvdWxkTm90aWZ5UGFnZUJyZWFrTGlzdG5lcikgewor ICAgICAgICBmb3IgKElubGluZUZsb3dCb3gqIGN1cnIgPSBmaXJzdExpbmVCb3goKTsgY3Vycjsg Y3VyciA9IGN1cnItPm5leHRMaW5lQm94KCkpCisgICAgICAgICAgICArK2xpbmVUb3RhbDsKKyAg ICB9CisgICAgaW50IGxpbmVDb3VudCA9IDA7CiAgICAgZm9yIChJbmxpbmVGbG93Qm94KiBjdXJy ID0gZmlyc3RMaW5lQm94KCk7IGN1cnI7IGN1cnIgPSBjdXJyLT5uZXh0TGluZUJveCgpKSB7Ci0g ICAgICAgIGlmICh1c2VQcmludFJlY3QpIHsKKyAgICAgICAgbGluZUNvdW50Kys7CisgICAgICAg IGlmIChzaG91bGROb3RpZnlQYWdlQnJlYWtMaXN0bmVyICYmIGN1cnItPm5leHRMaW5lQm94KCkp IHsKKyAgICAgICAgICAgIC8vIENvbGxlY3QgYWxsb3dlZCBwYWdlIGJyZWFzayBpbiBwcmludGln LgorICAgICAgICAgICAgdi0+cHJpbnRDb250ZXh0KCktPnZpc2l0QmV0d2VlbkxpbmVCb3hlcyh0 eSwgcmVuZGVyZXIsIGN1cnIsIGN1cnItPm5leHRMaW5lQm94KCksIGxpbmVDb3VudCwgbGluZVRv dGFsIC0gbGluZUNvdW50KTsKKyAgICAgICAgfSBlbHNlIGlmICh1c2VQcmludFJlY3QpIHsKKyAg ICAgICAgICAgIC8vIFdlIGNhbm5vdCByZW1vdmUgdGhpcyBjb2RlIGJlY2F1c2UgbXVsdGkgY29s dW1uIGxheW91dCBzdGlsbCBkZXBlbmRzIG9uIHRoaXMuCisgICAgICAgICAgICAvLwogICAgICAg ICAgICAgLy8gRklYTUU6IFRoaXMgaXMgYSBmZWVibGUgZWZmb3J0IHRvIGF2b2lkIHNwbGl0dGlu ZyBhIGxpbmUgYWNyb3NzIHR3byBwYWdlcy4KICAgICAgICAgICAgIC8vIEl0IGlzIHV0dGVybHkg aW5hZGVxdWF0ZSwgYW5kIHRoaXMgc2hvdWxkIG5vdCBiZSBkb25lIGF0IHBhaW50IHRpbWUgYXQg YWxsLgogICAgICAgICAgICAgLy8gVGhlIHdob2xlIHdheSBvYmplY3RzIGJyZWFrIGFjcm9zcyBw YWdlcyBuZWVkcyB0byBiZSByZWRvbmUuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJWaWV3LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuY3BwCmluZGV4IGEz OWMyMmJhYzBjODQxMmI5YmNhZTgxOGQ2NTUzOWQ1ZDEwNTk0NDkuLmM4ODM1YTU1ODNkMTBjOTQx ZDQ3MTAyZDBiZmYyOTdjOGY4MmM4NmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclZpZXcuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuY3BwCkBAIC01 NSw2ICs1NSw3IEBAIFJlbmRlclZpZXc6OlJlbmRlclZpZXcoTm9kZSogbm9kZSwgRnJhbWVWaWV3 KiB2aWV3KQogICAgICwgbV9mb3JjZWRQYWdlQnJlYWsoZmFsc2UpCiAgICAgLCBtX2xheW91dFN0 YXRlKDApCiAgICAgLCBtX2xheW91dFN0YXRlRGlzYWJsZUNvdW50KDApCisgICAgLCBtX3ByaW50 Q29udGV4dCgwKQogewogICAgIC8vIENsZWFyIG91ciBhbm9ueW1vdXMgYml0LCBzZXQgYmVjYXVz ZSBSZW5kZXJPYmplY3QgYXNzdW1lcwogICAgIC8vIGFueSByZW5kZXJlciB3aXRoIGRvY3VtZW50 IGFzIHRoZSBub2RlIGlzIGFub255bW91cy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlclZpZXcuaCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuaAppbmRleCBjZjJj NWU5OTliYmQ5OWQ5NDk5ZmExOGVlN2M4MjBlZDBmODQ0NzU1Li43ZTNlOGFmY2NlYmU0ZTk0Yzcy ZGJhNmFjMTgwZWZkMjc1ODUzMzIzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJWaWV3LmgKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5oCkBAIC0yOSw2ICsy OSw3IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgUHJpbnRDb250ZXh0OwogY2xh c3MgUmVuZGVyV2lkZ2V0OwogCiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQpAQCAt MTY3LDYgKzE2OCw5IEBAIHB1YmxpYzoKICAgICBib29sIHVzZXNDb21wb3NpdGluZygpIGNvbnN0 OwogI2VuZGlmCiAKKyAgICB2b2lkIHNldFByaW50Q29udGV4dChQcmludENvbnRleHQqIHByaW50 Q29udGV4dCkgeyBtX3ByaW50Q29udGV4dCA9IHByaW50Q29udGV4dDt9CisgICAgUHJpbnRDb250 ZXh0KiBwcmludENvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3ByaW50Q29udGV4dDt9CisKIHBy b3RlY3RlZDoKICAgICB2aXJ0dWFsIHZvaWQgbWFwTG9jYWxUb0NvbnRhaW5lcihSZW5kZXJCb3hN b2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciwgYm9vbCB1c2VUcmFuc2Zvcm1zLCBib29sIGZp eGVkLCBUcmFuc2Zvcm1TdGF0ZSYpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBtYXBBYnNvbHV0 ZVRvTG9jYWxQb2ludChib29sIGZpeGVkLCBib29sIHVzZVRyYW5zZm9ybXMsIFRyYW5zZm9ybVN0 YXRlJikgY29uc3Q7CkBAIC0yMDYsNiArMjEwLDcgQEAgcHJpdmF0ZToKICNpZiBVU0UoQUNDRUxF UkFURURfQ09NUE9TSVRJTkcpCiAgICAgT3duUHRyPFJlbmRlckxheWVyQ29tcG9zaXRvcj4gbV9j b21wb3NpdG9yOwogI2VuZGlmCisgICAgUHJpbnRDb250ZXh0KiBtX3ByaW50Q29udGV4dDsKIH07 CiAKIGlubGluZSBSZW5kZXJWaWV3KiB0b1JlbmRlclZpZXcoUmVuZGVyT2JqZWN0KiBvYmplY3Qp Cg== 94690 2011-05-24 14:34:29 -0700 2011-05-24 14:34:29 -0700 Test case for missing footers. test.html text/html 859 schenney PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFs Ly9FTiIgCiAgImh0dHA6Ly93d3cudzMub3JnL1RSL2h0bWw0L2xvb3NlLmR0ZCI+CjxodG1sPgog ICAgPGhlYWQ+CiAgICAgICAgPHRpdGxlPlRlc3QgUGFnZTwvdGl0bGU+CiAgICAgICAgPHN0eWxl IHR5cGU9InRleHQvY3NzIiAgbWVkaWE9InByaW50Ij4KICAgICAgICAgICAgLmZvb3RlciB7CiAg ICAgICAgICAgICAgICBkaXNwbGF5OiBibG9jazsKICAgICAgICAgICAgICAgIHBvc2l0aW9uOiBm aXhlZDsKICAgICAgICAgICAgICAgIGJvdHRvbTogMDsKICAgICAgICAgICAgICAgIGZvbnQtc2l6 ZTogeHgtc21hbGw7CiAgICAgICAgICAgIH0KICAgICAgICA8L3N0eWxlPgogICAgPC9oZWFkPgog ICAgPGJvZHk+CiAgICAgICAgPERpdj5UaGlzIGlzIHNvbWUgdGV4dCBvbiBwYWdlIDEuLi48L2Rp dj4KICAgICAgICA8ZGl2IGNsYXNzPSJmb290ZXIiPjxzbWFsbD5mb290ZXI8L3NtYWxsPjwvZGl2 PgogICAgICAgIDxwIHN0eWxlPSJwYWdlLWJyZWFrLWJlZm9yZTogYWx3YXlzIj4mbmJzcDs8L3A+ CiAgICAgICAgPERpdj5UaGlzIGlzIHNvbWUgdGV4dCBvbiBwYWdlIDIuLi48L2Rpdj4KICAgICAg ICA8ZGl2IGNsYXNzPSJmb290ZXIiPjxzbWFsbD5mb290ZXI8L3NtYWxsPjwvZGl2PgogICAgICAg IDxwIHN0eWxlPSJwYWdlLWJyZWFrLWJlZm9yZTogYWx3YXlzIj4mbmJzcDs8L3A+CiAgICAgICAg PERpdj5UaGlzIGlzIHNvbWUgdGV4dCBvbiBwYWdlIDMuLi48L2Rpdj4KICAgICAgICA8ZGl2IGNs YXNzPSJmb290ZXIiPjxzbWFsbD5mb290ZXI8L3NtYWxsPjwvZGl2PgogICAgPC9ib2R5Pgo8L2h0 bWw+Cg==