266521 2023-12-15 16:27:28 -0800 AX: Use cached text runs to compute: next, previous, next line end, previous line start, line range, and string-for-range text marker APIs 2024-01-10 12:27:02 -0800 1 1 1 Unclassified WebKit Accessibility Other Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 tyler_w tyler_w aboxhall andresg_22 annulen apinheiro cfleizach dmazzoni ews-watchlist gyuyoung.kim jcraig jhoffman23 ryuan.choi samuel_white sergio webkit-bug-importer oldest_to_newest 2000082 0 tyler_w 2023-12-15 16:27:28 -0800 ... 2000083 1 webkit-bug-importer 2023-12-15 16:27:39 -0800 <rdar://problem/119741911> 2000086 2 469079 tyler_w 2023-12-15 16:34:47 -0800 Created attachment 469079 Patch 2000203 3 469079 cfleizach 2023-12-16 12:38:15 -0800 Comment on attachment 469079 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=469079&action=review > Source/WebCore/accessibility/AXCoreObject.cpp:409 > +AXCoreObject* AXCoreObject::nextSibling() These two methods are mostly the same. Could they be combined > Source/WebCore/accessibility/AXPosition.h:37 > + Line, Character seems like it should be a unit too and then you don't need two methods that finds a positio > Source/WebCore/accessibility/AccessibilityObject.h:34 > +#include "AXTextRun.h" Macros around imports are not necessary since it will just import an empty file 2000206 4 469090 tyler_w 2023-12-16 14:43:38 -0800 Created attachment 469090 Patch 2000207 5 tyler_w 2023-12-16 14:46:47 -0800 (In reply to chris fleizach from comment #3) > Comment on attachment 469079 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=469079&action=review > > > Source/WebCore/accessibility/AXCoreObject.cpp:409 > > +AXCoreObject* AXCoreObject::nextSibling() > > These two methods are mostly the same. Could they be combined Yes, these could probably be refactored to have some shared implementation. Will do on Monday. Your comment also made me realize we already have `nextSibling` and `previousSibling` methods, so adding new ones with the same names is probably not a good idea. I'll address that on Monday too. > > Source/WebCore/accessibility/AXPosition.h:37 > > + Line, > > Character seems like it should be a unit too and then you don't need two > methods that finds a position Good idea, that makes sense to me. Will address on Monday. > > Source/WebCore/accessibility/AccessibilityObject.h:34 > > +#include "AXTextRun.h" > > Macros around imports are not necessary since it will just import an empty > file Good point, fixed. 2000571 6 469119 tyler_w 2023-12-18 15:58:33 -0800 Created attachment 469119 Patch 2000573 7 tyler_w 2023-12-18 16:07:12 -0800 (In reply to Tyler Wilcock from comment #5) > (In reply to chris fleizach from comment #3) > > Comment on attachment 469079 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=469079&action=review > > > > > Source/WebCore/accessibility/AXCoreObject.cpp:409 > > > +AXCoreObject* AXCoreObject::nextSibling() > > > > These two methods are mostly the same. Could they be combined Made this more simple in the latest patch. > > > Source/WebCore/accessibility/AXPosition.h:37 > > > + Line, > > > > Character seems like it should be a unit too and then you don't need two > > methods that finds a position Ended up deciding to keep it the way it is. It seems elegant to have a method that is basically just findPosition(next/previous), matching the actual AX API: next-text-marker and previous-text-marker. The AXTextUnitBoundary (start or end) parameter doesn't make any sense when trying to find the next / previous position, making it awkward to try to shoehorn it into that method. But I don't feel super strongly about it and could be convinced to do it that way too. 2000601 8 469122 tyler_w 2023-12-18 18:38:11 -0800 Created attachment 469122 Patch 2000881 9 469135 tyler_w 2023-12-19 15:55:00 -0800 Created attachment 469135 Patch 2001137 10 469148 tyler_w 2023-12-20 12:14:06 -0800 Created attachment 469148 Patch 2002107 11 469221 tyler_w 2023-12-27 12:16:59 -0800 Created attachment 469221 Patch 2002635 12 469221 jhoffman23 2024-01-02 15:58:42 -0800 Comment on attachment 469221 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=469221&action=review > Source/WebCore/accessibility/AXPosition.cpp:57 > +AXPosition AXPosition::fromTextMarker(const AXTextMarker& marker) It might be nice for this class to have a constructor that takes in an AXTextMarker as well (but definitely not necessary for this patch). > Source/WebCore/accessibility/AXPosition.cpp:164 > + if (textUnit == AXTextUnit::Line) { We should add a FIXME for the other units that are not implemented yet. > Source/WebCore/accessibility/AXPosition.cpp:167 > + const auto* currentRuns = currentObject->textRuns(); This can be null, so I think we need to null check it before using it below? 2002636 13 469221 jhoffman23 2024-01-02 15:58:43 -0800 Comment on attachment 469221 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=469221&action=review > Source/WebCore/accessibility/AXPosition.cpp:57 > +AXPosition AXPosition::fromTextMarker(const AXTextMarker& marker) It might be nice for this class to have a constructor that takes in an AXTextMarker as well (but definitely not necessary for this patch). > Source/WebCore/accessibility/AXPosition.cpp:164 > + if (textUnit == AXTextUnit::Line) { We should add a FIXME for the other units that are not implemented yet. > Source/WebCore/accessibility/AXPosition.cpp:167 > + const auto* currentRuns = currentObject->textRuns(); This can be null, so I think we need to null check it before using it below? 2002669 14 469267 tyler_w 2024-01-02 18:25:39 -0800 Created attachment 469267 Patch 2002692 15 tyler_w 2024-01-02 20:37:50 -0800 > > Source/WebCore/accessibility/AXPosition.cpp:167 > > + const auto* currentRuns = currentObject->textRuns(); > > This can be null, so I think we need to null check it before using it below? Currently, the way this is implemented is that if `isTextLeaf()`, `textRuns()` is guaranteed non-null, and anything else is a bug. So I think this is OK for now, but I imagine this code will continue to evolve and maybe a better design will make this less ambiguous. Addressed your other two comments, thanks! 2002841 16 andresg_22 2024-01-03 12:35:30 -0800 (In reply to Tyler Wilcock from comment #14) > Created attachment 469267 [details] > Patch diff --git a/Source/WebCore/accessibility/AXPosition.cpp b/Source/WebCore/accessibility/AXPosition.cpp new file mode 100644 index 000000000000..3a57bd2a4b31 --- /dev/null +++ b/Source/WebCore/accessibility/AXPosition.cpp @@ -0,0 +1,296 @@ +/* + * Copyright (C) 2023 Apple 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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. + */ + +#include "config.h" +#include "AXPosition.h" + +#if ENABLE(AX_THREAD_TEXT_APIS) + +#include "AXIsolatedObject.h" +#include "AXIsolatedTree.h" +#include "AXObjectCache.h" + +namespace WebCore { + +AXIsolatedObject* AXPosition::object() const +{ + RELEASE_ASSERT(!isMainThread()); + if (m_cachedObject) + return m_cachedObject.get(); + + if (!m_treeID.isValid() || !m_objectID.isValid()) + return nullptr; + + auto tree = std::get<RefPtr<AXIsolatedTree>>(axTreeForID(treeID())); + m_cachedObject = tree ? tree->objectForID(objectID()) : nullptr; + return m_cachedObject.get(); +} + +const AXTextRuns* AXPosition::runs() const +{ + auto* object = this->object(); + return object ? object->textRuns() : nullptr; +} + +String AXPosition::debugDescription() const +{ + auto separator = ", "; + RefPtr object = this->object(); + return makeString( + "treeID ", treeID().loggingString() + , separator, "objectID ", objectID().loggingString() + , separator, "role ", object ? accessibilityRoleToString(object->roleValue()) : String("no object"_s) + , separator, "offset ", m_offset + ); +} + +enum class CheckStart : bool { No, Yes }; +// Finds the next object with text runs in the given direction. +static RefPtr<AXIsolatedObject> findObjectWithRuns(AXIsolatedObject& start, AXDirection direction, CheckStart checkStart = CheckStart::No) +{ + if (checkStart == CheckStart::Yes) { + if (auto* runs = start.textRuns(); runs && runs->size()) + return &start; + } + + RefPtr current = &start; + while (current) { + if (current != &start) { + auto* runs = current->textRuns(); + if (runs && runs->size()) + return current; + } + + // FIXME: aria-owns breaks this traversal, as aria-owns causes the AX tree to be changed, affecting + // our iteration below, but it doesn't actually change text position on the page. So we need to ignore aria-owns + // tree changes here in order to behave correctly. + // We also probably need to do something about text within aria-hidden containers, which affects the AX tree. + + const auto& children = current->children(); + if (children.size()) { + size_t childIndex = direction == AXDirection::Next ? 0 : children.size() - 1; + RELEASE_ASSERT(children[childIndex]); + current = dynamicDowncast<AXIsolatedObject>(children[childIndex].get()); + continue; + } + + // `current` has no children, meaning it's a leaf node (e.g. it's text, which cannot have children). + // Check `current`s siblings. + if (auto* sibling = current->sibling(direction)) { + current = dynamicDowncast<AXIsolatedObject>(sibling); + continue; + } + + // We have no children, and no next/previous sibling. Try our parent's sibling. + if (auto* parent = current->parentObjectUnignored()) { + current = dynamicDowncast<AXIsolatedObject>(parent->sibling(direction)); + continue; + } + + break; + } + return nullptr; +} + +AXPosition AXPosition::findPosition(AXDirection direction) const +{ + if (isNull()) + return nullPosition(); + if (!isTextLeaf()) + return asTextLeafPosition().findPosition(direction); + RELEASE_ASSERT(isTextLeaf()); + + size_t runIndex = runIndexFromOffset(); + auto hasMoreTextInCurrentRun = [&] { + if (direction == AXDirection::Next) + return m_offset < runs()->at(runIndex).text.length(); + return m_offset > 0; + }; + bool hasAnotherRun = runIndex + 1 < runs()->size(); + // The next run should not have empty text, because we're going to return a position containing m_offset + 1, which would be wrong. + RELEASE_ASSERT(direction == AXDirection::Previous || !hasAnotherRun || runs()->runLength(runIndex + 1) > 0); + // Checking for the presence of another run is only relevant for moving AXDirection::Next, as just checking that m_offset > 0 is sufficient for AXDirection::Previous. + if (hasMoreTextInCurrentRun() || (direction == AXDirection::Next && hasAnotherRun)) { + // Return an offset to the next character in the current run. + return AXPosition(m_treeID, m_objectID, direction == AXDirection::Next ? m_offset + 1 : m_offset - 1); AG: Can you use return { ... } syntax? + } + // m_offset pointed to the last character in the given object's runs, so let's traverse to find the next object with runs. + if (RefPtr object = findObjectWithRuns(*this->object(), direction)) + return AXPosition(object->treeID(), object->objectID(), direction == AXDirection::Next ? 0 : object->textRuns()->lastRunLength()); AG: Same here. + + return nullPosition(); +} + +AXPosition AXPosition::findPosition(AXDirection direction, AXTextUnit textUnit, AXTextUnitBoundary boundary) const +{ + if (isNull()) + return nullPosition(); + if (!isTextLeaf()) + return asTextLeafPosition().findPosition(direction, textUnit, boundary); + RELEASE_ASSERT(isTextLeaf()); + + if (textUnit == AXTextUnit::Line) { + size_t runIndex = runIndexFromOffset(); + RefPtr currentObject = object(); + const auto* currentRuns = currentObject->textRuns(); + + auto computeOffset = [&] (size_t runEndOffset, size_t runLength) { + // This works because `runEndOffset` is the offset pointing to the end of the given run, which includes the length of all runs preceding it. So subtracting that from the length of the current run gives us an offset to the start of the current run. + return boundary == AXTextUnitBoundary::End ? runEndOffset : runEndOffset - runLength; + }; + auto linePosition = AXPosition(m_treeID, m_objectID, computeOffset(currentRuns->runLengthSumTo(runIndex), currentRuns->runLength(runIndex))); + auto startLineID = currentRuns->lineID(runIndex); + // We found the start run and associated line, now iterate until we find a line boundary. + while (currentObject) { + RELEASE_ASSERT(currentRuns->size()); + unsigned cumulativeOffset = 0; + for (size_t i = 0; i < currentRuns->size(); i++) { + cumulativeOffset += currentRuns->runLength(i); + if (currentRuns->lineID(i) != startLineID) + return linePosition; + linePosition = AXPosition(currentObject->treeID(), currentObject->objectID(), computeOffset(cumulativeOffset, currentRuns->runLength(i))); + } + currentObject = findObjectWithRuns(*currentObject, direction); + if (currentObject) + currentRuns = currentObject->textRuns(); + } + return linePosition; + } + // FIXME: Implement the other AXTextUnits. + + return nullPosition(); +} + +AXPosition AXPosition::asTextLeafPosition() const +{ + if (isNull() || isTextLeaf()) { + // If something has constructed a leaf position, it should've done so with an in-bounds offset. + RELEASE_ASSERT(isNull() || object()->textRuns()->runLengthSum() >= m_offset); + return *this; + } + + // Find the leaf node our offset points to. For example: + // AXPosition { ID 1: Group, Offset 6 } + // ID 1: Group + // - ID 2: Foo + // - ID 3: Line1 + // Line2 + // Calling asTextLeafPosition() on the original position should yield new position: + // AXPosition { ID 3: StaticText, Offset 3 } + // Because we had to walk over ID 2 which had length 3 text. + size_t precedingOffset = 0; + RefPtr current = findObjectWithRuns(*object(), AXDirection::Next, CheckStart::Yes); + while (current) { + unsigned currentSum = current->textRuns()->runLengthSum(); + if (precedingOffset + currentSum >= m_offset) + break; + precedingOffset += currentSum; + current = findObjectWithRuns(*current, AXDirection::Next); + } + + if (!current) + return nullPosition(); + + RELEASE_ASSERT(m_offset >= precedingOffset); + return AXPosition(current->treeID(), current->objectID(), m_offset - precedingOffset); AG: return { ... } +} + +bool AXPosition::isTextLeaf() const +{ + auto* object = this->object(); + // FIXME: Is it possible for non-leaf nodes to have text runs? If so, we don't handle them correctly. + return !object || (!object->children().size() && object->textRuns()); +} + +size_t AXPosition::runIndexFromOffset() const +{ + auto* runs = this->runs(); + if (!runs) + return notFound; + + size_t index = runs->indexForOffset(m_offset); + // If we couldn't find a corresponding run, that means m_offset pointed out of bounds of our text runs, which + // would only happen if we've constructed an invalid position. + RELEASE_ASSERT(index != notFound); + return index; +} + +AXTextMarkerRange AXPosition::lineRange(LineRangeType type) const +{ + if (isNull()) + return { nullPosition(), nullPosition() }; + + if (type == LineRangeType::Current) + return { findPosition(AXDirection::Previous, AXTextUnit::Line, AXTextUnitBoundary::Start), findPosition(AXDirection::Next, AXTextUnit::Line, AXTextUnitBoundary::End) }; + // The other types aren't implemented yet. AG: FIXME. + RELEASE_ASSERT_NOT_REACHED(); +} + +String AXPosition::substring(unsigned start, unsigned length) const +{ + if (isNull()) + return emptyString(); + if (!isTextLeaf()) + return asTextLeafPosition().substring(start, length); + RELEASE_ASSERT(isTextLeaf()); + return runs()->substring(start, length); +} + +String AXPosition::stringWithEnd(const AXPosition& endPosition) +{ + if (isNull()) + return emptyString(); + if (!isTextLeaf()) + return asTextLeafPosition().stringWithEnd(endPosition); + RELEASE_ASSERT(isTextLeaf()); + auto endLeafPosition = endPosition.asTextLeafPosition(); + + if (object() == endLeafPosition.object()) { + size_t minOffset = std::min(m_offset, endLeafPosition.offset()); + size_t maxOffset = std::max(m_offset, endLeafPosition.offset()); + return substring(minOffset, maxOffset - minOffset); + } + + StringBuilder result; + result.append(substring(m_offset)); + + // FIXME: If we've been given reversed positions, i.e. the end position actually comes before the start position, + // we may want to detect this and try searching AXDirection::Previous? + RefPtr current = object(); + while (current->objectID() != endLeafPosition.objectID()) { + current = findObjectWithRuns(*current, AXDirection::Next); + if (!current) + break; + + const auto* runs = current->textRuns(); + for (unsigned i = 0; i < runs->size(); i++) + result.append(runs->at(i).text); + } + result.append(endLeafPosition.substring(0, endLeafPosition.offset())); + return result.toString(); +} + +} // namespace WebCore +#endif // ENABLE(AX_THREAD_TEXT_APIS) diff --git a/Source/WebCore/accessibility/AXPosition.h b/Source/WebCore/accessibility/AXPosition.h new file mode 100644 index 000000000000..5e5744ceeb6d --- /dev/null +++ b/Source/WebCore/accessibility/AXPosition.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2023 Apple 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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. + */ + +#pragma once + +#if ENABLE(AX_THREAD_TEXT_APIS) +#include "AXIsolatedObject.h" +#include "AXTextMarker.h" + +namespace WebCore { + +enum class AXTextUnit : uint8_t { + Line, + Paragraph, + Sentence, + Word, +}; AG: should we have Character also? +enum class AXTextUnitBoundary : bool { Start, End, }; + +enum class LineRangeType : uint8_t { + Current, + Left, + Right, +}; + +class AXPosition { +public: + explicit AXPosition(AXID treeID, AXID objectID, unsigned offset) + : m_treeID(treeID) + , m_objectID(objectID) + , m_offset(offset) + { } + AXPosition(const AXTextMarker& marker) + : m_treeID(marker.treeID()) + , m_objectID(marker.objectID()) + , m_offset(marker.characterOffset()) + { } + static AXPosition nullPosition() { return AXPosition(AXID(), AXID(), 0); } AG: you can define a default contstructor AXPosition() that creates a null object, and then you can use { } where you need a null position. AG: Can't the compiler handle return { { }, { }, 0}; ? + + operator AXTextMarker() const + { + return { { treeID(), objectID(), nullptr, m_offset } }; + } + String debugDescription() const; + + // Find the next or previous position. + AXPosition findPosition(AXDirection) const; + // Starting from this position, creates a new position for the given direction and text unit type. + AXPosition findPosition(AXDirection, AXTextUnit, AXTextUnitBoundary) const; + AXTextMarkerRange lineRange(LineRangeType) const; + String stringWithEnd(const AXPosition&); AG: what is this method returning? + +private: + AXID treeID() const { return m_treeID; } + AXID objectID() const { return m_objectID; } + unsigned offset() const { return m_offset; } + + AXIsolatedObject* object() const; + const AXTextRuns* runs() const; + String substring(unsigned start, unsigned length = StringImpl::MaxLength) const; AG: not clear what a substring of a position is. To me a substring would be associated with a range, not with a single position. + size_t runIndexFromOffset() const; AG: shouldn't this be textRunIndexForOffset ? or offsetToRunTextIndex ? + bool isNull() const { return !object(); } + + AXPosition asTextLeafPosition() const; AG: maybe it makes more sense to put this method below the following comment that gives more context. + // A "text leaf" position is a leaf node (no children) with non-empty textruns. + bool isTextLeaf() const; + + AXID m_treeID; + AXID m_objectID; + unsigned m_offset { 0 }; + + mutable RefPtr<AXIsolatedObject> m_cachedObject; AG: I wouldn't include the word "cached" in this member name, too many caches already to be any meaningful. AG: no clear why you need to keep a reference to the object when you can always retrieve it from the tree that in turn is accessible from the AXTreeStore as you do in AXPosition::object(). +}; AG: So essentially, this is a subset of an AXTextMarker data plus additional functionality. It would be good to unify AXTextMarker and AXPosition. + +} // namespace WebCore +#endif // ENABLE(AX_THREAD_TEXT_APIS) 2002915 17 469285 tyler_w 2024-01-03 18:20:33 -0800 Created attachment 469285 Patch 2002917 18 tyler_w 2024-01-03 18:45:51 -0800 > +enum class AXTextUnit : uint8_t { > + Line, > + Paragraph, > + Sentence, > + Word, > +}; > > AG: should we have Character also? I did consider this. But it’s awkward because in `findMarker(AXDirection, AXTextUnit, AXTextUnitBoundary)`, the AXTextUnitBoundary boundary wouldn’t make sense for the character text unit. I decided to just create a `findMarker(AXDirection)` method to service this need (presumably just for AXNextTextMarker and AXPreviousTextMarker). But we could just make AXTextUnitBoundary a defaulted parameter, and not use it when handling AXTextUnit::Character. Let me know which you’d prefer, I’m good with keeping as-is or doing the default parameter or some other idea. > AG: So essentially, this is a subset of an AXTextMarker data plus additional > functionality. It would be good to unify AXTextMarker and AXPosition. Yes, you're spot on with that description. I made this a separate class for simplicity — avoid polluting the "old" text marker logic with this new way of doing things. But doing that just makes it complex in different ways, e.g. requiring conversions between the two. I moved all of AXPosition into AXTextMarker in the latest patch. > + String substring(unsigned start, unsigned length = > StringImpl::MaxLength) const; > > AG: not clear what a substring of a position is. To me a substring would be > associated with a range, not with a single position. I added a comment to help clarify this, but let me know if it’s still not a good fit or otherwise doesn’t make sense. Addressed all your other comments. Thanks! 2003608 19 andresg_22 2024-01-08 08:15:38 -0800 (In reply to Tyler Wilcock from comment #17) > Created attachment 469285 [details] > Patch diff --git a/Source/WebCore/accessibility/AXTextMarker.cpp b/Source/WebCore/accessibility/AXTextMarker.cpp index 9ad6abf93aac..89a154687ab9 100644 --- a/Source/WebCore/accessibility/AXTextMarker.cpp +++ b/Source/WebCore/accessibility/AXTextMarker.cpp @@ -194,6 +194,16 @@ std::optional<BoundaryPoint> AXTextMarker::boundaryPoint() const return { { *node, static_cast<unsigned>(offset) } }; } +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) +RefPtr<AXIsolatedObject> AXTextMarker::isolatedObject() const +{ + if (isNull() || isMainThread()) + return nullptr; + auto tree = std::get<RefPtr<AXIsolatedTree>>(axTreeForID(treeID())); + return tree ? tree->objectForID(objectID()) : nullptr; +} +#endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE) AG: I think this can be just something like: return dynamicDowncast<AXIsolatedObject>(object()); AG: We should also add a FIXME (maybe in the header) explaining why we need to differentiate isolated vs. live object in this stage, and that eventually this should be agnostic of the underlying AX object. + RefPtr<AXCoreObject> AXTextMarker::object() const { if (isNull()) @@ -335,7 +345,7 @@ std::optional<AXTextMarkerRange> AXTextMarkerRange::intersectionWith(const AXTex String AXTextMarkerRange::debugDescription() const { - return makeString("start: {", m_start.debugDescription(), "}\nend: {", m_end.debugDescription(), "}"); + return makeString("start: {", m_start.debugDescription(), "}\nend: {", m_end.debugDescription(), "}"); } std::partial_ordering partialOrder(const AXTextMarker& marker1, const AXTextMarker& marker2) @@ -368,4 +378,240 @@ bool AXTextMarkerRange::isConfinedTo(AXID objectID) const && LIKELY(m_start.treeID() == m_end.treeID()); } +#if ENABLE(AX_THREAD_TEXT_APIS) +enum class CheckStart : bool { No, Yes }; +// Finds the next object with text runs in the given direction. +static RefPtr<AXIsolatedObject> findObjectWithRuns(AXIsolatedObject& start, AXDirection direction, CheckStart checkStart = CheckStart::No) +{ + if (checkStart == CheckStart::Yes) { + if (auto* runs = start.textRuns(); runs && runs->size()) + return &start; + } + + RefPtr current = &start; + while (current) { + if (current != &start) { + auto* runs = current->textRuns(); + if (runs && runs->size()) + return current; + } + + // FIXME: aria-owns breaks this traversal, as aria-owns causes the AX tree to be changed, affecting + // our iteration below, but it doesn't actually change text position on the page. So we need to ignore aria-owns + // tree changes here in order to behave correctly. + // We also probably need to do something about text within aria-hidden containers, which affects the AX tree. + + const auto& children = current->children(); + if (children.size()) { + size_t childIndex = direction == AXDirection::Next ? 0 : children.size() - 1; + RELEASE_ASSERT(children[childIndex]); + current = dynamicDowncast<AXIsolatedObject>(children[childIndex].get()); + continue; + } + + // `current` has no children, meaning it's a leaf node (e.g. it's text, which cannot have children). + // Check `current`s siblings. + if (auto* sibling = current->sibling(direction)) { + current = dynamicDowncast<AXIsolatedObject>(sibling); + continue; + } + + // We have no children, and no next/previous sibling. Try our parent's sibling. + if (auto* parent = current->parentObjectUnignored()) { + current = dynamicDowncast<AXIsolatedObject>(parent->sibling(direction)); + continue; + } + + break; + } + return nullptr; +} + +String AXTextMarkerRange::toString() const +{ + RELEASE_ASSERT(!isMainThread()); + + auto start = m_start.asTextLeafMarker(); + if (!start.isValid()) + return emptyString(); + auto end = m_end.asTextLeafMarker(); + if (!end.isValid()) + return emptyString(); + + if (start.isolatedObject() == end.isolatedObject()) { + size_t minOffset = std::min(start.offset(), end.offset()); + size_t maxOffset = std::max(start.offset(), end.offset()); + return start.substring(minOffset, maxOffset - minOffset); + } + + StringBuilder result; + result.append(start.substring(start.offset())); + + // FIXME: If we've been given reversed markers, i.e. the end marker actually comes before the start marker, + // we may want to detect this and try searching AXDirection::Previous? + RefPtr current = start.isolatedObject(); + while (current->objectID() != end.objectID()) { AG: could current ever be null here? + current = findObjectWithRuns(*current, AXDirection::Next); + if (!current) + break; + + const auto* runs = current->textRuns(); + for (unsigned i = 0; i < runs->size(); i++) + result.append(runs->at(i).text); + } + result.append(end.substring(0, end.offset())); + return result.toString(); +} + +const AXTextRuns* AXTextMarker::runs() const +{ + RefPtr object = isolatedObject(); + return object ? object->textRuns() : nullptr; +} + +AXTextMarker AXTextMarker::findMarker(AXDirection direction) const +{ + if (!isValid()) + return { }; + if (!isTextLeaf()) + return asTextLeafMarker().findMarker(direction); + RELEASE_ASSERT(isTextLeaf()); + + size_t runIndex = textRunIndexForOffset(); + auto hasMoreTextInCurrentRun = [&] { + if (direction == AXDirection::Next) + return offset() < runs()->at(runIndex).text.length(); + return offset() > 0; + }; + bool hasAnotherRun = runIndex + 1 < runs()->size(); + // The next run should not have empty text, because we're going to return a position containing offset() + 1, which would be wrong. + RELEASE_ASSERT(direction == AXDirection::Previous || !hasAnotherRun || runs()->runLength(runIndex + 1) > 0); + // Checking for the presence of another run is only relevant for moving AXDirection::Next, as just checking that offset() > 0 is sufficient for AXDirection::Previous. + if (hasMoreTextInCurrentRun() || (direction == AXDirection::Next && hasAnotherRun)) { + // Return an offset to the next character in the current run. + return { treeID(), objectID(), direction == AXDirection::Next ? offset() + 1 : offset() - 1 }; + } + // offset() pointed to the last character in the given object's runs, so let's traverse to find the next object with runs. + if (RefPtr object = findObjectWithRuns(*this->isolatedObject(), direction)) + return { object->treeID(), object->objectID(), direction == AXDirection::Next ? 0 : object->textRuns()->lastRunLength() }; + + return { }; +} + +AXTextMarker AXTextMarker::findMarker(AXDirection direction, AXTextUnit textUnit, AXTextUnitBoundary boundary) const +{ + if (!isValid()) + return { }; + if (!isTextLeaf()) + return asTextLeafMarker().findMarker(direction, textUnit, boundary); + RELEASE_ASSERT(isTextLeaf()); + + if (textUnit == AXTextUnit::Line) { + size_t runIndex = textRunIndexForOffset(); + RefPtr currentObject = isolatedObject(); + const auto* currentRuns = currentObject->textRuns(); + + auto computeOffset = [&] (size_t runEndOffset, size_t runLength) { + // This works because `runEndOffset` is the offset pointing to the end of the given run, which includes the length of all runs preceding it. So subtracting that from the length of the current run gives us an offset to the start of the current run. + return boundary == AXTextUnitBoundary::End ? runEndOffset : runEndOffset - runLength; + }; + auto linePosition = AXTextMarker(treeID(), objectID(), computeOffset(currentRuns->runLengthSumTo(runIndex), currentRuns->runLength(runIndex))); + auto startLineID = currentRuns->lineID(runIndex); + // We found the start run and associated line, now iterate until we find a line boundary. + while (currentObject) { + RELEASE_ASSERT(currentRuns->size()); + unsigned cumulativeOffset = 0; + for (size_t i = 0; i < currentRuns->size(); i++) { + cumulativeOffset += currentRuns->runLength(i); + if (currentRuns->lineID(i) != startLineID) + return linePosition; + linePosition = AXTextMarker(currentObject->treeID(), currentObject->objectID(), computeOffset(cumulativeOffset, currentRuns->runLength(i))); + } + currentObject = findObjectWithRuns(*currentObject, direction); + if (currentObject) + currentRuns = currentObject->textRuns(); + } + return linePosition; + } + // FIXME: Implement the other AXTextUnits. + + return { }; +} + +AXTextMarker AXTextMarker::asTextLeafMarker() const +{ + if (!isValid() || isTextLeaf()) { + // If something has constructed a leaf marker, it should've done so with an in-bounds offset. + RELEASE_ASSERT(!isValid() || isolatedObject()->textRuns()->runLengthSum() >= offset()); + return *this; + } + + // Find the leaf node our offset points to. For example: + // AXTextMarker { ID 1: Group, Offset 6 } + // ID 1: Group + // - ID 2: Foo + // - ID 3: Line1 + // Line2 + // Calling asTextLeafMarker() on the original marker should yield new marker: + // AXTextMarker { ID 3: StaticText, Offset 3 } + // Because we had to walk over ID 2 which had length 3 text. + size_t precedingOffset = 0; + RefPtr current = findObjectWithRuns(*isolatedObject(), AXDirection::Next, CheckStart::Yes); + while (current) { + unsigned currentSum = current->textRuns()->runLengthSum(); + if (precedingOffset + currentSum >= offset()) + break; + precedingOffset += currentSum; + current = findObjectWithRuns(*current, AXDirection::Next); + } + + if (!current) + return { }; + + RELEASE_ASSERT(offset() >= precedingOffset); + return { current->treeID(), current->objectID(), static_cast<unsigned>(offset() - precedingOffset) }; +} + +bool AXTextMarker::isTextLeaf() const +{ + RefPtr object = this->isolatedObject(); + // FIXME: Is it possible for non-leaf nodes to have text runs? If so, we don't handle them correctly. + return !object || (!object->children().size() && object->textRuns()); +} + +size_t AXTextMarker::textRunIndexForOffset() const +{ + auto* runs = this->runs(); + if (!runs) + return notFound; + + size_t index = runs->indexForOffset(offset()); + // If we couldn't find a corresponding run, that means offset() pointed out of bounds of our text runs, which + // would only happen if we've constructed an invalid marker. + RELEASE_ASSERT(index != notFound); + return index; +} + +AXTextMarkerRange AXTextMarker::lineRange(LineRangeType type) const +{ + if (!isValid()) + return { { }, { } }; + + if (type == LineRangeType::Current) + return { findMarker(AXDirection::Previous, AXTextUnit::Line, AXTextUnitBoundary::Start), findMarker(AXDirection::Next, AXTextUnit::Line, AXTextUnitBoundary::End) }; + // FIXME: The other types aren't implemented yet. + RELEASE_ASSERT_NOT_REACHED(); +} + +String AXTextMarker::substring(unsigned start, unsigned length) const +{ + if (!isValid()) + return emptyString(); + if (!isTextLeaf()) + return asTextLeafMarker().substring(start, length); + RELEASE_ASSERT(isTextLeaf()); + return runs()->substring(start, length); +} +#endif // ENABLE(AX_THREAD_TEXT_APIS) + } // namespace WebCore diff --git a/Source/WebCore/accessibility/AXTextMarker.h b/Source/WebCore/accessibility/AXTextMarker.h index 17e9fc0dab98..524376f5bef5 100644 --- a/Source/WebCore/accessibility/AXTextMarker.h +++ b/Source/WebCore/accessibility/AXTextMarker.h @@ -28,7 +28,25 @@ namespace WebCore { +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) +class AXIsolatedObject; +#endif struct CharacterOffset; +struct AXTextRuns; + +enum class AXTextUnit : uint8_t { + Line, + Paragraph, + Sentence, + Word, +}; +enum class AXTextUnitBoundary : bool { Start, End, }; + +enum class LineRangeType : uint8_t { + Current, + Left, + Right, +}; struct TextMarkerData { unsigned treeID; @@ -109,6 +127,9 @@ public: #if PLATFORM(COCOA) AXTextMarker(PlatformTextMarkerData); #endif + AXTextMarker(AXID treeID, AXID objectID, unsigned offset) + : m_data({ treeID, objectID, nullptr, offset }) + { } AXTextMarker() = default; operator bool() const { return !isNull(); } @@ -123,7 +144,11 @@ public: AXID treeID() const { return m_data.axTreeID(); } AXID objectID() const { return m_data.axObjectID(); } + unsigned offset() const { return m_data.offset; } bool isNull() const { return !treeID().isValid() || !objectID().isValid(); } +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) + RefPtr<AXIsolatedObject> isolatedObject() const; +#endif RefPtr<AXCoreObject> object() const; bool isValid() const { return object(); } @@ -134,7 +159,28 @@ public: // Sets m_data.node when the marker was created with a PlatformTextMarkerData that lacks the node pointer because it was created off the main thread. void setNodeIfNeeded() const; + +#if ENABLE(AX_THREAD_TEXT_APIS) + // Find the next or previous marker. + AXTextMarker findMarker(AXDirection) const; + // Starting from this text marker, creates a new position for the given direction and text unit type. + AXTextMarker findMarker(AXDirection, AXTextUnit, AXTextUnitBoundary) const; + // Creates a range for the line this marker points to. + AXTextMarkerRange lineRange(LineRangeType) const; +#endif // ENABLE(AX_THREAD_TEXT_APIS) + private: +#if ENABLE(AX_THREAD_TEXT_APIS) + const AXTextRuns* runs() const; + // Substring into the text runs of the object associated with this text marker (if it has any). + String substring(unsigned start, unsigned length = StringImpl::MaxLength) const; + size_t textRunIndexForOffset() const; AG: these last two private methods seems to me belong to AXTextRuns, not to this class. + + // A "text leaf" marker is a leaf node (no children) with non-empty text runs. + bool isTextLeaf() const; + AXTextMarker asTextLeafMarker() const; AG: shouldn't this be called isInTextLeaf and toTextLeafMarker ? The first one because the marker is in a leaf object, not that the marker is a leaf itself. And the second one to better indicate that is a transformation from one marker to another marker. +#endif // ENABLE(AX_THREAD_TEXT_APIS) + TextMarkerData m_data; }; @@ -171,6 +217,11 @@ public: AXTextMarker end() const { return m_end; } bool isConfinedTo(AXID) const; +#if ENABLE(AX_THREAD_TEXT_APIS) + // Traverses from m_start to m_end, collecting all text along the way. + String toString() const; +#endif + String debugDescription() const; private: AXTextMarker m_start; 2003639 20 469341 tyler_w 2024-01-08 10:39:48 -0800 Created attachment 469341 Patch 2003640 21 tyler_w 2024-01-08 10:40:22 -0800 (In reply to Andres Gonzalez from comment #19) All comments addressed, thanks! 2003844 22 andresg_22 2024-01-09 09:26:45 -0800 (In reply to Tyler Wilcock from comment #20) > Created attachment 469341 [details] > Patch diff --git a/Source/WebCore/accessibility/AXTextRun.cpp b/Source/WebCore/accessibility/AXTextRun.cpp new file mode 100644 index 000000000000..504fa2472aa6 --- /dev/null +++ b/Source/WebCore/accessibility/AXTextRun.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2023 Apple 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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. + */ + +#include "config.h" +#include "AXTextRun.h" + +#if ENABLE(AX_THREAD_TEXT_APIS) +namespace WebCore { + +String AXTextRuns::debugDescription() const +{ + StringBuilder result; + result.append('['); + for (unsigned i = 0; i < runs.size(); i++) { + result.append(runs[i].debugDescription(containingBlock)); + if (i != runs.size() - 1) + result.append(", "); + } + result.append(']'); + return result.toString(); +} + +size_t AXTextRuns::indexForOffset(unsigned textOffset) const +{ + size_t cumulativeLength = 0; + for (size_t i = 0; i < runs.size(); i++) { + cumulativeLength += runLength(i); + if (cumulativeLength >= textOffset) + return i; + } + return notFound; +} + +unsigned AXTextRuns::runLengthSumTo(size_t index) const +{ + unsigned length = 0; + for (size_t i = 0; i <= index && i < runs.size(); i++) + length += runLength(i); + return length; +} + +String AXTextRuns::substring(unsigned start, unsigned length) const +{ + if (!length) + return emptyString(); + + StringBuilder result; + size_t charactersSeen = 0; + auto remaining = [&] () { + return result.length() >= length ? 0 : length - result.length(); + }; + for (unsigned i = 0; i < runs.size() && result.length() < length; i++) { + size_t runLength = this->runLength(i); + if (charactersSeen >= start) { + // The start points entirely within bounds of this run. + result.append(runs[i].text.left(remaining())); + } else if (charactersSeen + runLength > start) { + // start points somewhere in the middle of the current run, collect part of the text. + unsigned startInRun = start - charactersSeen; + RELEASE_ASSERT(startInRun < runLength); + result.append(runs[i].text.substring(startInRun, remaining())); + } + // If charactersSeen + runLength == start, the start points to the end of the run, and there is no text to gather. + + charactersSeen += runLength; + } + return result.toString(); +} + +} // namespace WebCore +#endif // ENABLE(AX_THREAD_TEXT_APIS) diff --git a/Source/WebCore/accessibility/AXTextRun.h b/Source/WebCore/accessibility/AXTextRun.h new file mode 100644 index 000000000000..a099f311f56d --- /dev/null +++ b/Source/WebCore/accessibility/AXTextRun.h @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2023 Apple 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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. + */ + +#pragma once + +#if ENABLE(AX_THREAD_TEXT_APIS) +namespace WebCore { + +class RenderBlock; + +struct AXTextRunLineID { + void* containingBlock { nullptr }; + size_t lineIndex { 0 }; + + AXTextRunLineID(void* containingBlock, size_t lineIndex) + : containingBlock(containingBlock) + , lineIndex(lineIndex) + { } + bool operator==(const AXTextRunLineID&) const = default; + String debugDescription() const + { + TextStream stream; + stream << "LineID " << containingBlock << " " << lineIndex; + return stream.release(); + } +}; + +struct AXTextRun { + // The line index of this run within the context of the containing RenderBlock of the main-thread AX object. + size_t lineIndex; + String text; + + AXTextRun(size_t lineIndex, String&& text) + : lineIndex(lineIndex) + , text(WTFMove(text)) + { } + + String debugDescription(void* containingBlock) const + { + AXTextRunLineID lineID = { containingBlock, lineIndex }; + return makeString(lineID.debugDescription(), ": |", makeStringByReplacingAll(text, '\n', "{newline}"_s), "|(len ", text.length(), ")"); + } +}; + +struct AXTextRuns { + // The containing block for the text runs. This is required because based on the structure + // of the AX tree, text runs for different objects can have the same line index but different + // containing blocks, meaning they are rendered on different lines. + // Do not de-reference. Use for comparison purposes only. + void* containingBlock { nullptr }; + Vector<AXTextRun> runs; + + AXTextRuns() = default; + AXTextRuns(RenderBlock* containingBlock, Vector<AXTextRun>&& runs) + : containingBlock(containingBlock) + , runs(WTFMove(runs)) + { } + String debugDescription() const; + + size_t size() const { return runs.size(); } + const AXTextRun& at(size_t index) const + { + return (*this)[index]; + } + const AXTextRun& operator[](size_t index) const + { + RELEASE_ASSERT(index < runs.size()); + return runs[index]; + } + + unsigned runLength(size_t index) const + { + RELEASE_ASSERT(index < runs.size()); + return runs[index].text.length(); + } + unsigned lastRunLength() const + { + if (runs.isEmpty()) + return 0; + return runs[runs.size() - 1].text.length(); + } + unsigned runLengthSum() const AG: maybe totalLength ? or just length ? + { + return runLengthSumTo(runs.size() - 1); + } + unsigned runLengthSumTo(size_t index) const; + + size_t indexForOffset(unsigned textOffset) const; + AXTextRunLineID lineID(size_t index) const + { + RELEASE_ASSERT(index < runs.size()); + return { containingBlock, runs[index].lineIndex }; + } + String substring(unsigned start, unsigned length = StringImpl::MaxLength) const; +}; + +} // namespace WebCore +#endif // ENABLE(AX_THREAD_TEXT_APIS) diff --git a/Source/WebCore/accessibility/AccessibilityObject.cpp b/Source/WebCore/accessibility/AccessibilityObject.cpp index 29a931c5aa14..f339b3ab0081 100644 --- a/Source/WebCore/accessibility/AccessibilityObject.cpp +++ b/Source/WebCore/accessibility/AccessibilityObject.cpp @@ -113,6 +113,12 @@ void AccessibilityObject::init() m_role = determineAccessibilityRole(); } +AXID AccessibilityObject::treeID() const +{ + auto* cache = axObjectCache(); + return cache ? cache->treeID() : AXID(); +} + inline ProcessID AccessibilityObject::processID() const { return presentingApplicationPID(); diff --git a/Source/WebCore/accessibility/AccessibilityObject.h b/Source/WebCore/accessibility/AccessibilityObject.h index e64b6306c08e..c7f28d5c3b55 100644 --- a/Source/WebCore/accessibility/AccessibilityObject.h +++ b/Source/WebCore/accessibility/AccessibilityObject.h @@ -30,6 +30,7 @@ #pragma once #include "AXCoreObject.h" +#include "AXTextRun.h" #include "CharacterRange.h" #include "FloatQuad.h" #include "LayoutRect.h" @@ -63,6 +64,7 @@ class AccessibilityObject : public AXCoreObject, public CanMakeWeakPtr<Accessibi public: virtual ~AccessibilityObject(); + AXID treeID() const final; ProcessID processID() const override; String dbg() const final; @@ -382,6 +384,9 @@ public: String textUnderElement(AccessibilityTextUnderElementMode = AccessibilityTextUnderElementMode()) const override { return { }; } String text() const override { return { }; } unsigned textLength() const final; +#if ENABLE(AX_THREAD_TEXT_APIS) + virtual AXTextRuns textRuns() { return { }; } +#endif #if PLATFORM(COCOA) // Returns an array of strings and AXObject wrappers corresponding to the // textruns and replacement nodes included in the given range. diff --git a/Source/WebCore/accessibility/AccessibilityRenderObject.cpp b/Source/WebCore/accessibility/AccessibilityRenderObject.cpp index 39469e690600..f738e89b42aa 100644 --- a/Source/WebCore/accessibility/AccessibilityRenderObject.cpp +++ b/Source/WebCore/accessibility/AccessibilityRenderObject.cpp @@ -1403,11 +1403,11 @@ CharacterRange AccessibilityRenderObject::selectedTextRange() const } #if ENABLE(AX_THREAD_TEXT_APIS) -Vector<AXTextRun> AccessibilityRenderObject::textRuns() +AXTextRuns AccessibilityRenderObject::textRuns() { if (auto* renderLineBreak = dynamicDowncast<RenderLineBreak>(renderer())) { auto box = InlineIterator::boxFor(*renderLineBreak); - return { { box->lineIndex(), makeString('\n') } }; + return { renderLineBreak->containingBlock(), { AXTextRun(box->lineIndex(), makeString('\n').isolatedCopy()) } }; AG: shouldn't have to make an isolatedCopy here since this is a main thread object. } WeakPtr renderText = dynamicDowncast<RenderText>(renderer()); @@ -1460,7 +1460,7 @@ Vector<AXTextRun> AccessibilityRenderObject::textRuns() if (!lineString.isEmpty()) runs.append({ currentLineIndex, lineString.toString().isolatedCopy() }); - return runs; + return { renderText->containingBlock(), WTFMove(runs) }; } #endif // ENABLE(AX_THREAD_TEXT_APIS) diff --git a/Source/WebCore/accessibility/AccessibilityRenderObject.h b/Source/WebCore/accessibility/AccessibilityRenderObject.h index ceec6bf3e898..be9ee4f86046 100644 --- a/Source/WebCore/accessibility/AccessibilityRenderObject.h +++ b/Source/WebCore/accessibility/AccessibilityRenderObject.h @@ -100,7 +100,7 @@ public: String textUnderElement(AccessibilityTextUnderElementMode = AccessibilityTextUnderElementMode()) const override; String selectedText() const override; #if ENABLE(AX_THREAD_TEXT_APIS) - Vector<AXTextRun> textRuns() final; + AXTextRuns textRuns() final; #endif bool isWidget() const override; diff --git a/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.cpp b/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.cpp index 62a1a575ae61..345f2d53df58 100644 --- a/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.cpp +++ b/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.cpp @@ -31,6 +31,7 @@ #include "AXGeometryManager.h" #include "AXIsolatedTree.h" #include "AXLogger.h" +#include "AXTextRun.h" #if PLATFORM(MAC) #import <pal/spi/mac/HIServicesSPI.h> @@ -464,6 +465,9 @@ void AXIsolatedObject::setProperty(AXPropertyName propertyName, AXPropertyValueV [](std::pair<AXID, CharacterRange>& typedValue) { return !typedValue.first.isValid() && !typedValue.second.location && !typedValue.second.length; }, +#if ENABLE(AX_THREAD_TEXT_APIS) + [](AXTextRuns runs) { return !runs.size(); }, AG: shouldn't the param be AXTextRuns& ? +#endif [](auto&) { ASSERT_NOT_REACHED(); return false; @@ -557,6 +561,19 @@ void AXIsolatedObject::setSelectedChildren(const AccessibilityChildrenVector& se }); } +AXCoreObject* AXIsolatedObject::sibling(AXDirection direction) const +{ + RefPtr parent = parentObjectUnignored(); + const auto& siblings = parent->children(); + size_t indexOfThis = siblings.find(this); + if (indexOfThis == notFound) + return nullptr; + + if (direction == AXDirection::Next) + return indexOfThis + 1 < siblings.size() ? siblings[indexOfThis + 1].get() : nullptr; + return indexOfThis > 0 ? siblings[indexOfThis - 1].get() : nullptr; +} + bool AXIsolatedObject::isDetachedFromParent() { if (parent().isValid()) @@ -971,6 +988,19 @@ int AXIsolatedObject::intAttributeValue(AXPropertyName propertyName) const ); } +#if ENABLE(AX_THREAD_TEXT_APIS) +const AXTextRuns* AXIsolatedObject::textRuns() const +{ + auto entry = m_propertyMap.find(AXPropertyName::TextRuns); + if (entry == m_propertyMap.end()) + return nullptr; + return WTF::switchOn(entry->value, + [] (const AXTextRuns& typedValue) -> const AXTextRuns* { return &typedValue; }, + [] (auto&) -> const AXTextRuns* { return nullptr; } + ); +} +#endif + template<typename T> T AXIsolatedObject::getOrRetrievePropertyValue(AXPropertyName propertyName) { 2003928 23 469352 tyler_w 2024-01-09 14:15:27 -0800 Created attachment 469352 Patch 2003932 24 tyler_w 2024-01-09 14:27:03 -0800 (In reply to Andres Gonzalez from comment #22) > + unsigned lastRunLength() const > + { > + if (runs.isEmpty()) > + return 0; > + return runs[runs.size() - 1].text.length(); > + } > + unsigned runLengthSum() const > AG: maybe totalLength ? or just length ? TW: Fixed, went with totalLength. > +AXTextRuns AccessibilityRenderObject::textRuns() > { > if (auto* renderLineBreak = dynamicDowncast<RenderLineBreak>(renderer())) { > auto box = InlineIterator::boxFor(*renderLineBreak); > - return { { box->lineIndex(), makeString('\n') } }; > + return { renderLineBreak->containingBlock(), { AXTextRun(box->lineIndex(), makeString('\n').isolatedCopy()) } }; > AG: shouldn't have to make an isolatedCopy here since this is a main thread object. TW: Right now, every string in this method does an isolatedCopy(), since the only consumer is for caching these runs in the secondary thread. I have a FIXME lower in this method to make this behavior configurable via parameter to the method, or we could simply not do an isolatedCopy() here and change AXIsolatedObject::initializeProperties to loop over textRuns() and perform the isolatedCopy() at that point. But I think that's an extra walk over every string, and an extra copy of every string? So I elected to do it this way. I envision this might be something we re-evaluate when we introduce our AXTextManager at some point in the future. But if you have a preference to do something for this now, happy to discuss. > @@ -464,6 +465,9 @@ void AXIsolatedObject::setProperty(AXPropertyName propertyName, AXPropertyValueV > [](std::pair<AXID, CharacterRange>& typedValue) { > return !typedValue.first.isValid() && !typedValue.second.location && !typedValue.second.length; > }, > +#if ENABLE(AX_THREAD_TEXT_APIS) > + [](AXTextRuns runs) { return !runs.size(); }, > AG: shouldn't the param be AXTextRuns& ? TW: Great catch! Fixed. 2004121 25 andresg_22 2024-01-10 08:47:59 -0800 (In reply to Tyler Wilcock from comment #23) > Created attachment 469352 [details] > Patch diff --git a/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp b/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp index f6f0622abe93..0e7539e3a8c0 100644 --- a/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp +++ b/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp @@ -30,6 +30,7 @@ #include "AXIsolatedObject.h" #include "AXLogger.h" +#include "AccessibilityTableRow.h" AG: why this include ? #include "FrameSelection.h" #include "LocalFrameView.h" #include "Page.h" @@ -230,22 +231,6 @@ RefPtr<AXIsolatedObject> AXIsolatedTree::objectForID(const AXID axID) const return axID.isValid() ? m_readerThreadNodeMap.get(axID) : nullptr; } -template<typename U> -Vector<RefPtr<AXCoreObject>> AXIsolatedTree::objectsForIDs(const U& axIDs) const -{ - AXTRACE("AXIsolatedTree::objectsForIDs"_s); - ASSERT(!isMainThread()); - - Vector<RefPtr<AXCoreObject>> result; - result.reserveInitialCapacity(axIDs.size()); - for (auto& axID : axIDs) { - if (RefPtr object = objectForID(axID)) - result.append(WTFMove(object)); - } - result.shrinkToFit(); - return result; -} - void AXIsolatedTree::generateSubtree(AccessibilityObject& axObject) { AXTRACE("AXIsolatedTree::generateSubtree"_s); diff --git a/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.h b/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.h index 59f19fa788f5..7e8f6178159b 100644 --- a/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.h +++ b/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.h @@ -29,6 +29,7 @@ #include "AXCoreObject.h" #include "AXTextMarker.h" +#include "AXTextRun.h" #include "AXTreeStore.h" #include "PageIdentifier.h" #include "RenderStyleConstants.h" @@ -47,6 +48,7 @@ class TextStream; namespace WebCore { class AXIsolatedObject; +class AXGeometryManager; class AXObjectCache; class AccessibilityObject; class Page; @@ -255,7 +257,7 @@ using AXPropertyValueVariant = std::variant<std::nullptr_t, AXID, String, bool, , RetainPtr<NSAttributedString> #endif #if ENABLE(AX_THREAD_TEXT_APIS) - , Vector<AXTextRun> + , AXTextRuns #endif >; using AXPropertyMap = HashMap<AXPropertyName, AXPropertyValueVariant, IntHash<AXPropertyName>, WTF::StrongEnumHashTraits<AXPropertyName>>; @@ -322,7 +324,20 @@ public: WEBCORE_EXPORT RefPtr<AXIsolatedObject> focusedNode(); RefPtr<AXIsolatedObject> objectForID(const AXID) const; - template<typename U> Vector<RefPtr<AXCoreObject>> objectsForIDs(const U&) const; + template<typename U> + Vector<RefPtr<AXCoreObject>> objectsForIDs(const U& axIDs) const + { + ASSERT(!isMainThread()); + + Vector<RefPtr<AXCoreObject>> result; + result.reserveInitialCapacity(axIDs.size()); + for (const auto& axID : axIDs) { + if (RefPtr object = objectForID(axID)) + result.append(WTFMove(object)); + } + result.shrinkToFit(); + return result; + } AG: it is better style to have the declaration of the template in the class declaration and the impl down below as an inline if needed. I supposed you had to put it in the header because of cpps being compiled in the different compilation units, right? void generateSubtree(AccessibilityObject&); void labelCreated(AccessibilityObject&); 2004152 26 tyler_w 2024-01-10 11:24:27 -0800 (In reply to Andres Gonzalez from comment #25) > +#include "AccessibilityTableRow.h" > > AG: why this include ? TW: This include always should've been there (we typecast to AccessibilityTableRow in this file), but it was only exposed as a compilation error by adding a new cpp source file, which caused the unified builds to change and expose this bug. > RefPtr<AXIsolatedObject> objectForID(const AXID) const; > - template<typename U> Vector<RefPtr<AXCoreObject>> objectsForIDs(const > U&) const; > + template<typename U> > + Vector<RefPtr<AXCoreObject>> objectsForIDs(const U& axIDs) const > + { > + ASSERT(!isMainThread()); > + > + Vector<RefPtr<AXCoreObject>> result; > + result.reserveInitialCapacity(axIDs.size()); > + for (const auto& axID : axIDs) { > + if (RefPtr object = objectForID(axID)) > + result.append(WTFMove(object)); > + } > + result.shrinkToFit(); > + return result; > + } > > AG: it is better style to have the declaration of the template in the class > declaration and the impl down below as an inline if needed. I supposed you > had to put it in the header because of cpps being compiled in the different > compilation units, right? TW: Yes, exactly right! I was getting compilation errors until inlining the definition here. Spent a good while trying to avoid doing this, but was not successful, and reading online suggested this is the only way to resolve it. 2004167 27 ews-feeder 2024-01-10 12:26:55 -0800 Committed 272858@main (ff85ff126cf1): <https://commits.webkit.org/272858@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 469352. 469079 2023-12-15 16:34:47 -0800 2023-12-18 16:51:45 -0800 Patch bug-266521-20231215163447.patch text/plain 45739 tyler_w RnJvbSAyMDdlZjI5YWNjZTMxOWM4ODkzNGQxMWYwYmVhNTU3NTM2OGJjMDllIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5jcHAgfCAgMzcgKysrCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDIyNyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8IDExNCArKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDExOCArKysrKysrKysKIC4uLi9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwICAgICB8ICAgNiArCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmggICAgICAgfCAgIDcgKwogLi4uL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwICAgICAgICAgICAgIHwgICA2ICstCiAuLi4vYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggfCAgIDIgKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5jcHAgICAgICAgICB8ICAxNyArKwogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0LmggICAgICAgICAgIHwgIDE3ICstCiAuLi4vaXNvbGF0ZWR0cmVlL0FYSXNvbGF0 ZWRUcmVlLmggICAgICAgICAgICAgfCAgIDIgKy0KIDE3IGZpbGVzIGNoYW5nZWQsIDU2MCBpbnNl cnRpb25zKCspLCAyOCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21h a2UKaW5kZXggY2M2YzRhMzFlNmQ1Li4zOTM0NGQwYzgwY2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZQpA QCAtNjUwLDcgKzY1MCw5IEBAIHNldChXZWJDb3JlX1BSSVZBVEVfRlJBTUVXT1JLX0hFQURFUlMK ICAgICBhY2Nlc3NpYmlsaXR5L0FYR2VvbWV0cnlNYW5hZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5 L0FYTG9nZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAorICAgIGFjY2Vz c2liaWxpdHkvQVhQb3NpdGlvbi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAor ICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFN0 YXRlQ2hhbmdlSW50ZW50LmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVHJlZVN0b3JlLmgKICAgICBh Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlMaXN0Qm94LmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL1NvdXJjZXMudHh0IGIvU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQKaW5kZXggZDMw MmQzMmVhNzZiLi41YmNiZjA1N2M2ODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1NvdXJj ZXMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CkBAIC01MjEsNiArNTIxLDcg QEAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5jcHAKIGFjY2Vzc2liaWxpdHkvQVhJ bWFnZS5jcHAKIGFjY2Vzc2liaWxpdHkvQVhMb2dnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYT2Jq ZWN0Q2FjaGUuY3BwCithY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBhY2Nlc3NpYmlsaXR5 L0FYVGV4dE1hcmtlci5jcHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkLmNw cAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRDZWxsLmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDdmODE4 MmYwOGFkYy4uMDNmMzIyNmZlZTM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xNzUwLDcgKzE3NTAsOSBAQAogCQk0N0Y5NDdE QjI2NTAyRjJGMDA4Nzk2OEMgLyogQmxvY2tGb3JtYXR0aW5nUXVpcmtzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0N0Y5NDdEQTI2NTAyRjJGMDA4Nzk2 OEMgLyogQmxvY2tGb3JtYXR0aW5nUXVpcmtzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDdGQTk3MDAyNjUwOTgyQjAwODQxNDE2IC8qIFRhYmxl Rm9ybWF0dGluZ0dlb21ldHJ5LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA0N0ZBOTZGRjI2NTA5ODJBMDA4NDE0MTYgLyogVGFibGVGb3JtYXR0aW5nR2Vv bWV0cnkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQk0ODIyOTcwRTI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDgyMjk3MEMyOUM4RUJDMDAwMzNB MTI2IC8qIFJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OworCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDg2MUUwQkQy QjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0ODZCOERDNzJBMDQzQzA2MDBFMDBFNzMgLyogQVhH ZW9tZXRyeU1hbmFnZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTQ4QjAyNDJB MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRleHRSdW4uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRleHRS dW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0 OEI1QkYzNzI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4QjVCRjM1MjlD QTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ4RDBFMTI5MjlGNzMyOUUw MDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVs ZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJNDkzRTVFMDkxMkQ2NDIwNTAwMDIwMDgxIC8qIFBsYXRmb3JtQ0FM YXllckNsaWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNDkzRTVFMDgxMkQ2NDIwNTAwMDIwMDgxIC8qIFBsYXRmb3JtQ0FMYXllckNsaWVudC5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC0xMDcyMCw4 ICsxMDcyMiwxMSBAQAogCQk0N0ZBOTZGRjI2NTA5ODJBMDA4NDE0MTYgLyogVGFibGVGb3JtYXR0 aW5nR2VvbWV0cnkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVGFibGVGb3Jt YXR0aW5nR2VvbWV0cnkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDgyMjk3MEIy OUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gUmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDg2MUUwQkQyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRp b24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gQVhQb3NpdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQk0ODYxRTBCRTJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBBWFBvc2l0aW9uLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJNDg2QjhEQzYyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ4NkI4REM4MkEwNDUwMEYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAv KiBBWFRleHRSdW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhUZXh0UnVuLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM1MjlDQTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5 UmVnaW9uQ29udGV4dC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBY2Nlc3Np YmlsaXR5UmVnaW9uQ29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OEI1 QkYzNjI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk0OEQwRTEyODI5RjczMjI5MDAyNjM4NTcgLyogRWxlbWVu dEFuaW1hdGlvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRWxlbWVudEFuaW1hdGlvbkNvbnRl eHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIzMTg2LDggKzIzMTkxLDExIEBA CiAJCQkJQzA0OTNFQjcyNDQ2OTlFNDAwOUFBQzgwIC8qIEFYTG9nZ2VyLmggKi8sCiAJCQkJMjk4 MUNBQUYxMzE4MjJFQzAwRDEyRjJBIC8qIEFYT2JqZWN0Q2FjaGUuY3BwICovLAogCQkJCTI5QTgx MjFBMEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmggKi8sCisJCQkJNDg2MUUwQkUy QjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovLAorCQkJCTQ4NjFFMEJEMkIyMDA3 NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi8sCiAJCQkJQzBFMjA4QTEyOTM3OUM2RjAwQzBE MkQzIC8qIEFYVGV4dE1hcmtlci5jcHAgKi8sCiAJCQkJQzBFMjA4QTAyOTM3OUM2RTAwQzBEMkQz IC8qIEFYVGV4dE1hcmtlci5oICovLAorCQkJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBB WFRleHRSdW4uaCAqLywKIAkJCQk5MUM5RjJGODFBRTNCRTI0MDA5NUI2MUMgLyogQVhUZXh0U3Rh dGVDaGFuZ2VJbnRlbnQuaCAqLywKIAkJCQlDMEU4QURDNDI5NEI1QTYyMDA3NkNCREMgLyogQVhU cmVlU3RvcmUuaCAqLywKIAkJCQlCQzRBNTMzMDI1NjA1OTAzMDAyOEM1OTIgLyogRm9yY2VkQWNj ZXNzaWJpbGl0eVZhbHVlLmggKi8sCkBAIC0zNzU3Nyw3ICszNzU4NSw5IEBACiAJCQkJMjlBRTIx MzUyMUFCQTQ4QTAwODY5MjgzIC8qIEFYSXNvbGF0ZWRPYmplY3QuaCBpbiBIZWFkZXJzICovLAog CQkJCTI5QUUyMTJEMjFBQjlFRUIwMDg2OTI4MyAvKiBBWElzb2xhdGVkVHJlZS5oIGluIEhlYWRl cnMgKi8sCiAJCQkJMjlBODEyMzgwRkJCOUMxRDAwNTEwMjkzIC8qIEFYT2JqZWN0Q2FjaGUuaCBp biBIZWFkZXJzICovLAorCQkJCTQ4NjFFMEJGMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9u LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEUyMDhBMjI5Mzc5QzZGMDBDMEQyRDMgLyogQVhUZXh0 TWFya2VyLmggaW4gSGVhZGVycyAqLywKKwkJCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLywKIAkJCQk5MUM5RjJGOTFBRTNCRUIwMDA5NUI2MUMg LyogQVhUZXh0U3RhdGVDaGFuZ2VJbnRlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUMwRThBREM1 Mjk0QjVBNjMwMDc2Q0JEQyAvKiBBWFRyZWVTdG9yZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQ3 N0U3NzcwQkY0MTM0QTAwMTUyODcyIC8qIEJhY2tGb3J3YXJkQ2FjaGUuaCBpbiBIZWFkZXJzICov LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3Qu Y3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuY3BwCmluZGV4 IGE2MDYzZGZkZjBkMy4uYjk3OTllNzFmN2I3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWENvcmVPYmplY3QuY3BwCkBAIC0zODksNiArMzg5LDQzIEBAIEFYQ29yZU9iamVj dDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIEFYQ29yZU9iamVjdDo6c2VsZWN0ZWRDZWxs cygpCiAgICAgcmV0dXJuIHNlbGVjdGVkQ2VsbHM7CiB9CiAKK0FYQ29yZU9iamVjdCogQVhDb3Jl T2JqZWN0OjpwcmV2aW91c1NpYmxpbmcoKQoreworICAgIFJlZlB0ciBwYXJlbnQgPSBwYXJlbnRP YmplY3RVbmlnbm9yZWQoKTsKKyAgICBjb25zdCBhdXRvJiBzaWJsaW5ncyA9IHBhcmVudC0+Y2hp bGRyZW4oKTsKKyAgICBzaXplX3QgaW5kZXhPZlRoaXMgPSBzaWJsaW5ncy5maW5kKHRoaXMpOwor ICAgIGlmIChpbmRleE9mVGhpcyA9PSBub3RGb3VuZCkgeworICAgICAgICAvLyBUaGUgb25seSBy ZWFzb24gd2Ugd291bGRuJ3QgYmUgaW4gb3VyIHBhcmVudCdzIGNoaWxkcmVuKCkgaXMgaWYgd2Ug YXJlIGlnbm9yZWQgKGJlY2F1c2UgaWdub3JlZCBvYmplY3RzIGRvIG5vdCBiZWNvbWUKKyAgICAg ICAgLy8gcGFydCBvZiBjaGlsZHJlbigpKS4gQW55dGhpbmcgZWxzZSBsaWtlbHkgaW5kaWNhdGVz IGEgcGFyZW50LWNoaWxkIGhpZXJhcmNoeSBtaXNtYXRjaC4KKyAgICAgICAgQVNTRVJUKGFjY2Vz c2liaWxpdHlJc0lnbm9yZWQoKSk7CisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KKyAg ICBpZiAoIWluZGV4T2ZUaGlzKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICBBU1NFUlQo c2libGluZ3NbaW5kZXhPZlRoaXMgLSAxXSk7CisgICAgcmV0dXJuIHNpYmxpbmdzW2luZGV4T2ZU aGlzIC0gMV0uZ2V0KCk7Cit9CisKK0FYQ29yZU9iamVjdCogQVhDb3JlT2JqZWN0OjpuZXh0U2li bGluZygpCit7CisgICAgUmVmUHRyIHBhcmVudCA9IHBhcmVudE9iamVjdFVuaWdub3JlZCgpOwor ICAgIGNvbnN0IGF1dG8mIHNpYmxpbmdzID0gcGFyZW50LT5jaGlsZHJlbigpOworICAgIHNpemVf dCBpbmRleE9mVGhpcyA9IHNpYmxpbmdzLmZpbmQodGhpcyk7CisgICAgaWYgKGluZGV4T2ZUaGlz ID09IG5vdEZvdW5kKSB7CisgICAgICAgIC8vIFRoZSBvbmx5IHJlYXNvbiB3ZSB3b3VsZG4ndCBi ZSBpbiBvdXIgcGFyZW50J3MgY2hpbGRyZW4oKSBpcyBpZiB3ZSBhcmUgaWdub3JlZCAoYmVjYXVz ZSBpZ25vcmVkIG9iamVjdHMgZG8gbm90IGJlY29tZQorICAgICAgICAvLyBwYXJ0IG9mIGNoaWxk cmVuKCkpLiBBbnl0aGluZyBlbHNlIGxpa2VseSBpbmRpY2F0ZXMgYSBwYXJlbnQtY2hpbGQgaGll cmFyY2h5IG1pc21hdGNoLgorICAgICAgICBBU1NFUlQoYWNjZXNzaWJpbGl0eUlzSWdub3JlZCgp KTsKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgfQorCisgICAgZm9yICh1bnNpZ25lZCBp ID0gaW5kZXhPZlRoaXMgKyAxOyBpIDwgc2libGluZ3Muc2l6ZSgpOyBpKyspIHsKKyAgICAgICAg QVNTRVJUKHNpYmxpbmdzW2ldKTsKKyAgICAgICAgaWYgKHNpYmxpbmdzW2ldKQorICAgICAgICAg ICAgcmV0dXJuIHNpYmxpbmdzW2ldLmdldCgpOworICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsK K30KKwogI2lmIFBMQVRGT1JNKENPQ09BKQogc3RhdGljIGJvb2wgaXNWaXNpYmxlVGV4dChBY2Nl c3NpYmlsaXR5VGV4dFNvdXJjZSB0ZXh0U291cmNlKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhDb3JlT2JqZWN0LmgKaW5kZXggMTAxMTRlY2I2ZGQ4Li5lM2IwNmIwNmY4N2Qg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgK KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaApAQCAtMTEw LDE5ICsxMTAsNiBAQCBlbnVtIGNsYXNzIEFYQW5jZXN0b3JGbGFnIDogdWludDhfdCB7CiAgICAg Ly8gQml0cyA2IGFuZCA3IGFyZSBmcmVlLgogfTsKIAotI2lmIEVOQUJMRShBWF9USFJFQURfVEVY VF9BUElTKQotc3RydWN0IEFYVGV4dFJ1biB7Ci0gICAgLy8gVGhlIGxpbmUgaW5kZXggb2YgdGhp cyBydW4gd2l0aGluIHRoZSBjb250ZXh0IG9mIHRoZSBjb250YWluaW5nIFJlbmRlckJsb2NrRmxv dyBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0LgotICAgIHNpemVfdCBsaW5lSW5kZXg7Ci0g ICAgU3RyaW5nIHRleHQ7Ci0KLSAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5n JiYgdGV4dCkKLSAgICAgICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQotICAgICAgICAsIHRleHQo V1RGTW92ZSh0ZXh0KSkKLSAgICB7IH0KLX07Ci0jZW5kaWYKLQogZW51bSBjbGFzcyBBY2Nlc3Np YmlsaXR5Um9sZSB7CiAgICAgQXBwbGljYXRpb24gPSAxLAogICAgIEFwcGxpY2F0aW9uQWxlcnQs CkBAIC04MDAsNiArNzg3LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElE IGF4SUQpIHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1 cm4gbV9pZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmly dHVhbCBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUg Y29ycmVzcG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QK QEAgLTExMDQsOSArMTA5Miw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJp bGl0eVRleHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBB IHByb2dyYW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0Lgog ICAgIHZpcnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAw OwotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFY VGV4dFJ1bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVh bCBTdHJpbmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRp b24oKSBjb25zdCA9IDA7CkBAIC0xMjI3LDYgKzEyMTIsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKGJvb2wgdXBkYXRl Q2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpID0gMDsKICAgICBWZWN0b3I8QVhJRD4gY2hpbGRyZW5J RHMoYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVjZXNzYXJ5ID0gdHJ1ZSk7CiAgICAgdmlydHVhbCB2 b2lkIHVwZGF0ZUNoaWxkcmVuSWZOZWNlc3NhcnkoKSA9IDA7CisgICAgQVhDb3JlT2JqZWN0KiBw cmV2aW91c1NpYmxpbmcoKTsKKyAgICBBWENvcmVPYmplY3QqIG5leHRTaWJsaW5nKCk7CiAgICAg dmlydHVhbCB2b2lkIGRldGFjaEZyb21QYXJlbnQoKSA9IDA7CiAgICAgdmlydHVhbCBib29sIGlz RGV0YWNoZWRGcm9tUGFyZW50KCkgPSAwOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BWFBvc2l0aW9uLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAu LjJjNmU2ZDE5MGY3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhQb3NpdGlvbi5jcHAKQEAgLTAsMCArMSwyMjcgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJV VE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMg Q09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFY X1RIUkVBRF9URVhUX0FQSVMpCisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9U UkVFKQorI2luY2x1ZGUgIkFYSXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRlICJBWElzb2xhdGVk VHJlZS5oIgorI2VuZGlmIC8vIEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCisj aW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0FYSXNv bGF0ZWRPYmplY3QqIEFYUG9zaXRpb246Om9iamVjdCgpIGNvbnN0Cit7CisgICAgUkVMRUFTRV9B U1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVy biBudWxscHRyOworCisgICAgaWYgKG1fY2FjaGVkT2JqZWN0KQorICAgICAgICByZXR1cm4gbV9j YWNoZWRPYmplY3QuZ2V0KCk7CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9U UkVFKQorICAgIGF1dG8gdHJlZSA9IHN0ZDo6Z2V0PFJlZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4 VHJlZUZvcklEKHRyZWVJRCgpKSk7CisgICAgbV9jYWNoZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+ b2JqZWN0Rm9ySUQob2JqZWN0SUQoKSkgOiBudWxscHRyOworICAgIHJldHVybiBtX2NhY2hlZE9i amVjdC5nZXQoKTsKKyNlbmRpZgorfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZyb21UZXh0 TWFya2VyKGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyKQoreworICAgIHJldHVybiBBWFBvc2l0 aW9uKG1hcmtlci50cmVlSUQoKSwgbWFya2VyLm9iamVjdElEKCksIG1hcmtlci5vZmZzZXQoKSAp OworfQorCitBWFBvc2l0aW9uOjpvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdAoreworICAg IHJldHVybiB7IHsgdHJlZUlEKCksIG9iamVjdElEKCksIG51bGxwdHIsIG1fb2Zmc2V0IH0gfTsK K30KKworU3RyaW5nIEFYUG9zaXRpb246OmRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAg IGF1dG8gc2VwYXJhdG9yID0gIiwgIjsKKyAgICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+b2JqZWN0 KCk7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoCisgICAgICAgICJ0cmVlSUQgIiwgdHJlZUlEKCku bG9nZ2luZ1N0cmluZygpCisgICAgICAgICwgc2VwYXJhdG9yLCAib2JqZWN0SUQgIiwgb2JqZWN0 SUQoKS5sb2dnaW5nU3RyaW5nKCkKKyAgICAgICAgLCBzZXBhcmF0b3IsICJyb2xlICIsIG9iamVj dCA/IGFjY2Vzc2liaWxpdHlSb2xlVG9TdHJpbmcob2JqZWN0LT5yb2xlVmFsdWUoKSkgOiBTdHJp bmcoIm5vIG9iamVjdCJfcykKKyAgICAgICAgLCBzZXBhcmF0b3IsICJvZmZzZXQgIiwgbV9vZmZz ZXQKKyAgICApOworfQorCitlbnVtIGNsYXNzIENoZWNrU3RhcnQgOiBib29sIHsgTm8sIFllcyB9 OworLy8gRmluZHMgdGhlIG5leHQgb2JqZWN0IHdpdGggdGV4dCBydW5zIGluIHRoZSBnaXZlbiBk aXJlY3Rpb24uCitzdGF0aWMgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZpbmRPYmplY3RXaXRo UnVucyhBWElzb2xhdGVkT2JqZWN0JiBzdGFydCwgQVhEaXJlY3Rpb24gZGlyZWN0aW9uLCBDaGVj a1N0YXJ0IGNoZWNrU3RhcnQgPSBDaGVja1N0YXJ0OjpObykKK3sKKyAgICBpZiAoY2hlY2tTdGFy dCA9PSBDaGVja1N0YXJ0OjpZZXMpIHsKKyAgICAgICAgaWYgKGF1dG8qIHJ1bnMgPSBzdGFydC50 ZXh0UnVucygpOyBydW5zICYmIHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgIHJldHVybiAmc3Rh cnQ7CisgICAgfQorCisgICAgUmVmUHRyIGN1cnJlbnQgPSAmc3RhcnQ7CisgICAgd2hpbGUgKGN1 cnJlbnQpIHsKKyAgICAgICAgaWYgKGN1cnJlbnQgIT0gJnN0YXJ0KSB7CisgICAgICAgICAgICBh dXRvKiBydW5zID0gY3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgICAgIGlmIChydW5zICYm IHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAg fQorCisgICAgICAgIC8vIEZJWE1FOiBhcmlhLW93bnMgYnJlYWtzIHRoaXMgdHJhdmVyc2FsLCBh cyBhcmlhLW93bnMgY2F1c2VzIHRoZSBBWCB0cmVlIHRvIGJlIGNoYW5nZWQsIGFmZmVjdGluZwor ICAgICAgICAvLyBvdXIgaXRlcmF0aW9uIGJlbG93LCBidXQgaXQgZG9lc24ndCBhY3R1YWxseSBj aGFuZ2UgdGV4dCBwb3NpdGlvbiBvbiB0aGUgcGFnZS4gU28gd2UgbmVlZCB0byBpZ25vcmUgYXJp YS1vd25zCisgICAgICAgIC8vIHRyZWUgY2hhbmdlcyBoZXJlIGluIG9yZGVyIHRvIGJlaGF2ZSBj b3JyZWN0bHkuCisgICAgICAgIC8vIFdlIGFsc28gcHJvYmFibHkgbmVlZCB0byBkbyBzb21ldGhp bmcgYWJvdXQgdGV4dCB3aXRoaW4gYXJpYS1oaWRkZW4gY29udGFpbmVycywgd2hpY2ggYWZmZWN0 cyB0aGUgQVggdHJlZS4KKworICAgICAgICBjb25zdCBhdXRvJiBjaGlsZHJlbiA9IGN1cnJlbnQt PmNoaWxkcmVuKCk7CisgICAgICAgIGlmIChjaGlsZHJlbi5zaXplKCkpIHsKKyAgICAgICAgICAg IHNpemVfdCBjaGlsZEluZGV4ID0gZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6 IGNoaWxkcmVuLnNpemUoKSAtIDE7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjaGlsZHJl bltjaGlsZEluZGV4XSk7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFY SXNvbGF0ZWRPYmplY3Q+KGNoaWxkcmVuW2NoaWxkSW5kZXhdLmdldCgpKTsKKyAgICAgICAgICAg IGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gYGN1cnJlbnRgIGhhcyBubyBjaGls ZHJlbiwgbWVhbmluZyBpdCdzIGEgbGVhZiBub2RlIChlLmcuIGl0J3MgdGV4dCwgd2hpY2ggY2Fu bm90IGhhdmUgY2hpbGRyZW4pLgorICAgICAgICAvLyBDaGVjayBgY3VycmVudGBzIHNpYmxpbmdz LgorICAgICAgICBpZiAoYXV0byogc2libGluZyA9IGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6 TmV4dCA/IGN1cnJlbnQtPm5leHRTaWJsaW5nKCkgOiBjdXJyZW50LT5wcmV2aW91c1NpYmxpbmco KSkgeworICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2Jq ZWN0PihzaWJsaW5nKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAg ICAgLy8gV2UgaGF2ZSBubyBjaGlsZHJlbiwgYW5kIG5vIG5leHQvcHJldmlvdXMgc2libGluZy4g VHJ5IG91ciBwYXJlbnQncyBzaWJsaW5nLgorICAgICAgICBpZiAoYXV0byogcGFyZW50ID0gY3Vy cmVudC0+cGFyZW50T2JqZWN0VW5pZ25vcmVkKCkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBk eW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oZGlyZWN0aW9uID09IEFYRGlyZWN0aW9u OjpOZXh0ID8gcGFyZW50LT5uZXh0U2libGluZygpIDogcGFyZW50LT5wcmV2aW91c1NpYmxpbmco KSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGJyZWFrOwor ICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsKK30KKworQVhQb3NpdGlvbiBBWFBvc2l0aW9uOjpm aW5kUG9zaXRpb24oQVhEaXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIGlmICghb2Jq ZWN0KCkpCisgICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKKyAgICBhdXRvIHJ1bkZyb21P ZmZzZXQgPSB0aGlzLT5ydW5Gcm9tT2Zmc2V0KCk7CisgICAgY29uc3QgYXV0byogcnVucyA9IHJ1 bkZyb21PZmZzZXQub2JqZWN0LT50ZXh0UnVucygpOworCisgICAgYXV0byBoYXNNb3JlVGV4dElu Q3VycmVudFJ1biA9IFsmLCB0aGlzXSB7CisgICAgICAgIGlmIChkaXJlY3Rpb24gPT0gQVhEaXJl Y3Rpb246Ok5leHQpCisgICAgICAgICAgICByZXR1cm4gbV9vZmZzZXQgPCBydW5Gcm9tT2Zmc2V0 LnJ1bigpLnRleHQubGVuZ3RoKCk7CisgICAgICAgIHJldHVybiBtX29mZnNldCA+IDA7CisgICAg fTsKKyAgICBib29sIGhhc0Fub3RoZXJSdW4gPSBydW5Gcm9tT2Zmc2V0LmluZGV4ICsgMSA8IHJ1 bnMtPnNpemUoKTsKKyAgICAvLyBUaGUgbmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRl eHQsIGJlY2F1c2Ugd2UncmUgZ29pbmcgdG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBt X29mZnNldCArIDEsIHdoaWNoIHdvdWxkIGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRp cmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVu cy0+cnVuTGVuZ3RoKHJ1bkZyb21PZmZzZXQuaW5kZXggKyAxKSA+IDApOworICAgIC8vIENoZWNr aW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5vdGhlciBydW4gaXMgb25seSByZWxldmFudCBmb3Ig bW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBhcyBqdXN0IGNoZWNraW5nIHRoYXQgbV9vZmZzZXQg PiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGlyZWN0aW9uOjpQcmV2aW91cy4KKyAgICBpZiAoaGFz TW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0 ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAgICAgIC8vIFJldHVybiBhbiBvZmZzZXQgdG8gdGhl IG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgcmV0dXJuIEFYUG9z aXRpb24ocnVuRnJvbU9mZnNldC50cmVlSUQoKSwgcnVuRnJvbU9mZnNldC5vYmplY3RJRCgpLCBk aXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5leHQgPyBtX29mZnNldCArIDEgOiBtX29mZnNldCAt IDEpOworICAgIH0KKyAgICAvLyBtX29mZnNldCBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3Rl ciBpbiB0aGUgZ2l2ZW4gb2JqZWN0J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0 aGUgbmV4dCBvYmplY3Qgd2l0aCBydW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9i amVjdFdpdGhSdW5zKHJ1bkZyb21PZmZzZXQub2JqZWN0LmdldCgpLCBkaXJlY3Rpb24pKQorICAg ICAgICByZXR1cm4gQVhQb3NpdGlvbihvYmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElE KCksIGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5z KCktPmxhc3RSdW5MZW5ndGgoKSk7CisKKyAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7Cit9CisK K0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uIGRpcmVjdGlv biwgQVhUZXh0VW5pdCB0ZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5IGJvdW5kYXJ5KSBjb25z dAoreworICAgIGlmICghb2JqZWN0KCkpCisgICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsK KworICAgIGlmICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7CisgICAgICAgIGF1dG8g cnVuRnJvbU9mZnNldCA9IHRoaXMtPnJ1bkZyb21PZmZzZXQoKTsKKyAgICAgICAgUmVmUHRyIGN1 cnJlbnRPYmplY3QgPSBXVEZNb3ZlKHJ1bkZyb21PZmZzZXQub2JqZWN0KTsKKyAgICAgICAgY29u c3QgYXV0byogY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0UnVucygpOworCisgICAg ICAgIGF1dG8gY29tcHV0ZU9mZnNldCA9IFsmXSAoc2l6ZV90IHJ1bkVuZE9mZnNldCwgc2l6ZV90 IHJ1bkxlbmd0aCkgeworICAgICAgICAgICAgLy8gVGhpcyB3b3JrcyBiZWNhdXNlIGBydW5FbmRP ZmZzZXRgIGlzIHRoZSBvZmZzZXQgcG9pbnRpbmcgdG8gdGhlIGVuZCBvZiB0aGUgZ2l2ZW4gcnVu LCB3aGljaCBpbmNsdWRlcyB0aGUgbGVuZ3RoIG9mIGFsbCBydW5zIHByZWNlZGluZyBpdC4gU28g c3VidHJhY3RpbmcgdGhhdCBmcm9tIHRoZSBsZW5ndGggb2YgdGhlIGN1cnJlbnQgcnVuIGdpdmVz IHVzIGFuIG9mZnNldCB0byB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgcnVuLgorICAgICAgICAg ICAgcmV0dXJuIGJvdW5kYXJ5ID09IEFYVGV4dFVuaXRCb3VuZGFyeTo6RW5kID8gcnVuRW5kT2Zm c2V0IDogcnVuRW5kT2Zmc2V0IC0gcnVuTGVuZ3RoOworICAgICAgICB9OworICAgICAgICBhdXRv IGxpbmVQb3NpdGlvbiA9IEFYUG9zaXRpb24oY3VycmVudE9iamVjdC0+dHJlZUlEKCksIGN1cnJl bnRPYmplY3QtPm9iamVjdElEKCksIGNvbXB1dGVPZmZzZXQocnVuRnJvbU9mZnNldC5ydW5MZW5n dGhTdW0sIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgocnVuRnJvbU9mZnNldC5pbmRleCkpKTsKKyAg ICAgICAgYXV0byBzdGFydExpbmVJRCA9IGN1cnJlbnRSdW5zLT5saW5lSUQocnVuRnJvbU9mZnNl dC5pbmRleCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0 ZWQgbGluZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAg ICAgIHdoaWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChj dXJyZW50UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZz ZXQgPSAwOworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+ c2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJl bnRSdW5zLT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5s aW5lSUQoaSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5l UG9zaXRpb247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihjdXJy ZW50T2JqZWN0LT50cmVlSUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29tcHV0ZU9m ZnNldChjdW11bGF0aXZlT2Zmc2V0LCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkpKSk7CisgICAg ICAgICAgICB9CisgICAgICAgICAgICBjdXJyZW50T2JqZWN0ID0gZmluZE9iamVjdFdpdGhSdW5z KCpjdXJyZW50T2JqZWN0LCBkaXJlY3Rpb24pOworICAgICAgICAgICAgaWYgKGN1cnJlbnRPYmpl Y3QpCisgICAgICAgICAgICAgICAgY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0UnVu cygpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAgfQorICAg IHJldHVybiBudWxsUG9zaXRpb24oKTsKK30KKworUnVuRnJvbU9mZnNldCBBWFBvc2l0aW9uOjpy dW5Gcm9tT2Zmc2V0KCkgY29uc3QKK3sKKyAgICBzaXplX3QgY3VtdWxhdGl2ZU9mZnNldCA9IDA7 CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKm9iamVjdCgpLCBBWERp cmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAgICAvLyBJbmRleCBvZiB0aGUgcnVu IHdlIHN0YXJ0IGF0IGJhc2VkIG9uIG1fb2Zmc2V0LgorICAgIHNpemVfdCBzdGFydFJ1bkluZGV4 ID0gbm90Rm91bmQ7CisgICAgd2hpbGUgKGN1cnJlbnQgJiYgc3RhcnRSdW5JbmRleCA9PSBub3RG b3VuZCkgeworICAgICAgICBhdXRvJiBjdXJyZW50UnVucyA9ICpjdXJyZW50LT50ZXh0UnVucygp OworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY3VycmVudFJ1bnMuc2l6ZSgpOyBp KyspIHsKKyAgICAgICAgICAgIGN1bXVsYXRpdmVPZmZzZXQgKz0gY3VycmVudFJ1bnMucnVuTGVu Z3RoKGkpOworICAgICAgICAgICAgaWYgKGN1bXVsYXRpdmVPZmZzZXQgPj0gbV9vZmZzZXQpIHsK KyAgICAgICAgICAgICAgICBzdGFydFJ1bkluZGV4ID0gaTsKKyAgICAgICAgICAgICAgICBicmVh azsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIGlmIChzdGFydFJ1bkluZGV4 ICE9IG5vdEZvdW5kKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGN1cnJlbnQgPSBmaW5k T2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnQsIEFYRGlyZWN0aW9uOjpOZXh0KTsKKyAgICB9CisKKyAg ICBpZiAoc3RhcnRSdW5JbmRleCA9PSBub3RGb3VuZCkgeworICAgICAgICAvLyBGSVhNRTogTm90 IHN1cmUgaG93IHRoaXMgY291bGQgaGFwcGVuLCBidXQgd2UgbWF5IG5lZWQgdG8gaGFuZGxlIGl0 IHNvbWVob3c/CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor ICAgIHJldHVybiB7ICpjdXJyZW50LCBzdGFydFJ1bkluZGV4LCBjdW11bGF0aXZlT2Zmc2V0IH07 Cit9CisKK0FYVGV4dE1hcmtlclJhbmdlIEFYUG9zaXRpb246OmxpbmVSYW5nZShMaW5lUmFuZ2VU eXBlIHR5cGUpIGNvbnN0Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHsg bnVsbFBvc2l0aW9uKCksIG51bGxQb3NpdGlvbigpIH07CisKKyAgICBpZiAodHlwZSA9PSBMaW5l UmFuZ2VUeXBlOjpDdXJyZW50KQorICAgICAgICByZXR1cm4geyBmaW5kUG9zaXRpb24oQVhEaXJl Y3Rpb246OlByZXZpb3VzLCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6OlN0 YXJ0KSwgZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpOZXh0LCBBWFRleHRVbml0OjpMaW5lLCBB WFRleHRVbml0Qm91bmRhcnk6OkVuZCkgfTsKKyAgICAvLyBUaGUgb3RoZXIgdHlwZXMgYXJlbid0 IGltcGxlbWVudGVkIHlldC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhU X0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRp b24uaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYzlhZTYwNjliZWExCi0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKQEAgLTAs MCArMSwxMTQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQorI2luY2x1ZGUgIkFYSXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRl ICJBWFRleHRNYXJrZXIuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitlbnVtIGNsYXNzIEFY RGlyZWN0aW9uIDogYm9vbCB7IE5leHQsIFByZXZpb3VzIH07CisKK2VudW0gY2xhc3MgQVhUZXh0 VW5pdCA6IHVpbnQ4X3QgeworICAgIExpbmUsCisgICAgUGFyYWdyYXBoLAorICAgIFNlbnRlbmNl LAorICAgIFdvcmQsCit9OworZW51bSBjbGFzcyBBWFRleHRVbml0Qm91bmRhcnkgOiBib29sIHsg U3RhcnQsIEVuZCwgfTsKKworZW51bSBjbGFzcyBMaW5lUmFuZ2VUeXBlIDogdWludDhfdCB7Cisg ICAgQ3VycmVudCwKKyAgICBMZWZ0LAorICAgIFJpZ2h0LAorfTsKKworc3RydWN0IFJ1bkZyb21P ZmZzZXQgeworICAgIC8vIFRoZSBsZWFmIG5vZGUgd2l0aCBydW5zIHBvaW50ZWQgdG8gYnkgdGhl IG9mZnNldCB1c2VkIHRvIGNvbXB1dGUgdGhpcyBzdHJ1Y3QuCisgICAgUmVmPEFYSXNvbGF0ZWRP YmplY3Q+IG9iamVjdDsKKyAgICAvLyBSdW4gaW5kZXggcG9pbnRlZCB0byBieSB0aGUgb2Zmc2V0 IHVzZWQgdG8gY29tcHV0ZSB0aGlzIHN0cnVjdC4KKyAgICBzaXplX3QgaW5kZXggeyAwIH07Cisg ICAgLy8gVGhlIHN1bSBvZiB0aGUgdGV4dCBmcm9tIHJ1bnMgcHJpb3IgdG8gYW5kIGluY2x1ZGlu ZyBvYmplY3QtPnRleHRSdW5zW2luZGV4XS4KKyAgICBzaXplX3QgcnVuTGVuZ3RoU3VtOworCisg ICAgQVhJRCB0cmVlSUQoKSBjb25zdCB7IHJldHVybiBvYmplY3QtPnRyZWVJRCgpOyB9CisgICAg QVhJRCBvYmplY3RJRCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdC0+b2JqZWN0SUQoKTsgfQorICAg IGNvbnN0IEFYVGV4dFJ1biYgcnVuKCkgY29uc3QgeyByZXR1cm4gKCpvYmplY3QtPnRleHRSdW5z KCkpW2luZGV4XTsgfQorCisgICAgUnVuRnJvbU9mZnNldChBWElzb2xhdGVkT2JqZWN0JiBvYmpl Y3QsIHNpemVfdCBydW5JbmRleCwgc2l6ZV90IHJ1bkxlbmd0aFN1bSkKKyAgICAgICAgOiBvYmpl Y3Qob2JqZWN0KQorICAgICAgICAsIGluZGV4KHJ1bkluZGV4KQorICAgICAgICAsIHJ1bkxlbmd0 aFN1bShydW5MZW5ndGhTdW0pCisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChydW5JbmRl eCA8IG9iamVjdC50ZXh0UnVucygpLT5zaXplKCkpOworICAgIH0KK307CisKK2NsYXNzIEFYUG9z aXRpb24geworcHVibGljOgorICAgIGV4cGxpY2l0IEFYUG9zaXRpb24odW5zaWduZWQgdHJlZUlE LCB1bnNpZ25lZCBvYmplY3RJRCwgdW5zaWduZWQgb2Zmc2V0KQorICAgICAgICA6IG1fdHJlZUlE KE9iamVjdElkZW50aWZpZXI8QVhJRFR5cGU+KHRyZWVJRCkpCisgICAgICAgICwgbV9vYmplY3RJ RChPYmplY3RJZGVudGlmaWVyPEFYSURUeXBlPihvYmplY3RJRCkpCisgICAgICAgICwgbV9vZmZz ZXQob2Zmc2V0KQorICAgIHsgfQorICAgIGV4cGxpY2l0IEFYUG9zaXRpb24oQVhJRCB0cmVlSUQs IEFYSUQgb2JqZWN0SUQsIHVuc2lnbmVkIG9mZnNldCkKKyAgICAgICAgOiBtX3RyZWVJRCh0cmVl SUQpCisgICAgICAgICwgbV9vYmplY3RJRChvYmplY3RJRCkKKyAgICAgICAgLCBtX29mZnNldChv ZmZzZXQpCisgICAgeyB9CisgICAgc3RhdGljIEFYUG9zaXRpb24gbnVsbFBvc2l0aW9uKCkgeyBy ZXR1cm4gQVhQb3NpdGlvbigwLCAwLCAwKTsgfQorICAgIHN0YXRpYyBBWFBvc2l0aW9uIGZyb21U ZXh0TWFya2VyKGNvbnN0IEFYVGV4dE1hcmtlciYpOworICAgIG9wZXJhdG9yIEFYVGV4dE1hcmtl cigpIGNvbnN0OworCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCB7IHJldHVybiBtX3RyZWVJRDsg fQorICAgIEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJldHVybiBtX29iamVjdElEOyB9CisgICAg dW5zaWduZWQgb2Zmc2V0KCkgY29uc3QgeyByZXR1cm4gbV9vZmZzZXQ7IH0KKworICAgIEFYSXNv bGF0ZWRPYmplY3QqIG9iamVjdCgpIGNvbnN0OworICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyBy ZXR1cm4gIXRyZWVJRCgpLmlzVmFsaWQoKSB8fCAhb2JqZWN0SUQoKS5pc1ZhbGlkKCk7IH0KKwor ICAgIC8vIEZpbmQgdGhlIG5leHQgb3IgcHJldmlvdXMgcG9zaXRpb24uCisgICAgQVhQb3NpdGlv biBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb24pIGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZyb20g dGhpcyBwb3NpdGlvbiwgY3JlYXRlcyBhIG5ldyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVuIGRpcmVj dGlvbiBhbmQgdGV4dCB1bml0IHR5cGUuCisgICAgQVhQb3NpdGlvbiBmaW5kUG9zaXRpb24oQVhE aXJlY3Rpb24sIEFYVGV4dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSkgY29uc3Q7CisgICAgQVhU ZXh0TWFya2VyUmFuZ2UgbGluZVJhbmdlKExpbmVSYW5nZVR5cGUpIGNvbnN0OworCisgICAgLy8g R2V0cyB0aGUgcnVuIHBvaW50ZWQgdG8gYnkgbV9vZmZzZXQgKGFuZCBzb21lIGFzc29jaWF0ZWQg aW5mb3JtYXRpb24pLgorICAgIFJ1bkZyb21PZmZzZXQgcnVuRnJvbU9mZnNldCgpIGNvbnN0Owor CisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdDsKKworcHJpdmF0ZToKKyAgICBB WElEIG1fdHJlZUlEOworICAgIEFYSUQgbV9vYmplY3RJRDsKKyAgICB1bnNpZ25lZCBtX29mZnNl dCB7IDAgfTsKKworICAgIG11dGFibGUgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IG1fY2FjaGVk T2JqZWN0OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShB WF9USFJFQURfVEVYVF9BUElTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFRleHRNYXJrZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRl eHRNYXJrZXIuY3BwCmluZGV4IDlhZDZhYmY5M2FhYy4uZDJkNDMzYmNiYjFiIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCkBAIC0zMzUsNyArMzM1 LDcgQEAgc3RkOjpvcHRpb25hbDxBWFRleHRNYXJrZXJSYW5nZT4gQVhUZXh0TWFya2VyUmFuZ2U6 OmludGVyc2VjdGlvbldpdGgoY29uc3QgQVhUZXgKIAogU3RyaW5nIEFYVGV4dE1hcmtlclJhbmdl OjpkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbWFrZVN0cmluZygic3Rh cnQ6IHsiLCBtX3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogeyIsIG1fZW5kLmRl YnVnRGVzY3JpcHRpb24oKSwgIn0iKTsKKyAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsi LCBtX3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogICB7IiwgbV9lbmQuZGVidWdE ZXNjcmlwdGlvbigpLCAifSIpOwogfQogCiBzdGQ6OnBhcnRpYWxfb3JkZXJpbmcgcGFydGlhbE9y ZGVyKGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMSwgY29uc3QgQVhUZXh0TWFya2VyJiBtYXJr ZXIyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJr ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKaW5kZXgg MTdlOWZjMGRhYjk4Li41OWY0ZjM3OTYzMTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFRleHRNYXJrZXIuaApAQCAtMTIzLDYgKzEyMyw3IEBAIHB1YmxpYzoKIAogICAgIEFY SUQgdHJlZUlEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4VHJlZUlEKCk7IH0KICAgICBBWElE IG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4T2JqZWN0SUQoKTsgfQorICAgIHVu c2lnbmVkIG9mZnNldCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5vZmZzZXQ7IH0KICAgICBib29s IGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICF0cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElE KCkuaXNWYWxpZCgpOyB9CiAgICAgUmVmUHRyPEFYQ29yZU9iamVjdD4gb2JqZWN0KCkgY29uc3Q7 CiAgICAgYm9vbCBpc1ZhbGlkKCkgY29uc3QgeyByZXR1cm4gb2JqZWN0KCk7IH0KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uYWU4N2EwNWVhMTQxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApAQCAtMCwwICsxLDExOCBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFJlbmRlckJsb2NrOworCitzdHJ1Y3QgQVhUZXh0 UnVuTGluZUlEIHsKKyAgICB2b2lkKiBjb250YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAg c2l6ZV90IGxpbmVJbmRleCB7IDAgfTsKKworICAgIEFYVGV4dFJ1bkxpbmVJRCh2b2lkKiBjb250 YWluaW5nQmxvY2ssIHNpemVfdCBsaW5lSW5kZXgpCisgICAgICAgIDogY29udGFpbmluZ0Jsb2Nr KGNvbnRhaW5pbmdCbG9jaykKKyAgICAgICAgLCBsaW5lSW5kZXgobGluZUluZGV4KQorICAgIHsg fQorICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBBWFRleHRSdW5MaW5lSUQmKSBjb25zdCA9IGRl ZmF1bHQ7CisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAorICAgIHsKKyAgICAg ICAgVGV4dFN0cmVhbSBzdHJlYW07CisgICAgICAgIHN0cmVhbSA8PCAiTGluZUlEICIgPDwgY29u dGFpbmluZ0Jsb2NrIDw8ICIgIiA8PCBsaW5lSW5kZXg7CisgICAgICAgIHJldHVybiBzdHJlYW0u cmVsZWFzZSgpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW4geworICAgIC8vIFRoZSBs aW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUgY29udGFpbmlu ZyBSZW5kZXJCbG9jayBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0LgorICAgIHNpemVfdCBs aW5lSW5kZXg7CisgICAgU3RyaW5nIHRleHQ7CisKKyAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJ bmRleCwgU3RyaW5nJiYgdGV4dCkKKyAgICAgICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQorICAg ICAgICAsIHRleHQoV1RGTW92ZSh0ZXh0KSkKKyAgICB7IH0KKworICAgIFN0cmluZyBkZWJ1Z0Rl c2NyaXB0aW9uKHZvaWQqIGNvbnRhaW5pbmdCbG9jaykgY29uc3QKKyAgICB7CisgICAgICAgIEFY VGV4dFJ1bkxpbmVJRCBsaW5lSUQgPSB7IGNvbnRhaW5pbmdCbG9jaywgbGluZUluZGV4IH07Cisg ICAgICAgIHJldHVybiBtYWtlU3RyaW5nKGxpbmVJRC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICI6IHwi LCBtYWtlU3RyaW5nQnlSZXBsYWNpbmdBbGwodGV4dCwgJ1xuJywgIntuZXdsaW5lfSJfcyksICJ8 KGxlbiAiLCB0ZXh0Lmxlbmd0aCgpLCAiKSIpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRS dW5zIHsKKyAgICAvLyBUaGUgY29udGFpbmluZyBibG9jayBmb3IgdGhlIHRleHQgcnVucy4gVGhp cyBpcyByZXF1aXJlZCBiZWNhdXNlIGJhc2VkIG9uIHRoZSBzdHJ1Y3R1cmUKKyAgICAvLyBvZiB0 aGUgQVggdHJlZSwgdGV4dCBydW5zIGZvciBkaWZmZXJlbnQgb2JqZWN0cyBjYW4gaGF2ZSB0aGUg c2FtZSBsaW5lIGluZGV4IGJ1dCBkaWZmZXJlbnQKKyAgICAvLyBjb250YWluaW5nIGJsb2Nrcywg bWVhbmluZyB0aGV5IGFyZSByZW5kZXJlZCBvbiBkaWZmZXJlbnQgbGluZXMuCisgICAgLy8gRG8g bm90IGRlLXJlZmVyZW5jZS4gVXNlIGZvciBjb21wYXJpc29uIHB1cnBvc2VzIG9ubHkuCisgICAg dm9pZCogY29udGFpbmluZ0Jsb2NrIHsgbnVsbHB0ciB9OworICAgIFZlY3RvcjxBWFRleHRSdW4+ IHJ1bnM7CisKKyAgICBBWFRleHRSdW5zKCkgPSBkZWZhdWx0OworICAgIEFYVGV4dFJ1bnMoUmVu ZGVyQmxvY2sqIGNvbnRhaW5pbmdCbG9jaywgVmVjdG9yPEFYVGV4dFJ1bj4mJiBydW5zKQorICAg ICAgICA6IGNvbnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgcnVucyhX VEZNb3ZlKHJ1bnMpKQorICAgIHsgfQorCisgICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IHJldHVy biBydW5zLnNpemUoKTsgfQorICAgIHVuc2lnbmVkIHJ1bkxlbmd0aChzaXplX3QgaW5kZXgpIGNv bnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsK KyAgICAgICAgcmV0dXJuIHJ1bnNbaW5kZXhdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVu c2lnbmVkIGxhc3RSdW5MZW5ndGgoKSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKHJ1bnMuaXNF bXB0eSgpKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIHJldHVybiBydW5zW3J1bnMu c2l6ZSgpIC0gMV0udGV4dC5sZW5ndGgoKTsKKyAgICB9CisgICAgQVhUZXh0UnVuTGluZUlEIGxp bmVJRChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChp bmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHsgY29udGFpbmluZ0Jsb2NrLCBy dW5zW2luZGV4XS5saW5lSW5kZXggfTsKKyAgICB9CisgICAgY29uc3QgQVhUZXh0UnVuJiBvcGVy YXRvcltdKHNpemVfdCBydW5JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNT RVJUKHJ1bkluZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICByZXR1cm4gcnVuc1tydW5JbmRl eF07CisgICAgfQorICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKKyAgICB7Cisg ICAgICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgICAgICByZXN1bHQuYXBwZW5kKCdbJyk7 CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7Cisg ICAgICAgICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0uZGVidWdEZXNjcmlwdGlvbihjb250YWlu aW5nQmxvY2spKTsKKyAgICAgICAgICAgIGlmIChpICE9IHJ1bnMuc2l6ZSgpIC0gMSkKKyAgICAg ICAgICAgICAgICByZXN1bHQuYXBwZW5kKCIsICIpOworICAgICAgICB9CisgICAgICAgIHJlc3Vs dC5hcHBlbmQoJ10nKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdC50b1N0cmluZygpOworICAgIH0K K307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFE X1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eU9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlPYmplY3QuY3BwCmluZGV4IGVmMDg3NzA1OGZlYi4uMDZkYTg5OTU5OWMwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAKQEAgLTExMyw2ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppbml0 KCkKICAgICBtX3JvbGUgPSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5Um9sZSgpOwogfQogCitBWElE IEFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7CisgICAgYXV0byogY2FjaGUg PSBheE9iamVjdENhY2hlKCk7CisgICAgcmV0dXJuIGNhY2hlID8gY2FjaGUtPnRyZWVJRCgpIDog QVhJRCgpOworfQorCiBpbmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByb2Nl c3NJRCgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHByZXNlbnRpbmdBcHBsaWNhdGlvblBJRCgpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2Jq ZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3Qu aAppbmRleCA1ZDg4Y2M2MTI4YzMuLjIyMTllNmNhNDkzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKKysrIGIvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKQEAgLTMwLDYgKzMwLDkg QEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCisjaWYgRU5BQkxF KEFYX1RIUkVBRF9URVhUX0FQSVMpCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCisjZW5kaWYgLy8g RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCiAjaW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2UuaCIK ICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNsdWRlICJMYXlvdXRSZWN0LmgiCkBAIC02Myw2 ICs2Niw3IEBAIGNsYXNzIEFjY2Vzc2liaWxpdHlPYmplY3QgOiBwdWJsaWMgQVhDb3JlT2JqZWN0 LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8QWNjZXNzaWJpCiBwdWJsaWM6CiAgICAgdmlydHVhbCB+ QWNjZXNzaWJpbGl0eU9iamVjdCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbDsK ICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIGRi ZygpIGNvbnN0IGZpbmFsOwogCkBAIC0zODAsNiArMzg0LDkgQEAgcHVibGljOgogICAgIFN0cmlu ZyB0ZXh0VW5kZXJFbGVtZW50KEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFj Y2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZSB7IHJldHVy biB7IH07IH0KICAgICBTdHJpbmcgdGV4dCgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsg fQogICAgIHVuc2lnbmVkIHRleHRMZW5ndGgoKSBjb25zdCBmaW5hbDsKKyNpZiBFTkFCTEUoQVhf VEhSRUFEX1RFWFRfQVBJUykKKyAgICB2aXJ0dWFsIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7IHJl dHVybiB7IH07IH0KKyNlbmRpZgogI2lmIFBMQVRGT1JNKENPQ09BKQogICAgIC8vIFJldHVybnMg YW4gYXJyYXkgb2Ygc3RyaW5ncyBhbmQgQVhPYmplY3Qgd3JhcHBlcnMgY29ycmVzcG9uZGluZyB0 byB0aGUKICAgICAvLyB0ZXh0cnVucyBhbmQgcmVwbGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQgaW4g dGhlIGdpdmVuIHJhbmdlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKaW5kZXggMzhhNGFhZjY1N2YyLi45 OGU4NDAyZTM2YTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcApAQCAtMTM5NSwxMSArMTM5NSwxMSBA QCBDaGFyYWN0ZXJSYW5nZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRleHRS YW5nZSgpIGNvbnN0CiB9CiAKICNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLVZlY3Rv cjxBWFRleHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FYVGV4 dFJ1bnMgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGV4dFJ1bnMoKQogewogICAgIGlmIChh dXRvKiByZW5kZXJMaW5lQnJlYWsgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVyTGluZUJyZWFrPihy ZW5kZXJlcigpKSkgewogICAgICAgICBhdXRvIGJveCA9IElubGluZUl0ZXJhdG9yOjpib3hGb3Io KnJlbmRlckxpbmVCcmVhayk7Ci0gICAgICAgIHJldHVybiB7IHsgYm94LT5saW5lSW5kZXgoKSwg bWFrZVN0cmluZygnXG4nKSB9IH07CisgICAgICAgIHJldHVybiB7IHJlbmRlckxpbmVCcmVhay0+ Y29udGFpbmluZ0Jsb2NrKCksIHsgQVhUZXh0UnVuKGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJp bmcoJ1xuJykuaXNvbGF0ZWRDb3B5KCkpIH0gfTsKICAgICB9CiAKICAgICBXZWFrUHRyIHJlbmRl clRleHQgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVyVGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0xNDUy LDcgKzE0NTIsNyBAQCBWZWN0b3I8QVhUZXh0UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojp0ZXh0UnVucygpCiAKICAgICBpZiAoIWxpbmVTdHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBy dW5zLmFwcGVuZCh7IGN1cnJlbnRMaW5lSW5kZXgsIGxpbmVTdHJpbmcudG9TdHJpbmcoKS5pc29s YXRlZENvcHkoKSB9KTsKLSAgICByZXR1cm4gcnVuczsKKyAgICByZXR1cm4geyByZW5kZXJUZXh0 LT5jb250YWluaW5nQmxvY2soKSwgV1RGTW92ZShydW5zKSB9OwogfQogI2VuZGlmIC8vIEVOQUJM RShBWF9USFJFQURfVEVYVF9BUElTKQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCmluZGV4IGNlZWM2YmYzZTg5 OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaApAQCAtMTAwLDcgKzEwMCw3IEBAIHB1 YmxpYzoKICAgICBTdHJpbmcgdGV4dFVuZGVyRWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVy RWxlbWVudE1vZGUgPSBBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qg b3ZlcnJpZGU7CiAgICAgU3RyaW5nIHNlbGVjdGVkVGV4dCgpIGNvbnN0IG92ZXJyaWRlOwogI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRS dW5zKCkgZmluYWw7CisgICAgQVhUZXh0UnVucyB0ZXh0UnVucygpIGZpbmFsOwogI2VuZGlmCiAK ICAgICBib29sIGlzV2lkZ2V0KCkgY29uc3Qgb3ZlcnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCBi L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmpl Y3QuY3BwCmluZGV4IDYyYTFhNTc1YWU2MS4uMjhmNDFjZWFkZDkxIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0LmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkFYR2VvbWV0cnlNYW5h Z2VyLmgiCiAjaW5jbHVkZSAiQVhJc29sYXRlZFRyZWUuaCIKICNpbmNsdWRlICJBWExvZ2dlci5o IgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgogCiAjaWYgUExBVEZPUk0oTUFDKQogI2ltcG9ydCA8 cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5oPgpAQCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQgQVhJ c29sYXRlZE9iamVjdDo6c2V0UHJvcGVydHkoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBB WFByb3BlcnR5VmFsdWVWCiAgICAgICAgIFtdKHN0ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJSYW5n ZT4mIHR5cGVkVmFsdWUpIHsKICAgICAgICAgICAgIHJldHVybiAhdHlwZWRWYWx1ZS5maXJzdC5p c1ZhbGlkKCkgJiYgIXR5cGVkVmFsdWUuc2Vjb25kLmxvY2F0aW9uICYmICF0eXBlZFZhbHVlLnNl Y29uZC5sZW5ndGg7CiAgICAgICAgIH0sCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CisgICAgICAgIFtdKEFYVGV4dFJ1bnMgcnVucykgeyByZXR1cm4gIXJ1bnMuc2l6ZSgpOyB9LAor I2VuZGlmCiAgICAgICAgIFtdKGF1dG8mKSB7CiAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTk3MSw2ICs5NzUsMTkgQEAgaW50 IEFYSXNvbGF0ZWRPYmplY3Q6OmludEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lIHByb3Bl cnR5TmFtZSkgY29uc3QKICAgICApOwogfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCitjb25zdCBBWFRleHRSdW5zKiBBWElzb2xhdGVkT2JqZWN0Ojp0ZXh0UnVucygpIGNvbnN0 Cit7CisgICAgYXV0byBlbnRyeSA9IG1fcHJvcGVydHlNYXAuZmluZChBWFByb3BlcnR5TmFtZTo6 VGV4dFJ1bnMpOworICAgIGlmIChlbnRyeSA9PSBtX3Byb3BlcnR5TWFwLmVuZCgpKQorICAgICAg ICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1cm4gV1RGOjpzd2l0Y2hPbihlbnRyeS0+dmFsdWUs CisgICAgICAgIFtdIChjb25zdCBBWFRleHRSdW5zJiB0eXBlZFZhbHVlKSAtPiBjb25zdCBBWFRl eHRSdW5zKiB7IHJldHVybiAmdHlwZWRWYWx1ZTsgfSwKKyAgICAgICAgW10gKGF1dG8mKSAtPiBj b25zdCBBWFRleHRSdW5zKiB7IHJldHVybiBudWxscHRyOyB9CisgICAgKTsKK30KKyNlbmRpZgor CiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogVCBBWElzb2xhdGVkT2JqZWN0OjpnZXRPclJldHJpZXZl UHJvcGVydHlWYWx1ZShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUpCiB7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2Jq ZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0LmgKaW5kZXggYTZjYTAzNDM3NzdkLi44MjhjNzI0ZTcwNTUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmpl Y3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElz b2xhdGVkT2JqZWN0LmgKQEAgLTQ0LDYgKzQ0LDkgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog Y2xhc3MgQVhJc29sYXRlZFRyZWU7CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitz dHJ1Y3QgQVhUZXh0UnVuczsKKyNlbmRpZgogCiBjbGFzcyBBWElzb2xhdGVkT2JqZWN0IGZpbmFs IDogcHVibGljIEFYQ29yZU9iamVjdCB7CiAgICAgZnJpZW5kIGNsYXNzIEFYSXNvbGF0ZWRUcmVl OwpAQCAtNTEsNyArNTQsOSBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFJlZjxBWElzb2xhdGVkT2Jq ZWN0PiBjcmVhdGUoY29uc3QgUmVmPEFjY2Vzc2liaWxpdHlPYmplY3Q+JiwgQVhJc29sYXRlZFRy ZWUqKTsKICAgICB+QVhJc29sYXRlZE9iamVjdCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25z dCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnRyZWVJRCgpOyB9CiAgICAgUHJvY2Vzc0lEIHByb2Nl c3NJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+cHJvY2Vzc0lEKCk7IH0KKyAgICBB Y2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBzdGF0aWNf Y2FzdDxBY2Nlc3NpYmlsaXR5Um9sZT4oaW50QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6 OlJvbGVWYWx1ZSkpOyB9CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCiAgICAgdm9p ZCBhdHRhY2hQbGF0Zm9ybVdyYXBwZXIoQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIqKTsKQEAg LTU5LDEwICs2NCwxNiBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc1RhYmxlKCkgY29uc3QgZmluYWwg eyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc1RhYmxlKTsgfQog ICAgIGJvb2wgaXNFeHBvc2FibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRl VmFsdWUoQVhQcm9wZXJ0eU5hbWU6OklzRXhwb3NhYmxlKTsgfQogCisgICAgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVk ZWQgPSB0cnVlKSBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3QoKSBj b25zdCBmaW5hbCB7IHJldHVybiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKTsgfQorICAgIEFYSXNv bGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNvbnN0IGZpbmFsOwogICAgIEFY SXNvbGF0ZWRPYmplY3QqIGVkaXRhYmxlQW5jZXN0b3IoKSBmaW5hbCB7IHJldHVybiBBY2Nlc3Np YmlsaXR5OjplZGl0YWJsZUFuY2VzdG9yKCp0aGlzKTsgfTsKICAgICBib29sIGNhblNldEZvY3Vz QXR0cmlidXRlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJv cGVydHlOYW1lOjpDYW5TZXRGb2N1c0F0dHJpYnV0ZSk7IH0KIAorI2lmIEVOQUJMRShBWF9USFJF QURfVEVYVF9BUElTKQorICAgIGNvbnN0IEFYVGV4dFJ1bnMqIHRleHRSdW5zKCkgY29uc3Q7Cisj ZW5kaWYKKwogcHJpdmF0ZToKICAgICB2b2lkIGRldGFjaFJlbW90ZVBhcnRzKEFjY2Vzc2liaWxp dHlEZXRhY2htZW50VHlwZSkgZmluYWw7CiAgICAgdm9pZCBkZXRhY2hQbGF0Zm9ybVdyYXBwZXIo QWNjZXNzaWJpbGl0eURldGFjaG1lbnRUeXBlKSBmaW5hbDsKQEAgLTI0Myw3ICsyNTQsNiBAQCBw cml2YXRlOgogICAgIFZlY3RvcjxTdHJpbmc+IGRldGVybWluZURyb3BFZmZlY3RzKCkgY29uc3Qg ZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogYWNjZXNzaWJpbGl0eUhpdFRlc3QoY29uc3Qg SW50UG9pbnQmKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBmb2N1c2VkVUlF bGVtZW50KCkgY29uc3QgZmluYWw7Ci0gICAgQVhJc29sYXRlZE9iamVjdCogcGFyZW50T2JqZWN0 VW5pZ25vcmVkKCkgY29uc3QgZmluYWw7CiAgICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y IGxpbmtlZE9iamVjdHMoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPm9iamVjdHNGb3JJ RHModmVjdG9yQXR0cmlidXRlVmFsdWU8QVhJRD4oQVhQcm9wZXJ0eU5hbWU6OkxpbmtlZE9iamVj dHMpKTsgfQogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHRpdGxlVUlFbGVtZW50KCkgY29uc3QgZmlu YWwgeyByZXR1cm4gb2JqZWN0QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlRpdGxlVUlF bGVtZW50KTsgfQogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHNjcm9sbEJhcihBY2Nlc3NpYmlsaXR5 T3JpZW50YXRpb24pIGZpbmFsOwpAQCAtMjUxLDcgKzI2MSw2IEBAIHByaXZhdGU6CiAgICAgU3Ry aW5nIGV4cGFuZGVkVGV4dFZhbHVlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmli dXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OkV4cGFuZGVkVGV4dFZhbHVlKTsgfQogICAgIGJvb2wg c3VwcG9ydHNFeHBhbmRlZFRleHRWYWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRy aWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6U3VwcG9ydHNFeHBhbmRlZFRleHRWYWx1ZSk7IH0K ICAgICBTUkdCQTx1aW50OF90PiBjb2xvclZhbHVlKCkgY29uc3QgZmluYWw7Ci0gICAgQWNjZXNz aWJpbGl0eVJvbGUgcm9sZVZhbHVlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RhdGljX2Nhc3Q8 QWNjZXNzaWJpbGl0eVJvbGU+KGludEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpSb2xl VmFsdWUpKTsgfQogICAgIFN0cmluZyByb2xlUGxhdGZvcm1TdHJpbmcoKSBjb25zdCBmaW5hbCB7 IHJldHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVBsYXRmb3Jt U3RyaW5nKTsgfQogICAgIFN0cmluZyByb2xlRGVzY3JpcHRpb24oKSBjb25zdCBmaW5hbCB7IHJl dHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZURlc2NyaXB0aW9u KTsgfQogICAgIFN0cmluZyBzdWJyb2xlUGxhdGZvcm1TdHJpbmcoKSBjb25zdCBmaW5hbCB7IHJl dHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6U3Vicm9sZVBsYXRmb3Jt U3RyaW5nKTsgfQpAQCAtMzE2LDcgKzMyNSw2IEBAIHByaXZhdGU6CiAgICAgQWNjZXNzaWJpbGl0 eUNoaWxkcmVuVmVjdG9yIHZpc2libGVDaGlsZHJlbigpIGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+ b2JqZWN0c0ZvcklEcyh2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWElEPihBWFByb3BlcnR5TmFtZTo6 VmlzaWJsZUNoaWxkcmVuKSk7IH0KICAgICBBdG9tU3RyaW5nIHRhZ05hbWUoKSBjb25zdCBmaW5h bDsKICAgICB2b2lkIHNldENoaWxkcmVuSURzKFZlY3RvcjxBWElEPiYmKTsKLSAgICBjb25zdCBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKGJvb2wgdXBkYXRlQ2hpbGRyZW5J Zk5lZWRlZCA9IHRydWUpIGZpbmFsOwogICAgIHZvaWQgdXBkYXRlQ2hpbGRyZW5JZk5lY2Vzc2Fy eSgpIGZpbmFsOwogICAgIGJvb2wgaXNEZXRhY2hlZEZyb21QYXJlbnQoKSBmaW5hbDsKICAgICBB WElzb2xhdGVkT2JqZWN0KiBsaXZlUmVnaW9uQW5jZXN0b3IoYm9vbCBleGNsdWRlSWZPZmYgPSB0 cnVlKSBjb25zdCBmaW5hbCB7IHJldHVybiBBY2Nlc3NpYmlsaXR5OjpsaXZlUmVnaW9uQW5jZXN0 b3IoKnRoaXMsIGV4Y2x1ZGVJZk9mZik7IH0KQEAgLTM0NSw5ICszNTMsNiBAQCBwcml2YXRlOgog CiAgICAgLy8gQ2hhcmFjdGVyUmFuZ2Ugc3VwcG9ydC4KICAgICBDaGFyYWN0ZXJSYW5nZSBzZWxl Y3RlZFRleHRSYW5nZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHByb3BlcnR5VmFsdWU8Q2hhcmFj dGVyUmFuZ2U+KEFYUHJvcGVydHlOYW1lOjpTZWxlY3RlZFRleHRSYW5nZSk7IH0KLSNpZiBFTkFC TEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICBWZWN0b3I8QVhUZXh0UnVuPiB0ZXh0UnVucygp IGZpbmFsIHsgcmV0dXJuIHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYVGV4dFJ1bj4oQVhQcm9wZXJ0 eU5hbWU6OlRleHRSdW5zKTsgfQotI2VuZGlmCiAgICAgaW50IGluc2VydGlvblBvaW50TGluZU51 bWJlcigpIGNvbnN0IGZpbmFsOwogICAgIENoYXJhY3RlclJhbmdlIGRvQVhSYW5nZUZvckxpbmUo dW5zaWduZWQpIGNvbnN0IGZpbmFsOwogICAgIFN0cmluZyBkb0FYU3RyaW5nRm9yUmFuZ2UoY29u c3QgQ2hhcmFjdGVyUmFuZ2UmKSBjb25zdCBmaW5hbDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmggYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCmluZGV4 IGYxMWVmODU1NWExNC4uOTQ1MDI5ZTA3MDZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKQEAgLTI1 NSw3ICsyNTUsNyBAQCB1c2luZyBBWFByb3BlcnR5VmFsdWVWYXJpYW50ID0gc3RkOjp2YXJpYW50 PHN0ZDo6bnVsbHB0cl90LCBBWElELCBTdHJpbmcsIGJvb2wsCiAgICAgLCBSZXRhaW5QdHI8TlNB dHRyaWJ1dGVkU3RyaW5nPgogI2VuZGlmCiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp Ci0gICAgLCBWZWN0b3I8QVhUZXh0UnVuPgorICAgICwgQVhUZXh0UnVucwogI2VuZGlmCiA+Owog dXNpbmcgQVhQcm9wZXJ0eU1hcCA9IEhhc2hNYXA8QVhQcm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlW YWx1ZVZhcmlhbnQsIEludEhhc2g8QVhQcm9wZXJ0eU5hbWU+LCBXVEY6OlN0cm9uZ0VudW1IYXNo VHJhaXRzPEFYUHJvcGVydHlOYW1lPj47Cg== 469090 2023-12-16 14:43:38 -0800 2023-12-18 15:58:30 -0800 Patch bug-266521-20231216144338.patch text/plain 45446 tyler_w RnJvbSAwNzFjN2YyMjEwMWY5NGJhY2MxZDcyMjU2NmIzMTRlOGZkMDIwZGE2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5jcHAgfCAgMzcgKysrCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDIyNyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8IDEwOSArKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDExOCArKysrKysrKysKIC4uLi9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwICAgICB8ICAgNiArCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmggICAgICAgfCAgIDUgKwogLi4uL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwICAgICAgICAgICAgIHwgICA2ICstCiAuLi4vYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggfCAgIDIgKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5jcHAgICAgICAgICB8ICAxNyArKwogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0LmggICAgICAgICAgIHwgIDE3ICstCiAuLi4vaXNvbGF0ZWR0cmVlL0FYSXNvbGF0 ZWRUcmVlLmggICAgICAgICAgICAgfCAgIDIgKy0KIDE3IGZpbGVzIGNoYW5nZWQsIDU1MyBpbnNl cnRpb25zKCspLCAyOCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21h a2UKaW5kZXggY2M2YzRhMzFlNmQ1Li4zOTM0NGQwYzgwY2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZQpA QCAtNjUwLDcgKzY1MCw5IEBAIHNldChXZWJDb3JlX1BSSVZBVEVfRlJBTUVXT1JLX0hFQURFUlMK ICAgICBhY2Nlc3NpYmlsaXR5L0FYR2VvbWV0cnlNYW5hZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5 L0FYTG9nZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAorICAgIGFjY2Vz c2liaWxpdHkvQVhQb3NpdGlvbi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAor ICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFN0 YXRlQ2hhbmdlSW50ZW50LmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVHJlZVN0b3JlLmgKICAgICBh Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlMaXN0Qm94LmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL1NvdXJjZXMudHh0IGIvU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQKaW5kZXggZDMw MmQzMmVhNzZiLi41YmNiZjA1N2M2ODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1NvdXJj ZXMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CkBAIC01MjEsNiArNTIxLDcg QEAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5jcHAKIGFjY2Vzc2liaWxpdHkvQVhJ bWFnZS5jcHAKIGFjY2Vzc2liaWxpdHkvQVhMb2dnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYT2Jq ZWN0Q2FjaGUuY3BwCithY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBhY2Nlc3NpYmlsaXR5 L0FYVGV4dE1hcmtlci5jcHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkLmNw cAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRDZWxsLmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDdmODE4 MmYwOGFkYy4uMDNmMzIyNmZlZTM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xNzUwLDcgKzE3NTAsOSBAQAogCQk0N0Y5NDdE QjI2NTAyRjJGMDA4Nzk2OEMgLyogQmxvY2tGb3JtYXR0aW5nUXVpcmtzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0N0Y5NDdEQTI2NTAyRjJGMDA4Nzk2 OEMgLyogQmxvY2tGb3JtYXR0aW5nUXVpcmtzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDdGQTk3MDAyNjUwOTgyQjAwODQxNDE2IC8qIFRhYmxl Rm9ybWF0dGluZ0dlb21ldHJ5LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA0N0ZBOTZGRjI2NTA5ODJBMDA4NDE0MTYgLyogVGFibGVGb3JtYXR0aW5nR2Vv bWV0cnkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQk0ODIyOTcwRTI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDgyMjk3MEMyOUM4RUJDMDAwMzNB MTI2IC8qIFJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OworCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDg2MUUwQkQy QjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0ODZCOERDNzJBMDQzQzA2MDBFMDBFNzMgLyogQVhH ZW9tZXRyeU1hbmFnZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTQ4QjAyNDJB MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRleHRSdW4uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRleHRS dW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0 OEI1QkYzNzI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4QjVCRjM1MjlD QTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ4RDBFMTI5MjlGNzMyOUUw MDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVs ZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJNDkzRTVFMDkxMkQ2NDIwNTAwMDIwMDgxIC8qIFBsYXRmb3JtQ0FM YXllckNsaWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNDkzRTVFMDgxMkQ2NDIwNTAwMDIwMDgxIC8qIFBsYXRmb3JtQ0FMYXllckNsaWVudC5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC0xMDcyMCw4 ICsxMDcyMiwxMSBAQAogCQk0N0ZBOTZGRjI2NTA5ODJBMDA4NDE0MTYgLyogVGFibGVGb3JtYXR0 aW5nR2VvbWV0cnkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVGFibGVGb3Jt YXR0aW5nR2VvbWV0cnkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDgyMjk3MEIy OUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gUmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDg2MUUwQkQyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRp b24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gQVhQb3NpdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQk0ODYxRTBCRTJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBBWFBvc2l0aW9uLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJNDg2QjhEQzYyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ4NkI4REM4MkEwNDUwMEYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAv KiBBWFRleHRSdW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhUZXh0UnVuLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM1MjlDQTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5 UmVnaW9uQ29udGV4dC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBY2Nlc3Np YmlsaXR5UmVnaW9uQ29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OEI1 QkYzNjI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk0OEQwRTEyODI5RjczMjI5MDAyNjM4NTcgLyogRWxlbWVu dEFuaW1hdGlvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRWxlbWVudEFuaW1hdGlvbkNvbnRl eHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIzMTg2LDggKzIzMTkxLDExIEBA CiAJCQkJQzA0OTNFQjcyNDQ2OTlFNDAwOUFBQzgwIC8qIEFYTG9nZ2VyLmggKi8sCiAJCQkJMjk4 MUNBQUYxMzE4MjJFQzAwRDEyRjJBIC8qIEFYT2JqZWN0Q2FjaGUuY3BwICovLAogCQkJCTI5QTgx MjFBMEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmggKi8sCisJCQkJNDg2MUUwQkUy QjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovLAorCQkJCTQ4NjFFMEJEMkIyMDA3 NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi8sCiAJCQkJQzBFMjA4QTEyOTM3OUM2RjAwQzBE MkQzIC8qIEFYVGV4dE1hcmtlci5jcHAgKi8sCiAJCQkJQzBFMjA4QTAyOTM3OUM2RTAwQzBEMkQz IC8qIEFYVGV4dE1hcmtlci5oICovLAorCQkJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBB WFRleHRSdW4uaCAqLywKIAkJCQk5MUM5RjJGODFBRTNCRTI0MDA5NUI2MUMgLyogQVhUZXh0U3Rh dGVDaGFuZ2VJbnRlbnQuaCAqLywKIAkJCQlDMEU4QURDNDI5NEI1QTYyMDA3NkNCREMgLyogQVhU cmVlU3RvcmUuaCAqLywKIAkJCQlCQzRBNTMzMDI1NjA1OTAzMDAyOEM1OTIgLyogRm9yY2VkQWNj ZXNzaWJpbGl0eVZhbHVlLmggKi8sCkBAIC0zNzU3Nyw3ICszNzU4NSw5IEBACiAJCQkJMjlBRTIx MzUyMUFCQTQ4QTAwODY5MjgzIC8qIEFYSXNvbGF0ZWRPYmplY3QuaCBpbiBIZWFkZXJzICovLAog CQkJCTI5QUUyMTJEMjFBQjlFRUIwMDg2OTI4MyAvKiBBWElzb2xhdGVkVHJlZS5oIGluIEhlYWRl cnMgKi8sCiAJCQkJMjlBODEyMzgwRkJCOUMxRDAwNTEwMjkzIC8qIEFYT2JqZWN0Q2FjaGUuaCBp biBIZWFkZXJzICovLAorCQkJCTQ4NjFFMEJGMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9u LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEUyMDhBMjI5Mzc5QzZGMDBDMEQyRDMgLyogQVhUZXh0 TWFya2VyLmggaW4gSGVhZGVycyAqLywKKwkJCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLywKIAkJCQk5MUM5RjJGOTFBRTNCRUIwMDA5NUI2MUMg LyogQVhUZXh0U3RhdGVDaGFuZ2VJbnRlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUMwRThBREM1 Mjk0QjVBNjMwMDc2Q0JEQyAvKiBBWFRyZWVTdG9yZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQ3 N0U3NzcwQkY0MTM0QTAwMTUyODcyIC8qIEJhY2tGb3J3YXJkQ2FjaGUuaCBpbiBIZWFkZXJzICov LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3Qu Y3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuY3BwCmluZGV4 IGE2MDYzZGZkZjBkMy4uYjk3OTllNzFmN2I3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWENvcmVPYmplY3QuY3BwCkBAIC0zODksNiArMzg5LDQzIEBAIEFYQ29yZU9iamVj dDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIEFYQ29yZU9iamVjdDo6c2VsZWN0ZWRDZWxs cygpCiAgICAgcmV0dXJuIHNlbGVjdGVkQ2VsbHM7CiB9CiAKK0FYQ29yZU9iamVjdCogQVhDb3Jl T2JqZWN0OjpwcmV2aW91c1NpYmxpbmcoKQoreworICAgIFJlZlB0ciBwYXJlbnQgPSBwYXJlbnRP YmplY3RVbmlnbm9yZWQoKTsKKyAgICBjb25zdCBhdXRvJiBzaWJsaW5ncyA9IHBhcmVudC0+Y2hp bGRyZW4oKTsKKyAgICBzaXplX3QgaW5kZXhPZlRoaXMgPSBzaWJsaW5ncy5maW5kKHRoaXMpOwor ICAgIGlmIChpbmRleE9mVGhpcyA9PSBub3RGb3VuZCkgeworICAgICAgICAvLyBUaGUgb25seSBy ZWFzb24gd2Ugd291bGRuJ3QgYmUgaW4gb3VyIHBhcmVudCdzIGNoaWxkcmVuKCkgaXMgaWYgd2Ug YXJlIGlnbm9yZWQgKGJlY2F1c2UgaWdub3JlZCBvYmplY3RzIGRvIG5vdCBiZWNvbWUKKyAgICAg ICAgLy8gcGFydCBvZiBjaGlsZHJlbigpKS4gQW55dGhpbmcgZWxzZSBsaWtlbHkgaW5kaWNhdGVz IGEgcGFyZW50LWNoaWxkIGhpZXJhcmNoeSBtaXNtYXRjaC4KKyAgICAgICAgQVNTRVJUKGFjY2Vz c2liaWxpdHlJc0lnbm9yZWQoKSk7CisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KKyAg ICBpZiAoIWluZGV4T2ZUaGlzKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICBBU1NFUlQo c2libGluZ3NbaW5kZXhPZlRoaXMgLSAxXSk7CisgICAgcmV0dXJuIHNpYmxpbmdzW2luZGV4T2ZU aGlzIC0gMV0uZ2V0KCk7Cit9CisKK0FYQ29yZU9iamVjdCogQVhDb3JlT2JqZWN0OjpuZXh0U2li bGluZygpCit7CisgICAgUmVmUHRyIHBhcmVudCA9IHBhcmVudE9iamVjdFVuaWdub3JlZCgpOwor ICAgIGNvbnN0IGF1dG8mIHNpYmxpbmdzID0gcGFyZW50LT5jaGlsZHJlbigpOworICAgIHNpemVf dCBpbmRleE9mVGhpcyA9IHNpYmxpbmdzLmZpbmQodGhpcyk7CisgICAgaWYgKGluZGV4T2ZUaGlz ID09IG5vdEZvdW5kKSB7CisgICAgICAgIC8vIFRoZSBvbmx5IHJlYXNvbiB3ZSB3b3VsZG4ndCBi ZSBpbiBvdXIgcGFyZW50J3MgY2hpbGRyZW4oKSBpcyBpZiB3ZSBhcmUgaWdub3JlZCAoYmVjYXVz ZSBpZ25vcmVkIG9iamVjdHMgZG8gbm90IGJlY29tZQorICAgICAgICAvLyBwYXJ0IG9mIGNoaWxk cmVuKCkpLiBBbnl0aGluZyBlbHNlIGxpa2VseSBpbmRpY2F0ZXMgYSBwYXJlbnQtY2hpbGQgaGll cmFyY2h5IG1pc21hdGNoLgorICAgICAgICBBU1NFUlQoYWNjZXNzaWJpbGl0eUlzSWdub3JlZCgp KTsKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgfQorCisgICAgZm9yICh1bnNpZ25lZCBp ID0gaW5kZXhPZlRoaXMgKyAxOyBpIDwgc2libGluZ3Muc2l6ZSgpOyBpKyspIHsKKyAgICAgICAg QVNTRVJUKHNpYmxpbmdzW2ldKTsKKyAgICAgICAgaWYgKHNpYmxpbmdzW2ldKQorICAgICAgICAg ICAgcmV0dXJuIHNpYmxpbmdzW2ldLmdldCgpOworICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsK K30KKwogI2lmIFBMQVRGT1JNKENPQ09BKQogc3RhdGljIGJvb2wgaXNWaXNpYmxlVGV4dChBY2Nl c3NpYmlsaXR5VGV4dFNvdXJjZSB0ZXh0U291cmNlKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhDb3JlT2JqZWN0LmgKaW5kZXggMTAxMTRlY2I2ZGQ4Li5lM2IwNmIwNmY4N2Qg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgK KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaApAQCAtMTEw LDE5ICsxMTAsNiBAQCBlbnVtIGNsYXNzIEFYQW5jZXN0b3JGbGFnIDogdWludDhfdCB7CiAgICAg Ly8gQml0cyA2IGFuZCA3IGFyZSBmcmVlLgogfTsKIAotI2lmIEVOQUJMRShBWF9USFJFQURfVEVY VF9BUElTKQotc3RydWN0IEFYVGV4dFJ1biB7Ci0gICAgLy8gVGhlIGxpbmUgaW5kZXggb2YgdGhp cyBydW4gd2l0aGluIHRoZSBjb250ZXh0IG9mIHRoZSBjb250YWluaW5nIFJlbmRlckJsb2NrRmxv dyBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0LgotICAgIHNpemVfdCBsaW5lSW5kZXg7Ci0g ICAgU3RyaW5nIHRleHQ7Ci0KLSAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5n JiYgdGV4dCkKLSAgICAgICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQotICAgICAgICAsIHRleHQo V1RGTW92ZSh0ZXh0KSkKLSAgICB7IH0KLX07Ci0jZW5kaWYKLQogZW51bSBjbGFzcyBBY2Nlc3Np YmlsaXR5Um9sZSB7CiAgICAgQXBwbGljYXRpb24gPSAxLAogICAgIEFwcGxpY2F0aW9uQWxlcnQs CkBAIC04MDAsNiArNzg3LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElE IGF4SUQpIHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1 cm4gbV9pZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmly dHVhbCBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUg Y29ycmVzcG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QK QEAgLTExMDQsOSArMTA5Miw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJp bGl0eVRleHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBB IHByb2dyYW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0Lgog ICAgIHZpcnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAw OwotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFY VGV4dFJ1bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVh bCBTdHJpbmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRp b24oKSBjb25zdCA9IDA7CkBAIC0xMjI3LDYgKzEyMTIsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKGJvb2wgdXBkYXRl Q2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpID0gMDsKICAgICBWZWN0b3I8QVhJRD4gY2hpbGRyZW5J RHMoYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVjZXNzYXJ5ID0gdHJ1ZSk7CiAgICAgdmlydHVhbCB2 b2lkIHVwZGF0ZUNoaWxkcmVuSWZOZWNlc3NhcnkoKSA9IDA7CisgICAgQVhDb3JlT2JqZWN0KiBw cmV2aW91c1NpYmxpbmcoKTsKKyAgICBBWENvcmVPYmplY3QqIG5leHRTaWJsaW5nKCk7CiAgICAg dmlydHVhbCB2b2lkIGRldGFjaEZyb21QYXJlbnQoKSA9IDA7CiAgICAgdmlydHVhbCBib29sIGlz RGV0YWNoZWRGcm9tUGFyZW50KCkgPSAwOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BWFBvc2l0aW9uLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAu LjJjNmU2ZDE5MGY3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhQb3NpdGlvbi5jcHAKQEAgLTAsMCArMSwyMjcgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJV VE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMg Q09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFY X1RIUkVBRF9URVhUX0FQSVMpCisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9U UkVFKQorI2luY2x1ZGUgIkFYSXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRlICJBWElzb2xhdGVk VHJlZS5oIgorI2VuZGlmIC8vIEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCisj aW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0FYSXNv bGF0ZWRPYmplY3QqIEFYUG9zaXRpb246Om9iamVjdCgpIGNvbnN0Cit7CisgICAgUkVMRUFTRV9B U1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVy biBudWxscHRyOworCisgICAgaWYgKG1fY2FjaGVkT2JqZWN0KQorICAgICAgICByZXR1cm4gbV9j YWNoZWRPYmplY3QuZ2V0KCk7CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9U UkVFKQorICAgIGF1dG8gdHJlZSA9IHN0ZDo6Z2V0PFJlZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4 VHJlZUZvcklEKHRyZWVJRCgpKSk7CisgICAgbV9jYWNoZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+ b2JqZWN0Rm9ySUQob2JqZWN0SUQoKSkgOiBudWxscHRyOworICAgIHJldHVybiBtX2NhY2hlZE9i amVjdC5nZXQoKTsKKyNlbmRpZgorfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZyb21UZXh0 TWFya2VyKGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyKQoreworICAgIHJldHVybiBBWFBvc2l0 aW9uKG1hcmtlci50cmVlSUQoKSwgbWFya2VyLm9iamVjdElEKCksIG1hcmtlci5vZmZzZXQoKSAp OworfQorCitBWFBvc2l0aW9uOjpvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdAoreworICAg IHJldHVybiB7IHsgdHJlZUlEKCksIG9iamVjdElEKCksIG51bGxwdHIsIG1fb2Zmc2V0IH0gfTsK K30KKworU3RyaW5nIEFYUG9zaXRpb246OmRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAg IGF1dG8gc2VwYXJhdG9yID0gIiwgIjsKKyAgICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+b2JqZWN0 KCk7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoCisgICAgICAgICJ0cmVlSUQgIiwgdHJlZUlEKCku bG9nZ2luZ1N0cmluZygpCisgICAgICAgICwgc2VwYXJhdG9yLCAib2JqZWN0SUQgIiwgb2JqZWN0 SUQoKS5sb2dnaW5nU3RyaW5nKCkKKyAgICAgICAgLCBzZXBhcmF0b3IsICJyb2xlICIsIG9iamVj dCA/IGFjY2Vzc2liaWxpdHlSb2xlVG9TdHJpbmcob2JqZWN0LT5yb2xlVmFsdWUoKSkgOiBTdHJp bmcoIm5vIG9iamVjdCJfcykKKyAgICAgICAgLCBzZXBhcmF0b3IsICJvZmZzZXQgIiwgbV9vZmZz ZXQKKyAgICApOworfQorCitlbnVtIGNsYXNzIENoZWNrU3RhcnQgOiBib29sIHsgTm8sIFllcyB9 OworLy8gRmluZHMgdGhlIG5leHQgb2JqZWN0IHdpdGggdGV4dCBydW5zIGluIHRoZSBnaXZlbiBk aXJlY3Rpb24uCitzdGF0aWMgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZpbmRPYmplY3RXaXRo UnVucyhBWElzb2xhdGVkT2JqZWN0JiBzdGFydCwgQVhEaXJlY3Rpb24gZGlyZWN0aW9uLCBDaGVj a1N0YXJ0IGNoZWNrU3RhcnQgPSBDaGVja1N0YXJ0OjpObykKK3sKKyAgICBpZiAoY2hlY2tTdGFy dCA9PSBDaGVja1N0YXJ0OjpZZXMpIHsKKyAgICAgICAgaWYgKGF1dG8qIHJ1bnMgPSBzdGFydC50 ZXh0UnVucygpOyBydW5zICYmIHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgIHJldHVybiAmc3Rh cnQ7CisgICAgfQorCisgICAgUmVmUHRyIGN1cnJlbnQgPSAmc3RhcnQ7CisgICAgd2hpbGUgKGN1 cnJlbnQpIHsKKyAgICAgICAgaWYgKGN1cnJlbnQgIT0gJnN0YXJ0KSB7CisgICAgICAgICAgICBh dXRvKiBydW5zID0gY3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgICAgIGlmIChydW5zICYm IHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAg fQorCisgICAgICAgIC8vIEZJWE1FOiBhcmlhLW93bnMgYnJlYWtzIHRoaXMgdHJhdmVyc2FsLCBh cyBhcmlhLW93bnMgY2F1c2VzIHRoZSBBWCB0cmVlIHRvIGJlIGNoYW5nZWQsIGFmZmVjdGluZwor ICAgICAgICAvLyBvdXIgaXRlcmF0aW9uIGJlbG93LCBidXQgaXQgZG9lc24ndCBhY3R1YWxseSBj aGFuZ2UgdGV4dCBwb3NpdGlvbiBvbiB0aGUgcGFnZS4gU28gd2UgbmVlZCB0byBpZ25vcmUgYXJp YS1vd25zCisgICAgICAgIC8vIHRyZWUgY2hhbmdlcyBoZXJlIGluIG9yZGVyIHRvIGJlaGF2ZSBj b3JyZWN0bHkuCisgICAgICAgIC8vIFdlIGFsc28gcHJvYmFibHkgbmVlZCB0byBkbyBzb21ldGhp bmcgYWJvdXQgdGV4dCB3aXRoaW4gYXJpYS1oaWRkZW4gY29udGFpbmVycywgd2hpY2ggYWZmZWN0 cyB0aGUgQVggdHJlZS4KKworICAgICAgICBjb25zdCBhdXRvJiBjaGlsZHJlbiA9IGN1cnJlbnQt PmNoaWxkcmVuKCk7CisgICAgICAgIGlmIChjaGlsZHJlbi5zaXplKCkpIHsKKyAgICAgICAgICAg IHNpemVfdCBjaGlsZEluZGV4ID0gZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6 IGNoaWxkcmVuLnNpemUoKSAtIDE7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjaGlsZHJl bltjaGlsZEluZGV4XSk7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFY SXNvbGF0ZWRPYmplY3Q+KGNoaWxkcmVuW2NoaWxkSW5kZXhdLmdldCgpKTsKKyAgICAgICAgICAg IGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gYGN1cnJlbnRgIGhhcyBubyBjaGls ZHJlbiwgbWVhbmluZyBpdCdzIGEgbGVhZiBub2RlIChlLmcuIGl0J3MgdGV4dCwgd2hpY2ggY2Fu bm90IGhhdmUgY2hpbGRyZW4pLgorICAgICAgICAvLyBDaGVjayBgY3VycmVudGBzIHNpYmxpbmdz LgorICAgICAgICBpZiAoYXV0byogc2libGluZyA9IGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6 TmV4dCA/IGN1cnJlbnQtPm5leHRTaWJsaW5nKCkgOiBjdXJyZW50LT5wcmV2aW91c1NpYmxpbmco KSkgeworICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2Jq ZWN0PihzaWJsaW5nKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAg ICAgLy8gV2UgaGF2ZSBubyBjaGlsZHJlbiwgYW5kIG5vIG5leHQvcHJldmlvdXMgc2libGluZy4g VHJ5IG91ciBwYXJlbnQncyBzaWJsaW5nLgorICAgICAgICBpZiAoYXV0byogcGFyZW50ID0gY3Vy cmVudC0+cGFyZW50T2JqZWN0VW5pZ25vcmVkKCkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBk eW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oZGlyZWN0aW9uID09IEFYRGlyZWN0aW9u OjpOZXh0ID8gcGFyZW50LT5uZXh0U2libGluZygpIDogcGFyZW50LT5wcmV2aW91c1NpYmxpbmco KSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGJyZWFrOwor ICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsKK30KKworQVhQb3NpdGlvbiBBWFBvc2l0aW9uOjpm aW5kUG9zaXRpb24oQVhEaXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIGlmICghb2Jq ZWN0KCkpCisgICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKKyAgICBhdXRvIHJ1bkZyb21P ZmZzZXQgPSB0aGlzLT5ydW5Gcm9tT2Zmc2V0KCk7CisgICAgY29uc3QgYXV0byogcnVucyA9IHJ1 bkZyb21PZmZzZXQub2JqZWN0LT50ZXh0UnVucygpOworCisgICAgYXV0byBoYXNNb3JlVGV4dElu Q3VycmVudFJ1biA9IFsmLCB0aGlzXSB7CisgICAgICAgIGlmIChkaXJlY3Rpb24gPT0gQVhEaXJl Y3Rpb246Ok5leHQpCisgICAgICAgICAgICByZXR1cm4gbV9vZmZzZXQgPCBydW5Gcm9tT2Zmc2V0 LnJ1bigpLnRleHQubGVuZ3RoKCk7CisgICAgICAgIHJldHVybiBtX29mZnNldCA+IDA7CisgICAg fTsKKyAgICBib29sIGhhc0Fub3RoZXJSdW4gPSBydW5Gcm9tT2Zmc2V0LmluZGV4ICsgMSA8IHJ1 bnMtPnNpemUoKTsKKyAgICAvLyBUaGUgbmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRl eHQsIGJlY2F1c2Ugd2UncmUgZ29pbmcgdG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBt X29mZnNldCArIDEsIHdoaWNoIHdvdWxkIGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRp cmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVu cy0+cnVuTGVuZ3RoKHJ1bkZyb21PZmZzZXQuaW5kZXggKyAxKSA+IDApOworICAgIC8vIENoZWNr aW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5vdGhlciBydW4gaXMgb25seSByZWxldmFudCBmb3Ig bW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBhcyBqdXN0IGNoZWNraW5nIHRoYXQgbV9vZmZzZXQg PiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGlyZWN0aW9uOjpQcmV2aW91cy4KKyAgICBpZiAoaGFz TW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0 ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAgICAgIC8vIFJldHVybiBhbiBvZmZzZXQgdG8gdGhl IG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgcmV0dXJuIEFYUG9z aXRpb24ocnVuRnJvbU9mZnNldC50cmVlSUQoKSwgcnVuRnJvbU9mZnNldC5vYmplY3RJRCgpLCBk aXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5leHQgPyBtX29mZnNldCArIDEgOiBtX29mZnNldCAt IDEpOworICAgIH0KKyAgICAvLyBtX29mZnNldCBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3Rl ciBpbiB0aGUgZ2l2ZW4gb2JqZWN0J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0 aGUgbmV4dCBvYmplY3Qgd2l0aCBydW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9i amVjdFdpdGhSdW5zKHJ1bkZyb21PZmZzZXQub2JqZWN0LmdldCgpLCBkaXJlY3Rpb24pKQorICAg ICAgICByZXR1cm4gQVhQb3NpdGlvbihvYmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElE KCksIGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5z KCktPmxhc3RSdW5MZW5ndGgoKSk7CisKKyAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7Cit9CisK K0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uIGRpcmVjdGlv biwgQVhUZXh0VW5pdCB0ZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5IGJvdW5kYXJ5KSBjb25z dAoreworICAgIGlmICghb2JqZWN0KCkpCisgICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsK KworICAgIGlmICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7CisgICAgICAgIGF1dG8g cnVuRnJvbU9mZnNldCA9IHRoaXMtPnJ1bkZyb21PZmZzZXQoKTsKKyAgICAgICAgUmVmUHRyIGN1 cnJlbnRPYmplY3QgPSBXVEZNb3ZlKHJ1bkZyb21PZmZzZXQub2JqZWN0KTsKKyAgICAgICAgY29u c3QgYXV0byogY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0UnVucygpOworCisgICAg ICAgIGF1dG8gY29tcHV0ZU9mZnNldCA9IFsmXSAoc2l6ZV90IHJ1bkVuZE9mZnNldCwgc2l6ZV90 IHJ1bkxlbmd0aCkgeworICAgICAgICAgICAgLy8gVGhpcyB3b3JrcyBiZWNhdXNlIGBydW5FbmRP ZmZzZXRgIGlzIHRoZSBvZmZzZXQgcG9pbnRpbmcgdG8gdGhlIGVuZCBvZiB0aGUgZ2l2ZW4gcnVu LCB3aGljaCBpbmNsdWRlcyB0aGUgbGVuZ3RoIG9mIGFsbCBydW5zIHByZWNlZGluZyBpdC4gU28g c3VidHJhY3RpbmcgdGhhdCBmcm9tIHRoZSBsZW5ndGggb2YgdGhlIGN1cnJlbnQgcnVuIGdpdmVz IHVzIGFuIG9mZnNldCB0byB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgcnVuLgorICAgICAgICAg ICAgcmV0dXJuIGJvdW5kYXJ5ID09IEFYVGV4dFVuaXRCb3VuZGFyeTo6RW5kID8gcnVuRW5kT2Zm c2V0IDogcnVuRW5kT2Zmc2V0IC0gcnVuTGVuZ3RoOworICAgICAgICB9OworICAgICAgICBhdXRv IGxpbmVQb3NpdGlvbiA9IEFYUG9zaXRpb24oY3VycmVudE9iamVjdC0+dHJlZUlEKCksIGN1cnJl bnRPYmplY3QtPm9iamVjdElEKCksIGNvbXB1dGVPZmZzZXQocnVuRnJvbU9mZnNldC5ydW5MZW5n dGhTdW0sIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgocnVuRnJvbU9mZnNldC5pbmRleCkpKTsKKyAg ICAgICAgYXV0byBzdGFydExpbmVJRCA9IGN1cnJlbnRSdW5zLT5saW5lSUQocnVuRnJvbU9mZnNl dC5pbmRleCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0 ZWQgbGluZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAg ICAgIHdoaWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChj dXJyZW50UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZz ZXQgPSAwOworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+ c2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJl bnRSdW5zLT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5s aW5lSUQoaSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5l UG9zaXRpb247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihjdXJy ZW50T2JqZWN0LT50cmVlSUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29tcHV0ZU9m ZnNldChjdW11bGF0aXZlT2Zmc2V0LCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkpKSk7CisgICAg ICAgICAgICB9CisgICAgICAgICAgICBjdXJyZW50T2JqZWN0ID0gZmluZE9iamVjdFdpdGhSdW5z KCpjdXJyZW50T2JqZWN0LCBkaXJlY3Rpb24pOworICAgICAgICAgICAgaWYgKGN1cnJlbnRPYmpl Y3QpCisgICAgICAgICAgICAgICAgY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0UnVu cygpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAgfQorICAg IHJldHVybiBudWxsUG9zaXRpb24oKTsKK30KKworUnVuRnJvbU9mZnNldCBBWFBvc2l0aW9uOjpy dW5Gcm9tT2Zmc2V0KCkgY29uc3QKK3sKKyAgICBzaXplX3QgY3VtdWxhdGl2ZU9mZnNldCA9IDA7 CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKm9iamVjdCgpLCBBWERp cmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAgICAvLyBJbmRleCBvZiB0aGUgcnVu IHdlIHN0YXJ0IGF0IGJhc2VkIG9uIG1fb2Zmc2V0LgorICAgIHNpemVfdCBzdGFydFJ1bkluZGV4 ID0gbm90Rm91bmQ7CisgICAgd2hpbGUgKGN1cnJlbnQgJiYgc3RhcnRSdW5JbmRleCA9PSBub3RG b3VuZCkgeworICAgICAgICBhdXRvJiBjdXJyZW50UnVucyA9ICpjdXJyZW50LT50ZXh0UnVucygp OworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY3VycmVudFJ1bnMuc2l6ZSgpOyBp KyspIHsKKyAgICAgICAgICAgIGN1bXVsYXRpdmVPZmZzZXQgKz0gY3VycmVudFJ1bnMucnVuTGVu Z3RoKGkpOworICAgICAgICAgICAgaWYgKGN1bXVsYXRpdmVPZmZzZXQgPj0gbV9vZmZzZXQpIHsK KyAgICAgICAgICAgICAgICBzdGFydFJ1bkluZGV4ID0gaTsKKyAgICAgICAgICAgICAgICBicmVh azsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIGlmIChzdGFydFJ1bkluZGV4 ICE9IG5vdEZvdW5kKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGN1cnJlbnQgPSBmaW5k T2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnQsIEFYRGlyZWN0aW9uOjpOZXh0KTsKKyAgICB9CisKKyAg ICBpZiAoc3RhcnRSdW5JbmRleCA9PSBub3RGb3VuZCkgeworICAgICAgICAvLyBGSVhNRTogTm90 IHN1cmUgaG93IHRoaXMgY291bGQgaGFwcGVuLCBidXQgd2UgbWF5IG5lZWQgdG8gaGFuZGxlIGl0 IHNvbWVob3c/CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor ICAgIHJldHVybiB7ICpjdXJyZW50LCBzdGFydFJ1bkluZGV4LCBjdW11bGF0aXZlT2Zmc2V0IH07 Cit9CisKK0FYVGV4dE1hcmtlclJhbmdlIEFYUG9zaXRpb246OmxpbmVSYW5nZShMaW5lUmFuZ2VU eXBlIHR5cGUpIGNvbnN0Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHsg bnVsbFBvc2l0aW9uKCksIG51bGxQb3NpdGlvbigpIH07CisKKyAgICBpZiAodHlwZSA9PSBMaW5l UmFuZ2VUeXBlOjpDdXJyZW50KQorICAgICAgICByZXR1cm4geyBmaW5kUG9zaXRpb24oQVhEaXJl Y3Rpb246OlByZXZpb3VzLCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6OlN0 YXJ0KSwgZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpOZXh0LCBBWFRleHRVbml0OjpMaW5lLCBB WFRleHRVbml0Qm91bmRhcnk6OkVuZCkgfTsKKyAgICAvLyBUaGUgb3RoZXIgdHlwZXMgYXJlbid0 IGltcGxlbWVudGVkIHlldC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhU X0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRp b24uaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZWE2YWMyZjNkNGY3Ci0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKQEAgLTAs MCArMSwxMDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQorI2luY2x1ZGUgIkFYSXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRl ICJBWFRleHRNYXJrZXIuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitlbnVtIGNsYXNzIEFY RGlyZWN0aW9uIDogYm9vbCB7IE5leHQsIFByZXZpb3VzIH07CisKK2VudW0gY2xhc3MgQVhUZXh0 VW5pdCA6IHVpbnQ4X3QgeworICAgIExpbmUsCisgICAgUGFyYWdyYXBoLAorICAgIFNlbnRlbmNl LAorICAgIFdvcmQsCit9OworZW51bSBjbGFzcyBBWFRleHRVbml0Qm91bmRhcnkgOiBib29sIHsg U3RhcnQsIEVuZCwgfTsKKworZW51bSBjbGFzcyBMaW5lUmFuZ2VUeXBlIDogdWludDhfdCB7Cisg ICAgQ3VycmVudCwKKyAgICBMZWZ0LAorICAgIFJpZ2h0LAorfTsKKworc3RydWN0IFJ1bkZyb21P ZmZzZXQgeworICAgIC8vIFRoZSBsZWFmIG5vZGUgd2l0aCBydW5zIHBvaW50ZWQgdG8gYnkgdGhl IG9mZnNldCB1c2VkIHRvIGNvbXB1dGUgdGhpcyBzdHJ1Y3QuCisgICAgUmVmPEFYSXNvbGF0ZWRP YmplY3Q+IG9iamVjdDsKKyAgICAvLyBSdW4gaW5kZXggcG9pbnRlZCB0byBieSB0aGUgb2Zmc2V0 IHVzZWQgdG8gY29tcHV0ZSB0aGlzIHN0cnVjdC4KKyAgICBzaXplX3QgaW5kZXggeyAwIH07Cisg ICAgLy8gVGhlIHN1bSBvZiB0aGUgdGV4dCBmcm9tIHJ1bnMgcHJpb3IgdG8gYW5kIGluY2x1ZGlu ZyBvYmplY3QtPnRleHRSdW5zW2luZGV4XS4KKyAgICBzaXplX3QgcnVuTGVuZ3RoU3VtOworCisg ICAgQVhJRCB0cmVlSUQoKSBjb25zdCB7IHJldHVybiBvYmplY3QtPnRyZWVJRCgpOyB9CisgICAg QVhJRCBvYmplY3RJRCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdC0+b2JqZWN0SUQoKTsgfQorICAg IGNvbnN0IEFYVGV4dFJ1biYgcnVuKCkgY29uc3QgeyByZXR1cm4gKCpvYmplY3QtPnRleHRSdW5z KCkpW2luZGV4XTsgfQorCisgICAgUnVuRnJvbU9mZnNldChBWElzb2xhdGVkT2JqZWN0JiBvYmpl Y3QsIHNpemVfdCBydW5JbmRleCwgc2l6ZV90IHJ1bkxlbmd0aFN1bSkKKyAgICAgICAgOiBvYmpl Y3Qob2JqZWN0KQorICAgICAgICAsIGluZGV4KHJ1bkluZGV4KQorICAgICAgICAsIHJ1bkxlbmd0 aFN1bShydW5MZW5ndGhTdW0pCisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChydW5JbmRl eCA8IG9iamVjdC50ZXh0UnVucygpLT5zaXplKCkpOworICAgIH0KK307CisKK2NsYXNzIEFYUG9z aXRpb24geworcHVibGljOgorICAgIGV4cGxpY2l0IEFYUG9zaXRpb24oQVhJRCB0cmVlSUQsIEFY SUQgb2JqZWN0SUQsIHVuc2lnbmVkIG9mZnNldCkKKyAgICAgICAgOiBtX3RyZWVJRCh0cmVlSUQp CisgICAgICAgICwgbV9vYmplY3RJRChvYmplY3RJRCkKKyAgICAgICAgLCBtX29mZnNldChvZmZz ZXQpCisgICAgeyB9CisgICAgc3RhdGljIEFYUG9zaXRpb24gbnVsbFBvc2l0aW9uKCkgeyByZXR1 cm4gQVhQb3NpdGlvbihBWElEKCksIEFYSUQoKSwgMCk7IH0KKyAgICBzdGF0aWMgQVhQb3NpdGlv biBmcm9tVGV4dE1hcmtlcihjb25zdCBBWFRleHRNYXJrZXImKTsKKyAgICBvcGVyYXRvciBBWFRl eHRNYXJrZXIoKSBjb25zdDsKKworICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgeyByZXR1cm4gbV90 cmVlSUQ7IH0KKyAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9vYmplY3RJRDsg fQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNvbnN0IHsgcmV0dXJuIG1fb2Zmc2V0OyB9CisKKyAg ICBBWElzb2xhdGVkT2JqZWN0KiBvYmplY3QoKSBjb25zdDsKKyAgICBib29sIGlzTnVsbCgpIGNv bnN0IHsgcmV0dXJuICF0cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElEKCkuaXNWYWxpZCgp OyB9CisKKyAgICAvLyBGaW5kIHRoZSBuZXh0IG9yIHByZXZpb3VzIHBvc2l0aW9uLgorICAgIEFY UG9zaXRpb24gZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uKSBjb25zdDsKKyAgICAvLyBTdGFydGlu ZyBmcm9tIHRoaXMgcG9zaXRpb24sIGNyZWF0ZXMgYSBuZXcgcG9zaXRpb24gZm9yIHRoZSBnaXZl biBkaXJlY3Rpb24gYW5kIHRleHQgdW5pdCB0eXBlLgorICAgIEFYUG9zaXRpb24gZmluZFBvc2l0 aW9uKEFYRGlyZWN0aW9uLCBBWFRleHRVbml0LCBBWFRleHRVbml0Qm91bmRhcnkpIGNvbnN0Owor ICAgIEFYVGV4dE1hcmtlclJhbmdlIGxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlKSBjb25zdDsKKwor ICAgIC8vIEdldHMgdGhlIHJ1biBwb2ludGVkIHRvIGJ5IG1fb2Zmc2V0IChhbmQgc29tZSBhc3Nv Y2lhdGVkIGluZm9ybWF0aW9uKS4KKyAgICBSdW5Gcm9tT2Zmc2V0IHJ1bkZyb21PZmZzZXQoKSBj b25zdDsKKworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3Q7CisKK3ByaXZhdGU6 CisgICAgQVhJRCBtX3RyZWVJRDsKKyAgICBBWElEIG1fb2JqZWN0SUQ7CisgICAgdW5zaWduZWQg bV9vZmZzZXQgeyAwIH07CisKKyAgICBtdXRhYmxlIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBt X2NhY2hlZE9iamVjdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBF TkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhUZXh0TWFya2VyLmNwcAppbmRleCA5YWQ2YWJmOTNhYWMuLmQyZDQzM2JjYmIxYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMzM1 LDcgKzMzNSw3IEBAIHN0ZDo6b3B0aW9uYWw8QVhUZXh0TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtl clJhbmdlOjppbnRlcnNlY3Rpb25XaXRoKGNvbnN0IEFYVGV4CiAKIFN0cmluZyBBWFRleHRNYXJr ZXJSYW5nZTo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJp bmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBt X2VuZC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9Iik7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0 YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5k LmRlYnVnRGVzY3JpcHRpb24oKSwgIn0iKTsKIH0KIAogc3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBh cnRpYWxPcmRlcihjb25zdCBBWFRleHRNYXJrZXImIG1hcmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtl ciYgbWFya2VyMikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5o CmluZGV4IDE3ZTlmYzBkYWI5OC4uNTlmNGYzNzk2MzE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKQEAgLTEyMyw2ICsxMjMsNyBAQCBwdWJsaWM6CiAK ICAgICBBWElEIHRyZWVJRCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5heFRyZWVJRCgpOyB9CiAg ICAgQVhJRCBvYmplY3RJRCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5heE9iamVjdElEKCk7IH0K KyAgICB1bnNpZ25lZCBvZmZzZXQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEub2Zmc2V0OyB9CiAg ICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhdHJlZUlEKCkuaXNWYWxpZCgpIHx8ICFv YmplY3RJRCgpLmlzVmFsaWQoKTsgfQogICAgIFJlZlB0cjxBWENvcmVPYmplY3Q+IG9iamVjdCgp IGNvbnN0OwogICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdCgpOyB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAuLmFlODdhMDVlYTE0MQotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKQEAgLTAsMCArMSwxMTggQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5D LiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9B UElTKQorbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBSZW5kZXJCbG9jazsKKworc3RydWN0 IEFYVGV4dFJ1bkxpbmVJRCB7CisgICAgdm9pZCogY29udGFpbmluZ0Jsb2NrIHsgbnVsbHB0ciB9 OworICAgIHNpemVfdCBsaW5lSW5kZXggeyAwIH07CisKKyAgICBBWFRleHRSdW5MaW5lSUQodm9p ZCogY29udGFpbmluZ0Jsb2NrLCBzaXplX3QgbGluZUluZGV4KQorICAgICAgICA6IGNvbnRhaW5p bmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgbGluZUluZGV4KGxpbmVJbmRleCkK KyAgICB7IH0KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQVhUZXh0UnVuTGluZUlEJikgY29u c3QgPSBkZWZhdWx0OworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKKyAgICB7 CisgICAgICAgIFRleHRTdHJlYW0gc3RyZWFtOworICAgICAgICBzdHJlYW0gPDwgIkxpbmVJRCAi IDw8IGNvbnRhaW5pbmdCbG9jayA8PCAiICIgPDwgbGluZUluZGV4OworICAgICAgICByZXR1cm4g c3RyZWFtLnJlbGVhc2UoKTsKKyAgICB9Cit9OworCitzdHJ1Y3QgQVhUZXh0UnVuIHsKKyAgICAv LyBUaGUgbGluZSBpbmRleCBvZiB0aGlzIHJ1biB3aXRoaW4gdGhlIGNvbnRleHQgb2YgdGhlIGNv bnRhaW5pbmcgUmVuZGVyQmxvY2sgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4KKyAgICBz aXplX3QgbGluZUluZGV4OworICAgIFN0cmluZyB0ZXh0OworCisgICAgQVhUZXh0UnVuKHNpemVf dCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCisgICAgICAgIDogbGluZUluZGV4KGxpbmVJbmRl eCkKKyAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCisgICAgeyB9CisKKyAgICBTdHJpbmcg ZGVidWdEZXNjcmlwdGlvbih2b2lkKiBjb250YWluaW5nQmxvY2spIGNvbnN0CisgICAgeworICAg ICAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEID0geyBjb250YWluaW5nQmxvY2ssIGxpbmVJbmRl eCB9OworICAgICAgICByZXR1cm4gbWFrZVN0cmluZyhsaW5lSUQuZGVidWdEZXNjcmlwdGlvbigp LCAiOiB8IiwgbWFrZVN0cmluZ0J5UmVwbGFjaW5nQWxsKHRleHQsICdcbicsICJ7bmV3bGluZX0i X3MpLCAifChsZW4gIiwgdGV4dC5sZW5ndGgoKSwgIikiKTsKKyAgICB9Cit9OworCitzdHJ1Y3Qg QVhUZXh0UnVucyB7CisgICAgLy8gVGhlIGNvbnRhaW5pbmcgYmxvY2sgZm9yIHRoZSB0ZXh0IHJ1 bnMuIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZSBiYXNlZCBvbiB0aGUgc3RydWN0dXJlCisgICAg Ly8gb2YgdGhlIEFYIHRyZWUsIHRleHQgcnVucyBmb3IgZGlmZmVyZW50IG9iamVjdHMgY2FuIGhh dmUgdGhlIHNhbWUgbGluZSBpbmRleCBidXQgZGlmZmVyZW50CisgICAgLy8gY29udGFpbmluZyBi bG9ja3MsIG1lYW5pbmcgdGhleSBhcmUgcmVuZGVyZWQgb24gZGlmZmVyZW50IGxpbmVzLgorICAg IC8vIERvIG5vdCBkZS1yZWZlcmVuY2UuIFVzZSBmb3IgY29tcGFyaXNvbiBwdXJwb3NlcyBvbmx5 LgorICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7IG51bGxwdHIgfTsKKyAgICBWZWN0b3I8QVhU ZXh0UnVuPiBydW5zOworCisgICAgQVhUZXh0UnVucygpID0gZGVmYXVsdDsKKyAgICBBWFRleHRS dW5zKFJlbmRlckJsb2NrKiBjb250YWluaW5nQmxvY2ssIFZlY3RvcjxBWFRleHRSdW4+JiYgcnVu cykKKyAgICAgICAgOiBjb250YWluaW5nQmxvY2soY29udGFpbmluZ0Jsb2NrKQorICAgICAgICAs IHJ1bnMoV1RGTW92ZShydW5zKSkKKyAgICB7IH0KKworICAgIHNpemVfdCBzaXplKCkgY29uc3Qg eyByZXR1cm4gcnVucy5zaXplKCk7IH0KKyAgICB1bnNpZ25lZCBydW5MZW5ndGgoc2l6ZV90IGlu ZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBydW5zLnNp emUoKSk7CisgICAgICAgIHJldHVybiBydW5zW2luZGV4XS50ZXh0Lmxlbmd0aCgpOworICAgIH0K KyAgICB1bnNpZ25lZCBsYXN0UnVuTGVuZ3RoKCkgY29uc3QKKyAgICB7CisgICAgICAgIGlmIChy dW5zLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICByZXR1cm4gcnVu c1tydW5zLnNpemUoKSAtIDFdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIEFYVGV4dFJ1bkxp bmVJRCBsaW5lSUQoc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9B U1NFUlQoaW5kZXggPCBydW5zLnNpemUoKSk7CisgICAgICAgIHJldHVybiB7IGNvbnRhaW5pbmdC bG9jaywgcnVuc1tpbmRleF0ubGluZUluZGV4IH07CisgICAgfQorICAgIGNvbnN0IEFYVGV4dFJ1 biYgb3BlcmF0b3JbXShzaXplX3QgcnVuSW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxF QVNFX0FTU0VSVChydW5JbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHJ1bnNb cnVuSW5kZXhdOworICAgIH0KKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0Cisg ICAgeworICAgICAgICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICAgICAgcmVzdWx0LmFwcGVu ZCgnWycpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcnVucy5zaXplKCk7IGkr KykgeworICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zW2ldLmRlYnVnRGVzY3JpcHRpb24o Y29udGFpbmluZ0Jsb2NrKSk7CisgICAgICAgICAgICBpZiAoaSAhPSBydW5zLnNpemUoKSAtIDEp CisgICAgICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICAgICAgfQorICAgICAg ICByZXN1bHQuYXBwZW5kKCddJyk7CisgICAgICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsK KyAgICB9Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFY X1RIUkVBRF9URVhUX0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAppbmRleCBlZjA4NzcwNThmZWIuLjA2ZGE4OTk1OTlj MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxp dHlPYmplY3QuY3BwCkBAIC0xMTMsNiArMTEzLDEyIEBAIHZvaWQgQWNjZXNzaWJpbGl0eU9iamVj dDo6aW5pdCgpCiAgICAgbV9yb2xlID0gZGV0ZXJtaW5lQWNjZXNzaWJpbGl0eVJvbGUoKTsKIH0K IAorQVhJRCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0cmVlSUQoKSBjb25zdAoreworICAgIGF1dG8q IGNhY2hlID0gYXhPYmplY3RDYWNoZSgpOworICAgIHJldHVybiBjYWNoZSA/IGNhY2hlLT50cmVl SUQoKSA6IEFYSUQoKTsKK30KKwogaW5saW5lIFByb2Nlc3NJRCBBY2Nlc3NpYmlsaXR5T2JqZWN0 Ojpwcm9jZXNzSUQoKSBjb25zdAogewogICAgIHJldHVybiBwcmVzZW50aW5nQXBwbGljYXRpb25Q SUQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eU9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmgKaW5kZXggNWQ4OGNjNjEyOGMzLi5jNWJiMzk1MjkzMjIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCkBAIC0zMCw2 ICszMCw3IEBACiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIkFYQ29yZU9iamVjdC5oIgorI2lu Y2x1ZGUgIkFYVGV4dFJ1bi5oIgogI2luY2x1ZGUgIkNoYXJhY3RlclJhbmdlLmgiCiAjaW5jbHVk ZSAiRmxvYXRRdWFkLmgiCiAjaW5jbHVkZSAiTGF5b3V0UmVjdC5oIgpAQCAtNjMsNiArNjQsNyBA QCBjbGFzcyBBY2Nlc3NpYmlsaXR5T2JqZWN0IDogcHVibGljIEFYQ29yZU9iamVjdCwgcHVibGlj IENhbk1ha2VXZWFrUHRyPEFjY2Vzc2liaQogcHVibGljOgogICAgIHZpcnR1YWwgfkFjY2Vzc2li aWxpdHlPYmplY3QoKTsKIAorICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgZmluYWw7CiAgICAgUHJv Y2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0IG92ZXJyaWRlOwogICAgIFN0cmluZyBkYmcoKSBjb25z dCBmaW5hbDsKIApAQCAtMzgwLDYgKzM4Miw5IEBAIHB1YmxpYzoKICAgICBTdHJpbmcgdGV4dFVu ZGVyRWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3NpYmls aXR5VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4geyB9OyB9 CiAgICAgU3RyaW5nIHRleHQoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0KICAgICB1 bnNpZ25lZCB0ZXh0TGVuZ3RoKCkgY29uc3QgZmluYWw7CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9U RVhUX0FQSVMpCisgICAgdmlydHVhbCBBWFRleHRSdW5zIHRleHRSdW5zKCkgeyByZXR1cm4geyB9 OyB9CisjZW5kaWYKICNpZiBQTEFURk9STShDT0NPQSkKICAgICAvLyBSZXR1cm5zIGFuIGFycmF5 IG9mIHN0cmluZ3MgYW5kIEFYT2JqZWN0IHdyYXBwZXJzIGNvcnJlc3BvbmRpbmcgdG8gdGhlCiAg ICAgLy8gdGV4dHJ1bnMgYW5kIHJlcGxhY2VtZW50IG5vZGVzIGluY2x1ZGVkIGluIHRoZSBnaXZl biByYW5nZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCmluZGV4IDM4YTRhYWY2NTdmMi4uOThlODQwMmUz NmEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKQEAgLTEzOTUsMTEgKzEzOTUsMTEgQEAgQ2hhcmFj dGVyUmFuZ2UgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6c2VsZWN0ZWRUZXh0UmFuZ2UoKSBj b25zdAogfQogCiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi1WZWN0b3I8QVhUZXh0 UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCitBWFRleHRSdW5zIEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKIHsKICAgICBpZiAoYXV0byogcmVu ZGVyTGluZUJyZWFrID0gZHluYW1pY0Rvd25jYXN0PFJlbmRlckxpbmVCcmVhaz4ocmVuZGVyZXIo KSkpIHsKICAgICAgICAgYXV0byBib3ggPSBJbmxpbmVJdGVyYXRvcjo6Ym94Rm9yKCpyZW5kZXJM aW5lQnJlYWspOwotICAgICAgICByZXR1cm4geyB7IGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJp bmcoJ1xuJykgfSB9OworICAgICAgICByZXR1cm4geyByZW5kZXJMaW5lQnJlYWstPmNvbnRhaW5p bmdCbG9jaygpLCB7IEFYVGV4dFJ1bihib3gtPmxpbmVJbmRleCgpLCBtYWtlU3RyaW5nKCdcbicp Lmlzb2xhdGVkQ29weSgpKSB9IH07CiAgICAgfQogCiAgICAgV2Vha1B0ciByZW5kZXJUZXh0ID0g ZHluYW1pY0Rvd25jYXN0PFJlbmRlclRleHQ+KHJlbmRlcmVyKCkpOwpAQCAtMTQ1Miw3ICsxNDUy LDcgQEAgVmVjdG9yPEFYVGV4dFJ1bj4gQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGV4dFJ1 bnMoKQogCiAgICAgaWYgKCFsaW5lU3RyaW5nLmlzRW1wdHkoKSkKICAgICAgICAgcnVucy5hcHBl bmQoeyBjdXJyZW50TGluZUluZGV4LCBsaW5lU3RyaW5nLnRvU3RyaW5nKCkuaXNvbGF0ZWRDb3B5 KCkgfSk7Ci0gICAgcmV0dXJuIHJ1bnM7CisgICAgcmV0dXJuIHsgcmVuZGVyVGV4dC0+Y29udGFp bmluZ0Jsb2NrKCksIFdURk1vdmUocnVucykgfTsKIH0KICNlbmRpZiAvLyBFTkFCTEUoQVhfVEhS RUFEX1RFWFRfQVBJUykKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAppbmRleCBjZWVjNmJmM2U4OTguLmJlOWVl NGY4NjA0NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKQEAgLTEwMCw3ICsxMDAsNyBAQCBwdWJsaWM6CiAg ICAgU3RyaW5nIHRleHRVbmRlckVsZW1lbnQoQWNjZXNzaWJpbGl0eVRleHRVbmRlckVsZW1lbnRN b2RlID0gQWNjZXNzaWJpbGl0eVRleHRVbmRlckVsZW1lbnRNb2RlKCkpIGNvbnN0IG92ZXJyaWRl OwogICAgIFN0cmluZyBzZWxlY3RlZFRleHQoKSBjb25zdCBvdmVycmlkZTsKICNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICBWZWN0b3I8QVhUZXh0UnVuPiB0ZXh0UnVucygpIGZp bmFsOworICAgIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSBmaW5hbDsKICNlbmRpZgogCiAgICAgYm9v bCBpc1dpZGdldCgpIGNvbnN0IG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcApp bmRleCA2MmExYTU3NWFlNjEuLjI4ZjQxY2VhZGQ5MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVj dC5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJBWEdlb21ldHJ5TWFuYWdlci5oIgog I2luY2x1ZGUgIkFYSXNvbGF0ZWRUcmVlLmgiCiAjaW5jbHVkZSAiQVhMb2dnZXIuaCIKKyNpbmNs dWRlICJBWFRleHRSdW4uaCIKIAogI2lmIFBMQVRGT1JNKE1BQykKICNpbXBvcnQgPHBhbC9zcGkv bWFjL0hJU2VydmljZXNTUEkuaD4KQEAgLTQ2NCw2ICs0NjUsOSBAQCB2b2lkIEFYSXNvbGF0ZWRP YmplY3Q6OnNldFByb3BlcnR5KEFYUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSwgQVhQcm9wZXJ0 eVZhbHVlVgogICAgICAgICBbXShzdGQ6OnBhaXI8QVhJRCwgQ2hhcmFjdGVyUmFuZ2U+JiB0eXBl ZFZhbHVlKSB7CiAgICAgICAgICAgICByZXR1cm4gIXR5cGVkVmFsdWUuZmlyc3QuaXNWYWxpZCgp ICYmICF0eXBlZFZhbHVlLnNlY29uZC5sb2NhdGlvbiAmJiAhdHlwZWRWYWx1ZS5zZWNvbmQubGVu Z3RoOwogICAgICAgICB9LAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgICAg ICBbXShBWFRleHRSdW5zIHJ1bnMpIHsgcmV0dXJuICFydW5zLnNpemUoKTsgfSwKKyNlbmRpZgog ICAgICAgICBbXShhdXRvJikgewogICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAg ICAgICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC05NzEsNiArOTc1LDE5IEBAIGludCBBWElzb2xh dGVkT2JqZWN0OjppbnRBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUp IGNvbnN0CiAgICAgKTsKIH0KIAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorY29u c3QgQVhUZXh0UnVucyogQVhJc29sYXRlZE9iamVjdDo6dGV4dFJ1bnMoKSBjb25zdAoreworICAg IGF1dG8gZW50cnkgPSBtX3Byb3BlcnR5TWFwLmZpbmQoQVhQcm9wZXJ0eU5hbWU6OlRleHRSdW5z KTsKKyAgICBpZiAoZW50cnkgPT0gbV9wcm9wZXJ0eU1hcC5lbmQoKSkKKyAgICAgICAgcmV0dXJu IG51bGxwdHI7CisgICAgcmV0dXJuIFdURjo6c3dpdGNoT24oZW50cnktPnZhbHVlLAorICAgICAg ICBbXSAoY29uc3QgQVhUZXh0UnVucyYgdHlwZWRWYWx1ZSkgLT4gY29uc3QgQVhUZXh0UnVucyog eyByZXR1cm4gJnR5cGVkVmFsdWU7IH0sCisgICAgICAgIFtdIChhdXRvJikgLT4gY29uc3QgQVhU ZXh0UnVucyogeyByZXR1cm4gbnVsbHB0cjsgfQorICAgICk7Cit9CisjZW5kaWYKKwogdGVtcGxh dGU8dHlwZW5hbWUgVD4KIFQgQVhJc29sYXRlZE9iamVjdDo6Z2V0T3JSZXRyaWV2ZVByb3BlcnR5 VmFsdWUoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lKQogewpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVj dC5oCmluZGV4IGE2Y2EwMzQzNzc3ZC4uODI4YzcyNGU3MDU1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKKysr IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9i amVjdC5oCkBAIC00NCw2ICs0NCw5IEBACiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEFY SXNvbGF0ZWRUcmVlOworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorc3RydWN0IEFY VGV4dFJ1bnM7CisjZW5kaWYKIAogY2xhc3MgQVhJc29sYXRlZE9iamVjdCBmaW5hbCA6IHB1Ymxp YyBBWENvcmVPYmplY3QgewogICAgIGZyaWVuZCBjbGFzcyBBWElzb2xhdGVkVHJlZTsKQEAgLTUx LDcgKzU0LDkgQEAgcHVibGljOgogICAgIHN0YXRpYyBSZWY8QVhJc29sYXRlZE9iamVjdD4gY3Jl YXRlKGNvbnN0IFJlZjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiYsIEFYSXNvbGF0ZWRUcmVlKik7CiAg ICAgfkFYSXNvbGF0ZWRPYmplY3QoKTsKIAorICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgZmluYWwg eyByZXR1cm4gdHJlZSgpLT50cmVlSUQoKTsgfQogICAgIFByb2Nlc3NJRCBwcm9jZXNzSUQoKSBj b25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnByb2Nlc3NJRCgpOyB9CisgICAgQWNjZXNzaWJp bGl0eVJvbGUgcm9sZVZhbHVlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RhdGljX2Nhc3Q8QWNj ZXNzaWJpbGl0eVJvbGU+KGludEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpSb2xlVmFs dWUpKTsgfQogICAgIFN0cmluZyBkYmcoKSBjb25zdCBmaW5hbDsKIAogICAgIHZvaWQgYXR0YWNo UGxhdGZvcm1XcmFwcGVyKEFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyKik7CkBAIC01OSwxMCAr NjQsMTYgQEAgcHVibGljOgogICAgIGJvb2wgaXNUYWJsZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJu IGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6SXNUYWJsZSk7IH0KICAgICBib29s IGlzRXhwb3NhYmxlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFY UHJvcGVydHlOYW1lOjpJc0V4cG9zYWJsZSk7IH0KIAorICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlD aGlsZHJlblZlY3RvciYgY2hpbGRyZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVlZGVkID0gdHJ1 ZSkgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogcGFyZW50T2JqZWN0KCkgY29uc3QgZmlu YWwgeyByZXR1cm4gcGFyZW50T2JqZWN0VW5pZ25vcmVkKCk7IH0KKyAgICBBWElzb2xhdGVkT2Jq ZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVk T2JqZWN0KiBlZGl0YWJsZUFuY2VzdG9yKCkgZmluYWwgeyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6 ZWRpdGFibGVBbmNlc3RvcigqdGhpcyk7IH07CiAgICAgYm9vbCBjYW5TZXRGb2N1c0F0dHJpYnV0 ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFt ZTo6Q2FuU2V0Rm9jdXNBdHRyaWJ1dGUpOyB9CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRf QVBJUykKKyAgICBjb25zdCBBWFRleHRSdW5zKiB0ZXh0UnVucygpIGNvbnN0OworI2VuZGlmCisK IHByaXZhdGU6CiAgICAgdm9pZCBkZXRhY2hSZW1vdGVQYXJ0cyhBY2Nlc3NpYmlsaXR5RGV0YWNo bWVudFR5cGUpIGZpbmFsOwogICAgIHZvaWQgZGV0YWNoUGxhdGZvcm1XcmFwcGVyKEFjY2Vzc2li aWxpdHlEZXRhY2htZW50VHlwZSkgZmluYWw7CkBAIC0yNDMsNyArMjU0LDYgQEAgcHJpdmF0ZToK ICAgICBWZWN0b3I8U3RyaW5nPiBkZXRlcm1pbmVEcm9wRWZmZWN0cygpIGNvbnN0IGZpbmFsOwog ICAgIEFYSXNvbGF0ZWRPYmplY3QqIGFjY2Vzc2liaWxpdHlIaXRUZXN0KGNvbnN0IEludFBvaW50 JikgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogZm9jdXNlZFVJRWxlbWVudCgp IGNvbnN0IGZpbmFsOwotICAgIEFYSXNvbGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdFVuaWdub3Jl ZCgpIGNvbnN0IGZpbmFsOwogICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBsaW5rZWRP YmplY3RzKCkgY29uc3QgZmluYWwgeyByZXR1cm4gdHJlZSgpLT5vYmplY3RzRm9ySURzKHZlY3Rv ckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFYUHJvcGVydHlOYW1lOjpMaW5rZWRPYmplY3RzKSk7IH0K ICAgICBBWElzb2xhdGVkT2JqZWN0KiB0aXRsZVVJRWxlbWVudCgpIGNvbnN0IGZpbmFsIHsgcmV0 dXJuIG9iamVjdEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpUaXRsZVVJRWxlbWVudCk7 IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiBzY3JvbGxCYXIoQWNjZXNzaWJpbGl0eU9yaWVudGF0 aW9uKSBmaW5hbDsKQEAgLTI1MSw3ICsyNjEsNiBAQCBwcml2YXRlOgogICAgIFN0cmluZyBleHBh bmRlZFRleHRWYWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVl KEFYUHJvcGVydHlOYW1lOjpFeHBhbmRlZFRleHRWYWx1ZSk7IH0KICAgICBib29sIHN1cHBvcnRz RXhwYW5kZWRUZXh0VmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFs dWUoQVhQcm9wZXJ0eU5hbWU6OlN1cHBvcnRzRXhwYW5kZWRUZXh0VmFsdWUpOyB9CiAgICAgU1JH QkE8dWludDhfdD4gY29sb3JWYWx1ZSgpIGNvbnN0IGZpbmFsOwotICAgIEFjY2Vzc2liaWxpdHlS b2xlIHJvbGVWYWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2li aWxpdHlSb2xlPihpbnRBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7 IH0KICAgICBTdHJpbmcgcm9sZVBsYXRmb3JtU3RyaW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4g c3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVQbGF0Zm9ybVN0cmluZyk7 IH0KICAgICBTdHJpbmcgcm9sZURlc2NyaXB0aW9uKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3Ry aW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVEZXNjcmlwdGlvbik7IH0KICAg ICBTdHJpbmcgc3Vicm9sZVBsYXRmb3JtU3RyaW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3Ry aW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlN1YnJvbGVQbGF0Zm9ybVN0cmluZyk7 IH0KQEAgLTMxNiw3ICszMjUsNiBAQCBwcml2YXRlOgogICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJl blZlY3RvciB2aXNpYmxlQ2hpbGRyZW4oKSBmaW5hbCB7IHJldHVybiB0cmVlKCktPm9iamVjdHNG b3JJRHModmVjdG9yQXR0cmlidXRlVmFsdWU8QVhJRD4oQVhQcm9wZXJ0eU5hbWU6OlZpc2libGVD aGlsZHJlbikpOyB9CiAgICAgQXRvbVN0cmluZyB0YWdOYW1lKCkgY29uc3QgZmluYWw7CiAgICAg dm9pZCBzZXRDaGlsZHJlbklEcyhWZWN0b3I8QVhJRD4mJik7Ci0gICAgY29uc3QgQWNjZXNzaWJp bGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQg PSB0cnVlKSBmaW5hbDsKICAgICB2b2lkIHVwZGF0ZUNoaWxkcmVuSWZOZWNlc3NhcnkoKSBmaW5h bDsKICAgICBib29sIGlzRGV0YWNoZWRGcm9tUGFyZW50KCkgZmluYWw7CiAgICAgQVhJc29sYXRl ZE9iamVjdCogbGl2ZVJlZ2lvbkFuY2VzdG9yKGJvb2wgZXhjbHVkZUlmT2ZmID0gdHJ1ZSkgY29u c3QgZmluYWwgeyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6bGl2ZVJlZ2lvbkFuY2VzdG9yKCp0aGlz LCBleGNsdWRlSWZPZmYpOyB9CkBAIC0zNDUsOSArMzUzLDYgQEAgcHJpdmF0ZToKIAogICAgIC8v IENoYXJhY3RlclJhbmdlIHN1cHBvcnQuCiAgICAgQ2hhcmFjdGVyUmFuZ2Ugc2VsZWN0ZWRUZXh0 UmFuZ2UoKSBjb25zdCBmaW5hbCB7IHJldHVybiBwcm9wZXJ0eVZhbHVlPENoYXJhY3RlclJhbmdl PihBWFByb3BlcnR5TmFtZTo6U2VsZWN0ZWRUZXh0UmFuZ2UpOyB9Ci0jaWYgRU5BQkxFKEFYX1RI UkVBRF9URVhUX0FQSVMpCi0gICAgVmVjdG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbCB7 IHJldHVybiB2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWFRleHRSdW4+KEFYUHJvcGVydHlOYW1lOjpU ZXh0UnVucyk7IH0KLSNlbmRpZgogICAgIGludCBpbnNlcnRpb25Qb2ludExpbmVOdW1iZXIoKSBj b25zdCBmaW5hbDsKICAgICBDaGFyYWN0ZXJSYW5nZSBkb0FYUmFuZ2VGb3JMaW5lKHVuc2lnbmVk KSBjb25zdCBmaW5hbDsKICAgICBTdHJpbmcgZG9BWFN0cmluZ0ZvclJhbmdlKGNvbnN0IENoYXJh Y3RlclJhbmdlJikgY29uc3QgZmluYWw7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaAppbmRleCBmMTFlZjg1 NTVhMTQuLjk0NTAyOWUwNzA2ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCkBAIC0yNTUsNyArMjU1 LDcgQEAgdXNpbmcgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCA9IHN0ZDo6dmFyaWFudDxzdGQ6Om51 bGxwdHJfdCwgQVhJRCwgU3RyaW5nLCBib29sLAogICAgICwgUmV0YWluUHRyPE5TQXR0cmlidXRl ZFN0cmluZz4KICNlbmRpZgogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgICwg VmVjdG9yPEFYVGV4dFJ1bj4KKyAgICAsIEFYVGV4dFJ1bnMKICNlbmRpZgogPjsKIHVzaW5nIEFY UHJvcGVydHlNYXAgPSBIYXNoTWFwPEFYUHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWYXJp YW50LCBJbnRIYXNoPEFYUHJvcGVydHlOYW1lPiwgV1RGOjpTdHJvbmdFbnVtSGFzaFRyYWl0czxB WFByb3BlcnR5TmFtZT4+Owo= 469119 2023-12-18 15:58:33 -0800 2023-12-18 18:38:08 -0800 Patch bug-266521-20231218155832.patch text/plain 43884 tyler_w RnJvbSAwNzUzOWYxMmUyMDY5NTAxZmRlNDVjODMzYzFlZDBkNzI3OTZkYTAyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDIyNyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8IDEwNyArKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDExOCArKysrKysrKysKIC4uLi9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwICAgICB8ICAgNiArCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmggICAgICAgfCAgIDUgKwogLi4uL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwICAgICAgICAgICAgIHwgICA2ICstCiAuLi4vYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggfCAgIDIgKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5jcHAgICAgICAgICB8ICAzMCArKysKIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkVHJlZS5oICAgICAgICAgICAgIHwgICAyICstCiAxNiBmaWxlcyBjaGFuZ2VkLCA1MjggaW5z ZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFNv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiBjcmVhdGUgbW9kZSAxMDA2 NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNt YWtlCmluZGV4IGNjNmM0YTMxZTZkNS4uMzkzNDRkMGM4MGNlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UK QEAgLTY1MCw3ICs2NTAsOSBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09SS19IRUFERVJT CiAgICAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5oCiAgICAgYWNjZXNzaWJpbGl0 eS9BWExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKyAgICBhY2Nl c3NpYmlsaXR5L0FYUG9zaXRpb24uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgK KyAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRT dGF0ZUNoYW5nZUludGVudC5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRyZWVTdG9yZS5oCiAgICAg YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5TGlzdEJveC5oCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CmluZGV4IGQz MDJkMzJlYTc2Yi4uNWJjYmYwNTdjNjg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dApAQCAtNTIxLDYgKzUyMSw3 IEBAIGFjY2Vzc2liaWxpdHkvQVhHZW9tZXRyeU1hbmFnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FY SW1hZ2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNjZXNzaWJpbGl0eS9BWE9i amVjdENhY2hlLmNwcAorYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogYWNjZXNzaWJpbGl0 eS9BWFRleHRNYXJrZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZC5j cHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5jcHAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3Zjgx ODJmMDhhZGMuLjAzZjMyMjZmZWUzNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTc1MCw3ICsxNzUwLDkgQEAKIAkJNDdGOTQ3 REIyNjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5 NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJs ZUZvcm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dl b21ldHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJNDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMz QTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKKwkJNDg2MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJE MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVU RVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFY R2VvbWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQy QTJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0 UnVuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ NDhCNUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0Lmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5 Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlF MDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBF bGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCTQ5M0U1RTA5MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNB TGF5ZXJDbGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDQ5M0U1RTA4MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjAs OCArMTA3MjIsMTEgQEAKIAkJNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0 dGluZ0dlb21ldHJ5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFRhYmxlRm9y bWF0dGluZ0dlb21ldHJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4MjI5NzBC MjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk0ODIyOTcwQzI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZWdpb25Db250ZXh0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0 aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYUG9zaXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDg2MUUwQkUyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gQVhQb3NpdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0ODZCOERDODJBMDQ1MDBGMDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQVhHZW9tZXRyeU1hbmFnZXIuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIg LyogQVhUZXh0UnVuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYVGV4dFJ1bi5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0 eVJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNz aWJpbGl0eVJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzYyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1l bnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250 ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE4Niw4ICsyMzE5MSwxMSBA QAogCQkJCUMwNDkzRUI3MjQ0Njk5RTQwMDlBQUM4MCAvKiBBWExvZ2dlci5oICovLAogCQkJCTI5 ODFDQUFGMTMxODIyRUMwMEQxMkYyQSAvKiBBWE9iamVjdENhY2hlLmNwcCAqLywKIAkJCQkyOUE4 MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5oICovLAorCQkJCTQ4NjFFMEJF MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLywKKwkJCQk0ODYxRTBCRDJCMjAw NzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMw RDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICovLAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUzQkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0 YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFEQzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFY VHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYwNTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFj Y2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1NzcsNyArMzc1ODUsOSBAQAogCQkJCTI5QUUy MTM1MjFBQkE0OEEwMDg2OTI4MyAvKiBBWElzb2xhdGVkT2JqZWN0LmggaW4gSGVhZGVycyAqLywK IAkJCQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRyZWUuaCBpbiBIZWFk ZXJzICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmgg aW4gSGVhZGVycyAqLywKKwkJCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlv bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzBFMjA4QTIyOTM3OUM2RjAwQzBEMkQzIC8qIEFYVGV4 dE1hcmtlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNDhCMDI0MkEyQjJBNjVBQTAwODNEMTIyIC8q IEFYVGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTFDOUYyRjkxQUUzQkVCMDAwOTVCNjFD IC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEU4QURD NTI5NEI1QTYzMDA3NkNCREMgLyogQVhUcmVlU3RvcmUuaCBpbiBIZWFkZXJzICovLAogCQkJCTE0 NzdFNzc3MEJGNDEzNEEwMDE1Mjg3MiAvKiBCYWNrRm9yd2FyZENhY2hlLmggaW4gSGVhZGVycyAq LywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0 LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCmluZGV4IDEw MTE0ZWNiNmRkOC4uOTkwY2RhOTgwNWMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhDb3JlT2JqZWN0LmgKQEAgLTExMCwxOSArMTEwLDYgQEAgZW51bSBjbGFzcyBBWEFuY2Vz dG9yRmxhZyA6IHVpbnQ4X3QgewogICAgIC8vIEJpdHMgNiBhbmQgNyBhcmUgZnJlZS4KIH07CiAK LSNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAg IC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUg Y29udGFpbmluZyBSZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4K LSAgICBzaXplX3QgbGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVu KHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxp bmVJbmRleCkKLSAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2Vu ZGlmCi0KIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0g MSwKICAgICBBcHBsaWNhdGlvbkFsZXJ0LApAQCAtNjUzLDYgKzY0MCw4IEBAIGVudW0gY2xhc3Mg QWNjZXNzaWJpbGl0eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3Mg QVhEaXJlY3Rpb24gOiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nl c3NpYmlsaXR5U29ydERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04 MDAsNiArNzg5LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQp IHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9p ZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQ cm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVz cG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTEx MDQsOSArMTA5NCw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRl eHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dy YW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZp cnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1 bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJp bmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBj b25zdCA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjhjZGE1NzE2YTg1ZgotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAKQEAgLTAsMCArMSwyMjcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorI2luY2x1ZGUgIkFY SXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRlICJBWElzb2xhdGVkVHJlZS5oIgorI2VuZGlmIC8v IEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCisjaW5jbHVkZSAiQVhPYmplY3RD YWNoZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0FYSXNvbGF0ZWRPYmplY3QqIEFYUG9z aXRpb246Om9iamVjdCgpIGNvbnN0Cit7CisgICAgUkVMRUFTRV9BU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAg aWYgKG1fY2FjaGVkT2JqZWN0KQorICAgICAgICByZXR1cm4gbV9jYWNoZWRPYmplY3QuZ2V0KCk7 CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorICAgIGF1dG8gdHJl ZSA9IHN0ZDo6Z2V0PFJlZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4VHJlZUZvcklEKHRyZWVJRCgp KSk7CisgICAgbV9jYWNoZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+b2JqZWN0Rm9ySUQob2JqZWN0 SUQoKSkgOiBudWxscHRyOworICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKKyNlbmRp ZgorfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZyb21UZXh0TWFya2VyKGNvbnN0IEFYVGV4 dE1hcmtlciYgbWFya2VyKQoreworICAgIHJldHVybiBBWFBvc2l0aW9uKG1hcmtlci50cmVlSUQo KSwgbWFya2VyLm9iamVjdElEKCksIG1hcmtlci5vZmZzZXQoKSApOworfQorCitBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdAoreworICAgIHJldHVybiB7IHsgdHJlZUlE KCksIG9iamVjdElEKCksIG51bGxwdHIsIG1fb2Zmc2V0IH0gfTsKK30KKworU3RyaW5nIEFYUG9z aXRpb246OmRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAgIGF1dG8gc2VwYXJhdG9yID0g IiwgIjsKKyAgICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+b2JqZWN0KCk7CisgICAgcmV0dXJuIG1h a2VTdHJpbmcoCisgICAgICAgICJ0cmVlSUQgIiwgdHJlZUlEKCkubG9nZ2luZ1N0cmluZygpCisg ICAgICAgICwgc2VwYXJhdG9yLCAib2JqZWN0SUQgIiwgb2JqZWN0SUQoKS5sb2dnaW5nU3RyaW5n KCkKKyAgICAgICAgLCBzZXBhcmF0b3IsICJyb2xlICIsIG9iamVjdCA/IGFjY2Vzc2liaWxpdHlS b2xlVG9TdHJpbmcob2JqZWN0LT5yb2xlVmFsdWUoKSkgOiBTdHJpbmcoIm5vIG9iamVjdCJfcykK KyAgICAgICAgLCBzZXBhcmF0b3IsICJvZmZzZXQgIiwgbV9vZmZzZXQKKyAgICApOworfQorCitl bnVtIGNsYXNzIENoZWNrU3RhcnQgOiBib29sIHsgTm8sIFllcyB9OworLy8gRmluZHMgdGhlIG5l eHQgb2JqZWN0IHdpdGggdGV4dCBydW5zIGluIHRoZSBnaXZlbiBkaXJlY3Rpb24uCitzdGF0aWMg UmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZpbmRPYmplY3RXaXRoUnVucyhBWElzb2xhdGVkT2Jq ZWN0JiBzdGFydCwgQVhEaXJlY3Rpb24gZGlyZWN0aW9uLCBDaGVja1N0YXJ0IGNoZWNrU3RhcnQg PSBDaGVja1N0YXJ0OjpObykKK3sKKyAgICBpZiAoY2hlY2tTdGFydCA9PSBDaGVja1N0YXJ0OjpZ ZXMpIHsKKyAgICAgICAgaWYgKGF1dG8qIHJ1bnMgPSBzdGFydC50ZXh0UnVucygpOyBydW5zICYm IHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgIHJldHVybiAmc3RhcnQ7CisgICAgfQorCisgICAg UmVmUHRyIGN1cnJlbnQgPSAmc3RhcnQ7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAg aWYgKGN1cnJlbnQgIT0gJnN0YXJ0KSB7CisgICAgICAgICAgICBhdXRvKiBydW5zID0gY3VycmVu dC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgICAgIGlmIChydW5zICYmIHJ1bnMtPnNpemUoKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEZJ WE1FOiBhcmlhLW93bnMgYnJlYWtzIHRoaXMgdHJhdmVyc2FsLCBhcyBhcmlhLW93bnMgY2F1c2Vz IHRoZSBBWCB0cmVlIHRvIGJlIGNoYW5nZWQsIGFmZmVjdGluZworICAgICAgICAvLyBvdXIgaXRl cmF0aW9uIGJlbG93LCBidXQgaXQgZG9lc24ndCBhY3R1YWxseSBjaGFuZ2UgdGV4dCBwb3NpdGlv biBvbiB0aGUgcGFnZS4gU28gd2UgbmVlZCB0byBpZ25vcmUgYXJpYS1vd25zCisgICAgICAgIC8v IHRyZWUgY2hhbmdlcyBoZXJlIGluIG9yZGVyIHRvIGJlaGF2ZSBjb3JyZWN0bHkuCisgICAgICAg IC8vIFdlIGFsc28gcHJvYmFibHkgbmVlZCB0byBkbyBzb21ldGhpbmcgYWJvdXQgdGV4dCB3aXRo aW4gYXJpYS1oaWRkZW4gY29udGFpbmVycywgd2hpY2ggYWZmZWN0cyB0aGUgQVggdHJlZS4KKwor ICAgICAgICBjb25zdCBhdXRvJiBjaGlsZHJlbiA9IGN1cnJlbnQtPmNoaWxkcmVuKCk7CisgICAg ICAgIGlmIChjaGlsZHJlbi5zaXplKCkpIHsKKyAgICAgICAgICAgIHNpemVfdCBjaGlsZEluZGV4 ID0gZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6IGNoaWxkcmVuLnNpemUoKSAt IDE7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjaGlsZHJlbltjaGlsZEluZGV4XSk7Cisg ICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KGNo aWxkcmVuW2NoaWxkSW5kZXhdLmdldCgpKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICB9CisKKyAgICAgICAgLy8gYGN1cnJlbnRgIGhhcyBubyBjaGlsZHJlbiwgbWVhbmluZyBpdCdz IGEgbGVhZiBub2RlIChlLmcuIGl0J3MgdGV4dCwgd2hpY2ggY2Fubm90IGhhdmUgY2hpbGRyZW4p LgorICAgICAgICAvLyBDaGVjayBgY3VycmVudGBzIHNpYmxpbmdzLgorICAgICAgICBpZiAoYXV0 byogc2libGluZyA9IGN1cnJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSkgeworICAgICAgICAgICAg Y3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0PihzaWJsaW5nKTsKKyAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gV2UgaGF2ZSBubyBj aGlsZHJlbiwgYW5kIG5vIG5leHQvcHJldmlvdXMgc2libGluZy4gVHJ5IG91ciBwYXJlbnQncyBz aWJsaW5nLgorICAgICAgICBpZiAoYXV0byogcGFyZW50ID0gY3VycmVudC0+cGFyZW50T2JqZWN0 VW5pZ25vcmVkKCkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJ c29sYXRlZE9iamVjdD4ocGFyZW50LT5zaWJsaW5nKGRpcmVjdGlvbikpOworICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJu IG51bGxwdHI7Cit9CisKK0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGly ZWN0aW9uIGRpcmVjdGlvbikgY29uc3QKK3sKKyAgICBpZiAoIW9iamVjdCgpKQorICAgICAgICBy ZXR1cm4gbnVsbFBvc2l0aW9uKCk7CisgICAgYXV0byBydW5Gcm9tT2Zmc2V0ID0gdGhpcy0+cnVu RnJvbU9mZnNldCgpOworICAgIGNvbnN0IGF1dG8qIHJ1bnMgPSBydW5Gcm9tT2Zmc2V0Lm9iamVj dC0+dGV4dFJ1bnMoKTsKKworICAgIGF1dG8gaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4gPSBbJiwg dGhpc10geworICAgICAgICBpZiAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0KQorICAg ICAgICAgICAgcmV0dXJuIG1fb2Zmc2V0IDwgcnVuRnJvbU9mZnNldC5ydW4oKS50ZXh0Lmxlbmd0 aCgpOworICAgICAgICByZXR1cm4gbV9vZmZzZXQgPiAwOworICAgIH07CisgICAgYm9vbCBoYXNB bm90aGVyUnVuID0gcnVuRnJvbU9mZnNldC5pbmRleCArIDEgPCBydW5zLT5zaXplKCk7CisgICAg Ly8gVGhlIG5leHQgcnVuIHNob3VsZCBub3QgaGF2ZSBlbXB0eSB0ZXh0LCBiZWNhdXNlIHdlJ3Jl IGdvaW5nIHRvIHJldHVybiBhIHBvc2l0aW9uIGNvbnRhaW5pbmcgbV9vZmZzZXQgKyAxLCB3aGlj aCB3b3VsZCBiZSB3cm9uZy4KKyAgICBSRUxFQVNFX0FTU0VSVChkaXJlY3Rpb24gPT0gQVhEaXJl Y3Rpb246OlByZXZpb3VzIHx8ICFoYXNBbm90aGVyUnVuIHx8IHJ1bnMtPnJ1bkxlbmd0aChydW5G cm9tT2Zmc2V0LmluZGV4ICsgMSkgPiAwKTsKKyAgICAvLyBDaGVja2luZyBmb3IgdGhlIHByZXNl bmNlIG9mIGFub3RoZXIgcnVuIGlzIG9ubHkgcmVsZXZhbnQgZm9yIG1vdmluZyBBWERpcmVjdGlv bjo6TmV4dCwgYXMganVzdCBjaGVja2luZyB0aGF0IG1fb2Zmc2V0ID4gMCBpcyBzdWZmaWNpZW50 IGZvciBBWERpcmVjdGlvbjo6UHJldmlvdXMuCisgICAgaWYgKGhhc01vcmVUZXh0SW5DdXJyZW50 UnVuKCkgfHwgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCAmJiBoYXNBbm90aGVyUnVu KSkgeworICAgICAgICAvLyBSZXR1cm4gYW4gb2Zmc2V0IHRvIHRoZSBuZXh0IGNoYXJhY3RlciBp biB0aGUgY3VycmVudCBydW4uCisgICAgICAgIHJldHVybiBBWFBvc2l0aW9uKHJ1bkZyb21PZmZz ZXQudHJlZUlEKCksIHJ1bkZyb21PZmZzZXQub2JqZWN0SUQoKSwgZGlyZWN0aW9uID09IEFYRGly ZWN0aW9uOjpOZXh0ID8gbV9vZmZzZXQgKyAxIDogbV9vZmZzZXQgLSAxKTsKKyAgICB9CisgICAg Ly8gbV9vZmZzZXQgcG9pbnRlZCB0byB0aGUgbGFzdCBjaGFyYWN0ZXIgaW4gdGhlIGdpdmVuIG9i amVjdCdzIHJ1bnMsIHNvIGxldCdzIHRyYXZlcnNlIHRvIGZpbmQgdGhlIG5leHQgb2JqZWN0IHdp dGggcnVucy4KKyAgICBpZiAoUmVmUHRyIG9iamVjdCA9IGZpbmRPYmplY3RXaXRoUnVucyhydW5G cm9tT2Zmc2V0Lm9iamVjdC5nZXQoKSwgZGlyZWN0aW9uKSkKKyAgICAgICAgcmV0dXJuIEFYUG9z aXRpb24ob2JqZWN0LT50cmVlSUQoKSwgb2JqZWN0LT5vYmplY3RJRCgpLCBkaXJlY3Rpb24gPT0g QVhEaXJlY3Rpb246Ok5leHQgPyAwIDogb2JqZWN0LT50ZXh0UnVucygpLT5sYXN0UnVuTGVuZ3Ro KCkpOworCisgICAgcmV0dXJuIG51bGxQb3NpdGlvbigpOworfQorCitBWFBvc2l0aW9uIEFYUG9z aXRpb246OmZpbmRQb3NpdGlvbihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4 dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoIW9i amVjdCgpKQorICAgICAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7CisKKyAgICBpZiAodGV4dFVu aXQgPT0gQVhUZXh0VW5pdDo6TGluZSkgeworICAgICAgICBhdXRvIHJ1bkZyb21PZmZzZXQgPSB0 aGlzLT5ydW5Gcm9tT2Zmc2V0KCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2JqZWN0ID0gV1RG TW92ZShydW5Gcm9tT2Zmc2V0Lm9iamVjdCk7CisgICAgICAgIGNvbnN0IGF1dG8qIGN1cnJlbnRS dW5zID0gY3VycmVudE9iamVjdC0+dGV4dFJ1bnMoKTsKKworICAgICAgICBhdXRvIGNvbXB1dGVP ZmZzZXQgPSBbJl0gKHNpemVfdCBydW5FbmRPZmZzZXQsIHNpemVfdCBydW5MZW5ndGgpIHsKKyAg ICAgICAgICAgIC8vIFRoaXMgd29ya3MgYmVjYXVzZSBgcnVuRW5kT2Zmc2V0YCBpcyB0aGUgb2Zm c2V0IHBvaW50aW5nIHRvIHRoZSBlbmQgb2YgdGhlIGdpdmVuIHJ1biwgd2hpY2ggaW5jbHVkZXMg dGhlIGxlbmd0aCBvZiBhbGwgcnVucyBwcmVjZWRpbmcgaXQuIFNvIHN1YnRyYWN0aW5nIHRoYXQg ZnJvbSB0aGUgbGVuZ3RoIG9mIHRoZSBjdXJyZW50IHJ1biBnaXZlcyB1cyBhbiBvZmZzZXQgdG8g dGhlIHN0YXJ0IG9mIHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgICAgIHJldHVybiBib3VuZGFy eSA9PSBBWFRleHRVbml0Qm91bmRhcnk6OkVuZCA/IHJ1bkVuZE9mZnNldCA6IHJ1bkVuZE9mZnNl dCAtIHJ1bkxlbmd0aDsKKyAgICAgICAgfTsKKyAgICAgICAgYXV0byBsaW5lUG9zaXRpb24gPSBB WFBvc2l0aW9uKGN1cnJlbnRPYmplY3QtPnRyZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJ RCgpLCBjb21wdXRlT2Zmc2V0KHJ1bkZyb21PZmZzZXQucnVuTGVuZ3RoU3VtLCBjdXJyZW50UnVu cy0+cnVuTGVuZ3RoKHJ1bkZyb21PZmZzZXQuaW5kZXgpKSk7CisgICAgICAgIGF1dG8gc3RhcnRM aW5lSUQgPSBjdXJyZW50UnVucy0+bGluZUlEKHJ1bkZyb21PZmZzZXQuaW5kZXgpOworICAgICAg ICAvLyBXZSBmb3VuZCB0aGUgc3RhcnQgcnVuIGFuZCBhc3NvY2lhdGVkIGxpbmUsIG5vdyBpdGVy YXRlIHVudGlsIHdlIGZpbmQgYSBsaW5lIGJvdW5kYXJ5LgorICAgICAgICB3aGlsZSAoY3VycmVu dE9iamVjdCkgeworICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoY3VycmVudFJ1bnMtPnNpemUo KSk7CisgICAgICAgICAgICB1bnNpZ25lZCBjdW11bGF0aXZlT2Zmc2V0ID0gMDsKKyAgICAgICAg ICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY3VycmVudFJ1bnMtPnNpemUoKTsgaSsrKSB7Cisg ICAgICAgICAgICAgICAgY3VtdWxhdGl2ZU9mZnNldCArPSBjdXJyZW50UnVucy0+cnVuTGVuZ3Ro KGkpOworICAgICAgICAgICAgICAgIGlmIChjdXJyZW50UnVucy0+bGluZUlEKGkpICE9IHN0YXJ0 TGluZUlEKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gbGluZVBvc2l0aW9uOworICAgICAg ICAgICAgICAgIGxpbmVQb3NpdGlvbiA9IEFYUG9zaXRpb24oY3VycmVudE9iamVjdC0+dHJlZUlE KCksIGN1cnJlbnRPYmplY3QtPm9iamVjdElEKCksIGNvbXB1dGVPZmZzZXQoY3VtdWxhdGl2ZU9m ZnNldCwgY3VycmVudFJ1bnMtPnJ1bkxlbmd0aChpKSkpOworICAgICAgICAgICAgfQorICAgICAg ICAgICAgY3VycmVudE9iamVjdCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudE9iamVjdCwg ZGlyZWN0aW9uKTsKKyAgICAgICAgICAgIGlmIChjdXJyZW50T2JqZWN0KQorICAgICAgICAgICAg ICAgIGN1cnJlbnRSdW5zID0gY3VycmVudE9iamVjdC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgfQor ICAgICAgICByZXR1cm4gbGluZVBvc2l0aW9uOworICAgIH0KKyAgICByZXR1cm4gbnVsbFBvc2l0 aW9uKCk7Cit9CisKK1J1bkZyb21PZmZzZXQgQVhQb3NpdGlvbjo6cnVuRnJvbU9mZnNldCgpIGNv bnN0Cit7CisgICAgc2l6ZV90IGN1bXVsYXRpdmVPZmZzZXQgPSAwOworICAgIFJlZlB0ciBjdXJy ZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpvYmplY3QoKSwgQVhEaXJlY3Rpb246Ok5leHQsIENo ZWNrU3RhcnQ6Olllcyk7CisgICAgLy8gSW5kZXggb2YgdGhlIHJ1biB3ZSBzdGFydCBhdCBiYXNl ZCBvbiBtX29mZnNldC4KKyAgICBzaXplX3Qgc3RhcnRSdW5JbmRleCA9IG5vdEZvdW5kOworICAg IHdoaWxlIChjdXJyZW50ICYmIHN0YXJ0UnVuSW5kZXggPT0gbm90Rm91bmQpIHsKKyAgICAgICAg YXV0byYgY3VycmVudFJ1bnMgPSAqY3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IGN1cnJlbnRSdW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAg ICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5zLnJ1bkxlbmd0aChpKTsKKyAgICAgICAg ICAgIGlmIChjdW11bGF0aXZlT2Zmc2V0ID49IG1fb2Zmc2V0KSB7CisgICAgICAgICAgICAgICAg c3RhcnRSdW5JbmRleCA9IGk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKworICAgICAgICBpZiAoc3RhcnRSdW5JbmRleCAhPSBub3RGb3VuZCkKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpj dXJyZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgfQorCisgICAgaWYgKHN0YXJ0UnVuSW5k ZXggPT0gbm90Rm91bmQpIHsKKyAgICAgICAgLy8gRklYTUU6IE5vdCBzdXJlIGhvdyB0aGlzIGNv dWxkIGhhcHBlbiwgYnV0IHdlIG1heSBuZWVkIHRvIGhhbmRsZSBpdCBzb21laG93PworICAgICAg ICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KKyAgICByZXR1cm4geyAqY3Vy cmVudCwgc3RhcnRSdW5JbmRleCwgY3VtdWxhdGl2ZU9mZnNldCB9OworfQorCitBWFRleHRNYXJr ZXJSYW5nZSBBWFBvc2l0aW9uOjpsaW5lUmFuZ2UoTGluZVJhbmdlVHlwZSB0eXBlKSBjb25zdAor eworICAgIGlmICghb2JqZWN0KCkpCisgICAgICAgIHJldHVybiB7IG51bGxQb3NpdGlvbigpLCBu dWxsUG9zaXRpb24oKSB9OworCisgICAgaWYgKHR5cGUgPT0gTGluZVJhbmdlVHlwZTo6Q3VycmVu dCkKKyAgICAgICAgcmV0dXJuIHsgZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpQcmV2aW91cywg QVhUZXh0VW5pdDo6TGluZSwgQVhUZXh0VW5pdEJvdW5kYXJ5OjpTdGFydCksIGZpbmRQb3NpdGlv bihBWERpcmVjdGlvbjo6TmV4dCwgQVhUZXh0VW5pdDo6TGluZSwgQVhUZXh0VW5pdEJvdW5kYXJ5 OjpFbmQpIH07CisgICAgLy8gVGhlIG90aGVyIHR5cGVzIGFyZW4ndCBpbXBsZW1lbnRlZCB5ZXQu CisgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKK30KKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmggYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLjg4MTY3NTYyYzZhYwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCkBAIC0wLDAgKzEsMTA3IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5E IElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykK KyNpbmNsdWRlICJBWElzb2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0TWFya2VyLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworZW51bSBjbGFzcyBBWFRleHRVbml0IDogdWludDhf dCB7CisgICAgTGluZSwKKyAgICBQYXJhZ3JhcGgsCisgICAgU2VudGVuY2UsCisgICAgV29yZCwK K307CitlbnVtIGNsYXNzIEFYVGV4dFVuaXRCb3VuZGFyeSA6IGJvb2wgeyBTdGFydCwgRW5kLCB9 OworCitlbnVtIGNsYXNzIExpbmVSYW5nZVR5cGUgOiB1aW50OF90IHsKKyAgICBDdXJyZW50LAor ICAgIExlZnQsCisgICAgUmlnaHQsCit9OworCitzdHJ1Y3QgUnVuRnJvbU9mZnNldCB7CisgICAg Ly8gVGhlIGxlYWYgbm9kZSB3aXRoIHJ1bnMgcG9pbnRlZCB0byBieSB0aGUgb2Zmc2V0IHVzZWQg dG8gY29tcHV0ZSB0aGlzIHN0cnVjdC4KKyAgICBSZWY8QVhJc29sYXRlZE9iamVjdD4gb2JqZWN0 OworICAgIC8vIFJ1biBpbmRleCBwb2ludGVkIHRvIGJ5IHRoZSBvZmZzZXQgdXNlZCB0byBjb21w dXRlIHRoaXMgc3RydWN0LgorICAgIHNpemVfdCBpbmRleCB7IDAgfTsKKyAgICAvLyBUaGUgc3Vt IG9mIHRoZSB0ZXh0IGZyb20gcnVucyBwcmlvciB0byBhbmQgaW5jbHVkaW5nIG9iamVjdC0+dGV4 dFJ1bnNbaW5kZXhdLgorICAgIHNpemVfdCBydW5MZW5ndGhTdW07CisKKyAgICBBWElEIHRyZWVJ RCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdC0+dHJlZUlEKCk7IH0KKyAgICBBWElEIG9iamVjdElE KCkgY29uc3QgeyByZXR1cm4gb2JqZWN0LT5vYmplY3RJRCgpOyB9CisgICAgY29uc3QgQVhUZXh0 UnVuJiBydW4oKSBjb25zdCB7IHJldHVybiAoKm9iamVjdC0+dGV4dFJ1bnMoKSlbaW5kZXhdOyB9 CisKKyAgICBSdW5Gcm9tT2Zmc2V0KEFYSXNvbGF0ZWRPYmplY3QmIG9iamVjdCwgc2l6ZV90IHJ1 bkluZGV4LCBzaXplX3QgcnVuTGVuZ3RoU3VtKQorICAgICAgICA6IG9iamVjdChvYmplY3QpCisg ICAgICAgICwgaW5kZXgocnVuSW5kZXgpCisgICAgICAgICwgcnVuTGVuZ3RoU3VtKHJ1bkxlbmd0 aFN1bSkKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKHJ1bkluZGV4IDwgb2JqZWN0LnRl eHRSdW5zKCktPnNpemUoKSk7CisgICAgfQorfTsKKworY2xhc3MgQVhQb3NpdGlvbiB7CitwdWJs aWM6CisgICAgZXhwbGljaXQgQVhQb3NpdGlvbihBWElEIHRyZWVJRCwgQVhJRCBvYmplY3RJRCwg dW5zaWduZWQgb2Zmc2V0KQorICAgICAgICA6IG1fdHJlZUlEKHRyZWVJRCkKKyAgICAgICAgLCBt X29iamVjdElEKG9iamVjdElEKQorICAgICAgICAsIG1fb2Zmc2V0KG9mZnNldCkKKyAgICB7IH0K KyAgICBzdGF0aWMgQVhQb3NpdGlvbiBudWxsUG9zaXRpb24oKSB7IHJldHVybiBBWFBvc2l0aW9u KEFYSUQoKSwgQVhJRCgpLCAwKTsgfQorICAgIHN0YXRpYyBBWFBvc2l0aW9uIGZyb21UZXh0TWFy a2VyKGNvbnN0IEFYVGV4dE1hcmtlciYpOworICAgIG9wZXJhdG9yIEFYVGV4dE1hcmtlcigpIGNv bnN0OworCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCB7IHJldHVybiBtX3RyZWVJRDsgfQorICAg IEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJldHVybiBtX29iamVjdElEOyB9CisgICAgdW5zaWdu ZWQgb2Zmc2V0KCkgY29uc3QgeyByZXR1cm4gbV9vZmZzZXQ7IH0KKworICAgIEFYSXNvbGF0ZWRP YmplY3QqIG9iamVjdCgpIGNvbnN0OworICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyByZXR1cm4g IXRyZWVJRCgpLmlzVmFsaWQoKSB8fCAhb2JqZWN0SUQoKS5pc1ZhbGlkKCk7IH0KKworICAgIC8v IEZpbmQgdGhlIG5leHQgb3IgcHJldmlvdXMgcG9zaXRpb24uCisgICAgQVhQb3NpdGlvbiBmaW5k UG9zaXRpb24oQVhEaXJlY3Rpb24pIGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZyb20gdGhpcyBw b3NpdGlvbiwgY3JlYXRlcyBhIG5ldyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVuIGRpcmVjdGlvbiBh bmQgdGV4dCB1bml0IHR5cGUuCisgICAgQVhQb3NpdGlvbiBmaW5kUG9zaXRpb24oQVhEaXJlY3Rp b24sIEFYVGV4dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSkgY29uc3Q7CisgICAgQVhUZXh0TWFy a2VyUmFuZ2UgbGluZVJhbmdlKExpbmVSYW5nZVR5cGUpIGNvbnN0OworCisgICAgLy8gR2V0cyB0 aGUgcnVuIHBvaW50ZWQgdG8gYnkgbV9vZmZzZXQgKGFuZCBzb21lIGFzc29jaWF0ZWQgaW5mb3Jt YXRpb24pLgorICAgIFJ1bkZyb21PZmZzZXQgcnVuRnJvbU9mZnNldCgpIGNvbnN0OworCisgICAg U3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdDsKKworcHJpdmF0ZToKKyAgICBBWElEIG1f dHJlZUlEOworICAgIEFYSUQgbV9vYmplY3RJRDsKKyAgICB1bnNpZ25lZCBtX29mZnNldCB7IDAg fTsKKworICAgIG11dGFibGUgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IG1fY2FjaGVkT2JqZWN0 OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJF QURfVEVYVF9BUElTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WFRleHRNYXJrZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJr ZXIuY3BwCmluZGV4IDlhZDZhYmY5M2FhYy4uZDJkNDMzYmNiYjFiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCkBAIC0zMzUsNyArMzM1LDcgQEAg c3RkOjpvcHRpb25hbDxBWFRleHRNYXJrZXJSYW5nZT4gQVhUZXh0TWFya2VyUmFuZ2U6OmludGVy c2VjdGlvbldpdGgoY29uc3QgQVhUZXgKIAogU3RyaW5nIEFYVGV4dE1hcmtlclJhbmdlOjpkZWJ1 Z0Rlc2NyaXB0aW9uKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsi LCBtX3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogeyIsIG1fZW5kLmRlYnVnRGVz Y3JpcHRpb24oKSwgIn0iKTsKKyAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsiLCBtX3N0 YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogICB7IiwgbV9lbmQuZGVidWdEZXNjcmlw dGlvbigpLCAifSIpOwogfQogCiBzdGQ6OnBhcnRpYWxfb3JkZXJpbmcgcGFydGlhbE9yZGVyKGNv bnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMSwgY29uc3QgQVhUZXh0TWFya2VyJiBtYXJrZXIyKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaCBi L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKaW5kZXggMTdlOWZj MGRhYjk4Li41OWY0ZjM3OTYzMTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0TWFya2VyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WFRleHRNYXJrZXIuaApAQCAtMTIzLDYgKzEyMyw3IEBAIHB1YmxpYzoKIAogICAgIEFYSUQgdHJl ZUlEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4VHJlZUlEKCk7IH0KICAgICBBWElEIG9iamVj dElEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4T2JqZWN0SUQoKTsgfQorICAgIHVuc2lnbmVk IG9mZnNldCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5vZmZzZXQ7IH0KICAgICBib29sIGlzTnVs bCgpIGNvbnN0IHsgcmV0dXJuICF0cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElEKCkuaXNW YWxpZCgpOyB9CiAgICAgUmVmUHRyPEFYQ29yZU9iamVjdD4gb2JqZWN0KCkgY29uc3Q7CiAgICAg Ym9vbCBpc1ZhbGlkKCkgY29uc3QgeyByZXR1cm4gb2JqZWN0KCk7IH0KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uYWU4N2EwNWVhMTQxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApAQCAtMCwwICsxLDExOCBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09O VFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisg KiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9S IElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICog QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNwcmFnbWEgb25jZQorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK2NsYXNzIFJlbmRlckJsb2NrOworCitzdHJ1Y3QgQVhUZXh0UnVuTGlu ZUlEIHsKKyAgICB2b2lkKiBjb250YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAgc2l6ZV90 IGxpbmVJbmRleCB7IDAgfTsKKworICAgIEFYVGV4dFJ1bkxpbmVJRCh2b2lkKiBjb250YWluaW5n QmxvY2ssIHNpemVfdCBsaW5lSW5kZXgpCisgICAgICAgIDogY29udGFpbmluZ0Jsb2NrKGNvbnRh aW5pbmdCbG9jaykKKyAgICAgICAgLCBsaW5lSW5kZXgobGluZUluZGV4KQorICAgIHsgfQorICAg IGJvb2wgb3BlcmF0b3I9PShjb25zdCBBWFRleHRSdW5MaW5lSUQmKSBjb25zdCA9IGRlZmF1bHQ7 CisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAorICAgIHsKKyAgICAgICAgVGV4 dFN0cmVhbSBzdHJlYW07CisgICAgICAgIHN0cmVhbSA8PCAiTGluZUlEICIgPDwgY29udGFpbmlu Z0Jsb2NrIDw8ICIgIiA8PCBsaW5lSW5kZXg7CisgICAgICAgIHJldHVybiBzdHJlYW0ucmVsZWFz ZSgpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW4geworICAgIC8vIFRoZSBsaW5lIGlu ZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUgY29udGFpbmluZyBSZW5k ZXJCbG9jayBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0LgorICAgIHNpemVfdCBsaW5lSW5k ZXg7CisgICAgU3RyaW5nIHRleHQ7CisKKyAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJbmRleCwg U3RyaW5nJiYgdGV4dCkKKyAgICAgICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQorICAgICAgICAs IHRleHQoV1RGTW92ZSh0ZXh0KSkKKyAgICB7IH0KKworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0 aW9uKHZvaWQqIGNvbnRhaW5pbmdCbG9jaykgY29uc3QKKyAgICB7CisgICAgICAgIEFYVGV4dFJ1 bkxpbmVJRCBsaW5lSUQgPSB7IGNvbnRhaW5pbmdCbG9jaywgbGluZUluZGV4IH07CisgICAgICAg IHJldHVybiBtYWtlU3RyaW5nKGxpbmVJRC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICI6IHwiLCBtYWtl U3RyaW5nQnlSZXBsYWNpbmdBbGwodGV4dCwgJ1xuJywgIntuZXdsaW5lfSJfcyksICJ8KGxlbiAi LCB0ZXh0Lmxlbmd0aCgpLCAiKSIpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW5zIHsK KyAgICAvLyBUaGUgY29udGFpbmluZyBibG9jayBmb3IgdGhlIHRleHQgcnVucy4gVGhpcyBpcyBy ZXF1aXJlZCBiZWNhdXNlIGJhc2VkIG9uIHRoZSBzdHJ1Y3R1cmUKKyAgICAvLyBvZiB0aGUgQVgg dHJlZSwgdGV4dCBydW5zIGZvciBkaWZmZXJlbnQgb2JqZWN0cyBjYW4gaGF2ZSB0aGUgc2FtZSBs aW5lIGluZGV4IGJ1dCBkaWZmZXJlbnQKKyAgICAvLyBjb250YWluaW5nIGJsb2NrcywgbWVhbmlu ZyB0aGV5IGFyZSByZW5kZXJlZCBvbiBkaWZmZXJlbnQgbGluZXMuCisgICAgLy8gRG8gbm90IGRl LXJlZmVyZW5jZS4gVXNlIGZvciBjb21wYXJpc29uIHB1cnBvc2VzIG9ubHkuCisgICAgdm9pZCog Y29udGFpbmluZ0Jsb2NrIHsgbnVsbHB0ciB9OworICAgIFZlY3RvcjxBWFRleHRSdW4+IHJ1bnM7 CisKKyAgICBBWFRleHRSdW5zKCkgPSBkZWZhdWx0OworICAgIEFYVGV4dFJ1bnMoUmVuZGVyQmxv Y2sqIGNvbnRhaW5pbmdCbG9jaywgVmVjdG9yPEFYVGV4dFJ1bj4mJiBydW5zKQorICAgICAgICA6 IGNvbnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgcnVucyhXVEZNb3Zl KHJ1bnMpKQorICAgIHsgfQorCisgICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IHJldHVybiBydW5z LnNpemUoKTsgfQorICAgIHVuc2lnbmVkIHJ1bkxlbmd0aChzaXplX3QgaW5kZXgpIGNvbnN0Cisg ICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAg ICAgcmV0dXJuIHJ1bnNbaW5kZXhdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2lnbmVk IGxhc3RSdW5MZW5ndGgoKSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKHJ1bnMuaXNFbXB0eSgp KQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIHJldHVybiBydW5zW3J1bnMuc2l6ZSgp IC0gMV0udGV4dC5sZW5ndGgoKTsKKyAgICB9CisgICAgQVhUZXh0UnVuTGluZUlEIGxpbmVJRChz aXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8 IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHsgY29udGFpbmluZ0Jsb2NrLCBydW5zW2lu ZGV4XS5saW5lSW5kZXggfTsKKyAgICB9CisgICAgY29uc3QgQVhUZXh0UnVuJiBvcGVyYXRvcltd KHNpemVfdCBydW5JbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKHJ1 bkluZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICByZXR1cm4gcnVuc1tydW5JbmRleF07Cisg ICAgfQorICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKKyAgICB7CisgICAgICAg IFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgICAgICByZXN1bHQuYXBwZW5kKCdbJyk7CisgICAg ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAg ICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0uZGVidWdEZXNjcmlwdGlvbihjb250YWluaW5nQmxv Y2spKTsKKyAgICAgICAgICAgIGlmIChpICE9IHJ1bnMuc2l6ZSgpIC0gMSkKKyAgICAgICAgICAg ICAgICByZXN1bHQuYXBwZW5kKCIsICIpOworICAgICAgICB9CisgICAgICAgIHJlc3VsdC5hcHBl bmQoJ10nKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdC50b1N0cmluZygpOworICAgIH0KK307CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRf QVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eU9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxp dHlPYmplY3QuY3BwCmluZGV4IGVmMDg3NzA1OGZlYi4uMDZkYTg5OTU5OWMwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAK QEAgLTExMyw2ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppbml0KCkKICAg ICBtX3JvbGUgPSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5Um9sZSgpOwogfQogCitBWElEIEFjY2Vz c2liaWxpdHlPYmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7CisgICAgYXV0byogY2FjaGUgPSBheE9i amVjdENhY2hlKCk7CisgICAgcmV0dXJuIGNhY2hlID8gY2FjaGUtPnRyZWVJRCgpIDogQVhJRCgp OworfQorCiBpbmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByb2Nlc3NJRCgp IGNvbnN0CiB7CiAgICAgcmV0dXJuIHByZXNlbnRpbmdBcHBsaWNhdGlvblBJRCgpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAppbmRl eCA1ZDg4Y2M2MTI4YzMuLmM1YmIzOTUyOTMyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNw cmFnbWEgb25jZQogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0 UnVuLmgiCiAjaW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2UuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQu aCIKICNpbmNsdWRlICJMYXlvdXRSZWN0LmgiCkBAIC02Myw2ICs2NCw3IEBAIGNsYXNzIEFjY2Vz c2liaWxpdHlPYmplY3QgOiBwdWJsaWMgQVhDb3JlT2JqZWN0LCBwdWJsaWMgQ2FuTWFrZVdlYWtQ dHI8QWNjZXNzaWJpCiBwdWJsaWM6CiAgICAgdmlydHVhbCB+QWNjZXNzaWJpbGl0eU9iamVjdCgp OwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbDsKICAgICBQcm9jZXNzSUQgcHJvY2Vz c0lEKCkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBA IC0zODAsNiArMzgyLDkgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5kZXJFbGVtZW50KEFj Y2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJF bGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0KICAgICBTdHJpbmcg dGV4dCgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIHVuc2lnbmVkIHRleHRM ZW5ndGgoKSBjb25zdCBmaW5hbDsKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAg ICB2aXJ0dWFsIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KKyNlbmRpZgog I2lmIFBMQVRGT1JNKENPQ09BKQogICAgIC8vIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyBh bmQgQVhPYmplY3Qgd3JhcHBlcnMgY29ycmVzcG9uZGluZyB0byB0aGUKICAgICAvLyB0ZXh0cnVu cyBhbmQgcmVwbGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQgaW4gdGhlIGdpdmVuIHJhbmdlLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5jcHAKaW5kZXggMzhhNGFhZjY1N2YyLi45OGU4NDAyZTM2YTMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0LmNwcApAQCAtMTM5NSwxMSArMTM5NSwxMSBAQCBDaGFyYWN0ZXJSYW5nZSBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRleHRSYW5nZSgpIGNvbnN0CiB9CiAKICNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLVZlY3RvcjxBWFRleHRSdW4+IEFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FYVGV4dFJ1bnMgQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdDo6dGV4dFJ1bnMoKQogewogICAgIGlmIChhdXRvKiByZW5kZXJMaW5lQnJlYWsg PSBkeW5hbWljRG93bmNhc3Q8UmVuZGVyTGluZUJyZWFrPihyZW5kZXJlcigpKSkgewogICAgICAg ICBhdXRvIGJveCA9IElubGluZUl0ZXJhdG9yOjpib3hGb3IoKnJlbmRlckxpbmVCcmVhayk7Ci0g ICAgICAgIHJldHVybiB7IHsgYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKSB9IH07 CisgICAgICAgIHJldHVybiB7IHJlbmRlckxpbmVCcmVhay0+Y29udGFpbmluZ0Jsb2NrKCksIHsg QVhUZXh0UnVuKGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJpbmcoJ1xuJykuaXNvbGF0ZWRDb3B5 KCkpIH0gfTsKICAgICB9CiAKICAgICBXZWFrUHRyIHJlbmRlclRleHQgPSBkeW5hbWljRG93bmNh c3Q8UmVuZGVyVGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0xNDUyLDcgKzE0NTIsNyBAQCBWZWN0b3I8 QVhUZXh0UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCiAKICAgICBp ZiAoIWxpbmVTdHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBydW5zLmFwcGVuZCh7IGN1cnJlbnRM aW5lSW5kZXgsIGxpbmVTdHJpbmcudG9TdHJpbmcoKS5pc29sYXRlZENvcHkoKSB9KTsKLSAgICBy ZXR1cm4gcnVuczsKKyAgICByZXR1cm4geyByZW5kZXJUZXh0LT5jb250YWluaW5nQmxvY2soKSwg V1RGTW92ZShydW5zKSB9OwogfQogI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdC5oCmluZGV4IGNlZWM2YmYzZTg5OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuaApAQCAtMTAwLDcgKzEwMCw3IEBAIHB1YmxpYzoKICAgICBTdHJpbmcgdGV4 dFVuZGVyRWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3Np YmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5n IHNlbGVjdGVkVGV4dCgpIGNvbnN0IG92ZXJyaWRlOwogI2lmIEVOQUJMRShBWF9USFJFQURfVEVY VF9BUElTKQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWw7CisgICAgQVhU ZXh0UnVucyB0ZXh0UnVucygpIGZpbmFsOwogI2VuZGlmCiAKICAgICBib29sIGlzV2lkZ2V0KCkg Y29uc3Qgb3ZlcnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCmluZGV4IDYyYTFhNTc1 YWU2MS4uMzQ1ZjJkNTNkZjU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcApAQCAtMzEs NiArMzEsNyBAQAogI2luY2x1ZGUgIkFYR2VvbWV0cnlNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiQVhJ c29sYXRlZFRyZWUuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1 bi5oIgogCiAjaWYgUExBVEZPUk0oTUFDKQogI2ltcG9ydCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNl c1NQSS5oPgpAQCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQgQVhJc29sYXRlZE9iamVjdDo6c2V0UHJv cGVydHkoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWCiAgICAg ICAgIFtdKHN0ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJSYW5nZT4mIHR5cGVkVmFsdWUpIHsKICAg ICAgICAgICAgIHJldHVybiAhdHlwZWRWYWx1ZS5maXJzdC5pc1ZhbGlkKCkgJiYgIXR5cGVkVmFs dWUuc2Vjb25kLmxvY2F0aW9uICYmICF0eXBlZFZhbHVlLnNlY29uZC5sZW5ndGg7CiAgICAgICAg IH0sCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgICAgIFtdKEFYVGV4dFJ1 bnMgcnVucykgeyByZXR1cm4gIXJ1bnMuc2l6ZSgpOyB9LAorI2VuZGlmCiAgICAgICAgIFtdKGF1 dG8mKSB7CiAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKQEAgLTU1Nyw2ICs1NjEsMTkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0Ojpz ZXRTZWxlY3RlZENoaWxkcmVuKGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2UK ICAgICB9KTsKIH0KIAorQVhDb3JlT2JqZWN0KiBBWElzb2xhdGVkT2JqZWN0OjpzaWJsaW5nKEFY RGlyZWN0aW9uIGRpcmVjdGlvbikgY29uc3QKK3sKKyAgICBSZWZQdHIgcGFyZW50ID0gcGFyZW50 T2JqZWN0VW5pZ25vcmVkKCk7CisgICAgY29uc3QgYXV0byYgc2libGluZ3MgPSBwYXJlbnQtPmNo aWxkcmVuKCk7CisgICAgc2l6ZV90IGluZGV4T2ZUaGlzID0gc2libGluZ3MuZmluZCh0aGlzKTsK KyAgICBpZiAoaW5kZXhPZlRoaXMgPT0gbm90Rm91bmQpCisgICAgICAgIHJldHVybiBudWxscHRy OworCisgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAgICAgICAgcmV0 dXJuIGluZGV4T2ZUaGlzICsgMSA8IHNpYmxpbmdzLnNpemUoKSA/IHNpYmxpbmdzW2luZGV4T2ZU aGlzICsgMV0uZ2V0KCkgOiBudWxscHRyOworICAgIHJldHVybiBpbmRleE9mVGhpcyA+IDAgPyBz aWJsaW5nc1tpbmRleE9mVGhpcyAtIDFdLmdldCgpIDogbnVsbHB0cjsKK30KKwogYm9vbCBBWElz b2xhdGVkT2JqZWN0Ojppc0RldGFjaGVkRnJvbVBhcmVudCgpCiB7CiAgICAgaWYgKHBhcmVudCgp LmlzVmFsaWQoKSkKQEAgLTk3MSw2ICs5ODgsMTkgQEAgaW50IEFYSXNvbGF0ZWRPYmplY3Q6Omlu dEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkgY29uc3QKICAgICAp OwogfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitjb25zdCBBWFRleHRSdW5z KiBBWElzb2xhdGVkT2JqZWN0Ojp0ZXh0UnVucygpIGNvbnN0Cit7CisgICAgYXV0byBlbnRyeSA9 IG1fcHJvcGVydHlNYXAuZmluZChBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMpOworICAgIGlmIChl bnRyeSA9PSBtX3Byb3BlcnR5TWFwLmVuZCgpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAg ICByZXR1cm4gV1RGOjpzd2l0Y2hPbihlbnRyeS0+dmFsdWUsCisgICAgICAgIFtdIChjb25zdCBB WFRleHRSdW5zJiB0eXBlZFZhbHVlKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiAmdHlw ZWRWYWx1ZTsgfSwKKyAgICAgICAgW10gKGF1dG8mKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJl dHVybiBudWxscHRyOyB9CisgICAgKTsKK30KKyNlbmRpZgorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBU PgogVCBBWElzb2xhdGVkT2JqZWN0OjpnZXRPclJldHJpZXZlUHJvcGVydHlWYWx1ZShBWFByb3Bl cnR5TmFtZSBwcm9wZXJ0eU5hbWUpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKaW5kZXggYTZj YTAzNDM3NzdkLi44ZDk0YWQyYmQ5ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKQEAgLTQ0 LDYgKzQ0LDkgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQVhJc29sYXRlZFRyZWU7 CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitzdHJ1Y3QgQVhUZXh0UnVuczsKKyNl bmRpZgogCiBjbGFzcyBBWElzb2xhdGVkT2JqZWN0IGZpbmFsIDogcHVibGljIEFYQ29yZU9iamVj dCB7CiAgICAgZnJpZW5kIGNsYXNzIEFYSXNvbGF0ZWRUcmVlOwpAQCAtNTEsNyArNTQsOSBAQCBw dWJsaWM6CiAgICAgc3RhdGljIFJlZjxBWElzb2xhdGVkT2JqZWN0PiBjcmVhdGUoY29uc3QgUmVm PEFjY2Vzc2liaWxpdHlPYmplY3Q+JiwgQVhJc29sYXRlZFRyZWUqKTsKICAgICB+QVhJc29sYXRl ZE9iamVjdCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVl KCktPnRyZWVJRCgpOyB9CiAgICAgUHJvY2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0IGZpbmFsIHsg cmV0dXJuIHRyZWUoKS0+cHJvY2Vzc0lEKCk7IH0KKyAgICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xl VmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5Um9s ZT4oaW50QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVWYWx1ZSkpOyB9CiAgICAg U3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCiAgICAgdm9pZCBhdHRhY2hQbGF0Zm9ybVdyYXBw ZXIoQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIqKTsKQEAgLTU5LDEwICs2NCwxNyBAQCBwdWJs aWM6CiAgICAgYm9vbCBpc1RhYmxlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0 ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc1RhYmxlKTsgfQogICAgIGJvb2wgaXNFeHBvc2FibGUo KSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6 OklzRXhwb3NhYmxlKTsgfQogCisgICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y JiBjaGlsZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQgPSB0cnVlKSBmaW5hbDsKKyAg ICBBWENvcmVPYmplY3QqIHNpYmxpbmcoQVhEaXJlY3Rpb24pIGNvbnN0OwogICAgIEFYSXNvbGF0 ZWRPYmplY3QqIHBhcmVudE9iamVjdCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHBhcmVudE9iamVj dFVuaWdub3JlZCgpOyB9CisgICAgQVhJc29sYXRlZE9iamVjdCogcGFyZW50T2JqZWN0VW5pZ25v cmVkKCkgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogZWRpdGFibGVBbmNlc3Rv cigpIGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6OmVkaXRhYmxlQW5jZXN0b3IoKnRoaXMp OyB9OwogICAgIGJvb2wgY2FuU2V0Rm9jdXNBdHRyaWJ1dGUoKSBjb25zdCBmaW5hbCB7IHJldHVy biBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OkNhblNldEZvY3VzQXR0cmlidXRl KTsgfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgY29uc3QgQVhUZXh0 UnVucyogdGV4dFJ1bnMoKSBjb25zdDsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIHZvaWQgZGV0 YWNoUmVtb3RlUGFydHMoQWNjZXNzaWJpbGl0eURldGFjaG1lbnRUeXBlKSBmaW5hbDsKICAgICB2 b2lkIGRldGFjaFBsYXRmb3JtV3JhcHBlcihBY2Nlc3NpYmlsaXR5RGV0YWNobWVudFR5cGUpIGZp bmFsOwpAQCAtMjQzLDcgKzI1NSw2IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPFN0cmluZz4gZGV0 ZXJtaW5lRHJvcEVmZmVjdHMoKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBh Y2Nlc3NpYmlsaXR5SGl0VGVzdChjb25zdCBJbnRQb2ludCYpIGNvbnN0IGZpbmFsOwogICAgIEFY SXNvbGF0ZWRPYmplY3QqIGZvY3VzZWRVSUVsZW1lbnQoKSBjb25zdCBmaW5hbDsKLSAgICBBWElz b2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKSBjb25zdCBmaW5hbDsKICAgICBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbGlua2VkT2JqZWN0cygpIGNvbnN0IGZpbmFsIHsg cmV0dXJuIHRyZWUoKS0+b2JqZWN0c0ZvcklEcyh2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWElEPihB WFByb3BlcnR5TmFtZTo6TGlua2VkT2JqZWN0cykpOyB9CiAgICAgQVhJc29sYXRlZE9iamVjdCog dGl0bGVVSUVsZW1lbnQoKSBjb25zdCBmaW5hbCB7IHJldHVybiBvYmplY3RBdHRyaWJ1dGVWYWx1 ZShBWFByb3BlcnR5TmFtZTo6VGl0bGVVSUVsZW1lbnQpOyB9CiAgICAgQVhJc29sYXRlZE9iamVj dCogc2Nyb2xsQmFyKEFjY2Vzc2liaWxpdHlPcmllbnRhdGlvbikgZmluYWw7CkBAIC0yNTEsNyAr MjYyLDYgQEAgcHJpdmF0ZToKICAgICBTdHJpbmcgZXhwYW5kZWRUZXh0VmFsdWUoKSBjb25zdCBm aW5hbCB7IHJldHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6RXhwYW5k ZWRUZXh0VmFsdWUpOyB9CiAgICAgYm9vbCBzdXBwb3J0c0V4cGFuZGVkVGV4dFZhbHVlKCkgY29u c3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpTdXBw b3J0c0V4cGFuZGVkVGV4dFZhbHVlKTsgfQogICAgIFNSR0JBPHVpbnQ4X3Q+IGNvbG9yVmFsdWUo KSBjb25zdCBmaW5hbDsKLSAgICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdCBm aW5hbCB7IHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5Um9sZT4oaW50QXR0cmlidXRl VmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVWYWx1ZSkpOyB9CiAgICAgU3RyaW5nIHJvbGVQbGF0 Zm9ybVN0cmluZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFY UHJvcGVydHlOYW1lOjpSb2xlUGxhdGZvcm1TdHJpbmcpOyB9CiAgICAgU3RyaW5nIHJvbGVEZXNj cmlwdGlvbigpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJv cGVydHlOYW1lOjpSb2xlRGVzY3JpcHRpb24pOyB9CiAgICAgU3RyaW5nIHN1YnJvbGVQbGF0Zm9y bVN0cmluZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJv cGVydHlOYW1lOjpTdWJyb2xlUGxhdGZvcm1TdHJpbmcpOyB9CkBAIC0zMTYsNyArMzI2LDYgQEAg cHJpdmF0ZToKICAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgdmlzaWJsZUNoaWxkcmVu KCkgZmluYWwgeyByZXR1cm4gdHJlZSgpLT5vYmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZh bHVlPEFYSUQ+KEFYUHJvcGVydHlOYW1lOjpWaXNpYmxlQ2hpbGRyZW4pKTsgfQogICAgIEF0b21T dHJpbmcgdGFnTmFtZSgpIGNvbnN0IGZpbmFsOwogICAgIHZvaWQgc2V0Q2hpbGRyZW5JRHMoVmVj dG9yPEFYSUQ+JiYpOwotICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hp bGRyZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVlZGVkID0gdHJ1ZSkgZmluYWw7CiAgICAgdm9p ZCB1cGRhdGVDaGlsZHJlbklmTmVjZXNzYXJ5KCkgZmluYWw7CiAgICAgYm9vbCBpc0RldGFjaGVk RnJvbVBhcmVudCgpIGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGxpdmVSZWdpb25BbmNl c3Rvcihib29sIGV4Y2x1ZGVJZk9mZiA9IHRydWUpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIEFjY2Vz c2liaWxpdHk6OmxpdmVSZWdpb25BbmNlc3RvcigqdGhpcywgZXhjbHVkZUlmT2ZmKTsgfQpAQCAt MzQ1LDkgKzM1NCw2IEBAIHByaXZhdGU6CiAKICAgICAvLyBDaGFyYWN0ZXJSYW5nZSBzdXBwb3J0 LgogICAgIENoYXJhY3RlclJhbmdlIHNlbGVjdGVkVGV4dFJhbmdlKCkgY29uc3QgZmluYWwgeyBy ZXR1cm4gcHJvcGVydHlWYWx1ZTxDaGFyYWN0ZXJSYW5nZT4oQVhQcm9wZXJ0eU5hbWU6OlNlbGVj dGVkVGV4dFJhbmdlKTsgfQotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIFZl Y3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWwgeyByZXR1cm4gdmVjdG9yQXR0cmlidXRl VmFsdWU8QVhUZXh0UnVuPihBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMpOyB9Ci0jZW5kaWYKICAg ICBpbnQgaW5zZXJ0aW9uUG9pbnRMaW5lTnVtYmVyKCkgY29uc3QgZmluYWw7CiAgICAgQ2hhcmFj dGVyUmFuZ2UgZG9BWFJhbmdlRm9yTGluZSh1bnNpZ25lZCkgY29uc3QgZmluYWw7CiAgICAgU3Ry aW5nIGRvQVhTdHJpbmdGb3JSYW5nZShjb25zdCBDaGFyYWN0ZXJSYW5nZSYpIGNvbnN0IGZpbmFs OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0 cmVlL0FYSXNvbGF0ZWRUcmVlLmgKaW5kZXggZjExZWY4NTU1YTE0Li45NDUwMjllMDcwNmQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNv bGF0ZWRUcmVlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRy ZWUvQVhJc29sYXRlZFRyZWUuaApAQCAtMjU1LDcgKzI1NSw3IEBAIHVzaW5nIEFYUHJvcGVydHlW YWx1ZVZhcmlhbnQgPSBzdGQ6OnZhcmlhbnQ8c3RkOjpudWxscHRyX3QsIEFYSUQsIFN0cmluZywg Ym9vbCwKICAgICAsIFJldGFpblB0cjxOU0F0dHJpYnV0ZWRTdHJpbmc+CiAjZW5kaWYKICNpZiBF TkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICAsIFZlY3RvcjxBWFRleHRSdW4+CisgICAg LCBBWFRleHRSdW5zCiAjZW5kaWYKID47CiB1c2luZyBBWFByb3BlcnR5TWFwID0gSGFzaE1hcDxB WFByb3BlcnR5TmFtZSwgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCwgSW50SGFzaDxBWFByb3BlcnR5 TmFtZT4sIFdURjo6U3Ryb25nRW51bUhhc2hUcmFpdHM8QVhQcm9wZXJ0eU5hbWU+PjsK 469122 2023-12-18 18:38:11 -0800 2023-12-19 15:54:57 -0800 Patch bug-266521-20231218183810.patch text/plain 43931 tyler_w RnJvbSA0YThlZGFhMDUyMWVmMzgyNGI0NDQ1NDAyZWY3MTM3Y2RjODU1MTc1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Q2hyaXMgRmxlaXphY2guCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDIyNyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8IDEwNCArKysrKysrKwogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwIHwgICAyICstCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oICAgfCAgIDEgKwogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFRleHRSdW4uaCAgICAgIHwgMTI1ICsrKysrKysrKysKIC4uLi9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwICAgICB8ICAgNiArCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmggICAgICAgfCAgIDUgKwogLi4uL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwICAgICAgICAgICAgIHwgICA2ICstCiAuLi4vYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggfCAgIDIgKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5jcHAgICAgICAgICB8ICAzMCArKysKIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkVHJlZS5oICAgICAgICAgICAgIHwgICAyICstCiAxNiBmaWxlcyBjaGFuZ2VkLCA1MzIgaW5z ZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFNv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiBjcmVhdGUgbW9kZSAxMDA2 NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNt YWtlCmluZGV4IGNjNmM0YTMxZTZkNS4uMzkzNDRkMGM4MGNlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UK QEAgLTY1MCw3ICs2NTAsOSBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09SS19IRUFERVJT CiAgICAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5oCiAgICAgYWNjZXNzaWJpbGl0 eS9BWExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKyAgICBhY2Nl c3NpYmlsaXR5L0FYUG9zaXRpb24uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgK KyAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRT dGF0ZUNoYW5nZUludGVudC5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRyZWVTdG9yZS5oCiAgICAg YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5TGlzdEJveC5oCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CmluZGV4IGQz MDJkMzJlYTc2Yi4uNWJjYmYwNTdjNjg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dApAQCAtNTIxLDYgKzUyMSw3 IEBAIGFjY2Vzc2liaWxpdHkvQVhHZW9tZXRyeU1hbmFnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FY SW1hZ2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNjZXNzaWJpbGl0eS9BWE9i amVjdENhY2hlLmNwcAorYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogYWNjZXNzaWJpbGl0 eS9BWFRleHRNYXJrZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZC5j cHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5jcHAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3Zjgx ODJmMDhhZGMuLjAzZjMyMjZmZWUzNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTc1MCw3ICsxNzUwLDkgQEAKIAkJNDdGOTQ3 REIyNjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5 NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJs ZUZvcm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dl b21ldHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJNDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMz QTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKKwkJNDg2MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJE MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVU RVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFY R2VvbWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQy QTJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0 UnVuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ NDhCNUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0Lmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5 Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlF MDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBF bGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCTQ5M0U1RTA5MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNB TGF5ZXJDbGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDQ5M0U1RTA4MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjAs OCArMTA3MjIsMTEgQEAKIAkJNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0 dGluZ0dlb21ldHJ5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFRhYmxlRm9y bWF0dGluZ0dlb21ldHJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4MjI5NzBC MjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk0ODIyOTcwQzI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZWdpb25Db250ZXh0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0 aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYUG9zaXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDg2MUUwQkUyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gQVhQb3NpdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0ODZCOERDODJBMDQ1MDBGMDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQVhHZW9tZXRyeU1hbmFnZXIuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIg LyogQVhUZXh0UnVuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYVGV4dFJ1bi5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0 eVJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNz aWJpbGl0eVJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzYyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1l bnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250 ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE4Niw4ICsyMzE5MSwxMSBA QAogCQkJCUMwNDkzRUI3MjQ0Njk5RTQwMDlBQUM4MCAvKiBBWExvZ2dlci5oICovLAogCQkJCTI5 ODFDQUFGMTMxODIyRUMwMEQxMkYyQSAvKiBBWE9iamVjdENhY2hlLmNwcCAqLywKIAkJCQkyOUE4 MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5oICovLAorCQkJCTQ4NjFFMEJF MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLywKKwkJCQk0ODYxRTBCRDJCMjAw NzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMw RDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICovLAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUzQkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0 YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFEQzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFY VHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYwNTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFj Y2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1NzcsNyArMzc1ODUsOSBAQAogCQkJCTI5QUUy MTM1MjFBQkE0OEEwMDg2OTI4MyAvKiBBWElzb2xhdGVkT2JqZWN0LmggaW4gSGVhZGVycyAqLywK IAkJCQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRyZWUuaCBpbiBIZWFk ZXJzICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmgg aW4gSGVhZGVycyAqLywKKwkJCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlv bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzBFMjA4QTIyOTM3OUM2RjAwQzBEMkQzIC8qIEFYVGV4 dE1hcmtlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNDhCMDI0MkEyQjJBNjVBQTAwODNEMTIyIC8q IEFYVGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTFDOUYyRjkxQUUzQkVCMDAwOTVCNjFD IC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEU4QURD NTI5NEI1QTYzMDA3NkNCREMgLyogQVhUcmVlU3RvcmUuaCBpbiBIZWFkZXJzICovLAogCQkJCTE0 NzdFNzc3MEJGNDEzNEEwMDE1Mjg3MiAvKiBCYWNrRm9yd2FyZENhY2hlLmggaW4gSGVhZGVycyAq LywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0 LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCmluZGV4IDEw MTE0ZWNiNmRkOC4uOTkwY2RhOTgwNWMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhDb3JlT2JqZWN0LmgKQEAgLTExMCwxOSArMTEwLDYgQEAgZW51bSBjbGFzcyBBWEFuY2Vz dG9yRmxhZyA6IHVpbnQ4X3QgewogICAgIC8vIEJpdHMgNiBhbmQgNyBhcmUgZnJlZS4KIH07CiAK LSNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAg IC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUg Y29udGFpbmluZyBSZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4K LSAgICBzaXplX3QgbGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVu KHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxp bmVJbmRleCkKLSAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2Vu ZGlmCi0KIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0g MSwKICAgICBBcHBsaWNhdGlvbkFsZXJ0LApAQCAtNjUzLDYgKzY0MCw4IEBAIGVudW0gY2xhc3Mg QWNjZXNzaWJpbGl0eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3Mg QVhEaXJlY3Rpb24gOiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nl c3NpYmlsaXR5U29ydERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04 MDAsNiArNzg5LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQp IHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9p ZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQ cm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVz cG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTEx MDQsOSArMTA5NCw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRl eHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dy YW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZp cnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1 bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJp bmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBj b25zdCA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjQ1ZDE5MjgxN2M2ZAotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAKQEAgLTAsMCArMSwyMjcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorI2luY2x1ZGUgIkFY SXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRlICJBWElzb2xhdGVkVHJlZS5oIgorI2VuZGlmIC8v IEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCisjaW5jbHVkZSAiQVhPYmplY3RD YWNoZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0FYSXNvbGF0ZWRPYmplY3QqIEFYUG9z aXRpb246Om9iamVjdCgpIGNvbnN0Cit7CisgICAgUkVMRUFTRV9BU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAg aWYgKG1fY2FjaGVkT2JqZWN0KQorICAgICAgICByZXR1cm4gbV9jYWNoZWRPYmplY3QuZ2V0KCk7 CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorICAgIGF1dG8gdHJl ZSA9IHN0ZDo6Z2V0PFJlZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4VHJlZUZvcklEKHRyZWVJRCgp KSk7CisgICAgbV9jYWNoZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+b2JqZWN0Rm9ySUQob2JqZWN0 SUQoKSkgOiBudWxscHRyOworICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKKyNlbmRp ZgorfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZyb21UZXh0TWFya2VyKGNvbnN0IEFYVGV4 dE1hcmtlciYgbWFya2VyKQoreworICAgIHJldHVybiBBWFBvc2l0aW9uKG1hcmtlci50cmVlSUQo KSwgbWFya2VyLm9iamVjdElEKCksIG1hcmtlci5vZmZzZXQoKSApOworfQorCitBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdAoreworICAgIHJldHVybiB7IHsgdHJlZUlE KCksIG9iamVjdElEKCksIG51bGxwdHIsIG1fb2Zmc2V0IH0gfTsKK30KKworU3RyaW5nIEFYUG9z aXRpb246OmRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAgIGF1dG8gc2VwYXJhdG9yID0g IiwgIjsKKyAgICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+b2JqZWN0KCk7CisgICAgcmV0dXJuIG1h a2VTdHJpbmcoCisgICAgICAgICJ0cmVlSUQgIiwgdHJlZUlEKCkubG9nZ2luZ1N0cmluZygpCisg ICAgICAgICwgc2VwYXJhdG9yLCAib2JqZWN0SUQgIiwgb2JqZWN0SUQoKS5sb2dnaW5nU3RyaW5n KCkKKyAgICAgICAgLCBzZXBhcmF0b3IsICJyb2xlICIsIG9iamVjdCA/IGFjY2Vzc2liaWxpdHlS b2xlVG9TdHJpbmcob2JqZWN0LT5yb2xlVmFsdWUoKSkgOiBTdHJpbmcoIm5vIG9iamVjdCJfcykK KyAgICAgICAgLCBzZXBhcmF0b3IsICJvZmZzZXQgIiwgbV9vZmZzZXQKKyAgICApOworfQorCitl bnVtIGNsYXNzIENoZWNrU3RhcnQgOiBib29sIHsgTm8sIFllcyB9OworLy8gRmluZHMgdGhlIG5l eHQgb2JqZWN0IHdpdGggdGV4dCBydW5zIGluIHRoZSBnaXZlbiBkaXJlY3Rpb24uCitzdGF0aWMg UmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZpbmRPYmplY3RXaXRoUnVucyhBWElzb2xhdGVkT2Jq ZWN0JiBzdGFydCwgQVhEaXJlY3Rpb24gZGlyZWN0aW9uLCBDaGVja1N0YXJ0IGNoZWNrU3RhcnQg PSBDaGVja1N0YXJ0OjpObykKK3sKKyAgICBpZiAoY2hlY2tTdGFydCA9PSBDaGVja1N0YXJ0OjpZ ZXMpIHsKKyAgICAgICAgaWYgKGF1dG8qIHJ1bnMgPSBzdGFydC50ZXh0UnVucygpOyBydW5zICYm IHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAgIHJldHVybiAmc3RhcnQ7CisgICAgfQorCisgICAg UmVmUHRyIGN1cnJlbnQgPSAmc3RhcnQ7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAg aWYgKGN1cnJlbnQgIT0gJnN0YXJ0KSB7CisgICAgICAgICAgICBhdXRvKiBydW5zID0gY3VycmVu dC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgICAgIGlmIChydW5zICYmIHJ1bnMtPnNpemUoKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEZJ WE1FOiBhcmlhLW93bnMgYnJlYWtzIHRoaXMgdHJhdmVyc2FsLCBhcyBhcmlhLW93bnMgY2F1c2Vz IHRoZSBBWCB0cmVlIHRvIGJlIGNoYW5nZWQsIGFmZmVjdGluZworICAgICAgICAvLyBvdXIgaXRl cmF0aW9uIGJlbG93LCBidXQgaXQgZG9lc24ndCBhY3R1YWxseSBjaGFuZ2UgdGV4dCBwb3NpdGlv biBvbiB0aGUgcGFnZS4gU28gd2UgbmVlZCB0byBpZ25vcmUgYXJpYS1vd25zCisgICAgICAgIC8v IHRyZWUgY2hhbmdlcyBoZXJlIGluIG9yZGVyIHRvIGJlaGF2ZSBjb3JyZWN0bHkuCisgICAgICAg IC8vIFdlIGFsc28gcHJvYmFibHkgbmVlZCB0byBkbyBzb21ldGhpbmcgYWJvdXQgdGV4dCB3aXRo aW4gYXJpYS1oaWRkZW4gY29udGFpbmVycywgd2hpY2ggYWZmZWN0cyB0aGUgQVggdHJlZS4KKwor ICAgICAgICBjb25zdCBhdXRvJiBjaGlsZHJlbiA9IGN1cnJlbnQtPmNoaWxkcmVuKCk7CisgICAg ICAgIGlmIChjaGlsZHJlbi5zaXplKCkpIHsKKyAgICAgICAgICAgIHNpemVfdCBjaGlsZEluZGV4 ID0gZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6IGNoaWxkcmVuLnNpemUoKSAt IDE7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjaGlsZHJlbltjaGlsZEluZGV4XSk7Cisg ICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KGNo aWxkcmVuW2NoaWxkSW5kZXhdLmdldCgpKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICB9CisKKyAgICAgICAgLy8gYGN1cnJlbnRgIGhhcyBubyBjaGlsZHJlbiwgbWVhbmluZyBpdCdz IGEgbGVhZiBub2RlIChlLmcuIGl0J3MgdGV4dCwgd2hpY2ggY2Fubm90IGhhdmUgY2hpbGRyZW4p LgorICAgICAgICAvLyBDaGVjayBgY3VycmVudGBzIHNpYmxpbmdzLgorICAgICAgICBpZiAoYXV0 byogc2libGluZyA9IGN1cnJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSkgeworICAgICAgICAgICAg Y3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0PihzaWJsaW5nKTsKKyAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gV2UgaGF2ZSBubyBj aGlsZHJlbiwgYW5kIG5vIG5leHQvcHJldmlvdXMgc2libGluZy4gVHJ5IG91ciBwYXJlbnQncyBz aWJsaW5nLgorICAgICAgICBpZiAoYXV0byogcGFyZW50ID0gY3VycmVudC0+cGFyZW50T2JqZWN0 VW5pZ25vcmVkKCkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJ c29sYXRlZE9iamVjdD4ocGFyZW50LT5zaWJsaW5nKGRpcmVjdGlvbikpOworICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJu IG51bGxwdHI7Cit9CisKK0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGly ZWN0aW9uIGRpcmVjdGlvbikgY29uc3QKK3sKKyAgICBpZiAoIW9iamVjdCgpKQorICAgICAgICBy ZXR1cm4gbnVsbFBvc2l0aW9uKCk7CisgICAgYXV0byBydW5Gcm9tT2Zmc2V0ID0gdGhpcy0+cnVu RnJvbU9mZnNldCgpOworICAgIGNvbnN0IGF1dG8qIHJ1bnMgPSBydW5Gcm9tT2Zmc2V0Lm9iamVj dC0+dGV4dFJ1bnMoKTsKKworICAgIGF1dG8gaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4gPSBbJiwg dGhpc10geworICAgICAgICBpZiAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0KQorICAg ICAgICAgICAgcmV0dXJuIG1fb2Zmc2V0IDwgcnVuRnJvbU9mZnNldC5ydW4oKS50ZXh0Lmxlbmd0 aCgpOworICAgICAgICByZXR1cm4gbV9vZmZzZXQgPiAwOworICAgIH07CisgICAgYm9vbCBoYXNB bm90aGVyUnVuID0gcnVuRnJvbU9mZnNldC5pbmRleCArIDEgPCBydW5zLT5zaXplKCk7CisgICAg Ly8gVGhlIG5leHQgcnVuIHNob3VsZCBub3QgaGF2ZSBlbXB0eSB0ZXh0LCBiZWNhdXNlIHdlJ3Jl IGdvaW5nIHRvIHJldHVybiBhIHBvc2l0aW9uIGNvbnRhaW5pbmcgbV9vZmZzZXQgKyAxLCB3aGlj aCB3b3VsZCBiZSB3cm9uZy4KKyAgICBSRUxFQVNFX0FTU0VSVChkaXJlY3Rpb24gPT0gQVhEaXJl Y3Rpb246OlByZXZpb3VzIHx8ICFoYXNBbm90aGVyUnVuIHx8IHJ1bnMtPnJ1bkxlbmd0aChydW5G cm9tT2Zmc2V0LmluZGV4ICsgMSkgPiAwKTsKKyAgICAvLyBDaGVja2luZyBmb3IgdGhlIHByZXNl bmNlIG9mIGFub3RoZXIgcnVuIGlzIG9ubHkgcmVsZXZhbnQgZm9yIG1vdmluZyBBWERpcmVjdGlv bjo6TmV4dCwgYXMganVzdCBjaGVja2luZyB0aGF0IG1fb2Zmc2V0ID4gMCBpcyBzdWZmaWNpZW50 IGZvciBBWERpcmVjdGlvbjo6UHJldmlvdXMuCisgICAgaWYgKGhhc01vcmVUZXh0SW5DdXJyZW50 UnVuKCkgfHwgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCAmJiBoYXNBbm90aGVyUnVu KSkgeworICAgICAgICAvLyBSZXR1cm4gYW4gb2Zmc2V0IHRvIHRoZSBuZXh0IGNoYXJhY3RlciBp biB0aGUgY3VycmVudCBydW4uCisgICAgICAgIHJldHVybiBBWFBvc2l0aW9uKHJ1bkZyb21PZmZz ZXQudHJlZUlEKCksIHJ1bkZyb21PZmZzZXQub2JqZWN0SUQoKSwgZGlyZWN0aW9uID09IEFYRGly ZWN0aW9uOjpOZXh0ID8gbV9vZmZzZXQgKyAxIDogbV9vZmZzZXQgLSAxKTsKKyAgICB9CisgICAg Ly8gbV9vZmZzZXQgcG9pbnRlZCB0byB0aGUgbGFzdCBjaGFyYWN0ZXIgaW4gdGhlIGdpdmVuIG9i amVjdCdzIHJ1bnMsIHNvIGxldCdzIHRyYXZlcnNlIHRvIGZpbmQgdGhlIG5leHQgb2JqZWN0IHdp dGggcnVucy4KKyAgICBpZiAoUmVmUHRyIG9iamVjdCA9IGZpbmRPYmplY3RXaXRoUnVucyhydW5G cm9tT2Zmc2V0Lm9iamVjdC5nZXQoKSwgZGlyZWN0aW9uKSkKKyAgICAgICAgcmV0dXJuIEFYUG9z aXRpb24ob2JqZWN0LT50cmVlSUQoKSwgb2JqZWN0LT5vYmplY3RJRCgpLCBkaXJlY3Rpb24gPT0g QVhEaXJlY3Rpb246Ok5leHQgPyAwIDogb2JqZWN0LT50ZXh0UnVucygpLT5sYXN0UnVuTGVuZ3Ro KCkpOworCisgICAgcmV0dXJuIG51bGxQb3NpdGlvbigpOworfQorCitBWFBvc2l0aW9uIEFYUG9z aXRpb246OmZpbmRQb3NpdGlvbihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4 dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoIW9i amVjdCgpKQorICAgICAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7CisKKyAgICBpZiAodGV4dFVu aXQgPT0gQVhUZXh0VW5pdDo6TGluZSkgeworICAgICAgICBhdXRvIHJ1bkZyb21PZmZzZXQgPSB0 aGlzLT5ydW5Gcm9tT2Zmc2V0KCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2JqZWN0ID0gV1RG TW92ZShydW5Gcm9tT2Zmc2V0Lm9iamVjdCk7CisgICAgICAgIGNvbnN0IGF1dG8qIGN1cnJlbnRS dW5zID0gY3VycmVudE9iamVjdC0+dGV4dFJ1bnMoKTsKKworICAgICAgICBhdXRvIGNvbXB1dGVP ZmZzZXQgPSBbJl0gKHNpemVfdCBydW5FbmRPZmZzZXQsIHNpemVfdCBydW5MZW5ndGgpIHsKKyAg ICAgICAgICAgIC8vIFRoaXMgd29ya3MgYmVjYXVzZSBgcnVuRW5kT2Zmc2V0YCBpcyB0aGUgb2Zm c2V0IHBvaW50aW5nIHRvIHRoZSBlbmQgb2YgdGhlIGdpdmVuIHJ1biwgd2hpY2ggaW5jbHVkZXMg dGhlIGxlbmd0aCBvZiBhbGwgcnVucyBwcmVjZWRpbmcgaXQuIFNvIHN1YnRyYWN0aW5nIHRoYXQg ZnJvbSB0aGUgbGVuZ3RoIG9mIHRoZSBjdXJyZW50IHJ1biBnaXZlcyB1cyBhbiBvZmZzZXQgdG8g dGhlIHN0YXJ0IG9mIHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgICAgIHJldHVybiBib3VuZGFy eSA9PSBBWFRleHRVbml0Qm91bmRhcnk6OkVuZCA/IHJ1bkVuZE9mZnNldCA6IHJ1bkVuZE9mZnNl dCAtIHJ1bkxlbmd0aDsKKyAgICAgICAgfTsKKyAgICAgICAgYXV0byBsaW5lUG9zaXRpb24gPSBB WFBvc2l0aW9uKGN1cnJlbnRPYmplY3QtPnRyZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJ RCgpLCBjb21wdXRlT2Zmc2V0KGN1cnJlbnRSdW5zLT5ydW5MZW5ndGhTdW0ocnVuRnJvbU9mZnNl dC5pbmRleCksIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgocnVuRnJvbU9mZnNldC5pbmRleCkpKTsK KyAgICAgICAgYXV0byBzdGFydExpbmVJRCA9IGN1cnJlbnRSdW5zLT5saW5lSUQocnVuRnJvbU9m ZnNldC5pbmRleCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29j aWF0ZWQgbGluZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisg ICAgICAgIHdoaWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VS VChjdXJyZW50UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVP ZmZzZXQgPSAwOworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVu cy0+c2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1 cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5z LT5saW5lSUQoaSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBs aW5lUG9zaXRpb247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihj dXJyZW50T2JqZWN0LT50cmVlSUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29tcHV0 ZU9mZnNldChjdW11bGF0aXZlT2Zmc2V0LCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkpKSk7Cisg ICAgICAgICAgICB9CisgICAgICAgICAgICBjdXJyZW50T2JqZWN0ID0gZmluZE9iamVjdFdpdGhS dW5zKCpjdXJyZW50T2JqZWN0LCBkaXJlY3Rpb24pOworICAgICAgICAgICAgaWYgKGN1cnJlbnRP YmplY3QpCisgICAgICAgICAgICAgICAgY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0 UnVucygpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAgfQor ICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKK30KKworUnVuRnJvbU9mZnNldCBBWFBvc2l0aW9u OjpydW5Gcm9tT2Zmc2V0KCkgY29uc3QKK3sKKyAgICBzaXplX3QgY3VtdWxhdGl2ZU9mZnNldCA9 IDA7CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKm9iamVjdCgpLCBB WERpcmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAgICAvLyBJbmRleCBvZiB0aGUg cnVuIHdlIHN0YXJ0IGF0IGJhc2VkIG9uIG1fb2Zmc2V0LgorICAgIHNpemVfdCBzdGFydFJ1bklu ZGV4ID0gbm90Rm91bmQ7CisgICAgd2hpbGUgKGN1cnJlbnQgJiYgc3RhcnRSdW5JbmRleCA9PSBu b3RGb3VuZCkgeworICAgICAgICBhdXRvJiBjdXJyZW50UnVucyA9ICpjdXJyZW50LT50ZXh0UnVu cygpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY3VycmVudFJ1bnMuc2l6ZSgp OyBpKyspIHsKKyAgICAgICAgICAgIGN1bXVsYXRpdmVPZmZzZXQgKz0gY3VycmVudFJ1bnMucnVu TGVuZ3RoKGkpOworICAgICAgICAgICAgaWYgKGN1bXVsYXRpdmVPZmZzZXQgPj0gbV9vZmZzZXQp IHsKKyAgICAgICAgICAgICAgICBzdGFydFJ1bkluZGV4ID0gaTsKKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIGlmIChzdGFydFJ1bklu ZGV4ICE9IG5vdEZvdW5kKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGN1cnJlbnQgPSBm aW5kT2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnQsIEFYRGlyZWN0aW9uOjpOZXh0KTsKKyAgICB9CisK KyAgICBpZiAoc3RhcnRSdW5JbmRleCA9PSBub3RGb3VuZCkgeworICAgICAgICAvLyBGSVhNRTog Tm90IHN1cmUgaG93IHRoaXMgY291bGQgaGFwcGVuLCBidXQgd2UgbWF5IG5lZWQgdG8gaGFuZGxl IGl0IHNvbWVob3c/CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAg fQorICAgIHJldHVybiB7ICpjdXJyZW50LCBzdGFydFJ1bkluZGV4IH07Cit9CisKK0FYVGV4dE1h cmtlclJhbmdlIEFYUG9zaXRpb246OmxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlIHR5cGUpIGNvbnN0 Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHsgbnVsbFBvc2l0aW9uKCks IG51bGxQb3NpdGlvbigpIH07CisKKyAgICBpZiAodHlwZSA9PSBMaW5lUmFuZ2VUeXBlOjpDdXJy ZW50KQorICAgICAgICByZXR1cm4geyBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb246OlByZXZpb3Vz LCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6OlN0YXJ0KSwgZmluZFBvc2l0 aW9uKEFYRGlyZWN0aW9uOjpOZXh0LCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRh cnk6OkVuZCkgfTsKKyAgICAvLyBUaGUgb3RoZXIgdHlwZXMgYXJlbid0IGltcGxlbWVudGVkIHll dC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorCit9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaCBiL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uMTMwZGVkODc2ZDk2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKQEAgLTAsMCArMSwxMDQgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBB TkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQorI2luY2x1ZGUgIkFYSXNvbGF0ZWRPYmplY3QuaCIKKyNpbmNsdWRlICJBWFRleHRNYXJrZXIu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitlbnVtIGNsYXNzIEFYVGV4dFVuaXQgOiB1aW50 OF90IHsKKyAgICBMaW5lLAorICAgIFBhcmFncmFwaCwKKyAgICBTZW50ZW5jZSwKKyAgICBXb3Jk LAorfTsKK2VudW0gY2xhc3MgQVhUZXh0VW5pdEJvdW5kYXJ5IDogYm9vbCB7IFN0YXJ0LCBFbmQs IH07CisKK2VudW0gY2xhc3MgTGluZVJhbmdlVHlwZSA6IHVpbnQ4X3QgeworICAgIEN1cnJlbnQs CisgICAgTGVmdCwKKyAgICBSaWdodCwKK307CisKK3N0cnVjdCBSdW5Gcm9tT2Zmc2V0IHsKKyAg ICAvLyBUaGUgbGVhZiBub2RlIHdpdGggcnVucyBwb2ludGVkIHRvIGJ5IHRoZSBvZmZzZXQgdXNl ZCB0byBjb21wdXRlIHRoaXMgc3RydWN0LgorICAgIFJlZjxBWElzb2xhdGVkT2JqZWN0PiBvYmpl Y3Q7CisgICAgLy8gUnVuIGluZGV4IHBvaW50ZWQgdG8gYnkgdGhlIG9mZnNldCB1c2VkIHRvIGNv bXB1dGUgdGhpcyBzdHJ1Y3QuCisgICAgc2l6ZV90IGluZGV4IHsgMCB9OworCisgICAgQVhJRCB0 cmVlSUQoKSBjb25zdCB7IHJldHVybiBvYmplY3QtPnRyZWVJRCgpOyB9CisgICAgQVhJRCBvYmpl Y3RJRCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdC0+b2JqZWN0SUQoKTsgfQorICAgIGNvbnN0IEFY VGV4dFJ1biYgcnVuKCkgY29uc3QgeyByZXR1cm4gKCpvYmplY3QtPnRleHRSdW5zKCkpW2luZGV4 XTsgfQorCisgICAgUnVuRnJvbU9mZnNldChBWElzb2xhdGVkT2JqZWN0JiBvYmplY3QsIHNpemVf dCBydW5JbmRleCkKKyAgICAgICAgOiBvYmplY3Qob2JqZWN0KQorICAgICAgICAsIGluZGV4KHJ1 bkluZGV4KQorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQocnVuSW5kZXggPCBvYmplY3Qu dGV4dFJ1bnMoKS0+c2l6ZSgpKTsKKyAgICB9Cit9OworCitjbGFzcyBBWFBvc2l0aW9uIHsKK3B1 YmxpYzoKKyAgICBleHBsaWNpdCBBWFBvc2l0aW9uKEFYSUQgdHJlZUlELCBBWElEIG9iamVjdElE LCB1bnNpZ25lZCBvZmZzZXQpCisgICAgICAgIDogbV90cmVlSUQodHJlZUlEKQorICAgICAgICAs IG1fb2JqZWN0SUQob2JqZWN0SUQpCisgICAgICAgICwgbV9vZmZzZXQob2Zmc2V0KQorICAgIHsg fQorICAgIHN0YXRpYyBBWFBvc2l0aW9uIG51bGxQb3NpdGlvbigpIHsgcmV0dXJuIEFYUG9zaXRp b24oQVhJRCgpLCBBWElEKCksIDApOyB9CisgICAgc3RhdGljIEFYUG9zaXRpb24gZnJvbVRleHRN YXJrZXIoY29uc3QgQVhUZXh0TWFya2VyJik7CisgICAgb3BlcmF0b3IgQVhUZXh0TWFya2VyKCkg Y29uc3Q7CisKKyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IHsgcmV0dXJuIG1fdHJlZUlEOyB9Cisg ICAgQVhJRCBvYmplY3RJRCgpIGNvbnN0IHsgcmV0dXJuIG1fb2JqZWN0SUQ7IH0KKyAgICB1bnNp Z25lZCBvZmZzZXQoKSBjb25zdCB7IHJldHVybiBtX29mZnNldDsgfQorCisgICAgQVhJc29sYXRl ZE9iamVjdCogb2JqZWN0KCkgY29uc3Q7CisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVy biAhdHJlZUlEKCkuaXNWYWxpZCgpIHx8ICFvYmplY3RJRCgpLmlzVmFsaWQoKTsgfQorCisgICAg Ly8gRmluZCB0aGUgbmV4dCBvciBwcmV2aW91cyBwb3NpdGlvbi4KKyAgICBBWFBvc2l0aW9uIGZp bmRQb3NpdGlvbihBWERpcmVjdGlvbikgY29uc3Q7CisgICAgLy8gU3RhcnRpbmcgZnJvbSB0aGlz IHBvc2l0aW9uLCBjcmVhdGVzIGEgbmV3IHBvc2l0aW9uIGZvciB0aGUgZ2l2ZW4gZGlyZWN0aW9u IGFuZCB0ZXh0IHVuaXQgdHlwZS4KKyAgICBBWFBvc2l0aW9uIGZpbmRQb3NpdGlvbihBWERpcmVj dGlvbiwgQVhUZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5KSBjb25zdDsKKyAgICBBWFRleHRN YXJrZXJSYW5nZSBsaW5lUmFuZ2UoTGluZVJhbmdlVHlwZSkgY29uc3Q7CisKKyAgICBTdHJpbmcg ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0OworCitwcml2YXRlOgorICAgIC8vIEdldHMgdGhlIHJ1 biBwb2ludGVkIHRvIGJ5IG1fb2Zmc2V0IChhbmQgc29tZSBhc3NvY2lhdGVkIGluZm9ybWF0aW9u KS4KKyAgICBSdW5Gcm9tT2Zmc2V0IHJ1bkZyb21PZmZzZXQoKSBjb25zdDsKKworICAgIEFYSUQg bV90cmVlSUQ7CisgICAgQVhJRCBtX29iamVjdElEOworICAgIHVuc2lnbmVkIG1fb2Zmc2V0IHsg MCB9OworCisgICAgbXV0YWJsZSBSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gbV9jYWNoZWRPYmpl Y3Q7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RI UkVBRF9URVhUX0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYVGV4dE1hcmtlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1h cmtlci5jcHAKaW5kZXggOWFkNmFiZjkzYWFjLi5kMmQ0MzNiY2JiMWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKQEAgLTMzNSw3ICszMzUsNyBA QCBzdGQ6Om9wdGlvbmFsPEFYVGV4dE1hcmtlclJhbmdlPiBBWFRleHRNYXJrZXJSYW5nZTo6aW50 ZXJzZWN0aW9uV2l0aChjb25zdCBBWFRleAogCiBTdHJpbmcgQVhUZXh0TWFya2VyUmFuZ2U6OmRl YnVnRGVzY3JpcHRpb24oKSBjb25zdAogewotICAgIHJldHVybiBtYWtlU3RyaW5nKCJzdGFydDog eyIsIG1fc3RhcnQuZGVidWdEZXNjcmlwdGlvbigpLCAifVxuZW5kOiB7IiwgbV9lbmQuZGVidWdE ZXNjcmlwdGlvbigpLCAifSIpOworICAgIHJldHVybiBtYWtlU3RyaW5nKCJzdGFydDogeyIsIG1f c3RhcnQuZGVidWdEZXNjcmlwdGlvbigpLCAifVxuZW5kOiAgIHsiLCBtX2VuZC5kZWJ1Z0Rlc2Ny aXB0aW9uKCksICJ9Iik7CiB9CiAKIHN0ZDo6cGFydGlhbF9vcmRlcmluZyBwYXJ0aWFsT3JkZXIo Y29uc3QgQVhUZXh0TWFya2VyJiBtYXJrZXIxLCBjb25zdCBBWFRleHRNYXJrZXImIG1hcmtlcjIp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5o IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAppbmRleCAxN2U5 ZmMwZGFiOTguLjU5ZjRmMzc5NjMxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYVGV4dE1hcmtlci5oCkBAIC0xMjMsNiArMTIzLDcgQEAgcHVibGljOgogCiAgICAgQVhJRCB0 cmVlSUQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEuYXhUcmVlSUQoKTsgfQogICAgIEFYSUQgb2Jq ZWN0SUQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEuYXhPYmplY3RJRCgpOyB9CisgICAgdW5zaWdu ZWQgb2Zmc2V0KCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLm9mZnNldDsgfQogICAgIGJvb2wgaXNO dWxsKCkgY29uc3QgeyByZXR1cm4gIXRyZWVJRCgpLmlzVmFsaWQoKSB8fCAhb2JqZWN0SUQoKS5p c1ZhbGlkKCk7IH0KICAgICBSZWZQdHI8QVhDb3JlT2JqZWN0PiBvYmplY3QoKSBjb25zdDsKICAg ICBib29sIGlzVmFsaWQoKSBjb25zdCB7IHJldHVybiBvYmplY3QoKTsgfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaCBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi5hODhmYzgyNzQ0N2QKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCkBAIC0wLDAgKzEsMTI1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBD T05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAq IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisg KiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI3ByYWdtYSBvbmNlCisKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworY2xhc3MgUmVuZGVyQmxvY2s7CisKK3N0cnVjdCBBWFRleHRSdW5M aW5lSUQgeworICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7IG51bGxwdHIgfTsKKyAgICBzaXpl X3QgbGluZUluZGV4IHsgMCB9OworCisgICAgQVhUZXh0UnVuTGluZUlEKHZvaWQqIGNvbnRhaW5p bmdCbG9jaywgc2l6ZV90IGxpbmVJbmRleCkKKyAgICAgICAgOiBjb250YWluaW5nQmxvY2soY29u dGFpbmluZ0Jsb2NrKQorICAgICAgICAsIGxpbmVJbmRleChsaW5lSW5kZXgpCisgICAgeyB9Cisg ICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEFYVGV4dFJ1bkxpbmVJRCYpIGNvbnN0ID0gZGVmYXVs dDsKKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0CisgICAgeworICAgICAgICBU ZXh0U3RyZWFtIHN0cmVhbTsKKyAgICAgICAgc3RyZWFtIDw8ICJMaW5lSUQgIiA8PCBjb250YWlu aW5nQmxvY2sgPDwgIiAiIDw8IGxpbmVJbmRleDsKKyAgICAgICAgcmV0dXJuIHN0cmVhbS5yZWxl YXNlKCk7CisgICAgfQorfTsKKworc3RydWN0IEFYVGV4dFJ1biB7CisgICAgLy8gVGhlIGxpbmUg aW5kZXggb2YgdGhpcyBydW4gd2l0aGluIHRoZSBjb250ZXh0IG9mIHRoZSBjb250YWluaW5nIFJl bmRlckJsb2NrIG9mIHRoZSBtYWluLXRocmVhZCBBWCBvYmplY3QuCisgICAgc2l6ZV90IGxpbmVJ bmRleDsKKyAgICBTdHJpbmcgdGV4dDsKKworICAgIEFYVGV4dFJ1bihzaXplX3QgbGluZUluZGV4 LCBTdHJpbmcmJiB0ZXh0KQorICAgICAgICA6IGxpbmVJbmRleChsaW5lSW5kZXgpCisgICAgICAg ICwgdGV4dChXVEZNb3ZlKHRleHQpKQorICAgIHsgfQorCisgICAgU3RyaW5nIGRlYnVnRGVzY3Jp cHRpb24odm9pZCogY29udGFpbmluZ0Jsb2NrKSBjb25zdAorICAgIHsKKyAgICAgICAgQVhUZXh0 UnVuTGluZUlEIGxpbmVJRCA9IHsgY29udGFpbmluZ0Jsb2NrLCBsaW5lSW5kZXggfTsKKyAgICAg ICAgcmV0dXJuIG1ha2VTdHJpbmcobGluZUlELmRlYnVnRGVzY3JpcHRpb24oKSwgIjogfCIsIG1h a2VTdHJpbmdCeVJlcGxhY2luZ0FsbCh0ZXh0LCAnXG4nLCAie25ld2xpbmV9Il9zKSwgInwobGVu ICIsIHRleHQubGVuZ3RoKCksICIpIik7CisgICAgfQorfTsKKworc3RydWN0IEFYVGV4dFJ1bnMg eworICAgIC8vIFRoZSBjb250YWluaW5nIGJsb2NrIGZvciB0aGUgdGV4dCBydW5zLiBUaGlzIGlz IHJlcXVpcmVkIGJlY2F1c2UgYmFzZWQgb24gdGhlIHN0cnVjdHVyZQorICAgIC8vIG9mIHRoZSBB WCB0cmVlLCB0ZXh0IHJ1bnMgZm9yIGRpZmZlcmVudCBvYmplY3RzIGNhbiBoYXZlIHRoZSBzYW1l IGxpbmUgaW5kZXggYnV0IGRpZmZlcmVudAorICAgIC8vIGNvbnRhaW5pbmcgYmxvY2tzLCBtZWFu aW5nIHRoZXkgYXJlIHJlbmRlcmVkIG9uIGRpZmZlcmVudCBsaW5lcy4KKyAgICAvLyBEbyBub3Qg ZGUtcmVmZXJlbmNlLiBVc2UgZm9yIGNvbXBhcmlzb24gcHVycG9zZXMgb25seS4KKyAgICB2b2lk KiBjb250YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAgVmVjdG9yPEFYVGV4dFJ1bj4gcnVu czsKKworICAgIEFYVGV4dFJ1bnMoKSA9IGRlZmF1bHQ7CisgICAgQVhUZXh0UnVucyhSZW5kZXJC bG9jayogY29udGFpbmluZ0Jsb2NrLCBWZWN0b3I8QVhUZXh0UnVuPiYmIHJ1bnMpCisgICAgICAg IDogY29udGFpbmluZ0Jsb2NrKGNvbnRhaW5pbmdCbG9jaykKKyAgICAgICAgLCBydW5zKFdURk1v dmUocnVucykpCisgICAgeyB9CisKKyAgICBzaXplX3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIHJ1 bnMuc2l6ZSgpOyB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoKHNpemVfdCBpbmRleCkgY29uc3QK KyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5zaXplKCkpOworICAg ICAgICByZXR1cm4gcnVuc1tpbmRleF0udGV4dC5sZW5ndGgoKTsKKyAgICB9CisgICAgdW5zaWdu ZWQgbGFzdFJ1bkxlbmd0aCgpIGNvbnN0CisgICAgeworICAgICAgICBpZiAocnVucy5pc0VtcHR5 KCkpCisgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgcmV0dXJuIHJ1bnNbcnVucy5zaXpl KCkgLSAxXS50ZXh0Lmxlbmd0aCgpOworICAgIH0KKyAgICB1bnNpZ25lZCBydW5MZW5ndGhTdW0o c2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgdW5zaWduZWQgbGVuZ3RoID0gMDsK KyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPD0gaW5kZXggJiYgaSA8IHJ1bnMuc2l6ZSgp OyBpKyspCisgICAgICAgICAgICBsZW5ndGggKz0gcnVuTGVuZ3RoKGkpOworICAgICAgICByZXR1 cm4gbGVuZ3RoOworICAgIH0KKyAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEKHNpemVfdCBpbmRl eCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5zaXpl KCkpOworICAgICAgICByZXR1cm4geyBjb250YWluaW5nQmxvY2ssIHJ1bnNbaW5kZXhdLmxpbmVJ bmRleCB9OworICAgIH0KKyAgICBjb25zdCBBWFRleHRSdW4mIG9wZXJhdG9yW10oc2l6ZV90IHJ1 bkluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQocnVuSW5kZXggPCBy dW5zLnNpemUoKSk7CisgICAgICAgIHJldHVybiBydW5zW3J1bkluZGV4XTsKKyAgICB9CisgICAg U3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAorICAgIHsKKyAgICAgICAgU3RyaW5nQnVp bGRlciByZXN1bHQ7CisgICAgICAgIHJlc3VsdC5hcHBlbmQoJ1snKTsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgIHJlc3Vs dC5hcHBlbmQocnVuc1tpXS5kZWJ1Z0Rlc2NyaXB0aW9uKGNvbnRhaW5pbmdCbG9jaykpOworICAg ICAgICAgICAgaWYgKGkgIT0gcnVucy5zaXplKCkgLSAxKQorICAgICAgICAgICAgICAgIHJlc3Vs dC5hcHBlbmQoIiwgIik7CisgICAgICAgIH0KKyAgICAgICAgcmVzdWx0LmFwcGVuZCgnXScpOwor ICAgICAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7CisgICAgfQorfTsKKworfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5j cHAKaW5kZXggZWYwODc3MDU4ZmViLi4wNmRhODk5NTk5YzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcApAQCAtMTEzLDYg KzExMywxMiBAQCB2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmluaXQoKQogICAgIG1fcm9sZSA9 IGRldGVybWluZUFjY2Vzc2liaWxpdHlSb2xlKCk7CiB9CiAKK0FYSUQgQWNjZXNzaWJpbGl0eU9i amVjdDo6dHJlZUlEKCkgY29uc3QKK3sKKyAgICBhdXRvKiBjYWNoZSA9IGF4T2JqZWN0Q2FjaGUo KTsKKyAgICByZXR1cm4gY2FjaGUgPyBjYWNoZS0+dHJlZUlEKCkgOiBBWElEKCk7Cit9CisKIGlu bGluZSBQcm9jZXNzSUQgQWNjZXNzaWJpbGl0eU9iamVjdDo6cHJvY2Vzc0lEKCkgY29uc3QKIHsK ICAgICByZXR1cm4gcHJlc2VudGluZ0FwcGxpY2F0aW9uUElEKCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaCBiL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCmluZGV4IDVkODhjYzYx MjhjMy4uYzViYjM5NTI5MzIyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaApAQCAtMzAsNiArMzAsNyBAQAogI3ByYWdtYSBvbmNl CiAKICNpbmNsdWRlICJBWENvcmVPYmplY3QuaCIKKyNpbmNsdWRlICJBWFRleHRSdW4uaCIKICNp bmNsdWRlICJDaGFyYWN0ZXJSYW5nZS5oIgogI2luY2x1ZGUgIkZsb2F0UXVhZC5oIgogI2luY2x1 ZGUgIkxheW91dFJlY3QuaCIKQEAgLTYzLDYgKzY0LDcgQEAgY2xhc3MgQWNjZXNzaWJpbGl0eU9i amVjdCA6IHB1YmxpYyBBWENvcmVPYmplY3QsIHB1YmxpYyBDYW5NYWtlV2Vha1B0cjxBY2Nlc3Np YmkKIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5BY2Nlc3NpYmlsaXR5T2JqZWN0KCk7CiAKKyAgICBB WElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsOwogICAgIFByb2Nlc3NJRCBwcm9jZXNzSUQoKSBjb25z dCBvdmVycmlkZTsKICAgICBTdHJpbmcgZGJnKCkgY29uc3QgZmluYWw7CiAKQEAgLTM4MCw2ICsz ODIsOSBAQCBwdWJsaWM6CiAgICAgU3RyaW5nIHRleHRVbmRlckVsZW1lbnQoQWNjZXNzaWJpbGl0 eVRleHRVbmRlckVsZW1lbnRNb2RlID0gQWNjZXNzaWJpbGl0eVRleHRVbmRlckVsZW1lbnRNb2Rl KCkpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIFN0cmluZyB0ZXh0KCkgY29u c3Qgb3ZlcnJpZGUgeyByZXR1cm4geyB9OyB9CiAgICAgdW5zaWduZWQgdGV4dExlbmd0aCgpIGNv bnN0IGZpbmFsOworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIHZpcnR1YWwg QVhUZXh0UnVucyB0ZXh0UnVucygpIHsgcmV0dXJuIHsgfTsgfQorI2VuZGlmCiAjaWYgUExBVEZP Uk0oQ09DT0EpCiAgICAgLy8gUmV0dXJucyBhbiBhcnJheSBvZiBzdHJpbmdzIGFuZCBBWE9iamVj dCB3cmFwcGVycyBjb3JyZXNwb25kaW5nIHRvIHRoZQogICAgIC8vIHRleHRydW5zIGFuZCByZXBs YWNlbWVudCBub2RlcyBpbmNsdWRlZCBpbiB0aGUgZ2l2ZW4gcmFuZ2UuCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3Bw IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcAppbmRleCAzOGE0YWFmNjU3ZjIuLjk4ZTg0MDJlMzZhMyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu Y3BwCkBAIC0xMzk1LDExICsxMzk1LDExIEBAIENoYXJhY3RlclJhbmdlIEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3Q6OnNlbGVjdGVkVGV4dFJhbmdlKCkgY29uc3QKIH0KIAogI2lmIEVOQUJMRShB WF9USFJFQURfVEVYVF9BUElTKQotVmVjdG9yPEFYVGV4dFJ1bj4gQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6dGV4dFJ1bnMoKQorQVhUZXh0UnVucyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojp0ZXh0UnVucygpCiB7CiAgICAgaWYgKGF1dG8qIHJlbmRlckxpbmVCcmVhayA9IGR5bmFtaWNE b3duY2FzdDxSZW5kZXJMaW5lQnJlYWs+KHJlbmRlcmVyKCkpKSB7CiAgICAgICAgIGF1dG8gYm94 ID0gSW5saW5lSXRlcmF0b3I6OmJveEZvcigqcmVuZGVyTGluZUJyZWFrKTsKLSAgICAgICAgcmV0 dXJuIHsgeyBib3gtPmxpbmVJbmRleCgpLCBtYWtlU3RyaW5nKCdcbicpIH0gfTsKKyAgICAgICAg cmV0dXJuIHsgcmVuZGVyTGluZUJyZWFrLT5jb250YWluaW5nQmxvY2soKSwgeyBBWFRleHRSdW4o Ym94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKS5pc29sYXRlZENvcHkoKSkgfSB9Owog ICAgIH0KIAogICAgIFdlYWtQdHIgcmVuZGVyVGV4dCA9IGR5bmFtaWNEb3duY2FzdDxSZW5kZXJU ZXh0PihyZW5kZXJlcigpKTsKQEAgLTE0NTIsNyArMTQ1Miw3IEBAIFZlY3RvcjxBWFRleHRSdW4+ IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKIAogICAgIGlmICghbGluZVN0 cmluZy5pc0VtcHR5KCkpCiAgICAgICAgIHJ1bnMuYXBwZW5kKHsgY3VycmVudExpbmVJbmRleCwg bGluZVN0cmluZy50b1N0cmluZygpLmlzb2xhdGVkQ29weSgpIH0pOwotICAgIHJldHVybiBydW5z OworICAgIHJldHVybiB7IHJlbmRlclRleHQtPmNvbnRhaW5pbmdCbG9jaygpLCBXVEZNb3ZlKHJ1 bnMpIH07CiB9CiAjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmgKaW5kZXggY2VlYzZiZjNlODk4Li5iZTllZTRmODYwNDYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5oCkBAIC0xMDAsNyArMTAwLDcgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5kZXJFbGVt ZW50KEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxpdHlUZXh0 VW5kZXJFbGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZTsKICAgICBTdHJpbmcgc2VsZWN0ZWRU ZXh0KCkgY29uc3Qgb3ZlcnJpZGU7CiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0g ICAgVmVjdG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbDsKKyAgICBBWFRleHRSdW5zIHRl eHRSdW5zKCkgZmluYWw7CiAjZW5kaWYKIAogICAgIGJvb2wgaXNXaWRnZXQoKSBjb25zdCBvdmVy cmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0 cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9p c29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAKaW5kZXggNjJhMWE1NzVhZTYxLi4zNDVm MmQ1M2RmNTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCkBAIC0zMSw2ICszMSw3IEBA CiAjaW5jbHVkZSAiQVhHZW9tZXRyeU1hbmFnZXIuaCIKICNpbmNsdWRlICJBWElzb2xhdGVkVHJl ZS5oIgogI2luY2x1ZGUgIkFYTG9nZ2VyLmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCiAKICNp ZiBQTEFURk9STShNQUMpCiAjaW1wb3J0IDxwYWwvc3BpL21hYy9ISVNlcnZpY2VzU1BJLmg+CkBA IC00NjQsNiArNDY1LDkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRQcm9wZXJ0eShBWFBy b3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlWYWx1ZVYKICAgICAgICAgW10oc3Rk OjpwYWlyPEFYSUQsIENoYXJhY3RlclJhbmdlPiYgdHlwZWRWYWx1ZSkgewogICAgICAgICAgICAg cmV0dXJuICF0eXBlZFZhbHVlLmZpcnN0LmlzVmFsaWQoKSAmJiAhdHlwZWRWYWx1ZS5zZWNvbmQu bG9jYXRpb24gJiYgIXR5cGVkVmFsdWUuc2Vjb25kLmxlbmd0aDsKICAgICAgICAgfSwKKyNpZiBF TkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICAgICAgW10oQVhUZXh0UnVucyBydW5zKSB7 IHJldHVybiAhcnVucy5zaXplKCk7IH0sCisjZW5kaWYKICAgICAgICAgW10oYXV0byYpIHsKICAg ICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwpAQCAtNTU3LDYgKzU2MSwxOSBAQCB2b2lkIEFYSXNvbGF0ZWRPYmplY3Q6OnNldFNlbGVjdGVk Q2hpbGRyZW4oY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBzZQogICAgIH0pOwog fQogCitBWENvcmVPYmplY3QqIEFYSXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcoQVhEaXJlY3Rpb24g ZGlyZWN0aW9uKSBjb25zdAoreworICAgIFJlZlB0ciBwYXJlbnQgPSBwYXJlbnRPYmplY3RVbmln bm9yZWQoKTsKKyAgICBjb25zdCBhdXRvJiBzaWJsaW5ncyA9IHBhcmVudC0+Y2hpbGRyZW4oKTsK KyAgICBzaXplX3QgaW5kZXhPZlRoaXMgPSBzaWJsaW5ncy5maW5kKHRoaXMpOworICAgIGlmIChp bmRleE9mVGhpcyA9PSBub3RGb3VuZCkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBp ZiAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0KQorICAgICAgICByZXR1cm4gaW5kZXhP ZlRoaXMgKyAxIDwgc2libGluZ3Muc2l6ZSgpID8gc2libGluZ3NbaW5kZXhPZlRoaXMgKyAxXS5n ZXQoKSA6IG51bGxwdHI7CisgICAgcmV0dXJuIGluZGV4T2ZUaGlzID4gMCA/IHNpYmxpbmdzW2lu ZGV4T2ZUaGlzIC0gMV0uZ2V0KCkgOiBudWxscHRyOworfQorCiBib29sIEFYSXNvbGF0ZWRPYmpl Y3Q6OmlzRGV0YWNoZWRGcm9tUGFyZW50KCkKIHsKICAgICBpZiAocGFyZW50KCkuaXNWYWxpZCgp KQpAQCAtOTcxLDYgKzk4OCwxOSBAQCBpbnQgQVhJc29sYXRlZE9iamVjdDo6aW50QXR0cmlidXRl VmFsdWUoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lKSBjb25zdAogICAgICk7CiB9CiAKKyNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK2NvbnN0IEFYVGV4dFJ1bnMqIEFYSXNvbGF0 ZWRPYmplY3Q6OnRleHRSdW5zKCkgY29uc3QKK3sKKyAgICBhdXRvIGVudHJ5ID0gbV9wcm9wZXJ0 eU1hcC5maW5kKEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7CisgICAgaWYgKGVudHJ5ID09IG1f cHJvcGVydHlNYXAuZW5kKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIHJldHVybiBX VEY6OnN3aXRjaE9uKGVudHJ5LT52YWx1ZSwKKyAgICAgICAgW10gKGNvbnN0IEFYVGV4dFJ1bnMm IHR5cGVkVmFsdWUpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0dXJuICZ0eXBlZFZhbHVlOyB9 LAorICAgICAgICBbXSAoYXV0byYpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0dXJuIG51bGxw dHI7IH0KKyAgICApOworfQorI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiBUIEFYSXNv bGF0ZWRPYmplY3Q6OmdldE9yUmV0cmlldmVQcm9wZXJ0eVZhbHVlKEFYUHJvcGVydHlOYW1lIHBy b3BlcnR5TmFtZSkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAppbmRleCBhNmNhMDM0Mzc3N2Qu LjhkOTRhZDJiZDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9p c29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaApAQCAtNDQsNiArNDQsOSBA QAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBWElzb2xhdGVkVHJlZTsKKyNpZiBFTkFC TEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK3N0cnVjdCBBWFRleHRSdW5zOworI2VuZGlmCiAKIGNs YXNzIEFYSXNvbGF0ZWRPYmplY3QgZmluYWwgOiBwdWJsaWMgQVhDb3JlT2JqZWN0IHsKICAgICBm cmllbmQgY2xhc3MgQVhJc29sYXRlZFRyZWU7CkBAIC01MSw3ICs1NCw5IEBAIHB1YmxpYzoKICAg ICBzdGF0aWMgUmVmPEFYSXNvbGF0ZWRPYmplY3Q+IGNyZWF0ZShjb25zdCBSZWY8QWNjZXNzaWJp bGl0eU9iamVjdD4mLCBBWElzb2xhdGVkVHJlZSopOwogICAgIH5BWElzb2xhdGVkT2JqZWN0KCk7 CiAKKyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+dHJlZUlE KCk7IH0KICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgZmluYWwgeyByZXR1cm4gdHJl ZSgpLT5wcm9jZXNzSUQoKTsgfQorICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNv bnN0IGZpbmFsIHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xlPihpbnRBdHRy aWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBTdHJpbmcgZGJn KCkgY29uc3QgZmluYWw7CiAKICAgICB2b2lkIGF0dGFjaFBsYXRmb3JtV3JhcHBlcihBY2Nlc3Np YmlsaXR5T2JqZWN0V3JhcHBlciopOwpAQCAtNTksMTAgKzY0LDE3IEBAIHB1YmxpYzoKICAgICBi b29sIGlzVGFibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQ cm9wZXJ0eU5hbWU6OklzVGFibGUpOyB9CiAgICAgYm9vbCBpc0V4cG9zYWJsZSgpIGNvbnN0IGZp bmFsIHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6SXNFeHBvc2Fi bGUpOyB9CiAKKyAgICBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVu KGJvb2wgdXBkYXRlQ2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpIGZpbmFsOworICAgIEFYQ29yZU9i amVjdCogc2libGluZyhBWERpcmVjdGlvbikgY29uc3Q7CiAgICAgQVhJc29sYXRlZE9iamVjdCog cGFyZW50T2JqZWN0KCkgY29uc3QgZmluYWwgeyByZXR1cm4gcGFyZW50T2JqZWN0VW5pZ25vcmVk KCk7IH0KKyAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKSBjb25z dCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBlZGl0YWJsZUFuY2VzdG9yKCkgZmluYWwg eyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6ZWRpdGFibGVBbmNlc3RvcigqdGhpcyk7IH07CiAgICAg Ym9vbCBjYW5TZXRGb2N1c0F0dHJpYnV0ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRy aWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Q2FuU2V0Rm9jdXNBdHRyaWJ1dGUpOyB9CiAKKyNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICBjb25zdCBBWFRleHRSdW5zKiB0ZXh0 UnVucygpIGNvbnN0OworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgdm9pZCBkZXRhY2hSZW1vdGVQ YXJ0cyhBY2Nlc3NpYmlsaXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwogICAgIHZvaWQgZGV0YWNo UGxhdGZvcm1XcmFwcGVyKEFjY2Vzc2liaWxpdHlEZXRhY2htZW50VHlwZSkgZmluYWw7CkBAIC0y NDMsNyArMjU1LDYgQEAgcHJpdmF0ZToKICAgICBWZWN0b3I8U3RyaW5nPiBkZXRlcm1pbmVEcm9w RWZmZWN0cygpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGFjY2Vzc2liaWxp dHlIaXRUZXN0KGNvbnN0IEludFBvaW50JikgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9i amVjdCogZm9jdXNlZFVJRWxlbWVudCgpIGNvbnN0IGZpbmFsOwotICAgIEFYSXNvbGF0ZWRPYmpl Y3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNvbnN0IGZpbmFsOwogICAgIEFjY2Vzc2liaWxp dHlDaGlsZHJlblZlY3RvciBsaW5rZWRPYmplY3RzKCkgY29uc3QgZmluYWwgeyByZXR1cm4gdHJl ZSgpLT5vYmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFYUHJvcGVydHlO YW1lOjpMaW5rZWRPYmplY3RzKSk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiB0aXRsZVVJRWxl bWVudCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIG9iamVjdEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVy dHlOYW1lOjpUaXRsZVVJRWxlbWVudCk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiBzY3JvbGxC YXIoQWNjZXNzaWJpbGl0eU9yaWVudGF0aW9uKSBmaW5hbDsKQEAgLTI1MSw3ICsyNjIsNiBAQCBw cml2YXRlOgogICAgIFN0cmluZyBleHBhbmRlZFRleHRWYWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0 dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpFeHBhbmRlZFRleHRWYWx1 ZSk7IH0KICAgICBib29sIHN1cHBvcnRzRXhwYW5kZWRUZXh0VmFsdWUoKSBjb25zdCBmaW5hbCB7 IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlN1cHBvcnRzRXhwYW5k ZWRUZXh0VmFsdWUpOyB9CiAgICAgU1JHQkE8dWludDhfdD4gY29sb3JWYWx1ZSgpIGNvbnN0IGZp bmFsOwotICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0 dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xlPihpbnRBdHRyaWJ1dGVWYWx1ZShBWFBy b3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBTdHJpbmcgcm9sZVBsYXRmb3JtU3RyaW5n KCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5h bWU6OlJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KICAgICBTdHJpbmcgcm9sZURlc2NyaXB0aW9uKCkg Y29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6 OlJvbGVEZXNjcmlwdGlvbik7IH0KICAgICBTdHJpbmcgc3Vicm9sZVBsYXRmb3JtU3RyaW5nKCkg Y29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6 OlN1YnJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KQEAgLTMxNiw3ICszMjYsNiBAQCBwcml2YXRlOgog ICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciB2aXNpYmxlQ2hpbGRyZW4oKSBmaW5hbCB7 IHJldHVybiB0cmVlKCktPm9iamVjdHNGb3JJRHModmVjdG9yQXR0cmlidXRlVmFsdWU8QVhJRD4o QVhQcm9wZXJ0eU5hbWU6OlZpc2libGVDaGlsZHJlbikpOyB9CiAgICAgQXRvbVN0cmluZyB0YWdO YW1lKCkgY29uc3QgZmluYWw7CiAgICAgdm9pZCBzZXRDaGlsZHJlbklEcyhWZWN0b3I8QVhJRD4m Jik7Ci0gICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbihib29s IHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQgPSB0cnVlKSBmaW5hbDsKICAgICB2b2lkIHVwZGF0ZUNo aWxkcmVuSWZOZWNlc3NhcnkoKSBmaW5hbDsKICAgICBib29sIGlzRGV0YWNoZWRGcm9tUGFyZW50 KCkgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogbGl2ZVJlZ2lvbkFuY2VzdG9yKGJvb2wg ZXhjbHVkZUlmT2ZmID0gdHJ1ZSkgY29uc3QgZmluYWwgeyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6 bGl2ZVJlZ2lvbkFuY2VzdG9yKCp0aGlzLCBleGNsdWRlSWZPZmYpOyB9CkBAIC0zNDUsOSArMzU0 LDYgQEAgcHJpdmF0ZToKIAogICAgIC8vIENoYXJhY3RlclJhbmdlIHN1cHBvcnQuCiAgICAgQ2hh cmFjdGVyUmFuZ2Ugc2VsZWN0ZWRUZXh0UmFuZ2UoKSBjb25zdCBmaW5hbCB7IHJldHVybiBwcm9w ZXJ0eVZhbHVlPENoYXJhY3RlclJhbmdlPihBWFByb3BlcnR5TmFtZTo6U2VsZWN0ZWRUZXh0UmFu Z2UpOyB9Ci0jaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgVmVjdG9yPEFYVGV4 dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbCB7IHJldHVybiB2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWFRl eHRSdW4+KEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7IH0KLSNlbmRpZgogICAgIGludCBpbnNl cnRpb25Qb2ludExpbmVOdW1iZXIoKSBjb25zdCBmaW5hbDsKICAgICBDaGFyYWN0ZXJSYW5nZSBk b0FYUmFuZ2VGb3JMaW5lKHVuc2lnbmVkKSBjb25zdCBmaW5hbDsKICAgICBTdHJpbmcgZG9BWFN0 cmluZ0ZvclJhbmdlKGNvbnN0IENoYXJhY3RlclJhbmdlJikgY29uc3QgZmluYWw7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk VHJlZS5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29s YXRlZFRyZWUuaAppbmRleCBmMTFlZjg1NTVhMTQuLjk0NTAyOWUwNzA2ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkVHJlZS5oCkBAIC0yNTUsNyArMjU1LDcgQEAgdXNpbmcgQVhQcm9wZXJ0eVZhbHVlVmFyaWFu dCA9IHN0ZDo6dmFyaWFudDxzdGQ6Om51bGxwdHJfdCwgQVhJRCwgU3RyaW5nLCBib29sLAogICAg ICwgUmV0YWluUHRyPE5TQXR0cmlidXRlZFN0cmluZz4KICNlbmRpZgogI2lmIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQotICAgICwgVmVjdG9yPEFYVGV4dFJ1bj4KKyAgICAsIEFYVGV4dFJ1 bnMKICNlbmRpZgogPjsKIHVzaW5nIEFYUHJvcGVydHlNYXAgPSBIYXNoTWFwPEFYUHJvcGVydHlO YW1lLCBBWFByb3BlcnR5VmFsdWVWYXJpYW50LCBJbnRIYXNoPEFYUHJvcGVydHlOYW1lPiwgV1RG OjpTdHJvbmdFbnVtSGFzaFRyYWl0czxBWFByb3BlcnR5TmFtZT4+Owo= 469135 2023-12-19 15:55:00 -0800 2023-12-20 12:14:04 -0800 Patch bug-266521-20231219155459.patch text/plain 43794 tyler_w RnJvbSA1ZjAxNGQ2YTQyM2I4ZTVlM2JkOTYzODM0OWJlODA1ZGI4NTc5YzQ1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Q2hyaXMgRmxlaXphY2guCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDIyMyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8IDEwNCArKysrKysrKwogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwIHwgICAyICstCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oICAgfCAgIDEgKwogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFRleHRSdW4uaCAgICAgIHwgMTI1ICsrKysrKysrKysKIC4uLi9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwICAgICB8ICAgNiArCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmggICAgICAgfCAgIDUgKwogLi4uL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwICAgICAgICAgICAgIHwgICA2ICstCiAuLi4vYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggfCAgIDIgKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5jcHAgICAgICAgICB8ICAzMCArKysKIC4uLi9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkVHJlZS5oICAgICAgICAgICAgIHwgICAyICstCiAxNiBmaWxlcyBjaGFuZ2VkLCA1MjggaW5z ZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFNv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiBjcmVhdGUgbW9kZSAxMDA2 NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNt YWtlCmluZGV4IGNjNmM0YTMxZTZkNS4uMzkzNDRkMGM4MGNlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UK QEAgLTY1MCw3ICs2NTAsOSBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09SS19IRUFERVJT CiAgICAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5oCiAgICAgYWNjZXNzaWJpbGl0 eS9BWExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKyAgICBhY2Nl c3NpYmlsaXR5L0FYUG9zaXRpb24uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgK KyAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRT dGF0ZUNoYW5nZUludGVudC5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRyZWVTdG9yZS5oCiAgICAg YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5TGlzdEJveC5oCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CmluZGV4IGQz MDJkMzJlYTc2Yi4uNWJjYmYwNTdjNjg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dApAQCAtNTIxLDYgKzUyMSw3 IEBAIGFjY2Vzc2liaWxpdHkvQVhHZW9tZXRyeU1hbmFnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FY SW1hZ2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNjZXNzaWJpbGl0eS9BWE9i amVjdENhY2hlLmNwcAorYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogYWNjZXNzaWJpbGl0 eS9BWFRleHRNYXJrZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZC5j cHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5jcHAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3Zjgx ODJmMDhhZGMuLjAzZjMyMjZmZWUzNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTc1MCw3ICsxNzUwLDkgQEAKIAkJNDdGOTQ3 REIyNjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5 NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJs ZUZvcm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dl b21ldHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJNDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMz QTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKKwkJNDg2MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJE MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVU RVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFY R2VvbWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQy QTJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0 UnVuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ NDhCNUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0Lmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5 Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlF MDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBF bGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCTQ5M0U1RTA5MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNB TGF5ZXJDbGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDQ5M0U1RTA4MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjAs OCArMTA3MjIsMTEgQEAKIAkJNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0 dGluZ0dlb21ldHJ5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFRhYmxlRm9y bWF0dGluZ0dlb21ldHJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4MjI5NzBC MjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk0ODIyOTcwQzI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZWdpb25Db250ZXh0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0 aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYUG9zaXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDg2MUUwQkUyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gQVhQb3NpdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0ODZCOERDODJBMDQ1MDBGMDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQVhHZW9tZXRyeU1hbmFnZXIuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIg LyogQVhUZXh0UnVuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYVGV4dFJ1bi5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0 eVJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNz aWJpbGl0eVJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzYyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1l bnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250 ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE4Niw4ICsyMzE5MSwxMSBA QAogCQkJCUMwNDkzRUI3MjQ0Njk5RTQwMDlBQUM4MCAvKiBBWExvZ2dlci5oICovLAogCQkJCTI5 ODFDQUFGMTMxODIyRUMwMEQxMkYyQSAvKiBBWE9iamVjdENhY2hlLmNwcCAqLywKIAkJCQkyOUE4 MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5oICovLAorCQkJCTQ4NjFFMEJF MkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLywKKwkJCQk0ODYxRTBCRDJCMjAw NzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMw RDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICovLAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUzQkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0 YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFEQzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFY VHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYwNTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFj Y2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1NzcsNyArMzc1ODUsOSBAQAogCQkJCTI5QUUy MTM1MjFBQkE0OEEwMDg2OTI4MyAvKiBBWElzb2xhdGVkT2JqZWN0LmggaW4gSGVhZGVycyAqLywK IAkJCQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRyZWUuaCBpbiBIZWFk ZXJzICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmgg aW4gSGVhZGVycyAqLywKKwkJCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlv bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzBFMjA4QTIyOTM3OUM2RjAwQzBEMkQzIC8qIEFYVGV4 dE1hcmtlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNDhCMDI0MkEyQjJBNjVBQTAwODNEMTIyIC8q IEFYVGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTFDOUYyRjkxQUUzQkVCMDAwOTVCNjFD IC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEU4QURD NTI5NEI1QTYzMDA3NkNCREMgLyogQVhUcmVlU3RvcmUuaCBpbiBIZWFkZXJzICovLAogCQkJCTE0 NzdFNzc3MEJGNDEzNEEwMDE1Mjg3MiAvKiBCYWNrRm9yd2FyZENhY2hlLmggaW4gSGVhZGVycyAq LywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0 LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCmluZGV4IDEw MTE0ZWNiNmRkOC4uOTkwY2RhOTgwNWMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhDb3JlT2JqZWN0LmgKQEAgLTExMCwxOSArMTEwLDYgQEAgZW51bSBjbGFzcyBBWEFuY2Vz dG9yRmxhZyA6IHVpbnQ4X3QgewogICAgIC8vIEJpdHMgNiBhbmQgNyBhcmUgZnJlZS4KIH07CiAK LSNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAg IC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUg Y29udGFpbmluZyBSZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4K LSAgICBzaXplX3QgbGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVu KHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxp bmVJbmRleCkKLSAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2Vu ZGlmCi0KIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0g MSwKICAgICBBcHBsaWNhdGlvbkFsZXJ0LApAQCAtNjUzLDYgKzY0MCw4IEBAIGVudW0gY2xhc3Mg QWNjZXNzaWJpbGl0eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3Mg QVhEaXJlY3Rpb24gOiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nl c3NpYmlsaXR5U29ydERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04 MDAsNiArNzg5LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQp IHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9p ZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQ cm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVz cG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTEx MDQsOSArMTA5NCw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRl eHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dy YW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZp cnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1 bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJp bmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBj b25zdCA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjg2Y2JmOGJjNTllNAotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAKQEAgLTAsMCArMSwyMjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CisKKyNpbmNsdWRlICJBWElzb2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhJc29sYXRlZFRy ZWUuaCIKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworQVhJc29sYXRlZE9iamVjdCogQVhQb3NpdGlvbjo6b2JqZWN0KCkgY29uc3QKK3sKKyAgICBS RUxFQVNFX0FTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIGlmIChpc051bGwoKSkKKyAgICAg ICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBpZiAobV9jYWNoZWRPYmplY3QpCisgICAgICAgIHJl dHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKKworICAgIGF1dG8gdHJlZSA9IHN0ZDo6Z2V0PFJl ZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4VHJlZUZvcklEKHRyZWVJRCgpKSk7CisgICAgbV9jYWNo ZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+b2JqZWN0Rm9ySUQob2JqZWN0SUQoKSkgOiBudWxscHRy OworICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKK30KKworQVhQb3NpdGlvbiBBWFBv c2l0aW9uOjpmcm9tVGV4dE1hcmtlcihjb25zdCBBWFRleHRNYXJrZXImIG1hcmtlcikKK3sKKyAg ICByZXR1cm4gQVhQb3NpdGlvbihtYXJrZXIudHJlZUlEKCksIG1hcmtlci5vYmplY3RJRCgpLCBt YXJrZXIub2Zmc2V0KCkgKTsKK30KKworQVhQb3NpdGlvbjo6b3BlcmF0b3IgQVhUZXh0TWFya2Vy KCkgY29uc3QKK3sKKyAgICByZXR1cm4geyB7IHRyZWVJRCgpLCBvYmplY3RJRCgpLCBudWxscHRy LCBtX29mZnNldCB9IH07Cit9CisKK1N0cmluZyBBWFBvc2l0aW9uOjpkZWJ1Z0Rlc2NyaXB0aW9u KCkgY29uc3QKK3sKKyAgICBhdXRvIHNlcGFyYXRvciA9ICIsICI7CisgICAgUmVmUHRyIG9iamVj dCA9IHRoaXMtPm9iamVjdCgpOworICAgIHJldHVybiBtYWtlU3RyaW5nKAorICAgICAgICAidHJl ZUlEICIsIHRyZWVJRCgpLmxvZ2dpbmdTdHJpbmcoKQorICAgICAgICAsIHNlcGFyYXRvciwgIm9i amVjdElEICIsIG9iamVjdElEKCkubG9nZ2luZ1N0cmluZygpCisgICAgICAgICwgc2VwYXJhdG9y LCAicm9sZSAiLCBvYmplY3QgPyBhY2Nlc3NpYmlsaXR5Um9sZVRvU3RyaW5nKG9iamVjdC0+cm9s ZVZhbHVlKCkpIDogU3RyaW5nKCJubyBvYmplY3QiX3MpCisgICAgICAgICwgc2VwYXJhdG9yLCAi b2Zmc2V0ICIsIG1fb2Zmc2V0CisgICAgKTsKK30KKworZW51bSBjbGFzcyBDaGVja1N0YXJ0IDog Ym9vbCB7IE5vLCBZZXMgfTsKKy8vIEZpbmRzIHRoZSBuZXh0IG9iamVjdCB3aXRoIHRleHQgcnVu cyBpbiB0aGUgZ2l2ZW4gZGlyZWN0aW9uLgorc3RhdGljIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0 PiBmaW5kT2JqZWN0V2l0aFJ1bnMoQVhJc29sYXRlZE9iamVjdCYgc3RhcnQsIEFYRGlyZWN0aW9u IGRpcmVjdGlvbiwgQ2hlY2tTdGFydCBjaGVja1N0YXJ0ID0gQ2hlY2tTdGFydDo6Tm8pCit7Cisg ICAgaWYgKGNoZWNrU3RhcnQgPT0gQ2hlY2tTdGFydDo6WWVzKSB7CisgICAgICAgIGlmIChhdXRv KiBydW5zID0gc3RhcnQudGV4dFJ1bnMoKTsgcnVucyAmJiBydW5zLT5zaXplKCkpCisgICAgICAg ICAgICByZXR1cm4gJnN0YXJ0OworICAgIH0KKworICAgIFJlZlB0ciBjdXJyZW50ID0gJnN0YXJ0 OworICAgIHdoaWxlIChjdXJyZW50KSB7CisgICAgICAgIGlmIChjdXJyZW50ICE9ICZzdGFydCkg eworICAgICAgICAgICAgYXV0byogcnVucyA9IGN1cnJlbnQtPnRleHRSdW5zKCk7CisgICAgICAg ICAgICBpZiAocnVucyAmJiBydW5zLT5zaXplKCkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGN1 cnJlbnQ7CisgICAgICAgIH0KKworICAgICAgICAvLyBGSVhNRTogYXJpYS1vd25zIGJyZWFrcyB0 aGlzIHRyYXZlcnNhbCwgYXMgYXJpYS1vd25zIGNhdXNlcyB0aGUgQVggdHJlZSB0byBiZSBjaGFu Z2VkLCBhZmZlY3RpbmcKKyAgICAgICAgLy8gb3VyIGl0ZXJhdGlvbiBiZWxvdywgYnV0IGl0IGRv ZXNuJ3QgYWN0dWFsbHkgY2hhbmdlIHRleHQgcG9zaXRpb24gb24gdGhlIHBhZ2UuIFNvIHdlIG5l ZWQgdG8gaWdub3JlIGFyaWEtb3ducworICAgICAgICAvLyB0cmVlIGNoYW5nZXMgaGVyZSBpbiBv cmRlciB0byBiZWhhdmUgY29ycmVjdGx5LgorICAgICAgICAvLyBXZSBhbHNvIHByb2JhYmx5IG5l ZWQgdG8gZG8gc29tZXRoaW5nIGFib3V0IHRleHQgd2l0aGluIGFyaWEtaGlkZGVuIGNvbnRhaW5l cnMsIHdoaWNoIGFmZmVjdHMgdGhlIEFYIHRyZWUuCisKKyAgICAgICAgY29uc3QgYXV0byYgY2hp bGRyZW4gPSBjdXJyZW50LT5jaGlsZHJlbigpOworICAgICAgICBpZiAoY2hpbGRyZW4uc2l6ZSgp KSB7CisgICAgICAgICAgICBzaXplX3QgY2hpbGRJbmRleCA9IGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6TmV4dCA/IDAgOiBjaGlsZHJlbi5zaXplKCkgLSAxOworICAgICAgICAgICAgUkVMRUFT RV9BU1NFUlQoY2hpbGRyZW5bY2hpbGRJbmRleF0pOworICAgICAgICAgICAgY3VycmVudCA9IGR5 bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0PihjaGlsZHJlbltjaGlsZEluZGV4XS5nZXQo KSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIGBjdXJy ZW50YCBoYXMgbm8gY2hpbGRyZW4sIG1lYW5pbmcgaXQncyBhIGxlYWYgbm9kZSAoZS5nLiBpdCdz IHRleHQsIHdoaWNoIGNhbm5vdCBoYXZlIGNoaWxkcmVuKS4KKyAgICAgICAgLy8gQ2hlY2sgYGN1 cnJlbnRgcyBzaWJsaW5ncy4KKyAgICAgICAgaWYgKGF1dG8qIHNpYmxpbmcgPSBjdXJyZW50LT5z aWJsaW5nKGRpcmVjdGlvbikpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNh c3Q8QVhJc29sYXRlZE9iamVjdD4oc2libGluZyk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAg ICAgICAgfQorCisgICAgICAgIC8vIFdlIGhhdmUgbm8gY2hpbGRyZW4sIGFuZCBubyBuZXh0L3By ZXZpb3VzIHNpYmxpbmcuIFRyeSBvdXIgcGFyZW50J3Mgc2libGluZy4KKyAgICAgICAgaWYgKGF1 dG8qIHBhcmVudCA9IGN1cnJlbnQtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpKSB7CisgICAgICAg ICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KHBhcmVudC0+ c2libGluZyhkaXJlY3Rpb24pKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisK KyAgICAgICAgYnJlYWs7CisgICAgfQorICAgIHJldHVybiBudWxscHRyOworfQorCitBWFBvc2l0 aW9uIEFYUG9zaXRpb246OmZpbmRQb3NpdGlvbihBWERpcmVjdGlvbiBkaXJlY3Rpb24pIGNvbnN0 Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIG51bGxQb3NpdGlvbigpOwor ICAgIGF1dG8gcnVuRnJvbU9mZnNldCA9IHRoaXMtPnJ1bkZyb21PZmZzZXQoKTsKKyAgICBjb25z dCBhdXRvKiBydW5zID0gcnVuRnJvbU9mZnNldC5vYmplY3QtPnRleHRSdW5zKCk7CisKKyAgICBh dXRvIGhhc01vcmVUZXh0SW5DdXJyZW50UnVuID0gWyYsIHRoaXNdIHsKKyAgICAgICAgaWYgKGRp cmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAgICAgICAgICAgIHJldHVybiBtX29mZnNl dCA8IHJ1bkZyb21PZmZzZXQucnVuKCkudGV4dC5sZW5ndGgoKTsKKyAgICAgICAgcmV0dXJuIG1f b2Zmc2V0ID4gMDsKKyAgICB9OworICAgIGJvb2wgaGFzQW5vdGhlclJ1biA9IHJ1bkZyb21PZmZz ZXQuaW5kZXggKyAxIDwgcnVucy0+c2l6ZSgpOworICAgIC8vIFRoZSBuZXh0IHJ1biBzaG91bGQg bm90IGhhdmUgZW1wdHkgdGV4dCwgYmVjYXVzZSB3ZSdyZSBnb2luZyB0byByZXR1cm4gYSBwb3Np dGlvbiBjb250YWluaW5nIG1fb2Zmc2V0ICsgMSwgd2hpY2ggd291bGQgYmUgd3JvbmcuCisgICAg UkVMRUFTRV9BU1NFUlQoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpQcmV2aW91cyB8fCAhaGFz QW5vdGhlclJ1biB8fCBydW5zLT5ydW5MZW5ndGgocnVuRnJvbU9mZnNldC5pbmRleCArIDEpID4g MCk7CisgICAgLy8gQ2hlY2tpbmcgZm9yIHRoZSBwcmVzZW5jZSBvZiBhbm90aGVyIHJ1biBpcyBv bmx5IHJlbGV2YW50IGZvciBtb3ZpbmcgQVhEaXJlY3Rpb246Ok5leHQsIGFzIGp1c3QgY2hlY2tp bmcgdGhhdCBtX29mZnNldCA+IDAgaXMgc3VmZmljaWVudCBmb3IgQVhEaXJlY3Rpb246OlByZXZp b3VzLgorICAgIGlmIChoYXNNb3JlVGV4dEluQ3VycmVudFJ1bigpIHx8IChkaXJlY3Rpb24gPT0g QVhEaXJlY3Rpb246Ok5leHQgJiYgaGFzQW5vdGhlclJ1bikpIHsKKyAgICAgICAgLy8gUmV0dXJu IGFuIG9mZnNldCB0byB0aGUgbmV4dCBjaGFyYWN0ZXIgaW4gdGhlIGN1cnJlbnQgcnVuLgorICAg ICAgICByZXR1cm4gQVhQb3NpdGlvbihydW5Gcm9tT2Zmc2V0LnRyZWVJRCgpLCBydW5Gcm9tT2Zm c2V0Lm9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IG1fb2Zmc2V0 ICsgMSA6IG1fb2Zmc2V0IC0gMSk7CisgICAgfQorICAgIC8vIG1fb2Zmc2V0IHBvaW50ZWQgdG8g dGhlIGxhc3QgY2hhcmFjdGVyIGluIHRoZSBnaXZlbiBvYmplY3QncyBydW5zLCBzbyBsZXQncyB0 cmF2ZXJzZSB0byBmaW5kIHRoZSBuZXh0IG9iamVjdCB3aXRoIHJ1bnMuCisgICAgaWYgKFJlZlB0 ciBvYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMocnVuRnJvbU9mZnNldC5vYmplY3QuZ2V0KCks IGRpcmVjdGlvbikpCisgICAgICAgIHJldHVybiBBWFBvc2l0aW9uKG9iamVjdC0+dHJlZUlEKCks IG9iamVjdC0+b2JqZWN0SUQoKSwgZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6 IG9iamVjdC0+dGV4dFJ1bnMoKS0+bGFzdFJ1bkxlbmd0aCgpKTsKKworICAgIHJldHVybiBudWxs UG9zaXRpb24oKTsKK30KKworQVhQb3NpdGlvbiBBWFBvc2l0aW9uOjpmaW5kUG9zaXRpb24oQVhE aXJlY3Rpb24gZGlyZWN0aW9uLCBBWFRleHRVbml0IHRleHRVbml0LCBBWFRleHRVbml0Qm91bmRh cnkgYm91bmRhcnkpIGNvbnN0Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJu IG51bGxQb3NpdGlvbigpOworCisgICAgaWYgKHRleHRVbml0ID09IEFYVGV4dFVuaXQ6OkxpbmUp IHsKKyAgICAgICAgYXV0byBydW5Gcm9tT2Zmc2V0ID0gdGhpcy0+cnVuRnJvbU9mZnNldCgpOwor ICAgICAgICBSZWZQdHIgY3VycmVudE9iamVjdCA9IFdURk1vdmUocnVuRnJvbU9mZnNldC5vYmpl Y3QpOworICAgICAgICBjb25zdCBhdXRvKiBjdXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRl eHRSdW5zKCk7CisKKyAgICAgICAgYXV0byBjb21wdXRlT2Zmc2V0ID0gWyZdIChzaXplX3QgcnVu RW5kT2Zmc2V0LCBzaXplX3QgcnVuTGVuZ3RoKSB7CisgICAgICAgICAgICAvLyBUaGlzIHdvcmtz IGJlY2F1c2UgYHJ1bkVuZE9mZnNldGAgaXMgdGhlIG9mZnNldCBwb2ludGluZyB0byB0aGUgZW5k IG9mIHRoZSBnaXZlbiBydW4sIHdoaWNoIGluY2x1ZGVzIHRoZSBsZW5ndGggb2YgYWxsIHJ1bnMg cHJlY2VkaW5nIGl0LiBTbyBzdWJ0cmFjdGluZyB0aGF0IGZyb20gdGhlIGxlbmd0aCBvZiB0aGUg Y3VycmVudCBydW4gZ2l2ZXMgdXMgYW4gb2Zmc2V0IHRvIHRoZSBzdGFydCBvZiB0aGUgY3VycmVu dCBydW4uCisgICAgICAgICAgICByZXR1cm4gYm91bmRhcnkgPT0gQVhUZXh0VW5pdEJvdW5kYXJ5 OjpFbmQgPyBydW5FbmRPZmZzZXQgOiBydW5FbmRPZmZzZXQgLSBydW5MZW5ndGg7CisgICAgICAg IH07CisgICAgICAgIGF1dG8gbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihjdXJyZW50T2JqZWN0 LT50cmVlSUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29tcHV0ZU9mZnNldChjdXJy ZW50UnVucy0+cnVuTGVuZ3RoU3VtKHJ1bkZyb21PZmZzZXQuaW5kZXgpLCBjdXJyZW50UnVucy0+ cnVuTGVuZ3RoKHJ1bkZyb21PZmZzZXQuaW5kZXgpKSk7CisgICAgICAgIGF1dG8gc3RhcnRMaW5l SUQgPSBjdXJyZW50UnVucy0+bGluZUlEKHJ1bkZyb21PZmZzZXQuaW5kZXgpOworICAgICAgICAv LyBXZSBmb3VuZCB0aGUgc3RhcnQgcnVuIGFuZCBhc3NvY2lhdGVkIGxpbmUsIG5vdyBpdGVyYXRl IHVudGlsIHdlIGZpbmQgYSBsaW5lIGJvdW5kYXJ5LgorICAgICAgICB3aGlsZSAoY3VycmVudE9i amVjdCkgeworICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoY3VycmVudFJ1bnMtPnNpemUoKSk7 CisgICAgICAgICAgICB1bnNpZ25lZCBjdW11bGF0aXZlT2Zmc2V0ID0gMDsKKyAgICAgICAgICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY3VycmVudFJ1bnMtPnNpemUoKTsgaSsrKSB7CisgICAg ICAgICAgICAgICAgY3VtdWxhdGl2ZU9mZnNldCArPSBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkp OworICAgICAgICAgICAgICAgIGlmIChjdXJyZW50UnVucy0+bGluZUlEKGkpICE9IHN0YXJ0TGlu ZUlEKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gbGluZVBvc2l0aW9uOworICAgICAgICAg ICAgICAgIGxpbmVQb3NpdGlvbiA9IEFYUG9zaXRpb24oY3VycmVudE9iamVjdC0+dHJlZUlEKCks IGN1cnJlbnRPYmplY3QtPm9iamVjdElEKCksIGNvbXB1dGVPZmZzZXQoY3VtdWxhdGl2ZU9mZnNl dCwgY3VycmVudFJ1bnMtPnJ1bkxlbmd0aChpKSkpOworICAgICAgICAgICAgfQorICAgICAgICAg ICAgY3VycmVudE9iamVjdCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudE9iamVjdCwgZGly ZWN0aW9uKTsKKyAgICAgICAgICAgIGlmIChjdXJyZW50T2JqZWN0KQorICAgICAgICAgICAgICAg IGN1cnJlbnRSdW5zID0gY3VycmVudE9iamVjdC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgfQorICAg ICAgICByZXR1cm4gbGluZVBvc2l0aW9uOworICAgIH0KKyAgICByZXR1cm4gbnVsbFBvc2l0aW9u KCk7Cit9CisKK1J1bkZyb21PZmZzZXQgQVhQb3NpdGlvbjo6cnVuRnJvbU9mZnNldCgpIGNvbnN0 Cit7CisgICAgc2l6ZV90IGN1bXVsYXRpdmVPZmZzZXQgPSAwOworICAgIFJlZlB0ciBjdXJyZW50 ID0gZmluZE9iamVjdFdpdGhSdW5zKCpvYmplY3QoKSwgQVhEaXJlY3Rpb246Ok5leHQsIENoZWNr U3RhcnQ6Olllcyk7CisgICAgLy8gSW5kZXggb2YgdGhlIHJ1biB3ZSBzdGFydCBhdCBiYXNlZCBv biBtX29mZnNldC4KKyAgICBzaXplX3Qgc3RhcnRSdW5JbmRleCA9IG5vdEZvdW5kOworICAgIHdo aWxlIChjdXJyZW50ICYmIHN0YXJ0UnVuSW5kZXggPT0gbm90Rm91bmQpIHsKKyAgICAgICAgYXV0 byYgY3VycmVudFJ1bnMgPSAqY3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgZm9yICh1bnNp Z25lZCBpID0gMDsgaSA8IGN1cnJlbnRSdW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBj dW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5zLnJ1bkxlbmd0aChpKTsKKyAgICAgICAgICAg IGlmIChjdW11bGF0aXZlT2Zmc2V0ID49IG1fb2Zmc2V0KSB7CisgICAgICAgICAgICAgICAgc3Rh cnRSdW5JbmRleCA9IGk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKworICAgICAgICBpZiAoc3RhcnRSdW5JbmRleCAhPSBub3RGb3VuZCkKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpjdXJy ZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgfQorCisgICAgaWYgKHN0YXJ0UnVuSW5kZXgg PT0gbm90Rm91bmQpIHsKKyAgICAgICAgLy8gRklYTUU6IE5vdCBzdXJlIGhvdyB0aGlzIGNvdWxk IGhhcHBlbiwgYnV0IHdlIG1heSBuZWVkIHRvIGhhbmRsZSBpdCBzb21laG93PworICAgICAgICBS RUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KKyAgICByZXR1cm4geyAqY3VycmVu dCwgc3RhcnRSdW5JbmRleCB9OworfQorCitBWFRleHRNYXJrZXJSYW5nZSBBWFBvc2l0aW9uOjps aW5lUmFuZ2UoTGluZVJhbmdlVHlwZSB0eXBlKSBjb25zdAoreworICAgIGlmICghb2JqZWN0KCkp CisgICAgICAgIHJldHVybiB7IG51bGxQb3NpdGlvbigpLCBudWxsUG9zaXRpb24oKSB9OworCisg ICAgaWYgKHR5cGUgPT0gTGluZVJhbmdlVHlwZTo6Q3VycmVudCkKKyAgICAgICAgcmV0dXJuIHsg ZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpQcmV2aW91cywgQVhUZXh0VW5pdDo6TGluZSwgQVhU ZXh0VW5pdEJvdW5kYXJ5OjpTdGFydCksIGZpbmRQb3NpdGlvbihBWERpcmVjdGlvbjo6TmV4dCwg QVhUZXh0VW5pdDo6TGluZSwgQVhUZXh0VW5pdEJvdW5kYXJ5OjpFbmQpIH07CisgICAgLy8gVGhl IG90aGVyIHR5cGVzIGFyZW4ndCBpbXBsZW1lbnRlZCB5ZXQuCisgICAgUkVMRUFTRV9BU1NFUlRf Tk9UX1JFQUNIRUQoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY UG9zaXRpb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjEzMGRl ZDg3NmQ5NgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhQb3NpdGlvbi5oCkBAIC0wLDAgKzEsMTA0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIz IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G CisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNl CisKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyNpbmNsdWRlICJBWElzb2xhdGVk T2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0TWFya2VyLmgiCisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworZW51bSBjbGFzcyBBWFRleHRVbml0IDogdWludDhfdCB7CisgICAgTGluZSwKKyAgICBQ YXJhZ3JhcGgsCisgICAgU2VudGVuY2UsCisgICAgV29yZCwKK307CitlbnVtIGNsYXNzIEFYVGV4 dFVuaXRCb3VuZGFyeSA6IGJvb2wgeyBTdGFydCwgRW5kLCB9OworCitlbnVtIGNsYXNzIExpbmVS YW5nZVR5cGUgOiB1aW50OF90IHsKKyAgICBDdXJyZW50LAorICAgIExlZnQsCisgICAgUmlnaHQs Cit9OworCitzdHJ1Y3QgUnVuRnJvbU9mZnNldCB7CisgICAgLy8gVGhlIGxlYWYgbm9kZSB3aXRo IHJ1bnMgcG9pbnRlZCB0byBieSB0aGUgb2Zmc2V0IHVzZWQgdG8gY29tcHV0ZSB0aGlzIHN0cnVj dC4KKyAgICBSZWY8QVhJc29sYXRlZE9iamVjdD4gb2JqZWN0OworICAgIC8vIFJ1biBpbmRleCBw b2ludGVkIHRvIGJ5IHRoZSBvZmZzZXQgdXNlZCB0byBjb21wdXRlIHRoaXMgc3RydWN0LgorICAg IHNpemVfdCBpbmRleCB7IDAgfTsKKworICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgeyByZXR1cm4g b2JqZWN0LT50cmVlSUQoKTsgfQorICAgIEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJldHVybiBv YmplY3QtPm9iamVjdElEKCk7IH0KKyAgICBjb25zdCBBWFRleHRSdW4mIHJ1bigpIGNvbnN0IHsg cmV0dXJuICgqb2JqZWN0LT50ZXh0UnVucygpKVtpbmRleF07IH0KKworICAgIFJ1bkZyb21PZmZz ZXQoQVhJc29sYXRlZE9iamVjdCYgb2JqZWN0LCBzaXplX3QgcnVuSW5kZXgpCisgICAgICAgIDog b2JqZWN0KG9iamVjdCkKKyAgICAgICAgLCBpbmRleChydW5JbmRleCkKKyAgICB7CisgICAgICAg IFJFTEVBU0VfQVNTRVJUKHJ1bkluZGV4IDwgb2JqZWN0LnRleHRSdW5zKCktPnNpemUoKSk7Cisg ICAgfQorfTsKKworY2xhc3MgQVhQb3NpdGlvbiB7CitwdWJsaWM6CisgICAgZXhwbGljaXQgQVhQ b3NpdGlvbihBWElEIHRyZWVJRCwgQVhJRCBvYmplY3RJRCwgdW5zaWduZWQgb2Zmc2V0KQorICAg ICAgICA6IG1fdHJlZUlEKHRyZWVJRCkKKyAgICAgICAgLCBtX29iamVjdElEKG9iamVjdElEKQor ICAgICAgICAsIG1fb2Zmc2V0KG9mZnNldCkKKyAgICB7IH0KKyAgICBzdGF0aWMgQVhQb3NpdGlv biBudWxsUG9zaXRpb24oKSB7IHJldHVybiBBWFBvc2l0aW9uKEFYSUQoKSwgQVhJRCgpLCAwKTsg fQorICAgIHN0YXRpYyBBWFBvc2l0aW9uIGZyb21UZXh0TWFya2VyKGNvbnN0IEFYVGV4dE1hcmtl ciYpOworICAgIG9wZXJhdG9yIEFYVGV4dE1hcmtlcigpIGNvbnN0OworCisgICAgQVhJRCB0cmVl SUQoKSBjb25zdCB7IHJldHVybiBtX3RyZWVJRDsgfQorICAgIEFYSUQgb2JqZWN0SUQoKSBjb25z dCB7IHJldHVybiBtX29iamVjdElEOyB9CisgICAgdW5zaWduZWQgb2Zmc2V0KCkgY29uc3QgeyBy ZXR1cm4gbV9vZmZzZXQ7IH0KKworICAgIEFYSXNvbGF0ZWRPYmplY3QqIG9iamVjdCgpIGNvbnN0 OworICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyByZXR1cm4gIXRyZWVJRCgpLmlzVmFsaWQoKSB8 fCAhb2JqZWN0SUQoKS5pc1ZhbGlkKCk7IH0KKworICAgIC8vIEZpbmQgdGhlIG5leHQgb3IgcHJl dmlvdXMgcG9zaXRpb24uCisgICAgQVhQb3NpdGlvbiBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb24p IGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZyb20gdGhpcyBwb3NpdGlvbiwgY3JlYXRlcyBhIG5l dyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVuIGRpcmVjdGlvbiBhbmQgdGV4dCB1bml0IHR5cGUuCisg ICAgQVhQb3NpdGlvbiBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb24sIEFYVGV4dFVuaXQsIEFYVGV4 dFVuaXRCb3VuZGFyeSkgY29uc3Q7CisgICAgQVhUZXh0TWFya2VyUmFuZ2UgbGluZVJhbmdlKExp bmVSYW5nZVR5cGUpIGNvbnN0OworCisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25z dDsKKworcHJpdmF0ZToKKyAgICAvLyBHZXRzIHRoZSBydW4gcG9pbnRlZCB0byBieSBtX29mZnNl dCAoYW5kIHNvbWUgYXNzb2NpYXRlZCBpbmZvcm1hdGlvbikuCisgICAgUnVuRnJvbU9mZnNldCBy dW5Gcm9tT2Zmc2V0KCkgY29uc3Q7CisKKyAgICBBWElEIG1fdHJlZUlEOworICAgIEFYSUQgbV9v YmplY3RJRDsKKyAgICB1bnNpZ25lZCBtX29mZnNldCB7IDAgfTsKKworICAgIG11dGFibGUgUmVm UHRyPEFYSXNvbGF0ZWRPYmplY3Q+IG1fY2FjaGVkT2JqZWN0OworfTsKKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCmluZGV4IDlhZDZhYmY5 M2FhYy4uZDJkNDMzYmNiYjFiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FYVGV4dE1hcmtlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WFRleHRNYXJrZXIuY3BwCkBAIC0zMzUsNyArMzM1LDcgQEAgc3RkOjpvcHRpb25hbDxBWFRleHRN YXJrZXJSYW5nZT4gQVhUZXh0TWFya2VyUmFuZ2U6OmludGVyc2VjdGlvbldpdGgoY29uc3QgQVhU ZXgKIAogU3RyaW5nIEFYVGV4dE1hcmtlclJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QK IHsKLSAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsiLCBtX3N0YXJ0LmRlYnVnRGVzY3Jp cHRpb24oKSwgIn1cbmVuZDogeyIsIG1fZW5kLmRlYnVnRGVzY3JpcHRpb24oKSwgIn0iKTsKKyAg ICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsiLCBtX3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24o KSwgIn1cbmVuZDogICB7IiwgbV9lbmQuZGVidWdEZXNjcmlwdGlvbigpLCAifSIpOwogfQogCiBz dGQ6OnBhcnRpYWxfb3JkZXJpbmcgcGFydGlhbE9yZGVyKGNvbnN0IEFYVGV4dE1hcmtlciYgbWFy a2VyMSwgY29uc3QgQVhUZXh0TWFya2VyJiBtYXJrZXIyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhUZXh0TWFya2VyLmgKaW5kZXggMTdlOWZjMGRhYjk4Li41OWY0ZjM3OTYzMTUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaApAQCAtMTIz LDYgKzEyMyw3IEBAIHB1YmxpYzoKIAogICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgeyByZXR1cm4g bV9kYXRhLmF4VHJlZUlEKCk7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4g bV9kYXRhLmF4T2JqZWN0SUQoKTsgfQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNvbnN0IHsgcmV0 dXJuIG1fZGF0YS5vZmZzZXQ7IH0KICAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICF0 cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElEKCkuaXNWYWxpZCgpOyB9CiAgICAgUmVmUHRy PEFYQ29yZU9iamVjdD4gb2JqZWN0KCkgY29uc3Q7CiAgICAgYm9vbCBpc1ZhbGlkKCkgY29uc3Qg eyByZXR1cm4gb2JqZWN0KCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0UnVuLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1 bi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYTg4ZmM4Mjc0NDdk Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRS dW4uaApAQCAtMCwwICsxLDEyNSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJwor ICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAq IEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYg RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNz IFJlbmRlckJsb2NrOworCitzdHJ1Y3QgQVhUZXh0UnVuTGluZUlEIHsKKyAgICB2b2lkKiBjb250 YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAgc2l6ZV90IGxpbmVJbmRleCB7IDAgfTsKKwor ICAgIEFYVGV4dFJ1bkxpbmVJRCh2b2lkKiBjb250YWluaW5nQmxvY2ssIHNpemVfdCBsaW5lSW5k ZXgpCisgICAgICAgIDogY29udGFpbmluZ0Jsb2NrKGNvbnRhaW5pbmdCbG9jaykKKyAgICAgICAg LCBsaW5lSW5kZXgobGluZUluZGV4KQorICAgIHsgfQorICAgIGJvb2wgb3BlcmF0b3I9PShjb25z dCBBWFRleHRSdW5MaW5lSUQmKSBjb25zdCA9IGRlZmF1bHQ7CisgICAgU3RyaW5nIGRlYnVnRGVz Y3JpcHRpb24oKSBjb25zdAorICAgIHsKKyAgICAgICAgVGV4dFN0cmVhbSBzdHJlYW07CisgICAg ICAgIHN0cmVhbSA8PCAiTGluZUlEICIgPDwgY29udGFpbmluZ0Jsb2NrIDw8ICIgIiA8PCBsaW5l SW5kZXg7CisgICAgICAgIHJldHVybiBzdHJlYW0ucmVsZWFzZSgpOworICAgIH0KK307CisKK3N0 cnVjdCBBWFRleHRSdW4geworICAgIC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhp biB0aGUgY29udGV4dCBvZiB0aGUgY29udGFpbmluZyBSZW5kZXJCbG9jayBvZiB0aGUgbWFpbi10 aHJlYWQgQVggb2JqZWN0LgorICAgIHNpemVfdCBsaW5lSW5kZXg7CisgICAgU3RyaW5nIHRleHQ7 CisKKyAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5nJiYgdGV4dCkKKyAgICAg ICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQorICAgICAgICAsIHRleHQoV1RGTW92ZSh0ZXh0KSkK KyAgICB7IH0KKworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKHZvaWQqIGNvbnRhaW5pbmdC bG9jaykgY29uc3QKKyAgICB7CisgICAgICAgIEFYVGV4dFJ1bkxpbmVJRCBsaW5lSUQgPSB7IGNv bnRhaW5pbmdCbG9jaywgbGluZUluZGV4IH07CisgICAgICAgIHJldHVybiBtYWtlU3RyaW5nKGxp bmVJRC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICI6IHwiLCBtYWtlU3RyaW5nQnlSZXBsYWNpbmdBbGwo dGV4dCwgJ1xuJywgIntuZXdsaW5lfSJfcyksICJ8KGxlbiAiLCB0ZXh0Lmxlbmd0aCgpLCAiKSIp OworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW5zIHsKKyAgICAvLyBUaGUgY29udGFpbmlu ZyBibG9jayBmb3IgdGhlIHRleHQgcnVucy4gVGhpcyBpcyByZXF1aXJlZCBiZWNhdXNlIGJhc2Vk IG9uIHRoZSBzdHJ1Y3R1cmUKKyAgICAvLyBvZiB0aGUgQVggdHJlZSwgdGV4dCBydW5zIGZvciBk aWZmZXJlbnQgb2JqZWN0cyBjYW4gaGF2ZSB0aGUgc2FtZSBsaW5lIGluZGV4IGJ1dCBkaWZmZXJl bnQKKyAgICAvLyBjb250YWluaW5nIGJsb2NrcywgbWVhbmluZyB0aGV5IGFyZSByZW5kZXJlZCBv biBkaWZmZXJlbnQgbGluZXMuCisgICAgLy8gRG8gbm90IGRlLXJlZmVyZW5jZS4gVXNlIGZvciBj b21wYXJpc29uIHB1cnBvc2VzIG9ubHkuCisgICAgdm9pZCogY29udGFpbmluZ0Jsb2NrIHsgbnVs bHB0ciB9OworICAgIFZlY3RvcjxBWFRleHRSdW4+IHJ1bnM7CisKKyAgICBBWFRleHRSdW5zKCkg PSBkZWZhdWx0OworICAgIEFYVGV4dFJ1bnMoUmVuZGVyQmxvY2sqIGNvbnRhaW5pbmdCbG9jaywg VmVjdG9yPEFYVGV4dFJ1bj4mJiBydW5zKQorICAgICAgICA6IGNvbnRhaW5pbmdCbG9jayhjb250 YWluaW5nQmxvY2spCisgICAgICAgICwgcnVucyhXVEZNb3ZlKHJ1bnMpKQorICAgIHsgfQorCisg ICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IHJldHVybiBydW5zLnNpemUoKTsgfQorICAgIHVuc2ln bmVkIHJ1bkxlbmd0aChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNF X0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHJ1bnNbaW5kZXhd LnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2lnbmVkIGxhc3RSdW5MZW5ndGgoKSBjb25z dAorICAgIHsKKyAgICAgICAgaWYgKHJ1bnMuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0dXJu IDA7CisgICAgICAgIHJldHVybiBydW5zW3J1bnMuc2l6ZSgpIC0gMV0udGV4dC5sZW5ndGgoKTsK KyAgICB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoU3VtKHNpemVfdCBpbmRleCkgY29uc3QKKyAg ICB7CisgICAgICAgIHVuc2lnbmVkIGxlbmd0aCA9IDA7CisgICAgICAgIGZvciAoc2l6ZV90IGkg PSAwOyBpIDw9IGluZGV4ICYmIGkgPCBydW5zLnNpemUoKTsgaSsrKQorICAgICAgICAgICAgbGVu Z3RoICs9IHJ1bkxlbmd0aChpKTsKKyAgICAgICAgcmV0dXJuIGxlbmd0aDsKKyAgICB9CisgICAg QVhUZXh0UnVuTGluZUlEIGxpbmVJRChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAg ICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHsg Y29udGFpbmluZ0Jsb2NrLCBydW5zW2luZGV4XS5saW5lSW5kZXggfTsKKyAgICB9CisgICAgY29u c3QgQVhUZXh0UnVuJiBvcGVyYXRvcltdKHNpemVfdCBydW5JbmRleCkgY29uc3QKKyAgICB7Cisg ICAgICAgIFJFTEVBU0VfQVNTRVJUKHJ1bkluZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICBy ZXR1cm4gcnVuc1tydW5JbmRleF07CisgICAgfQorICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9u KCkgY29uc3QKKyAgICB7CisgICAgICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgICAgICBy ZXN1bHQuYXBwZW5kKCdbJyk7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5z LnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0uZGVidWdE ZXNjcmlwdGlvbihjb250YWluaW5nQmxvY2spKTsKKyAgICAgICAgICAgIGlmIChpICE9IHJ1bnMu c2l6ZSgpIC0gMSkKKyAgICAgICAgICAgICAgICByZXN1bHQuYXBwZW5kKCIsICIpOworICAgICAg ICB9CisgICAgICAgIHJlc3VsdC5hcHBlbmQoJ10nKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdC50 b1N0cmluZygpOworICAgIH0KK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAv LyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCmluZGV4IGVmMDg3NzA1OGZlYi4u MDZkYTg5OTU5OWMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKQEAgLTExMyw2ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3Np YmlsaXR5T2JqZWN0Ojppbml0KCkKICAgICBtX3JvbGUgPSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5 Um9sZSgpOwogfQogCitBWElEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7 CisgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENhY2hlKCk7CisgICAgcmV0dXJuIGNhY2hlID8g Y2FjaGUtPnRyZWVJRCgpIDogQVhJRCgpOworfQorCiBpbmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2li aWxpdHlPYmplY3Q6OnByb2Nlc3NJRCgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHByZXNlbnRpbmdB cHBsaWNhdGlvblBJRCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlPYmplY3QuaAppbmRleCA1ZDg4Y2M2MTI4YzMuLmM1YmIzOTUyOTMyMiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSAiQVhDb3JlT2Jq ZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCiAjaW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2Uu aCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNsdWRlICJMYXlvdXRSZWN0LmgiCkBAIC02 Myw2ICs2NCw3IEBAIGNsYXNzIEFjY2Vzc2liaWxpdHlPYmplY3QgOiBwdWJsaWMgQVhDb3JlT2Jq ZWN0LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8QWNjZXNzaWJpCiBwdWJsaWM6CiAgICAgdmlydHVh bCB+QWNjZXNzaWJpbGl0eU9iamVjdCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5h bDsKICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5n IGRiZygpIGNvbnN0IGZpbmFsOwogCkBAIC0zODAsNiArMzgyLDkgQEAgcHVibGljOgogICAgIFN0 cmluZyB0ZXh0VW5kZXJFbGVtZW50KEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9 IEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZSB7IHJl dHVybiB7IH07IH0KICAgICBTdHJpbmcgdGV4dCgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsg fTsgfQogICAgIHVuc2lnbmVkIHRleHRMZW5ndGgoKSBjb25zdCBmaW5hbDsKKyNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICB2aXJ0dWFsIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7 IHJldHVybiB7IH07IH0KKyNlbmRpZgogI2lmIFBMQVRGT1JNKENPQ09BKQogICAgIC8vIFJldHVy bnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyBhbmQgQVhPYmplY3Qgd3JhcHBlcnMgY29ycmVzcG9uZGlu ZyB0byB0aGUKICAgICAvLyB0ZXh0cnVucyBhbmQgcmVwbGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQg aW4gdGhlIGdpdmVuIHJhbmdlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKaW5kZXggMzhhNGFhZjY1N2Yy Li45OGU4NDAyZTM2YTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcApAQCAtMTM5NSwxMSArMTM5NSwx MSBAQCBDaGFyYWN0ZXJSYW5nZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRl eHRSYW5nZSgpIGNvbnN0CiB9CiAKICNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLVZl Y3RvcjxBWFRleHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FY VGV4dFJ1bnMgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGV4dFJ1bnMoKQogewogICAgIGlm IChhdXRvKiByZW5kZXJMaW5lQnJlYWsgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVyTGluZUJyZWFr PihyZW5kZXJlcigpKSkgewogICAgICAgICBhdXRvIGJveCA9IElubGluZUl0ZXJhdG9yOjpib3hG b3IoKnJlbmRlckxpbmVCcmVhayk7Ci0gICAgICAgIHJldHVybiB7IHsgYm94LT5saW5lSW5kZXgo KSwgbWFrZVN0cmluZygnXG4nKSB9IH07CisgICAgICAgIHJldHVybiB7IHJlbmRlckxpbmVCcmVh ay0+Y29udGFpbmluZ0Jsb2NrKCksIHsgQVhUZXh0UnVuKGJveC0+bGluZUluZGV4KCksIG1ha2VT dHJpbmcoJ1xuJykuaXNvbGF0ZWRDb3B5KCkpIH0gfTsKICAgICB9CiAKICAgICBXZWFrUHRyIHJl bmRlclRleHQgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVyVGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0x NDUyLDcgKzE0NTIsNyBAQCBWZWN0b3I8QVhUZXh0UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0Ojp0ZXh0UnVucygpCiAKICAgICBpZiAoIWxpbmVTdHJpbmcuaXNFbXB0eSgpKQogICAgICAg ICBydW5zLmFwcGVuZCh7IGN1cnJlbnRMaW5lSW5kZXgsIGxpbmVTdHJpbmcudG9TdHJpbmcoKS5p c29sYXRlZENvcHkoKSB9KTsKLSAgICByZXR1cm4gcnVuczsKKyAgICByZXR1cm4geyByZW5kZXJU ZXh0LT5jb250YWluaW5nQmxvY2soKSwgV1RGTW92ZShydW5zKSB9OwogfQogI2VuZGlmIC8vIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCmluZGV4IGNlZWM2YmYz ZTg5OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaApAQCAtMTAwLDcgKzEwMCw3IEBA IHB1YmxpYzoKICAgICBTdHJpbmcgdGV4dFVuZGVyRWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVu ZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29u c3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIHNlbGVjdGVkVGV4dCgpIGNvbnN0IG92ZXJyaWRlOwog I2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRl eHRSdW5zKCkgZmluYWw7CisgICAgQVhUZXh0UnVucyB0ZXh0UnVucygpIGZpbmFsOwogI2VuZGlm CiAKICAgICBib29sIGlzV2lkZ2V0KCkgY29uc3Qgb3ZlcnJpZGU7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNw cCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRP YmplY3QuY3BwCmluZGV4IDYyYTFhNTc1YWU2MS4uMzQ1ZjJkNTNkZjU4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElz b2xhdGVkT2JqZWN0LmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkFYR2VvbWV0cnlN YW5hZ2VyLmgiCiAjaW5jbHVkZSAiQVhJc29sYXRlZFRyZWUuaCIKICNpbmNsdWRlICJBWExvZ2dl ci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgogCiAjaWYgUExBVEZPUk0oTUFDKQogI2ltcG9y dCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5oPgpAQCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQg QVhJc29sYXRlZE9iamVjdDo6c2V0UHJvcGVydHkoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1l LCBBWFByb3BlcnR5VmFsdWVWCiAgICAgICAgIFtdKHN0ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJS YW5nZT4mIHR5cGVkVmFsdWUpIHsKICAgICAgICAgICAgIHJldHVybiAhdHlwZWRWYWx1ZS5maXJz dC5pc1ZhbGlkKCkgJiYgIXR5cGVkVmFsdWUuc2Vjb25kLmxvY2F0aW9uICYmICF0eXBlZFZhbHVl LnNlY29uZC5sZW5ndGg7CiAgICAgICAgIH0sCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCisgICAgICAgIFtdKEFYVGV4dFJ1bnMgcnVucykgeyByZXR1cm4gIXJ1bnMuc2l6ZSgpOyB9 LAorI2VuZGlmCiAgICAgICAgIFtdKGF1dG8mKSB7CiAgICAgICAgICAgICBBU1NFUlRfTk9UX1JF QUNIRUQoKTsKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTU1Nyw2ICs1NjEsMTkgQEAg dm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRTZWxlY3RlZENoaWxkcmVuKGNvbnN0IEFjY2Vzc2li aWxpdHlDaGlsZHJlblZlY3RvciYgc2UKICAgICB9KTsKIH0KIAorQVhDb3JlT2JqZWN0KiBBWElz b2xhdGVkT2JqZWN0OjpzaWJsaW5nKEFYRGlyZWN0aW9uIGRpcmVjdGlvbikgY29uc3QKK3sKKyAg ICBSZWZQdHIgcGFyZW50ID0gcGFyZW50T2JqZWN0VW5pZ25vcmVkKCk7CisgICAgY29uc3QgYXV0 byYgc2libGluZ3MgPSBwYXJlbnQtPmNoaWxkcmVuKCk7CisgICAgc2l6ZV90IGluZGV4T2ZUaGlz ID0gc2libGluZ3MuZmluZCh0aGlzKTsKKyAgICBpZiAoaW5kZXhPZlRoaXMgPT0gbm90Rm91bmQp CisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6TmV4dCkKKyAgICAgICAgcmV0dXJuIGluZGV4T2ZUaGlzICsgMSA8IHNpYmxpbmdzLnNp emUoKSA/IHNpYmxpbmdzW2luZGV4T2ZUaGlzICsgMV0uZ2V0KCkgOiBudWxscHRyOworICAgIHJl dHVybiBpbmRleE9mVGhpcyA+IDAgPyBzaWJsaW5nc1tpbmRleE9mVGhpcyAtIDFdLmdldCgpIDog bnVsbHB0cjsKK30KKwogYm9vbCBBWElzb2xhdGVkT2JqZWN0Ojppc0RldGFjaGVkRnJvbVBhcmVu dCgpCiB7CiAgICAgaWYgKHBhcmVudCgpLmlzVmFsaWQoKSkKQEAgLTk3MSw2ICs5ODgsMTkgQEAg aW50IEFYSXNvbGF0ZWRPYmplY3Q6OmludEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lIHBy b3BlcnR5TmFtZSkgY29uc3QKICAgICApOwogfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhU X0FQSVMpCitjb25zdCBBWFRleHRSdW5zKiBBWElzb2xhdGVkT2JqZWN0Ojp0ZXh0UnVucygpIGNv bnN0Cit7CisgICAgYXV0byBlbnRyeSA9IG1fcHJvcGVydHlNYXAuZmluZChBWFByb3BlcnR5TmFt ZTo6VGV4dFJ1bnMpOworICAgIGlmIChlbnRyeSA9PSBtX3Byb3BlcnR5TWFwLmVuZCgpKQorICAg ICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1cm4gV1RGOjpzd2l0Y2hPbihlbnRyeS0+dmFs dWUsCisgICAgICAgIFtdIChjb25zdCBBWFRleHRSdW5zJiB0eXBlZFZhbHVlKSAtPiBjb25zdCBB WFRleHRSdW5zKiB7IHJldHVybiAmdHlwZWRWYWx1ZTsgfSwKKyAgICAgICAgW10gKGF1dG8mKSAt PiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiBudWxscHRyOyB9CisgICAgKTsKK30KKyNlbmRp ZgorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogVCBBWElzb2xhdGVkT2JqZWN0OjpnZXRPclJldHJp ZXZlUHJvcGVydHlWYWx1ZShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUpCiB7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk T2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElz b2xhdGVkT2JqZWN0LmgKaW5kZXggYTZjYTAzNDM3NzdkLi44ZDk0YWQyYmQ5ZDcgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRP YmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9B WElzb2xhdGVkT2JqZWN0LmgKQEAgLTQ0LDYgKzQ0LDkgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAogY2xhc3MgQVhJc29sYXRlZFRyZWU7CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CitzdHJ1Y3QgQVhUZXh0UnVuczsKKyNlbmRpZgogCiBjbGFzcyBBWElzb2xhdGVkT2JqZWN0IGZp bmFsIDogcHVibGljIEFYQ29yZU9iamVjdCB7CiAgICAgZnJpZW5kIGNsYXNzIEFYSXNvbGF0ZWRU cmVlOwpAQCAtNTEsNyArNTQsOSBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFJlZjxBWElzb2xhdGVk T2JqZWN0PiBjcmVhdGUoY29uc3QgUmVmPEFjY2Vzc2liaWxpdHlPYmplY3Q+JiwgQVhJc29sYXRl ZFRyZWUqKTsKICAgICB+QVhJc29sYXRlZE9iamVjdCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBj b25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnRyZWVJRCgpOyB9CiAgICAgUHJvY2Vzc0lEIHBy b2Nlc3NJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+cHJvY2Vzc0lEKCk7IH0KKyAg ICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBzdGF0 aWNfY2FzdDxBY2Nlc3NpYmlsaXR5Um9sZT4oaW50QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5h bWU6OlJvbGVWYWx1ZSkpOyB9CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCiAgICAg dm9pZCBhdHRhY2hQbGF0Zm9ybVdyYXBwZXIoQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIqKTsK QEAgLTU5LDEwICs2NCwxNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc1RhYmxlKCkgY29uc3QgZmlu YWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc1RhYmxlKTsg fQogICAgIGJvb2wgaXNFeHBvc2FibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmli dXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OklzRXhwb3NhYmxlKTsgfQogCisgICAgY29uc3QgQWNj ZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZO ZWVkZWQgPSB0cnVlKSBmaW5hbDsKKyAgICBBWENvcmVPYmplY3QqIHNpYmxpbmcoQVhEaXJlY3Rp b24pIGNvbnN0OwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdCgpIGNvbnN0IGZp bmFsIHsgcmV0dXJuIHBhcmVudE9iamVjdFVuaWdub3JlZCgpOyB9CisgICAgQVhJc29sYXRlZE9i amVjdCogcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRl ZE9iamVjdCogZWRpdGFibGVBbmNlc3RvcigpIGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6 OmVkaXRhYmxlQW5jZXN0b3IoKnRoaXMpOyB9OwogICAgIGJvb2wgY2FuU2V0Rm9jdXNBdHRyaWJ1 dGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5h bWU6OkNhblNldEZvY3VzQXR0cmlidXRlKTsgfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhU X0FQSVMpCisgICAgY29uc3QgQVhUZXh0UnVucyogdGV4dFJ1bnMoKSBjb25zdDsKKyNlbmRpZgor CiBwcml2YXRlOgogICAgIHZvaWQgZGV0YWNoUmVtb3RlUGFydHMoQWNjZXNzaWJpbGl0eURldGFj aG1lbnRUeXBlKSBmaW5hbDsKICAgICB2b2lkIGRldGFjaFBsYXRmb3JtV3JhcHBlcihBY2Nlc3Np YmlsaXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwpAQCAtMjQzLDcgKzI1NSw2IEBAIHByaXZhdGU6 CiAgICAgVmVjdG9yPFN0cmluZz4gZGV0ZXJtaW5lRHJvcEVmZmVjdHMoKSBjb25zdCBmaW5hbDsK ICAgICBBWElzb2xhdGVkT2JqZWN0KiBhY2Nlc3NpYmlsaXR5SGl0VGVzdChjb25zdCBJbnRQb2lu dCYpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGZvY3VzZWRVSUVsZW1lbnQo KSBjb25zdCBmaW5hbDsKLSAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9y ZWQoKSBjb25zdCBmaW5hbDsKICAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbGlua2Vk T2JqZWN0cygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+b2JqZWN0c0ZvcklEcyh2ZWN0 b3JBdHRyaWJ1dGVWYWx1ZTxBWElEPihBWFByb3BlcnR5TmFtZTo6TGlua2VkT2JqZWN0cykpOyB9 CiAgICAgQVhJc29sYXRlZE9iamVjdCogdGl0bGVVSUVsZW1lbnQoKSBjb25zdCBmaW5hbCB7IHJl dHVybiBvYmplY3RBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6VGl0bGVVSUVsZW1lbnQp OyB9CiAgICAgQVhJc29sYXRlZE9iamVjdCogc2Nyb2xsQmFyKEFjY2Vzc2liaWxpdHlPcmllbnRh dGlvbikgZmluYWw7CkBAIC0yNTEsNyArMjYyLDYgQEAgcHJpdmF0ZToKICAgICBTdHJpbmcgZXhw YW5kZWRUZXh0VmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1 ZShBWFByb3BlcnR5TmFtZTo6RXhwYW5kZWRUZXh0VmFsdWUpOyB9CiAgICAgYm9vbCBzdXBwb3J0 c0V4cGFuZGVkVGV4dFZhbHVlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZh bHVlKEFYUHJvcGVydHlOYW1lOjpTdXBwb3J0c0V4cGFuZGVkVGV4dFZhbHVlKTsgfQogICAgIFNS R0JBPHVpbnQ4X3Q+IGNvbG9yVmFsdWUoKSBjb25zdCBmaW5hbDsKLSAgICBBY2Nlc3NpYmlsaXR5 Um9sZSByb2xlVmFsdWUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3Np YmlsaXR5Um9sZT4oaW50QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVWYWx1ZSkp OyB9CiAgICAgU3RyaW5nIHJvbGVQbGF0Zm9ybVN0cmluZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJu IHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpSb2xlUGxhdGZvcm1TdHJpbmcp OyB9CiAgICAgU3RyaW5nIHJvbGVEZXNjcmlwdGlvbigpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0 cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpSb2xlRGVzY3JpcHRpb24pOyB9CiAg ICAgU3RyaW5nIHN1YnJvbGVQbGF0Zm9ybVN0cmluZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0 cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpTdWJyb2xlUGxhdGZvcm1TdHJpbmcp OyB9CkBAIC0zMTYsNyArMzI2LDYgQEAgcHJpdmF0ZToKICAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRy ZW5WZWN0b3IgdmlzaWJsZUNoaWxkcmVuKCkgZmluYWwgeyByZXR1cm4gdHJlZSgpLT5vYmplY3Rz Rm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFYUHJvcGVydHlOYW1lOjpWaXNpYmxl Q2hpbGRyZW4pKTsgfQogICAgIEF0b21TdHJpbmcgdGFnTmFtZSgpIGNvbnN0IGZpbmFsOwogICAg IHZvaWQgc2V0Q2hpbGRyZW5JRHMoVmVjdG9yPEFYSUQ+JiYpOwotICAgIGNvbnN0IEFjY2Vzc2li aWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVlZGVk ID0gdHJ1ZSkgZmluYWw7CiAgICAgdm9pZCB1cGRhdGVDaGlsZHJlbklmTmVjZXNzYXJ5KCkgZmlu YWw7CiAgICAgYm9vbCBpc0RldGFjaGVkRnJvbVBhcmVudCgpIGZpbmFsOwogICAgIEFYSXNvbGF0 ZWRPYmplY3QqIGxpdmVSZWdpb25BbmNlc3Rvcihib29sIGV4Y2x1ZGVJZk9mZiA9IHRydWUpIGNv bnN0IGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6OmxpdmVSZWdpb25BbmNlc3RvcigqdGhp cywgZXhjbHVkZUlmT2ZmKTsgfQpAQCAtMzQ1LDkgKzM1NCw2IEBAIHByaXZhdGU6CiAKICAgICAv LyBDaGFyYWN0ZXJSYW5nZSBzdXBwb3J0LgogICAgIENoYXJhY3RlclJhbmdlIHNlbGVjdGVkVGV4 dFJhbmdlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gcHJvcGVydHlWYWx1ZTxDaGFyYWN0ZXJSYW5n ZT4oQVhQcm9wZXJ0eU5hbWU6OlNlbGVjdGVkVGV4dFJhbmdlKTsgfQotI2lmIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWwg eyByZXR1cm4gdmVjdG9yQXR0cmlidXRlVmFsdWU8QVhUZXh0UnVuPihBWFByb3BlcnR5TmFtZTo6 VGV4dFJ1bnMpOyB9Ci0jZW5kaWYKICAgICBpbnQgaW5zZXJ0aW9uUG9pbnRMaW5lTnVtYmVyKCkg Y29uc3QgZmluYWw7CiAgICAgQ2hhcmFjdGVyUmFuZ2UgZG9BWFJhbmdlRm9yTGluZSh1bnNpZ25l ZCkgY29uc3QgZmluYWw7CiAgICAgU3RyaW5nIGRvQVhTdHJpbmdGb3JSYW5nZShjb25zdCBDaGFy YWN0ZXJSYW5nZSYpIGNvbnN0IGZpbmFsOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaCBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKaW5kZXggZjExZWY4 NTU1YTE0Li45NDUwMjllMDcwNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKKysrIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaApAQCAtMjU1LDcgKzI1 NSw3IEBAIHVzaW5nIEFYUHJvcGVydHlWYWx1ZVZhcmlhbnQgPSBzdGQ6OnZhcmlhbnQ8c3RkOjpu dWxscHRyX3QsIEFYSUQsIFN0cmluZywgYm9vbCwKICAgICAsIFJldGFpblB0cjxOU0F0dHJpYnV0 ZWRTdHJpbmc+CiAjZW5kaWYKICNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICAs IFZlY3RvcjxBWFRleHRSdW4+CisgICAgLCBBWFRleHRSdW5zCiAjZW5kaWYKID47CiB1c2luZyBB WFByb3BlcnR5TWFwID0gSGFzaE1hcDxBWFByb3BlcnR5TmFtZSwgQVhQcm9wZXJ0eVZhbHVlVmFy aWFudCwgSW50SGFzaDxBWFByb3BlcnR5TmFtZT4sIFdURjo6U3Ryb25nRW51bUhhc2hUcmFpdHM8 QVhQcm9wZXJ0eU5hbWU+PjsK 469148 2023-12-20 12:14:06 -0800 2023-12-27 12:16:57 -0800 Patch bug-266521-20231220121406.patch text/plain 44961 tyler_w RnJvbSAzNzQ0ZTFkYjhmMGQ5OTVhZTI2ODJmOTA3NmE5YTAxMWI2MzNiMjhiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGFuZCBsaW5lIHJhbmdlIHRleHQgbWFya2VyIEFQ SXMKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY1MjEgcmRhcjov LzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNo YXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKUmV2aWV3ZWQgYnkg Q2hyaXMgRmxlaXphY2guCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3NpdGlvbiBjbGFzcywgd2hpY2gg c2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmluZCBhbnkgdGV4dCBsZWFmIHBv c2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkgdHJlZSwgYW5hbHl6aW5nIHRo ZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNhbiBiZSBjb252ZXJ0ZWQgdG8g YW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVudGF0aW9uIGluIHRoaXMgcGF0 Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5nLiBhcmlhLW93bnMgdHJlZSBy ZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhlIHdyb25nIHJlc3VsdHMsIGFu ZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBwZWQuCgoqIFNvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQ6CiogU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9iamVjdDo6bmV4dFNpYmxpbmcp OgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmg6CihXZWJDb3Jl OjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJDb3JlOjpBWENvcmVPYmplY3Q6 OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9z aXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdCBjb25zdCk6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFBvc2l0aW9u OjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2JqZWN0V2l0aFJ1bnMpOgooV2Vi Q29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRp b246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6bGluZVJhbmdl IGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaDogQWRk ZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29uc3QpOgooV2ViQ29yZTo6UnVu RnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6cnVu IGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZyb21PZmZzZXQpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpudWxsUG9z aXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9mZnNldCBj b25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29uc3QpOgoqIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtl clJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpvZmZzZXQgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmg6IEFkZGVkLgoo V2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5lSUQpOgooV2ViQ29yZTo6QVhU ZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1 bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVidWdEZXNjcmlwdGlvbiBjb25z dCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToKKFdlYkNvcmU6OkFYVGV4dFJ1 bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10g Y29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6Ciog U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmpl Y3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zIGNv bnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQgICAgICAgICAg ICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiB8ICAxMCArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVj dC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5j cHAgICB8IDI1NyArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhQb3NpdGlvbi5oICAgICB8ICA4OSArKysrKysKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQVhUZXh0UnVuLmggICAgICB8IDE0MyArKysrKysrKysrCiAuLi4vYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmNwcCAgICAgfCAgIDYgKwogLi4uL2FjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eU9iamVjdC5oICAgICAgIHwgICA1ICsKIC4uLi9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmNwcCAgICAgICAgICAgICB8ICAgNiArLQogLi4uL2FjY2Vzc2liaWxpdHkvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5oIHwgICAyICstCiAuLi4vaXNvbGF0ZWR0cmVlL0FYSXNvbGF0 ZWRPYmplY3QuY3BwICAgICAgICAgfCAgMzAgKysKIC4uLi9pc29sYXRlZHRyZWUvQVhJc29sYXRl ZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk VHJlZS5oICAgICAgICAgICAgIHwgICAyICstCiAxNiBmaWxlcyBjaGFuZ2VkLCA1NjUgaW5zZXJ0 aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiBjcmVhdGUgbW9kZSAxMDA2NDQg U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtl CmluZGV4IGNjNmM0YTMxZTZkNS4uMzkzNDRkMGM4MGNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKQEAg LTY1MCw3ICs2NTAsOSBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09SS19IRUFERVJTCiAg ICAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5oCiAgICAgYWNjZXNzaWJpbGl0eS9B WExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKyAgICBhY2Nlc3Np YmlsaXR5L0FYUG9zaXRpb24uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKKyAg ICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRTdGF0 ZUNoYW5nZUludGVudC5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRyZWVTdG9yZS5oCiAgICAgYWNj ZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5TGlzdEJveC5oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CmluZGV4IGQzMDJk MzJlYTc2Yi4uNWJjYmYwNTdjNjg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2Vz LnR4dAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dApAQCAtNTIxLDYgKzUyMSw3IEBA IGFjY2Vzc2liaWxpdHkvQVhHZW9tZXRyeU1hbmFnZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYSW1h Z2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmNwcAorYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcAogYWNjZXNzaWJpbGl0eS9B WFRleHRNYXJrZXIuY3BwCiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZC5jcHAK IGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5jcHAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3ZjgxODJm MDhhZGMuLjAzZjMyMjZmZWUzNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTc1MCw3ICsxNzUwLDkgQEAKIAkJNDdGOTQ3REIy NjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5NjhD IC8qIEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJsZUZv cm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dlb21l dHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ NDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEy NiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKKwkJNDg2MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJEMkIy MDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2Vv bWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQyQTJC MkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVu LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDhC NUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5Q0E2 OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlFMDAy NjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBFbGVt ZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07CiAJCTQ5M0U1RTA5MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5 ZXJDbGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDQ5M0U1RTA4MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjAsOCAr MTA3MjIsMTEgQEAKIAkJNDdGQTk2RkYyNjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGlu Z0dlb21ldHJ5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFRhYmxlRm9ybWF0 dGluZ0dlb21ldHJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4MjI5NzBCMjlD OEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IFJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk0ODIyOTcwQzI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZWdpb25Db250ZXh0Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9u LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IEFYUG9zaXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJNDg2MUUwQkUyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAu Y3BwOyBwYXRoID0gQVhQb3NpdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTQ4NkI4REM2MkEwNDNDMDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk0ODZCOERDODJBMDQ1MDBGMDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQVhHZW9tZXRyeU1hbmFnZXIuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYVGV4dFJ1bi5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJl Z2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNzaWJp bGl0eVJlZ2lvbkNvbnRleHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhCNUJG MzYyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhEMEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1lbnRB bmltYXRpb25Db250ZXh0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250ZXh0 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE4Niw4ICsyMzE5MSwxMSBAQAog CQkJCUMwNDkzRUI3MjQ0Njk5RTQwMDlBQUM4MCAvKiBBWExvZ2dlci5oICovLAogCQkJCTI5ODFD QUFGMTMxODIyRUMwMEQxMkYyQSAvKiBBWE9iamVjdENhY2hlLmNwcCAqLywKIAkJCQkyOUE4MTIx QTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5oICovLAorCQkJCTQ4NjFFMEJFMkIy MDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLywKKwkJCQk0ODYxRTBCRDJCMjAwNzQ1 MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuY3BwICovLAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJEMyAv KiBBWFRleHRNYXJrZXIuaCAqLywKKwkJCQk0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhU ZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUzQkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0YXRl Q2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFEQzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFYVHJl ZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYwNTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFjY2Vz c2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1NzcsNyArMzc1ODUsOSBAQAogCQkJCTI5QUUyMTM1 MjFBQkE0OEEwMDg2OTI4MyAvKiBBWElzb2xhdGVkT2JqZWN0LmggaW4gSGVhZGVycyAqLywKIAkJ CQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRyZWUuaCBpbiBIZWFkZXJz ICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmggaW4g SGVhZGVycyAqLywKKwkJCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5o IGluIEhlYWRlcnMgKi8sCiAJCQkJQzBFMjA4QTIyOTM3OUM2RjAwQzBEMkQzIC8qIEFYVGV4dE1h cmtlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNDhCMDI0MkEyQjJBNjVBQTAwODNEMTIyIC8qIEFY VGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTFDOUYyRjkxQUUzQkVCMDAwOTVCNjFDIC8q IEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEU4QURDNTI5 NEI1QTYzMDA3NkNCREMgLyogQVhUcmVlU3RvcmUuaCBpbiBIZWFkZXJzICovLAogCQkJCTE0NzdF Nzc3MEJGNDEzNEEwMDE1Mjg3MiAvKiBCYWNrRm9yd2FyZENhY2hlLmggaW4gSGVhZGVycyAqLywK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCmluZGV4IDEwMTE0 ZWNiNmRkOC4uOTkwY2RhOTgwNWMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYQ29yZU9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhDb3JlT2JqZWN0LmgKQEAgLTExMCwxOSArMTEwLDYgQEAgZW51bSBjbGFzcyBBWEFuY2VzdG9y RmxhZyA6IHVpbnQ4X3QgewogICAgIC8vIEJpdHMgNiBhbmQgNyBhcmUgZnJlZS4KIH07CiAKLSNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAgIC8v IFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUgY29u dGFpbmluZyBSZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4KLSAg ICBzaXplX3QgbGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVuKHNp emVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxpbmVJ bmRleCkKLSAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2VuZGlm Ci0KIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0gMSwK ICAgICBBcHBsaWNhdGlvbkFsZXJ0LApAQCAtNjUzLDYgKzY0MCw4IEBAIGVudW0gY2xhc3MgQWNj ZXNzaWJpbGl0eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3MgQVhE aXJlY3Rpb24gOiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nlc3Np YmlsaXR5U29ydERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04MDAs NiArNzg5LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQpIHsg bV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9pZDsg fQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQcm9j ZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVzcG9u ZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTExMDQs OSArMTA5NCw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRleHQo VmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dyYW1t YXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZpcnR1 YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lmIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1bj4g dGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJpbmcg dGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBjb25z dCA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRp b24uY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjNhZTI2MDQzMzlhZgotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5jcHAK QEAgLTAsMCArMSwyNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiQVhQb3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisK KyNpbmNsdWRlICJBWElzb2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhJc29sYXRlZFRyZWUu aCIKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor QVhJc29sYXRlZE9iamVjdCogQVhQb3NpdGlvbjo6b2JqZWN0KCkgY29uc3QKK3sKKyAgICBSRUxF QVNFX0FTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIGlmIChpc051bGwoKSkKKyAgICAgICAg cmV0dXJuIG51bGxwdHI7CisKKyAgICBpZiAobV9jYWNoZWRPYmplY3QpCisgICAgICAgIHJldHVy biBtX2NhY2hlZE9iamVjdC5nZXQoKTsKKworICAgIGF1dG8gdHJlZSA9IHN0ZDo6Z2V0PFJlZlB0 cjxBWElzb2xhdGVkVHJlZT4+KGF4VHJlZUZvcklEKHRyZWVJRCgpKSk7CisgICAgbV9jYWNoZWRP YmplY3QgPSB0cmVlID8gdHJlZS0+b2JqZWN0Rm9ySUQob2JqZWN0SUQoKSkgOiBudWxscHRyOwor ICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKK30KKworY29uc3QgQVhUZXh0UnVucyog QVhQb3NpdGlvbjo6cnVucygpIGNvbnN0Cit7CisgICAgYXV0byogb2JqZWN0ID0gdGhpcy0+b2Jq ZWN0KCk7CisgICAgcmV0dXJuIG9iamVjdCA/IG9iamVjdC0+dGV4dFJ1bnMoKSA6IG51bGxwdHI7 Cit9CisKK0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZnJvbVRleHRNYXJrZXIoY29uc3QgQVhUZXh0 TWFya2VyJiBtYXJrZXIpCit7CisgICAgcmV0dXJuIEFYUG9zaXRpb24obWFya2VyLnRyZWVJRCgp LCBtYXJrZXIub2JqZWN0SUQoKSwgbWFya2VyLmNoYXJhY3Rlck9mZnNldCgpICk7Cit9CisKK0FY UG9zaXRpb246Om9wZXJhdG9yIEFYVGV4dE1hcmtlcigpIGNvbnN0Cit7CisgICAgcmV0dXJuIHsg eyB0cmVlSUQoKSwgb2JqZWN0SUQoKSwgbnVsbHB0ciwgbV9vZmZzZXQgfSB9OworfQorCitTdHJp bmcgQVhQb3NpdGlvbjo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0Cit7CisgICAgYXV0byBzZXBh cmF0b3IgPSAiLCAiOworICAgIFJlZlB0ciBvYmplY3QgPSB0aGlzLT5vYmplY3QoKTsKKyAgICBy ZXR1cm4gbWFrZVN0cmluZygKKyAgICAgICAgInRyZWVJRCAiLCB0cmVlSUQoKS5sb2dnaW5nU3Ry aW5nKCkKKyAgICAgICAgLCBzZXBhcmF0b3IsICJvYmplY3RJRCAiLCBvYmplY3RJRCgpLmxvZ2dp bmdTdHJpbmcoKQorICAgICAgICAsIHNlcGFyYXRvciwgInJvbGUgIiwgb2JqZWN0ID8gYWNjZXNz aWJpbGl0eVJvbGVUb1N0cmluZyhvYmplY3QtPnJvbGVWYWx1ZSgpKSA6IFN0cmluZygibm8gb2Jq ZWN0Il9zKQorICAgICAgICAsIHNlcGFyYXRvciwgIm9mZnNldCAiLCBtX29mZnNldAorICAgICk7 Cit9CisKK2VudW0gY2xhc3MgQ2hlY2tTdGFydCA6IGJvb2wgeyBObywgWWVzIH07CisvLyBGaW5k cyB0aGUgbmV4dCBvYmplY3Qgd2l0aCB0ZXh0IHJ1bnMgaW4gdGhlIGdpdmVuIGRpcmVjdGlvbi4K K3N0YXRpYyBSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gZmluZE9iamVjdFdpdGhSdW5zKEFYSXNv bGF0ZWRPYmplY3QmIHN0YXJ0LCBBWERpcmVjdGlvbiBkaXJlY3Rpb24sIENoZWNrU3RhcnQgY2hl Y2tTdGFydCA9IENoZWNrU3RhcnQ6Ok5vKQoreworICAgIGlmIChjaGVja1N0YXJ0ID09IENoZWNr U3RhcnQ6OlllcykgeworICAgICAgICBpZiAoYXV0byogcnVucyA9IHN0YXJ0LnRleHRSdW5zKCk7 IHJ1bnMgJiYgcnVucy0+c2l6ZSgpKQorICAgICAgICAgICAgcmV0dXJuICZzdGFydDsKKyAgICB9 CisKKyAgICBSZWZQdHIgY3VycmVudCA9ICZzdGFydDsKKyAgICB3aGlsZSAoY3VycmVudCkgewor ICAgICAgICBpZiAoY3VycmVudCAhPSAmc3RhcnQpIHsKKyAgICAgICAgICAgIGF1dG8qIHJ1bnMg PSBjdXJyZW50LT50ZXh0UnVucygpOworICAgICAgICAgICAgaWYgKHJ1bnMgJiYgcnVucy0+c2l6 ZSgpKQorICAgICAgICAgICAgICAgIHJldHVybiBjdXJyZW50OworICAgICAgICB9CisKKyAgICAg ICAgLy8gRklYTUU6IGFyaWEtb3ducyBicmVha3MgdGhpcyB0cmF2ZXJzYWwsIGFzIGFyaWEtb3du cyBjYXVzZXMgdGhlIEFYIHRyZWUgdG8gYmUgY2hhbmdlZCwgYWZmZWN0aW5nCisgICAgICAgIC8v IG91ciBpdGVyYXRpb24gYmVsb3csIGJ1dCBpdCBkb2Vzbid0IGFjdHVhbGx5IGNoYW5nZSB0ZXh0 IHBvc2l0aW9uIG9uIHRoZSBwYWdlLiBTbyB3ZSBuZWVkIHRvIGlnbm9yZSBhcmlhLW93bnMKKyAg ICAgICAgLy8gdHJlZSBjaGFuZ2VzIGhlcmUgaW4gb3JkZXIgdG8gYmVoYXZlIGNvcnJlY3RseS4K KyAgICAgICAgLy8gV2UgYWxzbyBwcm9iYWJseSBuZWVkIHRvIGRvIHNvbWV0aGluZyBhYm91dCB0 ZXh0IHdpdGhpbiBhcmlhLWhpZGRlbiBjb250YWluZXJzLCB3aGljaCBhZmZlY3RzIHRoZSBBWCB0 cmVlLgorCisgICAgICAgIGNvbnN0IGF1dG8mIGNoaWxkcmVuID0gY3VycmVudC0+Y2hpbGRyZW4o KTsKKyAgICAgICAgaWYgKGNoaWxkcmVuLnNpemUoKSkgeworICAgICAgICAgICAgc2l6ZV90IGNo aWxkSW5kZXggPSBkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5leHQgPyAwIDogY2hpbGRyZW4u c2l6ZSgpIC0gMTsKKyAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGNoaWxkcmVuW2NoaWxkSW5k ZXhdKTsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9i amVjdD4oY2hpbGRyZW5bY2hpbGRJbmRleF0uZ2V0KCkpOworICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgIH0KKworICAgICAgICAvLyBgY3VycmVudGAgaGFzIG5vIGNoaWxkcmVuLCBtZWFu aW5nIGl0J3MgYSBsZWFmIG5vZGUgKGUuZy4gaXQncyB0ZXh0LCB3aGljaCBjYW5ub3QgaGF2ZSBj aGlsZHJlbikuCisgICAgICAgIC8vIENoZWNrIGBjdXJyZW50YHMgc2libGluZ3MuCisgICAgICAg IGlmIChhdXRvKiBzaWJsaW5nID0gY3VycmVudC0+c2libGluZyhkaXJlY3Rpb24pKSB7CisgICAg ICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KHNpYmxp bmcpOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICAvLyBXZSBo YXZlIG5vIGNoaWxkcmVuLCBhbmQgbm8gbmV4dC9wcmV2aW91cyBzaWJsaW5nLiBUcnkgb3VyIHBh cmVudCdzIHNpYmxpbmcuCisgICAgICAgIGlmIChhdXRvKiBwYXJlbnQgPSBjdXJyZW50LT5wYXJl bnRPYmplY3RVbmlnbm9yZWQoKSkgeworICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3du Y2FzdDxBWElzb2xhdGVkT2JqZWN0PihwYXJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSk7CisgICAg ICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGJyZWFrOworICAgIH0KKyAg ICByZXR1cm4gbnVsbHB0cjsKK30KKworQVhQb3NpdGlvbiBBWFBvc2l0aW9uOjpmaW5kUG9zaXRp b24oQVhEaXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIGlmICghb2JqZWN0KCkpCisg ICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAg ICAgICAgcmV0dXJuIGFzVGV4dExlYWZQb3NpdGlvbigpLmZpbmRQb3NpdGlvbihkaXJlY3Rpb24p OworICAgIFJFTEVBU0VfQVNTRVJUKGlzVGV4dExlYWYoKSk7CisKKyAgICBzaXplX3QgcnVuSW5k ZXggPSBydW5JbmRleEZyb21PZmZzZXQoKTsKKyAgICBhdXRvIGhhc01vcmVUZXh0SW5DdXJyZW50 UnVuID0gWyZdIHsKKyAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkK KyAgICAgICAgICAgIHJldHVybiBtX29mZnNldCA8IHJ1bnMoKS0+YXQocnVuSW5kZXgpLnRleHQu bGVuZ3RoKCk7CisgICAgICAgIHJldHVybiBtX29mZnNldCA+IDA7CisgICAgfTsKKyAgICBib29s IGhhc0Fub3RoZXJSdW4gPSBydW5JbmRleCArIDEgPCBydW5zKCktPnNpemUoKTsKKyAgICAvLyBU aGUgbmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRleHQsIGJlY2F1c2Ugd2UncmUgZ29p bmcgdG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBtX29mZnNldCArIDEsIHdoaWNoIHdv dWxkIGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlv bjo6UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVucygpLT5ydW5MZW5ndGgocnVuSW5k ZXggKyAxKSA+IDApOworICAgIC8vIENoZWNraW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5vdGhl ciBydW4gaXMgb25seSByZWxldmFudCBmb3IgbW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBhcyBq dXN0IGNoZWNraW5nIHRoYXQgbV9vZmZzZXQgPiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGlyZWN0 aW9uOjpQcmV2aW91cy4KKyAgICBpZiAoaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAoZGly ZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAgICAg IC8vIFJldHVybiBhbiBvZmZzZXQgdG8gdGhlIG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJyZW50 IHJ1bi4KKyAgICAgICAgcmV0dXJuIEFYUG9zaXRpb24obV90cmVlSUQsIG1fb2JqZWN0SUQsIGRp cmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IG1fb2Zmc2V0ICsgMSA6IG1fb2Zmc2V0IC0g MSk7CisgICAgfQorICAgIC8vIG1fb2Zmc2V0IHBvaW50ZWQgdG8gdGhlIGxhc3QgY2hhcmFjdGVy IGluIHRoZSBnaXZlbiBvYmplY3QncyBydW5zLCBzbyBsZXQncyB0cmF2ZXJzZSB0byBmaW5kIHRo ZSBuZXh0IG9iamVjdCB3aXRoIHJ1bnMuCisgICAgaWYgKFJlZlB0ciBvYmplY3QgPSBmaW5kT2Jq ZWN0V2l0aFJ1bnMoKnRoaXMtPm9iamVjdCgpLCBkaXJlY3Rpb24pKQorICAgICAgICByZXR1cm4g QVhQb3NpdGlvbihvYmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElEKCksIGRpcmVjdGlv biA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5zKCktPmxhc3RSdW5M ZW5ndGgoKSk7CisKKyAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7Cit9CisKK0FYUG9zaXRpb24g QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uIGRpcmVjdGlvbiwgQVhUZXh0VW5p dCB0ZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5IGJvdW5kYXJ5KSBjb25zdAoreworICAgIGlm ICghb2JqZWN0KCkpCisgICAgICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKKyAgICBpZiAoIWlz VGV4dExlYWYoKSkKKyAgICAgICAgcmV0dXJuIGFzVGV4dExlYWZQb3NpdGlvbigpLmZpbmRQb3Np dGlvbihkaXJlY3Rpb24sIHRleHRVbml0LCBib3VuZGFyeSk7CisgICAgUkVMRUFTRV9BU1NFUlQo aXNUZXh0TGVhZigpKTsKKworICAgIGlmICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7 CisgICAgICAgIHNpemVfdCBydW5JbmRleCA9IHJ1bkluZGV4RnJvbU9mZnNldCgpOworICAgICAg ICBSZWZQdHIgY3VycmVudE9iamVjdCA9IG9iamVjdCgpOworICAgICAgICBjb25zdCBhdXRvKiBj dXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRleHRSdW5zKCk7CisKKyAgICAgICAgYXV0byBj b21wdXRlT2Zmc2V0ID0gWyZdIChzaXplX3QgcnVuRW5kT2Zmc2V0LCBzaXplX3QgcnVuTGVuZ3Ro KSB7CisgICAgICAgICAgICAvLyBUaGlzIHdvcmtzIGJlY2F1c2UgYHJ1bkVuZE9mZnNldGAgaXMg dGhlIG9mZnNldCBwb2ludGluZyB0byB0aGUgZW5kIG9mIHRoZSBnaXZlbiBydW4sIHdoaWNoIGlu Y2x1ZGVzIHRoZSBsZW5ndGggb2YgYWxsIHJ1bnMgcHJlY2VkaW5nIGl0LiBTbyBzdWJ0cmFjdGlu ZyB0aGF0IGZyb20gdGhlIGxlbmd0aCBvZiB0aGUgY3VycmVudCBydW4gZ2l2ZXMgdXMgYW4gb2Zm c2V0IHRvIHRoZSBzdGFydCBvZiB0aGUgY3VycmVudCBydW4uCisgICAgICAgICAgICByZXR1cm4g Ym91bmRhcnkgPT0gQVhUZXh0VW5pdEJvdW5kYXJ5OjpFbmQgPyBydW5FbmRPZmZzZXQgOiBydW5F bmRPZmZzZXQgLSBydW5MZW5ndGg7CisgICAgICAgIH07CisgICAgICAgIGF1dG8gbGluZVBvc2l0 aW9uID0gQVhQb3NpdGlvbihtX3RyZWVJRCwgbV9vYmplY3RJRCwgY29tcHV0ZU9mZnNldChjdXJy ZW50UnVucy0+cnVuTGVuZ3RoU3VtVG8ocnVuSW5kZXgpLCBjdXJyZW50UnVucy0+cnVuTGVuZ3Ro KHJ1bkluZGV4KSkpOworICAgICAgICBhdXRvIHN0YXJ0TGluZUlEID0gY3VycmVudFJ1bnMtPmxp bmVJRChydW5JbmRleCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFz c29jaWF0ZWQgbGluZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnku CisgICAgICAgIHdoaWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FT U0VSVChjdXJyZW50UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRp dmVPZmZzZXQgPSAwOworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50 UnVucy0+c2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9 IGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRS dW5zLT5saW5lSUQoaSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVy biBsaW5lUG9zaXRpb247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhQb3NpdGlv bihjdXJyZW50T2JqZWN0LT50cmVlSUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29t cHV0ZU9mZnNldChjdW11bGF0aXZlT2Zmc2V0LCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkpKSk7 CisgICAgICAgICAgICB9CisgICAgICAgICAgICBjdXJyZW50T2JqZWN0ID0gZmluZE9iamVjdFdp dGhSdW5zKCpjdXJyZW50T2JqZWN0LCBkaXJlY3Rpb24pOworICAgICAgICAgICAgaWYgKGN1cnJl bnRPYmplY3QpCisgICAgICAgICAgICAgICAgY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50 ZXh0UnVucygpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAg fQorICAgIHJldHVybiBudWxsUG9zaXRpb24oKTsKK30KKworQVhQb3NpdGlvbiBBWFBvc2l0aW9u Ojphc1RleHRMZWFmUG9zaXRpb24oKSBjb25zdAoreworICAgIGlmIChpc051bGwoKSB8fCBpc1Rl eHRMZWFmKCkpIHsKKyAgICAgICAgLy8gSWYgc29tZXRoaW5nIGhhcyBjb25zdHJ1Y3RlZCBhIGxl YWYgcG9zaXRpb24sIGl0IHNob3VsZCd2ZSBkb25lIHNvIHdpdGggYW4gaW4tYm91bmRzIG9mZnNl dC4KKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaXNOdWxsKCkgfHwgb2JqZWN0KCktPnRleHRSdW5z KCktPnJ1bkxlbmd0aFN1bSgpID49IG1fb2Zmc2V0KTsKKyAgICAgICAgcmV0dXJuICp0aGlzOwor ICAgIH0KKworICAgIC8vIEZpbmQgdGhlIGxlYWYgbm9kZSBvdXIgb2Zmc2V0IHBvaW50cyB0by4g Rm9yIGV4YW1wbGU6CisgICAgLy8gQVhQb3NpdGlvbiB7IElEIDE6IEdyb3VwLCBPZmZzZXQgNiB9 CisgICAgLy8gSUQgMTogR3JvdXAKKyAgICAvLyAgLSBJRCAyOiBGb28KKyAgICAvLyAgLSBJRCAz OiBMaW5lMQorICAgIC8vICAgICAgICAgIExpbmUyCisgICAgLy8gQ2FsbGluZyBhc1RleHRMZWFm UG9zaXRpb24oKSBvbiB0aGUgb3JpZ2luYWwgcG9zaXRpb24gc2hvdWxkIHlpZWxkIG5ldyBwb3Np dGlvbjoKKyAgICAvLyBBWFBvc2l0aW9uIHsgSUQgMzogU3RhdGljVGV4dCwgT2Zmc2V0IDMgfQor ICAgIC8vIEJlY2F1c2Ugd2UgaGFkIHRvIHdhbGsgb3ZlciBJRCAyIHdoaWNoIGhhZCBsZW5ndGgg MyB0ZXh0LgorICAgIHNpemVfdCBwcmVjZWRpbmdPZmZzZXQgPSAwOworICAgIFJlZlB0ciBjdXJy ZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpvYmplY3QoKSwgQVhEaXJlY3Rpb246Ok5leHQsIENo ZWNrU3RhcnQ6Olllcyk7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAgdW5zaWduZWQg Y3VycmVudFN1bSA9IGN1cnJlbnQtPnRleHRSdW5zKCktPnJ1bkxlbmd0aFN1bSgpOworICAgICAg ICBpZiAocHJlY2VkaW5nT2Zmc2V0ICsgY3VycmVudFN1bSA+PSBtX29mZnNldCkKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICBwcmVjZWRpbmdPZmZzZXQgKz0gY3VycmVudFN1bTsKKyAgICAg ICAgY3VycmVudCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudCwgQVhEaXJlY3Rpb246Ok5l eHQpOworICAgIH0KKworICAgIFJFTEVBU0VfQVNTRVJUKG1fb2Zmc2V0ID49IHByZWNlZGluZ09m ZnNldCk7CisgICAgcmV0dXJuIEFYUG9zaXRpb24oY3VycmVudC0+dHJlZUlEKCksIGN1cnJlbnQt Pm9iamVjdElEKCksIG1fb2Zmc2V0IC0gcHJlY2VkaW5nT2Zmc2V0KTsKK30KKworYm9vbCBBWFBv c2l0aW9uOjppc1RleHRMZWFmKCkgY29uc3QKK3sKKyAgICBhdXRvKiBvYmplY3QgPSB0aGlzLT5v YmplY3QoKTsKKyAgICAvLyBGSVhNRTogSXMgaXQgcG9zc2libGUgZm9yIG5vbi1sZWFmIG5vZGVz IHRvIGhhdmUgdGV4dCBydW5zPyBJZiBzbywgd2UgZG9uJ3QgaGFuZGxlIHRoZW0gY29ycmVjdGx5 LgorICAgIHJldHVybiAhb2JqZWN0IHx8ICghb2JqZWN0LT5jaGlsZHJlbigpLnNpemUoKSAmJiBv YmplY3QtPnRleHRSdW5zKCkpOworfQorCitzaXplX3QgQVhQb3NpdGlvbjo6cnVuSW5kZXhGcm9t T2Zmc2V0KCkgY29uc3QKK3sKKyAgICBhdXRvKiBydW5zID0gdGhpcy0+cnVucygpOworICAgIGlm ICghcnVucykKKyAgICAgICAgcmV0dXJuIG5vdEZvdW5kOworCisgICAgc2l6ZV90IGluZGV4ID0g cnVucy0+aW5kZXhGb3JPZmZzZXQobV9vZmZzZXQpOworICAgIC8vIElmIHdlIGNvdWxkbid0IGZp bmQgYSBjb3JyZXNwb25kaW5nIHJ1biwgdGhhdCBtZWFucyBtX29mZnNldCBwb2ludGVkIG91dCBv ZiBib3VuZHMgb2Ygb3VyIHRleHQgcnVucywgd2hpY2gKKyAgICAvLyB3b3VsZCBvbmx5IGhhcHBl biBpZiB3ZSd2ZSBjb25zdHJ1Y3RlZCBhbiBpbnZhbGlkIHBvc2l0aW9uLgorICAgIFJFTEVBU0Vf QVNTRVJUKGluZGV4ICE9IG5vdEZvdW5kKTsKKyAgICByZXR1cm4gaW5kZXg7Cit9CisKK0FYVGV4 dE1hcmtlclJhbmdlIEFYUG9zaXRpb246OmxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlIHR5cGUpIGNv bnN0Cit7CisgICAgaWYgKCFvYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHsgbnVsbFBvc2l0aW9u KCksIG51bGxQb3NpdGlvbigpIH07CisKKyAgICBpZiAodHlwZSA9PSBMaW5lUmFuZ2VUeXBlOjpD dXJyZW50KQorICAgICAgICByZXR1cm4geyBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb246OlByZXZp b3VzLCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6OlN0YXJ0KSwgZmluZFBv c2l0aW9uKEFYRGlyZWN0aW9uOjpOZXh0LCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91 bmRhcnk6OkVuZCkgfTsKKyAgICAvLyBUaGUgb3RoZXIgdHlwZXMgYXJlbid0IGltcGxlbWVudGVk IHlldC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorCit9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaCBiL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uMWI4NzY5MmM5ZjdkCi0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKQEAgLTAsMCArMSw4OSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMu IEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBB UFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCisjaW5jbHVkZSAiQVhJc29sYXRlZE9iamVjdC5oIgorI2luY2x1ZGUgIkFYVGV4dE1hcmtl ci5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2VudW0gY2xhc3MgQVhUZXh0VW5pdCA6IHVp bnQ4X3QgeworICAgIExpbmUsCisgICAgUGFyYWdyYXBoLAorICAgIFNlbnRlbmNlLAorICAgIFdv cmQsCit9OworZW51bSBjbGFzcyBBWFRleHRVbml0Qm91bmRhcnkgOiBib29sIHsgU3RhcnQsIEVu ZCwgfTsKKworZW51bSBjbGFzcyBMaW5lUmFuZ2VUeXBlIDogdWludDhfdCB7CisgICAgQ3VycmVu dCwKKyAgICBMZWZ0LAorICAgIFJpZ2h0LAorfTsKKworY2xhc3MgQVhQb3NpdGlvbiB7CitwdWJs aWM6CisgICAgZXhwbGljaXQgQVhQb3NpdGlvbihBWElEIHRyZWVJRCwgQVhJRCBvYmplY3RJRCwg dW5zaWduZWQgb2Zmc2V0KQorICAgICAgICA6IG1fdHJlZUlEKHRyZWVJRCkKKyAgICAgICAgLCBt X29iamVjdElEKG9iamVjdElEKQorICAgICAgICAsIG1fb2Zmc2V0KG9mZnNldCkKKyAgICB7IH0K KyAgICBzdGF0aWMgQVhQb3NpdGlvbiBudWxsUG9zaXRpb24oKSB7IHJldHVybiBBWFBvc2l0aW9u KEFYSUQoKSwgQVhJRCgpLCAwKTsgfQorICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29u c3Q7CisKKyAgICBzdGF0aWMgQVhQb3NpdGlvbiBmcm9tVGV4dE1hcmtlcihjb25zdCBBWFRleHRN YXJrZXImKTsKKyAgICBvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdDsKKworICAgIC8vIEZp bmQgdGhlIG5leHQgb3IgcHJldmlvdXMgcG9zaXRpb24uCisgICAgQVhQb3NpdGlvbiBmaW5kUG9z aXRpb24oQVhEaXJlY3Rpb24pIGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZyb20gdGhpcyBwb3Np dGlvbiwgY3JlYXRlcyBhIG5ldyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVuIGRpcmVjdGlvbiBhbmQg dGV4dCB1bml0IHR5cGUuCisgICAgQVhQb3NpdGlvbiBmaW5kUG9zaXRpb24oQVhEaXJlY3Rpb24s IEFYVGV4dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSkgY29uc3Q7CisgICAgQVhUZXh0TWFya2Vy UmFuZ2UgbGluZVJhbmdlKExpbmVSYW5nZVR5cGUpIGNvbnN0OworCitwcml2YXRlOgorICAgIEFY SUQgdHJlZUlEKCkgY29uc3QgeyByZXR1cm4gbV90cmVlSUQ7IH0KKyAgICBBWElEIG9iamVjdElE KCkgY29uc3QgeyByZXR1cm4gbV9vYmplY3RJRDsgfQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNv bnN0IHsgcmV0dXJuIG1fb2Zmc2V0OyB9CisKKyAgICBBWElzb2xhdGVkT2JqZWN0KiBvYmplY3Qo KSBjb25zdDsKKyAgICBjb25zdCBBWFRleHRSdW5zKiBydW5zKCkgY29uc3Q7CisgICAgc2l6ZV90 IHJ1bkluZGV4RnJvbU9mZnNldCgpIGNvbnN0OworICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyBy ZXR1cm4gIXRyZWVJRCgpLmlzVmFsaWQoKSB8fCAhb2JqZWN0SUQoKS5pc1ZhbGlkKCk7IH0KKwor ICAgIEFYUG9zaXRpb24gYXNUZXh0TGVhZlBvc2l0aW9uKCkgY29uc3Q7CisgICAgLy8gQSAidGV4 dCBsZWFmIiBwb3NpdGlvbiBpcyBhIGxlYWYgbm9kZSAobm8gY2hpbGRyZW4pIHdpdGggbm9uLWVt cHR5IHRleHRydW5zLgorICAgIGJvb2wgaXNUZXh0TGVhZigpIGNvbnN0OworCisgICAgQVhJRCBt X3RyZWVJRDsKKyAgICBBWElEIG1fb2JqZWN0SUQ7CisgICAgdW5zaWduZWQgbV9vZmZzZXQgeyAw IH07CisKKyAgICBtdXRhYmxlIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBtX2NhY2hlZE9iamVj dDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhS RUFEX1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFy a2VyLmNwcAppbmRleCA5YWQ2YWJmOTNhYWMuLmQyZDQzM2JjYmIxYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMzM1LDcgKzMzNSw3IEBA IHN0ZDo6b3B0aW9uYWw8QVhUZXh0TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtlclJhbmdlOjppbnRl cnNlY3Rpb25XaXRoKGNvbnN0IEFYVGV4CiAKIFN0cmluZyBBWFRleHRNYXJrZXJSYW5nZTo6ZGVi dWdEZXNjcmlwdGlvbigpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7 IiwgbV9zdGFydC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBtX2VuZC5kZWJ1Z0Rl c2NyaXB0aW9uKCksICJ9Iik7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9z dGFydC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5kLmRlYnVnRGVzY3Jp cHRpb24oKSwgIn0iKTsKIH0KIAogc3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBhcnRpYWxPcmRlcihj b25zdCBBWFRleHRNYXJrZXImIG1hcmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMikK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgg Yi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCmluZGV4IDE3ZTlm YzBkYWI5OC4uOGZkYTlhMmViMGM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dE1hcmtlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmgKQEAgLTEyMyw2ICsxMjMsNyBAQCBwdWJsaWM6CiAKICAgICBBWElEIHRy ZWVJRCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5heFRyZWVJRCgpOyB9CiAgICAgQVhJRCBvYmpl Y3RJRCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5heE9iamVjdElEKCk7IH0KKyAgICB1bnNpZ25l ZCBjaGFyYWN0ZXJPZmZzZXQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEuY2hhcmFjdGVyT2Zmc2V0 OyB9CiAgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhdHJlZUlEKCkuaXNWYWxpZCgp IHx8ICFvYmplY3RJRCgpLmlzVmFsaWQoKTsgfQogICAgIFJlZlB0cjxBWENvcmVPYmplY3Q+IG9i amVjdCgpIGNvbnN0OwogICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdCgp OyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5o IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjlmZDRjYWZiZmNmYwotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKQEAgLTAsMCArMSwx NDMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAor ICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisg KiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICog Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShBWF9USFJFQURf VEVYVF9BUElTKQorbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBSZW5kZXJCbG9jazsKKwor c3RydWN0IEFYVGV4dFJ1bkxpbmVJRCB7CisgICAgdm9pZCogY29udGFpbmluZ0Jsb2NrIHsgbnVs bHB0ciB9OworICAgIHNpemVfdCBsaW5lSW5kZXggeyAwIH07CisKKyAgICBBWFRleHRSdW5MaW5l SUQodm9pZCogY29udGFpbmluZ0Jsb2NrLCBzaXplX3QgbGluZUluZGV4KQorICAgICAgICA6IGNv bnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgbGluZUluZGV4KGxpbmVJ bmRleCkKKyAgICB7IH0KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQVhUZXh0UnVuTGluZUlE JikgY29uc3QgPSBkZWZhdWx0OworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QK KyAgICB7CisgICAgICAgIFRleHRTdHJlYW0gc3RyZWFtOworICAgICAgICBzdHJlYW0gPDwgIkxp bmVJRCAiIDw8IGNvbnRhaW5pbmdCbG9jayA8PCAiICIgPDwgbGluZUluZGV4OworICAgICAgICBy ZXR1cm4gc3RyZWFtLnJlbGVhc2UoKTsKKyAgICB9Cit9OworCitzdHJ1Y3QgQVhUZXh0UnVuIHsK KyAgICAvLyBUaGUgbGluZSBpbmRleCBvZiB0aGlzIHJ1biB3aXRoaW4gdGhlIGNvbnRleHQgb2Yg dGhlIGNvbnRhaW5pbmcgUmVuZGVyQmxvY2sgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4K KyAgICBzaXplX3QgbGluZUluZGV4OworICAgIFN0cmluZyB0ZXh0OworCisgICAgQVhUZXh0UnVu KHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCisgICAgICAgIDogbGluZUluZGV4KGxp bmVJbmRleCkKKyAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCisgICAgeyB9CisKKyAgICBT dHJpbmcgZGVidWdEZXNjcmlwdGlvbih2b2lkKiBjb250YWluaW5nQmxvY2spIGNvbnN0CisgICAg eworICAgICAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEID0geyBjb250YWluaW5nQmxvY2ssIGxp bmVJbmRleCB9OworICAgICAgICByZXR1cm4gbWFrZVN0cmluZyhsaW5lSUQuZGVidWdEZXNjcmlw dGlvbigpLCAiOiB8IiwgbWFrZVN0cmluZ0J5UmVwbGFjaW5nQWxsKHRleHQsICdcbicsICJ7bmV3 bGluZX0iX3MpLCAifChsZW4gIiwgdGV4dC5sZW5ndGgoKSwgIikiKTsKKyAgICB9Cit9OworCitz dHJ1Y3QgQVhUZXh0UnVucyB7CisgICAgLy8gVGhlIGNvbnRhaW5pbmcgYmxvY2sgZm9yIHRoZSB0 ZXh0IHJ1bnMuIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZSBiYXNlZCBvbiB0aGUgc3RydWN0dXJl CisgICAgLy8gb2YgdGhlIEFYIHRyZWUsIHRleHQgcnVucyBmb3IgZGlmZmVyZW50IG9iamVjdHMg Y2FuIGhhdmUgdGhlIHNhbWUgbGluZSBpbmRleCBidXQgZGlmZmVyZW50CisgICAgLy8gY29udGFp bmluZyBibG9ja3MsIG1lYW5pbmcgdGhleSBhcmUgcmVuZGVyZWQgb24gZGlmZmVyZW50IGxpbmVz LgorICAgIC8vIERvIG5vdCBkZS1yZWZlcmVuY2UuIFVzZSBmb3IgY29tcGFyaXNvbiBwdXJwb3Nl cyBvbmx5LgorICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7IG51bGxwdHIgfTsKKyAgICBWZWN0 b3I8QVhUZXh0UnVuPiBydW5zOworCisgICAgQVhUZXh0UnVucygpID0gZGVmYXVsdDsKKyAgICBB WFRleHRSdW5zKFJlbmRlckJsb2NrKiBjb250YWluaW5nQmxvY2ssIFZlY3RvcjxBWFRleHRSdW4+ JiYgcnVucykKKyAgICAgICAgOiBjb250YWluaW5nQmxvY2soY29udGFpbmluZ0Jsb2NrKQorICAg ICAgICAsIHJ1bnMoV1RGTW92ZShydW5zKSkKKyAgICB7IH0KKworICAgIHNpemVfdCBzaXplKCkg Y29uc3QgeyByZXR1cm4gcnVucy5zaXplKCk7IH0KKyAgICB1bnNpZ25lZCBydW5MZW5ndGgoc2l6 ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBy dW5zLnNpemUoKSk7CisgICAgICAgIHJldHVybiBydW5zW2luZGV4XS50ZXh0Lmxlbmd0aCgpOwor ICAgIH0KKyAgICB1bnNpZ25lZCBsYXN0UnVuTGVuZ3RoKCkgY29uc3QKKyAgICB7CisgICAgICAg IGlmIChydW5zLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICByZXR1 cm4gcnVuc1tydW5zLnNpemUoKSAtIDFdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2ln bmVkIHJ1bkxlbmd0aFN1bSgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gcnVuTGVuZ3Ro U3VtVG8ocnVucy5zaXplKCkgLSAxKTsKKyAgICB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoU3Vt VG8oc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgdW5zaWduZWQgbGVuZ3RoID0g MDsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPD0gaW5kZXggJiYgaSA8IHJ1bnMuc2l6 ZSgpOyBpKyspCisgICAgICAgICAgICBsZW5ndGggKz0gcnVuTGVuZ3RoKGkpOworICAgICAgICBy ZXR1cm4gbGVuZ3RoOworICAgIH0KKyAgICBzaXplX3QgaW5kZXhGb3JPZmZzZXQodW5zaWduZWQg dGV4dE9mZnNldCkgY29uc3QKKyAgICB7CisgICAgICAgIHNpemVfdCBjdW11bGF0aXZlTGVuZ3Ro ID0gMDsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7 CisgICAgICAgICAgICBjdW11bGF0aXZlTGVuZ3RoICs9IHJ1bkxlbmd0aChpKTsKKyAgICAgICAg ICAgIGlmIChjdW11bGF0aXZlTGVuZ3RoID49IHRleHRPZmZzZXQpCisgICAgICAgICAgICAgICAg cmV0dXJuIGk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIG5vdEZvdW5kOworICAgIH0KKyAg ICBBWFRleHRSdW5MaW5lSUQgbGluZUlEKHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAg ICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICByZXR1cm4g eyBjb250YWluaW5nQmxvY2ssIHJ1bnNbaW5kZXhdLmxpbmVJbmRleCB9OworICAgIH0KKyAgICBj b25zdCBBWFRleHRSdW4mIGF0KHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJl dHVybiAoKnRoaXMpW2luZGV4XTsKKyAgICB9CisgICAgY29uc3QgQVhUZXh0UnVuJiBvcGVyYXRv cltdKHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGlu ZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICByZXR1cm4gcnVuc1tpbmRleF07CisgICAgfQor ICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKKyAgICB7CisgICAgICAgIFN0cmlu Z0J1aWxkZXIgcmVzdWx0OworICAgICAgICByZXN1bHQuYXBwZW5kKCdbJyk7CisgICAgICAgIGZv ciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBy ZXN1bHQuYXBwZW5kKHJ1bnNbaV0uZGVidWdEZXNjcmlwdGlvbihjb250YWluaW5nQmxvY2spKTsK KyAgICAgICAgICAgIGlmIChpICE9IHJ1bnMuc2l6ZSgpIC0gMSkKKyAgICAgICAgICAgICAgICBy ZXN1bHQuYXBwZW5kKCIsICIpOworICAgICAgICB9CisgICAgICAgIHJlc3VsdC5hcHBlbmQoJ10n KTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdC50b1N0cmluZygpOworICAgIH0KK307CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9i amVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmpl Y3QuY3BwCmluZGV4IGVmMDg3NzA1OGZlYi4uMDZkYTg5OTU5OWMwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKQEAgLTEx Myw2ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppbml0KCkKICAgICBtX3Jv bGUgPSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5Um9sZSgpOwogfQogCitBWElEIEFjY2Vzc2liaWxp dHlPYmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7CisgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENh Y2hlKCk7CisgICAgcmV0dXJuIGNhY2hlID8gY2FjaGUtPnRyZWVJRCgpIDogQVhJRCgpOworfQor CiBpbmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByb2Nlc3NJRCgpIGNvbnN0 CiB7CiAgICAgcmV0dXJuIHByZXNlbnRpbmdBcHBsaWNhdGlvblBJRCgpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmggYi9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAppbmRleCA1ZDg4 Y2M2MTI4YzMuLmM1YmIzOTUyOTMyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNwcmFnbWEg b25jZQogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgi CiAjaW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2UuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNp bmNsdWRlICJMYXlvdXRSZWN0LmgiCkBAIC02Myw2ICs2NCw3IEBAIGNsYXNzIEFjY2Vzc2liaWxp dHlPYmplY3QgOiBwdWJsaWMgQVhDb3JlT2JqZWN0LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8QWNj ZXNzaWJpCiBwdWJsaWM6CiAgICAgdmlydHVhbCB+QWNjZXNzaWJpbGl0eU9iamVjdCgpOwogCisg ICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbDsKICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkg Y29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBAIC0zODAs NiArMzgyLDkgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5kZXJFbGVtZW50KEFjY2Vzc2li aWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50 TW9kZSgpKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0KICAgICBTdHJpbmcgdGV4dCgp IGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIHVuc2lnbmVkIHRleHRMZW5ndGgo KSBjb25zdCBmaW5hbDsKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICB2aXJ0 dWFsIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KKyNlbmRpZgogI2lmIFBM QVRGT1JNKENPQ09BKQogICAgIC8vIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyBhbmQgQVhP YmplY3Qgd3JhcHBlcnMgY29ycmVzcG9uZGluZyB0byB0aGUKICAgICAvLyB0ZXh0cnVucyBhbmQg cmVwbGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQgaW4gdGhlIGdpdmVuIHJhbmdlLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5jcHAKaW5kZXggMzhhNGFhZjY1N2YyLi45OGU4NDAyZTM2YTMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0LmNwcApAQCAtMTM5NSwxMSArMTM5NSwxMSBAQCBDaGFyYWN0ZXJSYW5nZSBBY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRleHRSYW5nZSgpIGNvbnN0CiB9CiAKICNpZiBFTkFC TEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLVZlY3RvcjxBWFRleHRSdW4+IEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FYVGV4dFJ1bnMgQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6dGV4dFJ1bnMoKQogewogICAgIGlmIChhdXRvKiByZW5kZXJMaW5lQnJlYWsgPSBkeW5h bWljRG93bmNhc3Q8UmVuZGVyTGluZUJyZWFrPihyZW5kZXJlcigpKSkgewogICAgICAgICBhdXRv IGJveCA9IElubGluZUl0ZXJhdG9yOjpib3hGb3IoKnJlbmRlckxpbmVCcmVhayk7Ci0gICAgICAg IHJldHVybiB7IHsgYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKSB9IH07CisgICAg ICAgIHJldHVybiB7IHJlbmRlckxpbmVCcmVhay0+Y29udGFpbmluZ0Jsb2NrKCksIHsgQVhUZXh0 UnVuKGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJpbmcoJ1xuJykuaXNvbGF0ZWRDb3B5KCkpIH0g fTsKICAgICB9CiAKICAgICBXZWFrUHRyIHJlbmRlclRleHQgPSBkeW5hbWljRG93bmNhc3Q8UmVu ZGVyVGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0xNDUyLDcgKzE0NTIsNyBAQCBWZWN0b3I8QVhUZXh0 UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCiAKICAgICBpZiAoIWxp bmVTdHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBydW5zLmFwcGVuZCh7IGN1cnJlbnRMaW5lSW5k ZXgsIGxpbmVTdHJpbmcudG9TdHJpbmcoKS5pc29sYXRlZENvcHkoKSB9KTsKLSAgICByZXR1cm4g cnVuczsKKyAgICByZXR1cm4geyByZW5kZXJUZXh0LT5jb250YWluaW5nQmxvY2soKSwgV1RGTW92 ZShydW5zKSB9OwogfQogI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5oCmluZGV4IGNlZWM2YmYzZTg5OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaApAQCAtMTAwLDcgKzEwMCw3IEBAIHB1YmxpYzoKICAgICBTdHJpbmcgdGV4dFVuZGVy RWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3NpYmlsaXR5 VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIHNlbGVj dGVkVGV4dCgpIGNvbnN0IG92ZXJyaWRlOwogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWw7CisgICAgQVhUZXh0UnVu cyB0ZXh0UnVucygpIGZpbmFsOwogI2VuZGlmCiAKICAgICBib29sIGlzV2lkZ2V0KCkgY29uc3Qg b3ZlcnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCmluZGV4IDYyYTFhNTc1YWU2MS4u MzQ1ZjJkNTNkZjU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcApAQCAtMzEsNiArMzEs NyBAQAogI2luY2x1ZGUgIkFYR2VvbWV0cnlNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiQVhJc29sYXRl ZFRyZWUuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgog CiAjaWYgUExBVEZPUk0oTUFDKQogI2ltcG9ydCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5o PgpAQCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQgQVhJc29sYXRlZE9iamVjdDo6c2V0UHJvcGVydHko QVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWCiAgICAgICAgIFtd KHN0ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJSYW5nZT4mIHR5cGVkVmFsdWUpIHsKICAgICAgICAg ICAgIHJldHVybiAhdHlwZWRWYWx1ZS5maXJzdC5pc1ZhbGlkKCkgJiYgIXR5cGVkVmFsdWUuc2Vj b25kLmxvY2F0aW9uICYmICF0eXBlZFZhbHVlLnNlY29uZC5sZW5ndGg7CiAgICAgICAgIH0sCisj aWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgICAgIFtdKEFYVGV4dFJ1bnMgcnVu cykgeyByZXR1cm4gIXJ1bnMuc2l6ZSgpOyB9LAorI2VuZGlmCiAgICAgICAgIFtdKGF1dG8mKSB7 CiAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgICAgIHJldHVybiBm YWxzZTsKQEAgLTU1Nyw2ICs1NjEsMTkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRTZWxl Y3RlZENoaWxkcmVuKGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2UKICAgICB9 KTsKIH0KIAorQVhDb3JlT2JqZWN0KiBBWElzb2xhdGVkT2JqZWN0OjpzaWJsaW5nKEFYRGlyZWN0 aW9uIGRpcmVjdGlvbikgY29uc3QKK3sKKyAgICBSZWZQdHIgcGFyZW50ID0gcGFyZW50T2JqZWN0 VW5pZ25vcmVkKCk7CisgICAgY29uc3QgYXV0byYgc2libGluZ3MgPSBwYXJlbnQtPmNoaWxkcmVu KCk7CisgICAgc2l6ZV90IGluZGV4T2ZUaGlzID0gc2libGluZ3MuZmluZCh0aGlzKTsKKyAgICBp ZiAoaW5kZXhPZlRoaXMgPT0gbm90Rm91bmQpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisg ICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAgICAgICAgcmV0dXJuIGlu ZGV4T2ZUaGlzICsgMSA8IHNpYmxpbmdzLnNpemUoKSA/IHNpYmxpbmdzW2luZGV4T2ZUaGlzICsg MV0uZ2V0KCkgOiBudWxscHRyOworICAgIHJldHVybiBpbmRleE9mVGhpcyA+IDAgPyBzaWJsaW5n c1tpbmRleE9mVGhpcyAtIDFdLmdldCgpIDogbnVsbHB0cjsKK30KKwogYm9vbCBBWElzb2xhdGVk T2JqZWN0Ojppc0RldGFjaGVkRnJvbVBhcmVudCgpCiB7CiAgICAgaWYgKHBhcmVudCgpLmlzVmFs aWQoKSkKQEAgLTk3MSw2ICs5ODgsMTkgQEAgaW50IEFYSXNvbGF0ZWRPYmplY3Q6OmludEF0dHJp YnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkgY29uc3QKICAgICApOwogfQog CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitjb25zdCBBWFRleHRSdW5zKiBBWElz b2xhdGVkT2JqZWN0Ojp0ZXh0UnVucygpIGNvbnN0Cit7CisgICAgYXV0byBlbnRyeSA9IG1fcHJv cGVydHlNYXAuZmluZChBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMpOworICAgIGlmIChlbnRyeSA9 PSBtX3Byb3BlcnR5TWFwLmVuZCgpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1 cm4gV1RGOjpzd2l0Y2hPbihlbnRyeS0+dmFsdWUsCisgICAgICAgIFtdIChjb25zdCBBWFRleHRS dW5zJiB0eXBlZFZhbHVlKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiAmdHlwZWRWYWx1 ZTsgfSwKKyAgICAgICAgW10gKGF1dG8mKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiBu dWxscHRyOyB9CisgICAgKTsKK30KKyNlbmRpZgorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogVCBB WElzb2xhdGVkT2JqZWN0OjpnZXRPclJldHJpZXZlUHJvcGVydHlWYWx1ZShBWFByb3BlcnR5TmFt ZSBwcm9wZXJ0eU5hbWUpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKaW5kZXggYTZjYTAzNDM3 NzdkLi44ZDk0YWQyYmQ5ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKQEAgLTQ0LDYgKzQ0 LDkgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQVhJc29sYXRlZFRyZWU7CisjaWYg RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitzdHJ1Y3QgQVhUZXh0UnVuczsKKyNlbmRpZgog CiBjbGFzcyBBWElzb2xhdGVkT2JqZWN0IGZpbmFsIDogcHVibGljIEFYQ29yZU9iamVjdCB7CiAg ICAgZnJpZW5kIGNsYXNzIEFYSXNvbGF0ZWRUcmVlOwpAQCAtNTEsNyArNTQsOSBAQCBwdWJsaWM6 CiAgICAgc3RhdGljIFJlZjxBWElzb2xhdGVkT2JqZWN0PiBjcmVhdGUoY29uc3QgUmVmPEFjY2Vz c2liaWxpdHlPYmplY3Q+JiwgQVhJc29sYXRlZFRyZWUqKTsKICAgICB+QVhJc29sYXRlZE9iamVj dCgpOwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnRy ZWVJRCgpOyB9CiAgICAgUHJvY2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJu IHRyZWUoKS0+cHJvY2Vzc0lEKCk7IH0KKyAgICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUo KSBjb25zdCBmaW5hbCB7IHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5Um9sZT4oaW50 QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlJvbGVWYWx1ZSkpOyB9CiAgICAgU3RyaW5n IGRiZygpIGNvbnN0IGZpbmFsOwogCiAgICAgdm9pZCBhdHRhY2hQbGF0Zm9ybVdyYXBwZXIoQWNj ZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIqKTsKQEAgLTU5LDEwICs2NCwxNyBAQCBwdWJsaWM6CiAg ICAgYm9vbCBpc1RhYmxlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVl KEFYUHJvcGVydHlOYW1lOjpJc1RhYmxlKTsgfQogICAgIGJvb2wgaXNFeHBvc2FibGUoKSBjb25z dCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OklzRXhw b3NhYmxlKTsgfQogCisgICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGls ZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQgPSB0cnVlKSBmaW5hbDsKKyAgICBBWENv cmVPYmplY3QqIHNpYmxpbmcoQVhEaXJlY3Rpb24pIGNvbnN0OwogICAgIEFYSXNvbGF0ZWRPYmpl Y3QqIHBhcmVudE9iamVjdCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHBhcmVudE9iamVjdFVuaWdu b3JlZCgpOyB9CisgICAgQVhJc29sYXRlZE9iamVjdCogcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkg Y29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogZWRpdGFibGVBbmNlc3RvcigpIGZp bmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6OmVkaXRhYmxlQW5jZXN0b3IoKnRoaXMpOyB9Owog ICAgIGJvb2wgY2FuU2V0Rm9jdXNBdHRyaWJ1dGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29s QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OkNhblNldEZvY3VzQXR0cmlidXRlKTsgfQog CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgY29uc3QgQVhUZXh0UnVucyog dGV4dFJ1bnMoKSBjb25zdDsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIHZvaWQgZGV0YWNoUmVt b3RlUGFydHMoQWNjZXNzaWJpbGl0eURldGFjaG1lbnRUeXBlKSBmaW5hbDsKICAgICB2b2lkIGRl dGFjaFBsYXRmb3JtV3JhcHBlcihBY2Nlc3NpYmlsaXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwpA QCAtMjQzLDcgKzI1NSw2IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPFN0cmluZz4gZGV0ZXJtaW5l RHJvcEVmZmVjdHMoKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBhY2Nlc3Np YmlsaXR5SGl0VGVzdChjb25zdCBJbnRQb2ludCYpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0 ZWRPYmplY3QqIGZvY3VzZWRVSUVsZW1lbnQoKSBjb25zdCBmaW5hbDsKLSAgICBBWElzb2xhdGVk T2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKSBjb25zdCBmaW5hbDsKICAgICBBY2Nlc3Np YmlsaXR5Q2hpbGRyZW5WZWN0b3IgbGlua2VkT2JqZWN0cygpIGNvbnN0IGZpbmFsIHsgcmV0dXJu IHRyZWUoKS0+b2JqZWN0c0ZvcklEcyh2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWElEPihBWFByb3Bl cnR5TmFtZTo6TGlua2VkT2JqZWN0cykpOyB9CiAgICAgQVhJc29sYXRlZE9iamVjdCogdGl0bGVV SUVsZW1lbnQoKSBjb25zdCBmaW5hbCB7IHJldHVybiBvYmplY3RBdHRyaWJ1dGVWYWx1ZShBWFBy b3BlcnR5TmFtZTo6VGl0bGVVSUVsZW1lbnQpOyB9CiAgICAgQVhJc29sYXRlZE9iamVjdCogc2Ny b2xsQmFyKEFjY2Vzc2liaWxpdHlPcmllbnRhdGlvbikgZmluYWw7CkBAIC0yNTEsNyArMjYyLDYg QEAgcHJpdmF0ZToKICAgICBTdHJpbmcgZXhwYW5kZWRUZXh0VmFsdWUoKSBjb25zdCBmaW5hbCB7 IHJldHVybiBzdHJpbmdBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6RXhwYW5kZWRUZXh0 VmFsdWUpOyB9CiAgICAgYm9vbCBzdXBwb3J0c0V4cGFuZGVkVGV4dFZhbHVlKCkgY29uc3QgZmlu YWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpTdXBwb3J0c0V4 cGFuZGVkVGV4dFZhbHVlKTsgfQogICAgIFNSR0JBPHVpbnQ4X3Q+IGNvbG9yVmFsdWUoKSBjb25z dCBmaW5hbDsKLSAgICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdCBmaW5hbCB7 IHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5Um9sZT4oaW50QXR0cmlidXRlVmFsdWUo QVhQcm9wZXJ0eU5hbWU6OlJvbGVWYWx1ZSkpOyB9CiAgICAgU3RyaW5nIHJvbGVQbGF0Zm9ybVN0 cmluZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVy dHlOYW1lOjpSb2xlUGxhdGZvcm1TdHJpbmcpOyB9CiAgICAgU3RyaW5nIHJvbGVEZXNjcmlwdGlv bigpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlO YW1lOjpSb2xlRGVzY3JpcHRpb24pOyB9CiAgICAgU3RyaW5nIHN1YnJvbGVQbGF0Zm9ybVN0cmlu ZygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlO YW1lOjpTdWJyb2xlUGxhdGZvcm1TdHJpbmcpOyB9CkBAIC0zMTYsNyArMzI2LDYgQEAgcHJpdmF0 ZToKICAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgdmlzaWJsZUNoaWxkcmVuKCkgZmlu YWwgeyByZXR1cm4gdHJlZSgpLT5vYmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFY SUQ+KEFYUHJvcGVydHlOYW1lOjpWaXNpYmxlQ2hpbGRyZW4pKTsgfQogICAgIEF0b21TdHJpbmcg dGFnTmFtZSgpIGNvbnN0IGZpbmFsOwogICAgIHZvaWQgc2V0Q2hpbGRyZW5JRHMoVmVjdG9yPEFY SUQ+JiYpOwotICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4o Ym9vbCB1cGRhdGVDaGlsZHJlbklmTmVlZGVkID0gdHJ1ZSkgZmluYWw7CiAgICAgdm9pZCB1cGRh dGVDaGlsZHJlbklmTmVjZXNzYXJ5KCkgZmluYWw7CiAgICAgYm9vbCBpc0RldGFjaGVkRnJvbVBh cmVudCgpIGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGxpdmVSZWdpb25BbmNlc3Rvcihi b29sIGV4Y2x1ZGVJZk9mZiA9IHRydWUpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxp dHk6OmxpdmVSZWdpb25BbmNlc3RvcigqdGhpcywgZXhjbHVkZUlmT2ZmKTsgfQpAQCAtMzQ1LDkg KzM1NCw2IEBAIHByaXZhdGU6CiAKICAgICAvLyBDaGFyYWN0ZXJSYW5nZSBzdXBwb3J0LgogICAg IENoYXJhY3RlclJhbmdlIHNlbGVjdGVkVGV4dFJhbmdlKCkgY29uc3QgZmluYWwgeyByZXR1cm4g cHJvcGVydHlWYWx1ZTxDaGFyYWN0ZXJSYW5nZT4oQVhQcm9wZXJ0eU5hbWU6OlNlbGVjdGVkVGV4 dFJhbmdlKTsgfQotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIFZlY3RvcjxB WFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWwgeyByZXR1cm4gdmVjdG9yQXR0cmlidXRlVmFsdWU8 QVhUZXh0UnVuPihBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMpOyB9Ci0jZW5kaWYKICAgICBpbnQg aW5zZXJ0aW9uUG9pbnRMaW5lTnVtYmVyKCkgY29uc3QgZmluYWw7CiAgICAgQ2hhcmFjdGVyUmFu Z2UgZG9BWFJhbmdlRm9yTGluZSh1bnNpZ25lZCkgY29uc3QgZmluYWw7CiAgICAgU3RyaW5nIGRv QVhTdHJpbmdGb3JSYW5nZShjb25zdCBDaGFyYWN0ZXJSYW5nZSYpIGNvbnN0IGZpbmFsOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29s YXRlZFRyZWUuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FY SXNvbGF0ZWRUcmVlLmgKaW5kZXggZjExZWY4NTU1YTE0Li45NDUwMjllMDcwNmQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRU cmVlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJ c29sYXRlZFRyZWUuaApAQCAtMjU1LDcgKzI1NSw3IEBAIHVzaW5nIEFYUHJvcGVydHlWYWx1ZVZh cmlhbnQgPSBzdGQ6OnZhcmlhbnQ8c3RkOjpudWxscHRyX3QsIEFYSUQsIFN0cmluZywgYm9vbCwK ICAgICAsIFJldGFpblB0cjxOU0F0dHJpYnV0ZWRTdHJpbmc+CiAjZW5kaWYKICNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICAsIFZlY3RvcjxBWFRleHRSdW4+CisgICAgLCBBWFRl eHRSdW5zCiAjZW5kaWYKID47CiB1c2luZyBBWFByb3BlcnR5TWFwID0gSGFzaE1hcDxBWFByb3Bl cnR5TmFtZSwgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCwgSW50SGFzaDxBWFByb3BlcnR5TmFtZT4s IFdURjo6U3Ryb25nRW51bUhhc2hUcmFpdHM8QVhQcm9wZXJ0eU5hbWU+PjsK 469221 2023-12-27 12:16:59 -0800 2024-01-02 18:25:36 -0800 Patch bug-266521-20231227121659.patch text/plain 53073 tyler_w RnJvbSAxOTJlODBjNzg3YjYwNGM0ZWZjMDcwOWM5YjkxZjZkNDU2YzllNzgxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGxpbmUgcmFuZ2UsIGFuZCBzdHJpbmctZm9yLXJh bmdlIHRleHQgbWFya2VyCiBBUElzIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjY1MjEgcmRhcjovLzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5 cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzog OGJpdAoKUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3Np dGlvbiBjbGFzcywgd2hpY2ggc2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmlu ZCBhbnkgdGV4dCBsZWFmIHBvc2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkg dHJlZSwgYW5hbHl6aW5nIHRoZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNh biBiZSBjb252ZXJ0ZWQgdG8gYW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVu dGF0aW9uIGluIHRoaXMgcGF0Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5n LiBhcmlhLW93bnMgdHJlZSByZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhl IHdyb25nIHJlc3VsdHMsIGFuZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBw ZWQuCgoqIFNvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291 cmNlcy50eHQ6CiogU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFYQ29yZU9iamVjdDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9i amVjdDo6bmV4dFNpYmxpbmcpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3Jl T2JqZWN0Lmg6CihXZWJDb3JlOjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJD b3JlOjpBWENvcmVPYmplY3Q6OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246 Om9iamVjdCBjb25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2Jq ZWN0V2l0aFJ1bnMpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToK KFdlYkNvcmU6OkFYUG9zaXRpb246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQ b3NpdGlvbjo6bGluZVJhbmdlIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYUG9zaXRpb24uaDogQWRkZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29u c3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6 UnVuRnJvbU9mZnNldDo6cnVuIGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZy b21PZmZzZXQpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpB WFBvc2l0aW9uOjpudWxsUG9zaXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNv bnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9mZnNldCBjb25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdl YkNvcmU6OkFYVGV4dE1hcmtlclJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0 TWFya2VyOjpvZmZzZXQgY29uc3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0UnVuLmg6IEFkZGVkLgooV2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5l SUQpOgooV2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6 cnVuTGVuZ3RoIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4 dFJ1bnM6Om9wZXJhdG9yW10gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNj cmlwdGlvbiBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmls aXR5T2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25z dCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6 CihXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6 OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNv cmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRP YmplY3Q6OnRleHRSdW5zIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9I ZWFkZXJzLmNtYWtlICAgICAgICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291 cmNlcy50eHQgICAgICAgICAgICAgICAgICAgIHwgICAyICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiB8ICAxMiArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYQ29yZU9iamVjdC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhQb3NpdGlvbi5jcHAgICB8IDMwMSArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oICAgICB8ICA5MSArKysrKysKIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcCAgICB8ICA5MyArKysrKysKIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDEyMCArKysrKysrCiAu Li4vYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcCAgICAgfCAgIDYgKwogLi4u L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oICAgICAgIHwgICA1ICsKIC4uLi9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCAgICAgICAgICAgICB8ICAgNiArLQogLi4uL2Fj Y2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIHwgICAyICstCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwICAgICAgICAgfCAgMzAgKysKIC4uLi9pc29s YXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAgICAgICAgICAgIHwgIDE3ICstCiAuLi4vaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmggICAgICAgICAgICAgfCAgMTkgKy0KIDE4IGZpbGVzIGNo YW5nZWQsIDcwMSBpbnNlcnRpb25zKCspLCA0NSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEw MDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBjcmVhdGUg bW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5j cHAKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4 dFJ1bi5oCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZSBiL1NvdXJj ZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKaW5kZXggOGI1MmJjOWI2Y2IxLi4zODVjZWQ4ZmMyZDEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dl YkNvcmUvSGVhZGVycy5jbWFrZQpAQCAtNjUxLDcgKzY1MSw5IEBAIHNldChXZWJDb3JlX1BSSVZB VEVfRlJBTUVXT1JLX0hFQURFUlMKICAgICBhY2Nlc3NpYmlsaXR5L0FYR2VvbWV0cnlNYW5hZ2Vy LmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYT2Jq ZWN0Q2FjaGUuaAorICAgIGFjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiAgICAgYWNjZXNzaWJp bGl0eS9BWFRleHRNYXJrZXIuaAorICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKICAgICBh Y2Nlc3NpYmlsaXR5L0FYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmgKICAgICBhY2Nlc3NpYmlsaXR5 L0FYVHJlZVN0b3JlLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlMaXN0Qm94LmgK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0IGIvU291cmNlL1dlYkNvcmUv U291cmNlcy50eHQKaW5kZXggZDMwMmQzMmVhNzZiLi43MWY4MDc4ZGExYjIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMu dHh0CkBAIC01MjEsNyArNTIxLDkgQEAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5j cHAKIGFjY2Vzc2liaWxpdHkvQVhJbWFnZS5jcHAKIGFjY2Vzc2liaWxpdHkvQVhMb2dnZXIuY3Bw CiBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCithY2Nlc3NpYmlsaXR5L0FYUG9zaXRp b24uY3BwCiBhY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKK2FjY2Vzc2liaWxpdHkvQVhU ZXh0UnVuLmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWQuY3BwCiBhY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZENlbGwuY3BwCiBhY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlBUklBR3JpZFJvdy5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA4MmRmOWM0MmE3MDAuLmE2NDhiNjY5Mzgw YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagpAQCAtMTc1MSw3ICsxNzUxLDkgQEAKIAkJNDdGOTQ3REIyNjUwMkYyRjAwODc5NjhDIC8q IEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGlu Z1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07 CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGQTk2RkYy NjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dlb21ldHJ5LmggKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDgyMjk3MEUyOUM4RUJDMDAw MzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0 LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJNDg2 MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBB WFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0ODZCOERDNjJBMDQz QzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDhCNUJGMzcyOUNBNjkxNzAwRkVC RTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNj ZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlFMDAyNjM4NTcgLyogRWxlbWVudEFu aW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4 dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ5 M0U1RTA5MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ5M0U1RTA4MTJENjQyMDUw MDAyMDA4MSAvKiBQbGF0Zm9ybUNBTGF5ZXJDbGllbnQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjQsMTAgKzEwNzI2LDE0IEBACiAJCTQ3 RkE5NkZGMjY1MDk4MkEwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0ODIyOTcwQjI5QzhFQkMwMDAzM0ExMjYgLyog UmVnaW9uQ29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBS ZWdpb25Db250ZXh0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDgyMjk3MEMy OUM4RUJDMDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gUmVnaW9uQ29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owor CQk0ODYxRTBCRDJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBBWFBvc2l0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJFMkIy MDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEFYUG9z aXRpb24uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0ODZCOERDNjJBMDQzQzA2 MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhHZW9tZXRy eU1hbmFnZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDg2QjhEQzgyQTA0NTAw RjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJNDhCMDI0MjgyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWFRleHRSdW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzUyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM2MjlDQTY5MTcwMEZFQkUz QiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBB Y2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTQ4QzRFODNDMkIzNEQ4MzgwMDgzNDYwQSAvKiBBWFRleHRSdW4uY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gQVhUZXh0UnVuLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhE MEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ5MjQ2MUUxMkFBNTFENDIwMDgxNDcxRSAvKiBDU1NDb2xvck1peFNlcmlhbGl6 YXRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ1NTQ29sb3JNaXhTZXJpYWxpemF0aW9uLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ5M0U1RTA4MTJENjQyMDUwMDAyMDA4MSAvKiBQbGF0 Zm9ybUNBTGF5ZXJDbGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGxh dGZvcm1DQUxheWVyQ2xpZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE5 Miw4ICsyMzE5OCwxMiBAQAogCQkJCUMwNDkzRUI3MjQ0Njk5RTQwMDlBQUM4MCAvKiBBWExvZ2dl ci5oICovLAogCQkJCTI5ODFDQUFGMTMxODIyRUMwMEQxMkYyQSAvKiBBWE9iamVjdENhY2hlLmNw cCAqLywKIAkJCQkyOUE4MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5oICov LAorCQkJCTQ4NjFFMEJFMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLywKKwkJ CQk0ODYxRTBCRDJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovLAogCQkJCUMwRTIw OEExMjkzNzlDNkYwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICovLAogCQkJCUMwRTIwOEEw MjkzNzlDNkUwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJCQk0OEM0RTgzQzJCMzRE ODM4MDA4MzQ2MEEgLyogQVhUZXh0UnVuLmNwcCAqLywKKwkJCQk0OEIwMjQyODJCMkE2NUFBMDA4 M0QxMjIgLyogQVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUzQkUyNDAwOTVCNjFDIC8q IEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFEQzQyOTRCNUE2MjAwNzZD QkRDIC8qIEFYVHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYwNTkwMzAwMjhDNTkyIC8q IEZvcmNlZEFjY2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1ODYsNyArMzc1OTYsOSBAQAog CQkJCTI5QUUyMTM1MjFBQkE0OEEwMDg2OTI4MyAvKiBBWElzb2xhdGVkT2JqZWN0LmggaW4gSGVh ZGVycyAqLywKIAkJCQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRyZWUu aCBpbiBIZWFkZXJzICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVj dENhY2hlLmggaW4gSGVhZGVycyAqLywKKwkJCQk0ODYxRTBCRjJCMjAwNzQ1MDAwRTcwMEYgLyog QVhQb3NpdGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzBFMjA4QTIyOTM3OUM2RjAwQzBEMkQz IC8qIEFYVGV4dE1hcmtlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNDhCMDI0MkEyQjJBNjVBQTAw ODNEMTIyIC8qIEFYVGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTFDOUYyRjkxQUUzQkVC MDAwOTVCNjFDIC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggaW4gSGVhZGVycyAqLywKIAkJ CQlDMEU4QURDNTI5NEI1QTYzMDA3NkNCREMgLyogQVhUcmVlU3RvcmUuaCBpbiBIZWFkZXJzICov LAogCQkJCTE0NzdFNzc3MEJGNDEzNEEwMDE1Mjg3MiAvKiBCYWNrRm9yd2FyZENhY2hlLmggaW4g SGVhZGVycyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhD b3JlT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5o CmluZGV4IDdkMThmNTIxMjY5NS4uOTQzMmRlZDZhODVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgKQEAgLTExMywxOSArMTEzLDYgQEAgZW51bSBjbGFz cyBBWEFuY2VzdG9yRmxhZyA6IHVpbnQ4X3QgewogICAgIC8vIEJpdCA3IGlzIGZyZWUuCiB9Owog Ci0jaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi1zdHJ1Y3QgQVhUZXh0UnVuIHsKLSAg ICAvLyBUaGUgbGluZSBpbmRleCBvZiB0aGlzIHJ1biB3aXRoaW4gdGhlIGNvbnRleHQgb2YgdGhl IGNvbnRhaW5pbmcgUmVuZGVyQmxvY2tGbG93IG9mIHRoZSBtYWluLXRocmVhZCBBWCBvYmplY3Qu Ci0gICAgc2l6ZV90IGxpbmVJbmRleDsKLSAgICBTdHJpbmcgdGV4dDsKLQotICAgIEFYVGV4dFJ1 bihzaXplX3QgbGluZUluZGV4LCBTdHJpbmcmJiB0ZXh0KQotICAgICAgICA6IGxpbmVJbmRleChs aW5lSW5kZXgpCi0gICAgICAgICwgdGV4dChXVEZNb3ZlKHRleHQpKQotICAgIHsgfQotfTsKLSNl bmRpZgotCiBlbnVtIGNsYXNzIEFjY2Vzc2liaWxpdHlSb2xlIHsKICAgICBBcHBsaWNhdGlvbiA9 IDEsCiAgICAgQXBwbGljYXRpb25BbGVydCwKQEAgLTY1Niw2ICs2NDMsOCBAQCBlbnVtIGNsYXNz IEFjY2Vzc2liaWxpdHlCdXR0b25TdGF0ZSB7CiAgICAgTWl4ZWQsCiB9OwogCitlbnVtIGNsYXNz IEFYRGlyZWN0aW9uIDogYm9vbCB7IE5leHQsIFByZXZpb3VzIH07CisKIGVudW0gY2xhc3MgQWNj ZXNzaWJpbGl0eVNvcnREaXJlY3Rpb24gewogICAgIE5vbmUsCiAgICAgQXNjZW5kaW5nLApAQCAt ODAzLDYgKzc5Miw3IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc2V0T2JqZWN0SUQoQVhJRCBheElE KSB7IG1faWQgPSBheElEOyB9CiAgICAgQVhJRCBvYmplY3RJRCgpIGNvbnN0IHsgcmV0dXJuIG1f aWQ7IH0KKyAgICB2aXJ0dWFsIEFYSUQgdHJlZUlEKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwg UHJvY2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0ID0gMDsKIAogICAgIC8vIFdoZW4gdGhlIGNvcnJl c3BvbmRpbmcgV2ViQ29yZSBvYmplY3QgdGhhdCB0aGlzIGFjY2Vzc2libGUgb2JqZWN0CkBAIC0x MTA3LDkgKzEwOTcsNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFjY2Vzc2liaWxpdHlU ZXh0KFZlY3RvcjxBY2Nlc3NpYmlsaXR5VGV4dD4mKSBjb25zdCA9IDA7CiAgICAgLy8gQSBwcm9n cmFtbWF0aWMgd2F5IHRvIHNldCBhIG5hbWUgb24gYW4gQWNjZXNzaWJsZU9iamVjdC4KICAgICB2 aXJ0dWFsIHZvaWQgc2V0QWNjZXNzaWJsZU5hbWUoY29uc3QgQXRvbVN0cmluZyYpID0gMDsKLSNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICB2aXJ0dWFsIFZlY3RvcjxBWFRleHRS dW4+IHRleHRSdW5zKCkgeyByZXR1cm4geyB9OyB9Ci0jZW5kaWYKIAogICAgIHZpcnR1YWwgU3Ry aW5nIHRpdGxlKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgU3RyaW5nIGRlc2NyaXB0aW9uKCkg Y29uc3QgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBv c2l0aW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44OGY1ODU5M2NhNGYKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24u Y3BwCkBAIC0wLDAgKzEsMzAxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisg KiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICog QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIkFYUG9zaXRpb24uaCIKKworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQorCisjaW5jbHVkZSAiQVhJc29sYXRlZE9iamVjdC5oIgorI2luY2x1ZGUgIkFYSXNvbGF0ZWRU cmVlLmgiCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKK0FYSXNvbGF0ZWRPYmplY3QqIEFYUG9zaXRpb246Om9iamVjdCgpIGNvbnN0Cit7CisgICAg UkVMRUFTRV9BU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAobV9jYWNoZWRPYmplY3Qp CisgICAgICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQoKTsKKworICAgIGlmICghbV90cmVl SUQuaXNWYWxpZCgpIHx8ICFtX29iamVjdElELmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIG51 bGxwdHI7CisKKyAgICBhdXRvIHRyZWUgPSBzdGQ6OmdldDxSZWZQdHI8QVhJc29sYXRlZFRyZWU+ PihheFRyZWVGb3JJRCh0cmVlSUQoKSkpOworICAgIG1fY2FjaGVkT2JqZWN0ID0gdHJlZSA/IHRy ZWUtPm9iamVjdEZvcklEKG9iamVjdElEKCkpIDogbnVsbHB0cjsKKyAgICByZXR1cm4gbV9jYWNo ZWRPYmplY3QuZ2V0KCk7Cit9CisKK2NvbnN0IEFYVGV4dFJ1bnMqIEFYUG9zaXRpb246OnJ1bnMo KSBjb25zdAoreworICAgIGF1dG8qIG9iamVjdCA9IHRoaXMtPm9iamVjdCgpOworICAgIHJldHVy biBvYmplY3QgPyBvYmplY3QtPnRleHRSdW5zKCkgOiBudWxscHRyOworfQorCitBWFBvc2l0aW9u IEFYUG9zaXRpb246OmZyb21UZXh0TWFya2VyKGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyKQor eworICAgIHJldHVybiBBWFBvc2l0aW9uKG1hcmtlci50cmVlSUQoKSwgbWFya2VyLm9iamVjdElE KCksIG1hcmtlci5jaGFyYWN0ZXJPZmZzZXQoKSApOworfQorCitBWFBvc2l0aW9uOjpvcGVyYXRv ciBBWFRleHRNYXJrZXIoKSBjb25zdAoreworICAgIHJldHVybiB7IHsgdHJlZUlEKCksIG9iamVj dElEKCksIG51bGxwdHIsIG1fb2Zmc2V0IH0gfTsKK30KKworU3RyaW5nIEFYUG9zaXRpb246OmRl YnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAgIGF1dG8gc2VwYXJhdG9yID0gIiwgIjsKKyAg ICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+b2JqZWN0KCk7CisgICAgcmV0dXJuIG1ha2VTdHJpbmco CisgICAgICAgICJ0cmVlSUQgIiwgdHJlZUlEKCkubG9nZ2luZ1N0cmluZygpCisgICAgICAgICwg c2VwYXJhdG9yLCAib2JqZWN0SUQgIiwgb2JqZWN0SUQoKS5sb2dnaW5nU3RyaW5nKCkKKyAgICAg ICAgLCBzZXBhcmF0b3IsICJyb2xlICIsIG9iamVjdCA/IGFjY2Vzc2liaWxpdHlSb2xlVG9TdHJp bmcob2JqZWN0LT5yb2xlVmFsdWUoKSkgOiBTdHJpbmcoIm5vIG9iamVjdCJfcykKKyAgICAgICAg LCBzZXBhcmF0b3IsICJvZmZzZXQgIiwgbV9vZmZzZXQKKyAgICApOworfQorCitlbnVtIGNsYXNz IENoZWNrU3RhcnQgOiBib29sIHsgTm8sIFllcyB9OworLy8gRmluZHMgdGhlIG5leHQgb2JqZWN0 IHdpdGggdGV4dCBydW5zIGluIHRoZSBnaXZlbiBkaXJlY3Rpb24uCitzdGF0aWMgUmVmUHRyPEFY SXNvbGF0ZWRPYmplY3Q+IGZpbmRPYmplY3RXaXRoUnVucyhBWElzb2xhdGVkT2JqZWN0JiBzdGFy dCwgQVhEaXJlY3Rpb24gZGlyZWN0aW9uLCBDaGVja1N0YXJ0IGNoZWNrU3RhcnQgPSBDaGVja1N0 YXJ0OjpObykKK3sKKyAgICBpZiAoY2hlY2tTdGFydCA9PSBDaGVja1N0YXJ0OjpZZXMpIHsKKyAg ICAgICAgaWYgKGF1dG8qIHJ1bnMgPSBzdGFydC50ZXh0UnVucygpOyBydW5zICYmIHJ1bnMtPnNp emUoKSkKKyAgICAgICAgICAgIHJldHVybiAmc3RhcnQ7CisgICAgfQorCisgICAgUmVmUHRyIGN1 cnJlbnQgPSAmc3RhcnQ7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAgaWYgKGN1cnJl bnQgIT0gJnN0YXJ0KSB7CisgICAgICAgICAgICBhdXRvKiBydW5zID0gY3VycmVudC0+dGV4dFJ1 bnMoKTsKKyAgICAgICAgICAgIGlmIChydW5zICYmIHJ1bnMtPnNpemUoKSkKKyAgICAgICAgICAg ICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEZJWE1FOiBhcmlh LW93bnMgYnJlYWtzIHRoaXMgdHJhdmVyc2FsLCBhcyBhcmlhLW93bnMgY2F1c2VzIHRoZSBBWCB0 cmVlIHRvIGJlIGNoYW5nZWQsIGFmZmVjdGluZworICAgICAgICAvLyBvdXIgaXRlcmF0aW9uIGJl bG93LCBidXQgaXQgZG9lc24ndCBhY3R1YWxseSBjaGFuZ2UgdGV4dCBwb3NpdGlvbiBvbiB0aGUg cGFnZS4gU28gd2UgbmVlZCB0byBpZ25vcmUgYXJpYS1vd25zCisgICAgICAgIC8vIHRyZWUgY2hh bmdlcyBoZXJlIGluIG9yZGVyIHRvIGJlaGF2ZSBjb3JyZWN0bHkuCisgICAgICAgIC8vIFdlIGFs c28gcHJvYmFibHkgbmVlZCB0byBkbyBzb21ldGhpbmcgYWJvdXQgdGV4dCB3aXRoaW4gYXJpYS1o aWRkZW4gY29udGFpbmVycywgd2hpY2ggYWZmZWN0cyB0aGUgQVggdHJlZS4KKworICAgICAgICBj b25zdCBhdXRvJiBjaGlsZHJlbiA9IGN1cnJlbnQtPmNoaWxkcmVuKCk7CisgICAgICAgIGlmIChj aGlsZHJlbi5zaXplKCkpIHsKKyAgICAgICAgICAgIHNpemVfdCBjaGlsZEluZGV4ID0gZGlyZWN0 aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ID8gMCA6IGNoaWxkcmVuLnNpemUoKSAtIDE7CisgICAg ICAgICAgICBSRUxFQVNFX0FTU0VSVChjaGlsZHJlbltjaGlsZEluZGV4XSk7CisgICAgICAgICAg ICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KGNoaWxkcmVuW2No aWxkSW5kZXhdLmdldCgpKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAg ICAgICAgLy8gYGN1cnJlbnRgIGhhcyBubyBjaGlsZHJlbiwgbWVhbmluZyBpdCdzIGEgbGVhZiBu b2RlIChlLmcuIGl0J3MgdGV4dCwgd2hpY2ggY2Fubm90IGhhdmUgY2hpbGRyZW4pLgorICAgICAg ICAvLyBDaGVjayBgY3VycmVudGBzIHNpYmxpbmdzLgorICAgICAgICBpZiAoYXV0byogc2libGlu ZyA9IGN1cnJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSkgeworICAgICAgICAgICAgY3VycmVudCA9 IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0PihzaWJsaW5nKTsKKyAgICAgICAgICAg IGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gV2UgaGF2ZSBubyBjaGlsZHJlbiwg YW5kIG5vIG5leHQvcHJldmlvdXMgc2libGluZy4gVHJ5IG91ciBwYXJlbnQncyBzaWJsaW5nLgor ICAgICAgICBpZiAoYXV0byogcGFyZW50ID0gY3VycmVudC0+cGFyZW50T2JqZWN0VW5pZ25vcmVk KCkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9i amVjdD4ocGFyZW50LT5zaWJsaW5nKGRpcmVjdGlvbikpOworICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgIH0KKworICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIG51bGxwdHI7 Cit9CisKK0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uIGRp cmVjdGlvbikgY29uc3QKK3sKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiBudWxs UG9zaXRpb24oKTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAgICAgICAgcmV0dXJuIGFzVGV4 dExlYWZQb3NpdGlvbigpLmZpbmRQb3NpdGlvbihkaXJlY3Rpb24pOworICAgIFJFTEVBU0VfQVNT RVJUKGlzVGV4dExlYWYoKSk7CisKKyAgICBzaXplX3QgcnVuSW5kZXggPSBydW5JbmRleEZyb21P ZmZzZXQoKTsKKyAgICBhdXRvIGhhc01vcmVUZXh0SW5DdXJyZW50UnVuID0gWyZdIHsKKyAgICAg ICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAgICAgICAgICAgIHJldHVy biBtX29mZnNldCA8IHJ1bnMoKS0+YXQocnVuSW5kZXgpLnRleHQubGVuZ3RoKCk7CisgICAgICAg IHJldHVybiBtX29mZnNldCA+IDA7CisgICAgfTsKKyAgICBib29sIGhhc0Fub3RoZXJSdW4gPSBy dW5JbmRleCArIDEgPCBydW5zKCktPnNpemUoKTsKKyAgICAvLyBUaGUgbmV4dCBydW4gc2hvdWxk IG5vdCBoYXZlIGVtcHR5IHRleHQsIGJlY2F1c2Ugd2UncmUgZ29pbmcgdG8gcmV0dXJuIGEgcG9z aXRpb24gY29udGFpbmluZyBtX29mZnNldCArIDEsIHdoaWNoIHdvdWxkIGJlIHdyb25nLgorICAg IFJFTEVBU0VfQVNTRVJUKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6UHJldmlvdXMgfHwgIWhh c0Fub3RoZXJSdW4gfHwgcnVucygpLT5ydW5MZW5ndGgocnVuSW5kZXggKyAxKSA+IDApOworICAg IC8vIENoZWNraW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5vdGhlciBydW4gaXMgb25seSByZWxl dmFudCBmb3IgbW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBhcyBqdXN0IGNoZWNraW5nIHRoYXQg bV9vZmZzZXQgPiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGlyZWN0aW9uOjpQcmV2aW91cy4KKyAg ICBpZiAoaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAoZGlyZWN0aW9uID09IEFYRGlyZWN0 aW9uOjpOZXh0ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAgICAgIC8vIFJldHVybiBhbiBvZmZz ZXQgdG8gdGhlIG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgcmV0 dXJuIEFYUG9zaXRpb24obV90cmVlSUQsIG1fb2JqZWN0SUQsIGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6TmV4dCA/IG1fb2Zmc2V0ICsgMSA6IG1fb2Zmc2V0IC0gMSk7CisgICAgfQorICAgIC8v IG1fb2Zmc2V0IHBvaW50ZWQgdG8gdGhlIGxhc3QgY2hhcmFjdGVyIGluIHRoZSBnaXZlbiBvYmpl Y3QncyBydW5zLCBzbyBsZXQncyB0cmF2ZXJzZSB0byBmaW5kIHRoZSBuZXh0IG9iamVjdCB3aXRo IHJ1bnMuCisgICAgaWYgKFJlZlB0ciBvYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKnRoaXMt Pm9iamVjdCgpLCBkaXJlY3Rpb24pKQorICAgICAgICByZXR1cm4gQVhQb3NpdGlvbihvYmplY3Qt PnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6 TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5zKCktPmxhc3RSdW5MZW5ndGgoKSk7CisKKyAgICBy ZXR1cm4gbnVsbFBvc2l0aW9uKCk7Cit9CisKK0FYUG9zaXRpb24gQVhQb3NpdGlvbjo6ZmluZFBv c2l0aW9uKEFYRGlyZWN0aW9uIGRpcmVjdGlvbiwgQVhUZXh0VW5pdCB0ZXh0VW5pdCwgQVhUZXh0 VW5pdEJvdW5kYXJ5IGJvdW5kYXJ5KSBjb25zdAoreworICAgIGlmIChpc051bGwoKSkKKyAgICAg ICAgcmV0dXJuIG51bGxQb3NpdGlvbigpOworICAgIGlmICghaXNUZXh0TGVhZigpKQorICAgICAg ICByZXR1cm4gYXNUZXh0TGVhZlBvc2l0aW9uKCkuZmluZFBvc2l0aW9uKGRpcmVjdGlvbiwgdGV4 dFVuaXQsIGJvdW5kYXJ5KTsKKyAgICBSRUxFQVNFX0FTU0VSVChpc1RleHRMZWFmKCkpOworCisg ICAgaWYgKHRleHRVbml0ID09IEFYVGV4dFVuaXQ6OkxpbmUpIHsKKyAgICAgICAgc2l6ZV90IHJ1 bkluZGV4ID0gcnVuSW5kZXhGcm9tT2Zmc2V0KCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2Jq ZWN0ID0gb2JqZWN0KCk7CisgICAgICAgIGNvbnN0IGF1dG8qIGN1cnJlbnRSdW5zID0gY3VycmVu dE9iamVjdC0+dGV4dFJ1bnMoKTsKKworICAgICAgICBhdXRvIGNvbXB1dGVPZmZzZXQgPSBbJl0g KHNpemVfdCBydW5FbmRPZmZzZXQsIHNpemVfdCBydW5MZW5ndGgpIHsKKyAgICAgICAgICAgIC8v IFRoaXMgd29ya3MgYmVjYXVzZSBgcnVuRW5kT2Zmc2V0YCBpcyB0aGUgb2Zmc2V0IHBvaW50aW5n IHRvIHRoZSBlbmQgb2YgdGhlIGdpdmVuIHJ1biwgd2hpY2ggaW5jbHVkZXMgdGhlIGxlbmd0aCBv ZiBhbGwgcnVucyBwcmVjZWRpbmcgaXQuIFNvIHN1YnRyYWN0aW5nIHRoYXQgZnJvbSB0aGUgbGVu Z3RoIG9mIHRoZSBjdXJyZW50IHJ1biBnaXZlcyB1cyBhbiBvZmZzZXQgdG8gdGhlIHN0YXJ0IG9m IHRoZSBjdXJyZW50IHJ1bi4KKyAgICAgICAgICAgIHJldHVybiBib3VuZGFyeSA9PSBBWFRleHRV bml0Qm91bmRhcnk6OkVuZCA/IHJ1bkVuZE9mZnNldCA6IHJ1bkVuZE9mZnNldCAtIHJ1bkxlbmd0 aDsKKyAgICAgICAgfTsKKyAgICAgICAgYXV0byBsaW5lUG9zaXRpb24gPSBBWFBvc2l0aW9uKG1f dHJlZUlELCBtX29iamVjdElELCBjb21wdXRlT2Zmc2V0KGN1cnJlbnRSdW5zLT5ydW5MZW5ndGhT dW1UbyhydW5JbmRleCksIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgocnVuSW5kZXgpKSk7CisgICAg ICAgIGF1dG8gc3RhcnRMaW5lSUQgPSBjdXJyZW50UnVucy0+bGluZUlEKHJ1bkluZGV4KTsKKyAg ICAgICAgLy8gV2UgZm91bmQgdGhlIHN0YXJ0IHJ1biBhbmQgYXNzb2NpYXRlZCBsaW5lLCBub3cg aXRlcmF0ZSB1bnRpbCB3ZSBmaW5kIGEgbGluZSBib3VuZGFyeS4KKyAgICAgICAgd2hpbGUgKGN1 cnJlbnRPYmplY3QpIHsKKyAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGN1cnJlbnRSdW5zLT5z aXplKCkpOworICAgICAgICAgICAgdW5zaWduZWQgY3VtdWxhdGl2ZU9mZnNldCA9IDA7CisgICAg ICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGN1cnJlbnRSdW5zLT5zaXplKCk7IGkrKykg eworICAgICAgICAgICAgICAgIGN1bXVsYXRpdmVPZmZzZXQgKz0gY3VycmVudFJ1bnMtPnJ1bkxl bmd0aChpKTsKKyAgICAgICAgICAgICAgICBpZiAoY3VycmVudFJ1bnMtPmxpbmVJRChpKSAhPSBz dGFydExpbmVJRCkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGxpbmVQb3NpdGlvbjsKKyAg ICAgICAgICAgICAgICBsaW5lUG9zaXRpb24gPSBBWFBvc2l0aW9uKGN1cnJlbnRPYmplY3QtPnRy ZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJRCgpLCBjb21wdXRlT2Zmc2V0KGN1bXVsYXRp dmVPZmZzZXQsIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSkpKTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIGN1cnJlbnRPYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnRPYmpl Y3QsIGRpcmVjdGlvbik7CisgICAgICAgICAgICBpZiAoY3VycmVudE9iamVjdCkKKyAgICAgICAg ICAgICAgICBjdXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRleHRSdW5zKCk7CisgICAgICAg IH0KKyAgICAgICAgcmV0dXJuIGxpbmVQb3NpdGlvbjsKKyAgICB9CisgICAgcmV0dXJuIG51bGxQ b3NpdGlvbigpOworfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmFzVGV4dExlYWZQb3NpdGlv bigpIGNvbnN0Cit7CisgICAgaWYgKGlzTnVsbCgpIHx8IGlzVGV4dExlYWYoKSkgeworICAgICAg ICAvLyBJZiBzb21ldGhpbmcgaGFzIGNvbnN0cnVjdGVkIGEgbGVhZiBwb3NpdGlvbiwgaXQgc2hv dWxkJ3ZlIGRvbmUgc28gd2l0aCBhbiBpbi1ib3VuZHMgb2Zmc2V0LgorICAgICAgICBSRUxFQVNF X0FTU0VSVChpc051bGwoKSB8fCBvYmplY3QoKS0+dGV4dFJ1bnMoKS0+cnVuTGVuZ3RoU3VtKCkg Pj0gbV9vZmZzZXQpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgLy8gRmlu ZCB0aGUgbGVhZiBub2RlIG91ciBvZmZzZXQgcG9pbnRzIHRvLiBGb3IgZXhhbXBsZToKKyAgICAv LyBBWFBvc2l0aW9uIHsgSUQgMTogR3JvdXAsIE9mZnNldCA2IH0KKyAgICAvLyBJRCAxOiBHcm91 cAorICAgIC8vICAtIElEIDI6IEZvbworICAgIC8vICAtIElEIDM6IExpbmUxCisgICAgLy8gICAg ICAgICAgTGluZTIKKyAgICAvLyBDYWxsaW5nIGFzVGV4dExlYWZQb3NpdGlvbigpIG9uIHRoZSBv cmlnaW5hbCBwb3NpdGlvbiBzaG91bGQgeWllbGQgbmV3IHBvc2l0aW9uOgorICAgIC8vIEFYUG9z aXRpb24geyBJRCAzOiBTdGF0aWNUZXh0LCBPZmZzZXQgMyB9CisgICAgLy8gQmVjYXVzZSB3ZSBo YWQgdG8gd2FsayBvdmVyIElEIDIgd2hpY2ggaGFkIGxlbmd0aCAzIHRleHQuCisgICAgc2l6ZV90 IHByZWNlZGluZ09mZnNldCA9IDA7CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0V2l0 aFJ1bnMoKm9iamVjdCgpLCBBWERpcmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAg ICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICB1bnNpZ25lZCBjdXJyZW50U3VtID0gY3VycmVu dC0+dGV4dFJ1bnMoKS0+cnVuTGVuZ3RoU3VtKCk7CisgICAgICAgIGlmIChwcmVjZWRpbmdPZmZz ZXQgKyBjdXJyZW50U3VtID49IG1fb2Zmc2V0KQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAg IHByZWNlZGluZ09mZnNldCArPSBjdXJyZW50U3VtOworICAgICAgICBjdXJyZW50ID0gZmluZE9i amVjdFdpdGhSdW5zKCpjdXJyZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgfQorCisgICAg UkVMRUFTRV9BU1NFUlQobV9vZmZzZXQgPj0gcHJlY2VkaW5nT2Zmc2V0KTsKKyAgICByZXR1cm4g QVhQb3NpdGlvbihjdXJyZW50LT50cmVlSUQoKSwgY3VycmVudC0+b2JqZWN0SUQoKSwgbV9vZmZz ZXQgLSBwcmVjZWRpbmdPZmZzZXQpOworfQorCitib29sIEFYUG9zaXRpb246OmlzVGV4dExlYWYo KSBjb25zdAoreworICAgIGF1dG8qIG9iamVjdCA9IHRoaXMtPm9iamVjdCgpOworICAgIC8vIEZJ WE1FOiBJcyBpdCBwb3NzaWJsZSBmb3Igbm9uLWxlYWYgbm9kZXMgdG8gaGF2ZSB0ZXh0IHJ1bnM/ IElmIHNvLCB3ZSBkb24ndCBoYW5kbGUgdGhlbSBjb3JyZWN0bHkuCisgICAgcmV0dXJuICFvYmpl Y3QgfHwgKCFvYmplY3QtPmNoaWxkcmVuKCkuc2l6ZSgpICYmIG9iamVjdC0+dGV4dFJ1bnMoKSk7 Cit9CisKK3NpemVfdCBBWFBvc2l0aW9uOjpydW5JbmRleEZyb21PZmZzZXQoKSBjb25zdAorewor ICAgIGF1dG8qIHJ1bnMgPSB0aGlzLT5ydW5zKCk7CisgICAgaWYgKCFydW5zKQorICAgICAgICBy ZXR1cm4gbm90Rm91bmQ7CisKKyAgICBzaXplX3QgaW5kZXggPSBydW5zLT5pbmRleEZvck9mZnNl dChtX29mZnNldCk7CisgICAgLy8gSWYgd2UgY291bGRuJ3QgZmluZCBhIGNvcnJlc3BvbmRpbmcg cnVuLCB0aGF0IG1lYW5zIG1fb2Zmc2V0IHBvaW50ZWQgb3V0IG9mIGJvdW5kcyBvZiBvdXIgdGV4 dCBydW5zLCB3aGljaAorICAgIC8vIHdvdWxkIG9ubHkgaGFwcGVuIGlmIHdlJ3ZlIGNvbnN0cnVj dGVkIGFuIGludmFsaWQgcG9zaXRpb24uCisgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggIT0gbm90 Rm91bmQpOworICAgIHJldHVybiBpbmRleDsKK30KKworQVhUZXh0TWFya2VyUmFuZ2UgQVhQb3Np dGlvbjo6bGluZVJhbmdlKExpbmVSYW5nZVR5cGUgdHlwZSkgY29uc3QKK3sKKyAgICBpZiAoaXNO dWxsKCkpCisgICAgICAgIHJldHVybiB7IG51bGxQb3NpdGlvbigpLCBudWxsUG9zaXRpb24oKSB9 OworCisgICAgaWYgKHR5cGUgPT0gTGluZVJhbmdlVHlwZTo6Q3VycmVudCkKKyAgICAgICAgcmV0 dXJuIHsgZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpQcmV2aW91cywgQVhUZXh0VW5pdDo6TGlu ZSwgQVhUZXh0VW5pdEJvdW5kYXJ5OjpTdGFydCksIGZpbmRQb3NpdGlvbihBWERpcmVjdGlvbjo6 TmV4dCwgQVhUZXh0VW5pdDo6TGluZSwgQVhUZXh0VW5pdEJvdW5kYXJ5OjpFbmQpIH07CisgICAg Ly8gVGhlIG90aGVyIHR5cGVzIGFyZW4ndCBpbXBsZW1lbnRlZCB5ZXQuCisgICAgUkVMRUFTRV9B U1NFUlRfTk9UX1JFQUNIRUQoKTsKK30KKworU3RyaW5nIEFYUG9zaXRpb246OnN1YnN0cmluZyh1 bnNpZ25lZCBzdGFydCwgdW5zaWduZWQgbGVuZ3RoKSBjb25zdAoreworICAgIGlmIChpc051bGwo KSkKKyAgICAgICAgcmV0dXJuIGVtcHR5U3RyaW5nKCk7CisgICAgaWYgKCFpc1RleHRMZWFmKCkp CisgICAgICAgIHJldHVybiBhc1RleHRMZWFmUG9zaXRpb24oKS5zdWJzdHJpbmcoc3RhcnQsIGxl bmd0aCk7CisgICAgUkVMRUFTRV9BU1NFUlQoaXNUZXh0TGVhZigpKTsKKyAgICByZXR1cm4gcnVu cygpLT5zdWJzdHJpbmcoc3RhcnQsIGxlbmd0aCk7Cit9CisKK1N0cmluZyBBWFBvc2l0aW9uOjpz dHJpbmdXaXRoRW5kKGNvbnN0IEFYUG9zaXRpb24mIGVuZFBvc2l0aW9uKQoreworICAgIGlmIChp c051bGwoKSkKKyAgICAgICAgcmV0dXJuIGVtcHR5U3RyaW5nKCk7CisgICAgaWYgKCFpc1RleHRM ZWFmKCkpCisgICAgICAgIHJldHVybiBhc1RleHRMZWFmUG9zaXRpb24oKS5zdHJpbmdXaXRoRW5k KGVuZFBvc2l0aW9uKTsKKyAgICBSRUxFQVNFX0FTU0VSVChpc1RleHRMZWFmKCkpOworICAgIGF1 dG8gZW5kTGVhZlBvc2l0aW9uID0gZW5kUG9zaXRpb24uYXNUZXh0TGVhZlBvc2l0aW9uKCk7CisK KyAgICBpZiAob2JqZWN0KCkgPT0gZW5kTGVhZlBvc2l0aW9uLm9iamVjdCgpKSB7CisgICAgICAg IHNpemVfdCBtaW5PZmZzZXQgPSBzdGQ6Om1pbihtX29mZnNldCwgZW5kTGVhZlBvc2l0aW9uLm9m ZnNldCgpKTsKKyAgICAgICAgc2l6ZV90IG1heE9mZnNldCA9IHN0ZDo6bWF4KG1fb2Zmc2V0LCBl bmRMZWFmUG9zaXRpb24ub2Zmc2V0KCkpOworICAgICAgICByZXR1cm4gc3Vic3RyaW5nKG1pbk9m ZnNldCwgbWF4T2Zmc2V0IC0gbWluT2Zmc2V0KTsKKyAgICB9CisKKyAgICBTdHJpbmdCdWlsZGVy IHJlc3VsdDsKKyAgICByZXN1bHQuYXBwZW5kKHN1YnN0cmluZyhtX29mZnNldCkpOworCisgICAg Ly8gRklYTUU6IElmIHdlJ3ZlIGJlZW4gZ2l2ZW4gcmV2ZXJzZWQgcG9zaXRpb25zLCBpLmUuIHRo ZSBlbmQgcG9zaXRpb24gYWN0dWFsbHkgY29tZXMgYmVmb3JlIHRoZSBzdGFydCBwb3NpdGlvbiwK KyAgICAvLyB3ZSBtYXkgd2FudCB0byBkZXRlY3QgdGhpcyBhbmQgdHJ5IHNlYXJjaGluZyBBWERp cmVjdGlvbjo6UHJldmlvdXM/CisgICAgUmVmUHRyIGN1cnJlbnQgPSBvYmplY3QoKTsKKyAgICB3 aGlsZSAoY3VycmVudC0+b2JqZWN0SUQoKSAhPSBlbmRMZWFmUG9zaXRpb24ub2JqZWN0SUQoKSkg eworICAgICAgICBSZWZQdHIgY3VycmVudCA9IGZpbmRPYmplY3RXaXRoUnVucygqb2JqZWN0KCks IEFYRGlyZWN0aW9uOjpOZXh0KTsKKyAgICAgICAgaWYgKCFjdXJyZW50KQorICAgICAgICAgICAg YnJlYWs7CisKKyAgICAgICAgY29uc3QgYXV0byogcnVucyA9IGN1cnJlbnQtPnRleHRSdW5zKCk7 CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5zLT5zaXplKCk7IGkrKykKKyAg ICAgICAgICAgIHJlc3VsdC5hcHBlbmQocnVucy0+YXQoaSkudGV4dCk7CisgICAgfQorICAgIHJl c3VsdC5hcHBlbmQoZW5kTGVhZlBvc2l0aW9uLnN1YnN0cmluZygwLCBlbmRMZWFmUG9zaXRpb24u b2Zmc2V0KCkpKTsKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4wMzJhY2Y5MTVjNWYKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uaApAQCAtMCwwICsxLDkxIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRf QVBJUykKKyNpbmNsdWRlICJBWElzb2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0TWFy a2VyLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworZW51bSBjbGFzcyBBWFRleHRVbml0IDog dWludDhfdCB7CisgICAgTGluZSwKKyAgICBQYXJhZ3JhcGgsCisgICAgU2VudGVuY2UsCisgICAg V29yZCwKK307CitlbnVtIGNsYXNzIEFYVGV4dFVuaXRCb3VuZGFyeSA6IGJvb2wgeyBTdGFydCwg RW5kLCB9OworCitlbnVtIGNsYXNzIExpbmVSYW5nZVR5cGUgOiB1aW50OF90IHsKKyAgICBDdXJy ZW50LAorICAgIExlZnQsCisgICAgUmlnaHQsCit9OworCitjbGFzcyBBWFBvc2l0aW9uIHsKK3B1 YmxpYzoKKyAgICBleHBsaWNpdCBBWFBvc2l0aW9uKEFYSUQgdHJlZUlELCBBWElEIG9iamVjdElE LCB1bnNpZ25lZCBvZmZzZXQpCisgICAgICAgIDogbV90cmVlSUQodHJlZUlEKQorICAgICAgICAs IG1fb2JqZWN0SUQob2JqZWN0SUQpCisgICAgICAgICwgbV9vZmZzZXQob2Zmc2V0KQorICAgIHsg fQorICAgIHN0YXRpYyBBWFBvc2l0aW9uIG51bGxQb3NpdGlvbigpIHsgcmV0dXJuIEFYUG9zaXRp b24oQVhJRCgpLCBBWElEKCksIDApOyB9CisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBj b25zdDsKKworICAgIHN0YXRpYyBBWFBvc2l0aW9uIGZyb21UZXh0TWFya2VyKGNvbnN0IEFYVGV4 dE1hcmtlciYpOworICAgIG9wZXJhdG9yIEFYVGV4dE1hcmtlcigpIGNvbnN0OworCisgICAgLy8g RmluZCB0aGUgbmV4dCBvciBwcmV2aW91cyBwb3NpdGlvbi4KKyAgICBBWFBvc2l0aW9uIGZpbmRQ b3NpdGlvbihBWERpcmVjdGlvbikgY29uc3Q7CisgICAgLy8gU3RhcnRpbmcgZnJvbSB0aGlzIHBv c2l0aW9uLCBjcmVhdGVzIGEgbmV3IHBvc2l0aW9uIGZvciB0aGUgZ2l2ZW4gZGlyZWN0aW9uIGFu ZCB0ZXh0IHVuaXQgdHlwZS4KKyAgICBBWFBvc2l0aW9uIGZpbmRQb3NpdGlvbihBWERpcmVjdGlv biwgQVhUZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5KSBjb25zdDsKKyAgICBBWFRleHRNYXJr ZXJSYW5nZSBsaW5lUmFuZ2UoTGluZVJhbmdlVHlwZSkgY29uc3Q7CisgICAgU3RyaW5nIHN0cmlu Z1dpdGhFbmQoY29uc3QgQVhQb3NpdGlvbiYpOworCitwcml2YXRlOgorICAgIEFYSUQgdHJlZUlE KCkgY29uc3QgeyByZXR1cm4gbV90cmVlSUQ7IH0KKyAgICBBWElEIG9iamVjdElEKCkgY29uc3Qg eyByZXR1cm4gbV9vYmplY3RJRDsgfQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNvbnN0IHsgcmV0 dXJuIG1fb2Zmc2V0OyB9CisKKyAgICBBWElzb2xhdGVkT2JqZWN0KiBvYmplY3QoKSBjb25zdDsK KyAgICBjb25zdCBBWFRleHRSdW5zKiBydW5zKCkgY29uc3Q7CisgICAgU3RyaW5nIHN1YnN0cmlu Zyh1bnNpZ25lZCBzdGFydCwgdW5zaWduZWQgbGVuZ3RoID0gU3RyaW5nSW1wbDo6TWF4TGVuZ3Ro KSBjb25zdDsKKyAgICBzaXplX3QgcnVuSW5kZXhGcm9tT2Zmc2V0KCkgY29uc3Q7CisgICAgYm9v bCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhb2JqZWN0KCk7IH0KKworICAgIEFYUG9zaXRpb24g YXNUZXh0TGVhZlBvc2l0aW9uKCkgY29uc3Q7CisgICAgLy8gQSAidGV4dCBsZWFmIiBwb3NpdGlv biBpcyBhIGxlYWYgbm9kZSAobm8gY2hpbGRyZW4pIHdpdGggbm9uLWVtcHR5IHRleHRydW5zLgor ICAgIGJvb2wgaXNUZXh0TGVhZigpIGNvbnN0OworCisgICAgQVhJRCBtX3RyZWVJRDsKKyAgICBB WElEIG1fb2JqZWN0SUQ7CisgICAgdW5zaWduZWQgbV9vZmZzZXQgeyAwIH07CisKKyAgICBtdXRh YmxlIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBtX2NhY2hlZE9iamVjdDsKK307CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcAppbmRleCA5 YWQ2YWJmOTNhYWMuLmQyZDQzM2JjYmIxYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMzM1LDcgKzMzNSw3IEBAIHN0ZDo6b3B0aW9uYWw8 QVhUZXh0TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtlclJhbmdlOjppbnRlcnNlY3Rpb25XaXRoKGNv bnN0IEFYVGV4CiAKIFN0cmluZyBBWFRleHRNYXJrZXJSYW5nZTo6ZGVidWdEZXNjcmlwdGlvbigp IGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1 Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBtX2VuZC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9 Iik7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2Ny aXB0aW9uKCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5kLmRlYnVnRGVzY3JpcHRpb24oKSwgIn0iKTsK IH0KIAogc3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBhcnRpYWxPcmRlcihjb25zdCBBWFRleHRNYXJr ZXImIG1hcmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMikKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmggYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCmluZGV4IDE3ZTlmYzBkYWI5OC4uOGZkYTlh MmViMGM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1h cmtlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgK QEAgLTEyMyw2ICsxMjMsNyBAQCBwdWJsaWM6CiAKICAgICBBWElEIHRyZWVJRCgpIGNvbnN0IHsg cmV0dXJuIG1fZGF0YS5heFRyZWVJRCgpOyB9CiAgICAgQVhJRCBvYmplY3RJRCgpIGNvbnN0IHsg cmV0dXJuIG1fZGF0YS5heE9iamVjdElEKCk7IH0KKyAgICB1bnNpZ25lZCBjaGFyYWN0ZXJPZmZz ZXQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEuY2hhcmFjdGVyT2Zmc2V0OyB9CiAgICAgYm9vbCBp c051bGwoKSBjb25zdCB7IHJldHVybiAhdHJlZUlEKCkuaXNWYWxpZCgpIHx8ICFvYmplY3RJRCgp LmlzVmFsaWQoKTsgfQogICAgIFJlZlB0cjxBWENvcmVPYmplY3Q+IG9iamVjdCgpIGNvbnN0Owog ICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdCgpOyB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi41MDRmYTI0NzJhYTYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKQEAgLTAsMCArMSw5MyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBWFRleHRSdW4uaCIKKwor I2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorbmFtZXNwYWNlIFdlYkNvcmUgeworCitT dHJpbmcgQVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0Cit7CisgICAgU3RyaW5n QnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgnWycpOworICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgIHJlc3VsdC5hcHBlbmQo cnVuc1tpXS5kZWJ1Z0Rlc2NyaXB0aW9uKGNvbnRhaW5pbmdCbG9jaykpOworICAgICAgICBpZiAo aSAhPSBydW5zLnNpemUoKSAtIDEpCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKCIsICIpOwor ICAgIH0KKyAgICByZXN1bHQuYXBwZW5kKCddJyk7CisgICAgcmV0dXJuIHJlc3VsdC50b1N0cmlu ZygpOworfQorCitzaXplX3QgQVhUZXh0UnVuczo6aW5kZXhGb3JPZmZzZXQodW5zaWduZWQgdGV4 dE9mZnNldCkgY29uc3QKK3sKKyAgICBzaXplX3QgY3VtdWxhdGl2ZUxlbmd0aCA9IDA7CisgICAg Zm9yIChzaXplX3QgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgIGN1bXVs YXRpdmVMZW5ndGggKz0gcnVuTGVuZ3RoKGkpOworICAgICAgICBpZiAoY3VtdWxhdGl2ZUxlbmd0 aCA+PSB0ZXh0T2Zmc2V0KQorICAgICAgICAgICAgcmV0dXJuIGk7CisgICAgfQorICAgIHJldHVy biBub3RGb3VuZDsKK30KKwordW5zaWduZWQgQVhUZXh0UnVuczo6cnVuTGVuZ3RoU3VtVG8oc2l6 ZV90IGluZGV4KSBjb25zdAoreworICAgIHVuc2lnbmVkIGxlbmd0aCA9IDA7CisgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPD0gaW5kZXggJiYgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspCisgICAgICAg IGxlbmd0aCArPSBydW5MZW5ndGgoaSk7CisgICAgcmV0dXJuIGxlbmd0aDsKK30KKworU3RyaW5n IEFYVGV4dFJ1bnM6OnN1YnN0cmluZyh1bnNpZ25lZCBzdGFydCwgdW5zaWduZWQgbGVuZ3RoKSBj b25zdAoreworICAgIGlmICghbGVuZ3RoKQorICAgICAgICByZXR1cm4gZW1wdHlTdHJpbmcoKTsK KworICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHNpemVfdCBjaGFyYWN0ZXJzU2VlbiA9 IDA7CisgICAgYXV0byByZW1haW5pbmcgPSBbJl0gKCkgeworICAgICAgICByZXR1cm4gcmVzdWx0 Lmxlbmd0aCgpID49IGxlbmd0aCA/IDAgOiBsZW5ndGggLSByZXN1bHQubGVuZ3RoKCk7CisgICAg fTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcnVucy5zaXplKCkgJiYgcmVzdWx0Lmxl bmd0aCgpIDwgbGVuZ3RoOyBpKyspIHsKKyAgICAgICAgc2l6ZV90IHJ1bkxlbmd0aCA9IHRoaXMt PnJ1bkxlbmd0aChpKTsKKyAgICAgICAgaWYgKGNoYXJhY3RlcnNTZWVuID49IHN0YXJ0KSB7Cisg ICAgICAgICAgICAvLyBUaGUgc3RhcnQgcG9pbnRzIGVudGlyZWx5IHdpdGhpbiBib3VuZHMgb2Yg dGhpcyBydW4uCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0udGV4dC5sZWZ0KHJl bWFpbmluZygpKSk7CisgICAgICAgIH0gZWxzZSBpZiAoY2hhcmFjdGVyc1NlZW4gKyBydW5MZW5n dGggPiBzdGFydCkgeworICAgICAgICAgICAgLy8gc3RhcnQgcG9pbnRzIHNvbWV3aGVyZSBpbiB0 aGUgbWlkZGxlIG9mIHRoZSBjdXJyZW50IHJ1biwgY29sbGVjdCBwYXJ0IG9mIHRoZSB0ZXh0Lgor ICAgICAgICAgICAgdW5zaWduZWQgc3RhcnRJblJ1biA9IHN0YXJ0IC0gY2hhcmFjdGVyc1NlZW47 CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChzdGFydEluUnVuIDwgcnVuTGVuZ3RoKTsKKyAg ICAgICAgICAgIHJlc3VsdC5hcHBlbmQocnVuc1tpXS50ZXh0LnN1YnN0cmluZyhzdGFydEluUnVu LCByZW1haW5pbmcoKSkpOworICAgICAgICB9CisgICAgICAgIC8vIElmIGNoYXJhY3RlcnNTZWVu ICsgcnVuTGVuZ3RoID09IHN0YXJ0LCB0aGUgc3RhcnQgcG9pbnRzIHRvIHRoZSBlbmQgb2YgdGhl IHJ1biwgYW5kIHRoZXJlIGlzIG5vIHRleHQgdG8gZ2F0aGVyLgorCisgICAgICAgIGNoYXJhY3Rl cnNTZWVuICs9IHJ1bkxlbmd0aDsKKyAgICB9CisgICAgcmV0dXJuIHJlc3VsdC50b1N0cmluZygp OworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVB RF9URVhUX0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY VGV4dFJ1bi5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmEwOTlmMzExZjU2ZAotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKQEAg LTAsMCArMSwxMjAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJMRShB WF9USFJFQURfVEVYVF9BUElTKQorbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBSZW5kZXJC bG9jazsKKworc3RydWN0IEFYVGV4dFJ1bkxpbmVJRCB7CisgICAgdm9pZCogY29udGFpbmluZ0Js b2NrIHsgbnVsbHB0ciB9OworICAgIHNpemVfdCBsaW5lSW5kZXggeyAwIH07CisKKyAgICBBWFRl eHRSdW5MaW5lSUQodm9pZCogY29udGFpbmluZ0Jsb2NrLCBzaXplX3QgbGluZUluZGV4KQorICAg ICAgICA6IGNvbnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgbGluZUlu ZGV4KGxpbmVJbmRleCkKKyAgICB7IH0KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQVhUZXh0 UnVuTGluZUlEJikgY29uc3QgPSBkZWZhdWx0OworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9u KCkgY29uc3QKKyAgICB7CisgICAgICAgIFRleHRTdHJlYW0gc3RyZWFtOworICAgICAgICBzdHJl YW0gPDwgIkxpbmVJRCAiIDw8IGNvbnRhaW5pbmdCbG9jayA8PCAiICIgPDwgbGluZUluZGV4Owor ICAgICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2UoKTsKKyAgICB9Cit9OworCitzdHJ1Y3QgQVhU ZXh0UnVuIHsKKyAgICAvLyBUaGUgbGluZSBpbmRleCBvZiB0aGlzIHJ1biB3aXRoaW4gdGhlIGNv bnRleHQgb2YgdGhlIGNvbnRhaW5pbmcgUmVuZGVyQmxvY2sgb2YgdGhlIG1haW4tdGhyZWFkIEFY IG9iamVjdC4KKyAgICBzaXplX3QgbGluZUluZGV4OworICAgIFN0cmluZyB0ZXh0OworCisgICAg QVhUZXh0UnVuKHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCisgICAgICAgIDogbGlu ZUluZGV4KGxpbmVJbmRleCkKKyAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCisgICAgeyB9 CisKKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbih2b2lkKiBjb250YWluaW5nQmxvY2spIGNv bnN0CisgICAgeworICAgICAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEID0geyBjb250YWluaW5n QmxvY2ssIGxpbmVJbmRleCB9OworICAgICAgICByZXR1cm4gbWFrZVN0cmluZyhsaW5lSUQuZGVi dWdEZXNjcmlwdGlvbigpLCAiOiB8IiwgbWFrZVN0cmluZ0J5UmVwbGFjaW5nQWxsKHRleHQsICdc bicsICJ7bmV3bGluZX0iX3MpLCAifChsZW4gIiwgdGV4dC5sZW5ndGgoKSwgIikiKTsKKyAgICB9 Cit9OworCitzdHJ1Y3QgQVhUZXh0UnVucyB7CisgICAgLy8gVGhlIGNvbnRhaW5pbmcgYmxvY2sg Zm9yIHRoZSB0ZXh0IHJ1bnMuIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZSBiYXNlZCBvbiB0aGUg c3RydWN0dXJlCisgICAgLy8gb2YgdGhlIEFYIHRyZWUsIHRleHQgcnVucyBmb3IgZGlmZmVyZW50 IG9iamVjdHMgY2FuIGhhdmUgdGhlIHNhbWUgbGluZSBpbmRleCBidXQgZGlmZmVyZW50CisgICAg Ly8gY29udGFpbmluZyBibG9ja3MsIG1lYW5pbmcgdGhleSBhcmUgcmVuZGVyZWQgb24gZGlmZmVy ZW50IGxpbmVzLgorICAgIC8vIERvIG5vdCBkZS1yZWZlcmVuY2UuIFVzZSBmb3IgY29tcGFyaXNv biBwdXJwb3NlcyBvbmx5LgorICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7IG51bGxwdHIgfTsK KyAgICBWZWN0b3I8QVhUZXh0UnVuPiBydW5zOworCisgICAgQVhUZXh0UnVucygpID0gZGVmYXVs dDsKKyAgICBBWFRleHRSdW5zKFJlbmRlckJsb2NrKiBjb250YWluaW5nQmxvY2ssIFZlY3RvcjxB WFRleHRSdW4+JiYgcnVucykKKyAgICAgICAgOiBjb250YWluaW5nQmxvY2soY29udGFpbmluZ0Js b2NrKQorICAgICAgICAsIHJ1bnMoV1RGTW92ZShydW5zKSkKKyAgICB7IH0KKyAgICBTdHJpbmcg ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0OworCisgICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IHJl dHVybiBydW5zLnNpemUoKTsgfQorICAgIGNvbnN0IEFYVGV4dFJ1biYgYXQoc2l6ZV90IGluZGV4 KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuICgqdGhpcylbaW5kZXhdOworICAgIH0KKyAg ICBjb25zdCBBWFRleHRSdW4mIG9wZXJhdG9yW10oc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsK KyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBydW5zLnNpemUoKSk7CisgICAgICAgIHJl dHVybiBydW5zW2luZGV4XTsKKyAgICB9CisKKyAgICB1bnNpZ25lZCBydW5MZW5ndGgoc2l6ZV90 IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBydW5z LnNpemUoKSk7CisgICAgICAgIHJldHVybiBydW5zW2luZGV4XS50ZXh0Lmxlbmd0aCgpOworICAg IH0KKyAgICB1bnNpZ25lZCBsYXN0UnVuTGVuZ3RoKCkgY29uc3QKKyAgICB7CisgICAgICAgIGlm IChydW5zLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICByZXR1cm4g cnVuc1tydW5zLnNpemUoKSAtIDFdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2lnbmVk IHJ1bkxlbmd0aFN1bSgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gcnVuTGVuZ3RoU3Vt VG8ocnVucy5zaXplKCkgLSAxKTsKKyAgICB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoU3VtVG8o c2l6ZV90IGluZGV4KSBjb25zdDsKKworICAgIHNpemVfdCBpbmRleEZvck9mZnNldCh1bnNpZ25l ZCB0ZXh0T2Zmc2V0KSBjb25zdDsKKyAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEKHNpemVfdCBp bmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5z aXplKCkpOworICAgICAgICByZXR1cm4geyBjb250YWluaW5nQmxvY2ssIHJ1bnNbaW5kZXhdLmxp bmVJbmRleCB9OworICAgIH0KKyAgICBTdHJpbmcgc3Vic3RyaW5nKHVuc2lnbmVkIHN0YXJ0LCB1 bnNpZ25lZCBsZW5ndGggPSBTdHJpbmdJbXBsOjpNYXhMZW5ndGgpIGNvbnN0OworfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9i amVjdC5jcHAKaW5kZXggMjlhOTMxYzVhYTE0Li5mMzM5YjNhYjAwODEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcApAQCAt MTEzLDYgKzExMywxMiBAQCB2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmluaXQoKQogICAgIG1f cm9sZSA9IGRldGVybWluZUFjY2Vzc2liaWxpdHlSb2xlKCk7CiB9CiAKK0FYSUQgQWNjZXNzaWJp bGl0eU9iamVjdDo6dHJlZUlEKCkgY29uc3QKK3sKKyAgICBhdXRvKiBjYWNoZSA9IGF4T2JqZWN0 Q2FjaGUoKTsKKyAgICByZXR1cm4gY2FjaGUgPyBjYWNoZS0+dHJlZUlEKCkgOiBBWElEKCk7Cit9 CisKIGlubGluZSBQcm9jZXNzSUQgQWNjZXNzaWJpbGl0eU9iamVjdDo6cHJvY2Vzc0lEKCkgY29u c3QKIHsKICAgICByZXR1cm4gcHJlc2VudGluZ0FwcGxpY2F0aW9uUElEKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaCBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCmluZGV4IGU2 NGI2MzA2YzA4ZS4uYzdmMjhkNWMzYjU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaApAQCAtMzAsNiArMzAsNyBAQAogI3ByYWdt YSBvbmNlCiAKICNpbmNsdWRlICJBWENvcmVPYmplY3QuaCIKKyNpbmNsdWRlICJBWFRleHRSdW4u aCIKICNpbmNsdWRlICJDaGFyYWN0ZXJSYW5nZS5oIgogI2luY2x1ZGUgIkZsb2F0UXVhZC5oIgog I2luY2x1ZGUgIkxheW91dFJlY3QuaCIKQEAgLTYzLDYgKzY0LDcgQEAgY2xhc3MgQWNjZXNzaWJp bGl0eU9iamVjdCA6IHB1YmxpYyBBWENvcmVPYmplY3QsIHB1YmxpYyBDYW5NYWtlV2Vha1B0cjxB Y2Nlc3NpYmkKIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5BY2Nlc3NpYmlsaXR5T2JqZWN0KCk7CiAK KyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsOwogICAgIFByb2Nlc3NJRCBwcm9jZXNzSUQo KSBjb25zdCBvdmVycmlkZTsKICAgICBTdHJpbmcgZGJnKCkgY29uc3QgZmluYWw7CiAKQEAgLTM4 Miw2ICszODQsOSBAQCBwdWJsaWM6CiAgICAgU3RyaW5nIHRleHRVbmRlckVsZW1lbnQoQWNjZXNz aWJpbGl0eVRleHRVbmRlckVsZW1lbnRNb2RlID0gQWNjZXNzaWJpbGl0eVRleHRVbmRlckVsZW1l bnRNb2RlKCkpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIFN0cmluZyB0ZXh0 KCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4geyB9OyB9CiAgICAgdW5zaWduZWQgdGV4dExlbmd0 aCgpIGNvbnN0IGZpbmFsOworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIHZp cnR1YWwgQVhUZXh0UnVucyB0ZXh0UnVucygpIHsgcmV0dXJuIHsgfTsgfQorI2VuZGlmCiAjaWYg UExBVEZPUk0oQ09DT0EpCiAgICAgLy8gUmV0dXJucyBhbiBhcnJheSBvZiBzdHJpbmdzIGFuZCBB WE9iamVjdCB3cmFwcGVycyBjb3JyZXNwb25kaW5nIHRvIHRoZQogICAgIC8vIHRleHRydW5zIGFu ZCByZXBsYWNlbWVudCBub2RlcyBpbmNsdWRlZCBpbiB0aGUgZ2l2ZW4gcmFuZ2UuCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmNwcAppbmRleCAzOTQ2OWU2OTA2MDAuLmY3MzhlODliNDJhYSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwCkBAIC0xNDAzLDExICsxNDAzLDExIEBAIENoYXJhY3RlclJhbmdlIEFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OnNlbGVjdGVkVGV4dFJhbmdlKCkgY29uc3QKIH0KIAogI2lmIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotVmVjdG9yPEFYVGV4dFJ1bj4gQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdDo6dGV4dFJ1bnMoKQorQVhUZXh0UnVucyBBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0Ojp0ZXh0UnVucygpCiB7CiAgICAgaWYgKGF1dG8qIHJlbmRlckxpbmVCcmVhayA9IGR5 bmFtaWNEb3duY2FzdDxSZW5kZXJMaW5lQnJlYWs+KHJlbmRlcmVyKCkpKSB7CiAgICAgICAgIGF1 dG8gYm94ID0gSW5saW5lSXRlcmF0b3I6OmJveEZvcigqcmVuZGVyTGluZUJyZWFrKTsKLSAgICAg ICAgcmV0dXJuIHsgeyBib3gtPmxpbmVJbmRleCgpLCBtYWtlU3RyaW5nKCdcbicpIH0gfTsKKyAg ICAgICAgcmV0dXJuIHsgcmVuZGVyTGluZUJyZWFrLT5jb250YWluaW5nQmxvY2soKSwgeyBBWFRl eHRSdW4oYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKS5pc29sYXRlZENvcHkoKSkg fSB9OwogICAgIH0KIAogICAgIFdlYWtQdHIgcmVuZGVyVGV4dCA9IGR5bmFtaWNEb3duY2FzdDxS ZW5kZXJUZXh0PihyZW5kZXJlcigpKTsKQEAgLTE0NjAsNyArMTQ2MCw3IEBAIFZlY3RvcjxBWFRl eHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKIAogICAgIGlmICgh bGluZVN0cmluZy5pc0VtcHR5KCkpCiAgICAgICAgIHJ1bnMuYXBwZW5kKHsgY3VycmVudExpbmVJ bmRleCwgbGluZVN0cmluZy50b1N0cmluZygpLmlzb2xhdGVkQ29weSgpIH0pOwotICAgIHJldHVy biBydW5zOworICAgIHJldHVybiB7IHJlbmRlclRleHQtPmNvbnRhaW5pbmdCbG9jaygpLCBXVEZN b3ZlKHJ1bnMpIH07CiB9CiAjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmgKaW5kZXggY2VlYzZiZjNlODk4Li5iZTllZTRmODYwNDYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oCkBAIC0xMDAsNyArMTAwLDcgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5k ZXJFbGVtZW50KEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxp dHlUZXh0VW5kZXJFbGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZTsKICAgICBTdHJpbmcgc2Vs ZWN0ZWRUZXh0KCkgY29uc3Qgb3ZlcnJpZGU7CiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCi0gICAgVmVjdG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbDsKKyAgICBBWFRleHRS dW5zIHRleHRSdW5zKCkgZmluYWw7CiAjZW5kaWYKIAogICAgIGJvb2wgaXNXaWRnZXQoKSBjb25z dCBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAKaW5kZXggNjJhMWE1NzVhZTYx Li4zNDVmMmQ1M2RmNTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCkBAIC0zMSw2ICsz MSw3IEBACiAjaW5jbHVkZSAiQVhHZW9tZXRyeU1hbmFnZXIuaCIKICNpbmNsdWRlICJBWElzb2xh dGVkVHJlZS5oIgogI2luY2x1ZGUgIkFYTG9nZ2VyLmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgi CiAKICNpZiBQTEFURk9STShNQUMpCiAjaW1wb3J0IDxwYWwvc3BpL21hYy9ISVNlcnZpY2VzU1BJ Lmg+CkBAIC00NjQsNiArNDY1LDkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRQcm9wZXJ0 eShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlWYWx1ZVYKICAgICAgICAg W10oc3RkOjpwYWlyPEFYSUQsIENoYXJhY3RlclJhbmdlPiYgdHlwZWRWYWx1ZSkgewogICAgICAg ICAgICAgcmV0dXJuICF0eXBlZFZhbHVlLmZpcnN0LmlzVmFsaWQoKSAmJiAhdHlwZWRWYWx1ZS5z ZWNvbmQubG9jYXRpb24gJiYgIXR5cGVkVmFsdWUuc2Vjb25kLmxlbmd0aDsKICAgICAgICAgfSwK KyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICAgICAgW10oQVhUZXh0UnVucyBy dW5zKSB7IHJldHVybiAhcnVucy5zaXplKCk7IH0sCisjZW5kaWYKICAgICAgICAgW10oYXV0byYp IHsKICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICAgICAgcmV0dXJu IGZhbHNlOwpAQCAtNTU3LDYgKzU2MSwxOSBAQCB2b2lkIEFYSXNvbGF0ZWRPYmplY3Q6OnNldFNl bGVjdGVkQ2hpbGRyZW4oY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBzZQogICAg IH0pOwogfQogCitBWENvcmVPYmplY3QqIEFYSXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcoQVhEaXJl Y3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIFJlZlB0ciBwYXJlbnQgPSBwYXJlbnRPYmpl Y3RVbmlnbm9yZWQoKTsKKyAgICBjb25zdCBhdXRvJiBzaWJsaW5ncyA9IHBhcmVudC0+Y2hpbGRy ZW4oKTsKKyAgICBzaXplX3QgaW5kZXhPZlRoaXMgPSBzaWJsaW5ncy5maW5kKHRoaXMpOworICAg IGlmIChpbmRleE9mVGhpcyA9PSBub3RGb3VuZCkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisK KyAgICBpZiAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0KQorICAgICAgICByZXR1cm4g aW5kZXhPZlRoaXMgKyAxIDwgc2libGluZ3Muc2l6ZSgpID8gc2libGluZ3NbaW5kZXhPZlRoaXMg KyAxXS5nZXQoKSA6IG51bGxwdHI7CisgICAgcmV0dXJuIGluZGV4T2ZUaGlzID4gMCA/IHNpYmxp bmdzW2luZGV4T2ZUaGlzIC0gMV0uZ2V0KCkgOiBudWxscHRyOworfQorCiBib29sIEFYSXNvbGF0 ZWRPYmplY3Q6OmlzRGV0YWNoZWRGcm9tUGFyZW50KCkKIHsKICAgICBpZiAocGFyZW50KCkuaXNW YWxpZCgpKQpAQCAtOTcxLDYgKzk4OCwxOSBAQCBpbnQgQVhJc29sYXRlZE9iamVjdDo6aW50QXR0 cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lKSBjb25zdAogICAgICk7CiB9 CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK2NvbnN0IEFYVGV4dFJ1bnMqIEFY SXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zKCkgY29uc3QKK3sKKyAgICBhdXRvIGVudHJ5ID0gbV9w cm9wZXJ0eU1hcC5maW5kKEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7CisgICAgaWYgKGVudHJ5 ID09IG1fcHJvcGVydHlNYXAuZW5kKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIHJl dHVybiBXVEY6OnN3aXRjaE9uKGVudHJ5LT52YWx1ZSwKKyAgICAgICAgW10gKGNvbnN0IEFYVGV4 dFJ1bnMmIHR5cGVkVmFsdWUpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0dXJuICZ0eXBlZFZh bHVlOyB9LAorICAgICAgICBbXSAoYXV0byYpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0dXJu IG51bGxwdHI7IH0KKyAgICApOworfQorI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiBU IEFYSXNvbGF0ZWRPYmplY3Q6OmdldE9yUmV0cmlldmVQcm9wZXJ0eVZhbHVlKEFYUHJvcGVydHlO YW1lIHByb3BlcnR5TmFtZSkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAppbmRleCBhNmNhMDM0 Mzc3N2QuLjhkOTRhZDJiZDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaApAQCAtNDQsNiAr NDQsOSBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBWElzb2xhdGVkVHJlZTsKKyNp ZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK3N0cnVjdCBBWFRleHRSdW5zOworI2VuZGlm CiAKIGNsYXNzIEFYSXNvbGF0ZWRPYmplY3QgZmluYWwgOiBwdWJsaWMgQVhDb3JlT2JqZWN0IHsK ICAgICBmcmllbmQgY2xhc3MgQVhJc29sYXRlZFRyZWU7CkBAIC01MSw3ICs1NCw5IEBAIHB1Ymxp YzoKICAgICBzdGF0aWMgUmVmPEFYSXNvbGF0ZWRPYmplY3Q+IGNyZWF0ZShjb25zdCBSZWY8QWNj ZXNzaWJpbGl0eU9iamVjdD4mLCBBWElzb2xhdGVkVHJlZSopOwogICAgIH5BWElzb2xhdGVkT2Jq ZWN0KCk7CiAKKyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+ dHJlZUlEKCk7IH0KICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgZmluYWwgeyByZXR1 cm4gdHJlZSgpLT5wcm9jZXNzSUQoKTsgfQorICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1 ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xlPihp bnRBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBTdHJp bmcgZGJnKCkgY29uc3QgZmluYWw7CiAKICAgICB2b2lkIGF0dGFjaFBsYXRmb3JtV3JhcHBlcihB Y2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlciopOwpAQCAtNTksMTAgKzY0LDE3IEBAIHB1YmxpYzoK ICAgICBib29sIGlzVGFibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFs dWUoQVhQcm9wZXJ0eU5hbWU6OklzVGFibGUpOyB9CiAgICAgYm9vbCBpc0V4cG9zYWJsZSgpIGNv bnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6SXNF eHBvc2FibGUpOyB9CiAKKyAgICBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNo aWxkcmVuKGJvb2wgdXBkYXRlQ2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpIGZpbmFsOworICAgIEFY Q29yZU9iamVjdCogc2libGluZyhBWERpcmVjdGlvbikgY29uc3Q7CiAgICAgQVhJc29sYXRlZE9i amVjdCogcGFyZW50T2JqZWN0KCkgY29uc3QgZmluYWwgeyByZXR1cm4gcGFyZW50T2JqZWN0VW5p Z25vcmVkKCk7IH0KKyAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQo KSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBlZGl0YWJsZUFuY2VzdG9yKCkg ZmluYWwgeyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6ZWRpdGFibGVBbmNlc3RvcigqdGhpcyk7IH07 CiAgICAgYm9vbCBjYW5TZXRGb2N1c0F0dHJpYnV0ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJv b2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Q2FuU2V0Rm9jdXNBdHRyaWJ1dGUpOyB9 CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICBjb25zdCBBWFRleHRSdW5z KiB0ZXh0UnVucygpIGNvbnN0OworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgdm9pZCBkZXRhY2hS ZW1vdGVQYXJ0cyhBY2Nlc3NpYmlsaXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwogICAgIHZvaWQg ZGV0YWNoUGxhdGZvcm1XcmFwcGVyKEFjY2Vzc2liaWxpdHlEZXRhY2htZW50VHlwZSkgZmluYWw7 CkBAIC0yNDMsNyArMjU1LDYgQEAgcHJpdmF0ZToKICAgICBWZWN0b3I8U3RyaW5nPiBkZXRlcm1p bmVEcm9wRWZmZWN0cygpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGFjY2Vz c2liaWxpdHlIaXRUZXN0KGNvbnN0IEludFBvaW50JikgY29uc3QgZmluYWw7CiAgICAgQVhJc29s YXRlZE9iamVjdCogZm9jdXNlZFVJRWxlbWVudCgpIGNvbnN0IGZpbmFsOwotICAgIEFYSXNvbGF0 ZWRPYmplY3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNvbnN0IGZpbmFsOwogICAgIEFjY2Vz c2liaWxpdHlDaGlsZHJlblZlY3RvciBsaW5rZWRPYmplY3RzKCkgY29uc3QgZmluYWwgeyByZXR1 cm4gdHJlZSgpLT5vYmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFYUHJv cGVydHlOYW1lOjpMaW5rZWRPYmplY3RzKSk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiB0aXRs ZVVJRWxlbWVudCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIG9iamVjdEF0dHJpYnV0ZVZhbHVlKEFY UHJvcGVydHlOYW1lOjpUaXRsZVVJRWxlbWVudCk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiBz Y3JvbGxCYXIoQWNjZXNzaWJpbGl0eU9yaWVudGF0aW9uKSBmaW5hbDsKQEAgLTI1MSw3ICsyNjIs NiBAQCBwcml2YXRlOgogICAgIFN0cmluZyBleHBhbmRlZFRleHRWYWx1ZSgpIGNvbnN0IGZpbmFs IHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpFeHBhbmRlZFRl eHRWYWx1ZSk7IH0KICAgICBib29sIHN1cHBvcnRzRXhwYW5kZWRUZXh0VmFsdWUoKSBjb25zdCBm aW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlN1cHBvcnRz RXhwYW5kZWRUZXh0VmFsdWUpOyB9CiAgICAgU1JHQkE8dWludDhfdD4gY29sb3JWYWx1ZSgpIGNv bnN0IGZpbmFsOwotICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNvbnN0IGZpbmFs IHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xlPihpbnRBdHRyaWJ1dGVWYWx1 ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBTdHJpbmcgcm9sZVBsYXRmb3Jt U3RyaW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9w ZXJ0eU5hbWU6OlJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KICAgICBTdHJpbmcgcm9sZURlc2NyaXB0 aW9uKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0 eU5hbWU6OlJvbGVEZXNjcmlwdGlvbik7IH0KICAgICBTdHJpbmcgc3Vicm9sZVBsYXRmb3JtU3Ry aW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0 eU5hbWU6OlN1YnJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KQEAgLTMxNiw3ICszMjYsNiBAQCBwcml2 YXRlOgogICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciB2aXNpYmxlQ2hpbGRyZW4oKSBm aW5hbCB7IHJldHVybiB0cmVlKCktPm9iamVjdHNGb3JJRHModmVjdG9yQXR0cmlidXRlVmFsdWU8 QVhJRD4oQVhQcm9wZXJ0eU5hbWU6OlZpc2libGVDaGlsZHJlbikpOyB9CiAgICAgQXRvbVN0cmlu ZyB0YWdOYW1lKCkgY29uc3QgZmluYWw7CiAgICAgdm9pZCBzZXRDaGlsZHJlbklEcyhWZWN0b3I8 QVhJRD4mJik7Ci0gICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJl bihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQgPSB0cnVlKSBmaW5hbDsKICAgICB2b2lkIHVw ZGF0ZUNoaWxkcmVuSWZOZWNlc3NhcnkoKSBmaW5hbDsKICAgICBib29sIGlzRGV0YWNoZWRGcm9t UGFyZW50KCkgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogbGl2ZVJlZ2lvbkFuY2VzdG9y KGJvb2wgZXhjbHVkZUlmT2ZmID0gdHJ1ZSkgY29uc3QgZmluYWwgeyByZXR1cm4gQWNjZXNzaWJp bGl0eTo6bGl2ZVJlZ2lvbkFuY2VzdG9yKCp0aGlzLCBleGNsdWRlSWZPZmYpOyB9CkBAIC0zNDUs OSArMzU0LDYgQEAgcHJpdmF0ZToKIAogICAgIC8vIENoYXJhY3RlclJhbmdlIHN1cHBvcnQuCiAg ICAgQ2hhcmFjdGVyUmFuZ2Ugc2VsZWN0ZWRUZXh0UmFuZ2UoKSBjb25zdCBmaW5hbCB7IHJldHVy biBwcm9wZXJ0eVZhbHVlPENoYXJhY3RlclJhbmdlPihBWFByb3BlcnR5TmFtZTo6U2VsZWN0ZWRU ZXh0UmFuZ2UpOyB9Ci0jaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgVmVjdG9y PEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbCB7IHJldHVybiB2ZWN0b3JBdHRyaWJ1dGVWYWx1 ZTxBWFRleHRSdW4+KEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7IH0KLSNlbmRpZgogICAgIGlu dCBpbnNlcnRpb25Qb2ludExpbmVOdW1iZXIoKSBjb25zdCBmaW5hbDsKICAgICBDaGFyYWN0ZXJS YW5nZSBkb0FYUmFuZ2VGb3JMaW5lKHVuc2lnbmVkKSBjb25zdCBmaW5hbDsKICAgICBTdHJpbmcg ZG9BWFN0cmluZ0ZvclJhbmdlKGNvbnN0IENoYXJhY3RlclJhbmdlJikgY29uc3QgZmluYWw7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElz b2xhdGVkVHJlZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJl ZS9BWElzb2xhdGVkVHJlZS5jcHAKaW5kZXggZjZmMDYyMmFiZTkzLi4wZTc1MzllM2E4YzAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNv bGF0ZWRUcmVlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVk dHJlZS9BWElzb2xhdGVkVHJlZS5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIkFY SXNvbGF0ZWRPYmplY3QuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFjY2Vz c2liaWxpdHlUYWJsZVJvdy5oIgogI2luY2x1ZGUgIkZyYW1lU2VsZWN0aW9uLmgiCiAjaW5jbHVk ZSAiTG9jYWxGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJQYWdlLmgiCkBAIC0yMzAsMjIgKzIzMSw2 IEBAIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBBWElzb2xhdGVkVHJlZTo6b2JqZWN0Rm9ySUQo Y29uc3QgQVhJRCBheElEKSBjb25zdAogICAgIHJldHVybiBheElELmlzVmFsaWQoKSA/IG1fcmVh ZGVyVGhyZWFkTm9kZU1hcC5nZXQoYXhJRCkgOiBudWxscHRyOwogfQogCi10ZW1wbGF0ZTx0eXBl bmFtZSBVPgotVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBBWElzb2xhdGVkVHJlZTo6b2Jq ZWN0c0ZvcklEcyhjb25zdCBVJiBheElEcykgY29uc3QKLXsKLSAgICBBWFRSQUNFKCJBWElzb2xh dGVkVHJlZTo6b2JqZWN0c0ZvcklEcyJfcyk7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7 Ci0KLSAgICBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IHJlc3VsdDsKLSAgICByZXN1bHQu cmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShheElEcy5zaXplKCkpOwotICAgIGZvciAoYXV0byYgYXhJ RCA6IGF4SURzKSB7Ci0gICAgICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gb2JqZWN0Rm9ySUQoYXhJ RCkpCi0gICAgICAgICAgICByZXN1bHQuYXBwZW5kKFdURk1vdmUob2JqZWN0KSk7Ci0gICAgfQot ICAgIHJlc3VsdC5zaHJpbmtUb0ZpdCgpOwotICAgIHJldHVybiByZXN1bHQ7Ci19Ci0KIHZvaWQg QVhJc29sYXRlZFRyZWU6OmdlbmVyYXRlU3VidHJlZShBY2Nlc3NpYmlsaXR5T2JqZWN0JiBheE9i amVjdCkKIHsKICAgICBBWFRSQUNFKCJBWElzb2xhdGVkVHJlZTo6Z2VuZXJhdGVTdWJ0cmVlIl9z KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVl L0FYSXNvbGF0ZWRUcmVlLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVk dHJlZS9BWElzb2xhdGVkVHJlZS5oCmluZGV4IDU5ZjE5ZmE3ODhmNS4uN2U4ZjYxNzgxNTliIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElz b2xhdGVkVHJlZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0 cmVlL0FYSXNvbGF0ZWRUcmVlLmgKQEAgLTI5LDYgKzI5LDcgQEAKIAogI2luY2x1ZGUgIkFYQ29y ZU9iamVjdC5oIgogI2luY2x1ZGUgIkFYVGV4dE1hcmtlci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1 bi5oIgogI2luY2x1ZGUgIkFYVHJlZVN0b3JlLmgiCiAjaW5jbHVkZSAiUGFnZUlkZW50aWZpZXIu aCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZUNvbnN0YW50cy5oIgpAQCAtNDcsNiArNDgsNyBAQCBj bGFzcyBUZXh0U3RyZWFtOwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBWElzb2xhdGVk T2JqZWN0OworY2xhc3MgQVhHZW9tZXRyeU1hbmFnZXI7CiBjbGFzcyBBWE9iamVjdENhY2hlOwog Y2xhc3MgQWNjZXNzaWJpbGl0eU9iamVjdDsKIGNsYXNzIFBhZ2U7CkBAIC0yNTUsNyArMjU3LDcg QEAgdXNpbmcgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCA9IHN0ZDo6dmFyaWFudDxzdGQ6Om51bGxw dHJfdCwgQVhJRCwgU3RyaW5nLCBib29sLAogICAgICwgUmV0YWluUHRyPE5TQXR0cmlidXRlZFN0 cmluZz4KICNlbmRpZgogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgICwgVmVj dG9yPEFYVGV4dFJ1bj4KKyAgICAsIEFYVGV4dFJ1bnMKICNlbmRpZgogPjsKIHVzaW5nIEFYUHJv cGVydHlNYXAgPSBIYXNoTWFwPEFYUHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWYXJpYW50 LCBJbnRIYXNoPEFYUHJvcGVydHlOYW1lPiwgV1RGOjpTdHJvbmdFbnVtSGFzaFRyYWl0czxBWFBy b3BlcnR5TmFtZT4+OwpAQCAtMzIyLDcgKzMyNCwyMCBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9F WFBPUlQgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZvY3VzZWROb2RlKCk7CiAKICAgICBSZWZQ dHI8QVhJc29sYXRlZE9iamVjdD4gb2JqZWN0Rm9ySUQoY29uc3QgQVhJRCkgY29uc3Q7Ci0gICAg dGVtcGxhdGU8dHlwZW5hbWUgVT4gVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBvYmplY3Rz Rm9ySURzKGNvbnN0IFUmKSBjb25zdDsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPgorICAgIFZl Y3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gb2JqZWN0c0ZvcklEcyhjb25zdCBVJiBheElEcykg Y29uc3QKKyAgICB7CisgICAgICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworCisgICAgICAg IFZlY3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gcmVzdWx0OworICAgICAgICByZXN1bHQucmVz ZXJ2ZUluaXRpYWxDYXBhY2l0eShheElEcy5zaXplKCkpOworICAgICAgICBmb3IgKGNvbnN0IGF1 dG8mIGF4SUQgOiBheElEcykgeworICAgICAgICAgICAgaWYgKFJlZlB0ciBvYmplY3QgPSBvYmpl Y3RGb3JJRChheElEKSkKKyAgICAgICAgICAgICAgICByZXN1bHQuYXBwZW5kKFdURk1vdmUob2Jq ZWN0KSk7CisgICAgICAgIH0KKyAgICAgICAgcmVzdWx0LnNocmlua1RvRml0KCk7CisgICAgICAg IHJldHVybiByZXN1bHQ7CisgICAgfQogCiAgICAgdm9pZCBnZW5lcmF0ZVN1YnRyZWUoQWNjZXNz aWJpbGl0eU9iamVjdCYpOwogICAgIHZvaWQgbGFiZWxDcmVhdGVkKEFjY2Vzc2liaWxpdHlPYmpl Y3QmKTsK 469267 2024-01-02 18:25:39 -0800 2024-01-03 18:20:30 -0800 Patch bug-266521-20240102182538.patch text/plain 53076 tyler_w RnJvbSA3ZmI2MWM0MzI2ZjBhYTU2OGE5MWY0ODQ0YTQzZmViNmI5ZDZhMDY0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGxpbmUgcmFuZ2UsIGFuZCBzdHJpbmctZm9yLXJh bmdlIHRleHQgbWFya2VyCiBBUElzIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjY1MjEgcmRhcjovLzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5 cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzog OGJpdAoKUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCgpJbnRyb2R1Y2UgYSBuZXcgQVhQb3Np dGlvbiBjbGFzcywgd2hpY2ggc2VydmVzIGFzIGEgcm9vdCBmcm9tIHdoaWNoIHlvdSBjYW4gZmlu ZCBhbnkgdGV4dCBsZWFmIHBvc2l0aW9uIGJ5IHRyYXZlcnNpbmcKdGhlIGFjY2Vzc2liaWxpdHkg dHJlZSwgYW5hbHl6aW5nIHRoZSB0ZXh0IHJ1bnMgYXQgZWFjaCBzdG9wLiBBWFBvc2l0aW9uIGNh biBiZSBjb252ZXJ0ZWQgdG8gYW5kIGZyb20gYW4gQVhUZXh0TWFya2VyLgoKVGhlIGltcGxlbWVu dGF0aW9uIGluIHRoaXMgcGF0Y2ggaWdub3JlcyBpbXBvcnRhbnQgZWRnZSBjYXNlcyDigJQgZS5n LiBhcmlhLW93bnMgdHJlZSByZS1vcmRlcmluZyB3aWxsIGNhdXNlIHVzIHRvCmNvbXB1dGUgdGhl IHdyb25nIHJlc3VsdHMsIGFuZCB0ZXh0IGluIGlnbm9yZWQgb2JqZWN0cyB3aWxsIGJlIHNraXBw ZWQuCgoqIFNvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2U6CiogU291cmNlL1dlYkNvcmUvU291 cmNlcy50eHQ6CiogU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmNwcDoKKFdl YkNvcmU6OkFYQ29yZU9iamVjdDo6cHJldmlvdXNTaWJsaW5nKToKKFdlYkNvcmU6OkFYQ29yZU9i amVjdDo6bmV4dFNpYmxpbmcpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3Jl T2JqZWN0Lmg6CihXZWJDb3JlOjpBWFRleHRSdW46OkFYVGV4dFJ1bik6IERlbGV0ZWQuCihXZWJD b3JlOjpBWENvcmVPYmplY3Q6OnRleHRSdW5zKTogRGVsZXRlZC4KKiBTb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwOiBBZGRlZC4KKFdlYkNvcmU6OkFYUG9zaXRpb246 Om9iamVjdCBjb25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjpmcm9tVGV4dE1hcmtlcik6CihX ZWJDb3JlOjpBWFBvc2l0aW9uOjpvcGVyYXRvciBBWFRleHRNYXJrZXIgY29uc3QpOgooV2ViQ29y ZTo6QVhQb3NpdGlvbjo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpmaW5kT2Jq ZWN0V2l0aFJ1bnMpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6ZmluZFBvc2l0aW9uIGNvbnN0KToK KFdlYkNvcmU6OkFYUG9zaXRpb246OnJ1bkZyb21PZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhQ b3NpdGlvbjo6bGluZVJhbmdlIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYUG9zaXRpb24uaDogQWRkZWQuCihXZWJDb3JlOjpSdW5Gcm9tT2Zmc2V0Ojp0cmVlSUQgY29u c3QpOgooV2ViQ29yZTo6UnVuRnJvbU9mZnNldDo6b2JqZWN0SUQgY29uc3QpOgooV2ViQ29yZTo6 UnVuRnJvbU9mZnNldDo6cnVuIGNvbnN0KToKKFdlYkNvcmU6OlJ1bkZyb21PZmZzZXQ6OlJ1bkZy b21PZmZzZXQpOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6QVhQb3NpdGlvbik6CihXZWJDb3JlOjpB WFBvc2l0aW9uOjpudWxsUG9zaXRpb24pOgooV2ViQ29yZTo6QVhQb3NpdGlvbjo6dHJlZUlEIGNv bnN0KToKKFdlYkNvcmU6OkFYUG9zaXRpb246Om9iamVjdElEIGNvbnN0KToKKFdlYkNvcmU6OkFY UG9zaXRpb246Om9mZnNldCBjb25zdCk6CihXZWJDb3JlOjpBWFBvc2l0aW9uOjppc051bGwgY29u c3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcDoKKFdl YkNvcmU6OkFYVGV4dE1hcmtlclJhbmdlOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oOgooV2ViQ29yZTo6QVhUZXh0 TWFya2VyOjpvZmZzZXQgY29uc3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0UnVuLmg6IEFkZGVkLgooV2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpBWFRleHRSdW5MaW5l SUQpOgooV2ViQ29yZTo6QVhUZXh0UnVuTGluZUlEOjpkZWJ1Z0Rlc2NyaXB0aW9uIGNvbnN0KToK KFdlYkNvcmU6OkFYVGV4dFJ1bjo6QVhUZXh0UnVuKToKKFdlYkNvcmU6OkFYVGV4dFJ1bjo6ZGVi dWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRSdW5zOjpBWFRleHRSdW5zKToK KFdlYkNvcmU6OkFYVGV4dFJ1bnM6OnNpemUgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6 cnVuTGVuZ3RoIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6bGluZUlEIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4 dFJ1bnM6Om9wZXJhdG9yW10gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6ZGVidWdEZXNj cmlwdGlvbiBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmls aXR5T2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRyZWVJRCBjb25z dCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6 CihXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKFdlYkNvcmU6 OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcDoKKFdlYkNv cmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRP YmplY3Q6OnRleHRSdW5zIGNvbnN0KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0Lmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaDoKLS0tCiBTb3VyY2UvV2ViQ29yZS9I ZWFkZXJzLmNtYWtlICAgICAgICAgICAgICAgICAgfCAgIDIgKwogU291cmNlL1dlYkNvcmUvU291 cmNlcy50eHQgICAgICAgICAgICAgICAgICAgIHwgICAyICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiB8ICAxMiArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYQ29yZU9iamVjdC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhQb3NpdGlvbi5jcHAgICB8IDI5NiArKysrKysrKysrKysrKysrKysKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oICAgICB8ICA5OCArKysrKysKIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcCB8ICAgMiArLQogU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaCAgIHwgICAxICsKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcCAgICB8ICA5MyArKysrKysKIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDEyMCArKysrKysrCiAu Li4vYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcCAgICAgfCAgIDYgKwogLi4u L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oICAgICAgIHwgICA1ICsKIC4uLi9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCAgICAgICAgICAgICB8ICAgNiArLQogLi4uL2Fj Y2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIHwgICAyICstCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwICAgICAgICAgfCAgMzAgKysKIC4uLi9pc29s YXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oICAgICAgICAgICB8ICAxOCArLQogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAgICAgICAgICAgIHwgIDE3ICstCiAuLi4vaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmggICAgICAgICAgICAgfCAgMTkgKy0KIDE4IGZpbGVzIGNo YW5nZWQsIDcwMyBpbnNlcnRpb25zKCspLCA0NSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEw MDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwCiBjcmVhdGUg bW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmgKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5j cHAKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4 dFJ1bi5oCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZSBiL1NvdXJj ZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKaW5kZXggMWFlMTdhNTJkMDkxLi4xZjMyMTdkYTc3N2Ig MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dl YkNvcmUvSGVhZGVycy5jbWFrZQpAQCAtNjUxLDcgKzY1MSw5IEBAIHNldChXZWJDb3JlX1BSSVZB VEVfRlJBTUVXT1JLX0hFQURFUlMKICAgICBhY2Nlc3NpYmlsaXR5L0FYR2VvbWV0cnlNYW5hZ2Vy LmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYT2Jq ZWN0Q2FjaGUuaAorICAgIGFjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oCiAgICAgYWNjZXNzaWJp bGl0eS9BWFRleHRNYXJrZXIuaAorICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKICAgICBh Y2Nlc3NpYmlsaXR5L0FYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmgKICAgICBhY2Nlc3NpYmlsaXR5 L0FYVHJlZVN0b3JlLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlMaXN0Qm94LmgK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0IGIvU291cmNlL1dlYkNvcmUv U291cmNlcy50eHQKaW5kZXggMTc4NDc4ZGQ4YWJmLi5jOGJjNTZmNTgzMTggMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMu dHh0CkBAIC01MjEsNyArNTIxLDkgQEAgYWNjZXNzaWJpbGl0eS9BWEdlb21ldHJ5TWFuYWdlci5j cHAKIGFjY2Vzc2liaWxpdHkvQVhJbWFnZS5jcHAKIGFjY2Vzc2liaWxpdHkvQVhMb2dnZXIuY3Bw CiBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCithY2Nlc3NpYmlsaXR5L0FYUG9zaXRp b24uY3BwCiBhY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKK2FjY2Vzc2liaWxpdHkvQVhU ZXh0UnVuLmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWQuY3BwCiBhY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlBUklBR3JpZENlbGwuY3BwCiBhY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlBUklBR3JpZFJvdy5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA5ZTc1Y2YwOWU0NDIuLmNkZWVjNGJlYjM4 NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagpAQCAtMTc1MSw3ICsxNzUxLDkgQEAKIAkJNDdGOTQ3REIyNjUwMkYyRjAwODc5NjhDIC8q IEJsb2NrRm9ybWF0dGluZ1F1aXJrcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNDdGOTQ3REEyNjUwMkYyRjAwODc5NjhDIC8qIEJsb2NrRm9ybWF0dGlu Z1F1aXJrcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07 CiAJCTQ3RkE5NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGQTk2RkYy NjUwOTgyQTAwODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dlb21ldHJ5LmggKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDgyMjk3MEUyOUM4RUJDMDAw MzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0 LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJNDg2 MUUwQkYyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4NjFFMEJEMkIyMDA3NDUwMDBFNzAwRiAvKiBB WFBvc2l0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsg fTsKIAkJNDg2QjhEQzcyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0ODZCOERDNjJBMDQz QzA2MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyog QVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA0OEIwMjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDhCNUJGMzcyOUNBNjkxNzAwRkVC RTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNj ZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQk0OEQwRTEyOTI5RjczMjlFMDAyNjM4NTcgLyogRWxlbWVudEFu aW1hdGlvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4RDBFMTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4 dC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ5 MTM0MkUzMkI0M0ZGRUYwMEZFRUYxOCAvKiBDU1NTZWxlY3RvcklubGluZXMuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ5MTM0MkRBMkI0M0ZBQTgwMEZF RUYxOCAvKiBDU1NTZWxlY3RvcklubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9 IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTA3MjIsMTAgKzEwNzI0LDE0IEBACiAJCTQ3RkE5NkZG MjY1MDk4MkEwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk0ODIyOTcwQjI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9u Q29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZWdpb25D b250ZXh0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDgyMjk3MEMyOUM4RUJD MDAwMzNBMTI2IC8qIFJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gUmVnaW9uQ29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0ODYx RTBCRDJCMjAwNzQ1MDAwRTcwMEYgLyogQVhQb3NpdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBWFBv c2l0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4NjFFMEJFMkIyMDA3NDUw MDBFNzAwRiAvKiBBWFBvc2l0aW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEFYUG9zaXRpb24u Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0ODZCOERDNjJBMDQzQzA2MDBFMDBF NzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhHZW9tZXRyeU1hbmFn ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDg2QjhEQzgyQTA0NTAwRjAwRTAw RTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJNDhCMDI0MjgyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBBWFRleHRSdW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhCNUJGMzUy OUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0Lmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM2MjlDQTY5MTcwMEZFQkUzQiAvKiBB Y2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBY2Nlc3Np YmlsaXR5UmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ4 QzRFODNDMkIzNEQ4MzgwMDgzNDYwQSAvKiBBWFRleHRSdW4uY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gQVhUZXh0UnVuLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhEMEUxMjgy OUY3MzIyOTAwMjYzODU3IC8qIEVsZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IEVsZW1lbnRBbmltYXRpb25Db250ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ5MTM0Mjk2MkI0MjVDMDEwMEZFRUYxOCAvKiBDU1NQc2V1ZG9TZWxlY3RvcnMuanNvbiAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuanNv bjsgcGF0aCA9IENTU1BzZXVkb1NlbGVjdG9ycy5qc29uOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk0OTEzNDI5NzJCNDI1QzAyMDBGRUVGMTggLyogcHJvY2Vzcy1jc3MtcHNldWRvLXNl bGVjdG9ycy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlw ZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9ICJwcm9jZXNzLWNzcy1wc2V1ZG8tc2VsZWN0 b3JzLnB5Ijsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIzMTk2LDggKzIzMjAyLDEy IEBACiAJCQkJQzA0OTNFQjcyNDQ2OTlFNDAwOUFBQzgwIC8qIEFYTG9nZ2VyLmggKi8sCiAJCQkJ Mjk4MUNBQUYxMzE4MjJFQzAwRDEyRjJBIC8qIEFYT2JqZWN0Q2FjaGUuY3BwICovLAogCQkJCTI5 QTgxMjFBMEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9iamVjdENhY2hlLmggKi8sCisJCQkJNDg2MUUw QkUyQjIwMDc0NTAwMEU3MDBGIC8qIEFYUG9zaXRpb24uY3BwICovLAorCQkJCTQ4NjFFMEJEMkIy MDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmggKi8sCiAJCQkJQzBFMjA4QTEyOTM3OUM2RjAw QzBEMkQzIC8qIEFYVGV4dE1hcmtlci5jcHAgKi8sCiAJCQkJQzBFMjA4QTAyOTM3OUM2RTAwQzBE MkQzIC8qIEFYVGV4dE1hcmtlci5oICovLAorCQkJCTQ4QzRFODNDMkIzNEQ4MzgwMDgzNDYwQSAv KiBBWFRleHRSdW4uY3BwICovLAorCQkJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRl eHRSdW4uaCAqLywKIAkJCQk5MUM5RjJGODFBRTNCRTI0MDA5NUI2MUMgLyogQVhUZXh0U3RhdGVD aGFuZ2VJbnRlbnQuaCAqLywKIAkJCQlDMEU4QURDNDI5NEI1QTYyMDA3NkNCREMgLyogQVhUcmVl U3RvcmUuaCAqLywKIAkJCQlCQzRBNTMzMDI1NjA1OTAzMDAyOEM1OTIgLyogRm9yY2VkQWNjZXNz aWJpbGl0eVZhbHVlLmggKi8sCkBAIC0zNzU5Miw3ICszNzYwMiw5IEBACiAJCQkJMjlBRTIxMzUy MUFCQTQ4QTAwODY5MjgzIC8qIEFYSXNvbGF0ZWRPYmplY3QuaCBpbiBIZWFkZXJzICovLAogCQkJ CTI5QUUyMTJEMjFBQjlFRUIwMDg2OTI4MyAvKiBBWElzb2xhdGVkVHJlZS5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJMjlBODEyMzgwRkJCOUMxRDAwNTEwMjkzIC8qIEFYT2JqZWN0Q2FjaGUuaCBpbiBI ZWFkZXJzICovLAorCQkJCTQ4NjFFMEJGMkIyMDA3NDUwMDBFNzAwRiAvKiBBWFBvc2l0aW9uLmgg aW4gSGVhZGVycyAqLywKIAkJCQlDMEUyMDhBMjI5Mzc5QzZGMDBDMEQyRDMgLyogQVhUZXh0TWFy a2VyLmggaW4gSGVhZGVycyAqLywKKwkJCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyogQVhU ZXh0UnVuLmggaW4gSGVhZGVycyAqLywKIAkJCQk5MUM5RjJGOTFBRTNCRUIwMDA5NUI2MUMgLyog QVhUZXh0U3RhdGVDaGFuZ2VJbnRlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUMwRThBREM1Mjk0 QjVBNjMwMDc2Q0JEQyAvKiBBWFRyZWVTdG9yZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQ3N0U3 NzcwQkY0MTM0QTAwMTUyODcyIC8qIEJhY2tGb3J3YXJkQ2FjaGUuaCBpbiBIZWFkZXJzICovLApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaCBi L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgKaW5kZXggN2QxOGY1 MjEyNjk1Li45NDMyZGVkNmE4NWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhDb3JlT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WENvcmVPYmplY3QuaApAQCAtMTEzLDE5ICsxMTMsNiBAQCBlbnVtIGNsYXNzIEFYQW5jZXN0b3JG bGFnIDogdWludDhfdCB7CiAgICAgLy8gQml0IDcgaXMgZnJlZS4KIH07CiAKLSNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAgIC8vIFRoZSBsaW5l IGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUgY29udGFpbmluZyBS ZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4KLSAgICBzaXplX3Qg bGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVuKHNpemVfdCBsaW5l SW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxpbmVJbmRleCkKLSAg ICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2VuZGlmCi0KIGVudW0g Y2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0gMSwKICAgICBBcHBs aWNhdGlvbkFsZXJ0LApAQCAtNjU2LDYgKzY0Myw4IEBAIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0 eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3MgQVhEaXJlY3Rpb24g OiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nlc3NpYmlsaXR5U29y dERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04MDMsNiArNzkyLDcg QEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQpIHsgbV9pZCA9IGF4 SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9pZDsgfQorICAgIHZp cnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQcm9jZXNzSUQgcHJv Y2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVzcG9uZGluZyBXZWJD b3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTExMDcsOSArMTA5Nyw2 IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRleHQoVmVjdG9yPEFj Y2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dyYW1tYXRpYyB3YXkg dG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZpcnR1YWwgdm9pZCBz ZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lmIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMo KSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJpbmcgdGl0bGUoKSBj b25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBjb25zdCA9IDA7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYUG9zaXRpb24uY3BwIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFBvc2l0aW9uLmNwcApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjNhNTdiZDJhNGIzMQotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5jcHAKQEAgLTAsMCAr MSwyOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S CisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgor ICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQVhQ b3NpdGlvbi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisKKyNpbmNsdWRl ICJBWElzb2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhJc29sYXRlZFRyZWUuaCIKKyNpbmNs dWRlICJBWE9iamVjdENhY2hlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworQVhJc29sYXRl ZE9iamVjdCogQVhQb3NpdGlvbjo6b2JqZWN0KCkgY29uc3QKK3sKKyAgICBSRUxFQVNFX0FTU0VS VCghaXNNYWluVGhyZWFkKCkpOworICAgIGlmIChtX2NhY2hlZE9iamVjdCkKKyAgICAgICAgcmV0 dXJuIG1fY2FjaGVkT2JqZWN0LmdldCgpOworCisgICAgaWYgKCFtX3RyZWVJRC5pc1ZhbGlkKCkg fHwgIW1fb2JqZWN0SUQuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAg IGF1dG8gdHJlZSA9IHN0ZDo6Z2V0PFJlZlB0cjxBWElzb2xhdGVkVHJlZT4+KGF4VHJlZUZvcklE KHRyZWVJRCgpKSk7CisgICAgbV9jYWNoZWRPYmplY3QgPSB0cmVlID8gdHJlZS0+b2JqZWN0Rm9y SUQob2JqZWN0SUQoKSkgOiBudWxscHRyOworICAgIHJldHVybiBtX2NhY2hlZE9iamVjdC5nZXQo KTsKK30KKworY29uc3QgQVhUZXh0UnVucyogQVhQb3NpdGlvbjo6cnVucygpIGNvbnN0Cit7Cisg ICAgYXV0byogb2JqZWN0ID0gdGhpcy0+b2JqZWN0KCk7CisgICAgcmV0dXJuIG9iamVjdCA/IG9i amVjdC0+dGV4dFJ1bnMoKSA6IG51bGxwdHI7Cit9CisKK1N0cmluZyBBWFBvc2l0aW9uOjpkZWJ1 Z0Rlc2NyaXB0aW9uKCkgY29uc3QKK3sKKyAgICBhdXRvIHNlcGFyYXRvciA9ICIsICI7CisgICAg UmVmUHRyIG9iamVjdCA9IHRoaXMtPm9iamVjdCgpOworICAgIHJldHVybiBtYWtlU3RyaW5nKAor ICAgICAgICAidHJlZUlEICIsIHRyZWVJRCgpLmxvZ2dpbmdTdHJpbmcoKQorICAgICAgICAsIHNl cGFyYXRvciwgIm9iamVjdElEICIsIG9iamVjdElEKCkubG9nZ2luZ1N0cmluZygpCisgICAgICAg ICwgc2VwYXJhdG9yLCAicm9sZSAiLCBvYmplY3QgPyBhY2Nlc3NpYmlsaXR5Um9sZVRvU3RyaW5n KG9iamVjdC0+cm9sZVZhbHVlKCkpIDogU3RyaW5nKCJubyBvYmplY3QiX3MpCisgICAgICAgICwg c2VwYXJhdG9yLCAib2Zmc2V0ICIsIG1fb2Zmc2V0CisgICAgKTsKK30KKworZW51bSBjbGFzcyBD aGVja1N0YXJ0IDogYm9vbCB7IE5vLCBZZXMgfTsKKy8vIEZpbmRzIHRoZSBuZXh0IG9iamVjdCB3 aXRoIHRleHQgcnVucyBpbiB0aGUgZ2l2ZW4gZGlyZWN0aW9uLgorc3RhdGljIFJlZlB0cjxBWElz b2xhdGVkT2JqZWN0PiBmaW5kT2JqZWN0V2l0aFJ1bnMoQVhJc29sYXRlZE9iamVjdCYgc3RhcnQs IEFYRGlyZWN0aW9uIGRpcmVjdGlvbiwgQ2hlY2tTdGFydCBjaGVja1N0YXJ0ID0gQ2hlY2tTdGFy dDo6Tm8pCit7CisgICAgaWYgKGNoZWNrU3RhcnQgPT0gQ2hlY2tTdGFydDo6WWVzKSB7CisgICAg ICAgIGlmIChhdXRvKiBydW5zID0gc3RhcnQudGV4dFJ1bnMoKTsgcnVucyAmJiBydW5zLT5zaXpl KCkpCisgICAgICAgICAgICByZXR1cm4gJnN0YXJ0OworICAgIH0KKworICAgIFJlZlB0ciBjdXJy ZW50ID0gJnN0YXJ0OworICAgIHdoaWxlIChjdXJyZW50KSB7CisgICAgICAgIGlmIChjdXJyZW50 ICE9ICZzdGFydCkgeworICAgICAgICAgICAgYXV0byogcnVucyA9IGN1cnJlbnQtPnRleHRSdW5z KCk7CisgICAgICAgICAgICBpZiAocnVucyAmJiBydW5zLT5zaXplKCkpCisgICAgICAgICAgICAg ICAgcmV0dXJuIGN1cnJlbnQ7CisgICAgICAgIH0KKworICAgICAgICAvLyBGSVhNRTogYXJpYS1v d25zIGJyZWFrcyB0aGlzIHRyYXZlcnNhbCwgYXMgYXJpYS1vd25zIGNhdXNlcyB0aGUgQVggdHJl ZSB0byBiZSBjaGFuZ2VkLCBhZmZlY3RpbmcKKyAgICAgICAgLy8gb3VyIGl0ZXJhdGlvbiBiZWxv dywgYnV0IGl0IGRvZXNuJ3QgYWN0dWFsbHkgY2hhbmdlIHRleHQgcG9zaXRpb24gb24gdGhlIHBh Z2UuIFNvIHdlIG5lZWQgdG8gaWdub3JlIGFyaWEtb3ducworICAgICAgICAvLyB0cmVlIGNoYW5n ZXMgaGVyZSBpbiBvcmRlciB0byBiZWhhdmUgY29ycmVjdGx5LgorICAgICAgICAvLyBXZSBhbHNv IHByb2JhYmx5IG5lZWQgdG8gZG8gc29tZXRoaW5nIGFib3V0IHRleHQgd2l0aGluIGFyaWEtaGlk ZGVuIGNvbnRhaW5lcnMsIHdoaWNoIGFmZmVjdHMgdGhlIEFYIHRyZWUuCisKKyAgICAgICAgY29u c3QgYXV0byYgY2hpbGRyZW4gPSBjdXJyZW50LT5jaGlsZHJlbigpOworICAgICAgICBpZiAoY2hp bGRyZW4uc2l6ZSgpKSB7CisgICAgICAgICAgICBzaXplX3QgY2hpbGRJbmRleCA9IGRpcmVjdGlv biA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IDAgOiBjaGlsZHJlbi5zaXplKCkgLSAxOworICAgICAg ICAgICAgUkVMRUFTRV9BU1NFUlQoY2hpbGRyZW5bY2hpbGRJbmRleF0pOworICAgICAgICAgICAg Y3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0PihjaGlsZHJlbltjaGls ZEluZGV4XS5nZXQoKSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAg ICAgIC8vIGBjdXJyZW50YCBoYXMgbm8gY2hpbGRyZW4sIG1lYW5pbmcgaXQncyBhIGxlYWYgbm9k ZSAoZS5nLiBpdCdzIHRleHQsIHdoaWNoIGNhbm5vdCBoYXZlIGNoaWxkcmVuKS4KKyAgICAgICAg Ly8gQ2hlY2sgYGN1cnJlbnRgcyBzaWJsaW5ncy4KKyAgICAgICAgaWYgKGF1dG8qIHNpYmxpbmcg PSBjdXJyZW50LT5zaWJsaW5nKGRpcmVjdGlvbikpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBk eW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oc2libGluZyk7CisgICAgICAgICAgICBj b250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFdlIGhhdmUgbm8gY2hpbGRyZW4sIGFu ZCBubyBuZXh0L3ByZXZpb3VzIHNpYmxpbmcuIFRyeSBvdXIgcGFyZW50J3Mgc2libGluZy4KKyAg ICAgICAgaWYgKGF1dG8qIHBhcmVudCA9IGN1cnJlbnQtPnBhcmVudE9iamVjdFVuaWdub3JlZCgp KSB7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmpl Y3Q+KHBhcmVudC0+c2libGluZyhkaXJlY3Rpb24pKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICB9CisKKyAgICAgICAgYnJlYWs7CisgICAgfQorICAgIHJldHVybiBudWxscHRyOwor fQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZpbmRQb3NpdGlvbihBWERpcmVjdGlvbiBkaXJl Y3Rpb24pIGNvbnN0Cit7CisgICAgaWYgKGlzTnVsbCgpKQorICAgICAgICByZXR1cm4gbnVsbFBv c2l0aW9uKCk7CisgICAgaWYgKCFpc1RleHRMZWFmKCkpCisgICAgICAgIHJldHVybiBhc1RleHRM ZWFmUG9zaXRpb24oKS5maW5kUG9zaXRpb24oZGlyZWN0aW9uKTsKKyAgICBSRUxFQVNFX0FTU0VS VChpc1RleHRMZWFmKCkpOworCisgICAgc2l6ZV90IHJ1bkluZGV4ID0gcnVuSW5kZXhGcm9tT2Zm c2V0KCk7CisgICAgYXV0byBoYXNNb3JlVGV4dEluQ3VycmVudFJ1biA9IFsmXSB7CisgICAgICAg IGlmIChkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5leHQpCisgICAgICAgICAgICByZXR1cm4g bV9vZmZzZXQgPCBydW5zKCktPmF0KHJ1bkluZGV4KS50ZXh0Lmxlbmd0aCgpOworICAgICAgICBy ZXR1cm4gbV9vZmZzZXQgPiAwOworICAgIH07CisgICAgYm9vbCBoYXNBbm90aGVyUnVuID0gcnVu SW5kZXggKyAxIDwgcnVucygpLT5zaXplKCk7CisgICAgLy8gVGhlIG5leHQgcnVuIHNob3VsZCBu b3QgaGF2ZSBlbXB0eSB0ZXh0LCBiZWNhdXNlIHdlJ3JlIGdvaW5nIHRvIHJldHVybiBhIHBvc2l0 aW9uIGNvbnRhaW5pbmcgbV9vZmZzZXQgKyAxLCB3aGljaCB3b3VsZCBiZSB3cm9uZy4KKyAgICBS RUxFQVNFX0FTU0VSVChkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246OlByZXZpb3VzIHx8ICFoYXNB bm90aGVyUnVuIHx8IHJ1bnMoKS0+cnVuTGVuZ3RoKHJ1bkluZGV4ICsgMSkgPiAwKTsKKyAgICAv LyBDaGVja2luZyBmb3IgdGhlIHByZXNlbmNlIG9mIGFub3RoZXIgcnVuIGlzIG9ubHkgcmVsZXZh bnQgZm9yIG1vdmluZyBBWERpcmVjdGlvbjo6TmV4dCwgYXMganVzdCBjaGVja2luZyB0aGF0IG1f b2Zmc2V0ID4gMCBpcyBzdWZmaWNpZW50IGZvciBBWERpcmVjdGlvbjo6UHJldmlvdXMuCisgICAg aWYgKGhhc01vcmVUZXh0SW5DdXJyZW50UnVuKCkgfHwgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlv bjo6TmV4dCAmJiBoYXNBbm90aGVyUnVuKSkgeworICAgICAgICAvLyBSZXR1cm4gYW4gb2Zmc2V0 IHRvIHRoZSBuZXh0IGNoYXJhY3RlciBpbiB0aGUgY3VycmVudCBydW4uCisgICAgICAgIHJldHVy biBBWFBvc2l0aW9uKG1fdHJlZUlELCBtX29iamVjdElELCBkaXJlY3Rpb24gPT0gQVhEaXJlY3Rp b246Ok5leHQgPyBtX29mZnNldCArIDEgOiBtX29mZnNldCAtIDEpOworICAgIH0KKyAgICAvLyBt X29mZnNldCBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3RlciBpbiB0aGUgZ2l2ZW4gb2JqZWN0 J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0aGUgbmV4dCBvYmplY3Qgd2l0aCBy dW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9iamVjdFdpdGhSdW5zKCp0aGlzLT5v YmplY3QoKSwgZGlyZWN0aW9uKSkKKyAgICAgICAgcmV0dXJuIEFYUG9zaXRpb24ob2JqZWN0LT50 cmVlSUQoKSwgb2JqZWN0LT5vYmplY3RJRCgpLCBkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5l eHQgPyAwIDogb2JqZWN0LT50ZXh0UnVucygpLT5sYXN0UnVuTGVuZ3RoKCkpOworCisgICAgcmV0 dXJuIG51bGxQb3NpdGlvbigpOworfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmZpbmRQb3Np dGlvbihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4dFVuaXQsIEFYVGV4dFVu aXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAg IHJldHVybiBudWxsUG9zaXRpb24oKTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAgICAgICAg cmV0dXJuIGFzVGV4dExlYWZQb3NpdGlvbigpLmZpbmRQb3NpdGlvbihkaXJlY3Rpb24sIHRleHRV bml0LCBib3VuZGFyeSk7CisgICAgUkVMRUFTRV9BU1NFUlQoaXNUZXh0TGVhZigpKTsKKworICAg IGlmICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7CisgICAgICAgIHNpemVfdCBydW5J bmRleCA9IHJ1bkluZGV4RnJvbU9mZnNldCgpOworICAgICAgICBSZWZQdHIgY3VycmVudE9iamVj dCA9IG9iamVjdCgpOworICAgICAgICBjb25zdCBhdXRvKiBjdXJyZW50UnVucyA9IGN1cnJlbnRP YmplY3QtPnRleHRSdW5zKCk7CisKKyAgICAgICAgYXV0byBjb21wdXRlT2Zmc2V0ID0gWyZdIChz aXplX3QgcnVuRW5kT2Zmc2V0LCBzaXplX3QgcnVuTGVuZ3RoKSB7CisgICAgICAgICAgICAvLyBU aGlzIHdvcmtzIGJlY2F1c2UgYHJ1bkVuZE9mZnNldGAgaXMgdGhlIG9mZnNldCBwb2ludGluZyB0 byB0aGUgZW5kIG9mIHRoZSBnaXZlbiBydW4sIHdoaWNoIGluY2x1ZGVzIHRoZSBsZW5ndGggb2Yg YWxsIHJ1bnMgcHJlY2VkaW5nIGl0LiBTbyBzdWJ0cmFjdGluZyB0aGF0IGZyb20gdGhlIGxlbmd0 aCBvZiB0aGUgY3VycmVudCBydW4gZ2l2ZXMgdXMgYW4gb2Zmc2V0IHRvIHRoZSBzdGFydCBvZiB0 aGUgY3VycmVudCBydW4uCisgICAgICAgICAgICByZXR1cm4gYm91bmRhcnkgPT0gQVhUZXh0VW5p dEJvdW5kYXJ5OjpFbmQgPyBydW5FbmRPZmZzZXQgOiBydW5FbmRPZmZzZXQgLSBydW5MZW5ndGg7 CisgICAgICAgIH07CisgICAgICAgIGF1dG8gbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihtX3Ry ZWVJRCwgbV9vYmplY3RJRCwgY29tcHV0ZU9mZnNldChjdXJyZW50UnVucy0+cnVuTGVuZ3RoU3Vt VG8ocnVuSW5kZXgpLCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKHJ1bkluZGV4KSkpOworICAgICAg ICBhdXRvIHN0YXJ0TGluZUlEID0gY3VycmVudFJ1bnMtPmxpbmVJRChydW5JbmRleCk7CisgICAg ICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0ZWQgbGluZSwgbm93IGl0 ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAgICAgIHdoaWxlIChjdXJy ZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjdXJyZW50UnVucy0+c2l6 ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZzZXQgPSAwOworICAgICAg ICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+c2l6ZSgpOyBpKyspIHsK KyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5zLT5ydW5MZW5n dGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5saW5lSUQoaSkgIT0gc3Rh cnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAg ICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhQb3NpdGlvbihjdXJyZW50T2JqZWN0LT50cmVl SUQoKSwgY3VycmVudE9iamVjdC0+b2JqZWN0SUQoKSwgY29tcHV0ZU9mZnNldChjdW11bGF0aXZl T2Zmc2V0LCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKGkpKSk7CisgICAgICAgICAgICB9CisgICAg ICAgICAgICBjdXJyZW50T2JqZWN0ID0gZmluZE9iamVjdFdpdGhSdW5zKCpjdXJyZW50T2JqZWN0 LCBkaXJlY3Rpb24pOworICAgICAgICAgICAgaWYgKGN1cnJlbnRPYmplY3QpCisgICAgICAgICAg ICAgICAgY3VycmVudFJ1bnMgPSBjdXJyZW50T2JqZWN0LT50ZXh0UnVucygpOworICAgICAgICB9 CisgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAgfQorICAgIC8vIEZJWE1FOiBJbXBs ZW1lbnQgdGhlIG90aGVyIEFYVGV4dFVuaXRzLgorCisgICAgcmV0dXJuIG51bGxQb3NpdGlvbigp OworfQorCitBWFBvc2l0aW9uIEFYUG9zaXRpb246OmFzVGV4dExlYWZQb3NpdGlvbigpIGNvbnN0 Cit7CisgICAgaWYgKGlzTnVsbCgpIHx8IGlzVGV4dExlYWYoKSkgeworICAgICAgICAvLyBJZiBz b21ldGhpbmcgaGFzIGNvbnN0cnVjdGVkIGEgbGVhZiBwb3NpdGlvbiwgaXQgc2hvdWxkJ3ZlIGRv bmUgc28gd2l0aCBhbiBpbi1ib3VuZHMgb2Zmc2V0LgorICAgICAgICBSRUxFQVNFX0FTU0VSVChp c051bGwoKSB8fCBvYmplY3QoKS0+dGV4dFJ1bnMoKS0+cnVuTGVuZ3RoU3VtKCkgPj0gbV9vZmZz ZXQpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgLy8gRmluZCB0aGUgbGVh ZiBub2RlIG91ciBvZmZzZXQgcG9pbnRzIHRvLiBGb3IgZXhhbXBsZToKKyAgICAvLyBBWFBvc2l0 aW9uIHsgSUQgMTogR3JvdXAsIE9mZnNldCA2IH0KKyAgICAvLyBJRCAxOiBHcm91cAorICAgIC8v ICAtIElEIDI6IEZvbworICAgIC8vICAtIElEIDM6IExpbmUxCisgICAgLy8gICAgICAgICAgTGlu ZTIKKyAgICAvLyBDYWxsaW5nIGFzVGV4dExlYWZQb3NpdGlvbigpIG9uIHRoZSBvcmlnaW5hbCBw b3NpdGlvbiBzaG91bGQgeWllbGQgbmV3IHBvc2l0aW9uOgorICAgIC8vIEFYUG9zaXRpb24geyBJ RCAzOiBTdGF0aWNUZXh0LCBPZmZzZXQgMyB9CisgICAgLy8gQmVjYXVzZSB3ZSBoYWQgdG8gd2Fs ayBvdmVyIElEIDIgd2hpY2ggaGFkIGxlbmd0aCAzIHRleHQuCisgICAgc2l6ZV90IHByZWNlZGlu Z09mZnNldCA9IDA7CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKm9i amVjdCgpLCBBWERpcmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAgICB3aGlsZSAo Y3VycmVudCkgeworICAgICAgICB1bnNpZ25lZCBjdXJyZW50U3VtID0gY3VycmVudC0+dGV4dFJ1 bnMoKS0+cnVuTGVuZ3RoU3VtKCk7CisgICAgICAgIGlmIChwcmVjZWRpbmdPZmZzZXQgKyBjdXJy ZW50U3VtID49IG1fb2Zmc2V0KQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIHByZWNlZGlu Z09mZnNldCArPSBjdXJyZW50U3VtOworICAgICAgICBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhS dW5zKCpjdXJyZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgfQorCisgICAgaWYgKCFjdXJy ZW50KQorICAgICAgICByZXR1cm4gbnVsbFBvc2l0aW9uKCk7CisKKyAgICBSRUxFQVNFX0FTU0VS VChtX29mZnNldCA+PSBwcmVjZWRpbmdPZmZzZXQpOworICAgIHJldHVybiBBWFBvc2l0aW9uKGN1 cnJlbnQtPnRyZWVJRCgpLCBjdXJyZW50LT5vYmplY3RJRCgpLCBtX29mZnNldCAtIHByZWNlZGlu Z09mZnNldCk7Cit9CisKK2Jvb2wgQVhQb3NpdGlvbjo6aXNUZXh0TGVhZigpIGNvbnN0Cit7Cisg ICAgYXV0byogb2JqZWN0ID0gdGhpcy0+b2JqZWN0KCk7CisgICAgLy8gRklYTUU6IElzIGl0IHBv c3NpYmxlIGZvciBub24tbGVhZiBub2RlcyB0byBoYXZlIHRleHQgcnVucz8gSWYgc28sIHdlIGRv bid0IGhhbmRsZSB0aGVtIGNvcnJlY3RseS4KKyAgICByZXR1cm4gIW9iamVjdCB8fCAoIW9iamVj dC0+Y2hpbGRyZW4oKS5zaXplKCkgJiYgb2JqZWN0LT50ZXh0UnVucygpKTsKK30KKworc2l6ZV90 IEFYUG9zaXRpb246OnJ1bkluZGV4RnJvbU9mZnNldCgpIGNvbnN0Cit7CisgICAgYXV0byogcnVu cyA9IHRoaXMtPnJ1bnMoKTsKKyAgICBpZiAoIXJ1bnMpCisgICAgICAgIHJldHVybiBub3RGb3Vu ZDsKKworICAgIHNpemVfdCBpbmRleCA9IHJ1bnMtPmluZGV4Rm9yT2Zmc2V0KG1fb2Zmc2V0KTsK KyAgICAvLyBJZiB3ZSBjb3VsZG4ndCBmaW5kIGEgY29ycmVzcG9uZGluZyBydW4sIHRoYXQgbWVh bnMgbV9vZmZzZXQgcG9pbnRlZCBvdXQgb2YgYm91bmRzIG9mIG91ciB0ZXh0IHJ1bnMsIHdoaWNo CisgICAgLy8gd291bGQgb25seSBoYXBwZW4gaWYgd2UndmUgY29uc3RydWN0ZWQgYW4gaW52YWxp ZCBwb3NpdGlvbi4KKyAgICBSRUxFQVNFX0FTU0VSVChpbmRleCAhPSBub3RGb3VuZCk7CisgICAg cmV0dXJuIGluZGV4OworfQorCitBWFRleHRNYXJrZXJSYW5nZSBBWFBvc2l0aW9uOjpsaW5lUmFu Z2UoTGluZVJhbmdlVHlwZSB0eXBlKSBjb25zdAoreworICAgIGlmIChpc051bGwoKSkKKyAgICAg ICAgcmV0dXJuIHsgbnVsbFBvc2l0aW9uKCksIG51bGxQb3NpdGlvbigpIH07CisKKyAgICBpZiAo dHlwZSA9PSBMaW5lUmFuZ2VUeXBlOjpDdXJyZW50KQorICAgICAgICByZXR1cm4geyBmaW5kUG9z aXRpb24oQVhEaXJlY3Rpb246OlByZXZpb3VzLCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0 Qm91bmRhcnk6OlN0YXJ0KSwgZmluZFBvc2l0aW9uKEFYRGlyZWN0aW9uOjpOZXh0LCBBWFRleHRV bml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6OkVuZCkgfTsKKyAgICAvLyBUaGUgb3RoZXIg dHlwZXMgYXJlbid0IGltcGxlbWVudGVkIHlldC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVB Q0hFRCgpOworfQorCitTdHJpbmcgQVhQb3NpdGlvbjo6c3Vic3RyaW5nKHVuc2lnbmVkIHN0YXJ0 LCB1bnNpZ25lZCBsZW5ndGgpIGNvbnN0Cit7CisgICAgaWYgKGlzTnVsbCgpKQorICAgICAgICBy ZXR1cm4gZW1wdHlTdHJpbmcoKTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAgICAgICAgcmV0 dXJuIGFzVGV4dExlYWZQb3NpdGlvbigpLnN1YnN0cmluZyhzdGFydCwgbGVuZ3RoKTsKKyAgICBS RUxFQVNFX0FTU0VSVChpc1RleHRMZWFmKCkpOworICAgIHJldHVybiBydW5zKCktPnN1YnN0cmlu ZyhzdGFydCwgbGVuZ3RoKTsKK30KKworU3RyaW5nIEFYUG9zaXRpb246OnN0cmluZ1dpdGhFbmQo Y29uc3QgQVhQb3NpdGlvbiYgZW5kUG9zaXRpb24pCit7CisgICAgaWYgKGlzTnVsbCgpKQorICAg ICAgICByZXR1cm4gZW1wdHlTdHJpbmcoKTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAgICAg ICAgcmV0dXJuIGFzVGV4dExlYWZQb3NpdGlvbigpLnN0cmluZ1dpdGhFbmQoZW5kUG9zaXRpb24p OworICAgIFJFTEVBU0VfQVNTRVJUKGlzVGV4dExlYWYoKSk7CisgICAgYXV0byBlbmRMZWFmUG9z aXRpb24gPSBlbmRQb3NpdGlvbi5hc1RleHRMZWFmUG9zaXRpb24oKTsKKworICAgIGlmIChvYmpl Y3QoKSA9PSBlbmRMZWFmUG9zaXRpb24ub2JqZWN0KCkpIHsKKyAgICAgICAgc2l6ZV90IG1pbk9m ZnNldCA9IHN0ZDo6bWluKG1fb2Zmc2V0LCBlbmRMZWFmUG9zaXRpb24ub2Zmc2V0KCkpOworICAg ICAgICBzaXplX3QgbWF4T2Zmc2V0ID0gc3RkOjptYXgobV9vZmZzZXQsIGVuZExlYWZQb3NpdGlv bi5vZmZzZXQoKSk7CisgICAgICAgIHJldHVybiBzdWJzdHJpbmcobWluT2Zmc2V0LCBtYXhPZmZz ZXQgLSBtaW5PZmZzZXQpOworICAgIH0KKworICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAg IHJlc3VsdC5hcHBlbmQoc3Vic3RyaW5nKG1fb2Zmc2V0KSk7CisKKyAgICAvLyBGSVhNRTogSWYg d2UndmUgYmVlbiBnaXZlbiByZXZlcnNlZCBwb3NpdGlvbnMsIGkuZS4gdGhlIGVuZCBwb3NpdGlv biBhY3R1YWxseSBjb21lcyBiZWZvcmUgdGhlIHN0YXJ0IHBvc2l0aW9uLAorICAgIC8vIHdlIG1h eSB3YW50IHRvIGRldGVjdCB0aGlzIGFuZCB0cnkgc2VhcmNoaW5nIEFYRGlyZWN0aW9uOjpQcmV2 aW91cz8KKyAgICBSZWZQdHIgY3VycmVudCA9IG9iamVjdCgpOworICAgIHdoaWxlIChjdXJyZW50 LT5vYmplY3RJRCgpICE9IGVuZExlYWZQb3NpdGlvbi5vYmplY3RJRCgpKSB7CisgICAgICAgIGN1 cnJlbnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnQsIEFYRGlyZWN0aW9uOjpOZXh0KTsK KyAgICAgICAgaWYgKCFjdXJyZW50KQorICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY29u c3QgYXV0byogcnVucyA9IGN1cnJlbnQtPnRleHRSdW5zKCk7CisgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBydW5zLT5zaXplKCk7IGkrKykKKyAgICAgICAgICAgIHJlc3VsdC5hcHBl bmQocnVucy0+YXQoaSkudGV4dCk7CisgICAgfQorICAgIHJlc3VsdC5hcHBlbmQoZW5kTGVhZlBv c2l0aW9uLnN1YnN0cmluZygwLCBlbmRMZWFmUG9zaXRpb24ub2Zmc2V0KCkpKTsKKyAgICByZXR1 cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRp ZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhQb3NpdGlvbi5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWFBvc2l0aW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li41ZTU3NDRjZWViNmQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYUG9zaXRpb24uaApAQCAtMCwwICsxLDk4IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRP UlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdt YSBvbmNlCisKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyNpbmNsdWRlICJBWElz b2xhdGVkT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0TWFya2VyLmgiCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworZW51bSBjbGFzcyBBWFRleHRVbml0IDogdWludDhfdCB7CisgICAgTGluZSwK KyAgICBQYXJhZ3JhcGgsCisgICAgU2VudGVuY2UsCisgICAgV29yZCwKK307CitlbnVtIGNsYXNz IEFYVGV4dFVuaXRCb3VuZGFyeSA6IGJvb2wgeyBTdGFydCwgRW5kLCB9OworCitlbnVtIGNsYXNz IExpbmVSYW5nZVR5cGUgOiB1aW50OF90IHsKKyAgICBDdXJyZW50LAorICAgIExlZnQsCisgICAg UmlnaHQsCit9OworCitjbGFzcyBBWFBvc2l0aW9uIHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBB WFBvc2l0aW9uKEFYSUQgdHJlZUlELCBBWElEIG9iamVjdElELCB1bnNpZ25lZCBvZmZzZXQpCisg ICAgICAgIDogbV90cmVlSUQodHJlZUlEKQorICAgICAgICAsIG1fb2JqZWN0SUQob2JqZWN0SUQp CisgICAgICAgICwgbV9vZmZzZXQob2Zmc2V0KQorICAgIHsgfQorICAgIEFYUG9zaXRpb24oY29u c3QgQVhUZXh0TWFya2VyJiBtYXJrZXIpCisgICAgICAgIDogbV90cmVlSUQobWFya2VyLnRyZWVJ RCgpKQorICAgICAgICAsIG1fb2JqZWN0SUQobWFya2VyLm9iamVjdElEKCkpCisgICAgICAgICwg bV9vZmZzZXQobWFya2VyLmNoYXJhY3Rlck9mZnNldCgpKQorICAgIHsgfQorICAgIHN0YXRpYyBB WFBvc2l0aW9uIG51bGxQb3NpdGlvbigpIHsgcmV0dXJuIEFYUG9zaXRpb24oQVhJRCgpLCBBWElE KCksIDApOyB9CisKKyAgICBvcGVyYXRvciBBWFRleHRNYXJrZXIoKSBjb25zdAorICAgIHsKKyAg ICAgICAgcmV0dXJuIHsgeyB0cmVlSUQoKSwgb2JqZWN0SUQoKSwgbnVsbHB0ciwgbV9vZmZzZXQg fSB9OworICAgIH0KKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0OworCisgICAg Ly8gRmluZCB0aGUgbmV4dCBvciBwcmV2aW91cyBwb3NpdGlvbi4KKyAgICBBWFBvc2l0aW9uIGZp bmRQb3NpdGlvbihBWERpcmVjdGlvbikgY29uc3Q7CisgICAgLy8gU3RhcnRpbmcgZnJvbSB0aGlz IHBvc2l0aW9uLCBjcmVhdGVzIGEgbmV3IHBvc2l0aW9uIGZvciB0aGUgZ2l2ZW4gZGlyZWN0aW9u IGFuZCB0ZXh0IHVuaXQgdHlwZS4KKyAgICBBWFBvc2l0aW9uIGZpbmRQb3NpdGlvbihBWERpcmVj dGlvbiwgQVhUZXh0VW5pdCwgQVhUZXh0VW5pdEJvdW5kYXJ5KSBjb25zdDsKKyAgICBBWFRleHRN YXJrZXJSYW5nZSBsaW5lUmFuZ2UoTGluZVJhbmdlVHlwZSkgY29uc3Q7CisgICAgU3RyaW5nIHN0 cmluZ1dpdGhFbmQoY29uc3QgQVhQb3NpdGlvbiYpOworCitwcml2YXRlOgorICAgIEFYSUQgdHJl ZUlEKCkgY29uc3QgeyByZXR1cm4gbV90cmVlSUQ7IH0KKyAgICBBWElEIG9iamVjdElEKCkgY29u c3QgeyByZXR1cm4gbV9vYmplY3RJRDsgfQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNvbnN0IHsg cmV0dXJuIG1fb2Zmc2V0OyB9CisKKyAgICBBWElzb2xhdGVkT2JqZWN0KiBvYmplY3QoKSBjb25z dDsKKyAgICBjb25zdCBBWFRleHRSdW5zKiBydW5zKCkgY29uc3Q7CisgICAgU3RyaW5nIHN1YnN0 cmluZyh1bnNpZ25lZCBzdGFydCwgdW5zaWduZWQgbGVuZ3RoID0gU3RyaW5nSW1wbDo6TWF4TGVu Z3RoKSBjb25zdDsKKyAgICBzaXplX3QgcnVuSW5kZXhGcm9tT2Zmc2V0KCkgY29uc3Q7CisgICAg Ym9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhb2JqZWN0KCk7IH0KKworICAgIEFYUG9zaXRp b24gYXNUZXh0TGVhZlBvc2l0aW9uKCkgY29uc3Q7CisgICAgLy8gQSAidGV4dCBsZWFmIiBwb3Np dGlvbiBpcyBhIGxlYWYgbm9kZSAobm8gY2hpbGRyZW4pIHdpdGggbm9uLWVtcHR5IHRleHRydW5z LgorICAgIGJvb2wgaXNUZXh0TGVhZigpIGNvbnN0OworCisgICAgQVhJRCBtX3RyZWVJRDsKKyAg ICBBWElEIG1fb2JqZWN0SUQ7CisgICAgdW5zaWduZWQgbV9vZmZzZXQgeyAwIH07CisKKyAgICBt dXRhYmxlIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBtX2NhY2hlZE9iamVjdDsKK307CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJ UykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2Vy LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcAppbmRl eCA5YWQ2YWJmOTNhYWMuLmQyZDQzM2JjYmIxYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMzM1LDcgKzMzNSw3IEBAIHN0ZDo6b3B0aW9u YWw8QVhUZXh0TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtlclJhbmdlOjppbnRlcnNlY3Rpb25XaXRo KGNvbnN0IEFYVGV4CiAKIFN0cmluZyBBWFRleHRNYXJrZXJSYW5nZTo6ZGVidWdEZXNjcmlwdGlv bigpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5k ZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBtX2VuZC5kZWJ1Z0Rlc2NyaXB0aW9uKCks ICJ9Iik7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rl c2NyaXB0aW9uKCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5kLmRlYnVnRGVzY3JpcHRpb24oKSwgIn0i KTsKIH0KIAogc3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBhcnRpYWxPcmRlcihjb25zdCBBWFRleHRN YXJrZXImIG1hcmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMikKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmggYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCmluZGV4IDE3ZTlmYzBkYWI5OC4uOGZk YTlhMmViMGM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4 dE1hcmtlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2Vy LmgKQEAgLTEyMyw2ICsxMjMsNyBAQCBwdWJsaWM6CiAKICAgICBBWElEIHRyZWVJRCgpIGNvbnN0 IHsgcmV0dXJuIG1fZGF0YS5heFRyZWVJRCgpOyB9CiAgICAgQVhJRCBvYmplY3RJRCgpIGNvbnN0 IHsgcmV0dXJuIG1fZGF0YS5heE9iamVjdElEKCk7IH0KKyAgICB1bnNpZ25lZCBjaGFyYWN0ZXJP ZmZzZXQoKSBjb25zdCB7IHJldHVybiBtX2RhdGEuY2hhcmFjdGVyT2Zmc2V0OyB9CiAgICAgYm9v bCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhdHJlZUlEKCkuaXNWYWxpZCgpIHx8ICFvYmplY3RJ RCgpLmlzVmFsaWQoKTsgfQogICAgIFJlZlB0cjxBWENvcmVPYmplY3Q+IG9iamVjdCgpIGNvbnN0 OwogICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdCgpOyB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi41MDRmYTI0NzJhYTYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKQEAgLTAsMCArMSw5MyBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMu IEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBB UFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBWFRleHRSdW4uaCIK KworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorbmFtZXNwYWNlIFdlYkNvcmUgewor CitTdHJpbmcgQVhUZXh0UnVuczo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0Cit7CisgICAgU3Ry aW5nQnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgnWycpOworICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgIHJlc3VsdC5hcHBl bmQocnVuc1tpXS5kZWJ1Z0Rlc2NyaXB0aW9uKGNvbnRhaW5pbmdCbG9jaykpOworICAgICAgICBp ZiAoaSAhPSBydW5zLnNpemUoKSAtIDEpCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKCIsICIp OworICAgIH0KKyAgICByZXN1bHQuYXBwZW5kKCddJyk7CisgICAgcmV0dXJuIHJlc3VsdC50b1N0 cmluZygpOworfQorCitzaXplX3QgQVhUZXh0UnVuczo6aW5kZXhGb3JPZmZzZXQodW5zaWduZWQg dGV4dE9mZnNldCkgY29uc3QKK3sKKyAgICBzaXplX3QgY3VtdWxhdGl2ZUxlbmd0aCA9IDA7Cisg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBydW5zLnNpemUoKTsgaSsrKSB7CisgICAgICAgIGN1 bXVsYXRpdmVMZW5ndGggKz0gcnVuTGVuZ3RoKGkpOworICAgICAgICBpZiAoY3VtdWxhdGl2ZUxl bmd0aCA+PSB0ZXh0T2Zmc2V0KQorICAgICAgICAgICAgcmV0dXJuIGk7CisgICAgfQorICAgIHJl dHVybiBub3RGb3VuZDsKK30KKwordW5zaWduZWQgQVhUZXh0UnVuczo6cnVuTGVuZ3RoU3VtVG8o c2l6ZV90IGluZGV4KSBjb25zdAoreworICAgIHVuc2lnbmVkIGxlbmd0aCA9IDA7CisgICAgZm9y IChzaXplX3QgaSA9IDA7IGkgPD0gaW5kZXggJiYgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspCisgICAg ICAgIGxlbmd0aCArPSBydW5MZW5ndGgoaSk7CisgICAgcmV0dXJuIGxlbmd0aDsKK30KKworU3Ry aW5nIEFYVGV4dFJ1bnM6OnN1YnN0cmluZyh1bnNpZ25lZCBzdGFydCwgdW5zaWduZWQgbGVuZ3Ro KSBjb25zdAoreworICAgIGlmICghbGVuZ3RoKQorICAgICAgICByZXR1cm4gZW1wdHlTdHJpbmco KTsKKworICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHNpemVfdCBjaGFyYWN0ZXJzU2Vl biA9IDA7CisgICAgYXV0byByZW1haW5pbmcgPSBbJl0gKCkgeworICAgICAgICByZXR1cm4gcmVz dWx0Lmxlbmd0aCgpID49IGxlbmd0aCA/IDAgOiBsZW5ndGggLSByZXN1bHQubGVuZ3RoKCk7Cisg ICAgfTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcnVucy5zaXplKCkgJiYgcmVzdWx0 Lmxlbmd0aCgpIDwgbGVuZ3RoOyBpKyspIHsKKyAgICAgICAgc2l6ZV90IHJ1bkxlbmd0aCA9IHRo aXMtPnJ1bkxlbmd0aChpKTsKKyAgICAgICAgaWYgKGNoYXJhY3RlcnNTZWVuID49IHN0YXJ0KSB7 CisgICAgICAgICAgICAvLyBUaGUgc3RhcnQgcG9pbnRzIGVudGlyZWx5IHdpdGhpbiBib3VuZHMg b2YgdGhpcyBydW4uCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0udGV4dC5sZWZ0 KHJlbWFpbmluZygpKSk7CisgICAgICAgIH0gZWxzZSBpZiAoY2hhcmFjdGVyc1NlZW4gKyBydW5M ZW5ndGggPiBzdGFydCkgeworICAgICAgICAgICAgLy8gc3RhcnQgcG9pbnRzIHNvbWV3aGVyZSBp biB0aGUgbWlkZGxlIG9mIHRoZSBjdXJyZW50IHJ1biwgY29sbGVjdCBwYXJ0IG9mIHRoZSB0ZXh0 LgorICAgICAgICAgICAgdW5zaWduZWQgc3RhcnRJblJ1biA9IHN0YXJ0IC0gY2hhcmFjdGVyc1Nl ZW47CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChzdGFydEluUnVuIDwgcnVuTGVuZ3RoKTsK KyAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQocnVuc1tpXS50ZXh0LnN1YnN0cmluZyhzdGFydElu UnVuLCByZW1haW5pbmcoKSkpOworICAgICAgICB9CisgICAgICAgIC8vIElmIGNoYXJhY3RlcnNT ZWVuICsgcnVuTGVuZ3RoID09IHN0YXJ0LCB0aGUgc3RhcnQgcG9pbnRzIHRvIHRoZSBlbmQgb2Yg dGhlIHJ1biwgYW5kIHRoZXJlIGlzIG5vIHRleHQgdG8gZ2F0aGVyLgorCisgICAgICAgIGNoYXJh Y3RlcnNTZWVuICs9IHJ1bkxlbmd0aDsKKyAgICB9CisgICAgcmV0dXJuIHJlc3VsdC50b1N0cmlu ZygpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5BQkxFKEFYX1RI UkVBRF9URVhUX0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYVGV4dFJ1bi5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmEwOTlmMzExZjU2ZAotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgK QEAgLTAsMCArMSwxMjAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVOQUJM RShBWF9USFJFQURfVEVYVF9BUElTKQorbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBSZW5k ZXJCbG9jazsKKworc3RydWN0IEFYVGV4dFJ1bkxpbmVJRCB7CisgICAgdm9pZCogY29udGFpbmlu Z0Jsb2NrIHsgbnVsbHB0ciB9OworICAgIHNpemVfdCBsaW5lSW5kZXggeyAwIH07CisKKyAgICBB WFRleHRSdW5MaW5lSUQodm9pZCogY29udGFpbmluZ0Jsb2NrLCBzaXplX3QgbGluZUluZGV4KQor ICAgICAgICA6IGNvbnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgbGlu ZUluZGV4KGxpbmVJbmRleCkKKyAgICB7IH0KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQVhU ZXh0UnVuTGluZUlEJikgY29uc3QgPSBkZWZhdWx0OworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0 aW9uKCkgY29uc3QKKyAgICB7CisgICAgICAgIFRleHRTdHJlYW0gc3RyZWFtOworICAgICAgICBz dHJlYW0gPDwgIkxpbmVJRCAiIDw8IGNvbnRhaW5pbmdCbG9jayA8PCAiICIgPDwgbGluZUluZGV4 OworICAgICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2UoKTsKKyAgICB9Cit9OworCitzdHJ1Y3Qg QVhUZXh0UnVuIHsKKyAgICAvLyBUaGUgbGluZSBpbmRleCBvZiB0aGlzIHJ1biB3aXRoaW4gdGhl IGNvbnRleHQgb2YgdGhlIGNvbnRhaW5pbmcgUmVuZGVyQmxvY2sgb2YgdGhlIG1haW4tdGhyZWFk IEFYIG9iamVjdC4KKyAgICBzaXplX3QgbGluZUluZGV4OworICAgIFN0cmluZyB0ZXh0OworCisg ICAgQVhUZXh0UnVuKHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCisgICAgICAgIDog bGluZUluZGV4KGxpbmVJbmRleCkKKyAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCisgICAg eyB9CisKKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbih2b2lkKiBjb250YWluaW5nQmxvY2sp IGNvbnN0CisgICAgeworICAgICAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEID0geyBjb250YWlu aW5nQmxvY2ssIGxpbmVJbmRleCB9OworICAgICAgICByZXR1cm4gbWFrZVN0cmluZyhsaW5lSUQu ZGVidWdEZXNjcmlwdGlvbigpLCAiOiB8IiwgbWFrZVN0cmluZ0J5UmVwbGFjaW5nQWxsKHRleHQs ICdcbicsICJ7bmV3bGluZX0iX3MpLCAifChsZW4gIiwgdGV4dC5sZW5ndGgoKSwgIikiKTsKKyAg ICB9Cit9OworCitzdHJ1Y3QgQVhUZXh0UnVucyB7CisgICAgLy8gVGhlIGNvbnRhaW5pbmcgYmxv Y2sgZm9yIHRoZSB0ZXh0IHJ1bnMuIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZSBiYXNlZCBvbiB0 aGUgc3RydWN0dXJlCisgICAgLy8gb2YgdGhlIEFYIHRyZWUsIHRleHQgcnVucyBmb3IgZGlmZmVy ZW50IG9iamVjdHMgY2FuIGhhdmUgdGhlIHNhbWUgbGluZSBpbmRleCBidXQgZGlmZmVyZW50Cisg ICAgLy8gY29udGFpbmluZyBibG9ja3MsIG1lYW5pbmcgdGhleSBhcmUgcmVuZGVyZWQgb24gZGlm ZmVyZW50IGxpbmVzLgorICAgIC8vIERvIG5vdCBkZS1yZWZlcmVuY2UuIFVzZSBmb3IgY29tcGFy aXNvbiBwdXJwb3NlcyBvbmx5LgorICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7IG51bGxwdHIg fTsKKyAgICBWZWN0b3I8QVhUZXh0UnVuPiBydW5zOworCisgICAgQVhUZXh0UnVucygpID0gZGVm YXVsdDsKKyAgICBBWFRleHRSdW5zKFJlbmRlckJsb2NrKiBjb250YWluaW5nQmxvY2ssIFZlY3Rv cjxBWFRleHRSdW4+JiYgcnVucykKKyAgICAgICAgOiBjb250YWluaW5nQmxvY2soY29udGFpbmlu Z0Jsb2NrKQorICAgICAgICAsIHJ1bnMoV1RGTW92ZShydW5zKSkKKyAgICB7IH0KKyAgICBTdHJp bmcgZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0OworCisgICAgc2l6ZV90IHNpemUoKSBjb25zdCB7 IHJldHVybiBydW5zLnNpemUoKTsgfQorICAgIGNvbnN0IEFYVGV4dFJ1biYgYXQoc2l6ZV90IGlu ZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuICgqdGhpcylbaW5kZXhdOworICAgIH0K KyAgICBjb25zdCBBWFRleHRSdW4mIG9wZXJhdG9yW10oc2l6ZV90IGluZGV4KSBjb25zdAorICAg IHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBydW5zLnNpemUoKSk7CisgICAgICAg IHJldHVybiBydW5zW2luZGV4XTsKKyAgICB9CisKKyAgICB1bnNpZ25lZCBydW5MZW5ndGgoc2l6 ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5kZXggPCBy dW5zLnNpemUoKSk7CisgICAgICAgIHJldHVybiBydW5zW2luZGV4XS50ZXh0Lmxlbmd0aCgpOwor ICAgIH0KKyAgICB1bnNpZ25lZCBsYXN0UnVuTGVuZ3RoKCkgY29uc3QKKyAgICB7CisgICAgICAg IGlmIChydW5zLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICByZXR1 cm4gcnVuc1tydW5zLnNpemUoKSAtIDFdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2ln bmVkIHJ1bkxlbmd0aFN1bSgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gcnVuTGVuZ3Ro U3VtVG8ocnVucy5zaXplKCkgLSAxKTsKKyAgICB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoU3Vt VG8oc2l6ZV90IGluZGV4KSBjb25zdDsKKworICAgIHNpemVfdCBpbmRleEZvck9mZnNldCh1bnNp Z25lZCB0ZXh0T2Zmc2V0KSBjb25zdDsKKyAgICBBWFRleHRSdW5MaW5lSUQgbGluZUlEKHNpemVf dCBpbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVu cy5zaXplKCkpOworICAgICAgICByZXR1cm4geyBjb250YWluaW5nQmxvY2ssIHJ1bnNbaW5kZXhd LmxpbmVJbmRleCB9OworICAgIH0KKyAgICBTdHJpbmcgc3Vic3RyaW5nKHVuc2lnbmVkIHN0YXJ0 LCB1bnNpZ25lZCBsZW5ndGggPSBTdHJpbmdJbXBsOjpNYXhMZW5ndGgpIGNvbnN0OworfTsKKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9B UElTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmls aXR5T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0 eU9iamVjdC5jcHAKaW5kZXggMjlhOTMxYzVhYTE0Li5mMzM5YjNhYjAwODEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcApA QCAtMTEzLDYgKzExMywxMiBAQCB2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmluaXQoKQogICAg IG1fcm9sZSA9IGRldGVybWluZUFjY2Vzc2liaWxpdHlSb2xlKCk7CiB9CiAKK0FYSUQgQWNjZXNz aWJpbGl0eU9iamVjdDo6dHJlZUlEKCkgY29uc3QKK3sKKyAgICBhdXRvKiBjYWNoZSA9IGF4T2Jq ZWN0Q2FjaGUoKTsKKyAgICByZXR1cm4gY2FjaGUgPyBjYWNoZS0+dHJlZUlEKCkgOiBBWElEKCk7 Cit9CisKIGlubGluZSBQcm9jZXNzSUQgQWNjZXNzaWJpbGl0eU9iamVjdDo6cHJvY2Vzc0lEKCkg Y29uc3QKIHsKICAgICByZXR1cm4gcHJlc2VudGluZ0FwcGxpY2F0aW9uUElEKCk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaCBi L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCmluZGV4 IGU2NGI2MzA2YzA4ZS4uYzdmMjhkNWMzYjU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaApAQCAtMzAsNiArMzAsNyBAQAogI3By YWdtYSBvbmNlCiAKICNpbmNsdWRlICJBWENvcmVPYmplY3QuaCIKKyNpbmNsdWRlICJBWFRleHRS dW4uaCIKICNpbmNsdWRlICJDaGFyYWN0ZXJSYW5nZS5oIgogI2luY2x1ZGUgIkZsb2F0UXVhZC5o IgogI2luY2x1ZGUgIkxheW91dFJlY3QuaCIKQEAgLTYzLDYgKzY0LDcgQEAgY2xhc3MgQWNjZXNz aWJpbGl0eU9iamVjdCA6IHB1YmxpYyBBWENvcmVPYmplY3QsIHB1YmxpYyBDYW5NYWtlV2Vha1B0 cjxBY2Nlc3NpYmkKIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5BY2Nlc3NpYmlsaXR5T2JqZWN0KCk7 CiAKKyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsOwogICAgIFByb2Nlc3NJRCBwcm9jZXNz SUQoKSBjb25zdCBvdmVycmlkZTsKICAgICBTdHJpbmcgZGJnKCkgY29uc3QgZmluYWw7CiAKQEAg LTM4Miw2ICszODQsOSBAQCBwdWJsaWM6CiAgICAgU3RyaW5nIHRleHRVbmRlckVsZW1lbnQoQWNj ZXNzaWJpbGl0eVRleHRVbmRlckVsZW1lbnRNb2RlID0gQWNjZXNzaWJpbGl0eVRleHRVbmRlckVs ZW1lbnRNb2RlKCkpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIFN0cmluZyB0 ZXh0KCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4geyB9OyB9CiAgICAgdW5zaWduZWQgdGV4dExl bmd0aCgpIGNvbnN0IGZpbmFsOworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAg IHZpcnR1YWwgQVhUZXh0UnVucyB0ZXh0UnVucygpIHsgcmV0dXJuIHsgfTsgfQorI2VuZGlmCiAj aWYgUExBVEZPUk0oQ09DT0EpCiAgICAgLy8gUmV0dXJucyBhbiBhcnJheSBvZiBzdHJpbmdzIGFu ZCBBWE9iamVjdCB3cmFwcGVycyBjb3JyZXNwb25kaW5nIHRvIHRoZQogICAgIC8vIHRleHRydW5z IGFuZCByZXBsYWNlbWVudCBub2RlcyBpbmNsdWRlZCBpbiB0aGUgZ2l2ZW4gcmFuZ2UuCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0LmNwcAppbmRleCAzOTQ2OWU2OTA2MDAuLmY3MzhlODliNDJhYSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwCkBAIC0xNDAzLDExICsxNDAzLDExIEBAIENoYXJhY3RlclJhbmdlIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6OnNlbGVjdGVkVGV4dFJhbmdlKCkgY29uc3QKIH0KIAogI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotVmVjdG9yPEFYVGV4dFJ1bj4gQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6dGV4dFJ1bnMoKQorQVhUZXh0UnVucyBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0Ojp0ZXh0UnVucygpCiB7CiAgICAgaWYgKGF1dG8qIHJlbmRlckxpbmVCcmVhayA9 IGR5bmFtaWNEb3duY2FzdDxSZW5kZXJMaW5lQnJlYWs+KHJlbmRlcmVyKCkpKSB7CiAgICAgICAg IGF1dG8gYm94ID0gSW5saW5lSXRlcmF0b3I6OmJveEZvcigqcmVuZGVyTGluZUJyZWFrKTsKLSAg ICAgICAgcmV0dXJuIHsgeyBib3gtPmxpbmVJbmRleCgpLCBtYWtlU3RyaW5nKCdcbicpIH0gfTsK KyAgICAgICAgcmV0dXJuIHsgcmVuZGVyTGluZUJyZWFrLT5jb250YWluaW5nQmxvY2soKSwgeyBB WFRleHRSdW4oYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKS5pc29sYXRlZENvcHko KSkgfSB9OwogICAgIH0KIAogICAgIFdlYWtQdHIgcmVuZGVyVGV4dCA9IGR5bmFtaWNEb3duY2Fz dDxSZW5kZXJUZXh0PihyZW5kZXJlcigpKTsKQEAgLTE0NjAsNyArMTQ2MCw3IEBAIFZlY3RvcjxB WFRleHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKIAogICAgIGlm ICghbGluZVN0cmluZy5pc0VtcHR5KCkpCiAgICAgICAgIHJ1bnMuYXBwZW5kKHsgY3VycmVudExp bmVJbmRleCwgbGluZVN0cmluZy50b1N0cmluZygpLmlzb2xhdGVkQ29weSgpIH0pOwotICAgIHJl dHVybiBydW5zOworICAgIHJldHVybiB7IHJlbmRlclRleHQtPmNvbnRhaW5pbmdCbG9jaygpLCBX VEZNb3ZlKHJ1bnMpIH07CiB9CiAjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMp CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0LmgKaW5kZXggY2VlYzZiZjNlODk4Li5iZTllZTRmODYwNDYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5oCkBAIC0xMDAsNyArMTAwLDcgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0 VW5kZXJFbGVtZW50KEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2li aWxpdHlUZXh0VW5kZXJFbGVtZW50TW9kZSgpKSBjb25zdCBvdmVycmlkZTsKICAgICBTdHJpbmcg c2VsZWN0ZWRUZXh0KCkgY29uc3Qgb3ZlcnJpZGU7CiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhU X0FQSVMpCi0gICAgVmVjdG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbDsKKyAgICBBWFRl eHRSdW5zIHRleHRSdW5zKCkgZmluYWw7CiAjZW5kaWYKIAogICAgIGJvb2wgaXNXaWRnZXQoKSBj b25zdCBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAKaW5kZXggNjJhMWE1NzVh ZTYxLi4zNDVmMmQ1M2RmNTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCkBAIC0zMSw2 ICszMSw3IEBACiAjaW5jbHVkZSAiQVhHZW9tZXRyeU1hbmFnZXIuaCIKICNpbmNsdWRlICJBWElz b2xhdGVkVHJlZS5oIgogI2luY2x1ZGUgIkFYTG9nZ2VyLmgiCisjaW5jbHVkZSAiQVhUZXh0UnVu LmgiCiAKICNpZiBQTEFURk9STShNQUMpCiAjaW1wb3J0IDxwYWwvc3BpL21hYy9ISVNlcnZpY2Vz U1BJLmg+CkBAIC00NjQsNiArNDY1LDkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRQcm9w ZXJ0eShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlWYWx1ZVYKICAgICAg ICAgW10oc3RkOjpwYWlyPEFYSUQsIENoYXJhY3RlclJhbmdlPiYgdHlwZWRWYWx1ZSkgewogICAg ICAgICAgICAgcmV0dXJuICF0eXBlZFZhbHVlLmZpcnN0LmlzVmFsaWQoKSAmJiAhdHlwZWRWYWx1 ZS5zZWNvbmQubG9jYXRpb24gJiYgIXR5cGVkVmFsdWUuc2Vjb25kLmxlbmd0aDsKICAgICAgICAg fSwKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICAgICAgW10oQVhUZXh0UnVu cyBydW5zKSB7IHJldHVybiAhcnVucy5zaXplKCk7IH0sCisjZW5kaWYKICAgICAgICAgW10oYXV0 byYpIHsKICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOwpAQCAtNTU3LDYgKzU2MSwxOSBAQCB2b2lkIEFYSXNvbGF0ZWRPYmplY3Q6OnNl dFNlbGVjdGVkQ2hpbGRyZW4oY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBzZQog ICAgIH0pOwogfQogCitBWENvcmVPYmplY3QqIEFYSXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcoQVhE aXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIFJlZlB0ciBwYXJlbnQgPSBwYXJlbnRP YmplY3RVbmlnbm9yZWQoKTsKKyAgICBjb25zdCBhdXRvJiBzaWJsaW5ncyA9IHBhcmVudC0+Y2hp bGRyZW4oKTsKKyAgICBzaXplX3QgaW5kZXhPZlRoaXMgPSBzaWJsaW5ncy5maW5kKHRoaXMpOwor ICAgIGlmIChpbmRleE9mVGhpcyA9PSBub3RGb3VuZCkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7 CisKKyAgICBpZiAoZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0KQorICAgICAgICByZXR1 cm4gaW5kZXhPZlRoaXMgKyAxIDwgc2libGluZ3Muc2l6ZSgpID8gc2libGluZ3NbaW5kZXhPZlRo aXMgKyAxXS5nZXQoKSA6IG51bGxwdHI7CisgICAgcmV0dXJuIGluZGV4T2ZUaGlzID4gMCA/IHNp YmxpbmdzW2luZGV4T2ZUaGlzIC0gMV0uZ2V0KCkgOiBudWxscHRyOworfQorCiBib29sIEFYSXNv bGF0ZWRPYmplY3Q6OmlzRGV0YWNoZWRGcm9tUGFyZW50KCkKIHsKICAgICBpZiAocGFyZW50KCku aXNWYWxpZCgpKQpAQCAtOTcxLDYgKzk4OCwxOSBAQCBpbnQgQVhJc29sYXRlZE9iamVjdDo6aW50 QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lKSBjb25zdAogICAgICk7 CiB9CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK2NvbnN0IEFYVGV4dFJ1bnMq IEFYSXNvbGF0ZWRPYmplY3Q6OnRleHRSdW5zKCkgY29uc3QKK3sKKyAgICBhdXRvIGVudHJ5ID0g bV9wcm9wZXJ0eU1hcC5maW5kKEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7CisgICAgaWYgKGVu dHJ5ID09IG1fcHJvcGVydHlNYXAuZW5kKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworICAg IHJldHVybiBXVEY6OnN3aXRjaE9uKGVudHJ5LT52YWx1ZSwKKyAgICAgICAgW10gKGNvbnN0IEFY VGV4dFJ1bnMmIHR5cGVkVmFsdWUpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0dXJuICZ0eXBl ZFZhbHVlOyB9LAorICAgICAgICBbXSAoYXV0byYpIC0+IGNvbnN0IEFYVGV4dFJ1bnMqIHsgcmV0 dXJuIG51bGxwdHI7IH0KKyAgICApOworfQorI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+ CiBUIEFYSXNvbGF0ZWRPYmplY3Q6OmdldE9yUmV0cmlldmVQcm9wZXJ0eVZhbHVlKEFYUHJvcGVy dHlOYW1lIHByb3BlcnR5TmFtZSkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAppbmRleCBhNmNh MDM0Mzc3N2QuLjhkOTRhZDJiZDlkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaApAQCAtNDQs NiArNDQsOSBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBWElzb2xhdGVkVHJlZTsK KyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK3N0cnVjdCBBWFRleHRSdW5zOworI2Vu ZGlmCiAKIGNsYXNzIEFYSXNvbGF0ZWRPYmplY3QgZmluYWwgOiBwdWJsaWMgQVhDb3JlT2JqZWN0 IHsKICAgICBmcmllbmQgY2xhc3MgQVhJc29sYXRlZFRyZWU7CkBAIC01MSw3ICs1NCw5IEBAIHB1 YmxpYzoKICAgICBzdGF0aWMgUmVmPEFYSXNvbGF0ZWRPYmplY3Q+IGNyZWF0ZShjb25zdCBSZWY8 QWNjZXNzaWJpbGl0eU9iamVjdD4mLCBBWElzb2xhdGVkVHJlZSopOwogICAgIH5BWElzb2xhdGVk T2JqZWN0KCk7CiAKKyAgICBBWElEIHRyZWVJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUo KS0+dHJlZUlEKCk7IH0KICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgZmluYWwgeyBy ZXR1cm4gdHJlZSgpLT5wcm9jZXNzSUQoKTsgfQorICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVW YWx1ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xl PihpbnRBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBT dHJpbmcgZGJnKCkgY29uc3QgZmluYWw7CiAKICAgICB2b2lkIGF0dGFjaFBsYXRmb3JtV3JhcHBl cihBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlciopOwpAQCAtNTksMTAgKzY0LDE3IEBAIHB1Ymxp YzoKICAgICBib29sIGlzVGFibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRl VmFsdWUoQVhQcm9wZXJ0eU5hbWU6OklzVGFibGUpOyB9CiAgICAgYm9vbCBpc0V4cG9zYWJsZSgp IGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6 SXNFeHBvc2FibGUpOyB9CiAKKyAgICBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3Im IGNoaWxkcmVuKGJvb2wgdXBkYXRlQ2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpIGZpbmFsOworICAg IEFYQ29yZU9iamVjdCogc2libGluZyhBWERpcmVjdGlvbikgY29uc3Q7CiAgICAgQVhJc29sYXRl ZE9iamVjdCogcGFyZW50T2JqZWN0KCkgY29uc3QgZmluYWwgeyByZXR1cm4gcGFyZW50T2JqZWN0 VW5pZ25vcmVkKCk7IH0KKyAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9y ZWQoKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBlZGl0YWJsZUFuY2VzdG9y KCkgZmluYWwgeyByZXR1cm4gQWNjZXNzaWJpbGl0eTo6ZWRpdGFibGVBbmNlc3RvcigqdGhpcyk7 IH07CiAgICAgYm9vbCBjYW5TZXRGb2N1c0F0dHJpYnV0ZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJu IGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6Q2FuU2V0Rm9jdXNBdHRyaWJ1dGUp OyB9CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICBjb25zdCBBWFRleHRS dW5zKiB0ZXh0UnVucygpIGNvbnN0OworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgdm9pZCBkZXRh Y2hSZW1vdGVQYXJ0cyhBY2Nlc3NpYmlsaXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwogICAgIHZv aWQgZGV0YWNoUGxhdGZvcm1XcmFwcGVyKEFjY2Vzc2liaWxpdHlEZXRhY2htZW50VHlwZSkgZmlu YWw7CkBAIC0yNDMsNyArMjU1LDYgQEAgcHJpdmF0ZToKICAgICBWZWN0b3I8U3RyaW5nPiBkZXRl cm1pbmVEcm9wRWZmZWN0cygpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGFj Y2Vzc2liaWxpdHlIaXRUZXN0KGNvbnN0IEludFBvaW50JikgY29uc3QgZmluYWw7CiAgICAgQVhJ c29sYXRlZE9iamVjdCogZm9jdXNlZFVJRWxlbWVudCgpIGNvbnN0IGZpbmFsOwotICAgIEFYSXNv bGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNvbnN0IGZpbmFsOwogICAgIEFj Y2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBsaW5rZWRPYmplY3RzKCkgY29uc3QgZmluYWwgeyBy ZXR1cm4gdHJlZSgpLT5vYmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFY UHJvcGVydHlOYW1lOjpMaW5rZWRPYmplY3RzKSk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0KiB0 aXRsZVVJRWxlbWVudCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIG9iamVjdEF0dHJpYnV0ZVZhbHVl KEFYUHJvcGVydHlOYW1lOjpUaXRsZVVJRWxlbWVudCk7IH0KICAgICBBWElzb2xhdGVkT2JqZWN0 KiBzY3JvbGxCYXIoQWNjZXNzaWJpbGl0eU9yaWVudGF0aW9uKSBmaW5hbDsKQEAgLTI1MSw3ICsy NjIsNiBAQCBwcml2YXRlOgogICAgIFN0cmluZyBleHBhbmRlZFRleHRWYWx1ZSgpIGNvbnN0IGZp bmFsIHsgcmV0dXJuIHN0cmluZ0F0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpFeHBhbmRl ZFRleHRWYWx1ZSk7IH0KICAgICBib29sIHN1cHBvcnRzRXhwYW5kZWRUZXh0VmFsdWUoKSBjb25z dCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlN1cHBv cnRzRXhwYW5kZWRUZXh0VmFsdWUpOyB9CiAgICAgU1JHQkE8dWludDhfdD4gY29sb3JWYWx1ZSgp IGNvbnN0IGZpbmFsOwotICAgIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNvbnN0IGZp bmFsIHsgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSb2xlPihpbnRBdHRyaWJ1dGVW YWx1ZShBWFByb3BlcnR5TmFtZTo6Um9sZVZhbHVlKSk7IH0KICAgICBTdHJpbmcgcm9sZVBsYXRm b3JtU3RyaW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQ cm9wZXJ0eU5hbWU6OlJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KICAgICBTdHJpbmcgcm9sZURlc2Ny aXB0aW9uKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9w ZXJ0eU5hbWU6OlJvbGVEZXNjcmlwdGlvbik7IH0KICAgICBTdHJpbmcgc3Vicm9sZVBsYXRmb3Jt U3RyaW5nKCkgY29uc3QgZmluYWwgeyByZXR1cm4gc3RyaW5nQXR0cmlidXRlVmFsdWUoQVhQcm9w ZXJ0eU5hbWU6OlN1YnJvbGVQbGF0Zm9ybVN0cmluZyk7IH0KQEAgLTMxNiw3ICszMjYsNiBAQCBw cml2YXRlOgogICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciB2aXNpYmxlQ2hpbGRyZW4o KSBmaW5hbCB7IHJldHVybiB0cmVlKCktPm9iamVjdHNGb3JJRHModmVjdG9yQXR0cmlidXRlVmFs dWU8QVhJRD4oQVhQcm9wZXJ0eU5hbWU6OlZpc2libGVDaGlsZHJlbikpOyB9CiAgICAgQXRvbVN0 cmluZyB0YWdOYW1lKCkgY29uc3QgZmluYWw7CiAgICAgdm9pZCBzZXRDaGlsZHJlbklEcyhWZWN0 b3I8QVhJRD4mJik7Ci0gICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGls ZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVkZWQgPSB0cnVlKSBmaW5hbDsKICAgICB2b2lk IHVwZGF0ZUNoaWxkcmVuSWZOZWNlc3NhcnkoKSBmaW5hbDsKICAgICBib29sIGlzRGV0YWNoZWRG cm9tUGFyZW50KCkgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogbGl2ZVJlZ2lvbkFuY2Vz dG9yKGJvb2wgZXhjbHVkZUlmT2ZmID0gdHJ1ZSkgY29uc3QgZmluYWwgeyByZXR1cm4gQWNjZXNz aWJpbGl0eTo6bGl2ZVJlZ2lvbkFuY2VzdG9yKCp0aGlzLCBleGNsdWRlSWZPZmYpOyB9CkBAIC0z NDUsOSArMzU0LDYgQEAgcHJpdmF0ZToKIAogICAgIC8vIENoYXJhY3RlclJhbmdlIHN1cHBvcnQu CiAgICAgQ2hhcmFjdGVyUmFuZ2Ugc2VsZWN0ZWRUZXh0UmFuZ2UoKSBjb25zdCBmaW5hbCB7IHJl dHVybiBwcm9wZXJ0eVZhbHVlPENoYXJhY3RlclJhbmdlPihBWFByb3BlcnR5TmFtZTo6U2VsZWN0 ZWRUZXh0UmFuZ2UpOyB9Ci0jaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgVmVj dG9yPEFYVGV4dFJ1bj4gdGV4dFJ1bnMoKSBmaW5hbCB7IHJldHVybiB2ZWN0b3JBdHRyaWJ1dGVW YWx1ZTxBWFRleHRSdW4+KEFYUHJvcGVydHlOYW1lOjpUZXh0UnVucyk7IH0KLSNlbmRpZgogICAg IGludCBpbnNlcnRpb25Qb2ludExpbmVOdW1iZXIoKSBjb25zdCBmaW5hbDsKICAgICBDaGFyYWN0 ZXJSYW5nZSBkb0FYUmFuZ2VGb3JMaW5lKHVuc2lnbmVkKSBjb25zdCBmaW5hbDsKICAgICBTdHJp bmcgZG9BWFN0cmluZ0ZvclJhbmdlKGNvbnN0IENoYXJhY3RlclJhbmdlJikgY29uc3QgZmluYWw7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9B WElzb2xhdGVkVHJlZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVk dHJlZS9BWElzb2xhdGVkVHJlZS5jcHAKaW5kZXggZjZmMDYyMmFiZTkzLi4wZTc1MzllM2E4YzAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FY SXNvbGF0ZWRUcmVlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUg IkFYSXNvbGF0ZWRPYmplY3QuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFj Y2Vzc2liaWxpdHlUYWJsZVJvdy5oIgogI2luY2x1ZGUgIkZyYW1lU2VsZWN0aW9uLmgiCiAjaW5j bHVkZSAiTG9jYWxGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJQYWdlLmgiCkBAIC0yMzAsMjIgKzIz MSw2IEBAIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBBWElzb2xhdGVkVHJlZTo6b2JqZWN0Rm9y SUQoY29uc3QgQVhJRCBheElEKSBjb25zdAogICAgIHJldHVybiBheElELmlzVmFsaWQoKSA/IG1f cmVhZGVyVGhyZWFkTm9kZU1hcC5nZXQoYXhJRCkgOiBudWxscHRyOwogfQogCi10ZW1wbGF0ZTx0 eXBlbmFtZSBVPgotVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBBWElzb2xhdGVkVHJlZTo6 b2JqZWN0c0ZvcklEcyhjb25zdCBVJiBheElEcykgY29uc3QKLXsKLSAgICBBWFRSQUNFKCJBWElz b2xhdGVkVHJlZTo6b2JqZWN0c0ZvcklEcyJfcyk7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQo KSk7Ci0KLSAgICBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IHJlc3VsdDsKLSAgICByZXN1 bHQucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShheElEcy5zaXplKCkpOwotICAgIGZvciAoYXV0byYg YXhJRCA6IGF4SURzKSB7Ci0gICAgICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gb2JqZWN0Rm9ySUQo YXhJRCkpCi0gICAgICAgICAgICByZXN1bHQuYXBwZW5kKFdURk1vdmUob2JqZWN0KSk7Ci0gICAg fQotICAgIHJlc3VsdC5zaHJpbmtUb0ZpdCgpOwotICAgIHJldHVybiByZXN1bHQ7Ci19Ci0KIHZv aWQgQVhJc29sYXRlZFRyZWU6OmdlbmVyYXRlU3VidHJlZShBY2Nlc3NpYmlsaXR5T2JqZWN0JiBh eE9iamVjdCkKIHsKICAgICBBWFRSQUNFKCJBWElzb2xhdGVkVHJlZTo6Z2VuZXJhdGVTdWJ0cmVl Il9zKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0 cmVlL0FYSXNvbGF0ZWRUcmVlLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCmluZGV4IDU5ZjE5ZmE3ODhmNS4uN2U4ZjYxNzgxNTli IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9B WElzb2xhdGVkVHJlZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKQEAgLTI5LDYgKzI5LDcgQEAKIAogI2luY2x1ZGUgIkFY Q29yZU9iamVjdC5oIgogI2luY2x1ZGUgIkFYVGV4dE1hcmtlci5oIgorI2luY2x1ZGUgIkFYVGV4 dFJ1bi5oIgogI2luY2x1ZGUgIkFYVHJlZVN0b3JlLmgiCiAjaW5jbHVkZSAiUGFnZUlkZW50aWZp ZXIuaCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZUNvbnN0YW50cy5oIgpAQCAtNDcsNiArNDgsNyBA QCBjbGFzcyBUZXh0U3RyZWFtOwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBWElzb2xh dGVkT2JqZWN0OworY2xhc3MgQVhHZW9tZXRyeU1hbmFnZXI7CiBjbGFzcyBBWE9iamVjdENhY2hl OwogY2xhc3MgQWNjZXNzaWJpbGl0eU9iamVjdDsKIGNsYXNzIFBhZ2U7CkBAIC0yNTUsNyArMjU3 LDcgQEAgdXNpbmcgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCA9IHN0ZDo6dmFyaWFudDxzdGQ6Om51 bGxwdHJfdCwgQVhJRCwgU3RyaW5nLCBib29sLAogICAgICwgUmV0YWluUHRyPE5TQXR0cmlidXRl ZFN0cmluZz4KICNlbmRpZgogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgICwg VmVjdG9yPEFYVGV4dFJ1bj4KKyAgICAsIEFYVGV4dFJ1bnMKICNlbmRpZgogPjsKIHVzaW5nIEFY UHJvcGVydHlNYXAgPSBIYXNoTWFwPEFYUHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWYXJp YW50LCBJbnRIYXNoPEFYUHJvcGVydHlOYW1lPiwgV1RGOjpTdHJvbmdFbnVtSGFzaFRyYWl0czxB WFByb3BlcnR5TmFtZT4+OwpAQCAtMzIyLDcgKzMyNCwyMCBAQCBwdWJsaWM6CiAgICAgV0VCQ09S RV9FWFBPUlQgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IGZvY3VzZWROb2RlKCk7CiAKICAgICBS ZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gb2JqZWN0Rm9ySUQoY29uc3QgQVhJRCkgY29uc3Q7Ci0g ICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBvYmpl Y3RzRm9ySURzKGNvbnN0IFUmKSBjb25zdDsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPgorICAg IFZlY3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gb2JqZWN0c0ZvcklEcyhjb25zdCBVJiBheElE cykgY29uc3QKKyAgICB7CisgICAgICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworCisgICAg ICAgIFZlY3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gcmVzdWx0OworICAgICAgICByZXN1bHQu cmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShheElEcy5zaXplKCkpOworICAgICAgICBmb3IgKGNvbnN0 IGF1dG8mIGF4SUQgOiBheElEcykgeworICAgICAgICAgICAgaWYgKFJlZlB0ciBvYmplY3QgPSBv YmplY3RGb3JJRChheElEKSkKKyAgICAgICAgICAgICAgICByZXN1bHQuYXBwZW5kKFdURk1vdmUo b2JqZWN0KSk7CisgICAgICAgIH0KKyAgICAgICAgcmVzdWx0LnNocmlua1RvRml0KCk7CisgICAg ICAgIHJldHVybiByZXN1bHQ7CisgICAgfQogCiAgICAgdm9pZCBnZW5lcmF0ZVN1YnRyZWUoQWNj ZXNzaWJpbGl0eU9iamVjdCYpOwogICAgIHZvaWQgbGFiZWxDcmVhdGVkKEFjY2Vzc2liaWxpdHlP YmplY3QmKTsK 469285 2024-01-03 18:20:33 -0800 2024-01-08 10:39:45 -0800 Patch bug-266521-20240103182032.patch text/plain 46979 tyler_w RnJvbSBjZjc5NzQwNmEzMmFhYzJkZDg3YmI5NmU0YmJhODEyOTY3Njc1YzdjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGxpbmUgcmFuZ2UsIGFuZCBzdHJpbmctZm9yLXJh bmdlIHRleHQgbWFya2VyCiBBUElzIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjY1MjEgcmRhcjovLzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5 cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzog OGJpdAoKUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCgpUaGlzIHBhdGNoIGFkZHMgZnVuY3Rp b25hbGl0eSB0byBBWFRleHRNYXJrZXIgdG8gdHJhdmVyc2UgdGhlIGFjY2Vzc2liaWxpdHkgdHJl ZSwgYW5hbHl6aW5nIGNhY2hlZCBBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMKYXQgZWFjaCBzdG9w LCB0byBzZXJ2ZSB0aGVzZSBBUElzIG9mZiB0aGUgbWFpbi10aHJlYWQuCgpUaGUgaW1wbGVtZW50 YXRpb24gaW4gdGhpcyBwYXRjaCBpZ25vcmVzIGltcG9ydGFudCBlZGdlIGNhc2VzIOKAlCBlLmcu IGFyaWEtb3ducyB0cmVlIHJlLW9yZGVyaW5nIHdpbGwgY2F1c2UgdXMgdG8KY29tcHV0ZSB0aGUg d3JvbmcgcmVzdWx0cywgYW5kIHRleHQgaW4gaWdub3JlZCBvYmplY3RzIHdpbGwgYmUgc2tpcHBl ZC4KCiogU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZToKKiBTb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dDoKKiBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaDoKKFdlYkNv cmU6OkFYVGV4dFJ1bjo6QVhUZXh0UnVuKTogRGVsZXRlZC4KKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6dGV4dFJ1bnMpOiBEZWxldGVkLgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtlcjo6aXNvbGF0ZWRPYmplY3QgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyUmFuZ2U6OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6ZmluZE9iamVjdFdpdGhSdW5zKToKKFdlYkNvcmU6OkFYVGV4dE1hcmtlclJh bmdlOjp0b1N0cmluZyBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6OnJ1bnMgY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpmaW5kTWFya2VyIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dE1hcmtlcjo6YXNUZXh0TGVhZk1hcmtlciBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OmlzVGV4dExlYWYgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjp0ZXh0UnVuSW5k ZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpsaW5lUmFuZ2UgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpzdWJzdHJpbmcgY29uc3QpOgoqIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmg6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OkFYVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6Om9mZnNldCBjb25zdCk6 CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bnM6OmRlYnVnRGVzY3JpcHRpb24gY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6aW5kZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoU3VtVG8gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6c3Vic3RyaW5nIGNvbnN0 KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bkxpbmVJRDo6QVhUZXh0UnVuTGluZUlEKToKKFdlYkNvcmU6OkFYVGV4 dFJ1bkxpbmVJRDo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRSdW46 OkFYVGV4dFJ1bik6CihXZWJDb3JlOjpBWFRleHRSdW46OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6QVhUZXh0UnVucyk6CihXZWJDb3JlOjpBWFRleHRSdW5z OjpzaXplIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6OmF0IGNvbnN0KToKKFdlYkNvcmU6 OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoU3VtIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dFJ1bnM6OmxpbmVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRy ZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoK KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNw cDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFY SXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcgY29uc3QpOgooV2ViQ29yZTo6QVhJc29sYXRlZE9iamVj dDo6dGV4dFJ1bnMgY29uc3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHA6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJl ZTo6b2JqZWN0c0ZvcklEcyBjb25zdCk6IERlbGV0ZWQuCiogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaDoKKFdlYkNvcmU6OkFYSXNvbGF0 ZWRUcmVlOjpvYmplY3RzRm9ySURzIGNvbnN0KToKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJz LmNtYWtlICAgICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50 eHQgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiB8ICAgNiArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYQ29yZU9iamVjdC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmNwcCB8IDI0OCArKysrKysrKysrKysrKysrKy0KIFNvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmggICB8ICA1MSArKysrCiBTb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAgICAgfCAgOTMgKysrKysrKwogU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaCAgICAgIHwgMTIwICsrKysrKysrKwogLi4u L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAgICAgIHwgICA2ICsKIC4uLi9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaCAgICAgICB8ICAgNSArCiAuLi4vQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAgICAgICAgICAgICAgfCAgIDYgKy0KIC4uLi9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCB8ICAgMiArLQogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCAgICAgICAgIHwgIDMwICsrKwogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmggICAgICAgICAgIHwgIDE2ICstCiAuLi4vaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcCAgICAgICAgICAgfCAgMTcgKy0KIC4uLi9pc29sYXRl ZHRyZWUvQVhJc29sYXRlZFRyZWUuaCAgICAgICAgICAgICB8ICAxOSArLQogMTYgZmlsZXMgY2hh bmdlZCwgNTk2IGluc2VydGlvbnMoKyksIDQ0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAw NjQ0IFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcAogY3JlYXRlIG1v ZGUgMTAwNjQ0IFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvSGVh ZGVycy5jbWFrZQppbmRleCAxYWUxN2E1MmQwOTEuLjc5YzM3ZmFjZDhkYSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJz LmNtYWtlCkBAIC02NTIsNiArNjUyLDcgQEAgc2V0KFdlYkNvcmVfUFJJVkFURV9GUkFNRVdPUktf SEVBREVSUwogICAgIGFjY2Vzc2liaWxpdHkvQVhMb2dnZXIuaAogICAgIGFjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5oCiAgICAgYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAorICAgIGFj Y2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dFN0YXRlQ2hh bmdlSW50ZW50LmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVHJlZVN0b3JlLmgKICAgICBhY2Nlc3Np YmlsaXR5L0FjY2Vzc2liaWxpdHlMaXN0Qm94LmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L1NvdXJjZXMudHh0IGIvU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQKaW5kZXggMTc4NDc4ZGQ4 YWJmLi41NjRjYjMxODI2NjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0 CisrKyBiL1NvdXJjZS9XZWJDb3JlL1NvdXJjZXMudHh0CkBAIC01MjIsNiArNTIyLDcgQEAgYWNj ZXNzaWJpbGl0eS9BWEltYWdlLmNwcAogYWNjZXNzaWJpbGl0eS9BWExvZ2dlci5jcHAKIGFjY2Vz c2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKIGFjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNw cAorYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwCiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxp dHlBUklBR3JpZC5jcHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5j cHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkUm93LmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDllNzVj ZjA5ZTQ0Mi4uZDMwMWMxN2UzMWYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xNzUyLDYgKzE3NTIsNyBAQAogCQk0N0ZBOTcw MDI2NTA5ODJCMDA4NDE0MTYgLyogVGFibGVGb3JtYXR0aW5nR2VvbWV0cnkuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ3RkE5NkZGMjY1MDk4MkEwMDg0 MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJV VEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ4MjI5NzBFMjlDOEVCQzAwMDMzQTEyNiAvKiBS ZWdpb25Db250ZXh0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA0ODIyOTcwQzI5QzhFQkMwMDAzM0ExMjYgLyogUmVnaW9uQ29udGV4dC5oICovOyBzZXR0 aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ4NkI4REM3MkEwNDND MDYwMEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDg2QjhEQzYyQTA0M0MwNjAwRTAwRTczIC8qIEFYR2Vv bWV0cnlNYW5hZ2VyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsg fTsgfTsKKwkJNDhCMDI0MkEyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDhCMDI0MjgyQjJBNjVBQTAw ODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07CiAJCTQ4QjVCRjM3MjlDQTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5 UmVnaW9uQ29udGV4dC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNDhCNUJGMzUyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250 ZXh0LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ NDhEMEUxMjkyOUY3MzI5RTAwMjYzODU3IC8qIEVsZW1lbnRBbmltYXRpb25Db250ZXh0LmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEQwRTEyODI5Rjcz MjI5MDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7 QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk0OTEzNDJFMzJCNDNGRkVGMDBGRUVG MTggLyogQ1NTU2VsZWN0b3JJbmxpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA0OTEzNDJEQTJCNDNGQUE4MDBGRUVGMTggLyogQ1NTU2VsZWN0b3JJ bmxpbmVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK QEAgLTEwNzI0LDggKzEwNzI1LDEwIEBACiAJCTQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBS ZWdpb25Db250ZXh0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJlZ2lvbkNv bnRleHQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDg2QjhEQzYyQTA0M0MwNjAw RTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFYR2VvbWV0cnlN YW5hZ2VyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4NkI4REM4MkEwNDUwMEYw MEUwMEU3MyAvKiBBWEdlb21ldHJ5TWFuYWdlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBBWEdlb21ldHJ5TWFuYWdlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CisJCTQ4QjAyNDI4MkIyQTY1QUEwMDgzRDEyMiAvKiBBWFRleHRSdW4uaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gQVhUZXh0UnVuLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4QjVC RjM1MjlDQTY5MTcwMEZFQkUzQiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OEI1QkYzNjI5Q0E2OTE3MDBGRUJFM0Ig LyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQWNj ZXNzaWJpbGl0eVJlZ2lvbkNvbnRleHQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owor CQk0OEM0RTgzQzJCMzREODM4MDA4MzQ2MEEgLyogQVhUZXh0UnVuLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IEFYVGV4dFJ1bi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4RDBF MTI4MjlGNzMyMjkwMDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk0OTEzNDI5NjJCNDI1QzAxMDBGRUVGMTggLyogQ1NTUHNldWRvU2VsZWN0b3JzLmpz b24gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0 Lmpzb247IHBhdGggPSBDU1NQc2V1ZG9TZWxlY3RvcnMuanNvbjsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNDkxMzQyOTcyQjQyNUMwMjAwRkVFRjE4IC8qIHByb2Nlc3MtY3NzLXBzZXVk by1zZWxlY3RvcnMucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSAicHJvY2Vzcy1jc3MtcHNldWRvLXNl bGVjdG9ycy5weSI7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMzE5OCw2ICsyMzIw MSw4IEBACiAJCQkJMjlBODEyMUEwRkJCOUMxRDAwNTEwMjkzIC8qIEFYT2JqZWN0Q2FjaGUuaCAq LywKIAkJCQlDMEUyMDhBMTI5Mzc5QzZGMDBDMEQyRDMgLyogQVhUZXh0TWFya2VyLmNwcCAqLywK IAkJCQlDMEUyMDhBMDI5Mzc5QzZFMDBDMEQyRDMgLyogQVhUZXh0TWFya2VyLmggKi8sCisJCQkJ NDhDNEU4M0MyQjM0RDgzODAwODM0NjBBIC8qIEFYVGV4dFJ1bi5jcHAgKi8sCisJCQkJNDhCMDI0 MjgyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovLAogCQkJCTkxQzlGMkY4MUFFM0JF MjQwMDk1QjYxQyAvKiBBWFRleHRTdGF0ZUNoYW5nZUludGVudC5oICovLAogCQkJCUMwRThBREM0 Mjk0QjVBNjIwMDc2Q0JEQyAvKiBBWFRyZWVTdG9yZS5oICovLAogCQkJCUJDNEE1MzMwMjU2MDU5 MDMwMDI4QzU5MiAvKiBGb3JjZWRBY2Nlc3NpYmlsaXR5VmFsdWUuaCAqLywKQEAgLTM3NTkzLDYg KzM3NTk4LDcgQEAKIAkJCQkyOUFFMjEyRDIxQUI5RUVCMDA4NjkyODMgLyogQVhJc29sYXRlZFRy ZWUuaCBpbiBIZWFkZXJzICovLAogCQkJCTI5QTgxMjM4MEZCQjlDMUQwMDUxMDI5MyAvKiBBWE9i amVjdENhY2hlLmggaW4gSGVhZGVycyAqLywKIAkJCQlDMEUyMDhBMjI5Mzc5QzZGMDBDMEQyRDMg LyogQVhUZXh0TWFya2VyLmggaW4gSGVhZGVycyAqLywKKwkJCQk0OEIwMjQyQTJCMkE2NUFBMDA4 M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVhZGVycyAqLywKIAkJCQk5MUM5RjJGOTFBRTNCRUIw MDA5NUI2MUMgLyogQVhUZXh0U3RhdGVDaGFuZ2VJbnRlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJ CUMwRThBREM1Mjk0QjVBNjMwMDc2Q0JEQyAvKiBBWFRyZWVTdG9yZS5oIGluIEhlYWRlcnMgKi8s CiAJCQkJMTQ3N0U3NzcwQkY0MTM0QTAwMTUyODcyIC8qIEJhY2tGb3J3YXJkQ2FjaGUuaCBpbiBI ZWFkZXJzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENv cmVPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgK aW5kZXggN2QxOGY1MjEyNjk1Li45NDMyZGVkNmE4NWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhDb3JlT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaApAQCAtMTEzLDE5ICsxMTMsNiBAQCBlbnVtIGNsYXNz IEFYQW5jZXN0b3JGbGFnIDogdWludDhfdCB7CiAgICAgLy8gQml0IDcgaXMgZnJlZS4KIH07CiAK LSNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLXN0cnVjdCBBWFRleHRSdW4gewotICAg IC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUg Y29udGFpbmluZyBSZW5kZXJCbG9ja0Zsb3cgb2YgdGhlIG1haW4tdGhyZWFkIEFYIG9iamVjdC4K LSAgICBzaXplX3QgbGluZUluZGV4OwotICAgIFN0cmluZyB0ZXh0OwotCi0gICAgQVhUZXh0UnVu KHNpemVfdCBsaW5lSW5kZXgsIFN0cmluZyYmIHRleHQpCi0gICAgICAgIDogbGluZUluZGV4KGxp bmVJbmRleCkKLSAgICAgICAgLCB0ZXh0KFdURk1vdmUodGV4dCkpCi0gICAgeyB9Ci19OwotI2Vu ZGlmCi0KIGVudW0gY2xhc3MgQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIEFwcGxpY2F0aW9uID0g MSwKICAgICBBcHBsaWNhdGlvbkFsZXJ0LApAQCAtNjU2LDYgKzY0Myw4IEBAIGVudW0gY2xhc3Mg QWNjZXNzaWJpbGl0eUJ1dHRvblN0YXRlIHsKICAgICBNaXhlZCwKIH07CiAKK2VudW0gY2xhc3Mg QVhEaXJlY3Rpb24gOiBib29sIHsgTmV4dCwgUHJldmlvdXMgfTsKKwogZW51bSBjbGFzcyBBY2Nl c3NpYmlsaXR5U29ydERpcmVjdGlvbiB7CiAgICAgTm9uZSwKICAgICBBc2NlbmRpbmcsCkBAIC04 MDMsNiArNzkyLDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRPYmplY3RJRChBWElEIGF4SUQp IHsgbV9pZCA9IGF4SUQ7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyByZXR1cm4gbV9p ZDsgfQorICAgIHZpcnR1YWwgQVhJRCB0cmVlSUQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQ cm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29uc3QgPSAwOwogCiAgICAgLy8gV2hlbiB0aGUgY29ycmVz cG9uZGluZyBXZWJDb3JlIG9iamVjdCB0aGF0IHRoaXMgYWNjZXNzaWJsZSBvYmplY3QKQEAgLTEx MDcsOSArMTA5Nyw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWNjZXNzaWJpbGl0eVRl eHQoVmVjdG9yPEFjY2Vzc2liaWxpdHlUZXh0PiYpIGNvbnN0ID0gMDsKICAgICAvLyBBIHByb2dy YW1tYXRpYyB3YXkgdG8gc2V0IGEgbmFtZSBvbiBhbiBBY2Nlc3NpYmxlT2JqZWN0LgogICAgIHZp cnR1YWwgdm9pZCBzZXRBY2Nlc3NpYmxlTmFtZShjb25zdCBBdG9tU3RyaW5nJikgPSAwOwotI2lm IEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIHZpcnR1YWwgVmVjdG9yPEFYVGV4dFJ1 bj4gdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KLSNlbmRpZgogCiAgICAgdmlydHVhbCBTdHJp bmcgdGl0bGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgZGVzY3JpcHRpb24oKSBj b25zdCA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4 dE1hcmtlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5j cHAKaW5kZXggOWFkNmFiZjkzYWFjLi44OWExNTQ2ODdhYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5jcHAKQEAgLTE5NCw2ICsxOTQsMTYgQEAgc3Rk OjpvcHRpb25hbDxCb3VuZGFyeVBvaW50PiBBWFRleHRNYXJrZXI6OmJvdW5kYXJ5UG9pbnQoKSBj b25zdAogICAgIHJldHVybiB7IHsgKm5vZGUsIHN0YXRpY19jYXN0PHVuc2lnbmVkPihvZmZzZXQp IH0gfTsKIH0KIAorI2lmIEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCitSZWZQ dHI8QVhJc29sYXRlZE9iamVjdD4gQVhUZXh0TWFya2VyOjppc29sYXRlZE9iamVjdCgpIGNvbnN0 Cit7CisgICAgaWYgKGlzTnVsbCgpIHx8IGlzTWFpblRocmVhZCgpKQorICAgICAgICByZXR1cm4g bnVsbHB0cjsKKyAgICBhdXRvIHRyZWUgPSBzdGQ6OmdldDxSZWZQdHI8QVhJc29sYXRlZFRyZWU+ PihheFRyZWVGb3JJRCh0cmVlSUQoKSkpOworICAgIHJldHVybiB0cmVlID8gdHJlZS0+b2JqZWN0 Rm9ySUQob2JqZWN0SUQoKSkgOiBudWxscHRyOworfQorI2VuZGlmIC8vIEVOQUJMRShBQ0NFU1NJ QklMSVRZX0lTT0xBVEVEX1RSRUUpCisKIFJlZlB0cjxBWENvcmVPYmplY3Q+IEFYVGV4dE1hcmtl cjo6b2JqZWN0KCkgY29uc3QKIHsKICAgICBpZiAoaXNOdWxsKCkpCkBAIC0zMzUsNyArMzQ1LDcg QEAgc3RkOjpvcHRpb25hbDxBWFRleHRNYXJrZXJSYW5nZT4gQVhUZXh0TWFya2VyUmFuZ2U6Omlu dGVyc2VjdGlvbldpdGgoY29uc3QgQVhUZXgKIAogU3RyaW5nIEFYVGV4dE1hcmtlclJhbmdlOjpk ZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6 IHsiLCBtX3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogeyIsIG1fZW5kLmRlYnVn RGVzY3JpcHRpb24oKSwgIn0iKTsKKyAgICByZXR1cm4gbWFrZVN0cmluZygic3RhcnQ6IHsiLCBt X3N0YXJ0LmRlYnVnRGVzY3JpcHRpb24oKSwgIn1cbmVuZDogICB7IiwgbV9lbmQuZGVidWdEZXNj cmlwdGlvbigpLCAifSIpOwogfQogCiBzdGQ6OnBhcnRpYWxfb3JkZXJpbmcgcGFydGlhbE9yZGVy KGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMSwgY29uc3QgQVhUZXh0TWFya2VyJiBtYXJrZXIy KQpAQCAtMzY4LDQgKzM3OCwyNDAgQEAgYm9vbCBBWFRleHRNYXJrZXJSYW5nZTo6aXNDb25maW5l ZFRvKEFYSUQgb2JqZWN0SUQpIGNvbnN0CiAgICAgICAgICYmIExJS0VMWShtX3N0YXJ0LnRyZWVJ RCgpID09IG1fZW5kLnRyZWVJRCgpKTsKIH0KIAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9B UElTKQorZW51bSBjbGFzcyBDaGVja1N0YXJ0IDogYm9vbCB7IE5vLCBZZXMgfTsKKy8vIEZpbmRz IHRoZSBuZXh0IG9iamVjdCB3aXRoIHRleHQgcnVucyBpbiB0aGUgZ2l2ZW4gZGlyZWN0aW9uLgor c3RhdGljIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBmaW5kT2JqZWN0V2l0aFJ1bnMoQVhJc29s YXRlZE9iamVjdCYgc3RhcnQsIEFYRGlyZWN0aW9uIGRpcmVjdGlvbiwgQ2hlY2tTdGFydCBjaGVj a1N0YXJ0ID0gQ2hlY2tTdGFydDo6Tm8pCit7CisgICAgaWYgKGNoZWNrU3RhcnQgPT0gQ2hlY2tT dGFydDo6WWVzKSB7CisgICAgICAgIGlmIChhdXRvKiBydW5zID0gc3RhcnQudGV4dFJ1bnMoKTsg cnVucyAmJiBydW5zLT5zaXplKCkpCisgICAgICAgICAgICByZXR1cm4gJnN0YXJ0OworICAgIH0K KworICAgIFJlZlB0ciBjdXJyZW50ID0gJnN0YXJ0OworICAgIHdoaWxlIChjdXJyZW50KSB7Cisg ICAgICAgIGlmIChjdXJyZW50ICE9ICZzdGFydCkgeworICAgICAgICAgICAgYXV0byogcnVucyA9 IGN1cnJlbnQtPnRleHRSdW5zKCk7CisgICAgICAgICAgICBpZiAocnVucyAmJiBydW5zLT5zaXpl KCkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGN1cnJlbnQ7CisgICAgICAgIH0KKworICAgICAg ICAvLyBGSVhNRTogYXJpYS1vd25zIGJyZWFrcyB0aGlzIHRyYXZlcnNhbCwgYXMgYXJpYS1vd25z IGNhdXNlcyB0aGUgQVggdHJlZSB0byBiZSBjaGFuZ2VkLCBhZmZlY3RpbmcKKyAgICAgICAgLy8g b3VyIGl0ZXJhdGlvbiBiZWxvdywgYnV0IGl0IGRvZXNuJ3QgYWN0dWFsbHkgY2hhbmdlIHRleHQg cG9zaXRpb24gb24gdGhlIHBhZ2UuIFNvIHdlIG5lZWQgdG8gaWdub3JlIGFyaWEtb3ducworICAg ICAgICAvLyB0cmVlIGNoYW5nZXMgaGVyZSBpbiBvcmRlciB0byBiZWhhdmUgY29ycmVjdGx5Lgor ICAgICAgICAvLyBXZSBhbHNvIHByb2JhYmx5IG5lZWQgdG8gZG8gc29tZXRoaW5nIGFib3V0IHRl eHQgd2l0aGluIGFyaWEtaGlkZGVuIGNvbnRhaW5lcnMsIHdoaWNoIGFmZmVjdHMgdGhlIEFYIHRy ZWUuCisKKyAgICAgICAgY29uc3QgYXV0byYgY2hpbGRyZW4gPSBjdXJyZW50LT5jaGlsZHJlbigp OworICAgICAgICBpZiAoY2hpbGRyZW4uc2l6ZSgpKSB7CisgICAgICAgICAgICBzaXplX3QgY2hp bGRJbmRleCA9IGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IDAgOiBjaGlsZHJlbi5z aXplKCkgLSAxOworICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoY2hpbGRyZW5bY2hpbGRJbmRl eF0pOworICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2Jq ZWN0PihjaGlsZHJlbltjaGlsZEluZGV4XS5nZXQoKSk7CisgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgfQorCisgICAgICAgIC8vIGBjdXJyZW50YCBoYXMgbm8gY2hpbGRyZW4sIG1lYW5p bmcgaXQncyBhIGxlYWYgbm9kZSAoZS5nLiBpdCdzIHRleHQsIHdoaWNoIGNhbm5vdCBoYXZlIGNo aWxkcmVuKS4KKyAgICAgICAgLy8gQ2hlY2sgYGN1cnJlbnRgcyBzaWJsaW5ncy4KKyAgICAgICAg aWYgKGF1dG8qIHNpYmxpbmcgPSBjdXJyZW50LT5zaWJsaW5nKGRpcmVjdGlvbikpIHsKKyAgICAg ICAgICAgIGN1cnJlbnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oc2libGlu Zyk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFdlIGhh dmUgbm8gY2hpbGRyZW4sIGFuZCBubyBuZXh0L3ByZXZpb3VzIHNpYmxpbmcuIFRyeSBvdXIgcGFy ZW50J3Mgc2libGluZy4KKyAgICAgICAgaWYgKGF1dG8qIHBhcmVudCA9IGN1cnJlbnQtPnBhcmVu dE9iamVjdFVuaWdub3JlZCgpKSB7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1pY0Rvd25j YXN0PEFYSXNvbGF0ZWRPYmplY3Q+KHBhcmVudC0+c2libGluZyhkaXJlY3Rpb24pKTsKKyAgICAg ICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgYnJlYWs7CisgICAgfQorICAg IHJldHVybiBudWxscHRyOworfQorCitTdHJpbmcgQVhUZXh0TWFya2VyUmFuZ2U6OnRvU3RyaW5n KCkgY29uc3QKK3sKKyAgICBSRUxFQVNFX0FTU0VSVCghaXNNYWluVGhyZWFkKCkpOworCisgICAg YXV0byBzdGFydCA9IG1fc3RhcnQuYXNUZXh0TGVhZk1hcmtlcigpOworICAgIGlmICghc3RhcnQu aXNWYWxpZCgpKQorICAgICAgICByZXR1cm4gZW1wdHlTdHJpbmcoKTsKKyAgICBhdXRvIGVuZCA9 IG1fZW5kLmFzVGV4dExlYWZNYXJrZXIoKTsKKyAgICBpZiAoIWVuZC5pc1ZhbGlkKCkpCisgICAg ICAgIHJldHVybiBlbXB0eVN0cmluZygpOworCisgICAgaWYgKHN0YXJ0Lmlzb2xhdGVkT2JqZWN0 KCkgPT0gZW5kLmlzb2xhdGVkT2JqZWN0KCkpIHsKKyAgICAgICAgc2l6ZV90IG1pbk9mZnNldCA9 IHN0ZDo6bWluKHN0YXJ0Lm9mZnNldCgpLCBlbmQub2Zmc2V0KCkpOworICAgICAgICBzaXplX3Qg bWF4T2Zmc2V0ID0gc3RkOjptYXgoc3RhcnQub2Zmc2V0KCksIGVuZC5vZmZzZXQoKSk7CisgICAg ICAgIHJldHVybiBzdGFydC5zdWJzdHJpbmcobWluT2Zmc2V0LCBtYXhPZmZzZXQgLSBtaW5PZmZz ZXQpOworICAgIH0KKworICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHJlc3VsdC5hcHBl bmQoc3RhcnQuc3Vic3RyaW5nKHN0YXJ0Lm9mZnNldCgpKSk7CisKKyAgICAvLyBGSVhNRTogSWYg d2UndmUgYmVlbiBnaXZlbiByZXZlcnNlZCBtYXJrZXJzLCBpLmUuIHRoZSBlbmQgbWFya2VyIGFj dHVhbGx5IGNvbWVzIGJlZm9yZSB0aGUgc3RhcnQgbWFya2VyLAorICAgIC8vIHdlIG1heSB3YW50 IHRvIGRldGVjdCB0aGlzIGFuZCB0cnkgc2VhcmNoaW5nIEFYRGlyZWN0aW9uOjpQcmV2aW91cz8K KyAgICBSZWZQdHIgY3VycmVudCA9IHN0YXJ0Lmlzb2xhdGVkT2JqZWN0KCk7CisgICAgd2hpbGUg KGN1cnJlbnQtPm9iamVjdElEKCkgIT0gZW5kLm9iamVjdElEKCkpIHsKKyAgICAgICAgY3VycmVu dCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudCwgQVhEaXJlY3Rpb246Ok5leHQpOworICAg ICAgICBpZiAoIWN1cnJlbnQpCisgICAgICAgICAgICBicmVhazsKKworICAgICAgICBjb25zdCBh dXRvKiBydW5zID0gY3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBp ID0gMDsgaSA8IHJ1bnMtPnNpemUoKTsgaSsrKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChy dW5zLT5hdChpKS50ZXh0KTsKKyAgICB9CisgICAgcmVzdWx0LmFwcGVuZChlbmQuc3Vic3RyaW5n KDAsIGVuZC5vZmZzZXQoKSkpOworICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsKK30KKwor Y29uc3QgQVhUZXh0UnVucyogQVhUZXh0TWFya2VyOjpydW5zKCkgY29uc3QKK3sKKyAgICBSZWZQ dHIgb2JqZWN0ID0gaXNvbGF0ZWRPYmplY3QoKTsKKyAgICByZXR1cm4gb2JqZWN0ID8gb2JqZWN0 LT50ZXh0UnVucygpIDogbnVsbHB0cjsKK30KKworQVhUZXh0TWFya2VyIEFYVGV4dE1hcmtlcjo6 ZmluZE1hcmtlcihBWERpcmVjdGlvbiBkaXJlY3Rpb24pIGNvbnN0Cit7CisgICAgaWYgKCFpc1Zh bGlkKCkpCisgICAgICAgIHJldHVybiB7IH07CisgICAgaWYgKCFpc1RleHRMZWFmKCkpCisgICAg ICAgIHJldHVybiBhc1RleHRMZWFmTWFya2VyKCkuZmluZE1hcmtlcihkaXJlY3Rpb24pOworICAg IFJFTEVBU0VfQVNTRVJUKGlzVGV4dExlYWYoKSk7CisKKyAgICBzaXplX3QgcnVuSW5kZXggPSB0 ZXh0UnVuSW5kZXhGb3JPZmZzZXQoKTsKKyAgICBhdXRvIGhhc01vcmVUZXh0SW5DdXJyZW50UnVu ID0gWyZdIHsKKyAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAg ICAgICAgICAgIHJldHVybiBvZmZzZXQoKSA8IHJ1bnMoKS0+YXQocnVuSW5kZXgpLnRleHQubGVu Z3RoKCk7CisgICAgICAgIHJldHVybiBvZmZzZXQoKSA+IDA7CisgICAgfTsKKyAgICBib29sIGhh c0Fub3RoZXJSdW4gPSBydW5JbmRleCArIDEgPCBydW5zKCktPnNpemUoKTsKKyAgICAvLyBUaGUg bmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRleHQsIGJlY2F1c2Ugd2UncmUgZ29pbmcg dG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBvZmZzZXQoKSArIDEsIHdoaWNoIHdvdWxk IGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6 UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVucygpLT5ydW5MZW5ndGgocnVuSW5kZXgg KyAxKSA+IDApOworICAgIC8vIENoZWNraW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5vdGhlciBy dW4gaXMgb25seSByZWxldmFudCBmb3IgbW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBhcyBqdXN0 IGNoZWNraW5nIHRoYXQgb2Zmc2V0KCkgPiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGlyZWN0aW9u OjpQcmV2aW91cy4KKyAgICBpZiAoaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAoZGlyZWN0 aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAgICAgIC8v IFJldHVybiBhbiBvZmZzZXQgdG8gdGhlIG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJyZW50IHJ1 bi4KKyAgICAgICAgcmV0dXJuIHsgdHJlZUlEKCksIG9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBB WERpcmVjdGlvbjo6TmV4dCA/IG9mZnNldCgpICsgMSA6IG9mZnNldCgpIC0gMSB9OworICAgIH0K KyAgICAvLyBvZmZzZXQoKSBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3RlciBpbiB0aGUgZ2l2 ZW4gb2JqZWN0J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0aGUgbmV4dCBvYmpl Y3Qgd2l0aCBydW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9iamVjdFdpdGhSdW5z KCp0aGlzLT5pc29sYXRlZE9iamVjdCgpLCBkaXJlY3Rpb24pKQorICAgICAgICByZXR1cm4geyBv YmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5zKCktPmxhc3RSdW5MZW5ndGgoKSB9Owor CisgICAgcmV0dXJuIHsgfTsKK30KKworQVhUZXh0TWFya2VyIEFYVGV4dE1hcmtlcjo6ZmluZE1h cmtlcihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4dFVuaXQsIEFYVGV4dFVu aXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoIWlzVmFsaWQoKSkKKyAgICAg ICAgcmV0dXJuIHsgfTsKKyAgICBpZiAoIWlzVGV4dExlYWYoKSkKKyAgICAgICAgcmV0dXJuIGFz VGV4dExlYWZNYXJrZXIoKS5maW5kTWFya2VyKGRpcmVjdGlvbiwgdGV4dFVuaXQsIGJvdW5kYXJ5 KTsKKyAgICBSRUxFQVNFX0FTU0VSVChpc1RleHRMZWFmKCkpOworCisgICAgaWYgKHRleHRVbml0 ID09IEFYVGV4dFVuaXQ6OkxpbmUpIHsKKyAgICAgICAgc2l6ZV90IHJ1bkluZGV4ID0gdGV4dFJ1 bkluZGV4Rm9yT2Zmc2V0KCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2JqZWN0ID0gaXNvbGF0 ZWRPYmplY3QoKTsKKyAgICAgICAgY29uc3QgYXV0byogY3VycmVudFJ1bnMgPSBjdXJyZW50T2Jq ZWN0LT50ZXh0UnVucygpOworCisgICAgICAgIGF1dG8gY29tcHV0ZU9mZnNldCA9IFsmXSAoc2l6 ZV90IHJ1bkVuZE9mZnNldCwgc2l6ZV90IHJ1bkxlbmd0aCkgeworICAgICAgICAgICAgLy8gVGhp cyB3b3JrcyBiZWNhdXNlIGBydW5FbmRPZmZzZXRgIGlzIHRoZSBvZmZzZXQgcG9pbnRpbmcgdG8g dGhlIGVuZCBvZiB0aGUgZ2l2ZW4gcnVuLCB3aGljaCBpbmNsdWRlcyB0aGUgbGVuZ3RoIG9mIGFs bCBydW5zIHByZWNlZGluZyBpdC4gU28gc3VidHJhY3RpbmcgdGhhdCBmcm9tIHRoZSBsZW5ndGgg b2YgdGhlIGN1cnJlbnQgcnVuIGdpdmVzIHVzIGFuIG9mZnNldCB0byB0aGUgc3RhcnQgb2YgdGhl IGN1cnJlbnQgcnVuLgorICAgICAgICAgICAgcmV0dXJuIGJvdW5kYXJ5ID09IEFYVGV4dFVuaXRC b3VuZGFyeTo6RW5kID8gcnVuRW5kT2Zmc2V0IDogcnVuRW5kT2Zmc2V0IC0gcnVuTGVuZ3RoOwor ICAgICAgICB9OworICAgICAgICBhdXRvIGxpbmVQb3NpdGlvbiA9IEFYVGV4dE1hcmtlcih0cmVl SUQoKSwgb2JqZWN0SUQoKSwgY29tcHV0ZU9mZnNldChjdXJyZW50UnVucy0+cnVuTGVuZ3RoU3Vt VG8ocnVuSW5kZXgpLCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKHJ1bkluZGV4KSkpOworICAgICAg ICBhdXRvIHN0YXJ0TGluZUlEID0gY3VycmVudFJ1bnMtPmxpbmVJRChydW5JbmRleCk7CisgICAg ICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0ZWQgbGluZSwgbm93IGl0 ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAgICAgIHdoaWxlIChjdXJy ZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjdXJyZW50UnVucy0+c2l6 ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZzZXQgPSAwOworICAgICAg ICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+c2l6ZSgpOyBpKyspIHsK KyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5zLT5ydW5MZW5n dGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5saW5lSUQoaSkgIT0gc3Rh cnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5lUG9zaXRpb247CisgICAg ICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhUZXh0TWFya2VyKGN1cnJlbnRPYmplY3QtPnRy ZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJRCgpLCBjb21wdXRlT2Zmc2V0KGN1bXVsYXRp dmVPZmZzZXQsIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSkpKTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIGN1cnJlbnRPYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnRPYmpl Y3QsIGRpcmVjdGlvbik7CisgICAgICAgICAgICBpZiAoY3VycmVudE9iamVjdCkKKyAgICAgICAg ICAgICAgICBjdXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRleHRSdW5zKCk7CisgICAgICAg IH0KKyAgICAgICAgcmV0dXJuIGxpbmVQb3NpdGlvbjsKKyAgICB9CisgICAgLy8gRklYTUU6IElt cGxlbWVudCB0aGUgb3RoZXIgQVhUZXh0VW5pdHMuCisKKyAgICByZXR1cm4geyB9OworfQorCitB WFRleHRNYXJrZXIgQVhUZXh0TWFya2VyOjphc1RleHRMZWFmTWFya2VyKCkgY29uc3QKK3sKKyAg ICBpZiAoIWlzVmFsaWQoKSB8fCBpc1RleHRMZWFmKCkpIHsKKyAgICAgICAgLy8gSWYgc29tZXRo aW5nIGhhcyBjb25zdHJ1Y3RlZCBhIGxlYWYgbWFya2VyLCBpdCBzaG91bGQndmUgZG9uZSBzbyB3 aXRoIGFuIGluLWJvdW5kcyBvZmZzZXQuCisgICAgICAgIFJFTEVBU0VfQVNTRVJUKCFpc1ZhbGlk KCkgfHwgaXNvbGF0ZWRPYmplY3QoKS0+dGV4dFJ1bnMoKS0+cnVuTGVuZ3RoU3VtKCkgPj0gb2Zm c2V0KCkpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgLy8gRmluZCB0aGUg bGVhZiBub2RlIG91ciBvZmZzZXQgcG9pbnRzIHRvLiBGb3IgZXhhbXBsZToKKyAgICAvLyBBWFRl eHRNYXJrZXIgeyBJRCAxOiBHcm91cCwgT2Zmc2V0IDYgfQorICAgIC8vIElEIDE6IEdyb3VwCisg ICAgLy8gIC0gSUQgMjogRm9vCisgICAgLy8gIC0gSUQgMzogTGluZTEKKyAgICAvLyAgICAgICAg ICBMaW5lMgorICAgIC8vIENhbGxpbmcgYXNUZXh0TGVhZk1hcmtlcigpIG9uIHRoZSBvcmlnaW5h bCBtYXJrZXIgc2hvdWxkIHlpZWxkIG5ldyBtYXJrZXI6CisgICAgLy8gQVhUZXh0TWFya2VyIHsg SUQgMzogU3RhdGljVGV4dCwgT2Zmc2V0IDMgfQorICAgIC8vIEJlY2F1c2Ugd2UgaGFkIHRvIHdh bGsgb3ZlciBJRCAyIHdoaWNoIGhhZCBsZW5ndGggMyB0ZXh0LgorICAgIHNpemVfdCBwcmVjZWRp bmdPZmZzZXQgPSAwOworICAgIFJlZlB0ciBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpp c29sYXRlZE9iamVjdCgpLCBBWERpcmVjdGlvbjo6TmV4dCwgQ2hlY2tTdGFydDo6WWVzKTsKKyAg ICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICB1bnNpZ25lZCBjdXJyZW50U3VtID0gY3VycmVu dC0+dGV4dFJ1bnMoKS0+cnVuTGVuZ3RoU3VtKCk7CisgICAgICAgIGlmIChwcmVjZWRpbmdPZmZz ZXQgKyBjdXJyZW50U3VtID49IG9mZnNldCgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAg IHByZWNlZGluZ09mZnNldCArPSBjdXJyZW50U3VtOworICAgICAgICBjdXJyZW50ID0gZmluZE9i amVjdFdpdGhSdW5zKCpjdXJyZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgfQorCisgICAg aWYgKCFjdXJyZW50KQorICAgICAgICByZXR1cm4geyB9OworCisgICAgUkVMRUFTRV9BU1NFUlQo b2Zmc2V0KCkgPj0gcHJlY2VkaW5nT2Zmc2V0KTsKKyAgICByZXR1cm4geyBjdXJyZW50LT50cmVl SUQoKSwgY3VycmVudC0+b2JqZWN0SUQoKSwgc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KG9mZnNldCgp IC0gcHJlY2VkaW5nT2Zmc2V0KSB9OworfQorCitib29sIEFYVGV4dE1hcmtlcjo6aXNUZXh0TGVh ZigpIGNvbnN0Cit7CisgICAgUmVmUHRyIG9iamVjdCA9IHRoaXMtPmlzb2xhdGVkT2JqZWN0KCk7 CisgICAgLy8gRklYTUU6IElzIGl0IHBvc3NpYmxlIGZvciBub24tbGVhZiBub2RlcyB0byBoYXZl IHRleHQgcnVucz8gSWYgc28sIHdlIGRvbid0IGhhbmRsZSB0aGVtIGNvcnJlY3RseS4KKyAgICBy ZXR1cm4gIW9iamVjdCB8fCAoIW9iamVjdC0+Y2hpbGRyZW4oKS5zaXplKCkgJiYgb2JqZWN0LT50 ZXh0UnVucygpKTsKK30KKworc2l6ZV90IEFYVGV4dE1hcmtlcjo6dGV4dFJ1bkluZGV4Rm9yT2Zm c2V0KCkgY29uc3QKK3sKKyAgICBhdXRvKiBydW5zID0gdGhpcy0+cnVucygpOworICAgIGlmICgh cnVucykKKyAgICAgICAgcmV0dXJuIG5vdEZvdW5kOworCisgICAgc2l6ZV90IGluZGV4ID0gcnVu cy0+aW5kZXhGb3JPZmZzZXQob2Zmc2V0KCkpOworICAgIC8vIElmIHdlIGNvdWxkbid0IGZpbmQg YSBjb3JyZXNwb25kaW5nIHJ1biwgdGhhdCBtZWFucyBvZmZzZXQoKSBwb2ludGVkIG91dCBvZiBi b3VuZHMgb2Ygb3VyIHRleHQgcnVucywgd2hpY2gKKyAgICAvLyB3b3VsZCBvbmx5IGhhcHBlbiBp ZiB3ZSd2ZSBjb25zdHJ1Y3RlZCBhbiBpbnZhbGlkIG1hcmtlci4KKyAgICBSRUxFQVNFX0FTU0VS VChpbmRleCAhPSBub3RGb3VuZCk7CisgICAgcmV0dXJuIGluZGV4OworfQorCitBWFRleHRNYXJr ZXJSYW5nZSBBWFRleHRNYXJrZXI6OmxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlIHR5cGUpIGNvbnN0 Cit7CisgICAgaWYgKCFpc1ZhbGlkKCkpCisgICAgICAgIHJldHVybiB7IHsgfSwgeyB9IH07CisK KyAgICBpZiAodHlwZSA9PSBMaW5lUmFuZ2VUeXBlOjpDdXJyZW50KQorICAgICAgICByZXR1cm4g eyBmaW5kTWFya2VyKEFYRGlyZWN0aW9uOjpQcmV2aW91cywgQVhUZXh0VW5pdDo6TGluZSwgQVhU ZXh0VW5pdEJvdW5kYXJ5OjpTdGFydCksIGZpbmRNYXJrZXIoQVhEaXJlY3Rpb246Ok5leHQsIEFY VGV4dFVuaXQ6OkxpbmUsIEFYVGV4dFVuaXRCb3VuZGFyeTo6RW5kKSB9OworICAgIC8vIEZJWE1F OiBUaGUgb3RoZXIgdHlwZXMgYXJlbid0IGltcGxlbWVudGVkIHlldC4KKyAgICBSRUxFQVNFX0FT U0VSVF9OT1RfUkVBQ0hFRCgpOworfQorCitTdHJpbmcgQVhUZXh0TWFya2VyOjpzdWJzdHJpbmco dW5zaWduZWQgc3RhcnQsIHVuc2lnbmVkIGxlbmd0aCkgY29uc3QKK3sKKyAgICBpZiAoIWlzVmFs aWQoKSkKKyAgICAgICAgcmV0dXJuIGVtcHR5U3RyaW5nKCk7CisgICAgaWYgKCFpc1RleHRMZWFm KCkpCisgICAgICAgIHJldHVybiBhc1RleHRMZWFmTWFya2VyKCkuc3Vic3RyaW5nKHN0YXJ0LCBs ZW5ndGgpOworICAgIFJFTEVBU0VfQVNTRVJUKGlzVGV4dExlYWYoKSk7CisgICAgcmV0dXJuIHJ1 bnMoKS0+c3Vic3RyaW5nKHN0YXJ0LCBsZW5ndGgpOworfQorI2VuZGlmIC8vIEVOQUJMRShBWF9U SFJFQURfVEVYVF9BUElTKQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oIGIvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAppbmRleCAxN2U5ZmMwZGFiOTguLjUyNDM3 NmY1YmVmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRN YXJrZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5o CkBAIC0yOCw3ICsyOCwyNSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKyNpZiBFTkFCTEUo QUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorY2xhc3MgQVhJc29sYXRlZE9iamVjdDsKKyNl bmRpZgogc3RydWN0IENoYXJhY3Rlck9mZnNldDsKK3N0cnVjdCBBWFRleHRSdW5zOworCitlbnVt IGNsYXNzIEFYVGV4dFVuaXQgOiB1aW50OF90IHsKKyAgICBMaW5lLAorICAgIFBhcmFncmFwaCwK KyAgICBTZW50ZW5jZSwKKyAgICBXb3JkLAorfTsKK2VudW0gY2xhc3MgQVhUZXh0VW5pdEJvdW5k YXJ5IDogYm9vbCB7IFN0YXJ0LCBFbmQsIH07CisKK2VudW0gY2xhc3MgTGluZVJhbmdlVHlwZSA6 IHVpbnQ4X3QgeworICAgIEN1cnJlbnQsCisgICAgTGVmdCwKKyAgICBSaWdodCwKK307CiAKIHN0 cnVjdCBUZXh0TWFya2VyRGF0YSB7CiAgICAgdW5zaWduZWQgdHJlZUlEOwpAQCAtMTA5LDYgKzEy Nyw5IEBAIHB1YmxpYzoKICNpZiBQTEFURk9STShDT0NPQSkKICAgICBBWFRleHRNYXJrZXIoUGxh dGZvcm1UZXh0TWFya2VyRGF0YSk7CiAjZW5kaWYKKyAgICBBWFRleHRNYXJrZXIoQVhJRCB0cmVl SUQsIEFYSUQgb2JqZWN0SUQsIHVuc2lnbmVkIG9mZnNldCkKKyAgICAgICAgOiBtX2RhdGEoeyB0 cmVlSUQsIG9iamVjdElELCBudWxscHRyLCBvZmZzZXQgfSkKKyAgICB7IH0KICAgICBBWFRleHRN YXJrZXIoKSA9IGRlZmF1bHQ7CiAKICAgICBvcGVyYXRvciBib29sKCkgY29uc3QgeyByZXR1cm4g IWlzTnVsbCgpOyB9CkBAIC0xMjMsNyArMTQ0LDExIEBAIHB1YmxpYzoKIAogICAgIEFYSUQgdHJl ZUlEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4VHJlZUlEKCk7IH0KICAgICBBWElEIG9iamVj dElEKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhLmF4T2JqZWN0SUQoKTsgfQorICAgIHVuc2lnbmVk IG9mZnNldCgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5vZmZzZXQ7IH0KICAgICBib29sIGlzTnVs bCgpIGNvbnN0IHsgcmV0dXJuICF0cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElEKCkuaXNW YWxpZCgpOyB9CisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURfVFJFRSkKKyAgICBS ZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gaXNvbGF0ZWRPYmplY3QoKSBjb25zdDsKKyNlbmRpZgog ICAgIFJlZlB0cjxBWENvcmVPYmplY3Q+IG9iamVjdCgpIGNvbnN0OwogICAgIGJvb2wgaXNWYWxp ZCgpIGNvbnN0IHsgcmV0dXJuIG9iamVjdCgpOyB9CiAKQEAgLTEzNCw3ICsxNTksMjggQEAgcHVi bGljOgogCiAgICAgLy8gU2V0cyBtX2RhdGEubm9kZSB3aGVuIHRoZSBtYXJrZXIgd2FzIGNyZWF0 ZWQgd2l0aCBhIFBsYXRmb3JtVGV4dE1hcmtlckRhdGEgdGhhdCBsYWNrcyB0aGUgbm9kZSBwb2lu dGVyIGJlY2F1c2UgaXQgd2FzIGNyZWF0ZWQgb2ZmIHRoZSBtYWluIHRocmVhZC4KICAgICB2b2lk IHNldE5vZGVJZk5lZWRlZCgpIGNvbnN0OworCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCisgICAgLy8gRmluZCB0aGUgbmV4dCBvciBwcmV2aW91cyBtYXJrZXIuCisgICAgQVhUZXh0 TWFya2VyIGZpbmRNYXJrZXIoQVhEaXJlY3Rpb24pIGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZy b20gdGhpcyB0ZXh0IG1hcmtlciwgY3JlYXRlcyBhIG5ldyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVu IGRpcmVjdGlvbiBhbmQgdGV4dCB1bml0IHR5cGUuCisgICAgQVhUZXh0TWFya2VyIGZpbmRNYXJr ZXIoQVhEaXJlY3Rpb24sIEFYVGV4dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSkgY29uc3Q7Cisg ICAgLy8gQ3JlYXRlcyBhIHJhbmdlIGZvciB0aGUgbGluZSB0aGlzIG1hcmtlciBwb2ludHMgdG8u CisgICAgQVhUZXh0TWFya2VyUmFuZ2UgbGluZVJhbmdlKExpbmVSYW5nZVR5cGUpIGNvbnN0Owor I2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorCiBwcml2YXRlOgorI2lmIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIGNvbnN0IEFYVGV4dFJ1bnMqIHJ1bnMoKSBj b25zdDsKKyAgICAvLyBTdWJzdHJpbmcgaW50byB0aGUgdGV4dCBydW5zIG9mIHRoZSBvYmplY3Qg YXNzb2NpYXRlZCB3aXRoIHRoaXMgdGV4dCBtYXJrZXIgKGlmIGl0IGhhcyBhbnkpLgorICAgIFN0 cmluZyBzdWJzdHJpbmcodW5zaWduZWQgc3RhcnQsIHVuc2lnbmVkIGxlbmd0aCA9IFN0cmluZ0lt cGw6Ok1heExlbmd0aCkgY29uc3Q7CisgICAgc2l6ZV90IHRleHRSdW5JbmRleEZvck9mZnNldCgp IGNvbnN0OworCisgICAgLy8gQSAidGV4dCBsZWFmIiBtYXJrZXIgaXMgYSBsZWFmIG5vZGUgKG5v IGNoaWxkcmVuKSB3aXRoIG5vbi1lbXB0eSB0ZXh0IHJ1bnMuCisgICAgYm9vbCBpc1RleHRMZWFm KCkgY29uc3Q7CisgICAgQVhUZXh0TWFya2VyIGFzVGV4dExlYWZNYXJrZXIoKSBjb25zdDsKKyNl bmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKwogICAgIFRleHRNYXJrZXJEYXRh IG1fZGF0YTsKIH07CiAKQEAgLTE3MSw2ICsyMTcsMTEgQEAgcHVibGljOgogICAgIEFYVGV4dE1h cmtlciBlbmQoKSBjb25zdCB7IHJldHVybiBtX2VuZDsgfQogICAgIGJvb2wgaXNDb25maW5lZFRv KEFYSUQpIGNvbnN0OwogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgLy8g VHJhdmVyc2VzIGZyb20gbV9zdGFydCB0byBtX2VuZCwgY29sbGVjdGluZyBhbGwgdGV4dCBhbG9u ZyB0aGUgd2F5LgorICAgIFN0cmluZyB0b1N0cmluZygpIGNvbnN0OworI2VuZGlmCisKICAgICBT dHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0OwogcHJpdmF0ZToKICAgICBBWFRleHRNYXJr ZXIgbV9zdGFydDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0UnVuLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjUwNGZhMjQ3MmFhNgotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNw cApAQCAtMCwwICsxLDkzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICog YXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lu Y2x1ZGUgIkFYVGV4dFJ1bi5oIgorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK1N0cmluZyBBWFRleHRSdW5zOjpkZWJ1Z0Rlc2NyaXB0aW9u KCkgY29uc3QKK3sKKyAgICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICByZXN1bHQuYXBwZW5k KCdbJyk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspIHsK KyAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zW2ldLmRlYnVnRGVzY3JpcHRpb24oY29udGFpbmlu Z0Jsb2NrKSk7CisgICAgICAgIGlmIChpICE9IHJ1bnMuc2l6ZSgpIC0gMSkKKyAgICAgICAgICAg IHJlc3VsdC5hcHBlbmQoIiwgIik7CisgICAgfQorICAgIHJlc3VsdC5hcHBlbmQoJ10nKTsKKyAg ICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK3NpemVfdCBBWFRleHRSdW5zOjppbmRl eEZvck9mZnNldCh1bnNpZ25lZCB0ZXh0T2Zmc2V0KSBjb25zdAoreworICAgIHNpemVfdCBjdW11 bGF0aXZlTGVuZ3RoID0gMDsKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHJ1bnMuc2l6ZSgp OyBpKyspIHsKKyAgICAgICAgY3VtdWxhdGl2ZUxlbmd0aCArPSBydW5MZW5ndGgoaSk7CisgICAg ICAgIGlmIChjdW11bGF0aXZlTGVuZ3RoID49IHRleHRPZmZzZXQpCisgICAgICAgICAgICByZXR1 cm4gaTsKKyAgICB9CisgICAgcmV0dXJuIG5vdEZvdW5kOworfQorCit1bnNpZ25lZCBBWFRleHRS dW5zOjpydW5MZW5ndGhTdW1UbyhzaXplX3QgaW5kZXgpIGNvbnN0Cit7CisgICAgdW5zaWduZWQg bGVuZ3RoID0gMDsKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8PSBpbmRleCAmJiBpIDwgcnVu cy5zaXplKCk7IGkrKykKKyAgICAgICAgbGVuZ3RoICs9IHJ1bkxlbmd0aChpKTsKKyAgICByZXR1 cm4gbGVuZ3RoOworfQorCitTdHJpbmcgQVhUZXh0UnVuczo6c3Vic3RyaW5nKHVuc2lnbmVkIHN0 YXJ0LCB1bnNpZ25lZCBsZW5ndGgpIGNvbnN0Cit7CisgICAgaWYgKCFsZW5ndGgpCisgICAgICAg IHJldHVybiBlbXB0eVN0cmluZygpOworCisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAg c2l6ZV90IGNoYXJhY3RlcnNTZWVuID0gMDsKKyAgICBhdXRvIHJlbWFpbmluZyA9IFsmXSAoKSB7 CisgICAgICAgIHJldHVybiByZXN1bHQubGVuZ3RoKCkgPj0gbGVuZ3RoID8gMCA6IGxlbmd0aCAt IHJlc3VsdC5sZW5ndGgoKTsKKyAgICB9OworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBy dW5zLnNpemUoKSAmJiByZXN1bHQubGVuZ3RoKCkgPCBsZW5ndGg7IGkrKykgeworICAgICAgICBz aXplX3QgcnVuTGVuZ3RoID0gdGhpcy0+cnVuTGVuZ3RoKGkpOworICAgICAgICBpZiAoY2hhcmFj dGVyc1NlZW4gPj0gc3RhcnQpIHsKKyAgICAgICAgICAgIC8vIFRoZSBzdGFydCBwb2ludHMgZW50 aXJlbHkgd2l0aGluIGJvdW5kcyBvZiB0aGlzIHJ1bi4KKyAgICAgICAgICAgIHJlc3VsdC5hcHBl bmQocnVuc1tpXS50ZXh0LmxlZnQocmVtYWluaW5nKCkpKTsKKyAgICAgICAgfSBlbHNlIGlmIChj aGFyYWN0ZXJzU2VlbiArIHJ1bkxlbmd0aCA+IHN0YXJ0KSB7CisgICAgICAgICAgICAvLyBzdGFy dCBwb2ludHMgc29tZXdoZXJlIGluIHRoZSBtaWRkbGUgb2YgdGhlIGN1cnJlbnQgcnVuLCBjb2xs ZWN0IHBhcnQgb2YgdGhlIHRleHQuCisgICAgICAgICAgICB1bnNpZ25lZCBzdGFydEluUnVuID0g c3RhcnQgLSBjaGFyYWN0ZXJzU2VlbjsKKyAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKHN0YXJ0 SW5SdW4gPCBydW5MZW5ndGgpOworICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zW2ldLnRl eHQuc3Vic3RyaW5nKHN0YXJ0SW5SdW4sIHJlbWFpbmluZygpKSk7CisgICAgICAgIH0KKyAgICAg ICAgLy8gSWYgY2hhcmFjdGVyc1NlZW4gKyBydW5MZW5ndGggPT0gc3RhcnQsIHRoZSBzdGFydCBw b2ludHMgdG8gdGhlIGVuZCBvZiB0aGUgcnVuLCBhbmQgdGhlcmUgaXMgbm8gdGV4dCB0byBnYXRo ZXIuCisKKyAgICAgICAgY2hhcmFjdGVyc1NlZW4gKz0gcnVuTGVuZ3RoOworICAgIH0KKyAgICBy ZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNl bmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYVGV4dFJ1bi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uYTA5OWYzMTFmNTZkCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWFRleHRSdW4uaApAQCAtMCwwICsxLDEyMCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVU T1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBD T05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1Ig QlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFn bWEgb25jZQorCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCituYW1lc3BhY2UgV2Vi Q29yZSB7CisKK2NsYXNzIFJlbmRlckJsb2NrOworCitzdHJ1Y3QgQVhUZXh0UnVuTGluZUlEIHsK KyAgICB2b2lkKiBjb250YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAgc2l6ZV90IGxpbmVJ bmRleCB7IDAgfTsKKworICAgIEFYVGV4dFJ1bkxpbmVJRCh2b2lkKiBjb250YWluaW5nQmxvY2ss IHNpemVfdCBsaW5lSW5kZXgpCisgICAgICAgIDogY29udGFpbmluZ0Jsb2NrKGNvbnRhaW5pbmdC bG9jaykKKyAgICAgICAgLCBsaW5lSW5kZXgobGluZUluZGV4KQorICAgIHsgfQorICAgIGJvb2wg b3BlcmF0b3I9PShjb25zdCBBWFRleHRSdW5MaW5lSUQmKSBjb25zdCA9IGRlZmF1bHQ7CisgICAg U3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAorICAgIHsKKyAgICAgICAgVGV4dFN0cmVh bSBzdHJlYW07CisgICAgICAgIHN0cmVhbSA8PCAiTGluZUlEICIgPDwgY29udGFpbmluZ0Jsb2Nr IDw8ICIgIiA8PCBsaW5lSW5kZXg7CisgICAgICAgIHJldHVybiBzdHJlYW0ucmVsZWFzZSgpOwor ICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW4geworICAgIC8vIFRoZSBsaW5lIGluZGV4IG9m IHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4dCBvZiB0aGUgY29udGFpbmluZyBSZW5kZXJCbG9j ayBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0LgorICAgIHNpemVfdCBsaW5lSW5kZXg7Cisg ICAgU3RyaW5nIHRleHQ7CisKKyAgICBBWFRleHRSdW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5n JiYgdGV4dCkKKyAgICAgICAgOiBsaW5lSW5kZXgobGluZUluZGV4KQorICAgICAgICAsIHRleHQo V1RGTW92ZSh0ZXh0KSkKKyAgICB7IH0KKworICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKHZv aWQqIGNvbnRhaW5pbmdCbG9jaykgY29uc3QKKyAgICB7CisgICAgICAgIEFYVGV4dFJ1bkxpbmVJ RCBsaW5lSUQgPSB7IGNvbnRhaW5pbmdCbG9jaywgbGluZUluZGV4IH07CisgICAgICAgIHJldHVy biBtYWtlU3RyaW5nKGxpbmVJRC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICI6IHwiLCBtYWtlU3RyaW5n QnlSZXBsYWNpbmdBbGwodGV4dCwgJ1xuJywgIntuZXdsaW5lfSJfcyksICJ8KGxlbiAiLCB0ZXh0 Lmxlbmd0aCgpLCAiKSIpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRSdW5zIHsKKyAgICAv LyBUaGUgY29udGFpbmluZyBibG9jayBmb3IgdGhlIHRleHQgcnVucy4gVGhpcyBpcyByZXF1aXJl ZCBiZWNhdXNlIGJhc2VkIG9uIHRoZSBzdHJ1Y3R1cmUKKyAgICAvLyBvZiB0aGUgQVggdHJlZSwg dGV4dCBydW5zIGZvciBkaWZmZXJlbnQgb2JqZWN0cyBjYW4gaGF2ZSB0aGUgc2FtZSBsaW5lIGlu ZGV4IGJ1dCBkaWZmZXJlbnQKKyAgICAvLyBjb250YWluaW5nIGJsb2NrcywgbWVhbmluZyB0aGV5 IGFyZSByZW5kZXJlZCBvbiBkaWZmZXJlbnQgbGluZXMuCisgICAgLy8gRG8gbm90IGRlLXJlZmVy ZW5jZS4gVXNlIGZvciBjb21wYXJpc29uIHB1cnBvc2VzIG9ubHkuCisgICAgdm9pZCogY29udGFp bmluZ0Jsb2NrIHsgbnVsbHB0ciB9OworICAgIFZlY3RvcjxBWFRleHRSdW4+IHJ1bnM7CisKKyAg ICBBWFRleHRSdW5zKCkgPSBkZWZhdWx0OworICAgIEFYVGV4dFJ1bnMoUmVuZGVyQmxvY2sqIGNv bnRhaW5pbmdCbG9jaywgVmVjdG9yPEFYVGV4dFJ1bj4mJiBydW5zKQorICAgICAgICA6IGNvbnRh aW5pbmdCbG9jayhjb250YWluaW5nQmxvY2spCisgICAgICAgICwgcnVucyhXVEZNb3ZlKHJ1bnMp KQorICAgIHsgfQorICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3Q7CisKKyAgICBz aXplX3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIHJ1bnMuc2l6ZSgpOyB9CisgICAgY29uc3QgQVhU ZXh0UnVuJiBhdChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gKCp0 aGlzKVtpbmRleF07CisgICAgfQorICAgIGNvbnN0IEFYVGV4dFJ1biYgb3BlcmF0b3JbXShzaXpl X3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1 bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHJ1bnNbaW5kZXhdOworICAgIH0KKworICAgIHVu c2lnbmVkIHJ1bkxlbmd0aChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxF QVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJuIHJ1bnNbaW5k ZXhdLnRleHQubGVuZ3RoKCk7CisgICAgfQorICAgIHVuc2lnbmVkIGxhc3RSdW5MZW5ndGgoKSBj b25zdAorICAgIHsKKyAgICAgICAgaWYgKHJ1bnMuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0 dXJuIDA7CisgICAgICAgIHJldHVybiBydW5zW3J1bnMuc2l6ZSgpIC0gMV0udGV4dC5sZW5ndGgo KTsKKyAgICB9CisgICAgdW5zaWduZWQgcnVuTGVuZ3RoU3VtKCkgY29uc3QKKyAgICB7CisgICAg ICAgIHJldHVybiBydW5MZW5ndGhTdW1UbyhydW5zLnNpemUoKSAtIDEpOworICAgIH0KKyAgICB1 bnNpZ25lZCBydW5MZW5ndGhTdW1UbyhzaXplX3QgaW5kZXgpIGNvbnN0OworCisgICAgc2l6ZV90 IGluZGV4Rm9yT2Zmc2V0KHVuc2lnbmVkIHRleHRPZmZzZXQpIGNvbnN0OworICAgIEFYVGV4dFJ1 bkxpbmVJRCBsaW5lSUQoc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgUkVMRUFT RV9BU1NFUlQoaW5kZXggPCBydW5zLnNpemUoKSk7CisgICAgICAgIHJldHVybiB7IGNvbnRhaW5p bmdCbG9jaywgcnVuc1tpbmRleF0ubGluZUluZGV4IH07CisgICAgfQorICAgIFN0cmluZyBzdWJz dHJpbmcodW5zaWduZWQgc3RhcnQsIHVuc2lnbmVkIGxlbmd0aCA9IFN0cmluZ0ltcGw6Ok1heExl bmd0aCkgY29uc3Q7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisjZW5kaWYgLy8gRU5B QkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAppbmRleCAyOWE5MzFjNWFhMTQuLmYzMzli M2FiMDA4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3Np YmlsaXR5T2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlPYmplY3QuY3BwCkBAIC0xMTMsNiArMTEzLDEyIEBAIHZvaWQgQWNjZXNzaWJpbGl0 eU9iamVjdDo6aW5pdCgpCiAgICAgbV9yb2xlID0gZGV0ZXJtaW5lQWNjZXNzaWJpbGl0eVJvbGUo KTsKIH0KIAorQVhJRCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0cmVlSUQoKSBjb25zdAoreworICAg IGF1dG8qIGNhY2hlID0gYXhPYmplY3RDYWNoZSgpOworICAgIHJldHVybiBjYWNoZSA/IGNhY2hl LT50cmVlSUQoKSA6IEFYSUQoKTsKK30KKwogaW5saW5lIFByb2Nlc3NJRCBBY2Nlc3NpYmlsaXR5 T2JqZWN0Ojpwcm9jZXNzSUQoKSBjb25zdAogewogICAgIHJldHVybiBwcmVzZW50aW5nQXBwbGlj YXRpb25QSUQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eU9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3Np YmlsaXR5T2JqZWN0LmgKaW5kZXggZTY0YjYzMDZjMDhlLi5jN2YyOGQ1YzNiNTUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oCkBA IC0zMCw2ICszMCw3IEBACiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIkFYQ29yZU9iamVjdC5o IgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgogI2luY2x1ZGUgIkNoYXJhY3RlclJhbmdlLmgiCiAj aW5jbHVkZSAiRmxvYXRRdWFkLmgiCiAjaW5jbHVkZSAiTGF5b3V0UmVjdC5oIgpAQCAtNjMsNiAr NjQsNyBAQCBjbGFzcyBBY2Nlc3NpYmlsaXR5T2JqZWN0IDogcHVibGljIEFYQ29yZU9iamVjdCwg cHVibGljIENhbk1ha2VXZWFrUHRyPEFjY2Vzc2liaQogcHVibGljOgogICAgIHZpcnR1YWwgfkFj Y2Vzc2liaWxpdHlPYmplY3QoKTsKIAorICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgZmluYWw7CiAg ICAgUHJvY2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0IG92ZXJyaWRlOwogICAgIFN0cmluZyBkYmco KSBjb25zdCBmaW5hbDsKIApAQCAtMzgyLDYgKzM4NCw5IEBAIHB1YmxpYzoKICAgICBTdHJpbmcg dGV4dFVuZGVyRWxlbWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nl c3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4g eyB9OyB9CiAgICAgU3RyaW5nIHRleHQoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0K ICAgICB1bnNpZ25lZCB0ZXh0TGVuZ3RoKCkgY29uc3QgZmluYWw7CisjaWYgRU5BQkxFKEFYX1RI UkVBRF9URVhUX0FQSVMpCisgICAgdmlydHVhbCBBWFRleHRSdW5zIHRleHRSdW5zKCkgeyByZXR1 cm4geyB9OyB9CisjZW5kaWYKICNpZiBQTEFURk9STShDT0NPQSkKICAgICAvLyBSZXR1cm5zIGFu IGFycmF5IG9mIHN0cmluZ3MgYW5kIEFYT2JqZWN0IHdyYXBwZXJzIGNvcnJlc3BvbmRpbmcgdG8g dGhlCiAgICAgLy8gdGV4dHJ1bnMgYW5kIHJlcGxhY2VtZW50IG5vZGVzIGluY2x1ZGVkIGluIHRo ZSBnaXZlbiByYW5nZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCmluZGV4IDM5NDY5ZTY5MDYwMC4uZjcz OGU4OWI0MmFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKQEAgLTE0MDMsMTEgKzE0MDMsMTEgQEAg Q2hhcmFjdGVyUmFuZ2UgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6c2VsZWN0ZWRUZXh0UmFu Z2UoKSBjb25zdAogfQogCiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi1WZWN0b3I8 QVhUZXh0UnVuPiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCitBWFRleHRS dW5zIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKCkKIHsKICAgICBpZiAoYXV0 byogcmVuZGVyTGluZUJyZWFrID0gZHluYW1pY0Rvd25jYXN0PFJlbmRlckxpbmVCcmVhaz4ocmVu ZGVyZXIoKSkpIHsKICAgICAgICAgYXV0byBib3ggPSBJbmxpbmVJdGVyYXRvcjo6Ym94Rm9yKCpy ZW5kZXJMaW5lQnJlYWspOwotICAgICAgICByZXR1cm4geyB7IGJveC0+bGluZUluZGV4KCksIG1h a2VTdHJpbmcoJ1xuJykgfSB9OworICAgICAgICByZXR1cm4geyByZW5kZXJMaW5lQnJlYWstPmNv bnRhaW5pbmdCbG9jaygpLCB7IEFYVGV4dFJ1bihib3gtPmxpbmVJbmRleCgpLCBtYWtlU3RyaW5n KCdcbicpLmlzb2xhdGVkQ29weSgpKSB9IH07CiAgICAgfQogCiAgICAgV2Vha1B0ciByZW5kZXJU ZXh0ID0gZHluYW1pY0Rvd25jYXN0PFJlbmRlclRleHQ+KHJlbmRlcmVyKCkpOwpAQCAtMTQ2MCw3 ICsxNDYwLDcgQEAgVmVjdG9yPEFYVGV4dFJ1bj4gQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6 dGV4dFJ1bnMoKQogCiAgICAgaWYgKCFsaW5lU3RyaW5nLmlzRW1wdHkoKSkKICAgICAgICAgcnVu cy5hcHBlbmQoeyBjdXJyZW50TGluZUluZGV4LCBsaW5lU3RyaW5nLnRvU3RyaW5nKCkuaXNvbGF0 ZWRDb3B5KCkgfSk7Ci0gICAgcmV0dXJuIHJ1bnM7CisgICAgcmV0dXJuIHsgcmVuZGVyVGV4dC0+ Y29udGFpbmluZ0Jsb2NrKCksIFdURk1vdmUocnVucykgfTsKIH0KICNlbmRpZiAvLyBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAppbmRleCBjZWVjNmJmM2U4OTgu LmJlOWVlNGY4NjA0NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKQEAgLTEwMCw3ICsxMDAsNyBAQCBwdWJs aWM6CiAgICAgU3RyaW5nIHRleHRVbmRlckVsZW1lbnQoQWNjZXNzaWJpbGl0eVRleHRVbmRlckVs ZW1lbnRNb2RlID0gQWNjZXNzaWJpbGl0eVRleHRVbmRlckVsZW1lbnRNb2RlKCkpIGNvbnN0IG92 ZXJyaWRlOwogICAgIFN0cmluZyBzZWxlY3RlZFRleHQoKSBjb25zdCBvdmVycmlkZTsKICNpZiBF TkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICBWZWN0b3I8QVhUZXh0UnVuPiB0ZXh0UnVu cygpIGZpbmFsOworICAgIEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSBmaW5hbDsKICNlbmRpZgogCiAg ICAgYm9vbCBpc1dpZGdldCgpIGNvbnN0IG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0 LmNwcAppbmRleCA2MmExYTU3NWFlNjEuLjM0NWYyZDUzZGY1OCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRl ZE9iamVjdC5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJBWEdlb21ldHJ5TWFuYWdl ci5oIgogI2luY2x1ZGUgIkFYSXNvbGF0ZWRUcmVlLmgiCiAjaW5jbHVkZSAiQVhMb2dnZXIuaCIK KyNpbmNsdWRlICJBWFRleHRSdW4uaCIKIAogI2lmIFBMQVRGT1JNKE1BQykKICNpbXBvcnQgPHBh bC9zcGkvbWFjL0hJU2VydmljZXNTUEkuaD4KQEAgLTQ2NCw2ICs0NjUsOSBAQCB2b2lkIEFYSXNv bGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KEFYUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSwgQVhQ cm9wZXJ0eVZhbHVlVgogICAgICAgICBbXShzdGQ6OnBhaXI8QVhJRCwgQ2hhcmFjdGVyUmFuZ2U+ JiB0eXBlZFZhbHVlKSB7CiAgICAgICAgICAgICByZXR1cm4gIXR5cGVkVmFsdWUuZmlyc3QuaXNW YWxpZCgpICYmICF0eXBlZFZhbHVlLnNlY29uZC5sb2NhdGlvbiAmJiAhdHlwZWRWYWx1ZS5zZWNv bmQubGVuZ3RoOwogICAgICAgICB9LAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQor ICAgICAgICBbXShBWFRleHRSdW5zIHJ1bnMpIHsgcmV0dXJuICFydW5zLnNpemUoKTsgfSwKKyNl bmRpZgogICAgICAgICBbXShhdXRvJikgewogICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CiAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC01NTcsNiArNTYxLDE5IEBAIHZvaWQg QVhJc29sYXRlZE9iamVjdDo6c2V0U2VsZWN0ZWRDaGlsZHJlbihjb25zdCBBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3ImIHNlCiAgICAgfSk7CiB9CiAKK0FYQ29yZU9iamVjdCogQVhJc29sYXRl ZE9iamVjdDo6c2libGluZyhBWERpcmVjdGlvbiBkaXJlY3Rpb24pIGNvbnN0Cit7CisgICAgUmVm UHRyIHBhcmVudCA9IHBhcmVudE9iamVjdFVuaWdub3JlZCgpOworICAgIGNvbnN0IGF1dG8mIHNp YmxpbmdzID0gcGFyZW50LT5jaGlsZHJlbigpOworICAgIHNpemVfdCBpbmRleE9mVGhpcyA9IHNp YmxpbmdzLmZpbmQodGhpcyk7CisgICAgaWYgKGluZGV4T2ZUaGlzID09IG5vdEZvdW5kKQorICAg ICAgICByZXR1cm4gbnVsbHB0cjsKKworICAgIGlmIChkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246 Ok5leHQpCisgICAgICAgIHJldHVybiBpbmRleE9mVGhpcyArIDEgPCBzaWJsaW5ncy5zaXplKCkg PyBzaWJsaW5nc1tpbmRleE9mVGhpcyArIDFdLmdldCgpIDogbnVsbHB0cjsKKyAgICByZXR1cm4g aW5kZXhPZlRoaXMgPiAwID8gc2libGluZ3NbaW5kZXhPZlRoaXMgLSAxXS5nZXQoKSA6IG51bGxw dHI7Cit9CisKIGJvb2wgQVhJc29sYXRlZE9iamVjdDo6aXNEZXRhY2hlZEZyb21QYXJlbnQoKQog ewogICAgIGlmIChwYXJlbnQoKS5pc1ZhbGlkKCkpCkBAIC05NzEsNiArOTg4LDE5IEBAIGludCBB WElzb2xhdGVkT2JqZWN0OjppbnRBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0 eU5hbWUpIGNvbnN0CiAgICAgKTsKIH0KIAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElT KQorY29uc3QgQVhUZXh0UnVucyogQVhJc29sYXRlZE9iamVjdDo6dGV4dFJ1bnMoKSBjb25zdAor eworICAgIGF1dG8gZW50cnkgPSBtX3Byb3BlcnR5TWFwLmZpbmQoQVhQcm9wZXJ0eU5hbWU6OlRl eHRSdW5zKTsKKyAgICBpZiAoZW50cnkgPT0gbV9wcm9wZXJ0eU1hcC5lbmQoKSkKKyAgICAgICAg cmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJuIFdURjo6c3dpdGNoT24oZW50cnktPnZhbHVlLAor ICAgICAgICBbXSAoY29uc3QgQVhUZXh0UnVucyYgdHlwZWRWYWx1ZSkgLT4gY29uc3QgQVhUZXh0 UnVucyogeyByZXR1cm4gJnR5cGVkVmFsdWU7IH0sCisgICAgICAgIFtdIChhdXRvJikgLT4gY29u c3QgQVhUZXh0UnVucyogeyByZXR1cm4gbnVsbHB0cjsgfQorICAgICk7Cit9CisjZW5kaWYKKwog dGVtcGxhdGU8dHlwZW5hbWUgVD4KIFQgQVhJc29sYXRlZE9iamVjdDo6Z2V0T3JSZXRyaWV2ZVBy b3BlcnR5VmFsdWUoQVhQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lKQogewpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVj dC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRl ZE9iamVjdC5oCmluZGV4IGE2Y2EwMzQzNzc3ZC4uYmY4OWMxM2YzNjhiIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29s YXRlZE9iamVjdC5oCkBAIC00NCw2ICs0NCw5IEBACiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNs YXNzIEFYSXNvbGF0ZWRUcmVlOworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorc3Ry dWN0IEFYVGV4dFJ1bnM7CisjZW5kaWYKIAogY2xhc3MgQVhJc29sYXRlZE9iamVjdCBmaW5hbCA6 IHB1YmxpYyBBWENvcmVPYmplY3QgewogICAgIGZyaWVuZCBjbGFzcyBBWElzb2xhdGVkVHJlZTsK QEAgLTUxLDYgKzU0LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBSZWY8QVhJc29sYXRlZE9iamVj dD4gY3JlYXRlKGNvbnN0IFJlZjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiYsIEFYSXNvbGF0ZWRUcmVl Kik7CiAgICAgfkFYSXNvbGF0ZWRPYmplY3QoKTsKIAorICAgIEFYSUQgdHJlZUlEKCkgY29uc3Qg ZmluYWwgeyByZXR1cm4gdHJlZSgpLT50cmVlSUQoKTsgfQogICAgIFByb2Nlc3NJRCBwcm9jZXNz SUQoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnByb2Nlc3NJRCgpOyB9CiAgICAgU3Ry aW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBAIC01OSwxMCArNjMsMTcgQEAgcHVibGljOgogICAg IGJvb2wgaXNUYWJsZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShB WFByb3BlcnR5TmFtZTo6SXNUYWJsZSk7IH0KICAgICBib29sIGlzRXhwb3NhYmxlKCkgY29uc3Qg ZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc0V4cG9z YWJsZSk7IH0KIAorICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRy ZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVlZGVkID0gdHJ1ZSkgZmluYWw7CisgICAgQVhDb3Jl T2JqZWN0KiBzaWJsaW5nKEFYRGlyZWN0aW9uKSBjb25zdDsKICAgICBBWElzb2xhdGVkT2JqZWN0 KiBwYXJlbnRPYmplY3QoKSBjb25zdCBmaW5hbCB7IHJldHVybiBwYXJlbnRPYmplY3RVbmlnbm9y ZWQoKTsgfQorICAgIEFYSXNvbGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNv bnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGVkaXRhYmxlQW5jZXN0b3IoKSBmaW5h bCB7IHJldHVybiBBY2Nlc3NpYmlsaXR5OjplZGl0YWJsZUFuY2VzdG9yKCp0aGlzKTsgfTsKICAg ICBib29sIGNhblNldEZvY3VzQXR0cmlidXRlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0 dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpDYW5TZXRGb2N1c0F0dHJpYnV0ZSk7IH0KIAor I2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIGNvbnN0IEFYVGV4dFJ1bnMqIHRl eHRSdW5zKCkgY29uc3Q7CisjZW5kaWYKKwogcHJpdmF0ZToKICAgICB2b2lkIGRldGFjaFJlbW90 ZVBhcnRzKEFjY2Vzc2liaWxpdHlEZXRhY2htZW50VHlwZSkgZmluYWw7CiAgICAgdm9pZCBkZXRh Y2hQbGF0Zm9ybVdyYXBwZXIoQWNjZXNzaWJpbGl0eURldGFjaG1lbnRUeXBlKSBmaW5hbDsKQEAg LTI0Myw3ICsyNTQsNiBAQCBwcml2YXRlOgogICAgIFZlY3RvcjxTdHJpbmc+IGRldGVybWluZURy b3BFZmZlY3RzKCkgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9iamVjdCogYWNjZXNzaWJp bGl0eUhpdFRlc3QoY29uc3QgSW50UG9pbnQmKSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVk T2JqZWN0KiBmb2N1c2VkVUlFbGVtZW50KCkgY29uc3QgZmluYWw7Ci0gICAgQVhJc29sYXRlZE9i amVjdCogcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkgY29uc3QgZmluYWw7CiAgICAgQWNjZXNzaWJp bGl0eUNoaWxkcmVuVmVjdG9yIGxpbmtlZE9iamVjdHMoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0 cmVlKCktPm9iamVjdHNGb3JJRHModmVjdG9yQXR0cmlidXRlVmFsdWU8QVhJRD4oQVhQcm9wZXJ0 eU5hbWU6OkxpbmtlZE9iamVjdHMpKTsgfQogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHRpdGxlVUlF bGVtZW50KCkgY29uc3QgZmluYWwgeyByZXR1cm4gb2JqZWN0QXR0cmlidXRlVmFsdWUoQVhQcm9w ZXJ0eU5hbWU6OlRpdGxlVUlFbGVtZW50KTsgfQogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHNjcm9s bEJhcihBY2Nlc3NpYmlsaXR5T3JpZW50YXRpb24pIGZpbmFsOwpAQCAtMzE2LDcgKzMyNiw2IEBA IHByaXZhdGU6CiAgICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIHZpc2libGVDaGlsZHJl bigpIGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+b2JqZWN0c0ZvcklEcyh2ZWN0b3JBdHRyaWJ1dGVW YWx1ZTxBWElEPihBWFByb3BlcnR5TmFtZTo6VmlzaWJsZUNoaWxkcmVuKSk7IH0KICAgICBBdG9t U3RyaW5nIHRhZ05hbWUoKSBjb25zdCBmaW5hbDsKICAgICB2b2lkIHNldENoaWxkcmVuSURzKFZl Y3RvcjxBWElEPiYmKTsKLSAgICBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNo aWxkcmVuKGJvb2wgdXBkYXRlQ2hpbGRyZW5JZk5lZWRlZCA9IHRydWUpIGZpbmFsOwogICAgIHZv aWQgdXBkYXRlQ2hpbGRyZW5JZk5lY2Vzc2FyeSgpIGZpbmFsOwogICAgIGJvb2wgaXNEZXRhY2hl ZEZyb21QYXJlbnQoKSBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBsaXZlUmVnaW9uQW5j ZXN0b3IoYm9vbCBleGNsdWRlSWZPZmYgPSB0cnVlKSBjb25zdCBmaW5hbCB7IHJldHVybiBBY2Nl c3NpYmlsaXR5OjpsaXZlUmVnaW9uQW5jZXN0b3IoKnRoaXMsIGV4Y2x1ZGVJZk9mZik7IH0KQEAg LTM0NSw5ICszNTQsNiBAQCBwcml2YXRlOgogCiAgICAgLy8gQ2hhcmFjdGVyUmFuZ2Ugc3VwcG9y dC4KICAgICBDaGFyYWN0ZXJSYW5nZSBzZWxlY3RlZFRleHRSYW5nZSgpIGNvbnN0IGZpbmFsIHsg cmV0dXJuIHByb3BlcnR5VmFsdWU8Q2hhcmFjdGVyUmFuZ2U+KEFYUHJvcGVydHlOYW1lOjpTZWxl Y3RlZFRleHRSYW5nZSk7IH0KLSNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICBW ZWN0b3I8QVhUZXh0UnVuPiB0ZXh0UnVucygpIGZpbmFsIHsgcmV0dXJuIHZlY3RvckF0dHJpYnV0 ZVZhbHVlPEFYVGV4dFJ1bj4oQVhQcm9wZXJ0eU5hbWU6OlRleHRSdW5zKTsgfQotI2VuZGlmCiAg ICAgaW50IGluc2VydGlvblBvaW50TGluZU51bWJlcigpIGNvbnN0IGZpbmFsOwogICAgIENoYXJh Y3RlclJhbmdlIGRvQVhSYW5nZUZvckxpbmUodW5zaWduZWQpIGNvbnN0IGZpbmFsOwogICAgIFN0 cmluZyBkb0FYU3RyaW5nRm9yUmFuZ2UoY29uc3QgQ2hhcmFjdGVyUmFuZ2UmKSBjb25zdCBmaW5h bDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVl L0FYSXNvbGF0ZWRUcmVlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcAppbmRleCBmNmYwNjIyYWJlOTMuLjBlNzUzOWUzYThj MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUv QVhJc29sYXRlZFRyZWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcApAQCAtMzAsNiArMzAsNyBAQAogCiAjaW5jbHVk ZSAiQVhJc29sYXRlZE9iamVjdC5oIgogI2luY2x1ZGUgIkFYTG9nZ2VyLmgiCisjaW5jbHVkZSAi QWNjZXNzaWJpbGl0eVRhYmxlUm93LmgiCiAjaW5jbHVkZSAiRnJhbWVTZWxlY3Rpb24uaCIKICNp bmNsdWRlICJMb2NhbEZyYW1lVmlldy5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKQEAgLTIzMCwyMiAr MjMxLDYgQEAgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IEFYSXNvbGF0ZWRUcmVlOjpvYmplY3RG b3JJRChjb25zdCBBWElEIGF4SUQpIGNvbnN0CiAgICAgcmV0dXJuIGF4SUQuaXNWYWxpZCgpID8g bV9yZWFkZXJUaHJlYWROb2RlTWFwLmdldChheElEKSA6IG51bGxwdHI7CiB9CiAKLXRlbXBsYXRl PHR5cGVuYW1lIFU+Ci1WZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IEFYSXNvbGF0ZWRUcmVl OjpvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4SURzKSBjb25zdAotewotICAgIEFYVFJBQ0UoIkFY SXNvbGF0ZWRUcmVlOjpvYmplY3RzRm9ySURzIl9zKTsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKLQotICAgIFZlY3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gcmVzdWx0OwotICAgIHJl c3VsdC5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGF4SURzLnNpemUoKSk7Ci0gICAgZm9yIChhdXRv JiBheElEIDogYXhJRHMpIHsKLSAgICAgICAgaWYgKFJlZlB0ciBvYmplY3QgPSBvYmplY3RGb3JJ RChheElEKSkKLSAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoV1RGTW92ZShvYmplY3QpKTsKLSAg ICB9Ci0gICAgcmVzdWx0LnNocmlua1RvRml0KCk7Ci0gICAgcmV0dXJuIHJlc3VsdDsKLX0KLQog dm9pZCBBWElzb2xhdGVkVHJlZTo6Z2VuZXJhdGVTdWJ0cmVlKEFjY2Vzc2liaWxpdHlPYmplY3Qm IGF4T2JqZWN0KQogewogICAgIEFYVFJBQ0UoIkFYSXNvbGF0ZWRUcmVlOjpnZW5lcmF0ZVN1YnRy ZWUiX3MpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRl ZHRyZWUvQVhJc29sYXRlZFRyZWUuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKaW5kZXggNTlmMTlmYTc4OGY1Li43ZThmNjE3ODE1 OWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVl L0FYSXNvbGF0ZWRUcmVlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29s YXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaApAQCAtMjksNiArMjksNyBAQAogCiAjaW5jbHVkZSAi QVhDb3JlT2JqZWN0LmgiCiAjaW5jbHVkZSAiQVhUZXh0TWFya2VyLmgiCisjaW5jbHVkZSAiQVhU ZXh0UnVuLmgiCiAjaW5jbHVkZSAiQVhUcmVlU3RvcmUuaCIKICNpbmNsdWRlICJQYWdlSWRlbnRp Zmllci5oIgogI2luY2x1ZGUgIlJlbmRlclN0eWxlQ29uc3RhbnRzLmgiCkBAIC00Nyw2ICs0OCw3 IEBAIGNsYXNzIFRleHRTdHJlYW07CiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEFYSXNv bGF0ZWRPYmplY3Q7CitjbGFzcyBBWEdlb21ldHJ5TWFuYWdlcjsKIGNsYXNzIEFYT2JqZWN0Q2Fj aGU7CiBjbGFzcyBBY2Nlc3NpYmlsaXR5T2JqZWN0OwogY2xhc3MgUGFnZTsKQEAgLTI1NSw3ICsy NTcsNyBAQCB1c2luZyBBWFByb3BlcnR5VmFsdWVWYXJpYW50ID0gc3RkOjp2YXJpYW50PHN0ZDo6 bnVsbHB0cl90LCBBWElELCBTdHJpbmcsIGJvb2wsCiAgICAgLCBSZXRhaW5QdHI8TlNBdHRyaWJ1 dGVkU3RyaW5nPgogI2VuZGlmCiAjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAg LCBWZWN0b3I8QVhUZXh0UnVuPgorICAgICwgQVhUZXh0UnVucwogI2VuZGlmCiA+OwogdXNpbmcg QVhQcm9wZXJ0eU1hcCA9IEhhc2hNYXA8QVhQcm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlWYWx1ZVZh cmlhbnQsIEludEhhc2g8QVhQcm9wZXJ0eU5hbWU+LCBXVEY6OlN0cm9uZ0VudW1IYXNoVHJhaXRz PEFYUHJvcGVydHlOYW1lPj47CkBAIC0zMjIsNyArMzI0LDIwIEBAIHB1YmxpYzoKICAgICBXRUJD T1JFX0VYUE9SVCBSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gZm9jdXNlZE5vZGUoKTsKIAogICAg IFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBvYmplY3RGb3JJRChjb25zdCBBWElEKSBjb25zdDsK LSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IG9i amVjdHNGb3JJRHMoY29uc3QgVSYpIGNvbnN0OworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+Cisg ICAgVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4 SURzKSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CisKKyAg ICAgICAgVmVjdG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiByZXN1bHQ7CisgICAgICAgIHJlc3Vs dC5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGF4SURzLnNpemUoKSk7CisgICAgICAgIGZvciAoY29u c3QgYXV0byYgYXhJRCA6IGF4SURzKSB7CisgICAgICAgICAgICBpZiAoUmVmUHRyIG9iamVjdCA9 IG9iamVjdEZvcklEKGF4SUQpKQorICAgICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoV1RGTW92 ZShvYmplY3QpKTsKKyAgICAgICAgfQorICAgICAgICByZXN1bHQuc2hyaW5rVG9GaXQoKTsKKyAg ICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9CiAKICAgICB2b2lkIGdlbmVyYXRlU3VidHJlZShB Y2Nlc3NpYmlsaXR5T2JqZWN0Jik7CiAgICAgdm9pZCBsYWJlbENyZWF0ZWQoQWNjZXNzaWJpbGl0 eU9iamVjdCYpOwo= 469341 2024-01-08 10:39:48 -0800 2024-01-09 14:15:24 -0800 Patch bug-266521-20240108103947.patch text/plain 46438 tyler_w RnJvbSBkOWFjZTc2MjJhZDBhN2MyMjVlNjJjOWFhNDJmNjM3N2VhZDE1M2QxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGxpbmUgcmFuZ2UsIGFuZCBzdHJpbmctZm9yLXJh bmdlIHRleHQgbWFya2VyCiBBUElzIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjY1MjEgcmRhcjovLzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5 cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzog OGJpdAoKUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCgpUaGlzIHBhdGNoIGFkZHMgZnVuY3Rp b25hbGl0eSB0byBBWFRleHRNYXJrZXIgdG8gdHJhdmVyc2UgdGhlIGFjY2Vzc2liaWxpdHkgdHJl ZSwgYW5hbHl6aW5nIGNhY2hlZCBBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMKYXQgZWFjaCBzdG9w LCB0byBzZXJ2ZSB0aGVzZSBBUElzIG9mZiB0aGUgbWFpbi10aHJlYWQuCgpUaGUgaW1wbGVtZW50 YXRpb24gaW4gdGhpcyBwYXRjaCBpZ25vcmVzIGltcG9ydGFudCBlZGdlIGNhc2VzIOKAlCBlLmcu IGFyaWEtb3ducyB0cmVlIHJlLW9yZGVyaW5nIHdpbGwgY2F1c2UgdXMgdG8KY29tcHV0ZSB0aGUg d3JvbmcgcmVzdWx0cywgYW5kIHRleHQgaW4gaWdub3JlZCBvYmplY3RzIHdpbGwgYmUgc2tpcHBl ZC4KCiogU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZToKKiBTb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dDoKKiBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaDoKKFdlYkNv cmU6OkFYVGV4dFJ1bjo6QVhUZXh0UnVuKTogRGVsZXRlZC4KKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6dGV4dFJ1bnMpOiBEZWxldGVkLgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtlcjo6aXNvbGF0ZWRPYmplY3QgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyUmFuZ2U6OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6ZmluZE9iamVjdFdpdGhSdW5zKToKKFdlYkNvcmU6OkFYVGV4dE1hcmtlclJh bmdlOjp0b1N0cmluZyBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6OnJ1bnMgY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpmaW5kTWFya2VyIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dE1hcmtlcjo6YXNUZXh0TGVhZk1hcmtlciBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OmlzVGV4dExlYWYgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjp0ZXh0UnVuSW5k ZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpsaW5lUmFuZ2UgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpzdWJzdHJpbmcgY29uc3QpOgoqIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmg6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OkFYVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6Om9mZnNldCBjb25zdCk6 CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bnM6OmRlYnVnRGVzY3JpcHRpb24gY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6aW5kZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoU3VtVG8gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6c3Vic3RyaW5nIGNvbnN0 KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bkxpbmVJRDo6QVhUZXh0UnVuTGluZUlEKToKKFdlYkNvcmU6OkFYVGV4 dFJ1bkxpbmVJRDo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRSdW46 OkFYVGV4dFJ1bik6CihXZWJDb3JlOjpBWFRleHRSdW46OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6QVhUZXh0UnVucyk6CihXZWJDb3JlOjpBWFRleHRSdW5z OjpzaXplIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6OmF0IGNvbnN0KToKKFdlYkNvcmU6 OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoU3VtIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dFJ1bnM6OmxpbmVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRy ZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoK KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNw cDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFY SXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcgY29uc3QpOgooV2ViQ29yZTo6QVhJc29sYXRlZE9iamVj dDo6dGV4dFJ1bnMgY29uc3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHA6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJl ZTo6b2JqZWN0c0ZvcklEcyBjb25zdCk6IERlbGV0ZWQuCiogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaDoKKFdlYkNvcmU6OkFYSXNvbGF0 ZWRUcmVlOjpvYmplY3RzRm9ySURzIGNvbnN0KToKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJz LmNtYWtlICAgICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50 eHQgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiB8ICAgNiArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYQ29yZU9iamVjdC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmNwcCB8IDIyMSArKysrKysrKysrKysrKysrKy0KIFNvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmggICB8ICA1MSArKysrCiBTb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAgICAgfCAgOTMgKysrKysrKysKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDEyMCArKysrKysrKysrCiAu Li4vYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcCAgICAgfCAgIDYgKwogLi4u L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oICAgICAgIHwgICA1ICsKIC4uLi9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCAgICAgICAgICAgICB8ICAgNiArLQogLi4uL2Fj Y2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIHwgICAyICstCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwICAgICAgICAgfCAgMzAgKysrCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaCAgICAgICAgICAgfCAgMTYgKy0KIC4uLi9pc29s YXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwICAgICAgICAgICB8ICAxNyArLQogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oICAgICAgICAgICAgIHwgIDE5ICstCiAxNiBmaWxlcyBj aGFuZ2VkLCA1NjkgaW5zZXJ0aW9ucygrKSwgNDQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAx MDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwCiBjcmVhdGUg bW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9I ZWFkZXJzLmNtYWtlCmluZGV4IDFhZTE3YTUyZDA5MS4uNzljMzdmYWNkOGRhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRl cnMuY21ha2UKQEAgLTY1Miw2ICs2NTIsNyBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09S S19IRUFERVJTCiAgICAgYWNjZXNzaWJpbGl0eS9BWExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCisgICAg YWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0U3RhdGVD aGFuZ2VJbnRlbnQuaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUcmVlU3RvcmUuaAogICAgIGFjY2Vz c2liaWxpdHkvQWNjZXNzaWJpbGl0eUxpc3RCb3guaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvU291cmNlcy50eHQgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dAppbmRleCAxNzg0Nzhk ZDhhYmYuLjU2NGNiMzE4MjY2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvU291cmNlcy50 eHQKKysrIGIvU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQKQEAgLTUyMiw2ICs1MjIsNyBAQCBh Y2Nlc3NpYmlsaXR5L0FYSW1hZ2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAogYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIu Y3BwCithY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eUFSSUFHcmlkLmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRDZWxs LmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRSb3cuY3BwCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggOWU3 NWNmMDllNDQyLi5kMzAxYzE3ZTMxZjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE3NTIsNiArMTc1Miw3IEBACiAJCTQ3RkE5 NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAw ODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dlb21ldHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8q IFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0 M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhH ZW9tZXRyeU1hbmFnZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OworCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFB MDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJNDhCNUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxp dHlSZWdpb25Db250ZXh0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNv bnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQk0OEQwRTEyOTI5RjczMjlFMDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlG NzMyMjkwMDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9 IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ5MTM0MkUzMkI0M0ZGRUYwMEZF RUYxOCAvKiBDU1NTZWxlY3RvcklubGluZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQ5MTM0MkRBMkI0M0ZBQTgwMEZFRUYxOCAvKiBDU1NTZWxlY3Rv cklubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwpAQCAtMTA3MjQsOCArMTA3MjUsMTAgQEAKIAkJNDgyMjk3MEMyOUM4RUJDMDAwMzNBMTI2IC8q IFJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVnaW9u Q29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0ODZCOERDNjJBMDQzQzA2 MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhHZW9tZXRy eU1hbmFnZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDg2QjhEQzgyQTA0NTAw RjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJNDhCMDI0MjgyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWFRleHRSdW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzUyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM2MjlDQTY5MTcwMEZFQkUz QiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBB Y2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTQ4QzRFODNDMkIzNEQ4MzgwMDgzNDYwQSAvKiBBWFRleHRSdW4uY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gQVhUZXh0UnVuLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhE MEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ5MTM0Mjk2MkI0MjVDMDEwMEZFRUYxOCAvKiBDU1NQc2V1ZG9TZWxlY3RvcnMu anNvbiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRl eHQuanNvbjsgcGF0aCA9IENTU1BzZXVkb1NlbGVjdG9ycy5qc29uOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk0OTEzNDI5NzJCNDI1QzAyMDBGRUVGMTggLyogcHJvY2Vzcy1jc3MtcHNl dWRvLXNlbGVjdG9ycy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9ICJwcm9jZXNzLWNzcy1wc2V1ZG8t c2VsZWN0b3JzLnB5Ijsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIzMTk4LDYgKzIz MjAxLDggQEAKIAkJCQkyOUE4MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5o ICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICov LAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJ CQk0OEM0RTgzQzJCMzREODM4MDA4MzQ2MEEgLyogQVhUZXh0UnVuLmNwcCAqLywKKwkJCQk0OEIw MjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUz QkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFE QzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFYVHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYw NTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFjY2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1OTMs NiArMzc1OTgsNyBAQAogCQkJCTI5QUUyMTJEMjFBQjlFRUIwMDg2OTI4MyAvKiBBWElzb2xhdGVk VHJlZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMjlBODEyMzgwRkJCOUMxRDAwNTEwMjkzIC8qIEFY T2JqZWN0Q2FjaGUuaCBpbiBIZWFkZXJzICovLAogCQkJCUMwRTIwOEEyMjkzNzlDNkYwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTQ4QjAyNDJBMkIyQTY1QUEw MDgzRDEyMiAvKiBBWFRleHRSdW4uaCBpbiBIZWFkZXJzICovLAogCQkJCTkxQzlGMkY5MUFFM0JF QjAwMDk1QjYxQyAvKiBBWFRleHRTdGF0ZUNoYW5nZUludGVudC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQzBFOEFEQzUyOTRCNUE2MzAwNzZDQkRDIC8qIEFYVHJlZVN0b3JlLmggaW4gSGVhZGVycyAq LywKIAkJCQkxNDc3RTc3NzBCRjQxMzRBMDAxNTI4NzIgLyogQmFja0ZvcndhcmRDYWNoZS5oIGlu IEhlYWRlcnMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY Q29yZU9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3Qu aAppbmRleCA3ZDE4ZjUyMTI2OTUuLjk0MzJkZWQ2YTg1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCkBAIC0xMTMsMTkgKzExMyw2IEBAIGVudW0gY2xh c3MgQVhBbmNlc3RvckZsYWcgOiB1aW50OF90IHsKICAgICAvLyBCaXQgNyBpcyBmcmVlLgogfTsK IAotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotc3RydWN0IEFYVGV4dFJ1biB7Ci0g ICAgLy8gVGhlIGxpbmUgaW5kZXggb2YgdGhpcyBydW4gd2l0aGluIHRoZSBjb250ZXh0IG9mIHRo ZSBjb250YWluaW5nIFJlbmRlckJsb2NrRmxvdyBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0 LgotICAgIHNpemVfdCBsaW5lSW5kZXg7Ci0gICAgU3RyaW5nIHRleHQ7Ci0KLSAgICBBWFRleHRS dW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5nJiYgdGV4dCkKLSAgICAgICAgOiBsaW5lSW5kZXgo bGluZUluZGV4KQotICAgICAgICAsIHRleHQoV1RGTW92ZSh0ZXh0KSkKLSAgICB7IH0KLX07Ci0j ZW5kaWYKLQogZW51bSBjbGFzcyBBY2Nlc3NpYmlsaXR5Um9sZSB7CiAgICAgQXBwbGljYXRpb24g PSAxLAogICAgIEFwcGxpY2F0aW9uQWxlcnQsCkBAIC02NTYsNiArNjQzLDggQEAgZW51bSBjbGFz cyBBY2Nlc3NpYmlsaXR5QnV0dG9uU3RhdGUgewogICAgIE1peGVkLAogfTsKIAorZW51bSBjbGFz cyBBWERpcmVjdGlvbiA6IGJvb2wgeyBOZXh0LCBQcmV2aW91cyB9OworCiBlbnVtIGNsYXNzIEFj Y2Vzc2liaWxpdHlTb3J0RGlyZWN0aW9uIHsKICAgICBOb25lLAogICAgIEFzY2VuZGluZywKQEAg LTgwMyw2ICs3OTIsNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldE9iamVjdElEKEFYSUQgYXhJ RCkgeyBtX2lkID0gYXhJRDsgfQogICAgIEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJldHVybiBt X2lkOyB9CisgICAgdmlydHVhbCBBWElEIHRyZWVJRCgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFs IFByb2Nlc3NJRCBwcm9jZXNzSUQoKSBjb25zdCA9IDA7CiAKICAgICAvLyBXaGVuIHRoZSBjb3Jy ZXNwb25kaW5nIFdlYkNvcmUgb2JqZWN0IHRoYXQgdGhpcyBhY2Nlc3NpYmxlIG9iamVjdApAQCAt MTEwNyw5ICsxMDk3LDYgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhY2Nlc3NpYmlsaXR5 VGV4dChWZWN0b3I8QWNjZXNzaWJpbGl0eVRleHQ+JikgY29uc3QgPSAwOwogICAgIC8vIEEgcHJv Z3JhbW1hdGljIHdheSB0byBzZXQgYSBuYW1lIG9uIGFuIEFjY2Vzc2libGVPYmplY3QuCiAgICAg dmlydHVhbCB2b2lkIHNldEFjY2Vzc2libGVOYW1lKGNvbnN0IEF0b21TdHJpbmcmKSA9IDA7Ci0j aWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgdmlydHVhbCBWZWN0b3I8QVhUZXh0 UnVuPiB0ZXh0UnVucygpIHsgcmV0dXJuIHsgfTsgfQotI2VuZGlmCiAKICAgICB2aXJ0dWFsIFN0 cmluZyB0aXRsZSgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFsIFN0cmluZyBkZXNjcmlwdGlvbigp IGNvbnN0ID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2Vy LmNwcAppbmRleCA5YWQ2YWJmOTNhYWMuLmY5YWM4OTRhYjI2OSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMTk0LDYgKzE5NCwxMyBAQCBz dGQ6Om9wdGlvbmFsPEJvdW5kYXJ5UG9pbnQ+IEFYVGV4dE1hcmtlcjo6Ym91bmRhcnlQb2ludCgp IGNvbnN0CiAgICAgcmV0dXJuIHsgeyAqbm9kZSwgc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KG9mZnNl dCkgfSB9OwogfQogCisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURfVFJFRSkKK1Jl ZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBBWFRleHRNYXJrZXI6Omlzb2xhdGVkT2JqZWN0KCkgY29u c3QKK3sKKyAgICByZXR1cm4gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KG9iamVj dCgpKTsKK30KKyNlbmRpZiAvLyBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQor CiBSZWZQdHI8QVhDb3JlT2JqZWN0PiBBWFRleHRNYXJrZXI6Om9iamVjdCgpIGNvbnN0CiB7CiAg ICAgaWYgKGlzTnVsbCgpKQpAQCAtMzM1LDcgKzM0Miw3IEBAIHN0ZDo6b3B0aW9uYWw8QVhUZXh0 TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtlclJhbmdlOjppbnRlcnNlY3Rpb25XaXRoKGNvbnN0IEFY VGV4CiAKIFN0cmluZyBBWFRleHRNYXJrZXJSYW5nZTo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0 CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2Ny aXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBtX2VuZC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9Iik7Cisg ICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2NyaXB0aW9u KCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5kLmRlYnVnRGVzY3JpcHRpb24oKSwgIn0iKTsKIH0KIAog c3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBhcnRpYWxPcmRlcihjb25zdCBBWFRleHRNYXJrZXImIG1h cmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMikKQEAgLTM2OCw0ICszNzUsMjE2IEBA IGJvb2wgQVhUZXh0TWFya2VyUmFuZ2U6OmlzQ29uZmluZWRUbyhBWElEIG9iamVjdElEKSBjb25z dAogICAgICAgICAmJiBMSUtFTFkobV9zdGFydC50cmVlSUQoKSA9PSBtX2VuZC50cmVlSUQoKSk7 CiB9CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK2VudW0gY2xhc3MgQ2hlY2tT dGFydCA6IGJvb2wgeyBObywgWWVzIH07CisvLyBGaW5kcyB0aGUgbmV4dCBvYmplY3Qgd2l0aCB0 ZXh0IHJ1bnMgaW4gdGhlIGdpdmVuIGRpcmVjdGlvbi4KK3N0YXRpYyBSZWZQdHI8QVhJc29sYXRl ZE9iamVjdD4gZmluZE9iamVjdFdpdGhSdW5zKEFYSXNvbGF0ZWRPYmplY3QmIHN0YXJ0LCBBWERp cmVjdGlvbiBkaXJlY3Rpb24sIENoZWNrU3RhcnQgY2hlY2tTdGFydCA9IENoZWNrU3RhcnQ6Ok5v KQoreworICAgIGlmIChjaGVja1N0YXJ0ID09IENoZWNrU3RhcnQ6OlllcykgeworICAgICAgICBp ZiAoYXV0byogcnVucyA9IHN0YXJ0LnRleHRSdW5zKCk7IHJ1bnMgJiYgcnVucy0+c2l6ZSgpKQor ICAgICAgICAgICAgcmV0dXJuICZzdGFydDsKKyAgICB9CisKKyAgICBSZWZQdHIgY3VycmVudCA9 ICZzdGFydDsKKyAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICBpZiAoY3VycmVudCAhPSAm c3RhcnQpIHsKKyAgICAgICAgICAgIGF1dG8qIHJ1bnMgPSBjdXJyZW50LT50ZXh0UnVucygpOwor ICAgICAgICAgICAgaWYgKHJ1bnMgJiYgcnVucy0+c2l6ZSgpKQorICAgICAgICAgICAgICAgIHJl dHVybiBjdXJyZW50OworICAgICAgICB9CisKKyAgICAgICAgLy8gRklYTUU6IGFyaWEtb3ducyBi cmVha3MgdGhpcyB0cmF2ZXJzYWwsIGFzIGFyaWEtb3ducyBjYXVzZXMgdGhlIEFYIHRyZWUgdG8g YmUgY2hhbmdlZCwgYWZmZWN0aW5nCisgICAgICAgIC8vIG91ciBpdGVyYXRpb24gYmVsb3csIGJ1 dCBpdCBkb2Vzbid0IGFjdHVhbGx5IGNoYW5nZSB0ZXh0IHBvc2l0aW9uIG9uIHRoZSBwYWdlLiBT byB3ZSBuZWVkIHRvIGlnbm9yZSBhcmlhLW93bnMKKyAgICAgICAgLy8gdHJlZSBjaGFuZ2VzIGhl cmUgaW4gb3JkZXIgdG8gYmVoYXZlIGNvcnJlY3RseS4KKyAgICAgICAgLy8gV2UgYWxzbyBwcm9i YWJseSBuZWVkIHRvIGRvIHNvbWV0aGluZyBhYm91dCB0ZXh0IHdpdGhpbiBhcmlhLWhpZGRlbiBj b250YWluZXJzLCB3aGljaCBhZmZlY3RzIHRoZSBBWCB0cmVlLgorCisgICAgICAgIGNvbnN0IGF1 dG8mIGNoaWxkcmVuID0gY3VycmVudC0+Y2hpbGRyZW4oKTsKKyAgICAgICAgaWYgKGNoaWxkcmVu LnNpemUoKSkgeworICAgICAgICAgICAgc2l6ZV90IGNoaWxkSW5kZXggPSBkaXJlY3Rpb24gPT0g QVhEaXJlY3Rpb246Ok5leHQgPyAwIDogY2hpbGRyZW4uc2l6ZSgpIC0gMTsKKyAgICAgICAgICAg IFJFTEVBU0VfQVNTRVJUKGNoaWxkcmVuW2NoaWxkSW5kZXhdKTsKKyAgICAgICAgICAgIGN1cnJl bnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oY2hpbGRyZW5bY2hpbGRJbmRl eF0uZ2V0KCkpOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICAv LyBgY3VycmVudGAgaGFzIG5vIGNoaWxkcmVuLCBtZWFuaW5nIGl0J3MgYSBsZWFmIG5vZGUgKGUu Zy4gaXQncyB0ZXh0LCB3aGljaCBjYW5ub3QgaGF2ZSBjaGlsZHJlbikuCisgICAgICAgIC8vIENo ZWNrIGBjdXJyZW50YHMgc2libGluZ3MuCisgICAgICAgIGlmIChhdXRvKiBzaWJsaW5nID0gY3Vy cmVudC0+c2libGluZyhkaXJlY3Rpb24pKSB7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1p Y0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KHNpYmxpbmcpOworICAgICAgICAgICAgY29udGlu dWU7CisgICAgICAgIH0KKworICAgICAgICAvLyBXZSBoYXZlIG5vIGNoaWxkcmVuLCBhbmQgbm8g bmV4dC9wcmV2aW91cyBzaWJsaW5nLiBUcnkgb3VyIHBhcmVudCdzIHNpYmxpbmcuCisgICAgICAg IGlmIChhdXRvKiBwYXJlbnQgPSBjdXJyZW50LT5wYXJlbnRPYmplY3RVbmlnbm9yZWQoKSkgewor ICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0Pihw YXJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgfQorCisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsKK30KKwor U3RyaW5nIEFYVGV4dE1hcmtlclJhbmdlOjp0b1N0cmluZygpIGNvbnN0Cit7CisgICAgUkVMRUFT RV9BU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKworICAgIGF1dG8gc3RhcnQgPSBtX3N0YXJ0LnRv VGV4dExlYWZNYXJrZXIoKTsKKyAgICBpZiAoIXN0YXJ0LmlzVmFsaWQoKSkKKyAgICAgICAgcmV0 dXJuIGVtcHR5U3RyaW5nKCk7CisgICAgYXV0byBlbmQgPSBtX2VuZC50b1RleHRMZWFmTWFya2Vy KCk7CisgICAgaWYgKCFlbmQuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm4gZW1wdHlTdHJpbmco KTsKKworICAgIGlmIChzdGFydC5pc29sYXRlZE9iamVjdCgpID09IGVuZC5pc29sYXRlZE9iamVj dCgpKSB7CisgICAgICAgIHNpemVfdCBtaW5PZmZzZXQgPSBzdGQ6Om1pbihzdGFydC5vZmZzZXQo KSwgZW5kLm9mZnNldCgpKTsKKyAgICAgICAgc2l6ZV90IG1heE9mZnNldCA9IHN0ZDo6bWF4KHN0 YXJ0Lm9mZnNldCgpLCBlbmQub2Zmc2V0KCkpOworICAgICAgICByZXR1cm4gc3RhcnQucnVucygp LT5zdWJzdHJpbmcobWluT2Zmc2V0LCBtYXhPZmZzZXQgLSBtaW5PZmZzZXQpOworICAgIH0KKwor ICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHJlc3VsdC5hcHBlbmQoc3RhcnQucnVucygp LT5zdWJzdHJpbmcoc3RhcnQub2Zmc2V0KCkpKTsKKworICAgIC8vIEZJWE1FOiBJZiB3ZSd2ZSBi ZWVuIGdpdmVuIHJldmVyc2VkIG1hcmtlcnMsIGkuZS4gdGhlIGVuZCBtYXJrZXIgYWN0dWFsbHkg Y29tZXMgYmVmb3JlIHRoZSBzdGFydCBtYXJrZXIsCisgICAgLy8gd2UgbWF5IHdhbnQgdG8gZGV0 ZWN0IHRoaXMgYW5kIHRyeSBzZWFyY2hpbmcgQVhEaXJlY3Rpb246OlByZXZpb3VzPworICAgIFJl ZlB0ciBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpzdGFydC5pc29sYXRlZE9iamVjdCgp LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgd2hpbGUgKGN1cnJlbnQgJiYgY3VycmVudC0+b2Jq ZWN0SUQoKSAhPSBlbmQub2JqZWN0SUQoKSkgeworICAgICAgICBjb25zdCBhdXRvKiBydW5zID0g Y3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHJ1 bnMtPnNpemUoKTsgaSsrKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zLT5hdChpKS50 ZXh0KTsKKyAgICAgICAgY3VycmVudCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudCwgQVhE aXJlY3Rpb246Ok5leHQpOworICAgIH0KKyAgICByZXN1bHQuYXBwZW5kKGVuZC5ydW5zKCktPnN1 YnN0cmluZygwLCBlbmQub2Zmc2V0KCkpKTsKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7 Cit9CisKK2NvbnN0IEFYVGV4dFJ1bnMqIEFYVGV4dE1hcmtlcjo6cnVucygpIGNvbnN0Cit7Cisg ICAgUmVmUHRyIG9iamVjdCA9IGlzb2xhdGVkT2JqZWN0KCk7CisgICAgcmV0dXJuIG9iamVjdCA/ IG9iamVjdC0+dGV4dFJ1bnMoKSA6IG51bGxwdHI7Cit9CisKK0FYVGV4dE1hcmtlciBBWFRleHRN YXJrZXI6OmZpbmRNYXJrZXIoQVhEaXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIGlm ICghaXNWYWxpZCgpKQorICAgICAgICByZXR1cm4geyB9OworICAgIGlmICghaXNJblRleHRMZWFm KCkpCisgICAgICAgIHJldHVybiB0b1RleHRMZWFmTWFya2VyKCkuZmluZE1hcmtlcihkaXJlY3Rp b24pOworICAgIFJFTEVBU0VfQVNTRVJUKGlzSW5UZXh0TGVhZigpKTsKKworICAgIHNpemVfdCBy dW5JbmRleCA9IHJ1bnMoKS0+aW5kZXhGb3JPZmZzZXQob2Zmc2V0KCkpOworICAgIFJFTEVBU0Vf QVNTRVJUKHJ1bkluZGV4ICE9IG5vdEZvdW5kKTsKKyAgICBhdXRvIGhhc01vcmVUZXh0SW5DdXJy ZW50UnVuID0gWyZdIHsKKyAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4 dCkKKyAgICAgICAgICAgIHJldHVybiBvZmZzZXQoKSA8IHJ1bnMoKS0+YXQocnVuSW5kZXgpLnRl eHQubGVuZ3RoKCk7CisgICAgICAgIHJldHVybiBvZmZzZXQoKSA+IDA7CisgICAgfTsKKyAgICBi b29sIGhhc0Fub3RoZXJSdW4gPSBydW5JbmRleCArIDEgPCBydW5zKCktPnNpemUoKTsKKyAgICAv LyBUaGUgbmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRleHQsIGJlY2F1c2Ugd2UncmUg Z29pbmcgdG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBvZmZzZXQoKSArIDEsIHdoaWNo IHdvdWxkIGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVucygpLT5ydW5MZW5ndGgocnVu SW5kZXggKyAxKSA+IDApOworICAgIC8vIENoZWNraW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5v dGhlciBydW4gaXMgb25seSByZWxldmFudCBmb3IgbW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBh cyBqdXN0IGNoZWNraW5nIHRoYXQgb2Zmc2V0KCkgPiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGly ZWN0aW9uOjpQcmV2aW91cy4KKyAgICBpZiAoaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAo ZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAg ICAgIC8vIFJldHVybiBhbiBvZmZzZXQgdG8gdGhlIG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJy ZW50IHJ1bi4KKyAgICAgICAgcmV0dXJuIHsgdHJlZUlEKCksIG9iamVjdElEKCksIGRpcmVjdGlv biA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IG9mZnNldCgpICsgMSA6IG9mZnNldCgpIC0gMSB9Owor ICAgIH0KKyAgICAvLyBvZmZzZXQoKSBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3RlciBpbiB0 aGUgZ2l2ZW4gb2JqZWN0J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0aGUgbmV4 dCBvYmplY3Qgd2l0aCBydW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9iamVjdFdp dGhSdW5zKCp0aGlzLT5pc29sYXRlZE9iamVjdCgpLCBkaXJlY3Rpb24pKQorICAgICAgICByZXR1 cm4geyBvYmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBB WERpcmVjdGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5zKCktPmxhc3RSdW5MZW5ndGgo KSB9OworCisgICAgcmV0dXJuIHsgfTsKK30KKworQVhUZXh0TWFya2VyIEFYVGV4dE1hcmtlcjo6 ZmluZE1hcmtlcihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4dFVuaXQsIEFY VGV4dFVuaXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoIWlzVmFsaWQoKSkK KyAgICAgICAgcmV0dXJuIHsgfTsKKyAgICBpZiAoIWlzSW5UZXh0TGVhZigpKQorICAgICAgICBy ZXR1cm4gdG9UZXh0TGVhZk1hcmtlcigpLmZpbmRNYXJrZXIoZGlyZWN0aW9uLCB0ZXh0VW5pdCwg Ym91bmRhcnkpOworICAgIFJFTEVBU0VfQVNTRVJUKGlzSW5UZXh0TGVhZigpKTsKKworICAgIGlm ICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7CisgICAgICAgIHNpemVfdCBydW5JbmRl eCA9IHJ1bnMoKS0+aW5kZXhGb3JPZmZzZXQob2Zmc2V0KCkpOworICAgICAgICBSRUxFQVNFX0FT U0VSVChydW5JbmRleCAhPSBub3RGb3VuZCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2JqZWN0 ID0gaXNvbGF0ZWRPYmplY3QoKTsKKyAgICAgICAgY29uc3QgYXV0byogY3VycmVudFJ1bnMgPSBj dXJyZW50T2JqZWN0LT50ZXh0UnVucygpOworCisgICAgICAgIGF1dG8gY29tcHV0ZU9mZnNldCA9 IFsmXSAoc2l6ZV90IHJ1bkVuZE9mZnNldCwgc2l6ZV90IHJ1bkxlbmd0aCkgeworICAgICAgICAg ICAgLy8gVGhpcyB3b3JrcyBiZWNhdXNlIGBydW5FbmRPZmZzZXRgIGlzIHRoZSBvZmZzZXQgcG9p bnRpbmcgdG8gdGhlIGVuZCBvZiB0aGUgZ2l2ZW4gcnVuLCB3aGljaCBpbmNsdWRlcyB0aGUgbGVu Z3RoIG9mIGFsbCBydW5zIHByZWNlZGluZyBpdC4gU28gc3VidHJhY3RpbmcgdGhhdCBmcm9tIHRo ZSBsZW5ndGggb2YgdGhlIGN1cnJlbnQgcnVuIGdpdmVzIHVzIGFuIG9mZnNldCB0byB0aGUgc3Rh cnQgb2YgdGhlIGN1cnJlbnQgcnVuLgorICAgICAgICAgICAgcmV0dXJuIGJvdW5kYXJ5ID09IEFY VGV4dFVuaXRCb3VuZGFyeTo6RW5kID8gcnVuRW5kT2Zmc2V0IDogcnVuRW5kT2Zmc2V0IC0gcnVu TGVuZ3RoOworICAgICAgICB9OworICAgICAgICBhdXRvIGxpbmVQb3NpdGlvbiA9IEFYVGV4dE1h cmtlcih0cmVlSUQoKSwgb2JqZWN0SUQoKSwgY29tcHV0ZU9mZnNldChjdXJyZW50UnVucy0+cnVu TGVuZ3RoU3VtVG8ocnVuSW5kZXgpLCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKHJ1bkluZGV4KSkp OworICAgICAgICBhdXRvIHN0YXJ0TGluZUlEID0gY3VycmVudFJ1bnMtPmxpbmVJRChydW5JbmRl eCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0ZWQgbGlu ZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAgICAgIHdo aWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjdXJyZW50 UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZzZXQgPSAw OworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+c2l6ZSgp OyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5z LT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5saW5lSUQo aSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5lUG9zaXRp b247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhUZXh0TWFya2VyKGN1cnJlbnRP YmplY3QtPnRyZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJRCgpLCBjb21wdXRlT2Zmc2V0 KGN1bXVsYXRpdmVPZmZzZXQsIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSkpKTsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIGN1cnJlbnRPYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1 cnJlbnRPYmplY3QsIGRpcmVjdGlvbik7CisgICAgICAgICAgICBpZiAoY3VycmVudE9iamVjdCkK KyAgICAgICAgICAgICAgICBjdXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRleHRSdW5zKCk7 CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGxpbmVQb3NpdGlvbjsKKyAgICB9CisgICAgLy8g RklYTUU6IEltcGxlbWVudCB0aGUgb3RoZXIgQVhUZXh0VW5pdHMuCisKKyAgICByZXR1cm4geyB9 OworfQorCitBWFRleHRNYXJrZXIgQVhUZXh0TWFya2VyOjp0b1RleHRMZWFmTWFya2VyKCkgY29u c3QKK3sKKyAgICBpZiAoIWlzVmFsaWQoKSB8fCBpc0luVGV4dExlYWYoKSkgeworICAgICAgICAv LyBJZiBzb21ldGhpbmcgaGFzIGNvbnN0cnVjdGVkIGEgbGVhZiBtYXJrZXIsIGl0IHNob3VsZCd2 ZSBkb25lIHNvIHdpdGggYW4gaW4tYm91bmRzIG9mZnNldC4KKyAgICAgICAgUkVMRUFTRV9BU1NF UlQoIWlzVmFsaWQoKSB8fCBpc29sYXRlZE9iamVjdCgpLT50ZXh0UnVucygpLT5ydW5MZW5ndGhT dW0oKSA+PSBvZmZzZXQoKSk7CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisKKyAgICAv LyBGaW5kIHRoZSBsZWFmIG5vZGUgb3VyIG9mZnNldCBwb2ludHMgdG8uIEZvciBleGFtcGxlOgor ICAgIC8vIEFYVGV4dE1hcmtlciB7IElEIDE6IEdyb3VwLCBPZmZzZXQgNiB9CisgICAgLy8gSUQg MTogR3JvdXAKKyAgICAvLyAgLSBJRCAyOiBGb28KKyAgICAvLyAgLSBJRCAzOiBMaW5lMQorICAg IC8vICAgICAgICAgIExpbmUyCisgICAgLy8gQ2FsbGluZyB0b1RleHRMZWFmTWFya2VyKCkgb24g dGhlIG9yaWdpbmFsIG1hcmtlciBzaG91bGQgeWllbGQgbmV3IG1hcmtlcjoKKyAgICAvLyBBWFRl eHRNYXJrZXIgeyBJRCAzOiBTdGF0aWNUZXh0LCBPZmZzZXQgMyB9CisgICAgLy8gQmVjYXVzZSB3 ZSBoYWQgdG8gd2FsayBvdmVyIElEIDIgd2hpY2ggaGFkIGxlbmd0aCAzIHRleHQuCisgICAgc2l6 ZV90IHByZWNlZGluZ09mZnNldCA9IDA7CisgICAgUmVmUHRyIGN1cnJlbnQgPSBmaW5kT2JqZWN0 V2l0aFJ1bnMoKmlzb2xhdGVkT2JqZWN0KCksIEFYRGlyZWN0aW9uOjpOZXh0LCBDaGVja1N0YXJ0 OjpZZXMpOworICAgIHdoaWxlIChjdXJyZW50KSB7CisgICAgICAgIHVuc2lnbmVkIGN1cnJlbnRT dW0gPSBjdXJyZW50LT50ZXh0UnVucygpLT5ydW5MZW5ndGhTdW0oKTsKKyAgICAgICAgaWYgKHBy ZWNlZGluZ09mZnNldCArIGN1cnJlbnRTdW0gPj0gb2Zmc2V0KCkpCisgICAgICAgICAgICBicmVh azsKKyAgICAgICAgcHJlY2VkaW5nT2Zmc2V0ICs9IGN1cnJlbnRTdW07CisgICAgICAgIGN1cnJl bnQgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1cnJlbnQsIEFYRGlyZWN0aW9uOjpOZXh0KTsKKyAg ICB9CisKKyAgICBpZiAoIWN1cnJlbnQpCisgICAgICAgIHJldHVybiB7IH07CisKKyAgICBSRUxF QVNFX0FTU0VSVChvZmZzZXQoKSA+PSBwcmVjZWRpbmdPZmZzZXQpOworICAgIHJldHVybiB7IGN1 cnJlbnQtPnRyZWVJRCgpLCBjdXJyZW50LT5vYmplY3RJRCgpLCBzdGF0aWNfY2FzdDx1bnNpZ25l ZD4ob2Zmc2V0KCkgLSBwcmVjZWRpbmdPZmZzZXQpIH07Cit9CisKK2Jvb2wgQVhUZXh0TWFya2Vy Ojppc0luVGV4dExlYWYoKSBjb25zdAoreworICAgIFJlZlB0ciBvYmplY3QgPSB0aGlzLT5pc29s YXRlZE9iamVjdCgpOworICAgIC8vIEZJWE1FOiBJcyBpdCBwb3NzaWJsZSBmb3Igbm9uLWxlYWYg bm9kZXMgdG8gaGF2ZSB0ZXh0IHJ1bnM/IElmIHNvLCB3ZSBkb24ndCBoYW5kbGUgdGhlbSBjb3Jy ZWN0bHkuCisgICAgcmV0dXJuICFvYmplY3QgfHwgKCFvYmplY3QtPmNoaWxkcmVuKCkuc2l6ZSgp ICYmIG9iamVjdC0+dGV4dFJ1bnMoKSk7Cit9CisKK0FYVGV4dE1hcmtlclJhbmdlIEFYVGV4dE1h cmtlcjo6bGluZVJhbmdlKExpbmVSYW5nZVR5cGUgdHlwZSkgY29uc3QKK3sKKyAgICBpZiAoIWlz VmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIHsgeyB9LCB7IH0gfTsKKworICAgIGlmICh0eXBlID09 IExpbmVSYW5nZVR5cGU6OkN1cnJlbnQpCisgICAgICAgIHJldHVybiB7IGZpbmRNYXJrZXIoQVhE aXJlY3Rpb246OlByZXZpb3VzLCBBWFRleHRVbml0OjpMaW5lLCBBWFRleHRVbml0Qm91bmRhcnk6 OlN0YXJ0KSwgZmluZE1hcmtlcihBWERpcmVjdGlvbjo6TmV4dCwgQVhUZXh0VW5pdDo6TGluZSwg QVhUZXh0VW5pdEJvdW5kYXJ5OjpFbmQpIH07CisgICAgLy8gRklYTUU6IFRoZSBvdGhlciB0eXBl cyBhcmVuJ3QgaW1wbGVtZW50ZWQgeWV0LgorICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVE KCk7Cit9CisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtl ci5oCmluZGV4IDE3ZTlmYzBkYWI5OC4uOTY2NDA1ZDNlYjlmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmgKQEAgLTI4LDcgKzI4LDI1IEBACiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAorI2lmIEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUp CitjbGFzcyBBWElzb2xhdGVkT2JqZWN0OworI2VuZGlmCiBzdHJ1Y3QgQ2hhcmFjdGVyT2Zmc2V0 Oworc3RydWN0IEFYVGV4dFJ1bnM7CisKK2VudW0gY2xhc3MgQVhUZXh0VW5pdCA6IHVpbnQ4X3Qg eworICAgIExpbmUsCisgICAgUGFyYWdyYXBoLAorICAgIFNlbnRlbmNlLAorICAgIFdvcmQsCit9 OworZW51bSBjbGFzcyBBWFRleHRVbml0Qm91bmRhcnkgOiBib29sIHsgU3RhcnQsIEVuZCwgfTsK KworZW51bSBjbGFzcyBMaW5lUmFuZ2VUeXBlIDogdWludDhfdCB7CisgICAgQ3VycmVudCwKKyAg ICBMZWZ0LAorICAgIFJpZ2h0LAorfTsKIAogc3RydWN0IFRleHRNYXJrZXJEYXRhIHsKICAgICB1 bnNpZ25lZCB0cmVlSUQ7CkBAIC0xMDksNiArMTI3LDkgQEAgcHVibGljOgogI2lmIFBMQVRGT1JN KENPQ09BKQogICAgIEFYVGV4dE1hcmtlcihQbGF0Zm9ybVRleHRNYXJrZXJEYXRhKTsKICNlbmRp ZgorICAgIEFYVGV4dE1hcmtlcihBWElEIHRyZWVJRCwgQVhJRCBvYmplY3RJRCwgdW5zaWduZWQg b2Zmc2V0KQorICAgICAgICA6IG1fZGF0YSh7IHRyZWVJRCwgb2JqZWN0SUQsIG51bGxwdHIsIG9m ZnNldCwgUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvciwgQWZmaW5pdHk6OkRvd25z dHJlYW0sIDAsIG9mZnNldCB9KQorICAgIHsgfQogICAgIEFYVGV4dE1hcmtlcigpID0gZGVmYXVs dDsKIAogICAgIG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiAhaXNOdWxsKCk7IH0KQEAg LTEyMyw3ICsxNDQsMTIgQEAgcHVibGljOgogCiAgICAgQVhJRCB0cmVlSUQoKSBjb25zdCB7IHJl dHVybiBtX2RhdGEuYXhUcmVlSUQoKTsgfQogICAgIEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJl dHVybiBtX2RhdGEuYXhPYmplY3RJRCgpOyB9CisgICAgdW5zaWduZWQgb2Zmc2V0KCkgY29uc3Qg eyByZXR1cm4gbV9kYXRhLm9mZnNldDsgfQogICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyByZXR1 cm4gIXRyZWVJRCgpLmlzVmFsaWQoKSB8fCAhb2JqZWN0SUQoKS5pc1ZhbGlkKCk7IH0KKyNpZiBF TkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQorICAgIC8vIEZJWE1FOiBDdXJyZW50 bHksIHRoZSBsb2dpYyBmb3Igc2VydmluZyB0ZXh0IEFQSXMgb2ZmIHRoZSBtYWluLXRocmVhZCBy ZXF1aXJlcyBpc29sYXRlZCBvYmplY3RzLCBidXQgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVmYWN0 b3JlZCB0byB3b3JrIHdpdGggQVhDb3JlT2JqZWN0cy4KKyAgICBSZWZQdHI8QVhJc29sYXRlZE9i amVjdD4gaXNvbGF0ZWRPYmplY3QoKSBjb25zdDsKKyNlbmRpZgogICAgIFJlZlB0cjxBWENvcmVP YmplY3Q+IG9iamVjdCgpIGNvbnN0OwogICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsgcmV0dXJu IG9iamVjdCgpOyB9CiAKQEAgLTEzNCw3ICsxNjAsMjcgQEAgcHVibGljOgogCiAgICAgLy8gU2V0 cyBtX2RhdGEubm9kZSB3aGVuIHRoZSBtYXJrZXIgd2FzIGNyZWF0ZWQgd2l0aCBhIFBsYXRmb3Jt VGV4dE1hcmtlckRhdGEgdGhhdCBsYWNrcyB0aGUgbm9kZSBwb2ludGVyIGJlY2F1c2UgaXQgd2Fz IGNyZWF0ZWQgb2ZmIHRoZSBtYWluIHRocmVhZC4KICAgICB2b2lkIHNldE5vZGVJZk5lZWRlZCgp IGNvbnN0OworCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgLy8gRmluZCB0 aGUgbmV4dCBvciBwcmV2aW91cyBtYXJrZXIuCisgICAgQVhUZXh0TWFya2VyIGZpbmRNYXJrZXIo QVhEaXJlY3Rpb24pIGNvbnN0OworICAgIC8vIFN0YXJ0aW5nIGZyb20gdGhpcyB0ZXh0IG1hcmtl ciwgY3JlYXRlcyBhIG5ldyBwb3NpdGlvbiBmb3IgdGhlIGdpdmVuIGRpcmVjdGlvbiBhbmQgdGV4 dCB1bml0IHR5cGUuCisgICAgQVhUZXh0TWFya2VyIGZpbmRNYXJrZXIoQVhEaXJlY3Rpb24sIEFY VGV4dFVuaXQsIEFYVGV4dFVuaXRCb3VuZGFyeSkgY29uc3Q7CisgICAgLy8gQ3JlYXRlcyBhIHJh bmdlIGZvciB0aGUgbGluZSB0aGlzIG1hcmtlciBwb2ludHMgdG8uCisgICAgQVhUZXh0TWFya2Vy UmFuZ2UgbGluZVJhbmdlKExpbmVSYW5nZVR5cGUpIGNvbnN0OworICAgIC8vIEdpdmVuIGEgY2hh cmFjdGVyIG9mZnNldCByZWxhdGl2ZSB0byB0aGlzIG1hcmtlciwgZmluZCB0aGUgbmV4dCBtYXJr ZXIgdGhlIG9mZnNldCBwb2ludHMgdG8uCisgICAgQVhUZXh0TWFya2VyIG5leHRNYXJrZXJGcm9t T2Zmc2V0KHNpemVfdCkgY29uc3Q7CisjZW5kaWYgLy8gRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCisKIHByaXZhdGU6CisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgY29u c3QgQVhUZXh0UnVucyogcnVucygpIGNvbnN0OworCisgICAgLy8gVHJ1ZSBpZiB0aGlzIG1hcmtl ciBwb2ludHMgdG8gYSBsZWFmIG5vZGUgKG5vIGNoaWxkcmVuKSB3aXRoIG5vbi1lbXB0eSB0ZXh0 IHJ1bnMuCisgICAgYm9vbCBpc0luVGV4dExlYWYoKSBjb25zdDsKKyAgICBBWFRleHRNYXJrZXIg dG9UZXh0TGVhZk1hcmtlcigpIGNvbnN0OworI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVY VF9BUElTKQorCiAgICAgVGV4dE1hcmtlckRhdGEgbV9kYXRhOwogfTsKIApAQCAtMTcxLDYgKzIx NywxMSBAQCBwdWJsaWM6CiAgICAgQVhUZXh0TWFya2VyIGVuZCgpIGNvbnN0IHsgcmV0dXJuIG1f ZW5kOyB9CiAgICAgYm9vbCBpc0NvbmZpbmVkVG8oQVhJRCkgY29uc3Q7CiAKKyNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICAvLyBUcmF2ZXJzZXMgZnJvbSBtX3N0YXJ0IHRvIG1f ZW5kLCBjb2xsZWN0aW5nIGFsbCB0ZXh0IGFsb25nIHRoZSB3YXkuCisgICAgU3RyaW5nIHRvU3Ry aW5nKCkgY29uc3Q7CisjZW5kaWYKKwogICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29u c3Q7CiBwcml2YXRlOgogICAgIEFYVGV4dE1hcmtlciBtX3N0YXJ0OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uNTA0ZmEyNDcyYWE2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwCkBAIC0wLDAgKzEsOTMgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMjMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRT IENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5D LiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgor ICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkK KyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCisKKyNpZiBF TkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworU3RyaW5n IEFYVGV4dFJ1bnM6OmRlYnVnRGVzY3JpcHRpb24oKSBjb25zdAoreworICAgIFN0cmluZ0J1aWxk ZXIgcmVzdWx0OworICAgIHJlc3VsdC5hcHBlbmQoJ1snKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgcnVucy5zaXplKCk7IGkrKykgeworICAgICAgICByZXN1bHQuYXBwZW5kKHJ1bnNb aV0uZGVidWdEZXNjcmlwdGlvbihjb250YWluaW5nQmxvY2spKTsKKyAgICAgICAgaWYgKGkgIT0g cnVucy5zaXplKCkgLSAxKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgiLCAiKTsKKyAgICB9 CisgICAgcmVzdWx0LmFwcGVuZCgnXScpOworICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsK K30KKworc2l6ZV90IEFYVGV4dFJ1bnM6OmluZGV4Rm9yT2Zmc2V0KHVuc2lnbmVkIHRleHRPZmZz ZXQpIGNvbnN0Cit7CisgICAgc2l6ZV90IGN1bXVsYXRpdmVMZW5ndGggPSAwOworICAgIGZvciAo c2l6ZV90IGkgPSAwOyBpIDwgcnVucy5zaXplKCk7IGkrKykgeworICAgICAgICBjdW11bGF0aXZl TGVuZ3RoICs9IHJ1bkxlbmd0aChpKTsKKyAgICAgICAgaWYgKGN1bXVsYXRpdmVMZW5ndGggPj0g dGV4dE9mZnNldCkKKyAgICAgICAgICAgIHJldHVybiBpOworICAgIH0KKyAgICByZXR1cm4gbm90 Rm91bmQ7Cit9CisKK3Vuc2lnbmVkIEFYVGV4dFJ1bnM6OnJ1bkxlbmd0aFN1bVRvKHNpemVfdCBp bmRleCkgY29uc3QKK3sKKyAgICB1bnNpZ25lZCBsZW5ndGggPSAwOworICAgIGZvciAoc2l6ZV90 IGkgPSAwOyBpIDw9IGluZGV4ICYmIGkgPCBydW5zLnNpemUoKTsgaSsrKQorICAgICAgICBsZW5n dGggKz0gcnVuTGVuZ3RoKGkpOworICAgIHJldHVybiBsZW5ndGg7Cit9CisKK1N0cmluZyBBWFRl eHRSdW5zOjpzdWJzdHJpbmcodW5zaWduZWQgc3RhcnQsIHVuc2lnbmVkIGxlbmd0aCkgY29uc3QK K3sKKyAgICBpZiAoIWxlbmd0aCkKKyAgICAgICAgcmV0dXJuIGVtcHR5U3RyaW5nKCk7CisKKyAg ICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICBzaXplX3QgY2hhcmFjdGVyc1NlZW4gPSAwOwor ICAgIGF1dG8gcmVtYWluaW5nID0gWyZdICgpIHsKKyAgICAgICAgcmV0dXJuIHJlc3VsdC5sZW5n dGgoKSA+PSBsZW5ndGggPyAwIDogbGVuZ3RoIC0gcmVzdWx0Lmxlbmd0aCgpOworICAgIH07Cisg ICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHJ1bnMuc2l6ZSgpICYmIHJlc3VsdC5sZW5ndGgo KSA8IGxlbmd0aDsgaSsrKSB7CisgICAgICAgIHNpemVfdCBydW5MZW5ndGggPSB0aGlzLT5ydW5M ZW5ndGgoaSk7CisgICAgICAgIGlmIChjaGFyYWN0ZXJzU2VlbiA+PSBzdGFydCkgeworICAgICAg ICAgICAgLy8gVGhlIHN0YXJ0IHBvaW50cyBlbnRpcmVseSB3aXRoaW4gYm91bmRzIG9mIHRoaXMg cnVuLgorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zW2ldLnRleHQubGVmdChyZW1haW5p bmcoKSkpOworICAgICAgICB9IGVsc2UgaWYgKGNoYXJhY3RlcnNTZWVuICsgcnVuTGVuZ3RoID4g c3RhcnQpIHsKKyAgICAgICAgICAgIC8vIHN0YXJ0IHBvaW50cyBzb21ld2hlcmUgaW4gdGhlIG1p ZGRsZSBvZiB0aGUgY3VycmVudCBydW4sIGNvbGxlY3QgcGFydCBvZiB0aGUgdGV4dC4KKyAgICAg ICAgICAgIHVuc2lnbmVkIHN0YXJ0SW5SdW4gPSBzdGFydCAtIGNoYXJhY3RlcnNTZWVuOworICAg ICAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3RhcnRJblJ1biA8IHJ1bkxlbmd0aCk7CisgICAgICAg ICAgICByZXN1bHQuYXBwZW5kKHJ1bnNbaV0udGV4dC5zdWJzdHJpbmcoc3RhcnRJblJ1biwgcmVt YWluaW5nKCkpKTsKKyAgICAgICAgfQorICAgICAgICAvLyBJZiBjaGFyYWN0ZXJzU2VlbiArIHJ1 bkxlbmd0aCA9PSBzdGFydCwgdGhlIHN0YXJ0IHBvaW50cyB0byB0aGUgZW5kIG9mIHRoZSBydW4s IGFuZCB0aGVyZSBpcyBubyB0ZXh0IHRvIGdhdGhlci4KKworICAgICAgICBjaGFyYWN0ZXJzU2Vl biArPSBydW5MZW5ndGg7CisgICAgfQorICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsKK30K KworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVY VF9BUElTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRS dW4uaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5hMDk5ZjMxMWY1NmQKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCkBAIC0wLDAg KzEsMTIwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBFTkFCTEUoQVhfVEhS RUFEX1RFWFRfQVBJUykKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgUmVuZGVyQmxvY2s7 CisKK3N0cnVjdCBBWFRleHRSdW5MaW5lSUQgeworICAgIHZvaWQqIGNvbnRhaW5pbmdCbG9jayB7 IG51bGxwdHIgfTsKKyAgICBzaXplX3QgbGluZUluZGV4IHsgMCB9OworCisgICAgQVhUZXh0UnVu TGluZUlEKHZvaWQqIGNvbnRhaW5pbmdCbG9jaywgc2l6ZV90IGxpbmVJbmRleCkKKyAgICAgICAg OiBjb250YWluaW5nQmxvY2soY29udGFpbmluZ0Jsb2NrKQorICAgICAgICAsIGxpbmVJbmRleChs aW5lSW5kZXgpCisgICAgeyB9CisgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEFYVGV4dFJ1bkxp bmVJRCYpIGNvbnN0ID0gZGVmYXVsdDsKKyAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNv bnN0CisgICAgeworICAgICAgICBUZXh0U3RyZWFtIHN0cmVhbTsKKyAgICAgICAgc3RyZWFtIDw8 ICJMaW5lSUQgIiA8PCBjb250YWluaW5nQmxvY2sgPDwgIiAiIDw8IGxpbmVJbmRleDsKKyAgICAg ICAgcmV0dXJuIHN0cmVhbS5yZWxlYXNlKCk7CisgICAgfQorfTsKKworc3RydWN0IEFYVGV4dFJ1 biB7CisgICAgLy8gVGhlIGxpbmUgaW5kZXggb2YgdGhpcyBydW4gd2l0aGluIHRoZSBjb250ZXh0 IG9mIHRoZSBjb250YWluaW5nIFJlbmRlckJsb2NrIG9mIHRoZSBtYWluLXRocmVhZCBBWCBvYmpl Y3QuCisgICAgc2l6ZV90IGxpbmVJbmRleDsKKyAgICBTdHJpbmcgdGV4dDsKKworICAgIEFYVGV4 dFJ1bihzaXplX3QgbGluZUluZGV4LCBTdHJpbmcmJiB0ZXh0KQorICAgICAgICA6IGxpbmVJbmRl eChsaW5lSW5kZXgpCisgICAgICAgICwgdGV4dChXVEZNb3ZlKHRleHQpKQorICAgIHsgfQorCisg ICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24odm9pZCogY29udGFpbmluZ0Jsb2NrKSBjb25zdAor ICAgIHsKKyAgICAgICAgQVhUZXh0UnVuTGluZUlEIGxpbmVJRCA9IHsgY29udGFpbmluZ0Jsb2Nr LCBsaW5lSW5kZXggfTsKKyAgICAgICAgcmV0dXJuIG1ha2VTdHJpbmcobGluZUlELmRlYnVnRGVz Y3JpcHRpb24oKSwgIjogfCIsIG1ha2VTdHJpbmdCeVJlcGxhY2luZ0FsbCh0ZXh0LCAnXG4nLCAi e25ld2xpbmV9Il9zKSwgInwobGVuICIsIHRleHQubGVuZ3RoKCksICIpIik7CisgICAgfQorfTsK Kworc3RydWN0IEFYVGV4dFJ1bnMgeworICAgIC8vIFRoZSBjb250YWluaW5nIGJsb2NrIGZvciB0 aGUgdGV4dCBydW5zLiBUaGlzIGlzIHJlcXVpcmVkIGJlY2F1c2UgYmFzZWQgb24gdGhlIHN0cnVj dHVyZQorICAgIC8vIG9mIHRoZSBBWCB0cmVlLCB0ZXh0IHJ1bnMgZm9yIGRpZmZlcmVudCBvYmpl Y3RzIGNhbiBoYXZlIHRoZSBzYW1lIGxpbmUgaW5kZXggYnV0IGRpZmZlcmVudAorICAgIC8vIGNv bnRhaW5pbmcgYmxvY2tzLCBtZWFuaW5nIHRoZXkgYXJlIHJlbmRlcmVkIG9uIGRpZmZlcmVudCBs aW5lcy4KKyAgICAvLyBEbyBub3QgZGUtcmVmZXJlbmNlLiBVc2UgZm9yIGNvbXBhcmlzb24gcHVy cG9zZXMgb25seS4KKyAgICB2b2lkKiBjb250YWluaW5nQmxvY2sgeyBudWxscHRyIH07CisgICAg VmVjdG9yPEFYVGV4dFJ1bj4gcnVuczsKKworICAgIEFYVGV4dFJ1bnMoKSA9IGRlZmF1bHQ7Cisg ICAgQVhUZXh0UnVucyhSZW5kZXJCbG9jayogY29udGFpbmluZ0Jsb2NrLCBWZWN0b3I8QVhUZXh0 UnVuPiYmIHJ1bnMpCisgICAgICAgIDogY29udGFpbmluZ0Jsb2NrKGNvbnRhaW5pbmdCbG9jaykK KyAgICAgICAgLCBydW5zKFdURk1vdmUocnVucykpCisgICAgeyB9CisgICAgU3RyaW5nIGRlYnVn RGVzY3JpcHRpb24oKSBjb25zdDsKKworICAgIHNpemVfdCBzaXplKCkgY29uc3QgeyByZXR1cm4g cnVucy5zaXplKCk7IH0KKyAgICBjb25zdCBBWFRleHRSdW4mIGF0KHNpemVfdCBpbmRleCkgY29u c3QKKyAgICB7CisgICAgICAgIHJldHVybiAoKnRoaXMpW2luZGV4XTsKKyAgICB9CisgICAgY29u c3QgQVhUZXh0UnVuJiBvcGVyYXRvcltdKHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAg ICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5zaXplKCkpOworICAgICAgICByZXR1cm4g cnVuc1tpbmRleF07CisgICAgfQorCisgICAgdW5zaWduZWQgcnVuTGVuZ3RoKHNpemVfdCBpbmRl eCkgY29uc3QKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGluZGV4IDwgcnVucy5zaXpl KCkpOworICAgICAgICByZXR1cm4gcnVuc1tpbmRleF0udGV4dC5sZW5ndGgoKTsKKyAgICB9Cisg ICAgdW5zaWduZWQgbGFzdFJ1bkxlbmd0aCgpIGNvbnN0CisgICAgeworICAgICAgICBpZiAocnVu cy5pc0VtcHR5KCkpCisgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgcmV0dXJuIHJ1bnNb cnVucy5zaXplKCkgLSAxXS50ZXh0Lmxlbmd0aCgpOworICAgIH0KKyAgICB1bnNpZ25lZCBydW5M ZW5ndGhTdW0oKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIHJ1bkxlbmd0aFN1bVRvKHJ1 bnMuc2l6ZSgpIC0gMSk7CisgICAgfQorICAgIHVuc2lnbmVkIHJ1bkxlbmd0aFN1bVRvKHNpemVf dCBpbmRleCkgY29uc3Q7CisKKyAgICBzaXplX3QgaW5kZXhGb3JPZmZzZXQodW5zaWduZWQgdGV4 dE9mZnNldCkgY29uc3Q7CisgICAgQVhUZXh0UnVuTGluZUlEIGxpbmVJRChzaXplX3QgaW5kZXgp IGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgp KTsKKyAgICAgICAgcmV0dXJuIHsgY29udGFpbmluZ0Jsb2NrLCBydW5zW2luZGV4XS5saW5lSW5k ZXggfTsKKyAgICB9CisgICAgU3RyaW5nIHN1YnN0cmluZyh1bnNpZ25lZCBzdGFydCwgdW5zaWdu ZWQgbGVuZ3RoID0gU3RyaW5nSW1wbDo6TWF4TGVuZ3RoKSBjb25zdDsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwCmluZGV4IDI5YTkzMWM1YWExNC4uZjMzOWIzYWIwMDgxIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKQEAgLTExMyw2 ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppbml0KCkKICAgICBtX3JvbGUg PSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5Um9sZSgpOwogfQogCitBWElEIEFjY2Vzc2liaWxpdHlP YmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7CisgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENhY2hl KCk7CisgICAgcmV0dXJuIGNhY2hlID8gY2FjaGUtPnRyZWVJRCgpIDogQVhJRCgpOworfQorCiBp bmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByb2Nlc3NJRCgpIGNvbnN0CiB7 CiAgICAgcmV0dXJuIHByZXNlbnRpbmdBcHBsaWNhdGlvblBJRCgpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmggYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAppbmRleCBlNjRiNjMw NmMwOGUuLmM3ZjI4ZDVjM2I1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNwcmFnbWEgb25j ZQogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCiAj aW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2UuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNs dWRlICJMYXlvdXRSZWN0LmgiCkBAIC02Myw2ICs2NCw3IEBAIGNsYXNzIEFjY2Vzc2liaWxpdHlP YmplY3QgOiBwdWJsaWMgQVhDb3JlT2JqZWN0LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8QWNjZXNz aWJpCiBwdWJsaWM6CiAgICAgdmlydHVhbCB+QWNjZXNzaWJpbGl0eU9iamVjdCgpOwogCisgICAg QVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbDsKICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29u c3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBAIC0zODIsNiAr Mzg0LDkgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5kZXJFbGVtZW50KEFjY2Vzc2liaWxp dHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9k ZSgpKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0KICAgICBTdHJpbmcgdGV4dCgpIGNv bnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIHVuc2lnbmVkIHRleHRMZW5ndGgoKSBj b25zdCBmaW5hbDsKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICB2aXJ0dWFs IEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KKyNlbmRpZgogI2lmIFBMQVRG T1JNKENPQ09BKQogICAgIC8vIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyBhbmQgQVhPYmpl Y3Qgd3JhcHBlcnMgY29ycmVzcG9uZGluZyB0byB0aGUKICAgICAvLyB0ZXh0cnVucyBhbmQgcmVw bGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQgaW4gdGhlIGdpdmVuIHJhbmdlLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNw cCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHAKaW5kZXggMzk0NjllNjkwNjAwLi5mNzM4ZTg5YjQyYWEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcApAQCAtMTQwMywxMSArMTQwMywxMSBAQCBDaGFyYWN0ZXJSYW5nZSBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRleHRSYW5nZSgpIGNvbnN0CiB9CiAKICNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKLVZlY3RvcjxBWFRleHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FYVGV4dFJ1bnMgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dDo6dGV4dFJ1bnMoKQogewogICAgIGlmIChhdXRvKiByZW5kZXJMaW5lQnJlYWsgPSBkeW5hbWlj RG93bmNhc3Q8UmVuZGVyTGluZUJyZWFrPihyZW5kZXJlcigpKSkgewogICAgICAgICBhdXRvIGJv eCA9IElubGluZUl0ZXJhdG9yOjpib3hGb3IoKnJlbmRlckxpbmVCcmVhayk7Ci0gICAgICAgIHJl dHVybiB7IHsgYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKSB9IH07CisgICAgICAg IHJldHVybiB7IHJlbmRlckxpbmVCcmVhay0+Y29udGFpbmluZ0Jsb2NrKCksIHsgQVhUZXh0UnVu KGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJpbmcoJ1xuJykuaXNvbGF0ZWRDb3B5KCkpIH0gfTsK ICAgICB9CiAKICAgICBXZWFrUHRyIHJlbmRlclRleHQgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVy VGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0xNDYwLDcgKzE0NjAsNyBAQCBWZWN0b3I8QVhUZXh0UnVu PiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCiAKICAgICBpZiAoIWxpbmVT dHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBydW5zLmFwcGVuZCh7IGN1cnJlbnRMaW5lSW5kZXgs IGxpbmVTdHJpbmcudG9TdHJpbmcoKS5pc29sYXRlZENvcHkoKSB9KTsKLSAgICByZXR1cm4gcnVu czsKKyAgICByZXR1cm4geyByZW5kZXJUZXh0LT5jb250YWluaW5nQmxvY2soKSwgV1RGTW92ZShy dW5zKSB9OwogfQogI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oCmluZGV4IGNlZWM2YmYzZTg5OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuaApAQCAtMTAwLDcgKzEwMCw3IEBAIHB1YmxpYzoKICAgICBTdHJpbmcgdGV4dFVuZGVyRWxl bWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3NpYmlsaXR5VGV4 dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIHNlbGVjdGVk VGV4dCgpIGNvbnN0IG92ZXJyaWRlOwogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQot ICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWw7CisgICAgQVhUZXh0UnVucyB0 ZXh0UnVucygpIGZpbmFsOwogI2VuZGlmCiAKICAgICBib29sIGlzV2lkZ2V0KCkgY29uc3Qgb3Zl cnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVk dHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCmluZGV4IDYyYTFhNTc1YWU2MS4uMzQ1 ZjJkNTNkZjU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcApAQCAtMzEsNiArMzEsNyBA QAogI2luY2x1ZGUgIkFYR2VvbWV0cnlNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiQVhJc29sYXRlZFRy ZWUuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgogCiAj aWYgUExBVEZPUk0oTUFDKQogI2ltcG9ydCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5oPgpA QCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQgQVhJc29sYXRlZE9iamVjdDo6c2V0UHJvcGVydHkoQVhQ cm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWCiAgICAgICAgIFtdKHN0 ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJSYW5nZT4mIHR5cGVkVmFsdWUpIHsKICAgICAgICAgICAg IHJldHVybiAhdHlwZWRWYWx1ZS5maXJzdC5pc1ZhbGlkKCkgJiYgIXR5cGVkVmFsdWUuc2Vjb25k LmxvY2F0aW9uICYmICF0eXBlZFZhbHVlLnNlY29uZC5sZW5ndGg7CiAgICAgICAgIH0sCisjaWYg RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgICAgIFtdKEFYVGV4dFJ1bnMgcnVucykg eyByZXR1cm4gIXJ1bnMuc2l6ZSgpOyB9LAorI2VuZGlmCiAgICAgICAgIFtdKGF1dG8mKSB7CiAg ICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgICAgIHJldHVybiBmYWxz ZTsKQEAgLTU1Nyw2ICs1NjEsMTkgQEAgdm9pZCBBWElzb2xhdGVkT2JqZWN0OjpzZXRTZWxlY3Rl ZENoaWxkcmVuKGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2UKICAgICB9KTsK IH0KIAorQVhDb3JlT2JqZWN0KiBBWElzb2xhdGVkT2JqZWN0OjpzaWJsaW5nKEFYRGlyZWN0aW9u IGRpcmVjdGlvbikgY29uc3QKK3sKKyAgICBSZWZQdHIgcGFyZW50ID0gcGFyZW50T2JqZWN0VW5p Z25vcmVkKCk7CisgICAgY29uc3QgYXV0byYgc2libGluZ3MgPSBwYXJlbnQtPmNoaWxkcmVuKCk7 CisgICAgc2l6ZV90IGluZGV4T2ZUaGlzID0gc2libGluZ3MuZmluZCh0aGlzKTsKKyAgICBpZiAo aW5kZXhPZlRoaXMgPT0gbm90Rm91bmQpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAg aWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4dCkKKyAgICAgICAgcmV0dXJuIGluZGV4 T2ZUaGlzICsgMSA8IHNpYmxpbmdzLnNpemUoKSA/IHNpYmxpbmdzW2luZGV4T2ZUaGlzICsgMV0u Z2V0KCkgOiBudWxscHRyOworICAgIHJldHVybiBpbmRleE9mVGhpcyA+IDAgPyBzaWJsaW5nc1tp bmRleE9mVGhpcyAtIDFdLmdldCgpIDogbnVsbHB0cjsKK30KKwogYm9vbCBBWElzb2xhdGVkT2Jq ZWN0Ojppc0RldGFjaGVkRnJvbVBhcmVudCgpCiB7CiAgICAgaWYgKHBhcmVudCgpLmlzVmFsaWQo KSkKQEAgLTk3MSw2ICs5ODgsMTkgQEAgaW50IEFYSXNvbGF0ZWRPYmplY3Q6OmludEF0dHJpYnV0 ZVZhbHVlKEFYUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkgY29uc3QKICAgICApOwogfQogCisj aWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitjb25zdCBBWFRleHRSdW5zKiBBWElzb2xh dGVkT2JqZWN0Ojp0ZXh0UnVucygpIGNvbnN0Cit7CisgICAgYXV0byBlbnRyeSA9IG1fcHJvcGVy dHlNYXAuZmluZChBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMpOworICAgIGlmIChlbnRyeSA9PSBt X3Byb3BlcnR5TWFwLmVuZCgpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1cm4g V1RGOjpzd2l0Y2hPbihlbnRyeS0+dmFsdWUsCisgICAgICAgIFtdIChjb25zdCBBWFRleHRSdW5z JiB0eXBlZFZhbHVlKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiAmdHlwZWRWYWx1ZTsg fSwKKyAgICAgICAgW10gKGF1dG8mKSAtPiBjb25zdCBBWFRleHRSdW5zKiB7IHJldHVybiBudWxs cHRyOyB9CisgICAgKTsKK30KKyNlbmRpZgorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogVCBBWElz b2xhdGVkT2JqZWN0OjpnZXRPclJldHJpZXZlUHJvcGVydHlWYWx1ZShBWFByb3BlcnR5TmFtZSBw cm9wZXJ0eU5hbWUpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKaW5kZXggYTZjYTAzNDM3Nzdk Li5iZjg5YzEzZjM2OGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKQEAgLTQ0LDYgKzQ0LDkg QEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQVhJc29sYXRlZFRyZWU7CisjaWYgRU5B QkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCitzdHJ1Y3QgQVhUZXh0UnVuczsKKyNlbmRpZgogCiBj bGFzcyBBWElzb2xhdGVkT2JqZWN0IGZpbmFsIDogcHVibGljIEFYQ29yZU9iamVjdCB7CiAgICAg ZnJpZW5kIGNsYXNzIEFYSXNvbGF0ZWRUcmVlOwpAQCAtNTEsNiArNTQsNyBAQCBwdWJsaWM6CiAg ICAgc3RhdGljIFJlZjxBWElzb2xhdGVkT2JqZWN0PiBjcmVhdGUoY29uc3QgUmVmPEFjY2Vzc2li aWxpdHlPYmplY3Q+JiwgQVhJc29sYXRlZFRyZWUqKTsKICAgICB+QVhJc29sYXRlZE9iamVjdCgp OwogCisgICAgQVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPnRyZWVJ RCgpOyB9CiAgICAgUHJvY2Vzc0lEIHByb2Nlc3NJRCgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRy ZWUoKS0+cHJvY2Vzc0lEKCk7IH0KICAgICBTdHJpbmcgZGJnKCkgY29uc3QgZmluYWw7CiAKQEAg LTU5LDEwICs2MywxNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc1RhYmxlKCkgY29uc3QgZmluYWwg eyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc1RhYmxlKTsgfQog ICAgIGJvb2wgaXNFeHBvc2FibGUoKSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRl VmFsdWUoQVhQcm9wZXJ0eU5hbWU6OklzRXhwb3NhYmxlKTsgfQogCisgICAgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbihib29sIHVwZGF0ZUNoaWxkcmVuSWZOZWVk ZWQgPSB0cnVlKSBmaW5hbDsKKyAgICBBWENvcmVPYmplY3QqIHNpYmxpbmcoQVhEaXJlY3Rpb24p IGNvbnN0OwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHBhcmVudE9iamVjdCgpIGNvbnN0IGZpbmFs IHsgcmV0dXJuIHBhcmVudE9iamVjdFVuaWdub3JlZCgpOyB9CisgICAgQVhJc29sYXRlZE9iamVj dCogcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkgY29uc3QgZmluYWw7CiAgICAgQVhJc29sYXRlZE9i amVjdCogZWRpdGFibGVBbmNlc3RvcigpIGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6OmVk aXRhYmxlQW5jZXN0b3IoKnRoaXMpOyB9OwogICAgIGJvb2wgY2FuU2V0Rm9jdXNBdHRyaWJ1dGUo KSBjb25zdCBmaW5hbCB7IHJldHVybiBib29sQXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6 OkNhblNldEZvY3VzQXR0cmlidXRlKTsgfQogCisjaWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQ SVMpCisgICAgY29uc3QgQVhUZXh0UnVucyogdGV4dFJ1bnMoKSBjb25zdDsKKyNlbmRpZgorCiBw cml2YXRlOgogICAgIHZvaWQgZGV0YWNoUmVtb3RlUGFydHMoQWNjZXNzaWJpbGl0eURldGFjaG1l bnRUeXBlKSBmaW5hbDsKICAgICB2b2lkIGRldGFjaFBsYXRmb3JtV3JhcHBlcihBY2Nlc3NpYmls aXR5RGV0YWNobWVudFR5cGUpIGZpbmFsOwpAQCAtMjQzLDcgKzI1NCw2IEBAIHByaXZhdGU6CiAg ICAgVmVjdG9yPFN0cmluZz4gZGV0ZXJtaW5lRHJvcEVmZmVjdHMoKSBjb25zdCBmaW5hbDsKICAg ICBBWElzb2xhdGVkT2JqZWN0KiBhY2Nlc3NpYmlsaXR5SGl0VGVzdChjb25zdCBJbnRQb2ludCYp IGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRPYmplY3QqIGZvY3VzZWRVSUVsZW1lbnQoKSBj b25zdCBmaW5hbDsKLSAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3RVbmlnbm9yZWQo KSBjb25zdCBmaW5hbDsKICAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbGlua2VkT2Jq ZWN0cygpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+b2JqZWN0c0ZvcklEcyh2ZWN0b3JB dHRyaWJ1dGVWYWx1ZTxBWElEPihBWFByb3BlcnR5TmFtZTo6TGlua2VkT2JqZWN0cykpOyB9CiAg ICAgQVhJc29sYXRlZE9iamVjdCogdGl0bGVVSUVsZW1lbnQoKSBjb25zdCBmaW5hbCB7IHJldHVy biBvYmplY3RBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6VGl0bGVVSUVsZW1lbnQpOyB9 CiAgICAgQVhJc29sYXRlZE9iamVjdCogc2Nyb2xsQmFyKEFjY2Vzc2liaWxpdHlPcmllbnRhdGlv bikgZmluYWw7CkBAIC0zMTYsNyArMzI2LDYgQEAgcHJpdmF0ZToKICAgICBBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3IgdmlzaWJsZUNoaWxkcmVuKCkgZmluYWwgeyByZXR1cm4gdHJlZSgpLT5v YmplY3RzRm9ySURzKHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYSUQ+KEFYUHJvcGVydHlOYW1lOjpW aXNpYmxlQ2hpbGRyZW4pKTsgfQogICAgIEF0b21TdHJpbmcgdGFnTmFtZSgpIGNvbnN0IGZpbmFs OwogICAgIHZvaWQgc2V0Q2hpbGRyZW5JRHMoVmVjdG9yPEFYSUQ+JiYpOwotICAgIGNvbnN0IEFj Y2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklm TmVlZGVkID0gdHJ1ZSkgZmluYWw7CiAgICAgdm9pZCB1cGRhdGVDaGlsZHJlbklmTmVjZXNzYXJ5 KCkgZmluYWw7CiAgICAgYm9vbCBpc0RldGFjaGVkRnJvbVBhcmVudCgpIGZpbmFsOwogICAgIEFY SXNvbGF0ZWRPYmplY3QqIGxpdmVSZWdpb25BbmNlc3Rvcihib29sIGV4Y2x1ZGVJZk9mZiA9IHRy dWUpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIEFjY2Vzc2liaWxpdHk6OmxpdmVSZWdpb25BbmNlc3Rv cigqdGhpcywgZXhjbHVkZUlmT2ZmKTsgfQpAQCAtMzQ1LDkgKzM1NCw2IEBAIHByaXZhdGU6CiAK ICAgICAvLyBDaGFyYWN0ZXJSYW5nZSBzdXBwb3J0LgogICAgIENoYXJhY3RlclJhbmdlIHNlbGVj dGVkVGV4dFJhbmdlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gcHJvcGVydHlWYWx1ZTxDaGFyYWN0 ZXJSYW5nZT4oQVhQcm9wZXJ0eU5hbWU6OlNlbGVjdGVkVGV4dFJhbmdlKTsgfQotI2lmIEVOQUJM RShBWF9USFJFQURfVEVYVF9BUElTKQotICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkg ZmluYWwgeyByZXR1cm4gdmVjdG9yQXR0cmlidXRlVmFsdWU8QVhUZXh0UnVuPihBWFByb3BlcnR5 TmFtZTo6VGV4dFJ1bnMpOyB9Ci0jZW5kaWYKICAgICBpbnQgaW5zZXJ0aW9uUG9pbnRMaW5lTnVt YmVyKCkgY29uc3QgZmluYWw7CiAgICAgQ2hhcmFjdGVyUmFuZ2UgZG9BWFJhbmdlRm9yTGluZSh1 bnNpZ25lZCkgY29uc3QgZmluYWw7CiAgICAgU3RyaW5nIGRvQVhTdHJpbmdGb3JSYW5nZShjb25z dCBDaGFyYWN0ZXJSYW5nZSYpIGNvbnN0IGZpbmFsOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwIGIvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwCmlu ZGV4IGY2ZjA2MjJhYmU5My4uMGU3NTM5ZTNhOGMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3Bw CkBAIC0zMCw2ICszMCw3IEBACiAKICNpbmNsdWRlICJBWElzb2xhdGVkT2JqZWN0LmgiCiAjaW5j bHVkZSAiQVhMb2dnZXIuaCIKKyNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5VGFibGVSb3cuaCIKICNp bmNsdWRlICJGcmFtZVNlbGVjdGlvbi5oIgogI2luY2x1ZGUgIkxvY2FsRnJhbWVWaWV3LmgiCiAj aW5jbHVkZSAiUGFnZS5oIgpAQCAtMjMwLDIyICsyMzEsNiBAQCBSZWZQdHI8QVhJc29sYXRlZE9i amVjdD4gQVhJc29sYXRlZFRyZWU6Om9iamVjdEZvcklEKGNvbnN0IEFYSUQgYXhJRCkgY29uc3QK ICAgICByZXR1cm4gYXhJRC5pc1ZhbGlkKCkgPyBtX3JlYWRlclRocmVhZE5vZGVNYXAuZ2V0KGF4 SUQpIDogbnVsbHB0cjsKIH0KIAotdGVtcGxhdGU8dHlwZW5hbWUgVT4KLVZlY3RvcjxSZWZQdHI8 QVhDb3JlT2JqZWN0Pj4gQVhJc29sYXRlZFRyZWU6Om9iamVjdHNGb3JJRHMoY29uc3QgVSYgYXhJ RHMpIGNvbnN0Ci17Ci0gICAgQVhUUkFDRSgiQVhJc29sYXRlZFRyZWU6Om9iamVjdHNGb3JJRHMi X3MpOwotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOwotCi0gICAgVmVjdG9yPFJlZlB0cjxB WENvcmVPYmplY3Q+PiByZXN1bHQ7Ci0gICAgcmVzdWx0LnJlc2VydmVJbml0aWFsQ2FwYWNpdHko YXhJRHMuc2l6ZSgpKTsKLSAgICBmb3IgKGF1dG8mIGF4SUQgOiBheElEcykgewotICAgICAgICBp ZiAoUmVmUHRyIG9iamVjdCA9IG9iamVjdEZvcklEKGF4SUQpKQotICAgICAgICAgICAgcmVzdWx0 LmFwcGVuZChXVEZNb3ZlKG9iamVjdCkpOwotICAgIH0KLSAgICByZXN1bHQuc2hyaW5rVG9GaXQo KTsKLSAgICByZXR1cm4gcmVzdWx0OwotfQotCiB2b2lkIEFYSXNvbGF0ZWRUcmVlOjpnZW5lcmF0 ZVN1YnRyZWUoQWNjZXNzaWJpbGl0eU9iamVjdCYgYXhPYmplY3QpCiB7CiAgICAgQVhUUkFDRSgi QVhJc29sYXRlZFRyZWU6OmdlbmVyYXRlU3VidHJlZSJfcyk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaApp bmRleCA1OWYxOWZhNzg4ZjUuLjdlOGY2MTc4MTU5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCkBA IC0yOSw2ICsyOSw3IEBACiAKICNpbmNsdWRlICJBWENvcmVPYmplY3QuaCIKICNpbmNsdWRlICJB WFRleHRNYXJrZXIuaCIKKyNpbmNsdWRlICJBWFRleHRSdW4uaCIKICNpbmNsdWRlICJBWFRyZWVT dG9yZS5oIgogI2luY2x1ZGUgIlBhZ2VJZGVudGlmaWVyLmgiCiAjaW5jbHVkZSAiUmVuZGVyU3R5 bGVDb25zdGFudHMuaCIKQEAgLTQ3LDYgKzQ4LDcgQEAgY2xhc3MgVGV4dFN0cmVhbTsKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQVhJc29sYXRlZE9iamVjdDsKK2NsYXNzIEFYR2VvbWV0 cnlNYW5hZ2VyOwogY2xhc3MgQVhPYmplY3RDYWNoZTsKIGNsYXNzIEFjY2Vzc2liaWxpdHlPYmpl Y3Q7CiBjbGFzcyBQYWdlOwpAQCAtMjU1LDcgKzI1Nyw3IEBAIHVzaW5nIEFYUHJvcGVydHlWYWx1 ZVZhcmlhbnQgPSBzdGQ6OnZhcmlhbnQ8c3RkOjpudWxscHRyX3QsIEFYSUQsIFN0cmluZywgYm9v bCwKICAgICAsIFJldGFpblB0cjxOU0F0dHJpYnV0ZWRTdHJpbmc+CiAjZW5kaWYKICNpZiBFTkFC TEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICAsIFZlY3RvcjxBWFRleHRSdW4+CisgICAgLCBB WFRleHRSdW5zCiAjZW5kaWYKID47CiB1c2luZyBBWFByb3BlcnR5TWFwID0gSGFzaE1hcDxBWFBy b3BlcnR5TmFtZSwgQVhQcm9wZXJ0eVZhbHVlVmFyaWFudCwgSW50SGFzaDxBWFByb3BlcnR5TmFt ZT4sIFdURjo6U3Ryb25nRW51bUhhc2hUcmFpdHM8QVhQcm9wZXJ0eU5hbWU+PjsKQEAgLTMyMiw3 ICszMjQsMjAgQEAgcHVibGljOgogICAgIFdFQkNPUkVfRVhQT1JUIFJlZlB0cjxBWElzb2xhdGVk T2JqZWN0PiBmb2N1c2VkTm9kZSgpOwogCiAgICAgUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IG9i amVjdEZvcklEKGNvbnN0IEFYSUQpIGNvbnN0OwotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IFZl Y3RvcjxSZWZQdHI8QVhDb3JlT2JqZWN0Pj4gb2JqZWN0c0ZvcklEcyhjb25zdCBVJikgY29uc3Q7 CisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4KKyAgICBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVj dD4+IG9iamVjdHNGb3JJRHMoY29uc3QgVSYgYXhJRHMpIGNvbnN0CisgICAgeworICAgICAgICBB U1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKworICAgICAgICBWZWN0b3I8UmVmUHRyPEFYQ29yZU9i amVjdD4+IHJlc3VsdDsKKyAgICAgICAgcmVzdWx0LnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoYXhJ RHMuc2l6ZSgpKTsKKyAgICAgICAgZm9yIChjb25zdCBhdXRvJiBheElEIDogYXhJRHMpIHsKKyAg ICAgICAgICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gb2JqZWN0Rm9ySUQoYXhJRCkpCisgICAgICAg ICAgICAgICAgcmVzdWx0LmFwcGVuZChXVEZNb3ZlKG9iamVjdCkpOworICAgICAgICB9CisgICAg ICAgIHJlc3VsdC5zaHJpbmtUb0ZpdCgpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0K IAogICAgIHZvaWQgZ2VuZXJhdGVTdWJ0cmVlKEFjY2Vzc2liaWxpdHlPYmplY3QmKTsKICAgICB2 b2lkIGxhYmVsQ3JlYXRlZChBY2Nlc3NpYmlsaXR5T2JqZWN0Jik7Cg== 469352 2024-01-09 14:15:27 -0800 2024-01-10 12:26:58 -0800 Patch bug-266521-20240109141526.patch text/plain 46439 tyler_w RnJvbSA4YzNlZThmODk5NGI2YWY0OWM5NDk2MTc0MzM1YWY4ZGRkY2IxM2FiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUeWxlciBXaWxjb2NrIDx0eWxlcl93QGFwcGxlLmNvbT4KRGF0 ZTogRnJpLCAxNSBEZWMgMjAyMyAxNjoyODoyMSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEFYOiBV c2UgY2FjaGVkIHRleHQgcnVucyB0byBjb21wdXRlOiBuZXh0LCBwcmV2aW91cywgbmV4dAogbGlu ZSBlbmQsIHByZXZpb3VzIGxpbmUgc3RhcnQsIGxpbmUgcmFuZ2UsIGFuZCBzdHJpbmctZm9yLXJh bmdlIHRleHQgbWFya2VyCiBBUElzIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjY1MjEgcmRhcjovLzExOTc0MTkxMQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5 cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzog OGJpdAoKUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCgpUaGlzIHBhdGNoIGFkZHMgZnVuY3Rp b25hbGl0eSB0byBBWFRleHRNYXJrZXIgdG8gdHJhdmVyc2UgdGhlIGFjY2Vzc2liaWxpdHkgdHJl ZSwgYW5hbHl6aW5nIGNhY2hlZCBBWFByb3BlcnR5TmFtZTo6VGV4dFJ1bnMKYXQgZWFjaCBzdG9w LCB0byBzZXJ2ZSB0aGVzZSBBUElzIG9mZiB0aGUgbWFpbi10aHJlYWQuCgpUaGUgaW1wbGVtZW50 YXRpb24gaW4gdGhpcyBwYXRjaCBpZ25vcmVzIGltcG9ydGFudCBlZGdlIGNhc2VzIOKAlCBlLmcu IGFyaWEtb3ducyB0cmVlIHJlLW9yZGVyaW5nIHdpbGwgY2F1c2UgdXMgdG8KY29tcHV0ZSB0aGUg d3JvbmcgcmVzdWx0cywgYW5kIHRleHQgaW4gaWdub3JlZCBvYmplY3RzIHdpbGwgYmUgc2tpcHBl ZC4KCiogU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZToKKiBTb3VyY2UvV2ViQ29yZS9Tb3Vy Y2VzLnR4dDoKKiBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2o6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaDoKKFdlYkNv cmU6OkFYVGV4dFJ1bjo6QVhUZXh0UnVuKTogRGVsZXRlZC4KKFdlYkNvcmU6OkFYQ29yZU9iamVj dDo6dGV4dFJ1bnMpOiBEZWxldGVkLgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmNwcDoKKFdlYkNvcmU6OkFYVGV4dE1hcmtlcjo6aXNvbGF0ZWRPYmplY3QgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyUmFuZ2U6OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6ZmluZE9iamVjdFdpdGhSdW5zKToKKFdlYkNvcmU6OkFYVGV4dE1hcmtlclJh bmdlOjp0b1N0cmluZyBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6OnJ1bnMgY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpmaW5kTWFya2VyIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dE1hcmtlcjo6YXNUZXh0TGVhZk1hcmtlciBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OmlzVGV4dExlYWYgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjp0ZXh0UnVuSW5k ZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpsaW5lUmFuZ2UgY29u c3QpOgooV2ViQ29yZTo6QVhUZXh0TWFya2VyOjpzdWJzdHJpbmcgY29uc3QpOgoqIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmg6CihXZWJDb3JlOjpBWFRleHRNYXJr ZXI6OkFYVGV4dE1hcmtlcik6CihXZWJDb3JlOjpBWFRleHRNYXJrZXI6Om9mZnNldCBjb25zdCk6 CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bnM6OmRlYnVnRGVzY3JpcHRpb24gY29uc3QpOgooV2ViQ29yZTo6QVhU ZXh0UnVuczo6aW5kZXhGb3JPZmZzZXQgY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoU3VtVG8gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6c3Vic3RyaW5nIGNvbnN0 KToKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oOiBBZGRlZC4KKFdl YkNvcmU6OkFYVGV4dFJ1bkxpbmVJRDo6QVhUZXh0UnVuTGluZUlEKToKKFdlYkNvcmU6OkFYVGV4 dFJ1bkxpbmVJRDo6ZGVidWdEZXNjcmlwdGlvbiBjb25zdCk6CihXZWJDb3JlOjpBWFRleHRSdW46 OkFYVGV4dFJ1bik6CihXZWJDb3JlOjpBWFRleHRSdW46OmRlYnVnRGVzY3JpcHRpb24gY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6QVhUZXh0UnVucyk6CihXZWJDb3JlOjpBWFRleHRSdW5z OjpzaXplIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6OmF0IGNvbnN0KToKKFdlYkNvcmU6 OkFYVGV4dFJ1bnM6Om9wZXJhdG9yW10gY29uc3QpOgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVu TGVuZ3RoIGNvbnN0KToKKFdlYkNvcmU6OkFYVGV4dFJ1bnM6Omxhc3RSdW5MZW5ndGggY29uc3Qp OgooV2ViQ29yZTo6QVhUZXh0UnVuczo6cnVuTGVuZ3RoU3VtIGNvbnN0KToKKFdlYkNvcmU6OkFY VGV4dFJ1bnM6OmxpbmVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B Y2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnRy ZWVJRCBjb25zdCk6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 T2JqZWN0Lmg6CihXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojp0ZXh0UnVucyk6CiogU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoK KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRleHRSdW5zKToKKiBTb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNw cDoKKFdlYkNvcmU6OkFYSXNvbGF0ZWRPYmplY3Q6OnNldFByb3BlcnR5KToKKFdlYkNvcmU6OkFY SXNvbGF0ZWRPYmplY3Q6OnNpYmxpbmcgY29uc3QpOgooV2ViQ29yZTo6QVhJc29sYXRlZE9iamVj dDo6dGV4dFJ1bnMgY29uc3QpOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaDoKKiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHA6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJl ZTo6b2JqZWN0c0ZvcklEcyBjb25zdCk6IERlbGV0ZWQuCiogU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaDoKKFdlYkNvcmU6OkFYSXNvbGF0 ZWRUcmVlOjpvYmplY3RzRm9ySURzIGNvbnN0KToKLS0tCiBTb3VyY2UvV2ViQ29yZS9IZWFkZXJz LmNtYWtlICAgICAgICAgICAgICAgICAgfCAgIDEgKwogU291cmNlL1dlYkNvcmUvU291cmNlcy50 eHQgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIC4uLi9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiB8ICAgNiArCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYQ29yZU9iamVjdC5oICAgfCAgMTkgKy0KIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhUZXh0TWFya2VyLmNwcCB8IDIyMSArKysrKysrKysrKysrKysrKy0KIFNvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmggICB8ICA1MSArKysrCiBTb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAgICAgfCAgOTMgKysrKysrKysKIFNvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmggICAgICB8IDEyMCArKysrKysrKysrCiAu Li4vYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcCAgICAgfCAgIDYgKwogLi4u L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5oICAgICAgIHwgICA1ICsKIC4uLi9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCAgICAgICAgICAgICB8ICAgNiArLQogLi4uL2Fj Y2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIHwgICAyICstCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwICAgICAgICAgfCAgMzAgKysrCiAuLi4vaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuaCAgICAgICAgICAgfCAgMTYgKy0KIC4uLi9pc29s YXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwICAgICAgICAgICB8ICAxNyArLQogLi4uL2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oICAgICAgICAgICAgIHwgIDE5ICstCiAxNiBmaWxlcyBj aGFuZ2VkLCA1NjkgaW5zZXJ0aW9ucygrKSwgNDQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAx MDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uY3BwCiBjcmVhdGUg bW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAoKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9I ZWFkZXJzLmNtYWtlCmluZGV4IDFhZTE3YTUyZDA5MS4uNzljMzdmYWNkOGRhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRl cnMuY21ha2UKQEAgLTY1Miw2ICs2NTIsNyBAQCBzZXQoV2ViQ29yZV9QUklWQVRFX0ZSQU1FV09S S19IRUFERVJTCiAgICAgYWNjZXNzaWJpbGl0eS9BWExvZ2dlci5oCiAgICAgYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmgKICAgICBhY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCisgICAg YWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUZXh0U3RhdGVD aGFuZ2VJbnRlbnQuaAogICAgIGFjY2Vzc2liaWxpdHkvQVhUcmVlU3RvcmUuaAogICAgIGFjY2Vz c2liaWxpdHkvQWNjZXNzaWJpbGl0eUxpc3RCb3guaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvU291cmNlcy50eHQgYi9Tb3VyY2UvV2ViQ29yZS9Tb3VyY2VzLnR4dAppbmRleCAxNzg0Nzhk ZDhhYmYuLjU2NGNiMzE4MjY2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvU291cmNlcy50 eHQKKysrIGIvU291cmNlL1dlYkNvcmUvU291cmNlcy50eHQKQEAgLTUyMiw2ICs1MjIsNyBAQCBh Y2Nlc3NpYmlsaXR5L0FYSW1hZ2UuY3BwCiBhY2Nlc3NpYmlsaXR5L0FYTG9nZ2VyLmNwcAogYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAogYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIu Y3BwCithY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5jcHAKIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eUFSSUFHcmlkLmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRDZWxs LmNwcAogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRSb3cuY3BwCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggOWU3 NWNmMDllNDQyLi5kMzAxYzE3ZTMxZjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE3NTIsNiArMTc1Miw3IEBACiAJCTQ3RkE5 NzAwMjY1MDk4MkIwMDg0MTQxNiAvKiBUYWJsZUZvcm1hdHRpbmdHZW9tZXRyeS5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDdGQTk2RkYyNjUwOTgyQTAw ODQxNDE2IC8qIFRhYmxlRm9ybWF0dGluZ0dlb21ldHJ5LmggKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDgyMjk3MEUyOUM4RUJDMDAwMzNBMTI2IC8q IFJlZ2lvbkNvbnRleHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ4MjI5NzBDMjlDOEVCQzAwMDMzQTEyNiAvKiBSZWdpb25Db250ZXh0LmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNDg2QjhEQzcyQTA0 M0MwNjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0ODZCOERDNjJBMDQzQzA2MDBFMDBFNzMgLyogQVhH ZW9tZXRyeU1hbmFnZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OworCQk0OEIwMjQyQTJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OEIwMjQyODJCMkE2NUFB MDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJNDhCNUJGMzcyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxp dHlSZWdpb25Db250ZXh0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0OEI1QkYzNTI5Q0E2OTE3MDBGRUJFM0IgLyogQWNjZXNzaWJpbGl0eVJlZ2lvbkNv bnRleHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQk0OEQwRTEyOTI5RjczMjlFMDAyNjM4NTcgLyogRWxlbWVudEFuaW1hdGlvbkNvbnRleHQuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ4RDBFMTI4MjlG NzMyMjkwMDI2Mzg1NyAvKiBFbGVtZW50QW5pbWF0aW9uQ29udGV4dC5oICovOyBzZXR0aW5ncyA9 IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTQ5MTM0MkUzMkI0M0ZGRUYwMEZF RUYxOCAvKiBDU1NTZWxlY3RvcklubGluZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQ5MTM0MkRBMkI0M0ZBQTgwMEZFRUYxOCAvKiBDU1NTZWxlY3Rv cklubGluZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwpAQCAtMTA3MjQsOCArMTA3MjUsMTAgQEAKIAkJNDgyMjk3MEMyOUM4RUJDMDAwMzNBMTI2IC8q IFJlZ2lvbkNvbnRleHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVnaW9u Q29udGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0ODZCOERDNjJBMDQzQzA2 MDBFMDBFNzMgLyogQVhHZW9tZXRyeU1hbmFnZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVhHZW9tZXRy eU1hbmFnZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDg2QjhEQzgyQTA0NTAw RjAwRTAwRTczIC8qIEFYR2VvbWV0cnlNYW5hZ2VyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEFYR2VvbWV0cnlNYW5hZ2VyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJNDhCMDI0MjgyQjJBNjVBQTAwODNEMTIyIC8qIEFYVGV4dFJ1bi5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBWFRleHRSdW4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhC NUJGMzUyOUNBNjkxNzAwRkVCRTNCIC8qIEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlSZWdpb25Db250ZXh0 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ4QjVCRjM2MjlDQTY5MTcwMEZFQkUz QiAvKiBBY2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBB Y2Nlc3NpYmlsaXR5UmVnaW9uQ29udGV4dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTQ4QzRFODNDMkIzNEQ4MzgwMDgzNDYwQSAvKiBBWFRleHRSdW4uY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gQVhUZXh0UnVuLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDhE MEUxMjgyOUY3MzIyOTAwMjYzODU3IC8qIEVsZW1lbnRBbmltYXRpb25Db250ZXh0LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IEVsZW1lbnRBbmltYXRpb25Db250ZXh0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ5MTM0Mjk2MkI0MjVDMDEwMEZFRUYxOCAvKiBDU1NQc2V1ZG9TZWxlY3RvcnMu anNvbiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRl eHQuanNvbjsgcGF0aCA9IENTU1BzZXVkb1NlbGVjdG9ycy5qc29uOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk0OTEzNDI5NzJCNDI1QzAyMDBGRUVGMTggLyogcHJvY2Vzcy1jc3MtcHNl dWRvLXNlbGVjdG9ycy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9ICJwcm9jZXNzLWNzcy1wc2V1ZG8t c2VsZWN0b3JzLnB5Ijsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIzMTk4LDYgKzIz MjAxLDggQEAKIAkJCQkyOUE4MTIxQTBGQkI5QzFEMDA1MTAyOTMgLyogQVhPYmplY3RDYWNoZS5o ICovLAogCQkJCUMwRTIwOEExMjkzNzlDNkYwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuY3BwICov LAogCQkJCUMwRTIwOEEwMjkzNzlDNkUwMEMwRDJEMyAvKiBBWFRleHRNYXJrZXIuaCAqLywKKwkJ CQk0OEM0RTgzQzJCMzREODM4MDA4MzQ2MEEgLyogQVhUZXh0UnVuLmNwcCAqLywKKwkJCQk0OEIw MjQyODJCMkE2NUFBMDA4M0QxMjIgLyogQVhUZXh0UnVuLmggKi8sCiAJCQkJOTFDOUYyRjgxQUUz QkUyNDAwOTVCNjFDIC8qIEFYVGV4dFN0YXRlQ2hhbmdlSW50ZW50LmggKi8sCiAJCQkJQzBFOEFE QzQyOTRCNUE2MjAwNzZDQkRDIC8qIEFYVHJlZVN0b3JlLmggKi8sCiAJCQkJQkM0QTUzMzAyNTYw NTkwMzAwMjhDNTkyIC8qIEZvcmNlZEFjY2Vzc2liaWxpdHlWYWx1ZS5oICovLApAQCAtMzc1OTMs NiArMzc1OTgsNyBAQAogCQkJCTI5QUUyMTJEMjFBQjlFRUIwMDg2OTI4MyAvKiBBWElzb2xhdGVk VHJlZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMjlBODEyMzgwRkJCOUMxRDAwNTEwMjkzIC8qIEFY T2JqZWN0Q2FjaGUuaCBpbiBIZWFkZXJzICovLAogCQkJCUMwRTIwOEEyMjkzNzlDNkYwMEMwRDJE MyAvKiBBWFRleHRNYXJrZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTQ4QjAyNDJBMkIyQTY1QUEw MDgzRDEyMiAvKiBBWFRleHRSdW4uaCBpbiBIZWFkZXJzICovLAogCQkJCTkxQzlGMkY5MUFFM0JF QjAwMDk1QjYxQyAvKiBBWFRleHRTdGF0ZUNoYW5nZUludGVudC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQzBFOEFEQzUyOTRCNUE2MzAwNzZDQkRDIC8qIEFYVHJlZVN0b3JlLmggaW4gSGVhZGVycyAq LywKIAkJCQkxNDc3RTc3NzBCRjQxMzRBMDAxNTI4NzIgLyogQmFja0ZvcndhcmRDYWNoZS5oIGlu IEhlYWRlcnMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY Q29yZU9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3Qu aAppbmRleCA3ZDE4ZjUyMTI2OTUuLjk0MzJkZWQ2YTg1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWENvcmVPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYQ29yZU9iamVjdC5oCkBAIC0xMTMsMTkgKzExMyw2IEBAIGVudW0gY2xh c3MgQVhBbmNlc3RvckZsYWcgOiB1aW50OF90IHsKICAgICAvLyBCaXQgNyBpcyBmcmVlLgogfTsK IAotI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQotc3RydWN0IEFYVGV4dFJ1biB7Ci0g ICAgLy8gVGhlIGxpbmUgaW5kZXggb2YgdGhpcyBydW4gd2l0aGluIHRoZSBjb250ZXh0IG9mIHRo ZSBjb250YWluaW5nIFJlbmRlckJsb2NrRmxvdyBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2JqZWN0 LgotICAgIHNpemVfdCBsaW5lSW5kZXg7Ci0gICAgU3RyaW5nIHRleHQ7Ci0KLSAgICBBWFRleHRS dW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5nJiYgdGV4dCkKLSAgICAgICAgOiBsaW5lSW5kZXgo bGluZUluZGV4KQotICAgICAgICAsIHRleHQoV1RGTW92ZSh0ZXh0KSkKLSAgICB7IH0KLX07Ci0j ZW5kaWYKLQogZW51bSBjbGFzcyBBY2Nlc3NpYmlsaXR5Um9sZSB7CiAgICAgQXBwbGljYXRpb24g PSAxLAogICAgIEFwcGxpY2F0aW9uQWxlcnQsCkBAIC02NTYsNiArNjQzLDggQEAgZW51bSBjbGFz cyBBY2Nlc3NpYmlsaXR5QnV0dG9uU3RhdGUgewogICAgIE1peGVkLAogfTsKIAorZW51bSBjbGFz cyBBWERpcmVjdGlvbiA6IGJvb2wgeyBOZXh0LCBQcmV2aW91cyB9OworCiBlbnVtIGNsYXNzIEFj Y2Vzc2liaWxpdHlTb3J0RGlyZWN0aW9uIHsKICAgICBOb25lLAogICAgIEFzY2VuZGluZywKQEAg LTgwMyw2ICs3OTIsNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldE9iamVjdElEKEFYSUQgYXhJ RCkgeyBtX2lkID0gYXhJRDsgfQogICAgIEFYSUQgb2JqZWN0SUQoKSBjb25zdCB7IHJldHVybiBt X2lkOyB9CisgICAgdmlydHVhbCBBWElEIHRyZWVJRCgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFs IFByb2Nlc3NJRCBwcm9jZXNzSUQoKSBjb25zdCA9IDA7CiAKICAgICAvLyBXaGVuIHRoZSBjb3Jy ZXNwb25kaW5nIFdlYkNvcmUgb2JqZWN0IHRoYXQgdGhpcyBhY2Nlc3NpYmxlIG9iamVjdApAQCAt MTEwNyw5ICsxMDk3LDYgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhY2Nlc3NpYmlsaXR5 VGV4dChWZWN0b3I8QWNjZXNzaWJpbGl0eVRleHQ+JikgY29uc3QgPSAwOwogICAgIC8vIEEgcHJv Z3JhbW1hdGljIHdheSB0byBzZXQgYSBuYW1lIG9uIGFuIEFjY2Vzc2libGVPYmplY3QuCiAgICAg dmlydHVhbCB2b2lkIHNldEFjY2Vzc2libGVOYW1lKGNvbnN0IEF0b21TdHJpbmcmKSA9IDA7Ci0j aWYgRU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgdmlydHVhbCBWZWN0b3I8QVhUZXh0 UnVuPiB0ZXh0UnVucygpIHsgcmV0dXJuIHsgfTsgfQotI2VuZGlmCiAKICAgICB2aXJ0dWFsIFN0 cmluZyB0aXRsZSgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFsIFN0cmluZyBkZXNjcmlwdGlvbigp IGNvbnN0ID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhU ZXh0TWFya2VyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2Vy LmNwcAppbmRleCA5YWQ2YWJmOTNhYWMuLjA5MWI5M2Q1NGQxZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0TWFya2VyLmNwcApAQCAtMTk0LDYgKzE5NCwxMyBAQCBz dGQ6Om9wdGlvbmFsPEJvdW5kYXJ5UG9pbnQ+IEFYVGV4dE1hcmtlcjo6Ym91bmRhcnlQb2ludCgp IGNvbnN0CiAgICAgcmV0dXJuIHsgeyAqbm9kZSwgc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KG9mZnNl dCkgfSB9OwogfQogCisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURfVFJFRSkKK1Jl ZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBBWFRleHRNYXJrZXI6Omlzb2xhdGVkT2JqZWN0KCkgY29u c3QKK3sKKyAgICByZXR1cm4gZHluYW1pY0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KG9iamVj dCgpKTsKK30KKyNlbmRpZiAvLyBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQor CiBSZWZQdHI8QVhDb3JlT2JqZWN0PiBBWFRleHRNYXJrZXI6Om9iamVjdCgpIGNvbnN0CiB7CiAg ICAgaWYgKGlzTnVsbCgpKQpAQCAtMzM1LDcgKzM0Miw3IEBAIHN0ZDo6b3B0aW9uYWw8QVhUZXh0 TWFya2VyUmFuZ2U+IEFYVGV4dE1hcmtlclJhbmdlOjppbnRlcnNlY3Rpb25XaXRoKGNvbnN0IEFY VGV4CiAKIFN0cmluZyBBWFRleHRNYXJrZXJSYW5nZTo6ZGVidWdEZXNjcmlwdGlvbigpIGNvbnN0 CiB7Ci0gICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2Ny aXB0aW9uKCksICJ9XG5lbmQ6IHsiLCBtX2VuZC5kZWJ1Z0Rlc2NyaXB0aW9uKCksICJ9Iik7Cisg ICAgcmV0dXJuIG1ha2VTdHJpbmcoInN0YXJ0OiB7IiwgbV9zdGFydC5kZWJ1Z0Rlc2NyaXB0aW9u KCksICJ9XG5lbmQ6ICAgeyIsIG1fZW5kLmRlYnVnRGVzY3JpcHRpb24oKSwgIn0iKTsKIH0KIAog c3RkOjpwYXJ0aWFsX29yZGVyaW5nIHBhcnRpYWxPcmRlcihjb25zdCBBWFRleHRNYXJrZXImIG1h cmtlcjEsIGNvbnN0IEFYVGV4dE1hcmtlciYgbWFya2VyMikKQEAgLTM2OCw0ICszNzUsMjE2IEBA IGJvb2wgQVhUZXh0TWFya2VyUmFuZ2U6OmlzQ29uZmluZWRUbyhBWElEIG9iamVjdElEKSBjb25z dAogICAgICAgICAmJiBMSUtFTFkobV9zdGFydC50cmVlSUQoKSA9PSBtX2VuZC50cmVlSUQoKSk7 CiB9CiAKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKK2VudW0gY2xhc3MgQ2hlY2tT dGFydCA6IGJvb2wgeyBObywgWWVzIH07CisvLyBGaW5kcyB0aGUgbmV4dCBvYmplY3Qgd2l0aCB0 ZXh0IHJ1bnMgaW4gdGhlIGdpdmVuIGRpcmVjdGlvbi4KK3N0YXRpYyBSZWZQdHI8QVhJc29sYXRl ZE9iamVjdD4gZmluZE9iamVjdFdpdGhSdW5zKEFYSXNvbGF0ZWRPYmplY3QmIHN0YXJ0LCBBWERp cmVjdGlvbiBkaXJlY3Rpb24sIENoZWNrU3RhcnQgY2hlY2tTdGFydCA9IENoZWNrU3RhcnQ6Ok5v KQoreworICAgIGlmIChjaGVja1N0YXJ0ID09IENoZWNrU3RhcnQ6OlllcykgeworICAgICAgICBp ZiAoYXV0byogcnVucyA9IHN0YXJ0LnRleHRSdW5zKCk7IHJ1bnMgJiYgcnVucy0+c2l6ZSgpKQor ICAgICAgICAgICAgcmV0dXJuICZzdGFydDsKKyAgICB9CisKKyAgICBSZWZQdHIgY3VycmVudCA9 ICZzdGFydDsKKyAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICBpZiAoY3VycmVudCAhPSAm c3RhcnQpIHsKKyAgICAgICAgICAgIGF1dG8qIHJ1bnMgPSBjdXJyZW50LT50ZXh0UnVucygpOwor ICAgICAgICAgICAgaWYgKHJ1bnMgJiYgcnVucy0+c2l6ZSgpKQorICAgICAgICAgICAgICAgIHJl dHVybiBjdXJyZW50OworICAgICAgICB9CisKKyAgICAgICAgLy8gRklYTUU6IGFyaWEtb3ducyBi cmVha3MgdGhpcyB0cmF2ZXJzYWwsIGFzIGFyaWEtb3ducyBjYXVzZXMgdGhlIEFYIHRyZWUgdG8g YmUgY2hhbmdlZCwgYWZmZWN0aW5nCisgICAgICAgIC8vIG91ciBpdGVyYXRpb24gYmVsb3csIGJ1 dCBpdCBkb2Vzbid0IGFjdHVhbGx5IGNoYW5nZSB0ZXh0IHBvc2l0aW9uIG9uIHRoZSBwYWdlLiBT byB3ZSBuZWVkIHRvIGlnbm9yZSBhcmlhLW93bnMKKyAgICAgICAgLy8gdHJlZSBjaGFuZ2VzIGhl cmUgaW4gb3JkZXIgdG8gYmVoYXZlIGNvcnJlY3RseS4KKyAgICAgICAgLy8gV2UgYWxzbyBwcm9i YWJseSBuZWVkIHRvIGRvIHNvbWV0aGluZyBhYm91dCB0ZXh0IHdpdGhpbiBhcmlhLWhpZGRlbiBj b250YWluZXJzLCB3aGljaCBhZmZlY3RzIHRoZSBBWCB0cmVlLgorCisgICAgICAgIGNvbnN0IGF1 dG8mIGNoaWxkcmVuID0gY3VycmVudC0+Y2hpbGRyZW4oKTsKKyAgICAgICAgaWYgKGNoaWxkcmVu LnNpemUoKSkgeworICAgICAgICAgICAgc2l6ZV90IGNoaWxkSW5kZXggPSBkaXJlY3Rpb24gPT0g QVhEaXJlY3Rpb246Ok5leHQgPyAwIDogY2hpbGRyZW4uc2l6ZSgpIC0gMTsKKyAgICAgICAgICAg IFJFTEVBU0VfQVNTRVJUKGNoaWxkcmVuW2NoaWxkSW5kZXhdKTsKKyAgICAgICAgICAgIGN1cnJl bnQgPSBkeW5hbWljRG93bmNhc3Q8QVhJc29sYXRlZE9iamVjdD4oY2hpbGRyZW5bY2hpbGRJbmRl eF0uZ2V0KCkpOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICAv LyBgY3VycmVudGAgaGFzIG5vIGNoaWxkcmVuLCBtZWFuaW5nIGl0J3MgYSBsZWFmIG5vZGUgKGUu Zy4gaXQncyB0ZXh0LCB3aGljaCBjYW5ub3QgaGF2ZSBjaGlsZHJlbikuCisgICAgICAgIC8vIENo ZWNrIGBjdXJyZW50YHMgc2libGluZ3MuCisgICAgICAgIGlmIChhdXRvKiBzaWJsaW5nID0gY3Vy cmVudC0+c2libGluZyhkaXJlY3Rpb24pKSB7CisgICAgICAgICAgICBjdXJyZW50ID0gZHluYW1p Y0Rvd25jYXN0PEFYSXNvbGF0ZWRPYmplY3Q+KHNpYmxpbmcpOworICAgICAgICAgICAgY29udGlu dWU7CisgICAgICAgIH0KKworICAgICAgICAvLyBXZSBoYXZlIG5vIGNoaWxkcmVuLCBhbmQgbm8g bmV4dC9wcmV2aW91cyBzaWJsaW5nLiBUcnkgb3VyIHBhcmVudCdzIHNpYmxpbmcuCisgICAgICAg IGlmIChhdXRvKiBwYXJlbnQgPSBjdXJyZW50LT5wYXJlbnRPYmplY3RVbmlnbm9yZWQoKSkgewor ICAgICAgICAgICAgY3VycmVudCA9IGR5bmFtaWNEb3duY2FzdDxBWElzb2xhdGVkT2JqZWN0Pihw YXJlbnQtPnNpYmxpbmcoZGlyZWN0aW9uKSk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgfQorCisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICByZXR1cm4gbnVsbHB0cjsKK30KKwor U3RyaW5nIEFYVGV4dE1hcmtlclJhbmdlOjp0b1N0cmluZygpIGNvbnN0Cit7CisgICAgUkVMRUFT RV9BU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKworICAgIGF1dG8gc3RhcnQgPSBtX3N0YXJ0LnRv VGV4dExlYWZNYXJrZXIoKTsKKyAgICBpZiAoIXN0YXJ0LmlzVmFsaWQoKSkKKyAgICAgICAgcmV0 dXJuIGVtcHR5U3RyaW5nKCk7CisgICAgYXV0byBlbmQgPSBtX2VuZC50b1RleHRMZWFmTWFya2Vy KCk7CisgICAgaWYgKCFlbmQuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm4gZW1wdHlTdHJpbmco KTsKKworICAgIGlmIChzdGFydC5pc29sYXRlZE9iamVjdCgpID09IGVuZC5pc29sYXRlZE9iamVj dCgpKSB7CisgICAgICAgIHNpemVfdCBtaW5PZmZzZXQgPSBzdGQ6Om1pbihzdGFydC5vZmZzZXQo KSwgZW5kLm9mZnNldCgpKTsKKyAgICAgICAgc2l6ZV90IG1heE9mZnNldCA9IHN0ZDo6bWF4KHN0 YXJ0Lm9mZnNldCgpLCBlbmQub2Zmc2V0KCkpOworICAgICAgICByZXR1cm4gc3RhcnQucnVucygp LT5zdWJzdHJpbmcobWluT2Zmc2V0LCBtYXhPZmZzZXQgLSBtaW5PZmZzZXQpOworICAgIH0KKwor ICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHJlc3VsdC5hcHBlbmQoc3RhcnQucnVucygp LT5zdWJzdHJpbmcoc3RhcnQub2Zmc2V0KCkpKTsKKworICAgIC8vIEZJWE1FOiBJZiB3ZSd2ZSBi ZWVuIGdpdmVuIHJldmVyc2VkIG1hcmtlcnMsIGkuZS4gdGhlIGVuZCBtYXJrZXIgYWN0dWFsbHkg Y29tZXMgYmVmb3JlIHRoZSBzdGFydCBtYXJrZXIsCisgICAgLy8gd2UgbWF5IHdhbnQgdG8gZGV0 ZWN0IHRoaXMgYW5kIHRyeSBzZWFyY2hpbmcgQVhEaXJlY3Rpb246OlByZXZpb3VzPworICAgIFJl ZlB0ciBjdXJyZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpzdGFydC5pc29sYXRlZE9iamVjdCgp LCBBWERpcmVjdGlvbjo6TmV4dCk7CisgICAgd2hpbGUgKGN1cnJlbnQgJiYgY3VycmVudC0+b2Jq ZWN0SUQoKSAhPSBlbmQub2JqZWN0SUQoKSkgeworICAgICAgICBjb25zdCBhdXRvKiBydW5zID0g Y3VycmVudC0+dGV4dFJ1bnMoKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHJ1 bnMtPnNpemUoKTsgaSsrKQorICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChydW5zLT5hdChpKS50 ZXh0KTsKKyAgICAgICAgY3VycmVudCA9IGZpbmRPYmplY3RXaXRoUnVucygqY3VycmVudCwgQVhE aXJlY3Rpb246Ok5leHQpOworICAgIH0KKyAgICByZXN1bHQuYXBwZW5kKGVuZC5ydW5zKCktPnN1 YnN0cmluZygwLCBlbmQub2Zmc2V0KCkpKTsKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7 Cit9CisKK2NvbnN0IEFYVGV4dFJ1bnMqIEFYVGV4dE1hcmtlcjo6cnVucygpIGNvbnN0Cit7Cisg ICAgUmVmUHRyIG9iamVjdCA9IGlzb2xhdGVkT2JqZWN0KCk7CisgICAgcmV0dXJuIG9iamVjdCA/ IG9iamVjdC0+dGV4dFJ1bnMoKSA6IG51bGxwdHI7Cit9CisKK0FYVGV4dE1hcmtlciBBWFRleHRN YXJrZXI6OmZpbmRNYXJrZXIoQVhEaXJlY3Rpb24gZGlyZWN0aW9uKSBjb25zdAoreworICAgIGlm ICghaXNWYWxpZCgpKQorICAgICAgICByZXR1cm4geyB9OworICAgIGlmICghaXNJblRleHRMZWFm KCkpCisgICAgICAgIHJldHVybiB0b1RleHRMZWFmTWFya2VyKCkuZmluZE1hcmtlcihkaXJlY3Rp b24pOworICAgIFJFTEVBU0VfQVNTRVJUKGlzSW5UZXh0TGVhZigpKTsKKworICAgIHNpemVfdCBy dW5JbmRleCA9IHJ1bnMoKS0+aW5kZXhGb3JPZmZzZXQob2Zmc2V0KCkpOworICAgIFJFTEVBU0Vf QVNTRVJUKHJ1bkluZGV4ICE9IG5vdEZvdW5kKTsKKyAgICBhdXRvIGhhc01vcmVUZXh0SW5DdXJy ZW50UnVuID0gWyZdIHsKKyAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBBWERpcmVjdGlvbjo6TmV4 dCkKKyAgICAgICAgICAgIHJldHVybiBvZmZzZXQoKSA8IHJ1bnMoKS0+YXQocnVuSW5kZXgpLnRl eHQubGVuZ3RoKCk7CisgICAgICAgIHJldHVybiBvZmZzZXQoKSA+IDA7CisgICAgfTsKKyAgICBi b29sIGhhc0Fub3RoZXJSdW4gPSBydW5JbmRleCArIDEgPCBydW5zKCktPnNpemUoKTsKKyAgICAv LyBUaGUgbmV4dCBydW4gc2hvdWxkIG5vdCBoYXZlIGVtcHR5IHRleHQsIGJlY2F1c2Ugd2UncmUg Z29pbmcgdG8gcmV0dXJuIGEgcG9zaXRpb24gY29udGFpbmluZyBvZmZzZXQoKSArIDEsIHdoaWNo IHdvdWxkIGJlIHdyb25nLgorICAgIFJFTEVBU0VfQVNTRVJUKGRpcmVjdGlvbiA9PSBBWERpcmVj dGlvbjo6UHJldmlvdXMgfHwgIWhhc0Fub3RoZXJSdW4gfHwgcnVucygpLT5ydW5MZW5ndGgocnVu SW5kZXggKyAxKSA+IDApOworICAgIC8vIENoZWNraW5nIGZvciB0aGUgcHJlc2VuY2Ugb2YgYW5v dGhlciBydW4gaXMgb25seSByZWxldmFudCBmb3IgbW92aW5nIEFYRGlyZWN0aW9uOjpOZXh0LCBh cyBqdXN0IGNoZWNraW5nIHRoYXQgb2Zmc2V0KCkgPiAwIGlzIHN1ZmZpY2llbnQgZm9yIEFYRGly ZWN0aW9uOjpQcmV2aW91cy4KKyAgICBpZiAoaGFzTW9yZVRleHRJbkN1cnJlbnRSdW4oKSB8fCAo ZGlyZWN0aW9uID09IEFYRGlyZWN0aW9uOjpOZXh0ICYmIGhhc0Fub3RoZXJSdW4pKSB7CisgICAg ICAgIC8vIFJldHVybiBhbiBvZmZzZXQgdG8gdGhlIG5leHQgY2hhcmFjdGVyIGluIHRoZSBjdXJy ZW50IHJ1bi4KKyAgICAgICAgcmV0dXJuIHsgdHJlZUlEKCksIG9iamVjdElEKCksIGRpcmVjdGlv biA9PSBBWERpcmVjdGlvbjo6TmV4dCA/IG9mZnNldCgpICsgMSA6IG9mZnNldCgpIC0gMSB9Owor ICAgIH0KKyAgICAvLyBvZmZzZXQoKSBwb2ludGVkIHRvIHRoZSBsYXN0IGNoYXJhY3RlciBpbiB0 aGUgZ2l2ZW4gb2JqZWN0J3MgcnVucywgc28gbGV0J3MgdHJhdmVyc2UgdG8gZmluZCB0aGUgbmV4 dCBvYmplY3Qgd2l0aCBydW5zLgorICAgIGlmIChSZWZQdHIgb2JqZWN0ID0gZmluZE9iamVjdFdp dGhSdW5zKCp0aGlzLT5pc29sYXRlZE9iamVjdCgpLCBkaXJlY3Rpb24pKQorICAgICAgICByZXR1 cm4geyBvYmplY3QtPnRyZWVJRCgpLCBvYmplY3QtPm9iamVjdElEKCksIGRpcmVjdGlvbiA9PSBB WERpcmVjdGlvbjo6TmV4dCA/IDAgOiBvYmplY3QtPnRleHRSdW5zKCktPmxhc3RSdW5MZW5ndGgo KSB9OworCisgICAgcmV0dXJuIHsgfTsKK30KKworQVhUZXh0TWFya2VyIEFYVGV4dE1hcmtlcjo6 ZmluZE1hcmtlcihBWERpcmVjdGlvbiBkaXJlY3Rpb24sIEFYVGV4dFVuaXQgdGV4dFVuaXQsIEFY VGV4dFVuaXRCb3VuZGFyeSBib3VuZGFyeSkgY29uc3QKK3sKKyAgICBpZiAoIWlzVmFsaWQoKSkK KyAgICAgICAgcmV0dXJuIHsgfTsKKyAgICBpZiAoIWlzSW5UZXh0TGVhZigpKQorICAgICAgICBy ZXR1cm4gdG9UZXh0TGVhZk1hcmtlcigpLmZpbmRNYXJrZXIoZGlyZWN0aW9uLCB0ZXh0VW5pdCwg Ym91bmRhcnkpOworICAgIFJFTEVBU0VfQVNTRVJUKGlzSW5UZXh0TGVhZigpKTsKKworICAgIGlm ICh0ZXh0VW5pdCA9PSBBWFRleHRVbml0OjpMaW5lKSB7CisgICAgICAgIHNpemVfdCBydW5JbmRl eCA9IHJ1bnMoKS0+aW5kZXhGb3JPZmZzZXQob2Zmc2V0KCkpOworICAgICAgICBSRUxFQVNFX0FT U0VSVChydW5JbmRleCAhPSBub3RGb3VuZCk7CisgICAgICAgIFJlZlB0ciBjdXJyZW50T2JqZWN0 ID0gaXNvbGF0ZWRPYmplY3QoKTsKKyAgICAgICAgY29uc3QgYXV0byogY3VycmVudFJ1bnMgPSBj dXJyZW50T2JqZWN0LT50ZXh0UnVucygpOworCisgICAgICAgIGF1dG8gY29tcHV0ZU9mZnNldCA9 IFsmXSAoc2l6ZV90IHJ1bkVuZE9mZnNldCwgc2l6ZV90IHJ1bkxlbmd0aCkgeworICAgICAgICAg ICAgLy8gVGhpcyB3b3JrcyBiZWNhdXNlIGBydW5FbmRPZmZzZXRgIGlzIHRoZSBvZmZzZXQgcG9p bnRpbmcgdG8gdGhlIGVuZCBvZiB0aGUgZ2l2ZW4gcnVuLCB3aGljaCBpbmNsdWRlcyB0aGUgbGVu Z3RoIG9mIGFsbCBydW5zIHByZWNlZGluZyBpdC4gU28gc3VidHJhY3RpbmcgdGhhdCBmcm9tIHRo ZSBsZW5ndGggb2YgdGhlIGN1cnJlbnQgcnVuIGdpdmVzIHVzIGFuIG9mZnNldCB0byB0aGUgc3Rh cnQgb2YgdGhlIGN1cnJlbnQgcnVuLgorICAgICAgICAgICAgcmV0dXJuIGJvdW5kYXJ5ID09IEFY VGV4dFVuaXRCb3VuZGFyeTo6RW5kID8gcnVuRW5kT2Zmc2V0IDogcnVuRW5kT2Zmc2V0IC0gcnVu TGVuZ3RoOworICAgICAgICB9OworICAgICAgICBhdXRvIGxpbmVQb3NpdGlvbiA9IEFYVGV4dE1h cmtlcih0cmVlSUQoKSwgb2JqZWN0SUQoKSwgY29tcHV0ZU9mZnNldChjdXJyZW50UnVucy0+cnVu TGVuZ3RoU3VtVG8ocnVuSW5kZXgpLCBjdXJyZW50UnVucy0+cnVuTGVuZ3RoKHJ1bkluZGV4KSkp OworICAgICAgICBhdXRvIHN0YXJ0TGluZUlEID0gY3VycmVudFJ1bnMtPmxpbmVJRChydW5JbmRl eCk7CisgICAgICAgIC8vIFdlIGZvdW5kIHRoZSBzdGFydCBydW4gYW5kIGFzc29jaWF0ZWQgbGlu ZSwgbm93IGl0ZXJhdGUgdW50aWwgd2UgZmluZCBhIGxpbmUgYm91bmRhcnkuCisgICAgICAgIHdo aWxlIChjdXJyZW50T2JqZWN0KSB7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChjdXJyZW50 UnVucy0+c2l6ZSgpKTsKKyAgICAgICAgICAgIHVuc2lnbmVkIGN1bXVsYXRpdmVPZmZzZXQgPSAw OworICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjdXJyZW50UnVucy0+c2l6ZSgp OyBpKyspIHsKKyAgICAgICAgICAgICAgICBjdW11bGF0aXZlT2Zmc2V0ICs9IGN1cnJlbnRSdW5z LT5ydW5MZW5ndGgoaSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRSdW5zLT5saW5lSUQo aSkgIT0gc3RhcnRMaW5lSUQpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBsaW5lUG9zaXRp b247CisgICAgICAgICAgICAgICAgbGluZVBvc2l0aW9uID0gQVhUZXh0TWFya2VyKGN1cnJlbnRP YmplY3QtPnRyZWVJRCgpLCBjdXJyZW50T2JqZWN0LT5vYmplY3RJRCgpLCBjb21wdXRlT2Zmc2V0 KGN1bXVsYXRpdmVPZmZzZXQsIGN1cnJlbnRSdW5zLT5ydW5MZW5ndGgoaSkpKTsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIGN1cnJlbnRPYmplY3QgPSBmaW5kT2JqZWN0V2l0aFJ1bnMoKmN1 cnJlbnRPYmplY3QsIGRpcmVjdGlvbik7CisgICAgICAgICAgICBpZiAoY3VycmVudE9iamVjdCkK KyAgICAgICAgICAgICAgICBjdXJyZW50UnVucyA9IGN1cnJlbnRPYmplY3QtPnRleHRSdW5zKCk7 CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGxpbmVQb3NpdGlvbjsKKyAgICB9CisgICAgLy8g RklYTUU6IEltcGxlbWVudCB0aGUgb3RoZXIgQVhUZXh0VW5pdHMuCisKKyAgICByZXR1cm4geyB9 OworfQorCitBWFRleHRNYXJrZXIgQVhUZXh0TWFya2VyOjp0b1RleHRMZWFmTWFya2VyKCkgY29u c3QKK3sKKyAgICBpZiAoIWlzVmFsaWQoKSB8fCBpc0luVGV4dExlYWYoKSkgeworICAgICAgICAv LyBJZiBzb21ldGhpbmcgaGFzIGNvbnN0cnVjdGVkIGEgbGVhZiBtYXJrZXIsIGl0IHNob3VsZCd2 ZSBkb25lIHNvIHdpdGggYW4gaW4tYm91bmRzIG9mZnNldC4KKyAgICAgICAgUkVMRUFTRV9BU1NF UlQoIWlzVmFsaWQoKSB8fCBpc29sYXRlZE9iamVjdCgpLT50ZXh0UnVucygpLT50b3RhbExlbmd0 aCgpID49IG9mZnNldCgpKTsKKyAgICAgICAgcmV0dXJuICp0aGlzOworICAgIH0KKworICAgIC8v IEZpbmQgdGhlIGxlYWYgbm9kZSBvdXIgb2Zmc2V0IHBvaW50cyB0by4gRm9yIGV4YW1wbGU6Cisg ICAgLy8gQVhUZXh0TWFya2VyIHsgSUQgMTogR3JvdXAsIE9mZnNldCA2IH0KKyAgICAvLyBJRCAx OiBHcm91cAorICAgIC8vICAtIElEIDI6IEZvbworICAgIC8vICAtIElEIDM6IExpbmUxCisgICAg Ly8gICAgICAgICAgTGluZTIKKyAgICAvLyBDYWxsaW5nIHRvVGV4dExlYWZNYXJrZXIoKSBvbiB0 aGUgb3JpZ2luYWwgbWFya2VyIHNob3VsZCB5aWVsZCBuZXcgbWFya2VyOgorICAgIC8vIEFYVGV4 dE1hcmtlciB7IElEIDM6IFN0YXRpY1RleHQsIE9mZnNldCAzIH0KKyAgICAvLyBCZWNhdXNlIHdl IGhhZCB0byB3YWxrIG92ZXIgSUQgMiB3aGljaCBoYWQgbGVuZ3RoIDMgdGV4dC4KKyAgICBzaXpl X3QgcHJlY2VkaW5nT2Zmc2V0ID0gMDsKKyAgICBSZWZQdHIgY3VycmVudCA9IGZpbmRPYmplY3RX aXRoUnVucygqaXNvbGF0ZWRPYmplY3QoKSwgQVhEaXJlY3Rpb246Ok5leHQsIENoZWNrU3RhcnQ6 Olllcyk7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAgdW5zaWduZWQgdG90YWxMZW5n dGggPSBjdXJyZW50LT50ZXh0UnVucygpLT50b3RhbExlbmd0aCgpOworICAgICAgICBpZiAocHJl Y2VkaW5nT2Zmc2V0ICsgdG90YWxMZW5ndGggPj0gb2Zmc2V0KCkpCisgICAgICAgICAgICBicmVh azsKKyAgICAgICAgcHJlY2VkaW5nT2Zmc2V0ICs9IHRvdGFsTGVuZ3RoOworICAgICAgICBjdXJy ZW50ID0gZmluZE9iamVjdFdpdGhSdW5zKCpjdXJyZW50LCBBWERpcmVjdGlvbjo6TmV4dCk7Cisg ICAgfQorCisgICAgaWYgKCFjdXJyZW50KQorICAgICAgICByZXR1cm4geyB9OworCisgICAgUkVM RUFTRV9BU1NFUlQob2Zmc2V0KCkgPj0gcHJlY2VkaW5nT2Zmc2V0KTsKKyAgICByZXR1cm4geyBj dXJyZW50LT50cmVlSUQoKSwgY3VycmVudC0+b2JqZWN0SUQoKSwgc3RhdGljX2Nhc3Q8dW5zaWdu ZWQ+KG9mZnNldCgpIC0gcHJlY2VkaW5nT2Zmc2V0KSB9OworfQorCitib29sIEFYVGV4dE1hcmtl cjo6aXNJblRleHRMZWFmKCkgY29uc3QKK3sKKyAgICBSZWZQdHIgb2JqZWN0ID0gdGhpcy0+aXNv bGF0ZWRPYmplY3QoKTsKKyAgICAvLyBGSVhNRTogSXMgaXQgcG9zc2libGUgZm9yIG5vbi1sZWFm IG5vZGVzIHRvIGhhdmUgdGV4dCBydW5zPyBJZiBzbywgd2UgZG9uJ3QgaGFuZGxlIHRoZW0gY29y cmVjdGx5LgorICAgIHJldHVybiAhb2JqZWN0IHx8ICghb2JqZWN0LT5jaGlsZHJlbigpLnNpemUo KSAmJiBvYmplY3QtPnRleHRSdW5zKCkpOworfQorCitBWFRleHRNYXJrZXJSYW5nZSBBWFRleHRN YXJrZXI6OmxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlIHR5cGUpIGNvbnN0Cit7CisgICAgaWYgKCFp c1ZhbGlkKCkpCisgICAgICAgIHJldHVybiB7IHsgfSwgeyB9IH07CisKKyAgICBpZiAodHlwZSA9 PSBMaW5lUmFuZ2VUeXBlOjpDdXJyZW50KQorICAgICAgICByZXR1cm4geyBmaW5kTWFya2VyKEFY RGlyZWN0aW9uOjpQcmV2aW91cywgQVhUZXh0VW5pdDo6TGluZSwgQVhUZXh0VW5pdEJvdW5kYXJ5 OjpTdGFydCksIGZpbmRNYXJrZXIoQVhEaXJlY3Rpb246Ok5leHQsIEFYVGV4dFVuaXQ6OkxpbmUs IEFYVGV4dFVuaXRCb3VuZGFyeTo6RW5kKSB9OworICAgIC8vIEZJWE1FOiBUaGUgb3RoZXIgdHlw ZXMgYXJlbid0IGltcGxlbWVudGVkIHlldC4KKyAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hF RCgpOworfQorI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorCiB9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYVGV4dE1hcmtlci5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJr ZXIuaAppbmRleCAxN2U5ZmMwZGFiOTguLjk2NjQwNWQzZWI5ZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRNYXJrZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dE1hcmtlci5oCkBAIC0yOCw3ICsyOCwyNSBAQAogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElUWV9JU09MQVRFRF9UUkVF KQorY2xhc3MgQVhJc29sYXRlZE9iamVjdDsKKyNlbmRpZgogc3RydWN0IENoYXJhY3Rlck9mZnNl dDsKK3N0cnVjdCBBWFRleHRSdW5zOworCitlbnVtIGNsYXNzIEFYVGV4dFVuaXQgOiB1aW50OF90 IHsKKyAgICBMaW5lLAorICAgIFBhcmFncmFwaCwKKyAgICBTZW50ZW5jZSwKKyAgICBXb3JkLAor fTsKK2VudW0gY2xhc3MgQVhUZXh0VW5pdEJvdW5kYXJ5IDogYm9vbCB7IFN0YXJ0LCBFbmQsIH07 CisKK2VudW0gY2xhc3MgTGluZVJhbmdlVHlwZSA6IHVpbnQ4X3QgeworICAgIEN1cnJlbnQsCisg ICAgTGVmdCwKKyAgICBSaWdodCwKK307CiAKIHN0cnVjdCBUZXh0TWFya2VyRGF0YSB7CiAgICAg dW5zaWduZWQgdHJlZUlEOwpAQCAtMTA5LDYgKzEyNyw5IEBAIHB1YmxpYzoKICNpZiBQTEFURk9S TShDT0NPQSkKICAgICBBWFRleHRNYXJrZXIoUGxhdGZvcm1UZXh0TWFya2VyRGF0YSk7CiAjZW5k aWYKKyAgICBBWFRleHRNYXJrZXIoQVhJRCB0cmVlSUQsIEFYSUQgb2JqZWN0SUQsIHVuc2lnbmVk IG9mZnNldCkKKyAgICAgICAgOiBtX2RhdGEoeyB0cmVlSUQsIG9iamVjdElELCBudWxscHRyLCBv ZmZzZXQsIFBvc2l0aW9uOjpQb3NpdGlvbklzT2Zmc2V0SW5BbmNob3IsIEFmZmluaXR5OjpEb3du c3RyZWFtLCAwLCBvZmZzZXQgfSkKKyAgICB7IH0KICAgICBBWFRleHRNYXJrZXIoKSA9IGRlZmF1 bHQ7CiAKICAgICBvcGVyYXRvciBib29sKCkgY29uc3QgeyByZXR1cm4gIWlzTnVsbCgpOyB9CkBA IC0xMjMsNyArMTQ0LDEyIEBAIHB1YmxpYzoKIAogICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgeyBy ZXR1cm4gbV9kYXRhLmF4VHJlZUlEKCk7IH0KICAgICBBWElEIG9iamVjdElEKCkgY29uc3QgeyBy ZXR1cm4gbV9kYXRhLmF4T2JqZWN0SUQoKTsgfQorICAgIHVuc2lnbmVkIG9mZnNldCgpIGNvbnN0 IHsgcmV0dXJuIG1fZGF0YS5vZmZzZXQ7IH0KICAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0 dXJuICF0cmVlSUQoKS5pc1ZhbGlkKCkgfHwgIW9iamVjdElEKCkuaXNWYWxpZCgpOyB9CisjaWYg RU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURfVFJFRSkKKyAgICAvLyBGSVhNRTogQ3VycmVu dGx5LCB0aGUgbG9naWMgZm9yIHNlcnZpbmcgdGV4dCBBUElzIG9mZiB0aGUgbWFpbi10aHJlYWQg cmVxdWlyZXMgaXNvbGF0ZWQgb2JqZWN0cywgYnV0IHNob3VsZCBldmVudHVhbGx5IGJlIHJlZmFj dG9yZWQgdG8gd29yayB3aXRoIEFYQ29yZU9iamVjdHMuCisgICAgUmVmUHRyPEFYSXNvbGF0ZWRP YmplY3Q+IGlzb2xhdGVkT2JqZWN0KCkgY29uc3Q7CisjZW5kaWYKICAgICBSZWZQdHI8QVhDb3Jl T2JqZWN0PiBvYmplY3QoKSBjb25zdDsKICAgICBib29sIGlzVmFsaWQoKSBjb25zdCB7IHJldHVy biBvYmplY3QoKTsgfQogCkBAIC0xMzQsNyArMTYwLDI3IEBAIHB1YmxpYzoKIAogICAgIC8vIFNl dHMgbV9kYXRhLm5vZGUgd2hlbiB0aGUgbWFya2VyIHdhcyBjcmVhdGVkIHdpdGggYSBQbGF0Zm9y bVRleHRNYXJrZXJEYXRhIHRoYXQgbGFja3MgdGhlIG5vZGUgcG9pbnRlciBiZWNhdXNlIGl0IHdh cyBjcmVhdGVkIG9mZiB0aGUgbWFpbiB0aHJlYWQuCiAgICAgdm9pZCBzZXROb2RlSWZOZWVkZWQo KSBjb25zdDsKKworI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIC8vIEZpbmQg dGhlIG5leHQgb3IgcHJldmlvdXMgbWFya2VyLgorICAgIEFYVGV4dE1hcmtlciBmaW5kTWFya2Vy KEFYRGlyZWN0aW9uKSBjb25zdDsKKyAgICAvLyBTdGFydGluZyBmcm9tIHRoaXMgdGV4dCBtYXJr ZXIsIGNyZWF0ZXMgYSBuZXcgcG9zaXRpb24gZm9yIHRoZSBnaXZlbiBkaXJlY3Rpb24gYW5kIHRl eHQgdW5pdCB0eXBlLgorICAgIEFYVGV4dE1hcmtlciBmaW5kTWFya2VyKEFYRGlyZWN0aW9uLCBB WFRleHRVbml0LCBBWFRleHRVbml0Qm91bmRhcnkpIGNvbnN0OworICAgIC8vIENyZWF0ZXMgYSBy YW5nZSBmb3IgdGhlIGxpbmUgdGhpcyBtYXJrZXIgcG9pbnRzIHRvLgorICAgIEFYVGV4dE1hcmtl clJhbmdlIGxpbmVSYW5nZShMaW5lUmFuZ2VUeXBlKSBjb25zdDsKKyAgICAvLyBHaXZlbiBhIGNo YXJhY3RlciBvZmZzZXQgcmVsYXRpdmUgdG8gdGhpcyBtYXJrZXIsIGZpbmQgdGhlIG5leHQgbWFy a2VyIHRoZSBvZmZzZXQgcG9pbnRzIHRvLgorICAgIEFYVGV4dE1hcmtlciBuZXh0TWFya2VyRnJv bU9mZnNldChzaXplX3QpIGNvbnN0OworI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9B UElTKQorCiBwcml2YXRlOgorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorICAgIGNv bnN0IEFYVGV4dFJ1bnMqIHJ1bnMoKSBjb25zdDsKKworICAgIC8vIFRydWUgaWYgdGhpcyBtYXJr ZXIgcG9pbnRzIHRvIGEgbGVhZiBub2RlIChubyBjaGlsZHJlbikgd2l0aCBub24tZW1wdHkgdGV4 dCBydW5zLgorICAgIGJvb2wgaXNJblRleHRMZWFmKCkgY29uc3Q7CisgICAgQVhUZXh0TWFya2Vy IHRvVGV4dExlYWZNYXJrZXIoKSBjb25zdDsKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RF WFRfQVBJUykKKwogICAgIFRleHRNYXJrZXJEYXRhIG1fZGF0YTsKIH07CiAKQEAgLTE3MSw2ICsy MTcsMTEgQEAgcHVibGljOgogICAgIEFYVGV4dE1hcmtlciBlbmQoKSBjb25zdCB7IHJldHVybiBt X2VuZDsgfQogICAgIGJvb2wgaXNDb25maW5lZFRvKEFYSUQpIGNvbnN0OwogCisjaWYgRU5BQkxF KEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgLy8gVHJhdmVyc2VzIGZyb20gbV9zdGFydCB0byBt X2VuZCwgY29sbGVjdGluZyBhbGwgdGV4dCBhbG9uZyB0aGUgd2F5LgorICAgIFN0cmluZyB0b1N0 cmluZygpIGNvbnN0OworI2VuZGlmCisKICAgICBTdHJpbmcgZGVidWdEZXNjcmlwdGlvbigpIGNv bnN0OwogcHJpdmF0ZToKICAgICBBWFRleHRNYXJrZXIgbV9zdGFydDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLjUwNGZhMjQ3MmFhNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0UnVuLmNwcApAQCAtMCwwICsxLDkzIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDIzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YK KyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up CisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgorCisjaWYg RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1N0cmlu ZyBBWFRleHRSdW5zOjpkZWJ1Z0Rlc2NyaXB0aW9uKCkgY29uc3QKK3sKKyAgICBTdHJpbmdCdWls ZGVyIHJlc3VsdDsKKyAgICByZXN1bHQuYXBwZW5kKCdbJyk7CisgICAgZm9yICh1bnNpZ25lZCBp ID0gMDsgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgcmVzdWx0LmFwcGVuZChydW5z W2ldLmRlYnVnRGVzY3JpcHRpb24oY29udGFpbmluZ0Jsb2NrKSk7CisgICAgICAgIGlmIChpICE9 IHJ1bnMuc2l6ZSgpIC0gMSkKKyAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoIiwgIik7CisgICAg fQorICAgIHJlc3VsdC5hcHBlbmQoJ10nKTsKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7 Cit9CisKK3NpemVfdCBBWFRleHRSdW5zOjppbmRleEZvck9mZnNldCh1bnNpZ25lZCB0ZXh0T2Zm c2V0KSBjb25zdAoreworICAgIHNpemVfdCBjdW11bGF0aXZlTGVuZ3RoID0gMDsKKyAgICBmb3Ig KHNpemVfdCBpID0gMDsgaSA8IHJ1bnMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgY3VtdWxhdGl2 ZUxlbmd0aCArPSBydW5MZW5ndGgoaSk7CisgICAgICAgIGlmIChjdW11bGF0aXZlTGVuZ3RoID49 IHRleHRPZmZzZXQpCisgICAgICAgICAgICByZXR1cm4gaTsKKyAgICB9CisgICAgcmV0dXJuIG5v dEZvdW5kOworfQorCit1bnNpZ25lZCBBWFRleHRSdW5zOjpydW5MZW5ndGhTdW1UbyhzaXplX3Qg aW5kZXgpIGNvbnN0Cit7CisgICAgdW5zaWduZWQgbGVuZ3RoID0gMDsKKyAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8PSBpbmRleCAmJiBpIDwgcnVucy5zaXplKCk7IGkrKykKKyAgICAgICAgbGVu Z3RoICs9IHJ1bkxlbmd0aChpKTsKKyAgICByZXR1cm4gbGVuZ3RoOworfQorCitTdHJpbmcgQVhU ZXh0UnVuczo6c3Vic3RyaW5nKHVuc2lnbmVkIHN0YXJ0LCB1bnNpZ25lZCBsZW5ndGgpIGNvbnN0 Cit7CisgICAgaWYgKCFsZW5ndGgpCisgICAgICAgIHJldHVybiBlbXB0eVN0cmluZygpOworCisg ICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgc2l6ZV90IGNoYXJhY3RlcnNTZWVuID0gMDsK KyAgICBhdXRvIHJlbWFpbmluZyA9IFsmXSAoKSB7CisgICAgICAgIHJldHVybiByZXN1bHQubGVu Z3RoKCkgPj0gbGVuZ3RoID8gMCA6IGxlbmd0aCAtIHJlc3VsdC5sZW5ndGgoKTsKKyAgICB9Owor ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBydW5zLnNpemUoKSAmJiByZXN1bHQubGVuZ3Ro KCkgPCBsZW5ndGg7IGkrKykgeworICAgICAgICBzaXplX3QgcnVuTGVuZ3RoID0gdGhpcy0+cnVu TGVuZ3RoKGkpOworICAgICAgICBpZiAoY2hhcmFjdGVyc1NlZW4gPj0gc3RhcnQpIHsKKyAgICAg ICAgICAgIC8vIFRoZSBzdGFydCBwb2ludHMgZW50aXJlbHkgd2l0aGluIGJvdW5kcyBvZiB0aGlz IHJ1bi4KKyAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQocnVuc1tpXS50ZXh0LmxlZnQocmVtYWlu aW5nKCkpKTsKKyAgICAgICAgfSBlbHNlIGlmIChjaGFyYWN0ZXJzU2VlbiArIHJ1bkxlbmd0aCA+ IHN0YXJ0KSB7CisgICAgICAgICAgICAvLyBzdGFydCBwb2ludHMgc29tZXdoZXJlIGluIHRoZSBt aWRkbGUgb2YgdGhlIGN1cnJlbnQgcnVuLCBjb2xsZWN0IHBhcnQgb2YgdGhlIHRleHQuCisgICAg ICAgICAgICB1bnNpZ25lZCBzdGFydEluUnVuID0gc3RhcnQgLSBjaGFyYWN0ZXJzU2VlbjsKKyAg ICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKHN0YXJ0SW5SdW4gPCBydW5MZW5ndGgpOworICAgICAg ICAgICAgcmVzdWx0LmFwcGVuZChydW5zW2ldLnRleHQuc3Vic3RyaW5nKHN0YXJ0SW5SdW4sIHJl bWFpbmluZygpKSk7CisgICAgICAgIH0KKyAgICAgICAgLy8gSWYgY2hhcmFjdGVyc1NlZW4gKyBy dW5MZW5ndGggPT0gc3RhcnQsIHRoZSBzdGFydCBwb2ludHMgdG8gdGhlIGVuZCBvZiB0aGUgcnVu LCBhbmQgdGhlcmUgaXMgbm8gdGV4dCB0byBnYXRoZXIuCisKKyAgICAgICAgY2hhcmFjdGVyc1Nl ZW4gKz0gcnVuTGVuZ3RoOworICAgIH0KKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9 CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RF WFRfQVBJUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhUZXh0 UnVuLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYVGV4dFJ1bi5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYzhkYTIzYTU0ZWIyCi0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWFRleHRSdW4uaApAQCAtMCww ICsxLDEyMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6 CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO CisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5BQkxFKEFYX1RI UkVBRF9URVhUX0FQSVMpCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFJlbmRlckJsb2Nr OworCitzdHJ1Y3QgQVhUZXh0UnVuTGluZUlEIHsKKyAgICB2b2lkKiBjb250YWluaW5nQmxvY2sg eyBudWxscHRyIH07CisgICAgc2l6ZV90IGxpbmVJbmRleCB7IDAgfTsKKworICAgIEFYVGV4dFJ1 bkxpbmVJRCh2b2lkKiBjb250YWluaW5nQmxvY2ssIHNpemVfdCBsaW5lSW5kZXgpCisgICAgICAg IDogY29udGFpbmluZ0Jsb2NrKGNvbnRhaW5pbmdCbG9jaykKKyAgICAgICAgLCBsaW5lSW5kZXgo bGluZUluZGV4KQorICAgIHsgfQorICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBBWFRleHRSdW5M aW5lSUQmKSBjb25zdCA9IGRlZmF1bHQ7CisgICAgU3RyaW5nIGRlYnVnRGVzY3JpcHRpb24oKSBj b25zdAorICAgIHsKKyAgICAgICAgVGV4dFN0cmVhbSBzdHJlYW07CisgICAgICAgIHN0cmVhbSA8 PCAiTGluZUlEICIgPDwgY29udGFpbmluZ0Jsb2NrIDw8ICIgIiA8PCBsaW5lSW5kZXg7CisgICAg ICAgIHJldHVybiBzdHJlYW0ucmVsZWFzZSgpOworICAgIH0KK307CisKK3N0cnVjdCBBWFRleHRS dW4geworICAgIC8vIFRoZSBsaW5lIGluZGV4IG9mIHRoaXMgcnVuIHdpdGhpbiB0aGUgY29udGV4 dCBvZiB0aGUgY29udGFpbmluZyBSZW5kZXJCbG9jayBvZiB0aGUgbWFpbi10aHJlYWQgQVggb2Jq ZWN0LgorICAgIHNpemVfdCBsaW5lSW5kZXg7CisgICAgU3RyaW5nIHRleHQ7CisKKyAgICBBWFRl eHRSdW4oc2l6ZV90IGxpbmVJbmRleCwgU3RyaW5nJiYgdGV4dCkKKyAgICAgICAgOiBsaW5lSW5k ZXgobGluZUluZGV4KQorICAgICAgICAsIHRleHQoV1RGTW92ZSh0ZXh0KSkKKyAgICB7IH0KKwor ICAgIFN0cmluZyBkZWJ1Z0Rlc2NyaXB0aW9uKHZvaWQqIGNvbnRhaW5pbmdCbG9jaykgY29uc3QK KyAgICB7CisgICAgICAgIEFYVGV4dFJ1bkxpbmVJRCBsaW5lSUQgPSB7IGNvbnRhaW5pbmdCbG9j aywgbGluZUluZGV4IH07CisgICAgICAgIHJldHVybiBtYWtlU3RyaW5nKGxpbmVJRC5kZWJ1Z0Rl c2NyaXB0aW9uKCksICI6IHwiLCBtYWtlU3RyaW5nQnlSZXBsYWNpbmdBbGwodGV4dCwgJ1xuJywg IntuZXdsaW5lfSJfcyksICJ8KGxlbiAiLCB0ZXh0Lmxlbmd0aCgpLCAiKSIpOworICAgIH0KK307 CisKK3N0cnVjdCBBWFRleHRSdW5zIHsKKyAgICAvLyBUaGUgY29udGFpbmluZyBibG9jayBmb3Ig dGhlIHRleHQgcnVucy4gVGhpcyBpcyByZXF1aXJlZCBiZWNhdXNlIGJhc2VkIG9uIHRoZSBzdHJ1 Y3R1cmUKKyAgICAvLyBvZiB0aGUgQVggdHJlZSwgdGV4dCBydW5zIGZvciBkaWZmZXJlbnQgb2Jq ZWN0cyBjYW4gaGF2ZSB0aGUgc2FtZSBsaW5lIGluZGV4IGJ1dCBkaWZmZXJlbnQKKyAgICAvLyBj b250YWluaW5nIGJsb2NrcywgbWVhbmluZyB0aGV5IGFyZSByZW5kZXJlZCBvbiBkaWZmZXJlbnQg bGluZXMuCisgICAgLy8gRG8gbm90IGRlLXJlZmVyZW5jZS4gVXNlIGZvciBjb21wYXJpc29uIHB1 cnBvc2VzIG9ubHkuCisgICAgdm9pZCogY29udGFpbmluZ0Jsb2NrIHsgbnVsbHB0ciB9OworICAg IFZlY3RvcjxBWFRleHRSdW4+IHJ1bnM7CisKKyAgICBBWFRleHRSdW5zKCkgPSBkZWZhdWx0Owor ICAgIEFYVGV4dFJ1bnMoUmVuZGVyQmxvY2sqIGNvbnRhaW5pbmdCbG9jaywgVmVjdG9yPEFYVGV4 dFJ1bj4mJiBydW5zKQorICAgICAgICA6IGNvbnRhaW5pbmdCbG9jayhjb250YWluaW5nQmxvY2sp CisgICAgICAgICwgcnVucyhXVEZNb3ZlKHJ1bnMpKQorICAgIHsgfQorICAgIFN0cmluZyBkZWJ1 Z0Rlc2NyaXB0aW9uKCkgY29uc3Q7CisKKyAgICBzaXplX3Qgc2l6ZSgpIGNvbnN0IHsgcmV0dXJu IHJ1bnMuc2l6ZSgpOyB9CisgICAgY29uc3QgQVhUZXh0UnVuJiBhdChzaXplX3QgaW5kZXgpIGNv bnN0CisgICAgeworICAgICAgICByZXR1cm4gKCp0aGlzKVtpbmRleF07CisgICAgfQorICAgIGNv bnN0IEFYVGV4dFJ1biYgb3BlcmF0b3JbXShzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAg ICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgpKTsKKyAgICAgICAgcmV0dXJu IHJ1bnNbaW5kZXhdOworICAgIH0KKworICAgIHVuc2lnbmVkIHJ1bkxlbmd0aChzaXplX3QgaW5k ZXgpIGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6 ZSgpKTsKKyAgICAgICAgcmV0dXJuIHJ1bnNbaW5kZXhdLnRleHQubGVuZ3RoKCk7CisgICAgfQor ICAgIHVuc2lnbmVkIGxhc3RSdW5MZW5ndGgoKSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKHJ1 bnMuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIHJldHVybiBydW5z W3J1bnMuc2l6ZSgpIC0gMV0udGV4dC5sZW5ndGgoKTsKKyAgICB9CisgICAgdW5zaWduZWQgdG90 YWxMZW5ndGgoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIHJ1bkxlbmd0aFN1bVRvKHJ1 bnMuc2l6ZSgpIC0gMSk7CisgICAgfQorICAgIHVuc2lnbmVkIHJ1bkxlbmd0aFN1bVRvKHNpemVf dCBpbmRleCkgY29uc3Q7CisKKyAgICBzaXplX3QgaW5kZXhGb3JPZmZzZXQodW5zaWduZWQgdGV4 dE9mZnNldCkgY29uc3Q7CisgICAgQVhUZXh0UnVuTGluZUlEIGxpbmVJRChzaXplX3QgaW5kZXgp IGNvbnN0CisgICAgeworICAgICAgICBSRUxFQVNFX0FTU0VSVChpbmRleCA8IHJ1bnMuc2l6ZSgp KTsKKyAgICAgICAgcmV0dXJuIHsgY29udGFpbmluZ0Jsb2NrLCBydW5zW2luZGV4XS5saW5lSW5k ZXggfTsKKyAgICB9CisgICAgU3RyaW5nIHN1YnN0cmluZyh1bnNpZ25lZCBzdGFydCwgdW5zaWdu ZWQgbGVuZ3RoID0gU3RyaW5nSW1wbDo6TWF4TGVuZ3RoKSBjb25zdDsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKyNlbmRpZiAvLyBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwCmluZGV4IDI5YTkzMWM1YWExNC4uZjMzOWIzYWIwMDgxIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKQEAgLTExMyw2 ICsxMTMsMTIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppbml0KCkKICAgICBtX3JvbGUg PSBkZXRlcm1pbmVBY2Nlc3NpYmlsaXR5Um9sZSgpOwogfQogCitBWElEIEFjY2Vzc2liaWxpdHlP YmplY3Q6OnRyZWVJRCgpIGNvbnN0Cit7CisgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENhY2hl KCk7CisgICAgcmV0dXJuIGNhY2hlID8gY2FjaGUtPnRyZWVJRCgpIDogQVhJRCgpOworfQorCiBp bmxpbmUgUHJvY2Vzc0lEIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByb2Nlc3NJRCgpIGNvbnN0CiB7 CiAgICAgcmV0dXJuIHByZXNlbnRpbmdBcHBsaWNhdGlvblBJRCgpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmggYi9Tb3VyY2Uv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlPYmplY3QuaAppbmRleCBlNjRiNjMw NmMwOGUuLmM3ZjI4ZDVjM2I1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNwcmFnbWEgb25j ZQogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCiAj aW5jbHVkZSAiQ2hhcmFjdGVyUmFuZ2UuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNs dWRlICJMYXlvdXRSZWN0LmgiCkBAIC02Myw2ICs2NCw3IEBAIGNsYXNzIEFjY2Vzc2liaWxpdHlP YmplY3QgOiBwdWJsaWMgQVhDb3JlT2JqZWN0LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8QWNjZXNz aWJpCiBwdWJsaWM6CiAgICAgdmlydHVhbCB+QWNjZXNzaWJpbGl0eU9iamVjdCgpOwogCisgICAg QVhJRCB0cmVlSUQoKSBjb25zdCBmaW5hbDsKICAgICBQcm9jZXNzSUQgcHJvY2Vzc0lEKCkgY29u c3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBAIC0zODIsNiAr Mzg0LDkgQEAgcHVibGljOgogICAgIFN0cmluZyB0ZXh0VW5kZXJFbGVtZW50KEFjY2Vzc2liaWxp dHlUZXh0VW5kZXJFbGVtZW50TW9kZSA9IEFjY2Vzc2liaWxpdHlUZXh0VW5kZXJFbGVtZW50TW9k ZSgpKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiB7IH07IH0KICAgICBTdHJpbmcgdGV4dCgpIGNv bnN0IG92ZXJyaWRlIHsgcmV0dXJuIHsgfTsgfQogICAgIHVuc2lnbmVkIHRleHRMZW5ndGgoKSBj b25zdCBmaW5hbDsKKyNpZiBFTkFCTEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKKyAgICB2aXJ0dWFs IEFYVGV4dFJ1bnMgdGV4dFJ1bnMoKSB7IHJldHVybiB7IH07IH0KKyNlbmRpZgogI2lmIFBMQVRG T1JNKENPQ09BKQogICAgIC8vIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyBhbmQgQVhPYmpl Y3Qgd3JhcHBlcnMgY29ycmVzcG9uZGluZyB0byB0aGUKICAgICAvLyB0ZXh0cnVucyBhbmQgcmVw bGFjZW1lbnQgbm9kZXMgaW5jbHVkZWQgaW4gdGhlIGdpdmVuIHJhbmdlLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNw cCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHAKaW5kZXggMzk0NjllNjkwNjAwLi5mNzM4ZTg5YjQyYWEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcApAQCAtMTQwMywxMSArMTQwMywxMSBAQCBDaGFyYWN0ZXJSYW5nZSBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpzZWxlY3RlZFRleHRSYW5nZSgpIGNvbnN0CiB9CiAKICNpZiBFTkFCTEUo QVhfVEhSRUFEX1RFWFRfQVBJUykKLVZlY3RvcjxBWFRleHRSdW4+IEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRleHRSdW5zKCkKK0FYVGV4dFJ1bnMgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dDo6dGV4dFJ1bnMoKQogewogICAgIGlmIChhdXRvKiByZW5kZXJMaW5lQnJlYWsgPSBkeW5hbWlj RG93bmNhc3Q8UmVuZGVyTGluZUJyZWFrPihyZW5kZXJlcigpKSkgewogICAgICAgICBhdXRvIGJv eCA9IElubGluZUl0ZXJhdG9yOjpib3hGb3IoKnJlbmRlckxpbmVCcmVhayk7Ci0gICAgICAgIHJl dHVybiB7IHsgYm94LT5saW5lSW5kZXgoKSwgbWFrZVN0cmluZygnXG4nKSB9IH07CisgICAgICAg IHJldHVybiB7IHJlbmRlckxpbmVCcmVhay0+Y29udGFpbmluZ0Jsb2NrKCksIHsgQVhUZXh0UnVu KGJveC0+bGluZUluZGV4KCksIG1ha2VTdHJpbmcoJ1xuJykuaXNvbGF0ZWRDb3B5KCkpIH0gfTsK ICAgICB9CiAKICAgICBXZWFrUHRyIHJlbmRlclRleHQgPSBkeW5hbWljRG93bmNhc3Q8UmVuZGVy VGV4dD4ocmVuZGVyZXIoKSk7CkBAIC0xNDYwLDcgKzE0NjAsNyBAQCBWZWN0b3I8QVhUZXh0UnVu PiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0ZXh0UnVucygpCiAKICAgICBpZiAoIWxpbmVT dHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBydW5zLmFwcGVuZCh7IGN1cnJlbnRMaW5lSW5kZXgs IGxpbmVTdHJpbmcudG9TdHJpbmcoKS5pc29sYXRlZENvcHkoKSB9KTsKLSAgICByZXR1cm4gcnVu czsKKyAgICByZXR1cm4geyByZW5kZXJUZXh0LT5jb250YWluaW5nQmxvY2soKSwgV1RGTW92ZShy dW5zKSB9OwogfQogI2VuZGlmIC8vIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oCmluZGV4IGNlZWM2YmYzZTg5OC4uYmU5ZWU0Zjg2MDQ2IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuaApAQCAtMTAwLDcgKzEwMCw3IEBAIHB1YmxpYzoKICAgICBTdHJpbmcgdGV4dFVuZGVyRWxl bWVudChBY2Nlc3NpYmlsaXR5VGV4dFVuZGVyRWxlbWVudE1vZGUgPSBBY2Nlc3NpYmlsaXR5VGV4 dFVuZGVyRWxlbWVudE1vZGUoKSkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgU3RyaW5nIHNlbGVjdGVk VGV4dCgpIGNvbnN0IG92ZXJyaWRlOwogI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQot ICAgIFZlY3RvcjxBWFRleHRSdW4+IHRleHRSdW5zKCkgZmluYWw7CisgICAgQVhUZXh0UnVucyB0 ZXh0UnVucygpIGZpbmFsOwogI2VuZGlmCiAKICAgICBib29sIGlzV2lkZ2V0KCkgY29uc3Qgb3Zl cnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVk dHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRPYmplY3QuY3BwCmluZGV4IDYyYTFhNTc1YWU2MS4uMTA4 ZjUwOGIxMDgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmNwcApAQCAtMzEsNiArMzEsNyBA QAogI2luY2x1ZGUgIkFYR2VvbWV0cnlNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiQVhJc29sYXRlZFRy ZWUuaCIKICNpbmNsdWRlICJBWExvZ2dlci5oIgorI2luY2x1ZGUgIkFYVGV4dFJ1bi5oIgogCiAj aWYgUExBVEZPUk0oTUFDKQogI2ltcG9ydCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5oPgpA QCAtNDY0LDYgKzQ2NSw5IEBAIHZvaWQgQVhJc29sYXRlZE9iamVjdDo6c2V0UHJvcGVydHkoQVhQ cm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBBWFByb3BlcnR5VmFsdWVWCiAgICAgICAgIFtdKHN0 ZDo6cGFpcjxBWElELCBDaGFyYWN0ZXJSYW5nZT4mIHR5cGVkVmFsdWUpIHsKICAgICAgICAgICAg IHJldHVybiAhdHlwZWRWYWx1ZS5maXJzdC5pc1ZhbGlkKCkgJiYgIXR5cGVkVmFsdWUuc2Vjb25k LmxvY2F0aW9uICYmICF0eXBlZFZhbHVlLnNlY29uZC5sZW5ndGg7CiAgICAgICAgIH0sCisjaWYg RU5BQkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCisgICAgICAgIFtdKEFYVGV4dFJ1bnMmIHJ1bnMp IHsgcmV0dXJuICFydW5zLnNpemUoKTsgfSwKKyNlbmRpZgogICAgICAgICBbXShhdXRvJikgewog ICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgICAgICByZXR1cm4gZmFs c2U7CkBAIC01NTcsNiArNTYxLDE5IEBAIHZvaWQgQVhJc29sYXRlZE9iamVjdDo6c2V0U2VsZWN0 ZWRDaGlsZHJlbihjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIHNlCiAgICAgfSk7 CiB9CiAKK0FYQ29yZU9iamVjdCogQVhJc29sYXRlZE9iamVjdDo6c2libGluZyhBWERpcmVjdGlv biBkaXJlY3Rpb24pIGNvbnN0Cit7CisgICAgUmVmUHRyIHBhcmVudCA9IHBhcmVudE9iamVjdFVu aWdub3JlZCgpOworICAgIGNvbnN0IGF1dG8mIHNpYmxpbmdzID0gcGFyZW50LT5jaGlsZHJlbigp OworICAgIHNpemVfdCBpbmRleE9mVGhpcyA9IHNpYmxpbmdzLmZpbmQodGhpcyk7CisgICAgaWYg KGluZGV4T2ZUaGlzID09IG5vdEZvdW5kKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAg IGlmIChkaXJlY3Rpb24gPT0gQVhEaXJlY3Rpb246Ok5leHQpCisgICAgICAgIHJldHVybiBpbmRl eE9mVGhpcyArIDEgPCBzaWJsaW5ncy5zaXplKCkgPyBzaWJsaW5nc1tpbmRleE9mVGhpcyArIDFd LmdldCgpIDogbnVsbHB0cjsKKyAgICByZXR1cm4gaW5kZXhPZlRoaXMgPiAwID8gc2libGluZ3Nb aW5kZXhPZlRoaXMgLSAxXS5nZXQoKSA6IG51bGxwdHI7Cit9CisKIGJvb2wgQVhJc29sYXRlZE9i amVjdDo6aXNEZXRhY2hlZEZyb21QYXJlbnQoKQogewogICAgIGlmIChwYXJlbnQoKS5pc1ZhbGlk KCkpCkBAIC05NzEsNiArOTg4LDE5IEBAIGludCBBWElzb2xhdGVkT2JqZWN0OjppbnRBdHRyaWJ1 dGVWYWx1ZShBWFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUpIGNvbnN0CiAgICAgKTsKIH0KIAor I2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorY29uc3QgQVhUZXh0UnVucyogQVhJc29s YXRlZE9iamVjdDo6dGV4dFJ1bnMoKSBjb25zdAoreworICAgIGF1dG8gZW50cnkgPSBtX3Byb3Bl cnR5TWFwLmZpbmQoQVhQcm9wZXJ0eU5hbWU6OlRleHRSdW5zKTsKKyAgICBpZiAoZW50cnkgPT0g bV9wcm9wZXJ0eU1hcC5lbmQoKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJu IFdURjo6c3dpdGNoT24oZW50cnktPnZhbHVlLAorICAgICAgICBbXSAoY29uc3QgQVhUZXh0UnVu cyYgdHlwZWRWYWx1ZSkgLT4gY29uc3QgQVhUZXh0UnVucyogeyByZXR1cm4gJnR5cGVkVmFsdWU7 IH0sCisgICAgICAgIFtdIChhdXRvJikgLT4gY29uc3QgQVhUZXh0UnVucyogeyByZXR1cm4gbnVs bHB0cjsgfQorICAgICk7Cit9CisjZW5kaWYKKwogdGVtcGxhdGU8dHlwZW5hbWUgVD4KIFQgQVhJ c29sYXRlZE9iamVjdDo6Z2V0T3JSZXRyaWV2ZVByb3BlcnR5VmFsdWUoQVhQcm9wZXJ0eU5hbWUg cHJvcGVydHlOYW1lKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oCmluZGV4IGE2Y2EwMzQzNzc3 ZC4uYmY4OWMxM2YzNjhiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZE9iamVjdC5oCkBAIC00NCw2ICs0NCw5 IEBACiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEFYSXNvbGF0ZWRUcmVlOworI2lmIEVO QUJMRShBWF9USFJFQURfVEVYVF9BUElTKQorc3RydWN0IEFYVGV4dFJ1bnM7CisjZW5kaWYKIAog Y2xhc3MgQVhJc29sYXRlZE9iamVjdCBmaW5hbCA6IHB1YmxpYyBBWENvcmVPYmplY3QgewogICAg IGZyaWVuZCBjbGFzcyBBWElzb2xhdGVkVHJlZTsKQEAgLTUxLDYgKzU0LDcgQEAgcHVibGljOgog ICAgIHN0YXRpYyBSZWY8QVhJc29sYXRlZE9iamVjdD4gY3JlYXRlKGNvbnN0IFJlZjxBY2Nlc3Np YmlsaXR5T2JqZWN0PiYsIEFYSXNvbGF0ZWRUcmVlKik7CiAgICAgfkFYSXNvbGF0ZWRPYmplY3Qo KTsKIAorICAgIEFYSUQgdHJlZUlEKCkgY29uc3QgZmluYWwgeyByZXR1cm4gdHJlZSgpLT50cmVl SUQoKTsgfQogICAgIFByb2Nlc3NJRCBwcm9jZXNzSUQoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0 cmVlKCktPnByb2Nlc3NJRCgpOyB9CiAgICAgU3RyaW5nIGRiZygpIGNvbnN0IGZpbmFsOwogCkBA IC01OSwxMCArNjMsMTcgQEAgcHVibGljOgogICAgIGJvb2wgaXNUYWJsZSgpIGNvbnN0IGZpbmFs IHsgcmV0dXJuIGJvb2xBdHRyaWJ1dGVWYWx1ZShBWFByb3BlcnR5TmFtZTo6SXNUYWJsZSk7IH0K ICAgICBib29sIGlzRXhwb3NhYmxlKCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0 ZVZhbHVlKEFYUHJvcGVydHlOYW1lOjpJc0V4cG9zYWJsZSk7IH0KIAorICAgIGNvbnN0IEFjY2Vz c2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oYm9vbCB1cGRhdGVDaGlsZHJlbklmTmVl ZGVkID0gdHJ1ZSkgZmluYWw7CisgICAgQVhDb3JlT2JqZWN0KiBzaWJsaW5nKEFYRGlyZWN0aW9u KSBjb25zdDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBwYXJlbnRPYmplY3QoKSBjb25zdCBmaW5h bCB7IHJldHVybiBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKTsgfQorICAgIEFYSXNvbGF0ZWRPYmpl Y3QqIHBhcmVudE9iamVjdFVuaWdub3JlZCgpIGNvbnN0IGZpbmFsOwogICAgIEFYSXNvbGF0ZWRP YmplY3QqIGVkaXRhYmxlQW5jZXN0b3IoKSBmaW5hbCB7IHJldHVybiBBY2Nlc3NpYmlsaXR5Ojpl ZGl0YWJsZUFuY2VzdG9yKCp0aGlzKTsgfTsKICAgICBib29sIGNhblNldEZvY3VzQXR0cmlidXRl KCkgY29uc3QgZmluYWwgeyByZXR1cm4gYm9vbEF0dHJpYnV0ZVZhbHVlKEFYUHJvcGVydHlOYW1l OjpDYW5TZXRGb2N1c0F0dHJpYnV0ZSk7IH0KIAorI2lmIEVOQUJMRShBWF9USFJFQURfVEVYVF9B UElTKQorICAgIGNvbnN0IEFYVGV4dFJ1bnMqIHRleHRSdW5zKCkgY29uc3Q7CisjZW5kaWYKKwog cHJpdmF0ZToKICAgICB2b2lkIGRldGFjaFJlbW90ZVBhcnRzKEFjY2Vzc2liaWxpdHlEZXRhY2ht ZW50VHlwZSkgZmluYWw7CiAgICAgdm9pZCBkZXRhY2hQbGF0Zm9ybVdyYXBwZXIoQWNjZXNzaWJp bGl0eURldGFjaG1lbnRUeXBlKSBmaW5hbDsKQEAgLTI0Myw3ICsyNTQsNiBAQCBwcml2YXRlOgog ICAgIFZlY3RvcjxTdHJpbmc+IGRldGVybWluZURyb3BFZmZlY3RzKCkgY29uc3QgZmluYWw7CiAg ICAgQVhJc29sYXRlZE9iamVjdCogYWNjZXNzaWJpbGl0eUhpdFRlc3QoY29uc3QgSW50UG9pbnQm KSBjb25zdCBmaW5hbDsKICAgICBBWElzb2xhdGVkT2JqZWN0KiBmb2N1c2VkVUlFbGVtZW50KCkg Y29uc3QgZmluYWw7Ci0gICAgQVhJc29sYXRlZE9iamVjdCogcGFyZW50T2JqZWN0VW5pZ25vcmVk KCkgY29uc3QgZmluYWw7CiAgICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIGxpbmtlZE9i amVjdHMoKSBjb25zdCBmaW5hbCB7IHJldHVybiB0cmVlKCktPm9iamVjdHNGb3JJRHModmVjdG9y QXR0cmlidXRlVmFsdWU8QVhJRD4oQVhQcm9wZXJ0eU5hbWU6OkxpbmtlZE9iamVjdHMpKTsgfQog ICAgIEFYSXNvbGF0ZWRPYmplY3QqIHRpdGxlVUlFbGVtZW50KCkgY29uc3QgZmluYWwgeyByZXR1 cm4gb2JqZWN0QXR0cmlidXRlVmFsdWUoQVhQcm9wZXJ0eU5hbWU6OlRpdGxlVUlFbGVtZW50KTsg fQogICAgIEFYSXNvbGF0ZWRPYmplY3QqIHNjcm9sbEJhcihBY2Nlc3NpYmlsaXR5T3JpZW50YXRp b24pIGZpbmFsOwpAQCAtMzE2LDcgKzMyNiw2IEBAIHByaXZhdGU6CiAgICAgQWNjZXNzaWJpbGl0 eUNoaWxkcmVuVmVjdG9yIHZpc2libGVDaGlsZHJlbigpIGZpbmFsIHsgcmV0dXJuIHRyZWUoKS0+ b2JqZWN0c0ZvcklEcyh2ZWN0b3JBdHRyaWJ1dGVWYWx1ZTxBWElEPihBWFByb3BlcnR5TmFtZTo6 VmlzaWJsZUNoaWxkcmVuKSk7IH0KICAgICBBdG9tU3RyaW5nIHRhZ05hbWUoKSBjb25zdCBmaW5h bDsKICAgICB2b2lkIHNldENoaWxkcmVuSURzKFZlY3RvcjxBWElEPiYmKTsKLSAgICBjb25zdCBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKGJvb2wgdXBkYXRlQ2hpbGRyZW5J Zk5lZWRlZCA9IHRydWUpIGZpbmFsOwogICAgIHZvaWQgdXBkYXRlQ2hpbGRyZW5JZk5lY2Vzc2Fy eSgpIGZpbmFsOwogICAgIGJvb2wgaXNEZXRhY2hlZEZyb21QYXJlbnQoKSBmaW5hbDsKICAgICBB WElzb2xhdGVkT2JqZWN0KiBsaXZlUmVnaW9uQW5jZXN0b3IoYm9vbCBleGNsdWRlSWZPZmYgPSB0 cnVlKSBjb25zdCBmaW5hbCB7IHJldHVybiBBY2Nlc3NpYmlsaXR5OjpsaXZlUmVnaW9uQW5jZXN0 b3IoKnRoaXMsIGV4Y2x1ZGVJZk9mZik7IH0KQEAgLTM0NSw5ICszNTQsNiBAQCBwcml2YXRlOgog CiAgICAgLy8gQ2hhcmFjdGVyUmFuZ2Ugc3VwcG9ydC4KICAgICBDaGFyYWN0ZXJSYW5nZSBzZWxl Y3RlZFRleHRSYW5nZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIHByb3BlcnR5VmFsdWU8Q2hhcmFj dGVyUmFuZ2U+KEFYUHJvcGVydHlOYW1lOjpTZWxlY3RlZFRleHRSYW5nZSk7IH0KLSNpZiBFTkFC TEUoQVhfVEhSRUFEX1RFWFRfQVBJUykKLSAgICBWZWN0b3I8QVhUZXh0UnVuPiB0ZXh0UnVucygp IGZpbmFsIHsgcmV0dXJuIHZlY3RvckF0dHJpYnV0ZVZhbHVlPEFYVGV4dFJ1bj4oQVhQcm9wZXJ0 eU5hbWU6OlRleHRSdW5zKTsgfQotI2VuZGlmCiAgICAgaW50IGluc2VydGlvblBvaW50TGluZU51 bWJlcigpIGNvbnN0IGZpbmFsOwogICAgIENoYXJhY3RlclJhbmdlIGRvQVhSYW5nZUZvckxpbmUo dW5zaWduZWQpIGNvbnN0IGZpbmFsOwogICAgIFN0cmluZyBkb0FYU3RyaW5nRm9yUmFuZ2UoY29u c3QgQ2hhcmFjdGVyUmFuZ2UmKSBjb25zdCBmaW5hbDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcApp bmRleCBmNmYwNjIyYWJlOTMuLjBlNzUzOWUzYThjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNw cApAQCAtMzAsNiArMzAsNyBAQAogCiAjaW5jbHVkZSAiQVhJc29sYXRlZE9iamVjdC5oIgogI2lu Y2x1ZGUgIkFYTG9nZ2VyLmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVRhYmxlUm93LmgiCiAj aW5jbHVkZSAiRnJhbWVTZWxlY3Rpb24uaCIKICNpbmNsdWRlICJMb2NhbEZyYW1lVmlldy5oIgog I2luY2x1ZGUgIlBhZ2UuaCIKQEAgLTIzMCwyMiArMjMxLDYgQEAgUmVmUHRyPEFYSXNvbGF0ZWRP YmplY3Q+IEFYSXNvbGF0ZWRUcmVlOjpvYmplY3RGb3JJRChjb25zdCBBWElEIGF4SUQpIGNvbnN0 CiAgICAgcmV0dXJuIGF4SUQuaXNWYWxpZCgpID8gbV9yZWFkZXJUaHJlYWROb2RlTWFwLmdldChh eElEKSA6IG51bGxwdHI7CiB9CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFU+Ci1WZWN0b3I8UmVmUHRy PEFYQ29yZU9iamVjdD4+IEFYSXNvbGF0ZWRUcmVlOjpvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4 SURzKSBjb25zdAotewotICAgIEFYVFJBQ0UoIkFYSXNvbGF0ZWRUcmVlOjpvYmplY3RzRm9ySURz Il9zKTsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKLQotICAgIFZlY3RvcjxSZWZQdHI8 QVhDb3JlT2JqZWN0Pj4gcmVzdWx0OwotICAgIHJlc3VsdC5yZXNlcnZlSW5pdGlhbENhcGFjaXR5 KGF4SURzLnNpemUoKSk7Ci0gICAgZm9yIChhdXRvJiBheElEIDogYXhJRHMpIHsKLSAgICAgICAg aWYgKFJlZlB0ciBvYmplY3QgPSBvYmplY3RGb3JJRChheElEKSkKLSAgICAgICAgICAgIHJlc3Vs dC5hcHBlbmQoV1RGTW92ZShvYmplY3QpKTsKLSAgICB9Ci0gICAgcmVzdWx0LnNocmlua1RvRml0 KCk7Ci0gICAgcmV0dXJuIHJlc3VsdDsKLX0KLQogdm9pZCBBWElzb2xhdGVkVHJlZTo6Z2VuZXJh dGVTdWJ0cmVlKEFjY2Vzc2liaWxpdHlPYmplY3QmIGF4T2JqZWN0KQogewogICAgIEFYVFJBQ0Uo IkFYSXNvbGF0ZWRUcmVlOjpnZW5lcmF0ZVN1YnRyZWUiX3MpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaCBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgK aW5kZXggNTlmMTlmYTc4OGY1Li43ZThmNjE3ODE1OWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaApA QCAtMjksNiArMjksNyBAQAogCiAjaW5jbHVkZSAiQVhDb3JlT2JqZWN0LmgiCiAjaW5jbHVkZSAi QVhUZXh0TWFya2VyLmgiCisjaW5jbHVkZSAiQVhUZXh0UnVuLmgiCiAjaW5jbHVkZSAiQVhUcmVl U3RvcmUuaCIKICNpbmNsdWRlICJQYWdlSWRlbnRpZmllci5oIgogI2luY2x1ZGUgIlJlbmRlclN0 eWxlQ29uc3RhbnRzLmgiCkBAIC00Nyw2ICs0OCw3IEBAIGNsYXNzIFRleHRTdHJlYW07CiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEFYSXNvbGF0ZWRPYmplY3Q7CitjbGFzcyBBWEdlb21l dHJ5TWFuYWdlcjsKIGNsYXNzIEFYT2JqZWN0Q2FjaGU7CiBjbGFzcyBBY2Nlc3NpYmlsaXR5T2Jq ZWN0OwogY2xhc3MgUGFnZTsKQEAgLTI1NSw3ICsyNTcsNyBAQCB1c2luZyBBWFByb3BlcnR5VmFs dWVWYXJpYW50ID0gc3RkOjp2YXJpYW50PHN0ZDo6bnVsbHB0cl90LCBBWElELCBTdHJpbmcsIGJv b2wsCiAgICAgLCBSZXRhaW5QdHI8TlNBdHRyaWJ1dGVkU3RyaW5nPgogI2VuZGlmCiAjaWYgRU5B QkxFKEFYX1RIUkVBRF9URVhUX0FQSVMpCi0gICAgLCBWZWN0b3I8QVhUZXh0UnVuPgorICAgICwg QVhUZXh0UnVucwogI2VuZGlmCiA+OwogdXNpbmcgQVhQcm9wZXJ0eU1hcCA9IEhhc2hNYXA8QVhQ cm9wZXJ0eU5hbWUsIEFYUHJvcGVydHlWYWx1ZVZhcmlhbnQsIEludEhhc2g8QVhQcm9wZXJ0eU5h bWU+LCBXVEY6OlN0cm9uZ0VudW1IYXNoVHJhaXRzPEFYUHJvcGVydHlOYW1lPj47CkBAIC0zMjIs NyArMzI0LDIwIEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCBSZWZQdHI8QVhJc29sYXRl ZE9iamVjdD4gZm9jdXNlZE5vZGUoKTsKIAogICAgIFJlZlB0cjxBWElzb2xhdGVkT2JqZWN0PiBv YmplY3RGb3JJRChjb25zdCBBWElEKSBjb25zdDsKLSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBW ZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IG9iamVjdHNGb3JJRHMoY29uc3QgVSYpIGNvbnN0 OworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+CisgICAgVmVjdG9yPFJlZlB0cjxBWENvcmVPYmpl Y3Q+PiBvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4SURzKSBjb25zdAorICAgIHsKKyAgICAgICAg QVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CisKKyAgICAgICAgVmVjdG9yPFJlZlB0cjxBWENvcmVP YmplY3Q+PiByZXN1bHQ7CisgICAgICAgIHJlc3VsdC5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGF4 SURzLnNpemUoKSk7CisgICAgICAgIGZvciAoY29uc3QgYXV0byYgYXhJRCA6IGF4SURzKSB7Cisg ICAgICAgICAgICBpZiAoUmVmUHRyIG9iamVjdCA9IG9iamVjdEZvcklEKGF4SUQpKQorICAgICAg ICAgICAgICAgIHJlc3VsdC5hcHBlbmQoV1RGTW92ZShvYmplY3QpKTsKKyAgICAgICAgfQorICAg ICAgICByZXN1bHQuc2hyaW5rVG9GaXQoKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9 CiAKICAgICB2b2lkIGdlbmVyYXRlU3VidHJlZShBY2Nlc3NpYmlsaXR5T2JqZWN0Jik7CiAgICAg dm9pZCBsYWJlbENyZWF0ZWQoQWNjZXNzaWJpbGl0eU9iamVjdCYpOwo=