5241 2005-10-02 20:41:03 -0700 Space and tab characters "sent" by an input method give totally different results than typing them directly 2011-01-24 06:08:52 -0800 1 1 1 Unclassified WebKit HTML Editing 420+ Mac OS X 10.4 RESOLVED FIXED P2 Normal --- 52799 52781 1 evan webkit-unassigned abarth ap eric gyuyoung.kim hyatt ian justin.garcia morrita rniwa webkit.review.bot oldest_to_newest 21210 0 evan 2005-10-02 20:41:03 -0700 If an input method sends space, tab, and perhaps other whitespace characters via an UpdateActiveInputArea TSM event, the results are totally different than typing them. I'll upload an input method you can use to reproduce this problem. Steps to reproduce: 1. In Blot (good because you can save the html to disk), just a keyboard selected, type "one<space>space<space><space>two<space>spaces<space><space><space>three<space>spaces " 2. Save the file. 3. Close the document, create a new untitled one. 4. Activate the input method I've attached - it allows spaces and tabs in the inline input area. 5. Type the same text as in step 1. 6. Save the file. Open each in a text editor so you can view the differences. The basic issue is that spaces from UAIA don't go through the same transformation (wrt option-space) as when you type them. Tab characters cause similar (perhaps worse!) problems. The resulting html is VERY different when the above test is done with tabs. Don't know how bad it is with returns, as this input method uses them to fix the inline text. Most applications do the right thing here with spaces and tabs, few deal with returns well. 21211 1 4164 evan 2005-10-02 20:42:30 -0700 Created attachment 4164 Input method for testing various issues Here's a modified version of the BasicInputMethod sample, enhanced to do the following: 1. The Send Event Palette can send OffsetToPos with positive/zero/negative offsets. Good for this particular bug. 2. Various enhancements to the inline input: - Can do click-positioning of the caret via PosToOffset - Arrow keys work - Drag-selecting within inline area works (well, not in NSTextView, radar filed long, long ago) - Shift-arrow extends selection - You can type spaces and tabs into the inline text (good for showing all the bugs with input methods sending whitespace vs. typing spaces and tabs - radars filed long, long ago). A bit buggy, you may need to open and close a window to get it to activate properly at times. Good for testing with bug 4681, bug 4682, bug 5230, perhaps others. 21212 2 evan 2005-10-02 20:44:55 -0700 Missed one perhaps not-so-obvious step to reproduce - before saving the file when the input method is active, confirm the text by hitting enter or return! 21258 3 ap 2005-10-03 01:40:37 -0700 Confirmed with 10.4.2 and ToT. It may be necessary to open the files with a hex editor to see the differences, actually. Is this limited to kEventTextInputUpdateActiveInputArea, and kEventTextInputUnicodeText is unaffected? I mean, IMs rarely need to input spaces, let alone tabs, into inline input areas. 21305 4 evan 2005-10-03 19:42:26 -0700 (In reply to comment #3) You should be able to use BBEdit or even drag the files onto Xcode to at least see the difference (option spaces in the typed-in text, only spaces from the input method). As for rarely needing to input spaces or tabs, well, perhaps not in the inline area, but that's not what this is about. It's about sending them via UAIA (and yes, I think kEventTextInputUnicodeText is also affected, I can check later to see). There are thousands of Spell Catcher, TypeIt4Me and Grammarian users out there that might not agree with the fact that spaces and tabs don't need to be sent to an app by an input method ;-). Consider some sort of auto-completing input method where typing "fyi" results in "for your information". Spell Catcher doesn't currently do this via inline input right now, too many apps don't support it. But that's not to say it won't ever work that way. Doesn't really matter, the current behavior is wrong and causes trouble. Spaces, for certain, are accepted properly via UAIA by every text editing widget I've come across. I have to special-case Mail on Tiger just to work-around this. Time to fix it. I tried stepping through the code with typing vs. UAIA, but without a whole lot of luck. We really need someone that knows this stuff inside-out to help us come up with the correct solution... 21727 5 4293 ap 2005-10-10 11:35:29 -0700 Created attachment 4293 automated test (goes to editing/input). I haven't tried with "real" TSM events, but from this test, it looks like both kEventTextInputUpdateActiveInputArea and kEventTextInputUnicodeText are affected, indeed. 27881 6 ap 2006-01-06 15:06:38 -0800 Hyatt says he's unlikely to look at this bug any time soon; unassigning. 332182 7 morrita 2011-01-11 00:42:49 -0800 *** Bug 51918 has been marked as a duplicate of this bug. *** 332185 8 78502 morrita 2011-01-11 00:54:37 -0800 Created attachment 78502 Patch 332186 9 morrita 2011-01-11 00:56:04 -0800 Adding hyatt and rniwa for possible reviewers. 332189 10 rniwa 2011-01-11 01:04:33 -0800 (In reply to comment #9) > Adding hyatt and rniwa for possible reviewers. Please address the comments I made on the bug 51918. 332892 11 78646 morrita 2011-01-11 20:52:20 -0800 Created attachment 78646 Patch 332893 12 morrita 2011-01-11 20:55:21 -0800 (In reply to comment #10) > Please address the comments I made on the bug 51918. I'm sorry I missed it. I updated the patch to address it. (In reply to comment #3) > (From update of attachment 78211 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=78211&action=review > > > LayoutTests/ChangeLog:7 > > + > > You probably want to explain what kind of test you're adding. Added an explanation. > > > WebCore/editing/CompositeEditCommand.cpp:433 > > +String CompositeEditCommand::stringWithBalancedWhitespaceAt(const Position& position, const String& text) > > Nit: the original function name "rebalanceWhitespaceAt" is better IMO. Renamed to "rebalanceWhitespaceBetweenWordsAt", which indicates its intension more closely. > > > WebCore/editing/CompositeEditCommand.cpp:438 > > + String ret; > > Nit: please don't use abbreviation. Fixed. > > > WebCore/editing/CompositeEditCommand.cpp:469 > > + } > > Why aren't we calling stringWithRebalancedWhitespace in htmlediting.cpp? It is for dirrent purpose. stringWithRebalancedWhitespace is for leading/trailing whitespace. new one is for whitespace other than leading/trailing. I renamed the function to indicate that. > > > WebCore/editing/Editor.cpp:1604 > > + // Some IME pass sequence of whitespace ' ' instead of nbsp even they expect > > + // multiple whitespaces inserted into the redering result. > > + // So we mix some nbsp characters for preserving the whitespace. > > Nit: I don't think this comment is necessary. Anyone who knows about whitespace rebalancing would understand what this code does. Removed. > > > WebCore/editing/Editor.cpp:1696 > > + // Some IME pass sequence of whitespace ' ' instead of nbsp even they expect > > + // multiple whitespaces inserted into the redering result. > > + // So we mix some nbsp characters for preserving the whitespace. > > Ditto. Removed. 332904 13 78646 rniwa 2011-01-11 21:38:40 -0800 Comment on attachment 78646 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=78646&action=review > LayoutTests/editing/inserting/script-tests/insert-composition-whitespace.js:34 > +test("div", "A B", "A \xA0B"); > +test("div", "A B", "A \xA0 B"); > +test("div", "A B", "A \xA0 \xA0B"); Mn... nbsp is 0xC2 0xA0 in UTF-8 but I guess it doesn't matter here. But watch out for test failures when you're landing this. > Source/WebCore/ChangeLog:24 > + * editing/CompositeEditCommand.cpp: > + (WebCore::hasWhitespaceList): > + (WebCore::CompositeEditCommand::shouldBalanceWhitespaceAt): > + (WebCore::CompositeEditCommand::rebalanceWhitespaceAt): > + (WebCore::CompositeEditCommand::rebalanceWhitespaceBetweenWordsAt): Added. > + * editing/CompositeEditCommand.h: > + * editing/Editor.cpp: > + (WebCore::Editor::confirmComposition): > + (WebCore::Editor::setComposition): Nit: Since you're making quite few modifications, it'll be nice if you also added inline description to each function. > Source/WebCore/editing/CompositeEditCommand.cpp:411 > +bool CompositeEditCommand::shouldBalanceWhitespaceAt(const Position& position, bool willInsert) I'm asking this function "should I balance whitespace at this position?" What does willInsert mean in that semantics? > Source/WebCore/editing/CompositeEditCommand.cpp:424 > + if (node->isTextNode()) { > + Text* textNode = static_cast<Text*>(node); > + if (!textNode->length() && !willInsert) > + return false; > + } else { > + if (!willInsert) > + return false; > + } Can't you just do: if ((!node->isTextNode() || !static_cast<Text*>(node)->length()) && !willInsert) return false; > Source/WebCore/editing/CompositeEditCommand.cpp:436 > + if (!hasWhitespaceList(text) || !shouldBalanceWhitespaceAt(position, true)) > + return text; Per recent discussion on webkit-dev, we don't want to be calling a function with true/false. r- for this. Consider making the argument enum type. But also reconsider the name willInsert. I don't think it's descriptive enough. > Source/WebCore/editing/CompositeEditCommand.cpp:469 > + String balancedText; > + unsigned whiteCount = 0; > + > + for (unsigned i = 0; i < text.length(); ++i) { > + bool isWhitespace = text[i] == ' '; > + if (isWhitespace) { > + whiteCount++; > + > + if (i + 1 < text.length()) > + continue; > + // Preserves trailing whitespace, which will be balanced by rebalanceWhitespaceAt() > + balancedText.append(text.characters() + text.length() - whiteCount, whiteCount); > + break; > + } > + > + // Preseves leading whitespace, which will be balanced by rebalanceWhitespaceAt() > + if (whiteCount == i) > + balancedText.append(text.characters(), whiteCount); > + else { > + // Interleaves nbsp and whitespace to preserve > + // space characters and line-breakability. > + if (1 == whiteCount) > + balancedText.append(' '); > + else { > + for (unsigned whiteIndex = 0; whiteIndex < whiteCount; ++whiteIndex) > + balancedText.append(static_cast<UChar>(whiteIndex%2 ? noBreakSpace : ' ')); > + } > + } > + > + balancedText.append(text.characters()[i]); > + whiteCount = 0; > + } It's really unfortunate that we can't share any code with rebalanceWhitespaceAt. Is there any way we can add more general version of the two and call that one in rebalanceWhitespaceAt and rebalanceWhitespaceBetweenWordsAt? 332914 14 78646 ap 2011-01-11 22:06:17 -0800 Comment on attachment 78646 Patch + * editing/inserting/insert-composition-whitespace.html: Added. + * editing/inserting/script-tests/insert-composition-whitespace.js: Added. Please don't split the test into .js and .html parts. Although this anti-pattern is used in many existing tests, it serves no purpose, and is actually harmful. 332915 15 ap 2011-01-11 22:07:51 -0800 This bug is about both spaces and tabs. Are tabs being fixed here? 332921 16 morrita 2011-01-11 22:44:13 -0800 (In reply to comment #15) > This bug is about both spaces and tabs. Are tabs being fixed here? Good point. I'll address it. 333621 17 78794 morrita 2011-01-13 03:22:39 -0800 Created attachment 78794 Patch 333622 18 morrita 2011-01-13 03:27:21 -0800 Ryosuke, Alexey, thank you for reviewing! I rewrote the patch to share the code path to rebalanceWhitespaceAt() that also addressed other feedback which you were pointing out. Could you take another look? 333626 19 gyuyoung.kim 2011-01-13 03:34:50 -0800 Your last patch has a build break in WebKit EFL. Please fix it. Linking CXX static library libwebcore_efl.a [100%] Built target webcore_efl Linking CXX shared library libewebkit.so [100%] Built target ewebkit Linking CXX executable Programs/EWebLauncher WebKit/libewebkit.so.0.1.0: undefined reference to `WebCore::InsertTextCommand::input(WTF::String const&, bool, WebCore::InsertTextCommand::WhitespaceRebalanceType)' collect2: ld returned 1 exit status make[2]: *** [Programs/EWebLauncher] Error 1 make[1]: *** [CMakeFiles/Programs/EWebLauncher.dir/all] Error 2 make: *** [all] Error 2 Failed to build Efl port 333747 20 78794 rniwa 2011-01-13 09:49:37 -0800 Comment on attachment 78794 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=78794&action=review The change looks much saner but I still need answers to the following questions. > LayoutTests/editing/inserting/insert-composition-whitespace.html:52 > +test("div", " AB", "\xA0AB"); > +test("div", " AB", "\xA0\xA0AB"); > +test("div", " AB", "\xA0\xA0 AB"); > +test("div", " AB", "\xA0\xA0 \xA0AB"); > +test("div", " AB", "\xA0\xA0 \xA0 AB"); > +test("div", " AB", "\xA0\xA0 \xA0 \xA0AB"); > +test("div", " AB", "\xA0\xA0 \xA0 \xA0 AB"); Huh. It's kind of odd that these expected results have two consecutive non-breaking spaces. Is this really expected? > Source/WebCore/dom/TextEvent.h:39 > + InputTypeComposition, // input is done by IME, so whitespace characters should be preserved. I'm not sure if we should mention about whitespace preservation at all here. That sounds rather arbitrary. > Source/WebCore/editing/CompositeEditCommand.cpp:427 > + int newOffset = startOffset - 1; > + if (newOffset < 0 || !isWhitespace(text[newOffset])) > return; > + startOffset = endOffset = newOffset; Why do we do this off-by-one adjustment here? > Source/WebCore/editing/CompositeEditCommand.cpp:435 > + int downstream = std::max(startOffset, endOffset - 1); I don't get this -1 either. Could you explain what they are doing? > Source/WebCore/editing/InsertTextCommand.cpp:184 > + if (whitespaceRebalance == WhitespaceRebalanceSurrounding) { > + // The insertion may require adjusting adjacent whitespace, if it is present. > + rebalanceWhitespaceAt(endPosition); > + // Rebalancing on both sides isn't necessary if we've inserted a space. > + if (text != " ") > + rebalanceWhitespaceAt(startPosition); > + } else { > + ASSERT(whitespaceRebalance == WhitespaceRebalanceAll); > + rebalanceWhitespaceBetween(startPosition, endPosition); > + } You could use switch but I guess that's an overkill for just two values. But I'm quite surprised about 'text != " "'. Shouldn't we also be checking for the case where text had 2, 3, 4, ... whitespaces? > Source/WebCore/editing/InsertTextCommand.h:37 > + WhitespaceRebalanceSurrounding, > + WhitespaceRebalanceAll, Mn... I think these should be RebalanceLeadingAndTrailingWhitespaces and RebalanceAllWhitespaces respectively. 334252 21 78929 morrita 2011-01-14 05:15:52 -0800 Created attachment 78929 Patch 334266 22 morrita 2011-01-14 06:02:32 -0800 Hi Ryosuke, thank you for reviewing! I updated the patch again for addressing the feedback. (In reply to comment #20) > (From update of attachment 78794 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=78794&action=review > > The change looks much saner but I still need answers to the following questions. > > > LayoutTests/editing/inserting/insert-composition-whitespace.html:52 > > +test("div", " AB", "\xA0AB"); > > +test("div", " AB", "\xA0\xA0AB"); > > +test("div", " AB", "\xA0\xA0 AB"); > > +test("div", " AB", "\xA0\xA0 \xA0AB"); > > +test("div", " AB", "\xA0\xA0 \xA0 AB"); > > +test("div", " AB", "\xA0\xA0 \xA0 \xA0AB"); > > +test("div", " AB", "\xA0\xA0 \xA0 \xA0 AB"); > > Huh. It's kind of odd that these expected results have two consecutive non-breaking spaces. Is this really expected? Honestly, I have no idea. This is the default behavior. > > > Source/WebCore/dom/TextEvent.h:39 > > + InputTypeComposition, // input is done by IME, so whitespace characters should be preserved. > > I'm not sure if we should mention about whitespace preservation at all here. That sounds rather arbitrary. > Removed the redundant part. > > Source/WebCore/editing/CompositeEditCommand.cpp:427 > > + int newOffset = startOffset - 1; > > + if (newOffset < 0 || !isWhitespace(text[newOffset])) > > return; > > + startOffset = endOffset = newOffset; > > Why do we do this off-by-one adjustment here? > I have no idea here... But I tried to sweep out one-by-one tricks around here and tests passed. > > Source/WebCore/editing/CompositeEditCommand.cpp:435 > > + int downstream = std::max(startOffset, endOffset - 1); > > I don't get this -1 either. Could you explain what they are doing? Purged one-by-one. > > > Source/WebCore/editing/InsertTextCommand.cpp:184 > > + if (whitespaceRebalance == WhitespaceRebalanceSurrounding) { > > + // The insertion may require adjusting adjacent whitespace, if it is present. > > + rebalanceWhitespaceAt(endPosition); > > + // Rebalancing on both sides isn't necessary if we've inserted a space. > > + if (text != " ") > > + rebalanceWhitespaceAt(startPosition); > > + } else { > > + ASSERT(whitespaceRebalance == WhitespaceRebalanceAll); > > + rebalanceWhitespaceBetween(startPosition, endPosition); > > + } > > You could use switch but I guess that's an overkill for just two values. But I'm quite surprised about 'text != " "'. Shouldn't we also be checking for the case where text had 2, 3, 4, ... whitespaces? My guess is that this is for handling special case for typing the space key. Updated patch generalized this though. > > > Source/WebCore/editing/InsertTextCommand.h:37 > > + WhitespaceRebalanceSurrounding, > > + WhitespaceRebalanceAll, > > Mn... I think these should be RebalanceLeadingAndTrailingWhitespaces and RebalanceAllWhitespaces respectively. Sure. Renamed. 335169 23 79131 morrita 2011-01-17 00:00:57 -0800 Created attachment 79131 updated to ToT 335430 24 79131 rniwa 2011-01-17 12:00:45 -0800 Comment on attachment 79131 updated to ToT View in context: https://bugs.webkit.org/attachment.cgi?id=79131&action=review I was looking at trac logs and found out that enrica attempted a fix at a related bug 30946 (her patch was rolled out in http://trac.webkit.org/changeset/55271). Have you taken a look at that bug? > Source/WebCore/editing/CompositeEditCommand.cpp:398 > +static inline bool isWhitespaces(const String& text) How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? > Source/WebCore/editing/CompositeEditCommand.cpp:419 > +void CompositeEditCommand::rebalanceWhitespaceBetween(const Position& startPosition, const Position& endPosition) "between" is kind of misleading because you're extending positions to include all surrounding whitespace. How about rebalanceSurroundingWhitespace? > Source/WebCore/editing/CompositeEditCommand.cpp:422 > + if (startPosition.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode()) You need to do the same check for endPosition. In fact, don't you need to assert that startPosition and endPosition point to the same text node? r- for this. Maybe it's better to move this check into caller and have them pass a RefPtr to the text node, startOffset, and endOffset. You don't need to check this condition in InsertTextCommand::input for example. Although if we're fixing this function to consider surrounding text nodes, taking two positions might make more sense. > Source/WebCore/editing/CompositeEditCommand.cpp:-421 > - int offset = position.deprecatedEditingOffset(); > - // If neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing. > - if (!isWhitespace(text[offset])) { > - offset--; > - if (offset < 0 || !isWhitespace(text[offset])) > - return; > - } If you make the above change, then we can move this optimization into CompositeEditCommand::rebalanceWhitespaceAt. But I'm still not sure that'll make sense if we extended this function to walk surrounding text nodes though. > Source/WebCore/page/EventHandler.cpp:2656 > -bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab) > +bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab, bool isComposition) I really don't like the fact this function takes 3! boolean arguments. Would you mind cleaning that up in a separate patch? 335655 25 79240 morrita 2011-01-17 21:27:22 -0800 Created attachment 79240 Patch 335656 26 morrita 2011-01-17 21:34:41 -0800 Ryosuke, thank you for continuing the review! I updated the patch. (In reply to comment #24) > (From update of attachment 79131 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=79131&action=review > > I was looking at trac logs and found out that enrica attempted a fix at a related bug 30946 (her patch was rolled out in http://trac.webkit.org/changeset/55271). Have you taken a look at that bug? I didn't notice that. But I tried tests under fast/form and they passed. Fortunately, the change looks orthogonal, at least conceptually. > > > Source/WebCore/editing/CompositeEditCommand.cpp:398 > > +static inline bool isWhitespaces(const String& text) > > How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? > Looks nice, So Replaced this with String::containsOnlyWhitespace() > > Source/WebCore/editing/CompositeEditCommand.cpp:419 > > +void CompositeEditCommand::rebalanceWhitespaceBetween(const Position& startPosition, const Position& endPosition) > > "between" is kind of misleading because you're extending positions to include all surrounding whitespace. Renamed to rebalanceWhitespaceOnTextSubstring() with changing signature as your feedback below. > > How about rebalanceSurroundingWhitespace? > > > Source/WebCore/editing/CompositeEditCommand.cpp:422 > > + if (startPosition.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode()) > > You need to do the same check for endPosition. In fact, don't you need to assert that startPosition and endPosition point to the same text node? r- for this. > > Maybe it's better to move this check into caller and have them pass a RefPtr to the text node, startOffset, and endOffset. You don't need to check this condition in InsertTextCommand::input for example. Although if we're fixing this function to consider surrounding text nodes, taking two positions might make more sense. Good point. I extracted the guard code and invoke it from call sites. > > > Source/WebCore/editing/CompositeEditCommand.cpp:-421 > > - int offset = position.deprecatedEditingOffset(); > > - // If neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing. > > - if (!isWhitespace(text[offset])) { > > - offset--; > > - if (offset < 0 || !isWhitespace(text[offset])) > > - return; > > - } > > If you make the above change, then we can move this optimization into CompositeEditCommand::rebalanceWhitespaceAt. But I'm still not sure that'll make sense if we extended this function to walk surrounding text nodes though. > I'd like to keep this code removed because it will pull back off-by-one tricks... > > Source/WebCore/page/EventHandler.cpp:2656 > > -bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab) > > +bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab, bool isComposition) > > I really don't like the fact this function takes 3! boolean arguments. Would you mind cleaning that up in a separate patch? Agreed and filed Bug 52608. I'll do it sometime soon. 335663 27 rniwa 2011-01-17 22:11:38 -0800 (In reply to comment #26) > > > Source/WebCore/editing/CompositeEditCommand.cpp:398 > > > +static inline bool isWhitespaces(const String& text) > > > > How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? > > > Looks nice, So Replaced this with String::containsOnlyWhitespace() Oh I didn't mean to replace it with String::containsOnlyWhitespace. That function calls isASCIISpace and that function doesn't return true for a non-breaking space. We should add a test for that. > > If you make the above change, then we can move this optimization into CompositeEditCommand::rebalanceWhitespaceAt. But I'm still not sure that'll make sense if we extended this function to walk surrounding text nodes though. > > > I'd like to keep this code removed because it will pull back off-by-one tricks... But doesn't it undo optimization though? > > > Source/WebCore/page/EventHandler.cpp:2656 > > > -bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab) > > > +bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab, bool isComposition) > > > > I really don't like the fact this function takes 3! boolean arguments. Would you mind cleaning that up in a separate patch? > Agreed and filed Bug 52608. I'll do it sometime soon. Great. We should probably fix the bug 52608 before fixing this bug though. 336326 28 morrita 2011-01-18 21:01:03 -0800 Ryosuke, thank you for reviewing. > > > How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? > > > > > Looks nice, So Replaced this with String::containsOnlyWhitespace() > > Oh I didn't mean to replace it with String::containsOnlyWhitespace. That function calls isASCIISpace and that function doesn't return true for a non-breaking space. We should add a test for that. I'm sorry but I don't think I understand what the point here is... What should happen? > > > > +bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab, bool isComposition) > > > > > > I really don't like the fact this function takes 3! boolean arguments. Would you mind cleaning that up in a separate patch? > > Agreed and filed Bug 52608. I'll do it sometime soon. > > Great. We should probably fix the bug 52608 before fixing this bug though. Fixed. 336700 29 79240 rniwa 2011-01-19 12:25:37 -0800 Comment on attachment 79240 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=79240&action=review > Source/JavaScriptCore/wtf/text/WTFString.h:331 > + bool containsOnlyWhitespace() const { return m_impl ? m_impl->containsOnlyWhitespace() : false; } So this function returns false for any string that contains a non-breaking space because containsOnlyWhitespace calls isASCIISpace and isASCIISpace returns false for 0xA0 for the obvious reason that 0xA0 isn't available in the ASCII encoding. See also: http://trac.webkit.org/browser/trunk/Source/JavaScriptCore/wtf/ASCIICType.h http://trac.webkit.org/browser/trunk/Source/JavaScriptCore/wtf/text/StringImpl.cpp > Source/WebCore/editing/InsertTextCommand.cpp:180 > + // Rebalancing on both sides isn't necessary if we've inserted olly spaces. > + if (!text.containsOnlyWhitespace()) > + rebalanceWhitespaceAt(startPosition); And don't you still want to rebalance even if text contained a non-breaking space here? 336995 30 morrita 2011-01-19 17:52:46 -0800 (In reply to comment #29) > (From update of attachment 79240 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=79240&action=review > > > Source/JavaScriptCore/wtf/text/WTFString.h:331 > > + bool containsOnlyWhitespace() const { return m_impl ? m_impl->containsOnlyWhitespace() : false; } > > So this function returns false for any string that contains a non-breaking space because containsOnlyWhitespace calls isASCIISpace and isASCIISpace returns false for 0xA0 for the obvious reason that 0xA0 isn't available in the ASCII encoding. I realized that containsOnlyWhitespace() doesn't work. What I'd like to discuss is your first feedback: > > > How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? Could you clarify what the point here is ...? 337012 31 rniwa 2011-01-19 18:13:53 -0800 (In reply to comment #30) > What I'd like to discuss is your first feedback: > > > > How about containsOnlyWhitespace as in JavaScriptCore/wtf/text/StringImpl.h? > Could you clarify what the point here is ...? I meant to suggest a function name. Nothing more. Sorry about the confusion. 337079 32 79545 morrita 2011-01-19 20:24:54 -0800 Created attachment 79545 Patch 337082 33 morrita 2011-01-19 20:28:32 -0800 > > I meant to suggest a function name. Nothing more. Sorry about the confusion. Ah, OK. Thanks for the clarification! I updated patch for addressing #27. Could you take another (possibly the last ;-) look? > > > If you make the above change, then we can move this optimization into CompositeEditCommand::rebalanceWhitespaceAt. But I'm still not sure that'll make sense if we extended this function to walk surrounding text nodes though. > > > > > I'd like to keep this code removed because it will pull back off-by-one tricks... > > But doesn't it undo optimization though? > So recovered this in the rebalanceWhitespaceAt(). 337089 34 79545 rniwa 2011-01-19 20:48:01 -0800 Comment on attachment 79545 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=79545&action=review r=me provided you respond to the following two comments. > LayoutTests/editing/inserting/insert-composition-whitespace.html:65 > +test("div", " ", "\xA0"); > +test("div", " ", "\xA0\xA0"); > +test("div", " ", "\xA0\xA0\xA0"); This isn't right. Why are we having 3 nbsp's here without any regular spaces? This might be a bug in stringWithRebalancedWhitespace. It inserts nbsp at the beginning and the end AFTER replacing twoSpaces with a pattern. We should probably putting nbsp's at each end first and then replace two spaces with the pattern. That could be a separate fix but we should definitely file a bug, and refer to the bug in the test if we're not fixing it in this patch. > Source/WebCore/editing/CompositeEditCommand.cpp:439 > + String text = static_cast<Text*>(node)->data(); Nit: I think there's an extra space here before String. > Source/WebCore/editing/CompositeEditCommand.cpp:446 > + rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.deprecatedEditingOffset(), position.deprecatedEditingOffset()); We should not be calling deprecatedEditingOffset(). Because we've already checked that position is PositionIsOffsetInAnchor, we should be calling offsetInContainerNode() instead. 337183 35 morrita 2011-01-20 01:19:20 -0800 Committed r76215: <http://trac.webkit.org/changeset/76215> 337184 36 morrita 2011-01-20 01:20:58 -0800 Hi Ryosuke thanks much for r+ ;-0 (In reply to comment #34) > (From update of attachment 79545 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=79545&action=review > > r=me provided you respond to the following two comments. > > > LayoutTests/editing/inserting/insert-composition-whitespace.html:65 > > +test("div", " ", "\xA0"); > > +test("div", " ", "\xA0\xA0"); > > +test("div", " ", "\xA0\xA0\xA0"); Filed Bug 52781 for this. > > Source/WebCore/editing/CompositeEditCommand.cpp:439 > > + String text = static_cast<Text*>(node)->data(); It looks OK (I cannot find any extra spaces.) check-webkit-style should complain if any. > > Nit: I think there's an extra space here before String. > > > Source/WebCore/editing/CompositeEditCommand.cpp:446 > > + rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.deprecatedEditingOffset(), position.deprecatedEditingOffset()); > > We should not be calling deprecatedEditingOffset(). Because we've already checked that position is PositionIsOffsetInAnchor, we should be calling offsetInContainerNode() instead. Fixed. 337192 37 webkit.review.bot 2011-01-20 01:57:55 -0800 http://trac.webkit.org/changeset/76215 might have broken Qt Linux Release The following tests are not passing: editing/inserting/insert-composition-whitespace.html 338803 38 79886 morrita 2011-01-23 17:38:39 -0800 Created attachment 79886 Patch 338804 39 morrita 2011-01-23 17:44:46 -0800 Hi, Ryosuke, can I ask you to rs+ this? r76125 was reverted at r76226 due to chromium test failure and the test actually broken. And Mac DRT did't catch the error but Chromium's did: + textInputController.setMarkedText(compositionText, 0, compositionText); should be + textInputController.setMarkedText(compositionText, 0, compositionText.length); After this change the test passed on Chromium DRT. I'm sorry for disturbing you so much on this bug... 338824 40 79886 rniwa 2011-01-23 21:28:05 -0800 Comment on attachment 79886 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=79886&action=review > LayoutTests/editing/inserting/insert-composition-whitespace.html:37 > + textInputController.unmarkText(); > + confirmedText = node.innerText; > + > + shouldBe("compositingText", "'" + expected + "'"); Why are we storing confirmedText here? Don't we also want to check the value of confirmedText? 338843 41 79895 morrita 2011-01-23 22:39:18 -0800 Created attachment 79895 Patch 338844 42 morrita 2011-01-23 22:40:26 -0800 (In reply to comment #40) > > Why are we storing confirmedText here? Don't we also want to check the value of confirmedText? Oops, this is a junk during a debug... But verifying the confirmed text looks reasonable. So I updated the patch to do it. 338845 43 rniwa 2011-01-23 22:48:46 -0800 (In reply to comment #42) > (In reply to comment #40) > > Why are we storing confirmedText here? Don't we also want to check the value of confirmedText? > Oops, this is a junk during a debug... > But verifying the confirmed text looks reasonable. So I updated the patch to do it. Ok. r=me. 338846 44 morrita 2011-01-23 22:53:56 -0800 Committed r76482: <http://trac.webkit.org/changeset/76482> 338885 45 webkit.review.bot 2011-01-24 00:50:14 -0800 http://trac.webkit.org/changeset/76482 might have broken GTK Linux 32-bit Release and GTK Linux 32-bit Debug The following tests are not passing: editing/inserting/insert-composition-whitespace.html 338967 46 rniwa 2011-01-24 06:08:52 -0800 Test disabled in http://trac.webkit.org/changeset/76489 on GTK due to the lack of DRT feature required by the test. 4164 2005-10-02 20:42:30 -0700 2005-10-02 20:42:30 -0700 Input method for testing various issues Roman Input Method.component.zip application/octet-stream 43071 evan UEsDBAoAAAAAAPO1QjMAAAAAAAAAAAAAAAAdABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVu dC9VWAwAQ5xAQ8qbQEP1ARQAUEsDBAoAAAAAAEm0QjMAAAAAAAAAAAAAAAAmABAAUm9tYW4gSW5w dXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50cy9VWAwAQ5xAQ6mYQEP1ARQAUEsDBBQACAAIAEO0 QjMAAAAAAAAAAAAAAAAwABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50cy9J bmZvLnBsaXN0VVgMAEacQEOemEBD9QEUAKVTT2+bMBQ/L5/C49zYZFKnrqJEa0gqpLRFCZ20owev YAVsyzya8u37CO2kJmGXcQO/318/gvlrXbEXcI0y+sabcd9joDOTK13ceE/panrlzcNJ8DV6XKS/ kyWzlWqQJU+363jBvKkQP62tgC1MbVsEJ0SURixZx9uUEZkQywePeSWivRZiv99z2Y/zzNT9YCMS Zyw47NbEOiUAzzH3SG+Q+eSLvuYqw3DyJdhBFy5Wt63OK4jgBSpja9C4gYKmA9Ef01SDjlKES10Q WRmI9/cj/PIVshblnwqOgRtTS81iTcHYPWBp8jGOO8BYP5vt4fA8zUDwkYjNfO7L2QX1ZjunihLZ 7MfV5fSb71+yjVS6ljtwbAMNSJeVZCLjY+JxTtHVswJ3rEwtc/dBxg8+Dmn+HaZPElHRZFO67tdg +Jj6O/fH8A+y/o8qE5ntZAFpZ09IsOzLPQ/blsbhu9fz1zA0PopXhZbYuhPROT1joJFueqUTyJbu 0rQug2alKrin3wDyv0B0LQjabzEseCAO6x9O3gBQSwcIRq6D9pMBAACeAwAAUEsDBAoAAAAAAPO1 QjMAAAAAAAAAAAAAAAAsABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50cy9N YWNPUy9VWAwANpxAQ8mbQEP1ARQAUEsDBBQACAAIAPO1QjMAAAAAAAAAAAAAAAA+ABAAUm9tYW4g SW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50cy9NYWNPUy9Sb21hbiBJbnB1dCBNZXRob2RV WAwARpxAQ8mbQEP1ARQA7L0LfJRXmT/+zmQglIZLgXJNYYABEm65J5MLNDcggQCBBAiUNgnJhEQm mTAzaYMb2qFSRZdqWFHpLtSorVatLq51rWt1o7Y/27W6Veuul1rx3mrd1bWudbct/+9zzvO875nJ JAPd/e3/s/8/0w7n+577ec5znss55828/pv/+IZlWbMs/ZmC73WWNakN4T34uvD/M62tzZtamq2E T78ZpuM7Cd/J9NDaGg0MRp2cY8vfMGRZW3N1aLklNmZ5jDL9PR2RY72HQsHWSHTg0Ng6bnnYCI06 1Bjo4zPqoCryktQxalnXt+lQ9V/6IXV4W1s7Qn0RZzBj6zjs1eNWoctK8kEdkWi4p+/w+HVkoduP 6tAZi4lbW4M90UC4Pegfr47QJfwzn8M0I8FjYJ7P2qrmKrMszeFMI1TzmWbZ89nZHm03x5OsvFXB odF/l1Gm81iwc8I6UJ7mToUmDYwyHV0mIZPUUYs2R3Vo1pFm1BFsb2W+6o+Gk9QRBr1cQR3GjYVo couuoy84cR0RIkQGh+ZYiJ5/q+s4FInEjW1MHbQ2MvnBrMOVgP2trQ31O7Ztqq23+SGG7zMcfgXr TM2nlPPovlkt+M6vKd/8FpUNLeQ0HYtEA705DT2Hwu3hYzmbw+29gTtC4SORnJr28KFQ3/ouicnZ GwhHerAycqo4TddN9Xba9c7SrU5UbygcaAqEb+/pCETGqd3I4bSRq9vY9JR1kNsYiIRzgj2H6Ns7 uL5qPdit55Cdv9DO3+JyJ+bX3VtfbZQhemMtncR6TH+nZf3krGW1nUfc9fg28lRe1l/qS3oOTaE1 7udHF/HP5yzr+Wf0nBLBlXy99rn2ufa59rn2ufa59rn2ufa59rn2+f/JZ2iK+8PV77cmHT/l/vDQ lLQPH491DG44bVknTt/26PG3p314KCNNnod2xDxeO3+3zr/hCNKO3Hb6eE/ahyX97790+ZVhlzXl 7NLLF4c2Xj84fKfVPXy/FRz+otUfu80KxsjPi1lW1f1WoTwPpaUN1llbvxf/vDM7/rlhP209EI4t hQeDNqgPn0d7O2KWbvsDl1/Wbb8+TG1TX+96wf3h4Ttdp4bvd52m8sOLrUq/dfnyxcVWRQU8Jn91 e6aKRzv87JXnOqv0pqG2RYNUJoYv9bvyfqshtth1Svdp+wpKp7rqrB37k+T1jiBtyJ1eSG3edbeK ywC+OSFfm267eXSExmulF+r6t02iOqVfZh8NOmaacbHbXKd131U7lQntdFdYHb1tVmcE8bUYpwth nVmex9U7dJzbPbQIY9t2nPrhv82qvetDvx4c8qQN+kcs19Dm2YP+S5ZValF72+5LMv5CHteX1biI DoutBmpjqHY21WG1PXjZkvoTynbq9i8HwRsXON0f4/J+5Gk7edmKfdHy+0ep/fo/xe60/Ah3xdPD zj9paNNsjG3Lp8a25fJxPx83+tlo9NMF/iulOH8b0vX40ebWFcb8+Jz5GbceN8b6u7H11P/QqCfr CupJQz0fTVLPe4x61l5BPR7U056knu1GPblUTyIfg+/mqDibV7fcZ8zdzDrL/5pJ5zHrFmvVXrcJ MsNZt1Z3nXXzmTpr43Hdl1s749fqrd3ynFomXE6QCdYplge1GPv8OmvzsUS+wBgfAv9UxqpR92Lr 1LDmp8oTy9C2LuvnsALpflpLCCsQQkYAg/eGr7M8w/XWFKmH8p9zWxnmM+qdSc9v+aAeV6z64Kuy FonP0bdbVd9usuZQ38Dnp2iu6qy6J3idn6VxIK32auhM9EWZbh6rH33oVmN1W3M4br4Zp+e57ndU huf8nnHp7rQ1kkB35qtbhlHPoJZV5TcZ69vPPDTfT/yl2il/MEn6nFNIb7Ymb9R5ZgeSl604dgVl n6C0CXXLBDyqx3Ng1NEbZfdQm+PVR3WhnlGegxbox4OgcwvxFcKDNPd3vR39vGCtpXh6Rv/nSxrF MS8eRL/nC/9PVD/0bxvytqBM212xmVT3TDy3Ub3goSxOO6jSzqu0g5yWQWmqfXxlTFc612h7CG3H FN+DPxWt3HuDaGvoxEYrJrLo+IptmIe5NyF+MJ7fNruMdTkkawJyv3Lb5csLOG0IabH4tNdF/sSo Tqatykfya8iyVjZbf3z93HVYPygP3Wb3BWXbjX541PrmZ9TjMdKmDF3nnqN4S9ddoeh3v1qn1K6f ZWW3XQZtYb48Rp9ialzWzEbIiilEn9Jle4dO3An63Kb7TuVOQWYQvx5fvm3weOctg8c3NQ0OTSb6 zHmR9DjRFjxdKzx9BfIwN2GuXsBcvcTz1AIZ81KdVfsE07BZP1f/gZ8b0edmhCMV1pFAm3XsEPo5 wmPNrLB6Q23WQMSJc5+tsyY/gudGv/vy5TUxy1V1YfIDoPtBqrcidqSj7WSos2Kkt73twcN9pM9h V3jIrhi6jsZYewF52zBHnU7+7nDFSPOmtgdbmjm/C2MdHKonHV/bi/zdnLc3Rd1VyBvkvANtJ/t6 KkYGom0PDkY5r0X1lnppXdfeyONvYLlP8r6BZcp54CDLTZJtQc2/Ne1chuTzuO0MpaMN1Ik1UYsy n5B2jPpztW7Y9xLzUbDZeuXOoZrZg7H7IfcnUVuVA1yuTnQBdOcHaJ1zv2Kav5ovgVc6Fa9cnzYo mGS98BfVR/Zd7HWrrs6adQ/J/Gbryxu7wWvNVvrrXF+FWRZje4H0EtlZseep3GRl1xE/QY7M1PZc w0HIW6qvjuvIQDnkrb6Px/fb8g9aFzW/bVzxqjVlGG20UBvfXYz421TaI0NvWqTmehjP4N1Hnvqi dfFVuBpkn6p27m44CTnw0vGVGM+WpsFXvdYwzSP0AWw5D8m7RtDpAdT3QM7dlhs8GkXcA+jTZOBB jnehf1PqrLRXwCP9eu56g+CnjoqRXbVtD/ZHx/JTFdl30SvjvaoneD5+C1sqrGwpzAdwP2H0IZo4 H3XWzD+hfrLFh0ohP4nmmP9+ZY9DHgxtgSzNIlm6/EWiveadNL/StYvBo7dZ5/V4LS/iziM9jfiC 4zFeF/gvbYrWaXuIH4dA/5jiFfDacd+2Qc1rM4+izAvxsrpyjymrVdsX3I8RJvuGZGPVBffDWgfs manLzMzmtrwTtDUJdUSbrb+7M4H/Zip5qvwvyCTuj8hKzpMl8Sy7X0iQ3VR2jhHvYXtuiGlbQX3Y dvlPC4SeZPtSGukabS8vfA/LYPC562keT+7445lRhHwP6PWw/QGMbwDPZzGvd18Zj918r+abPZXg lZOKb9yKb+4mTDxDeky3Nf0p1HsK/HIa/DLMY7p7LL8s/ZzDL64pyt5dbJ0DXc4xv4wi7hzzyxyO p/XxOOj3XZ5TmoPTokfR9vY3OCf+JHNCPHya++/Xc/LHe8afkwUuZ04sP/evLb5/0z6BtExO609I OyNyZ0Kb2tGnMba3ztm6ATSKXx8bimwaX7CejVHe2OXLur/zd9myG+UMH6NS/BSy/ZUuBh4mHU2Y bEHHxziX4GOcS/Ax1DP8jDlj+1Zx39Ah+Pjs10Cuik9zkH0ash/JTiWbsQHpjSRrY7Qf8kWrETb6 90imX63/UWflnLkCW/kZym/vP9Xp/aeKrbTOdtaJrzSBXdqfYOs8NBRbPgi79OLw89Yj4JGH2e7Z x+FeDvdgTBdJ7mBdRYkXSPac03R/SHgT4RSaj+HbFH0eiqdreZXYTOCnh6kO4EGSx+CDjKoLaj4J X195fnIFY6wxT52NLyh7kjDWW9qj0F9SxoPnnzGegjXQiTQ/P98EPXbSxheUvCc8DWVeYpwJed+P Mh5+XoK0szY+n9bA+C7U/TD0wnPkC4iPT/yg196kk7zW9okfQfwyTPYa7APOn0m8Q/af4iWk+d1q /6kzkWbgqTbwFMZSeo+dRvVpu/khg6encLt7OdyDsbwi/WI7nPrTqHTP/Z7nkvSze5j2Gdl2U+PC M/ctmKRv3ehbsM7yv2j0rfsK+3bQoJ/XoZ+HbPdmkY+V93sKpZ/x8VahU0bRn/yyBrKtSA4wbZXN SHIE8TY/Jshfr/IrUdeQW8nbOqOuTMZ1CXkaaD/DbgNrCLSoAy0atl3+3WuOHE4blHGDX4J2HdVu motG3gP1xc9LWsL408Ybf4Ux/vkyh0PWLOpfrUMHNXe1LCcrr4IOlTz2WoMOlQl5avFca7eh6VAJ OtRuu/zbPzh0cPc7dHDTOmhke6jF5kGUFX2Fsp8zyhYaZbOMsplmWbTbSLIXZY87ZV2vOGVdLzll XZekrMg4qgN2zQbke5zjNiL/I0ybk2Rn11nFJwydRTbwI3pPquDtsvftb6P90UKlP0bUvopH2Tt6 jyr/hKGjc0UG4vk6tkG5f7SPZfePwo3Iu9GZe5dXyqLNfu0r7KR1acG26Y/fqy3olT0fbSc1nFVl r5+8UYVTlb+i+OGEW+lCR5YLhkw3fW34M/7j6TWDjo856agpGwQrGXE36vkg9PHzZMcULuU+PGDm Vzaaos+kbL1vXXQfpas9gXoIceKv61LLFGOd7DPWyUw9t39sBx+vRdpeg+cz8bxH+WzMf2yTflPq eCP7YOzndZ9SfqLdVq62hbc8RuNiPEpzRuNH2y7ddtFx6meSvI8nybvrv7lvXqO9tUZ7bt1e4Y+N vpl5c5Pk/cyV9k3tvSbsrep1VbgL89LNdiF4eXrpRPbR1dWd+574uqf98CrqHrN/Pny/dRo21LCf 5Mad1umK2Lp1bSfXrasY6e5oe7C3k/2W6Y7fkv+dsXuxbrI9qsl+qrBq9rRZjeRDtOh9I9dDCXGV sGMyEdfQZu3cZ+SD3nJdrLCa6tqsWqO89ZCO22bGwZ93nXT2h1fUJ9kfzpX9YfEtkO9Lko/0DJ5f nHjP2ve7selKhtn7ztsuv/op9CXD6MvXr6wvKzfF92Vl78R9WTGQJP1sQl++hLpimrc3PWmcLwbN OJ33tTyj/YYkZfxJyuw3ysz3W9/rY5whOOUe/InLv+Xz3fh95vtdQ8NfdMWGn3edHH7dderMYtfp Mxtdw2duc50dvtM1SGdbddYabt9V6cdX02Xtg0M98Hn4fApr5LLq9wdLX6V9I/gmP0feIZSp1fqm JpfPWGudvWYX78us+ROPr0Ly0nkO4hXfsK+k9hKwLm5G/NsT5wR0a+SyhbwHBvqs/tLQ0KJBjde/ R/rr7HOVzaQ673rrTwePr6I+Zy/VeXPqEVYgrIqjJ2iYxHcds2+vabZ6halHY9VVP6N++VX9a7Nl XLof/iepH9B56EPWhSvwAZOeFYj/SfveI27IVd7b8FfDx71N2al1a2LWjKoL7qeRp665cmaZ5jWr c6hy1pyYfTaIZ9iFkDvqbgKqfRpfukMdxLfSstyEX4H6zMK3Bd9T+D6K7wtIy9Dp7goO9Ro45G/b dvn1p2J8hhW7e2Mm5Ohv66z0Cw5vuys572nkvYC8Q5h3nf+DG33+0TTK/3MjP++L+h9D/l6Vz71x LbXB57EXkX+Dk991ifO/hPwbjL5kIG8u8t5g5H1E5y3NRN4bEvqSxX0x1qXrJOeHTf/ajxPyTwHf Uv5sI38z5x9C/k8l5J+v80/+k5Hfx/kfRv4TCfm9nP8pQ068zPmfQ/5dCfk9nP8+I//jCXnm6DFO HjDyjOg6yzIg815LyF/I+U352s/5K5D/6wn5c7kPNxr5ef7LupE/cf5n6vyTfm7K7worZrVh1q9I Bk6wfuy1A5+d5VuAbW+X8r/l7PXustFtl5/7ZrJzUcqz7fKlp8y0q+nPmHUs+8CwSf3W5W/wmGVv Q9mj0t9tl398K9FL2yrZL8p5H2TlBWMcdF4AfvvRUxP1zTwDZT+lBb5Ji7rDoGUJ+VVZWpZYjWRH Q55kDVkzc9FHOndd21/515e47z56bq5MF/t6CvmHbHvP1/rMxhnsS82Hfp1v2tPJ9rQgYFxXcqaa RD4Oib4lGwHy2g06qf13SuPzYTOP3BMw57tW8rA+Qx2rz+Cb1J5QebVvpPyRi2619yHp3X7LZSl/ kNLIJpS6SX6zLeLcO8n+aJI2fNIG2dkj1/GdFfhCpAcuXue0R/a7OT725e2xwCai/Zkh+35Ial55 hulcZ94zu5o8E92x0Pz9/ItvyJa3y//o2BspT/fvpA7IoiDW2Z/e6J4rjR31Nei912K5j9BANH5j NHnhC/81mrz40asoH7eW5F4Cn/fQWdqQ9slX/cbmTeSl8wbElYp9p+2rVR+NMU+/kXaHn7dOGm3T XkuM2z6a0PYQ3XFD/IKE9rOvvP3/bIzXFZ4nh+/3PD00sgZ+secZ7kdLbLHnaTmT1fLMTuvU9p9f 9ls6qd2KWDTQdnIwSr7khpst68nswn7l66n9kVWyvlucPc908IrnSfZLqV6ax07U1831RdpOdvRU jHT0tj3Y3wNd6aHzKdR1fGxdkx9B3+6EnAmyvOnjuoJOXZFgxUhPX9uD0aBRV16SurrpfFedrTj9 4/375SeMOw+NzdaUijUxD+1XZcoz55N7RnYdkGFzDD3YOGzfE/Oc0mcqntMxwrd5TtM5C3RSG+0n xOg+EN3Xed5qhhwjvdRpt1Uzm8cWHZT7A3SOF3td5ZXz1xbaE6PzIfZ5aa+4Wfdz8Rln3JP6ac79 lZcv872VDN1Pjz7DdBc9omWG5+ltl//tBOWlPiC9X9Pa0+/Qugv9CYbaHuw77NB6xRNjae159RT4 yvBnYRdYsH0850l30j2LMxs959HWecxpwwjd94Tsb3ZPqSBbn/aR/eQXaB9b6qe96jrKSzopof6H KY31gNuY35k0FkpD/GTJg/JTjfwZQnfON9PIN8eui2jm1vcbSpcVPU55ThyithBW67pP6PM4Oqua ae4rHp9cM0h3P7Zd/t3SExutzvHGS2U0nQf6K0ai4bYH24/xvNeBDrcadK7TtMn8qEPzNOKxJ/V9 I+4zbCCaT7535EmSPsVIn6Lti5uEv2pFVlTC99Y87okatPUwn5BN6rm42DOk9syRx7ABptZZSx+k eL4HVUtl7Xuqps4fW2/UWGMeI12dH0vbZrxjg9K+vecc89ok8No5jOXcBH10XU0fJ+hPVHgpNV28 915Jm3I+LD5N6aGiZ+meRWm15fQZ6dRmsxu8RP5w5dY5J9Q6GD899hPFs+Omw36eqvpDdw06wMe1 4ONJ4ONflDMv/8se6gefkVTGjYH9eapXyaYLl427St7v0BpIzJ+4FiTdWRPdPeaa0LJnab2xJrj+ zO8Y529R5ts7jXm520gvZBl3pyPj+vvQzmDbg2G6yzNVt+P98VgZp86mOnlMJ4z0TuPsjtOXfIl1 K+35X1RtKR8tbxQ6oKXOmreL6v2v7NGSnoe9cXb4devcmcXWefgmw4YfcVatCW3HnaP73YzPKxvA bfMZ72vlzmcboCLBBvBoG2DtKccGWJLk3q6bfI5Thg1AZ24VqK9yYhtgSZJ7vK5XuOxpo2y/cW9G ym5IUvYxLjvslO3srRg5BB0WInvBxWVdScrGYvbe6uIPJElv47prue5w28nwYUM/Ovd5FJ0WfcHc Z/O7170a47LqrssmupP6a5dRP61LouNZ9m2orTqnrWDAGIe6G2m0tSuurer1GfBT6+SOknO35ldn zH0ByUN8cU63WavvI1hRbr/BaT8aGn+sC78ZP9b1dC+gIX6sv7oxbk8COpHuOhJ/yniNdcTzkHmM 61srdcE3+HrK/YsJ9kANf7tS8/7a5/Sebua9dC/R3od11kAa3TMsJZ9enXdkJru3TvM2aPA/2YSV xnoah/8zk91jJxlF8nXIKRvuGGuHZSbhf4VVWdoPccrHzR2XX/RaivJTJra5Hf4ep3yGUz6Od3kN LjqepDzJWN7HX+S8P6DvYfuVrWbnTcsy2prv8Gl/NOkdO8Wn87ONvZQ5RvnFTvm4sSaUn5fsfGgO 70mQXM3k+wpDfF8r02jD57TRFR1/Lc27J0UbyxLaWGa0sdagw5srRrp64Et0JmljaZI2Ms19KG4r K6Etk+aF8W11YjwDh7itKU5bcz9zhW3lJrSVa7S10ZCD3RUjkW7wUpjbchttJTv3S9ZWRUJbFUZb 1UZb7eO3deMPr7CtyoS2Ko22DPkebR9/vm48eoVt1Sa0pe4XGnKV19a8pVdwlmOZsjPh3mKFtK3l 84rH5V0zrDHZZzffuZofu5PoMOftXO4FugPDZZ/lPt1r3KmvNe5/Ykzz5P2+CkNPSPmfUdvGORzd uxyj3+kcjt6Jo30W3c95G4w7LOodOsjrETkDpPs76g4/ZJV+F3Ledrm/z+9nvT4cf5efzmZH9Fhc PU7eeXvUHUy35+Kwvr9VN5Zm825IpBndJUP8ApZXdfDlK/V9Guc+mHFnj+l8+SGD5hma5rNvNGiQ ofeZZrsMOmboM8VZv6E6jX0Dn9aPqx6It2GXfbfOyjiDcbRx/tcnzr98DvLTnZVc6XPV+Hlb6O4Z 8ufF9H23FxC+cIV2snFXt6GG9qrBa17h2Yvq3ditFG5GnedoLpgX2/TZ542/uYo9x1iStVGXsEb8 9H6L5oe5cm9AnXUa/MLpru0G70t6N9cj76U0ctgse3scHqT3b3kN6HexPuh+gHwmes8F4/pOEt4S PjL740M/r0tcZ5z39YS8udxepb7nPCfJvQhV7rWEcl49777Tao8ZfCe2Kfo5bSyfztw/lp9nbpL9 kNTz9FqC/UfvgOCrfZ1K5174nBs43uO/zWXEz/4TPZcus1ynlM88eaMqRz5rNcW5KuX9Ledu/px7 VF433UvT6XTHkMJzbHP63UsV/ehuApex5VuddX1AyQviI5YP+h3naffaNGa6oVypptOMvKvYt27k dfIkbOGnh79oPQM/8llj3/rpYXpHQL8X8FTV/Wr+NNZ3lgk/WaX4xZXJz/+A57WMvwZ8GmkW9X/b 5e99gM58Nf5+HvAL2y5/K5l8fgb4GcaPG2tJ3cn0Ex/diTx8L1O/JzfrPtuHYbkucnvb5W9+B20N IXxPkrY6jbZajLYauK2GJG2t43jVzrbLv79P1h23C7k1K9tcP1dz/oF66J534GrPTVAugHLr3kC5 rjor7Q9v5JzFtgH0PdHDfOcx2fu+tYae8SfOqU0jprO+ZzLzCcf/y9if0tcbO64ejOumN0CPN8Em +fl/Az26NT080/576DHjMw49rq9/A/Q4gnFNewP0CGINf+eN6kTSw/w+xgjkywPnFqt3KUnv0n35 EdK7p/S+VWeCfrPfw9SyctGzjp007cUkelR0mTrLMXQrn43MkHsiZnoty1+L6Cu2mmlT8bl6o7oH oN+VbeB1PgVl2hPaOmikZyC9ykjnu3SL6J2OB0Arkt91/E5zg95fW/CCCusXvDC0Vb1j9WPDNhX9 22jYT6QLIW+uKxU6OO9cXrcixn8P4o3M2Thz0Rw/JwsrnTnJ2HMVc9Ki52Taj5PMCdngLYY8BZ0z vpdkbuTOQ/x80rvLTFusn3NEW+rrk8vmq3u+T1bPX1taSfM97Z4ro236DxHXbPhOzE/pT4ylefqn /is0hx4+P/EamP+0Q++pP7/6NZBxdBx6N8fT+/qeK6Q38/R82m89n0h3zdNzn9Q8PfdJzdMZ066M 7pMDY+k7eVcq+hI9h/g+w4a7Lav09ILME6ctK+e06u/JRPk21Dp7UP6GEeRTdPh1a/DMYmvozEYr duY266T9NyAO3Ug+2/ahoPztlAWZZ+5Wtmv3CeQ7gfwn6L1SlIe8jsbobyLR3YyEftLfXrL/ntKJ y78d6lzk8IBLvQPQSu+0+dut0nMusumuvxXYP3TnIpL7n6p4P+ZpCLL4zoVz/CfnnEfcBurPXV/5 /WD5B+c8dNcDv6Z8161Nw3jvRrt3/viTFEfpiIfddf12/1JrmPpE90WpX0Q7K8nH/JtQ9PegKO89 fz63whxDknRvinTPxOk3vpAi/ekU6RdTpJ9NkT6YIv1givTKFOm+FOlTJk6f81KK9GdSpD+SIv1c ivShFOltKdJrU6RnpUjPmDh99m9TpD+bIv3RFOnnU6THUqR3pkivS5G+NkX6zInTZ72cIv27KdIf S5E+kiL9ZIr07hTpDSnSc1Okz5k4/YZXUqQ/lyJ9NEX6AynST6VID6ZIb0yRXpgiff7E6TNfTZF+ KUX64ynSH0qRfjpFen+K9OYU6f4U6Zkp0q2J02f8LEX6kynSH06RPpwiPZoivSVFegr9PyOF/p+R Qv9PT6H/p6fQ/9NT6P/pKfT/9BT6f3oK/T89hf6fnkL/T0+h/6el0P/TUuj/aSn0/7QU+n9aCv0/ LYX+n5ZC/09Lof+npdD/GSn0f0YK/Z+RQv9npND/GSn0f4at/ze66D/Lqq7f3hSINgWCgY5oT6jP 29MH3BRtD0fLVnTqp019ncBTtV1eU1e1Y8um2rLEchEpElC5ve19Hd2hcH1ECjfVUIEI/frFptsD fdGyIyqoCbZHItsCxw6F2sOd3o7u9nBNqDNQtqLDW7FicKO3N9TZ09UTCEfKVgx6B/p6OpAIXDnV quqIDrQHvZGeNwe8PRHvmwPh0Fpvfzh0qP1Q8Ji3M9De6T0SODbVqmvv6wwG0C3V6Ip+75ZAVLXc 3NOLdrq867xqbFt2Nnt1l7aHBiKB2tAdfUu9/aGevuj6bhqPhrcTRKeoP1OtI81N2+v7Ij2dgZ1d 1aHOY95oN1BXJKAIgYcGdKOn7/CmzsMBoeCYMpurGhq8zXW7d+7ZUlcWXyfG2HN7oL6vfyBaFQ60 p6yeyu4ciF5VhxLGvad/6dQxtAi3Hz4c6ByHHFOtK+7z1GTjT8gw8RimWj19NYlMggxN6tdzwBje cPsdzYHBKMFIILi7ve9wYH0w1EF9Dgb6dBs1m3X+3YH+YHtHIK4C6uOK/etW9K5DiRV1ZSu2l61o oriId8X61REKwfreFfSbLQA1od7+UB8oVdsT6W+PdnSXlR2x43b2B/r0CpmaMm9NMBQJSOYrqLum va82dBX5+Zdn7BLj5d+O9dHUEe7pjzaAdk0D/f2h8IT56/t6oj3t0QBRnX/PZuoE/dneHAj39vSN KTBufsVQV1F/baA9WYmJxmtk3B7oG5iQnts39wwmdGX8vHXg4sb2YCAaDezr6esM3RHRMkCtrcb2 cHsvVaUWSxPkJqpuEB4d6O9sp9/FAv96cyGkEuTrWm/e2EiqvK6Hfk9L8b13OVLWebtsad6lhbG3 S2dqih4L2nIJY9ijmkxcwOFAZCCI4sHOcftO6+jY7sBh8JeS50YZWltGCq/x8eowxFNCHWME17h1 0JOWFwlVOAnGmLV6aAxFmkMJhZClI9S7Ptze09fbfiQQXr871Nvep9rZHoh2hzrXg2L1xAaBMOqa OK9lqRgvJIeUWd/eTz+iVeWNQhGFBqLeUEfHQBia6o7uniBkUvgYxuuNhrzB9gHoUhoBykKoqcKq /3v6oOwCKk+oA1On8jRBPAY6eeF6O3vCWO+h8DGocpKpKkuHMCuqqerzBsLhUNgb6vJGj/UHoA2v uifxY2/qDwSDNbQG6EGp/Sui0Xo1fdsh2WlsXf0QyNEuy9dQW92Ql09b0Zbzk1bOPmHlHA59yXYR 6VOaYVn+k5ZV/LJllXnx3IDnhyyraC3CpxE+ZlklqKW4BWmX8D37rkszLXz5t/LSn+Tfr1ttPCOv VWI8DwPsdJ676Xe8Coxn+u2wXOP5HMAS4/lRgHLjGX218pznHvrtuPXGM71rnm08U32LjedH4+vv +S6xu/P8Jvr9tZuc5yC9s77MeB4FKDKeX7H0b43xc29LfH295xOeL1nqXXh57vPF96evNr7/ff3x /e8jet44fv4QjX+F8XwWIGtsfvodxmvf/5nvtc+1z7XPtc+1z7XPtc+1z7XPtc+1z7XP/1sfcild lZZ1FL7uJAozdNj/Kocvcfgch09z+BiHD3N4nsPTHA5xGOTwIIcNHPp1u/2FHOZyuJbDLA59HHo5 zORwPodzOJzJYQaHU3hc3J+j3J+j3J+j3J+j3J+jFRyu5ZDHd5THd5THd5THf5Tpc5Tpc5TpE35M txt+lMNHOLzI4cMcPsThAxyOcHiew3McnuVwmMPTHJ7i8CSHMQ6HOBzkMMphP4dBDrs57OSwjcOD HLZw2MxhI4cNHNZxWMthJYcVHPL8hnl+wzy/YZ7fMM9vmOc3zPMb5vkN8/yGeX7DPL9hnt8wz2/Y w+ElDp/j8LscPsvhMxw+zeGTHD7O4agOI7wewq9y+AqHL3P4Ww5f4vAFDn/G5XkcER5HhMcR4XFE eBwRHkeExxHhcUSYvhGmb4TpG2H6Rpi+EaZvhOkbYfpGmL4Rpm+E6Rvh+YzwfEZ4PiPMDxHmhwjz Q4T5IcL8cP2nO10gjdrDuP7xmCWf639h4FccnOE+aefP8Bl4o4HrDdxi4Dcb+LzP5Upj/GitywU6 3YBmMj4HPAkY/J/xd8CTgbEmMj4PnA6MdZLxGDDoewPWTsYXpqudyn7QL+MniL8O8VhbGT8FngqM 9ZbxM+DrgbEGM34OjDm6YQT4F9PTVVka12uIn4Z4rNuM14GnA2MtZ1wGngGM9T3NQp9nM56LeMz9 DVj/0+YB3wgMmTBtPvBcYMiJaQuA5wFDdkxbyP0EzacVIB78cwN4c1oh8AJg8Ou0IuCFwODhacXA i4DB19NKeI7ob216FmuMPljzFtv0nOZHHjfnv9fA/1lhz930qdOdeqz1Bq51WbcZuB34Jcbgmxte ZRywrFkZjLuAMxn3AK9l/CZg8Oz0xT67zun+mOVycR+2YZLbGbc6fDX9HZiQWwHAr9PPMQYPT/8E Y0zS9CdQz2zO/32U/RnjPzr1zLgOeW5g7DPiK4F/yvgW4MOMjxp5PsTb6Go/b4fq8aw6h1YaY4wx A78NOMgYfDoryhh8Ogv1zHhguqJYZIjj70U80mY8wvExjj+D+POM3wP8EOP3Aj/C+H3ATzIGX896 lvF9wC8zvh9Y5uv9ljV7CmOQcXYu4w8A1zL+EPBBxmhzdifjjwL3M/4YsPT/48BYmzO+pHlpnfT5 bxAv/fk08CXGn7GsOTMZfxZYeAbrY47053PADYw/D9zMeBRY2v0S8CnGXwYG/894jml4kuOxhuY8 w/gJYNBkpsV5pOxXLevG+YxByxuxPGb6OM9pjv8HxLcx/how6p9Zz3mGOf6biJc5+hbwY4z/CVjW 0T8Df5fxD4B/xhi67Ebol5l9PpuXZp4EeFKz38wPxSz5zHwWE3enpf6O7szfAt8FjH7eMBt5vqDz 3LAvZqWtYvw2xD/G+CmnnlmzgE9Y6lxilhf4bmCMfdY64LdQt4CbsHb4nGPWCaMs1UM0xhzNeh55 Rjn+T4i/BwA6Zzatu/M6fnaRU3b2baP22plN6x08QH/6Zvbdzjqd/X7gGYz/UecnPpn9zCWNwQOz v6nxXMrzLb1O0+ich9fpXBWz3sCg828M/C/AXsb/Cuxj/G/AWYx/D+xnDN6ZS33+ts+uZ/YvQX+S i5BRc9JYVhw0+nDQ6AOvKdI7NgYHzWV+pvHOZb51YX3MPcsY8m3uCGPol7nQL3M8Wm/OlbX/hIH/ D7DwPHh7LvhtDuvfuS9wPTcaGAOZ+wpj6KZ5LB9I78zj9ei6CZjlg2sJMK9NF+g3D3M957M+e1xz vjFikZ4l2TfnV5hHWiUoO+cVntNK8PpMzDvz543QBdZKxiR7+Rzrxgcdnpm7E3iUcRfq8TI+jvi/ YnwW+IOMn3byz3PH1PwoPH/Unot5CzT/zEPavIV67lRfee7mdTtzpzHGm2vgPOAYY6yReSwrXEXA Ml/gnXksq11lwOjTvEU+u555+aBVjqX6N28r80/Q6MOzRh9YlroaDAzaz2M574KMnO9hDBtwPstY 135glrGuA8Ayp7cAVzAGPebLnEK3zm9hDH09n3WZqxV4kHEbMMtPF3T3fIx93jaf3bd5XRjXNiQj /7w7MV/bLbXG550GdvNcPAC8w1IyZ94jo/YY531Gz8t82F3z/pZp8oxDE4oXmmiMPkQNPAD8OONj wEKrNwNDzs4jXuX88yBLXRGm/0vcVqPRFmg77zfTbWy3KzQ/bmDI5AWydsAXC7yMIWMXsC3kgoxd IDTHWl8AeTLv3312PfMnjdCfnbMsmr95jGluloJWxGvQU/PXaVpR/fPXa1pRPfNzuP9tTv8XEE/k Trex9H8B61PX2wz8DmCZ6z8HFrmEuV0gcw1bZcE5xu8CFprDVlnwMOO/AL5IvOWz65+/E2N5K4+r lTGNK8qY+Al6inSaGuO5Uaf/9/EYR4H/cuwaUfF/Nd3G9hhHuT/vMTBspwUi9zCOBb9lDHtpoawX 6KyFMl8XgNmuc40Asy3kgr20UGQ1aLBQaPIgMNsALoQLWSa7YCMtlHZBp4Uibz9hWYuk3b8GFhkL 22mRrEfYTouIDg/77LHMfxx0I/0wSDzNGPM1/18ZE//hHxovyd4F84ExRpK9C6Dfqc+07hbUAKPP tDYX7Bu16bagRdN8Eei8YD/Lxocdmi8KOnReJDzzhIGhgxaxXeR6CljoAztqkdAHdtSiRxn/IzD7 Fy7YS4vYXnXBRspkXez6EbDIJdjtmUL/XwBLPb8Elrl+EZhtLdevgaV+hDd5GUOP3yRzDRvgJqkf ev8mmes/ALPd68K83ST9/xOwtIX+3iT1vw4s83vZshazTHaDWovZV3LDr1zMstQN/b6Y63RD/y5m eeVeIFdEgKF/lxQyRuQS1kHu5cBMWzemaQnbnG7o0CU8dnc2MMso93rL8kp/8oGZtu4C4ErG9Cda mPfoTyt5mQ7ucmCWA+6bgaVdlPMy/d3VwMzz7hpgtkPcW4BlXDuBeX7dkLVLWWa69wALffYBs93l hp5aKn2Abloq7ULvLJW2kL70EmP4pEuZ/m74dMtY97nhhy7juXYfAZYx9gKzPebuA5a2wsBCZ+iI ZTHGdwAz75FpsYz9HTfk/DKsqwUHfPZaWBDGeiRdhLW/4B2MwScLLsRs+2fBP2INYr2QbFxAtjTW i4X1vuD3wFgvpI8Wpo/aa23hFMR/x1LycyEMENf3LCU/F64F/j4w+r+wAvh5S+m1hduBf2Ipmbmw E5h8Xox9YRgYa8eCfFt4D/rzAd2fhRe5LczRwk8hz4uWkiELv8LyhPJ8n+UJ4VdjrHNQZlbMks+i Gl0PrcFFtVqe0JpatElj4v9Fm2OWe5alfPlFrdwWlT1u1PMx5CFjGzp70eeBYZeS3FsEG8+9yFJy b9EPgWmeUWzR73W7tKYWvYx4El/g0czrdDytl8ypug+0FjKvRx6ywSAPM5eMOvFezgO+zVzKGDTJ BCO4SWdCl2fmA5PMwLrIhCx1w9YiPz+zGRi2lgUZmPkmXSfxduYRxB+ylLzNvIvjn6SfwNP1E79l nmAMvsq8mzHWdeZbtBxON+yTZWq9rzcw+PDdBoYuWCbrDnO37DnGoMEyWYOYx+VzSJ5qH2G57Ns8 YWDw53KWP+RTLCdaPcX5ZR39pYFhky+XNYVxLAfv3VTC+c8b9Z836n/AqB+65qYhzv+YUY/g+4HZ p3a/Hxhy5qZf+eyxL7ZGLDfsENoTWQzdR3QgPl+8ctSm1eJVmrbLsTYXZ7GOW+vQdvkLDm2Xs+52 XzTwpyxLlwKGvvZBji3O9tl5FtehD9DptAYXt7Hd4nfq93md+jVGPV8y8JeB2VZ0f8WiP+1jLW73 2XkWH09SZ4tRJ+sy97cNDF7wiQyHnvWxjnb/M7DIVaxX3whjyBafyHbIFp/Ic/CRj/Wd+8dw2S4y hmxZITL558CSH3JmxSXGoM0KKYv1vkJkNeJWim6CXl4pdICfvpJ9FjfstZWVjH8HzLaZG3WsZDvW /R/ArK/d4PGVomdfA5axQ0evZP86Df+u5PGmgXIrmcfS4KesZB5LQ79W8tpJmwTM+zZp8HlXsg2Z Bp2+iveR0m4A5v6nYW2t4v6nwe9exXOaBv2+ivufBtm1ivufBp2+qo0x9Pgq7n8afORV3P+01cDS /zXAvI7SIMdWsR2eBp2+iucuDWt3FcuBNPihq3gu0tCXLOkz6JolfYbuzpI+Q/ZnSZ/R36xGxvDv sniNp+0GZl2ZhnFkxRhDp2cxj6VBNmZJPyEbs3i9p8HHzGIfOQ2yMWuUcQew0By6O4vXXRpkSRbb M2nQ11ksx9JClpUtY7kdmPdz0kC/bBkLfMBstivS/gxYaH4PsNAcNM5mOzbt7cC8f5sG/yibfaI0 rJVsmQvIz2wZI+ReNq+FNMiobPZD00bkujQw9OxqtnPSPgg8h/GHgdlWSYO/sJplbxrmc7X0Gf7C aunnJ4GFVyFnVgtPov01vI7SIJfWSFvwI9bI/H4GWGjyt8BS/2eBKxljHtYIf0LmrGEZkga5tIZt pDTIpTVCH8jzNbwHkgZ5vgb8ufhOny1/Fr8H8vBbSIZeXvwJxhjb4lHGF8n2ZQx+WPxLyG3iWdiC i/8dGPLK2gv97QGGvLLAW0tuAiY7F/O4ZD0w2UJoa0kVMNlC4NUle0dtebhkH+Ihl8heWcJ6meTV kiNaF5AMWRJEHuIp8PMS1tEkT5awjqb1vuREzEqjvSzouyVngcmHA62WPKTzkxxY8lGdf9UlYNgw aRstZUct+QIw7GeySZZ8U+enNbjkWzo/8fmSbyMPyWOUWfIznYf4bcnPEU/7XViPS/7I8aDbkld0 WeKfJX9CHvAP2VRe2IrEP6QjvJk6P/GV9yadn+bXu9jASxijjNfL9oZaIzvseNEva0TOfNvAmK81 LPPTYKOuucQYc7RW+BDzshbyyLvUZ5f17hqx0r6lae7tZL123ml3rXHmslZ48pcGBs3WypqFTlkr 6xQ6ZS37VmnQI2vRN2/AZ5f1vhft/oLb/WiSdrGmvB+bbmO7D7zWPCZGylqWRR4olXW8rj3ItA5+ lvdLPju/90do9zK3+8ex+8brwBveV6bbWNrVGHXOMTB0yjpemx74j+tY93nAU+vgpyyd4bPzL103 Ynlm63aXbkrS7nmjLZbVnrUGhk5ZxzLNUwTMuttTjFIsczzwE9ezzvKAT9ezTPBsAGYbwwO+Xs/z 4kG/1rOe8sB/XC/1QwetZ17yYN2sFzpvAmad64EOypF2sRZzWP57tgOz/PfsAGbb1QN5kMN7LB7o rBzWZZ4mYNZlHvB7jtAQMiaHeckDPzSH5bwHeXNYf3mgs3Kkz9BZOex3e7qAhT7wN3Oln+DTXF4L HvieuZAdSzf7bDov7cYckbLAel/6VmDod/Iplt7HGH1Y+vGYNYWPcZfCT/Sss9QaX+YCpvdikLbs BmDya0DrZeti1orrdf5lTTFLPssgl1Zcx/gXkBXzNV6eNmrzwHKPlgm54OHlkzTPuE87PJOb5fBM Lu8neMIGhn7IZX3hOQbM+sID/Zs7whg0zhV+uAuYbRUPupondIO/lcd7ZR7wdR7rbs/bgGXuQLM8 tLV8ss/uw/K5oNtR2PbgyeXw3Ty03wueW14PzHdmlt+Ghv6Bxx6N6QsAhN+NPAOanstBK8/tms7L P4c80znPvyD+DtRTS/4A4nt0vI8OB9YwNs6/fLzPRn3z8T5bHvrmk302w7/LG3Romydr6t0Gho7N kzUF/y5PaPg+YLLjD/js/D7iK/KJCA+iz2f1WHz3jjp9eCf3B3LT9y6WD1GjPxQ/nJVhbdbn176P AG/RZ9a+zwPX6bNX3y+A6/UZ64obgLfqs9QVG4C36TPTFT1e+x2mFfd4bVqt+Euv/e7Xir/ptNtd 8Wl9h4HwyikGvsu5z2DTSu4q1BgYfc6Xc2f0J1/OfHcCy7ktaJ8vZ+uQD/lyjgY5kC9n2bBB8i8x 3i+vtQGDBwuYV+l+QoG0Bfu2QM6124HFj4bcKKhkDLlRIGfukM0FbYzBSwVylwBhgZxHw9YtkHNn 8GqB+NHg7QI5dwavFowyBn8WyBk0bOACoclxYJaldKZcIPcETlhWoZzLYz4LvYxhJxfKngDmtlDO 6NGvQpal1ruA5Z4A+K1Q7j+ADwtjjMGrhSOMYT8Xiu//l8BsP1sXgIX+yFso9If9XCj0f0Bey9P3 E4qE/rCHi4T+qK8I+m/lO302P6zEWpaz9ZVfjdncs/LfR/R7e1gLq3yMweerypHn0zrPKmJ2vmey 6p1O2aypBl4Zs++WZNE9k9sYNxt5jPP0rE8b+LmYshNpbWa9OGrzc9av9Nqk9zSzfs3n3ZX07w47 Xvi/SOboywaGfV4k8wVeKJI7FV8HFh77JrDcnYA9ViQ8BtoXjTD+EzDonvWSz64/24PEL2m6ZdNd Ar6HkN0Zs+8eZH/YGWP2D4Cf0GPMfmHU7nP2izxGlMn+FcufYWOMxn5XEfM5ndnaGD54kez5wz4v usQYvFAk+/Owl4qM8+5iOTOFPCiWs5jFwHJmugSY16xrKbCc3y0DBv2zf+2z+7AadKBzcKLD6kWM wT+rS2IW9Y3Gu7p21O7/at4LpXdtV28ea38WG/s5xXI2kW9gMH+xnLnAvioWOkDnF8sZKGyhYjmH gi1UzGvKBZunWM5GIdOK2dd2wd8qBn+v3uKz21q9D2Oh928Jvylm39daHcO4SACCdqvf6ZzLr35w 1BnXh3mM8NlXfyTJGI1z1WI5Sw0YuEteLQY+DIz5Wv2Qz86z+gtcp9eps2SOU2cJ2+Gk/20MWVci 5+CwK0rY/3W9BVjO+7AOSuSeBuReidD5HcAs0+icFFOrMWRgidzZuBd4hPE7geVsFP5+ySjjDwGz TKbzuBKZiweBZS4+ApYR/oSO8gt/fgJY+v9JYOFJyD2/nBtC7vml/5Bdfrm3AP3mx1hWf9Fn02T1 DzG/ZNsQ374MDH1BfLtmDnzhLE3eNVuA+cxizTAw39lY842YJZ+1rYhfyvivjHj48i62l9a5nLs9 6xYAww6kdbFulXM3YN3NMfvOxjrITHUOXkG+zag9p+uOar6id9nXhdl26nd4wH/S4QG/nBU+buCv Ast8YX34YUeti/jsPOvOgA5fsZRfv+4h5jGfUf9DRv1yJvjPBoaf65dzyR8AY22u+6jPzrPuSdT/ T1z/j5LU/7RRv/DJvxoYetvPPpHrd8BYC+su+ew8615H/fB5iY7rb+T6K536SzOc+kvl3G2ygdOB 2YdyTwGGDFw/12fnWV88Yrkncf3bk9TfYNQv5wKLDAz5WirnazcBY47X7/DZedYHR/RZD9X/Fsbg 2/XvjdlnZ+uf5HbrjHbPGu3y/LpzDQw5Vip72pBvpXKOADlWCtm4/imfnX/9L0b02RDqX/8aY/Iz F8FXYts1p8i5a5cT4P40GP25ZPTnEre1ycCwS0tlDxy2dBlondPls/Pk3IV2azUdct47ls70Nxyk fo1RzwEDw28tk7NUyIMyjCXnfT47T84jI/rciur/WpL62xD/9HQb2221cZ0hA8P+LIsxhowsk/12 +FBlI4whZ8rYxqaz1DI504HsKRtFWz/02XXmQBbR+SzJpVwPY/IV4dPRWS25W7nZkA/rdLdzd0L+ kAyArMg9CAy/j2RLLvwdVy3nOc86i/Bjo/ZYcr+g5UkZ7IfcLzIdBg06UPzfT7exTQc5Z3+ngWH3 lsn5GuzecjnXAE+Vy3n0e4DlTB/2cLmc9cB3Kwf9c3/gs+vMJd77c92fvOkj2v8GHfIWA9+r6ZCX y5h8YzqLfJemQ14j8LCmQ15w1O5zXq8ebzl0dF4fjzfmjFfFh7z235HIO9XpxL9d+18KP+/g/H1j fbFytlWsdQZeDyx2JtZjufg1WI/l7M9axcDMM2QAlIuPhnGUs9yzYPOUi/+yUQ1X45uBxefCvFcw bS2sqQqxgbHuKnhvx4KNVMG8asFGqhC7F75hBetu8g0rxLfaBQx9nd+lzygrpA9PGPj/APO6pjNN dNXK/7jOv2GmU4+NYYNtYHlLfuUGoRXW6QaWk+RjbhB/CvbPhhhj2EgbpM+wkTYIDVFug/QfvuQG lnt0J38Dn6eQz7iBbS3y9Td6GWPNbmRbiPhuo/gLoNlG3s8h/3Gj+HqwqTYKDWFHbWR5S/y4UeYR dtRG8e/eBiz0fDuw+KfghZtZB1ng/5vFr8T4bhYfGT7jzUIT+Iw3S7uwnW4WPgGP3Czj/QUw28PW L4GlLdDg5kuMfwUsNPm1/LmWWnXXt1LmBfq0kmUp3RmulP5A/1YKD/8bsPizoGsl297WH4DF7/53 YOENhFXSFnyrKtmXeB1Y7Dr8W1VnxIuPMxcuqtiH8GWqxT5cAMxzRO+MVMv9Jdhm1czz5L9Uiy20 HFjua2Gs1byf4MLarxZ7A/quWtrF+q0Wfwo6sVr8KazlGukPZGwN043ux9agrgKfz5YDBbWOvVdw IGbbewV9MUs+BRfAOPALPaBhwSOM0Z+CrzKGvi4gf5n1b6HL8UEK58bse8WF2506C2l/j+8YFz7k xBftitl+a9F7Yvb94aKHY/Yd46Ivx+w7xkX/EbN92+IKJ39x2Kmz+O8M/FJM/80ijL2Y7slDvtFd nZLrnP6XlDv5S+jOMwkN0KWkG5j0F+yfkvc7NnbJD5z8/lWOje2vcmxs//6Y7a/5Q0Z+6EFlp4A3 /F917vb4n4/Z93n8Lzv5S1cA0z1eyIHSDc79n1K6w0/3eLFOS++Iqf56UGfpO2L6JTu0UUrvL5Dc Ag+XPob+/y2X/SPwZzQuW+W0VXYG8Z9k/Fknvvx6YLqvCFqUI7/7sxxPe9ofttR+bvlh4NcstYDL +42y5zVveCCnyh8etXVT+Se0Hqyh/J/kMy8lB3bY8aLLNAY/lxq4DJj3Y8kHr4kxhj6qYZnggj6q YZnsqgZm+eCqARbfEGOqYfnjAp1qxP+tx7+yprbiX9mLAM1rpQ/QU7WyxuHX18oax1zVSv0Ya634 I9AvtbKub8O/sq5bLWuTyJA2YN47cnUAi48M/bKJz1BcmOtN0hb0yyaRG9Avm8QPgs22SdpFHzfJ vgRss01sI7nClrWZ5R7d394scgO+4WYZL9rZLOPFHG4WPxf03tzG+AQw1lT5X/vsOSr/Gvwg6jt0 RPlPGGNeyl9jDLlXMYMxdFbFOsaYr4qbGWNcFbc699Mq/szhq4qPIR48QHZJBXiV5pcMkQpaUySz 0YeKnwLTO2tki7wCDH1Na2HDtFGbrzZMRzzsXlovG5bpeKLVhuWaP4kOG3yMQYsNK3gPsMLh1c1D Dq9ulnl5t4Exps0jjC8Ayxx9AFh4D/Jts/Dehyxri7H/sEXm4qPAMhefABbew5rdIm39DTDretp/ 2CJ7U1izW+TeNfhii/AA0utkT+ML9JOMjP8emG0A8sfrZE8Dtlad7Gk8BSxj+Qdg8Yu/BixtfcOi IwmNvwXMNobr28Cy5wObrl7uw8NPrxcdCv+9Xsb4HLCsqR8CC28/DzzK+MfAss/2c2DZz4EdslX4 HHbIVuFz0H6rrDXYHltl7LAxtkrfMI6toq9hb2wVfQ17Y6vIFtgYW4UOsCW2sp/l+g9gocN/AgvN EW6T+b0MzPtj7jRgL2Okb2Oak7+/TXz2ycByz+o64Bhj6KBtLPfc0EHbuG90z3Mb5N6GlT6bJzfU YH3xmdSGA4wp/oyqTH0q82PqnojCm434QzF91x3rrhJ6je7G07qrPMW6DPxZye8RUFuV/B7BNsxX Jb9HMMlYOyr+rzodfF77NQr/zsFVR8b6ONvEzvQbGHJgm5xZQM5vYx4gGbBN/Bcw5DaxCSHbG6Yw 3gbMc0HyoEHOYuAjNPC5KvkFDZWM4eM3iF/TBix2KfR+g9jJkNsNYqMiruERI/4SY8jtBukb/OsG 6RvkUoPYq9Cx28U+h6zeLn07Bsw8Y0FubxefC7TfftDIL77DCfoJH8Z3Axu+w3bxZcDv2+VsC77D drGr3wosfgTKbReaw4/YLvb2O4DFnofvvF36DxrsEBsb/vIOse3hL+9gvUY6YQdkTtWbffacVp1x 7NWqj8Rse7Xq8w5PVv0KmH6aFnNRRe8gk17A+q2eFNNnmqi/+ibgWTp/NS0aohPmsZrsqJkc/76Y tv2QVv3XMXlp0ar+SUyd51Ofqn8PTPeI0M+aGTH9Hhk+Neuc/tT0GJj2Y/kcquaiEf+9mHZ2RoBh l5INo6iwwMlT22XgdyPPI4w/CXyB8XdH7bVQ+z291naARrXf5zsDar52OPE/mG5jWUc7hFdHDAwd tCPGGPO/w/D1dgifwPbbIT7vR4BHGEMW7hB/EDprh/DMx4Chb2p/67Pb2nQ9wPstpfc3+WL6Pjzo vIns8L16jJve7tBhi8/Ae2L23yPdApuTbD+FkZ/0i8JfQZ7NjF91ytY1Am9ifGfMfg+97qyR5/WY OIlW/WDMts/r3+nYJPUPO/nrfzBq07P+OZ4L0m0/5H0edZaxw4l/vtPBP9KyjvDWQgNfHCv3doh8 yzMweH6H7IGA53fIuquQPwmr5eFOkXVYEztFhoAOO0W+QTbuFBkC2bhT/F/Ixp2yJ4B1tlP2SeCb 7GxjDNt4p/APGt0JPbWV9+52Cc+gjp3CM7uARbZgrnfKnsk+YJEtaGen7CHAft4pZ9OQvTvZfqb9 mZ0iP2Hv7ZTzdKy7Rhkv+tgoez6Qz40y9oClf2rO0vs5jSKLwA+NItsxpkYZL+ztRhkv5HYj5OrW f/bZc7H1VUdebaP3MlhebVvp8Mk24tt8S8mobdCn6jID6Sd6D/cDnIfObcnuQx+2PR3jczbgf3Fw A8ko9pEbnnDqbyDZQgf0lcA/j9nybTudEZP/i/ndnhPTfiXFUx/osA902E6+WxPHU/1EG4x3+4+d NbVjkdPWDvJtee3suMeI/+yozas7HtVroRF6Z8fn+MxIyYcdTvzfTbex8Hmj6KkhA0M3NRq6qVH0 KXRTo+wvQR/tshhD1+ySuX4nsPD2GeA2xrB/dslZPGykXbLXBztnF2ykHV/32X3Y8YsRi/Qs7Zvv nIPxHtf03OmL2XsUO2nf405Nz51Ez7v0XOw847ybv/MLDq120t94iek7UY1TR+2xN15/yV47jRlM tzkO3fSaWh+/vj5iYMjdXUIf+AW7ZN/v85a1W9YF4nbLuoBtv1vsn/8DLHSD3b7byxg8sFvuNmD9 7Za18z1gWTvfB5a1Axt+t+xhwhbbLXSGjbNb7KLfAItMgF29W2TC74FFd8A32i0yAfb27lHG/w4s cuCPwOJPYQ02iY0Nu7oJ422c5rPp07g2Zt8la2wf0fsbsGEaBxiDlxpPjaj9DXoPuvF9jMHPjZ9A 2Y/peW/8IvDH9fw2/lPM3o9q/I2Ddy2PaVsatNrlj9n7TrvaYvZe2a77Yvb+2K6vO7yxOxiz98d2 X3T22XbT/RneB2u6zsnfRPtp8A1JtjS1A9N+Duai6V1Onr37nb2sve9xdNneT8dsm3+vcT9n708c vG+GgW8x8DucfbB9Dzj7YPsei9n7YPu+NWrz6r5va95uwnj2Pcu8bdw5UfHf6XTwP2mdSLhljYEf GKsfmxSNwA+rDbwGWO6AgX+bKlH20z47T8u3HLnd8kLMltsths2wfw3rcb/RzxajXdERpQaGXm4S nodeboLc2L/WZ+fZvz1Jnca6bpK1XGdg6OgmWSPQ0U1YI/t3+Ow8+/uT1PmkUafY6vsNDF3ZdIlx B7DY8IfV1qMlerBZbHjowWahLfRgs9gPR4ArGfcCixyAX9MM3b//qM9ud/+7R9S+LPmh+z/h8Pb+ Lxs0fxH4gB7L/n8Hht6ndXdgcsxevwdoTZGvg3YPkF03yvGHDUzvfrKuPPDpUZsOBx7RfNiMsR34 DNNtxKFbs2EnN4tt82cGhpxuFt0EXdAMO/nA3/rsPAeeHTsXzSNGnSNc9h0Ght/ULHIbMrIZYzjw HZ+d58Dvk9RpnI02izz8KwOjXLPYh5BvzWIfwj7fI/IfMm2PzCNk2h45y4NM2CNyHrJlj9iBfw0s PiZ4cE8b+vayz273FvqDHH+p5/eW1TF9/wj13EKXdy7oebxlC/D9eu5uaR61+3/LHj0ve6js3rHz smfQGe8e3gcmOWnjLwKLfvl7YOiXW/b57Dy33D6WhnsuGnWK3nnawF8HFlv0G8DQC7fc4bPz3PLe JHW+YNQpa+oHBr4E+Spr6ifAQvOfAgvNYdvurWQMWb1XbPJfAYtf/2tgORP8V2ChA+Z8r5z5Qrfu FT0L3brXOC/ba+jWvTJG6NO9Ym//J7DY2LCv98q+FmTmPkPP7pN97MnAsn94PTDLQ7qzt0/296YB y/0urOV9sp8PP31fjPFsYPT/lvf5bLrd8kkwAr1nRHM6yhi8dcu3GCO45ReMMcaD9MI426gH58cs +RzcCkz7Q+jnQWrwh5bSlQdJbrD+Okh6k97pBs0PPhCzbemDPwL+kaWE461pMb3/gM+txlnSrX/h 2My3Pu3E30Z2+CVLyazbqN3lHP9xJ08r/80cGm8r/82cfRhjq/zNHCUfdjjxi6bbWPhtn5wLLDNw NulkxtB9++RcAPpxn5xNrCWdzBh+zT7ZR4XPsk/OHOGztMi8w3dokX1d8GyL7LVC97XI/ip0X4uc ZWDdt8h+7wbgNsbwT1tkbxm2ZIvc94P/3iJ7v/BDW2R/FXPVMsoYvkwL6zI6o2mR/sMPbbnEGPPc IuenaL9F9tv3AGNcrUU+m1ate0YsOrclHmul/Zy38by8FXNK84W6WmlPhqYD/Wj9IPAKzQ+tfwNM dh14ppXOI8jeA/+3fmfUma9/0nO6H/zU+s88p8adfxX/3ek2ljndL+vrsIGhZ/fLGQH07H7Zxw4B y5kR6t4vZzcDwELn24GFzm8GlnME6K/9vOdDfydnv/AP/Jr9stcNv2a/8A9ItF/23uGL7ZezLdBt v5wLQH8dkL33dwELbwyTDmcMv+xAJWP4ZQekz+8FFp55HzDR8z99Nh3afJivgJ6vNv+IPutBn9vo 7zB06/lqOwDco+erDXNK52U0R230t5KO6LlrOz1q07ntXj1HByBX297Jc9TmzJGKf1eng4f5b9PB b5z8psV2/PUbNb6F/Klcjekz+eEZCtO9wcmPa0x3dyd/Q2O6qzz5xxrTXfTJf9SY7gGm38CYeLtG Y3o/Pd2nMd3VTN/Aec7S+4RcP/F8C+dHW1PeP8Peq3edn2Gfi7n+ZoZtn6R3aEz31lz/MMPRj90a 09+Uc/10hu3vp7+ZxwW57XbPsG0t9+IZtn53l89w9vDv4DFC/qf/BY8dvOFumGHb8+7ADNvGdsdm 2Lbx1F/PcHTrXRqrv9P1bsY09w9orP5W1d9prP5mztc0Vn+34fsaq78z8G8a098rczNNyJZzPzLD tjdcPC7aIk7n+ul+afoXmObgMffXNabzbtdMjem9S1eZxvQupIvHRe8lpX9nhv47qJCrrtAMJV0P Qx65jjMm+v85Y7DjdX+EG8TcdF2Jgfc42P1LB6d5HDz1VQNPdvD1M4z8K4w8c4x4o62pPqPd2434 jUadRp60OiNPm4GjBn67kb/JwMeMPPcZ8cMG/qSBnzXwyw72GHSY8hkjfqmBCw2808CHDBwxxn7G wI86ON2gf/rrRtm3Gn3wGvhpl/03Wj0XjPhSo+wnDPyYkf9bRh++auR53skz5XsOnvqIUfY3Bn7V wZOmGvgmA68xsNG3SVuM+Eaj3X8x8nQauM/Jc53Rt0lvMca+1+Cl3S7LIzhg4JMOnmLw1aQzRh8M /pn0oIE/Y7Rr0G3KHwx+M+In/aOR56RBc7dRz8+N+JlG/L8a8T6jbwYPT85w4idnG/R5ychTrrZA NL4VYxfc4dBh8pCTZ+qzRv4zBt0+ZOQ/b8R/3Ij/sIOPzrHST0KXHvXosP9lDn/G4bMcPs7hIxw+ wOFZDk9yGOWwk8NmDmu5Hc53lPMd5XxHOd9RyVfIoY9Dbvcot3uU2z3K/TrK/T7K/T7K/U6/F1/Y 8um34Hs36T58YeumV+MLmZ4OWzQduiMdNlP62/Gt1+/qp8N2TT+A7yZ8Yf+kw+5Mhw2Sfiu+sJvT 9+Hbji9sr/Qt+MJGTQ/jux9f2CHp8InSoQ/SYUunH8MXdlY6bN102Gfpbfj+Ob4b8T2EL+ycdNg9 6dDZ6bBn0mH7pp8gvYsvbNn03fjCJkyP4duEL/RP+lF8I/jCrkuHLku/A9+t+N6GL+y79L34wp5L h72fvgtf+KHp0H/psNvT36L//lE6bKR00tGwL9Nhr6UX4XszvrDz03PwrcK3El/YnOmtZH/gC7s0 vRhf2KLpsP/SYQ+lw0ZNP32N1v+jtIYdnn4Pvsqmb23tPBbsbO0a6OtoDYZCRwb6LRURiQ4caj3U 00e/ctraHQj2B8LI29vdemiAfqEUUe2dFFVdT79Yq3+klX9PW0XqHzJVP6epnvXP8gZ73hxQjw2h wyrkIvKjumac+gViM8L5JV0zVv3uqhmxuWfQfDR+8zZixtOPIatn+weA1ZP+0dmm7tAdVFB+CZwr oF/jrY8GepPkpN/L5Z+ATchaW92ofzq09Uh9zY7B1sZAX0dPEE/bN+3Y4zw1Ne8ebJVSEYOGxo/B 6tix/bLjE3uRQPrtGHr74cDuQEeg53ZMrE6OJNSGijqZNvWRxBqNxAb186v8a6qasn2dMpOd3Jad 4MzemCRziuLSQNtkI6X4pCNN+ovBVmvNZvqNbjQfCDcFomDXxnCgM9DV0xfoTEysj9hP2wO9h2hg NZtr26PtKFV9LBpojJoxDYG+w9FuitgdCAbaiV3lt7xr0HI0sGkQFfW1B3cH+sOBCHrbHlULJD7X 9oEo/XBuYvS+nmi33ZtIstTNoXBve7QKVA8fHuhF9UlzNbZHOtqDOtZJr0WPo0abGI7dWFW0vq8z MBiX6IzVjtI/frupryPUGVd1Q+iOQLgjjhz80+ZOxJ7+fjsPLXT7B6t3ByKbe4gYtYFoe0c3HkMD YSpJv2SNjHpR2I/1HVp6hPr2NDbasWqaQJ1NqIFy1IasVnRYMYz64WfncRtknPOkfsAZdAk7Uc09 vQH1RBU1DfRE+amvU0iKJ1q4NtDF2sOHacXW7Qg1DoSJo+v7ItH2YFCl6lGglYZQe6czxh2BO8xk NSTE6ccasFhYPScMGjFqwCTSxtIRYBP9orLVCv62k1Vn+joCTdFQWK23Jt13kj70y9SK+TbLCDmx uScaVBSHKqCFE1KVRJnhiK67A12BMERagHJENlutHVFFPv75ZPXryU1QLRB4NZurgup3okPh2kBX +0AQxKLnoC4RiYa7NNL/Ynkn+el1Fa9+e16jOFbSUYm/hK5ik/4qu0qJ/z11UXBjfoJeEhJ+q12i +eftbcEc/6vrhlge24G4WYzXUIlZjWfFNqC+1Xp4TJdqwHV2jZshtFkIJYumebd5oiY00DeWZSL2 MhtTWrEjBCczHBgzeRabp61WcC4EGD0pNtPRTWIn6Eet/ZpDUIXJBRZFa4GrrQFKGwiDEc0lXNcQ 6jgiq4UXE8ttLkZKxf71djtujGSo2VytjKCaUP+xuJ8337O7wUkljaEAkbQeSjPa09Wji7OSa0QR 3e3dgd6QFsaoQkdR5VUQksoCa2zHanR4QmVD/Zub1IxvbqLxQiUFQ4fr+7qwFLRqRvFgTwernOae jiNqPkFXLLMj20O3B0iNiTrTrSaou0jS3jbQKk0+joG+hlCov4nFGfSijqjq7BwT58yRM6d6wOPo R6KIObWN4RCYEV3cMdDbHBJRdcRuAATrDfXRD7hHbFMD5gTPqx6nbtAeqkMIQycbo6QqdgeODgQi USXgyEiGlEeJYHtnJ3F8E4YKVR/Z2dV0rPdQKEhRsKIU3gEGqtV2B/FEXQ/1Y0dTgzK7sQiqIR10 TicZYrCDho0wCLvrz2gJdsIe8vYQjx63kKksmrchnFe+Lj+vsKTQX1Bc6C+3YUm51QEOLYvmbwjn l+eW5+Uj5vZQT2dZtGBDgZWjZ6UGajKQUxMZoO+6In+ONvLz1kfGzZFjVRwa6AlG1/X0bbQqOkBq 9MsbxNg2/hdqdXKM54SUbeZXh1WGYPubj7VGFMnsfJjd8LHW/hCRz8441nNJ6vtI7YnxujpdyrJy 9oaCMLciObXtPcFjObWB2wPBUD/ZXzlN/YFg0FtDeiYQ9rbkZIWCnev6Andk5yiZ4t0eiHaHOr0Y WFeXjtIxOf9XKjWTmeQ5WAjrO6zDHR35rZi1fpgInevF2CLVbhsjY6PKurJy1+ZlWzubIN/Louph A/7Nz7aa6vuiecUqLl/FFWRbkW6sGK9iUBWxoTKSV1weVrh8XUF+SbG/nP4FR/b0NR/rD5T1I60w 2+oJUavqqSh7w2oExRRJixOSW8WX6Hh/toXOqbJRVZaaLs22tNpQccUqLi9XF8hD9zX7q9IbdB2b MTzSJTWQFSqlVBfCwPTqoQcMIKxDWUfUmaiuVGUv5DYw9j2gR0G+TtUEySvKtoKhvsPegb5Iz2GI AJsySNE1F1HNuQUl9qccPHo4wbc+rD1G29hwHuMNy8NJvCcx8ERWHp7Ax7XzJPO2klaUIlOcJ1q2 mQaMaTXtVZiAmiA8ZyVMMZtQJUyokuxxpV1P3xh7RTFMHqY5NJBorumkUj1v+blGd+zCUV1Y8Xke Z8SMDkbGZIVbHQp3lllUMfSyXgy5umQBlyykkjv726FCJNvYNrmiKDdFQdGELY6X0MxFI4Xwi9vL 6AmkbSca5pcoZivX5FyLNZlfXm6F9STw3IQDXVCtZXo19wqHQRp1qKr81CdtX2EBqmgr/jHK2Sgo TZm7mbNF/AHbTyvTC0j3LyD+msQW5OtuU99s70z1F1NpR8hcFOi5KNZjIU5QWSERwKH5RUU6k17L BflxdEIqUaoAdLCXry0ZCpRo82vJViDZLSvaHRgrQ7Xbphou1H20HTldmZZhBUVmIlk6ImyQojIU a44qwJpgsUwf01tQawxsP9GSgCZWTnxOQ8+hcHv4WM5msnLvCIWPRHJqQuEAJCPMDerD+i5JyalT GhQZNlfDdl7f/T+su+L38GxJMtEw4/kaEyObg1pPEB2Ry9g0dPRHgebfAhYShblmPpmUQs1ahSwg CpWAcLLJOh0TE+XMFBRcYZlmzhzJL+waO2I9YL1eIoHgbnisKrJQSR7YxiqCVk5xYTlKQEfXRzbp JVVYlL22tHitvxyMd3sgHA106k0flVacjSXnp2rD7XfI4imE6MgrZuEhlUe5OQqIqqEQfKw+Hc3M i3VUs1ntMeloLfALSymaLW/ZN9JrFw1RjiJW40V5NJpW208os3QuP0kPtanAi4y6rboXjBuJCI4m R00XltpKR68jcxvaWUrxDNLPnGPkl00Kgy+Tl3F4siifbKqmaHt0IKL6UpRv06MnondceX7i++bs YqRsjVzdnWEyfDlUxhwS2rWdxQoKxLEOSYwFwdDPJFP2cmNPX32fmmTLgaqiQtX03vbgAFtx6lml Y1zhaGIkcZxEYTnutmkhTalBQlUHA3q3IuFZN1o0/ngpPpjYNKLMhiNSG2w/9EnWAHWIGDyO+Sly Z7DTrjQxVpZQccIUKRWXcnZ6+mT/RtMeqsGOiOoIxf5sDhcVO2aEnc/qVnWao9iUqEftSEOLWtaR wDFl+Tp5wMQD7UHahZHIDjGPefn2hjrVdoZZ856+ng7yts1yEc3VzOVGJhVVQgs+fqUX8Ur381Cx LI/oFW/JxJDUJUUOUYzaakQPF2vVXZxvR4t4LmbNz0yOjMpAZ4elWK+24kJxWcZY6EhynBc8QMUX FxUVFKm/kotONZJ3qLqk7DT9aOkgytEUFI9JbeboSOHt2s5aS4xS3s0PecX0VJ6U2rsDh1nIkcwi RlS7ZEZEA/Q0KLupk1VAkUPCeN5W0VVKGTSEOgw+Thjbf6nZZPX/r7Q//hd2Oe509Co0U16iODOP 6lLrnCSHw6qQJBqHxCp+YoFue+j9LIN6aHOP10U/L4yePlvA9LOESZCLnaE9VfVVCbK+rj2SoAQi 3T1d0drQHX1GzqZ4g2qcxaTs/viM40fWtIcDUWNRJF8oV5wRAmwg2EmTbKw8EZIs+nR1RgSNzJbB TDTxJq7oPNwxj+rFXOmX9q/4pHyiSvRBjjJKm0PO8WLSWGUaFOVPZAqZ5ZyDyKSxqWsbdw/GKGpG 07GLKPrikqS6H0wcCYRpv4s3u6xkFUR1BUqzsLYsLk0wDBKKJBidicYlb+PSY0ku1VRXX8NRlgOj nExB3ri5mjk5klfYHgV3HRqIBuLdeW6tvjbenSfnXPUAMcWFsOmh/3Sb0NOR4l7eNslSmyu6pl5m Ie1RUNYCVZvSndvjEqM6VQwFfOR+hvBfV2/UFh1YGdWQsgG1VEoKk+0J0G4fLSClE+igSWUleQHc qvV/idb/JViira2d7eE7evpazWRnv8u2hdmvcfpRyzs4JcpmoifhgRLNAyXMAyVsMflzxUdSRZXA CB9u6Imo6ffTRmh7a5Aeo/pZbYbmUxcP9w10tMalahPJX0Cpat8fI4jLUODsfWrB0RA6LBTt1Qco WkYXjkMufOK3OsuaeIUZO54qjvbpUu9uqqxEu9SbnE7W1Hud8dVeYV7zqk/ZFiJKoZ4jUMu8FCRp VsJtIDv+f/3Rg71hMfYMItlZvTYxxtkllrOHuD3ifL1FnD/RDrE6ytX2gbi9cdur9lFvpCyp2C8y OmTkdU4gisetzthYYplgH2Qky9+sK4v4u4Lth5X0LCWR5y/vpzziZyHOj7g7utu10ZYrjkO/HmiW PqJQsgtyVvZ9jQ3UKznl8Cc95PCb5yVFiYc+dOxiO054SDj2Gec8pJj7UDz2PGTs7iudnsjuqz5B Ubuvhg0rEinuYoVw1ri7hiXjHgZocZvH4jav9A1tzUe5qJZnb3hzP9fc3MckJ9nIl+HH341xxp+U vyciS7K66QaOWSVtrIT0UV1+XvzxYJ4cyBkV5efH7xPmO2dmlrgRfKVGWrHGuZiTYmChAS5iRBun M5ZT3wBUFtdprNr8QvtARhUpHqeIrJp8rdvzeZ3rQ5OkJcqSVzT2EOWqStuHKsVd8RnUXRARF2rT ISFDVTjcfowPU8bIjoK8sT1hviTZozdXk6UmnLGMU0fyss1cKFLIXeXNKO6+5ObDFXvzROe1z3YL CuQwz6ISTnyhHe8wJp3DxG3NOscv5uZxQbEoo0iyjusxMysnufeVgmfjTnWurliSK3NXUCrp7bgr 6uSY+2gp5Uyc81NQkrDxWaCFbQEL24JE/0Y5NVbSq3ipBQHlMiIL+XChEIWMpKiOUhvy+dlxp7vG 0Y0qmOx01xpzp/AKCDn2ymCqQuo2HzUl1/sSnuXuRoL1Q898uCjOto6he2Q6DzjdPH/kI5xCPn8s 5PPH/AS90JHk3p9yM01Lx0yT85ssfe6xpw+eQDjSHoxrWytMPgdJHLJ5dXH8JIcQEmGz4hugzBWP mdybRAbdwiz1v96qd+5LRsba9f/btkvjBzPeWwWyHuOUQ9x1KFYN9nWoODeFzeyCidyUsQtdbQ1B mPCGY79urKePGEu2L5mbk55l296J2ieIN7mK5DLU2NPtEr5Wpe3d3OTn1GMtc79jmPttuzzpEXie 3k3Ky7uKI3DKPP4ReH6SI/C8gtRH4BOcgOcVJjsBh4lqnIAndxjYmGW6k/8wkblvnKLnFYirEXdc nlcofDbOaXmenkzjYlPCafmEXkmJfdlpgm7a96Liz9uJSAnn7RQlfuaEvkxe3EUl+wJOgWN02u5N cseRbPOwDsc4js45ZJ5zClqmLfl4kyNfEy+fpyu/JJnJYd8hFMvcb4j/BE5U+13jmIXJLPoJbeAo F2K7/Ort59xE+zkvqf2cP779nGff4Yi3n/PteMPdY2u7oHDMfVDzTBUPCVsDfEShb/ezJW4yRFFe XjnrYPMMmA1xsiONE17HihzvhLfAb/bGb5zwxnWET54LSsccMRewacI2ZAHfa9CCIk6IULwjw7Vu QNSOAXrdbGeXWv0RuSBGpzdK/ahobp4MVKpWxSk3zTaQbDtVG2dK4sVnLUsoqsvpWdIGbIr8zZwx kpdP1wMTesy85Bx0FY1dx4XFcc0oj9GfC05zosxbQSXxuY1czZwcycvtsq9liJToYpFeIOKnq64n 2BOFqDwWtH3E4kLN46CzTlUVO9fCyHSLH7+pTm1z1fYb+ETQGT4djyrFkpttCbPRLaawDsdV//18 USb+UsmYN0IncguUtbCrVh/gK7Mgz7h/0NNXC+v3MKkDxyPSh/v6xoiKZUbKV6ncJCdQjHnUb14j Qm3O7YcizZRFhUlvP1C03H4ojLv+YLjwE0pvWqETiF5zTPZqS7ijYNyMcK4zFNhXKse8haTInj/O hTDQPeRkNZyKhOs7Y/JYY6OaOXukpLgLiqeGr44Kiyd2WDi9qWE3X9ItVTxOcWOGrC2dLno185je V7dvAdmWjk5VszU2izZ7jCxlerZheOQ7KaovdMGXTurFyMrPL7TbjutsfqFR6eaQvm4cV7Ik3y5J 6TzwfH9if2l3PLFwQX6uXdjOxIds0DBGrzcHQ+3R8evxO92Pz6ky+LMhDIrJvNRZGnr6AnWBnsPd Y0ZT6Hc65OQS9i8sLdbSVJKrIh2BsSQpysuPq0TnkkqKMJN2JcQwVX2Hg2NGVFTojMjOJJQpKuEt PeitQKd5TSuf7lMMHJIjDb8j2PyQ9fHrdiL7KG5B/3/hHRvz5fikZ11mhv/rzmTcNgWdPEN2s4jr PWYLT/26YpkWYfIao73XpYW4vI/DDgUXsSJqHPSKHJ/Nq1Nq4805+7Ca3UxVTalUY2REXQmvVPIm taXeerRdHMdlXK3ZSB2oah+vVb8hKd0y6tAR6r1JNseQXT9aOjAcrLyiManNHB3x53bbVyfy5KWK PHUxoKRU3QtQt7CLC3PHdVfIPQvrcIy74hytybsnuclePcjPdXxsYHGyeZQ9epmrZZWnh6Lfu+DQ OI7Rr7QkpDdzQqQk9/bd9rsg+bLh3t8e1nc39EVFCIi+dn2en0+yy09yiXR3nNmfb74Hlj/mRTA4 qNRtelMy4biFkooLEj00g+zFBeVMJ74/rFeY+jsJajxWkjjZDewSWqk9FTmsQUJQFWi0D1L1AU6D E6tepiUFZiWLHHN4c8Ul7YObwkL60xGY0M68Ms0tWvlLbD6f0fCFF91hVQ3PTq6aDDtpU2O14Y/Y 9oFOJOJvlrNmKqk1kE6E9RH9f7q5tuWmYSDqzwl9Sm1JcdqnDrwwUGCG8AGdTguelCYTBwp/j6Td lVbSyknK5YG3jCPrZl3Ont2zu81D/N9d9ees1avtlhacNyABQ+AUglr34zt02jgsiI/udsPNA9g/ Fx5V2IuTXnL5BNxpQCHFS8AOodrr4XH4+u1r8r828f+r7/ao9wwJL9GzjtlOM487XpoOKHRx9Zb2 Indsd3NmL8K3hDni5rJdl7DkgsXYkmewkSaCG8+6NltN0vlQsyokQj/GdJhikytsa+y/WBTy1h5a 7+8/4AcjTcnD5qn4g9idtAlueC+FHjCJJGps7KfJ6ljhy2OrLEi4Hj8HnKDAa9n2oAqL2Nh9X1x4 GHeUrvZA1gXhjv2MFDqhiAyhkCUcIRxvT1/gvHdPVI9PdnBhttG4sbasb53HbKu4VS45M6Hi6ogG U6IIKgwmr/0Bg6lN4sVbFjD+P0CoJFvRnSBajmV8BgLn8rm5XadC0zzl0b+FWg7BvMNLUZVahxxT rQEgpVztrT11kWzugcDmg8Y/G/FpDNuxO4sCdcZ2/h1DKWbk/bfLdXBurRRR4cbe3e1vhkdi0M8Q H90jEjpDALTGd+A22UFejQu4naFQjy+1/lbxAaDbn6/uwGM+hN0bKGsv8Qmb+TKlwOf0yQITSzR7 C9OOqEdGoQz1nCEoEYDoDvJIIKJpQmKJUEsRC4K1YDmLP0E3j8d8+APWeKhmQRQyVLPMqoHSF81W OLJnRAOLt0P1XoHZgyCOo99c4SvS9dDWrgcWZMYP/MgVy9i4o43WCZp4jOD2eTo+4A5riicgESOv bT6YLd6TZ3jnrfEU5jvWkbgVD0vkmcmXJnydJKheTRTBSyXRIUfZqce4as5ijh3TWBoD7i4hY8D+ JmNAaPXt5iltGGgu4TCFSWzzkGMh8MFNoNJpyPHw6FPF+N1EoWDDIzZj0WlwYIZQd9VC7Jk/v4Kn /dzH5GwfflIQtCu2Y/Qo8+ulMtRAITdBRpo5rOalw2oe1+yY64RVTSeckcFa1Alr2Hgaz1h9ik4Y RaH6FJ2wntIJayXphEEdK3hGp1yjc8k12pmDrlHSNSJS1dOu0cRdrUlxPenMZGrCZ4ZYulejW1Kn +zFzS3KRpOtZSQPPQIx4Avvrij+X/TUTUXoVVvhv0cKGA+RD/HCNILbjOUQQ/x5DPEURm+4Eivgg R2zUkRzxJEls9JEk8SRL7Go5hiWeoond7ASauOq5JomuqXuumWoWdbkLZgZFAtp0AgFtMAIg8M8J 92Q0l/Hqgnuq+cxBoMt85qaXfOZmGe0vpu5dBHPNzXM014yuutgN3CWLeeZiN8vwnLnYUYtl/hPm HOGBk9aIxLmUZfavW3XUcJnFlsejV5LZ8iKVbLtUZPNtn6ofgz+1jNUyEgg0EQMaWQyRAKlSTJbx 8+sZhXxFWBeQFwRsiciLcmK1iLycdZYhr65EXh0LFeLWXtjrKEYuxV98jgXBV/oJ5KTG9W8wPYF8 OlgH80byHk79z1MVRhf/G8zTQDq6TBJtBEW0Qrc+9dg/1MFo4WnKFEWpPUOWk8zP6PYJSVIWzITi 6yxX0QTfDPMhnS8r5jsTziBPL5nvkOjPG9+As2/G4RZLQICphZTls/0spt3qTnhvhS+M/b1kcM4o +5fIenvO+7JqsDOm4USDvZX53BinlxnsPFoPSdBXLHeYvbVfsjOc1ug1K9kcLLGfJbqYP1LnCisb z1uezoSGmSbQCGPkgN147qq/DASD24TYxGrz6TUmOq/9EePKM/vWGYxstdjH3Cn0or53FuVRI26R ZJ1Pdt75vfxZUB1FKDE1HOlEmRzGcd1ufMbN7d5n2fwFUEsHCBjns+1FZgAAMEMBAFBLAwQKAAAA AABJtEIzAAAAAAAAAAAAAAAAMAAQAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVu dHMvUmVzb3VyY2VzL1VYDABDnEBDqZhAQ/UBFABQSwMEFAAIAAgASbRCMwAAAAAAAAAAAAAAAEcA EABSb21hbiBJbnB1dCBNZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1Jlc291cmNlcy9Sb21hbiBJ bnB1dCBNZXRob2QucnNyY1VYDABGnEBDqZhAQ/UBFADllbtv00Acx3+hDc/QyLQVDEDMYwJRBZWB KalIihr6VNMKJtQ0sUhIY0eJmxYk4hQQEgsDE6DyKFIRSExsDNCyMKBIEQsTEhUzoslAVZCb43d3 dmz3wT/ASefv7/N73O/isx0AFwBsfw3gxuk6Cv/fOK/mC/GUnM0MD0ciACXmTExMSAGIjgyL5jUS GhwIALtdADsD9Oqi2TwT3Mjt5yL9ISWTVWRJVsOpfDamxpM0sXXfsJKJyWJEzk6qYr+kJpUEuk+e iCuZjlwsJWdiaSnXwZJYDk/psNmYfhma26NJZUrsla6NK7FcQhyKTUiqKrX3pBLSBu9+lhuV5ITY XcANNfwse6MfO9wK8FsSBCA43H46Nu8JvQBbdYAw3ptTdKG2kCIXpJwqjihinzIl5eKxvAR9zsBo NmsERnn7ItD76Yr29A7tZQ7cS33dqWE0vHUU46G+wYtbV4dGh/5V3QVNuINdIMARf6jnzl3PxwNh /9iYuHi61AqHwQMY3wFe8EHQr03Xf+tkVatqS8HFYMnH4+aDhA24eH1ca1y9Atea8I1meIVDda9Q pfijJlQpLi4LPopQ+eyjCC01gSJ41hgCLDMEqHCEFo7g4Wg+rNYgxIlu4kQHI9qZYidprMFRN4sM XDWKTPylM0cDYZV0IjcQeEIDgSdYyBMspAkOxAQH0gQHQpdWLM3Mvn02/+Dd7bXZtRv1hQ8LD5/O P5mbnXv+uDSjFbUisQ2tThxDo09jyYsWzqpeLpdxVvQKKetEr+gIul5B1pEJXitlIvhYvIbqrQlE oHU1oeajdUQQdJpdEXy8TtBxDb4eVZ0uR9fhfcy+7CyNHYEpK3wYSgid9GIIMSJMiRFfMeKcWTE7 HmKrd3MGYh6e2Y8xjRn9iJHaWJsX2Pqxhfg+7Psz6xu7a+zH9nvW/17Y7L9qN86DaHvUpHwF7av0 e4xaoF9t1JvxcTmDeg/5GOqj/u4B+pl5MZ2RJ1HfpOJ56n+Pegb1E+pZ1C9p7v+e5v6fae7/AyXr LQrwt+GCzY6bb9oYwHXmdzH/K8t27bHZ9y17W5vNvmSzv1rrNy1ZdvNxm/2S2n8BUEsHCINKrUEu AwAAzgcAAFBLAwQKAAAAAABJtEIzAAAAAAAAAAAAAAAANAAQAFJvbWFuIElucHV0IE1ldGhvZC5j b21wb25lbnQvQ29udGVudHMvU2hhcmVkU3VwcG9ydC9VWAwANpxAQ6mYQEP1ARQAUEsDBAoAAAAA AEm0QjMAAAAAAAAAAAAAAABKABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50 cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9VWAwANpxAQ6mYQEP1ARQAUEsD BAoAAAAAAEm0QjMAAAAAAAAAAAAAAABTABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9D b250ZW50cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9VWAwA NpxAQ6mYQEP1ARQAUEsDBBQACAAIAEm0QjMAAAAAAAAAAAAAAABdABAAUm9tYW4gSW5wdXQgTWV0 aG9kLmNvbXBvbmVudC9Db250ZW50cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFw cC9Db250ZW50cy9JbmZvLnBsaXN0VVgMAEacQEOpmEBD9QEUAJ2TUU+zMBSGr92vqFy7lplo/Ayy uDENCVMymImXFY7QDNqmdE7+/XcYGuMmMZG70vO+5zlvW2/6XlfkDUwjlLxxJtR1CMhM5UIWN846 vRtfOVN/5J0Gj/P0OV4QXYnGkng9i8I5ccaM3WpdAZmrWm8tGMaCNCBxFCYpQTPGFg8OcUpr9TVj u92O8q6cZqruChsWG6XB2DZC1zEKaG5zB/v1bb5x4d9cZNYfnXgbaP353Wwr8woCeINK6RqkXUGB 1R7rtrGqsQan8BeyQLPSYx/rA/3iHbKt5S8VHApXquaShEuyDhMwyDJkcQ82lK8q2W8OuEiMhyzB lipHP9Ibfg5IJi51+eQMY9StEUVpyeTf1cX43HUvyIoLWfMNVq+gAW6yEt0yOgQT5piEeBUd7ncS DJ2aTzO659pj9VQ0XP42ZzdkgEeAxNy0Tz37YZdL6g7pH3j995Bjnm14AWmrjzxu4zgakiWlMvYD 9ecD6rMf1ItCcrs1R02n+A2JBqLpOh1KomSGgxVGofBRVu2R5kvgsf7+e2z/OvzRf1BLBwgJMPPT mwEAAL0DAABQSwMECgAAAAAASbRCMwAAAAAAAAAAAAAAAFkAEABSb21hbiBJbnB1dCBNZXRob2Qu Y29tcG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0Nv bnRlbnRzL01hY09TL1VYDAA2nEBDqZhAQ/UBFABQSwMEFAAIAAgASbRCMwAAAAAAAAAAAAAAAGoA EABSb21hbiBJbnB1dCBNZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9t YW4gSU0gVUlTZXJ2ZXIuYXBwL0NvbnRlbnRzL01hY09TL1JvbWFuIElNIFVJU2VydmVyVVgMAEac QEOpmEBD9QEUAO19f3RcxZVmdasltay2EbZsDJZFy5aNDbYkQEmecNuRWrLdQrKRLRkEOG61up+k jlvdTfeT3cq07JYxsyYxE3njmaPMYEewwAlnPBlnDpndnCSOSUgGZskecpachU3I2gcySw4wwyyw B+YYa79bVa+7+ofUIjP71/iZ0rt1761bt27dulX1XvXj6nv/8t8YY0uZuKxIDsbKpnF/BMmCpHm9 PW07tz+wfe89TLmq2ByXTZSzVnu9fdv7+3LLtEqY38uRSuWdeb2GnjAy3Pnlb3AxdtvLYHdJXfmV 4lWaZaJBf3x8dDAS8saNscF8Ge12cb/Tni2DSTyr93oVAQX1KCqjWtGDpNxeQIYT7UCRO53SBmZb TBlOr9cfN2LB8PCc9rh7BuaGjLtmVD1UGDIi4XjGqPky7qH6f87YF+luYQUurzcUNPSYL6TNKeNt xjv3i3QvUQg2BZY+0dHW16aW7WEZv+A+VS5lSJ8I+Ayfqkuh8swp/Um1gVImHDK7NGrECsmgttdD hjNHRhmSS9rAV0RGB/68DxkdOTKoHdtlW8ZDgfnasqcZf2oYa2ueuy3+IdUpCsgggzRBRk+2DKsi YzAez5KZJyOFP6/mFVT8g/xqdDQSnlvG3gH8OSkzOX6QBSO+dHfu7tre0Zn2KSq6olv0Ld25Dc1y JGsJ43ZijsaxeKwxFBxszJgW8Yv1I61s37LjYRqU1ILG3vG4oY82dgcHY77YeOOOmG9UPxyJHYw3 tvtig5Fww5CJabxXj8WDGDWNbZKWkdsk5G5/ie0XGqXrRxpNNLQ1QI/gYJq/Oc3fb7Hm8guVGtxK GbL1SunTU4zdj/HkoGZVMokke8m0HGkXUjub87rvLfyZxB0xM2tcrmB8sN17UZan+HNe2niDiLPX rmJX8q7KhFY3e6WvjjVTh0zBeqfrZi+mvoIO+nNm2+Jnlvv+qOqu5FP/s3rrAGO+gzckJ4Ilz+xO 2eqOXmL2pN36zI8nZ99HOTvKzbi/xUqPvm19JplclUieWZtIXrgt4WGli11exr5xTIvy+5Oawe8/ 0RJ0T7m1qclj8CuMtLazzDHxqJAvadOFaB522y6iTx7TUil4aWMK9Asq3XLZw6yvu46iHf47q7VJ pnmY7Y2Uj2mND3NZdsjYSG2W9ZyegudOTkDW1xABL7DjHsY6ILcRsD1597LExJquxIkKxlo2MkuS lY+1Hpt9q/GrXFa1tohZSM6UVUuinIPgU4NaMlUrdIMMx9GffwBbsGq6Hy9jNo4/O/vx0YffTBx9 6p3E0Z99kNB+zmweVv6sh9266wRGDNXT9uTscy23McvE4IOJllbGumZnQ2R3svXECeszW2GbpL3k mZaTt9bL9jsL08v3z08vVr7k2/PTLcb8dNY/P33j8fnp1ldU+jcuz17J9TvR303Pif62vjeJu+kT Wh0bSFnIZ0ueeRhld6fYXPVcNOs5USL6YNcx8A6uSpA/kB9qbmahftYG4QvAn7AKPvjEJZJ7AhE+ aUX+SeYC34Zkiec7oBtHU/3oc+ak8snOZYmkreo7yUpRThtgFiqLO+MyRN0oU0V+8q4m+v5FPuZ8 s+/Ktqey2974tmi75Z9l/gryLhoP0jY0FlqR/6XMb0K+A/nnZb4beQ/y3yXbyXH3Guzm4mPsLHsZ cKuELwLukPBzgD0SNv2kLjmxarztSTa95SJWVt9CQh1Hf/pBArJdJk/X7NUz2uNNI7j/go/NC2y/ 5Gk1eeSY7dD+oimqzTAbaB05tA3AeUzcJtgO9VYnQ4hDQTMmsKotv2WWo2feJ3sm4Q8p0x9+AHvO 7Q9XW+f3y0/fLuL3UZNOMXTy4J7mTYgx3f+Avp5hu12w2cDxrhT63Yp4ZMPiywo2hvwW5C2Up1hL aSt4U449zcmKkmcI9p2sYopcTcZmrsePn5/92BwfyW2ViakjLDF1liXJz7QU2+Bht2xMDqxKTNUy LXUAqRZ0K7NJOAnYTjB02ECxURuwbPaw9WNUhvDAVREudZb8bf2PUnXQzbQn6p7bnusfn99e62uK 0JMqfc520nyGtgm91/1ItrVVQ8KdxqWBdrhSbor/aDfaf/QYxWTWreDtZAuJb+Z4q5DL7QQbEI7s I/MU7zeQP3pY/e9NORr4qE6zvIz9x1OkD/RL2kowN6wbR16TY6hZynPIfI2ZTx1hWtJRkjB9nfIo u3rh9q+/Mr99i9KL9E/9/vn6x4xXsE+nmHubEmiXnds00/6V1N4Z+GMfs227LcWsbWdYDfFrg58O eNjavxLwVcSqtc8vvO1rZ+bXfe1AEfrMQnwPbXvMw6oeSo8v2S74UA3wzxI+WUJ9bi0tzHO9JcNz fSE5VfDflgJ4rGvWPkR5KjuXXRS9U2qfyDHTIe+t5hgS/dTwMs9bzTVTOm+TfB5575b3Hnnvk/d+ 3mfWJnvLNvAiZpHfc1lPNrw9sb4roV1iDPrfbo5VGh+yXQ6Nzc6SbsB1SFy9h635neR1Ae9SeK/m 8DZRfYhVrYi5qGPNaAHbUblPc8o5ZVvfpXGLseaieJcspX5Z06n4q0OMwzXfM3WWOMy1a56g9v8h /UE6TteyaeHrpU/BNmNS727EsQGSqaUsU9oM0kXLy9oly63g+SXR0F47BZuB41hrlAo7az9p+Db0 2SNl9EHXPtnOfhc7HBxg4QD1E/T14L6fl3E3fJvaLnxx7XIqqx1g/bw9iJWwpyW5YxnvuxbG+++U KZ/afb6Wryc2zOBOYxllud7JjmXk/xtNvJBvWyzL9kC3HmnHqKnHJPaYJn8fw76kQrbL2nAu2Wmt hl8NyH2MNtWGNYb/wcREfVcidQG+eBHzntSxxYnUSrrWPZK2xRHW42HOjxSbjLiYPzzAjJC0iYVs YtYvdTrH9WhdWp2xUd2p4jZK+1/fzAGMBeysyU5K3dVmPYh9Da1nrr6g0DacgE/0sbJtMr8yv5+c vyD+BfrcedXnhKxNzeY81ZaWL3BS/ugfJve23+TLFTgp91fF5V69lDtGps5aXOdrLZrwhY0nYXsN fXwg2U5rbMyV67og++bXJb0B9D8rQP++0GdjPekzuYbZZtx8Xvrw1Db28fkD7MoM6jD7pO2MpdnM 91ntLo1irttaPSP2As01jC3DHqBZs86+T/nUAehoJf/NL4P9wIGschXl88pOWjHurbOzOTJ+mKZX WKtl3e8pdVvpznk4jVUpNNt89aG/SineyvJWWT6mlC/DfOTKoVfl0GtSRywurD0ZxWCMRybi/c11 C/Clmdw+x3iRY7/eQXEc4yWR6RvWZObJVinZHrlPMxBTXRQncN/K93ECpna7zHlJmymDbqtLzXl4 AX4p1wAW8sfk1AVLSmOvh/k8dsSCNUHNJ+m5iudrK5Q5yDVVa/GY8QY289CaE2PEY8ZlBYc5np2T c49H5h9HLP1eeo07QPtT+0TX7JWHQEtJXovkjWo0x0EHV2rz5oHjmze7ZvzGwNOxkOwTG8Uoiq3Q +XcF5uImmh8xhjyZOL56AjGpk2KSXNc8oZZbYByaUvsYa6kTWEudnLrApqZ+y06baxHIm5LxY5Oy TrHzdQvF0CNsiuZ5xPyOZBnpsroOa8mTmnv28SnEZJTvh4/YMX5HgO/va626S4x7dtqM4+k8W1pN ey1a7zH+fJ3RE94E0lOMPytnryDBiy0YtpZNVD+1la8Zjq0PwM9h75rLHlbG+0ba7/2u2X+ZRD+8 LdYW4MtaV6XzNvC8gLLjSlk7yp4B7rKCm/GwinHwTgO/S64ZcnyZ/KEmvV4Eb4ho4L+/a/aTj5Df L3ymrBPyaUx0A56YW9aq9xRZTinrUfjcN2mfLWVBJ/vlz7AW5fMFyr5IMQI+9N2Fj7102Zdk2bHP UJaPW9nWhPQp3l7tLJPtvelTs73A/73Y81qvT/s4X/ut/P4f6uumH/P+t65NKbZGP9w0ma5bjO3/ mlmDWn9VYP3bqqxBm5U1ffeUWGOIetxrU3J90oGx4qH1iYfd+JFoyw3vkbyFteXTmexxa02kDlhp T8cQI1ozMeKmGyXeph2wqHgL5VvWMAtiSCvFEF5OzGnAWThuYm0X5xftvvExzmst22bSk1ZrNd2n Zfs069pXeR+m2Kwsk46/gP+KnttJe3JbJ7fz9u9Lx2S51gfusrDJitcXbpPCsWyOfZG5X/Lwfhms m+6avWrGT+ovT84eKL02bqUYKPY1WGPfeL+5NwC9O2cvpJahONlHa2S0qxtlT6D/T1LdL66p4zq8 6K7ziPXxyqfNONOWLatP4qrMdaaHLf++qavc+0Cn5U+bukgc/Hn5KdLlXzsn5Ngyx4bOnq7ZT7/0 2W24cvkCbdgjxpCzjz8nwpyUa8+tX4QdNzrt/N7p5O8QMK72zWHPHLtVj+bbrfr++exGNoO9XuGx zHx24cFaCTyuu2k+q6unPcw0zTMiv87Mq/vThctzvkrrKXPOX2hZGWc9UsY0xrGHdPiMdd//b1D3 6kJ1z+d/svwJ0fern8uet9N5m5rH2teek1+k5Mn+DrG/r2zysGV/SnWI9cfNb5myNevNdsTE7kzM XPGesnY0n19ok9tYt8nP46V8vqI9efMllBlXynSLMbtiu1I+oTwDcMlnAK3KHrhD7oE9Ur9LmX3b 0k+TwYzeMva7TB0wj1mz97/LCj1/qfIwS0UBPO13T+Tvd9X6r3/js64zsveltY78fanASfkTf5jc 1c/lyxU4Kfd3c8p9YvbDgmuFARvZ7zH12T3fv5CvsA73ANu3U66JrdRnss795nxMz95MPxL73mVP 5K8hLDOi3KpNyh5Q7h8s/Uo9FHcXUQzLqacb9fTl1NOirFlbM/PGMouCXynGxqom2SYHvTNVcHy8 4F65sDqX/kyRXZ+pcym3Xx+Gpik7M25XNWHvz0yY1ivJyiXRiYOW0yYONrHzffYiudYXuEUcZ8/g EKMc5Le0fuC6Hruhj/SaGHowMbGzNyH2WJWL0cYmjF3B477hIn/+MMhsk25mn3Ezx1QFY6eCzHaq k9nPd2I+yKz1tIcv8D0P1idL+frm6H96J0FrYNeMoQ88nTBoD5S6yuktBdaKNH97pC9+kv880/Gz gmse+GbaT9Pv/z8eyPfTKnP/2E97rQJ+Ss/rSnAPiLbf9JzsywH05Uh2X1aZ67f90Gm/0L+0WpY7 b84HQn/b+wK/8ni+/9qeEv2z8gTK1GTKiNhJeJSp5X1ZafYlxznFs5USWjeGzH2edmz5hgkd/bme dKxoo/e90D0k4vDybjo30OJkd2U/a1q8S9FhjaLDJhMPH6zXai1qPSdEWfsbqAPj2CLqcC8/rfrL pDXbX05VMIpjVSfcrBr4qulOczzxujcodQdMPPg3CZ+47mdXsLXWaq2h12rLU6kDSEfKjye/jL1V 57LEFPJTyL90oTx1hY1MKbqe436+ozdxxcmmoPNGYReraZcXpF3qsu3i+JyiW5OiW7+Jf9GKPU1t yWfV5+1sfcq/KfQpkfqsYIX1qXxa0cel6NOs+MW2jF/YlP5aUS9klG9GXZ6WbTbZXyu0hfQX6NVY W66kPgOteqrTjI1cl9Y5dHFndClVdekTupQ9IXQpNXUZ+TfQpWMOH5JxZfGk8KGyz9hnK45n91np 76B7T8u2MlP3Bfk96f4odEccvdHU/5vQH3H0RmWsVaXhwcz4gD1vyo7zHLfSjPNbLrDQlrOWEI0P Wv+TX+LuIj/AvZX6APcOajvuFKf7ZdvOq/PA0WffSRz96pt0VorOlbRiLuiXY3tlsbmAnreI2Oqk tSXLxEY+N4xQnRhXb8wzNxB9dX5s5XPDiOjDSlpf9StzA8qUPUu8eXMD5oMCa5hUzj5uGvu4x7GP m5HPSDsg83GMlV8pz1SQt6vv91r5PJF+RsoC+c9I0zjE+ZJpOc/JZ6QlJ7pm3/uFlNdBz6i6Zj/4 Vdfs/90KWkjyyjmiZL9G+zLoUPwZafnzpkz1vSHt1bKfkVZ8ks9n/ZDmX1cr5kP3vp101kfUb/0N rdFpfkSbBhqPMVvbWSs9xx5AOVvbGYxHgSd968F/TtIWga9V0irbzlqmQZsSvrR0JP1+YDV/Jt4j +raCP18y3ykcPUP2s+5X6D6VTuVNeefTz0ozsk0fuk3oeQm67M88Y7XWZD9jRT77GWs1E2dO6Tkr Hfo+Lfiqp801sxg/Ve9Crwp6tl2Yfr0NvvN70AfmoFeD/hKNtTnosKn9WXq2OQfdBfqjknbaXNd0 zX7Ymd/Hlir42OsmHutnpon3jfAtf3TgeMyAb0XhW4b0LWvGt0r1GVqzivVLNY1JuQfr5+8tWmdn zWfatBfAeO/J9Fv5s2a/8b0Rf29kraY7xQFx5sT+CMbAn2Z0YwHkH1Hyfbn9q7xHQLve2VzI9xW7 WIRdPnpd5ZtvPUkxIin361sxlltOViUnT4ozoJB9PHe/lfQuozMXIcSS6NRvmTF1lSVO1bLkqW0s deoAO45YMyL214s3QedddCZM6FeVPHWMv9MfmQQfYm5qEuUQDxMpyElBXgpyc/dnWec/EOuSgVWZ uAY+tNkL3aKaj7VMW2gNXf4EYC15ZBX1yT7Xt2BHOh975KZq7bgjBdwk6UNn3rY86ThJZ0GB20Vn 2FqPod4jl7/Dz4f+lM6Plo8hndLq2BTpRLGW9CLbsTmu9DOQEeszWw+KcyyPfG1x/hmebDqbn+54 qwj9xSL0c0XoU0Xo+WdNs+n5Z02z6a4idGcRum1+emX+mcBs+stF6OeL0E8XoSeK0PPPAmfT8888 ZtPzzwpn0+3z0xe9W4T+ShH6c0Xo00XoySL0/HNg2fSOIvQNReiO+ekV7xehv1qE/l+K0PPPYGbT U0XogSJ0TxH6piL0qvnp9g+L0F8rQv9hEXr+OcFsev5Z9Wz6SBF6dxF6UxF69fz08o+L0H9ThH6x CP2pIvQTReihIvSeIvTmIvSV89PL8s+4ZtMvFaG/UISe/q0EzcHid3Pe0UjAa+ixUe/QWNgfV/C+ g7o3oId84zpnGgvp3mA4aAR9oeBX9JjX7wuF4oqc4KhvWPf6I2NhI40b1g2JD/tGdVYAP6L7AnrM xO/u7Y5EDo5Fe/kvAjvDncSj1LG7ty0QiOnx+D1DgoVooeBgZPDLfvDQrRMqYoE4ojsP6rGwHnLG x6LRSMxwDkViTgPowDh0CfqdoWAYHM5g3BmOGM4opOphw2lEnLGxMBiBj8YiwzHfaMMixvyR0YaY Lxgmo8Qa9kZGfeHOcHTM2KUbI5FAQ+eufZ29euwQWsLY7Xfc2fy5z39Ba2navHXPfdv39t2/r/Oe nge/tL+tt2PHTs/dXd1bbnmgv/1e9+5dmxoanczd26uHA9sPofoeX0g3DLR4rz7UHgk7tzrXhQKL +vSE4bxnaCiuGwLjvNUZRx9EhjbsCwfbR3yxjYt6/bFg1HC2RwK6LNXtCw+PwXxZOFg7GB52bg8M cxT/aR9kjEZD+ijq1wmRI6qApEAODxkwHtX9waGgns+eRYX8HZGwYVYu4VwWtiOY0APOnkgQ5F40 lfiHCuPzy4YiPqNQ2Xx8XtnuYFh3evTg8EhaxRxcdhFOa4v79XAOfxqXzc+7si08HJJaZeVztNmr x8dCWV26V4+GxmUL8qkCv9W5YV1gE1TZuGhdPP8/6Ld8XzTgM/Q2vxE8pHMvbovpPsYqhYv1RXoi fFxX4t4XEUjKV/eORA57ggHdHTGMyOh9wXAgchj463bqRq8e0v1wnz75S/N4NAZlhlh9d4e7+/Y7 NDlO5U8zGf1qcjFbymqYCxtPK3I2VsrKWDmzswq2iFUyx5z4xXNQCmEtc/6zzvmvpOA/W4F/6V+X Y09UP9dOhy76PfnNj6NHp8WvbffO5PNs/KG4752Wd/DUvPvvKX39UhVDsmfbhWjmVf4idu10tm3j 3PnuTSzz3YVr17Xr2nXtunZdu65d165r17Xr2nXtunZdu/4/X2UfLOE72Z4q7EvXLuH7/hs/BNwi 4Jv2A94p4dOAH5Dw+4C/vKSSYPpuWfnXl/DnDF0pwGckXgP8t7Wcf7UN8EsCrjkH+NcCviEJ+E2J xx66/IqQv7qaMfvNEr4CeLvgcSYAdwm4rgmwd8liXhfqtT8k+Dck6SdtEn8c8DeX0Jfc+Lfu7E9L +FbA35XwCcA/EmXXvQX4NwK+5TXAn4i61lxkrGKFgNedBLxZwmh7RYeA6dlIxYOi7GYD8EEBN0B+ xaMCbnwF8HnBv4nKviDg26js2xL/bcYWWSX+Y8C3iLbsbQXcJuE2wPsFz+39gB+R8KuA/1rC6NlF L0oYfbfonwV8B/q6cpWU0wH4VukDKwFvlXgPPVkTOm+dBhyV+G7AXxf4ZtRV+V0BfwE2r3xFyu8B /I8CbgbeUSbhesC1Ug54HLcIfNvLgFsE7Eb/OnbVLuE89IzJdp2dvlXGP3/mkDB9A676Os5Pz6vY XRJP31zbUcK/bca/JfjAdUsI4N+ie0jC9OzzTyQ8Avg5CdMz+r+TcBTwZQnTc8IrEoZulhsljHZZ 7pQwfM/SJ2H4m+WQhNHvlj+XMHzG8gOpJ6xteeE60cYZwK9JninAvxftom+wWf7Jwizyu3eWqxnY 6lDgGgX+vALvUeC4Aj+mwNMKfE6Bn1fgXyrwuxm4pFyBb1FgtwLvV+BRBZ5U4D9T4L9U4O8r8EUF fkWB/7cCf5SBbWUKfIMCr1fgZgXeqcBfUuCgAo8p8FctrMSEzyjwDxX41wq/0o+2Kxm4dLkCr1Ng pR9Lv6jAdyvwvZb0JxFLE5l6S//Ckv7UX+k5Bf6pwvMPGbjMocA3KXCrAo8ocESBDyvw0UxdZX+s 4E8q8H/M6Fz2rAJfVMr+d4X/1wr8pgK/Y8I1CLRrmG0YKYz0v5AuIV1G+v0aVnoM6TTS42tYWQ3S 55DuQnIjjSBYHEb6BtJppO85mKUR6b4aZvk/uP8PpDeQLiG9h/SPDmbtRboXqd/BSmodzPaDama9 3sFKKXruRnoQacDByvbUMJsPd8go+9TByh3VrOTXuP9npDfXMPuXMZ4fQfpjGstI65E20Phl/DNW 1q3w5/uR/gn+gjmutAVpD9JP1rCK3Uj3YF7C3GF/GAnzSeXfIP1YfPvzK0h7BuQ9Ku7sPyD9ERJi E0MZdgTpKOPfhuRfyEScYseY+OYvxbu9SPuQ7mUi8I4ycaYQOrEvIVHcpC9gjiM9hkQxFW1i9Frx IBLF0iASvXahV1r0Cc17pI3om5UPIMWlvXqZ+F7nfUhoI/9mKL1LpS+c+pn4vTh9HdOHNMbEx0G9 SIeQDiB9HYni9Z8gPYQUQfoaEmzLJpCSKeE0j8r7V5Hu/ndoE+bd3d8WG/bL+yHmpY/rxg4Hw95h v/9ObzSmx/ThYNzQY17+MVRvMDwUIS56v8zfi3u9oyNePaH7x4zMG3G/z/AT1q9HjWAk7I35gnF9 DrQ3bviM+YneYEAPG0FjHFyhiP+g1xfyxUa9MXqlyLyBiHfUh6LhiBEcGvcGoIN4ZZ9LCUe8cT0M BeN5JHrLTgcGdHqNnEukQt5I2C8kxvWHwpH4PFUWYMipuQBHngIFeBQ99PChYCwSZt5h5cVnjw9d hBpiul8PHoLtfPRuPM5gw5jBvG4y3a7IIb2DPp/sbd9B9/aYzq0vcjt1wz1uoAjyu/R43Des90Ax wdQd8ftCBSl79dGIEJJPGgt3RyLR3shYzJ/LQUcH9uoPjelxgyh70XpfnDPJUm2BQKagxEHF9rFY DP5AyF7+3eO2aBSiMnlR9a4xwzcY0tsj0fFc0n1BY6RdIAqRenxxNDWXTq+K+Tvg7WF/JCBIvIhb P6SH3GOGEQm3R8JGLBIyKbv1w/JVs4kIDu7VhzCoeC+aNRLHjlhkFFTm7QjGo5F4DmdHzHf49rTw HcHEHf3MS6YQKPd4Z4ea5wcy+nyxYd1Q0dlMfUEjpKuIe32hMYHg5dtDvng8k+0KkonNHPc1OGuM o0QTsmqll+1m2+lcCzotHokRDHcMCQ09vnAgRCLyz8YA1RkX8G5U1KEPBcN6gDrHE6SuN0/btIUD btQiOBWyflitYV9PD3Bjo30Rs1PhTfCaUBBRB8GG85J3MW9v2hximPTmmgeIvbrf4MB90oZ0usBs rBcO004fWPeFDelYZEilM73eg/r46HDMGzjsiw3d4U2H2Djk0lemFZbhUGSQRp3Xb4zEKMzQMSZv LDJmwB7m0aJMjB4L+71DkZjXF5CHmuZmiWHQIkiYXFyuqJRlatcNLyzo5UEXId+PLjqMjpXfO5dc cck1Fi7M5xuMUPyBqyeCBuOHryKYcvRYLIy5RCCHYjq0OJge5u38U+K7IgEKRhk0/MA3FjIIz0Rs zLbHqJQ9qo/6adjHjZh5D+kIl1E6ZwIrGJEFTnSkLD9mxusRx8y8fsTqQYQqEfIpB/mDKB9Gq40R s1j6SBfvgZDvK+Pm5+IH4StwDIRxIzYulGIwB3plVIRHUYT3VYj7uam52Z8KKX2IjTT0j+j+g8CI mM/x/P95YNY4ooeiJEU2fiyMvwFRPu0z3hHILcii+ozkGvUFYVd3b2f6eJ08TOYd7tLHByO+WMA8 GQauHFR2FBgWMRRxseHOlobPf66ppZnDGofv5PAXOHwHyULcMcWJgu7IWDgQF4PT3SuCazaHHK6q tgWUpNBVAE2DvABanfLQ624f2V9UTrjd3EdoqpOMfRFxegkeHo2E+Tw2H5Vi2l6x0BGH7eTZPeEm EpejFhqABVMOj7JQyKHkHuHLKT7cGS8on1MKl5Xd0xMzg158Thn5jHOLzPSaUkC0YoF15TLOVdew OKIWR8wPYtYblksOZSIczjv46M0/DJnj3/OThXbmvBrvxco36KdDael5n3NIzQqS1UGYrx35dUGt 4dj5eIowPHzL83D8OFwv/e9PvF4RUzA7wM1DiBvUOOVMnjhZSvuL/wdQSwcI5caM5fYfAABMZgAA UEsDBBQACAAIAEm0QjMAAAAAAAAAAAAAAABaABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVu dC9Db250ZW50cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9Q a2dJbmZvVVgMAEacQEOpmEBD9QEUAHMMCPCxBwIAUEsHCEkEilsIAAAACAAAAFBLAwQKAAAAAABJ tEIzAAAAAAAAAAAAAAAAXQAQAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMv U2hhcmVkU3VwcG9ydC9Sb21hbiBJTSBVSVNlcnZlci5hcHAvQ29udGVudHMvUmVzb3VyY2VzL1VY DAA2nEBDqZhAQ/UBFABQSwMECgAAAAAASbRCMwAAAAAAAAAAAAAAAHQAEABSb21hbiBJbnB1dCBN ZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIu YXBwL0NvbnRlbnRzL1Jlc291cmNlcy9CU1NlbmRFdmVudFBhbGV0dGUubmliL1VYDAA2nEBDqZhA Q/UBFABQSwMEFAAIAAgASbRCMwAAAAAAAAAAAAAAAH8AEABSb21hbiBJbnB1dCBNZXRob2QuY29t cG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0NvbnRl bnRzL1Jlc291cmNlcy9CU1NlbmRFdmVudFBhbGV0dGUubmliL2NsYXNzZXMubmliVVgMAEacQEOp mEBD9QEUAKvm8nRyzkksLk4tVrBV0NC0BvLDUouKM/PzgHxDa65aLgBQSwcIMQkzXSIAAAAjAAAA UEsDBBQACAAIAEm0QjMAAAAAAAAAAAAAAAB8ABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVu dC9Db250ZW50cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9S ZXNvdXJjZXMvQlNTZW5kRXZlbnRQYWxldHRlLm5pYi9pbmZvLm5pYlVYDABGnEBDqZhAQ/UBFACl kUFvgkAQhc/1V0y5y4IglWbFVNCEhBQSsUmPCBtLBZYsY6n/vksVUm166m139nvvzezQxWdZwAcT Tc6ruaKrmgKsSnmWV/u5so3X45mycEb03gvd+DVaQV3kDUK0XQa+C8qYkKe6Lhi4vKyPyAQhXuxB FPibGKQZIatnBZQ3xPqRkLZt1aTD1ZSXHdiQSPCaCTwF0nUsBWqGmSLzzjFXfclqlqfojO7ogZ0c f+nx9FiyCgOeJigxSrq6fG5QyPYd3TZAn2pgmgaY1gNoYMnCZKaBbdhAyQUb/NYiKVnLxQFezrm3 hqZhq9pvncw/sCzcvbMUm0GTCJF0hzuaV8j2TDi6ZVHSXyRBeuTiExYZazDcDBY9O7mSXeCaVf+P 3JwaZOVf887W+vR2XEzEnuHwVbcSf+kmYserH0Cvp+S8Pkq+l+uMvgBQSwcI4gjmlEcBAAB8AgAA UEsDBBQACAAIAEm0QjMAAAAAAAAAAAAAAAB/ABAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVu dC9Db250ZW50cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9S ZXNvdXJjZXMvQlNTZW5kRXZlbnRQYWxldHRlLm5pYi9vYmplY3RzLnhpYlVYDABGnEBDqZhAQ/UB FADtWltv2zYUfu+vIPQwbA9bdLWlzXERu00boGuKOOmAvQy0xCTsJNIQqVz663coyYkki5TtLGkH 7CVIRJ7D8537ITN5fZel6IbkgnJ2aDm/2BYSErMEp5yRQ+ueCOv19NWEL7+QWKI4xUIcWh8XJ7PT 8ssbLLE1fYXQRMicsivEcAZkEudXRB7n8Mctz/+2piezOc6XnD18mhxUBCVtzb2izTmXFXPr8bx5 ISTP1p9pAqKWx3YPjst9c0VmTT8ujlarlMZYArjWgQfVieXvOM/xPYp5weSh5QL+ihNO0+o4sT6o rYM1oj8oS/htLdNoVG/uynVb7jpT0k+DkY+isYsiJ0JOYIeoKdomqaQyJdb09PJSEHnOP3GxsX9D f3POZM5TqyvsWXOtknj8IHH34CWoJAH0NrKRFwQo8EYbonZpbii5LW1ckSkSRdpD1lK7s9a6KJaK hWgIpdX8u5wXqxm/q5C4tt0i0qEJkQtwPIDj9MExQgLKEPkRYHLHOtoWrsiIy4BtVkjJWW2jqItM j84NPeTbDvJsDwW2rRHSCNILHeSOAxRFSlMGBlzI+xVZB17lVQt6xbAscuDzZnbxDgKt3NRDTZls k568sab+5AC+DwlbR8SCsAS9vSFMGoR8PGZZqvQcpLGmTu85zbSwhY0+8RX4X9NQ4faG8l3khWjk Ine0mQC2sJITIs9Hrme/vJH6ldfaLUgKCiPJiSQZOKWOoJW3MsKKjYT1e/mxUq7Xo1yNa5Sm+VWv lm6cBus4pSDwZpC2xe0RscRZi+lryIHBkvOUYFaflVCBlylJrOn52cXbyUG9qqXuA3qxSrAkR7Gk N+SErQp5lBNswq338p1AutuCjK9J/PfTMBoq3zMgc17SfADpnFf4XgBa8JLQFtf89j1NyIxDgsyq LukFMI5eEuM7Ihd1pjsnd08w4eSgTEc9KVJXknYrVd1Wqc8T+uvUuKxT7miM3CDas1BBv+u6DnKi vkbwgcEODeEA2oWEjj9WFqnxen11WY85ClEAIgfQB/meQWQz7hFoDTmh6vEHmTypSpcceiu1rvCW FO1wIKyOhuOjD4uhcOjQigyGpa3iaFPMBf2q7cdKCm3U6GOmN9NiZRYJg67BBduwVjnNcH4/pJIn haJnR7uEojuOyljcs7VXIfytg9Fzdg5GF2RV0eiH/n85Gr3/o3EdjWdEFKn81qE4V73pYyg6fU1t v1N6dogcGLE914dIMnml1iNhUPcgiiMIRd09RCX6Mwxwtm4g28eTdvWiXof4QHCiPr5NrshW0zxl VFKcquzyb83zm5mqb+LU3buMK4cAkzow2+/nECq9e5CiTBnq29momlO0U/WO2v5AJXA9ynMO9aTW d9/orL/ncvwx6DuA+NmrGDruuLznAm27RoM9RwRucYeSgYtnRfYZpwWc8rNj29qwbRDhuwaRlubJ kbH9AKEiAyaIMtfte9Ol4gKM/J3GxYJIVLaXwnDj1DjpSyEkvayfJZRln8dEfZOwIXmNKhu52ptt s5H8ykrBd5u9frxgdH6Nc/HTbgmst7HZ4z56k3uHc3dDR1U5iQm9IdWFn9B1Qh2iayzmPE3xShDV 52xN9J7n9CuoGqd/cp5tSUcFtHX0q+pctz/pM8nBb3c6J+bZigso/+xK4zpNh2k80tXPgmHLbRp7 5TXJyCwvxDUMW+1NHblpQk7ZcZGmizgnhPWK0bbnJCeXJCcsJhCeZ+Syeno70C6GtmnRMS26pkXP tOibFgPT4siwGBmgqFc7w6LhTHWpo11UY7V+0TFROgb1qY7QsGhQn6qYhsVafY2MYHiWhloDOebh WXpT4QZbjAyGMtpiwHOMi8/E1rBohmIKvCc4pInS6JADZz7vYtPnEhqrngQm7Y0HbPXzvErtFce6 ws0WquyVVe8TTomUnfHN7IP1zmOakh8wJPXfBDq9ZSQf5NHl0HwOGCRueE4PuXpNGGbhD7Fwhnm4 QzzcYR5GTZQ8thAkGGayBZcNs/Y8lA9zeXDLR2cs/y6YgJmLJH891msG3W71Pzrl9ZoDNbu5a/rq sQT/A1BLBwjgkYAOBQYAAOgkAABQSwECFQMKAAAAAADztUIzAAAAAAAAAAAAAAAAHQAMAAAAAAAA AABA7UEAAAAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9VWAgAQ5xAQ8qbQENQSwECFQMK AAAAAABJtEIzAAAAAAAAAAAAAAAAJgAMAAAAAAAAAABA7UFLAAAAUm9tYW4gSW5wdXQgTWV0aG9k LmNvbXBvbmVudC9Db250ZW50cy9VWAgAQ5xAQ6mYQENQSwECFQMUAAgACABDtEIzRq6D9pMBAACe AwAAMAAMAAAAAAAAAABApIGfAAAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50 cy9JbmZvLnBsaXN0VVgIAEacQEOemEBDUEsBAhUDCgAAAAAA87VCMwAAAAAAAAAAAAAAACwADAAA AAAAAAAAQO1BoAIAAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvTWFjT1Mv VVgIADacQEPJm0BDUEsBAhUDFAAIAAgA87VCMxjns+1FZgAAMEMBAD4ADAAAAAAAAAAAQO2B+gIA AFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvTWFjT1MvUm9tYW4gSW5wdXQg TWV0aG9kVVgIAEacQEPJm0BDUEsBAhUDCgAAAAAASbRCMwAAAAAAAAAAAAAAADAADAAAAAAAAAAA QO1Bu2kAAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvUmVzb3VyY2VzL1VY CABDnEBDqZhAQ1BLAQIVAxQACAAIAEm0QjODSq1BLgMAAM4HAABHAAwAAAAAAAAAAECkgRlqAABS b21hbiBJbnB1dCBNZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1Jlc291cmNlcy9Sb21hbiBJbnB1 dCBNZXRob2QucnNyY1VYCABGnEBDqZhAQ1BLAQIVAwoAAAAAAEm0QjMAAAAAAAAAAAAAAAA0AAwA AAAAAAAAAEDtQcxtAABSb21hbiBJbnB1dCBNZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1NoYXJl ZFN1cHBvcnQvVVgIADacQEOpmEBDUEsBAhUDCgAAAAAASbRCMwAAAAAAAAAAAAAAAEoADAAAAAAA AAAAQO1BLm4AAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvU2hhcmVkU3Vw cG9ydC9Sb21hbiBJTSBVSVNlcnZlci5hcHAvVVgIADacQEOpmEBDUEsBAhUDCgAAAAAASbRCMwAA AAAAAAAAAAAAAFMADAAAAAAAAAAAQO1Bpm4AAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQv Q29udGVudHMvU2hhcmVkU3VwcG9ydC9Sb21hbiBJTSBVSVNlcnZlci5hcHAvQ29udGVudHMvVVgI ADacQEOpmEBDUEsBAhUDFAAIAAgASbRCMwkw89ObAQAAvQMAAF0ADAAAAAAAAAAAQKSBJ28AAFJv bWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvU2hhcmVkU3VwcG9ydC9Sb21hbiBJ TSBVSVNlcnZlci5hcHAvQ29udGVudHMvSW5mby5wbGlzdFVYCABGnEBDqZhAQ1BLAQIVAwoAAAAA AEm0QjMAAAAAAAAAAAAAAABZAAwAAAAAAAAAAEDtQV1xAABSb21hbiBJbnB1dCBNZXRob2QuY29t cG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0NvbnRl bnRzL01hY09TL1VYCAA2nEBDqZhAQ1BLAQIVAxQACAAIAEm0QjPlxozl9h8AAExmAABqAAwAAAAA AAAAAEDtgeRxAABSb21hbiBJbnB1dCBNZXRob2QuY29tcG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1 cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0NvbnRlbnRzL01hY09TL1JvbWFuIElNIFVJU2Vy dmVyVVgIAEacQEOpmEBDUEsBAhUDFAAIAAgASbRCM0kEilsIAAAACAAAAFoADAAAAAAAAAAAQKSB gpIAAFJvbWFuIElucHV0IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvU2hhcmVkU3VwcG9ydC9S b21hbiBJTSBVSVNlcnZlci5hcHAvQ29udGVudHMvUGtnSW5mb1VYCABGnEBDqZhAQ1BLAQIVAwoA AAAAAEm0QjMAAAAAAAAAAAAAAABdAAwAAAAAAAAAAEDtQSKTAABSb21hbiBJbnB1dCBNZXRob2Qu Y29tcG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0Nv bnRlbnRzL1Jlc291cmNlcy9VWAgANpxAQ6mYQENQSwECFQMKAAAAAABJtEIzAAAAAAAAAAAAAAAA dAAMAAAAAAAAAABA7UGtkwAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50cy9T aGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9SZXNvdXJjZXMvQlNT ZW5kRXZlbnRQYWxldHRlLm5pYi9VWAgANpxAQ6mYQENQSwECFQMUAAgACABJtEIzMQkzXSIAAAAj AAAAfwAMAAAAAAAAAABApIFPlAAAUm9tYW4gSW5wdXQgTWV0aG9kLmNvbXBvbmVudC9Db250ZW50 cy9TaGFyZWRTdXBwb3J0L1JvbWFuIElNIFVJU2VydmVyLmFwcC9Db250ZW50cy9SZXNvdXJjZXMv QlNTZW5kRXZlbnRQYWxldHRlLm5pYi9jbGFzc2VzLm5pYlVYCABGnEBDqZhAQ1BLAQIVAxQACAAI AEm0QjPiCOaURwEAAHwCAAB8AAwAAAAAAAAAAECkgS6VAABSb21hbiBJbnB1dCBNZXRob2QuY29t cG9uZW50L0NvbnRlbnRzL1NoYXJlZFN1cHBvcnQvUm9tYW4gSU0gVUlTZXJ2ZXIuYXBwL0NvbnRl bnRzL1Jlc291cmNlcy9CU1NlbmRFdmVudFBhbGV0dGUubmliL2luZm8ubmliVVgIAEacQEOpmEBD UEsBAhUDFAAIAAgASbRCM+CRgA4FBgAA6CQAAH8ADAAAAAAAAAAAQKSBL5cAAFJvbWFuIElucHV0 IE1ldGhvZC5jb21wb25lbnQvQ29udGVudHMvU2hhcmVkU3VwcG9ydC9Sb21hbiBJTSBVSVNlcnZl ci5hcHAvQ29udGVudHMvUmVzb3VyY2VzL0JTU2VuZEV2ZW50UGFsZXR0ZS5uaWIvb2JqZWN0cy54 aWJVWAgARpxAQ6mYQENQSwUGAAAAABMAEwA4CgAA8Z0AAAAA 4293 2005-10-10 11:35:29 -0700 2005-10-10 11:35:29 -0700 automated test insert-spaces.html text/html 841 ap 77u/PGh0bWw+CjxoZWFkPgo8c3R5bGU+CmJvZHkgeyBtYXJnaW46IDA7IHBhZGRpbmc6IDAgfQo8 L3N0eWxlPgo8L2hlYWQ+Cjxib2R5Pgo8ZGl2IGNvbnRlbnRlZGl0YWJsZT48c3BhbiBpZD0idGVz dCIvPjwvZGl2Pgo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CgoJaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgewoJCQoJCXRyeSB7CgkJCgkJCWxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKCQkKCQkJd2luZG93LmdldFNlbGVjdGlvbigpLnNldFBvc2l0aW9u KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0IiksIDApOwoJCQl0ZXh0SW5wdXRDb250cm9s bGVyLmluc2VydFRleHQoIjAgMSAgMiAgIDM7Iik7CgoJCQl3aW5kb3cuZ2V0U2VsZWN0aW9uKCku c2V0UG9zaXRpb24oZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QiKSwgMTEpOwoJCQl0ZXh0 SW5wdXRDb250cm9sbGVyLnNldE1hcmtlZFRleHQoIjAgMSAgMiAgIDM7IiwgMCwgMCk7CgkJCXRl eHRJbnB1dENvbnRyb2xsZXIudW5tYXJrVGV4dCgpOwoKCQkJd2luZG93LmdldFNlbGVjdGlvbigp LnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0IiksIDIyKTsKCQkJdGV4 dElucHV0Q29udHJvbGxlci5zZXRNYXJrZWRUZXh0KCIwIDEgIDIgICAzOyIsIDAsIDApOwoKCgkJ fSBjYXRjaCAoZXgpIHsKCQkJZG9jdW1lbnQud3JpdGUoIkV4Y2VwdGlvbjogIiArIGV4LmRlc2Ny aXB0aW9uKTsKCQl9Cgl9IGVsc2UgewoJCWRvY3VtZW50LndyaXRlKCIoY2Fubm90IHJ1biBpbnRl cmFjdGl2ZWx5KSIpOwoJfQo8L3NjcmlwdD4KPC9ib2R5Pgo8L2h0bWw+Cg== 78502 2011-01-11 00:54:37 -0800 2011-01-11 20:52:15 -0800 Patch bug-5241-20110111175435.patch text/plain 14871 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxMjY2MTEyNmIyMTk1MGVlYTE2YzY1MTA1ODA3YzI0MDdkYTk0MTUwLi5hMTZlYTky ZTA5MzBkNWQwYzAwY2JiNWMwOGU0OTliODVhNzY0ODQ0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTEtMDEtMTEgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKworICAgICAgICAqIGVkaXRpbmcvaW5z ZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3Bh Y2UuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvc2NyaXB0LXRlc3Rz L2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmpzOiBBZGRlZC4KKwogMjAxMS0wMS0xMCAg TWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmll d2VkIENocm9taXVtIHRlc3QgZXhwZWN0YXRpb25zIHVwZGF0ZS4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3Np dGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iNjUzMzY0NjU2MWZmNjdm MGE3ZTcyNjYwMjg0MGE4YTRkYmQwMDYxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMzkgQEAKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoEIn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoCBCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ0EgwqAgwqBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgQUInCitQQVNTIGNvbXBv c2l0aW5nVGV4dCBpcyAnwqDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgQUIn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoEFCJworUEFTUyBjb21wb3NpdGluZ1Rl eHQgaXMgJ8KgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoEFC JworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnQUIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqDCoCcKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlz ICdBQiDCoCDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4 dCBpcyAnQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSBCJworUEFTUyBjb21wb3NpdGlu Z1RleHQgaXMgJ0EgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSAgIEInCitQQVNTIGNv bXBvc2l0aW5nVGV4dCBpcyAnQSAgICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBp cyAnQUIgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAnCitQQVNTIGNvbXBv c2l0aW5nVGV4dCBpcyAnQUIgICAgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgICAg ICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4 dCBpcyAnICAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICAgIEFCJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJyAgICAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICAgICAg QUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICAgICAgIEFCJworUEFTUyBzdWNjZXNzZnVs bHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0bWwg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVz cGFjZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjVmYjkzNDc1MThiYWQyYjJmNWY1MTdiNTJmYzFkMTRjMGFj ZDMwOWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9p bnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sCkBAIC0wLDAgKzEsMTMgQEAKKzwhRE9D VFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+ Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pz LXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9q cy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlw dGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNyYz0ic2NyaXB0 LXRlc3RzL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmpzIj48L3NjcmlwdD4KKzxzY3Jp cHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNl cnRpbmcvc2NyaXB0LXRlc3RzL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmpzIGIvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvc2NyaXB0LXRlc3RzL2luc2VydC1jb21wb3NpdGlv bi13aGl0ZXNwYWNlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdmYjc5MGM2OThkMTIwMWFhNjBiZjVmYmYxNDJh YTExMGE3YzhkMjQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2Vy dGluZy9zY3JpcHQtdGVzdHMvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuanMKQEAgLTAs MCArMSw2OSBAQAorCit2YXIgc2VsID0gZG9jdW1lbnQuZ2V0U2VsZWN0aW9uKCk7Cit2YXIgcm9v dCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInJvb3QiKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5k Q2hpbGQocm9vdCk7CisKKworZnVuY3Rpb24gY3JlYXRlRWRpdGFibGUodGFnTmFtZSwgdGV4dCkg eworICAgIHZhciBub2RlID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCh0YWdOYW1lKTsKKyAgICBu b2RlLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisgICAgbm9kZS5pbm5lckhUTUwgPSB0ZXh0Owor ICAgIHJldHVybiBub2RlOworfQorCitmdW5jdGlvbiB0ZXN0KHRhZ05hbWUsIGNvbXBvc2l0aW9u VGV4dCwgZXhwZWN0ZWQpIHsKKyAgICB2YXIgbm9kZSA9IGNyZWF0ZUVkaXRhYmxlKHRhZ05hbWUs ICJYIik7CisgICAgcm9vdC5hcHBlbmRDaGlsZChub2RlKTsKKworICAgIHZhciB0ZXh0Tm9kZSA9 IG5vZGUuZmlyc3RDaGlsZDsKKyAgICBzZWwuc2V0QmFzZUFuZEV4dGVudCh0ZXh0Tm9kZSwgMCwg dGV4dE5vZGUsIHRleHROb2RlLmRhdGEubGVuZ3RoKTsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFu ZCgiRGVsZXRlIiwgZmFsc2UpOworCisgICAgdGV4dElucHV0Q29udHJvbGxlci5zZXRNYXJrZWRU ZXh0KGNvbXBvc2l0aW9uVGV4dCwgMCwgY29tcG9zaXRpb25UZXh0KTsKKyAgICBjb21wb3NpdGlu Z1RleHQgPSBub2RlLmlubmVyVGV4dDsKKyAgICB0ZXh0SW5wdXRDb250cm9sbGVyLnVubWFya1Rl eHQoKTsKKyAgICBjb25maXJtZWRUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisKKyAgICBzaG91bGRC ZSgiY29tcG9zaXRpbmdUZXh0IiwgIiciICsgZXhwZWN0ZWQgKyAiJyIpOworfQorCit0ZXN0KCJk aXYiLCAiQUIiLCAiQUIiKTsKK3Rlc3QoImRpdiIsICJBIEIiLCAiQSBCIik7Cit0ZXN0KCJkaXYi LCAiQSAgQiIsICJBIFx4QTBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgIEIiLCAiQSBceEEwIEIiKTsK K3Rlc3QoImRpdiIsICJBICAgIEIiLCAiQSBceEEwIFx4QTBCIik7IAordGVzdCgiZGl2IiwgIiBB QiIsICJceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgIEFCIiwgIlx4QTBceEEwQUIiKTsKK3Rlc3Qo ImRpdiIsICIgICBBQiIsICJceEEwXHhBMCBBQiIpOwordGVzdCgiZGl2IiwgIiAgICBBQiIsICJc eEEwXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgIEFCIiwgIlx4QTBceEEwIFx4QTAg QUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICBBQiIsICJceEEwXHhBMCBceEEwIFx4QTBBQiIpOwor dGVzdCgiZGl2IiwgIiAgICAgICBBQiIsICJceEEwXHhBMCBceEEwIFx4QTAgQUIiKTsKK3Rlc3Qo ImRpdiIsICJBQiAgIiwgIkFCIFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICIsICJBQiBceEEw XHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICIsICJBQiBceEEwIFx4QTAiKTsKK3Rlc3QoImRp diIsICJBQiAgICAgIiwgIkFCIFx4QTAgXHhBMFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAg ICIsICJBQiBceEEwIFx4QTAgXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICAgICIsICJBQiBc eEEwIFx4QTAgXHhBMFx4QTAiKTsKKwordGVzdCgicHJlIiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJw cmUiLCAiQSBCIiwgIkEgQiIpOwordGVzdCgicHJlIiwgIkEgIEIiLCAiQSAgQiIpOwordGVzdCgi cHJlIiwgIkEgICBCIiwgIkEgICBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgICBCIiwgIkEgICAgQiIp OwordGVzdCgicHJlIiwgIkFCICAiLCAiQUIgICIpOwordGVzdCgicHJlIiwgIkFCICAgIiwgIkFC ICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgIiwgIkFCICAgICIpOwordGVzdCgicHJlIiwgIkFC ICAgICAiLCAiQUIgICAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICAgIiwgIkFCICAgICAgIik7 Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAgIiwgIkFCICAgICAgICIpOwordGVzdCgicHJlIiwgIiAg QUIiLCAiICBBQiIpOwordGVzdCgicHJlIiwgIiAgIEFCIiwgIiAgIEFCIik7Cit0ZXN0KCJwcmUi LCAiICAgIEFCIiwgIiAgICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgQUIiLCAiICAgICBBQiIp OwordGVzdCgicHJlIiwgIiAgICAgIEFCIiwgIiAgICAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAg ICAgIEFCIiwgIiAgICAgICBBQiIpOworCityb290LnN0eWxlLmRpc3BsYXkgPSAibm9uZSI7Citz dWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWU1MzUwNWRkOGE2M2Nh OWUwOTIxYmEwZmQzNDg3MjI3OTAyYjJlZS4uZDg3OTBhZTNkOThhOTI5ZmI5YjFhM2VlMzE5ODgy NjVlNDU0NDVkMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDExLTAxLTExICBNT1JJ VEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFNwYWNlIGFuZCB0YWIgY2hhcmFjdGVycyAic2VudCIg YnkgYW4gaW5wdXQgbWV0aG9kIGdpdmUgdG90YWxseSBkaWZmZXJlbnQgcmVzdWx0cyB0aGFuIHR5 cGluZyB0aGVtIGRpcmVjdGx5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD01MjQxCisKKyAgICAgICAgRml4IHNldENvbXBvc2l0aW9uKCkgYW5kIGNvbmZp cm1Db21wb3NpdGlvbigpIHRvIHJld3JpdGUgdGhlIGxpc3QKKyAgICAgICAgb2Ygd2hpdGVzcGFj ZSgweDIwKSBpbiBnaXZlbiB0ZXh0IHRvIGFuIGludGVybGVhdmVkIHNlcXVlbmNlIG9mCisgICAg ICAgIG5ic3AoMHhhMCkgYW5kIHdoaXRlc3BhY2UoMHgyMCkuICBUaGlzIGNoYW5nZSBtb2RpZmll cyB0aGUgdGV4dCBpbgorICAgICAgICBFZGl0b3IgaW5zdGVhZCBvZiBDb21wb3NpdGVFZGl0Q29t bWFuZCBiZWNhdXNlIG5vdCBhbGwgIkluc2VydFRleHQiIAorICAgICAgICBvcGVyYXRpb24gd2Fu dHMgdG8gcHJlc2VydmUgd2hpdGVzcGFjZSBvZiB0aGUgY29udGVudC4KKyAgICAgICAgCisgICAg ICAgIFRlc3Q6IGVkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNl Lmh0bWwKKworICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6aGFzV2hpdGVzcGFjZUxpc3QpOgorICAgICAgICAoV2ViQ29yZTo6Q29t cG9zaXRlRWRpdENvbW1hbmQ6OnNob3VsZEJhbGFuY2VXaGl0ZXNwYWNlQXQpOgorICAgICAgICAo V2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnN0cmluZ1dpdGhCYWxhbmNlZFdoaXRlc3Bh Y2VBdCk6CisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNl V2hpdGVzcGFjZUF0KToKKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmg6 CisgICAgICAgICogZWRpdGluZy9FZGl0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RWRpdG9y Ojpjb25maXJtQ29tcG9zaXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZXRDb21w b3NpdGlvbik6CisKIDIwMTAtMTAtMTAgIERhdmlkIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEZyYXNlci4KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKaW5kZXggNzQ4Nzc3ZDYwYWJhYjJlOWZi YTA5NjNjZmQ2NzAyZTgwOWMxNDlhZi4uYzNhYzc4MmJkYzYxOTAxN2RiNDIxMDFhMzkyODViNTc5 MjcyMDg4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0 Q29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29t bWFuZC5jcHAKQEAgLTM5NSwyMCArMzk1LDg5IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBpc1doaXRl c3BhY2UoVUNoYXIgYykKICAgICByZXR1cm4gYyA9PSBub0JyZWFrU3BhY2UgfHwgYyA9PSAnICcg fHwgYyA9PSAnXG4nIHx8IGMgPT0gJ1x0JzsKIH0KIAotLy8gRklYTUU6IERvZXNuJ3QgZ28gaW50 byB0ZXh0IG5vZGVzIHRoYXQgY29udHJpYnV0ZSBhZGphY2VudCB0ZXh0IChzaWJsaW5ncywgY291 c2lucywgZXRjKS4KLXZvaWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3Bh Y2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24pCitzdGF0aWMgYm9vbCBoYXNXaGl0ZXNwYWNl TGlzdChjb25zdCBTdHJpbmcmIHRleHQpCit7CisgICAgYm9vbCBmb3VuZFdoaXRlc3BhY2UgPSBm YWxzZTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdGV4dC5sZW5ndGgoKTsgKytpKSB7 CisgICAgICAgIGJvb2wgZm91bmRIZXJlID0gKHRleHRbaV0gPT0gJyAnKTsKKyAgICAgICAgaWYg KGZvdW5kV2hpdGVzcGFjZSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICBmb3Vu ZFdoaXRlc3BhY2UgPSBmb3VuZEhlcmU7CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOworfQor Citib29sIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpzaG91bGRCYWxhbmNlV2hpdGVzcGFjZUF0KGNv bnN0IFBvc2l0aW9uJiBwb3NpdGlvbiwgYm9vbCB3aWxsSW5zZXJ0KQogewogICAgIE5vZGUqIG5v ZGUgPSBwb3NpdGlvbi5ub2RlKCk7Ci0gICAgaWYgKCFub2RlIHx8ICFub2RlLT5pc1RleHROb2Rl KCkpCi0gICAgICAgIHJldHVybjsKLSAgICBUZXh0KiB0ZXh0Tm9kZSA9IHN0YXRpY19jYXN0PFRl eHQqPihub2RlKTsKLSAgICAKLSAgICBpZiAodGV4dE5vZGUtPmxlbmd0aCgpID09IDApCi0gICAg ICAgIHJldHVybjsKLSAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gdGV4dE5vZGUtPnJlbmRl cmVyKCk7CisgICAgaWYgKCFub2RlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAo bm9kZS0+aXNUZXh0Tm9kZSgpKSB7CisgICAgICAgIFRleHQqIHRleHROb2RlID0gc3RhdGljX2Nh c3Q8VGV4dCo+KG5vZGUpOworICAgICAgICBpZiAoIXRleHROb2RlLT5sZW5ndGgoKSAmJiAhd2ls bEluc2VydCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9IGVsc2UgeworICAgICAg ICBpZiAoIXdpbGxJbnNlcnQpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisg ICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUtPnJlbmRlcmVyKCk7CiAgICAgaWYgKHJl bmRlcmVyICYmICFyZW5kZXJlci0+c3R5bGUoKS0+Y29sbGFwc2VXaGl0ZVNwYWNlKCkpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiB0cnVlOworfQorCitTdHJpbmcgQ29tcG9z aXRlRWRpdENvbW1hbmQ6OnN0cmluZ1dpdGhCYWxhbmNlZFdoaXRlc3BhY2VBdChjb25zdCBQb3Np dGlvbiYgcG9zaXRpb24sIGNvbnN0IFN0cmluZyYgdGV4dCkKK3sKKyAgICBpZiAoIWhhc1doaXRl c3BhY2VMaXN0KHRleHQpIHx8ICFzaG91bGRCYWxhbmNlV2hpdGVzcGFjZUF0KHBvc2l0aW9uLCB0 cnVlKSkKKyAgICAgICAgcmV0dXJuIHRleHQ7CisKKyAgICBTdHJpbmcgcmV0OworICAgIHVuc2ln bmVkIHdoaXRlQ291bnQgPSAwOworCisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHRleHQu bGVuZ3RoKCk7ICsraSkgeworICAgICAgICBib29sIGlzV2hpdGVzcGFjZSA9IHRleHRbaV0gPT0g JyAnOworICAgICAgICBpZiAoaXNXaGl0ZXNwYWNlKSB7CisgICAgICAgICAgICB3aGl0ZUNvdW50 Kys7CisKKyAgICAgICAgICAgIGlmIChpICsgMSA8IHRleHQubGVuZ3RoKCkpCisgICAgICAgICAg ICAgICAgY29udGludWU7CisgICAgICAgICAgICAvLyBQcmVzZXJ2ZXMgdHJhaWxpbmcgd2hpdGVz cGFjZSwgd2hpY2ggd2lsbCBiZSBiYWxhbmNlZCBieSByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoKQor ICAgICAgICAgICAgcmV0LmFwcGVuZCh0ZXh0LmNoYXJhY3RlcnMoKSArIHRleHQubGVuZ3RoKCkg LSB3aGl0ZUNvdW50LCB3aGl0ZUNvdW50KTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9 CisKKyAgICAgICAgLy8gUHJlc2V2ZXMgbGVhZGluZyB3aGl0ZXNwYWNlLCB3aGljaCB3aWxsIGJl IGJhbGFuY2VkIGJ5IHJlYmFsYW5jZVdoaXRlc3BhY2VBdCgpCisgICAgICAgIGlmICh3aGl0ZUNv dW50ID09IGkpCisgICAgICAgICAgICByZXQuYXBwZW5kKHRleHQuY2hhcmFjdGVycygpLCB3aGl0 ZUNvdW50KTsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAvLyBJbnRlcmxlYXZlcyBuYnNw IGFuZCB3aGl0ZXNwYWNlIHRvIHByZXNlcnZlCisgICAgICAgICAgICAvLyBzcGFjZSBjaGFyYWN0 ZXJzIGFuZCBsaW5lLWJyZWFrYWJpbGl0eS4KKyAgICAgICAgICAgIGlmICgxID09IHdoaXRlQ291 bnQpCisgICAgICAgICAgICAgICAgcmV0LmFwcGVuZCgnICcpOworICAgICAgICAgICAgZWxzZSB7 CisgICAgICAgICAgICAgICAgZm9yICh1bnNpZ25lZCB3aGl0ZUluZGV4ID0gMDsgd2hpdGVJbmRl eCA8IHdoaXRlQ291bnQ7ICsrd2hpdGVJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgcmV0LmFw cGVuZChzdGF0aWNfY2FzdDxVQ2hhcj4od2hpdGVJbmRleCUyID8gbm9CcmVha1NwYWNlIDogJyAn KSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgICByZXQuYXBwZW5kKHRleHQu Y2hhcmFjdGVycygpW2ldKTsKKyAgICAgICAgd2hpdGVDb3VudCA9IDA7CisgICAgfQorCisgICAg cmV0dXJuIHJldDsKK30KKworLy8gRklYTUU6IERvZXNuJ3QgZ28gaW50byB0ZXh0IG5vZGVzIHRo YXQgY29udHJpYnV0ZSBhZGphY2VudCB0ZXh0IChzaWJsaW5ncywgY291c2lucywgZXRjKS4KK3Zv aWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3Np dGlvbiYgcG9zaXRpb24pCit7CisgICAgaWYgKCFzaG91bGRCYWxhbmNlV2hpdGVzcGFjZUF0KHBv c2l0aW9uLCBmYWxzZSkpCiAgICAgICAgIHJldHVybjsKLSAgICAgICAgCisKKyAgICBUZXh0KiB0 ZXh0Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQqPihwb3NpdGlvbi5ub2RlKCkpOwogICAgIFN0cmlu ZyB0ZXh0ID0gdGV4dE5vZGUtPmRhdGEoKTsKICAgICBBU1NFUlQoIXRleHQuaXNFbXB0eSgpKTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFu ZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCmluZGV4 IDZkYjRlYjE4MmEwODg2YWQxZmQ4MGIwNGU4YzFjNmYzNjFjYjAzMDAuLmY0NWFiODVmMTFkNTk3 MGJjODg3MTY0Nzc0N2U0MWZhYmM2NWVjNmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKQEAgLTQzLDYgKzQzLDcgQEAgcHVibGljOgogICAgIHZp cnR1YWwgfkNvbXBvc2l0ZUVkaXRDb21tYW5kKCk7CiAKICAgICBib29sIGlzRmlyc3RDb21tYW5k KEVkaXRDb21tYW5kKiBjb21tYW5kKSB7IHJldHVybiAhbV9jb21tYW5kcy5pc0VtcHR5KCkgJiYg bV9jb21tYW5kcy5maXJzdCgpID09IGNvbW1hbmQ7IH0KKyAgICBzdGF0aWMgU3RyaW5nIHN0cmlu Z1dpdGhCYWxhbmNlZFdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYsIGNvbnN0IFN0cmluZyYp OwogCiBwcm90ZWN0ZWQ6CiAgICAgZXhwbGljaXQgQ29tcG9zaXRlRWRpdENvbW1hbmQoRG9jdW1l bnQqKTsKQEAgLTExOCw2ICsxMTksNyBAQCBwcm90ZWN0ZWQ6CiAKICAgICBWZWN0b3I8UmVmUHRy PEVkaXRDb21tYW5kPiA+IG1fY29tbWFuZHM7CiAKKyAgICBzdGF0aWMgYm9vbCBzaG91bGRCYWxh bmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0aW9uJiwgYm9vbCB3aWxsSW5zZXJ0KTsKIHByaXZh dGU6CiAgICAgdmlydHVhbCB2b2lkIGRvVW5hcHBseSgpOwogICAgIHZpcnR1YWwgdm9pZCBkb1Jl YXBwbHkoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBi L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAppbmRleCBhMjRlN2M2MGI1MjVlNjE1 YWExZWUxMzYzZjU4MDAxZDZlMTEwYTQyLi43NmU1OWRlNjFhYzlmYjk3MGE4OTJiMTJiNmRkNzQ1 ZGY4MzAxZWY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCkBAIC0xNTk4LDEzICsxNTk4 LDE4IEBAIHZvaWQgRWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0 LCBib29sIHByZXNlcnZlU2VsZWN0aW9uKQogICAgICAgICBzZXRJZ25vcmVDb21wb3NpdGlvblNl bGVjdGlvbkNoYW5nZShmYWxzZSk7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgCisKKyAg ICAvLyBTb21lIElNRSBwYXNzIHNlcXVlbmNlIG9mIHdoaXRlc3BhY2UgJyAnIGluc3RlYWQgb2Yg bmJzcCBldmVuIHRoZXkgZXhwZWN0CisgICAgLy8gbXVsdGlwbGUgd2hpdGVzcGFjZXMgaW5zZXJ0 ZWQgaW50byB0aGUgcmVkZXJpbmcgcmVzdWx0LiAKKyAgICAvLyBTbyB3ZSBtaXggc29tZSBuYnNw IGNoYXJhY3RlcnMgZm9yIHByZXNlcnZpbmcgdGhlIHdoaXRlc3BhY2UuCisgICAgU3RyaW5nIGJh bGFuY2VkVGV4dCA9IENvbXBvc2l0ZUVkaXRDb21tYW5kOjpzdHJpbmdXaXRoQmFsYW5jZWRXaGl0 ZXNwYWNlQXQobV9mcmFtZS0+c2VsZWN0aW9uKCktPmJhc2UoKSwgdGV4dCk7CisKICAgICAvLyBE aXNwYXRjaCBhIGNvbXBvc2l0aW9uZW5kIGV2ZW50IHRvIHRoZSBmb2N1c2VkIG5vZGUuCiAgICAg Ly8gV2Ugc2hvdWxkIHNlbmQgdGhpcyBldmVudCBiZWZvcmUgc2VuZGluZyBhIFRleHRFdmVudCBh cyB3cml0dGVuIGluIFNlY3Rpb24gNi4yLjIgYW5kIDYuMi4zIG9mCiAgICAgLy8gdGhlIERPTSBF dmVudCBzcGVjaWZpY2F0aW9uLgogICAgIE5vZGUqIHRhcmdldCA9IG1fZnJhbWUtPmRvY3VtZW50 KCktPmZvY3VzZWROb2RlKCk7CiAgICAgaWYgKHRhcmdldCkgewotICAgICAgICBSZWZQdHI8Q29t cG9zaXRpb25FdmVudD4gZXZlbnQgPSBDb21wb3NpdGlvbkV2ZW50OjpjcmVhdGUoZXZlbnROYW1l cygpLmNvbXBvc2l0aW9uZW5kRXZlbnQsIG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0KTsKKyAg ICAgICAgUmVmUHRyPENvbXBvc2l0aW9uRXZlbnQ+IGV2ZW50ID0gQ29tcG9zaXRpb25FdmVudDo6 Y3JlYXRlKGV2ZW50TmFtZXMoKS5jb21wb3NpdGlvbmVuZEV2ZW50LCBtX2ZyYW1lLT5kb21XaW5k b3coKSwgYmFsYW5jZWRUZXh0KTsKICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAg ICAgIHRhcmdldC0+ZGlzcGF0Y2hFdmVudChldmVudCwgZWMpOwogICAgIH0KQEAgLTE2MTcsNyAr MTYyMiw3IEBAIHZvaWQgRWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0 ZXh0LCBib29sIHByZXNlcnZlU2VsZWN0aW9uKQogICAgIG1fY29tcG9zaXRpb25Ob2RlID0gMDsK ICAgICBtX2N1c3RvbUNvbXBvc2l0aW9uVW5kZXJsaW5lcy5jbGVhcigpOwogCi0gICAgaW5zZXJ0 VGV4dCh0ZXh0LCAwKTsKKyAgICBpbnNlcnRUZXh0KGJhbGFuY2VkVGV4dCwgMCk7CiAKICAgICBp ZiAocHJlc2VydmVTZWxlY3Rpb24pIHsKICAgICAgICAgbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNl dFNlbGVjdGlvbihvbGRTZWxlY3Rpb24sIGZhbHNlLCBmYWxzZSk7CkBAIC0xNjg2LDcgKzE2OTEs MTEgQEAgdm9pZCBFZGl0b3I6OnNldENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCwgY29u c3QgVmVjdG9yPENvbXBvc2l0aW9uVW5kZXJsaW4KICAgICBtX2N1c3RvbUNvbXBvc2l0aW9uVW5k ZXJsaW5lcy5jbGVhcigpOwogCiAgICAgaWYgKCF0ZXh0LmlzRW1wdHkoKSkgewotICAgICAgICBU eXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KG1fZnJhbWUtPmRvY3VtZW50KCksIHRleHQsIHRydWUs IHRydWUpOworICAgICAgICAvLyBTb21lIElNRSBwYXNzIHNlcXVlbmNlIG9mIHdoaXRlc3BhY2Ug JyAnIGluc3RlYWQgb2YgbmJzcCBldmVuIHRoZXkgZXhwZWN0CisgICAgICAgIC8vIG11bHRpcGxl IHdoaXRlc3BhY2VzIGluc2VydGVkIGludG8gdGhlIHJlZGVyaW5nIHJlc3VsdC4gCisgICAgICAg IC8vIFNvIHdlIG1peCBzb21lIG5ic3AgY2hhcmFjdGVycyBmb3IgcHJlc2VydmluZyB0aGUgd2hp dGVzcGFjZS4KKyAgICAgICAgU3RyaW5nIGJhbGFuY2VkVGV4dCA9IENvbXBvc2l0ZUVkaXRDb21t YW5kOjpzdHJpbmdXaXRoQmFsYW5jZWRXaGl0ZXNwYWNlQXQobV9mcmFtZS0+c2VsZWN0aW9uKCkt PmJhc2UoKSwgdGV4dCk7CisgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQobV9mcmFt ZS0+ZG9jdW1lbnQoKSwgYmFsYW5jZWRUZXh0LCB0cnVlLCB0cnVlKTsKIAogICAgICAgICAvLyBG aW5kIG91dCB3aGF0IG5vZGUgaGFzIHRoZSBjb21wb3NpdGlvbiBub3cuCiAgICAgICAgIFBvc2l0 aW9uIGJhc2UgPSBtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+YmFzZSgpLmRvd25zdHJlYW0oKTsKQEAg LTE2OTYsNyArMTcwNSw3IEBAIHZvaWQgRWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJp bmcmIHRleHQsIGNvbnN0IFZlY3RvcjxDb21wb3NpdGlvblVuZGVybGluCiAgICAgICAgIE5vZGUq IGV4dGVudE5vZGUgPSBleHRlbnQubm9kZSgpOwogICAgICAgICB1bnNpZ25lZCBleHRlbnRPZmZz ZXQgPSBleHRlbnQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKTsKIAotICAgICAgICBpZiAoYmFz ZU5vZGUgJiYgYmFzZU5vZGUgPT0gZXh0ZW50Tm9kZSAmJiBiYXNlTm9kZS0+aXNUZXh0Tm9kZSgp ICYmIGJhc2VPZmZzZXQgKyB0ZXh0Lmxlbmd0aCgpID09IGV4dGVudE9mZnNldCkgeworICAgICAg ICBpZiAoYmFzZU5vZGUgJiYgYmFzZU5vZGUgPT0gZXh0ZW50Tm9kZSAmJiBiYXNlTm9kZS0+aXNU ZXh0Tm9kZSgpICYmIGJhc2VPZmZzZXQgKyBiYWxhbmNlZFRleHQubGVuZ3RoKCkgPT0gZXh0ZW50 T2Zmc2V0KSB7CiAgICAgICAgICAgICBtX2NvbXBvc2l0aW9uTm9kZSA9IHN0YXRpY19jYXN0PFRl eHQqPihiYXNlTm9kZSk7CiAgICAgICAgICAgICBtX2NvbXBvc2l0aW9uU3RhcnQgPSBiYXNlT2Zm c2V0OwogICAgICAgICAgICAgbV9jb21wb3NpdGlvbkVuZCA9IGV4dGVudE9mZnNldDsK 78646 2011-01-11 20:52:20 -0800 2011-01-13 03:22:32 -0800 Patch bug-5241-20110112135218.patch text/plain 14584 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiYjE2ODA0MmQ1MmRmZWI0YTYwZDgyMTI4NTNmY2YxOTkxNzQ3MjhjLi42YzczNTYx YTJkY2JmMDMyYmIwMzIyYmRmNzg2NGVmMWMyNjUwMzQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDEtMTEgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKworICAgICAgICBBZGRlZCBhIHRlc3Qg dGhhdCBleGVyY2lzZXMgY29udGlub3VzIHdoaXRlc3BhY2UgY2hhcmFjdGVycyBpbnNlcnRlZCBi eSBJTUUuCisgICAgICAgIAorICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21w b3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGlu Zy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbDogQWRkZWQuCisg ICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvc2NyaXB0LXRlc3RzL2luc2VydC1jb21wb3NpdGlv bi13aGl0ZXNwYWNlLmpzOiBBZGRlZC4KKwogMjAxMS0wMS0xMSAgTmljbyBXZWJlciAgPHRoYWtp c0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgdGVzdCBleHBlY3RhdGlvbnMu CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9z aXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2Vy dGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYjY1MzM2NDY1NjFmZjY3ZjBhN2U3MjY2MDI4NDBhOGE0ZGJkMDA2MQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13 aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDM5IEBACitQQVNTIGNvbXBvc2l0aW5n VGV4dCBpcyAnQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSBCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0EgwqBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgwqAgQicKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKgIMKgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlz ICfCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqBBQicKK1BBU1MgY29tcG9zaXRp bmdUZXh0IGlzICfCoMKgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgwqBBQicK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIEFCJworUEFTUyBjb21wb3NpdGluZ1Rl eHQgaXMgJ8KgwqAgwqAgwqBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKg IEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgJworUEFTUyBjb21wb3NpdGluZ1Rl eHQgaXMgJ0FCIMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAnCitQQVNT IGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlz ICdBQiDCoCDCoCDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoCDCoMKgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0Eg QicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ0EgICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICdBQiAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdB QiAgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0FCICAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEFCJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg JyAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJyAgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgICBB QicKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRp b24td2hpdGVzcGFjZS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0 LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41ZmI5MzQ3NTE4YmFkMmIy ZjVmNTE3YjUyZmMxZDE0YzBhY2QzMDllCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApAQCAt MCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9F TiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9m YXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4v ZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2Pgor PHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5q cyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3NjcmlwdC10ZXN0cy9pbnNlcnQtY29tcG9zaXRpb24t d2hpdGVzcGFjZS5qcyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3NjcmlwdC10ZXN0 cy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ZmI3OTBjNjk4 ZDEyMDFhYTYwYmY1ZmJmMTQyYWExMTBhN2M4ZDI0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvc2NyaXB0LXRlc3RzL2luc2VydC1jb21wb3NpdGlvbi13 aGl0ZXNwYWNlLmpzCkBAIC0wLDAgKzEsNjkgQEAKKwordmFyIHNlbCA9IGRvY3VtZW50LmdldFNl bGVjdGlvbigpOwordmFyIHJvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJyb290Iik7Citk b2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHJvb3QpOworCisKK2Z1bmN0aW9uIGNyZWF0ZUVkaXRh YmxlKHRhZ05hbWUsIHRleHQpIHsKKyAgICB2YXIgbm9kZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1l bnQodGFnTmFtZSk7CisgICAgbm9kZS5jb250ZW50RWRpdGFibGUgPSB0cnVlOworICAgIG5vZGUu aW5uZXJIVE1MID0gdGV4dDsKKyAgICByZXR1cm4gbm9kZTsKK30KKworZnVuY3Rpb24gdGVzdCh0 YWdOYW1lLCBjb21wb3NpdGlvblRleHQsIGV4cGVjdGVkKSB7CisgICAgdmFyIG5vZGUgPSBjcmVh dGVFZGl0YWJsZSh0YWdOYW1lLCAiWCIpOworICAgIHJvb3QuYXBwZW5kQ2hpbGQobm9kZSk7CisK KyAgICB2YXIgdGV4dE5vZGUgPSBub2RlLmZpcnN0Q2hpbGQ7CisgICAgc2VsLnNldEJhc2VBbmRF eHRlbnQodGV4dE5vZGUsIDAsIHRleHROb2RlLCB0ZXh0Tm9kZS5kYXRhLmxlbmd0aCk7CisgICAg ZG9jdW1lbnQuZXhlY0NvbW1hbmQoIkRlbGV0ZSIsIGZhbHNlKTsKKworICAgIHRleHRJbnB1dENv bnRyb2xsZXIuc2V0TWFya2VkVGV4dChjb21wb3NpdGlvblRleHQsIDAsIGNvbXBvc2l0aW9uVGV4 dCk7CisgICAgY29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisgICAgdGV4dElucHV0 Q29udHJvbGxlci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4dCA9IG5vZGUuaW5uZXJU ZXh0OworCisgICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICInIiArIGV4cGVjdGVkICsg IiciKTsKK30KKwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJkaXYiLCAiQSBCIiwg IkEgQiIpOwordGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwordGVzdCgiZGl2IiwgIkEg ICBCIiwgIkEgXHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwgIkEgXHhBMCBceEEwQiIp OyAKK3Rlc3QoImRpdiIsICIgQUIiLCAiXHhBMEFCIik7Cit0ZXN0KCJkaXYiLCAiICBBQiIsICJc eEEwXHhBMEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgQUIiLCAiXHhBMFx4QTAgQUIiKTsKK3Rlc3Qo ImRpdiIsICIgICAgQUIiLCAiXHhBMFx4QTAgXHhBMEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgICBB QiIsICJceEEwXHhBMCBceEEwIEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgICAgQUIiLCAiXHhBMFx4 QTAgXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICAgQUIiLCAiXHhBMFx4QTAgXHhB MCBceEEwIEFCIik7Cit0ZXN0KCJkaXYiLCAiQUIgICIsICJBQiBceEEwIik7Cit0ZXN0KCJkaXYi LCAiQUIgICAiLCAiQUIgXHhBMFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAiLCAiQUIgXHhB MCBceEEwIik7Cit0ZXN0KCJkaXYiLCAiQUIgICAgICIsICJBQiBceEEwIFx4QTBceEEwIik7Cit0 ZXN0KCJkaXYiLCAiQUIgICAgICAiLCAiQUIgXHhBMCBceEEwIFx4QTAiKTsKK3Rlc3QoImRpdiIs ICJBQiAgICAgICAiLCAiQUIgXHhBMCBceEEwIFx4QTBceEEwIik7CisKK3Rlc3QoInByZSIsICJB QiIsICJBQiIpOwordGVzdCgicHJlIiwgIkEgQiIsICJBIEIiKTsKK3Rlc3QoInByZSIsICJBICBC IiwgIkEgIEIiKTsKK3Rlc3QoInByZSIsICJBICAgQiIsICJBICAgQiIpOwordGVzdCgicHJlIiwg IkEgICAgQiIsICJBICAgIEIiKTsKK3Rlc3QoInByZSIsICJBQiAgIiwgIkFCICAiKTsKK3Rlc3Qo InByZSIsICJBQiAgICIsICJBQiAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICIsICJBQiAgICAi KTsKK3Rlc3QoInByZSIsICJBQiAgICAgIiwgIkFCICAgICAiKTsKK3Rlc3QoInByZSIsICJBQiAg ICAgICIsICJBQiAgICAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICAgICIsICJBQiAgICAgICAi KTsKK3Rlc3QoInByZSIsICIgIEFCIiwgIiAgQUIiKTsKK3Rlc3QoInByZSIsICIgICBBQiIsICIg ICBBQiIpOwordGVzdCgicHJlIiwgIiAgICBBQiIsICIgICAgQUIiKTsKK3Rlc3QoInByZSIsICIg ICAgIEFCIiwgIiAgICAgQUIiKTsKK3Rlc3QoInByZSIsICIgICAgICBBQiIsICIgICAgICBBQiIp OwordGVzdCgicHJlIiwgIiAgICAgICBBQiIsICIgICAgICAgQUIiKTsKKworcm9vdC5zdHlsZS5k aXNwbGF5ID0gIm5vbmUiOworc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IGU0OGIwMjQ1NmZlMDhhNTEwYmMyNDU4ZDFmMTMyNzRiMzk3Y2M0ZGEuLjEzNGM2YmZjZmJk MDU3NGU2MWU1ZjU3MDRhOWUzOGI2YmRhZWU0MDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOCBA QAorMjAxMS0wMS0xMSAgTU9SSVRBIEhhamltZSAgPG1vcnJpdGFAZ29vZ2xlLmNvbT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTcGFjZSBhbmQgdGFi IGNoYXJhY3RlcnMgInNlbnQiIGJ5IGFuIGlucHV0IG1ldGhvZCBnaXZlIHRvdGFsbHkgZGlmZmVy ZW50IHJlc3VsdHMgdGhhbiB0eXBpbmcgdGhlbSBkaXJlY3RseQorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0MQorCisgICAgICAgIEZpeCBzZXRDb21w b3NpdGlvbigpIGFuZCBjb25maXJtQ29tcG9zaXRpb24oKSB0byByZXdyaXRlIHRoZSBsaXN0Cisg ICAgICAgIG9mIHdoaXRlc3BhY2UoMHgyMCkgaW4gZ2l2ZW4gdGV4dCB0byBhbiBpbnRlcmxlYXZl ZCBzZXF1ZW5jZSBvZgorICAgICAgICBuYnNwKDB4YTApIGFuZCB3aGl0ZXNwYWNlKDB4MjApLiAg VGhpcyBjaGFuZ2UgbW9kaWZpZXMgdGhlIHRleHQgaW4KKyAgICAgICAgRWRpdG9yIGluc3RlYWQg b2YgQ29tcG9zaXRlRWRpdENvbW1hbmQgYmVjYXVzZSBub3QgYWxsICJJbnNlcnRUZXh0IiAKKyAg ICAgICAgb3BlcmF0aW9uIHdhbnRzIHRvIHByZXNlcnZlIHdoaXRlc3BhY2Ugb2YgdGhlIGNvbnRl bnQuCisgICAgICAgIAorICAgICAgICBUZXN0OiBlZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29t cG9zaXRpb24td2hpdGVzcGFjZS5odG1sCisKKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVk aXRDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Omhhc1doaXRlc3BhY2VMaXN0KToKKyAg ICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpzaG91bGRCYWxhbmNlV2hpdGVz cGFjZUF0KToKKyAgICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFu Y2VXaGl0ZXNwYWNlQXQpOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6 OnJlYmFsYW5jZVdoaXRlc3BhY2VCZXR3ZWVuV29yZHNBdCk6IEFkZGVkLgorICAgICAgICAqIGVk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmNvbmZpcm1Db21wb3NpdGlvbik6CisgICAg ICAgIChXZWJDb3JlOjpFZGl0b3I6OnNldENvbXBvc2l0aW9uKToKKwogMjAxMS0wMS0xMSAgQW5k eSBFc3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g QWRsZXIuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRD b21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQu Y3BwCmluZGV4IDc0ODc3N2Q2MGFiYWIyZTlmYmEwOTYzY2ZkNjcwMmU4MDljMTQ5YWYuLjc0MTUz OWY3OGRhYTc0MTY3ZjI4MzFhZTc4ZDAzNDAyOTk5ODg1ZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCkBAIC0zOTUsMjAgKzM5NSw4OSBA QCBzdGF0aWMgaW5saW5lIGJvb2wgaXNXaGl0ZXNwYWNlKFVDaGFyIGMpCiAgICAgcmV0dXJuIGMg PT0gbm9CcmVha1NwYWNlIHx8IGMgPT0gJyAnIHx8IGMgPT0gJ1xuJyB8fCBjID09ICdcdCc7CiB9 CiAKLS8vIEZJWE1FOiBEb2Vzbid0IGdvIGludG8gdGV4dCBub2RlcyB0aGF0IGNvbnRyaWJ1dGUg YWRqYWNlbnQgdGV4dCAoc2libGluZ3MsIGNvdXNpbnMsIGV0YykuCi12b2lkIENvbXBvc2l0ZUVk aXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mIHBvc2l0aW9u KQorc3RhdGljIGJvb2wgaGFzV2hpdGVzcGFjZUxpc3QoY29uc3QgU3RyaW5nJiB0ZXh0KQorewor ICAgIGJvb2wgZm91bmRXaGl0ZXNwYWNlID0gZmFsc2U7CisgICAgZm9yICh1bnNpZ25lZCBpID0g MDsgaSA8IHRleHQubGVuZ3RoKCk7ICsraSkgeworICAgICAgICBib29sIGZvdW5kSGVyZSA9ICh0 ZXh0W2ldID09ICcgJyk7CisgICAgICAgIGlmIChmb3VuZFdoaXRlc3BhY2UpCisgICAgICAgICAg ICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgZm91bmRXaGl0ZXNwYWNlID0gZm91bmRIZXJlOworICAg IH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6 c2hvdWxkQmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24sIGJvb2wg d2lsbEluc2VydCkKIHsKICAgICBOb2RlKiBub2RlID0gcG9zaXRpb24ubm9kZSgpOwotICAgIGlm ICghbm9kZSB8fCAhbm9kZS0+aXNUZXh0Tm9kZSgpKQotICAgICAgICByZXR1cm47Ci0gICAgVGV4 dCogdGV4dE5vZGUgPSBzdGF0aWNfY2FzdDxUZXh0Kj4obm9kZSk7Ci0gICAgCi0gICAgaWYgKHRl eHROb2RlLT5sZW5ndGgoKSA9PSAwKQotICAgICAgICByZXR1cm47Ci0gICAgUmVuZGVyT2JqZWN0 KiByZW5kZXJlciA9IHRleHROb2RlLT5yZW5kZXJlcigpOworICAgIGlmICghbm9kZSkKKyAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKG5vZGUtPmlzVGV4dE5vZGUoKSkgeworICAgICAg ICBUZXh0KiB0ZXh0Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQqPihub2RlKTsKKyAgICAgICAgaWYg KCF0ZXh0Tm9kZS0+bGVuZ3RoKCkgJiYgIXdpbGxJbnNlcnQpCisgICAgICAgICAgICByZXR1cm4g ZmFsc2U7CisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKCF3aWxsSW5zZXJ0KQorICAgICAgICAg ICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBu b2RlLT5yZW5kZXJlcigpOwogICAgIGlmIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPnN0eWxlKCkt PmNvbGxhcHNlV2hpdGVTcGFjZSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICByZXR1 cm4gdHJ1ZTsKK30KKworU3RyaW5nIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0 ZXNwYWNlQmV0d2VlbldvcmRzQXQoY29uc3QgUG9zaXRpb24mIHBvc2l0aW9uLCBjb25zdCBTdHJp bmcmIHRleHQpCit7CisgICAgaWYgKCFoYXNXaGl0ZXNwYWNlTGlzdCh0ZXh0KSB8fCAhc2hvdWxk QmFsYW5jZVdoaXRlc3BhY2VBdChwb3NpdGlvbiwgdHJ1ZSkpCisgICAgICAgIHJldHVybiB0ZXh0 OworCisgICAgU3RyaW5nIGJhbGFuY2VkVGV4dDsKKyAgICB1bnNpZ25lZCB3aGl0ZUNvdW50ID0g MDsKKworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCB0ZXh0Lmxlbmd0aCgpOyArK2kpIHsK KyAgICAgICAgYm9vbCBpc1doaXRlc3BhY2UgPSB0ZXh0W2ldID09ICcgJzsKKyAgICAgICAgaWYg KGlzV2hpdGVzcGFjZSkgeworICAgICAgICAgICAgd2hpdGVDb3VudCsrOworCisgICAgICAgICAg ICBpZiAoaSArIDEgPCB0ZXh0Lmxlbmd0aCgpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICAgICAgLy8gUHJlc2VydmVzIHRyYWlsaW5nIHdoaXRlc3BhY2UsIHdoaWNoIHdpbGwg YmUgYmFsYW5jZWQgYnkgcmViYWxhbmNlV2hpdGVzcGFjZUF0KCkKKyAgICAgICAgICAgIGJhbGFu Y2VkVGV4dC5hcHBlbmQodGV4dC5jaGFyYWN0ZXJzKCkgKyB0ZXh0Lmxlbmd0aCgpIC0gd2hpdGVD b3VudCwgd2hpdGVDb3VudCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAg ICAgIC8vIFByZXNldmVzIGxlYWRpbmcgd2hpdGVzcGFjZSwgd2hpY2ggd2lsbCBiZSBiYWxhbmNl ZCBieSByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoKQorICAgICAgICBpZiAod2hpdGVDb3VudCA9PSBp KQorICAgICAgICAgICAgYmFsYW5jZWRUZXh0LmFwcGVuZCh0ZXh0LmNoYXJhY3RlcnMoKSwgd2hp dGVDb3VudCk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgLy8gSW50ZXJsZWF2ZXMgbmJz cCBhbmQgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZQorICAgICAgICAgICAgLy8gc3BhY2UgY2hhcmFj dGVycyBhbmQgbGluZS1icmVha2FiaWxpdHkuCisgICAgICAgICAgICBpZiAoMSA9PSB3aGl0ZUNv dW50KQorICAgICAgICAgICAgICAgIGJhbGFuY2VkVGV4dC5hcHBlbmQoJyAnKTsKKyAgICAgICAg ICAgIGVsc2UgeworICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgd2hpdGVJbmRleCA9IDA7 IHdoaXRlSW5kZXggPCB3aGl0ZUNvdW50OyArK3doaXRlSW5kZXgpCisgICAgICAgICAgICAgICAg ICAgIGJhbGFuY2VkVGV4dC5hcHBlbmQoc3RhdGljX2Nhc3Q8VUNoYXI+KHdoaXRlSW5kZXglMiA/ IG5vQnJlYWtTcGFjZSA6ICcgJykpOworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAg ICAgYmFsYW5jZWRUZXh0LmFwcGVuZCh0ZXh0LmNoYXJhY3RlcnMoKVtpXSk7CisgICAgICAgIHdo aXRlQ291bnQgPSAwOworICAgIH0KKworICAgIHJldHVybiBiYWxhbmNlZFRleHQ7Cit9CisKKy8v IEZJWE1FOiBEb2Vzbid0IGdvIGludG8gdGV4dCBub2RlcyB0aGF0IGNvbnRyaWJ1dGUgYWRqYWNl bnQgdGV4dCAoc2libGluZ3MsIGNvdXNpbnMsIGV0YykuCit2b2lkIENvbXBvc2l0ZUVkaXRDb21t YW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mIHBvc2l0aW9uKQorewor ICAgIGlmICghc2hvdWxkQmFsYW5jZVdoaXRlc3BhY2VBdChwb3NpdGlvbiwgZmFsc2UpKQogICAg ICAgICByZXR1cm47Ci0gICAgICAgIAorCisgICAgVGV4dCogdGV4dE5vZGUgPSBzdGF0aWNfY2Fz dDxUZXh0Kj4ocG9zaXRpb24ubm9kZSgpKTsKICAgICBTdHJpbmcgdGV4dCA9IHRleHROb2RlLT5k YXRhKCk7CiAgICAgQVNTRVJUKCF0ZXh0LmlzRW1wdHkoKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAppbmRleCA2ZGI0ZWIxODJhMDg4NmFkMWZk ODBiMDRlOGMxYzZmMzYxY2IwMzAwLi44MDNlM2FlOTQ1MjM0ZTBiOWI4NzdkMjEyMGZkMzY0Mjk4 Yjc2N2IwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRD b21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFu ZC5oCkBAIC00Myw2ICs0Myw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5Db21wb3NpdGVFZGl0 Q29tbWFuZCgpOwogCiAgICAgYm9vbCBpc0ZpcnN0Q29tbWFuZChFZGl0Q29tbWFuZCogY29tbWFu ZCkgeyByZXR1cm4gIW1fY29tbWFuZHMuaXNFbXB0eSgpICYmIG1fY29tbWFuZHMuZmlyc3QoKSA9 PSBjb21tYW5kOyB9CisgICAgc3RhdGljIFN0cmluZyByZWJhbGFuY2VXaGl0ZXNwYWNlQmV0d2Vl bldvcmRzQXQoY29uc3QgUG9zaXRpb24mLCBjb25zdCBTdHJpbmcmKTsKIAogcHJvdGVjdGVkOgog ICAgIGV4cGxpY2l0IENvbXBvc2l0ZUVkaXRDb21tYW5kKERvY3VtZW50Kik7CkBAIC0xMTgsNiAr MTE5LDcgQEAgcHJvdGVjdGVkOgogCiAgICAgVmVjdG9yPFJlZlB0cjxFZGl0Q29tbWFuZD4gPiBt X2NvbW1hbmRzOwogCisgICAgc3RhdGljIGJvb2wgc2hvdWxkQmFsYW5jZVdoaXRlc3BhY2VBdChj b25zdCBQb3NpdGlvbiYsIGJvb2wgd2lsbEluc2VydCk7CiBwcml2YXRlOgogICAgIHZpcnR1YWwg dm9pZCBkb1VuYXBwbHkoKTsKICAgICB2aXJ0dWFsIHZvaWQgZG9SZWFwcGx5KCk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggYTI0ZTdjNjBiNTI1ZTYxNWFhMWVlMTM2M2Y1ODAwMWQ2 ZTExMGE0Mi4uZjllOTBmYzkyNzQ5YmJlYmNjOTRhMDk0YzYzODdkNjJiNDlhYTMyYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvRWRpdG9yLmNwcApAQCAtMTU5OCwxMyArMTU5OCwxNSBAQCB2b2lkIEVkaXRv cjo6Y29uZmlybUNvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBwcmVzZXJ2ZVNl bGVjdGlvbikKICAgICAgICAgc2V0SWdub3JlQ29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2UoZmFs c2UpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCisgICAgU3RyaW5nIGJhbGFuY2Vk VGV4dCA9IENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQmV0d2Vlbldv cmRzQXQobV9mcmFtZS0+c2VsZWN0aW9uKCktPmJhc2UoKSwgdGV4dCk7CisKICAgICAvLyBEaXNw YXRjaCBhIGNvbXBvc2l0aW9uZW5kIGV2ZW50IHRvIHRoZSBmb2N1c2VkIG5vZGUuCiAgICAgLy8g V2Ugc2hvdWxkIHNlbmQgdGhpcyBldmVudCBiZWZvcmUgc2VuZGluZyBhIFRleHRFdmVudCBhcyB3 cml0dGVuIGluIFNlY3Rpb24gNi4yLjIgYW5kIDYuMi4zIG9mCiAgICAgLy8gdGhlIERPTSBFdmVu dCBzcGVjaWZpY2F0aW9uLgogICAgIE5vZGUqIHRhcmdldCA9IG1fZnJhbWUtPmRvY3VtZW50KCkt PmZvY3VzZWROb2RlKCk7CiAgICAgaWYgKHRhcmdldCkgewotICAgICAgICBSZWZQdHI8Q29tcG9z aXRpb25FdmVudD4gZXZlbnQgPSBDb21wb3NpdGlvbkV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygp LmNvbXBvc2l0aW9uZW5kRXZlbnQsIG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0KTsKKyAgICAg ICAgUmVmUHRyPENvbXBvc2l0aW9uRXZlbnQ+IGV2ZW50ID0gQ29tcG9zaXRpb25FdmVudDo6Y3Jl YXRlKGV2ZW50TmFtZXMoKS5jb21wb3NpdGlvbmVuZEV2ZW50LCBtX2ZyYW1lLT5kb21XaW5kb3co KSwgYmFsYW5jZWRUZXh0KTsKICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAg IHRhcmdldC0+ZGlzcGF0Y2hFdmVudChldmVudCwgZWMpOwogICAgIH0KQEAgLTE2MTcsNyArMTYx OSw3IEBAIHZvaWQgRWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0 LCBib29sIHByZXNlcnZlU2VsZWN0aW9uKQogICAgIG1fY29tcG9zaXRpb25Ob2RlID0gMDsKICAg ICBtX2N1c3RvbUNvbXBvc2l0aW9uVW5kZXJsaW5lcy5jbGVhcigpOwogCi0gICAgaW5zZXJ0VGV4 dCh0ZXh0LCAwKTsKKyAgICBpbnNlcnRUZXh0KGJhbGFuY2VkVGV4dCwgMCk7CiAKICAgICBpZiAo cHJlc2VydmVTZWxlY3Rpb24pIHsKICAgICAgICAgbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNldFNl bGVjdGlvbihvbGRTZWxlY3Rpb24sIGZhbHNlLCBmYWxzZSk7CkBAIC0xNjg2LDcgKzE2ODgsOCBA QCB2b2lkIEVkaXRvcjo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBW ZWN0b3I8Q29tcG9zaXRpb25VbmRlcmxpbgogICAgIG1fY3VzdG9tQ29tcG9zaXRpb25VbmRlcmxp bmVzLmNsZWFyKCk7CiAKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKSB7Ci0gICAgICAgIFR5cGlu Z0NvbW1hbmQ6Omluc2VydFRleHQobV9mcmFtZS0+ZG9jdW1lbnQoKSwgdGV4dCwgdHJ1ZSwgdHJ1 ZSk7CisgICAgICAgIFN0cmluZyBiYWxhbmNlZFRleHQgPSBDb21wb3NpdGVFZGl0Q29tbWFuZDo6 cmViYWxhbmNlV2hpdGVzcGFjZUJldHdlZW5Xb3Jkc0F0KG1fZnJhbWUtPnNlbGVjdGlvbigpLT5i YXNlKCksIHRleHQpOworICAgICAgICBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KG1fZnJhbWUt PmRvY3VtZW50KCksIGJhbGFuY2VkVGV4dCwgdHJ1ZSwgdHJ1ZSk7CiAKICAgICAgICAgLy8gRmlu ZCBvdXQgd2hhdCBub2RlIGhhcyB0aGUgY29tcG9zaXRpb24gbm93LgogICAgICAgICBQb3NpdGlv biBiYXNlID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPmJhc2UoKS5kb3duc3RyZWFtKCk7CkBAIC0x Njk2LDcgKzE2OTksNyBAQCB2b2lkIEVkaXRvcjo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5n JiB0ZXh0LCBjb25zdCBWZWN0b3I8Q29tcG9zaXRpb25VbmRlcmxpbgogICAgICAgICBOb2RlKiBl eHRlbnROb2RlID0gZXh0ZW50Lm5vZGUoKTsKICAgICAgICAgdW5zaWduZWQgZXh0ZW50T2Zmc2V0 ID0gZXh0ZW50LmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCk7CiAKLSAgICAgICAgaWYgKGJhc2VO b2RlICYmIGJhc2VOb2RlID09IGV4dGVudE5vZGUgJiYgYmFzZU5vZGUtPmlzVGV4dE5vZGUoKSAm JiBiYXNlT2Zmc2V0ICsgdGV4dC5sZW5ndGgoKSA9PSBleHRlbnRPZmZzZXQpIHsKKyAgICAgICAg aWYgKGJhc2VOb2RlICYmIGJhc2VOb2RlID09IGV4dGVudE5vZGUgJiYgYmFzZU5vZGUtPmlzVGV4 dE5vZGUoKSAmJiBiYXNlT2Zmc2V0ICsgYmFsYW5jZWRUZXh0Lmxlbmd0aCgpID09IGV4dGVudE9m ZnNldCkgewogICAgICAgICAgICAgbV9jb21wb3NpdGlvbk5vZGUgPSBzdGF0aWNfY2FzdDxUZXh0 Kj4oYmFzZU5vZGUpOwogICAgICAgICAgICAgbV9jb21wb3NpdGlvblN0YXJ0ID0gYmFzZU9mZnNl dDsKICAgICAgICAgICAgIG1fY29tcG9zaXRpb25FbmQgPSBleHRlbnRPZmZzZXQ7Cg== 78794 2011-01-13 03:22:39 -0800 2011-01-14 05:15:45 -0800 Patch bug-5241-20110113202236.patch text/plain 29882 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3YTZlZWNiMGVjMmY5MjBmZmVmZDY4YWJlYTE2ZWRiNGRhZTFmNWJiLi4yNjFiNzkw MmMzZTBhYzg2NDFiOTI0N2MwZjA3MTk3YzJiMzNmZjVhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTMgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKyAgICAgICAgCisgICAgICAgIEFkZGVk IGEgdGVzdCB0aGF0IGV4ZXJjaXNlcyBjb250aW5vdXMgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzIGFu ZCB0YWJzIGluc2VydGVkIGJ5IElNRS4KKworICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbDog QWRkZWQuCisKIDIwMTEtMDEtMTMgIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBEYXZlIEh5YXR0LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdo aXRlc3BhY2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJjMzc4OTMyMmQzMzQ1NGM4MDc2NmM3 NjQyMDVlYjQ3ZTg3OGY2YjEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0MyBAQAorUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBIMKgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDC oCDCoEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICfCoMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCBBQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAn wqDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKgQUInCitQQVNT IGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICdBQiDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoMKgJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKg IMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqAnCitQQVNTIGNvbXBv c2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfC oMKgQSDCoEIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoEEgwqBCIMKgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgQicK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0EgICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9zaXRp bmdUZXh0IGlzICdBQiAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgJworUEFTUyBj b21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAg ICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBjb21wb3NpdGlu Z1RleHQgaXMgJ0FCICAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEFCJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJyAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAg ICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3NpdGlu Z1RleHQgaXMgJyAgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgICBBQicK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEEgIEIgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICcJCUEJCUIJCScKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBD T01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9pbnNl cnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNl cnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43OGRm ZjYwNWI1OGViYTgxM2UwY2EyNDA1MWQzYmI2OGRiNDI0YmI1Ci0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3Bh Y2UuaHRtbApAQCAtMCwwICsxLDkwIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYv L0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBo cmVmPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNv bGUiPjwvZGl2PgorPHNjcmlwdD4KKwordmFyIHNlbCA9IGRvY3VtZW50LmdldFNlbGVjdGlvbigp OwordmFyIHJvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJyb290Iik7Citkb2N1bWVudC5i b2R5LmFwcGVuZENoaWxkKHJvb3QpOworCisKK2Z1bmN0aW9uIGNyZWF0ZUVkaXRhYmxlKHRhZ05h bWUsIHRleHQpIHsKKyAgICB2YXIgbm9kZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQodGFnTmFt ZSk7CisgICAgbm9kZS5jb250ZW50RWRpdGFibGUgPSB0cnVlOworICAgIG5vZGUuaW5uZXJIVE1M ID0gdGV4dDsKKyAgICByZXR1cm4gbm9kZTsKK30KKworZnVuY3Rpb24gdGVzdCh0YWdOYW1lLCBj b21wb3NpdGlvblRleHQsIGV4cGVjdGVkKSB7CisgICAgdmFyIG5vZGUgPSBjcmVhdGVFZGl0YWJs ZSh0YWdOYW1lLCAiWCIpOworICAgIHJvb3QuYXBwZW5kQ2hpbGQobm9kZSk7CisKKyAgICB2YXIg dGV4dE5vZGUgPSBub2RlLmZpcnN0Q2hpbGQ7CisgICAgc2VsLnNldEJhc2VBbmRFeHRlbnQodGV4 dE5vZGUsIDAsIHRleHROb2RlLCB0ZXh0Tm9kZS5kYXRhLmxlbmd0aCk7CisgICAgZG9jdW1lbnQu ZXhlY0NvbW1hbmQoIkRlbGV0ZSIsIGZhbHNlKTsKKworICAgIHRleHRJbnB1dENvbnRyb2xsZXIu c2V0TWFya2VkVGV4dChjb21wb3NpdGlvblRleHQsIDAsIGNvbXBvc2l0aW9uVGV4dCk7CisgICAg Y29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisgICAgdGV4dElucHV0Q29udHJvbGxl ci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4dCA9IG5vZGUuaW5uZXJUZXh0OworCisg ICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICInIiArIGV4cGVjdGVkICsgIiciKTsKK30K KwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJkaXYiLCAiQSBCIiwgIkEgQiIpOwor dGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwordGVzdCgiZGl2IiwgIkEgICBCIiwgIkEg XHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwgIkEgXHhBMCBceEEwQiIpOyAKKwordGVz dCgiZGl2IiwgIiBBQiIsICJceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgIEFCIiwgIlx4QTBceEEw QUIiKTsKK3Rlc3QoImRpdiIsICIgICBBQiIsICJceEEwXHhBMCBBQiIpOwordGVzdCgiZGl2Iiwg IiAgICBBQiIsICJceEEwXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgIEFCIiwgIlx4 QTBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICBBQiIsICJceEEwXHhBMCBceEEw IFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgICAgICBBQiIsICJceEEwXHhBMCBceEEwIFx4QTAg QUIiKTsKK3Rlc3QoImRpdiIsICJBQiAgIiwgIkFCIFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAg ICIsICJBQiBceEEwXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICIsICJBQiBceEEwIFx4QTAi KTsKK3Rlc3QoImRpdiIsICJBQiAgICAgIiwgIkFCIFx4QTAgXHhBMFx4QTAiKTsKK3Rlc3QoImRp diIsICJBQiAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAg ICAgICIsICJBQiBceEEwIFx4QTAgXHhBMFx4QTAiKTsKKwordGVzdCgiZGl2IiwgIiAgQSAgQiAg IiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7Cit0ZXN0KCJkaXYiLCAiXHRcdEFcdFx0Qlx0XHQi LCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKKwordGVzdCgicHJlIiwgIkFCIiwgIkFCIik7Cit0 ZXN0KCJwcmUiLCAiQSBCIiwgIkEgQiIpOwordGVzdCgicHJlIiwgIkEgIEIiLCAiQSAgQiIpOwor dGVzdCgicHJlIiwgIkEgICBCIiwgIkEgICBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgICBCIiwgIkEg ICAgQiIpOwordGVzdCgicHJlIiwgIkFCICAiLCAiQUIgICIpOwordGVzdCgicHJlIiwgIkFCICAg IiwgIkFCICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgIiwgIkFCICAgICIpOwordGVzdCgicHJl IiwgIkFCICAgICAiLCAiQUIgICAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICAgIiwgIkFCICAg ICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAgIiwgIkFCICAgICAgICIpOwordGVzdCgicHJl IiwgIiAgQUIiLCAiICBBQiIpOwordGVzdCgicHJlIiwgIiAgIEFCIiwgIiAgIEFCIik7Cit0ZXN0 KCJwcmUiLCAiICAgIEFCIiwgIiAgICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgQUIiLCAiICAg ICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgIEFCIiwgIiAgICAgIEFCIik7Cit0ZXN0KCJwcmUi LCAiICAgICAgIEFCIiwgIiAgICAgICBBQiIpOworCit0ZXN0KCJwcmUiLCAiICBBICBCICAiLCAi ICBBICBCICAiKTsKK3Rlc3QoInByZSIsICJcdFx0QVx0XHRCXHRcdCIsICJcdFx0QVx0XHRCXHRc dCIpOworCityb290LnN0eWxlLmRpc3BsYXkgPSAibm9uZSI7CitzdWNjZXNzZnVsbHlQYXJzZWQg PSB0cnVlOworCis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNl cy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IGFhMjY2NGU2MWNiNGYxNGQxZDJhZjk2OGFhOTk2YzJhNzc1MDk4MzkuLjc5ZTk1YTFmNTE2 Zjc5ZTRiMGFkM2YwYzFmZDllMmVlZTk2YzY2MDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NSBA QAorMjAxMS0wMS0xMyAgTU9SSVRBIEhhamltZSAgPG1vcnJpdGFAZ29vZ2xlLmNvbT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTcGFjZSBhbmQgdGFi IGNoYXJhY3RlcnMgInNlbnQiIGJ5IGFuIGlucHV0IG1ldGhvZCBnaXZlIHRvdGFsbHkgZGlmZmVy ZW50IHJlc3VsdHMgdGhhbiB0eXBpbmcgdGhlbSBkaXJlY3RseQorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0MQorICAgICAgICAKKyAgICAgICAgKiBJ bnRyb2R1Y2VkIFRleHRFdmVudDo6SW5wdXRUeXBlQ29tcG9zaXRpb24gYW5kIFR5cGluZ0NvbW1h bmQ6OlRleHRDb21wb3NpdGlvblR5cGUgdG8gCisgICAgICAgICAgZGlzdGluZ3Vpc2ggdGV4dCBp bnB1dCB3aGljaCBpcyBvcmlnaW5hdGVkIGJ5IGNvbXBvc2l0aW9uLgorICAgICAgICAqIEdlbmVy YWxpemVkIHJlYmFsYW5jZVdoaXRlc3BhY2VBdCgpIHRvIHJlYmFsYW5jZVdoaXRlc3BhY2VCZXR3 ZWVuKCkgdG8gcmViYWxhbmNpbmcgCisgICAgICAgICAgcmFuZ2Ugb2Ygc3RyaW5nIG9uIHRleHQg bm9kZSwgaW5zdGVhZCBvZiBzdXJyb3VuZGluZyBwYXJ0IG9mIHRoYXQuCisKKyAgICAgICAgVGVz dDogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbAor CisgICAgICAgICogZG9tL1RleHRFdmVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUZXh0RXZl bnQ6OnNlbGVjdElucHV0VHlwZSk6CisgICAgICAgICogZG9tL1RleHRFdmVudC5oOiBhZGQgVGV4 dEV2ZW50OjpJbnB1dFR5cGVDb21wb3NpdGlvbiBhcyBhIG1lbWJlciBvZiBUZXh0RXZlbnQ6Oklu cHV0VHlwZQorICAgICAgICAoV2ViQ29yZTo6VGV4dEV2ZW50Ojppc0NvbXBvc2l0aW9uKToKKyAg ICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQXQpOiByZXBsYWNl ZCB3aXRoIHJlYmFsYW5jZVdoaXRlc3BhY2VCZXR3ZWVuKCkKKyAgICAgICAgKFdlYkNvcmU6OkNv bXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQmV0d2Vlbik6IGdlbmVyYWxp emVkIHZlcnNpb24gb2YgcmViYWxhbmNlV2hpdGVzcGFjZUF0KCksIHdoaWNoIHRha2VzIDIgcG9z aXRpb24gYXMgYXJndW1ldG5zLgorICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1h bmQuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpF ZGl0b3I6Omluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbik6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6RWRpdG9yOjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24pOiBOb3cgdXNlcyBu c2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbigpCisgICAgICAgIChXZWJDb3JlOjpFZGl0 b3I6OnNldENvbXBvc2l0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5oOgorICAgICAg ICAqIGVkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5z ZXJ0VGV4dENvbW1hbmQ6OmlucHV0KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydFRleHRDb21t YW5kLmg6CisgICAgICAgICogZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlR5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1hbmQpOgorICAgICAgICAoV2ViQ29yZTo6 VHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21t YW5kOjppbnNlcnRUZXh0UnVuV2l0aG91dE5ld2xpbmVzKToKKyAgICAgICAgKiBlZGl0aW5nL1R5 cGluZ0NvbW1hbmQuaDogQWRkZWQgVHlwaW5nQ29tbWFuZDo6bV9jb21wb3NpdGlvblR5cGUgYW5k IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvblR5cGUKKyAgICAgICAgKFdlYkNvcmU6OlR5 cGluZ0NvbW1hbmQ6OnNldENvbXBvc2l0aW9uVHlwZSk6IEFkZGVkCisgICAgICAgIChXZWJDb3Jl OjpUeXBpbmdDb21tYW5kOjpjcmVhdGUpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQp OgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmg6CisKIDIwMTEtMDEtMTMgIERhbiBCZXJu c3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZlIEh5YXR0 LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcAppbmRleCA2OGVkNGIyNzMzYTJiZTFkYTRkOTYwMjA4 NWIwOGFjNTRlM2I5YmIxLi4yMmFlZTA3ZDFmOWJjMDRjMzRlNjBkOTQ0NTRlNGU1ODFiODA5ZmVk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcApAQCAtMzEsMTIgKzMxLDE0IEBACiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAotVGV4dEV2ZW50OjpJbnB1dFR5cGUgVGV4dEV2ZW50OjpzZWxlY3RJ bnB1dFR5cGUoYm9vbCBpc0xpbmVCcmVhaywgYm9vbCBpc0JhY2tUYWIpCitUZXh0RXZlbnQ6Oklu cHV0VHlwZSBUZXh0RXZlbnQ6OnNlbGVjdElucHV0VHlwZShib29sIGlzTGluZUJyZWFrLCBib29s IGlzQmFja1RhYiwgYm9vbCBpc0NvbXBvc2l0aW9uKQogewogICAgIGlmIChpc0xpbmVCcmVhaykK ICAgICAgICAgcmV0dXJuIFRleHRFdmVudDo6SW5wdXRUeXBlTGluZUJyZWFrOwogICAgIGlmIChp c0JhY2tUYWIpCiAgICAgICAgIHJldHVybiBUZXh0RXZlbnQ6OklucHV0VHlwZUJhY2tUYWI7Cisg ICAgaWYgKGlzQ29tcG9zaXRpb24pCisgICAgICAgIHJldHVybiBUZXh0RXZlbnQ6OklucHV0VHlw ZUNvbXBvc2l0aW9uOwogICAgIHJldHVybiBUZXh0RXZlbnQ6OklucHV0VHlwZUtleWJvYXJkOwog fQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9kb20vVGV4dEV2ZW50LmgKaW5kZXggZjFkMjRlOWM2ODEwZjU1YTQzNmNlZTZkMDRh ZTNkZDQxMmI3OTYyNC4uNWJiMzMzMGU1ZjkzNDVmNGJjMzNlOTY5ZTA4NmU3M2I4YTFjNjA0ZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9UZXh0RXZlbnQuaApAQCAtMzYsMTMgKzM2LDE0IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICBwdWJsaWM6CiAgICAgICAgIGVudW0gSW5wdXRUeXBlIHsKICAgICAgICAgICAg IElucHV0VHlwZUtleWJvYXJkLCAvLyBhbnkgbmV3bGluZSBjaGFyYWN0ZXJzIGluIHRoZSB0ZXh0 IGFyZSBsaW5lIGJyZWFrcyBvbmx5LCBub3QgcGFyYWdyYXBoIHNlcGFyYXRvcnMuCisgICAgICAg ICAgICBJbnB1dFR5cGVDb21wb3NpdGlvbiwgLy8gaW5wdXQgaXMgZG9uZSBieSBJTUUsIHNvIHdo aXRlc3BhY2UgY2hhcmFjdGVycyBzaG91bGQgYmUgcHJlc2VydmVkLgogICAgICAgICAgICAgSW5w dXRUeXBlTGluZUJyZWFrLCAvLyBhbnkgdGFiIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQgYXJlIGJh Y2t0YWJzLgogICAgICAgICAgICAgSW5wdXRUeXBlQmFja1RhYiwKICAgICAgICAgICAgIElucHV0 VHlwZVBhc3RlLAogICAgICAgICAgICAgSW5wdXRUeXBlRHJvcCwKICAgICAgICAgfTsKIAotICAg ICAgICBzdGF0aWMgSW5wdXRUeXBlIHNlbGVjdElucHV0VHlwZShib29sIGlzTGluZUJyZWFrLCBi b29sIGlzQmFja1RhYik7CisgICAgICAgIHN0YXRpYyBJbnB1dFR5cGUgc2VsZWN0SW5wdXRUeXBl KGJvb2wgaXNMaW5lQnJlYWssIGJvb2wgaXNCYWNrVGFiLCBib29sIGlzQ29tcG9zaXRpb24pOwog ICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxUZXh0RXZlbnQ+IGNyZWF0ZSgpOwogICAgICAgICBz dGF0aWMgUGFzc1JlZlB0cjxUZXh0RXZlbnQ+IGNyZWF0ZShQYXNzUmVmUHRyPEFic3RyYWN0Vmll dz4gdmlldywgY29uc3QgU3RyaW5nJiBkYXRhLCBJbnB1dFR5cGUgPSBJbnB1dFR5cGVLZXlib2Fy ZCk7CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPFRleHRFdmVudD4gY3JlYXRlRm9yUGxhaW5U ZXh0UGFzdGUoUGFzc1JlZlB0cjxBYnN0cmFjdFZpZXc+IHZpZXcsIGNvbnN0IFN0cmluZyYgZGF0 YSwgYm9vbCBzaG91bGRTbWFydFJlcGxhY2UpOwpAQCAtNTcsNiArNTgsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKICAgICAgICAgdmlydHVhbCBib29sIGlzVGV4dEV2ZW50KCkgY29uc3Q7CiAK KyAgICAgICAgYm9vbCBpc0NvbXBvc2l0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUg PT0gSW5wdXRUeXBlQ29tcG9zaXRpb247IH0KICAgICAgICAgYm9vbCBpc0xpbmVCcmVhaygpIGNv bnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IElucHV0VHlwZUxpbmVCcmVhazsgfQogICAgICAg ICBib29sIGlzQmFja1RhYigpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IElucHV0VHlw ZUJhY2tUYWI7IH0KICAgICAgICAgYm9vbCBpc1Bhc3RlKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1 dFR5cGUgPT0gSW5wdXRUeXBlUGFzdGU7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9D b21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKaW5kZXggNzQ4Nzc3ZDYwYWJhYjJlOWZiYTA5NjNjZmQ2 NzAyZTgwOWMxNDlhZi4uOGJjOTcwYTE4YjRiY2FlMzA0MjUxNDY4ZDBkYWI3MjMxMTcxYmU4NSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAK QEAgLTM5OCw3ICszOTgsMTIgQEAgc3RhdGljIGlubGluZSBib29sIGlzV2hpdGVzcGFjZShVQ2hh ciBjKQogLy8gRklYTUU6IERvZXNuJ3QgZ28gaW50byB0ZXh0IG5vZGVzIHRoYXQgY29udHJpYnV0 ZSBhZGphY2VudCB0ZXh0IChzaWJsaW5ncywgY291c2lucywgZXRjKS4KIHZvaWQgQ29tcG9zaXRl RWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRp b24pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHBvc2l0aW9uLm5vZGUoKTsKKyAgICByZWJhbGFuY2VX aGl0ZXNwYWNlQmV0d2Vlbihwb3NpdGlvbiwgcG9zaXRpb24pOworfQorCit2b2lkIENvbXBvc2l0 ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQmV0d2Vlbihjb25zdCBQb3NpdGlvbiYg c3RhcnRQb3NpdGlvbiwgY29uc3QgUG9zaXRpb24mIGVuZFBvc2l0aW9uKQoreworICAgIE5vZGUq IG5vZGUgPSBzdGFydFBvc2l0aW9uLm5vZGUoKTsKICAgICBpZiAoIW5vZGUgfHwgIW5vZGUtPmlz VGV4dE5vZGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgIFRleHQqIHRleHROb2RlID0gc3RhdGlj X2Nhc3Q8VGV4dCo+KG5vZGUpOwpAQCAtNDEyLDI4ICs0MTcsMzAgQEAgdm9pZCBDb21wb3NpdGVF ZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlv bikKICAgICBTdHJpbmcgdGV4dCA9IHRleHROb2RlLT5kYXRhKCk7CiAgICAgQVNTRVJUKCF0ZXh0 LmlzRW1wdHkoKSk7CiAKLSAgICBpbnQgb2Zmc2V0ID0gcG9zaXRpb24uZGVwcmVjYXRlZEVkaXRp bmdPZmZzZXQoKTsKKyAgICBpbnQgc3RhcnRPZmZzZXQgPSBzdGFydFBvc2l0aW9uLmRlcHJlY2F0 ZWRFZGl0aW5nT2Zmc2V0KCk7CisgICAgaW50IGVuZE9mZnNldCA9IGVuZFBvc2l0aW9uLmRlcHJl Y2F0ZWRFZGl0aW5nT2Zmc2V0KCk7CiAgICAgLy8gSWYgbmVpdGhlciB0ZXh0W29mZnNldF0gbm9y IHRleHRbb2Zmc2V0IC0gMV0gYXJlIHNvbWUgZm9ybSBvZiB3aGl0ZXNwYWNlLCBkbyBub3RoaW5n LgotICAgIGlmICghaXNXaGl0ZXNwYWNlKHRleHRbb2Zmc2V0XSkpIHsKLSAgICAgICAgb2Zmc2V0 LS07Ci0gICAgICAgIGlmIChvZmZzZXQgPCAwIHx8ICFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRd KSkKKyAgICBpZiAoIWlzV2hpdGVzcGFjZSh0ZXh0W3N0YXJ0T2Zmc2V0XSkgJiYgc3RhcnRPZmZz ZXQgPT0gZW5kT2Zmc2V0KSB7CisgICAgICAgIGludCBuZXdPZmZzZXQgPSBzdGFydE9mZnNldCAt IDE7CisgICAgICAgIGlmIChuZXdPZmZzZXQgPCAwIHx8ICFpc1doaXRlc3BhY2UodGV4dFtuZXdP ZmZzZXRdKSkKICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgc3RhcnRPZmZzZXQgPSBlbmRP ZmZzZXQgPSBuZXdPZmZzZXQ7CiAgICAgfQogICAgIAogICAgIC8vIFNldCB1cHN0cmVhbSBhbmQg ZG93bnN0cmVhbSB0byBkZWZpbmUgdGhlIGV4dGVudCBvZiB0aGUgd2hpdGVzcGFjZSBzdXJyb3Vu ZGluZyB0ZXh0W29mZnNldF0uCi0gICAgaW50IHVwc3RyZWFtID0gb2Zmc2V0OworICAgIGludCB1 cHN0cmVhbSA9IHN0YXJ0T2Zmc2V0OwogICAgIHdoaWxlICh1cHN0cmVhbSA+IDAgJiYgaXNXaGl0 ZXNwYWNlKHRleHRbdXBzdHJlYW0gLSAxXSkpCiAgICAgICAgIHVwc3RyZWFtLS07CiAgICAgCi0g ICAgaW50IGRvd25zdHJlYW0gPSBvZmZzZXQ7CisgICAgaW50IGRvd25zdHJlYW0gPSBzdGQ6Om1h eChzdGFydE9mZnNldCwgZW5kT2Zmc2V0IC0gMSk7CiAgICAgd2hpbGUgKCh1bnNpZ25lZClkb3du c3RyZWFtICsgMSA8IHRleHQubGVuZ3RoKCkgJiYgaXNXaGl0ZXNwYWNlKHRleHRbZG93bnN0cmVh bSArIDFdKSkKICAgICAgICAgZG93bnN0cmVhbSsrOwogICAgIAogICAgIGludCBsZW5ndGggPSBk b3duc3RyZWFtIC0gdXBzdHJlYW0gKyAxOwogICAgIEFTU0VSVChsZW5ndGggPiAwKTsKICAgICAK LSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0aW9uKHBvc2l0aW9u Lm5vZGUoKSwgdXBzdHJlYW0pKTsKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZURvd25zdHJl YW1Qb3MoUG9zaXRpb24ocG9zaXRpb24ubm9kZSgpLCBkb3duc3RyZWFtICsgMSkpOworICAgIFZp c2libGVQb3NpdGlvbiB2aXNpYmxlVXBzdHJlYW1Qb3MoUG9zaXRpb24oc3RhcnRQb3NpdGlvbi5u b2RlKCksIHVwc3RyZWFtKSk7CisgICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVEb3duc3RyZWFt UG9zKFBvc2l0aW9uKGVuZFBvc2l0aW9uLm5vZGUoKSwgZG93bnN0cmVhbSArIDEpKTsKICAgICAK ICAgICBTdHJpbmcgc3RyaW5nID0gdGV4dC5zdWJzdHJpbmcodXBzdHJlYW0sIGxlbmd0aCk7CiAg ICAgU3RyaW5nIHJlYmFsYW5jZWRTdHJpbmcgPSBzdHJpbmdXaXRoUmViYWxhbmNlZFdoaXRlc3Bh Y2Uoc3RyaW5nLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVF ZGl0Q29tbWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFu ZC5oCmluZGV4IDZkYjRlYjE4MmEwODg2YWQxZmQ4MGIwNGU4YzFjNmYzNjFjYjAzMDAuLjc0OGZm NmIzYjk4ODc2NDI3NjQ0MTdiNTE3MjMzNTg5NDUxYzNhZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKQEAgLTcxLDYgKzcxLDcgQEAgcHJvdGVj dGVkOgogICAgIHZvaWQgbWVyZ2VJZGVudGljYWxFbGVtZW50cyhQYXNzUmVmUHRyPEVsZW1lbnQ+ LCBQYXNzUmVmUHRyPEVsZW1lbnQ+KTsKICAgICB2b2lkIHJlYmFsYW5jZVdoaXRlc3BhY2UoKTsK ICAgICB2b2lkIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYpOworICAgIHZv aWQgcmViYWxhbmNlV2hpdGVzcGFjZUJldHdlZW4oY29uc3QgUG9zaXRpb24mLCBjb25zdCBQb3Np dGlvbiYpOwogICAgIHZvaWQgcHJlcGFyZVdoaXRlc3BhY2VBdFBvc2l0aW9uRm9yU3BsaXQoUG9z aXRpb24mKTsKICAgICB2b2lkIHJlbW92ZUNTU1Byb3BlcnR5KFBhc3NSZWZQdHI8U3R5bGVkRWxl bWVudD4sIENTU1Byb3BlcnR5SUQpOwogICAgIHZvaWQgcmVtb3ZlTm9kZUF0dHJpYnV0ZShQYXNz UmVmUHRyPEVsZW1lbnQ+LCBjb25zdCBRdWFsaWZpZWROYW1lJiBhdHRyaWJ1dGUpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IGEyNGU3YzYwYjUyNWU2MTVhYTFlZTEzNjNmNTgwMDFk NmUxMTBhNDIuLjVmY2RkNThjZTM5MmMwOTY4MDZhMGNmMmU5NzljMTBjZWVjYmNkM2EgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTExNzIsNyArMTE3MiwxMiBAQCBib29sIEVkaXRv cjo6aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQp CiAgICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5oYW5kbGVUZXh0SW5wdXRFdmVu dCh0ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwogfQogCi1ib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdp dGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCitib29sIEVkaXRvcjo6aW5zZXJ0VGV4 dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCkKK3sKKyAgICByZXR1 cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhhbmRsZVRleHRJbnB1dEV2ZW50KHRleHQsIDAs IGZhbHNlLCBmYWxzZSwgdHJ1ZSk7Cit9CisKK2Jvb2wgRWRpdG9yOjppbnNlcnRUZXh0V2l0aG91 dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVk VGV4dCwgVGV4dEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCiB7CiAgICAgaWYgKHRleHQuaXNFbXB0 eSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xMTk0LDcgKzExOTksOCBAQCBib29sIEVk aXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4 dCwgYm9vbCBzZWxlY3RJbgogICAgICAgICAgICAgUmVmUHRyPERvY3VtZW50PiBkb2N1bWVudCA9 IHNlbGVjdGlvblN0YXJ0LT5kb2N1bWVudCgpOwogICAgICAgICAgICAgCiAgICAgICAgICAgICAv LyBJbnNlcnQgdGhlIHRleHQKLSAgICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQo ZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKKyAg ICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQs IHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdHJpZ2dlcmluZ0V2ZW50ICYmIHRyaWdnZXJpbmdFdmVudC0+aXNDb21w b3NpdGlvbigpID8gVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uQ29uZmlybSA6IFR5cGlu Z0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbk5vbmUpOwogCiAgICAgICAgICAgICAvLyBSZXZlYWwg dGhlIGN1cnJlbnQgc2VsZWN0aW9uIAogICAgICAgICAgICAgaWYgKEZyYW1lKiBlZGl0ZWRGcmFt ZSA9IGRvY3VtZW50LT5mcmFtZSgpKQpAQCAtMTYxNyw3ICsxNjIzLDcgQEAgdm9pZCBFZGl0b3I6 OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgcHJlc2VydmVTZWxl Y3Rpb24pCiAgICAgbV9jb21wb3NpdGlvbk5vZGUgPSAwOwogICAgIG1fY3VzdG9tQ29tcG9zaXRp b25VbmRlcmxpbmVzLmNsZWFyKCk7CiAKLSAgICBpbnNlcnRUZXh0KHRleHQsIDApOworICAgIGlu c2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbih0ZXh0KTsKIAogICAgIGlmIChwcmVzZXJ2 ZVNlbGVjdGlvbikgewogICAgICAgICBtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+c2V0U2VsZWN0aW9u KG9sZFNlbGVjdGlvbiwgZmFsc2UsIGZhbHNlKTsKQEAgLTE2ODYsNyArMTY5Miw3IEBAIHZvaWQg RWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZlY3RvcjxD b21wb3NpdGlvblVuZGVybGluCiAgICAgbV9jdXN0b21Db21wb3NpdGlvblVuZGVybGluZXMuY2xl YXIoKTsKIAogICAgIGlmICghdGV4dC5pc0VtcHR5KCkpIHsKLSAgICAgICAgVHlwaW5nQ29tbWFu ZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0LCB0cnVlLCB0cnVlKTsKKyAg ICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0 LCB0cnVlLCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25VcGRhdGUpOwogCiAgICAgICAg IC8vIEZpbmQgb3V0IHdoYXQgbm9kZSBoYXMgdGhlIGNvbXBvc2l0aW9uIG5vdy4KICAgICAgICAg UG9zaXRpb24gYmFzZSA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5iYXNlKCkuZG93bnN0cmVhbSgp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaCBiL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKaW5kZXggMmU2MWNlNjdkMTgxODVhNjZhOTI4MDFkNmI3 YTk1YTQ3ODk0NmVjOS4uMWU2ZTM4NzNmNWRjOGRlZjJkMGQyMGEwMGNiMTMzMzhhOWMwOWE5ZiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0xOTgsNyArMTk4LDggQEAgcHVibGljOgogICAg IHN0YXRpYyBib29sIGNvbW1hbmRJc1N1cHBvcnRlZEZyb21NZW51T3JLZXlCaW5kaW5nKGNvbnN0 IFN0cmluZyYgY29tbWFuZE5hbWUpOyAvLyBXb3JrcyB3aXRob3V0IGEgZnJhbWUuCiAKICAgICBi b29sIGluc2VydFRleHQoY29uc3QgU3RyaW5nJiwgRXZlbnQqIHRyaWdnZXJpbmdFdmVudCk7Ci0g ICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpOworICAgIGJv b2wgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCk7 CisgICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5n JiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRFdmVudCogdHJpZ2dlcmluZ0V2ZW50KTsK ICAgICBib29sIGluc2VydExpbmVCcmVhaygpOwogICAgIGJvb2wgaW5zZXJ0UGFyYWdyYXBoU2Vw YXJhdG9yKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dFRleHRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1h bmQuY3BwCmluZGV4IGZjMThlOTEyZjk1MzYzNmFmYjI3MTZmMGMxNjIzZDUwOTA2ODlmNWQuLjk1 ZDAzMjVkNGM3YzIzMzhhZDI1ZTkwYjhhZTM4YmQ5MGRmM2JlYzAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCkBAIC0xMDYsNyArMTA2LDcgQEAgYm9v bCBJbnNlcnRUZXh0Q29tbWFuZDo6cGVyZm9ybVRyaXZpYWxSZXBsYWNlKGNvbnN0IFN0cmluZyYg dGV4dCwgYm9vbCBzZWxlY3RJbnMKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBJbnNlcnRU ZXh0Q29tbWFuZDo6aW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVk VGV4dCkKK3ZvaWQgSW5zZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFdoaXRlc3BhY2VSZWJhbGFuY2VUeXBlIHdoaXRlc3Bh Y2VSZWJhbGFuY2UpCiB7CiAgICAgCiAgICAgQVNTRVJUKHRleHQuZmluZCgnXG4nKSA9PSBub3RG b3VuZCk7CkBAIC0xNzIsMTEgKzE3MiwxNiBAQCB2b2lkIEluc2VydFRleHRDb21tYW5kOjppbnB1 dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0KQogICAgICAgICBp bnNlcnRUZXh0SW50b05vZGUodGV4dE5vZGUsIG9mZnNldCwgdGV4dCk7CiAgICAgICAgIGVuZFBv c2l0aW9uID0gUG9zaXRpb24odGV4dE5vZGUsIG9mZnNldCArIHRleHQubGVuZ3RoKCkpOwogCi0g ICAgICAgIC8vIFRoZSBpbnNlcnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdo aXRlc3BhY2UsIGlmIGl0IGlzIHByZXNlbnQuCi0gICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VB dChlbmRQb3NpdGlvbik7Ci0gICAgICAgIC8vIFJlYmFsYW5jaW5nIG9uIGJvdGggc2lkZXMgaXNu J3QgbmVjZXNzYXJ5IGlmIHdlJ3ZlIGluc2VydGVkIGEgc3BhY2UuCi0gICAgICAgIGlmICh0ZXh0 ICE9ICIgIikgCi0gICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoc3RhcnRQb3NpdGlv bik7CisgICAgICAgIGlmICh3aGl0ZXNwYWNlUmViYWxhbmNlID09IFdoaXRlc3BhY2VSZWJhbGFu Y2VTdXJyb3VuZGluZykgeworICAgICAgICAgICAgLy8gVGhlIGluc2VydGlvbiBtYXkgcmVxdWly ZSBhZGp1c3RpbmcgYWRqYWNlbnQgd2hpdGVzcGFjZSwgaWYgaXQgaXMgcHJlc2VudC4KKyAgICAg ICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChlbmRQb3NpdGlvbik7CisgICAgICAgICAgICAv LyBSZWJhbGFuY2luZyBvbiBib3RoIHNpZGVzIGlzbid0IG5lY2Vzc2FyeSBpZiB3ZSd2ZSBpbnNl cnRlZCBhIHNwYWNlLgorICAgICAgICAgICAgaWYgKHRleHQgIT0gIiAiKSAKKyAgICAgICAgICAg ICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoc3RhcnRQb3NpdGlvbik7CisgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICBBU1NFUlQod2hpdGVzcGFjZVJlYmFsYW5jZSA9PSBXaGl0ZXNwYWNl UmViYWxhbmNlQWxsKTsKKyAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VCZXR3ZWVuKHN0 YXJ0UG9zaXRpb24sIGVuZFBvc2l0aW9uKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIC8vIFdl IGNvdWxkIGhhdmUgaW5zZXJ0ZWQgYSBwYXJ0IG9mIGNvbXBvc2VkIGNoYXJhY3RlciBzZXF1ZW5j ZSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQu aCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaAppbmRleCA3N2Fl MDE2ZDM2YTE0ZmIxZjgxNDlkZjdhYTM0MTJjZGVjMWQyMmRlLi43NDFiMDVhM2M0OGRiZTA5YzBi YmE4ZWFjODdhY2VmZTIyODQ0OTc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0luc2VydFRleHRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRU ZXh0Q29tbWFuZC5oCkBAIC0zMiwxNCArMzIsMjAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBJbnNlcnRUZXh0Q29tbWFuZCA6IHB1YmxpYyBDb21wb3NpdGVFZGl0Q29tbWFuZCB7CiBw dWJsaWM6CisgICAgZW51bSBXaGl0ZXNwYWNlUmViYWxhbmNlVHlwZSB7CisgICAgICAgIFdoaXRl c3BhY2VSZWJhbGFuY2VTdXJyb3VuZGluZywKKyAgICAgICAgV2hpdGVzcGFjZVJlYmFsYW5jZUFs bCwKKyAgICB9OworCiAgICAgc3RhdGljIFBhc3NSZWZQdHI8SW5zZXJ0VGV4dENvbW1hbmQ+IGNy ZWF0ZShEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgewogICAgICAgICByZXR1cm4gYWRvcHRSZWYo bmV3IEluc2VydFRleHRDb21tYW5kKGRvY3VtZW50KSk7CiAgICAgfQogCi0gICAgdm9pZCBpbnB1 dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UpOwor ICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4 dCA9IGZhbHNlLCBXaGl0ZXNwYWNlUmViYWxhbmNlVHlwZSA9IFdoaXRlc3BhY2VSZWJhbGFuY2VT dXJyb3VuZGluZyk7CiAKIHByaXZhdGU6CisKICAgICBJbnNlcnRUZXh0Q29tbWFuZChEb2N1bWVu dCopOwogCiAgICAgdm9pZCBkZWxldGVDaGFyYWN0ZXIoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L1R5cGluZ0NvbW1hbmQuY3BwCmluZGV4IGQ1NGIzODg1YmY5OGZlNTJiZDlhNjVjNTRhOGQ3MWQ5 Njc2MDdlOWQuLmMzYzdiYWI4MTRhNTQxNGQ4Mjk0ZDBiMzU5MWM5OWVjMmQxZDcxODMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcApAQCAtNDcsNyArNDcsOCBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIHVzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CiAKLVR5cGlu Z0NvbW1hbmQ6OlR5cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRvY3VtZW50LCBFVHlwaW5nQ29tbWFu ZCBjb21tYW5kVHlwZSwgY29uc3QgU3RyaW5nICZ0ZXh0VG9JbnNlcnQsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcpCitU eXBpbmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwgRVR5cGluZ0Nv bW1hbmQgY29tbWFuZFR5cGUsIGNvbnN0IFN0cmluZyAmdGV4dFRvSW5zZXJ0LCBib29sIHNlbGVj dEluc2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5LCBUZXh0Q29tcG9zaXRp b25UeXBlIGNvbXBvc2l0aW9uVHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9v bCBraWxsUmluZykKICAgICA6IENvbXBvc2l0ZUVkaXRDb21tYW5kKGRvY3VtZW50KSwgCiAgICAg ICBtX2NvbW1hbmRUeXBlKGNvbW1hbmRUeXBlKSwgCiAgICAgICBtX3RleHRUb0luc2VydCh0ZXh0 VG9JbnNlcnQpLCAKQEAgLTU1LDYgKzU2LDcgQEAgVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFu ZChEb2N1bWVudCAqZG9jdW1lbnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb24KICAg ICAgIG1fc2VsZWN0SW5zZXJ0ZWRUZXh0KHNlbGVjdEluc2VydGVkVGV4dCksCiAgICAgICBtX3Nt YXJ0RGVsZXRlKGZhbHNlKSwKICAgICAgIG1fZ3JhbnVsYXJpdHkoZ3JhbnVsYXJpdHkpLAorICAg ICAgbV9jb21wb3NpdGlvblR5cGUoY29tcG9zaXRpb25UeXBlKSwKICAgICAgIG1fa2lsbFJpbmco a2lsbFJpbmcpLAogICAgICAgbV9vcGVuZWRCeUJhY2t3YXJkRGVsZXRlKGZhbHNlKQogewpAQCAt MTMzLDE4ICsxMzUsMTggQEAgdm9pZCBUeXBpbmdDb21tYW5kOjp1cGRhdGVTZWxlY3Rpb25JZkRp ZmZlcmVudEZyb21DdXJyZW50U2VsZWN0aW9uKFR5cGluZ0NvbW1hbmQKIH0KICAgICAKIAotdm9p ZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3Ry aW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgYm9vbCBpbnNlcnRlZFRleHRJc0Nv bXBvc2l0aW9uKQordm9pZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1 bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dENv bXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvbikKIHsKICAgICBBU1NFUlQoZG9jdW1lbnQpOwogICAg IAogICAgIEZyYW1lKiBmcmFtZSA9IGRvY3VtZW50LT5mcmFtZSgpOwogICAgIEFTU0VSVChmcmFt ZSk7CiAKLSAgICBpbnNlcnRUZXh0KGRvY3VtZW50LCB0ZXh0LCBmcmFtZS0+c2VsZWN0aW9uKCkt PnNlbGVjdGlvbigpLCBzZWxlY3RJbnNlcnRlZFRleHQsIGluc2VydGVkVGV4dElzQ29tcG9zaXRp b24pOworICAgIGluc2VydFRleHQoZG9jdW1lbnQsIHRleHQsIGZyYW1lLT5zZWxlY3Rpb24oKS0+ c2VsZWN0aW9uKCksIHNlbGVjdEluc2VydGVkVGV4dCwgY29tcG9zaXRpb24pOwogfQogCiAvLyBG SVhNRTogV2Ugc2hvdWxkbid0IG5lZWQgdG8gdGFrZSBzZWxlY3Rpb25Gb3JJbnNlcnRpb24uIEl0 IHNob3VsZCBiZSBpZGVudGljYWwgdG8gU2VsZWN0aW9uQ29udHJvbGxlcidzIGN1cnJlbnQgc2Vs ZWN0aW9uLgotdm9pZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVu dCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb25G b3JJbnNlcnRpb24sIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBib29sIGluc2VydGVkVGV4dElz Q29tcG9zaXRpb24pCit2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRv Y3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVj dGlvbkZvckluc2VydGlvbiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRDb21wb3NpdGlv blR5cGUgY29tcG9zaXRpb25UeXBlKQogewogI2lmIFJFTU9WRV9NQVJLRVJTX1VQT05fRURJVElO RwogICAgIGlmICghdGV4dC5pc0VtcHR5KCkpCkBAIC0xNjEsNyArMTYzLDcgQEAgdm9pZCBUeXBp bmdDb21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0 ZXh0LCBjb25zdCBWaXMKICAgICBTdHJpbmcgbmV3VGV4dCA9IHRleHQ7CiAgICAgTm9kZSogc3Rh cnROb2RlID0gc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLnN0YXJ0KCkubm9kZSgpOwogICAgIAotICAg IGlmIChzdGFydE5vZGUgJiYgc3RhcnROb2RlLT5yb290RWRpdGFibGVFbGVtZW50KCkgJiYgIWlu c2VydGVkVGV4dElzQ29tcG9zaXRpb24pIHsgICAgICAgIAorICAgIGlmIChzdGFydE5vZGUgJiYg c3RhcnROb2RlLT5yb290RWRpdGFibGVFbGVtZW50KCkgJiYgY29tcG9zaXRpb25UeXBlICE9IFRl eHRDb21wb3NpdGlvblVwZGF0ZSkgewogICAgICAgICAvLyBTZW5kIEJlZm9yZVRleHRJbnNlcnRl ZEV2ZW50LiBUaGUgZXZlbnQgaGFuZGxlciB3aWxsIHVwZGF0ZSB0ZXh0IGlmIG5lY2Vzc2FyeS4K ICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAgIFJlZlB0cjxCZWZvcmVUZXh0 SW5zZXJ0ZWRFdmVudD4gZXZ0ID0gQmVmb3JlVGV4dEluc2VydGVkRXZlbnQ6OmNyZWF0ZSh0ZXh0 KTsKQEAgLTE4MiwxMSArMTg0LDEzIEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChE b2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzCiAgICAgICAg ICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+c2V0U3RhcnRpbmdTZWxlY3Rpb24oc2VsZWN0aW9uRm9y SW5zZXJ0aW9uKTsKICAgICAgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRFbmRpbmdTZWxl Y3Rpb24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKICAgICAgICAgfQorICAgICAgICAKKyAgICAg ICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNldENvbXBvc2l0aW9uVHlwZShjb21wb3NpdGlvblR5cGUp OwogICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+aW5zZXJ0VGV4dChuZXdUZXh0LCBzZWxlY3RJ bnNlcnRlZFRleHQpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgUmVmUHRyPFR5cGlu Z0NvbW1hbmQ+IGNtZCA9IFR5cGluZ0NvbW1hbmQ6OmNyZWF0ZShkb2N1bWVudCwgSW5zZXJ0VGV4 dCwgbmV3VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKKyAgICBSZWZQdHI8VHlwaW5nQ29tbWFu ZD4gY21kID0gVHlwaW5nQ29tbWFuZDo6Y3JlYXRlKGRvY3VtZW50LCBJbnNlcnRUZXh0LCBuZXdU ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGNvbXBvc2l0aW9uVHlwZSk7CiAgICAgaWYgKGNoYW5n ZVNlbGVjdGlvbikgIHsKICAgICAgICAgY21kLT5zZXRTdGFydGluZ1NlbGVjdGlvbihzZWxlY3Rp b25Gb3JJbnNlcnRpb24pOwogICAgICAgICBjbWQtPnNldEVuZGluZ1NlbGVjdGlvbihzZWxlY3Rp b25Gb3JJbnNlcnRpb24pOwpAQCAtMzg2LDcgKzM5MCw4IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6 aW5zZXJ0VGV4dFJ1bldpdGhvdXROZXdsaW5lcyhjb25zdCBTdHJpbmcgJnRleHQsIGJvb2wgc2Vs ZWN0CiAgICAgICAgIGNvbW1hbmQtPnNldFN0YXJ0aW5nU2VsZWN0aW9uKGVuZGluZ1NlbGVjdGlv bigpKTsKICAgICAgICAgY29tbWFuZC0+c2V0RW5kaW5nU2VsZWN0aW9uKGVuZGluZ1NlbGVjdGlv bigpKTsKICAgICB9Ci0gICAgY29tbWFuZC0+aW5wdXQodGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0 KTsKKyAgICBjb21tYW5kLT5pbnB1dCh0ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIAorICAgICAg ICAgICAgICAgICAgIG1fY29tcG9zaXRpb25UeXBlID09IFRleHRDb21wb3NpdGlvbk5vbmUgPyBJ bnNlcnRUZXh0Q29tbWFuZDo6V2hpdGVzcGFjZVJlYmFsYW5jZVN1cnJvdW5kaW5nIDogSW5zZXJ0 VGV4dENvbW1hbmQ6OldoaXRlc3BhY2VSZWJhbGFuY2VBbGwpOwogICAgIHR5cGluZ0FkZGVkVG9P cGVuQ29tbWFuZChJbnNlcnRUZXh0KTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9UeXBpbmdDb21tYW5kLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0Nv bW1hbmQuaAppbmRleCAyODRlYmMwYWMyNjVkNzZiMTZhODBiZjI2MTFjN2E4MGU2ODBhZDBmLi5i MzRiZGMxMjIxYTIyYTMwMTI0YTkwODgwMTBjMDU0NjUxYmZkZTZkIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL1R5cGluZ0NvbW1hbmQuaApAQCAtNDIsMTEgKzQyLDE3IEBAIHB1YmxpYzoKICAgICAg ICAgSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9ySW5RdW90ZWRDb250ZW50CiAgICAgfTsKIAorICAg IGVudW0gVGV4dENvbXBvc2l0aW9uVHlwZSB7CisgICAgICAgIFRleHRDb21wb3NpdGlvbk5vbmUs CisgICAgICAgIFRleHRDb21wb3NpdGlvblVwZGF0ZSwKKyAgICAgICAgVGV4dENvbXBvc2l0aW9u Q29uZmlybQorICAgIH07CisKICAgICBzdGF0aWMgdm9pZCBkZWxldGVTZWxlY3Rpb24oRG9jdW1l bnQqLCBib29sIHNtYXJ0RGVsZXRlID0gZmFsc2UpOwogICAgIHN0YXRpYyB2b2lkIGRlbGV0ZUtl eVByZXNzZWQoRG9jdW1lbnQqLCBib29sIHNtYXJ0RGVsZXRlID0gZmFsc2UsIFRleHRHcmFudWxh cml0eSA9IENoYXJhY3RlckdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nID0gZmFsc2UpOwogICAg IHN0YXRpYyB2b2lkIGZvcndhcmREZWxldGVLZXlQcmVzc2VkKERvY3VtZW50KiwgYm9vbCBzbWFy dERlbGV0ZSA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSwg Ym9vbCBraWxsUmluZyA9IGZhbHNlKTsKLSAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3Vt ZW50KiwgY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgYm9v bCBpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uID0gZmFsc2UpOwotICAgIHN0YXRpYyB2b2lkIGlu c2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBWaXNpYmxlU2VsZWN0aW9u JiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgYm9vbCBpbnNlcnRlZFRleHRJc0Nv bXBvc2l0aW9uID0gZmFsc2UpOworICAgIHN0YXRpYyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQq LCBjb25zdCBTdHJpbmcmLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBUZXh0Q29t cG9zaXRpb25UeXBlID0gVGV4dENvbXBvc2l0aW9uTm9uZSk7CisgICAgc3RhdGljIHZvaWQgaW5z ZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IFZpc2libGVTZWxlY3Rpb24m LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBUZXh0Q29tcG9zaXRpb25UeXBlID0g VGV4dENvbXBvc2l0aW9uTm9uZSk7CiAgICAgc3RhdGljIHZvaWQgaW5zZXJ0TGluZUJyZWFrKERv Y3VtZW50Kik7CiAgICAgc3RhdGljIHZvaWQgaW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yKERvY3Vt ZW50Kik7CiAgICAgc3RhdGljIHZvaWQgaW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9ySW5RdW90ZWRD b250ZW50KERvY3VtZW50Kik7CkBAIC02NCwxNCArNzAsMjAgQEAgcHVibGljOgogICAgIHZvaWQg ZGVsZXRlS2V5UHJlc3NlZChUZXh0R3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcpOwogICAgIHZv aWQgZm9yd2FyZERlbGV0ZUtleVByZXNzZWQoVGV4dEdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5n KTsKICAgICB2b2lkIGRlbGV0ZVNlbGVjdGlvbihib29sIHNtYXJ0RGVsZXRlKTsKKyAgICB2b2lk IHNldENvbXBvc2l0aW9uVHlwZShUZXh0Q29tcG9zaXRpb25UeXBlIHR5cGUpIHsgbV9jb21wb3Np dGlvblR5cGUgPSB0eXBlOyB9CiAKIHByaXZhdGU6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8VHlw aW5nQ29tbWFuZD4gY3JlYXRlKERvY3VtZW50KiBkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29t bWFuZCwgY29uc3QgU3RyaW5nJiB0ZXh0ID0gIiIsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0g ZmFsc2UsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSA9IENoYXJhY3RlckdyYW51bGFyaXR5 LCBib29sIGtpbGxSaW5nID0gZmFsc2UpCiAgICAgewotICAgICAgICByZXR1cm4gYWRvcHRSZWYo bmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVjdEluc2VydGVk VGV4dCwgZ3JhbnVsYXJpdHksIGtpbGxSaW5nKSk7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihu ZXcgVHlwaW5nQ29tbWFuZChkb2N1bWVudCwgY29tbWFuZCwgdGV4dCwgc2VsZWN0SW5zZXJ0ZWRU ZXh0LCBncmFudWxhcml0eSwgVGV4dENvbXBvc2l0aW9uTm9uZSwga2lsbFJpbmcpKTsKKyAgICB9 CisKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUeXBpbmdDb21tYW5kPiBjcmVhdGUoRG9jdW1lbnQq IGRvY3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kLCBjb25zdCBTdHJpbmcmIHRleHQsIGJv b2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uVHlw ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgVHlwaW5nQ29tbWFuZChkb2N1 bWVudCwgY29tbWFuZCwgdGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBDaGFyYWN0ZXJHcmFudWxh cml0eSwgY29tcG9zaXRpb25UeXBlLCBmYWxzZSkpOwogICAgIH0KIAotICAgIFR5cGluZ0NvbW1h bmQoRG9jdW1lbnQqLCBFVHlwaW5nQ29tbWFuZCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNl bGVjdEluc2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nKTsKKyAgICBU eXBpbmdDb21tYW5kKERvY3VtZW50KiwgRVR5cGluZ0NvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4 dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSwgVGV4dENvbXBvc2l0 aW9uVHlwZSwgYm9vbCBraWxsUmluZyk7CiAKICAgICBib29sIHNtYXJ0RGVsZXRlKCkgY29uc3Qg eyByZXR1cm4gbV9zbWFydERlbGV0ZTsgfQogICAgIHZvaWQgc2V0U21hcnREZWxldGUoYm9vbCBz bWFydERlbGV0ZSkgeyBtX3NtYXJ0RGVsZXRlID0gc21hcnREZWxldGU7IH0KQEAgLTk0LDYgKzEw Niw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX3NlbGVjdEluc2VydGVkVGV4dDsKICAgICBib29s IG1fc21hcnREZWxldGU7CiAgICAgVGV4dEdyYW51bGFyaXR5IG1fZ3JhbnVsYXJpdHk7CisgICAg VGV4dENvbXBvc2l0aW9uVHlwZSBtX2NvbXBvc2l0aW9uVHlwZTsKICAgICBib29sIG1fa2lsbFJp bmc7CiAgICAgYm9vbCBtX3ByZXNlcnZlc1R5cGluZ1N0eWxlOwogICAgIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IGQwZjE3NTZhOTU2ZmU2NmM0MjBhNTI2NjJjODdhOTFl OWFjMjI2YWUuLmNkNTcxZjZmYjUyYWQ2ODc4ZjE4NWZkOTBlN2IwZmEzNTYyZjEyMzQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTI2NTIsNyArMjY1Miw3IEBAIGNsZWFu dXBEcmFnOgogfQogI2VuZGlmIC8vIEVOQUJMRShEUkFHX1NVUFBPUlQpCiAgIAotYm9vbCBFdmVu dEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQq IHVuZGVybHlpbmdFdmVudCwgYm9vbCBpc0xpbmVCcmVhaywgYm9vbCBpc0JhY2tUYWIpCitib29s IEV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0LCBF dmVudCogdW5kZXJseWluZ0V2ZW50LCBib29sIGlzTGluZUJyZWFrLCBib29sIGlzQmFja1RhYiwg Ym9vbCBpc0NvbXBvc2l0aW9uKQogewogICAgIC8vIFBsYXRmb3JtcyBzaG91bGQgZGlmZmVyZW50 aWF0ZSByZWFsIGNvbW1hbmRzIGxpa2Ugc2VsZWN0QWxsIGZyb20gdGV4dCBpbnB1dCBpbiBkaXNn dWlzZSAobGlrZSBpbnNlcnROZXdsaW5lKSwKICAgICAvLyBhbmQgYXZvaWQgZGlzcGF0Y2hpbmcg dGV4dCBpbnB1dCBldmVudHMgZnJvbSBrZXlkb3duIGRlZmF1bHQgaGFuZGxlcnMuCkBAIC0yNjcz LDcgKzI2NzMsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQoY29u c3QgU3RyaW5nJiB0ZXh0LCBFdmVudCogdW5kZXJseWluZ0V2ZQogICAgIGlmIChGcmFtZVZpZXcq IHZpZXcgPSBtX2ZyYW1lLT52aWV3KCkpCiAgICAgICAgIHZpZXctPnJlc2V0RGVmZXJyZWRSZXBh aW50RGVsYXkoKTsKIAotICAgIFJlZlB0cjxUZXh0RXZlbnQ+IGV2ZW50ID0gVGV4dEV2ZW50Ojpj cmVhdGUobV9mcmFtZS0+ZG9tV2luZG93KCksIHRleHQsIFRleHRFdmVudDo6c2VsZWN0SW5wdXRU eXBlKGlzTGluZUJyZWFrLCBpc0JhY2tUYWIpKTsKKyAgICBSZWZQdHI8VGV4dEV2ZW50PiBldmVu dCA9IFRleHRFdmVudDo6Y3JlYXRlKG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBUZXh0RXZl bnQ6OnNlbGVjdElucHV0VHlwZShpc0xpbmVCcmVhaywgaXNCYWNrVGFiLCBpc0NvbXBvc2l0aW9u KSk7CiAgICAgZXZlbnQtPnNldFVuZGVybHlpbmdFdmVudCh1bmRlcmx5aW5nRXZlbnQpOwogCiAg ICAgRXhjZXB0aW9uQ29kZSBlYzsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZl bnRIYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCmluZGV4IDY1 Njk1YzI3NWYwMDZhMGQ4OTg5ODgzM2FjNzU3MGE3ODRmYmEwN2MuLjdmZTVkYmFhZmFmYTQ5M2Yz ZTM3NGI2ZGFjNWVkM2QyOWZkNGI3OTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv RXZlbnRIYW5kbGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuaApA QCAtMTc0LDcgKzE3NCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGRlZmF1bHRLZXlib2FyZEV2ZW50 SGFuZGxlcihLZXlib2FyZEV2ZW50Kik7CiAKICAgICBib29sIGhhbmRsZVRleHRJbnB1dEV2ZW50 KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmVudCA9IDAsCi0gICAgICAg IGJvb2wgaXNMaW5lQnJlYWsgPSBmYWxzZSwgYm9vbCBpc0JhY2tUYWIgPSBmYWxzZSk7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBib29sIGlzTGluZUJyZWFrID0gZmFsc2UsIGJvb2wg aXNCYWNrVGFiID0gZmFsc2UsIGJvb2wgaXNDb21wb3NpdGlvbiA9IGZhbHNlKTsKICAgICB2b2lk IGRlZmF1bHRUZXh0SW5wdXRFdmVudEhhbmRsZXIoVGV4dEV2ZW50Kik7CiAKICNpZiBFTkFCTEUo RFJBR19TVVBQT1JUKQo= 78929 2011-01-14 05:15:52 -0800 2011-01-17 00:00:50 -0800 Patch bug-5241-20110114221549.patch text/plain 31488 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0ZjY4OTAwMTU4M2VhMzhhNmIwOGZiNTM3ZWVkNDJiYWViNTAwOTliLi5jNjJjMWI5 NGRkYzkzZjk5Mzk2N2NmYjEzY2Y3ZjgxYTQ0ZmY2ODI1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTMgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKyAgICAgICAgCisgICAgICAgIEFkZGVk IGEgdGVzdCB0aGF0IGV4ZXJjaXNlcyBjb250aW5vdXMgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzIGFu ZCB0YWJzIGluc2VydGVkIGJ5IElNRS4KKworICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbDog QWRkZWQuCisKIDIwMTEtMDEtMTQgIEFuZHJleSBLb3N5YWtvdiAgPGNhc2VxQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBSZXZpZXdlZCBieSBQYXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2Ut ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBv c2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQwODdjYTRjOTFlMzZm YmIzMTIxZDhiNDNjMmE2ZThiMGVjNzJiYzkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSw0OSBAQAorUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKg QicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4 dCBpcyAnQSDCoCDCoEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqBBQicKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICfCoMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCBB QicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgQUInCitQQVNTIGNvbXBvc2l0aW5n VGV4dCBpcyAnwqDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKg QUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoCBBQicKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICdBQiDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoMKgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ0FCIMKgIMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqAnCitQ QVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICfCoMKgQSDCoEIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoEEgwqBC IMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ8KgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoMKgJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICBCJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlz ICdBQiAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgJworUEFTUyBjb21wb3NpdGlu Z1RleHQgaXMgJ0FCICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICAgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0FCICAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEFCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJyAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICBBQicKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg JyAgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgICBBQicKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICcgIEEgIEIgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcJCUEJ CUIJCScKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJyAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICcKK1BBU1Mgc3VjY2Vzc2Z1bGx5 UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sIGIv TGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3Bh Y2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5lMDEyMTA0N2Q1ZWUyMjYwNDRmNjJjNjg5ZmI0OTZkZmVjYjgy ODkyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5z ZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApAQCAtMCwwICsxLDk3IEBACis8IURPQ1RZ UEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgor PGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10 ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRp b24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdD4KKwordmFyIHNlbCA9 IGRvY3VtZW50LmdldFNlbGVjdGlvbigpOwordmFyIHJvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJyb290Iik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHJvb3QpOworCisKK2Z1bmN0 aW9uIGNyZWF0ZUVkaXRhYmxlKHRhZ05hbWUsIHRleHQpIHsKKyAgICB2YXIgbm9kZSA9IGRvY3Vt ZW50LmNyZWF0ZUVsZW1lbnQodGFnTmFtZSk7CisgICAgbm9kZS5jb250ZW50RWRpdGFibGUgPSB0 cnVlOworICAgIG5vZGUuaW5uZXJIVE1MID0gdGV4dDsKKyAgICByZXR1cm4gbm9kZTsKK30KKwor ZnVuY3Rpb24gdGVzdCh0YWdOYW1lLCBjb21wb3NpdGlvblRleHQsIGV4cGVjdGVkKSB7CisgICAg dmFyIG5vZGUgPSBjcmVhdGVFZGl0YWJsZSh0YWdOYW1lLCAiWCIpOworICAgIHJvb3QuYXBwZW5k Q2hpbGQobm9kZSk7CisKKyAgICB2YXIgdGV4dE5vZGUgPSBub2RlLmZpcnN0Q2hpbGQ7CisgICAg c2VsLnNldEJhc2VBbmRFeHRlbnQodGV4dE5vZGUsIDAsIHRleHROb2RlLCB0ZXh0Tm9kZS5kYXRh Lmxlbmd0aCk7CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoIkRlbGV0ZSIsIGZhbHNlKTsKKwor ICAgIHRleHRJbnB1dENvbnRyb2xsZXIuc2V0TWFya2VkVGV4dChjb21wb3NpdGlvblRleHQsIDAs IGNvbXBvc2l0aW9uVGV4dCk7CisgICAgY29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7 CisgICAgdGV4dElucHV0Q29udHJvbGxlci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4 dCA9IG5vZGUuaW5uZXJUZXh0OworCisgICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICIn IiArIGV4cGVjdGVkICsgIiciKTsKK30KKwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0 KCJkaXYiLCAiQSBCIiwgIkEgQiIpOwordGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwor dGVzdCgiZGl2IiwgIkEgICBCIiwgIkEgXHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwg IkEgXHhBMCBceEEwQiIpOyAKKwordGVzdCgiZGl2IiwgIiBBQiIsICJceEEwQUIiKTsKK3Rlc3Qo ImRpdiIsICIgIEFCIiwgIlx4QTBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICBBQiIsICJceEEw XHhBMCBBQiIpOwordGVzdCgiZGl2IiwgIiAgICBBQiIsICJceEEwXHhBMCBceEEwQUIiKTsKK3Rl c3QoImRpdiIsICIgICAgIEFCIiwgIlx4QTBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICIg ICAgICBBQiIsICJceEEwXHhBMCBceEEwIFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgICAgICBB QiIsICJceEEwXHhBMCBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICJBQiAgIiwgIkFCIFx4 QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICIsICJBQiBceEEwXHhBMCIpOwordGVzdCgiZGl2Iiwg IkFCICAgICIsICJBQiBceEEwIFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgIiwgIkFCIFx4 QTAgXHhBMFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgICIsICJBQiBceEEwIFx4QTAgXHhB MCIpOwordGVzdCgiZGl2IiwgIkFCICAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMFx4QTAiKTsK KwordGVzdCgiZGl2IiwgIiAgQSAgQiAgIiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7Cit0ZXN0 KCJkaXYiLCAiXHRcdEFcdFx0Qlx0XHQiLCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKKwordGVz dCgiZGl2IiwgIiAiLCAiXHhBMCIpOwordGVzdCgiZGl2IiwgIiAgIiwgIlx4QTBceEEwIik7Cit0 ZXN0KCJkaXYiLCAiICAgIiwgIlx4QTBceEEwXHhBMCIpOworCit0ZXN0KCJwcmUiLCAiQUIiLCAi QUIiKTsKK3Rlc3QoInByZSIsICJBIEIiLCAiQSBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgQiIsICJB ICBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgIEIiLCAiQSAgIEIiKTsKK3Rlc3QoInByZSIsICJBICAg IEIiLCAiQSAgICBCIik7Cit0ZXN0KCJwcmUiLCAiQUIgICIsICJBQiAgIik7Cit0ZXN0KCJwcmUi LCAiQUIgICAiLCAiQUIgICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAiLCAiQUIgICAgIik7Cit0 ZXN0KCJwcmUiLCAiQUIgICAgICIsICJBQiAgICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAi LCAiQUIgICAgICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAgICAiLCAiQUIgICAgICAgIik7Cit0 ZXN0KCJwcmUiLCAiICBBQiIsICIgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgQUIiLCAiICAgQUIi KTsKK3Rlc3QoInByZSIsICIgICAgQUIiLCAiICAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICBB QiIsICIgICAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICAgQUIiLCAiICAgICAgQUIiKTsKK3Rl c3QoInByZSIsICIgICAgICAgQUIiLCAiICAgICAgIEFCIik7CisKK3Rlc3QoInByZSIsICIgIEEg IEIgICIsICIgIEEgIEIgICIpOwordGVzdCgicHJlIiwgIlx0XHRBXHRcdEJcdFx0IiwgIlx0XHRB XHRcdEJcdFx0Iik7Cit0ZXN0KCJwcmUiLCAiICIsICIgIik7Cit0ZXN0KCJwcmUiLCAiICAiLCAi ICAiKTsKK3Rlc3QoInByZSIsICIgICAiLCAiICAgIik7CisKK3Jvb3Quc3R5bGUuZGlzcGxheSA9 ICJub25lIjsKK3N1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CisKKzwvc2NyaXB0PgorPHNjcmlw dCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+ Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTQ1MTg2MzViMzE4ODVhNTMwNGEyZjYz YzFhM2QyZDU1N2E2MzkwNi4uOWE1NWVjNmUxNjgxYjA4ZjVkYWMxYzU3YzE3NmY3YjdkNGM4ZWIx YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ1IEBACisyMDExLTAxLTEzICBNT1JJVEEgSGFqaW1l ICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNwYWNlIGFuZCB0YWIgY2hhcmFjdGVycyAic2VudCIgYnkgYW4gaW5w dXQgbWV0aG9kIGdpdmUgdG90YWxseSBkaWZmZXJlbnQgcmVzdWx0cyB0aGFuIHR5cGluZyB0aGVt IGRpcmVjdGx5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MjQxCisgICAgICAgIAorICAgICAgICAqIEludHJvZHVjZWQgVGV4dEV2ZW50OjpJbnB1dFR5 cGVDb21wb3NpdGlvbiBhbmQgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVHlwZSB0byAK KyAgICAgICAgICBkaXN0aW5ndWlzaCB0ZXh0IGlucHV0IHdoaWNoIGlzIG9yaWdpbmF0ZWQgYnkg Y29tcG9zaXRpb24uCisgICAgICAgICogR2VuZXJhbGl6ZWQgcmViYWxhbmNlV2hpdGVzcGFjZUF0 KCkgdG8gcmViYWxhbmNlV2hpdGVzcGFjZUJldHdlZW4oKSB0byByZWJhbGFuY2luZyAKKyAgICAg ICAgICByYW5nZSBvZiBzdHJpbmcgb24gdGV4dCBub2RlLCBpbnN0ZWFkIG9mIHN1cnJvdW5kaW5n IHBhcnQgb2YgdGhhdC4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL2luc2VydGluZy9pbnNlcnQt Y29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sCisKKyAgICAgICAgKiBkb20vVGV4dEV2ZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlRleHRFdmVudDo6c2VsZWN0SW5wdXRUeXBlKToKKyAgICAg ICAgKiBkb20vVGV4dEV2ZW50Lmg6IGFkZCBUZXh0RXZlbnQ6OklucHV0VHlwZUNvbXBvc2l0aW9u IGFzIGEgbWVtYmVyIG9mIFRleHRFdmVudDo6SW5wdXRUeXBlCisgICAgICAgIChXZWJDb3JlOjpU ZXh0RXZlbnQ6OmlzQ29tcG9zaXRpb24pOgorICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJl YmFsYW5jZVdoaXRlc3BhY2VBdCk6IHJlcGxhY2VkIHdpdGggcmViYWxhbmNlV2hpdGVzcGFjZUJl dHdlZW4oKQorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5j ZVdoaXRlc3BhY2VCZXR3ZWVuKTogZ2VuZXJhbGl6ZWQgdmVyc2lvbiBvZiByZWJhbGFuY2VXaGl0 ZXNwYWNlQXQoKSwgd2hpY2ggdGFrZXMgMiBwb3NpdGlvbiBhcyBhcmd1bWV0bnMuCisgICAgICAg ICogZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRWRp dG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1l ZENvbXBvc2l0aW9uKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6Omluc2VydFRl eHRXaXRob3V0U2VuZGluZ1RleHRFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmNv bmZpcm1Db21wb3NpdGlvbik6IE5vdyB1c2VzIG5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0 aW9uKCkKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6c2V0Q29tcG9zaXRpb24pOgorICAgICAg ICAqIGVkaXRpbmcvRWRpdG9yLmg6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFu ZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQpOgorICAg ICAgICAqIGVkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaDoKKyAgICAgICAgKiBlZGl0aW5nL1R5 cGluZ0NvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6VHlwaW5n Q29tbWFuZCk6CisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KToK KyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHRSdW5XaXRob3V0TmV3 bGluZXMpOgorICAgICAgICAqIGVkaXRpbmcvVHlwaW5nQ29tbWFuZC5oOiBBZGRlZCBUeXBpbmdD b21tYW5kOjptX2NvbXBvc2l0aW9uVHlwZSBhbmQgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0 aW9uVHlwZQorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6c2V0Q29tcG9zaXRpb25U eXBlKTogQWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6OmNyZWF0ZSk6Cisg ICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRI YW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudCk6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRs ZXIuaDoKKwogMjAxMS0wMS0xMiAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1Rl eHRFdmVudC5jcHAKaW5kZXggNjhlZDRiMjczM2EyYmUxZGE0ZDk2MDIwODViMDhhYzU0ZTNiOWJi MS4uMjJhZWUwN2QxZjliYzA0YzM0ZTYwZDk0NDU0ZTRlNTgxYjgwOWZlZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L1RleHRFdmVudC5jcHAKQEAgLTMxLDEyICszMSwxNCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKLVRleHRFdmVudDo6SW5wdXRUeXBlIFRleHRFdmVudDo6c2VsZWN0SW5wdXRUeXBlKGJvb2wg aXNMaW5lQnJlYWssIGJvb2wgaXNCYWNrVGFiKQorVGV4dEV2ZW50OjpJbnB1dFR5cGUgVGV4dEV2 ZW50OjpzZWxlY3RJbnB1dFR5cGUoYm9vbCBpc0xpbmVCcmVhaywgYm9vbCBpc0JhY2tUYWIsIGJv b2wgaXNDb21wb3NpdGlvbikKIHsKICAgICBpZiAoaXNMaW5lQnJlYWspCiAgICAgICAgIHJldHVy biBUZXh0RXZlbnQ6OklucHV0VHlwZUxpbmVCcmVhazsKICAgICBpZiAoaXNCYWNrVGFiKQogICAg ICAgICByZXR1cm4gVGV4dEV2ZW50OjpJbnB1dFR5cGVCYWNrVGFiOworICAgIGlmIChpc0NvbXBv c2l0aW9uKQorICAgICAgICByZXR1cm4gVGV4dEV2ZW50OjpJbnB1dFR5cGVDb21wb3NpdGlvbjsK ICAgICByZXR1cm4gVGV4dEV2ZW50OjpJbnB1dFR5cGVLZXlib2FyZDsKIH0KIApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1Rl eHRFdmVudC5oCmluZGV4IGYxZDI0ZTljNjgxMGY1NWE0MzZjZWU2ZDA0YWUzZGQ0MTJiNzk2MjQu LmZkM2Q5ZjZhNGM0YWE3MGE5N2UyOTk2YWY2MTg3ZjcwY2ZiMjEwYzcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4 dEV2ZW50LmgKQEAgLTM2LDEzICszNiwxNCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHVi bGljOgogICAgICAgICBlbnVtIElucHV0VHlwZSB7CiAgICAgICAgICAgICBJbnB1dFR5cGVLZXli b2FyZCwgLy8gYW55IG5ld2xpbmUgY2hhcmFjdGVycyBpbiB0aGUgdGV4dCBhcmUgbGluZSBicmVh a3Mgb25seSwgbm90IHBhcmFncmFwaCBzZXBhcmF0b3JzLgorICAgICAgICAgICAgSW5wdXRUeXBl Q29tcG9zaXRpb24sIC8vIGlucHV0IGlzIGRvbmUgYnkgSU1FLgogICAgICAgICAgICAgSW5wdXRU eXBlTGluZUJyZWFrLCAvLyBhbnkgdGFiIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQgYXJlIGJhY2t0 YWJzLgogICAgICAgICAgICAgSW5wdXRUeXBlQmFja1RhYiwKICAgICAgICAgICAgIElucHV0VHlw ZVBhc3RlLAogICAgICAgICAgICAgSW5wdXRUeXBlRHJvcCwKICAgICAgICAgfTsKIAotICAgICAg ICBzdGF0aWMgSW5wdXRUeXBlIHNlbGVjdElucHV0VHlwZShib29sIGlzTGluZUJyZWFrLCBib29s IGlzQmFja1RhYik7CisgICAgICAgIHN0YXRpYyBJbnB1dFR5cGUgc2VsZWN0SW5wdXRUeXBlKGJv b2wgaXNMaW5lQnJlYWssIGJvb2wgaXNCYWNrVGFiLCBib29sIGlzQ29tcG9zaXRpb24pOwogICAg ICAgICBzdGF0aWMgUGFzc1JlZlB0cjxUZXh0RXZlbnQ+IGNyZWF0ZSgpOwogICAgICAgICBzdGF0 aWMgUGFzc1JlZlB0cjxUZXh0RXZlbnQ+IGNyZWF0ZShQYXNzUmVmUHRyPEFic3RyYWN0Vmlldz4g dmlldywgY29uc3QgU3RyaW5nJiBkYXRhLCBJbnB1dFR5cGUgPSBJbnB1dFR5cGVLZXlib2FyZCk7 CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPFRleHRFdmVudD4gY3JlYXRlRm9yUGxhaW5UZXh0 UGFzdGUoUGFzc1JlZlB0cjxBYnN0cmFjdFZpZXc+IHZpZXcsIGNvbnN0IFN0cmluZyYgZGF0YSwg Ym9vbCBzaG91bGRTbWFydFJlcGxhY2UpOwpAQCAtNTcsNiArNTgsNyBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKICAgICAgICAgdmlydHVhbCBib29sIGlzVGV4dEV2ZW50KCkgY29uc3Q7CiAKKyAg ICAgICAgYm9vbCBpc0NvbXBvc2l0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUgPT0g SW5wdXRUeXBlQ29tcG9zaXRpb247IH0KICAgICAgICAgYm9vbCBpc0xpbmVCcmVhaygpIGNvbnN0 IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IElucHV0VHlwZUxpbmVCcmVhazsgfQogICAgICAgICBi b29sIGlzQmFja1RhYigpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IElucHV0VHlwZUJh Y2tUYWI7IH0KICAgICAgICAgYm9vbCBpc1Bhc3RlKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5 cGUgPT0gSW5wdXRUeXBlUGFzdGU7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21w b3NpdGVFZGl0Q29tbWFuZC5jcHAKaW5kZXggNzQ4Nzc3ZDYwYWJhYjJlOWZiYTA5NjNjZmQ2NzAy ZTgwOWMxNDlhZi4uY2E3MTc3MTUwNjZjYTUxNGQzMTEwY2E5Y2ZiYmM1ZGQ0ZTQ0NGUwZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKQEAg LTM5NSwxMCArMzk1LDMwIEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBpc1doaXRlc3BhY2UoVUNoYXIg YykKICAgICByZXR1cm4gYyA9PSBub0JyZWFrU3BhY2UgfHwgYyA9PSAnICcgfHwgYyA9PSAnXG4n IHx8IGMgPT0gJ1x0JzsKIH0KIAorc3RhdGljIGlubGluZSBib29sIGlzV2hpdGVzcGFjZXMoY29u c3QgU3RyaW5nJiB0ZXh0KQoreworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCB0ZXh0Lmxl bmd0aCgpOyArK2kpIHsKKyAgICAgICAgaWYgKCFpc1doaXRlc3BhY2UodGV4dC5jaGFyYWN0ZXJz KClbaV0pKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKyAgICAKKyAgICByZXR1 cm4gdHJ1ZTsKK30KKworYm9vbCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6c2hvdWxkUmViYWxhbmNl Qm90aExlYWRpbmdBbmRUcmFpbGluZ1doaXRlc3BhY2VzRm9yKGNvbnN0IFN0cmluZyYgdGV4dCkg Y29uc3QKK3sKKyAgICByZXR1cm4gIWlzV2hpdGVzcGFjZXModGV4dCk7Cit9CisKIC8vIEZJWE1F OiBEb2Vzbid0IGdvIGludG8gdGV4dCBub2RlcyB0aGF0IGNvbnRyaWJ1dGUgYWRqYWNlbnQgdGV4 dCAoc2libGluZ3MsIGNvdXNpbnMsIGV0YykuCiB2b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpy ZWJhbGFuY2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mIHBvc2l0aW9uKQogewotICAgIE5v ZGUqIG5vZGUgPSBwb3NpdGlvbi5ub2RlKCk7CisgICAgcmViYWxhbmNlV2hpdGVzcGFjZUJldHdl ZW4ocG9zaXRpb24sIHBvc2l0aW9uKTsKK30KKwordm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6 cmViYWxhbmNlV2hpdGVzcGFjZUJldHdlZW4oY29uc3QgUG9zaXRpb24mIHN0YXJ0UG9zaXRpb24s IGNvbnN0IFBvc2l0aW9uJiBlbmRQb3NpdGlvbikKK3sKKyAgICBOb2RlKiBub2RlID0gc3RhcnRQ b3NpdGlvbi5ub2RlKCk7CiAgICAgaWYgKCFub2RlIHx8ICFub2RlLT5pc1RleHROb2RlKCkpCiAg ICAgICAgIHJldHVybjsKICAgICBUZXh0KiB0ZXh0Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQqPihu b2RlKTsKQEAgLTQxMiwzNSArNDMyLDMxIEBAIHZvaWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnJl YmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24pCiAgICAgU3RyaW5n IHRleHQgPSB0ZXh0Tm9kZS0+ZGF0YSgpOwogICAgIEFTU0VSVCghdGV4dC5pc0VtcHR5KCkpOwog Ci0gICAgaW50IG9mZnNldCA9IHBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCk7Ci0g ICAgLy8gSWYgbmVpdGhlciB0ZXh0W29mZnNldF0gbm9yIHRleHRbb2Zmc2V0IC0gMV0gYXJlIHNv bWUgZm9ybSBvZiB3aGl0ZXNwYWNlLCBkbyBub3RoaW5nLgotICAgIGlmICghaXNXaGl0ZXNwYWNl KHRleHRbb2Zmc2V0XSkpIHsKLSAgICAgICAgb2Zmc2V0LS07Ci0gICAgICAgIGlmIChvZmZzZXQg PCAwIHx8ICFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkKLSAgICAgICAgICAgIHJldHVybjsK LSAgICB9Ci0gICAgCisgICAgaW50IHN0YXJ0T2Zmc2V0ID0gc3RhcnRQb3NpdGlvbi5kZXByZWNh dGVkRWRpdGluZ09mZnNldCgpOworICAgIGludCBlbmRPZmZzZXQgPSBlbmRQb3NpdGlvbi5kZXBy ZWNhdGVkRWRpdGluZ09mZnNldCgpOworCiAgICAgLy8gU2V0IHVwc3RyZWFtIGFuZCBkb3duc3Ry ZWFtIHRvIGRlZmluZSB0aGUgZXh0ZW50IG9mIHRoZSB3aGl0ZXNwYWNlIHN1cnJvdW5kaW5nIHRl eHRbb2Zmc2V0XS4KLSAgICBpbnQgdXBzdHJlYW0gPSBvZmZzZXQ7CisgICAgaW50IHVwc3RyZWFt ID0gc3RhcnRPZmZzZXQ7CiAgICAgd2hpbGUgKHVwc3RyZWFtID4gMCAmJiBpc1doaXRlc3BhY2Uo dGV4dFt1cHN0cmVhbSAtIDFdKSkKICAgICAgICAgdXBzdHJlYW0tLTsKICAgICAKLSAgICBpbnQg ZG93bnN0cmVhbSA9IG9mZnNldDsKLSAgICB3aGlsZSAoKHVuc2lnbmVkKWRvd25zdHJlYW0gKyAx IDwgdGV4dC5sZW5ndGgoKSAmJiBpc1doaXRlc3BhY2UodGV4dFtkb3duc3RyZWFtICsgMV0pKQor ICAgIGludCBkb3duc3RyZWFtID0gZW5kT2Zmc2V0OworICAgIHdoaWxlICgodW5zaWduZWQpZG93 bnN0cmVhbSA8IHRleHQubGVuZ3RoKCkgJiYgaXNXaGl0ZXNwYWNlKHRleHRbZG93bnN0cmVhbV0p KQogICAgICAgICBkb3duc3RyZWFtKys7CiAgICAgCi0gICAgaW50IGxlbmd0aCA9IGRvd25zdHJl YW0gLSB1cHN0cmVhbSArIDE7Ci0gICAgQVNTRVJUKGxlbmd0aCA+IDApOworICAgIGludCBsZW5n dGggPSBkb3duc3RyZWFtIC0gdXBzdHJlYW07CisgICAgaWYgKCFsZW5ndGgpCisgICAgICAgIHJl dHVybjsKICAgICAKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0 aW9uKHBvc2l0aW9uLm5vZGUoKSwgdXBzdHJlYW0pKTsKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlz aWJsZURvd25zdHJlYW1Qb3MoUG9zaXRpb24ocG9zaXRpb24ubm9kZSgpLCBkb3duc3RyZWFtICsg MSkpOworICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxlVXBzdHJlYW1Qb3MoUG9zaXRpb24oc3Rh cnRQb3NpdGlvbi5ub2RlKCksIHVwc3RyZWFtKSk7CisgICAgVmlzaWJsZVBvc2l0aW9uIHZpc2li bGVEb3duc3RyZWFtUG9zKFBvc2l0aW9uKGVuZFBvc2l0aW9uLm5vZGUoKSwgZG93bnN0cmVhbSkp OwogICAgIAogICAgIFN0cmluZyBzdHJpbmcgPSB0ZXh0LnN1YnN0cmluZyh1cHN0cmVhbSwgbGVu Z3RoKTsKICAgICBTdHJpbmcgcmViYWxhbmNlZFN0cmluZyA9IHN0cmluZ1dpdGhSZWJhbGFuY2Vk V2hpdGVzcGFjZShzdHJpbmcsCiAgICAgLy8gRklYTUU6IEJlY2F1c2Ugb2YgdGhlIHByb2JsZW0g bWVudGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhpcyBmdW5jdGlvbiwgd2UgbXVzdCBhbHNvIHVzZSBu YnNwcyBhdCB0aGUgc3RhcnQvZW5kIG9mIHRoZSBzdHJpbmcgYmVjYXVzZQogICAgIC8vIHRoaXMg ZnVuY3Rpb24gZG9lc24ndCBnZXQgYWxsIHN1cnJvdW5kaW5nIHdoaXRlc3BhY2UsIGp1c3QgdGhl IHdoaXRlc3BhY2UgaW4gdGhlIGN1cnJlbnQgdGV4dCBub2RlLgogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlzU3RhcnRPZlBhcmFn cmFwaCh2aXNpYmxlVXBzdHJlYW1Qb3MpIHx8IHVwc3RyZWFtID09IDAsIAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlzRW5kT2ZQ YXJhZ3JhcGgodmlzaWJsZURvd25zdHJlYW1Qb3MpIHx8ICh1bnNpZ25lZClkb3duc3RyZWFtID09 IHRleHQubGVuZ3RoKCkgLSAxKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBpc0VuZE9mUGFyYWdyYXBoKHZpc2libGVEb3duc3Ry ZWFtUG9zKSB8fCAodW5zaWduZWQpZG93bnN0cmVhbSA9PSB0ZXh0Lmxlbmd0aCgpKTsKICAgICAK ICAgICBpZiAoc3RyaW5nICE9IHJlYmFsYW5jZWRTdHJpbmcpCiAgICAgICAgIHJlcGxhY2VUZXh0 SW5Ob2RlKHRleHROb2RlLCB1cHN0cmVhbSwgbGVuZ3RoLCByZWJhbGFuY2VkU3RyaW5nKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBi L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAppbmRleCA2ZGI0 ZWIxODJhMDg4NmFkMWZkODBiMDRlOGMxYzZmMzYxY2IwMzAwLi5lOTc0NzYyMTIzNDlkMWYyOWNj MTE3MGUyOGVmODFkNjVhYjljMzk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21w b3NpdGVFZGl0Q29tbWFuZC5oCkBAIC03MSw2ICs3MSw4IEBAIHByb3RlY3RlZDoKICAgICB2b2lk IG1lcmdlSWRlbnRpY2FsRWxlbWVudHMoUGFzc1JlZlB0cjxFbGVtZW50PiwgUGFzc1JlZlB0cjxF bGVtZW50Pik7CiAgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlKCk7CiAgICAgdm9pZCByZWJh bGFuY2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mKTsKKyAgICB2b2lkIHJlYmFsYW5jZVdo aXRlc3BhY2VCZXR3ZWVuKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRpb24mKTsKKyAgICBi b29sIHNob3VsZFJlYmFsYW5jZUJvdGhMZWFkaW5nQW5kVHJhaWxpbmdXaGl0ZXNwYWNlc0Zvcihj b25zdCBTdHJpbmcmIHRleHQpIGNvbnN0OwogICAgIHZvaWQgcHJlcGFyZVdoaXRlc3BhY2VBdFBv c2l0aW9uRm9yU3BsaXQoUG9zaXRpb24mKTsKICAgICB2b2lkIHJlbW92ZUNTU1Byb3BlcnR5KFBh c3NSZWZQdHI8U3R5bGVkRWxlbWVudD4sIENTU1Byb3BlcnR5SUQpOwogICAgIHZvaWQgcmVtb3Zl Tm9kZUF0dHJpYnV0ZShQYXNzUmVmUHRyPEVsZW1lbnQ+LCBjb25zdCBRdWFsaWZpZWROYW1lJiBh dHRyaWJ1dGUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3Bw IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IGEyNGU3YzYwYjUyNWU2 MTVhYTFlZTEzNjNmNTgwMDFkNmUxMTBhNDIuLjVmY2RkNThjZTM5MmMwOTY4MDZhMGNmMmU5Nzlj MTBjZWVjYmNkM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTExNzIsNyArMTE3 MiwxMiBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50 KiB0cmlnZ2VyaW5nRXZlbnQpCiAgICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5o YW5kbGVUZXh0SW5wdXRFdmVudCh0ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwogfQogCi1ib29sIEVk aXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4 dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCitib29s IEVkaXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYg dGV4dCkKK3sKKyAgICByZXR1cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhhbmRsZVRleHRJ bnB1dEV2ZW50KHRleHQsIDAsIGZhbHNlLCBmYWxzZSwgdHJ1ZSk7Cit9CisKK2Jvb2wgRWRpdG9y OjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0LCBi b29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCiB7CiAg ICAgaWYgKHRleHQuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xMTk0LDcg KzExOTksOCBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50 KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbgogICAgICAgICAgICAgUmVmUHRyPERv Y3VtZW50PiBkb2N1bWVudCA9IHNlbGVjdGlvblN0YXJ0LT5kb2N1bWVudCgpOwogICAgICAgICAg ICAgCiAgICAgICAgICAgICAvLyBJbnNlcnQgdGhlIHRleHQKLSAgICAgICAgICAgIFR5cGluZ0Nv bW1hbmQ6Omluc2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0 SW5zZXJ0ZWRUZXh0KTsKKyAgICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoZG9j dW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJpZ2dlcmluZ0V2ZW50ICYmIHRyaWdn ZXJpbmdFdmVudC0+aXNDb21wb3NpdGlvbigpID8gVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0 aW9uQ29uZmlybSA6IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbk5vbmUpOwogCiAgICAg ICAgICAgICAvLyBSZXZlYWwgdGhlIGN1cnJlbnQgc2VsZWN0aW9uIAogICAgICAgICAgICAgaWYg KEZyYW1lKiBlZGl0ZWRGcmFtZSA9IGRvY3VtZW50LT5mcmFtZSgpKQpAQCAtMTYxNyw3ICsxNjIz LDcgQEAgdm9pZCBFZGl0b3I6OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQs IGJvb2wgcHJlc2VydmVTZWxlY3Rpb24pCiAgICAgbV9jb21wb3NpdGlvbk5vZGUgPSAwOwogICAg IG1fY3VzdG9tQ29tcG9zaXRpb25VbmRlcmxpbmVzLmNsZWFyKCk7CiAKLSAgICBpbnNlcnRUZXh0 KHRleHQsIDApOworICAgIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbih0ZXh0KTsK IAogICAgIGlmIChwcmVzZXJ2ZVNlbGVjdGlvbikgewogICAgICAgICBtX2ZyYW1lLT5zZWxlY3Rp b24oKS0+c2V0U2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgZmFsc2UsIGZhbHNlKTsKQEAgLTE2ODYs NyArMTY5Miw3IEBAIHZvaWQgRWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRl eHQsIGNvbnN0IFZlY3RvcjxDb21wb3NpdGlvblVuZGVybGluCiAgICAgbV9jdXN0b21Db21wb3Np dGlvblVuZGVybGluZXMuY2xlYXIoKTsKIAogICAgIGlmICghdGV4dC5pc0VtcHR5KCkpIHsKLSAg ICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0 LCB0cnVlLCB0cnVlKTsKKyAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1l LT5kb2N1bWVudCgpLCB0ZXh0LCB0cnVlLCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25V cGRhdGUpOwogCiAgICAgICAgIC8vIEZpbmQgb3V0IHdoYXQgbm9kZSBoYXMgdGhlIGNvbXBvc2l0 aW9uIG5vdy4KICAgICAgICAgUG9zaXRpb24gYmFzZSA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5i YXNlKCkuZG93bnN0cmVhbSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9F ZGl0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKaW5kZXggMmU2MWNlNjdk MTgxODVhNjZhOTI4MDFkNmI3YTk1YTQ3ODk0NmVjOS4uMWU2ZTM4NzNmNWRjOGRlZjJkMGQyMGEw MGNiMTMzMzhhOWMwOWE5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0xOTgsNyArMTk4 LDggQEAgcHVibGljOgogICAgIHN0YXRpYyBib29sIGNvbW1hbmRJc1N1cHBvcnRlZEZyb21NZW51 T3JLZXlCaW5kaW5nKGNvbnN0IFN0cmluZyYgY29tbWFuZE5hbWUpOyAvLyBXb3JrcyB3aXRob3V0 IGEgZnJhbWUuCiAKICAgICBib29sIGluc2VydFRleHQoY29uc3QgU3RyaW5nJiwgRXZlbnQqIHRy aWdnZXJpbmdFdmVudCk7Ci0gICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZl bnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2Vy aW5nRXZlbnQpOworICAgIGJvb2wgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNv bnN0IFN0cmluZyYgdGV4dCk7CisgICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0 RXZlbnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRFdmVudCog dHJpZ2dlcmluZ0V2ZW50KTsKICAgICBib29sIGluc2VydExpbmVCcmVhaygpOwogICAgIGJvb2wg aW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCmluZGV4IGZjMThlOTEyZjk1MzYzNmFmYjI3MTZmMGMx NjIzZDUwOTA2ODlmNWQuLmYzNTM0NTdhOWJmMjRlYjk1Y2U5NGRjMzk4ZGQ2NTZjN2JkNDlmZDUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCkBAIC0x MDYsNyArMTA2LDcgQEAgYm9vbCBJbnNlcnRUZXh0Q29tbWFuZDo6cGVyZm9ybVRyaXZpYWxSZXBs YWNlKGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnMKICAgICByZXR1cm4gdHJ1ZTsK IH0KIAotdm9pZCBJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBi b29sIHNlbGVjdEluc2VydGVkVGV4dCkKK3ZvaWQgSW5zZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNv bnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFJlYmFsYW5jZVR5cGUg d2hpdGVzcGFjZVJlYmFsYW5jZSkKIHsKICAgICAKICAgICBBU1NFUlQodGV4dC5maW5kKCdcbicp ID09IG5vdEZvdW5kKTsKQEAgLTE3MiwxMSArMTcyLDE2IEBAIHZvaWQgSW5zZXJ0VGV4dENvbW1h bmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQpCiAg ICAgICAgIGluc2VydFRleHRJbnRvTm9kZSh0ZXh0Tm9kZSwgb2Zmc2V0LCB0ZXh0KTsKICAgICAg ICAgZW5kUG9zaXRpb24gPSBQb3NpdGlvbih0ZXh0Tm9kZSwgb2Zmc2V0ICsgdGV4dC5sZW5ndGgo KSk7CiAKLSAgICAgICAgLy8gVGhlIGluc2VydGlvbiBtYXkgcmVxdWlyZSBhZGp1c3RpbmcgYWRq YWNlbnQgd2hpdGVzcGFjZSwgaWYgaXQgaXMgcHJlc2VudC4KLSAgICAgICAgcmViYWxhbmNlV2hp dGVzcGFjZUF0KGVuZFBvc2l0aW9uKTsKLSAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBz aWRlcyBpc24ndCBuZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFjZS4KLSAgICAgICAg aWYgKHRleHQgIT0gIiAiKSAKLSAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChzdGFy dFBvc2l0aW9uKTsKKyAgICAgICAgaWYgKHdoaXRlc3BhY2VSZWJhbGFuY2UgPT0gUmViYWxhbmNl TGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpIHsKKyAgICAgICAgICAgIC8vIFRoZSBpbnNl cnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdoaXRlc3BhY2UsIGlmIGl0IGlz IHByZXNlbnQuCisgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoZW5kUG9zaXRpb24p OworICAgICAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBzaWRlcyBpc24ndCBuZWNlc3Nh cnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFjZS4KKyAgICAgICAgICAgIGlmIChzaG91bGRSZWJh bGFuY2VCb3RoTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXNGb3IodGV4dCkpCisgICAgICAg ICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZUF0KHN0YXJ0UG9zaXRpb24pOworICAgICAgICB9 IGVsc2UgeworICAgICAgICAgICAgQVNTRVJUKHdoaXRlc3BhY2VSZWJhbGFuY2UgPT0gUmViYWxh bmNlQWxsV2hpdGVzcGFjZXMpOworICAgICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZUJldHdl ZW4oc3RhcnRQb3NpdGlvbiwgZW5kUG9zaXRpb24pOworICAgICAgICB9CiAgICAgfQogCiAgICAg Ly8gV2UgY291bGQgaGF2ZSBpbnNlcnRlZCBhIHBhcnQgb2YgY29tcG9zZWQgY2hhcmFjdGVyIHNl cXVlbmNlLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29t bWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oCmluZGV4 IDc3YWUwMTZkMzZhMTRmYjFmODE0OWRmN2FhMzQxMmNkZWMxZDIyZGUuLjY3MmU1NzZmOTIwNzlh NWNmOTc3YWU1Y2Y4YTI0YmQ5YzI3ZmE0YzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0lu c2VydFRleHRDb21tYW5kLmgKQEAgLTMyLDE0ICszMiwyMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKIGNsYXNzIEluc2VydFRleHRDb21tYW5kIDogcHVibGljIENvbXBvc2l0ZUVkaXRDb21tYW5k IHsKIHB1YmxpYzoKKyAgICBlbnVtIFJlYmFsYW5jZVR5cGUgeworICAgICAgICBSZWJhbGFuY2VM ZWFkaW5nQW5kVHJhaWxpbmdXaGl0ZXNwYWNlcywKKyAgICAgICAgUmViYWxhbmNlQWxsV2hpdGVz cGFjZXMKKyAgICB9OworCiAgICAgc3RhdGljIFBhc3NSZWZQdHI8SW5zZXJ0VGV4dENvbW1hbmQ+ IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgewogICAgICAgICByZXR1cm4gYWRvcHRS ZWYobmV3IEluc2VydFRleHRDb21tYW5kKGRvY3VtZW50KSk7CiAgICAgfQogCi0gICAgdm9pZCBp bnB1dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2Up OworICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVk VGV4dCA9IGZhbHNlLCBSZWJhbGFuY2VUeXBlID0gUmViYWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5n V2hpdGVzcGFjZXMpOwogCiBwcml2YXRlOgorCiAgICAgSW5zZXJ0VGV4dENvbW1hbmQoRG9jdW1l bnQqKTsKIAogICAgIHZvaWQgZGVsZXRlQ2hhcmFjdGVyKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9UeXBpbmdDb21tYW5kLmNwcAppbmRleCBkNTRiMzg4NWJmOThmZTUyYmQ5YTY1YzU0YThkNzFk OTY3NjA3ZTlkLi4yMWQ0MzE0YWQwNzU0OGEwOGM5ODI3YjBmMTU1Yjk5YWIyMjhiNjE3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKQEAgLTQ3LDcgKzQ3LDggQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOwogCi1UeXBp bmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwgRVR5cGluZ0NvbW1h bmQgY29tbWFuZFR5cGUsIGNvbnN0IFN0cmluZyAmdGV4dFRvSW5zZXJ0LCBib29sIHNlbGVjdElu c2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nKQor VHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZChEb2N1bWVudCAqZG9jdW1lbnQsIEVUeXBpbmdD b21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBTdHJpbmcgJnRleHRUb0luc2VydCwgYm9vbCBzZWxl Y3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSwgVGV4dENvbXBvc2l0 aW9uVHlwZSBjb21wb3NpdGlvblR5cGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJv b2wga2lsbFJpbmcpCiAgICAgOiBDb21wb3NpdGVFZGl0Q29tbWFuZChkb2N1bWVudCksIAogICAg ICAgbV9jb21tYW5kVHlwZShjb21tYW5kVHlwZSksIAogICAgICAgbV90ZXh0VG9JbnNlcnQodGV4 dFRvSW5zZXJ0KSwgCkBAIC01NSw2ICs1Niw3IEBAIFR5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1h bmQoRG9jdW1lbnQgKmRvY3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kVHlwZSwgY29uCiAg ICAgICBtX3NlbGVjdEluc2VydGVkVGV4dChzZWxlY3RJbnNlcnRlZFRleHQpLAogICAgICAgbV9z bWFydERlbGV0ZShmYWxzZSksCiAgICAgICBtX2dyYW51bGFyaXR5KGdyYW51bGFyaXR5KSwKKyAg ICAgIG1fY29tcG9zaXRpb25UeXBlKGNvbXBvc2l0aW9uVHlwZSksCiAgICAgICBtX2tpbGxSaW5n KGtpbGxSaW5nKSwKICAgICAgIG1fb3BlbmVkQnlCYWNrd2FyZERlbGV0ZShmYWxzZSkKIHsKQEAg LTEzMywxOCArMTM1LDE4IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6dXBkYXRlU2VsZWN0aW9uSWZE aWZmZXJlbnRGcm9tQ3VycmVudFNlbGVjdGlvbihUeXBpbmdDb21tYW5kCiB9CiAgICAgCiAKLXZv aWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0 cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIGJvb2wgaW5zZXJ0ZWRUZXh0SXND b21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9j dW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRD b21wb3NpdGlvblR5cGUgY29tcG9zaXRpb24pCiB7CiAgICAgQVNTRVJUKGRvY3VtZW50KTsKICAg ICAKICAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKICAgICBBU1NFUlQoZnJh bWUpOwogCi0gICAgaW5zZXJ0VGV4dChkb2N1bWVudCwgdGV4dCwgZnJhbWUtPnNlbGVjdGlvbigp LT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBpbnNlcnRlZFRleHRJc0NvbXBvc2l0 aW9uKTsKKyAgICBpbnNlcnRUZXh0KGRvY3VtZW50LCB0ZXh0LCBmcmFtZS0+c2VsZWN0aW9uKCkt PnNlbGVjdGlvbigpLCBzZWxlY3RJbnNlcnRlZFRleHQsIGNvbXBvc2l0aW9uKTsKIH0KIAogLy8g RklYTUU6IFdlIHNob3VsZG4ndCBuZWVkIHRvIHRha2Ugc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLiBJ dCBzaG91bGQgYmUgaWRlbnRpY2FsIHRvIFNlbGVjdGlvbkNvbnRyb2xsZXIncyBjdXJyZW50IHNl bGVjdGlvbi4KLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1l bnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9u Rm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgYm9vbCBpbnNlcnRlZFRleHRJ c0NvbXBvc2l0aW9uKQordm9pZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBk b2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxl Y3Rpb25Gb3JJbnNlcnRpb24sIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0Q29tcG9zaXRp b25UeXBlIGNvbXBvc2l0aW9uVHlwZSkKIHsKICNpZiBSRU1PVkVfTUFSS0VSU19VUE9OX0VESVRJ TkcKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKQpAQCAtMTYxLDcgKzE2Myw3IEBAIHZvaWQgVHlw aW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYg dGV4dCwgY29uc3QgVmlzCiAgICAgU3RyaW5nIG5ld1RleHQgPSB0ZXh0OwogICAgIE5vZGUqIHN0 YXJ0Tm9kZSA9IHNlbGVjdGlvbkZvckluc2VydGlvbi5zdGFydCgpLm5vZGUoKTsKICAgICAKLSAg ICBpZiAoc3RhcnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpICYmICFp bnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKSB7ICAgICAgICAKKyAgICBpZiAoc3RhcnROb2RlICYm IHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpICYmIGNvbXBvc2l0aW9uVHlwZSAhPSBU ZXh0Q29tcG9zaXRpb25VcGRhdGUpIHsKICAgICAgICAgLy8gU2VuZCBCZWZvcmVUZXh0SW5zZXJ0 ZWRFdmVudC4gVGhlIGV2ZW50IGhhbmRsZXIgd2lsbCB1cGRhdGUgdGV4dCBpZiBuZWNlc3Nhcnku CiAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgICAgICBSZWZQdHI8QmVmb3JlVGV4 dEluc2VydGVkRXZlbnQ+IGV2dCA9IEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50OjpjcmVhdGUodGV4 dCk7CkBAIC0xODIsMTEgKzE4NCwxMyBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQo RG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpcwogICAgICAg ICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNldFN0YXJ0aW5nU2VsZWN0aW9uKHNlbGVjdGlvbkZv ckluc2VydGlvbik7CiAgICAgICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+c2V0RW5kaW5nU2Vs ZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgIH0KKyAgICAgICAgCisgICAg ICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRDb21wb3NpdGlvblR5cGUoY29tcG9zaXRpb25UeXBl KTsKICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPmluc2VydFRleHQobmV3VGV4dCwgc2VsZWN0 SW5zZXJ0ZWRUZXh0KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIFJlZlB0cjxUeXBp bmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21tYW5kOjpjcmVhdGUoZG9jdW1lbnQsIEluc2VydFRl eHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CisgICAgUmVmUHRyPFR5cGluZ0NvbW1h bmQ+IGNtZCA9IFR5cGluZ0NvbW1hbmQ6OmNyZWF0ZShkb2N1bWVudCwgSW5zZXJ0VGV4dCwgbmV3 VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBjb21wb3NpdGlvblR5cGUpOwogICAgIGlmIChjaGFu Z2VTZWxlY3Rpb24pICB7CiAgICAgICAgIGNtZC0+c2V0U3RhcnRpbmdTZWxlY3Rpb24oc2VsZWN0 aW9uRm9ySW5zZXJ0aW9uKTsKICAgICAgICAgY21kLT5zZXRFbmRpbmdTZWxlY3Rpb24oc2VsZWN0 aW9uRm9ySW5zZXJ0aW9uKTsKQEAgLTM4Niw3ICszOTAsOCBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6 Omluc2VydFRleHRSdW5XaXRob3V0TmV3bGluZXMoY29uc3QgU3RyaW5nICZ0ZXh0LCBib29sIHNl bGVjdAogICAgICAgICBjb21tYW5kLT5zZXRTdGFydGluZ1NlbGVjdGlvbihlbmRpbmdTZWxlY3Rp b24oKSk7CiAgICAgICAgIGNvbW1hbmQtPnNldEVuZGluZ1NlbGVjdGlvbihlbmRpbmdTZWxlY3Rp b24oKSk7CiAgICAgfQotICAgIGNvbW1hbmQtPmlucHV0KHRleHQsIHNlbGVjdEluc2VydGVkVGV4 dCk7CisgICAgY29tbWFuZC0+aW5wdXQodGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAKKyAgICAg ICAgICAgICAgICAgICBtX2NvbXBvc2l0aW9uVHlwZSA9PSBUZXh0Q29tcG9zaXRpb25Ob25lID8g SW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUxlYWRpbmdBbmRUcmFpbGluZ1doaXRlc3BhY2Vz IDogSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUFsbFdoaXRlc3BhY2VzKTsKICAgICB0eXBp bmdBZGRlZFRvT3BlbkNvbW1hbmQoSW5zZXJ0VGV4dCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9UeXBpbmdDb21tYW5kLmgKaW5kZXggMjg0ZWJjMGFjMjY1ZDc2YjE2YTgwYmYyNjExYzdhODBl NjgwYWQwZi4uYjM0YmRjMTIyMWEyMmEzMDEyNGE5MDg4MDEwYzA1NDY1MWJmZGU2ZCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKKysrIGIvU291cmNl L1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKQEAgLTQyLDExICs0MiwxNyBAQCBwdWJs aWM6CiAgICAgICAgIEluc2VydFBhcmFncmFwaFNlcGFyYXRvckluUXVvdGVkQ29udGVudAogICAg IH07CiAKKyAgICBlbnVtIFRleHRDb21wb3NpdGlvblR5cGUgeworICAgICAgICBUZXh0Q29tcG9z aXRpb25Ob25lLAorICAgICAgICBUZXh0Q29tcG9zaXRpb25VcGRhdGUsCisgICAgICAgIFRleHRD b21wb3NpdGlvbkNvbmZpcm0KKyAgICB9OworCiAgICAgc3RhdGljIHZvaWQgZGVsZXRlU2VsZWN0 aW9uKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0ZSA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9p ZCBkZWxldGVLZXlQcmVzc2VkKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0ZSA9IGZhbHNlLCBU ZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9IGZh bHNlKTsKICAgICBzdGF0aWMgdm9pZCBmb3J3YXJkRGVsZXRlS2V5UHJlc3NlZChEb2N1bWVudCos IGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3Jh bnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBmYWxzZSk7Ci0gICAgc3RhdGljIHZvaWQgaW5zZXJ0 VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0g ZmFsc2UsIGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNlKTsKLSAgICBzdGF0 aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgY29uc3QgVmlzaWJs ZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UsIGJvb2wgaW5zZXJ0 ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNlKTsKKyAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0 KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxz ZSwgVGV4dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUpOworICAgIHN0YXRp YyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBWaXNpYmxl U2VsZWN0aW9uJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgVGV4dENvbXBvc2l0 aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUpOwogICAgIHN0YXRpYyB2b2lkIGluc2VydExp bmVCcmVhayhEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBhcmFncmFwaFNlcGFy YXRvcihEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBhcmFncmFwaFNlcGFyYXRv ckluUXVvdGVkQ29udGVudChEb2N1bWVudCopOwpAQCAtNjQsMTQgKzcwLDIwIEBAIHB1YmxpYzoK ICAgICB2b2lkIGRlbGV0ZUtleVByZXNzZWQoVGV4dEdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5n KTsKICAgICB2b2lkIGZvcndhcmREZWxldGVLZXlQcmVzc2VkKFRleHRHcmFudWxhcml0eSwgYm9v bCBraWxsUmluZyk7CiAgICAgdm9pZCBkZWxldGVTZWxlY3Rpb24oYm9vbCBzbWFydERlbGV0ZSk7 CisgICAgdm9pZCBzZXRDb21wb3NpdGlvblR5cGUoVGV4dENvbXBvc2l0aW9uVHlwZSB0eXBlKSB7 IG1fY29tcG9zaXRpb25UeXBlID0gdHlwZTsgfQogCiBwcml2YXRlOgogICAgIHN0YXRpYyBQYXNz UmVmUHRyPFR5cGluZ0NvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQsIEVUeXBpbmdD b21tYW5kIGNvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4dCA9ICIiLCBib29sIHNlbGVjdEluc2Vy dGVkVGV4dCA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJH cmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9IGZhbHNlKQogICAgIHsKLSAgICAgICAgcmV0dXJu IGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5kLCB0ZXh0LCBzZWxl Y3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5LCBraWxsUmluZykpOworICAgICAgICByZXR1cm4g YWRvcHRSZWYobmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVj dEluc2VydGVkVGV4dCwgZ3JhbnVsYXJpdHksIFRleHRDb21wb3NpdGlvbk5vbmUsIGtpbGxSaW5n KSk7CisgICAgfQorCisgICAgc3RhdGljIFBhc3NSZWZQdHI8VHlwaW5nQ29tbWFuZD4gY3JlYXRl KERvY3VtZW50KiBkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29tbWFuZCwgY29uc3QgU3RyaW5n JiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dENvbXBvc2l0aW9uVHlwZSBjb21w b3NpdGlvblR5cGUpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFR5cGluZ0Nv bW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVjdEluc2VydGVkVGV4dCwgQ2hhcmFj dGVyR3JhbnVsYXJpdHksIGNvbXBvc2l0aW9uVHlwZSwgZmFsc2UpKTsKICAgICB9CiAKLSAgICBU eXBpbmdDb21tYW5kKERvY3VtZW50KiwgRVR5cGluZ0NvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4 dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSwgYm9vbCBraWxsUmlu Zyk7CisgICAgVHlwaW5nQ29tbWFuZChEb2N1bWVudCosIEVUeXBpbmdDb21tYW5kLCBjb25zdCBT dHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHksIFRl eHRDb21wb3NpdGlvblR5cGUsIGJvb2wga2lsbFJpbmcpOwogCiAgICAgYm9vbCBzbWFydERlbGV0 ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc21hcnREZWxldGU7IH0KICAgICB2b2lkIHNldFNtYXJ0RGVs ZXRlKGJvb2wgc21hcnREZWxldGUpIHsgbV9zbWFydERlbGV0ZSA9IHNtYXJ0RGVsZXRlOyB9CkBA IC05NCw2ICsxMDYsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9zZWxlY3RJbnNlcnRlZFRleHQ7 CiAgICAgYm9vbCBtX3NtYXJ0RGVsZXRlOwogICAgIFRleHRHcmFudWxhcml0eSBtX2dyYW51bGFy aXR5OworICAgIFRleHRDb21wb3NpdGlvblR5cGUgbV9jb21wb3NpdGlvblR5cGU7CiAgICAgYm9v bCBtX2tpbGxSaW5nOwogICAgIGJvb2wgbV9wcmVzZXJ2ZXNUeXBpbmdTdHlsZTsKICAgICAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCBkMGYxNzU2YTk1NmZlNjZjNDIwYTUy NjYyYzg3YTkxZTlhYzIyNmFlLi5jZDU3MWY2ZmI1MmFkNjg3OGYxODVmZDkwZTdiMGZhMzU2MmYx MjM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0yNjUyLDcgKzI2NTIs NyBAQCBjbGVhbnVwRHJhZzoKIH0KICNlbmRpZiAvLyBFTkFCTEUoRFJBR19TVVBQT1JUKQogICAK LWJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRl eHQsIEV2ZW50KiB1bmRlcmx5aW5nRXZlbnQsIGJvb2wgaXNMaW5lQnJlYWssIGJvb2wgaXNCYWNr VGFiKQorYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmlu ZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmVudCwgYm9vbCBpc0xpbmVCcmVhaywgYm9vbCBp c0JhY2tUYWIsIGJvb2wgaXNDb21wb3NpdGlvbikKIHsKICAgICAvLyBQbGF0Zm9ybXMgc2hvdWxk IGRpZmZlcmVudGlhdGUgcmVhbCBjb21tYW5kcyBsaWtlIHNlbGVjdEFsbCBmcm9tIHRleHQgaW5w dXQgaW4gZGlzZ3Vpc2UgKGxpa2UgaW5zZXJ0TmV3bGluZSksCiAgICAgLy8gYW5kIGF2b2lkIGRp c3BhdGNoaW5nIHRleHQgaW5wdXQgZXZlbnRzIGZyb20ga2V5ZG93biBkZWZhdWx0IGhhbmRsZXJz LgpAQCAtMjY3Myw3ICsyNjczLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1 dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmUKICAgICBpZiAo RnJhbWVWaWV3KiB2aWV3ID0gbV9mcmFtZS0+dmlldygpKQogICAgICAgICB2aWV3LT5yZXNldERl ZmVycmVkUmVwYWludERlbGF5KCk7CiAKLSAgICBSZWZQdHI8VGV4dEV2ZW50PiBldmVudCA9IFRl eHRFdmVudDo6Y3JlYXRlKG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBUZXh0RXZlbnQ6OnNl bGVjdElucHV0VHlwZShpc0xpbmVCcmVhaywgaXNCYWNrVGFiKSk7CisgICAgUmVmUHRyPFRleHRF dmVudD4gZXZlbnQgPSBUZXh0RXZlbnQ6OmNyZWF0ZShtX2ZyYW1lLT5kb21XaW5kb3coKSwgdGV4 dCwgVGV4dEV2ZW50OjpzZWxlY3RJbnB1dFR5cGUoaXNMaW5lQnJlYWssIGlzQmFja1RhYiwgaXND b21wb3NpdGlvbikpOwogICAgIGV2ZW50LT5zZXRVbmRlcmx5aW5nRXZlbnQodW5kZXJseWluZ0V2 ZW50KTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0V2ZW50SGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu aAppbmRleCA2NTY5NWMyNzVmMDA2YTBkODk4OTg4MzNhYzc1NzBhNzg0ZmJhMDdjLi43ZmU1ZGJh YWZhZmE0OTNmM2UzNzRiNmRhYzVlZDNkMjlmZDRiNzkzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRI YW5kbGVyLmgKQEAgLTE3NCw3ICsxNzQsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBkZWZhdWx0S2V5 Ym9hcmRFdmVudEhhbmRsZXIoS2V5Ym9hcmRFdmVudCopOwogCiAgICAgYm9vbCBoYW5kbGVUZXh0 SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5aW5nRXZlbnQgPSAw LAotICAgICAgICBib29sIGlzTGluZUJyZWFrID0gZmFsc2UsIGJvb2wgaXNCYWNrVGFiID0gZmFs c2UpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCBpc0xpbmVCcmVhayA9IGZh bHNlLCBib29sIGlzQmFja1RhYiA9IGZhbHNlLCBib29sIGlzQ29tcG9zaXRpb24gPSBmYWxzZSk7 CiAgICAgdm9pZCBkZWZhdWx0VGV4dElucHV0RXZlbnRIYW5kbGVyKFRleHRFdmVudCopOwogCiAj aWYgRU5BQkxFKERSQUdfU1VQUE9SVCkK 79131 2011-01-17 00:00:57 -0800 2011-01-17 21:27:15 -0800 updated to ToT bug-5241-20110117170055.patch text/plain 31842 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA2ZGEzZTc5YmM4Njg5Y2E2YjE5Yjg3YTE2NDNiMTJlNjMwMWJmZjYwLi4yZTg5MjQ4 MTBmNjNkYzM2Y2VlNTA5MmFkY2VlNWE1MmNkYzQzMTJiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTMgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKyAgICAgICAgCisgICAgICAgIEFkZGVk IGEgdGVzdCB0aGF0IGV4ZXJjaXNlcyBjb250aW5vdXMgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzIGFu ZCB0YWJzIGluc2VydGVkIGJ5IElNRS4KKworICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbDog QWRkZWQuCisKIDIwMTEtMDEtMTYgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdo aXRlc3BhY2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQwODdjYTRjOTFlMzZmYmIzMTIxZDhi NDNjMmE2ZThiMGVjNzJiYzkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0OSBAQAorUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBIMKgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDC oCDCoEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICfCoMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCBBQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAn wqDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKgQUInCitQQVNT IGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICdBQiDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoMKgJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKg IMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqAnCitQQVNTIGNvbXBv c2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfC oMKgQSDCoEIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoEEgwqBCIMKgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ0FCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICBCJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0FCICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICAgJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJyAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICBBQicKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgIEFC JworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICcgIEEgIEIgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcJCUEJCUIJCScKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICcgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICcKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lMDEyMTA0N2Q1ZWUyMjYwNDRmNjJjNjg5ZmI0OTZkZmVjYjgyODkyCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBv c2l0aW9uLXdoaXRlc3BhY2UuaHRtbApAQCAtMCwwICsxLDk3IEBACis8IURPQ1RZUEUgSFRNTCBQ VUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVs PSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxl LmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdD4KKwordmFyIHNlbCA9IGRvY3VtZW50 LmdldFNlbGVjdGlvbigpOwordmFyIHJvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJyb290 Iik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHJvb3QpOworCisKK2Z1bmN0aW9uIGNyZWF0 ZUVkaXRhYmxlKHRhZ05hbWUsIHRleHQpIHsKKyAgICB2YXIgbm9kZSA9IGRvY3VtZW50LmNyZWF0 ZUVsZW1lbnQodGFnTmFtZSk7CisgICAgbm9kZS5jb250ZW50RWRpdGFibGUgPSB0cnVlOworICAg IG5vZGUuaW5uZXJIVE1MID0gdGV4dDsKKyAgICByZXR1cm4gbm9kZTsKK30KKworZnVuY3Rpb24g dGVzdCh0YWdOYW1lLCBjb21wb3NpdGlvblRleHQsIGV4cGVjdGVkKSB7CisgICAgdmFyIG5vZGUg PSBjcmVhdGVFZGl0YWJsZSh0YWdOYW1lLCAiWCIpOworICAgIHJvb3QuYXBwZW5kQ2hpbGQobm9k ZSk7CisKKyAgICB2YXIgdGV4dE5vZGUgPSBub2RlLmZpcnN0Q2hpbGQ7CisgICAgc2VsLnNldEJh c2VBbmRFeHRlbnQodGV4dE5vZGUsIDAsIHRleHROb2RlLCB0ZXh0Tm9kZS5kYXRhLmxlbmd0aCk7 CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoIkRlbGV0ZSIsIGZhbHNlKTsKKworICAgIHRleHRJ bnB1dENvbnRyb2xsZXIuc2V0TWFya2VkVGV4dChjb21wb3NpdGlvblRleHQsIDAsIGNvbXBvc2l0 aW9uVGV4dCk7CisgICAgY29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisgICAgdGV4 dElucHV0Q29udHJvbGxlci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4dCA9IG5vZGUu aW5uZXJUZXh0OworCisgICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICInIiArIGV4cGVj dGVkICsgIiciKTsKK30KKwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJkaXYiLCAi QSBCIiwgIkEgQiIpOwordGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwordGVzdCgiZGl2 IiwgIkEgICBCIiwgIkEgXHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwgIkEgXHhBMCBc eEEwQiIpOyAKKwordGVzdCgiZGl2IiwgIiBBQiIsICJceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIg IEFCIiwgIlx4QTBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICBBQiIsICJceEEwXHhBMCBBQiIp OwordGVzdCgiZGl2IiwgIiAgICBBQiIsICJceEEwXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIs ICIgICAgIEFCIiwgIlx4QTBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICBBQiIs ICJceEEwXHhBMCBceEEwIFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgICAgICBBQiIsICJceEEw XHhBMCBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICJBQiAgIiwgIkFCIFx4QTAiKTsKK3Rl c3QoImRpdiIsICJBQiAgICIsICJBQiBceEEwXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICIs ICJBQiBceEEwIFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgIiwgIkFCIFx4QTAgXHhBMFx4 QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMCIpOwordGVz dCgiZGl2IiwgIkFCICAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMFx4QTAiKTsKKwordGVzdCgi ZGl2IiwgIiAgQSAgQiAgIiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7Cit0ZXN0KCJkaXYiLCAi XHRcdEFcdFx0Qlx0XHQiLCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKKwordGVzdCgiZGl2Iiwg IiAiLCAiXHhBMCIpOwordGVzdCgiZGl2IiwgIiAgIiwgIlx4QTBceEEwIik7Cit0ZXN0KCJkaXYi LCAiICAgIiwgIlx4QTBceEEwXHhBMCIpOworCit0ZXN0KCJwcmUiLCAiQUIiLCAiQUIiKTsKK3Rl c3QoInByZSIsICJBIEIiLCAiQSBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgQiIsICJBICBCIik7Cit0 ZXN0KCJwcmUiLCAiQSAgIEIiLCAiQSAgIEIiKTsKK3Rlc3QoInByZSIsICJBICAgIEIiLCAiQSAg ICBCIik7Cit0ZXN0KCJwcmUiLCAiQUIgICIsICJBQiAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAi LCAiQUIgICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAiLCAiQUIgICAgIik7Cit0ZXN0KCJwcmUi LCAiQUIgICAgICIsICJBQiAgICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAiLCAiQUIgICAg ICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAgICAiLCAiQUIgICAgICAgIik7Cit0ZXN0KCJwcmUi LCAiICBBQiIsICIgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgQUIiLCAiICAgQUIiKTsKK3Rlc3Qo InByZSIsICIgICAgQUIiLCAiICAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICBBQiIsICIgICAg IEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICAgQUIiLCAiICAgICAgQUIiKTsKK3Rlc3QoInByZSIs ICIgICAgICAgQUIiLCAiICAgICAgIEFCIik7CisKK3Rlc3QoInByZSIsICIgIEEgIEIgICIsICIg IEEgIEIgICIpOwordGVzdCgicHJlIiwgIlx0XHRBXHRcdEJcdFx0IiwgIlx0XHRBXHRcdEJcdFx0 Iik7Cit0ZXN0KCJwcmUiLCAiICIsICIgIik7Cit0ZXN0KCJwcmUiLCAiICAiLCAiICAiKTsKK3Rl c3QoInByZSIsICIgICAiLCAiICAgIik7CisKK3Jvb3Quc3R5bGUuZGlzcGxheSA9ICJub25lIjsK K3N1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CisKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzljYjhiYTM2NjRjNmJhZDk3ZTg4MzQzZWYwZGFiODg5 YjcxOTk2Zi4uMTI2NThiMzFiYzEyODQyYzlhMzJiOGRiNWJkNzMyMWVkYzAwZmY1NiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDQ1IEBACisyMDExLTAxLTEzICBNT1JJVEEgSGFqaW1lICA8bW9ycml0 YUBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFNwYWNlIGFuZCB0YWIgY2hhcmFjdGVycyAic2VudCIgYnkgYW4gaW5wdXQgbWV0aG9k IGdpdmUgdG90YWxseSBkaWZmZXJlbnQgcmVzdWx0cyB0aGFuIHR5cGluZyB0aGVtIGRpcmVjdGx5 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MjQxCisg ICAgICAgIAorICAgICAgICAqIEludHJvZHVjZWQgVGV4dEV2ZW50OjpJbnB1dFR5cGVDb21wb3Np dGlvbiBhbmQgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVHlwZSB0byAKKyAgICAgICAg ICBkaXN0aW5ndWlzaCB0ZXh0IGlucHV0IHdoaWNoIGlzIG9yaWdpbmF0ZWQgYnkgY29tcG9zaXRp b24uCisgICAgICAgICogR2VuZXJhbGl6ZWQgcmViYWxhbmNlV2hpdGVzcGFjZUF0KCkgdG8gcmVi YWxhbmNlV2hpdGVzcGFjZUJldHdlZW4oKSB0byByZWJhbGFuY2luZyAKKyAgICAgICAgICByYW5n ZSBvZiBzdHJpbmcgb24gdGV4dCBub2RlLCBpbnN0ZWFkIG9mIHN1cnJvdW5kaW5nIHBhcnQgb2Yg dGhhdC4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRp b24td2hpdGVzcGFjZS5odG1sCisKKyAgICAgICAgKiBkb20vVGV4dEV2ZW50LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRFdmVudDo6c2VsZWN0SW5wdXRUeXBlKToKKyAgICAgICAgKiBkb20v VGV4dEV2ZW50Lmg6IGFkZCBUZXh0RXZlbnQ6OklucHV0VHlwZUNvbXBvc2l0aW9uIGFzIGEgbWVt YmVyIG9mIFRleHRFdmVudDo6SW5wdXRUeXBlCisgICAgICAgIChXZWJDb3JlOjpUZXh0RXZlbnQ6 OmlzQ29tcG9zaXRpb24pOgorICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdo aXRlc3BhY2VBdCk6IHJlcGxhY2VkIHdpdGggcmViYWxhbmNlV2hpdGVzcGFjZUJldHdlZW4oKQor ICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3Bh Y2VCZXR3ZWVuKTogZ2VuZXJhbGl6ZWQgdmVyc2lvbiBvZiByZWJhbGFuY2VXaGl0ZXNwYWNlQXQo KSwgd2hpY2ggdGFrZXMgMiBwb3NpdGlvbiBhcyBhcmd1bWV0bnMuCisgICAgICAgICogZWRpdGlu Zy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRWRpdG9yLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0 aW9uKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6Omluc2VydFRleHRXaXRob3V0 U2VuZGluZ1RleHRFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmNvbmZpcm1Db21w b3NpdGlvbik6IE5vdyB1c2VzIG5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKCkKKyAg ICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6c2V0Q29tcG9zaXRpb24pOgorICAgICAgICAqIGVkaXRp bmcvRWRpdG9yLmg6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQpOgorICAgICAgICAqIGVk aXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaDoKKyAgICAgICAgKiBlZGl0aW5nL1R5cGluZ0NvbW1h bmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZCk6 CisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KToKKyAgICAgICAg KFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHRSdW5XaXRob3V0TmV3bGluZXMpOgor ICAgICAgICAqIGVkaXRpbmcvVHlwaW5nQ29tbWFuZC5oOiBBZGRlZCBUeXBpbmdDb21tYW5kOjpt X2NvbXBvc2l0aW9uVHlwZSBhbmQgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVHlwZQor ICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6c2V0Q29tcG9zaXRpb25UeXBlKTogQWRk ZWQKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6OmNyZWF0ZSk6CisgICAgICAgICog cGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpo YW5kbGVUZXh0SW5wdXRFdmVudCk6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuaDoKKwog MjAxMS0wMS0xNiAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJ1 YmJlci1zdGFtcGVkIGJ5IEVyaWMgU2VpZGVsLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL1RleHRFdmVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcAppbmRl eCA2OGVkNGIyNzMzYTJiZTFkYTRkOTYwMjA4NWIwOGFjNTRlM2I5YmIxLi4yMmFlZTA3ZDFmOWJj MDRjMzRlNjBkOTQ0NTRlNGU1ODFiODA5ZmVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9k b20vVGV4dEV2ZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcApA QCAtMzEsMTIgKzMxLDE0IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotVGV4dEV2ZW50OjpJ bnB1dFR5cGUgVGV4dEV2ZW50OjpzZWxlY3RJbnB1dFR5cGUoYm9vbCBpc0xpbmVCcmVhaywgYm9v bCBpc0JhY2tUYWIpCitUZXh0RXZlbnQ6OklucHV0VHlwZSBUZXh0RXZlbnQ6OnNlbGVjdElucHV0 VHlwZShib29sIGlzTGluZUJyZWFrLCBib29sIGlzQmFja1RhYiwgYm9vbCBpc0NvbXBvc2l0aW9u KQogewogICAgIGlmIChpc0xpbmVCcmVhaykKICAgICAgICAgcmV0dXJuIFRleHRFdmVudDo6SW5w dXRUeXBlTGluZUJyZWFrOwogICAgIGlmIChpc0JhY2tUYWIpCiAgICAgICAgIHJldHVybiBUZXh0 RXZlbnQ6OklucHV0VHlwZUJhY2tUYWI7CisgICAgaWYgKGlzQ29tcG9zaXRpb24pCisgICAgICAg IHJldHVybiBUZXh0RXZlbnQ6OklucHV0VHlwZUNvbXBvc2l0aW9uOwogICAgIHJldHVybiBUZXh0 RXZlbnQ6OklucHV0VHlwZUtleWJvYXJkOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9kb20vVGV4dEV2ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmgKaW5kZXgg ZjFkMjRlOWM2ODEwZjU1YTQzNmNlZTZkMDRhZTNkZDQxMmI3OTYyNC4uZmQzZDlmNmE0YzRhYTcw YTk3ZTI5OTZhZjYxODdmNzBjZmIyMTBjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L1RleHRFdmVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuaApAQCAtMzYs MTMgKzM2LDE0IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBwdWJsaWM6CiAgICAgICAgIGVu dW0gSW5wdXRUeXBlIHsKICAgICAgICAgICAgIElucHV0VHlwZUtleWJvYXJkLCAvLyBhbnkgbmV3 bGluZSBjaGFyYWN0ZXJzIGluIHRoZSB0ZXh0IGFyZSBsaW5lIGJyZWFrcyBvbmx5LCBub3QgcGFy YWdyYXBoIHNlcGFyYXRvcnMuCisgICAgICAgICAgICBJbnB1dFR5cGVDb21wb3NpdGlvbiwgLy8g aW5wdXQgaXMgZG9uZSBieSBJTUUuCiAgICAgICAgICAgICBJbnB1dFR5cGVMaW5lQnJlYWssIC8v IGFueSB0YWIgY2hhcmFjdGVycyBpbiB0aGUgdGV4dCBhcmUgYmFja3RhYnMuCiAgICAgICAgICAg ICBJbnB1dFR5cGVCYWNrVGFiLAogICAgICAgICAgICAgSW5wdXRUeXBlUGFzdGUsCiAgICAgICAg ICAgICBJbnB1dFR5cGVEcm9wLAogICAgICAgICB9OwogCi0gICAgICAgIHN0YXRpYyBJbnB1dFR5 cGUgc2VsZWN0SW5wdXRUeXBlKGJvb2wgaXNMaW5lQnJlYWssIGJvb2wgaXNCYWNrVGFiKTsKKyAg ICAgICAgc3RhdGljIElucHV0VHlwZSBzZWxlY3RJbnB1dFR5cGUoYm9vbCBpc0xpbmVCcmVhaywg Ym9vbCBpc0JhY2tUYWIsIGJvb2wgaXNDb21wb3NpdGlvbik7CiAgICAgICAgIHN0YXRpYyBQYXNz UmVmUHRyPFRleHRFdmVudD4gY3JlYXRlKCk7CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPFRl eHRFdmVudD4gY3JlYXRlKFBhc3NSZWZQdHI8QWJzdHJhY3RWaWV3PiB2aWV3LCBjb25zdCBTdHJp bmcmIGRhdGEsIElucHV0VHlwZSA9IElucHV0VHlwZUtleWJvYXJkKTsKICAgICAgICAgc3RhdGlj IFBhc3NSZWZQdHI8VGV4dEV2ZW50PiBjcmVhdGVGb3JQbGFpblRleHRQYXN0ZShQYXNzUmVmUHRy PEFic3RyYWN0Vmlldz4gdmlldywgY29uc3QgU3RyaW5nJiBkYXRhLCBib29sIHNob3VsZFNtYXJ0 UmVwbGFjZSk7CkBAIC01Nyw2ICs1OCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAg ICB2aXJ0dWFsIGJvb2wgaXNUZXh0RXZlbnQoKSBjb25zdDsKIAorICAgICAgICBib29sIGlzQ29t cG9zaXRpb24oKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9PSBJbnB1dFR5cGVDb21wb3Np dGlvbjsgfQogICAgICAgICBib29sIGlzTGluZUJyZWFrKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1 dFR5cGUgPT0gSW5wdXRUeXBlTGluZUJyZWFrOyB9CiAgICAgICAgIGJvb2wgaXNCYWNrVGFiKCkg Y29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUgPT0gSW5wdXRUeXBlQmFja1RhYjsgfQogICAgICAg ICBib29sIGlzUGFzdGUoKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9PSBJbnB1dFR5cGVQ YXN0ZTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0 Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5k LmNwcAppbmRleCA5ZTFkZmNhNTU4Y2RhODlmZGVjYWE3MTRiZWE2ODIyYjA3OTdlZTA4Li5hNzJi MWE1MGQ5ZjdiNzZkYzkyYTFlNmQ2YWQ2M2FiMmM4YmFhYWRhIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcApAQCAtMzk1LDExICszOTUsMzEg QEAgc3RhdGljIGlubGluZSBib29sIGlzV2hpdGVzcGFjZShVQ2hhciBjKQogICAgIHJldHVybiBj ID09IG5vQnJlYWtTcGFjZSB8fCBjID09ICcgJyB8fCBjID09ICdcbicgfHwgYyA9PSAnXHQnOwog fQogCitzdGF0aWMgaW5saW5lIGJvb2wgaXNXaGl0ZXNwYWNlcyhjb25zdCBTdHJpbmcmIHRleHQp Cit7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHRleHQubGVuZ3RoKCk7ICsraSkgewor ICAgICAgICBpZiAoIWlzV2hpdGVzcGFjZSh0ZXh0LmNoYXJhY3RlcnMoKVtpXSkpCisgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorICAgIAorICAgIHJldHVybiB0cnVlOworfQorCiti b29sIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpzaG91bGRSZWJhbGFuY2VCb3RoTGVhZGluZ0FuZFRy YWlsaW5nV2hpdGVzcGFjZXNGb3IoY29uc3QgU3RyaW5nJiB0ZXh0KSBjb25zdAoreworICAgIHJl dHVybiAhaXNXaGl0ZXNwYWNlcyh0ZXh0KTsKK30KKwogLy8gRklYTUU6IERvZXNuJ3QgZ28gaW50 byB0ZXh0IG5vZGVzIHRoYXQgY29udHJpYnV0ZSBhZGphY2VudCB0ZXh0IChzaWJsaW5ncywgY291 c2lucywgZXRjKS4KIHZvaWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3Bh Y2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHBvc2l0 aW9uLmNvbnRhaW5lck5vZGUoKTsKLSAgICBpZiAocG9zaXRpb24uYW5jaG9yVHlwZSgpICE9IFBv c2l0aW9uOjpQb3NpdGlvbklzT2Zmc2V0SW5BbmNob3IgfHwgIW5vZGUgfHwgIW5vZGUtPmlzVGV4 dE5vZGUoKSkKKyAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQmV0d2Vlbihwb3NpdGlvbiwgcG9zaXRp b24pOworfQorCit2b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNl QmV0d2Vlbihjb25zdCBQb3NpdGlvbiYgc3RhcnRQb3NpdGlvbiwgY29uc3QgUG9zaXRpb24mIGVu ZFBvc2l0aW9uKQoreworICAgIE5vZGUqIG5vZGUgPSBzdGFydFBvc2l0aW9uLmNvbnRhaW5lck5v ZGUoKTsKKyAgICBpZiAoc3RhcnRQb3NpdGlvbi5hbmNob3JUeXBlKCkgIT0gUG9zaXRpb246OlBv c2l0aW9uSXNPZmZzZXRJbkFuY2hvciB8fCAhbm9kZSB8fCAhbm9kZS0+aXNUZXh0Tm9kZSgpKQog ICAgICAgICByZXR1cm47CiAgICAgVGV4dCogdGV4dE5vZGUgPSBzdGF0aWNfY2FzdDxUZXh0Kj4o bm9kZSk7CiAKQEAgLTQxMiwzNSArNDMyLDMxIEBAIHZvaWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6 OnJlYmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24pCiAgICAgU3Ry aW5nIHRleHQgPSB0ZXh0Tm9kZS0+ZGF0YSgpOwogICAgIEFTU0VSVCghdGV4dC5pc0VtcHR5KCkp OwogCi0gICAgaW50IG9mZnNldCA9IHBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCk7 Ci0gICAgLy8gSWYgbmVpdGhlciB0ZXh0W29mZnNldF0gbm9yIHRleHRbb2Zmc2V0IC0gMV0gYXJl IHNvbWUgZm9ybSBvZiB3aGl0ZXNwYWNlLCBkbyBub3RoaW5nLgotICAgIGlmICghaXNXaGl0ZXNw YWNlKHRleHRbb2Zmc2V0XSkpIHsKLSAgICAgICAgb2Zmc2V0LS07Ci0gICAgICAgIGlmIChvZmZz ZXQgPCAwIHx8ICFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkKLSAgICAgICAgICAgIHJldHVy bjsKLSAgICB9Ci0gICAgCisgICAgaW50IHN0YXJ0T2Zmc2V0ID0gc3RhcnRQb3NpdGlvbi5kZXBy ZWNhdGVkRWRpdGluZ09mZnNldCgpOworICAgIGludCBlbmRPZmZzZXQgPSBlbmRQb3NpdGlvbi5k ZXByZWNhdGVkRWRpdGluZ09mZnNldCgpOworCiAgICAgLy8gU2V0IHVwc3RyZWFtIGFuZCBkb3du c3RyZWFtIHRvIGRlZmluZSB0aGUgZXh0ZW50IG9mIHRoZSB3aGl0ZXNwYWNlIHN1cnJvdW5kaW5n IHRleHRbb2Zmc2V0XS4KLSAgICBpbnQgdXBzdHJlYW0gPSBvZmZzZXQ7CisgICAgaW50IHVwc3Ry ZWFtID0gc3RhcnRPZmZzZXQ7CiAgICAgd2hpbGUgKHVwc3RyZWFtID4gMCAmJiBpc1doaXRlc3Bh Y2UodGV4dFt1cHN0cmVhbSAtIDFdKSkKICAgICAgICAgdXBzdHJlYW0tLTsKICAgICAKLSAgICBp bnQgZG93bnN0cmVhbSA9IG9mZnNldDsKLSAgICB3aGlsZSAoKHVuc2lnbmVkKWRvd25zdHJlYW0g KyAxIDwgdGV4dC5sZW5ndGgoKSAmJiBpc1doaXRlc3BhY2UodGV4dFtkb3duc3RyZWFtICsgMV0p KQorICAgIGludCBkb3duc3RyZWFtID0gZW5kT2Zmc2V0OworICAgIHdoaWxlICgodW5zaWduZWQp ZG93bnN0cmVhbSA8IHRleHQubGVuZ3RoKCkgJiYgaXNXaGl0ZXNwYWNlKHRleHRbZG93bnN0cmVh bV0pKQogICAgICAgICBkb3duc3RyZWFtKys7CiAgICAgCi0gICAgaW50IGxlbmd0aCA9IGRvd25z dHJlYW0gLSB1cHN0cmVhbSArIDE7Ci0gICAgQVNTRVJUKGxlbmd0aCA+IDApOworICAgIGludCBs ZW5ndGggPSBkb3duc3RyZWFtIC0gdXBzdHJlYW07CisgICAgaWYgKCFsZW5ndGgpCisgICAgICAg IHJldHVybjsKICAgICAKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBv c2l0aW9uKHBvc2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgdXBzdHJlYW0sIFBvc2l0aW9uOjpQb3Np dGlvbklzT2Zmc2V0SW5BbmNob3IpKTsKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZURvd25z dHJlYW1Qb3MoUG9zaXRpb24ocG9zaXRpb24uY29udGFpbmVyTm9kZSgpLCBkb3duc3RyZWFtICsg MSwgUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOworICAgIFZpc2libGVQb3Np dGlvbiB2aXNpYmxlVXBzdHJlYW1Qb3MoUG9zaXRpb24oc3RhcnRQb3NpdGlvbi5jb250YWluZXJO b2RlKCksIHVwc3RyZWFtLCBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9yKSk7Cisg ICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVEb3duc3RyZWFtUG9zKFBvc2l0aW9uKGVuZFBvc2l0 aW9uLmNvbnRhaW5lck5vZGUoKSwgZG93bnN0cmVhbSwgUG9zaXRpb246OlBvc2l0aW9uSXNPZmZz ZXRJbkFuY2hvcikpOwogICAgIAogICAgIFN0cmluZyBzdHJpbmcgPSB0ZXh0LnN1YnN0cmluZyh1 cHN0cmVhbSwgbGVuZ3RoKTsKICAgICBTdHJpbmcgcmViYWxhbmNlZFN0cmluZyA9IHN0cmluZ1dp dGhSZWJhbGFuY2VkV2hpdGVzcGFjZShzdHJpbmcsCiAgICAgLy8gRklYTUU6IEJlY2F1c2Ugb2Yg dGhlIHByb2JsZW0gbWVudGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhpcyBmdW5jdGlvbiwgd2UgbXVz dCBhbHNvIHVzZSBuYnNwcyBhdCB0aGUgc3RhcnQvZW5kIG9mIHRoZSBzdHJpbmcgYmVjYXVzZQog ICAgIC8vIHRoaXMgZnVuY3Rpb24gZG9lc24ndCBnZXQgYWxsIHN1cnJvdW5kaW5nIHdoaXRlc3Bh Y2UsIGp1c3QgdGhlIHdoaXRlc3BhY2UgaW4gdGhlIGN1cnJlbnQgdGV4dCBub2RlLgogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlz U3RhcnRPZlBhcmFncmFwaCh2aXNpYmxlVXBzdHJlYW1Qb3MpIHx8IHVwc3RyZWFtID09IDAsIAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGlzRW5kT2ZQYXJhZ3JhcGgodmlzaWJsZURvd25zdHJlYW1Qb3MpIHx8ICh1bnNpZ25lZClk b3duc3RyZWFtID09IHRleHQubGVuZ3RoKCkgLSAxKTsKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpc0VuZE9mUGFyYWdyYXBoKHZp c2libGVEb3duc3RyZWFtUG9zKSB8fCAodW5zaWduZWQpZG93bnN0cmVhbSA9PSB0ZXh0Lmxlbmd0 aCgpKTsKICAgICAKICAgICBpZiAoc3RyaW5nICE9IHJlYmFsYW5jZWRTdHJpbmcpCiAgICAgICAg IHJlcGxhY2VUZXh0SW5Ob2RlKHRleHROb2RlLCB1cHN0cmVhbSwgbGVuZ3RoLCByZWJhbGFuY2Vk U3RyaW5nKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQu aAppbmRleCA2ZGI0ZWIxODJhMDg4NmFkMWZkODBiMDRlOGMxYzZmMzYxY2IwMzAwLi5lOTc0NzYy MTIzNDlkMWYyOWNjMTE3MGUyOGVmODFkNjVhYjljMzk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC03MSw2ICs3MSw4IEBAIHByb3RlY3Rl ZDoKICAgICB2b2lkIG1lcmdlSWRlbnRpY2FsRWxlbWVudHMoUGFzc1JlZlB0cjxFbGVtZW50Piwg UGFzc1JlZlB0cjxFbGVtZW50Pik7CiAgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlKCk7CiAg ICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mKTsKKyAgICB2b2lk IHJlYmFsYW5jZVdoaXRlc3BhY2VCZXR3ZWVuKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRp b24mKTsKKyAgICBib29sIHNob3VsZFJlYmFsYW5jZUJvdGhMZWFkaW5nQW5kVHJhaWxpbmdXaGl0 ZXNwYWNlc0Zvcihjb25zdCBTdHJpbmcmIHRleHQpIGNvbnN0OwogICAgIHZvaWQgcHJlcGFyZVdo aXRlc3BhY2VBdFBvc2l0aW9uRm9yU3BsaXQoUG9zaXRpb24mKTsKICAgICB2b2lkIHJlbW92ZUNT U1Byb3BlcnR5KFBhc3NSZWZQdHI8U3R5bGVkRWxlbWVudD4sIENTU1Byb3BlcnR5SUQpOwogICAg IHZvaWQgcmVtb3ZlTm9kZUF0dHJpYnV0ZShQYXNzUmVmUHRyPEVsZW1lbnQ+LCBjb25zdCBRdWFs aWZpZWROYW1lJiBhdHRyaWJ1dGUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9FZGl0b3IuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IGJl YTc0ZDk2MTIwZDFhMzhmZDY4ODRhNjIyNzFmY2NhZWVhNmRjZTIuLjFiMjZmM2UxNGVmNmYwMzg3 ZTQ3YWU0M2FmOWFmZGZmMjg5YTE2NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAg LTExNzMsNyArMTE3MywxMiBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcm IHRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCiAgICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50 SGFuZGxlcigpLT5oYW5kbGVUZXh0SW5wdXRFdmVudCh0ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwog fQogCi1ib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0 IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5n RXZlbnQpCitib29sIEVkaXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNv bnN0IFN0cmluZyYgdGV4dCkKK3sKKyAgICByZXR1cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCkt PmhhbmRsZVRleHRJbnB1dEV2ZW50KHRleHQsIDAsIGZhbHNlLCBmYWxzZSwgdHJ1ZSk7Cit9CisK K2Jvb2wgRWRpdG9yOjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3Ry aW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEV2ZW50KiB0cmlnZ2VyaW5n RXZlbnQpCiB7CiAgICAgaWYgKHRleHQuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7 CkBAIC0xMTk1LDcgKzEyMDAsOCBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5k aW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbgogICAgICAgICAg ICAgUmVmUHRyPERvY3VtZW50PiBkb2N1bWVudCA9IHNlbGVjdGlvblN0YXJ0LT5kb2N1bWVudCgp OwogICAgICAgICAgICAgCiAgICAgICAgICAgICAvLyBJbnNlcnQgdGhlIHRleHQKLSAgICAgICAg ICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVj dGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKKyAgICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omlu c2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRU ZXh0LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJpZ2dlcmluZ0V2 ZW50ICYmIHRyaWdnZXJpbmdFdmVudC0+aXNDb21wb3NpdGlvbigpID8gVHlwaW5nQ29tbWFuZDo6 VGV4dENvbXBvc2l0aW9uQ29uZmlybSA6IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbk5v bmUpOwogCiAgICAgICAgICAgICAvLyBSZXZlYWwgdGhlIGN1cnJlbnQgc2VsZWN0aW9uIAogICAg ICAgICAgICAgaWYgKEZyYW1lKiBlZGl0ZWRGcmFtZSA9IGRvY3VtZW50LT5mcmFtZSgpKQpAQCAt MTYxOCw3ICsxNjI0LDcgQEAgdm9pZCBFZGl0b3I6OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBT dHJpbmcmIHRleHQsIGJvb2wgcHJlc2VydmVTZWxlY3Rpb24pCiAgICAgbV9jb21wb3NpdGlvbk5v ZGUgPSAwOwogICAgIG1fY3VzdG9tQ29tcG9zaXRpb25VbmRlcmxpbmVzLmNsZWFyKCk7CiAKLSAg ICBpbnNlcnRUZXh0KHRleHQsIDApOworICAgIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3Np dGlvbih0ZXh0KTsKIAogICAgIGlmIChwcmVzZXJ2ZVNlbGVjdGlvbikgewogICAgICAgICBtX2Zy YW1lLT5zZWxlY3Rpb24oKS0+c2V0U2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgZmFsc2UsIGZhbHNl KTsKQEAgLTE2ODcsNyArMTY5Myw3IEBAIHZvaWQgRWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25z dCBTdHJpbmcmIHRleHQsIGNvbnN0IFZlY3RvcjxDb21wb3NpdGlvblVuZGVybGluCiAgICAgbV9j dXN0b21Db21wb3NpdGlvblVuZGVybGluZXMuY2xlYXIoKTsKIAogICAgIGlmICghdGV4dC5pc0Vt cHR5KCkpIHsKLSAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1 bWVudCgpLCB0ZXh0LCB0cnVlLCB0cnVlKTsKKyAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0 VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0LCB0cnVlLCBUeXBpbmdDb21tYW5kOjpUZXh0 Q29tcG9zaXRpb25VcGRhdGUpOwogCiAgICAgICAgIC8vIEZpbmQgb3V0IHdoYXQgbm9kZSBoYXMg dGhlIGNvbXBvc2l0aW9uIG5vdy4KICAgICAgICAgUG9zaXRpb24gYmFzZSA9IG1fZnJhbWUtPnNl bGVjdGlvbigpLT5iYXNlKCkuZG93bnN0cmVhbSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZWRpdGluZy9FZGl0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKaW5k ZXggMmU2MWNlNjdkMTgxODVhNjZhOTI4MDFkNmI3YTk1YTQ3ODk0NmVjOS4uMWU2ZTM4NzNmNWRj OGRlZjJkMGQyMGEwMGNiMTMzMzhhOWMwOWE5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9FZGl0b3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBA IC0xOTgsNyArMTk4LDggQEAgcHVibGljOgogICAgIHN0YXRpYyBib29sIGNvbW1hbmRJc1N1cHBv cnRlZEZyb21NZW51T3JLZXlCaW5kaW5nKGNvbnN0IFN0cmluZyYgY29tbWFuZE5hbWUpOyAvLyBX b3JrcyB3aXRob3V0IGEgZnJhbWUuCiAKICAgICBib29sIGluc2VydFRleHQoY29uc3QgU3RyaW5n JiwgRXZlbnQqIHRyaWdnZXJpbmdFdmVudCk7Ci0gICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNl bmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2 ZW50KiB0cmlnZ2VyaW5nRXZlbnQpOworICAgIGJvb2wgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENv bXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCk7CisgICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91 dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQs IFRleHRFdmVudCogdHJpZ2dlcmluZ0V2ZW50KTsKICAgICBib29sIGluc2VydExpbmVCcmVhaygp OwogICAgIGJvb2wgaW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yKCk7CiAgICAgCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCmluZGV4IGZjMThlOTEyZjk1MzYz NmFmYjI3MTZmMGMxNjIzZDUwOTA2ODlmNWQuLmYzNTM0NTdhOWJmMjRlYjk1Y2U5NGRjMzk4ZGQ2 NTZjN2JkNDlmZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4 dENvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1h bmQuY3BwCkBAIC0xMDYsNyArMTA2LDcgQEAgYm9vbCBJbnNlcnRUZXh0Q29tbWFuZDo6cGVyZm9y bVRyaXZpYWxSZXBsYWNlKGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnMKICAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQoY29uc3QgU3Ry aW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCkKK3ZvaWQgSW5zZXJ0VGV4dENvbW1h bmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFJl YmFsYW5jZVR5cGUgd2hpdGVzcGFjZVJlYmFsYW5jZSkKIHsKICAgICAKICAgICBBU1NFUlQodGV4 dC5maW5kKCdcbicpID09IG5vdEZvdW5kKTsKQEAgLTE3MiwxMSArMTcyLDE2IEBAIHZvaWQgSW5z ZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQpCiAgICAgICAgIGluc2VydFRleHRJbnRvTm9kZSh0ZXh0Tm9kZSwgb2Zmc2V0LCB0 ZXh0KTsKICAgICAgICAgZW5kUG9zaXRpb24gPSBQb3NpdGlvbih0ZXh0Tm9kZSwgb2Zmc2V0ICsg dGV4dC5sZW5ndGgoKSk7CiAKLSAgICAgICAgLy8gVGhlIGluc2VydGlvbiBtYXkgcmVxdWlyZSBh ZGp1c3RpbmcgYWRqYWNlbnQgd2hpdGVzcGFjZSwgaWYgaXQgaXMgcHJlc2VudC4KLSAgICAgICAg cmViYWxhbmNlV2hpdGVzcGFjZUF0KGVuZFBvc2l0aW9uKTsKLSAgICAgICAgLy8gUmViYWxhbmNp bmcgb24gYm90aCBzaWRlcyBpc24ndCBuZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFj ZS4KLSAgICAgICAgaWYgKHRleHQgIT0gIiAiKSAKLSAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRl c3BhY2VBdChzdGFydFBvc2l0aW9uKTsKKyAgICAgICAgaWYgKHdoaXRlc3BhY2VSZWJhbGFuY2Ug PT0gUmViYWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpIHsKKyAgICAgICAgICAg IC8vIFRoZSBpbnNlcnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdoaXRlc3Bh Y2UsIGlmIGl0IGlzIHByZXNlbnQuCisgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQo ZW5kUG9zaXRpb24pOworICAgICAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBzaWRlcyBp c24ndCBuZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFjZS4KKyAgICAgICAgICAgIGlm IChzaG91bGRSZWJhbGFuY2VCb3RoTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXNGb3IodGV4 dCkpCisgICAgICAgICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZUF0KHN0YXJ0UG9zaXRpb24p OworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgQVNTRVJUKHdoaXRlc3BhY2VSZWJhbGFu Y2UgPT0gUmViYWxhbmNlQWxsV2hpdGVzcGFjZXMpOworICAgICAgICAgICAgcmViYWxhbmNlV2hp dGVzcGFjZUJldHdlZW4oc3RhcnRQb3NpdGlvbiwgZW5kUG9zaXRpb24pOworICAgICAgICB9CiAg ICAgfQogCiAgICAgLy8gV2UgY291bGQgaGF2ZSBpbnNlcnRlZCBhIHBhcnQgb2YgY29tcG9zZWQg Y2hhcmFjdGVyIHNlcXVlbmNlLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9J bnNlcnRUZXh0Q29tbWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29t bWFuZC5oCmluZGV4IDc3YWUwMTZkMzZhMTRmYjFmODE0OWRmN2FhMzQxMmNkZWMxZDIyZGUuLjY3 MmU1NzZmOTIwNzlhNWNmOTc3YWU1Y2Y4YTI0YmQ5YzI3ZmE0YzcgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmgKQEAgLTMyLDE0ICszMiwyMCBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIGNsYXNzIEluc2VydFRleHRDb21tYW5kIDogcHVibGljIENvbXBvc2l0 ZUVkaXRDb21tYW5kIHsKIHB1YmxpYzoKKyAgICBlbnVtIFJlYmFsYW5jZVR5cGUgeworICAgICAg ICBSZWJhbGFuY2VMZWFkaW5nQW5kVHJhaWxpbmdXaGl0ZXNwYWNlcywKKyAgICAgICAgUmViYWxh bmNlQWxsV2hpdGVzcGFjZXMKKyAgICB9OworCiAgICAgc3RhdGljIFBhc3NSZWZQdHI8SW5zZXJ0 VGV4dENvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgewogICAgICAgICBy ZXR1cm4gYWRvcHRSZWYobmV3IEluc2VydFRleHRDb21tYW5kKGRvY3VtZW50KSk7CiAgICAgfQog Ci0gICAgdm9pZCBpbnB1dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRU ZXh0ID0gZmFsc2UpOworICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNl bGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBSZWJhbGFuY2VUeXBlID0gUmViYWxhbmNlTGVhZGlu Z0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpOwogCiBwcml2YXRlOgorCiAgICAgSW5zZXJ0VGV4dENv bW1hbmQoRG9jdW1lbnQqKTsKIAogICAgIHZvaWQgZGVsZXRlQ2hhcmFjdGVyKCk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcAppbmRleCBkNTRiMzg4NWJmOThmZTUyYmQ5 YTY1YzU0YThkNzFkOTY3NjA3ZTlkLi4yMWQ0MzE0YWQwNzU0OGEwOGM5ODI3YjBmMTU1Yjk5YWIy MjhiNjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKQEAgLTQ3 LDcgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRNTE5h bWVzOwogCi1UeXBpbmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwg RVR5cGluZ0NvbW1hbmQgY29tbWFuZFR5cGUsIGNvbnN0IFN0cmluZyAmdGV4dFRvSW5zZXJ0LCBi b29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5LCBib29s IGtpbGxSaW5nKQorVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZChEb2N1bWVudCAqZG9jdW1l bnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBTdHJpbmcgJnRleHRUb0luc2Vy dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSwg VGV4dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGJvb2wga2lsbFJpbmcpCiAgICAgOiBDb21wb3NpdGVFZGl0Q29tbWFuZChkb2N1 bWVudCksIAogICAgICAgbV9jb21tYW5kVHlwZShjb21tYW5kVHlwZSksIAogICAgICAgbV90ZXh0 VG9JbnNlcnQodGV4dFRvSW5zZXJ0KSwgCkBAIC01NSw2ICs1Niw3IEBAIFR5cGluZ0NvbW1hbmQ6 OlR5cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRvY3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5k VHlwZSwgY29uCiAgICAgICBtX3NlbGVjdEluc2VydGVkVGV4dChzZWxlY3RJbnNlcnRlZFRleHQp LAogICAgICAgbV9zbWFydERlbGV0ZShmYWxzZSksCiAgICAgICBtX2dyYW51bGFyaXR5KGdyYW51 bGFyaXR5KSwKKyAgICAgIG1fY29tcG9zaXRpb25UeXBlKGNvbXBvc2l0aW9uVHlwZSksCiAgICAg ICBtX2tpbGxSaW5nKGtpbGxSaW5nKSwKICAgICAgIG1fb3BlbmVkQnlCYWNrd2FyZERlbGV0ZShm YWxzZSkKIHsKQEAgLTEzMywxOCArMTM1LDE4IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6dXBkYXRl U2VsZWN0aW9uSWZEaWZmZXJlbnRGcm9tQ3VycmVudFNlbGVjdGlvbihUeXBpbmdDb21tYW5kCiB9 CiAgICAgCiAKLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1l bnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIGJvb2wgaW5z ZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChE b2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRl ZFRleHQsIFRleHRDb21wb3NpdGlvblR5cGUgY29tcG9zaXRpb24pCiB7CiAgICAgQVNTRVJUKGRv Y3VtZW50KTsKICAgICAKICAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKICAg ICBBU1NFUlQoZnJhbWUpOwogCi0gICAgaW5zZXJ0VGV4dChkb2N1bWVudCwgdGV4dCwgZnJhbWUt PnNlbGVjdGlvbigpLT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBpbnNlcnRlZFRl eHRJc0NvbXBvc2l0aW9uKTsKKyAgICBpbnNlcnRUZXh0KGRvY3VtZW50LCB0ZXh0LCBmcmFtZS0+ c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpLCBzZWxlY3RJbnNlcnRlZFRleHQsIGNvbXBvc2l0aW9u KTsKIH0KIAogLy8gRklYTUU6IFdlIHNob3VsZG4ndCBuZWVkIHRvIHRha2Ugc2VsZWN0aW9uRm9y SW5zZXJ0aW9uLiBJdCBzaG91bGQgYmUgaWRlbnRpY2FsIHRvIFNlbGVjdGlvbkNvbnRyb2xsZXIn cyBjdXJyZW50IHNlbGVjdGlvbi4KLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzaWJsZVNlbGVjdGlv biYgc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgYm9vbCBp bnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKQordm9pZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0 KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBWaXNpYmxlU2Vs ZWN0aW9uJiBzZWxlY3Rpb25Gb3JJbnNlcnRpb24sIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBU ZXh0Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uVHlwZSkKIHsKICNpZiBSRU1PVkVfTUFSS0VS U19VUE9OX0VESVRJTkcKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKQpAQCAtMTYxLDcgKzE2Myw3 IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNv bnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzCiAgICAgU3RyaW5nIG5ld1RleHQgPSB0ZXh0Owog ICAgIE5vZGUqIHN0YXJ0Tm9kZSA9IHNlbGVjdGlvbkZvckluc2VydGlvbi5zdGFydCgpLm5vZGUo KTsKICAgICAKLSAgICBpZiAoc3RhcnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxl bWVudCgpICYmICFpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKSB7ICAgICAgICAKKyAgICBpZiAo c3RhcnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpICYmIGNvbXBvc2l0 aW9uVHlwZSAhPSBUZXh0Q29tcG9zaXRpb25VcGRhdGUpIHsKICAgICAgICAgLy8gU2VuZCBCZWZv cmVUZXh0SW5zZXJ0ZWRFdmVudC4gVGhlIGV2ZW50IGhhbmRsZXIgd2lsbCB1cGRhdGUgdGV4dCBp ZiBuZWNlc3NhcnkuCiAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgICAgICBSZWZQ dHI8QmVmb3JlVGV4dEluc2VydGVkRXZlbnQ+IGV2dCA9IEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50 OjpjcmVhdGUodGV4dCk7CkBAIC0xODIsMTEgKzE4NCwxMyBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6 Omluc2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0 IFZpcwogICAgICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNldFN0YXJ0aW5nU2VsZWN0aW9u KHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+ c2V0RW5kaW5nU2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgIH0KKyAg ICAgICAgCisgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRDb21wb3NpdGlvblR5cGUoY29t cG9zaXRpb25UeXBlKTsKICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPmluc2VydFRleHQobmV3 VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IFJlZlB0cjxUeXBpbmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21tYW5kOjpjcmVhdGUoZG9jdW1l bnQsIEluc2VydFRleHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CisgICAgUmVmUHRy PFR5cGluZ0NvbW1hbmQ+IGNtZCA9IFR5cGluZ0NvbW1hbmQ6OmNyZWF0ZShkb2N1bWVudCwgSW5z ZXJ0VGV4dCwgbmV3VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBjb21wb3NpdGlvblR5cGUpOwog ICAgIGlmIChjaGFuZ2VTZWxlY3Rpb24pICB7CiAgICAgICAgIGNtZC0+c2V0U3RhcnRpbmdTZWxl Y3Rpb24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKICAgICAgICAgY21kLT5zZXRFbmRpbmdTZWxl Y3Rpb24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKQEAgLTM4Niw3ICszOTAsOCBAQCB2b2lkIFR5 cGluZ0NvbW1hbmQ6Omluc2VydFRleHRSdW5XaXRob3V0TmV3bGluZXMoY29uc3QgU3RyaW5nICZ0 ZXh0LCBib29sIHNlbGVjdAogICAgICAgICBjb21tYW5kLT5zZXRTdGFydGluZ1NlbGVjdGlvbihl bmRpbmdTZWxlY3Rpb24oKSk7CiAgICAgICAgIGNvbW1hbmQtPnNldEVuZGluZ1NlbGVjdGlvbihl bmRpbmdTZWxlY3Rpb24oKSk7CiAgICAgfQotICAgIGNvbW1hbmQtPmlucHV0KHRleHQsIHNlbGVj dEluc2VydGVkVGV4dCk7CisgICAgY29tbWFuZC0+aW5wdXQodGV4dCwgc2VsZWN0SW5zZXJ0ZWRU ZXh0LCAKKyAgICAgICAgICAgICAgICAgICBtX2NvbXBvc2l0aW9uVHlwZSA9PSBUZXh0Q29tcG9z aXRpb25Ob25lID8gSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUxlYWRpbmdBbmRUcmFpbGlu Z1doaXRlc3BhY2VzIDogSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUFsbFdoaXRlc3BhY2Vz KTsKICAgICB0eXBpbmdBZGRlZFRvT3BlbkNvbW1hbmQoSW5zZXJ0VGV4dCk7CiB9CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKaW5kZXggMjg0ZWJjMGFjMjY1ZDc2YjE2YTgw YmYyNjExYzdhODBlNjgwYWQwZi4uYjM0YmRjMTIyMWEyMmEzMDEyNGE5MDg4MDEwYzA1NDY1MWJm ZGU2ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKQEAgLTQyLDExICs0 MiwxNyBAQCBwdWJsaWM6CiAgICAgICAgIEluc2VydFBhcmFncmFwaFNlcGFyYXRvckluUXVvdGVk Q29udGVudAogICAgIH07CiAKKyAgICBlbnVtIFRleHRDb21wb3NpdGlvblR5cGUgeworICAgICAg ICBUZXh0Q29tcG9zaXRpb25Ob25lLAorICAgICAgICBUZXh0Q29tcG9zaXRpb25VcGRhdGUsCisg ICAgICAgIFRleHRDb21wb3NpdGlvbkNvbmZpcm0KKyAgICB9OworCiAgICAgc3RhdGljIHZvaWQg ZGVsZXRlU2VsZWN0aW9uKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0ZSA9IGZhbHNlKTsKICAg ICBzdGF0aWMgdm9pZCBkZWxldGVLZXlQcmVzc2VkKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0 ZSA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBr aWxsUmluZyA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9pZCBmb3J3YXJkRGVsZXRlS2V5UHJlc3Nl ZChEb2N1bWVudCosIGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0g Q2hhcmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBmYWxzZSk7Ci0gICAgc3RhdGlj IHZvaWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0ID0gZmFsc2UsIGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNl KTsKLSAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwg Y29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2Us IGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNlKTsKKyAgICBzdGF0aWMgdm9p ZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRl ZFRleHQgPSBmYWxzZSwgVGV4dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUp OworICAgIHN0YXRpYyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBj b25zdCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwg VGV4dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUpOwogICAgIHN0YXRpYyB2 b2lkIGluc2VydExpbmVCcmVhayhEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBh cmFncmFwaFNlcGFyYXRvcihEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBhcmFn cmFwaFNlcGFyYXRvckluUXVvdGVkQ29udGVudChEb2N1bWVudCopOwpAQCAtNjQsMTQgKzcwLDIw IEBAIHB1YmxpYzoKICAgICB2b2lkIGRlbGV0ZUtleVByZXNzZWQoVGV4dEdyYW51bGFyaXR5LCBi b29sIGtpbGxSaW5nKTsKICAgICB2b2lkIGZvcndhcmREZWxldGVLZXlQcmVzc2VkKFRleHRHcmFu dWxhcml0eSwgYm9vbCBraWxsUmluZyk7CiAgICAgdm9pZCBkZWxldGVTZWxlY3Rpb24oYm9vbCBz bWFydERlbGV0ZSk7CisgICAgdm9pZCBzZXRDb21wb3NpdGlvblR5cGUoVGV4dENvbXBvc2l0aW9u VHlwZSB0eXBlKSB7IG1fY29tcG9zaXRpb25UeXBlID0gdHlwZTsgfQogCiBwcml2YXRlOgogICAg IHN0YXRpYyBQYXNzUmVmUHRyPFR5cGluZ0NvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1l bnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4dCA9ICIiLCBib29s IHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkg PSBDaGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9IGZhbHNlKQogICAgIHsKLSAg ICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5k LCB0ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5LCBraWxsUmluZykpOworICAg ICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQs IHRleHQsIHNlbGVjdEluc2VydGVkVGV4dCwgZ3JhbnVsYXJpdHksIFRleHRDb21wb3NpdGlvbk5v bmUsIGtpbGxSaW5nKSk7CisgICAgfQorCisgICAgc3RhdGljIFBhc3NSZWZQdHI8VHlwaW5nQ29t bWFuZD4gY3JlYXRlKERvY3VtZW50KiBkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29tbWFuZCwg Y29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dENvbXBvc2l0 aW9uVHlwZSBjb21wb3NpdGlvblR5cGUpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYo bmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVjdEluc2VydGVk VGV4dCwgQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGNvbXBvc2l0aW9uVHlwZSwgZmFsc2UpKTsKICAg ICB9CiAKLSAgICBUeXBpbmdDb21tYW5kKERvY3VtZW50KiwgRVR5cGluZ0NvbW1hbmQsIGNvbnN0 IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSwg Ym9vbCBraWxsUmluZyk7CisgICAgVHlwaW5nQ29tbWFuZChEb2N1bWVudCosIEVUeXBpbmdDb21t YW5kLCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3Jh bnVsYXJpdHksIFRleHRDb21wb3NpdGlvblR5cGUsIGJvb2wga2lsbFJpbmcpOwogCiAgICAgYm9v bCBzbWFydERlbGV0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc21hcnREZWxldGU7IH0KICAgICB2b2lk IHNldFNtYXJ0RGVsZXRlKGJvb2wgc21hcnREZWxldGUpIHsgbV9zbWFydERlbGV0ZSA9IHNtYXJ0 RGVsZXRlOyB9CkBAIC05NCw2ICsxMDYsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9zZWxlY3RJ bnNlcnRlZFRleHQ7CiAgICAgYm9vbCBtX3NtYXJ0RGVsZXRlOwogICAgIFRleHRHcmFudWxhcml0 eSBtX2dyYW51bGFyaXR5OworICAgIFRleHRDb21wb3NpdGlvblR5cGUgbV9jb21wb3NpdGlvblR5 cGU7CiAgICAgYm9vbCBtX2tpbGxSaW5nOwogICAgIGJvb2wgbV9wcmVzZXJ2ZXNUeXBpbmdTdHls ZTsKICAgICAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCBmZWMxNzkzMWFk MzU0YWNlYzJjYWRmNmQ4YjY5NmE2NmExNjVkOTdlLi5jNWZhZmYxYTA5OWQ0NjVkNzgwNDMwNWFj OWQ5NTM5Yzk4MzUxYTI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFu ZGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0y NjUzLDcgKzI2NTMsNyBAQCBjbGVhbnVwRHJhZzoKIH0KICNlbmRpZiAvLyBFTkFCTEUoRFJBR19T VVBQT1JUKQogICAKLWJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudChjb25z dCBTdHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5aW5nRXZlbnQsIGJvb2wgaXNMaW5lQnJlYWss IGJvb2wgaXNCYWNrVGFiKQorYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50 KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmVudCwgYm9vbCBpc0xpbmVC cmVhaywgYm9vbCBpc0JhY2tUYWIsIGJvb2wgaXNDb21wb3NpdGlvbikKIHsKICAgICAvLyBQbGF0 Zm9ybXMgc2hvdWxkIGRpZmZlcmVudGlhdGUgcmVhbCBjb21tYW5kcyBsaWtlIHNlbGVjdEFsbCBm cm9tIHRleHQgaW5wdXQgaW4gZGlzZ3Vpc2UgKGxpa2UgaW5zZXJ0TmV3bGluZSksCiAgICAgLy8g YW5kIGF2b2lkIGRpc3BhdGNoaW5nIHRleHQgaW5wdXQgZXZlbnRzIGZyb20ga2V5ZG93biBkZWZh dWx0IGhhbmRsZXJzLgpAQCAtMjY3NCw3ICsyNjc0LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdF dmUKICAgICBpZiAoRnJhbWVWaWV3KiB2aWV3ID0gbV9mcmFtZS0+dmlldygpKQogICAgICAgICB2 aWV3LT5yZXNldERlZmVycmVkUmVwYWludERlbGF5KCk7CiAKLSAgICBSZWZQdHI8VGV4dEV2ZW50 PiBldmVudCA9IFRleHRFdmVudDo6Y3JlYXRlKG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBU ZXh0RXZlbnQ6OnNlbGVjdElucHV0VHlwZShpc0xpbmVCcmVhaywgaXNCYWNrVGFiKSk7CisgICAg UmVmUHRyPFRleHRFdmVudD4gZXZlbnQgPSBUZXh0RXZlbnQ6OmNyZWF0ZShtX2ZyYW1lLT5kb21X aW5kb3coKSwgdGV4dCwgVGV4dEV2ZW50OjpzZWxlY3RJbnB1dFR5cGUoaXNMaW5lQnJlYWssIGlz QmFja1RhYiwgaXNDb21wb3NpdGlvbikpOwogICAgIGV2ZW50LT5zZXRVbmRlcmx5aW5nRXZlbnQo dW5kZXJseWluZ0V2ZW50KTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9F dmVudEhhbmRsZXIuaAppbmRleCA2NTY5NWMyNzVmMDA2YTBkODk4OTg4MzNhYzc1NzBhNzg0ZmJh MDdjLi43ZmU1ZGJhYWZhZmE0OTNmM2UzNzRiNmRhYzVlZDNkMjlmZDRiNzkzIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRXZlbnRIYW5kbGVyLmgKQEAgLTE3NCw3ICsxNzQsNyBAQCBwdWJsaWM6CiAgICAgdm9p ZCBkZWZhdWx0S2V5Ym9hcmRFdmVudEhhbmRsZXIoS2V5Ym9hcmRFdmVudCopOwogCiAgICAgYm9v bCBoYW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5 aW5nRXZlbnQgPSAwLAotICAgICAgICBib29sIGlzTGluZUJyZWFrID0gZmFsc2UsIGJvb2wgaXNC YWNrVGFiID0gZmFsc2UpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCBpc0xp bmVCcmVhayA9IGZhbHNlLCBib29sIGlzQmFja1RhYiA9IGZhbHNlLCBib29sIGlzQ29tcG9zaXRp b24gPSBmYWxzZSk7CiAgICAgdm9pZCBkZWZhdWx0VGV4dElucHV0RXZlbnRIYW5kbGVyKFRleHRF dmVudCopOwogCiAjaWYgRU5BQkxFKERSQUdfU1VQUE9SVCkK 79240 2011-01-17 21:27:22 -0800 2011-01-19 20:24:47 -0800 Patch bug-5241-20110118142720.patch text/plain 33663 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA2ZGEzZTc5YmM4Njg5Y2E2YjE5Yjg3YTE2NDNiMTJlNjMwMWJmZjYwLi4yZTg5MjQ4 MTBmNjNkYzM2Y2VlNTA5MmFkY2VlNWE1MmNkYzQzMTJiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTMgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyNDEKKyAgICAgICAgCisgICAgICAgIEFkZGVk IGEgdGVzdCB0aGF0IGV4ZXJjaXNlcyBjb250aW5vdXMgd2hpdGVzcGFjZSBjaGFyYWN0ZXJzIGFu ZCB0YWJzIGluc2VydGVkIGJ5IElNRS4KKworICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbDog QWRkZWQuCisKIDIwMTEtMDEtMTYgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdo aXRlc3BhY2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQwODdjYTRjOTFlMzZmYmIzMTIxZDhi NDNjMmE2ZThiMGVjNzJiYzkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0OSBAQAorUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIMKgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBIMKgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDC oCDCoEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICfCoMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCBBQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAn wqDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKgQUInCitQQVNT IGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoCBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICdBQiDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoMKgJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKg IMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqAnCitQQVNTIGNvbXBv c2l0aW5nVGV4dCBpcyAnQUIgwqAgwqAgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfC oMKgQSDCoEIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoEEgwqBCIMKgJworUEFT UyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ0FCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICBCJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0FCICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICAgJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJyAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICBBQicKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgIEFC JworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICcgIEEgIEIgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcJCUEJCUIJCScKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICcgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICcKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lMDEyMTA0N2Q1ZWUyMjYwNDRmNjJjNjg5ZmI0OTZkZmVjYjgyODkyCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBv c2l0aW9uLXdoaXRlc3BhY2UuaHRtbApAQCAtMCwwICsxLDk3IEBACis8IURPQ1RZUEUgSFRNTCBQ VUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVs PSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxl LmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdD4KKwordmFyIHNlbCA9IGRvY3VtZW50 LmdldFNlbGVjdGlvbigpOwordmFyIHJvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJyb290 Iik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHJvb3QpOworCisKK2Z1bmN0aW9uIGNyZWF0 ZUVkaXRhYmxlKHRhZ05hbWUsIHRleHQpIHsKKyAgICB2YXIgbm9kZSA9IGRvY3VtZW50LmNyZWF0 ZUVsZW1lbnQodGFnTmFtZSk7CisgICAgbm9kZS5jb250ZW50RWRpdGFibGUgPSB0cnVlOworICAg IG5vZGUuaW5uZXJIVE1MID0gdGV4dDsKKyAgICByZXR1cm4gbm9kZTsKK30KKworZnVuY3Rpb24g dGVzdCh0YWdOYW1lLCBjb21wb3NpdGlvblRleHQsIGV4cGVjdGVkKSB7CisgICAgdmFyIG5vZGUg PSBjcmVhdGVFZGl0YWJsZSh0YWdOYW1lLCAiWCIpOworICAgIHJvb3QuYXBwZW5kQ2hpbGQobm9k ZSk7CisKKyAgICB2YXIgdGV4dE5vZGUgPSBub2RlLmZpcnN0Q2hpbGQ7CisgICAgc2VsLnNldEJh c2VBbmRFeHRlbnQodGV4dE5vZGUsIDAsIHRleHROb2RlLCB0ZXh0Tm9kZS5kYXRhLmxlbmd0aCk7 CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoIkRlbGV0ZSIsIGZhbHNlKTsKKworICAgIHRleHRJ bnB1dENvbnRyb2xsZXIuc2V0TWFya2VkVGV4dChjb21wb3NpdGlvblRleHQsIDAsIGNvbXBvc2l0 aW9uVGV4dCk7CisgICAgY29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisgICAgdGV4 dElucHV0Q29udHJvbGxlci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4dCA9IG5vZGUu aW5uZXJUZXh0OworCisgICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICInIiArIGV4cGVj dGVkICsgIiciKTsKK30KKwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJkaXYiLCAi QSBCIiwgIkEgQiIpOwordGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwordGVzdCgiZGl2 IiwgIkEgICBCIiwgIkEgXHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwgIkEgXHhBMCBc eEEwQiIpOyAKKwordGVzdCgiZGl2IiwgIiBBQiIsICJceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIg IEFCIiwgIlx4QTBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICBBQiIsICJceEEwXHhBMCBBQiIp OwordGVzdCgiZGl2IiwgIiAgICBBQiIsICJceEEwXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIs ICIgICAgIEFCIiwgIlx4QTBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICBBQiIs ICJceEEwXHhBMCBceEEwIFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgICAgICBBQiIsICJceEEw XHhBMCBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICJBQiAgIiwgIkFCIFx4QTAiKTsKK3Rl c3QoImRpdiIsICJBQiAgICIsICJBQiBceEEwXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICIs ICJBQiBceEEwIFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgIiwgIkFCIFx4QTAgXHhBMFx4 QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMCIpOwordGVz dCgiZGl2IiwgIkFCICAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMFx4QTAiKTsKKwordGVzdCgi ZGl2IiwgIiAgQSAgQiAgIiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7Cit0ZXN0KCJkaXYiLCAi XHRcdEFcdFx0Qlx0XHQiLCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKKwordGVzdCgiZGl2Iiwg IiAiLCAiXHhBMCIpOwordGVzdCgiZGl2IiwgIiAgIiwgIlx4QTBceEEwIik7Cit0ZXN0KCJkaXYi LCAiICAgIiwgIlx4QTBceEEwXHhBMCIpOworCit0ZXN0KCJwcmUiLCAiQUIiLCAiQUIiKTsKK3Rl c3QoInByZSIsICJBIEIiLCAiQSBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgQiIsICJBICBCIik7Cit0 ZXN0KCJwcmUiLCAiQSAgIEIiLCAiQSAgIEIiKTsKK3Rlc3QoInByZSIsICJBICAgIEIiLCAiQSAg ICBCIik7Cit0ZXN0KCJwcmUiLCAiQUIgICIsICJBQiAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAi LCAiQUIgICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAiLCAiQUIgICAgIik7Cit0ZXN0KCJwcmUi LCAiQUIgICAgICIsICJBQiAgICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAiLCAiQUIgICAg ICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAgICAiLCAiQUIgICAgICAgIik7Cit0ZXN0KCJwcmUi LCAiICBBQiIsICIgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgQUIiLCAiICAgQUIiKTsKK3Rlc3Qo InByZSIsICIgICAgQUIiLCAiICAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICBBQiIsICIgICAg IEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICAgQUIiLCAiICAgICAgQUIiKTsKK3Rlc3QoInByZSIs ICIgICAgICAgQUIiLCAiICAgICAgIEFCIik7CisKK3Rlc3QoInByZSIsICIgIEEgIEIgICIsICIg IEEgIEIgICIpOwordGVzdCgicHJlIiwgIlx0XHRBXHRcdEJcdFx0IiwgIlx0XHRBXHRcdEJcdFx0 Iik7Cit0ZXN0KCJwcmUiLCAiICIsICIgIik7Cit0ZXN0KCJwcmUiLCAiICAiLCAiICAiKTsKK3Rl c3QoInByZSIsICIgICAiLCAiICAgIik7CisKK3Jvb3Quc3R5bGUuZGlzcGxheSA9ICJub25lIjsK K3N1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CisKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA5MmIxMzY5NjU1M2YzYjJlODUx MWYyYmExZDFjMjEyNTA0YzM3OGFjLi4wZGJlZjgwZGI5OTI3MmU5ZTg1MGY4MDMwYjdiMWEyNTBk ZmM1N2I0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMS0w MS0xNyAgTU9SSVRBIEhhamltZSAgPG1vcnJpdGFAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTcGFjZSBhbmQgdGFiIGNoYXJhY3Rl cnMgInNlbnQiIGJ5IGFuIGlucHV0IG1ldGhvZCBnaXZlIHRvdGFsbHkgZGlmZmVyZW50IHJlc3Vs dHMgdGhhbiB0eXBpbmcgdGhlbSBkaXJlY3RseQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0MQorCisgICAgICAgICogd3RmL3RleHQvV1RGU3RyaW5n Lmg6CisgICAgICAgIChXVEY6OlN0cmluZzo6Y29udGFpbnNPbmx5V2hpdGVzcGFjZSk6IEFkZGVk IGEgd3JhcHBlciBmb3IgU3RyaW5nSW1wbDo6Y29udGFpbnNPbmx5V2hpdGVzcGFjZSgpCisKIDIw MTEtMDEtMTYgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBSdWJi ZXItc3RhbXBlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4 dC9XVEZTdHJpbmcuaAppbmRleCA0ZDg1M2QyZjQ4NzEwNjlkN2NhYjAwMGI1NGQ5NTE0MzMyNWJi ZGMzLi5lMWZmNTNhYWI2YjIyNzI3MTNhMzU2YjNiNjJiODAyZWEyMjU0ZTk1IDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oCkBAIC0zMjgsNiArMzI4LDcgQEAg cHVibGljOgogICAgIFdURjo6VW5pY29kZTo6RGlyZWN0aW9uIGRlZmF1bHRXcml0aW5nRGlyZWN0 aW9uKCkgY29uc3QgeyByZXR1cm4gbV9pbXBsID8gbV9pbXBsLT5kZWZhdWx0V3JpdGluZ0RpcmVj dGlvbigpIDogV1RGOjpVbmljb2RlOjpMZWZ0VG9SaWdodDsgfQogCiAgICAgYm9vbCBjb250YWlu c09ubHlBU0NJSSgpIGNvbnN0IHsgcmV0dXJuIGNoYXJhY3RlcnNBcmVBbGxBU0NJSShjaGFyYWN0 ZXJzKCksIGxlbmd0aCgpKTsgfQorICAgIGJvb2wgY29udGFpbnNPbmx5V2hpdGVzcGFjZSgpIGNv bnN0IHsgcmV0dXJuIG1faW1wbCA/IG1faW1wbC0+Y29udGFpbnNPbmx5V2hpdGVzcGFjZSgpIDog ZmFsc2U7IH0KIAogICAgIC8vIEhhc2ggdGFibGUgZGVsZXRlZCB2YWx1ZXMsIHdoaWNoIGFyZSBv bmx5IGNvbnN0cnVjdGVkIGFuZCBuZXZlciBjb3BpZWQgb3IgZGVzdHJveWVkLgogICAgIFN0cmlu ZyhXVEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZVR5cGUpIDogbV9pbXBsKFdURjo6SGFzaFRhYmxl RGVsZXRlZFZhbHVlKSB7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA3OWNiOGJhMzY2NGM2YmFkOTdlODgzNDNl ZjBkYWI4ODliNzE5OTZmLi5hMTE5ZjVmYjg0NWQ2MWU5YjUxYWRkNjA3Yzc0NjNhMzUyMWIzYjYw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDYgQEAKKzIwMTEtMDEtMTcgIE1PUklUQSBIYWppbWUg IDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBjaGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1 dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVudCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0g ZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTUyNDEKKyAgICAgICAgCisgICAgICAgICogSW50cm9kdWNlZCBUZXh0RXZlbnQ6OklucHV0VHlw ZUNvbXBvc2l0aW9uIGFuZCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25UeXBlIHRvIAor ICAgICAgICAgIGRpc3Rpbmd1aXNoIHRleHQgaW5wdXQgd2hpY2ggaXMgb3JpZ2luYXRlZCBieSBj b21wb3NpdGlvbi4KKyAgICAgICAgKiBHZW5lcmFsaXplZCByZWJhbGFuY2VXaGl0ZXNwYWNlQXQo KSB0byByZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKCkgdG8gcmViYWxhbmNpbmcg CisgICAgICAgICAgcmFuZ2Ugb2Ygc3RyaW5nIG9uIHRleHQgbm9kZSwgaW5zdGVhZCBvZiBzdXJy b3VuZGluZyBwYXJ0IG9mIHRoYXQuCisKKyAgICAgICAgVGVzdDogZWRpdGluZy9pbnNlcnRpbmcv aW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbAorCisgICAgICAgICogZG9tL1RleHRF dmVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUZXh0RXZlbnQ6OnNlbGVjdElucHV0VHlwZSk6 CisgICAgICAgICogZG9tL1RleHRFdmVudC5oOiBBZGRlZCBUZXh0RXZlbnQ6OklucHV0VHlwZUNv bXBvc2l0aW9uIGFzIGEgbWVtYmVyIG9mIFRleHRFdmVudDo6SW5wdXRUeXBlCisgICAgICAgIChX ZWJDb3JlOjpUZXh0RXZlbnQ6OmlzQ29tcG9zaXRpb24pOgorICAgICAgICAqIGVkaXRpbmcvQ29t cG9zaXRlRWRpdENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENv bW1hbmQ6OmNhblJlYmFsYW5jZSk6CisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29t bWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZUF0KTogUmVwbGFjZWQgd2l0aCByZWJhbGFuY2VXaGl0 ZXNwYWNlQmV0d2VlbigpCisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFuZDo6 cmViYWxhbmNlV2hpdGVzcGFjZU9uVGV4dFN1YnN0cmluZyk6IFRoZSBnZW5lcmFsaXplZCB2ZXJz aW9uIG9mIHJlYmFsYW5jZVdoaXRlc3BhY2VBdCgpLCB3aGljaCB0YWtlcyAyIHBvc2l0aW9uIGFz IGFyZ3VtZXRucy4KKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmg6Cisg ICAgICAgICogZWRpdGluZy9FZGl0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpp bnNlcnRUZXh0Rm9yQ29uZmlybWVkQ29tcG9zaXRpb24pOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmU6OkVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KToKKyAgICAgICAg KFdlYkNvcmU6OkVkaXRvcjo6Y29uZmlybUNvbXBvc2l0aW9uKTogTm93IHVzZXMgbnNlcnRUZXh0 Rm9yQ29uZmlybWVkQ29tcG9zaXRpb24oKQorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZXRD b21wb3NpdGlvbik6CisgICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0 aW5nL0luc2VydFRleHRDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydFRleHRD b21tYW5kOjppbnB1dCk6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oOgor ICAgICAgICAqIGVkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpU eXBpbmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0Nv bW1hbmQ6Omluc2VydFRleHQpOgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6aW5z ZXJ0VGV4dFJ1bldpdGhvdXROZXdsaW5lcyk6CisgICAgICAgICogZWRpdGluZy9UeXBpbmdDb21t YW5kLmg6IEFkZGVkIFR5cGluZ0NvbW1hbmQ6Om1fY29tcG9zaXRpb25UeXBlIGFuZCBUeXBpbmdD b21tYW5kOjpUZXh0Q29tcG9zaXRpb25UeXBlCisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21t YW5kOjpzZXRDb21wb3NpdGlvblR5cGUpOiBBZGRlZAorICAgICAgICAoV2ViQ29yZTo6VHlwaW5n Q29tbWFuZDo6Y3JlYXRlKToKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KToKKyAgICAg ICAgKiBwYWdlL0V2ZW50SGFuZGxlci5oOgorCiAyMDExLTAxLTE2ICBBZGFtIEJhcnRoICA8YWJh cnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgRXJpYyBTZWlkZWwu CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9UZXh0RXZlbnQuY3BwCmluZGV4IDY4ZWQ0YjI3MzNhMmJlMWRhNGQ5NjAyMDg1 YjA4YWM1NGUzYjliYjEuLjIyYWVlMDdkMWY5YmMwNGMzNGU2MGQ5NDQ1NGU0ZTU4MWI4MDlmZWQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuY3BwCkBAIC0zMSwxMiArMzEsMTQgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCi1UZXh0RXZlbnQ6OklucHV0VHlwZSBUZXh0RXZlbnQ6OnNlbGVjdElu cHV0VHlwZShib29sIGlzTGluZUJyZWFrLCBib29sIGlzQmFja1RhYikKK1RleHRFdmVudDo6SW5w dXRUeXBlIFRleHRFdmVudDo6c2VsZWN0SW5wdXRUeXBlKGJvb2wgaXNMaW5lQnJlYWssIGJvb2wg aXNCYWNrVGFiLCBib29sIGlzQ29tcG9zaXRpb24pCiB7CiAgICAgaWYgKGlzTGluZUJyZWFrKQog ICAgICAgICByZXR1cm4gVGV4dEV2ZW50OjpJbnB1dFR5cGVMaW5lQnJlYWs7CiAgICAgaWYgKGlz QmFja1RhYikKICAgICAgICAgcmV0dXJuIFRleHRFdmVudDo6SW5wdXRUeXBlQmFja1RhYjsKKyAg ICBpZiAoaXNDb21wb3NpdGlvbikKKyAgICAgICAgcmV0dXJuIFRleHRFdmVudDo6SW5wdXRUeXBl Q29tcG9zaXRpb247CiAgICAgcmV0dXJuIFRleHRFdmVudDo6SW5wdXRUeXBlS2V5Ym9hcmQ7CiB9 CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9UZXh0RXZlbnQuaAppbmRleCBmMWQyNGU5YzY4MTBmNTVhNDM2Y2VlNmQwNGFl M2RkNDEyYjc5NjI0Li5mZDNkOWY2YTRjNGFhNzBhOTdlMjk5NmFmNjE4N2Y3MGNmYjIxMGM3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmgKKysrIGIvU291cmNlL1dl YkNvcmUvZG9tL1RleHRFdmVudC5oCkBAIC0zNiwxMyArMzYsMTQgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgIHB1YmxpYzoKICAgICAgICAgZW51bSBJbnB1dFR5cGUgewogICAgICAgICAgICAg SW5wdXRUeXBlS2V5Ym9hcmQsIC8vIGFueSBuZXdsaW5lIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQg YXJlIGxpbmUgYnJlYWtzIG9ubHksIG5vdCBwYXJhZ3JhcGggc2VwYXJhdG9ycy4KKyAgICAgICAg ICAgIElucHV0VHlwZUNvbXBvc2l0aW9uLCAvLyBpbnB1dCBpcyBkb25lIGJ5IElNRS4KICAgICAg ICAgICAgIElucHV0VHlwZUxpbmVCcmVhaywgLy8gYW55IHRhYiBjaGFyYWN0ZXJzIGluIHRoZSB0 ZXh0IGFyZSBiYWNrdGFicy4KICAgICAgICAgICAgIElucHV0VHlwZUJhY2tUYWIsCiAgICAgICAg ICAgICBJbnB1dFR5cGVQYXN0ZSwKICAgICAgICAgICAgIElucHV0VHlwZURyb3AsCiAgICAgICAg IH07CiAKLSAgICAgICAgc3RhdGljIElucHV0VHlwZSBzZWxlY3RJbnB1dFR5cGUoYm9vbCBpc0xp bmVCcmVhaywgYm9vbCBpc0JhY2tUYWIpOworICAgICAgICBzdGF0aWMgSW5wdXRUeXBlIHNlbGVj dElucHV0VHlwZShib29sIGlzTGluZUJyZWFrLCBib29sIGlzQmFja1RhYiwgYm9vbCBpc0NvbXBv c2l0aW9uKTsKICAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8VGV4dEV2ZW50PiBjcmVhdGUoKTsK ICAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8VGV4dEV2ZW50PiBjcmVhdGUoUGFzc1JlZlB0cjxB YnN0cmFjdFZpZXc+IHZpZXcsIGNvbnN0IFN0cmluZyYgZGF0YSwgSW5wdXRUeXBlID0gSW5wdXRU eXBlS2V5Ym9hcmQpOwogICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxUZXh0RXZlbnQ+IGNyZWF0 ZUZvclBsYWluVGV4dFBhc3RlKFBhc3NSZWZQdHI8QWJzdHJhY3RWaWV3PiB2aWV3LCBjb25zdCBT dHJpbmcmIGRhdGEsIGJvb2wgc2hvdWxkU21hcnRSZXBsYWNlKTsKQEAgLTU3LDYgKzU4LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgYm9vbCBpc1RleHRFdmVudCgp IGNvbnN0OwogCisgICAgICAgIGJvb2wgaXNDb21wb3NpdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1f aW5wdXRUeXBlID09IElucHV0VHlwZUNvbXBvc2l0aW9uOyB9CiAgICAgICAgIGJvb2wgaXNMaW5l QnJlYWsoKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9PSBJbnB1dFR5cGVMaW5lQnJlYWs7 IH0KICAgICAgICAgYm9vbCBpc0JhY2tUYWIoKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9 PSBJbnB1dFR5cGVCYWNrVGFiOyB9CiAgICAgICAgIGJvb2wgaXNQYXN0ZSgpIGNvbnN0IHsgcmV0 dXJuIG1faW5wdXRUeXBlID09IElucHV0VHlwZVBhc3RlOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCmluZGV4IDllMWRmY2E1NThjZGE4OWZk ZWNhYTcxNGJlYTY4MjJiMDc5N2VlMDguLjE3NWUwZjBlOGI4NzZmZTczMDU4ZTk5NTkzNzhlNjAy ZTY1ZGVlYzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENv bW1hbmQuY3BwCkBAIC0zOTUsNTIgKzM5NSw1OCBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaXNXaGl0 ZXNwYWNlKFVDaGFyIGMpCiAgICAgcmV0dXJuIGMgPT0gbm9CcmVha1NwYWNlIHx8IGMgPT0gJyAn IHx8IGMgPT0gJ1xuJyB8fCBjID09ICdcdCc7CiB9CiAKLS8vIEZJWE1FOiBEb2Vzbid0IGdvIGlu dG8gdGV4dCBub2RlcyB0aGF0IGNvbnRyaWJ1dGUgYWRqYWNlbnQgdGV4dCAoc2libGluZ3MsIGNv dXNpbnMsIGV0YykuCi12b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNw YWNlQXQoY29uc3QgUG9zaXRpb24mIHBvc2l0aW9uKQorYm9vbCBDb21wb3NpdGVFZGl0Q29tbWFu ZDo6Y2FuUmViYWxhbmNlKGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlvbikgY29uc3QKIHsKICAgICBO b2RlKiBub2RlID0gcG9zaXRpb24uY29udGFpbmVyTm9kZSgpOwogICAgIGlmIChwb3NpdGlvbi5h bmNob3JUeXBlKCkgIT0gUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvciB8fCAhbm9k ZSB8fCAhbm9kZS0+aXNUZXh0Tm9kZSgpKQotICAgICAgICByZXR1cm47Ci0gICAgVGV4dCogdGV4 dE5vZGUgPSBzdGF0aWNfY2FzdDxUZXh0Kj4obm9kZSk7CisgICAgICAgIHJldHVybiBmYWxzZTsK IAorICAgIFRleHQqIHRleHROb2RlID0gc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpOwogICAgIGlm ICh0ZXh0Tm9kZS0+bGVuZ3RoKCkgPT0gMCkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1 cm4gZmFsc2U7CisKICAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gdGV4dE5vZGUtPnJlbmRl cmVyKCk7CiAgICAgaWYgKHJlbmRlcmVyICYmICFyZW5kZXJlci0+c3R5bGUoKS0+Y29sbGFwc2VX aGl0ZVNwYWNlKCkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgcmV0dXJuIHRydWU7Cit9CiAKKy8vIEZJWE1FOiBEb2Vzbid0IGdvIGludG8gdGV4dCBub2Rl cyB0aGF0IGNvbnRyaWJ1dGUgYWRqYWNlbnQgdGV4dCAoc2libGluZ3MsIGNvdXNpbnMsIGV0Yyku Cit2b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQXQoY29uc3Qg UG9zaXRpb24mIHBvc2l0aW9uKQoreworICAgIE5vZGUqIG5vZGUgPSBwb3NpdGlvbi5jb250YWlu ZXJOb2RlKCk7CisgICAgaWYgKGNhblJlYmFsYW5jZShwb3NpdGlvbikpCisgICAgICAgIHJlYmFs YW5jZVdoaXRlc3BhY2VPblRleHRTdWJzdHJpbmcoc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpLCBw b3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpLCBwb3NpdGlvbi5kZXByZWNhdGVkRWRp dGluZ09mZnNldCgpKTsKK30KKwordm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNl V2hpdGVzcGFjZU9uVGV4dFN1YnN0cmluZyhSZWZQdHI8VGV4dD4gdGV4dE5vZGUsIGludCBzdGFy dE9mZnNldCwgaW50IGVuZE9mZnNldCkKK3sKICAgICBTdHJpbmcgdGV4dCA9IHRleHROb2RlLT5k YXRhKCk7CiAgICAgQVNTRVJUKCF0ZXh0LmlzRW1wdHkoKSk7CiAKLSAgICBpbnQgb2Zmc2V0ID0g cG9zaXRpb24uZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKTsKLSAgICAvLyBJZiBuZWl0aGVyIHRl eHRbb2Zmc2V0XSBub3IgdGV4dFtvZmZzZXQgLSAxXSBhcmUgc29tZSBmb3JtIG9mIHdoaXRlc3Bh Y2UsIGRvIG5vdGhpbmcuCi0gICAgaWYgKCFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkgewot ICAgICAgICBvZmZzZXQtLTsKLSAgICAgICAgaWYgKG9mZnNldCA8IDAgfHwgIWlzV2hpdGVzcGFj ZSh0ZXh0W29mZnNldF0pKQotICAgICAgICAgICAgcmV0dXJuOwotICAgIH0KLSAgICAKICAgICAv LyBTZXQgdXBzdHJlYW0gYW5kIGRvd25zdHJlYW0gdG8gZGVmaW5lIHRoZSBleHRlbnQgb2YgdGhl IHdoaXRlc3BhY2Ugc3Vycm91bmRpbmcgdGV4dFtvZmZzZXRdLgotICAgIGludCB1cHN0cmVhbSA9 IG9mZnNldDsKKyAgICBpbnQgdXBzdHJlYW0gPSBzdGFydE9mZnNldDsKICAgICB3aGlsZSAodXBz dHJlYW0gPiAwICYmIGlzV2hpdGVzcGFjZSh0ZXh0W3Vwc3RyZWFtIC0gMV0pKQogICAgICAgICB1 cHN0cmVhbS0tOwogICAgIAotICAgIGludCBkb3duc3RyZWFtID0gb2Zmc2V0OwotICAgIHdoaWxl ICgodW5zaWduZWQpZG93bnN0cmVhbSArIDEgPCB0ZXh0Lmxlbmd0aCgpICYmIGlzV2hpdGVzcGFj ZSh0ZXh0W2Rvd25zdHJlYW0gKyAxXSkpCisgICAgaW50IGRvd25zdHJlYW0gPSBlbmRPZmZzZXQ7 CisgICAgd2hpbGUgKCh1bnNpZ25lZClkb3duc3RyZWFtIDwgdGV4dC5sZW5ndGgoKSAmJiBpc1do aXRlc3BhY2UodGV4dFtkb3duc3RyZWFtXSkpCiAgICAgICAgIGRvd25zdHJlYW0rKzsKICAgICAK LSAgICBpbnQgbGVuZ3RoID0gZG93bnN0cmVhbSAtIHVwc3RyZWFtICsgMTsKLSAgICBBU1NFUlQo bGVuZ3RoID4gMCk7Ci0gICAgCi0gICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVVcHN0cmVhbVBv cyhQb3NpdGlvbihwb3NpdGlvbi5jb250YWluZXJOb2RlKCksIHVwc3RyZWFtLCBQb3NpdGlvbjo6 UG9zaXRpb25Jc09mZnNldEluQW5jaG9yKSk7Ci0gICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVE b3duc3RyZWFtUG9zKFBvc2l0aW9uKHBvc2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgZG93bnN0cmVh bSArIDEsIFBvc2l0aW9uOjpQb3NpdGlvbklzT2Zmc2V0SW5BbmNob3IpKTsKKyAgICBpbnQgbGVu Z3RoID0gZG93bnN0cmVhbSAtIHVwc3RyZWFtOworICAgIGlmICghbGVuZ3RoKQorICAgICAgICBy ZXR1cm47CisKKyAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0aW9u KHRleHROb2RlLCB1cHN0cmVhbSwgUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikp OworICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxlRG93bnN0cmVhbVBvcyhQb3NpdGlvbih0ZXh0 Tm9kZSwgZG93bnN0cmVhbSwgUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOwog ICAgIAogICAgIFN0cmluZyBzdHJpbmcgPSB0ZXh0LnN1YnN0cmluZyh1cHN0cmVhbSwgbGVuZ3Ro KTsKICAgICBTdHJpbmcgcmViYWxhbmNlZFN0cmluZyA9IHN0cmluZ1dpdGhSZWJhbGFuY2VkV2hp dGVzcGFjZShzdHJpbmcsCiAgICAgLy8gRklYTUU6IEJlY2F1c2Ugb2YgdGhlIHByb2JsZW0gbWVu dGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhpcyBmdW5jdGlvbiwgd2UgbXVzdCBhbHNvIHVzZSBuYnNw cyBhdCB0aGUgc3RhcnQvZW5kIG9mIHRoZSBzdHJpbmcgYmVjYXVzZQogICAgIC8vIHRoaXMgZnVu Y3Rpb24gZG9lc24ndCBnZXQgYWxsIHN1cnJvdW5kaW5nIHdoaXRlc3BhY2UsIGp1c3QgdGhlIHdo aXRlc3BhY2UgaW4gdGhlIGN1cnJlbnQgdGV4dCBub2RlLgogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlzU3RhcnRPZlBhcmFncmFw aCh2aXNpYmxlVXBzdHJlYW1Qb3MpIHx8IHVwc3RyZWFtID09IDAsIAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlzRW5kT2ZQYXJh Z3JhcGgodmlzaWJsZURvd25zdHJlYW1Qb3MpIHx8ICh1bnNpZ25lZClkb3duc3RyZWFtID09IHRl eHQubGVuZ3RoKCkgLSAxKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBpc0VuZE9mUGFyYWdyYXBoKHZpc2libGVEb3duc3RyZWFt UG9zKSB8fCAodW5zaWduZWQpZG93bnN0cmVhbSA9PSB0ZXh0Lmxlbmd0aCgpKTsKICAgICAKICAg ICBpZiAoc3RyaW5nICE9IHJlYmFsYW5jZWRTdHJpbmcpCiAgICAgICAgIHJlcGxhY2VUZXh0SW5O b2RlKHRleHROb2RlLCB1cHN0cmVhbSwgbGVuZ3RoLCByZWJhbGFuY2VkU3RyaW5nKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAppbmRleCA2ZGI0ZWIx ODJhMDg4NmFkMWZkODBiMDRlOGMxYzZmMzYxY2IwMzAwLi45MmY4NDI3ZmMwN2FmZjdhOTU2OWFk YmJkMDkxNmEyZDMyYjkyODk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Nv bXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3Np dGVFZGl0Q29tbWFuZC5oCkBAIC03MSw3ICs3MSw5IEBAIHByb3RlY3RlZDoKICAgICB2b2lkIG1l cmdlSWRlbnRpY2FsRWxlbWVudHMoUGFzc1JlZlB0cjxFbGVtZW50PiwgUGFzc1JlZlB0cjxFbGVt ZW50Pik7CiAgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlKCk7CiAgICAgdm9pZCByZWJhbGFu Y2VXaGl0ZXNwYWNlQXQoY29uc3QgUG9zaXRpb24mKTsKKyAgICB2b2lkIHJlYmFsYW5jZVdoaXRl c3BhY2VPblRleHRTdWJzdHJpbmcoUmVmUHRyPFRleHQ+LCBpbnQgc3RhcnRPZmZzZXQsIGludCBl bmRPZmZzZXQpOwogICAgIHZvaWQgcHJlcGFyZVdoaXRlc3BhY2VBdFBvc2l0aW9uRm9yU3BsaXQo UG9zaXRpb24mKTsKKyAgICBib29sIGNhblJlYmFsYW5jZShjb25zdCBQb3NpdGlvbiYpIGNvbnN0 OwogICAgIHZvaWQgcmVtb3ZlQ1NTUHJvcGVydHkoUGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50Piwg Q1NTUHJvcGVydHlJRCk7CiAgICAgdm9pZCByZW1vdmVOb2RlQXR0cmlidXRlKFBhc3NSZWZQdHI8 RWxlbWVudD4sIGNvbnN0IFF1YWxpZmllZE5hbWUmIGF0dHJpYnV0ZSk7CiAgICAgdm9pZCByZW1v dmVDaGlsZHJlbkluUmFuZ2UoUGFzc1JlZlB0cjxOb2RlPiwgdW5zaWduZWQgZnJvbSwgdW5zaWdu ZWQgdG8pOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IGJlYTc0ZDk2MTIwZDFhMzhm ZDY4ODRhNjIyNzFmY2NhZWVhNmRjZTIuLjFiMjZmM2UxNGVmNmYwMzg3ZTQ3YWU0M2FmOWFmZGZm Mjg5YTE2NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTExNzMsNyArMTE3Mywx MiBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB0 cmlnZ2VyaW5nRXZlbnQpCiAgICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5oYW5k bGVUZXh0SW5wdXRFdmVudCh0ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwogfQogCi1ib29sIEVkaXRv cjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCitib29sIEVk aXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4 dCkKK3sKKyAgICByZXR1cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhhbmRsZVRleHRJbnB1 dEV2ZW50KHRleHQsIDAsIGZhbHNlLCBmYWxzZSwgdHJ1ZSk7Cit9CisKK2Jvb2wgRWRpdG9yOjpp bnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29s IHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCiB7CiAgICAg aWYgKHRleHQuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xMTk1LDcgKzEy MDAsOCBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNv bnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbgogICAgICAgICAgICAgUmVmUHRyPERvY3Vt ZW50PiBkb2N1bWVudCA9IHNlbGVjdGlvblN0YXJ0LT5kb2N1bWVudCgpOwogICAgICAgICAgICAg CiAgICAgICAgICAgICAvLyBJbnNlcnQgdGhlIHRleHQKLSAgICAgICAgICAgIFR5cGluZ0NvbW1h bmQ6Omluc2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5z ZXJ0ZWRUZXh0KTsKKyAgICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoZG9jdW1l bnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJpZ2dlcmluZ0V2ZW50ICYmIHRyaWdnZXJp bmdFdmVudC0+aXNDb21wb3NpdGlvbigpID8gVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9u Q29uZmlybSA6IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbk5vbmUpOwogCiAgICAgICAg ICAgICAvLyBSZXZlYWwgdGhlIGN1cnJlbnQgc2VsZWN0aW9uIAogICAgICAgICAgICAgaWYgKEZy YW1lKiBlZGl0ZWRGcmFtZSA9IGRvY3VtZW50LT5mcmFtZSgpKQpAQCAtMTYxOCw3ICsxNjI0LDcg QEAgdm9pZCBFZGl0b3I6OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQsIGJv b2wgcHJlc2VydmVTZWxlY3Rpb24pCiAgICAgbV9jb21wb3NpdGlvbk5vZGUgPSAwOwogICAgIG1f Y3VzdG9tQ29tcG9zaXRpb25VbmRlcmxpbmVzLmNsZWFyKCk7CiAKLSAgICBpbnNlcnRUZXh0KHRl eHQsIDApOworICAgIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbih0ZXh0KTsKIAog ICAgIGlmIChwcmVzZXJ2ZVNlbGVjdGlvbikgewogICAgICAgICBtX2ZyYW1lLT5zZWxlY3Rpb24o KS0+c2V0U2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgZmFsc2UsIGZhbHNlKTsKQEAgLTE2ODcsNyAr MTY5Myw3IEBAIHZvaWQgRWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQs IGNvbnN0IFZlY3RvcjxDb21wb3NpdGlvblVuZGVybGluCiAgICAgbV9jdXN0b21Db21wb3NpdGlv blVuZGVybGluZXMuY2xlYXIoKTsKIAogICAgIGlmICghdGV4dC5pc0VtcHR5KCkpIHsKLSAgICAg ICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0LCB0 cnVlLCB0cnVlKTsKKyAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5k b2N1bWVudCgpLCB0ZXh0LCB0cnVlLCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25VcGRh dGUpOwogCiAgICAgICAgIC8vIEZpbmQgb3V0IHdoYXQgbm9kZSBoYXMgdGhlIGNvbXBvc2l0aW9u IG5vdy4KICAgICAgICAgUG9zaXRpb24gYmFzZSA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5iYXNl KCkuZG93bnN0cmVhbSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKaW5kZXggMmU2MWNlNjdkMTgx ODVhNjZhOTI4MDFkNmI3YTk1YTQ3ODk0NmVjOS4uMWU2ZTM4NzNmNWRjOGRlZjJkMGQyMGEwMGNi MTMzMzhhOWMwOWE5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3Iu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0xOTgsNyArMTk4LDgg QEAgcHVibGljOgogICAgIHN0YXRpYyBib29sIGNvbW1hbmRJc1N1cHBvcnRlZEZyb21NZW51T3JL ZXlCaW5kaW5nKGNvbnN0IFN0cmluZyYgY29tbWFuZE5hbWUpOyAvLyBXb3JrcyB3aXRob3V0IGEg ZnJhbWUuCiAKICAgICBib29sIGluc2VydFRleHQoY29uc3QgU3RyaW5nJiwgRXZlbnQqIHRyaWdn ZXJpbmdFdmVudCk7Ci0gICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQo Y29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5n RXZlbnQpOworICAgIGJvb2wgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0 IFN0cmluZyYgdGV4dCk7CisgICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZl bnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRFdmVudCogdHJp Z2dlcmluZ0V2ZW50KTsKICAgICBib29sIGluc2VydExpbmVCcmVhaygpOwogICAgIGJvb2wgaW5z ZXJ0UGFyYWdyYXBoU2VwYXJhdG9yKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv SW5zZXJ0VGV4dENvbW1hbmQuY3BwCmluZGV4IGZjMThlOTEyZjk1MzYzNmFmYjI3MTZmMGMxNjIz ZDUwOTA2ODlmNWQuLjU5M2JhOTc3ZDNmMGZkNzkwYTQwYzdhOGYyODk4MWJmYmM5OGQyMzMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCkBAIC0xMDYs NyArMTA2LDcgQEAgYm9vbCBJbnNlcnRUZXh0Q29tbWFuZDo6cGVyZm9ybVRyaXZpYWxSZXBsYWNl KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnMKICAgICByZXR1cm4gdHJ1ZTsKIH0K IAotdm9pZCBJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29s IHNlbGVjdEluc2VydGVkVGV4dCkKK3ZvaWQgSW5zZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNvbnN0 IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFJlYmFsYW5jZVR5cGUgd2hp dGVzcGFjZVJlYmFsYW5jZSkKIHsKICAgICAKICAgICBBU1NFUlQodGV4dC5maW5kKCdcbicpID09 IG5vdEZvdW5kKTsKQEAgLTE3MiwxMSArMTcyLDE3IEBAIHZvaWQgSW5zZXJ0VGV4dENvbW1hbmQ6 OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQpCiAgICAg ICAgIGluc2VydFRleHRJbnRvTm9kZSh0ZXh0Tm9kZSwgb2Zmc2V0LCB0ZXh0KTsKICAgICAgICAg ZW5kUG9zaXRpb24gPSBQb3NpdGlvbih0ZXh0Tm9kZSwgb2Zmc2V0ICsgdGV4dC5sZW5ndGgoKSk7 CiAKLSAgICAgICAgLy8gVGhlIGluc2VydGlvbiBtYXkgcmVxdWlyZSBhZGp1c3RpbmcgYWRqYWNl bnQgd2hpdGVzcGFjZSwgaWYgaXQgaXMgcHJlc2VudC4KLSAgICAgICAgcmViYWxhbmNlV2hpdGVz cGFjZUF0KGVuZFBvc2l0aW9uKTsKLSAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBzaWRl cyBpc24ndCBuZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFjZS4KLSAgICAgICAgaWYg KHRleHQgIT0gIiAiKSAKLSAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChzdGFydFBv c2l0aW9uKTsKKyAgICAgICAgaWYgKHdoaXRlc3BhY2VSZWJhbGFuY2UgPT0gUmViYWxhbmNlTGVh ZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpIHsKKyAgICAgICAgICAgIC8vIFRoZSBpbnNlcnRp b24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdoaXRlc3BhY2UsIGlmIGl0IGlzIHBy ZXNlbnQuCisgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoZW5kUG9zaXRpb24pOwor ICAgICAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBzaWRlcyBpc24ndCBuZWNlc3Nhcnkg aWYgd2UndmUgaW5zZXJ0ZWQgb2xseSBzcGFjZXMuCisgICAgICAgICAgICBpZiAoIXRleHQuY29u dGFpbnNPbmx5V2hpdGVzcGFjZSgpKQorICAgICAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRlc3Bh Y2VBdChzdGFydFBvc2l0aW9uKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIEFTU0VS VCh3aGl0ZXNwYWNlUmViYWxhbmNlID09IFJlYmFsYW5jZUFsbFdoaXRlc3BhY2VzKTsKKyAgICAg ICAgICAgIGlmIChjYW5SZWJhbGFuY2Uoc3RhcnRQb3NpdGlvbikgJiYgY2FuUmViYWxhbmNlKGVu ZFBvc2l0aW9uKSkKKyAgICAgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vi c3RyaW5nKHRleHROb2RlLCBzdGFydFBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCks IGVuZFBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCkpOworICAgICAgICB9CiAgICAg fQogCiAgICAgLy8gV2UgY291bGQgaGF2ZSBpbnNlcnRlZCBhIHBhcnQgb2YgY29tcG9zZWQgY2hh cmFjdGVyIHNlcXVlbmNlLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNl cnRUZXh0Q29tbWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFu ZC5oCmluZGV4IDc3YWUwMTZkMzZhMTRmYjFmODE0OWRmN2FhMzQxMmNkZWMxZDIyZGUuLjY3MmU1 NzZmOTIwNzlhNWNmOTc3YWU1Y2Y4YTI0YmQ5YzI3ZmE0YzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmgKQEAgLTMyLDE0ICszMiwyMCBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKIGNsYXNzIEluc2VydFRleHRDb21tYW5kIDogcHVibGljIENvbXBvc2l0ZUVk aXRDb21tYW5kIHsKIHB1YmxpYzoKKyAgICBlbnVtIFJlYmFsYW5jZVR5cGUgeworICAgICAgICBS ZWJhbGFuY2VMZWFkaW5nQW5kVHJhaWxpbmdXaGl0ZXNwYWNlcywKKyAgICAgICAgUmViYWxhbmNl QWxsV2hpdGVzcGFjZXMKKyAgICB9OworCiAgICAgc3RhdGljIFBhc3NSZWZQdHI8SW5zZXJ0VGV4 dENvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgewogICAgICAgICByZXR1 cm4gYWRvcHRSZWYobmV3IEluc2VydFRleHRDb21tYW5kKGRvY3VtZW50KSk7CiAgICAgfQogCi0g ICAgdm9pZCBpbnB1dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0 ID0gZmFsc2UpOworICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVj dEluc2VydGVkVGV4dCA9IGZhbHNlLCBSZWJhbGFuY2VUeXBlID0gUmViYWxhbmNlTGVhZGluZ0Fu ZFRyYWlsaW5nV2hpdGVzcGFjZXMpOwogCiBwcml2YXRlOgorCiAgICAgSW5zZXJ0VGV4dENvbW1h bmQoRG9jdW1lbnQqKTsKIAogICAgIHZvaWQgZGVsZXRlQ2hhcmFjdGVyKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcAppbmRleCBkNTRiMzg4NWJmOThmZTUyYmQ5YTY1 YzU0YThkNzFkOTY3NjA3ZTlkLi4yMWQ0MzE0YWQwNzU0OGEwOGM5ODI3YjBmMTU1Yjk5YWIyMjhi NjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKQEAgLTQ3LDcg KzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVz OwogCi1UeXBpbmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwgRVR5 cGluZ0NvbW1hbmQgY29tbWFuZFR5cGUsIGNvbnN0IFN0cmluZyAmdGV4dFRvSW5zZXJ0LCBib29s IHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5LCBib29sIGtp bGxSaW5nKQorVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZChEb2N1bWVudCAqZG9jdW1lbnQs IEVUeXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBTdHJpbmcgJnRleHRUb0luc2VydCwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSwgVGV4 dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGJvb2wga2lsbFJpbmcpCiAgICAgOiBDb21wb3NpdGVFZGl0Q29tbWFuZChkb2N1bWVu dCksIAogICAgICAgbV9jb21tYW5kVHlwZShjb21tYW5kVHlwZSksIAogICAgICAgbV90ZXh0VG9J bnNlcnQodGV4dFRvSW5zZXJ0KSwgCkBAIC01NSw2ICs1Niw3IEBAIFR5cGluZ0NvbW1hbmQ6OlR5 cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRvY3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kVHlw ZSwgY29uCiAgICAgICBtX3NlbGVjdEluc2VydGVkVGV4dChzZWxlY3RJbnNlcnRlZFRleHQpLAog ICAgICAgbV9zbWFydERlbGV0ZShmYWxzZSksCiAgICAgICBtX2dyYW51bGFyaXR5KGdyYW51bGFy aXR5KSwKKyAgICAgIG1fY29tcG9zaXRpb25UeXBlKGNvbXBvc2l0aW9uVHlwZSksCiAgICAgICBt X2tpbGxSaW5nKGtpbGxSaW5nKSwKICAgICAgIG1fb3BlbmVkQnlCYWNrd2FyZERlbGV0ZShmYWxz ZSkKIHsKQEAgLTEzMywxOCArMTM1LDE4IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6dXBkYXRlU2Vs ZWN0aW9uSWZEaWZmZXJlbnRGcm9tQ3VycmVudFNlbGVjdGlvbihUeXBpbmdDb21tYW5kCiB9CiAg ICAgCiAKLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQs IGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIGJvb2wgaW5zZXJ0 ZWRUZXh0SXNDb21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRl eHQsIFRleHRDb21wb3NpdGlvblR5cGUgY29tcG9zaXRpb24pCiB7CiAgICAgQVNTRVJUKGRvY3Vt ZW50KTsKICAgICAKICAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKICAgICBB U1NFUlQoZnJhbWUpOwogCi0gICAgaW5zZXJ0VGV4dChkb2N1bWVudCwgdGV4dCwgZnJhbWUtPnNl bGVjdGlvbigpLT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBpbnNlcnRlZFRleHRJ c0NvbXBvc2l0aW9uKTsKKyAgICBpbnNlcnRUZXh0KGRvY3VtZW50LCB0ZXh0LCBmcmFtZS0+c2Vs ZWN0aW9uKCktPnNlbGVjdGlvbigpLCBzZWxlY3RJbnNlcnRlZFRleHQsIGNvbXBvc2l0aW9uKTsK IH0KIAogLy8gRklYTUU6IFdlIHNob3VsZG4ndCBuZWVkIHRvIHRha2Ugc2VsZWN0aW9uRm9ySW5z ZXJ0aW9uLiBJdCBzaG91bGQgYmUgaWRlbnRpY2FsIHRvIFNlbGVjdGlvbkNvbnRyb2xsZXIncyBj dXJyZW50IHNlbGVjdGlvbi4KLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVu dCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYg c2VsZWN0aW9uRm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgYm9vbCBpbnNl cnRlZFRleHRJc0NvbXBvc2l0aW9uKQordm9pZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KERv Y3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBWaXNpYmxlU2VsZWN0 aW9uJiBzZWxlY3Rpb25Gb3JJbnNlcnRpb24sIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0 Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uVHlwZSkKIHsKICNpZiBSRU1PVkVfTUFSS0VSU19V UE9OX0VESVRJTkcKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKQpAQCAtMTYxLDcgKzE2Myw3IEBA IHZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0 IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzCiAgICAgU3RyaW5nIG5ld1RleHQgPSB0ZXh0OwogICAg IE5vZGUqIHN0YXJ0Tm9kZSA9IHNlbGVjdGlvbkZvckluc2VydGlvbi5zdGFydCgpLm5vZGUoKTsK ICAgICAKLSAgICBpZiAoc3RhcnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxlbWVu dCgpICYmICFpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKSB7ICAgICAgICAKKyAgICBpZiAoc3Rh cnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpICYmIGNvbXBvc2l0aW9u VHlwZSAhPSBUZXh0Q29tcG9zaXRpb25VcGRhdGUpIHsKICAgICAgICAgLy8gU2VuZCBCZWZvcmVU ZXh0SW5zZXJ0ZWRFdmVudC4gVGhlIGV2ZW50IGhhbmRsZXIgd2lsbCB1cGRhdGUgdGV4dCBpZiBu ZWNlc3NhcnkuCiAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgICAgICBSZWZQdHI8 QmVmb3JlVGV4dEluc2VydGVkRXZlbnQ+IGV2dCA9IEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50Ojpj cmVhdGUodGV4dCk7CkBAIC0xODIsMTEgKzE4NCwxMyBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6Omlu c2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZp cwogICAgICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNldFN0YXJ0aW5nU2VsZWN0aW9uKHNl bGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+c2V0 RW5kaW5nU2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgIH0KKyAgICAg ICAgCisgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRDb21wb3NpdGlvblR5cGUoY29tcG9z aXRpb25UeXBlKTsKICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPmluc2VydFRleHQobmV3VGV4 dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIFJl ZlB0cjxUeXBpbmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21tYW5kOjpjcmVhdGUoZG9jdW1lbnQs IEluc2VydFRleHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CisgICAgUmVmUHRyPFR5 cGluZ0NvbW1hbmQ+IGNtZCA9IFR5cGluZ0NvbW1hbmQ6OmNyZWF0ZShkb2N1bWVudCwgSW5zZXJ0 VGV4dCwgbmV3VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBjb21wb3NpdGlvblR5cGUpOwogICAg IGlmIChjaGFuZ2VTZWxlY3Rpb24pICB7CiAgICAgICAgIGNtZC0+c2V0U3RhcnRpbmdTZWxlY3Rp b24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKICAgICAgICAgY21kLT5zZXRFbmRpbmdTZWxlY3Rp b24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKQEAgLTM4Niw3ICszOTAsOCBAQCB2b2lkIFR5cGlu Z0NvbW1hbmQ6Omluc2VydFRleHRSdW5XaXRob3V0TmV3bGluZXMoY29uc3QgU3RyaW5nICZ0ZXh0 LCBib29sIHNlbGVjdAogICAgICAgICBjb21tYW5kLT5zZXRTdGFydGluZ1NlbGVjdGlvbihlbmRp bmdTZWxlY3Rpb24oKSk7CiAgICAgICAgIGNvbW1hbmQtPnNldEVuZGluZ1NlbGVjdGlvbihlbmRp bmdTZWxlY3Rpb24oKSk7CiAgICAgfQotICAgIGNvbW1hbmQtPmlucHV0KHRleHQsIHNlbGVjdElu c2VydGVkVGV4dCk7CisgICAgY29tbWFuZC0+aW5wdXQodGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0 LCAKKyAgICAgICAgICAgICAgICAgICBtX2NvbXBvc2l0aW9uVHlwZSA9PSBUZXh0Q29tcG9zaXRp b25Ob25lID8gSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUxlYWRpbmdBbmRUcmFpbGluZ1do aXRlc3BhY2VzIDogSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5jZUFsbFdoaXRlc3BhY2VzKTsK ICAgICB0eXBpbmdBZGRlZFRvT3BlbkNvbW1hbmQoSW5zZXJ0VGV4dCk7CiB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKaW5kZXggMjg0ZWJjMGFjMjY1ZDc2YjE2YTgwYmYy NjExYzdhODBlNjgwYWQwZi4uYjM0YmRjMTIyMWEyMmEzMDEyNGE5MDg4MDEwYzA1NDY1MWJmZGU2 ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKKysr IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKQEAgLTQyLDExICs0Miwx NyBAQCBwdWJsaWM6CiAgICAgICAgIEluc2VydFBhcmFncmFwaFNlcGFyYXRvckluUXVvdGVkQ29u dGVudAogICAgIH07CiAKKyAgICBlbnVtIFRleHRDb21wb3NpdGlvblR5cGUgeworICAgICAgICBU ZXh0Q29tcG9zaXRpb25Ob25lLAorICAgICAgICBUZXh0Q29tcG9zaXRpb25VcGRhdGUsCisgICAg ICAgIFRleHRDb21wb3NpdGlvbkNvbmZpcm0KKyAgICB9OworCiAgICAgc3RhdGljIHZvaWQgZGVs ZXRlU2VsZWN0aW9uKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0ZSA9IGZhbHNlKTsKICAgICBz dGF0aWMgdm9pZCBkZWxldGVLZXlQcmVzc2VkKERvY3VtZW50KiwgYm9vbCBzbWFydERlbGV0ZSA9 IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBraWxs UmluZyA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9pZCBmb3J3YXJkRGVsZXRlS2V5UHJlc3NlZChE b2N1bWVudCosIGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hh cmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBmYWxzZSk7Ci0gICAgc3RhdGljIHZv aWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0 ZWRUZXh0ID0gZmFsc2UsIGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNlKTsK LSAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UsIGJv b2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNlKTsKKyAgICBzdGF0aWMgdm9pZCBp bnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRl eHQgPSBmYWxzZSwgVGV4dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUpOwor ICAgIHN0YXRpYyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBjb25z dCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgVGV4 dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5vbmUpOwogICAgIHN0YXRpYyB2b2lk IGluc2VydExpbmVCcmVhayhEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBhcmFn cmFwaFNlcGFyYXRvcihEb2N1bWVudCopOwogICAgIHN0YXRpYyB2b2lkIGluc2VydFBhcmFncmFw aFNlcGFyYXRvckluUXVvdGVkQ29udGVudChEb2N1bWVudCopOwpAQCAtNjQsMTQgKzcwLDIwIEBA IHB1YmxpYzoKICAgICB2b2lkIGRlbGV0ZUtleVByZXNzZWQoVGV4dEdyYW51bGFyaXR5LCBib29s IGtpbGxSaW5nKTsKICAgICB2b2lkIGZvcndhcmREZWxldGVLZXlQcmVzc2VkKFRleHRHcmFudWxh cml0eSwgYm9vbCBraWxsUmluZyk7CiAgICAgdm9pZCBkZWxldGVTZWxlY3Rpb24oYm9vbCBzbWFy dERlbGV0ZSk7CisgICAgdm9pZCBzZXRDb21wb3NpdGlvblR5cGUoVGV4dENvbXBvc2l0aW9uVHlw ZSB0eXBlKSB7IG1fY29tcG9zaXRpb25UeXBlID0gdHlwZTsgfQogCiBwcml2YXRlOgogICAgIHN0 YXRpYyBQYXNzUmVmUHRyPFR5cGluZ0NvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQs IEVUeXBpbmdDb21tYW5kIGNvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4dCA9ICIiLCBib29sIHNl bGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkgPSBD aGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9IGZhbHNlKQogICAgIHsKLSAgICAg ICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5kLCB0 ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5LCBraWxsUmluZykpOworICAgICAg ICByZXR1cm4gYWRvcHRSZWYobmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRl eHQsIHNlbGVjdEluc2VydGVkVGV4dCwgZ3JhbnVsYXJpdHksIFRleHRDb21wb3NpdGlvbk5vbmUs IGtpbGxSaW5nKSk7CisgICAgfQorCisgICAgc3RhdGljIFBhc3NSZWZQdHI8VHlwaW5nQ29tbWFu ZD4gY3JlYXRlKERvY3VtZW50KiBkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29tbWFuZCwgY29u c3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dENvbXBvc2l0aW9u VHlwZSBjb21wb3NpdGlvblR5cGUpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3 IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVjdEluc2VydGVkVGV4 dCwgQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGNvbXBvc2l0aW9uVHlwZSwgZmFsc2UpKTsKICAgICB9 CiAKLSAgICBUeXBpbmdDb21tYW5kKERvY3VtZW50KiwgRVR5cGluZ0NvbW1hbmQsIGNvbnN0IFN0 cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSwgYm9v bCBraWxsUmluZyk7CisgICAgVHlwaW5nQ29tbWFuZChEb2N1bWVudCosIEVUeXBpbmdDb21tYW5k LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVs YXJpdHksIFRleHRDb21wb3NpdGlvblR5cGUsIGJvb2wga2lsbFJpbmcpOwogCiAgICAgYm9vbCBz bWFydERlbGV0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc21hcnREZWxldGU7IH0KICAgICB2b2lkIHNl dFNtYXJ0RGVsZXRlKGJvb2wgc21hcnREZWxldGUpIHsgbV9zbWFydERlbGV0ZSA9IHNtYXJ0RGVs ZXRlOyB9CkBAIC05NCw2ICsxMDYsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9zZWxlY3RJbnNl cnRlZFRleHQ7CiAgICAgYm9vbCBtX3NtYXJ0RGVsZXRlOwogICAgIFRleHRHcmFudWxhcml0eSBt X2dyYW51bGFyaXR5OworICAgIFRleHRDb21wb3NpdGlvblR5cGUgbV9jb21wb3NpdGlvblR5cGU7 CiAgICAgYm9vbCBtX2tpbGxSaW5nOwogICAgIGJvb2wgbV9wcmVzZXJ2ZXNUeXBpbmdTdHlsZTsK ICAgICAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCBmZWMxNzkzMWFkMzU0 YWNlYzJjYWRmNmQ4YjY5NmE2NmExNjVkOTdlLi5jNWZhZmYxYTA5OWQ0NjVkNzgwNDMwNWFjOWQ5 NTM5Yzk4MzUxYTI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0yNjUz LDcgKzI2NTMsNyBAQCBjbGVhbnVwRHJhZzoKIH0KICNlbmRpZiAvLyBFTkFCTEUoRFJBR19TVVBQ T1JUKQogICAKLWJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBT dHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5aW5nRXZlbnQsIGJvb2wgaXNMaW5lQnJlYWssIGJv b2wgaXNCYWNrVGFiKQorYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KGNv bnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmVudCwgYm9vbCBpc0xpbmVCcmVh aywgYm9vbCBpc0JhY2tUYWIsIGJvb2wgaXNDb21wb3NpdGlvbikKIHsKICAgICAvLyBQbGF0Zm9y bXMgc2hvdWxkIGRpZmZlcmVudGlhdGUgcmVhbCBjb21tYW5kcyBsaWtlIHNlbGVjdEFsbCBmcm9t IHRleHQgaW5wdXQgaW4gZGlzZ3Vpc2UgKGxpa2UgaW5zZXJ0TmV3bGluZSksCiAgICAgLy8gYW5k IGF2b2lkIGRpc3BhdGNoaW5nIHRleHQgaW5wdXQgZXZlbnRzIGZyb20ga2V5ZG93biBkZWZhdWx0 IGhhbmRsZXJzLgpAQCAtMjY3NCw3ICsyNjc0LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRs ZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlpbmdFdmUK ICAgICBpZiAoRnJhbWVWaWV3KiB2aWV3ID0gbV9mcmFtZS0+dmlldygpKQogICAgICAgICB2aWV3 LT5yZXNldERlZmVycmVkUmVwYWludERlbGF5KCk7CiAKLSAgICBSZWZQdHI8VGV4dEV2ZW50PiBl dmVudCA9IFRleHRFdmVudDo6Y3JlYXRlKG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBUZXh0 RXZlbnQ6OnNlbGVjdElucHV0VHlwZShpc0xpbmVCcmVhaywgaXNCYWNrVGFiKSk7CisgICAgUmVm UHRyPFRleHRFdmVudD4gZXZlbnQgPSBUZXh0RXZlbnQ6OmNyZWF0ZShtX2ZyYW1lLT5kb21XaW5k b3coKSwgdGV4dCwgVGV4dEV2ZW50OjpzZWxlY3RJbnB1dFR5cGUoaXNMaW5lQnJlYWssIGlzQmFj a1RhYiwgaXNDb21wb3NpdGlvbikpOwogICAgIGV2ZW50LT5zZXRVbmRlcmx5aW5nRXZlbnQodW5k ZXJseWluZ0V2ZW50KTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVu dEhhbmRsZXIuaAppbmRleCA2NTY5NWMyNzVmMDA2YTBkODk4OTg4MzNhYzc1NzBhNzg0ZmJhMDdj Li43ZmU1ZGJhYWZhZmE0OTNmM2UzNzRiNmRhYzVlZDNkMjlmZDRiNzkzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmgKQEAgLTE3NCw3ICsxNzQsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBk ZWZhdWx0S2V5Ym9hcmRFdmVudEhhbmRsZXIoS2V5Ym9hcmRFdmVudCopOwogCiAgICAgYm9vbCBo YW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5aW5n RXZlbnQgPSAwLAotICAgICAgICBib29sIGlzTGluZUJyZWFrID0gZmFsc2UsIGJvb2wgaXNCYWNr VGFiID0gZmFsc2UpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCBpc0xpbmVC cmVhayA9IGZhbHNlLCBib29sIGlzQmFja1RhYiA9IGZhbHNlLCBib29sIGlzQ29tcG9zaXRpb24g PSBmYWxzZSk7CiAgICAgdm9pZCBkZWZhdWx0VGV4dElucHV0RXZlbnRIYW5kbGVyKFRleHRFdmVu dCopOwogCiAjaWYgRU5BQkxFKERSQUdfU1VQUE9SVCkK 79545 2011-01-19 20:24:54 -0800 2011-01-23 17:38:32 -0800 Patch bug-5241-20110120132451.patch text/plain 29767 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjMzU4OTcxODRiMDg3YTQ3YTQ2YzhhZGNkMTM0NDRjMWY5ZmQ2NWFkLi5lNWEzYmJl OTU4YWIwMTBlOTQzMDZkNmRkYzA4MTdhODgyNjZmZTMwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTkgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBj aGFyYWN0ZXJzICJzZW50IiBieSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVu dCByZXN1bHRzIHRoYW4gdHlwaW5nIHRoZW0gZGlyZWN0bHkuCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MjQxCisgICAgICAgIAorICAgICAgICBBZGRl ZCBhIHRlc3QgdGhhdCBleGVyY2lzZXMgY29udGlub3VzIHdoaXRlc3BhY2UgY2hhcmFjdGVycyBh bmQgdGFicyBpbnNlcnRlZCBieSBJTUUuCisKKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGluZy9p bnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGVkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0bWw6 IEFkZGVkLgorCiAyMDExLTAxLTE5ICBZdXpvIEZ1amlzaGltYSAgPHl1em9AZ29vZ2xlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlv bi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MDg3Y2E0YzkxZTM2ZmJiMzEy MWQ4YjQzYzJhNmU4YjBlYzcyYmM5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsNDkgQEAKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQicKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoEInCitQ QVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoCBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0EgwqAgwqBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgQUInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnwqDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgQUInCitQ QVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ8KgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoEFCJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5n VGV4dCBpcyAnQUIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqDCoCcKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdB QiDCoCDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgJworUEFTUyBj b21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBp cyAnwqDCoEEgwqBCIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqBBIMKgQiDCoCcK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfC oMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICdBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnQSAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBICAgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBICAgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICdBQiAgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgICAgICcKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBQiAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAg ICAgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICcgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgQUInCitQQVNTIGNv bXBvc2l0aW5nVGV4dCBpcyAnICAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAg ICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgICAgQUInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnICBBICBCICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnCQlBCQlCCQkn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAnCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZTAxMjEwNDdkNWVlMjI2MDQ0ZjYyYzY4OWZiNDk2ZGZlY2I4Mjg5Mgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1j b21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0bWwKQEAgLTAsMCArMSw5NyBAQAorPCFET0NUWVBFIEhU TUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5r IHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qt cHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48 L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQ+CisKK3ZhciBzZWwgPSBkb2N1 bWVudC5nZXRTZWxlY3Rpb24oKTsKK3ZhciByb290ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgi cm9vdCIpOworZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChyb290KTsKKworCitmdW5jdGlvbiBj cmVhdGVFZGl0YWJsZSh0YWdOYW1lLCB0ZXh0KSB7CisgICAgdmFyIG5vZGUgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KHRhZ05hbWUpOworICAgIG5vZGUuY29udGVudEVkaXRhYmxlID0gdHJ1ZTsK KyAgICBub2RlLmlubmVySFRNTCA9IHRleHQ7CisgICAgcmV0dXJuIG5vZGU7Cit9CisKK2Z1bmN0 aW9uIHRlc3QodGFnTmFtZSwgY29tcG9zaXRpb25UZXh0LCBleHBlY3RlZCkgeworICAgIHZhciBu b2RlID0gY3JlYXRlRWRpdGFibGUodGFnTmFtZSwgIlgiKTsKKyAgICByb290LmFwcGVuZENoaWxk KG5vZGUpOworCisgICAgdmFyIHRleHROb2RlID0gbm9kZS5maXJzdENoaWxkOworICAgIHNlbC5z ZXRCYXNlQW5kRXh0ZW50KHRleHROb2RlLCAwLCB0ZXh0Tm9kZSwgdGV4dE5vZGUuZGF0YS5sZW5n dGgpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCJEZWxldGUiLCBmYWxzZSk7CisKKyAgICB0 ZXh0SW5wdXRDb250cm9sbGVyLnNldE1hcmtlZFRleHQoY29tcG9zaXRpb25UZXh0LCAwLCBjb21w b3NpdGlvblRleHQpOworICAgIGNvbXBvc2l0aW5nVGV4dCA9IG5vZGUuaW5uZXJUZXh0OworICAg IHRleHRJbnB1dENvbnRyb2xsZXIudW5tYXJrVGV4dCgpOworICAgIGNvbmZpcm1lZFRleHQgPSBu b2RlLmlubmVyVGV4dDsKKworICAgIHNob3VsZEJlKCJjb21wb3NpdGluZ1RleHQiLCAiJyIgKyBl eHBlY3RlZCArICInIik7Cit9CisKK3Rlc3QoImRpdiIsICJBQiIsICJBQiIpOwordGVzdCgiZGl2 IiwgIkEgQiIsICJBIEIiKTsKK3Rlc3QoImRpdiIsICJBICBCIiwgIkEgXHhBMEIiKTsKK3Rlc3Qo ImRpdiIsICJBICAgQiIsICJBIFx4QTAgQiIpOwordGVzdCgiZGl2IiwgIkEgICAgQiIsICJBIFx4 QTAgXHhBMEIiKTsgCisKK3Rlc3QoImRpdiIsICIgQUIiLCAiXHhBMEFCIik7Cit0ZXN0KCJkaXYi LCAiICBBQiIsICJceEEwXHhBMEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgQUIiLCAiXHhBMFx4QTAg QUIiKTsKK3Rlc3QoImRpdiIsICIgICAgQUIiLCAiXHhBMFx4QTAgXHhBMEFCIik7Cit0ZXN0KCJk aXYiLCAiICAgICBBQiIsICJceEEwXHhBMCBceEEwIEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgICAg QUIiLCAiXHhBMFx4QTAgXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICAgQUIiLCAi XHhBMFx4QTAgXHhBMCBceEEwIEFCIik7Cit0ZXN0KCJkaXYiLCAiQUIgICIsICJBQiBceEEwIik7 Cit0ZXN0KCJkaXYiLCAiQUIgICAiLCAiQUIgXHhBMFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAg ICAiLCAiQUIgXHhBMCBceEEwIik7Cit0ZXN0KCJkaXYiLCAiQUIgICAgICIsICJBQiBceEEwIFx4 QTBceEEwIik7Cit0ZXN0KCJkaXYiLCAiQUIgICAgICAiLCAiQUIgXHhBMCBceEEwIFx4QTAiKTsK K3Rlc3QoImRpdiIsICJBQiAgICAgICAiLCAiQUIgXHhBMCBceEEwIFx4QTBceEEwIik7CisKK3Rl c3QoImRpdiIsICIgIEEgIEIgICIsICJceEEwXHhBMEEgXHhBMEIgXHhBMCIpOwordGVzdCgiZGl2 IiwgIlx0XHRBXHRcdEJcdFx0IiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7CisKK3Rlc3QoImRp diIsICIgIiwgIlx4QTAiKTsKK3Rlc3QoImRpdiIsICIgICIsICJceEEwXHhBMCIpOwordGVzdCgi ZGl2IiwgIiAgICIsICJceEEwXHhBMFx4QTAiKTsKKwordGVzdCgicHJlIiwgIkFCIiwgIkFCIik7 Cit0ZXN0KCJwcmUiLCAiQSBCIiwgIkEgQiIpOwordGVzdCgicHJlIiwgIkEgIEIiLCAiQSAgQiIp OwordGVzdCgicHJlIiwgIkEgICBCIiwgIkEgICBCIik7Cit0ZXN0KCJwcmUiLCAiQSAgICBCIiwg IkEgICAgQiIpOwordGVzdCgicHJlIiwgIkFCICAiLCAiQUIgICIpOwordGVzdCgicHJlIiwgIkFC ICAgIiwgIkFCICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgIiwgIkFCICAgICIpOwordGVzdCgi cHJlIiwgIkFCICAgICAiLCAiQUIgICAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICAgIiwgIkFC ICAgICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAgIiwgIkFCICAgICAgICIpOwordGVzdCgi cHJlIiwgIiAgQUIiLCAiICBBQiIpOwordGVzdCgicHJlIiwgIiAgIEFCIiwgIiAgIEFCIik7Cit0 ZXN0KCJwcmUiLCAiICAgIEFCIiwgIiAgICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgQUIiLCAi ICAgICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgIEFCIiwgIiAgICAgIEFCIik7Cit0ZXN0KCJw cmUiLCAiICAgICAgIEFCIiwgIiAgICAgICBBQiIpOworCit0ZXN0KCJwcmUiLCAiICBBICBCICAi LCAiICBBICBCICAiKTsKK3Rlc3QoInByZSIsICJcdFx0QVx0XHRCXHRcdCIsICJcdFx0QVx0XHRC XHRcdCIpOwordGVzdCgicHJlIiwgIiAiLCAiICIpOwordGVzdCgicHJlIiwgIiAgIiwgIiAgIik7 Cit0ZXN0KCJwcmUiLCAiICAgIiwgIiAgICIpOworCityb290LnN0eWxlLmRpc3BsYXkgPSAibm9u ZSI7CitzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworCis8L3NjcmlwdD4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGU4ZDc3ZDUxOGM3ZDA2OGJjYWJhNTE5ODc1ZDQz Y2E4ZTUxODgwNDkuLjgwNGNlOWY5MjJiNjcxZWE4OTg0ZGE1YzVhODI2MThhOTQ5NzNhZjEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAorMjAxMS0wMS0xOSAgTU9SSVRBIEhhamltZSAgPG1v cnJpdGFAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBTcGFjZSBhbmQgdGFiIGNoYXJhY3RlcnMgInNlbnQiIGJ5IGFuIGlucHV0IG1l dGhvZCBnaXZlIHRvdGFsbHkgZGlmZmVyZW50IHJlc3VsdHMgdGhhbiB0eXBpbmcgdGhlbSBkaXJl Y3RseQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0 MQorICAgICAgICAKKyAgICAgICAgKiBJbnRyb2R1Y2VkIFRleHRFdmVudDo6SW5wdXRUeXBlQ29t cG9zaXRpb24gYW5kIFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvblR5cGUgdG8gCisgICAg ICAgICAgZGlzdGluZ3Vpc2ggdGV4dCBpbnB1dCB3aGljaCBpcyBvcmlnaW5hdGVkIGJ5IGNvbXBv c2l0aW9uLgorICAgICAgICAqIEdlbmVyYWxpemVkIHJlYmFsYW5jZVdoaXRlc3BhY2VBdCgpIHRv IHJlYmFsYW5jZVdoaXRlc3BhY2VPblRleHRTdWJzdHJpbmcoKSB0byByZWJhbGFuY2luZyAKKyAg ICAgICAgICByYW5nZSBvZiBzdHJpbmcgb24gdGV4dCBub2RlLCBpbnN0ZWFkIG9mIHN1cnJvdW5k aW5nIHBhcnQgb2YgdGhhdC4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL2luc2VydGluZy9pbnNl cnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sCisKKyAgICAgICAgKiBkb20vVGV4dEV2ZW50 Lmg6CisgICAgICAgIChXZWJDb3JlOjpUZXh0RXZlbnQ6OmlzQ29tcG9zaXRpb24pOgorICAgICAg ICAqIGRvbS9UZXh0RXZlbnRJbnB1dFR5cGUuaDogQWRkZWQgVGV4dEV2ZW50SW5wdXRDb21wb3Np dGlvbiBhcyBhIG1lbWJlciBvZiBUZXh0RXZlbnQ6OklucHV0VHlwZQorICAgICAgICAqIGVkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y29udGFpbnNP bmx5V2hpdGVzcGFjZSk6CisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFuZDo6 c2hvdWxkUmViYWxhbmNlTGVhZGluZ1doaXRlc3BhY2VGb3IpOgorICAgICAgICAoV2ViQ29yZTo6 Q29tcG9zaXRlRWRpdENvbW1hbmQ6OmNhblJlYmFsYW5jZSk6CisgICAgICAgIChXZWJDb3JlOjpD b21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZUF0KToKKyAgICAgICAgKFdl YkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vi c3RyaW5nKTogQWRkZWQ6IEEgZ2VuZXJhbGl6ZWQgdmVyc2lvbiBvZiByZWJhbGFuY2VXaGl0ZXNw YWNlQXQoKSwgd2hpY2ggdGFrZXMgYSByYW5nZSBpbnNpZGUgVGV4dCBzdHJpbmcuCisgICAgICAg ICogZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRWRp dG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6aW5zZXJ0VGV4dEZvckNvbmZpcm1l ZENvbXBvc2l0aW9uKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6Omluc2VydFRl eHRXaXRob3V0U2VuZGluZ1RleHRFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmNv bmZpcm1Db21wb3NpdGlvbik6IE5vdyB1c2VzIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3Np dGlvbigpLgorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZXRDb21wb3NpdGlvbik6CisgICAg ICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydFRleHRDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydFRleHRDb21tYW5kOjppbnB1dCk6Cisg ICAgICAgICogZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcv VHlwaW5nQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5kOjpUeXBp bmdDb21tYW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQp OgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dFJ1bldpdGhvdXRO ZXdsaW5lcyk6CisgICAgICAgICogZWRpdGluZy9UeXBpbmdDb21tYW5kLmg6IEFkZGVkIFR5cGlu Z0NvbW1hbmQ6Om1fY29tcG9zaXRpb25UeXBlIGFuZCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9z aXRpb25UeXBlCisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5kOjpzZXRDb21wb3NpdGlv blR5cGUpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6OmNyZWF0ZSk6 CisKIDIwMTEtMDEtMTkgIFl1em8gRnVqaXNoaW1hICA8eXV6b0Bnb29nbGUuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEtlbnQgVGFtdXJhLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL1RleHRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5oCmluZGV4IGQ3 NzBkMzg4NDQzNDBmNjg0MDUyN2I4YzdjMTQ5ZWZmOWJkYzBiN2EuLjI2YzhiOTNkNDEwMjI4MzVk NDY1MzA0MDk3ZTJhYTJhMWUwM2E5YjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9U ZXh0RXZlbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50LmgKQEAgLTUxLDYg KzUxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIGJvb2wgaXNUZXh0 RXZlbnQoKSBjb25zdDsKIAogICAgICAgICBib29sIGlzTGluZUJyZWFrKCkgY29uc3QgeyByZXR1 cm4gbV9pbnB1dFR5cGUgPT0gVGV4dEV2ZW50SW5wdXRMaW5lQnJlYWs7IH0KKyAgICAgICAgYm9v bCBpc0NvbXBvc2l0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUgPT0gVGV4dEV2ZW50 SW5wdXRDb21wb3NpdGlvbjsgfQogICAgICAgICBib29sIGlzQmFja1RhYigpIGNvbnN0IHsgcmV0 dXJuIG1faW5wdXRUeXBlID09IFRleHRFdmVudElucHV0QmFja1RhYjsgfQogICAgICAgICBib29s IGlzUGFzdGUoKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9PSBUZXh0RXZlbnRJbnB1dFBh c3RlOyB9CiAgICAgICAgIGJvb2wgaXNEcm9wKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUg PT0gVGV4dEV2ZW50SW5wdXREcm9wOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20v VGV4dEV2ZW50SW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50SW5wdXRU eXBlLmgKaW5kZXggMjUyMmVjNDVmZjdmODE5MWY3NDU5MGJiZDg5OTM2M2U3Mjc0ZTY4NS4uZjVh MDVlYjcwMDRkZDgzYjhlMzFmZWEyNTI1YWI0ZTFkZTJlMWUyMiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL1RleHRFdmVudElucHV0VHlwZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9UZXh0RXZlbnRJbnB1dFR5cGUuaApAQCAtMzEsNiArMzEsNyBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiBlbnVtIFRleHRFdmVudElucHV0VHlwZSB7CiAgICAgVGV4dEV2ZW50SW5wdXRLZXlib2Fy ZCwgLy8gYW55IG5ld2xpbmUgY2hhcmFjdGVycyBpbiB0aGUgdGV4dCBhcmUgbGluZSBicmVha3Mg b25seSwgbm90IHBhcmFncmFwaCBzZXBhcmF0b3JzLgogICAgIFRleHRFdmVudElucHV0TGluZUJy ZWFrLCAvLyBhbnkgdGFiIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQgYXJlIGJhY2t0YWJzLgorICAg IFRleHRFdmVudElucHV0Q29tcG9zaXRpb24sCiAgICAgVGV4dEV2ZW50SW5wdXRCYWNrVGFiLAog ICAgIFRleHRFdmVudElucHV0UGFzdGUsCiAgICAgVGV4dEV2ZW50SW5wdXREcm9wLApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAppbmRleCA1NTJl ZDc5NGYxNDg0N2M1MzBkMmY4YThmN2MyMTFlOWUwZGMzNzEwLi4yZTYwNDFmY2QzZjU0YTM3YzVl MjIxM2FkMGVjZjM5N2ZkMzQ5ODA4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Nv bXBvc2l0ZUVkaXRDb21tYW5kLmNwcApAQCAtMzk1LDUyICszOTUsODQgQEAgc3RhdGljIGlubGlu ZSBib29sIGlzV2hpdGVzcGFjZShVQ2hhciBjKQogICAgIHJldHVybiBjID09IG5vQnJlYWtTcGFj ZSB8fCBjID09ICcgJyB8fCBjID09ICdcbicgfHwgYyA9PSAnXHQnOwogfQogCi0vLyBGSVhNRTog RG9lc24ndCBnbyBpbnRvIHRleHQgbm9kZXMgdGhhdCBjb250cmlidXRlIGFkamFjZW50IHRleHQg KHNpYmxpbmdzLCBjb3VzaW5zLCBldGMpLgotdm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmVi YWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlvbikKK3N0YXRpYyBpbmxp bmUgYm9vbCBjb250YWluc09ubHlXaGl0ZXNwYWNlKGNvbnN0IFN0cmluZyYgdGV4dCkKK3sKKyAg ICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdGV4dC5sZW5ndGgoKTsgKytpKSB7CisgICAgICAg IGlmICghaXNXaGl0ZXNwYWNlKHRleHQuY2hhcmFjdGVycygpW2ldKSkKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICB9CisgICAgCisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgQ29t cG9zaXRlRWRpdENvbW1hbmQ6OnNob3VsZFJlYmFsYW5jZUxlYWRpbmdXaGl0ZXNwYWNlRm9yKGNv bnN0IFN0cmluZyYgdGV4dCkgY29uc3QKK3sKKyAgICByZXR1cm4gY29udGFpbnNPbmx5V2hpdGVz cGFjZSh0ZXh0KTsKK30KKworYm9vbCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6Y2FuUmViYWxhbmNl KGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlvbikgY29uc3QKIHsKICAgICBOb2RlKiBub2RlID0gcG9z aXRpb24uY29udGFpbmVyTm9kZSgpOwogICAgIGlmIChwb3NpdGlvbi5hbmNob3JUeXBlKCkgIT0g UG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvciB8fCAhbm9kZSB8fCAhbm9kZS0+aXNU ZXh0Tm9kZSgpKQotICAgICAgICByZXR1cm47Ci0gICAgVGV4dCogdGV4dE5vZGUgPSBzdGF0aWNf Y2FzdDxUZXh0Kj4obm9kZSk7CisgICAgICAgIHJldHVybiBmYWxzZTsKIAorICAgIFRleHQqIHRl eHROb2RlID0gc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpOwogICAgIGlmICh0ZXh0Tm9kZS0+bGVu Z3RoKCkgPT0gMCkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1cm4gZmFsc2U7CisKICAg ICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gdGV4dE5vZGUtPnJlbmRlcmVyKCk7CiAgICAgaWYg KHJlbmRlcmVyICYmICFyZW5kZXJlci0+c3R5bGUoKS0+Y29sbGFwc2VXaGl0ZVNwYWNlKCkpCi0g ICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCi0gICAgU3RyaW5nIHRleHQg PSB0ZXh0Tm9kZS0+ZGF0YSgpOwotICAgIEFTU0VSVCghdGV4dC5pc0VtcHR5KCkpOworICAgIHJl dHVybiB0cnVlOworfQorCisvLyBGSVhNRTogRG9lc24ndCBnbyBpbnRvIHRleHQgbm9kZXMgdGhh dCBjb250cmlidXRlIGFkamFjZW50IHRleHQgKHNpYmxpbmdzLCBjb3VzaW5zLCBldGMpLgordm9p ZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0 aW9uJiBwb3NpdGlvbikKK3sKKyAgICBOb2RlKiBub2RlID0gcG9zaXRpb24uY29udGFpbmVyTm9k ZSgpOworICAgIGlmICghY2FuUmViYWxhbmNlKHBvc2l0aW9uKSkKKyAgICAgICAgcmV0dXJuOwog CisgICAgLy8gSWYgdGhlIHJlYmFsYW5jZSBpcyBmb3IgdGhlIHNpbmdsZSBvZmZzZXQsIGFuZCBu ZWl0aGVyIHRleHRbb2Zmc2V0XSBub3IgdGV4dFtvZmZzZXQgLSAxXSBhcmUgc29tZSBmb3JtIG9m IHdoaXRlc3BhY2UsIGRvIG5vdGhpbmcuCiAgICAgaW50IG9mZnNldCA9IHBvc2l0aW9uLmRlcHJl Y2F0ZWRFZGl0aW5nT2Zmc2V0KCk7Ci0gICAgLy8gSWYgbmVpdGhlciB0ZXh0W29mZnNldF0gbm9y IHRleHRbb2Zmc2V0IC0gMV0gYXJlIHNvbWUgZm9ybSBvZiB3aGl0ZXNwYWNlLCBkbyBub3RoaW5n LgorICAgIFN0cmluZyB0ZXh0ID0gc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpLT5kYXRhKCk7CiAg ICAgaWYgKCFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkgewogICAgICAgICBvZmZzZXQtLTsK ICAgICAgICAgaWYgKG9mZnNldCA8IDAgfHwgIWlzV2hpdGVzcGFjZSh0ZXh0W29mZnNldF0pKQog ICAgICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICAKKworICAgIHJlYmFsYW5jZVdoaXRlc3Bh Y2VPblRleHRTdWJzdHJpbmcoc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpLCBwb3NpdGlvbi5kZXBy ZWNhdGVkRWRpdGluZ09mZnNldCgpLCBwb3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgp KTsKK30KKwordm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZU9u VGV4dFN1YnN0cmluZyhSZWZQdHI8VGV4dD4gdGV4dE5vZGUsIGludCBzdGFydE9mZnNldCwgaW50 IGVuZE9mZnNldCkKK3sKKyAgICBTdHJpbmcgdGV4dCA9IHRleHROb2RlLT5kYXRhKCk7CisgICAg QVNTRVJUKCF0ZXh0LmlzRW1wdHkoKSk7CisKICAgICAvLyBTZXQgdXBzdHJlYW0gYW5kIGRvd25z dHJlYW0gdG8gZGVmaW5lIHRoZSBleHRlbnQgb2YgdGhlIHdoaXRlc3BhY2Ugc3Vycm91bmRpbmcg dGV4dFtvZmZzZXRdLgotICAgIGludCB1cHN0cmVhbSA9IG9mZnNldDsKKyAgICBpbnQgdXBzdHJl YW0gPSBzdGFydE9mZnNldDsKICAgICB3aGlsZSAodXBzdHJlYW0gPiAwICYmIGlzV2hpdGVzcGFj ZSh0ZXh0W3Vwc3RyZWFtIC0gMV0pKQogICAgICAgICB1cHN0cmVhbS0tOwogICAgIAotICAgIGlu dCBkb3duc3RyZWFtID0gb2Zmc2V0OwotICAgIHdoaWxlICgodW5zaWduZWQpZG93bnN0cmVhbSAr IDEgPCB0ZXh0Lmxlbmd0aCgpICYmIGlzV2hpdGVzcGFjZSh0ZXh0W2Rvd25zdHJlYW0gKyAxXSkp CisgICAgaW50IGRvd25zdHJlYW0gPSBlbmRPZmZzZXQ7CisgICAgd2hpbGUgKCh1bnNpZ25lZClk b3duc3RyZWFtIDwgdGV4dC5sZW5ndGgoKSAmJiBpc1doaXRlc3BhY2UodGV4dFtkb3duc3RyZWFt XSkpCiAgICAgICAgIGRvd25zdHJlYW0rKzsKICAgICAKLSAgICBpbnQgbGVuZ3RoID0gZG93bnN0 cmVhbSAtIHVwc3RyZWFtICsgMTsKLSAgICBBU1NFUlQobGVuZ3RoID4gMCk7Ci0gICAgCi0gICAg VmlzaWJsZVBvc2l0aW9uIHZpc2libGVVcHN0cmVhbVBvcyhQb3NpdGlvbihwb3NpdGlvbi5jb250 YWluZXJOb2RlKCksIHVwc3RyZWFtLCBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9y KSk7Ci0gICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVEb3duc3RyZWFtUG9zKFBvc2l0aW9uKHBv c2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgZG93bnN0cmVhbSArIDEsIFBvc2l0aW9uOjpQb3NpdGlv bklzT2Zmc2V0SW5BbmNob3IpKTsKKyAgICBpbnQgbGVuZ3RoID0gZG93bnN0cmVhbSAtIHVwc3Ry ZWFtOworICAgIGlmICghbGVuZ3RoKQorICAgICAgICByZXR1cm47CisKKyAgICBWaXNpYmxlUG9z aXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0aW9uKHRleHROb2RlLCB1cHN0cmVhbSwgUG9z aXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOworICAgIFZpc2libGVQb3NpdGlvbiB2 aXNpYmxlRG93bnN0cmVhbVBvcyhQb3NpdGlvbih0ZXh0Tm9kZSwgZG93bnN0cmVhbSwgUG9zaXRp b246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOwogICAgIAogICAgIFN0cmluZyBzdHJpbmcg PSB0ZXh0LnN1YnN0cmluZyh1cHN0cmVhbSwgbGVuZ3RoKTsKICAgICBTdHJpbmcgcmViYWxhbmNl ZFN0cmluZyA9IHN0cmluZ1dpdGhSZWJhbGFuY2VkV2hpdGVzcGFjZShzdHJpbmcsCiAgICAgLy8g RklYTUU6IEJlY2F1c2Ugb2YgdGhlIHByb2JsZW0gbWVudGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhp cyBmdW5jdGlvbiwgd2UgbXVzdCBhbHNvIHVzZSBuYnNwcyBhdCB0aGUgc3RhcnQvZW5kIG9mIHRo ZSBzdHJpbmcgYmVjYXVzZQogICAgIC8vIHRoaXMgZnVuY3Rpb24gZG9lc24ndCBnZXQgYWxsIHN1 cnJvdW5kaW5nIHdoaXRlc3BhY2UsIGp1c3QgdGhlIHdoaXRlc3BhY2UgaW4gdGhlIGN1cnJlbnQg dGV4dCBub2RlLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGlzU3RhcnRPZlBhcmFncmFwaCh2aXNpYmxlVXBzdHJlYW1Qb3MpIHx8 IHVwc3RyZWFtID09IDAsIAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGlzRW5kT2ZQYXJhZ3JhcGgodmlzaWJsZURvd25zdHJlYW1Q b3MpIHx8ICh1bnNpZ25lZClkb3duc3RyZWFtID09IHRleHQubGVuZ3RoKCkgLSAxKTsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBp c0VuZE9mUGFyYWdyYXBoKHZpc2libGVEb3duc3RyZWFtUG9zKSB8fCAodW5zaWduZWQpZG93bnN0 cmVhbSA9PSB0ZXh0Lmxlbmd0aCgpKTsKICAgICAKICAgICBpZiAoc3RyaW5nICE9IHJlYmFsYW5j ZWRTdHJpbmcpCiAgICAgICAgIHJlcGxhY2VUZXh0SW5Ob2RlKHRleHROb2RlLCB1cHN0cmVhbSwg bGVuZ3RoLCByZWJhbGFuY2VkU3RyaW5nKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29t cG9zaXRlRWRpdENvbW1hbmQuaAppbmRleCA2ZGI0ZWIxODJhMDg4NmFkMWZkODBiMDRlOGMxYzZm MzYxY2IwMzAwLi45MDY2YjY1MjUyNjA1NTVjOGQ4YjMyODhmYTczZDkyOTFhZTRiZDZkIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysr IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC03MSw3 ICs3MSwxMCBAQCBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBtZXJnZUlkZW50aWNhbEVsZW1lbnRzKFBh c3NSZWZQdHI8RWxlbWVudD4sIFBhc3NSZWZQdHI8RWxlbWVudD4pOwogICAgIHZvaWQgcmViYWxh bmNlV2hpdGVzcGFjZSgpOwogICAgIHZvaWQgcmViYWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBv c2l0aW9uJik7CisgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKFJl ZlB0cjxUZXh0PiwgaW50IHN0YXJ0T2Zmc2V0LCBpbnQgZW5kT2Zmc2V0KTsKICAgICB2b2lkIHBy ZXBhcmVXaGl0ZXNwYWNlQXRQb3NpdGlvbkZvclNwbGl0KFBvc2l0aW9uJik7CisgICAgYm9vbCBj YW5SZWJhbGFuY2UoY29uc3QgUG9zaXRpb24mKSBjb25zdDsKKyAgICBib29sIHNob3VsZFJlYmFs YW5jZUxlYWRpbmdXaGl0ZXNwYWNlRm9yKGNvbnN0IFN0cmluZyYpIGNvbnN0OwogICAgIHZvaWQg cmVtb3ZlQ1NTUHJvcGVydHkoUGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50PiwgQ1NTUHJvcGVydHlJ RCk7CiAgICAgdm9pZCByZW1vdmVOb2RlQXR0cmlidXRlKFBhc3NSZWZQdHI8RWxlbWVudD4sIGNv bnN0IFF1YWxpZmllZE5hbWUmIGF0dHJpYnV0ZSk7CiAgICAgdm9pZCByZW1vdmVDaGlsZHJlbklu UmFuZ2UoUGFzc1JlZlB0cjxOb2RlPiwgdW5zaWduZWQgZnJvbSwgdW5zaWduZWQgdG8pOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IDIzYjQxY2ViZWE3N2ZiMDFjMDcyMzQ2YmRkNDJk MzdjNmFiMTg3YjcuLjNhY2VjMjdhMzgzNDU1YzU1YjM5YTMwOTliNGRjNzIwNGVmMmYwODUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTExNzMsNyArMTE3MywxMiBAQCBib29sIEVk aXRvcjo6aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZl bnQpCiAgICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5oYW5kbGVUZXh0SW5wdXRF dmVudCh0ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwogfQogCi1ib29sIEVkaXRvcjo6aW5zZXJ0VGV4 dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJ bnNlcnRlZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCitib29sIEVkaXRvcjo6aW5zZXJ0 VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCkKK3sKKyAgICBy ZXR1cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhhbmRsZVRleHRJbnB1dEV2ZW50KHRleHQs IDAsIFRleHRFdmVudElucHV0Q29tcG9zaXRpb24pOworfQorCitib29sIEVkaXRvcjo6aW5zZXJ0 VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxl Y3RJbnNlcnRlZFRleHQsIFRleHRFdmVudCogdHJpZ2dlcmluZ0V2ZW50KQogewogICAgIGlmICh0 ZXh0LmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtMTE5NSw3ICsxMjAwLDgg QEAgYm9vbCBFZGl0b3I6Omluc2VydFRleHRXaXRob3V0U2VuZGluZ1RleHRFdmVudChjb25zdCBT dHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW4KICAgICAgICAgICAgIFJlZlB0cjxEb2N1bWVudD4g ZG9jdW1lbnQgPSBzZWxlY3Rpb25TdGFydC0+ZG9jdW1lbnQoKTsKICAgICAgICAgICAgIAogICAg ICAgICAgICAgLy8gSW5zZXJ0IHRoZSB0ZXh0Ci0gICAgICAgICAgICBUeXBpbmdDb21tYW5kOjpp bnNlcnRUZXh0KGRvY3VtZW50LmdldCgpLCB0ZXh0LCBzZWxlY3Rpb24sIHNlbGVjdEluc2VydGVk VGV4dCk7CisgICAgICAgICAgICBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KGRvY3VtZW50Lmdl dCgpLCB0ZXh0LCBzZWxlY3Rpb24sIHNlbGVjdEluc2VydGVkVGV4dCwgCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHRyaWdnZXJpbmdFdmVudCAmJiB0cmlnZ2VyaW5nRXZl bnQtPmlzQ29tcG9zaXRpb24oKSA/IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbkNvbmZp cm0gOiBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25Ob25lKTsKIAogICAgICAgICAgICAg Ly8gUmV2ZWFsIHRoZSBjdXJyZW50IHNlbGVjdGlvbiAKICAgICAgICAgICAgIGlmIChGcmFtZSog ZWRpdGVkRnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKSkKQEAgLTE2MTgsNyArMTYyNCw3IEBAIHZv aWQgRWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHBy ZXNlcnZlU2VsZWN0aW9uKQogICAgIG1fY29tcG9zaXRpb25Ob2RlID0gMDsKICAgICBtX2N1c3Rv bUNvbXBvc2l0aW9uVW5kZXJsaW5lcy5jbGVhcigpOwogCi0gICAgaW5zZXJ0VGV4dCh0ZXh0LCAw KTsKKyAgICBpbnNlcnRUZXh0Rm9yQ29uZmlybWVkQ29tcG9zaXRpb24odGV4dCk7CiAKICAgICBp ZiAocHJlc2VydmVTZWxlY3Rpb24pIHsKICAgICAgICAgbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNl dFNlbGVjdGlvbihvbGRTZWxlY3Rpb24sIGZhbHNlLCBmYWxzZSk7CkBAIC0xNjg3LDcgKzE2OTMs NyBAQCB2b2lkIEVkaXRvcjo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25z dCBWZWN0b3I8Q29tcG9zaXRpb25VbmRlcmxpbgogICAgIG1fY3VzdG9tQ29tcG9zaXRpb25VbmRl cmxpbmVzLmNsZWFyKCk7CiAKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKSB7Ci0gICAgICAgIFR5 cGluZ0NvbW1hbmQ6Omluc2VydFRleHQobV9mcmFtZS0+ZG9jdW1lbnQoKSwgdGV4dCwgdHJ1ZSwg dHJ1ZSk7CisgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQobV9mcmFtZS0+ZG9jdW1l bnQoKSwgdGV4dCwgdHJ1ZSwgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVXBkYXRlKTsK IAogICAgICAgICAvLyBGaW5kIG91dCB3aGF0IG5vZGUgaGFzIHRoZSBjb21wb3NpdGlvbiBub3cu CiAgICAgICAgIFBvc2l0aW9uIGJhc2UgPSBtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+YmFzZSgpLmRv d25zdHJlYW0oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCmluZGV4IDJlNjFjZTY3ZDE4MTg1YTY2 YTkyODAxZDZiN2E5NWE0Nzg5NDZlYzkuLjFlNmUzODczZjVkYzhkZWYyZDBkMjBhMDBjYjEzMzM4 YTljMDlhOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKKysr IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMTk4LDcgKzE5OCw4IEBAIHB1 YmxpYzoKICAgICBzdGF0aWMgYm9vbCBjb21tYW5kSXNTdXBwb3J0ZWRGcm9tTWVudU9yS2V5Qmlu ZGluZyhjb25zdCBTdHJpbmcmIGNvbW1hbmROYW1lKTsgLy8gV29ya3Mgd2l0aG91dCBhIGZyYW1l LgogCiAgICAgYm9vbCBpbnNlcnRUZXh0KGNvbnN0IFN0cmluZyYsIEV2ZW50KiB0cmlnZ2VyaW5n RXZlbnQpOwotICAgIGJvb2wgaW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0 IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBFdmVudCogdHJpZ2dlcmluZ0V2ZW50 KTsKKyAgICBib29sIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbihjb25zdCBTdHJp bmcmIHRleHQpOworICAgIGJvb2wgaW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNv bnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0RXZlbnQqIHRyaWdnZXJp bmdFdmVudCk7CiAgICAgYm9vbCBpbnNlcnRMaW5lQnJlYWsoKTsKICAgICBib29sIGluc2VydFBh cmFncmFwaFNlcGFyYXRvcigpOwogICAgIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9JbnNlcnRUZXh0Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dFRleHRDb21tYW5kLmNwcAppbmRleCBmYzE4ZTkxMmY5NTM2MzZhZmIyNzE2ZjBjMTYyM2Q1MDkw Njg5ZjVkLi43NGExMTFhMjJhNDM4MDA2YWMzYjczNWQ4Mzk5Yjk2MTkzMWUwZGI0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcApAQCAtMTA2LDcgKzEw Niw3IEBAIGJvb2wgSW5zZXJ0VGV4dENvbW1hbmQ6OnBlcmZvcm1Ucml2aWFsUmVwbGFjZShjb25z dCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZv aWQgSW5zZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxl Y3RJbnNlcnRlZFRleHQpCit2b2lkIEluc2VydFRleHRDb21tYW5kOjppbnB1dChjb25zdCBTdHJp bmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBSZWJhbGFuY2VUeXBlIHdoaXRlc3Bh Y2VSZWJhbGFuY2UpCiB7CiAgICAgCiAgICAgQVNTRVJUKHRleHQuZmluZCgnXG4nKSA9PSBub3RG b3VuZCk7CkBAIC0xNzIsMTEgKzE3MiwxNyBAQCB2b2lkIEluc2VydFRleHRDb21tYW5kOjppbnB1 dChjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0KQogICAgICAgICBp bnNlcnRUZXh0SW50b05vZGUodGV4dE5vZGUsIG9mZnNldCwgdGV4dCk7CiAgICAgICAgIGVuZFBv c2l0aW9uID0gUG9zaXRpb24odGV4dE5vZGUsIG9mZnNldCArIHRleHQubGVuZ3RoKCkpOwogCi0g ICAgICAgIC8vIFRoZSBpbnNlcnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdo aXRlc3BhY2UsIGlmIGl0IGlzIHByZXNlbnQuCi0gICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VB dChlbmRQb3NpdGlvbik7Ci0gICAgICAgIC8vIFJlYmFsYW5jaW5nIG9uIGJvdGggc2lkZXMgaXNu J3QgbmVjZXNzYXJ5IGlmIHdlJ3ZlIGluc2VydGVkIGEgc3BhY2UuCi0gICAgICAgIGlmICh0ZXh0 ICE9ICIgIikgCi0gICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoc3RhcnRQb3NpdGlv bik7CisgICAgICAgIGlmICh3aGl0ZXNwYWNlUmViYWxhbmNlID09IFJlYmFsYW5jZUxlYWRpbmdB bmRUcmFpbGluZ1doaXRlc3BhY2VzKSB7CisgICAgICAgICAgICAvLyBUaGUgaW5zZXJ0aW9uIG1h eSByZXF1aXJlIGFkanVzdGluZyBhZGphY2VudCB3aGl0ZXNwYWNlLCBpZiBpdCBpcyBwcmVzZW50 LgorICAgICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZUF0KGVuZFBvc2l0aW9uKTsKKyAgICAg ICAgICAgIC8vIFJlYmFsYW5jaW5nIG9uIGJvdGggc2lkZXMgaXNuJ3QgbmVjZXNzYXJ5IGlmIHdl J3ZlIGluc2VydGVkIG9ubHkgc3BhY2VzLgorICAgICAgICAgICAgaWYgKCFzaG91bGRSZWJhbGFu Y2VMZWFkaW5nV2hpdGVzcGFjZUZvcih0ZXh0KSkKKyAgICAgICAgICAgICAgICByZWJhbGFuY2VX aGl0ZXNwYWNlQXQoc3RhcnRQb3NpdGlvbik7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAg ICBBU1NFUlQod2hpdGVzcGFjZVJlYmFsYW5jZSA9PSBSZWJhbGFuY2VBbGxXaGl0ZXNwYWNlcyk7 CisgICAgICAgICAgICBpZiAoY2FuUmViYWxhbmNlKHN0YXJ0UG9zaXRpb24pICYmIGNhblJlYmFs YW5jZShlbmRQb3NpdGlvbikpCisgICAgICAgICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZU9u VGV4dFN1YnN0cmluZyh0ZXh0Tm9kZSwgc3RhcnRQb3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09m ZnNldCgpLCBlbmRQb3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpKTsKKyAgICAgICAg fQogICAgIH0KIAogICAgIC8vIFdlIGNvdWxkIGhhdmUgaW5zZXJ0ZWQgYSBwYXJ0IG9mIGNvbXBv c2VkIGNoYXJhY3RlciBzZXF1ZW5jZSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvSW5zZXJ0VGV4dENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4 dENvbW1hbmQuaAppbmRleCA3N2FlMDE2ZDM2YTE0ZmIxZjgxNDlkZjdhYTM0MTJjZGVjMWQyMmRl Li42NzJlNTc2ZjkyMDc5YTVjZjk3N2FlNWNmOGEyNGJkOWMyN2ZhNGM3IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmgKKysrIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oCkBAIC0zMiwxNCArMzIsMjAgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBJbnNlcnRUZXh0Q29tbWFuZCA6IHB1YmxpYyBDb21w b3NpdGVFZGl0Q29tbWFuZCB7CiBwdWJsaWM6CisgICAgZW51bSBSZWJhbGFuY2VUeXBlIHsKKyAg ICAgICAgUmViYWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMsCisgICAgICAgIFJl YmFsYW5jZUFsbFdoaXRlc3BhY2VzCisgICAgfTsKKwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPElu c2VydFRleHRDb21tYW5kPiBjcmVhdGUoRG9jdW1lbnQqIGRvY3VtZW50KQogICAgIHsKICAgICAg ICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBJbnNlcnRUZXh0Q29tbWFuZChkb2N1bWVudCkpOwogICAg IH0KIAotICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2Vy dGVkVGV4dCA9IGZhbHNlKTsKKyAgICB2b2lkIGlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9v bCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgUmViYWxhbmNlVHlwZSA9IFJlYmFsYW5jZUxl YWRpbmdBbmRUcmFpbGluZ1doaXRlc3BhY2VzKTsKIAogcHJpdmF0ZToKKwogICAgIEluc2VydFRl eHRDb21tYW5kKERvY3VtZW50Kik7CiAKICAgICB2b2lkIGRlbGV0ZUNoYXJhY3RlcigpOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKaW5kZXggZDU0YjM4ODViZjk4ZmU1 MmJkOWE2NWM1NGE4ZDcxZDk2NzYwN2U5ZC4uMjFkNDMxNGFkMDc1NDhhMDhjOTgyN2IwZjE1NWI5 OWFiMjI4YjYxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21t YW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwCkBA IC00Nyw3ICs0Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogdXNpbmcgbmFtZXNwYWNlIEhU TUxOYW1lczsKIAotVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZChEb2N1bWVudCAqZG9jdW1l bnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBTdHJpbmcgJnRleHRUb0luc2Vy dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSwg Ym9vbCBraWxsUmluZykKK1R5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRv Y3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kVHlwZSwgY29uc3QgU3RyaW5nICZ0ZXh0VG9J bnNlcnQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJp dHksIFRleHRDb21wb3NpdGlvblR5cGUgY29tcG9zaXRpb25UeXBlLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBib29sIGtpbGxSaW5nKQogICAgIDogQ29tcG9zaXRlRWRpdENvbW1hbmQo ZG9jdW1lbnQpLCAKICAgICAgIG1fY29tbWFuZFR5cGUoY29tbWFuZFR5cGUpLCAKICAgICAgIG1f dGV4dFRvSW5zZXJ0KHRleHRUb0luc2VydCksIApAQCAtNTUsNiArNTYsNyBAQCBUeXBpbmdDb21t YW5kOjpUeXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29t bWFuZFR5cGUsIGNvbgogICAgICAgbV9zZWxlY3RJbnNlcnRlZFRleHQoc2VsZWN0SW5zZXJ0ZWRU ZXh0KSwKICAgICAgIG1fc21hcnREZWxldGUoZmFsc2UpLAogICAgICAgbV9ncmFudWxhcml0eShn cmFudWxhcml0eSksCisgICAgICBtX2NvbXBvc2l0aW9uVHlwZShjb21wb3NpdGlvblR5cGUpLAog ICAgICAgbV9raWxsUmluZyhraWxsUmluZyksCiAgICAgICBtX29wZW5lZEJ5QmFja3dhcmREZWxl dGUoZmFsc2UpCiB7CkBAIC0xMzMsMTggKzEzNSwxOCBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6OnVw ZGF0ZVNlbGVjdGlvbklmRGlmZmVyZW50RnJvbUN1cnJlbnRTZWxlY3Rpb24oVHlwaW5nQ29tbWFu ZAogfQogICAgIAogCi12b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRv Y3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBib29s IGluc2VydGVkVGV4dElzQ29tcG9zaXRpb24pCit2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRl eHQoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0LCBUZXh0Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uKQogewogICAgIEFTU0VS VChkb2N1bWVudCk7CiAgICAgCiAgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQtPmZyYW1lKCk7 CiAgICAgQVNTRVJUKGZyYW1lKTsKIAotICAgIGluc2VydFRleHQoZG9jdW1lbnQsIHRleHQsIGZy YW1lLT5zZWxlY3Rpb24oKS0+c2VsZWN0aW9uKCksIHNlbGVjdEluc2VydGVkVGV4dCwgaW5zZXJ0 ZWRUZXh0SXNDb21wb3NpdGlvbik7CisgICAgaW5zZXJ0VGV4dChkb2N1bWVudCwgdGV4dCwgZnJh bWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBjb21wb3Np dGlvbik7CiB9CiAKIC8vIEZJWE1FOiBXZSBzaG91bGRuJ3QgbmVlZCB0byB0YWtlIHNlbGVjdGlv bkZvckluc2VydGlvbi4gSXQgc2hvdWxkIGJlIGlkZW50aWNhbCB0byBTZWxlY3Rpb25Db250cm9s bGVyJ3MgY3VycmVudCBzZWxlY3Rpb24uCi12b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQo RG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpc2libGVTZWxl Y3Rpb24mIHNlbGVjdGlvbkZvckluc2VydGlvbiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIGJv b2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0 VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzaWJs ZVNlbGVjdGlvbiYgc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdEluc2VydGVkVGV4 dCwgVGV4dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUpCiB7CiAjaWYgUkVNT1ZFX01B UktFUlNfVVBPTl9FRElUSU5HCiAgICAgaWYgKCF0ZXh0LmlzRW1wdHkoKSkKQEAgLTE2MSw3ICsx NjMsNyBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50 LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpcwogICAgIFN0cmluZyBuZXdUZXh0ID0gdGV4 dDsKICAgICBOb2RlKiBzdGFydE5vZGUgPSBzZWxlY3Rpb25Gb3JJbnNlcnRpb24uc3RhcnQoKS5u b2RlKCk7CiAgICAgCi0gICAgaWYgKHN0YXJ0Tm9kZSAmJiBzdGFydE5vZGUtPnJvb3RFZGl0YWJs ZUVsZW1lbnQoKSAmJiAhaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikgeyAgICAgICAgCisgICAg aWYgKHN0YXJ0Tm9kZSAmJiBzdGFydE5vZGUtPnJvb3RFZGl0YWJsZUVsZW1lbnQoKSAmJiBjb21w b3NpdGlvblR5cGUgIT0gVGV4dENvbXBvc2l0aW9uVXBkYXRlKSB7CiAgICAgICAgIC8vIFNlbmQg QmVmb3JlVGV4dEluc2VydGVkRXZlbnQuIFRoZSBldmVudCBoYW5kbGVyIHdpbGwgdXBkYXRlIHRl eHQgaWYgbmVjZXNzYXJ5LgogICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKICAgICAgICAg UmVmUHRyPEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50PiBldnQgPSBCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudDo6Y3JlYXRlKHRleHQpOwpAQCAtMTgyLDExICsxODQsMTMgQEAgdm9pZCBUeXBpbmdDb21t YW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBj b25zdCBWaXMKICAgICAgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRTdGFydGluZ1NlbGVj dGlvbihzZWxlY3Rpb25Gb3JJbnNlcnRpb24pOwogICAgICAgICAgICAgbGFzdFR5cGluZ0NvbW1h bmQtPnNldEVuZGluZ1NlbGVjdGlvbihzZWxlY3Rpb25Gb3JJbnNlcnRpb24pOwogICAgICAgICB9 CisgICAgICAgIAorICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+c2V0Q29tcG9zaXRpb25UeXBl KGNvbXBvc2l0aW9uVHlwZSk7CiAgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5pbnNlcnRUZXh0 KG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAK LSAgICBSZWZQdHI8VHlwaW5nQ29tbWFuZD4gY21kID0gVHlwaW5nQ29tbWFuZDo6Y3JlYXRlKGRv Y3VtZW50LCBJbnNlcnRUZXh0LCBuZXdUZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQpOworICAgIFJl ZlB0cjxUeXBpbmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21tYW5kOjpjcmVhdGUoZG9jdW1lbnQs IEluc2VydFRleHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCwgY29tcG9zaXRpb25UeXBl KTsKICAgICBpZiAoY2hhbmdlU2VsZWN0aW9uKSAgewogICAgICAgICBjbWQtPnNldFN0YXJ0aW5n U2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgIGNtZC0+c2V0RW5kaW5n U2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CkBAIC0zODYsNyArMzkwLDggQEAgdm9p ZCBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0UnVuV2l0aG91dE5ld2xpbmVzKGNvbnN0IFN0cmlu ZyAmdGV4dCwgYm9vbCBzZWxlY3QKICAgICAgICAgY29tbWFuZC0+c2V0U3RhcnRpbmdTZWxlY3Rp b24oZW5kaW5nU2VsZWN0aW9uKCkpOwogICAgICAgICBjb21tYW5kLT5zZXRFbmRpbmdTZWxlY3Rp b24oZW5kaW5nU2VsZWN0aW9uKCkpOwogICAgIH0KLSAgICBjb21tYW5kLT5pbnB1dCh0ZXh0LCBz ZWxlY3RJbnNlcnRlZFRleHQpOworICAgIGNvbW1hbmQtPmlucHV0KHRleHQsIHNlbGVjdEluc2Vy dGVkVGV4dCwgCisgICAgICAgICAgICAgICAgICAgbV9jb21wb3NpdGlvblR5cGUgPT0gVGV4dENv bXBvc2l0aW9uTm9uZSA/IEluc2VydFRleHRDb21tYW5kOjpSZWJhbGFuY2VMZWFkaW5nQW5kVHJh aWxpbmdXaGl0ZXNwYWNlcyA6IEluc2VydFRleHRDb21tYW5kOjpSZWJhbGFuY2VBbGxXaGl0ZXNw YWNlcyk7CiAgICAgdHlwaW5nQWRkZWRUb09wZW5Db21tYW5kKEluc2VydFRleHQpOwogfQogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuaCBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oCmluZGV4IDI4NGViYzBhYzI2NWQ3NmIx NmE4MGJmMjYxMWM3YTgwZTY4MGFkMGYuLmIzNGJkYzEyMjFhMjJhMzAxMjRhOTA4ODAxMGMwNTQ2 NTFiZmRlNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFu ZC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oCkBAIC00Miwx MSArNDIsMTcgQEAgcHVibGljOgogICAgICAgICBJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JJblF1 b3RlZENvbnRlbnQKICAgICB9OwogCisgICAgZW51bSBUZXh0Q29tcG9zaXRpb25UeXBlIHsKKyAg ICAgICAgVGV4dENvbXBvc2l0aW9uTm9uZSwKKyAgICAgICAgVGV4dENvbXBvc2l0aW9uVXBkYXRl LAorICAgICAgICBUZXh0Q29tcG9zaXRpb25Db25maXJtCisgICAgfTsKKwogICAgIHN0YXRpYyB2 b2lkIGRlbGV0ZVNlbGVjdGlvbihEb2N1bWVudCosIGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSk7 CiAgICAgc3RhdGljIHZvaWQgZGVsZXRlS2V5UHJlc3NlZChEb2N1bWVudCosIGJvb2wgc21hcnRE ZWxldGUgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGJv b2wga2lsbFJpbmcgPSBmYWxzZSk7CiAgICAgc3RhdGljIHZvaWQgZm9yd2FyZERlbGV0ZUtleVBy ZXNzZWQoRG9jdW1lbnQqLCBib29sIHNtYXJ0RGVsZXRlID0gZmFsc2UsIFRleHRHcmFudWxhcml0 eSA9IENoYXJhY3RlckdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nID0gZmFsc2UpOwotICAgIHN0 YXRpYyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBib29sIHNlbGVj dEluc2VydGVkVGV4dCA9IGZhbHNlLCBib29sIGluc2VydGVkVGV4dElzQ29tcG9zaXRpb24gPSBm YWxzZSk7Ci0gICAgc3RhdGljIHZvaWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmlu ZyYsIGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZh bHNlLCBib29sIGluc2VydGVkVGV4dElzQ29tcG9zaXRpb24gPSBmYWxzZSk7CisgICAgc3RhdGlj IHZvaWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0ID0gZmFsc2UsIFRleHRDb21wb3NpdGlvblR5cGUgPSBUZXh0Q29tcG9zaXRpb25O b25lKTsKKyAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5n JiwgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFs c2UsIFRleHRDb21wb3NpdGlvblR5cGUgPSBUZXh0Q29tcG9zaXRpb25Ob25lKTsKICAgICBzdGF0 aWMgdm9pZCBpbnNlcnRMaW5lQnJlYWsoRG9jdW1lbnQqKTsKICAgICBzdGF0aWMgdm9pZCBpbnNl cnRQYXJhZ3JhcGhTZXBhcmF0b3IoRG9jdW1lbnQqKTsKICAgICBzdGF0aWMgdm9pZCBpbnNlcnRQ YXJhZ3JhcGhTZXBhcmF0b3JJblF1b3RlZENvbnRlbnQoRG9jdW1lbnQqKTsKQEAgLTY0LDE0ICs3 MCwyMCBAQCBwdWJsaWM6CiAgICAgdm9pZCBkZWxldGVLZXlQcmVzc2VkKFRleHRHcmFudWxhcml0 eSwgYm9vbCBraWxsUmluZyk7CiAgICAgdm9pZCBmb3J3YXJkRGVsZXRlS2V5UHJlc3NlZChUZXh0 R3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcpOwogICAgIHZvaWQgZGVsZXRlU2VsZWN0aW9uKGJv b2wgc21hcnREZWxldGUpOworICAgIHZvaWQgc2V0Q29tcG9zaXRpb25UeXBlKFRleHRDb21wb3Np dGlvblR5cGUgdHlwZSkgeyBtX2NvbXBvc2l0aW9uVHlwZSA9IHR5cGU7IH0KIAogcHJpdmF0ZToK ICAgICBzdGF0aWMgUGFzc1JlZlB0cjxUeXBpbmdDb21tYW5kPiBjcmVhdGUoRG9jdW1lbnQqIGRv Y3VtZW50LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kLCBjb25zdCBTdHJpbmcmIHRleHQgPSAiIiwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFy aXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBmYWxzZSkKICAgICB7 Ci0gICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgVHlwaW5nQ29tbWFuZChkb2N1bWVudCwgY29t bWFuZCwgdGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBncmFudWxhcml0eSwga2lsbFJpbmcpKTsK KyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21t YW5kLCB0ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5LCBUZXh0Q29tcG9zaXRp b25Ob25lLCBraWxsUmluZykpOworICAgIH0KKworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFR5cGlu Z0NvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQsIEVUeXBpbmdDb21tYW5kIGNvbW1h bmQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRDb21w b3NpdGlvblR5cGUgY29tcG9zaXRpb25UeXBlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5kLCB0ZXh0LCBzZWxlY3RJbnNl cnRlZFRleHQsIENoYXJhY3RlckdyYW51bGFyaXR5LCBjb21wb3NpdGlvblR5cGUsIGZhbHNlKSk7 CiAgICAgfQogCi0gICAgVHlwaW5nQ29tbWFuZChEb2N1bWVudCosIEVUeXBpbmdDb21tYW5kLCBj b25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJp dHksIGJvb2wga2lsbFJpbmcpOworICAgIFR5cGluZ0NvbW1hbmQoRG9jdW1lbnQqLCBFVHlwaW5n Q29tbWFuZCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4 dEdyYW51bGFyaXR5LCBUZXh0Q29tcG9zaXRpb25UeXBlLCBib29sIGtpbGxSaW5nKTsKIAogICAg IGJvb2wgc21hcnREZWxldGUoKSBjb25zdCB7IHJldHVybiBtX3NtYXJ0RGVsZXRlOyB9CiAgICAg dm9pZCBzZXRTbWFydERlbGV0ZShib29sIHNtYXJ0RGVsZXRlKSB7IG1fc21hcnREZWxldGUgPSBz bWFydERlbGV0ZTsgfQpAQCAtOTQsNiArMTA2LDcgQEAgcHJpdmF0ZToKICAgICBib29sIG1fc2Vs ZWN0SW5zZXJ0ZWRUZXh0OwogICAgIGJvb2wgbV9zbWFydERlbGV0ZTsKICAgICBUZXh0R3JhbnVs YXJpdHkgbV9ncmFudWxhcml0eTsKKyAgICBUZXh0Q29tcG9zaXRpb25UeXBlIG1fY29tcG9zaXRp b25UeXBlOwogICAgIGJvb2wgbV9raWxsUmluZzsKICAgICBib29sIG1fcHJlc2VydmVzVHlwaW5n U3R5bGU7CiAgICAgCg== 79886 2011-01-23 17:38:39 -0800 2011-01-23 22:39:11 -0800 Patch bug-5241-20110124103837.patch text/plain 29895 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1OGM1NWVlNjMxNDE0NDFlYWVmNWY4MTFmMjM5NDcyNjdmMjVmYmM2Li41ZjM4MTRk YTVhNTI3OTI0NWJiNWE5ZDBhMmYxNmQ5YThiOGEzODUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTkgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgUnlvc3VrZSBOaXdhLgorCisgICAgICAgIFNwYWNlIGFuZCB0YWIgY2hh cmFjdGVycyAic2VudCIgYnkgYW4gaW5wdXQgbWV0aG9kIGdpdmUgdG90YWxseSBkaWZmZXJlbnQg cmVzdWx0cyB0aGFuIHR5cGluZyB0aGVtIGRpcmVjdGx5LgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0MQorICAgICAgICAKKyAgICAgICAgQWRkZWQg YSB0ZXN0IHRoYXQgZXhlcmNpc2VzIGNvbnRpbm91cyB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMgYW5k IHRhYnMgaW5zZXJ0ZWQgYnkgSU1FLgorCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvaW5z ZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAg KiBlZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sOiBB ZGRlZC4KKwogMjAxMS0wMS0yMyAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlv bi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MDg3Y2E0YzkxZTM2ZmJiMzEy MWQ4YjQzYzJhNmU4YjBlYzcyYmM5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsNDkgQEAKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQicKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoEInCitQ QVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoCBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMg J0EgwqAgwqBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgQUInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnwqDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgQUInCitQ QVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ8KgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoCDCoEFCJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgwqAgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5n VGV4dCBpcyAnQUIgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgwqDCoCcKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdB QiDCoCDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgJworUEFTUyBj b21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgIMKgwqAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBp cyAnwqDCoEEgwqBCIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqBBIMKgQiDCoCcK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfC oMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqDCoCcKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICdBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnQSAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBICAgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBICAgIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0 IGlzICdBQiAgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQUIgICAgICcKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBQiAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAg ICAgICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICBBQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICcgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgQUInCitQQVNTIGNv bXBvc2l0aW5nVGV4dCBpcyAnICAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAg ICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgICAgQUInCitQQVNTIGNvbXBvc2l0 aW5nVGV4dCBpcyAnICBBICBCICAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnCQlBCQlCCQkn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAnCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNjk5YjkzOTUxZGNkNzdjNzMwMDIyZDI5NDliNjdlYjljODQ1NTM2YQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1j b21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0bWwKQEAgLTAsMCArMSw5OCBAQAorPCFET0NUWVBFIEhU TUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5r IHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qt cHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48 L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQ+CisKK3ZhciBzZWwgPSBkb2N1 bWVudC5nZXRTZWxlY3Rpb24oKTsKK3ZhciByb290ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgi cm9vdCIpOworZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChyb290KTsKKworCitmdW5jdGlvbiBj cmVhdGVFZGl0YWJsZSh0YWdOYW1lLCB0ZXh0KSB7CisgICAgdmFyIG5vZGUgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KHRhZ05hbWUpOworICAgIG5vZGUuY29udGVudEVkaXRhYmxlID0gdHJ1ZTsK KyAgICBub2RlLmlubmVySFRNTCA9IHRleHQ7CisgICAgcmV0dXJuIG5vZGU7Cit9CisKK2Z1bmN0 aW9uIHRlc3QodGFnTmFtZSwgY29tcG9zaXRpb25UZXh0LCBleHBlY3RlZCkgeworICAgIHZhciBu b2RlID0gY3JlYXRlRWRpdGFibGUodGFnTmFtZSwgIlgiKTsKKyAgICByb290LmFwcGVuZENoaWxk KG5vZGUpOworCisgICAgdmFyIHRleHROb2RlID0gbm9kZS5maXJzdENoaWxkOworICAgIHNlbC5z ZXRCYXNlQW5kRXh0ZW50KHRleHROb2RlLCAwLCB0ZXh0Tm9kZSwgdGV4dE5vZGUuZGF0YS5sZW5n dGgpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCJEZWxldGUiLCBmYWxzZSk7CisKKyAgICB0 ZXh0SW5wdXRDb250cm9sbGVyLnNldE1hcmtlZFRleHQoY29tcG9zaXRpb25UZXh0LCAwLCBjb21w b3NpdGlvblRleHQubGVuZ3RoKTsKKyAgICBjb21wb3NpdGluZ1RleHQgPSBub2RlLmlubmVyVGV4 dDsKKyAgICB0ZXh0SW5wdXRDb250cm9sbGVyLnVubWFya1RleHQoKTsKKyAgICBjb25maXJtZWRU ZXh0ID0gbm9kZS5pbm5lclRleHQ7CisKKyAgICBzaG91bGRCZSgiY29tcG9zaXRpbmdUZXh0Iiwg IiciICsgZXhwZWN0ZWQgKyAiJyIpOworfQorCit0ZXN0KCJkaXYiLCAiQUIiLCAiQUIiKTsKK3Rl c3QoImRpdiIsICJBIEIiLCAiQSBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgQiIsICJBIFx4QTBCIik7 Cit0ZXN0KCJkaXYiLCAiQSAgIEIiLCAiQSBceEEwIEIiKTsKK3Rlc3QoImRpdiIsICJBICAgIEIi LCAiQSBceEEwIFx4QTBCIik7IAorCit0ZXN0KCJkaXYiLCAiIEFCIiwgIlx4QTBBQiIpOwordGVz dCgiZGl2IiwgIiAgQUIiLCAiXHhBMFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgIEFCIiwgIlx4 QTBceEEwIEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgIEFCIiwgIlx4QTBceEEwIFx4QTBBQiIpOwor dGVzdCgiZGl2IiwgIiAgICAgQUIiLCAiXHhBMFx4QTAgXHhBMCBBQiIpOwordGVzdCgiZGl2Iiwg IiAgICAgIEFCIiwgIlx4QTBceEEwIFx4QTAgXHhBMEFCIik7Cit0ZXN0KCJkaXYiLCAiICAgICAg IEFCIiwgIlx4QTBceEEwIFx4QTAgXHhBMCBBQiIpOwordGVzdCgiZGl2IiwgIkFCICAiLCAiQUIg XHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgIiwgIkFCIFx4QTBceEEwIik7Cit0ZXN0KCJkaXYi LCAiQUIgICAgIiwgIkFCIFx4QTAgXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICAiLCAiQUIg XHhBMCBceEEwXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICAgIiwgIkFCIFx4QTAgXHhBMCBc eEEwIik7Cit0ZXN0KCJkaXYiLCAiQUIgICAgICAgIiwgIkFCIFx4QTAgXHhBMCBceEEwXHhBMCIp OworCit0ZXN0KCJkaXYiLCAiICBBICBCICAiLCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKK3Rl c3QoImRpdiIsICJcdFx0QVx0XHRCXHRcdCIsICJceEEwXHhBMEEgXHhBMEIgXHhBMCIpOworCit0 ZXN0KCJkaXYiLCAiICIsICJceEEwIik7Cit0ZXN0KCJkaXYiLCAiICAiLCAiXHhBMFx4QTAiKTsK Ky8vIFRoaXMgaXMgd3JvbmcuIFRoaXMgc2hvdWxkIGluc2VydCBpbnRlcmxlYXZlZCBuYnNwIGFu ZCB3aGl0ZXNwYWNlLiBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTUyNzgxLgordGVzdCgiZGl2IiwgIiAgICIsICJceEEwXHhBMFx4QTAiKTsKKwordGVzdCgicHJl IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJwcmUiLCAiQSBCIiwgIkEgQiIpOwordGVzdCgicHJlIiwg IkEgIEIiLCAiQSAgQiIpOwordGVzdCgicHJlIiwgIkEgICBCIiwgIkEgICBCIik7Cit0ZXN0KCJw cmUiLCAiQSAgICBCIiwgIkEgICAgQiIpOwordGVzdCgicHJlIiwgIkFCICAiLCAiQUIgICIpOwor dGVzdCgicHJlIiwgIkFCICAgIiwgIkFCICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgIiwgIkFC ICAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICAiLCAiQUIgICAgICIpOwordGVzdCgicHJlIiwg IkFCICAgICAgIiwgIkFCICAgICAgIik7Cit0ZXN0KCJwcmUiLCAiQUIgICAgICAgIiwgIkFCICAg ICAgICIpOwordGVzdCgicHJlIiwgIiAgQUIiLCAiICBBQiIpOwordGVzdCgicHJlIiwgIiAgIEFC IiwgIiAgIEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgIEFCIiwgIiAgICBBQiIpOwordGVzdCgicHJl IiwgIiAgICAgQUIiLCAiICAgICBBQiIpOwordGVzdCgicHJlIiwgIiAgICAgIEFCIiwgIiAgICAg IEFCIik7Cit0ZXN0KCJwcmUiLCAiICAgICAgIEFCIiwgIiAgICAgICBBQiIpOworCit0ZXN0KCJw cmUiLCAiICBBICBCICAiLCAiICBBICBCICAiKTsKK3Rlc3QoInByZSIsICJcdFx0QVx0XHRCXHRc dCIsICJcdFx0QVx0XHRCXHRcdCIpOwordGVzdCgicHJlIiwgIiAiLCAiICIpOwordGVzdCgicHJl IiwgIiAgIiwgIiAgIik7Cit0ZXN0KCJwcmUiLCAiICAgIiwgIiAgICIpOworCityb290LnN0eWxl LmRpc3BsYXkgPSAibm9uZSI7CitzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworCis8L3Njcmlw dD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMi Pjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDIyYjg2MDliZTk2NGZm ZjU3MmRiYzRkZjUyOThmZDgxZmRhOGMyYzkuLjQyNzA0ODYwMzZiZTRiMDI3YzgyNTYxMTI3Zjgy MTg4ZmU1MDBlMzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAorMjAxMS0wMS0xOSAgTU9S SVRBIEhhamltZSAgPG1vcnJpdGFAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBS eW9zdWtlIE5pd2EuCisKKyAgICAgICAgU3BhY2UgYW5kIHRhYiBjaGFyYWN0ZXJzICJzZW50IiBi eSBhbiBpbnB1dCBtZXRob2QgZ2l2ZSB0b3RhbGx5IGRpZmZlcmVudCByZXN1bHRzIHRoYW4gdHlw aW5nIHRoZW0gZGlyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTUyNDEKKyAgICAgICAgCisgICAgICAgICogSW50cm9kdWNlZCBUZXh0RXZlbnQ6 OklucHV0VHlwZUNvbXBvc2l0aW9uIGFuZCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25U eXBlIHRvIAorICAgICAgICAgIGRpc3Rpbmd1aXNoIHRleHQgaW5wdXQgd2hpY2ggaXMgb3JpZ2lu YXRlZCBieSBjb21wb3NpdGlvbi4KKyAgICAgICAgKiBHZW5lcmFsaXplZCByZWJhbGFuY2VXaGl0 ZXNwYWNlQXQoKSB0byByZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKCkgdG8gcmVi YWxhbmNpbmcgCisgICAgICAgICAgcmFuZ2Ugb2Ygc3RyaW5nIG9uIHRleHQgbm9kZSwgaW5zdGVh ZCBvZiBzdXJyb3VuZGluZyBwYXJ0IG9mIHRoYXQuCisKKyAgICAgICAgVGVzdDogZWRpdGluZy9p bnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UuaHRtbAorCisgICAgICAgICog ZG9tL1RleHRFdmVudC5oOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEV2ZW50Ojppc0NvbXBvc2l0 aW9uKToKKyAgICAgICAgKiBkb20vVGV4dEV2ZW50SW5wdXRUeXBlLmg6IEFkZGVkIFRleHRFdmVu dElucHV0Q29tcG9zaXRpb24gYXMgYSBtZW1iZXIgb2YgVGV4dEV2ZW50OjpJbnB1dFR5cGUKKyAg ICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmNvbnRhaW5zT25seVdoaXRlc3BhY2UpOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRl RWRpdENvbW1hbmQ6OnNob3VsZFJlYmFsYW5jZUxlYWRpbmdXaGl0ZXNwYWNlRm9yKToKKyAgICAg ICAgKFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpjYW5SZWJhbGFuY2UpOgorICAgICAg ICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3BhY2VBdCk6 CisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVz cGFjZU9uVGV4dFN1YnN0cmluZyk6IEFkZGVkOiBBIGdlbmVyYWxpemVkIHZlcnNpb24gb2YgcmVi YWxhbmNlV2hpdGVzcGFjZUF0KCksIHdoaWNoIHRha2VzIGEgcmFuZ2UgaW5zaWRlIFRleHQgc3Ry aW5nLgorICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaDoKKyAgICAgICAg KiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6Omluc2VydFRl eHRGb3JDb25maXJtZWRDb21wb3NpdGlvbik6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6RWRp dG9yOjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQpOgorICAgICAgICAoV2ViQ29y ZTo6RWRpdG9yOjpjb25maXJtQ29tcG9zaXRpb24pOiBOb3cgdXNlcyBpbnNlcnRUZXh0Rm9yQ29u ZmlybWVkQ29tcG9zaXRpb24oKS4KKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6c2V0Q29tcG9z aXRpb24pOgorICAgICAgICAqIGVkaXRpbmcvRWRpdG9yLmg6CisgICAgICAgICogZWRpdGluZy9J bnNlcnRUZXh0Q29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRUZXh0Q29tbWFu ZDo6aW5wdXQpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaDoKKyAgICAg ICAgKiBlZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5n Q29tbWFuZDo6VHlwaW5nQ29tbWFuZCk6CisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5k OjppbnNlcnRUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6Omluc2VydFRl eHRSdW5XaXRob3V0TmV3bGluZXMpOgorICAgICAgICAqIGVkaXRpbmcvVHlwaW5nQ29tbWFuZC5o OiBBZGRlZCBUeXBpbmdDb21tYW5kOjptX2NvbXBvc2l0aW9uVHlwZSBhbmQgVHlwaW5nQ29tbWFu ZDo6VGV4dENvbXBvc2l0aW9uVHlwZQorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6 c2V0Q29tcG9zaXRpb25UeXBlKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpUeXBpbmdDb21t YW5kOjpjcmVhdGUpOgorCiAyMDExLTAxLTIzICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9nYUB3 ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1Rl eHRFdmVudC5oCmluZGV4IGQ3NzBkMzg4NDQzNDBmNjg0MDUyN2I4YzdjMTQ5ZWZmOWJkYzBiN2Eu LjI2YzhiOTNkNDEwMjI4MzVkNDY1MzA0MDk3ZTJhYTJhMWUwM2E5YjggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4 dEV2ZW50LmgKQEAgLTUxLDYgKzUxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2 aXJ0dWFsIGJvb2wgaXNUZXh0RXZlbnQoKSBjb25zdDsKIAogICAgICAgICBib29sIGlzTGluZUJy ZWFrKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUgPT0gVGV4dEV2ZW50SW5wdXRMaW5lQnJl YWs7IH0KKyAgICAgICAgYm9vbCBpc0NvbXBvc2l0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1 dFR5cGUgPT0gVGV4dEV2ZW50SW5wdXRDb21wb3NpdGlvbjsgfQogICAgICAgICBib29sIGlzQmFj a1RhYigpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IFRleHRFdmVudElucHV0QmFja1Rh YjsgfQogICAgICAgICBib29sIGlzUGFzdGUoKSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZSA9 PSBUZXh0RXZlbnRJbnB1dFBhc3RlOyB9CiAgICAgICAgIGJvb2wgaXNEcm9wKCkgY29uc3QgeyBy ZXR1cm4gbV9pbnB1dFR5cGUgPT0gVGV4dEV2ZW50SW5wdXREcm9wOyB9CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9kb20vVGV4dEV2ZW50SW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9k b20vVGV4dEV2ZW50SW5wdXRUeXBlLmgKaW5kZXggMjUyMmVjNDVmZjdmODE5MWY3NDU5MGJiZDg5 OTM2M2U3Mjc0ZTY4NS4uZjVhMDVlYjcwMDRkZDgzYjhlMzFmZWEyNTI1YWI0ZTFkZTJlMWUyMiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudElucHV0VHlwZS5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnRJbnB1dFR5cGUuaApAQCAtMzEsNiArMzEsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBlbnVtIFRleHRFdmVudElucHV0VHlwZSB7CiAgICAgVGV4 dEV2ZW50SW5wdXRLZXlib2FyZCwgLy8gYW55IG5ld2xpbmUgY2hhcmFjdGVycyBpbiB0aGUgdGV4 dCBhcmUgbGluZSBicmVha3Mgb25seSwgbm90IHBhcmFncmFwaCBzZXBhcmF0b3JzLgogICAgIFRl eHRFdmVudElucHV0TGluZUJyZWFrLCAvLyBhbnkgdGFiIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQg YXJlIGJhY2t0YWJzLgorICAgIFRleHRFdmVudElucHV0Q29tcG9zaXRpb24sCiAgICAgVGV4dEV2 ZW50SW5wdXRCYWNrVGFiLAogICAgIFRleHRFdmVudElucHV0UGFzdGUsCiAgICAgVGV4dEV2ZW50 SW5wdXREcm9wLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVF ZGl0Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21t YW5kLmNwcAppbmRleCA1NTJlZDc5NGYxNDg0N2M1MzBkMmY4YThmN2MyMTFlOWUwZGMzNzEwLi4z OTI4MGQ0YzExOGRhOWM5NWUzZGY1ZGRmOTY1MDI0ZGY5ZThkZGFiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcApAQCAtMzk1LDUyICszOTUs ODQgQEAgc3RhdGljIGlubGluZSBib29sIGlzV2hpdGVzcGFjZShVQ2hhciBjKQogICAgIHJldHVy biBjID09IG5vQnJlYWtTcGFjZSB8fCBjID09ICcgJyB8fCBjID09ICdcbicgfHwgYyA9PSAnXHQn OwogfQogCi0vLyBGSVhNRTogRG9lc24ndCBnbyBpbnRvIHRleHQgbm9kZXMgdGhhdCBjb250cmli dXRlIGFkamFjZW50IHRleHQgKHNpYmxpbmdzLCBjb3VzaW5zLCBldGMpLgotdm9pZCBDb21wb3Np dGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0aW9uJiBwb3Np dGlvbikKK3N0YXRpYyBpbmxpbmUgYm9vbCBjb250YWluc09ubHlXaGl0ZXNwYWNlKGNvbnN0IFN0 cmluZyYgdGV4dCkKK3sKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdGV4dC5sZW5ndGgo KTsgKytpKSB7CisgICAgICAgIGlmICghaXNXaGl0ZXNwYWNlKHRleHQuY2hhcmFjdGVycygpW2ld KSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgCisgICAgcmV0dXJuIHRy dWU7Cit9CisKK2Jvb2wgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnNob3VsZFJlYmFsYW5jZUxlYWRp bmdXaGl0ZXNwYWNlRm9yKGNvbnN0IFN0cmluZyYgdGV4dCkgY29uc3QKK3sKKyAgICByZXR1cm4g Y29udGFpbnNPbmx5V2hpdGVzcGFjZSh0ZXh0KTsKK30KKworYm9vbCBDb21wb3NpdGVFZGl0Q29t bWFuZDo6Y2FuUmViYWxhbmNlKGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlvbikgY29uc3QKIHsKICAg ICBOb2RlKiBub2RlID0gcG9zaXRpb24uY29udGFpbmVyTm9kZSgpOwogICAgIGlmIChwb3NpdGlv bi5hbmNob3JUeXBlKCkgIT0gUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvciB8fCAh bm9kZSB8fCAhbm9kZS0+aXNUZXh0Tm9kZSgpKQotICAgICAgICByZXR1cm47Ci0gICAgVGV4dCog dGV4dE5vZGUgPSBzdGF0aWNfY2FzdDxUZXh0Kj4obm9kZSk7CisgICAgICAgIHJldHVybiBmYWxz ZTsKIAorICAgIFRleHQqIHRleHROb2RlID0gc3RhdGljX2Nhc3Q8VGV4dCo+KG5vZGUpOwogICAg IGlmICh0ZXh0Tm9kZS0+bGVuZ3RoKCkgPT0gMCkKLSAgICAgICAgcmV0dXJuOworICAgICAgICBy ZXR1cm4gZmFsc2U7CisKICAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gdGV4dE5vZGUtPnJl bmRlcmVyKCk7CiAgICAgaWYgKHJlbmRlcmVyICYmICFyZW5kZXJlci0+c3R5bGUoKS0+Y29sbGFw c2VXaGl0ZVNwYWNlKCkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwog Ci0gICAgU3RyaW5nIHRleHQgPSB0ZXh0Tm9kZS0+ZGF0YSgpOwotICAgIEFTU0VSVCghdGV4dC5p c0VtcHR5KCkpOworICAgIHJldHVybiB0cnVlOworfQorCisvLyBGSVhNRTogRG9lc24ndCBnbyBp bnRvIHRleHQgbm9kZXMgdGhhdCBjb250cmlidXRlIGFkamFjZW50IHRleHQgKHNpYmxpbmdzLCBj b3VzaW5zLCBldGMpLgordm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVz cGFjZUF0KGNvbnN0IFBvc2l0aW9uJiBwb3NpdGlvbikKK3sKKyAgICBOb2RlKiBub2RlID0gcG9z aXRpb24uY29udGFpbmVyTm9kZSgpOworICAgIGlmICghY2FuUmViYWxhbmNlKHBvc2l0aW9uKSkK KyAgICAgICAgcmV0dXJuOwogCisgICAgLy8gSWYgdGhlIHJlYmFsYW5jZSBpcyBmb3IgdGhlIHNp bmdsZSBvZmZzZXQsIGFuZCBuZWl0aGVyIHRleHRbb2Zmc2V0XSBub3IgdGV4dFtvZmZzZXQgLSAx XSBhcmUgc29tZSBmb3JtIG9mIHdoaXRlc3BhY2UsIGRvIG5vdGhpbmcuCiAgICAgaW50IG9mZnNl dCA9IHBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCk7Ci0gICAgLy8gSWYgbmVpdGhl ciB0ZXh0W29mZnNldF0gbm9yIHRleHRbb2Zmc2V0IC0gMV0gYXJlIHNvbWUgZm9ybSBvZiB3aGl0 ZXNwYWNlLCBkbyBub3RoaW5nLgorICAgIFN0cmluZyB0ZXh0ID0gc3RhdGljX2Nhc3Q8VGV4dCo+ KG5vZGUpLT5kYXRhKCk7CiAgICAgaWYgKCFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkgewog ICAgICAgICBvZmZzZXQtLTsKICAgICAgICAgaWYgKG9mZnNldCA8IDAgfHwgIWlzV2hpdGVzcGFj ZSh0ZXh0W29mZnNldF0pKQogICAgICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICAKKworICAg IHJlYmFsYW5jZVdoaXRlc3BhY2VPblRleHRTdWJzdHJpbmcoc3RhdGljX2Nhc3Q8VGV4dCo+KG5v ZGUpLCBwb3NpdGlvbi5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSwgcG9zaXRpb24ub2Zmc2V0SW5D b250YWluZXJOb2RlKCkpOworfQorCit2b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjpyZWJhbGFu Y2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKFJlZlB0cjxUZXh0PiB0ZXh0Tm9kZSwgaW50IHN0 YXJ0T2Zmc2V0LCBpbnQgZW5kT2Zmc2V0KQoreworICAgIFN0cmluZyB0ZXh0ID0gdGV4dE5vZGUt PmRhdGEoKTsKKyAgICBBU1NFUlQoIXRleHQuaXNFbXB0eSgpKTsKKwogICAgIC8vIFNldCB1cHN0 cmVhbSBhbmQgZG93bnN0cmVhbSB0byBkZWZpbmUgdGhlIGV4dGVudCBvZiB0aGUgd2hpdGVzcGFj ZSBzdXJyb3VuZGluZyB0ZXh0W29mZnNldF0uCi0gICAgaW50IHVwc3RyZWFtID0gb2Zmc2V0Owor ICAgIGludCB1cHN0cmVhbSA9IHN0YXJ0T2Zmc2V0OwogICAgIHdoaWxlICh1cHN0cmVhbSA+IDAg JiYgaXNXaGl0ZXNwYWNlKHRleHRbdXBzdHJlYW0gLSAxXSkpCiAgICAgICAgIHVwc3RyZWFtLS07 CiAgICAgCi0gICAgaW50IGRvd25zdHJlYW0gPSBvZmZzZXQ7Ci0gICAgd2hpbGUgKCh1bnNpZ25l ZClkb3duc3RyZWFtICsgMSA8IHRleHQubGVuZ3RoKCkgJiYgaXNXaGl0ZXNwYWNlKHRleHRbZG93 bnN0cmVhbSArIDFdKSkKKyAgICBpbnQgZG93bnN0cmVhbSA9IGVuZE9mZnNldDsKKyAgICB3aGls ZSAoKHVuc2lnbmVkKWRvd25zdHJlYW0gPCB0ZXh0Lmxlbmd0aCgpICYmIGlzV2hpdGVzcGFjZSh0 ZXh0W2Rvd25zdHJlYW1dKSkKICAgICAgICAgZG93bnN0cmVhbSsrOwogICAgIAotICAgIGludCBs ZW5ndGggPSBkb3duc3RyZWFtIC0gdXBzdHJlYW0gKyAxOwotICAgIEFTU0VSVChsZW5ndGggPiAw KTsKLSAgICAKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0aW9u KHBvc2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgdXBzdHJlYW0sIFBvc2l0aW9uOjpQb3NpdGlvbklz T2Zmc2V0SW5BbmNob3IpKTsKLSAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZURvd25zdHJlYW1Q b3MoUG9zaXRpb24ocG9zaXRpb24uY29udGFpbmVyTm9kZSgpLCBkb3duc3RyZWFtICsgMSwgUG9z aXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOworICAgIGludCBsZW5ndGggPSBkb3du c3RyZWFtIC0gdXBzdHJlYW07CisgICAgaWYgKCFsZW5ndGgpCisgICAgICAgIHJldHVybjsKKwor ICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxlVXBzdHJlYW1Qb3MoUG9zaXRpb24odGV4dE5vZGUs IHVwc3RyZWFtLCBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9yKSk7CisgICAgVmlz aWJsZVBvc2l0aW9uIHZpc2libGVEb3duc3RyZWFtUG9zKFBvc2l0aW9uKHRleHROb2RlLCBkb3du c3RyZWFtLCBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9yKSk7CiAgICAgCiAgICAg U3RyaW5nIHN0cmluZyA9IHRleHQuc3Vic3RyaW5nKHVwc3RyZWFtLCBsZW5ndGgpOwogICAgIFN0 cmluZyByZWJhbGFuY2VkU3RyaW5nID0gc3RyaW5nV2l0aFJlYmFsYW5jZWRXaGl0ZXNwYWNlKHN0 cmluZywKICAgICAvLyBGSVhNRTogQmVjYXVzZSBvZiB0aGUgcHJvYmxlbSBtZW50aW9uZWQgYXQg dGhlIHRvcCBvZiB0aGlzIGZ1bmN0aW9uLCB3ZSBtdXN0IGFsc28gdXNlIG5ic3BzIGF0IHRoZSBz dGFydC9lbmQgb2YgdGhlIHN0cmluZyBiZWNhdXNlCiAgICAgLy8gdGhpcyBmdW5jdGlvbiBkb2Vz bid0IGdldCBhbGwgc3Vycm91bmRpbmcgd2hpdGVzcGFjZSwganVzdCB0aGUgd2hpdGVzcGFjZSBp biB0aGUgY3VycmVudCB0ZXh0IG5vZGUuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXNTdGFydE9mUGFyYWdyYXBoKHZpc2libGVV cHN0cmVhbVBvcykgfHwgdXBzdHJlYW0gPT0gMCwgCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXNFbmRPZlBhcmFncmFwaCh2aXNp YmxlRG93bnN0cmVhbVBvcykgfHwgKHVuc2lnbmVkKWRvd25zdHJlYW0gPT0gdGV4dC5sZW5ndGgo KSAtIDEpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGlzRW5kT2ZQYXJhZ3JhcGgodmlzaWJsZURvd25zdHJlYW1Qb3MpIHx8ICh1 bnNpZ25lZClkb3duc3RyZWFtID09IHRleHQubGVuZ3RoKCkpOwogICAgIAogICAgIGlmIChzdHJp bmcgIT0gcmViYWxhbmNlZFN0cmluZykKICAgICAgICAgcmVwbGFjZVRleHRJbk5vZGUodGV4dE5v ZGUsIHVwc3RyZWFtLCBsZW5ndGgsIHJlYmFsYW5jZWRTdHJpbmcpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCmluZGV4IDZkYjRlYjE4MmEwODg2YWQx ZmQ4MGIwNGU4YzFjNmYzNjFjYjAzMDAuLjkwNjZiNjUyNTI2MDU1NWM4ZDhiMzI4OGZhNzNkOTI5 MWFlNGJkNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21t YW5kLmgKQEAgLTcxLDcgKzcxLDEwIEBAIHByb3RlY3RlZDoKICAgICB2b2lkIG1lcmdlSWRlbnRp Y2FsRWxlbWVudHMoUGFzc1JlZlB0cjxFbGVtZW50PiwgUGFzc1JlZlB0cjxFbGVtZW50Pik7CiAg ICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlKCk7CiAgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNw YWNlQXQoY29uc3QgUG9zaXRpb24mKTsKKyAgICB2b2lkIHJlYmFsYW5jZVdoaXRlc3BhY2VPblRl eHRTdWJzdHJpbmcoUmVmUHRyPFRleHQ+LCBpbnQgc3RhcnRPZmZzZXQsIGludCBlbmRPZmZzZXQp OwogICAgIHZvaWQgcHJlcGFyZVdoaXRlc3BhY2VBdFBvc2l0aW9uRm9yU3BsaXQoUG9zaXRpb24m KTsKKyAgICBib29sIGNhblJlYmFsYW5jZShjb25zdCBQb3NpdGlvbiYpIGNvbnN0OworICAgIGJv b2wgc2hvdWxkUmViYWxhbmNlTGVhZGluZ1doaXRlc3BhY2VGb3IoY29uc3QgU3RyaW5nJikgY29u c3Q7CiAgICAgdm9pZCByZW1vdmVDU1NQcm9wZXJ0eShQYXNzUmVmUHRyPFN0eWxlZEVsZW1lbnQ+ LCBDU1NQcm9wZXJ0eUlEKTsKICAgICB2b2lkIHJlbW92ZU5vZGVBdHRyaWJ1dGUoUGFzc1JlZlB0 cjxFbGVtZW50PiwgY29uc3QgUXVhbGlmaWVkTmFtZSYgYXR0cmlidXRlKTsKICAgICB2b2lkIHJl bW92ZUNoaWxkcmVuSW5SYW5nZShQYXNzUmVmUHRyPE5vZGU+LCB1bnNpZ25lZCBmcm9tLCB1bnNp Z25lZCB0byk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggMjNiNDFjZWJlYTc3ZmIw MWMwNzIzNDZiZGQ0MmQzN2M2YWIxODdiNy4uM2FjZWMyN2EzODM0NTVjNTViMzlhMzA5OWI0ZGM3 MjA0ZWYyZjA4NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcApAQCAtMTE3Myw3ICsxMTcz LDEyIEBAIGJvb2wgRWRpdG9yOjppbnNlcnRUZXh0KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQq IHRyaWdnZXJpbmdFdmVudCkKICAgICByZXR1cm4gbV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhh bmRsZVRleHRJbnB1dEV2ZW50KHRleHQsIHRyaWdnZXJpbmdFdmVudCk7CiB9CiAKLWJvb2wgRWRp dG9yOjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0 LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgRXZlbnQqIHRyaWdnZXJpbmdFdmVudCkKK2Jvb2wg RWRpdG9yOjppbnNlcnRUZXh0Rm9yQ29uZmlybWVkQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0 ZXh0KQoreworICAgIHJldHVybiBtX2ZyYW1lLT5ldmVudEhhbmRsZXIoKS0+aGFuZGxlVGV4dElu cHV0RXZlbnQodGV4dCwgMCwgVGV4dEV2ZW50SW5wdXRDb21wb3NpdGlvbik7Cit9CisKK2Jvb2wg RWRpdG9yOjppbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiB0 ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQp CiB7CiAgICAgaWYgKHRleHQuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0x MTk1LDcgKzEyMDAsOCBAQCBib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4 dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbgogICAgICAgICAgICAgUmVm UHRyPERvY3VtZW50PiBkb2N1bWVudCA9IHNlbGVjdGlvblN0YXJ0LT5kb2N1bWVudCgpOwogICAg ICAgICAgICAgCiAgICAgICAgICAgICAvLyBJbnNlcnQgdGhlIHRleHQKLSAgICAgICAgICAgIFR5 cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwg c2VsZWN0SW5zZXJ0ZWRUZXh0KTsKKyAgICAgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRl eHQoZG9jdW1lbnQuZ2V0KCksIHRleHQsIHNlbGVjdGlvbiwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJpZ2dlcmluZ0V2ZW50ICYm IHRyaWdnZXJpbmdFdmVudC0+aXNDb21wb3NpdGlvbigpID8gVHlwaW5nQ29tbWFuZDo6VGV4dENv bXBvc2l0aW9uQ29uZmlybSA6IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbk5vbmUpOwog CiAgICAgICAgICAgICAvLyBSZXZlYWwgdGhlIGN1cnJlbnQgc2VsZWN0aW9uIAogICAgICAgICAg ICAgaWYgKEZyYW1lKiBlZGl0ZWRGcmFtZSA9IGRvY3VtZW50LT5mcmFtZSgpKQpAQCAtMTYxOCw3 ICsxNjI0LDcgQEAgdm9pZCBFZGl0b3I6OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcm IHRleHQsIGJvb2wgcHJlc2VydmVTZWxlY3Rpb24pCiAgICAgbV9jb21wb3NpdGlvbk5vZGUgPSAw OwogICAgIG1fY3VzdG9tQ29tcG9zaXRpb25VbmRlcmxpbmVzLmNsZWFyKCk7CiAKLSAgICBpbnNl cnRUZXh0KHRleHQsIDApOworICAgIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbih0 ZXh0KTsKIAogICAgIGlmIChwcmVzZXJ2ZVNlbGVjdGlvbikgewogICAgICAgICBtX2ZyYW1lLT5z ZWxlY3Rpb24oKS0+c2V0U2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgZmFsc2UsIGZhbHNlKTsKQEAg LTE2ODcsNyArMTY5Myw3IEBAIHZvaWQgRWRpdG9yOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJp bmcmIHRleHQsIGNvbnN0IFZlY3RvcjxDb21wb3NpdGlvblVuZGVybGluCiAgICAgbV9jdXN0b21D b21wb3NpdGlvblVuZGVybGluZXMuY2xlYXIoKTsKIAogICAgIGlmICghdGV4dC5pc0VtcHR5KCkp IHsKLSAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChtX2ZyYW1lLT5kb2N1bWVudCgp LCB0ZXh0LCB0cnVlLCB0cnVlKTsKKyAgICAgICAgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dCht X2ZyYW1lLT5kb2N1bWVudCgpLCB0ZXh0LCB0cnVlLCBUeXBpbmdDb21tYW5kOjpUZXh0Q29tcG9z aXRpb25VcGRhdGUpOwogCiAgICAgICAgIC8vIEZpbmQgb3V0IHdoYXQgbm9kZSBoYXMgdGhlIGNv bXBvc2l0aW9uIG5vdy4KICAgICAgICAgUG9zaXRpb24gYmFzZSA9IG1fZnJhbWUtPnNlbGVjdGlv bigpLT5iYXNlKCkuZG93bnN0cmVhbSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9FZGl0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKaW5kZXggMmU2 MWNlNjdkMTgxODVhNjZhOTI4MDFkNmI3YTk1YTQ3ODk0NmVjOS4uMWU2ZTM4NzNmNWRjOGRlZjJk MGQyMGEwMGNiMTMzMzhhOWMwOWE5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9FZGl0b3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0xOTgs NyArMTk4LDggQEAgcHVibGljOgogICAgIHN0YXRpYyBib29sIGNvbW1hbmRJc1N1cHBvcnRlZEZy b21NZW51T3JLZXlCaW5kaW5nKGNvbnN0IFN0cmluZyYgY29tbWFuZE5hbWUpOyAvLyBXb3JrcyB3 aXRob3V0IGEgZnJhbWUuCiAKICAgICBib29sIGluc2VydFRleHQoY29uc3QgU3RyaW5nJiwgRXZl bnQqIHRyaWdnZXJpbmdFdmVudCk7Ci0gICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRpbmdU ZXh0RXZlbnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIEV2ZW50KiB0 cmlnZ2VyaW5nRXZlbnQpOworICAgIGJvb2wgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0 aW9uKGNvbnN0IFN0cmluZyYgdGV4dCk7CisgICAgYm9vbCBpbnNlcnRUZXh0V2l0aG91dFNlbmRp bmdUZXh0RXZlbnQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRF dmVudCogdHJpZ2dlcmluZ0V2ZW50KTsKICAgICBib29sIGluc2VydExpbmVCcmVhaygpOwogICAg IGJvb2wgaW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCmluZGV4IGZjMThlOTEyZjk1MzYzNmFmYjI3 MTZmMGMxNjIzZDUwOTA2ODlmNWQuLjc0YTExMWEyMmE0MzgwMDZhYzNiNzM1ZDgzOTliOTYxOTMx ZTBkYjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1h bmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3Bw CkBAIC0xMDYsNyArMTA2LDcgQEAgYm9vbCBJbnNlcnRUZXh0Q29tbWFuZDo6cGVyZm9ybVRyaXZp YWxSZXBsYWNlKGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnMKICAgICByZXR1cm4g dHJ1ZTsKIH0KIAotdm9pZCBJbnNlcnRUZXh0Q29tbWFuZDo6aW5wdXQoY29uc3QgU3RyaW5nJiB0 ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCkKK3ZvaWQgSW5zZXJ0VGV4dENvbW1hbmQ6Omlu cHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFJlYmFsYW5j ZVR5cGUgd2hpdGVzcGFjZVJlYmFsYW5jZSkKIHsKICAgICAKICAgICBBU1NFUlQodGV4dC5maW5k KCdcbicpID09IG5vdEZvdW5kKTsKQEAgLTE3MiwxMSArMTcyLDE3IEBAIHZvaWQgSW5zZXJ0VGV4 dENvbW1hbmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRl eHQpCiAgICAgICAgIGluc2VydFRleHRJbnRvTm9kZSh0ZXh0Tm9kZSwgb2Zmc2V0LCB0ZXh0KTsK ICAgICAgICAgZW5kUG9zaXRpb24gPSBQb3NpdGlvbih0ZXh0Tm9kZSwgb2Zmc2V0ICsgdGV4dC5s ZW5ndGgoKSk7CiAKLSAgICAgICAgLy8gVGhlIGluc2VydGlvbiBtYXkgcmVxdWlyZSBhZGp1c3Rp bmcgYWRqYWNlbnQgd2hpdGVzcGFjZSwgaWYgaXQgaXMgcHJlc2VudC4KLSAgICAgICAgcmViYWxh bmNlV2hpdGVzcGFjZUF0KGVuZFBvc2l0aW9uKTsKLSAgICAgICAgLy8gUmViYWxhbmNpbmcgb24g Ym90aCBzaWRlcyBpc24ndCBuZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgYSBzcGFjZS4KLSAg ICAgICAgaWYgKHRleHQgIT0gIiAiKSAKLSAgICAgICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VB dChzdGFydFBvc2l0aW9uKTsKKyAgICAgICAgaWYgKHdoaXRlc3BhY2VSZWJhbGFuY2UgPT0gUmVi YWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpIHsKKyAgICAgICAgICAgIC8vIFRo ZSBpbnNlcnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdoaXRlc3BhY2UsIGlm IGl0IGlzIHByZXNlbnQuCisgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoZW5kUG9z aXRpb24pOworICAgICAgICAgICAgLy8gUmViYWxhbmNpbmcgb24gYm90aCBzaWRlcyBpc24ndCBu ZWNlc3NhcnkgaWYgd2UndmUgaW5zZXJ0ZWQgb25seSBzcGFjZXMuCisgICAgICAgICAgICBpZiAo IXNob3VsZFJlYmFsYW5jZUxlYWRpbmdXaGl0ZXNwYWNlRm9yKHRleHQpKQorICAgICAgICAgICAg ICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChzdGFydFBvc2l0aW9uKTsKKyAgICAgICAgfSBlbHNl IHsKKyAgICAgICAgICAgIEFTU0VSVCh3aGl0ZXNwYWNlUmViYWxhbmNlID09IFJlYmFsYW5jZUFs bFdoaXRlc3BhY2VzKTsKKyAgICAgICAgICAgIGlmIChjYW5SZWJhbGFuY2Uoc3RhcnRQb3NpdGlv bikgJiYgY2FuUmViYWxhbmNlKGVuZFBvc2l0aW9uKSkKKyAgICAgICAgICAgICAgICByZWJhbGFu Y2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKHRleHROb2RlLCBzdGFydFBvc2l0aW9uLmRlcHJl Y2F0ZWRFZGl0aW5nT2Zmc2V0KCksIGVuZFBvc2l0aW9uLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0 KCkpOworICAgICAgICB9CiAgICAgfQogCiAgICAgLy8gV2UgY291bGQgaGF2ZSBpbnNlcnRlZCBh IHBhcnQgb2YgY29tcG9zZWQgY2hhcmFjdGVyIHNlcXVlbmNlLApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRp dGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oCmluZGV4IDc3YWUwMTZkMzZhMTRmYjFmODE0OWRmN2Fh MzQxMmNkZWMxZDIyZGUuLjY3MmU1NzZmOTIwNzlhNWNmOTc3YWU1Y2Y4YTI0YmQ5YzI3ZmE0Yzcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmgKQEAgLTMyLDE0 ICszMiwyMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEluc2VydFRleHRDb21tYW5k IDogcHVibGljIENvbXBvc2l0ZUVkaXRDb21tYW5kIHsKIHB1YmxpYzoKKyAgICBlbnVtIFJlYmFs YW5jZVR5cGUgeworICAgICAgICBSZWJhbGFuY2VMZWFkaW5nQW5kVHJhaWxpbmdXaGl0ZXNwYWNl cywKKyAgICAgICAgUmViYWxhbmNlQWxsV2hpdGVzcGFjZXMKKyAgICB9OworCiAgICAgc3RhdGlj IFBhc3NSZWZQdHI8SW5zZXJ0VGV4dENvbW1hbmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQp CiAgICAgewogICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEluc2VydFRleHRDb21tYW5kKGRv Y3VtZW50KSk7CiAgICAgfQogCi0gICAgdm9pZCBpbnB1dChjb25zdCBTdHJpbmcmIHRleHQsIGJv b2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UpOworICAgIHZvaWQgaW5wdXQoY29uc3QgU3Ry aW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBSZWJhbGFuY2VUeXBl ID0gUmViYWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMpOwogCiBwcml2YXRlOgor CiAgICAgSW5zZXJ0VGV4dENvbW1hbmQoRG9jdW1lbnQqKTsKIAogICAgIHZvaWQgZGVsZXRlQ2hh cmFjdGVyKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1h bmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcAppbmRleCBk NTRiMzg4NWJmOThmZTUyYmQ5YTY1YzU0YThkNzFkOTY3NjA3ZTlkLi4yMWQ0MzE0YWQwNzU0OGEw OGM5ODI3YjBmMTU1Yjk5YWIyMjhiNjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0 aW5nL1R5cGluZ0NvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5n Q29tbWFuZC5jcHAKQEAgLTQ3LDcgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2lu ZyBuYW1lc3BhY2UgSFRNTE5hbWVzOwogCi1UeXBpbmdDb21tYW5kOjpUeXBpbmdDb21tYW5kKERv Y3VtZW50ICpkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29tbWFuZFR5cGUsIGNvbnN0IFN0cmlu ZyAmdGV4dFRvSW5zZXJ0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEdyYW51bGFyaXR5 IGdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nKQorVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFu ZChEb2N1bWVudCAqZG9jdW1lbnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBT dHJpbmcgJnRleHRUb0luc2VydCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxh cml0eSBncmFudWxhcml0eSwgVGV4dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJvb2wga2lsbFJpbmcpCiAgICAgOiBDb21wb3Np dGVFZGl0Q29tbWFuZChkb2N1bWVudCksIAogICAgICAgbV9jb21tYW5kVHlwZShjb21tYW5kVHlw ZSksIAogICAgICAgbV90ZXh0VG9JbnNlcnQodGV4dFRvSW5zZXJ0KSwgCkBAIC01NSw2ICs1Niw3 IEBAIFR5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRvY3VtZW50LCBFVHlw aW5nQ29tbWFuZCBjb21tYW5kVHlwZSwgY29uCiAgICAgICBtX3NlbGVjdEluc2VydGVkVGV4dChz ZWxlY3RJbnNlcnRlZFRleHQpLAogICAgICAgbV9zbWFydERlbGV0ZShmYWxzZSksCiAgICAgICBt X2dyYW51bGFyaXR5KGdyYW51bGFyaXR5KSwKKyAgICAgIG1fY29tcG9zaXRpb25UeXBlKGNvbXBv c2l0aW9uVHlwZSksCiAgICAgICBtX2tpbGxSaW5nKGtpbGxSaW5nKSwKICAgICAgIG1fb3BlbmVk QnlCYWNrd2FyZERlbGV0ZShmYWxzZSkKIHsKQEAgLTEzMywxOCArMTM1LDE4IEBAIHZvaWQgVHlw aW5nQ29tbWFuZDo6dXBkYXRlU2VsZWN0aW9uSWZEaWZmZXJlbnRGcm9tQ3VycmVudFNlbGVjdGlv bihUeXBpbmdDb21tYW5kCiB9CiAgICAgCiAKLXZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4 dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQsIGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29t bWFuZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRDb21wb3NpdGlvblR5cGUgY29tcG9zaXRpb24p CiB7CiAgICAgQVNTRVJUKGRvY3VtZW50KTsKICAgICAKICAgICBGcmFtZSogZnJhbWUgPSBkb2N1 bWVudC0+ZnJhbWUoKTsKICAgICBBU1NFUlQoZnJhbWUpOwogCi0gICAgaW5zZXJ0VGV4dChkb2N1 bWVudCwgdGV4dCwgZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0 ZWRUZXh0LCBpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKTsKKyAgICBpbnNlcnRUZXh0KGRvY3Vt ZW50LCB0ZXh0LCBmcmFtZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpLCBzZWxlY3RJbnNlcnRl ZFRleHQsIGNvbXBvc2l0aW9uKTsKIH0KIAogLy8gRklYTUU6IFdlIHNob3VsZG4ndCBuZWVkIHRv IHRha2Ugc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLiBJdCBzaG91bGQgYmUgaWRlbnRpY2FsIHRvIFNl bGVjdGlvbkNvbnRyb2xsZXIncyBjdXJyZW50IHNlbGVjdGlvbi4KLXZvaWQgVHlwaW5nQ29tbWFu ZDo6aW5zZXJ0VGV4dChEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdElu c2VydGVkVGV4dCwgYm9vbCBpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKQordm9pZCBUeXBpbmdD b21tYW5kOjppbnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0 LCBjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb25Gb3JJbnNlcnRpb24sIGJvb2wgc2Vs ZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uVHlwZSkKIHsK ICNpZiBSRU1PVkVfTUFSS0VSU19VUE9OX0VESVRJTkcKICAgICBpZiAoIXRleHQuaXNFbXB0eSgp KQpAQCAtMTYxLDcgKzE2Myw3IEBAIHZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzCiAgICAgU3RyaW5n IG5ld1RleHQgPSB0ZXh0OwogICAgIE5vZGUqIHN0YXJ0Tm9kZSA9IHNlbGVjdGlvbkZvckluc2Vy dGlvbi5zdGFydCgpLm5vZGUoKTsKICAgICAKLSAgICBpZiAoc3RhcnROb2RlICYmIHN0YXJ0Tm9k ZS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpICYmICFpbnNlcnRlZFRleHRJc0NvbXBvc2l0aW9uKSB7 ICAgICAgICAKKyAgICBpZiAoc3RhcnROb2RlICYmIHN0YXJ0Tm9kZS0+cm9vdEVkaXRhYmxlRWxl bWVudCgpICYmIGNvbXBvc2l0aW9uVHlwZSAhPSBUZXh0Q29tcG9zaXRpb25VcGRhdGUpIHsKICAg ICAgICAgLy8gU2VuZCBCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudC4gVGhlIGV2ZW50IGhhbmRsZXIg d2lsbCB1cGRhdGUgdGV4dCBpZiBuZWNlc3NhcnkuCiAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMg PSAwOwogICAgICAgICBSZWZQdHI8QmVmb3JlVGV4dEluc2VydGVkRXZlbnQ+IGV2dCA9IEJlZm9y ZVRleHRJbnNlcnRlZEV2ZW50OjpjcmVhdGUodGV4dCk7CkBAIC0xODIsMTEgKzE4NCwxMyBAQCB2 b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBT dHJpbmcmIHRleHQsIGNvbnN0IFZpcwogICAgICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNl dFN0YXJ0aW5nU2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgICAgICBs YXN0VHlwaW5nQ29tbWFuZC0+c2V0RW5kaW5nU2VsZWN0aW9uKHNlbGVjdGlvbkZvckluc2VydGlv bik7CiAgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRD b21wb3NpdGlvblR5cGUoY29tcG9zaXRpb25UeXBlKTsKICAgICAgICAgbGFzdFR5cGluZ0NvbW1h bmQtPmluc2VydFRleHQobmV3VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0KTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KIAotICAgIFJlZlB0cjxUeXBpbmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21t YW5kOjpjcmVhdGUoZG9jdW1lbnQsIEluc2VydFRleHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVk VGV4dCk7CisgICAgUmVmUHRyPFR5cGluZ0NvbW1hbmQ+IGNtZCA9IFR5cGluZ0NvbW1hbmQ6OmNy ZWF0ZShkb2N1bWVudCwgSW5zZXJ0VGV4dCwgbmV3VGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBj b21wb3NpdGlvblR5cGUpOwogICAgIGlmIChjaGFuZ2VTZWxlY3Rpb24pICB7CiAgICAgICAgIGNt ZC0+c2V0U3RhcnRpbmdTZWxlY3Rpb24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKICAgICAgICAg Y21kLT5zZXRFbmRpbmdTZWxlY3Rpb24oc2VsZWN0aW9uRm9ySW5zZXJ0aW9uKTsKQEAgLTM4Niw3 ICszOTAsOCBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHRSdW5XaXRob3V0TmV3bGlu ZXMoY29uc3QgU3RyaW5nICZ0ZXh0LCBib29sIHNlbGVjdAogICAgICAgICBjb21tYW5kLT5zZXRT dGFydGluZ1NlbGVjdGlvbihlbmRpbmdTZWxlY3Rpb24oKSk7CiAgICAgICAgIGNvbW1hbmQtPnNl dEVuZGluZ1NlbGVjdGlvbihlbmRpbmdTZWxlY3Rpb24oKSk7CiAgICAgfQotICAgIGNvbW1hbmQt PmlucHV0KHRleHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CisgICAgY29tbWFuZC0+aW5wdXQodGV4 dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCAKKyAgICAgICAgICAgICAgICAgICBtX2NvbXBvc2l0aW9u VHlwZSA9PSBUZXh0Q29tcG9zaXRpb25Ob25lID8gSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFsYW5j ZUxlYWRpbmdBbmRUcmFpbGluZ1doaXRlc3BhY2VzIDogSW5zZXJ0VGV4dENvbW1hbmQ6OlJlYmFs YW5jZUFsbFdoaXRlc3BhY2VzKTsKICAgICB0eXBpbmdBZGRlZFRvT3BlbkNvbW1hbmQoSW5zZXJ0 VGV4dCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29t bWFuZC5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmgKaW5kZXggMjg0 ZWJjMGFjMjY1ZDc2YjE2YTgwYmYyNjExYzdhODBlNjgwYWQwZi4uYjM0YmRjMTIyMWEyMmEzMDEy NGE5MDg4MDEwYzA1NDY1MWJmZGU2ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9UeXBpbmdDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21t YW5kLmgKQEAgLTQyLDExICs0MiwxNyBAQCBwdWJsaWM6CiAgICAgICAgIEluc2VydFBhcmFncmFw aFNlcGFyYXRvckluUXVvdGVkQ29udGVudAogICAgIH07CiAKKyAgICBlbnVtIFRleHRDb21wb3Np dGlvblR5cGUgeworICAgICAgICBUZXh0Q29tcG9zaXRpb25Ob25lLAorICAgICAgICBUZXh0Q29t cG9zaXRpb25VcGRhdGUsCisgICAgICAgIFRleHRDb21wb3NpdGlvbkNvbmZpcm0KKyAgICB9Owor CiAgICAgc3RhdGljIHZvaWQgZGVsZXRlU2VsZWN0aW9uKERvY3VtZW50KiwgYm9vbCBzbWFydERl bGV0ZSA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9pZCBkZWxldGVLZXlQcmVzc2VkKERvY3VtZW50 KiwgYm9vbCBzbWFydERlbGV0ZSA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJH cmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9pZCBmb3J3 YXJkRGVsZXRlS2V5UHJlc3NlZChEb2N1bWVudCosIGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSwg VGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBm YWxzZSk7Ci0gICAgc3RhdGljIHZvaWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmlu ZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UsIGJvb2wgaW5zZXJ0ZWRUZXh0SXND b21wb3NpdGlvbiA9IGZhbHNlKTsKLSAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50 KiwgY29uc3QgU3RyaW5nJiwgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0ID0gZmFsc2UsIGJvb2wgaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbiA9IGZhbHNl KTsKKyAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwg Ym9vbCBzZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgVGV4dENvbXBvc2l0aW9uVHlwZSA9IFRl eHRDb21wb3NpdGlvbk5vbmUpOworICAgIHN0YXRpYyB2b2lkIGluc2VydFRleHQoRG9jdW1lbnQq LCBjb25zdCBTdHJpbmcmLCBjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQgPSBmYWxzZSwgVGV4dENvbXBvc2l0aW9uVHlwZSA9IFRleHRDb21wb3NpdGlvbk5v bmUpOwogICAgIHN0YXRpYyB2b2lkIGluc2VydExpbmVCcmVhayhEb2N1bWVudCopOwogICAgIHN0 YXRpYyB2b2lkIGluc2VydFBhcmFncmFwaFNlcGFyYXRvcihEb2N1bWVudCopOwogICAgIHN0YXRp YyB2b2lkIGluc2VydFBhcmFncmFwaFNlcGFyYXRvckluUXVvdGVkQ29udGVudChEb2N1bWVudCop OwpAQCAtNjQsMTQgKzcwLDIwIEBAIHB1YmxpYzoKICAgICB2b2lkIGRlbGV0ZUtleVByZXNzZWQo VGV4dEdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nKTsKICAgICB2b2lkIGZvcndhcmREZWxldGVL ZXlQcmVzc2VkKFRleHRHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyk7CiAgICAgdm9pZCBkZWxl dGVTZWxlY3Rpb24oYm9vbCBzbWFydERlbGV0ZSk7CisgICAgdm9pZCBzZXRDb21wb3NpdGlvblR5 cGUoVGV4dENvbXBvc2l0aW9uVHlwZSB0eXBlKSB7IG1fY29tcG9zaXRpb25UeXBlID0gdHlwZTsg fQogCiBwcml2YXRlOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFR5cGluZ0NvbW1hbmQ+IGNyZWF0 ZShEb2N1bWVudCogZG9jdW1lbnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmQsIGNvbnN0IFN0cmlu ZyYgdGV4dCA9ICIiLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBUZXh0R3JhbnVs YXJpdHkgZ3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyA9 IGZhbHNlKQogICAgIHsKLSAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5k KGRvY3VtZW50LCBjb21tYW5kLCB0ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5 LCBraWxsUmluZykpOworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFR5cGluZ0NvbW1hbmQo ZG9jdW1lbnQsIGNvbW1hbmQsIHRleHQsIHNlbGVjdEluc2VydGVkVGV4dCwgZ3JhbnVsYXJpdHks IFRleHRDb21wb3NpdGlvbk5vbmUsIGtpbGxSaW5nKSk7CisgICAgfQorCisgICAgc3RhdGljIFBh c3NSZWZQdHI8VHlwaW5nQ29tbWFuZD4gY3JlYXRlKERvY3VtZW50KiBkb2N1bWVudCwgRVR5cGlu Z0NvbW1hbmQgY29tbWFuZCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVk VGV4dCwgVGV4dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUpCisgICAgeworICAgICAg ICByZXR1cm4gYWRvcHRSZWYobmV3IFR5cGluZ0NvbW1hbmQoZG9jdW1lbnQsIGNvbW1hbmQsIHRl eHQsIHNlbGVjdEluc2VydGVkVGV4dCwgQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGNvbXBvc2l0aW9u VHlwZSwgZmFsc2UpKTsKICAgICB9CiAKLSAgICBUeXBpbmdDb21tYW5kKERvY3VtZW50KiwgRVR5 cGluZ0NvbW1hbmQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQs IFRleHRHcmFudWxhcml0eSwgYm9vbCBraWxsUmluZyk7CisgICAgVHlwaW5nQ29tbWFuZChEb2N1 bWVudCosIEVUeXBpbmdDb21tYW5kLCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5z ZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHksIFRleHRDb21wb3NpdGlvblR5cGUsIGJvb2wga2ls bFJpbmcpOwogCiAgICAgYm9vbCBzbWFydERlbGV0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc21hcnRE ZWxldGU7IH0KICAgICB2b2lkIHNldFNtYXJ0RGVsZXRlKGJvb2wgc21hcnREZWxldGUpIHsgbV9z bWFydERlbGV0ZSA9IHNtYXJ0RGVsZXRlOyB9CkBAIC05NCw2ICsxMDYsNyBAQCBwcml2YXRlOgog ICAgIGJvb2wgbV9zZWxlY3RJbnNlcnRlZFRleHQ7CiAgICAgYm9vbCBtX3NtYXJ0RGVsZXRlOwog ICAgIFRleHRHcmFudWxhcml0eSBtX2dyYW51bGFyaXR5OworICAgIFRleHRDb21wb3NpdGlvblR5 cGUgbV9jb21wb3NpdGlvblR5cGU7CiAgICAgYm9vbCBtX2tpbGxSaW5nOwogICAgIGJvb2wgbV9w cmVzZXJ2ZXNUeXBpbmdTdHlsZTsKICAgICAK 79895 2011-01-23 22:39:18 -0800 2011-01-23 22:48:06 -0800 Patch bug-5241-20110124153916.patch text/plain 31414 morrita ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1OGM1NWVlNjMxNDE0NDFlYWVmNWY4MTFmMjM5NDcyNjdmMjVmYmM2Li41ZjM4MTRk YTVhNTI3OTI0NWJiNWE5ZDBhMmYxNmQ5YThiOGEzODUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDEtMTkgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgUnlvc3VrZSBOaXdhLgorCisgICAgICAgIFNwYWNlIGFuZCB0YWIgY2hh cmFjdGVycyAic2VudCIgYnkgYW4gaW5wdXQgbWV0aG9kIGdpdmUgdG90YWxseSBkaWZmZXJlbnQg cmVzdWx0cyB0aGFuIHR5cGluZyB0aGVtIGRpcmVjdGx5LgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI0MQorICAgICAgICAKKyAgICAgICAgQWRkZWQg YSB0ZXN0IHRoYXQgZXhlcmNpc2VzIGNvbnRpbm91cyB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMgYW5k IHRhYnMgaW5zZXJ0ZWQgYnkgSU1FLgorCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvaW5z ZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAg KiBlZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sOiBB ZGRlZC4KKwogMjAxMS0wMS0yMyAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21wb3NpdGlv bi13aGl0ZXNwYWNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hZGUwNzI1MDc3NzZiOGZlZmE2 ZmZhNTA5NWZmYjM0YzdkZmM1OGI2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnNlcnRpbmcvaW5zZXJ0LWNvbXBvc2l0aW9uLXdoaXRlc3BhY2UtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsOTQgQEAKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQicKK1BBU1MgY29u ZmlybWVkVGV4dCBpcyAnQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSBCJworUEFTUyBj b25maXJtZWRUZXh0IGlzICdBIEInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnQSDCoEInCitQ QVNTIGNvbmZpcm1lZFRleHQgaXMgJ0EgwqBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0Eg wqAgQicKK1BBU1MgY29uZmlybWVkVGV4dCBpcyAnQSDCoCBCJworUEFTUyBjb21wb3NpdGluZ1Rl eHQgaXMgJ0EgwqAgwqBCJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBIMKgIMKgQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICfCoEFCJworUEFTUyBjb25maXJtZWRUZXh0IGlzICfCoEFCJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqBBQicKK1BBU1MgY29uZmlybWVkVGV4dCBpcyAn wqDCoEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqAgQUInCitQQVNTIGNvbmZpcm1l ZFRleHQgaXMgJ8KgwqAgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnwqDCoCDCoEFCJwor UEFTUyBjb25maXJtZWRUZXh0IGlzICfCoMKgIMKgQUInCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBp cyAnwqDCoCDCoCBBQicKK1BBU1MgY29uZmlybWVkVGV4dCBpcyAnwqDCoCDCoCBBQicKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKgQUInCitQQVNTIGNvbmZpcm1lZFRleHQgaXMg J8KgwqAgwqAgwqBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgIMKgIMKgIEFCJwor UEFTUyBjb25maXJtZWRUZXh0IGlzICfCoMKgIMKgIMKgIEFCJworUEFTUyBjb21wb3NpdGluZ1Rl eHQgaXMgJ0FCIMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBQiDCoCcKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICdBQiDCoMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBQiDCoMKgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCIMKgIMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlz ICdBQiDCoCDCoCcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoMKgJworUEFTUyBj b25maXJtZWRUZXh0IGlzICdBQiDCoCDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FC IMKgIMKgIMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBQiDCoCDCoCDCoCcKK1BBU1MgY29t cG9zaXRpbmdUZXh0IGlzICdBQiDCoCDCoCDCoMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdB QiDCoCDCoCDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqBBIMKgQiDCoCcKK1BB U1MgY29uZmlybWVkVGV4dCBpcyAnwqDCoEEgwqBCIMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQg aXMgJ8KgwqBBIMKgQiDCoCcKK1BBU1MgY29uZmlybWVkVGV4dCBpcyAnwqDCoEEgwqBCIMKgJwor UEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICfCoCcK K1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICfCoMKgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICfC oMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ8KgwqDCoCcKK1BBU1MgY29uZmlybWVkVGV4 dCBpcyAnwqDCoMKgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCJworUEFTUyBjb25maXJt ZWRUZXh0IGlzICdBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBIEInCitQQVNTIGNvbmZp cm1lZFRleHQgaXMgJ0EgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBICBCJworUEFTUyBj b25maXJtZWRUZXh0IGlzICdBICBCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0EgICBCJwor UEFTUyBjb25maXJtZWRUZXh0IGlzICdBICAgQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdB ICAgIEInCitQQVNTIGNvbmZpcm1lZFRleHQgaXMgJ0EgICAgQicKK1BBU1MgY29tcG9zaXRpbmdU ZXh0IGlzICdBQiAgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBQiAgJworUEFTUyBjb21wb3Np dGluZ1RleHQgaXMgJ0FCICAgJworUEFTUyBjb25maXJtZWRUZXh0IGlzICdBQiAgICcKK1BBU1Mg Y29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICAnCitQQVNTIGNvbmZpcm1lZFRleHQgaXMgJ0FCICAg ICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAgICAgJworUEFTUyBjb25maXJtZWRUZXh0 IGlzICdBQiAgICAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJ0FCICAgICAgJworUEFTUyBj b25maXJtZWRUZXh0IGlzICdBQiAgICAgICcKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICdBQiAg ICAgICAnCitQQVNTIGNvbmZpcm1lZFRleHQgaXMgJ0FCICAgICAgICcKK1BBU1MgY29tcG9zaXRp bmdUZXh0IGlzICcgIEFCJworUEFTUyBjb25maXJtZWRUZXh0IGlzICcgIEFCJworUEFTUyBjb21w b3NpdGluZ1RleHQgaXMgJyAgIEFCJworUEFTUyBjb25maXJtZWRUZXh0IGlzICcgICBBQicKK1BB U1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgQUInCitQQVNTIGNvbmZpcm1lZFRleHQgaXMgJyAg ICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcgICAgIEFCJworUEFTUyBjb25maXJtZWRU ZXh0IGlzICcgICAgIEFCJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICAgIEFCJworUEFT UyBjb25maXJtZWRUZXh0IGlzICcgICAgICBBQicKK1BBU1MgY29tcG9zaXRpbmdUZXh0IGlzICcg ICAgICAgQUInCitQQVNTIGNvbmZpcm1lZFRleHQgaXMgJyAgICAgICBBQicKK1BBU1MgY29tcG9z aXRpbmdUZXh0IGlzICcgIEEgIEIgICcKK1BBU1MgY29uZmlybWVkVGV4dCBpcyAnICBBICBCICAn CitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnCQlBCQlCCQknCitQQVNTIGNvbmZpcm1lZFRleHQg aXMgJwkJQQkJQgkJJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAnCitQQVNTIGNvbmZpcm1l ZFRleHQgaXMgJyAnCitQQVNTIGNvbXBvc2l0aW5nVGV4dCBpcyAnICAnCitQQVNTIGNvbmZpcm1l ZFRleHQgaXMgJyAgJworUEFTUyBjb21wb3NpdGluZ1RleHQgaXMgJyAgICcKK1BBU1MgY29uZmly bWVkVGV4dCBpcyAnICAgJworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNU IENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1jb21wb3NpdGlvbi13aGl0ZXNwYWNlLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lu c2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVzcGFjZS5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjgx MjE1ZGQxYTBmYjRhZDJhMGFkYWJjOTdjY2MyNjUzNTRkYWE3M2EKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtY29tcG9zaXRpb24td2hpdGVz cGFjZS5odG1sCkBAIC0wLDAgKzEsOTkgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVU Ri8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQi IGhyZWY9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3Jp cHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29u c29sZSI+PC9kaXY+Cis8c2NyaXB0PgorCit2YXIgc2VsID0gZG9jdW1lbnQuZ2V0U2VsZWN0aW9u KCk7Cit2YXIgcm9vdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInJvb3QiKTsKK2RvY3VtZW50 LmJvZHkuYXBwZW5kQ2hpbGQocm9vdCk7CisKKworZnVuY3Rpb24gY3JlYXRlRWRpdGFibGUodGFn TmFtZSwgdGV4dCkgeworICAgIHZhciBub2RlID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCh0YWdO YW1lKTsKKyAgICBub2RlLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisgICAgbm9kZS5pbm5lckhU TUwgPSB0ZXh0OworICAgIHJldHVybiBub2RlOworfQorCitmdW5jdGlvbiB0ZXN0KHRhZ05hbWUs IGNvbXBvc2l0aW9uVGV4dCwgZXhwZWN0ZWQpIHsKKyAgICB2YXIgbm9kZSA9IGNyZWF0ZUVkaXRh YmxlKHRhZ05hbWUsICJYIik7CisgICAgcm9vdC5hcHBlbmRDaGlsZChub2RlKTsKKworICAgIHZh ciB0ZXh0Tm9kZSA9IG5vZGUuZmlyc3RDaGlsZDsKKyAgICBzZWwuc2V0QmFzZUFuZEV4dGVudCh0 ZXh0Tm9kZSwgMCwgdGV4dE5vZGUsIHRleHROb2RlLmRhdGEubGVuZ3RoKTsKKyAgICBkb2N1bWVu dC5leGVjQ29tbWFuZCgiRGVsZXRlIiwgZmFsc2UpOworCisgICAgdGV4dElucHV0Q29udHJvbGxl ci5zZXRNYXJrZWRUZXh0KGNvbXBvc2l0aW9uVGV4dCwgMCwgY29tcG9zaXRpb25UZXh0Lmxlbmd0 aCk7CisgICAgY29tcG9zaXRpbmdUZXh0ID0gbm9kZS5pbm5lclRleHQ7CisgICAgdGV4dElucHV0 Q29udHJvbGxlci51bm1hcmtUZXh0KCk7CisgICAgY29uZmlybWVkVGV4dCA9IG5vZGUuaW5uZXJU ZXh0OworCisgICAgc2hvdWxkQmUoImNvbXBvc2l0aW5nVGV4dCIsICInIiArIGV4cGVjdGVkICsg IiciKTsKKyAgICBzaG91bGRCZSgiY29uZmlybWVkVGV4dCIsICInIiArIGV4cGVjdGVkICsgIici KTsKK30KKwordGVzdCgiZGl2IiwgIkFCIiwgIkFCIik7Cit0ZXN0KCJkaXYiLCAiQSBCIiwgIkEg QiIpOwordGVzdCgiZGl2IiwgIkEgIEIiLCAiQSBceEEwQiIpOwordGVzdCgiZGl2IiwgIkEgICBC IiwgIkEgXHhBMCBCIik7Cit0ZXN0KCJkaXYiLCAiQSAgICBCIiwgIkEgXHhBMCBceEEwQiIpOyAK KwordGVzdCgiZGl2IiwgIiBBQiIsICJceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgIEFCIiwgIlx4 QTBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICBBQiIsICJceEEwXHhBMCBBQiIpOwordGVzdCgi ZGl2IiwgIiAgICBBQiIsICJceEEwXHhBMCBceEEwQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgIEFC IiwgIlx4QTBceEEwIFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICIgICAgICBBQiIsICJceEEwXHhB MCBceEEwIFx4QTBBQiIpOwordGVzdCgiZGl2IiwgIiAgICAgICBBQiIsICJceEEwXHhBMCBceEEw IFx4QTAgQUIiKTsKK3Rlc3QoImRpdiIsICJBQiAgIiwgIkFCIFx4QTAiKTsKK3Rlc3QoImRpdiIs ICJBQiAgICIsICJBQiBceEEwXHhBMCIpOwordGVzdCgiZGl2IiwgIkFCICAgICIsICJBQiBceEEw IFx4QTAiKTsKK3Rlc3QoImRpdiIsICJBQiAgICAgIiwgIkFCIFx4QTAgXHhBMFx4QTAiKTsKK3Rl c3QoImRpdiIsICJBQiAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMCIpOwordGVzdCgiZGl2Iiwg IkFCICAgICAgICIsICJBQiBceEEwIFx4QTAgXHhBMFx4QTAiKTsKKwordGVzdCgiZGl2IiwgIiAg QSAgQiAgIiwgIlx4QTBceEEwQSBceEEwQiBceEEwIik7Cit0ZXN0KCJkaXYiLCAiXHRcdEFcdFx0 Qlx0XHQiLCAiXHhBMFx4QTBBIFx4QTBCIFx4QTAiKTsKKwordGVzdCgiZGl2IiwgIiAiLCAiXHhB MCIpOwordGVzdCgiZGl2IiwgIiAgIiwgIlx4QTBceEEwIik7CisvLyBUaGlzIGlzIHdyb25nLiBU aGlzIHNob3VsZCBpbnNlcnQgaW50ZXJsZWF2ZWQgbmJzcCBhbmQgd2hpdGVzcGFjZS4gU2VlIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01Mjc4MS4KK3Rlc3QoImRpdiIs ICIgICAiLCAiXHhBMFx4QTBceEEwIik7CisKK3Rlc3QoInByZSIsICJBQiIsICJBQiIpOwordGVz dCgicHJlIiwgIkEgQiIsICJBIEIiKTsKK3Rlc3QoInByZSIsICJBICBCIiwgIkEgIEIiKTsKK3Rl c3QoInByZSIsICJBICAgQiIsICJBICAgQiIpOwordGVzdCgicHJlIiwgIkEgICAgQiIsICJBICAg IEIiKTsKK3Rlc3QoInByZSIsICJBQiAgIiwgIkFCICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICIs ICJBQiAgICIpOwordGVzdCgicHJlIiwgIkFCICAgICIsICJBQiAgICAiKTsKK3Rlc3QoInByZSIs ICJBQiAgICAgIiwgIkFCICAgICAiKTsKK3Rlc3QoInByZSIsICJBQiAgICAgICIsICJBQiAgICAg ICIpOwordGVzdCgicHJlIiwgIkFCICAgICAgICIsICJBQiAgICAgICAiKTsKK3Rlc3QoInByZSIs ICIgIEFCIiwgIiAgQUIiKTsKK3Rlc3QoInByZSIsICIgICBBQiIsICIgICBBQiIpOwordGVzdCgi cHJlIiwgIiAgICBBQiIsICIgICAgQUIiKTsKK3Rlc3QoInByZSIsICIgICAgIEFCIiwgIiAgICAg QUIiKTsKK3Rlc3QoInByZSIsICIgICAgICBBQiIsICIgICAgICBBQiIpOwordGVzdCgicHJlIiwg IiAgICAgICBBQiIsICIgICAgICAgQUIiKTsKKwordGVzdCgicHJlIiwgIiAgQSAgQiAgIiwgIiAg QSAgQiAgIik7Cit0ZXN0KCJwcmUiLCAiXHRcdEFcdFx0Qlx0XHQiLCAiXHRcdEFcdFx0Qlx0XHQi KTsKK3Rlc3QoInByZSIsICIgIiwgIiAiKTsKK3Rlc3QoInByZSIsICIgICIsICIgICIpOwordGVz dCgicHJlIiwgIiAgICIsICIgICAiKTsKKworcm9vdC5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOwor c3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4v Li4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyMmI4NjA5YmU5NjRmZmY1NzJkYmM0ZGY1Mjk4ZmQ4MWZk YThjMmM5Li40MjcwNDg2MDM2YmU0YjAyN2M4MjU2MTEyN2Y4MjE4OGZlNTAwZTMzIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsNDQgQEAKKzIwMTEtMDEtMTkgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRh QGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgUnlvc3VrZSBOaXdhLgorCisgICAg ICAgIFNwYWNlIGFuZCB0YWIgY2hhcmFjdGVycyAic2VudCIgYnkgYW4gaW5wdXQgbWV0aG9kIGdp dmUgdG90YWxseSBkaWZmZXJlbnQgcmVzdWx0cyB0aGFuIHR5cGluZyB0aGVtIGRpcmVjdGx5Cisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MjQxCisgICAg ICAgIAorICAgICAgICAqIEludHJvZHVjZWQgVGV4dEV2ZW50OjpJbnB1dFR5cGVDb21wb3NpdGlv biBhbmQgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVHlwZSB0byAKKyAgICAgICAgICBk aXN0aW5ndWlzaCB0ZXh0IGlucHV0IHdoaWNoIGlzIG9yaWdpbmF0ZWQgYnkgY29tcG9zaXRpb24u CisgICAgICAgICogR2VuZXJhbGl6ZWQgcmViYWxhbmNlV2hpdGVzcGFjZUF0KCkgdG8gcmViYWxh bmNlV2hpdGVzcGFjZU9uVGV4dFN1YnN0cmluZygpIHRvIHJlYmFsYW5jaW5nIAorICAgICAgICAg IHJhbmdlIG9mIHN0cmluZyBvbiB0ZXh0IG5vZGUsIGluc3RlYWQgb2Ygc3Vycm91bmRpbmcgcGFy dCBvZiB0aGF0LgorCisgICAgICAgIFRlc3Q6IGVkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1jb21w b3NpdGlvbi13aGl0ZXNwYWNlLmh0bWwKKworICAgICAgICAqIGRvbS9UZXh0RXZlbnQuaDoKKyAg ICAgICAgKFdlYkNvcmU6OlRleHRFdmVudDo6aXNDb21wb3NpdGlvbik6CisgICAgICAgICogZG9t L1RleHRFdmVudElucHV0VHlwZS5oOiBBZGRlZCBUZXh0RXZlbnRJbnB1dENvbXBvc2l0aW9uIGFz IGEgbWVtYmVyIG9mIFRleHRFdmVudDo6SW5wdXRUeXBlCisgICAgICAgICogZWRpdGluZy9Db21w b3NpdGVFZGl0Q29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpjb250YWluc09ubHlXaGl0 ZXNwYWNlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpzaG91bGRS ZWJhbGFuY2VMZWFkaW5nV2hpdGVzcGFjZUZvcik6CisgICAgICAgIChXZWJDb3JlOjpDb21wb3Np dGVFZGl0Q29tbWFuZDo6Y2FuUmViYWxhbmNlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0 ZUVkaXRDb21tYW5kOjpyZWJhbGFuY2VXaGl0ZXNwYWNlQXQpOgorICAgICAgICAoV2ViQ29yZTo6 Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3BhY2VPblRleHRTdWJzdHJpbmcp OiBBZGRlZDogQSBnZW5lcmFsaXplZCB2ZXJzaW9uIG9mIHJlYmFsYW5jZVdoaXRlc3BhY2VBdCgp LCB3aGljaCB0YWtlcyBhIHJhbmdlIGluc2lkZSBUZXh0IHN0cmluZy4KKyAgICAgICAgKiBlZGl0 aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmg6CisgICAgICAgICogZWRpdGluZy9FZGl0b3IuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjppbnNlcnRUZXh0Rm9yQ29uZmlybWVkQ29tcG9z aXRpb24pOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhv dXRTZW5kaW5nVGV4dEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6Y29uZmlybUNv bXBvc2l0aW9uKTogTm93IHVzZXMgaW5zZXJ0VGV4dEZvckNvbmZpcm1lZENvbXBvc2l0aW9uKCku CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OnNldENvbXBvc2l0aW9uKToKKyAgICAgICAgKiBl ZGl0aW5nL0VkaXRvci5oOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0VGV4dENvbW1hbmQ6OmlucHV0KToKKyAgICAgICAg KiBlZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmg6CisgICAgICAgICogZWRpdGluZy9UeXBpbmdD b21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1h bmQpOgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dCk6CisgICAg ICAgIChXZWJDb3JlOjpUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0UnVuV2l0aG91dE5ld2xpbmVz KToKKyAgICAgICAgKiBlZGl0aW5nL1R5cGluZ0NvbW1hbmQuaDogQWRkZWQgVHlwaW5nQ29tbWFu ZDo6bV9jb21wb3NpdGlvblR5cGUgYW5kIFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvblR5 cGUKKyAgICAgICAgKFdlYkNvcmU6OlR5cGluZ0NvbW1hbmQ6OnNldENvbXBvc2l0aW9uVHlwZSk6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VHlwaW5nQ29tbWFuZDo6Y3JlYXRlKToKKwogMjAx MS0wMS0yMyAgUGF0cmljayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KIAogICAgICAg ICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Rv bS9UZXh0RXZlbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9UZXh0RXZlbnQuaAppbmRleCBkNzcw ZDM4ODQ0MzQwZjY4NDA1MjdiOGM3YzE0OWVmZjliZGMwYjdhLi4yNmM4YjkzZDQxMDIyODM1ZDQ2 NTMwNDA5N2UyYWEyYTFlMDNhOWI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vVGV4 dEV2ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudC5oCkBAIC01MSw2ICs1 MSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBib29sIGlzVGV4dEV2 ZW50KCkgY29uc3Q7CiAKICAgICAgICAgYm9vbCBpc0xpbmVCcmVhaygpIGNvbnN0IHsgcmV0dXJu IG1faW5wdXRUeXBlID09IFRleHRFdmVudElucHV0TGluZUJyZWFrOyB9CisgICAgICAgIGJvb2wg aXNDb21wb3NpdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09IFRleHRFdmVudElu cHV0Q29tcG9zaXRpb247IH0KICAgICAgICAgYm9vbCBpc0JhY2tUYWIoKSBjb25zdCB7IHJldHVy biBtX2lucHV0VHlwZSA9PSBUZXh0RXZlbnRJbnB1dEJhY2tUYWI7IH0KICAgICAgICAgYm9vbCBp c1Bhc3RlKCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUgPT0gVGV4dEV2ZW50SW5wdXRQYXN0 ZTsgfQogICAgICAgICBib29sIGlzRHJvcCgpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlID09 IFRleHRFdmVudElucHV0RHJvcDsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1Rl eHRFdmVudElucHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1RleHRFdmVudElucHV0VHlw ZS5oCmluZGV4IDI1MjJlYzQ1ZmY3ZjgxOTFmNzQ1OTBiYmQ4OTkzNjNlNzI3NGU2ODUuLmY1YTA1 ZWI3MDA0ZGQ4M2I4ZTMxZmVhMjUyNWFiNGUxZGUyZTFlMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2RvbS9UZXh0RXZlbnRJbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20v VGV4dEV2ZW50SW5wdXRUeXBlLmgKQEAgLTMxLDYgKzMxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogZW51bSBUZXh0RXZlbnRJbnB1dFR5cGUgewogICAgIFRleHRFdmVudElucHV0S2V5Ym9hcmQs IC8vIGFueSBuZXdsaW5lIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQgYXJlIGxpbmUgYnJlYWtzIG9u bHksIG5vdCBwYXJhZ3JhcGggc2VwYXJhdG9ycy4KICAgICBUZXh0RXZlbnRJbnB1dExpbmVCcmVh aywgLy8gYW55IHRhYiBjaGFyYWN0ZXJzIGluIHRoZSB0ZXh0IGFyZSBiYWNrdGFicy4KKyAgICBU ZXh0RXZlbnRJbnB1dENvbXBvc2l0aW9uLAogICAgIFRleHRFdmVudElucHV0QmFja1RhYiwKICAg ICBUZXh0RXZlbnRJbnB1dFBhc3RlLAogICAgIFRleHRFdmVudElucHV0RHJvcCwKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwIGIvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKaW5kZXggNTUyZWQ3 OTRmMTQ4NDdjNTMwZDJmOGE4ZjdjMjExZTllMGRjMzcxMC4uMzkyODBkNGMxMThkYTljOTVlM2Rm NWRkZjk2NTAyNGRmOWU4ZGRhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9D b21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21w b3NpdGVFZGl0Q29tbWFuZC5jcHAKQEAgLTM5NSw1MiArMzk1LDg0IEBAIHN0YXRpYyBpbmxpbmUg Ym9vbCBpc1doaXRlc3BhY2UoVUNoYXIgYykKICAgICByZXR1cm4gYyA9PSBub0JyZWFrU3BhY2Ug fHwgYyA9PSAnICcgfHwgYyA9PSAnXG4nIHx8IGMgPT0gJ1x0JzsKIH0KIAotLy8gRklYTUU6IERv ZXNuJ3QgZ28gaW50byB0ZXh0IG5vZGVzIHRoYXQgY29udHJpYnV0ZSBhZGphY2VudCB0ZXh0IChz aWJsaW5ncywgY291c2lucywgZXRjKS4KLXZvaWQgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFs YW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlvbiYgcG9zaXRpb24pCitzdGF0aWMgaW5saW5l IGJvb2wgY29udGFpbnNPbmx5V2hpdGVzcGFjZShjb25zdCBTdHJpbmcmIHRleHQpCit7CisgICAg Zm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHRleHQubGVuZ3RoKCk7ICsraSkgeworICAgICAgICBp ZiAoIWlzV2hpdGVzcGFjZSh0ZXh0LmNoYXJhY3RlcnMoKVtpXSkpCisgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgfQorICAgIAorICAgIHJldHVybiB0cnVlOworfQorCitib29sIENvbXBv c2l0ZUVkaXRDb21tYW5kOjpzaG91bGRSZWJhbGFuY2VMZWFkaW5nV2hpdGVzcGFjZUZvcihjb25z dCBTdHJpbmcmIHRleHQpIGNvbnN0Cit7CisgICAgcmV0dXJuIGNvbnRhaW5zT25seVdoaXRlc3Bh Y2UodGV4dCk7Cit9CisKK2Jvb2wgQ29tcG9zaXRlRWRpdENvbW1hbmQ6OmNhblJlYmFsYW5jZShj b25zdCBQb3NpdGlvbiYgcG9zaXRpb24pIGNvbnN0CiB7CiAgICAgTm9kZSogbm9kZSA9IHBvc2l0 aW9uLmNvbnRhaW5lck5vZGUoKTsKICAgICBpZiAocG9zaXRpb24uYW5jaG9yVHlwZSgpICE9IFBv c2l0aW9uOjpQb3NpdGlvbklzT2Zmc2V0SW5BbmNob3IgfHwgIW5vZGUgfHwgIW5vZGUtPmlzVGV4 dE5vZGUoKSkKLSAgICAgICAgcmV0dXJuOwotICAgIFRleHQqIHRleHROb2RlID0gc3RhdGljX2Nh c3Q8VGV4dCo+KG5vZGUpOworICAgICAgICByZXR1cm4gZmFsc2U7CiAKKyAgICBUZXh0KiB0ZXh0 Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQqPihub2RlKTsKICAgICBpZiAodGV4dE5vZGUtPmxlbmd0 aCgpID09IDApCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCiAgICAg UmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IHRleHROb2RlLT5yZW5kZXJlcigpOwogICAgIGlmIChy ZW5kZXJlciAmJiAhcmVuZGVyZXItPnN0eWxlKCktPmNvbGxhcHNlV2hpdGVTcGFjZSgpKQotICAg ICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKIAotICAgIFN0cmluZyB0ZXh0ID0g dGV4dE5vZGUtPmRhdGEoKTsKLSAgICBBU1NFUlQoIXRleHQuaXNFbXB0eSgpKTsKKyAgICByZXR1 cm4gdHJ1ZTsKK30KKworLy8gRklYTUU6IERvZXNuJ3QgZ28gaW50byB0ZXh0IG5vZGVzIHRoYXQg Y29udHJpYnV0ZSBhZGphY2VudCB0ZXh0IChzaWJsaW5ncywgY291c2lucywgZXRjKS4KK3ZvaWQg Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnJlYmFsYW5jZVdoaXRlc3BhY2VBdChjb25zdCBQb3NpdGlv biYgcG9zaXRpb24pCit7CisgICAgTm9kZSogbm9kZSA9IHBvc2l0aW9uLmNvbnRhaW5lck5vZGUo KTsKKyAgICBpZiAoIWNhblJlYmFsYW5jZShwb3NpdGlvbikpCisgICAgICAgIHJldHVybjsKIAor ICAgIC8vIElmIHRoZSByZWJhbGFuY2UgaXMgZm9yIHRoZSBzaW5nbGUgb2Zmc2V0LCBhbmQgbmVp dGhlciB0ZXh0W29mZnNldF0gbm9yIHRleHRbb2Zmc2V0IC0gMV0gYXJlIHNvbWUgZm9ybSBvZiB3 aGl0ZXNwYWNlLCBkbyBub3RoaW5nLgogICAgIGludCBvZmZzZXQgPSBwb3NpdGlvbi5kZXByZWNh dGVkRWRpdGluZ09mZnNldCgpOwotICAgIC8vIElmIG5laXRoZXIgdGV4dFtvZmZzZXRdIG5vciB0 ZXh0W29mZnNldCAtIDFdIGFyZSBzb21lIGZvcm0gb2Ygd2hpdGVzcGFjZSwgZG8gbm90aGluZy4K KyAgICBTdHJpbmcgdGV4dCA9IHN0YXRpY19jYXN0PFRleHQqPihub2RlKS0+ZGF0YSgpOwogICAg IGlmICghaXNXaGl0ZXNwYWNlKHRleHRbb2Zmc2V0XSkpIHsKICAgICAgICAgb2Zmc2V0LS07CiAg ICAgICAgIGlmIChvZmZzZXQgPCAwIHx8ICFpc1doaXRlc3BhY2UodGV4dFtvZmZzZXRdKSkKICAg ICAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgCisKKyAgICByZWJhbGFuY2VXaGl0ZXNwYWNl T25UZXh0U3Vic3RyaW5nKHN0YXRpY19jYXN0PFRleHQqPihub2RlKSwgcG9zaXRpb24ub2Zmc2V0 SW5Db250YWluZXJOb2RlKCksIHBvc2l0aW9uLm9mZnNldEluQ29udGFpbmVyTm9kZSgpKTsKK30K Kwordm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6cmViYWxhbmNlV2hpdGVzcGFjZU9uVGV4dFN1 YnN0cmluZyhSZWZQdHI8VGV4dD4gdGV4dE5vZGUsIGludCBzdGFydE9mZnNldCwgaW50IGVuZE9m ZnNldCkKK3sKKyAgICBTdHJpbmcgdGV4dCA9IHRleHROb2RlLT5kYXRhKCk7CisgICAgQVNTRVJU KCF0ZXh0LmlzRW1wdHkoKSk7CisKICAgICAvLyBTZXQgdXBzdHJlYW0gYW5kIGRvd25zdHJlYW0g dG8gZGVmaW5lIHRoZSBleHRlbnQgb2YgdGhlIHdoaXRlc3BhY2Ugc3Vycm91bmRpbmcgdGV4dFtv ZmZzZXRdLgotICAgIGludCB1cHN0cmVhbSA9IG9mZnNldDsKKyAgICBpbnQgdXBzdHJlYW0gPSBz dGFydE9mZnNldDsKICAgICB3aGlsZSAodXBzdHJlYW0gPiAwICYmIGlzV2hpdGVzcGFjZSh0ZXh0 W3Vwc3RyZWFtIC0gMV0pKQogICAgICAgICB1cHN0cmVhbS0tOwogICAgIAotICAgIGludCBkb3du c3RyZWFtID0gb2Zmc2V0OwotICAgIHdoaWxlICgodW5zaWduZWQpZG93bnN0cmVhbSArIDEgPCB0 ZXh0Lmxlbmd0aCgpICYmIGlzV2hpdGVzcGFjZSh0ZXh0W2Rvd25zdHJlYW0gKyAxXSkpCisgICAg aW50IGRvd25zdHJlYW0gPSBlbmRPZmZzZXQ7CisgICAgd2hpbGUgKCh1bnNpZ25lZClkb3duc3Ry ZWFtIDwgdGV4dC5sZW5ndGgoKSAmJiBpc1doaXRlc3BhY2UodGV4dFtkb3duc3RyZWFtXSkpCiAg ICAgICAgIGRvd25zdHJlYW0rKzsKICAgICAKLSAgICBpbnQgbGVuZ3RoID0gZG93bnN0cmVhbSAt IHVwc3RyZWFtICsgMTsKLSAgICBBU1NFUlQobGVuZ3RoID4gMCk7Ci0gICAgCi0gICAgVmlzaWJs ZVBvc2l0aW9uIHZpc2libGVVcHN0cmVhbVBvcyhQb3NpdGlvbihwb3NpdGlvbi5jb250YWluZXJO b2RlKCksIHVwc3RyZWFtLCBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9yKSk7Ci0g ICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVEb3duc3RyZWFtUG9zKFBvc2l0aW9uKHBvc2l0aW9u LmNvbnRhaW5lck5vZGUoKSwgZG93bnN0cmVhbSArIDEsIFBvc2l0aW9uOjpQb3NpdGlvbklzT2Zm c2V0SW5BbmNob3IpKTsKKyAgICBpbnQgbGVuZ3RoID0gZG93bnN0cmVhbSAtIHVwc3RyZWFtOwor ICAgIGlmICghbGVuZ3RoKQorICAgICAgICByZXR1cm47CisKKyAgICBWaXNpYmxlUG9zaXRpb24g dmlzaWJsZVVwc3RyZWFtUG9zKFBvc2l0aW9uKHRleHROb2RlLCB1cHN0cmVhbSwgUG9zaXRpb246 OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOworICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxl RG93bnN0cmVhbVBvcyhQb3NpdGlvbih0ZXh0Tm9kZSwgZG93bnN0cmVhbSwgUG9zaXRpb246OlBv c2l0aW9uSXNPZmZzZXRJbkFuY2hvcikpOwogICAgIAogICAgIFN0cmluZyBzdHJpbmcgPSB0ZXh0 LnN1YnN0cmluZyh1cHN0cmVhbSwgbGVuZ3RoKTsKICAgICBTdHJpbmcgcmViYWxhbmNlZFN0cmlu ZyA9IHN0cmluZ1dpdGhSZWJhbGFuY2VkV2hpdGVzcGFjZShzdHJpbmcsCiAgICAgLy8gRklYTUU6 IEJlY2F1c2Ugb2YgdGhlIHByb2JsZW0gbWVudGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhpcyBmdW5j dGlvbiwgd2UgbXVzdCBhbHNvIHVzZSBuYnNwcyBhdCB0aGUgc3RhcnQvZW5kIG9mIHRoZSBzdHJp bmcgYmVjYXVzZQogICAgIC8vIHRoaXMgZnVuY3Rpb24gZG9lc24ndCBnZXQgYWxsIHN1cnJvdW5k aW5nIHdoaXRlc3BhY2UsIGp1c3QgdGhlIHdoaXRlc3BhY2UgaW4gdGhlIGN1cnJlbnQgdGV4dCBu b2RlLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGlzU3RhcnRPZlBhcmFncmFwaCh2aXNpYmxlVXBzdHJlYW1Qb3MpIHx8IHVwc3Ry ZWFtID09IDAsIAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGlzRW5kT2ZQYXJhZ3JhcGgodmlzaWJsZURvd25zdHJlYW1Qb3MpIHx8 ICh1bnNpZ25lZClkb3duc3RyZWFtID09IHRleHQubGVuZ3RoKCkgLSAxKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpc0VuZE9m UGFyYWdyYXBoKHZpc2libGVEb3duc3RyZWFtUG9zKSB8fCAodW5zaWduZWQpZG93bnN0cmVhbSA9 PSB0ZXh0Lmxlbmd0aCgpKTsKICAgICAKICAgICBpZiAoc3RyaW5nICE9IHJlYmFsYW5jZWRTdHJp bmcpCiAgICAgICAgIHJlcGxhY2VUZXh0SW5Ob2RlKHRleHROb2RlLCB1cHN0cmVhbSwgbGVuZ3Ro LCByZWJhbGFuY2VkU3RyaW5nKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv Q29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRl RWRpdENvbW1hbmQuaAppbmRleCA2ZGI0ZWIxODJhMDg4NmFkMWZkODBiMDRlOGMxYzZmMzYxY2Iw MzAwLi45MDY2YjY1MjUyNjA1NTVjOGQ4YjMyODhmYTczZDkyOTFhZTRiZDZkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC03MSw3ICs3MSwx MCBAQCBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBtZXJnZUlkZW50aWNhbEVsZW1lbnRzKFBhc3NSZWZQ dHI8RWxlbWVudD4sIFBhc3NSZWZQdHI8RWxlbWVudD4pOwogICAgIHZvaWQgcmViYWxhbmNlV2hp dGVzcGFjZSgpOwogICAgIHZvaWQgcmViYWxhbmNlV2hpdGVzcGFjZUF0KGNvbnN0IFBvc2l0aW9u Jik7CisgICAgdm9pZCByZWJhbGFuY2VXaGl0ZXNwYWNlT25UZXh0U3Vic3RyaW5nKFJlZlB0cjxU ZXh0PiwgaW50IHN0YXJ0T2Zmc2V0LCBpbnQgZW5kT2Zmc2V0KTsKICAgICB2b2lkIHByZXBhcmVX aGl0ZXNwYWNlQXRQb3NpdGlvbkZvclNwbGl0KFBvc2l0aW9uJik7CisgICAgYm9vbCBjYW5SZWJh bGFuY2UoY29uc3QgUG9zaXRpb24mKSBjb25zdDsKKyAgICBib29sIHNob3VsZFJlYmFsYW5jZUxl YWRpbmdXaGl0ZXNwYWNlRm9yKGNvbnN0IFN0cmluZyYpIGNvbnN0OwogICAgIHZvaWQgcmVtb3Zl Q1NTUHJvcGVydHkoUGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50PiwgQ1NTUHJvcGVydHlJRCk7CiAg ICAgdm9pZCByZW1vdmVOb2RlQXR0cmlidXRlKFBhc3NSZWZQdHI8RWxlbWVudD4sIGNvbnN0IFF1 YWxpZmllZE5hbWUmIGF0dHJpYnV0ZSk7CiAgICAgdm9pZCByZW1vdmVDaGlsZHJlbkluUmFuZ2Uo UGFzc1JlZlB0cjxOb2RlPiwgdW5zaWduZWQgZnJvbSwgdW5zaWduZWQgdG8pOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRp dGluZy9FZGl0b3IuY3BwCmluZGV4IDIzYjQxY2ViZWE3N2ZiMDFjMDcyMzQ2YmRkNDJkMzdjNmFi MTg3YjcuLjNhY2VjMjdhMzgzNDU1YzU1YjM5YTMwOTliNGRjNzIwNGVmMmYwODUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTExNzMsNyArMTE3MywxMiBAQCBib29sIEVkaXRvcjo6 aW5zZXJ0VGV4dChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCiAg ICAgcmV0dXJuIG1fZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5oYW5kbGVUZXh0SW5wdXRFdmVudCh0 ZXh0LCB0cmlnZ2VyaW5nRXZlbnQpOwogfQogCi1ib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdpdGhv dXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRl ZFRleHQsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQpCitib29sIEVkaXRvcjo6aW5zZXJ0VGV4dEZv ckNvbmZpcm1lZENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCkKK3sKKyAgICByZXR1cm4g bV9mcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmhhbmRsZVRleHRJbnB1dEV2ZW50KHRleHQsIDAsIFRl eHRFdmVudElucHV0Q29tcG9zaXRpb24pOworfQorCitib29sIEVkaXRvcjo6aW5zZXJ0VGV4dFdp dGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQsIFRleHRFdmVudCogdHJpZ2dlcmluZ0V2ZW50KQogewogICAgIGlmICh0ZXh0Lmlz RW1wdHkoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtMTE5NSw3ICsxMjAwLDggQEAgYm9v bCBFZGl0b3I6Omluc2VydFRleHRXaXRob3V0U2VuZGluZ1RleHRFdmVudChjb25zdCBTdHJpbmcm IHRleHQsIGJvb2wgc2VsZWN0SW4KICAgICAgICAgICAgIFJlZlB0cjxEb2N1bWVudD4gZG9jdW1l bnQgPSBzZWxlY3Rpb25TdGFydC0+ZG9jdW1lbnQoKTsKICAgICAgICAgICAgIAogICAgICAgICAg ICAgLy8gSW5zZXJ0IHRoZSB0ZXh0Ci0gICAgICAgICAgICBUeXBpbmdDb21tYW5kOjppbnNlcnRU ZXh0KGRvY3VtZW50LmdldCgpLCB0ZXh0LCBzZWxlY3Rpb24sIHNlbGVjdEluc2VydGVkVGV4dCk7 CisgICAgICAgICAgICBUeXBpbmdDb21tYW5kOjppbnNlcnRUZXh0KGRvY3VtZW50LmdldCgpLCB0 ZXh0LCBzZWxlY3Rpb24sIHNlbGVjdEluc2VydGVkVGV4dCwgCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHRyaWdnZXJpbmdFdmVudCAmJiB0cmlnZ2VyaW5nRXZlbnQtPmlz Q29tcG9zaXRpb24oKSA/IFR5cGluZ0NvbW1hbmQ6OlRleHRDb21wb3NpdGlvbkNvbmZpcm0gOiBU eXBpbmdDb21tYW5kOjpUZXh0Q29tcG9zaXRpb25Ob25lKTsKIAogICAgICAgICAgICAgLy8gUmV2 ZWFsIHRoZSBjdXJyZW50IHNlbGVjdGlvbiAKICAgICAgICAgICAgIGlmIChGcmFtZSogZWRpdGVk RnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKSkKQEAgLTE2MTgsNyArMTYyNCw3IEBAIHZvaWQgRWRp dG9yOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHByZXNlcnZl U2VsZWN0aW9uKQogICAgIG1fY29tcG9zaXRpb25Ob2RlID0gMDsKICAgICBtX2N1c3RvbUNvbXBv c2l0aW9uVW5kZXJsaW5lcy5jbGVhcigpOwogCi0gICAgaW5zZXJ0VGV4dCh0ZXh0LCAwKTsKKyAg ICBpbnNlcnRUZXh0Rm9yQ29uZmlybWVkQ29tcG9zaXRpb24odGV4dCk7CiAKICAgICBpZiAocHJl c2VydmVTZWxlY3Rpb24pIHsKICAgICAgICAgbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNldFNlbGVj dGlvbihvbGRTZWxlY3Rpb24sIGZhbHNlLCBmYWxzZSk7CkBAIC0xNjg3LDcgKzE2OTMsNyBAQCB2 b2lkIEVkaXRvcjo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBWZWN0 b3I8Q29tcG9zaXRpb25VbmRlcmxpbgogICAgIG1fY3VzdG9tQ29tcG9zaXRpb25VbmRlcmxpbmVz LmNsZWFyKCk7CiAKICAgICBpZiAoIXRleHQuaXNFbXB0eSgpKSB7Ci0gICAgICAgIFR5cGluZ0Nv bW1hbmQ6Omluc2VydFRleHQobV9mcmFtZS0+ZG9jdW1lbnQoKSwgdGV4dCwgdHJ1ZSwgdHJ1ZSk7 CisgICAgICAgIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQobV9mcmFtZS0+ZG9jdW1lbnQoKSwg dGV4dCwgdHJ1ZSwgVHlwaW5nQ29tbWFuZDo6VGV4dENvbXBvc2l0aW9uVXBkYXRlKTsKIAogICAg ICAgICAvLyBGaW5kIG91dCB3aGF0IG5vZGUgaGFzIHRoZSBjb21wb3NpdGlvbiBub3cuCiAgICAg ICAgIFBvc2l0aW9uIGJhc2UgPSBtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+YmFzZSgpLmRvd25zdHJl YW0oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggYi9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCmluZGV4IDJlNjFjZTY3ZDE4MTg1YTY2YTkyODAx ZDZiN2E5NWE0Nzg5NDZlYzkuLjFlNmUzODczZjVkYzhkZWYyZDBkMjBhMDBjYjEzMzM4YTljMDlh OWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMTk4LDcgKzE5OCw4IEBAIHB1YmxpYzoK ICAgICBzdGF0aWMgYm9vbCBjb21tYW5kSXNTdXBwb3J0ZWRGcm9tTWVudU9yS2V5QmluZGluZyhj b25zdCBTdHJpbmcmIGNvbW1hbmROYW1lKTsgLy8gV29ya3Mgd2l0aG91dCBhIGZyYW1lLgogCiAg ICAgYm9vbCBpbnNlcnRUZXh0KGNvbnN0IFN0cmluZyYsIEV2ZW50KiB0cmlnZ2VyaW5nRXZlbnQp OwotICAgIGJvb2wgaW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0cmlu ZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBFdmVudCogdHJpZ2dlcmluZ0V2ZW50KTsKKyAg ICBib29sIGluc2VydFRleHRGb3JDb25maXJtZWRDb21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRl eHQpOworICAgIGJvb2wgaW5zZXJ0VGV4dFdpdGhvdXRTZW5kaW5nVGV4dEV2ZW50KGNvbnN0IFN0 cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0RXZlbnQqIHRyaWdnZXJpbmdFdmVu dCk7CiAgICAgYm9vbCBpbnNlcnRMaW5lQnJlYWsoKTsKICAgICBib29sIGluc2VydFBhcmFncmFw aFNlcGFyYXRvcigpOwogICAgIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9J bnNlcnRUZXh0Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRD b21tYW5kLmNwcAppbmRleCBmYzE4ZTkxMmY5NTM2MzZhZmIyNzE2ZjBjMTYyM2Q1MDkwNjg5ZjVk Li43NGExMTFhMjJhNDM4MDA2YWMzYjczNWQ4Mzk5Yjk2MTkzMWUwZGI0IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcApAQCAtMTA2LDcgKzEwNiw3IEBA IGJvb2wgSW5zZXJ0VGV4dENvbW1hbmQ6OnBlcmZvcm1Ucml2aWFsUmVwbGFjZShjb25zdCBTdHJp bmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSW5z ZXJ0VGV4dENvbW1hbmQ6OmlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNl cnRlZFRleHQpCit2b2lkIEluc2VydFRleHRDb21tYW5kOjppbnB1dChjb25zdCBTdHJpbmcmIHRl eHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBSZWJhbGFuY2VUeXBlIHdoaXRlc3BhY2VSZWJh bGFuY2UpCiB7CiAgICAgCiAgICAgQVNTRVJUKHRleHQuZmluZCgnXG4nKSA9PSBub3RGb3VuZCk7 CkBAIC0xNzIsMTEgKzE3MiwxNyBAQCB2b2lkIEluc2VydFRleHRDb21tYW5kOjppbnB1dChjb25z dCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0KQogICAgICAgICBpbnNlcnRU ZXh0SW50b05vZGUodGV4dE5vZGUsIG9mZnNldCwgdGV4dCk7CiAgICAgICAgIGVuZFBvc2l0aW9u ID0gUG9zaXRpb24odGV4dE5vZGUsIG9mZnNldCArIHRleHQubGVuZ3RoKCkpOwogCi0gICAgICAg IC8vIFRoZSBpbnNlcnRpb24gbWF5IHJlcXVpcmUgYWRqdXN0aW5nIGFkamFjZW50IHdoaXRlc3Bh Y2UsIGlmIGl0IGlzIHByZXNlbnQuCi0gICAgICAgIHJlYmFsYW5jZVdoaXRlc3BhY2VBdChlbmRQ b3NpdGlvbik7Ci0gICAgICAgIC8vIFJlYmFsYW5jaW5nIG9uIGJvdGggc2lkZXMgaXNuJ3QgbmVj ZXNzYXJ5IGlmIHdlJ3ZlIGluc2VydGVkIGEgc3BhY2UuCi0gICAgICAgIGlmICh0ZXh0ICE9ICIg IikgCi0gICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNwYWNlQXQoc3RhcnRQb3NpdGlvbik7Cisg ICAgICAgIGlmICh3aGl0ZXNwYWNlUmViYWxhbmNlID09IFJlYmFsYW5jZUxlYWRpbmdBbmRUcmFp bGluZ1doaXRlc3BhY2VzKSB7CisgICAgICAgICAgICAvLyBUaGUgaW5zZXJ0aW9uIG1heSByZXF1 aXJlIGFkanVzdGluZyBhZGphY2VudCB3aGl0ZXNwYWNlLCBpZiBpdCBpcyBwcmVzZW50LgorICAg ICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZUF0KGVuZFBvc2l0aW9uKTsKKyAgICAgICAgICAg IC8vIFJlYmFsYW5jaW5nIG9uIGJvdGggc2lkZXMgaXNuJ3QgbmVjZXNzYXJ5IGlmIHdlJ3ZlIGlu c2VydGVkIG9ubHkgc3BhY2VzLgorICAgICAgICAgICAgaWYgKCFzaG91bGRSZWJhbGFuY2VMZWFk aW5nV2hpdGVzcGFjZUZvcih0ZXh0KSkKKyAgICAgICAgICAgICAgICByZWJhbGFuY2VXaGl0ZXNw YWNlQXQoc3RhcnRQb3NpdGlvbik7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBBU1NF UlQod2hpdGVzcGFjZVJlYmFsYW5jZSA9PSBSZWJhbGFuY2VBbGxXaGl0ZXNwYWNlcyk7CisgICAg ICAgICAgICBpZiAoY2FuUmViYWxhbmNlKHN0YXJ0UG9zaXRpb24pICYmIGNhblJlYmFsYW5jZShl bmRQb3NpdGlvbikpCisgICAgICAgICAgICAgICAgcmViYWxhbmNlV2hpdGVzcGFjZU9uVGV4dFN1 YnN0cmluZyh0ZXh0Tm9kZSwgc3RhcnRQb3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgp LCBlbmRQb3NpdGlvbi5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpKTsKKyAgICAgICAgfQogICAg IH0KIAogICAgIC8vIFdlIGNvdWxkIGhhdmUgaW5zZXJ0ZWQgYSBwYXJ0IG9mIGNvbXBvc2VkIGNo YXJhY3RlciBzZXF1ZW5jZSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0VGV4dENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1h bmQuaAppbmRleCA3N2FlMDE2ZDM2YTE0ZmIxZjgxNDlkZjdhYTM0MTJjZGVjMWQyMmRlLi42NzJl NTc2ZjkyMDc5YTVjZjk3N2FlNWNmOGEyNGJkOWMyN2ZhNGM3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFuZC5oCkBAIC0zMiwxNCArMzIsMjAgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogCiBjbGFzcyBJbnNlcnRUZXh0Q29tbWFuZCA6IHB1YmxpYyBDb21wb3NpdGVF ZGl0Q29tbWFuZCB7CiBwdWJsaWM6CisgICAgZW51bSBSZWJhbGFuY2VUeXBlIHsKKyAgICAgICAg UmViYWxhbmNlTGVhZGluZ0FuZFRyYWlsaW5nV2hpdGVzcGFjZXMsCisgICAgICAgIFJlYmFsYW5j ZUFsbFdoaXRlc3BhY2VzCisgICAgfTsKKwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPEluc2VydFRl eHRDb21tYW5kPiBjcmVhdGUoRG9jdW1lbnQqIGRvY3VtZW50KQogICAgIHsKICAgICAgICAgcmV0 dXJuIGFkb3B0UmVmKG5ldyBJbnNlcnRUZXh0Q29tbWFuZChkb2N1bWVudCkpOwogICAgIH0KIAot ICAgIHZvaWQgaW5wdXQoY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4 dCA9IGZhbHNlKTsKKyAgICB2b2lkIGlucHV0KGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxl Y3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgUmViYWxhbmNlVHlwZSA9IFJlYmFsYW5jZUxlYWRpbmdB bmRUcmFpbGluZ1doaXRlc3BhY2VzKTsKIAogcHJpdmF0ZToKKwogICAgIEluc2VydFRleHRDb21t YW5kKERvY3VtZW50Kik7CiAKICAgICB2b2lkIGRlbGV0ZUNoYXJhY3RlcigpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5jcHAKaW5kZXggZDU0YjM4ODViZjk4ZmU1MmJkOWE2 NWM1NGE4ZDcxZDk2NzYwN2U5ZC4uMjFkNDMxNGFkMDc1NDhhMDhjOTgyN2IwZjE1NWI5OWFiMjI4 YjYxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwCkBAIC00Nyw3 ICs0Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogdXNpbmcgbmFtZXNwYWNlIEhUTUxOYW1l czsKIAotVHlwaW5nQ29tbWFuZDo6VHlwaW5nQ29tbWFuZChEb2N1bWVudCAqZG9jdW1lbnQsIEVU eXBpbmdDb21tYW5kIGNvbW1hbmRUeXBlLCBjb25zdCBTdHJpbmcgJnRleHRUb0luc2VydCwgYm9v bCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSwgYm9vbCBr aWxsUmluZykKK1R5cGluZ0NvbW1hbmQ6OlR5cGluZ0NvbW1hbmQoRG9jdW1lbnQgKmRvY3VtZW50 LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kVHlwZSwgY29uc3QgU3RyaW5nICZ0ZXh0VG9JbnNlcnQs IGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHksIFRl eHRDb21wb3NpdGlvblR5cGUgY29tcG9zaXRpb25UeXBlLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBib29sIGtpbGxSaW5nKQogICAgIDogQ29tcG9zaXRlRWRpdENvbW1hbmQoZG9jdW1l bnQpLCAKICAgICAgIG1fY29tbWFuZFR5cGUoY29tbWFuZFR5cGUpLCAKICAgICAgIG1fdGV4dFRv SW5zZXJ0KHRleHRUb0luc2VydCksIApAQCAtNTUsNiArNTYsNyBAQCBUeXBpbmdDb21tYW5kOjpU eXBpbmdDb21tYW5kKERvY3VtZW50ICpkb2N1bWVudCwgRVR5cGluZ0NvbW1hbmQgY29tbWFuZFR5 cGUsIGNvbgogICAgICAgbV9zZWxlY3RJbnNlcnRlZFRleHQoc2VsZWN0SW5zZXJ0ZWRUZXh0KSwK ICAgICAgIG1fc21hcnREZWxldGUoZmFsc2UpLAogICAgICAgbV9ncmFudWxhcml0eShncmFudWxh cml0eSksCisgICAgICBtX2NvbXBvc2l0aW9uVHlwZShjb21wb3NpdGlvblR5cGUpLAogICAgICAg bV9raWxsUmluZyhraWxsUmluZyksCiAgICAgICBtX29wZW5lZEJ5QmFja3dhcmREZWxldGUoZmFs c2UpCiB7CkBAIC0xMzMsMTggKzEzNSwxOCBAQCB2b2lkIFR5cGluZ0NvbW1hbmQ6OnVwZGF0ZVNl bGVjdGlvbklmRGlmZmVyZW50RnJvbUN1cnJlbnRTZWxlY3Rpb24oVHlwaW5nQ29tbWFuZAogfQog ICAgIAogCi12b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50 LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBib29sIGluc2Vy dGVkVGV4dElzQ29tcG9zaXRpb24pCit2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9j dW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRU ZXh0LCBUZXh0Q29tcG9zaXRpb25UeXBlIGNvbXBvc2l0aW9uKQogewogICAgIEFTU0VSVChkb2N1 bWVudCk7CiAgICAgCiAgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQtPmZyYW1lKCk7CiAgICAg QVNTRVJUKGZyYW1lKTsKIAotICAgIGluc2VydFRleHQoZG9jdW1lbnQsIHRleHQsIGZyYW1lLT5z ZWxlY3Rpb24oKS0+c2VsZWN0aW9uKCksIHNlbGVjdEluc2VydGVkVGV4dCwgaW5zZXJ0ZWRUZXh0 SXNDb21wb3NpdGlvbik7CisgICAgaW5zZXJ0VGV4dChkb2N1bWVudCwgdGV4dCwgZnJhbWUtPnNl bGVjdGlvbigpLT5zZWxlY3Rpb24oKSwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBjb21wb3NpdGlvbik7 CiB9CiAKIC8vIEZJWE1FOiBXZSBzaG91bGRuJ3QgbmVlZCB0byB0YWtlIHNlbGVjdGlvbkZvcklu c2VydGlvbi4gSXQgc2hvdWxkIGJlIGlkZW50aWNhbCB0byBTZWxlY3Rpb25Db250cm9sbGVyJ3Mg Y3VycmVudCBzZWxlY3Rpb24uCi12b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1l bnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpc2libGVTZWxlY3Rpb24m IHNlbGVjdGlvbkZvckluc2VydGlvbiwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIGJvb2wgaW5z ZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikKK3ZvaWQgVHlwaW5nQ29tbWFuZDo6aW5zZXJ0VGV4dChE b2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmlzaWJsZVNlbGVj dGlvbiYgc2VsZWN0aW9uRm9ySW5zZXJ0aW9uLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4 dENvbXBvc2l0aW9uVHlwZSBjb21wb3NpdGlvblR5cGUpCiB7CiAjaWYgUkVNT1ZFX01BUktFUlNf VVBPTl9FRElUSU5HCiAgICAgaWYgKCF0ZXh0LmlzRW1wdHkoKSkKQEAgLTE2MSw3ICsxNjMsNyBA QCB2b2lkIFR5cGluZ0NvbW1hbmQ6Omluc2VydFRleHQoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25z dCBTdHJpbmcmIHRleHQsIGNvbnN0IFZpcwogICAgIFN0cmluZyBuZXdUZXh0ID0gdGV4dDsKICAg ICBOb2RlKiBzdGFydE5vZGUgPSBzZWxlY3Rpb25Gb3JJbnNlcnRpb24uc3RhcnQoKS5ub2RlKCk7 CiAgICAgCi0gICAgaWYgKHN0YXJ0Tm9kZSAmJiBzdGFydE5vZGUtPnJvb3RFZGl0YWJsZUVsZW1l bnQoKSAmJiAhaW5zZXJ0ZWRUZXh0SXNDb21wb3NpdGlvbikgeyAgICAgICAgCisgICAgaWYgKHN0 YXJ0Tm9kZSAmJiBzdGFydE5vZGUtPnJvb3RFZGl0YWJsZUVsZW1lbnQoKSAmJiBjb21wb3NpdGlv blR5cGUgIT0gVGV4dENvbXBvc2l0aW9uVXBkYXRlKSB7CiAgICAgICAgIC8vIFNlbmQgQmVmb3Jl VGV4dEluc2VydGVkRXZlbnQuIFRoZSBldmVudCBoYW5kbGVyIHdpbGwgdXBkYXRlIHRleHQgaWYg bmVjZXNzYXJ5LgogICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKICAgICAgICAgUmVmUHRy PEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50PiBldnQgPSBCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudDo6 Y3JlYXRlKHRleHQpOwpAQCAtMTgyLDExICsxODQsMTMgQEAgdm9pZCBUeXBpbmdDb21tYW5kOjpp bnNlcnRUZXh0KERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBjb25zdCBW aXMKICAgICAgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5zZXRTdGFydGluZ1NlbGVjdGlvbihz ZWxlY3Rpb25Gb3JJbnNlcnRpb24pOwogICAgICAgICAgICAgbGFzdFR5cGluZ0NvbW1hbmQtPnNl dEVuZGluZ1NlbGVjdGlvbihzZWxlY3Rpb25Gb3JJbnNlcnRpb24pOwogICAgICAgICB9CisgICAg ICAgIAorICAgICAgICBsYXN0VHlwaW5nQ29tbWFuZC0+c2V0Q29tcG9zaXRpb25UeXBlKGNvbXBv c2l0aW9uVHlwZSk7CiAgICAgICAgIGxhc3RUeXBpbmdDb21tYW5kLT5pbnNlcnRUZXh0KG5ld1Rl eHQsIHNlbGVjdEluc2VydGVkVGV4dCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBS ZWZQdHI8VHlwaW5nQ29tbWFuZD4gY21kID0gVHlwaW5nQ29tbWFuZDo6Y3JlYXRlKGRvY3VtZW50 LCBJbnNlcnRUZXh0LCBuZXdUZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQpOworICAgIFJlZlB0cjxU eXBpbmdDb21tYW5kPiBjbWQgPSBUeXBpbmdDb21tYW5kOjpjcmVhdGUoZG9jdW1lbnQsIEluc2Vy dFRleHQsIG5ld1RleHQsIHNlbGVjdEluc2VydGVkVGV4dCwgY29tcG9zaXRpb25UeXBlKTsKICAg ICBpZiAoY2hhbmdlU2VsZWN0aW9uKSAgewogICAgICAgICBjbWQtPnNldFN0YXJ0aW5nU2VsZWN0 aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CiAgICAgICAgIGNtZC0+c2V0RW5kaW5nU2VsZWN0 aW9uKHNlbGVjdGlvbkZvckluc2VydGlvbik7CkBAIC0zODYsNyArMzkwLDggQEAgdm9pZCBUeXBp bmdDb21tYW5kOjppbnNlcnRUZXh0UnVuV2l0aG91dE5ld2xpbmVzKGNvbnN0IFN0cmluZyAmdGV4 dCwgYm9vbCBzZWxlY3QKICAgICAgICAgY29tbWFuZC0+c2V0U3RhcnRpbmdTZWxlY3Rpb24oZW5k aW5nU2VsZWN0aW9uKCkpOwogICAgICAgICBjb21tYW5kLT5zZXRFbmRpbmdTZWxlY3Rpb24oZW5k aW5nU2VsZWN0aW9uKCkpOwogICAgIH0KLSAgICBjb21tYW5kLT5pbnB1dCh0ZXh0LCBzZWxlY3RJ bnNlcnRlZFRleHQpOworICAgIGNvbW1hbmQtPmlucHV0KHRleHQsIHNlbGVjdEluc2VydGVkVGV4 dCwgCisgICAgICAgICAgICAgICAgICAgbV9jb21wb3NpdGlvblR5cGUgPT0gVGV4dENvbXBvc2l0 aW9uTm9uZSA/IEluc2VydFRleHRDb21tYW5kOjpSZWJhbGFuY2VMZWFkaW5nQW5kVHJhaWxpbmdX aGl0ZXNwYWNlcyA6IEluc2VydFRleHRDb21tYW5kOjpSZWJhbGFuY2VBbGxXaGl0ZXNwYWNlcyk7 CiAgICAgdHlwaW5nQWRkZWRUb09wZW5Db21tYW5kKEluc2VydFRleHQpOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuaCBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oCmluZGV4IDI4NGViYzBhYzI2NWQ3NmIxNmE4MGJm MjYxMWM3YTgwZTY4MGFkMGYuLmIzNGJkYzEyMjFhMjJhMzAxMjRhOTA4ODAxMGMwNTQ2NTFiZmRl NmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFuZC5oCkBAIC00MiwxMSArNDIs MTcgQEAgcHVibGljOgogICAgICAgICBJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JJblF1b3RlZENv bnRlbnQKICAgICB9OwogCisgICAgZW51bSBUZXh0Q29tcG9zaXRpb25UeXBlIHsKKyAgICAgICAg VGV4dENvbXBvc2l0aW9uTm9uZSwKKyAgICAgICAgVGV4dENvbXBvc2l0aW9uVXBkYXRlLAorICAg ICAgICBUZXh0Q29tcG9zaXRpb25Db25maXJtCisgICAgfTsKKwogICAgIHN0YXRpYyB2b2lkIGRl bGV0ZVNlbGVjdGlvbihEb2N1bWVudCosIGJvb2wgc21hcnREZWxldGUgPSBmYWxzZSk7CiAgICAg c3RhdGljIHZvaWQgZGVsZXRlS2V5UHJlc3NlZChEb2N1bWVudCosIGJvb2wgc21hcnREZWxldGUg PSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2ls bFJpbmcgPSBmYWxzZSk7CiAgICAgc3RhdGljIHZvaWQgZm9yd2FyZERlbGV0ZUtleVByZXNzZWQo RG9jdW1lbnQqLCBib29sIHNtYXJ0RGVsZXRlID0gZmFsc2UsIFRleHRHcmFudWxhcml0eSA9IENo YXJhY3RlckdyYW51bGFyaXR5LCBib29sIGtpbGxSaW5nID0gZmFsc2UpOwotICAgIHN0YXRpYyB2 b2lkIGluc2VydFRleHQoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBib29sIHNlbGVjdEluc2Vy dGVkVGV4dCA9IGZhbHNlLCBib29sIGluc2VydGVkVGV4dElzQ29tcG9zaXRpb24gPSBmYWxzZSk7 Ci0gICAgc3RhdGljIHZvaWQgaW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGNv bnN0IFZpc2libGVTZWxlY3Rpb24mLCBib29sIHNlbGVjdEluc2VydGVkVGV4dCA9IGZhbHNlLCBi b29sIGluc2VydGVkVGV4dElzQ29tcG9zaXRpb24gPSBmYWxzZSk7CisgICAgc3RhdGljIHZvaWQg aW5zZXJ0VGV4dChEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRU ZXh0ID0gZmFsc2UsIFRleHRDb21wb3NpdGlvblR5cGUgPSBUZXh0Q29tcG9zaXRpb25Ob25lKTsK KyAgICBzdGF0aWMgdm9pZCBpbnNlcnRUZXh0KERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0ID0gZmFsc2UsIFRl eHRDb21wb3NpdGlvblR5cGUgPSBUZXh0Q29tcG9zaXRpb25Ob25lKTsKICAgICBzdGF0aWMgdm9p ZCBpbnNlcnRMaW5lQnJlYWsoRG9jdW1lbnQqKTsKICAgICBzdGF0aWMgdm9pZCBpbnNlcnRQYXJh Z3JhcGhTZXBhcmF0b3IoRG9jdW1lbnQqKTsKICAgICBzdGF0aWMgdm9pZCBpbnNlcnRQYXJhZ3Jh cGhTZXBhcmF0b3JJblF1b3RlZENvbnRlbnQoRG9jdW1lbnQqKTsKQEAgLTY0LDE0ICs3MCwyMCBA QCBwdWJsaWM6CiAgICAgdm9pZCBkZWxldGVLZXlQcmVzc2VkKFRleHRHcmFudWxhcml0eSwgYm9v bCBraWxsUmluZyk7CiAgICAgdm9pZCBmb3J3YXJkRGVsZXRlS2V5UHJlc3NlZChUZXh0R3JhbnVs YXJpdHksIGJvb2wga2lsbFJpbmcpOwogICAgIHZvaWQgZGVsZXRlU2VsZWN0aW9uKGJvb2wgc21h cnREZWxldGUpOworICAgIHZvaWQgc2V0Q29tcG9zaXRpb25UeXBlKFRleHRDb21wb3NpdGlvblR5 cGUgdHlwZSkgeyBtX2NvbXBvc2l0aW9uVHlwZSA9IHR5cGU7IH0KIAogcHJpdmF0ZToKICAgICBz dGF0aWMgUGFzc1JlZlB0cjxUeXBpbmdDb21tYW5kPiBjcmVhdGUoRG9jdW1lbnQqIGRvY3VtZW50 LCBFVHlwaW5nQ29tbWFuZCBjb21tYW5kLCBjb25zdCBTdHJpbmcmIHRleHQgPSAiIiwgYm9vbCBz ZWxlY3RJbnNlcnRlZFRleHQgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5ID0g Q2hhcmFjdGVyR3JhbnVsYXJpdHksIGJvb2wga2lsbFJpbmcgPSBmYWxzZSkKICAgICB7Ci0gICAg ICAgIHJldHVybiBhZG9wdFJlZihuZXcgVHlwaW5nQ29tbWFuZChkb2N1bWVudCwgY29tbWFuZCwg dGV4dCwgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBncmFudWxhcml0eSwga2lsbFJpbmcpKTsKKyAgICAg ICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5kLCB0 ZXh0LCBzZWxlY3RJbnNlcnRlZFRleHQsIGdyYW51bGFyaXR5LCBUZXh0Q29tcG9zaXRpb25Ob25l LCBraWxsUmluZykpOworICAgIH0KKworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFR5cGluZ0NvbW1h bmQ+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQsIEVUeXBpbmdDb21tYW5kIGNvbW1hbmQsIGNv bnN0IFN0cmluZyYgdGV4dCwgYm9vbCBzZWxlY3RJbnNlcnRlZFRleHQsIFRleHRDb21wb3NpdGlv blR5cGUgY29tcG9zaXRpb25UeXBlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5l dyBUeXBpbmdDb21tYW5kKGRvY3VtZW50LCBjb21tYW5kLCB0ZXh0LCBzZWxlY3RJbnNlcnRlZFRl eHQsIENoYXJhY3RlckdyYW51bGFyaXR5LCBjb21wb3NpdGlvblR5cGUsIGZhbHNlKSk7CiAgICAg fQogCi0gICAgVHlwaW5nQ29tbWFuZChEb2N1bWVudCosIEVUeXBpbmdDb21tYW5kLCBjb25zdCBT dHJpbmcmIHRleHQsIGJvb2wgc2VsZWN0SW5zZXJ0ZWRUZXh0LCBUZXh0R3JhbnVsYXJpdHksIGJv b2wga2lsbFJpbmcpOworICAgIFR5cGluZ0NvbW1hbmQoRG9jdW1lbnQqLCBFVHlwaW5nQ29tbWFu ZCwgY29uc3QgU3RyaW5nJiB0ZXh0LCBib29sIHNlbGVjdEluc2VydGVkVGV4dCwgVGV4dEdyYW51 bGFyaXR5LCBUZXh0Q29tcG9zaXRpb25UeXBlLCBib29sIGtpbGxSaW5nKTsKIAogICAgIGJvb2wg c21hcnREZWxldGUoKSBjb25zdCB7IHJldHVybiBtX3NtYXJ0RGVsZXRlOyB9CiAgICAgdm9pZCBz ZXRTbWFydERlbGV0ZShib29sIHNtYXJ0RGVsZXRlKSB7IG1fc21hcnREZWxldGUgPSBzbWFydERl bGV0ZTsgfQpAQCAtOTQsNiArMTA2LDcgQEAgcHJpdmF0ZToKICAgICBib29sIG1fc2VsZWN0SW5z ZXJ0ZWRUZXh0OwogICAgIGJvb2wgbV9zbWFydERlbGV0ZTsKICAgICBUZXh0R3JhbnVsYXJpdHkg bV9ncmFudWxhcml0eTsKKyAgICBUZXh0Q29tcG9zaXRpb25UeXBlIG1fY29tcG9zaXRpb25UeXBl OwogICAgIGJvb2wgbV9raWxsUmluZzsKICAgICBib29sIG1fcHJlc2VydmVzVHlwaW5nU3R5bGU7 CiAgICAgCg==