61594 2011-05-26 19:34:36 -0700 REGRESSION: Hitting enter in the middle of this span causes the cursor to go to the end of the span 2011-06-22 16:19:17 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P1 Normal --- 62582 1 adele webkit-unassigned dcomfort enrica mitz rniwa sullivan webkit.review.bot oldest_to_newest 411080 0 adele 2011-05-26 19:34:36 -0700 REGRESSION: Hitting enter in the middle of this span causes the cursor to go to the end of the span I'm not sure when this regressed, but it works fine in Safari 5. 411083 1 95097 adele 2011-05-26 19:35:57 -0700 Created attachment 95097 test case 413796 2 sullivan 2011-06-01 17:57:22 -0700 It looks like this regressed in ChangeSet 83247. The original editing area contains <span>textnode1<br>textnode2</span>. Previously, a new div was created as a sibling to the span, a new span appended as a child of the new div, and the <br> and textnode2 were moved inside the new span. Now the div is created, but no new span is added and the <br> and textnode2 aren't moved. Two things changed: 1. The calls to getAncestorsInsideBlock() on line 305 and cloneHierarchyUnderNewBlock() on line 340 were removed, which prevents the new span from being added into the new div. 2. The loop on lines 345-356 was changed so that n is set to the newly inserted div. Previously, it was set to the <br> after the cursor, so that the loop on lines 358-363 copied the <br> and the second text node to the new <div>. Now that loop does nothing. 413839 3 rniwa 2011-06-01 19:22:31 -0700 This is a bug in splitTreeToNode. In the following DOM tree, splitTreeToNode doesn't split span because it thinks we're splitting the tree at the beginning of the first text node. BODY 0x116a3f370 * #text 0x116a3f660 "\n " SPAN 0x116a3f6c0 #text 0x116a3f890 "Hit Enter after this line" BR 0x116a3f970 #text 0x116a3fb70 "See the cursor appear at the end of this line" #text 0x116a3fc50 "\n\n" DIV 0x113408bf0 We'd have to modify splitTreeToNode to take a Position instead to handle this case in general. 415356 4 96004 sullivan 2011-06-03 18:57:32 -0700 Created attachment 96004 Work in Progress 415357 5 sullivan 2011-06-03 19:10:32 -0700 Some notes about this patch: I wasn't sure whether to implement a new splitTreeToPosition method, or modify splitTreeToNode to take either. Please let me know what you think. splitTreeToPosition currently doesn't handle splitting nodes if the position is not at the start or end of the node. Currently InsertParagraphSeparatorCommand is the only caller, and it never creates a case like that because it splits text nodes before calling splitTreeTo(Node|Position). I worry that callers may expect the method to split a node if the position is in the middle, but I don't want to add code that's not used or tested. What do you think? If you think I should add the code, I could try to use window.internal to add a test for it. I was pretty surprised at the results for the layout test when the cursor is at the start of the text node. It turns out that this is handled by a different codepath in InsertParagraphSeparatorCommand. I get the same results in Safari 5. The reason that the id is duplicated for the span "wrapper" is that InsertParagraphSeparatorCommand::cloneHierarchyUnderNewBlock() doesn't avoid duplicating ids, as SplitElementCommand::executeApply() does. Should I file a separate bug/write a separate patch for that? 415362 6 96004 rniwa 2011-06-03 19:28:20 -0700 Comment on attachment 96004 Work in Progress View in context: https://bugs.webkit.org/attachment.cgi?id=96004&action=review > Source/WebCore/editing/CompositeEditCommand.cpp:1250 > + // If the position is at the end of the node, split at the next node. > + if ((p.containerNode()->isTextNode() && p.offsetInContainerNode() == (int)static_cast<Text*>(p.containerNode())->length()) > + || (p.containerNode()->isElementNode() && p.offsetInContainerNode() == (int)splitNode->childNodes()->length())) > + splitNode = splitNode->nextSibling(); This logic is likely wrong as it doesn't take invisible nodes into account. 415365 7 rniwa 2011-06-03 19:35:13 -0700 Thanks for working on this bug. I'm excited to see a progress. (In reply to comment #5) > I wasn't sure whether to implement a new splitTreeToPosition method, or modify splitTreeToNode to take either. Please let me know what you think. We should modify splitTreeToNode to take a Position instead of adding a new function. > splitTreeToPosition currently doesn't handle splitting nodes if the position is not at the start or end of the node. Currently InsertParagraphSeparatorCommand is the only caller, and it never creates a case like that because it splits text nodes before calling splitTreeTo(Node|Position). It worries me to no end that we're adding a brand new function for dealing with this very specific case whereas splitTreeToNode is a well-understood function and used in many places. > The reason that the id is duplicated for the span "wrapper" is that InsertParagraphSeparatorCommand::cloneHierarchyUnderNewBlock() doesn't avoid duplicating ids, as SplitElementCommand::executeApply() does. Should I file a separate bug/write a separate patch for that? Yes, please file a separate bug for that. But maybe we should first merge that function with CompositeEditCommand::cloneParagraphUnderNewElement. It's really terrible that we have all these functions that do slightly different things all over the place. 415371 8 sullivan 2011-06-03 19:58:51 -0700 (In reply to comment #6) > (From update of attachment 96004 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=96004&action=review > > > Source/WebCore/editing/CompositeEditCommand.cpp:1250 > > + // If the position is at the end of the node, split at the next node. > > + if ((p.containerNode()->isTextNode() && p.offsetInContainerNode() == (int)static_cast<Text*>(p.containerNode())->length()) > > + || (p.containerNode()->isElementNode() && p.offsetInContainerNode() == (int)splitNode->childNodes()->length())) > > + splitNode = splitNode->nextSibling(); > > This logic is likely wrong as it doesn't take invisible nodes into account. You're right that I didn't take invisible nodes into account at all when writing this code. By invisible, do you mean display:none or something else? Is there a case I should add as a layout test? (In reply to comment #7) > Thanks for working on this bug. I'm excited to see a progress. > > (In reply to comment #5) > > I wasn't sure whether to implement a new splitTreeToPosition method, or modify splitTreeToNode to take either. Please let me know what you think. > > We should modify splitTreeToNode to take a Position instead of adding a new function. Sounds good. I rewrote as a separate function to start with so that it's easier to see what I'm trying to do and point out mistakes in early review. I also wasn't clear on what the arguments should be--it could take a node AND a position, expecting one of them to be null, or just take a position, expecting that in the common case the position would be at the start of the node. > > splitTreeToPosition currently doesn't handle splitting nodes if the position is not at the start or end of the node. Currently InsertParagraphSeparatorCommand is the only caller, and it never creates a case like that because it splits text nodes before calling splitTreeTo(Node|Position). > > It worries me to no end that we're adding a brand new function for dealing with this very specific case whereas splitTreeToNode is a well-understood function and used in many places. At the same time, complicating the arguments and adding one-off functionality to a simple, well-understood function used in many places seems quite dangerous, too. When I modify the function to take a position, I'll still need to answer this question about whether the position should be split, and make sure I don't introduce bugs with invisible nodes or anything else. Am I missing a less complicated way to fix this bug? Also, it took me a bit of extra time to understand what splitTreeToNode() is supposed to do because there wasn't a unit testing framework that allowed me to pass in arbitrary nodes/dom trees and look at the output. Do you think it would be worth trying to add common editing methods like this to window.internals so that we can test them independently? (Or maybe I'm missing some existing way to do this?) > > > The reason that the id is duplicated for the span "wrapper" is that InsertParagraphSeparatorCommand::cloneHierarchyUnderNewBlock() doesn't avoid duplicating ids, as SplitElementCommand::executeApply() does. Should I file a separate bug/write a separate patch for that? > > Yes, please file a separate bug for that. But maybe we should first merge that function with CompositeEditCommand::cloneParagraphUnderNewElement. It's really terrible that we have all these functions that do slightly different things all over the place. Okay, I'll look into that. 415380 9 rniwa 2011-06-03 20:58:30 -0700 (In reply to comment #8) > (In reply to comment #6) > > This logic is likely wrong as it doesn't take invisible nodes into account. > > You're right that I didn't take invisible nodes into account at all when writing this code. By invisible, do you mean display:none or something else? Is there a case I should add as a layout test? Yes. display: none and text nodes with collapsible whitespace, etc... In general, we need to be consistent in how we deal with these invisible nodes and the best way to do is to rely on VisiblePosition. > > It worries me to no end that we're adding a brand new function for dealing with this very specific case whereas splitTreeToNode is a well-understood function and used in many places. > > At the same time, complicating the arguments and adding one-off functionality to a simple, well-understood function used in many places seems quite dangerous, too. When I modify the function to take a position, I'll still need to answer this question about whether the position should be split, and make sure I don't introduce bugs with invisible nodes or anything else. Am I missing a less complicated way to fix this bug? By splitting the position, do you mean splitting a text node which is the anchor node of a Position (where AnchorType is PositionIsOffsetInAnchor)? We should be doing that iff we can come up with a test case where that is necessary. As far as I know, we deal with that in callers. But maybe it's better to encapsulate all of that in splitTreeToNode instead of imposing implicit pre-condition like that. > Also, it took me a bit of extra time to understand what splitTreeToNode() is supposed to do because there wasn't a unit testing framework that allowed me to pass in arbitrary nodes/dom trees and look at the output. Do you think it would be worth trying to add common editing methods like this to window.internals so that we can test them independently? (Or maybe I'm missing some existing way to do this?) I'm not so sure because that'll require us adding a custom editing command for splitTreeToNode since you can't call splitTreeToNode without instantiating a CompositeEditCommand. 415945 10 sullivan 2011-06-06 12:33:59 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #6) > > > This logic is likely wrong as it doesn't take invisible nodes into account. > > > > You're right that I didn't take invisible nodes into account at all when writing this code. By invisible, do you mean display:none or something else? Is there a case I should add as a layout test? > > Yes. display: none and text nodes with collapsible whitespace, etc... In general, we need to be consistent in how we deal with these invisible nodes and the best way to do is to rely on VisiblePosition. I wanted to add a layout test where this doesn't work, so I could understand the problem better before trying to fix it. So I experimented with a few cases, and I wasn't able to find one where I was sure my function splits in the wrong place. Using "|" for cursor, I tried: <span>Line1| <br>Line2</span> (extra whitespace after cursor removed when pressing enter) <span>Line1|<span style="display:none">Invisible</span><br>Line2</span> (invisible span moved to next line) I must be misunderstanding the problem--do you have a more specific example of a case where this code is likely to break, so I can add a layout test for it? When I do change the code to use VisiblePosition, is the correct approach to call Position::next instead of Node::nextSibling()? > > > It worries me to no end that we're adding a brand new function for dealing with this very specific case whereas splitTreeToNode is a well-understood function and used in many places. > > > > At the same time, complicating the arguments and adding one-off functionality to a simple, well-understood function used in many places seems quite dangerous, too. When I modify the function to take a position, I'll still need to answer this question about whether the position should be split, and make sure I don't introduce bugs with invisible nodes or anything else. Am I missing a less complicated way to fix this bug? > > By splitting the position, do you mean splitting a text node which is the anchor node of a Position (where AnchorType is PositionIsOffsetInAnchor)? We should be doing that iff we can come up with a test case where that is necessary. As far as I know, we deal with that in callers. But maybe it's better to encapsulate all of that in splitTreeToNode instead of imposing implicit pre-condition like that. Yes, by splitting the position, I mean if the position is in the middle of a text node, it seems logical that splitTreeToPosition() would split the text node so that the tree is split exactly at the given position. Right now, all the callers do the splitting themselves, since the function used to only split to node boundaries. I agree that it's not a great idea to add code if no one uses it yet. But I think that since the new function will take a position, it will be confusing to callers who aren't familiar with the history of the editing code why callers are expected to do any actual splitting of text nodes at the position. Not sure how this type of problem is usually handled--a comment above the function? Also, I'm still not clear on what the declaration of the new function should be: Should it be renamed to splitTreeToPosition? Should it take Position or a VisiblePosition? Its arguments should be a start position and and end node? > > Also, it took me a bit of extra time to understand what splitTreeToNode() is supposed to do because there wasn't a unit testing framework that allowed me to pass in arbitrary nodes/dom trees and look at the output. Do you think it would be worth trying to add common editing methods like this to window.internals so that we can test them independently? (Or maybe I'm missing some existing way to do this?) > > I'm not so sure because that'll require us adding a custom editing command for splitTreeToNode since you can't call splitTreeToNode without instantiating a CompositeEditCommand. My understanding is that CompositeEditingCommand exists to allow shared code between various editing commands. I know in some codebases, making a UnitTestEditingCommand that derives from CompositeEditingCommand that we could use to write unit tests for all those functions would be a way to do this. Not sure about WebKit. 415973 11 rniwa 2011-06-06 13:32:20 -0700 (In reply to comment #10) > Yes, by splitting the position, I mean if the position is in the middle of a text node, it seems logical that splitTreeToPosition() would split the text node so that the tree is split exactly at the given position. Right now, all the callers do the splitting themselves, since the function used to only split to node boundaries. Another concern I have is that callers of splitTree wouldn't be aware of the fact text node has been split. So if they kept some positions anchored at the text node or have some assumptions about DOM structure around the text node, they might get affected by this change. > I agree that it's not a great idea to add code if no one uses it yet. But I think that since the new function will take a position, it will be confusing to callers who aren't familiar with the history of the editing code why callers are expected to do any actual splitting of text nodes at the position. Not sure how this type of problem is usually handled--a comment above the function? I'd rather rename the function or change the function behavior than adding a comment. In general, we favor refactoring over adding comments. > Also, I'm still not clear on what the declaration of the new function should be: > Should it be renamed to splitTreeToPosition? I always thought ToNode didn't any value to the function name. I'd try renaming it to splitTree. > Should it take Position or a VisiblePosition? Is there a benefit in this function knowing upstream/downstream? VisiblePosition is an expensive object to instantiate so I'd start with Position unless there is a compelling reason. > My understanding is that CompositeEditingCommand exists to allow shared code between various editing commands. I know in some codebases, making a UnitTestEditingCommand that derives from CompositeEditingCommand that we could use to write unit tests for all those functions would be a way to do this. Not sure about WebKit. That'll require us creating a Document, DocumentLoader, etc... because CompositeEditCommand can't be instantiated without a document. In the discussion we had in webkit-dev, the general consensus (as far as I understand it) was to try to add unit tests for things in wtf and other components that are isolated from the rest of WebKit. And I don't think editing is such a component because it depends heavily on CSS, DOM, and rendering components. 416901 12 96322 sullivan 2011-06-07 16:20:49 -0700 Created attachment 96322 Work in Progress 416925 13 96322 rniwa 2011-06-07 16:39:33 -0700 Comment on attachment 96322 Work in Progress View in context: https://bugs.webkit.org/attachment.cgi?id=96322&action=review > LayoutTests/editing/inserting/return-key-before-br-in-span-expected.txt:1 > +This sets the selection to the end of the first line, and hits the enter key. Expected behavior: a div is created around the second line, and the cursor is placed at the start of the second line. See bug 61594. This line is probably too long. You should put \n before "Expected behavior:" > LayoutTests/editing/inserting/return-key-middle-of-span-expected.txt:1 > +This sets the selection to the middle of the first line, and hits the enter key. Expected behavior: the text node is split at the cursor. The span is cloned, and everything that was split out is placed inside the clone in a new div which is a child of the root. See bug 61594. Ditto about the line length. > Source/WebCore/editing/CompositeEditCommand.cpp:1232 > +PassRefPtr<Node> CompositeEditCommand::splitTree(Position const* start, Node* end, bool shouldSplitAncestor) We don't normally pass stack allocated objects by pointers. Either Position& or const Position&. Since you're changing the signature anyway, you may consider replacing the boolean by an enum. > Source/WebCore/editing/CompositeEditCommand.cpp:1248 > + if ((unsigned)start->offsetInContainerNode() == static_cast<Text*>(start->containerNode())->length()) Please use C++ style cast (i.e. static_cast<unsigned>()). > Source/WebCore/editing/CompositeEditCommand.cpp:1252 > + startNode = startNode->nextSibling(); This can't be right. SplitTextNodeCommand inserts a new text node before (not after) start->containerNode(). That tells me that this code isn't well-tested. > Source/WebCore/editing/CompositeEditCommand.cpp:1257 > + for (node = startNode; node && node->parentNode() != endNode; node = node->parentNode()) { You should probably move the declaration of node into for loop as in for (RefPtr<Node> node =...) { > Source/WebCore/editing/IndentOutdentCommand.cpp:174 > + Position beforeEnclosingBlockFlow(firstPositionInNode(enclosingBlockFlow)); > + splitBlockquoteNode = splitTree(&beforeEnclosingBlockFlow, enclosingNode, true); You wouldn't need to declare beforeEnclosingBlockFlow if you made splitTree to take a reference. > Source/WebCore/editing/InsertListCommand.cpp:293 > + Position beforeNextListChild(firstPositionInNode(nextListChild)); > + splitElement(listNode, splitTree(&beforeNextListChild, listNode)); Ditto. > Source/WebCore/editing/ReplaceSelectionCommand.cpp:949 > + nodeToSplitTo = splitTree(&insertionPos, nodeToSplitTo.get(), true).get(); The fact we're passing true here strongly suggests that shouldSplitAncestor should be an enum. 416927 14 96322 sullivan 2011-06-07 16:46:02 -0700 Comment on attachment 96322 Work in Progress View in context: https://bugs.webkit.org/attachment.cgi?id=96322&action=review > Source/WebCore/editing/CompositeEditCommand.cpp:1243 > + Node* startNode = start->containerNode(); The way I rewrote this function, it is the same as splitTreeToNode, except that it handles some special cases for choosing which starting node to use: * If the position is at the end of a text node, it starts at the next node in the tree. * If the position is in the middle of a text node, it splits the text node and starts at the second half of the split. It turns out I did find a clear use case for this behavior; see changes to ReplaceSelectionCommand::insertAsListItems The new layout tests I added work fine with this new code. However, when I converted the other callers of splitTreeToNode to call splitTree() with a position, I ran into some trouble because I am making too many assumptions about positions, and several layout tests regressed. I think the problems all have the same root cause--I am assuming the containerNode of the position is the same node that was passed into splitTreeToNode originally. However, stepping through the debugger I have found that this is definitely not always the case. Many of the callers of splitTreeToNode() were actually already using a position, and passing in deprecatedNode() or anchorNode(). So I thought I could just pass the position in directly. But there are multiple ways a position can be anchored, and so often the containerNode I check below is not the same as the deprecatedNode/anchorNode that was passed in originally. I think I want to normalize the position so that the containerNode is always what used to be the start argument. I think I want to use containerNode instead of deprecatedNode/anchorNode, because I also call offsetInContainerNode(). But I don't see a normalization function for Position except parentAnchoredEquivalent(), which I think sets the containerNode to the parent of the node I wanted it to be. Do you know what the correct thing to do here is? > Source/WebCore/editing/CompositeEditCommand.cpp:1247 > + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? If traverseNextNode() returns null on line 1249, it is because the position is at the end of the last node inside the end node. I am not sure how the function should behave in that case--should it start splitting at the containerNode's parent? 416996 15 rniwa 2011-06-07 18:28:07 -0700 (In reply to comment #14) > The new layout tests I added work fine with this new code. However, when I converted the other callers of splitTreeToNode to call splitTree() with a position, I ran into some trouble because I am making too many assumptions about positions, and several layout tests regressed. I think the problems all have the same root cause--I am assuming the containerNode of the position is the same node that was passed into splitTreeToNode originally. However, stepping through the debugger I have found that this is definitely not always the case. Right, I was expecting this to happen. > I think I want to use containerNode instead of deprecatedNode/anchorNode, because I also call offsetInContainerNode(). But I don't see a normalization function for Position except parentAnchoredEquivalent(), which I think sets the containerNode to the parent of the node I wanted it to be. Do you know what the correct thing to do here is? The correct thing to do is to fix each caller of splitTree. You're getting into the nasty part of editing now where fixing one bug gives you new bug. Unfortunately, there's no easy way out of this other than looking at each caller of splitTree and fixing each one of them. parentAnchoredEquivalent is specifically designed to create a Position to be passed to Range objects and we don't want to call it everywhere because as we discussed during the contributor's meeting, we want to move away from having positions with offset inside an element and calling parentAnchoredEquivalent will move us away from that goal. > > Source/WebCore/editing/CompositeEditCommand.cpp:1247 > > + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? > > If traverseNextNode() returns null on line 1249, it is because the position is at the end of the last node inside the end node. I am not sure how the function should behave in that case--should it start splitting at the containerNode's parent? If traverseNextNode returns true, then there's no node left in the tree after this node. There's no point in splitting tree at that point. You should probably assert that this never happens. 417053 16 96368 sullivan 2011-06-07 20:38:51 -0700 Created attachment 96368 Work in Progress 417054 17 96368 rniwa 2011-06-07 20:47:32 -0700 Comment on attachment 96368 Work in Progress View in context: https://bugs.webkit.org/attachment.cgi?id=96368&action=review > Source/WebCore/editing/CompositeEditCommand.cpp:1246 > + if (start.offsetInContainerNode() == caretMaxOffset(start.containerNode())) should be >= instead of ==. > Source/WebCore/editing/CompositeEditCommand.h:40 > +enum AncestorSplitPolicy { DoNotSplit, Split }; I'm not sure if 'policy' is a good noun here. Maybe rule? I'd also declare it inside CompositeEditCommand to avoid polluting WebCore namespace. And I'd name values DoNotSplitEnd and SplitEnd. > Source/WebCore/editing/FormatBlockCommand.cpp:64 > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); You shouldn't be calling deprecatedNode here. > Source/WebCore/editing/IndentOutdentCommand.cpp:106 > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); Ditto. 417056 18 sullivan 2011-06-07 21:11:31 -0700 > > Source/WebCore/editing/FormatBlockCommand.cpp:64 > > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); > > You shouldn't be calling deprecatedNode here. > > > Source/WebCore/editing/IndentOutdentCommand.cpp:106 > > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); > > Ditto. The good news about this patch is that all the layout tests pass. It turns out that on these two lines of code, there would be consistent failures because containerNode() was always the parent of the correct node. That means that unless further testing proves otherwise, at least the selection seems to have consistent behavior about how deprecatedNode is set. The bad news, of course, is that I am calling deprecatedNode() where I shouldn't be. And unfortunately, the problem goes deeper than just these two lines. If you look at the code surrounding my other calls, you'll see that it has dependencies on deprecatedNode() in other places, too: In IndentOutdentCommand::outdentParagraph(), the code that finds enclosingBlockFlow looks like this: enclosingBlock(visibleStartOfParagraph.deepEquivalent().deprecatedNode()). Then I make a Position from enclosingBlockFlow and pass it to splitTree. In InsertListCommand::unlistifyParagraph, the same thing happens with the nextListChild and listChildNode nodes used to make the selections passed into splitTree(). In ReplaceSelectionCommand::insertAsListItems(), there used to be code that called deprecatedNode() to split the children, but my new code seems to work fine calling containerNode()/offsetInContainer instead. Is that one okay? I think ReplaceSelectionCommand::doApply() and InsertParagraphSeparatorCommand::doApply() are okay as-is as well. Let me know if you disagree. So I wanted to check about the right way to move forward. I think it is: 1. File dependent bugs to not use deprecatedNode() in the places I listed above. Are there some existing refactoring patches I can look at to see examples of how this is usually done? 2. File dependent bugs on the refactoring bugs above to add test cases. 3. Add more tests cases to this patch, too. It turns out that editing/pasteboard/paste-list-004.html does test the case where we need to split a text node, but we should have more test cases as well. 4. Finally finish off this patch, without depending on deprecatedNode. Is that right? Or is there some simpler way to do things? Maybe we could add more tests to the codepaths that use deprecatedNode in this patch, and if they prove to be consistent, do some smaller patch-up? 417106 19 rniwa 2011-06-07 23:17:59 -0700 (In reply to comment #18) > In IndentOutdentCommand::outdentParagraph(), the code that finds enclosingBlockFlow looks like this: enclosingBlock(visibleStartOfParagraph.deepEquivalent().deprecatedNode()). Then I make a Position from enclosingBlockFlow and pass it to splitTree. We should be calling containerNode instead of deprecatedNode there. Because if we're before or after a block, the block isn't enclosing the position at all. If something goes wrong with that change, then we'd have to fix that bug. Once you do that, the change is straight-forward. You'd just need to split the tree at the beginning of this block. > In ReplaceSelectionCommand::insertAsListItems(), there used to be code that called deprecatedNode() to split the children, but my new code seems to work fine calling containerNode()/offsetInContainer instead. Is that one okay? I think ReplaceSelectionCommand::doApply() and InsertParagraphSeparatorCommand::doApply() are okay as-is as well. Let me know if you disagree. That sounds like a reasonable change. > So I wanted to check about the right way to move forward. I think it is: > 1. File dependent bugs to not use deprecatedNode() in the places I listed above. Are there some existing refactoring patches I can look at to see examples of how this is usually done? You can see blockers on https://bugs.webkit.org/show_bug.cgi?id=52099 that have been resolved. > 2. File dependent bugs on the refactoring bugs above to add test cases. That sounds great! > Is that right? Or is there some simpler way to do things? Maybe we could add more tests to the codepaths that use deprecatedNode in this patch, and if they prove to be consistent, do some smaller patch-up? That sounds like a very reasonable approach. 417747 20 sullivan 2011-06-08 19:06:09 -0700 (In reply to comment #19) > (In reply to comment #18) > > In IndentOutdentCommand::outdentParagraph(), the code that finds enclosingBlockFlow looks like this: enclosingBlock(visibleStartOfParagraph.deepEquivalent().deprecatedNode()). Then I make a Position from enclosingBlockFlow and pass it to splitTree. > > We should be calling containerNode instead of deprecatedNode there. Because if we're before or after a block, the block isn't enclosing the position at all. If something goes wrong with that change, then we'd have to fix that bug. I made some progress on this part. In 2 of the 3 cases I mentioned, all the layout tests pass when I switch to calling containerNode(). But I got two test failures in InsertListCommand::unlistifyParagraph(). Line 268 of my patch used to be: nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode); I switched it to: nextListChild = enclosingListChild(end.next().deepEquivalent().containerNode(), listNode); I got two layout tests failures: editing/execCommand/remove-list-items.html editing/execCommand/switch-list-type.html In both tests, sometimes the position is a PositionIsOffsetInAnchor, and the containerNode, anchorNode, and deprecatedNode are all the same node. Everything works fine in that case. But sometimes the position is a PositionIsBeforeAnchor, before the <br><br> after item1. In that case, the deprecatedNode and anchorNode are the <br>, where the split is supposed to occur. But the containerNode() is the parent <ol>. So the split occurs in the wrong place. Is there some better way to get the correct Position before end.next() (where end is a VisiblePosition)? 418070 21 rniwa 2011-06-09 09:45:52 -0700 (In reply to comment #20) > Line 268 of my patch used to be: > nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode); > I switched it to: > nextListChild = enclosingListChild(end.next().deepEquivalent().containerNode(), listNode); I don't understand why you'd call next. That seems wrong. > I got two layout tests failures: > editing/execCommand/remove-list-items.html > editing/execCommand/switch-list-type.html > > In both tests, sometimes the position is a PositionIsOffsetInAnchor, and the containerNode, anchorNode, and deprecatedNode are all the same node. Everything works fine in that case. But sometimes the position is a PositionIsBeforeAnchor, before the <br><br> after item1. In that case, the deprecatedNode and anchorNode are the <br>, where the split is supposed to occur. But the containerNode() is the parent <ol>. So the split occurs in the wrong place. I see. <br> is certainly NOT the enclosing list child for a position before or after the br. I think what you need to do is check whether the containerNode is a list element or not, and if it is, just pass end as the place to split rather than finding the enclosing list child. Another way to fix this is to make enclosingListChild also take const Position&. 422890 22 dcomfort 2011-06-17 14:35:56 -0700 This bug is really hurting Zimbra. All of our users on Chrome who have a signature are struggling just to compose an email message. 423008 23 97678 sullivan 2011-06-17 18:40:41 -0700 Created attachment 97678 Patch 423009 24 sullivan 2011-06-17 18:43:47 -0700 The newest patch is a cleaned-up version that fixes usages of deprecatedNode() where possible, but leaves some in where the code would need significant refactoring. There are a couple places where I switched deprecatedNode to containerNode because it didn't break anything, but maybe this is too aggressive. If you think so I'd be happy to change them back. About the FIXME in splitTree: what should we do if the position is the last visible position in the node, and traverseNextNode returns null? Probably exit early, but not sure which node the function should return. If you can think of more tests to add, please let me know. 423517 25 97678 webkit-ews 2011-06-20 00:40:20 -0700 Comment on attachment 97678 Patch Attachment 97678 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/8907479 424759 26 97678 rniwa 2011-06-21 14:23:26 -0700 Comment on attachment 97678 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97678&action=review This patch looks great but I have a few questions and nits. I'd say r- for now since I'd like see change log and some comments being revised before this patch is landed. > Source/WebCore/ChangeLog:16 > + (WebCore::CompositeEditCommand::splitTree): > + Implement new function. Like splitTreeToNode(), but picks start node based on position so that text nodes are split correctly. So we usually start sentences after "splitTree): " then wrap at wherever is appropriate. This line is probably too long. You should also mention that this new function replaces the old splitTreeToNode. > Source/WebCore/editing/CompositeEditCommand.cpp:-1235 > - ASSERT(start); We should probably assert that start.containerNode is not null. > Source/WebCore/editing/CompositeEditCommand.cpp:1243 > + // For text nodes, handle the case where the offset is in the middle of the node or at the end, > + // moving the start node to the beginning of the position, splitting the node if necessary. This comment repeats what code says. You should either remove the comment or explain why this is needed instead. > Source/WebCore/editing/CompositeEditCommand.cpp:1245 > + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? If startNode ends up being null, then we're trying to split a node at the very end of the tree. In that case, we shouldn't be splitting the tree so this should be fine. I think you should remove this comment. > Source/WebCore/editing/FormatBlockCommand.cpp:64 > - RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTreeToNode(start.deprecatedNode(), nodeToSplitTo); > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); So you can't just pass start here? Also, you should probably call firstPositionInOrBeforeNode instead. > Source/WebCore/editing/InsertListCommand.cpp:-271 > - nextListChild = listChildNode->nextSibling(); > - previousListChild = listChildNode->previousSibling(); > } else { > // A paragraph is visually a list item minus a list marker. The paragraph will be moved. > start = startOfParagraph(originalStart, CanSkipOverEditingBoundary); > end = endOfParagraph(start, CanSkipOverEditingBoundary); > - nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode); > - ASSERT(nextListChild != listChildNode); > - previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode(), listNode); > - ASSERT(previousListChild != listChildNode); Nice to see code being removed! > Source/WebCore/editing/InsertListCommand.cpp:277 > + // Unless this is the first node in the list, the list needs to be split. Again, this comment seems to repeat code. Can we explain why this needs to be done instead? If not, we should get rid of this comment. > Source/WebCore/editing/InsertListCommand.cpp:282 > + // If this is the only node in the list, insert the placeholder after it, so that if splitAt > + // and the node before the placeholder are both text nodes, they will not be merged. See > + // LayoutTests/editing/execCommand/switch-list-type.html This comment seems a bit verbose. I'd just say "insert a placeholder to avoid texts nodes of splitAt and the node before the placeholder won't get merged" 424801 27 97678 sullivan 2011-06-21 15:35:11 -0700 Comment on attachment 97678 Patch I'm working on addressing the comments but I had a question and a follow-up comment. View in context: https://bugs.webkit.org/attachment.cgi?id=97678&action=review >> Source/WebCore/editing/CompositeEditCommand.cpp:1245 >> + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? > > If startNode ends up being null, then we're trying to split a node at the very end of the tree. In that case, we shouldn't be splitting the tree so this should be fine. > I think you should remove this comment. Should there be a return value in this case though? >> Source/WebCore/editing/FormatBlockCommand.cpp:64 >> + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); > > So you can't just pass start here? Also, you should probably call firstPositionInOrBeforeNode instead. Unfortunately, a lot of edge cases around top-level non-block elements fail here. For example, if the editable div contains only a <hr>, start.deprectatedNode() is the <hr> and start.containerNode() is the editable div. The ASSERT(start.containerNode() != end) fails, and if I take it out I end up with a crash later on. I'll try firstPositionInOrBeforeNode instead. 424805 28 97678 rniwa 2011-06-21 15:37:38 -0700 Comment on attachment 97678 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97678&action=review >>> Source/WebCore/editing/CompositeEditCommand.cpp:1245 >>> + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? >> >> If startNode ends up being null, then we're trying to split a node at the very end of the tree. In that case, we shouldn't be splitting the tree so this should be fine. >> I think you should remove this comment. > > Should there be a return value in this case though? You should probably return the original startNode in that case because that's what we do when we don't split any node. >>> Source/WebCore/editing/FormatBlockCommand.cpp:64 >>> + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); >> >> So you can't just pass start here? Also, you should probably call firstPositionInOrBeforeNode instead. > > Unfortunately, a lot of edge cases around top-level non-block elements fail here. For example, if the editable div contains only a <hr>, start.deprectatedNode() is the <hr> and start.containerNode() is the editable div. The ASSERT(start.containerNode() != end) fails, and if I take it out I end up with a crash later on. > > I'll try firstPositionInOrBeforeNode instead. I see. Okay. I suppose we can live with this code for now. 424935 29 98094 sullivan 2011-06-21 18:24:31 -0700 Created attachment 98094 Patch 424936 30 97678 sullivan 2011-06-21 18:24:43 -0700 Comment on attachment 97678 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97678&action=review >> Source/WebCore/ChangeLog:16 >> + Implement new function. Like splitTreeToNode(), but picks start node based on position so that text nodes are split correctly. > > So we usually start sentences after "splitTree): " then wrap at wherever is appropriate. This line is probably too long. You should also mention that this new function replaces the old splitTreeToNode. Done. >> Source/WebCore/editing/CompositeEditCommand.cpp:-1235 >> - ASSERT(start); > > We should probably assert that start.containerNode is not null. Good catch! Done. >> Source/WebCore/editing/CompositeEditCommand.cpp:1243 >> + // moving the start node to the beginning of the position, splitting the node if necessary. > > This comment repeats what code says. You should either remove the comment or explain why this is needed instead. Comment removed. >>>> Source/WebCore/editing/FormatBlockCommand.cpp:64 >>>> + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); >>> >>> So you can't just pass start here? Also, you should probably call firstPositionInOrBeforeNode instead. >> >> Unfortunately, a lot of edge cases around top-level non-block elements fail here. For example, if the editable div contains only a <hr>, start.deprectatedNode() is the <hr> and start.containerNode() is the editable div. The ASSERT(start.containerNode() != end) fails, and if I take it out I end up with a crash later on. >> >> I'll try firstPositionInOrBeforeNode instead. > > I see. Okay. I suppose we can live with this code for now. It turns out that calling firstPositionInOrBeforeNode trips on the same edge cases that break when I pass the position into splitTree directly--the container node of the position ends up being the editable div instead of the <hr>, and I hit the assert and it crashes. >> Source/WebCore/editing/InsertListCommand.cpp:277 >> + // Unless this is the first node in the list, the list needs to be split. > > Again, this comment seems to repeat code. Can we explain why this needs to be done instead? If not, we should get rid of this comment. comment removed. >> Source/WebCore/editing/InsertListCommand.cpp:282 >> + // LayoutTests/editing/execCommand/switch-list-type.html > > This comment seems a bit verbose. I'd just say "insert a placeholder to avoid texts nodes of splitAt and the node before the placeholder won't get merged" done. 424937 31 97678 rniwa 2011-06-21 18:26:26 -0700 Comment on attachment 97678 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97678&action=review >>>>> Source/WebCore/editing/FormatBlockCommand.cpp:64 >>>>> + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); >>>> >>>> So you can't just pass start here? Also, you should probably call firstPositionInOrBeforeNode instead. >>> >>> Unfortunately, a lot of edge cases around top-level non-block elements fail here. For example, if the editable div contains only a <hr>, start.deprectatedNode() is the <hr> and start.containerNode() is the editable div. The ASSERT(start.containerNode() != end) fails, and if I take it out I end up with a crash later on. >>> >>> I'll try firstPositionInOrBeforeNode instead. >> >> I see. Okay. I suppose we can live with this code for now. > > It turns out that calling firstPositionInOrBeforeNode trips on the same edge cases that break when I pass the position into splitTree directly--the container node of the position ends up being the editable div instead of the <hr>, and I hit the assert and it crashes. That makes me think that we should probably be instantiating a legacy editing position here. 424938 32 rniwa 2011-06-21 18:27:39 -0700 (In reply to comment #31) > > It turns out that calling firstPositionInOrBeforeNode trips on the same edge cases that break when I pass the position into splitTree directly--the container node of the position ends up being the editable div instead of the <hr>, and I hit the assert and it crashes. > > That makes me think that we should probably be instantiating a legacy editing position here. Also where do we hit this assertion? 424939 33 98094 rniwa 2011-06-21 18:32:52 -0700 Comment on attachment 98094 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=98094&action=review > Source/WebCore/editing/CompositeEditCommand.cpp:1246 > + // FIXME: startNode can be null if traverseNextNode returns null. What should it be set to in that case? You should remove this comment now that you handle this case. > Source/WebCore/editing/FormatBlockCommand.cpp:64 > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); We should really be cautious when we call firstPositionInNode because we really don't want to instantiate a position inside a br, hr, etc... So whenever there's a chance that a node can be one of those atomic/content-ignored node, we can't pass it to firstPositionInNode as it creates a new kind of position that doesn't have legacy editing quirks. r- because deprecatedNode can be one of those elements. > Source/WebCore/editing/IndentOutdentCommand.cpp:106 > + RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTree(firstPositionInNode(start.deprecatedNode()), nodeToSplitTo); Ditto. > Source/WebCore/editing/InsertListCommand.cpp:279 > + // Insert a placeholder to avoid texts nodes of splitAt and the node before the placeholder won't get merged Nit: avoid ~~ won't get merged. Maybe it was my fault? 425429 34 98209 sullivan 2011-06-22 11:44:24 -0700 Created attachment 98209 Alternate approach This approach fixes the specific problem that regressed. It is much lower risk than refactoring splitTreeToNode, but it does not improve the code at all. 425440 35 sullivan 2011-06-22 11:56:13 -0700 I filed bug 63164 to continue the work on refactoring splitTreeToNode to take a position. 425713 36 webkit.review.bot 2011-06-22 16:17:31 -0700 The commit-queue encountered the following flaky tests while processing attachment 98209: http/tests/misc/dns-prefetch-control.html bug 63200 (authors: ap@webkit.org, collinj@webkit.org, and gns@gnome.org) The commit-queue is continuing to process your patch. 425714 37 98209 webkit.review.bot 2011-06-22 16:19:10 -0700 Comment on attachment 98209 Alternate approach Clearing flags on attachment: 98209 Committed r89492: <http://trac.webkit.org/changeset/89492> 425715 38 webkit.review.bot 2011-06-22 16:19:17 -0700 All reviewed patches have been landed. Closing bug. 95097 2011-05-26 19:35:57 -0700 2011-05-26 19:35:57 -0700 test case notes.html text/html 123 adele PGJvZHkgY29udGVudGVkaXRhYmxlPgogICAgPHNwYW4+SGl0IEVudGVyIGFmdGVyIHRoaXMgbGlu ZTxicj5TZWUgdGhlIGN1cnNvciBhcHBlYXIgYXQgdGhlIGVuZCBvZiB0aGlzIGxpbmU8L3NwYW4+ CjwvYm9keT4K 96004 2011-06-03 18:57:32 -0700 2011-06-07 16:20:45 -0700 Work in Progress bug-61594-20110603185731.patch text/plain 11962 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODc5MjQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZWRlMDk5YTNmNzMyYjUwMzE0M2Ew NzhmN2FhYmRmNDQ0NmRlMTQ1Li42OGYwZmJlNWZjNTM1ODM2NWMwZjFiNjIxNTdkMjkyNWQ3ZGNk NmFjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDYtMDMgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRzIG5ldyBsYXlvdXQgdGVzdHMgdG8gY2hlY2sgYmVoYXZpb3Igd2hlbiBw cmVzc2luZyBlbnRlciBpbiBhIHNwYW4gYXQgdGhlIHN0YXJ0LCBtaWRkbGUsIGFuZCBlbmQgb2Yg YSB0ZXh0IG5vZGUuCisKKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJl Zm9yZS1ici1pbi1zcGFuLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9p bnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRk bGUtb2Ytc3Bhbi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1 cm4ta2V5LXN0YXJ0LW9mLXNwYW4tZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0 aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LXN0YXJ0LW9mLXNwYW4uaHRtbDogQWRkZWQuCisKIDIw MTEtMDYtMDIgIERpbWl0cmkgR2xhemtvdiAgPGRnbGF6a292QGNocm9taXVtLm9yZz4KIAogICAg ICAgICBbV2luXSBTdGFydCBza2lwcGluZyBhIHRlc3QgdGhhdCdzIG5vdyB1c2luZyBzaGFkb3dS b290IG1hY2hpbmVyeS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5n L3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZDAxNzEwY2FkNjZiYmRkMTk2OThlZDMzYThkZDBjY2Y1MDBiZmM0Ywot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1r ZXktYmVmb3JlLWJyLWluLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyBz ZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIGVuZCBvZiB0aGUgZmlyc3QgbGluZSwgYW5kIGhpdHMg dGhlIGVudGVyIGtleS4gRXhwZWN0ZWQgYmVoYXZpb3I6IGEgZGl2IGlzIGNyZWF0ZWQgYXJvdW5k IHRoZSBzZWNvbmQgbGluZSwgYW5kIHRoZSBjdXJzb3IgaXMgcGxhY2VkIGF0IHRoZSBzdGFydCBv ZiB0aGUgc2Vjb25kIGxpbmUuIFNlZSBidWcgNjE1OTQuCit8IDxzcGFuPgorfCAgIGlkPSJ3cmFw cGVyIgorfCAgICJGaXJzdCBsaW5lIgorfCA8ZGl2PgorfCAgIDxzcGFuPgorfCAgICAgPCNzZWxl Y3Rpb24tY2FyZXQ+Cit8ICAgICA8YnI+Cit8ICAgICAiU2Vjb25kIGxpbmUiCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1z cGFuLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9y ZS1ici1pbi1zcGFuLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODdhNGNhM2Y4MzZkZjMwZGZiY2Q5NzUyNjkx OGFlMzExOWFhNWIxYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5z ZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbApAQCAtMCwwICsxLDE2IEBA Cis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8ZGl2IGNvbnRlbnRlZGl0YWJsZSBp ZD0icm9vdCI+PHNwYW4gaWQ9IndyYXBwZXIiPkZpcnN0IGxpbmU8YnI+U2Vjb25kIGxpbmU8L3Nw YW4+PC9kaXY+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpz Ij48L3NjcmlwdD4KKzxzY3JpcHQ+CitNYXJrdXAuZGVzY3JpcHRpb24oIlRoaXMgc2V0cyB0aGUg c2VsZWN0aW9uIHRvIHRoZSBlbmQgb2YgdGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRl ciBrZXkuICIKKyAgICArICJFeHBlY3RlZCBiZWhhdmlvcjogYSBkaXYgaXMgY3JlYXRlZCBhcm91 bmQgdGhlIHNlY29uZCBsaW5lLCBhbmQgdGhlIGN1cnNvciBpcyBwbGFjZWQgYXQgdGhlICIKKyAg ICArICJzdGFydCBvZiB0aGUgc2Vjb25kIGxpbmUuIFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2Vs ID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2VsLnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJ3cmFwcGVyIiksIDEpOworZXZlbnRTZW5kZXIua2V5RG93bignXG4nKTsKK01h cmt1cC5kdW1wKHJvb3QpOworCis8L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUt b2Ytc3Bhbi1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDhjYTU3MTBkY2FmNTViMjBlZTcwNTEw YzRmZTU1NzgzMTBiOWFhYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcv aW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAg KzEsOSBAQAorVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmly c3QgbGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS4gRXhwZWN0ZWQgYmVoYXZpb3I6IHRoZSB0 ZXh0IG5vZGUgaXMgc3BsaXQgYXQgdGhlIGN1cnNvci4gVGhlIHNwYW4gaXMgY2xvbmVkLCBhbmQg ZXZlcnl0aGluZyB0aGF0IHdhcyBzcGxpdCBvdXQgaXMgcGxhY2VkIGluc2lkZSB0aGUgY2xvbmUg aW4gYSBuZXcgZGl2IHdoaWNoIGlzIGEgY2hpbGQgb2YgdGhlIHJvb3QuIFNlZSBidWcgNjE1OTQu Cit8IDxzcGFuPgorfCAgIGlkPSJ3cmFwcGVyIgorfCAgICJGaXJzdCIKK3wgPGRpdj4KK3wgICA8 c3Bhbj4KK3wgICAgICI8I3NlbGVjdGlvbi1jYXJldD7CoGxpbmUiCit8ICAgICA8YnI+Cit8ICAg ICAiU2Vjb25kIGxpbmUiCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lu c2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGQ0ZGRh ZjAzZWMxZWMyMzUwZWZlYjVkNjIwYjE1ZTVkOWYzYmI1MwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4uaHRt bApAQCAtMCwwICsxLDE1IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8ZGl2 IGNvbnRlbnRlZGl0YWJsZSBpZD0icm9vdCI+PHNwYW4gaWQ9IndyYXBwZXIiPkZpcnN0IGxpbmU8 YnI+U2Vjb25kIGxpbmU8L3NwYW4+PC9kaXY+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2Vz L2R1bXAtYXMtbWFya3VwLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQ+CitNYXJrdXAuZGVzY3JpcHRp b24oIlRoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBtaWRkbGUgb2YgdGhlIGZpcnN0IGxp bmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuICIKKyAgICArICJFeHBlY3RlZCBiZWhhdmlvcjog dGhlIHRleHQgbm9kZSBpcyBzcGxpdCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQs IGFuZCBldmVyeXRoaW5nICIKKyAgICArICJ0aGF0IHdhcyBzcGxpdCBvdXQgaXMgcGxhY2VkIGlu c2lkZSB0aGUgY2xvbmUgaW4gYSBuZXcgZGl2IHdoaWNoIGlzIGEgY2hpbGQgb2YgdGhlIHJvb3Qu IFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2Vs LnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIikuZmlyc3RDaGls ZCwgNSk7CitldmVudFNlbmRlci5rZXlEb3duKCdcbicpOworTWFya3VwLmR1bXAocm9vdCk7Cis8 L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0 aW5nL3JldHVybi1rZXktc3RhcnQtb2Ytc3Bhbi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LXN0YXJ0LW9mLXNwYW4tZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjI0Y2I5Mjg1MTc1MjhiMTZkNmYzMGQwZWIyNmQwN2RlYjE4YWRkNzkKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LXN0 YXJ0LW9mLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMgc2V0cyB0aGUg c2VsZWN0aW9uIHRvIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QgbGluZSBpbiBhIHNwYW4sIGFuZCBo aXRzIHRoZSBlbnRlciBrZXkuIEV4cGVjdGVkIGJlaGF2aW9yOiB0aGUgc3BhbiBpcyBjbG9uZWQs IGluc2VydGVkIGludG8gYSBkaXYsIGFuZCBhIGJyIGlzIGFkZGVkIGFzIGEgY2hpbGQuIFNlZSBi dWcgNjE1OTQuCit8IDxzcGFuPgorfCAgIGlkPSJ3cmFwcGVyIgorfCAgIDxkaXY+Cit8ICAgICA8 c3Bhbj4KK3wgICAgICAgaWQ9IndyYXBwZXIiCit8ICAgICAgIDxicj4KK3wgICAiPCNzZWxlY3Rp b24tY2FyZXQ+Rmlyc3QgbGluZSIKK3wgICA8YnI+Cit8ICAgIlNlY29uZCBsaW5lIgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1zdGFydC1vZi1z cGFuLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LXN0YXJ0 LW9mLXNwYW4uaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44MGI1ZmJkNTcyODljZjZlMDAwMjZjYjE2ZmViNGEx OWFlMGVkOTBiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRp bmcvcmV0dXJuLWtleS1zdGFydC1vZi1zcGFuLmh0bWwKQEAgLTAsMCArMSwxNSBAQAorPCFET0NU WVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5PgorPGRpdiBjb250ZW50ZWRpdGFibGUgaWQ9InJvb3Qi PjxzcGFuIGlkPSJ3cmFwcGVyIj5GaXJzdCBsaW5lPGJyPlNlY29uZCBsaW5lPC9zcGFuPjwvZGl2 PgorPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9kdW1wLWFzLW1hcmt1cC5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0PgorTWFya3VwLmRlc2NyaXB0aW9uKCJUaGlzIHNldHMgdGhlIHNlbGVjdGlv biB0byB0aGUgc3RhcnQgb2YgdGhlIGZpcnN0IGxpbmUgaW4gYSBzcGFuLCBhbmQgaGl0cyB0aGUg ZW50ZXIga2V5LiAiCisgICAgKyAiRXhwZWN0ZWQgYmVoYXZpb3I6IHRoZSBzcGFuIGlzIGNsb25l ZCwgaW5zZXJ0ZWQgaW50byBhIGRpdiwgYW5kIGEgYnIgaXMgYWRkZWQgYXMgYSBjaGlsZC4gIgor ICAgICsgIlNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigp Oworc2VsLnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIiksIDAp OworZXZlbnRTZW5kZXIua2V5RG93bignXG4nKTsKK01hcmt1cC5kdW1wKHJvb3QpOworPC9zY3Jp cHQ+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDQwMzNhMTViY2Q3ZmYyNmUzNDc3MDI1MGM0ZDg4 MTZiNmU4YThiYi4uM2NkZGYxMDlhNDMxM2EyMjY1NmMzYzljODU3ZWVjMGEwYjYzZjgxNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDExLTA2LTAzICBBbm5pZSBTdWxsaXZhbiAgPHN1 bGxpdmFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBSRUdSRVNTSU9OOiBIaXR0aW5nIGVudGVyIGluIHRoZSBtaWRkbGUgb2Yg dGhpcyBzcGFuIGNhdXNlcyB0aGUgY3Vyc29yIHRvIGdvIHRvIHRoZSBlbmQgb2YgdGhlIHNwYW4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYxNTk0CisK KyAgICAgICAgSW1wbGVtZW50cyBuZXcgc3BsaXRUcmVlVG9Qb3NpdGlvbiBtZXRob2Qgd2hpY2gg YWxsb3dzIHRoZSB0cmVlIHRvIGJlIHNwbGl0IGNvcnJlY3RseSBpZiB0aGUgY3Vyc29yIGlzIG5v dCBhdCB0aGUgc3RhcnQgb2YgYSB0ZXh0IG5vZGUuCisKKyAgICAgICAgVGVzdHM6IGVkaXRpbmcv aW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbAorICAgICAgICAgICAg ICAgZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sCisgICAg ICAgICAgICAgICBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LXN0YXJ0LW9mLXNwYW4uaHRt bAorCisgICAgICAgICogZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHA6IEltcGxlbWVu dCBuZXcgc3BsaXRUcmVlVG9Qb3NpdGlvbiBtZXRob2QuCisgICAgICAgIChXZWJDb3JlOjpDb21w b3NpdGVFZGl0Q29tbWFuZDo6c3BsaXRUcmVlVG9Qb3NpdGlvbik6IFNwbGl0cyB0aGUgdHJlZSBh dCB0aGUgZ2l2ZW4gcG9zaXRpb24uCisgICAgICAgICogZWRpdGluZy9Db21wb3NpdGVFZGl0Q29t bWFuZC5oOiBEZWNsYXJlIHNwbGl0VHJlZVRvUG9zaXRpb24KKyAgICAgICAgKiBlZGl0aW5nL0lu c2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5z ZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIENhbGwgbmV3 IHNwbGl0VHJlZVRvUG9zaXRpb24gbWV0aG9kIGluc3RlYWQgb2Ygc3BsaXRUcmVlVG9Ob2RlLCBz byB0aGF0IGEgdGV4dCBub2RlIHdpbGwgYmUgc3BsaXQgY29ycmVjdGx5IGlmIHRoZSBjdXJzb3Ig aXMgYWZ0ZXIgaXQuCisKIDIwMTEtMDYtMDIgIE5hb2tpIFRha2FubyAgPHRha2Fuby5uYW9raUBn bWFpbC5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGltaXRyaSBHbGF6a292LgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAppbmRleCA5NGNk NzczNmE2NmUyM2I4MjMyNWUwZmI1ZTIxODk2NmRhNzhlMjIyLi45Nzc3N2I3Mjg5MGMwZDAwY2Yx ZWViYjk5ODJkNzliYzhiYmE1N2QxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Nv bXBvc2l0ZUVkaXRDb21tYW5kLmNwcApAQCAtNDQsNiArNDQsNyBAQAogI2luY2x1ZGUgIkluc2Vy dFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuaCIKICNpbmNsdWRlICJJbnNlcnRUZXh0Q29tbWFu ZC5oIgogI2luY2x1ZGUgIk1lcmdlSWRlbnRpY2FsRWxlbWVudHNDb21tYW5kLmgiCisjaW5jbHVk ZSAiTm9kZUxpc3QuaCIKICNpbmNsdWRlICJSYW5nZS5oIgogI2luY2x1ZGUgIlJlbW92ZUNTU1By b3BlcnR5Q29tbWFuZC5oIgogI2luY2x1ZGUgIlJlbW92ZU5vZGVDb21tYW5kLmgiCkBAIC0xMjI4 LDYgKzEyMjksMzggQEAgUG9zaXRpb24gQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnBvc2l0aW9uQXZv aWRpbmdTcGVjaWFsRWxlbWVudEJvdW5kYXJ5KGNvbnN0IFBvc2kKICAgICByZXR1cm4gcmVzdWx0 OwogfQogCitQYXNzUmVmUHRyPE5vZGU+IENvbXBvc2l0ZUVkaXRDb21tYW5kOjpzcGxpdFRyZWVU b1Bvc2l0aW9uKFBvc2l0aW9uKiBwb3MsIE5vZGUqIGFuY2VzdG9yLCBib29sIHNob3VsZFNwbGl0 QW5jZXN0b3IpCit7CisgICAgQVNTRVJUKHBvcyk7CisgICAgQVNTRVJUKGFuY2VzdG9yKTsKKwor ICAgIGlmIChzaG91bGRTcGxpdEFuY2VzdG9yICYmIGFuY2VzdG9yLT5wYXJlbnROb2RlKCkpCisg ICAgICAgIGFuY2VzdG9yID0gYW5jZXN0b3ItPnBhcmVudE5vZGUoKTsKKworICAgIFBvc2l0aW9u IHA7CisgICAgUmVmUHRyPE5vZGU+IGVuZE5vZGUgPSBhbmNlc3RvcjsKKyAgICBmb3IgKHAgPSBw b3MtPnBhcmVudEFuY2hvcmVkRXF1aXZhbGVudCgpOyBwLmNvbnRhaW5lck5vZGUoKSAmJiBwLmNv bnRhaW5lck5vZGUoKS0+cGFyZW50Tm9kZSgpICYmIHAuY29udGFpbmVyTm9kZSgpLT5wYXJlbnRO b2RlKCkgIT0gZW5kTm9kZTsgcCA9IGZpcnN0UG9zaXRpb25Jbk5vZGUocC5jb250YWluZXJOb2Rl KCktPnBhcmVudE5vZGUoKSkpIHsKKyAgICAgICAgaWYgKCFwLmNvbnRhaW5lck5vZGUoKS0+cGFy ZW50Tm9kZSgpLT5pc0VsZW1lbnROb2RlKCkpCisgICAgICAgICAgICBicmVhazsKKworICAgICAg ICBSZWZQdHI8Tm9kZT4gc3BsaXROb2RlID0gcC5jb250YWluZXJOb2RlKCk7CisgICAgICAgIC8v IElmIHRoZSBwb3NpdGlvbiBpcyBhdCB0aGUgZW5kIG9mIHRoZSBub2RlLCBzcGxpdCBhdCB0aGUg bmV4dCBub2RlLgorICAgICAgICBpZiAoKHAuY29udGFpbmVyTm9kZSgpLT5pc1RleHROb2RlKCkg JiYgcC5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSA9PSAoaW50KXN0YXRpY19jYXN0PFRleHQqPihw LmNvbnRhaW5lck5vZGUoKSktPmxlbmd0aCgpKQorICAgICAgICAgICAgfHwgKHAuY29udGFpbmVy Tm9kZSgpLT5pc0VsZW1lbnROb2RlKCkgJiYgcC5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSA9PSAo aW50KXNwbGl0Tm9kZS0+Y2hpbGROb2RlcygpLT5sZW5ndGgoKSkpCisgICAgICAgICAgICBzcGxp dE5vZGUgPSBzcGxpdE5vZGUtPm5leHRTaWJsaW5nKCk7CisgICAgICAgIC8vIEZJWE1FOiBkbyB3 ZSBuZWVkIHRvIHNwbGl0IG5vZGVzIGlmIHRoZSBwb3NpdGlvbiBpcyBpbiB0aGUgbWlkZGxlPyBD dXJyZW50bHksIGNhbGxlcnMgaGFuZGxlIHRoYXQuCisKKyAgICAgICAgaWYgKHNwbGl0Tm9kZSkg eworICAgICAgICAgICAgLy8gRG8gbm90IHNwbGl0IGEgbm9kZSB3aGVuIGRvaW5nIHNvIGludHJv ZHVjZXMgYW4gZW1wdHkgbm9kZS4KKyAgICAgICAgICAgIFZpc2libGVQb3NpdGlvbiBwb3NpdGlv bkluUGFyZW50ID0gZmlyc3RQb3NpdGlvbkluTm9kZShzcGxpdE5vZGUtPnBhcmVudE5vZGUoKSk7 CisgICAgICAgICAgICBWaXNpYmxlUG9zaXRpb24gcG9zaXRpb25Jbk5vZGUgPSBmaXJzdFBvc2l0 aW9uSW5PckJlZm9yZU5vZGUoc3BsaXROb2RlLmdldCgpKTsKKyAgICAgICAgICAgIGlmIChwb3Np dGlvbkluUGFyZW50ICE9IHBvc2l0aW9uSW5Ob2RlKQorICAgICAgICAgICAgICAgIHNwbGl0RWxl bWVudChzdGF0aWNfY2FzdDxFbGVtZW50Kj4oc3BsaXROb2RlLT5wYXJlbnROb2RlKCkpLCBzcGxp dE5vZGUpOworICAgICAgICB9CisgICAgfQorICAgIHJldHVybiBwLmNvbnRhaW5lck5vZGUoKTsK K30KKwogLy8gU3BsaXRzIHRoZSB0cmVlIHBhcmVudCBieSBwYXJlbnQgdW50aWwgd2UgcmVhY2gg dGhlIHNwZWNpZmllZCBhbmNlc3Rvci4gV2UgdXNlIFZpc2libGVQb3NpdGlvbnMKIC8vIHRvIGRl dGVybWluZSBpZiB0aGUgc3BsaXQgaXMgbmVjZXNzYXJ5LiBSZXR1cm5zIHRoZSBsYXN0IHNwbGl0 IG5vZGUuCiBQYXNzUmVmUHRyPE5vZGU+IENvbXBvc2l0ZUVkaXRDb21tYW5kOjpzcGxpdFRyZWVU b05vZGUoTm9kZSogc3RhcnQsIE5vZGUqIGVuZCwgYm9vbCBzaG91bGRTcGxpdEFuY2VzdG9yKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5o IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCmluZGV4IDRm MjJhMDZmMjlkOWFkY2IyY2VhNWU3ODhmYmIxNmIwODVmOTcwOWUuLmEzYzQ5NWQwMzM3ZDQ4NTBj NDJmZDViY2FkZTNlNWYyYmU2MGZmOTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Nv bXBvc2l0ZUVkaXRDb21tYW5kLmgKQEAgLTExNyw2ICsxMTcsNyBAQCBwcm90ZWN0ZWQ6CiAgICAg UG9zaXRpb24gcG9zaXRpb25Bdm9pZGluZ1NwZWNpYWxFbGVtZW50Qm91bmRhcnkoY29uc3QgUG9z aXRpb24mKTsKICAgICAKICAgICBQYXNzUmVmUHRyPE5vZGU+IHNwbGl0VHJlZVRvTm9kZShOb2Rl KiwgTm9kZSosIGJvb2wgc3BsaXRBbmNlc3RvciA9IGZhbHNlKTsKKyAgICBQYXNzUmVmUHRyPE5v ZGU+IHNwbGl0VHJlZVRvUG9zaXRpb24oUG9zaXRpb24qLCBOb2RlKiwgYm9vbCBzaG91bGRTcGxp dEFuY2VzdG9yID0gZmFsc2UpOwogCiAgICAgVmVjdG9yPFJlZlB0cjxFZGl0Q29tbWFuZD4gPiBt X2NvbW1hbmRzOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBh cmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNl cnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcAppbmRleCA4Mzg0ZjMwNjkwNjQ0YjQ5MDQ3 NTk2MmY3M2FjNWEyNGFmNmEzMWU5Li41NTBiM2ExODMwOWE1MjM1YTYxYjFhODkyM2MwNDI0YWFl MmI1NmJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFw aFNlcGFyYXRvckNvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAKQEAgLTM0Nyw3ICszNDcsNyBAQCB2b2lkIElu c2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICBpZiAoaW5z ZXJ0aW9uUG9zaXRpb24uY29udGFpbmVyTm9kZSgpID09IHN0YXJ0QmxvY2spCiAgICAgICAgICAg ICBuID0gaW5zZXJ0aW9uUG9zaXRpb24uY29tcHV0ZU5vZGVBZnRlclBvc2l0aW9uKCk7CiAgICAg ICAgIGVsc2UgewotICAgICAgICAgICAgc3BsaXRUcmVlVG9Ob2RlKGluc2VydGlvblBvc2l0aW9u LmNvbnRhaW5lck5vZGUoKSwgc3RhcnRCbG9jayk7CisgICAgICAgICAgICBzcGxpdFRyZWVUb1Bv c2l0aW9uKCZpbnNlcnRpb25Qb3NpdGlvbiwgc3RhcnRCbG9jayk7CiAKICAgICAgICAgICAgIGZv ciAobiA9IHN0YXJ0QmxvY2stPmZpcnN0Q2hpbGQoKTsgbjsgbiA9IG4tPm5leHRTaWJsaW5nKCkp IHsKICAgICAgICAgICAgICAgICBpZiAoY29tcGFyZVBvc2l0aW9ucyhWaXNpYmxlUG9zaXRpb24o aW5zZXJ0aW9uUG9zaXRpb24pLCBwb3NpdGlvbkJlZm9yZU5vZGUobikpIDw9IDApCg== 96322 2011-06-07 16:20:49 -0700 2011-06-07 20:38:46 -0700 Work in Progress bug-61594-20110607162048.patch text/plain 17315 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODgyNDcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4MTNlNzNiZjczOTQ2YWFkOGJiYmM0 YjljMTllMjgyODQzZDIxOGMxLi5hNWZiMGM3YjQ3ZmQzZWZlNDVlODJhZThhY2E1NjM3Mjc5OWIz NzdmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYtMDcgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRlZCBuZXcgbGF5b3V0IHRlc3RzIGZvciB0aGlzIHByb2JsZW0sIG9uZSBp biB0aGUgbWlkZGxlIG9mIGEgdGV4dCBub2RlLCBhbmQgb25lIGF0IHRoZSBlbmQuCisKKyAgICAg ICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLWV4cGVj dGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1i ZWZvcmUtYnItaW4tc3Bhbi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sOiBBZGRl ZC4KKwogMjAxMS0wNi0wNyAgWW91bmcgSGFuIExlZSAgPGpveWJyb0Bjb21wYW55MTAwLm5ldD4K IAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbi4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJy LWluLXNwYW4tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0 dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDAxNzEw Y2FkNjZiYmRkMTk2OThlZDMzYThkZDBjY2Y1MDBiZmM0YwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4t ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8g dGhlIGVuZCBvZiB0aGUgZmlyc3QgbGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS4gRXhwZWN0 ZWQgYmVoYXZpb3I6IGEgZGl2IGlzIGNyZWF0ZWQgYXJvdW5kIHRoZSBzZWNvbmQgbGluZSwgYW5k IHRoZSBjdXJzb3IgaXMgcGxhY2VkIGF0IHRoZSBzdGFydCBvZiB0aGUgc2Vjb25kIGxpbmUuIFNl ZSBidWcgNjE1OTQuCit8IDxzcGFuPgorfCAgIGlkPSJ3cmFwcGVyIgorfCAgICJGaXJzdCBsaW5l IgorfCA8ZGl2PgorfCAgIDxzcGFuPgorfCAgICAgPCNzZWxlY3Rpb24tY2FyZXQ+Cit8ICAgICA8 YnI+Cit8ICAgICAiU2Vjb25kIGxpbmUiCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWwgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uODdhNGNhM2Y4MzZkZjMwZGZiY2Q5NzUyNjkxOGFlMzExOWFhNWIxYgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVm b3JlLWJyLWluLXNwYW4uaHRtbApAQCAtMCwwICsxLDE2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGJvZHk+Cis8ZGl2IGNvbnRlbnRlZGl0YWJsZSBpZD0icm9vdCI+PHNwYW4gaWQ9Indy YXBwZXIiPkZpcnN0IGxpbmU8YnI+U2Vjb25kIGxpbmU8L3NwYW4+PC9kaXY+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQ+ CitNYXJrdXAuZGVzY3JpcHRpb24oIlRoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBlbmQg b2YgdGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuICIKKyAgICArICJFeHBl Y3RlZCBiZWhhdmlvcjogYSBkaXYgaXMgY3JlYXRlZCBhcm91bmQgdGhlIHNlY29uZCBsaW5lLCBh bmQgdGhlIGN1cnNvciBpcyBwbGFjZWQgYXQgdGhlICIKKyAgICArICJzdGFydCBvZiB0aGUgc2Vj b25kIGxpbmUuIFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlv bigpOworc2VsLnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIiks IDEpOworZXZlbnRTZW5kZXIua2V5RG93bignXG4nKTsKK01hcmt1cC5kdW1wKHJvb3QpOworCis8 L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0 aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZDhjYTU3MTBkY2FmNTViMjBlZTcwNTEwYzRmZTU1NzgzMTBiOWFhYwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXkt bWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyBzZXRzIHRo ZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmlyc3QgbGluZSwgYW5kIGhpdHMgdGhl IGVudGVyIGtleS4gRXhwZWN0ZWQgYmVoYXZpb3I6IHRoZSB0ZXh0IG5vZGUgaXMgc3BsaXQgYXQg dGhlIGN1cnNvci4gVGhlIHNwYW4gaXMgY2xvbmVkLCBhbmQgZXZlcnl0aGluZyB0aGF0IHdhcyBz cGxpdCBvdXQgaXMgcGxhY2VkIGluc2lkZSB0aGUgY2xvbmUgaW4gYSBuZXcgZGl2IHdoaWNoIGlz IGEgY2hpbGQgb2YgdGhlIHJvb3QuIFNlZSBidWcgNjE1OTQuCit8IDxzcGFuPgorfCAgIGlkPSJ3 cmFwcGVyIgorfCAgICJGaXJzdCIKK3wgPGRpdj4KK3wgICA8c3Bhbj4KK3wgICAgICI8I3NlbGVj dGlvbi1jYXJldD7CoGxpbmUiCit8ICAgICA8YnI+Cit8ICAgICAiU2Vjb25kIGxpbmUiCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1v Zi1zcGFuLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1p ZGRsZS1vZi1zcGFuLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGQ0ZGRhZjAzZWMxZWMyMzUwZWZlYjVkNjIw YjE1ZTVkOWYzYmI1MwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5z ZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4uaHRtbApAQCAtMCwwICsxLDE1IEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8ZGl2IGNvbnRlbnRlZGl0YWJsZSBpZD0i cm9vdCI+PHNwYW4gaWQ9IndyYXBwZXIiPkZpcnN0IGxpbmU8YnI+U2Vjb25kIGxpbmU8L3NwYW4+ PC9kaXY+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIj48 L3NjcmlwdD4KKzxzY3JpcHQ+CitNYXJrdXAuZGVzY3JpcHRpb24oIlRoaXMgc2V0cyB0aGUgc2Vs ZWN0aW9uIHRvIHRoZSBtaWRkbGUgb2YgdGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRl ciBrZXkuICIKKyAgICArICJFeHBlY3RlZCBiZWhhdmlvcjogdGhlIHRleHQgbm9kZSBpcyBzcGxp dCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQsIGFuZCBldmVyeXRoaW5nICIKKyAg ICArICJ0aGF0IHdhcyBzcGxpdCBvdXQgaXMgcGxhY2VkIGluc2lkZSB0aGUgY2xvbmUgaW4gYSBu ZXcgZGl2IHdoaWNoIGlzIGEgY2hpbGQgb2YgdGhlIHJvb3QuIFNlZSBidWcgNjE1OTQuIik7Cit2 YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2VsLnNldFBvc2l0aW9uKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIikuZmlyc3RDaGlsZCwgNSk7CitldmVudFNlbmRlci5r ZXlEb3duKCdcbicpOworTWFya3VwLmR1bXAocm9vdCk7Cis8L3NjcmlwdD4KKzwvaHRtbD4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwppbmRleCAwODkyMDY2YmIzMjdlYWZlNzY0MjgxZTYxZDMzMzI5ZGNkNDBkNjJkLi4xNzA3 MjhmYTE0ZTE3NDkxYmZjMjBjMmVmZDNlYzQ1NmQ3NTIxMGYzIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMzIgQEAKKzIwMTEtMDYtMDcgIEFubmllIFN1bGxpdmFuICA8c3VsbGl2YW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJF R1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBvZiB0aGlzIHNwYW4gY2F1c2Vz IHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3BhbgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQKKworICAgICAgICBDaGFuZ2Vk IHNwbGl0VHJlZVRvTm9kZSB0byBhIG1ldGhvZCBzcGxpdFRyZWUoKSB3aGljaCB0YWtlcyBhIFBv c2l0aW9uLCBhbmQgdXBkYXRlZCBjYWxsZXJzLiAKKworICAgICAgICBUZXN0czogZWRpdGluZy9p bnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi5odG1sCisgICAgICAgICAgICAg ICBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwKKworICAg ICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZSk6CisgICAgICAgICogZWRpdGluZy9D b21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRm9ybWF0QmxvY2tDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZvcm1hdEJsb2NrQ29tbWFuZDo6Zm9ybWF0UmFu Z2UpOgorICAgICAgICAqIGVkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SW5kZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudEludG9CbG9ja3F1b3RlKToK KyAgICAgICAgKFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjpvdXRkZW50UGFyYWdyYXBo KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6Okluc2VydExpc3RDb21tYW5kOjp1bmxpc3RpZnlQYXJhZ3JhcGgpOgorICAgICAgICAq IGVkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kOjpkb0FwcGx5KToKKyAgICAg ICAgKiBlZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6 OlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kOjppbnNlcnRBc0xpc3RJdGVtcyk6CisgICAgICAgICog ZWRpdGluZy9odG1sZWRpdGluZy5jcHA6CisKIDIwMTEtMDYtMDcgIFlvdW5nIEhhbiBMZWUgIDxq b3licm9AY29tcGFueTEwMC5uZXQ+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hk ZSBDaHJpc3RpYW5zZW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBv c2l0ZUVkaXRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuY3BwCmluZGV4IDk0Y2Q3NzM2YTY2ZTIzYjgyMzI1ZTBmYjVlMjE4OTY2ZGE3OGUy MjIuLjQwYTAyNDgzMzExMDQxYmUzODZlYWQzZGM0YTgwYzlmM2EwNTM3MzkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCkBAIC00NCw2ICs0 NCw3IEBACiAjaW5jbHVkZSAiSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5oIgogI2lu Y2x1ZGUgIkluc2VydFRleHRDb21tYW5kLmgiCiAjaW5jbHVkZSAiTWVyZ2VJZGVudGljYWxFbGVt ZW50c0NvbW1hbmQuaCIKKyNpbmNsdWRlICJOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlJhbmdlLmgi CiAjaW5jbHVkZSAiUmVtb3ZlQ1NTUHJvcGVydHlDb21tYW5kLmgiCiAjaW5jbHVkZSAiUmVtb3Zl Tm9kZUNvbW1hbmQuaCIKQEAgLTEyMjgsMjAgKzEyMjksMzIgQEAgUG9zaXRpb24gQ29tcG9zaXRl RWRpdENvbW1hbmQ6OnBvc2l0aW9uQXZvaWRpbmdTcGVjaWFsRWxlbWVudEJvdW5kYXJ5KGNvbnN0 IFBvc2kKICAgICByZXR1cm4gcmVzdWx0OwogfQogCi0vLyBTcGxpdHMgdGhlIHRyZWUgcGFyZW50 IGJ5IHBhcmVudCB1bnRpbCB3ZSByZWFjaCB0aGUgc3BlY2lmaWVkIGFuY2VzdG9yLiBXZSB1c2Ug VmlzaWJsZVBvc2l0aW9ucwotLy8gdG8gZGV0ZXJtaW5lIGlmIHRoZSBzcGxpdCBpcyBuZWNlc3Nh cnkuIFJldHVybnMgdGhlIGxhc3Qgc3BsaXQgbm9kZS4KLVBhc3NSZWZQdHI8Tm9kZT4gQ29tcG9z aXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZVRvTm9kZShOb2RlKiBzdGFydCwgTm9kZSogZW5kLCBi b29sIHNob3VsZFNwbGl0QW5jZXN0b3IpCitQYXNzUmVmUHRyPE5vZGU+IENvbXBvc2l0ZUVkaXRD b21tYW5kOjpzcGxpdFRyZWUoUG9zaXRpb24gY29uc3QqIHN0YXJ0LCBOb2RlKiBlbmQsIGJvb2wg c2hvdWxkU3BsaXRBbmNlc3RvcikKIHsKICAgICBBU1NFUlQoc3RhcnQpOwogICAgIEFTU0VSVChl bmQpOwotICAgIEFTU0VSVChzdGFydCAhPSBlbmQpOworICAgIEFTU0VSVChzdGFydC0+Y29udGFp bmVyTm9kZSgpICE9IGVuZCk7CiAKICAgICBSZWZQdHI8Tm9kZT4gbm9kZTsKICAgICBpZiAoc2hv dWxkU3BsaXRBbmNlc3RvciAmJiBlbmQtPnBhcmVudE5vZGUoKSkKICAgICAgICAgZW5kID0gZW5k LT5wYXJlbnROb2RlKCk7Ci0KICAgICBSZWZQdHI8Tm9kZT4gZW5kTm9kZSA9IGVuZDsKLSAgICBm b3IgKG5vZGUgPSBzdGFydDsgbm9kZSAmJiBub2RlLT5wYXJlbnROb2RlKCkgIT0gZW5kTm9kZTsg bm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKSkgeworCisgICAgTm9kZSogc3RhcnROb2RlID0gc3Rh cnQtPmNvbnRhaW5lck5vZGUoKTsKKyAgICAvLyBGb3IgdGV4dCBub2RlcywgaGFuZGxlIHRoZSBj YXNlIHdoZXJlIHRoZSBvZmZzZXQgaXMgaW4gdGhlIG1pZGRsZSBvZiB0aGUgbm9kZSBvciBhdCB0 aGUgZW5kLAorICAgIC8vIG1vdmluZyB0aGUgc3RhcnQgbm9kZSB0byB0aGUgYmVnaW5uaW5nIG9m IHRoZSBwb3NpdGlvbiwgc3BsaXR0aW5nIHRoZSBub2RlIGlmIG5lY2Vzc2FyeS4KKyAgICBpZiAo c3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKKyAgICAgICAgLy8gRklYTUU6IHN0YXJ0Tm9kZSBj YW4gYmUgbnVsbCBpZiB0cmF2ZXJzZU5leHROb2RlIHJldHVybnMgbnVsbC4gV2hhdCBzaG91bGQg aXQgYmUgc2V0IHRvIGluIHRoYXQgY2FzZT8KKyAgICAgICAgaWYgKCh1bnNpZ25lZClzdGFydC0+ b2Zmc2V0SW5Db250YWluZXJOb2RlKCkgPT0gc3RhdGljX2Nhc3Q8VGV4dCo+KHN0YXJ0LT5jb250 YWluZXJOb2RlKCkpLT5sZW5ndGgoKSkKKyAgICAgICAgICAgIHN0YXJ0Tm9kZSA9IHN0YXJ0Tm9k ZS0+dHJhdmVyc2VOZXh0Tm9kZShlbmQpOworICAgICAgICBlbHNlIGlmIChzdGFydC0+b2Zmc2V0 SW5Db250YWluZXJOb2RlKCkgPiAwKSB7CisgICAgICAgICAgICBzcGxpdFRleHROb2RlKHN0YXRp Y19jYXN0PFRleHQqPihzdGFydC0+Y29udGFpbmVyTm9kZSgpKSwgc3RhcnQtPm9mZnNldEluQ29u dGFpbmVyTm9kZSgpKTsKKyAgICAgICAgICAgIHN0YXJ0Tm9kZSA9IHN0YXJ0Tm9kZS0+bmV4dFNp YmxpbmcoKTsKKyAgICAgICAgICAgIEFTU0VSVChzdGFydE5vZGUpOworICAgICAgICB9CisgICAg fQorCisgICAgZm9yIChub2RlID0gc3RhcnROb2RlOyBub2RlICYmIG5vZGUtPnBhcmVudE5vZGUo KSAhPSBlbmROb2RlOyBub2RlID0gbm9kZS0+cGFyZW50Tm9kZSgpKSB7CiAgICAgICAgIGlmICgh bm9kZS0+cGFyZW50Tm9kZSgpLT5pc0VsZW1lbnROb2RlKCkpCiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgLy8gRG8gbm90IHNwbGl0IGEgbm9kZSB3aGVuIGRvaW5nIHNvIGludHJvZHVjZXMg YW4gZW1wdHkgbm9kZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9z aXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENv bW1hbmQuaAppbmRleCA0ZjIyYTA2ZjI5ZDlhZGNiMmNlYTVlNzg4ZmJiMTZiMDg1Zjk3MDllLi4x NmU2OWVlMzNkMWQyOWEyNzQ1N2NjNDc2NTkzOTNlNTY1NTBkZmE5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC0xMTUsOCArMTE1LDggQEAg cHJvdGVjdGVkOgogICAgIGJvb2wgYnJlYWtPdXRPZkVtcHR5TWFpbEJsb2NrcXVvdGVkUGFyYWdy YXBoKCk7CiAgICAgCiAgICAgUG9zaXRpb24gcG9zaXRpb25Bdm9pZGluZ1NwZWNpYWxFbGVtZW50 Qm91bmRhcnkoY29uc3QgUG9zaXRpb24mKTsKLSAgICAKLSAgICBQYXNzUmVmUHRyPE5vZGU+IHNw bGl0VHJlZVRvTm9kZShOb2RlKiwgTm9kZSosIGJvb2wgc3BsaXRBbmNlc3RvciA9IGZhbHNlKTsK KworICAgIFBhc3NSZWZQdHI8Tm9kZT4gc3BsaXRUcmVlKFBvc2l0aW9uIGNvbnN0KiwgTm9kZSos IGJvb2wgc2hvdWxkU3BsaXRBbmNlc3RvciA9IGZhbHNlKTsKIAogICAgIFZlY3RvcjxSZWZQdHI8 RWRpdENvbW1hbmQ+ID4gbV9jb21tYW5kczsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9G b3JtYXRCbG9ja0NvbW1hbmQuY3BwCmluZGV4IDc1OWNhMzE3MWU5NmViYjg3MWU3ZWI2NzNhYTQx NTY0YWE1YzQ5NGUuLmMxMGI0NTI0NmUxOGRhMmYxMDk1NjcxYWYzMzkzOTQ5OGRiNWU4NzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKQEAgLTYx LDcgKzYxLDcgQEAgdm9pZCBGb3JtYXRCbG9ja0NvbW1hbmQ6OmZvcm1hdFNlbGVjdGlvbihjb25z dCBWaXNpYmxlUG9zaXRpb24mIHN0YXJ0T2ZTZWxlY3Rpb24KIHZvaWQgRm9ybWF0QmxvY2tDb21t YW5kOjpmb3JtYXRSYW5nZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIGNvbnN0IFBvc2l0aW9uJiBl bmQsIGNvbnN0IFBvc2l0aW9uJiBlbmRPZlNlbGVjdGlvbiwgUmVmUHRyPEVsZW1lbnQ+JiBibG9j a05vZGUpCiB7CiAgICAgTm9kZSogbm9kZVRvU3BsaXRUbyA9IGVuY2xvc2luZ0Jsb2NrVG9TcGxp dFRyZWVUbyhzdGFydC5kZXByZWNhdGVkTm9kZSgpKTsKLSAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJC bG9jayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQu ZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZVRvTm9kZShzdGFydC5kZXByZWNhdGVkTm9kZSgp LCBub2RlVG9TcGxpdFRvKTsKKyAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5k ZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUo KSA6IHNwbGl0VHJlZSgmc3RhcnQsIG5vZGVUb1NwbGl0VG8pOwogICAgIFJlZlB0cjxOb2RlPiBu b2RlQWZ0ZXJJbnNlcnRpb25Qb3NpdGlvbiA9IG91dGVyQmxvY2s7CiAKICAgICBSZWZQdHI8UmFu Z2U+IHJhbmdlID0gUmFuZ2U6OmNyZWF0ZShkb2N1bWVudCgpLCBzdGFydCwgZW5kT2ZTZWxlY3Rp b24pOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29t bWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNw cAppbmRleCA3ZWQ0YzBjZGI2ZWM4NjdjODU5Y2Q2NWZkMTExOTdlZWQ3OTUzNTUxLi5kNzRmMGE4 MzdkYWJiNTEwZDdhNjJlYjY4MDNhN2QxOWZiYmQ4N2UxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcApAQCAtMTAzLDcgKzEwMyw3IEBAIHZv aWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudEludG9CbG9ja3F1b3RlKGNvbnN0IFBvc2l0 aW9uJiBzdGFydCwgY29uc3QgUG9zCiAgICAgaWYgKCFub2RlVG9TcGxpdFRvKQogICAgICAgICBy ZXR1cm47CiAKLSAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5kZXByZWNhdGVk Tm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0 VHJlZVRvTm9kZShzdGFydC5kZXByZWNhdGVkTm9kZSgpLCBub2RlVG9TcGxpdFRvKTsKKyAgICBS ZWZQdHI8Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVU b1NwbGl0VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZSgmc3RhcnQsIG5v ZGVUb1NwbGl0VG8pOwogCiAgICAgaWYgKCF0YXJnZXRCbG9ja3F1b3RlKSB7CiAgICAgICAgIC8v IENyZWF0ZSBhIG5ldyBibG9ja3F1b3RlIGFuZCBpbnNlcnQgaXQgYXMgYSBjaGlsZCBvZiB0aGUg cm9vdCBlZGl0YWJsZSBlbGVtZW50LiBXZSBhY2NvbXBsaXNoCkBAIC0xNjksOSArMTY5LDEwIEBA IHZvaWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6Om91dGRlbnRQYXJhZ3JhcGgoKQogICAgIH0KICAg ICBOb2RlKiBlbmNsb3NpbmdCbG9ja0Zsb3cgPSBlbmNsb3NpbmdCbG9jayh2aXNpYmxlU3RhcnRP ZlBhcmFncmFwaC5kZWVwRXF1aXZhbGVudCgpLmRlcHJlY2F0ZWROb2RlKCkpOwogICAgIFJlZlB0 cjxOb2RlPiBzcGxpdEJsb2NrcXVvdGVOb2RlID0gZW5jbG9zaW5nTm9kZTsKLSAgICBpZiAoZW5j bG9zaW5nQmxvY2tGbG93ICE9IGVuY2xvc2luZ05vZGUpCi0gICAgICAgIHNwbGl0QmxvY2txdW90 ZU5vZGUgPSBzcGxpdFRyZWVUb05vZGUoZW5jbG9zaW5nQmxvY2tGbG93LCBlbmNsb3NpbmdOb2Rl LCB0cnVlKTsKLSAgICBlbHNlIHsKKyAgICBpZiAoZW5jbG9zaW5nQmxvY2tGbG93ICE9IGVuY2xv c2luZ05vZGUpIHsKKyAgICAgICAgUG9zaXRpb24gYmVmb3JlRW5jbG9zaW5nQmxvY2tGbG93KGZp cnN0UG9zaXRpb25Jbk5vZGUoZW5jbG9zaW5nQmxvY2tGbG93KSk7CisgICAgICAgIHNwbGl0Qmxv Y2txdW90ZU5vZGUgPSBzcGxpdFRyZWUoJmJlZm9yZUVuY2xvc2luZ0Jsb2NrRmxvdywgZW5jbG9z aW5nTm9kZSwgdHJ1ZSk7CisgICAgfSBlbHNlIHsKICAgICAgICAgLy8gV2Ugc3BsaXQgdGhlIGJs b2NrcXVvdGUgYXQgd2hlcmUgd2Ugc3RhcnQgb3V0ZGVudGluZy4KICAgICAgICAgc3BsaXRFbGVt ZW50KHN0YXRpY19jYXN0PEVsZW1lbnQqPihlbmNsb3NpbmdOb2RlKSwgdmlzaWJsZVN0YXJ0T2ZQ YXJhZ3JhcGguZGVlcEVxdWl2YWxlbnQoKS5kZXByZWNhdGVkTm9kZSgpKTsKICAgICB9CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0TGlzdENvbW1hbmQuY3BwCmluZGV4IDQ1ODViMmU4 ODY3NWQxZWQ1NjhkODYxZjg1MzcyNTBhZTk5NzE5MGQuLjQ1ODQ3YTVjOWM3MmVkOGU2MTIxMGNj NGU2NzYyYjA3YWQ5N2M1NzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0TGlzdENvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0TGlz dENvbW1hbmQuY3BwCkBAIC0yODksMTUgKzI4OSwxOCBAQCB2b2lkIEluc2VydExpc3RDb21tYW5k Ojp1bmxpc3RpZnlQYXJhZ3JhcGgoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiBvcmlnaW5hbFN0YXJ0 LAogICAgICAgICAvLyBGSVhNRTogV2UgYXBwZWFyIHRvIHNwbGl0IGF0IG5leHRMaXN0Q2hpbGQg YXMgb3Bwb3NlZCB0byBsaXN0Q2hpbGROb2RlIHNvIHRoYXQgd2hlbiB3ZSByZW1vdmUKICAgICAg ICAgLy8gbGlzdENoaWxkTm9kZSBiZWxvdyBpbiBtb3ZlUGFyYWdyYXBocywgcHJldmlvdXNMaXN0 Q2hpbGQgd2lsbCBiZSByZW1vdmVkIGFsb25nIHdpdGggaXQgaWYgaXQgaXMgCiAgICAgICAgIC8v IHVucmVuZGVyZWQuIEJ1dCB3ZSBvdWdodCB0byByZW1vdmUgbmV4dExpc3RDaGlsZCB0b28sIGlm IGl0IGlzIHVucmVuZGVyZWQuCi0gICAgICAgIHNwbGl0RWxlbWVudChsaXN0Tm9kZSwgc3BsaXRU cmVlVG9Ob2RlKG5leHRMaXN0Q2hpbGQsIGxpc3ROb2RlKSk7CisgICAgICAgIFBvc2l0aW9uIGJl Zm9yZU5leHRMaXN0Q2hpbGQoZmlyc3RQb3NpdGlvbkluTm9kZShuZXh0TGlzdENoaWxkKSk7Cisg ICAgICAgIHNwbGl0RWxlbWVudChsaXN0Tm9kZSwgc3BsaXRUcmVlKCZiZWZvcmVOZXh0TGlzdENo aWxkLCBsaXN0Tm9kZSkpOwogICAgICAgICBpbnNlcnROb2RlQmVmb3JlKG5vZGVUb0luc2VydCwg bGlzdE5vZGUpOwogICAgIH0gZWxzZSBpZiAobmV4dExpc3RDaGlsZCB8fCBsaXN0Q2hpbGROb2Rl LT5wYXJlbnROb2RlKCkgIT0gbGlzdE5vZGUpIHsKICAgICAgICAgLy8gSnVzdCBiZWNhdXNlIGxp c3RDaGlsZE5vZGUgaGFzIG5vIHByZXZpb3VzTGlzdENoaWxkIGRvZXNuJ3QgbWVhbiB0aGVyZSBp c24ndCBhbnkgY29udGVudAogICAgICAgICAvLyBpbiBsaXN0Tm9kZSB0aGF0IGNvbWVzIGJlZm9y ZSBsaXN0Q2hpbGROb2RlLCBhcyBsaXN0Q2hpbGROb2RlIGNvdWxkIGhhdmUgYW5jZXN0b3JzCiAg ICAgICAgIC8vIGJldHdlZW4gaXQgYW5kIGxpc3ROb2RlLiBTbywgd2Ugc3BsaXQgdXAgdG8gbGlz dE5vZGUgYmVmb3JlIGluc2VydGluZyB0aGUgcGxhY2Vob2xkZXIKICAgICAgICAgLy8gd2hlcmUg d2UncmUgYWJvdXQgdG8gbW92ZSBsaXN0Q2hpbGROb2RlIHRvLgotICAgICAgICBpZiAobGlzdENo aWxkTm9kZS0+cGFyZW50Tm9kZSgpICE9IGxpc3ROb2RlKQotICAgICAgICAgICAgc3BsaXRFbGVt ZW50KGxpc3ROb2RlLCBzcGxpdFRyZWVUb05vZGUobGlzdENoaWxkTm9kZSwgbGlzdE5vZGUpLmdl dCgpKTsKKyAgICAgICAgaWYgKGxpc3RDaGlsZE5vZGUtPnBhcmVudE5vZGUoKSAhPSBsaXN0Tm9k ZSkgeworICAgICAgICAgICAgUG9zaXRpb24gYmVmb3JlTGlzdENoaWxkTm9kZShmaXJzdFBvc2l0 aW9uSW5Ob2RlKGxpc3RDaGlsZE5vZGUpKTsKKyAgICAgICAgICAgIHNwbGl0RWxlbWVudChsaXN0 Tm9kZSwgc3BsaXRUcmVlKCZiZWZvcmVMaXN0Q2hpbGROb2RlLCBsaXN0Tm9kZSkuZ2V0KCkpOwor ICAgICAgICB9CiAgICAgICAgIGluc2VydE5vZGVCZWZvcmUobm9kZVRvSW5zZXJ0LCBsaXN0Tm9k ZSk7CiAgICAgfSBlbHNlCiAgICAgICAgIGluc2VydE5vZGVBZnRlcihub2RlVG9JbnNlcnQsIGxp c3ROb2RlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdy YXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBh cmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwCmluZGV4IDgzODRmMzA2OTA2NDRiNDkwNDc1OTYy ZjczYWM1YTI0YWY2YTMxZTkuLmQ1YjhhMzUyOTJiNjY4YWNiNzc2Yzk5ZjZjMTNkZTc0YzMwZmU0 MzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2Vw YXJhdG9yQ29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQYXJh Z3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcApAQCAtMzQ3LDcgKzM0Nyw3IEBAIHZvaWQgSW5zZXJ0 UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgICAgIGlmIChpbnNlcnRp b25Qb3NpdGlvbi5jb250YWluZXJOb2RlKCkgPT0gc3RhcnRCbG9jaykKICAgICAgICAgICAgIG4g PSBpbnNlcnRpb25Qb3NpdGlvbi5jb21wdXRlTm9kZUFmdGVyUG9zaXRpb24oKTsKICAgICAgICAg ZWxzZSB7Ci0gICAgICAgICAgICBzcGxpdFRyZWVUb05vZGUoaW5zZXJ0aW9uUG9zaXRpb24uY29u dGFpbmVyTm9kZSgpLCBzdGFydEJsb2NrKTsKKyAgICAgICAgICAgIHNwbGl0VHJlZSgmaW5zZXJ0 aW9uUG9zaXRpb24sIHN0YXJ0QmxvY2spOwogCiAgICAgICAgICAgICBmb3IgKG4gPSBzdGFydEJs b2NrLT5maXJzdENoaWxkKCk7IG47IG4gPSBuLT5uZXh0U2libGluZygpKSB7CiAgICAgICAgICAg ICAgICAgaWYgKGNvbXBhcmVQb3NpdGlvbnMoVmlzaWJsZVBvc2l0aW9uKGluc2VydGlvblBvc2l0 aW9uKSwgcG9zaXRpb25CZWZvcmVOb2RlKG4pKSA8PSAwKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvZWRpdGluZy9SZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcAppbmRleCA2M2RjMzhjNDQ3NmQ1 YjY4OTI3YThjNGFkM2EyYWNiY2ZjZjcwNGU0Li42YmM5OGM3ZTZiYWVlZmU5MTc3YTMxMTdiZDJk NTg5ZGEwNGUwOWQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VT ZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VT ZWxlY3Rpb25Db21tYW5kLmNwcApAQCAtOTQ2LDcgKzk0Niw3IEBAIHZvaWQgUmVwbGFjZVNlbGVj dGlvbkNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICAvLyBGSVhNRTogaXNJbmxpbmVOb2RlV2l0 aFN0eWxlIGRvZXMgbm90IGNoZWNrIGVkaXRhYmlsaXR5LgogICAgICAgICBpZiAoUmVmUHRyPE5v ZGU+IG5vZGVUb1NwbGl0VG8gPSBoaWdoZXN0RW5jbG9zaW5nTm9kZU9mVHlwZShpbnNlcnRpb25Q b3MsIGlzSW5saW5lTm9kZVdpdGhTdHlsZSkpIHsKICAgICAgICAgICAgIGlmIChpbnNlcnRpb25Q b3MuY29udGFpbmVyTm9kZSgpICE9IG5vZGVUb1NwbGl0VG8pIHsKLSAgICAgICAgICAgICAgICBu b2RlVG9TcGxpdFRvID0gc3BsaXRUcmVlVG9Ob2RlKGluc2VydGlvblBvcy5hbmNob3JOb2RlKCks IG5vZGVUb1NwbGl0VG8uZ2V0KCksIHRydWUpLmdldCgpOworICAgICAgICAgICAgICAgIG5vZGVU b1NwbGl0VG8gPSBzcGxpdFRyZWUoJmluc2VydGlvblBvcywgbm9kZVRvU3BsaXRUby5nZXQoKSwg dHJ1ZSkuZ2V0KCk7CiAgICAgICAgICAgICAgICAgaW5zZXJ0aW9uUG9zID0gcG9zaXRpb25JblBh cmVudEJlZm9yZU5vZGUobm9kZVRvU3BsaXRUby5nZXQoKSk7CiAgICAgICAgICAgICB9CiAgICAg ICAgIH0KQEAgLTEyNDgsMTAgKzEyNDgsNyBAQCBOb2RlKiBSZXBsYWNlU2VsZWN0aW9uQ29tbWFu ZDo6aW5zZXJ0QXNMaXN0SXRlbXMoUGFzc1JlZlB0cjxOb2RlPiBsaXN0RWxlbWVudCwgTgogICAg IC8vIElmIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2YgYSBsaXN0IGl0ZW0sIHdlIHNob3VsZCBzcGxp dCBpdCBpbnRvIHR3byBzZXBhcmF0ZQogICAgIC8vIGxpc3QgaXRlbXMgYW5kIGluc2VydCB0aGVz ZSBub2RlcyBiZXR3ZWVuIHRoZW0uCiAgICAgaWYgKGlzTWlkZGxlKSB7Ci0gICAgICAgIGludCB0 ZXh0Tm9kZU9mZnNldCA9IGluc2VydFBvcy5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKTsKLSAgICAg ICAgaWYgKGluc2VydFBvcy5kZXByZWNhdGVkTm9kZSgpLT5pc1RleHROb2RlKCkgJiYgdGV4dE5v ZGVPZmZzZXQgPiAwKQotICAgICAgICAgICAgc3BsaXRUZXh0Tm9kZShzdGF0aWNfY2FzdDxUZXh0 Kj4oaW5zZXJ0UG9zLmRlcHJlY2F0ZWROb2RlKCkpLCB0ZXh0Tm9kZU9mZnNldCk7Ci0gICAgICAg IHNwbGl0VHJlZVRvTm9kZShpbnNlcnRQb3MuZGVwcmVjYXRlZE5vZGUoKSwgbGFzdE5vZGUsIHRy dWUpOworICAgICAgICBzcGxpdFRyZWUoJmluc2VydFBvcywgbGFzdE5vZGUsIHRydWUpOwogICAg IH0KIAogICAgIHdoaWxlIChSZWZQdHI8Tm9kZT4gbGlzdEl0ZW0gPSBsaXN0RWxlbWVudC0+Zmly c3RDaGlsZCgpKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0 aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCmluZGV4IDI1 YzExZjcyZmQxMTBhZmIyNjg4OTMxNGRmOWZhOTU3MjE3OTlkNDEuLjg1MWQ2NWNlOTBkMWZiODk5 NmU2NTExMTRhYTA0YmY3ZWMzOTZjZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRp bmcuY3BwCkBAIC0xODcsNyArMTg3LDcgQEAgRWxlbWVudCogZWRpdGFibGVSb290Rm9yUG9zaXRp b24oY29uc3QgUG9zaXRpb24mIHApCiAKIC8vIEZpbmRzIHRoZSBlbmNsb3NpbmcgZWxlbWVudCB1 bnRpbCB3aGljaCB0aGUgdHJlZSBjYW4gYmUgc3BsaXQuCiAvLyBXaGVuIGEgdXNlciBoaXRzIEVO VEVSLCBoZS9zaGUgd29uJ3QgZXhwZWN0IHRoaXMgZWxlbWVudCB0byBiZSBzcGxpdCBpbnRvIHR3 by4KLS8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0VHJl ZVRvTm9kZS4KKy8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9mIHNw bGl0VHJlZS4KIEVsZW1lbnQqIHVuc3BsaXR0YWJsZUVsZW1lbnRGb3JQb3NpdGlvbihjb25zdCBQ b3NpdGlvbiYgcCkKIHsKICAgICAvLyBTaW5jZSBlbmNsb3NpbmdOb2RlT2ZUeXBlIHdvbid0IHNl YXJjaCBiZXlvbmQgdGhlIGhpZ2hlc3Qgcm9vdCBlZGl0YWJsZSBub2RlLAo= 96368 2011-06-07 20:38:51 -0700 2011-06-17 18:40:36 -0700 Work in Progress bug-61594-20110607203849.patch text/plain 17285 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODgyNDcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4MTNlNzNiZjczOTQ2YWFkOGJiYmM0 YjljMTllMjgyODQzZDIxOGMxLi5hNWZiMGM3YjQ3ZmQzZWZlNDVlODJhZThhY2E1NjM3Mjc5OWIz NzdmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYtMDcgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRlZCBuZXcgbGF5b3V0IHRlc3RzIGZvciB0aGlzIHByb2JsZW0sIG9uZSBp biB0aGUgbWlkZGxlIG9mIGEgdGV4dCBub2RlLCBhbmQgb25lIGF0IHRoZSBlbmQuCisKKyAgICAg ICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLWV4cGVj dGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1i ZWZvcmUtYnItaW4tc3Bhbi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sOiBBZGRl ZC4KKwogMjAxMS0wNi0wNyAgWW91bmcgSGFuIExlZSAgPGpveWJyb0Bjb21wYW55MTAwLm5ldD4K IAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbi4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJy LWluLXNwYW4tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0 dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2Y0NjJm NDk5MWM2NWUxOTExNWM2YzY5OTM1NTVmYzFhNGU1MzRkMAotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4t ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRv IHRoZSBlbmQgb2YgdGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuCitFeHBl Y3RlZCBiZWhhdmlvcjogYSBkaXYgaXMgY3JlYXRlZCBhcm91bmQgdGhlIHNlY29uZCBsaW5lLCBh bmQgdGhlIGN1cnNvciBpcyBwbGFjZWQgYXQgdGhlIHN0YXJ0IG9mIHRoZSBzZWNvbmQgbGluZS4g U2VlIGJ1ZyA2MTU5NC4KK3wgPHNwYW4+Cit8ICAgaWQ9IndyYXBwZXIiCit8ICAgIkZpcnN0IGxp bmUiCit8IDxkaXY+Cit8ICAgPHNwYW4+Cit8ICAgICA8I3NlbGVjdGlvbi1jYXJldD4KK3wgICAg IDxicj4KK3wgICAgICJTZWNvbmQgbGluZSIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRp bmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbCBiL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi43YjZkYmUwZmFkNjdmZDlmZjMwYjM0MWU1ZGRjZGJjZDcyYzlkMmU3Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1i ZWZvcmUtYnItaW4tc3Bhbi5odG1sCkBAIC0wLDAgKzEsMTYgQEAKKzwhRE9DVFlQRSBodG1sPgor PGh0bWw+Cis8Ym9keT4KKzxkaXYgY29udGVudGVkaXRhYmxlIGlkPSJyb290Ij48c3BhbiBpZD0i d3JhcHBlciI+Rmlyc3QgbGluZTxicj5TZWNvbmQgbGluZTwvc3Bhbj48L2Rpdj4KKzxzY3JpcHQg c3JjPSIuLi8uLi9yZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiPjwvc2NyaXB0PgorPHNjcmlw dD4KK01hcmt1cC5kZXNjcmlwdGlvbigiVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIGVu ZCBvZiB0aGUgZmlyc3QgbGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS5cbiIKKyAgICArICJF eHBlY3RlZCBiZWhhdmlvcjogYSBkaXYgaXMgY3JlYXRlZCBhcm91bmQgdGhlIHNlY29uZCBsaW5l LCBhbmQgdGhlIGN1cnNvciBpcyBwbGFjZWQgYXQgdGhlICIKKyAgICArICJzdGFydCBvZiB0aGUg c2Vjb25kIGxpbmUuIFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVj dGlvbigpOworc2VsLnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVy IiksIDEpOworZXZlbnRTZW5kZXIua2V5RG93bignXG4nKTsKK01hcmt1cC5kdW1wKHJvb3QpOwor Cis8L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5z ZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNDJjOTZkMTBkOTlhZjBiYTMyZmZlNjM4NmJjM2I5NDBjMjk5NDc1Ygot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1r ZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMgc2V0 cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBtaWRkbGUgb2YgdGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRz IHRoZSBlbnRlciBrZXkuCitFeHBlY3RlZCBiZWhhdmlvcjogdGhlIHRleHQgbm9kZSBpcyBzcGxp dCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQsIGFuZCBldmVyeXRoaW5nIHRoYXQg d2FzIHNwbGl0IG91dCBpcyBwbGFjZWQgaW5zaWRlIHRoZSBjbG9uZSBpbiBhIG5ldyBkaXYgd2hp Y2ggaXMgYSBjaGlsZCBvZiB0aGUgcm9vdC4gU2VlIGJ1ZyA2MTU5NC4KK3wgPHNwYW4+Cit8ICAg aWQ9IndyYXBwZXIiCit8ICAgIkZpcnN0IgorfCA8ZGl2PgorfCAgIDxzcGFuPgorfCAgICAgIjwj c2VsZWN0aW9uLWNhcmV0PsKgbGluZSIKK3wgICAgIDxicj4KK3wgICAgICJTZWNvbmQgbGluZSIK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlk ZGxlLW9mLXNwYW4uaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1r ZXktbWlkZGxlLW9mLXNwYW4uaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hNTA3OTk1OGVjYjIxNjMwZjgwMjU1 ZTFmNTIyOTU5NjdlYzlhYWEzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sCkBAIC0wLDAgKzEsMTUg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxkaXYgY29udGVudGVkaXRhYmxl IGlkPSJyb290Ij48c3BhbiBpZD0id3JhcHBlciI+Rmlyc3QgbGluZTxicj5TZWNvbmQgbGluZTwv c3Bhbj48L2Rpdj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAu anMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK01hcmt1cC5kZXNjcmlwdGlvbigiVGhpcyBzZXRzIHRo ZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmlyc3QgbGluZSwgYW5kIGhpdHMgdGhl IGVudGVyIGtleS5cbiIKKyAgICArICJFeHBlY3RlZCBiZWhhdmlvcjogdGhlIHRleHQgbm9kZSBp cyBzcGxpdCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQsIGFuZCBldmVyeXRoaW5n ICIKKyAgICArICJ0aGF0IHdhcyBzcGxpdCBvdXQgaXMgcGxhY2VkIGluc2lkZSB0aGUgY2xvbmUg aW4gYSBuZXcgZGl2IHdoaWNoIGlzIGEgY2hpbGQgb2YgdGhlIHJvb3QuIFNlZSBidWcgNjE1OTQu Iik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2VsLnNldFBvc2l0aW9uKGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIikuZmlyc3RDaGlsZCwgNSk7CitldmVudFNl bmRlci5rZXlEb3duKCdcbicpOworTWFya3VwLmR1bXAocm9vdCk7Cis8L3NjcmlwdD4KKzwvaHRt bD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCAwODkyMDY2YmIzMjdlYWZlNzY0MjgxZTYxZDMzMzI5ZGNkNDBkNjJk Li4xNzA3MjhmYTE0ZTE3NDkxYmZjMjBjMmVmZDNlYzQ1NmQ3NTIxMGYzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTEtMDYtMDcgIEFubmllIFN1bGxpdmFuICA8c3VsbGl2YW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBvZiB0aGlzIHNwYW4g Y2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3BhbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQKKworICAgICAgICBD aGFuZ2VkIHNwbGl0VHJlZVRvTm9kZSB0byBhIG1ldGhvZCBzcGxpdFRyZWUoKSB3aGljaCB0YWtl cyBhIFBvc2l0aW9uLCBhbmQgdXBkYXRlZCBjYWxsZXJzLiAKKworICAgICAgICBUZXN0czogZWRp dGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi5odG1sCisgICAgICAg ICAgICAgICBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwK KworICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZSk6CisgICAgICAgICogZWRp dGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRm9ybWF0Qmxv Y2tDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZvcm1hdEJsb2NrQ29tbWFuZDo6Zm9y bWF0UmFuZ2UpOgorICAgICAgICAqIGVkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6SW5kZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudEludG9CbG9ja3F1 b3RlKToKKyAgICAgICAgKFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjpvdXRkZW50UGFy YWdyYXBoKToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6Okluc2VydExpc3RDb21tYW5kOjp1bmxpc3RpZnlQYXJhZ3JhcGgpOgorICAg ICAgICAqIGVkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kOjpkb0FwcGx5KToK KyAgICAgICAgKiBlZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdl YkNvcmU6OlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kOjppbnNlcnRBc0xpc3RJdGVtcyk6CisgICAg ICAgICogZWRpdGluZy9odG1sZWRpdGluZy5jcHA6CisKIDIwMTEtMDYtMDcgIFlvdW5nIEhhbiBM ZWUgIDxqb3licm9AY29tcGFueTEwMC5uZXQ+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0 aCBSb2hkZSBDaHJpc3RpYW5zZW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9z aXRlRWRpdENvbW1hbmQuY3BwCmluZGV4IDk0Y2Q3NzM2YTY2ZTIzYjgyMzI1ZTBmYjVlMjE4OTY2 ZGE3OGUyMjIuLmQ2ZTcwMzYxMTA1OGMzMTE2MGQ5OGQ0ODM3NzZiNDQ1Yjc0ODBlZTAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCkBAIC00 NCw2ICs0NCw3IEBACiAjaW5jbHVkZSAiSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5o IgogI2luY2x1ZGUgIkluc2VydFRleHRDb21tYW5kLmgiCiAjaW5jbHVkZSAiTWVyZ2VJZGVudGlj YWxFbGVtZW50c0NvbW1hbmQuaCIKKyNpbmNsdWRlICJOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlJh bmdlLmgiCiAjaW5jbHVkZSAiUmVtb3ZlQ1NTUHJvcGVydHlDb21tYW5kLmgiCiAjaW5jbHVkZSAi UmVtb3ZlTm9kZUNvbW1hbmQuaCIKQEAgLTEyMjgsMjAgKzEyMjksMjggQEAgUG9zaXRpb24gQ29t cG9zaXRlRWRpdENvbW1hbmQ6OnBvc2l0aW9uQXZvaWRpbmdTcGVjaWFsRWxlbWVudEJvdW5kYXJ5 KGNvbnN0IFBvc2kKICAgICByZXR1cm4gcmVzdWx0OwogfQogCi0vLyBTcGxpdHMgdGhlIHRyZWUg cGFyZW50IGJ5IHBhcmVudCB1bnRpbCB3ZSByZWFjaCB0aGUgc3BlY2lmaWVkIGFuY2VzdG9yLiBX ZSB1c2UgVmlzaWJsZVBvc2l0aW9ucwotLy8gdG8gZGV0ZXJtaW5lIGlmIHRoZSBzcGxpdCBpcyBu ZWNlc3NhcnkuIFJldHVybnMgdGhlIGxhc3Qgc3BsaXQgbm9kZS4KLVBhc3NSZWZQdHI8Tm9kZT4g Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZVRvTm9kZShOb2RlKiBzdGFydCwgTm9kZSog ZW5kLCBib29sIHNob3VsZFNwbGl0QW5jZXN0b3IpCitQYXNzUmVmUHRyPE5vZGU+IENvbXBvc2l0 ZUVkaXRDb21tYW5kOjpzcGxpdFRyZWUoY29uc3QgUG9zaXRpb24mIHN0YXJ0LCBOb2RlKiBlbmQs IEFuY2VzdG9yU3BsaXRQb2xpY3kgc3BsaXRQb2xpY3kpCiB7Ci0gICAgQVNTRVJUKHN0YXJ0KTsK ICAgICBBU1NFUlQoZW5kKTsKLSAgICBBU1NFUlQoc3RhcnQgIT0gZW5kKTsKKyAgICBBU1NFUlQo c3RhcnQuY29udGFpbmVyTm9kZSgpICE9IGVuZCk7CiAKLSAgICBSZWZQdHI8Tm9kZT4gbm9kZTsK LSAgICBpZiAoc2hvdWxkU3BsaXRBbmNlc3RvciAmJiBlbmQtPnBhcmVudE5vZGUoKSkKKyAgICBp ZiAoc3BsaXRQb2xpY3kgPT0gU3BsaXQgJiYgZW5kLT5wYXJlbnROb2RlKCkpCiAgICAgICAgIGVu ZCA9IGVuZC0+cGFyZW50Tm9kZSgpOwotCiAgICAgUmVmUHRyPE5vZGU+IGVuZE5vZGUgPSBlbmQ7 Ci0gICAgZm9yIChub2RlID0gc3RhcnQ7IG5vZGUgJiYgbm9kZS0+cGFyZW50Tm9kZSgpICE9IGVu ZE5vZGU7IG5vZGUgPSBub2RlLT5wYXJlbnROb2RlKCkpIHsKKworICAgIE5vZGUqIHN0YXJ0Tm9k ZSA9IHN0YXJ0LmNvbnRhaW5lck5vZGUoKTsKKyAgICAvLyBGb3IgdGV4dCBub2RlcywgaGFuZGxl IHRoZSBjYXNlIHdoZXJlIHRoZSBvZmZzZXQgaXMgaW4gdGhlIG1pZGRsZSBvZiB0aGUgbm9kZSBv ciBhdCB0aGUgZW5kLAorICAgIC8vIG1vdmluZyB0aGUgc3RhcnQgbm9kZSB0byB0aGUgYmVnaW5u aW5nIG9mIHRoZSBwb3NpdGlvbiwgc3BsaXR0aW5nIHRoZSBub2RlIGlmIG5lY2Vzc2FyeS4KKyAg ICBpZiAoc3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKKyAgICAgICAgLy8gRklYTUU6IHN0YXJ0 Tm9kZSBjYW4gYmUgbnVsbCBpZiB0cmF2ZXJzZU5leHROb2RlIHJldHVybnMgbnVsbC4gV2hhdCBz aG91bGQgaXQgYmUgc2V0IHRvIGluIHRoYXQgY2FzZT8KKyAgICAgICAgaWYgKHN0YXJ0Lm9mZnNl dEluQ29udGFpbmVyTm9kZSgpID09IGNhcmV0TWF4T2Zmc2V0KHN0YXJ0LmNvbnRhaW5lck5vZGUo KSkpCisgICAgICAgICAgICBzdGFydE5vZGUgPSBzdGFydE5vZGUtPnRyYXZlcnNlTmV4dE5vZGUo ZW5kKTsKKyAgICAgICAgZWxzZSBpZiAoc3RhcnQub2Zmc2V0SW5Db250YWluZXJOb2RlKCkgPiBj YXJldE1pbk9mZnNldChzdGFydC5jb250YWluZXJOb2RlKCkpKQorICAgICAgICAgICAgc3BsaXRU ZXh0Tm9kZShzdGF0aWNfY2FzdDxUZXh0Kj4oc3RhcnQuY29udGFpbmVyTm9kZSgpKSwgc3RhcnQu b2Zmc2V0SW5Db250YWluZXJOb2RlKCkpOworICAgIH0KKworICAgIFJlZlB0cjxOb2RlPiBub2Rl OworICAgIGZvciAobm9kZSA9IHN0YXJ0Tm9kZTsgbm9kZSAmJiBub2RlLT5wYXJlbnROb2RlKCkg IT0gZW5kTm9kZTsgbm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKSkgewogICAgICAgICBpZiAoIW5v ZGUtPnBhcmVudE5vZGUoKS0+aXNFbGVtZW50Tm9kZSgpKQogICAgICAgICAgICAgYnJlYWs7CiAg ICAgICAgIC8vIERvIG5vdCBzcGxpdCBhIG5vZGUgd2hlbiBkb2luZyBzbyBpbnRyb2R1Y2VzIGFu IGVtcHR5IG5vZGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0 ZUVkaXRDb21tYW5kLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21t YW5kLmgKaW5kZXggNGYyMmEwNmYyOWQ5YWRjYjJjZWE1ZTc4OGZiYjE2YjA4NWY5NzA5ZS4uZmM4 NzQ3ZGE5OGQyZmFmODYzYTFiMTZkMjFlN2I3ZDE1ZmEzZDhjMSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaApAQCAtMzcsNiArMzcsOCBAQCBjbGFz cyBIVE1MRWxlbWVudDsKIGNsYXNzIFN0eWxlZEVsZW1lbnQ7CiBjbGFzcyBUZXh0OwogCitlbnVt IEFuY2VzdG9yU3BsaXRQb2xpY3kgeyBEb05vdFNwbGl0LCBTcGxpdCB9OworCiBjbGFzcyBDb21w b3NpdGVFZGl0Q29tbWFuZCA6IHB1YmxpYyBFZGl0Q29tbWFuZCB7CiBwdWJsaWM6CiAgICAgdmly dHVhbCB+Q29tcG9zaXRlRWRpdENvbW1hbmQoKTsKQEAgLTExNSw4ICsxMTcsOCBAQCBwcm90ZWN0 ZWQ6CiAgICAgYm9vbCBicmVha091dE9mRW1wdHlNYWlsQmxvY2txdW90ZWRQYXJhZ3JhcGgoKTsK ICAgICAKICAgICBQb3NpdGlvbiBwb3NpdGlvbkF2b2lkaW5nU3BlY2lhbEVsZW1lbnRCb3VuZGFy eShjb25zdCBQb3NpdGlvbiYpOwotICAgIAotICAgIFBhc3NSZWZQdHI8Tm9kZT4gc3BsaXRUcmVl VG9Ob2RlKE5vZGUqLCBOb2RlKiwgYm9vbCBzcGxpdEFuY2VzdG9yID0gZmFsc2UpOworCisgICAg UGFzc1JlZlB0cjxOb2RlPiBzcGxpdFRyZWUoY29uc3QgUG9zaXRpb24mLCBOb2RlKiwgQW5jZXN0 b3JTcGxpdFBvbGljeSBzcGxpdFBvbGljeSA9IERvTm90U3BsaXQpOwogCiAgICAgVmVjdG9yPFJl ZlB0cjxFZGl0Q29tbWFuZD4gPiBtX2NvbW1hbmRzOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0 aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKaW5kZXggNzU5Y2EzMTcxZTk2ZWJiODcxZTdlYjY3 M2FhNDE1NjRhYTVjNDk0ZS4uYzAxNWFkZjM5ZmQ0ZjY5MmExMTBmZGU3NjMxYTFlNDQzNDMzMDc4 NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcApA QCAtNjEsNyArNjEsNyBAQCB2b2lkIEZvcm1hdEJsb2NrQ29tbWFuZDo6Zm9ybWF0U2VsZWN0aW9u KGNvbnN0IFZpc2libGVQb3NpdGlvbiYgc3RhcnRPZlNlbGVjdGlvbgogdm9pZCBGb3JtYXRCbG9j a0NvbW1hbmQ6OmZvcm1hdFJhbmdlKGNvbnN0IFBvc2l0aW9uJiBzdGFydCwgY29uc3QgUG9zaXRp b24mIGVuZCwgY29uc3QgUG9zaXRpb24mIGVuZE9mU2VsZWN0aW9uLCBSZWZQdHI8RWxlbWVudD4m IGJsb2NrTm9kZSkKIHsKICAgICBOb2RlKiBub2RlVG9TcGxpdFRvID0gZW5jbG9zaW5nQmxvY2tU b1NwbGl0VHJlZVRvKHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkpOwotICAgIFJlZlB0cjxOb2RlPiBv dXRlckJsb2NrID0gKHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkgPT0gbm9kZVRvU3BsaXRUbykgPyBz dGFydC5kZXByZWNhdGVkTm9kZSgpIDogc3BsaXRUcmVlVG9Ob2RlKHN0YXJ0LmRlcHJlY2F0ZWRO b2RlKCksIG5vZGVUb1NwbGl0VG8pOworICAgIFJlZlB0cjxOb2RlPiBvdXRlckJsb2NrID0gKHN0 YXJ0LmRlcHJlY2F0ZWROb2RlKCkgPT0gbm9kZVRvU3BsaXRUbykgPyBzdGFydC5kZXByZWNhdGVk Tm9kZSgpIDogc3BsaXRUcmVlKGZpcnN0UG9zaXRpb25Jbk5vZGUoc3RhcnQuZGVwcmVjYXRlZE5v ZGUoKSksIG5vZGVUb1NwbGl0VG8pOwogICAgIFJlZlB0cjxOb2RlPiBub2RlQWZ0ZXJJbnNlcnRp b25Qb3NpdGlvbiA9IG91dGVyQmxvY2s7CiAKICAgICBSZWZQdHI8UmFuZ2U+IHJhbmdlID0gUmFu Z2U6OmNyZWF0ZShkb2N1bWVudCgpLCBzdGFydCwgZW5kT2ZTZWxlY3Rpb24pOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcAppbmRleCA3ZWQ0YzBj ZGI2ZWM4NjdjODU5Y2Q2NWZkMTExOTdlZWQ3OTUzNTUxLi4xOWM0MTAxZTlhMTcwMTFmZTQ1MGVi NDI2ZGVlZDg3YmIyMWQ4MTRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0lu ZGVudE91dGRlbnRDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luZGVu dE91dGRlbnRDb21tYW5kLmNwcApAQCAtMTAzLDcgKzEwMyw3IEBAIHZvaWQgSW5kZW50T3V0ZGVu dENvbW1hbmQ6OmluZGVudEludG9CbG9ja3F1b3RlKGNvbnN0IFBvc2l0aW9uJiBzdGFydCwgY29u c3QgUG9zCiAgICAgaWYgKCFub2RlVG9TcGxpdFRvKQogICAgICAgICByZXR1cm47CiAKLSAgICBS ZWZQdHI8Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVU b1NwbGl0VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZVRvTm9kZShzdGFy dC5kZXByZWNhdGVkTm9kZSgpLCBub2RlVG9TcGxpdFRvKTsKKyAgICBSZWZQdHI8Tm9kZT4gb3V0 ZXJCbG9jayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3Rh cnQuZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZShmaXJzdFBvc2l0aW9uSW5Ob2RlKHN0YXJ0 LmRlcHJlY2F0ZWROb2RlKCkpLCBub2RlVG9TcGxpdFRvKTsKIAogICAgIGlmICghdGFyZ2V0Qmxv Y2txdW90ZSkgewogICAgICAgICAvLyBDcmVhdGUgYSBuZXcgYmxvY2txdW90ZSBhbmQgaW5zZXJ0 IGl0IGFzIGEgY2hpbGQgb2YgdGhlIHJvb3QgZWRpdGFibGUgZWxlbWVudC4gV2UgYWNjb21wbGlz aApAQCAtMTcwLDcgKzE3MCw3IEBAIHZvaWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6Om91dGRlbnRQ YXJhZ3JhcGgoKQogICAgIE5vZGUqIGVuY2xvc2luZ0Jsb2NrRmxvdyA9IGVuY2xvc2luZ0Jsb2Nr KHZpc2libGVTdGFydE9mUGFyYWdyYXBoLmRlZXBFcXVpdmFsZW50KCkuZGVwcmVjYXRlZE5vZGUo KSk7CiAgICAgUmVmUHRyPE5vZGU+IHNwbGl0QmxvY2txdW90ZU5vZGUgPSBlbmNsb3NpbmdOb2Rl OwogICAgIGlmIChlbmNsb3NpbmdCbG9ja0Zsb3cgIT0gZW5jbG9zaW5nTm9kZSkKLSAgICAgICAg c3BsaXRCbG9ja3F1b3RlTm9kZSA9IHNwbGl0VHJlZVRvTm9kZShlbmNsb3NpbmdCbG9ja0Zsb3cs IGVuY2xvc2luZ05vZGUsIHRydWUpOworICAgICAgICBzcGxpdEJsb2NrcXVvdGVOb2RlID0gc3Bs aXRUcmVlKGZpcnN0UG9zaXRpb25Jbk5vZGUoZW5jbG9zaW5nQmxvY2tGbG93KSwgZW5jbG9zaW5n Tm9kZSwgU3BsaXQpOwogICAgIGVsc2UgewogICAgICAgICAvLyBXZSBzcGxpdCB0aGUgYmxvY2tx dW90ZSBhdCB3aGVyZSB3ZSBzdGFydCBvdXRkZW50aW5nLgogICAgICAgICBzcGxpdEVsZW1lbnQo c3RhdGljX2Nhc3Q8RWxlbWVudCo+KGVuY2xvc2luZ05vZGUpLCB2aXNpYmxlU3RhcnRPZlBhcmFn cmFwaC5kZWVwRXF1aXZhbGVudCgpLmRlcHJlY2F0ZWROb2RlKCkpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRMaXN0Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcAppbmRleCA0NTg1YjJlODg2NzVkMWVkNTY4 ZDg2MWY4NTM3MjUwYWU5OTcxOTBkLi5kNzc5ZDljYmVhNTE3ODZiMmU1ZTM3ZGVhNGRmNjhhYzU4 N2Q2MDc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21t YW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNw cApAQCAtMjg5LDcgKzI4OSw3IEBAIHZvaWQgSW5zZXJ0TGlzdENvbW1hbmQ6OnVubGlzdGlmeVBh cmFncmFwaChjb25zdCBWaXNpYmxlUG9zaXRpb24mIG9yaWdpbmFsU3RhcnQsCiAgICAgICAgIC8v IEZJWE1FOiBXZSBhcHBlYXIgdG8gc3BsaXQgYXQgbmV4dExpc3RDaGlsZCBhcyBvcHBvc2VkIHRv IGxpc3RDaGlsZE5vZGUgc28gdGhhdCB3aGVuIHdlIHJlbW92ZQogICAgICAgICAvLyBsaXN0Q2hp bGROb2RlIGJlbG93IGluIG1vdmVQYXJhZ3JhcGhzLCBwcmV2aW91c0xpc3RDaGlsZCB3aWxsIGJl IHJlbW92ZWQgYWxvbmcgd2l0aCBpdCBpZiBpdCBpcyAKICAgICAgICAgLy8gdW5yZW5kZXJlZC4g QnV0IHdlIG91Z2h0IHRvIHJlbW92ZSBuZXh0TGlzdENoaWxkIHRvbywgaWYgaXQgaXMgdW5yZW5k ZXJlZC4KLSAgICAgICAgc3BsaXRFbGVtZW50KGxpc3ROb2RlLCBzcGxpdFRyZWVUb05vZGUobmV4 dExpc3RDaGlsZCwgbGlzdE5vZGUpKTsKKyAgICAgICAgc3BsaXRFbGVtZW50KGxpc3ROb2RlLCBz cGxpdFRyZWUoZmlyc3RQb3NpdGlvbkluTm9kZShuZXh0TGlzdENoaWxkKSwgbGlzdE5vZGUpKTsK ICAgICAgICAgaW5zZXJ0Tm9kZUJlZm9yZShub2RlVG9JbnNlcnQsIGxpc3ROb2RlKTsKICAgICB9 IGVsc2UgaWYgKG5leHRMaXN0Q2hpbGQgfHwgbGlzdENoaWxkTm9kZS0+cGFyZW50Tm9kZSgpICE9 IGxpc3ROb2RlKSB7CiAgICAgICAgIC8vIEp1c3QgYmVjYXVzZSBsaXN0Q2hpbGROb2RlIGhhcyBu byBwcmV2aW91c0xpc3RDaGlsZCBkb2Vzbid0IG1lYW4gdGhlcmUgaXNuJ3QgYW55IGNvbnRlbnQK QEAgLTI5Nyw3ICsyOTcsNyBAQCB2b2lkIEluc2VydExpc3RDb21tYW5kOjp1bmxpc3RpZnlQYXJh Z3JhcGgoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiBvcmlnaW5hbFN0YXJ0LAogICAgICAgICAvLyBi ZXR3ZWVuIGl0IGFuZCBsaXN0Tm9kZS4gU28sIHdlIHNwbGl0IHVwIHRvIGxpc3ROb2RlIGJlZm9y ZSBpbnNlcnRpbmcgdGhlIHBsYWNlaG9sZGVyCiAgICAgICAgIC8vIHdoZXJlIHdlJ3JlIGFib3V0 IHRvIG1vdmUgbGlzdENoaWxkTm9kZSB0by4KICAgICAgICAgaWYgKGxpc3RDaGlsZE5vZGUtPnBh cmVudE5vZGUoKSAhPSBsaXN0Tm9kZSkKLSAgICAgICAgICAgIHNwbGl0RWxlbWVudChsaXN0Tm9k ZSwgc3BsaXRUcmVlVG9Ob2RlKGxpc3RDaGlsZE5vZGUsIGxpc3ROb2RlKS5nZXQoKSk7CisgICAg ICAgICAgICBzcGxpdEVsZW1lbnQobGlzdE5vZGUsIHNwbGl0VHJlZShmaXJzdFBvc2l0aW9uSW5O b2RlKGxpc3RDaGlsZE5vZGUpLCBsaXN0Tm9kZSkuZ2V0KCkpOwogICAgICAgICBpbnNlcnROb2Rl QmVmb3JlKG5vZGVUb0luc2VydCwgbGlzdE5vZGUpOwogICAgIH0gZWxzZQogICAgICAgICBpbnNl cnROb2RlQWZ0ZXIobm9kZVRvSW5zZXJ0LCBsaXN0Tm9kZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwIGIvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcApp bmRleCA4Mzg0ZjMwNjkwNjQ0YjQ5MDQ3NTk2MmY3M2FjNWEyNGFmNmEzMWU5Li44N2VhMThkZWYx ZTMwYzhlYmY0NTliMGNkY2M5Yjk3N2Y3OWE1MjdiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAKQEAg LTM0Nyw3ICszNDcsNyBAQCB2b2lkIEluc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQ6OmRv QXBwbHkoKQogICAgICAgICBpZiAoaW5zZXJ0aW9uUG9zaXRpb24uY29udGFpbmVyTm9kZSgpID09 IHN0YXJ0QmxvY2spCiAgICAgICAgICAgICBuID0gaW5zZXJ0aW9uUG9zaXRpb24uY29tcHV0ZU5v ZGVBZnRlclBvc2l0aW9uKCk7CiAgICAgICAgIGVsc2UgewotICAgICAgICAgICAgc3BsaXRUcmVl VG9Ob2RlKGluc2VydGlvblBvc2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgc3RhcnRCbG9jayk7Cisg ICAgICAgICAgICBzcGxpdFRyZWUoaW5zZXJ0aW9uUG9zaXRpb24sIHN0YXJ0QmxvY2spOwogCiAg ICAgICAgICAgICBmb3IgKG4gPSBzdGFydEJsb2NrLT5maXJzdENoaWxkKCk7IG47IG4gPSBuLT5u ZXh0U2libGluZygpKSB7CiAgICAgICAgICAgICAgICAgaWYgKGNvbXBhcmVQb3NpdGlvbnMoVmlz aWJsZVBvc2l0aW9uKGluc2VydGlvblBvc2l0aW9uKSwgcG9zaXRpb25CZWZvcmVOb2RlKG4pKSA8 PSAwKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9SZXBsYWNlU2VsZWN0aW9u Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21t YW5kLmNwcAppbmRleCA2M2RjMzhjNDQ3NmQ1YjY4OTI3YThjNGFkM2EyYWNiY2ZjZjcwNGU0Li43 YjU3MjEyOWNjNzg1YjQxMzhkNWY0MTUwYmNlMTI5NzU1Y2NjOTRiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcApAQCAtOTQ2LDcg Kzk0Niw3IEBAIHZvaWQgUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAg ICAvLyBGSVhNRTogaXNJbmxpbmVOb2RlV2l0aFN0eWxlIGRvZXMgbm90IGNoZWNrIGVkaXRhYmls aXR5LgogICAgICAgICBpZiAoUmVmUHRyPE5vZGU+IG5vZGVUb1NwbGl0VG8gPSBoaWdoZXN0RW5j bG9zaW5nTm9kZU9mVHlwZShpbnNlcnRpb25Qb3MsIGlzSW5saW5lTm9kZVdpdGhTdHlsZSkpIHsK ICAgICAgICAgICAgIGlmIChpbnNlcnRpb25Qb3MuY29udGFpbmVyTm9kZSgpICE9IG5vZGVUb1Nw bGl0VG8pIHsKLSAgICAgICAgICAgICAgICBub2RlVG9TcGxpdFRvID0gc3BsaXRUcmVlVG9Ob2Rl KGluc2VydGlvblBvcy5hbmNob3JOb2RlKCksIG5vZGVUb1NwbGl0VG8uZ2V0KCksIHRydWUpLmdl dCgpOworICAgICAgICAgICAgICAgIG5vZGVUb1NwbGl0VG8gPSBzcGxpdFRyZWUoaW5zZXJ0aW9u UG9zLCBub2RlVG9TcGxpdFRvLmdldCgpLCBTcGxpdCkuZ2V0KCk7CiAgICAgICAgICAgICAgICAg aW5zZXJ0aW9uUG9zID0gcG9zaXRpb25JblBhcmVudEJlZm9yZU5vZGUobm9kZVRvU3BsaXRUby5n ZXQoKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KQEAgLTEyNDgsMTAgKzEyNDgsNyBAQCBO b2RlKiBSZXBsYWNlU2VsZWN0aW9uQ29tbWFuZDo6aW5zZXJ0QXNMaXN0SXRlbXMoUGFzc1JlZlB0 cjxOb2RlPiBsaXN0RWxlbWVudCwgTgogICAgIC8vIElmIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2Yg YSBsaXN0IGl0ZW0sIHdlIHNob3VsZCBzcGxpdCBpdCBpbnRvIHR3byBzZXBhcmF0ZQogICAgIC8v IGxpc3QgaXRlbXMgYW5kIGluc2VydCB0aGVzZSBub2RlcyBiZXR3ZWVuIHRoZW0uCiAgICAgaWYg KGlzTWlkZGxlKSB7Ci0gICAgICAgIGludCB0ZXh0Tm9kZU9mZnNldCA9IGluc2VydFBvcy5vZmZz ZXRJbkNvbnRhaW5lck5vZGUoKTsKLSAgICAgICAgaWYgKGluc2VydFBvcy5kZXByZWNhdGVkTm9k ZSgpLT5pc1RleHROb2RlKCkgJiYgdGV4dE5vZGVPZmZzZXQgPiAwKQotICAgICAgICAgICAgc3Bs aXRUZXh0Tm9kZShzdGF0aWNfY2FzdDxUZXh0Kj4oaW5zZXJ0UG9zLmRlcHJlY2F0ZWROb2RlKCkp LCB0ZXh0Tm9kZU9mZnNldCk7Ci0gICAgICAgIHNwbGl0VHJlZVRvTm9kZShpbnNlcnRQb3MuZGVw cmVjYXRlZE5vZGUoKSwgbGFzdE5vZGUsIHRydWUpOworICAgICAgICBzcGxpdFRyZWUoaW5zZXJ0 UG9zLCBsYXN0Tm9kZSwgU3BsaXQpOwogICAgIH0KIAogICAgIHdoaWxlIChSZWZQdHI8Tm9kZT4g bGlzdEl0ZW0gPSBsaXN0RWxlbWVudC0+Zmlyc3RDaGlsZCgpKSB7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvaHRtbGVkaXRpbmcuY3BwCmluZGV4IDI1YzExZjcyZmQxMTBhZmIyNjg4OTMxNGRmOWZhOTU3 MjE3OTlkNDEuLjg1MWQ2NWNlOTBkMWZiODk5NmU2NTExMTRhYTA0YmY3ZWMzOTZjZGMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCkBAIC0xODcsNyArMTg3LDcgQEAgRWxl bWVudCogZWRpdGFibGVSb290Rm9yUG9zaXRpb24oY29uc3QgUG9zaXRpb24mIHApCiAKIC8vIEZp bmRzIHRoZSBlbmNsb3NpbmcgZWxlbWVudCB1bnRpbCB3aGljaCB0aGUgdHJlZSBjYW4gYmUgc3Bs aXQuCiAvLyBXaGVuIGEgdXNlciBoaXRzIEVOVEVSLCBoZS9zaGUgd29uJ3QgZXhwZWN0IHRoaXMg ZWxlbWVudCB0byBiZSBzcGxpdCBpbnRvIHR3by4KLS8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUg c2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0VHJlZVRvTm9kZS4KKy8vIFlvdSBtYXkgcGFzcyBpdCBh cyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0VHJlZS4KIEVsZW1lbnQqIHVuc3BsaXR0YWJs ZUVsZW1lbnRGb3JQb3NpdGlvbihjb25zdCBQb3NpdGlvbiYgcCkKIHsKICAgICAvLyBTaW5jZSBl bmNsb3NpbmdOb2RlT2ZUeXBlIHdvbid0IHNlYXJjaCBiZXlvbmQgdGhlIGhpZ2hlc3Qgcm9vdCBl ZGl0YWJsZSBub2RlLAo= 97678 2011-06-17 18:40:41 -0700 2011-06-22 11:44:15 -0700 Patch bug-61594-20110617184040.patch text/plain 22277 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODkxNzUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiMGY2NGEyMzU5YjY4NzEwZjdkMzY3 ODYxMzIwOGEwMTI0ZTRmMjk2Li45NDgwMmRiZTZkZjgyNmFlMTgxN2ViNDg3NmUyYmI0MzIxNjJl Y2YxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDYtMTcgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRlZCBuZXcgdGVzdHMgYW5kIHVwZGF0ZWQgcmVzdWx0cyBub3cgdGhhdCBl eHRyYSBlbXB0eSBsaXN0cyBhcmUgbm8gbG9uZ2VyIGJlaW5nIGdlbmVyYXRlZC4KKworICAgICAg ICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvNTc2MzA4Mi1leHBlY3RlZC50eHQ6IEdvdCByaWQgb2Yg ZW1wdHkgPHVsPiBub2RlLgorICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvb3V0ZGVudC1z ZWxlY3Rpb24tZXhwZWN0ZWQudHh0OiBFbXB0eSA8dWw+IG5vZGVzIG5vIGxvbmdlciBiZWluZyBj cmVhdGVkLgorICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJy LWluLXNwYW4tZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWw6IEFkZGVkIG5ldyB0ZXN0IGZyb20g dGVzdCBjYXNlIGluIGJ1Zy4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5 LW1pZGRsZS1vZi1zcGFuLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9p bnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sOiBBZGRlZCBuZXcgdGVzdCB0 byBlbnN1cmUgcG9zaXRpb24gYXQgc3RhcnQgb2Ygc3BhbiBzdGlsbCB3b3Jrcy4KKwogMjAxMS0w Ni0xNyAgU3RlcGhlbiBXaGl0ZSAgPHNlbm9yYmxhbmNvQGNocm9taXVtLm9yZz4KIAogICAgICAg ICBVbnJldmlld2VkLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFu ZC81NzYzMDgyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQv NTc2MzA4Mi1leHBlY3RlZC50eHQKaW5kZXggMjY3ZWIyMGExN2Q1ZWE0ZDFmYzU4MWQ5MDg2Mjdh ZDFhMzE4YzhhNS4uZDkzMWI1NDYyYjFiODY1ZDhlYjgxYzM4ZjEwY2Q2MjMyNmNjZGY3ZiAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC81NzYzMDgyLWV4cGVjdGVk LnR4dAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kLzU3NjMwODItZXhwZWN0 ZWQudHh0CkBAIC0zLDQgKzMsMyBAQCBvcmFuZ2UKIGxlbW9uCiBvcmFuZ2UKIGxlbW9uCi0KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvb3V0ZGVudC1zZWxlY3Rp b24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9vdXRkZW50 LXNlbGVjdGlvbi1leHBlY3RlZC50eHQKaW5kZXggYTNhYmRiMTVkOTYzMDRkYzg4OWUyOWNiMmE1 YTdmN2IxODgzODRiNS4uMGFjYjU1NjI2OWJhZDBmMjVhMWQ4N2M3M2ViN2M5NzY2YjA0MDQ0MiAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9vdXRkZW50LXNlbGVj dGlvbi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9v dXRkZW50LXNlbGVjdGlvbi1leHBlY3RlZC50eHQKQEAgLTI2LDE4ICsyNiwxMiBAQCBtb3JlIExv cmVtIQogfCAgIDxicj4KIHwgICAiQmF6IgogfCAgIDxicj4KLXwgICA8dWw+Ci18ICAgICAiCi0i CiB8ICJEb2xvciIKIHwgPGJyPgogfCAiCiAiCiB8ICJEaW5uZXIgdGltZT8iCiB8IDxicj4KLXwg PHVsPgotfCAgICIKLSIKIHwgIgogU3VtISIKIHwgPGJyPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1i ci1pbi1zcGFuLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zZjQ2MmY0OTkxYzY1ZTE5MTE1YzZj Njk5MzU1NWZjMWE0ZTUzNGQwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwxMCBAQAorVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIGVuZCBvZiB0aGUg Zmlyc3QgbGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS4KK0V4cGVjdGVkIGJlaGF2aW9yOiBh IGRpdiBpcyBjcmVhdGVkIGFyb3VuZCB0aGUgc2Vjb25kIGxpbmUsIGFuZCB0aGUgY3Vyc29yIGlz IHBsYWNlZCBhdCB0aGUgc3RhcnQgb2YgdGhlIHNlY29uZCBsaW5lLiBTZWUgYnVnIDYxNTk0Lgor fCA8c3Bhbj4KK3wgICBpZD0id3JhcHBlciIKK3wgICAiRmlyc3QgbGluZSIKK3wgPGRpdj4KK3wg ICA8c3Bhbj4KK3wgICAgIDwjc2VsZWN0aW9uLWNhcmV0PgorfCAgICAgPGJyPgorfCAgICAgIlNl Y29uZCBsaW5lIgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0 dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNl cnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bhbi5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmUzNWRh NzBkOTEyMDczMmNiNjc1ZDBlYzFlMTM4Nzk5MjQ1YmYyY2QKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFu Lmh0bWwKQEAgLTAsMCArMSwxNiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5Pgor PGRpdiBjb250ZW50ZWRpdGFibGUgaWQ9InJvb3QiPjxzcGFuIGlkPSJ3cmFwcGVyIj5GaXJzdCBs aW5lPGJyPlNlY29uZCBsaW5lPC9zcGFuPjwvZGl2PgorPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291 cmNlcy9kdW1wLWFzLW1hcmt1cC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0PgorTWFya3VwLmRlc2Ny aXB0aW9uKCJUaGlzIHNldHMgdGhlIHNlbGVjdGlvbiB0byB0aGUgZW5kIG9mIHRoZSBmaXJzdCBs aW5lLCBhbmQgaGl0cyB0aGUgZW50ZXIga2V5LlxuIgorICAgICsgIkV4cGVjdGVkIGJlaGF2aW9y OiBhIGRpdiBpcyBjcmVhdGVkIGFyb3VuZCB0aGUgc2Vjb25kIGxpbmUsIGFuZCB0aGUgY3Vyc29y IGlzIHBsYWNlZCBhdCB0aGUgIgorICAgICsgInN0YXJ0IG9mIHRoZSBzZWNvbmQgbGluZS4gU2Vl IGJ1ZyA2MTU5NC4iKTsKK3ZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CitzZWwuc2V0 UG9zaXRpb24oZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIndyYXBwZXIiKSwgMSk7Citkb2N1bWVu dC5leGVjQ29tbWFuZCgiSW5zZXJ0UGFyYWdyYXBoIiwgZmFsc2UsIG51bGwpOworTWFya3VwLmR1 bXAocm9vdCk7CisKKzwvc2NyaXB0PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFu LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MmM5NmQxMGQ5OWFmMGJhMzJmZmU2Mzg2YmMzYjk0 MGMyOTk0NzViCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRp bmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBA QAorVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmlyc3QgbGlu ZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS4KK0V4cGVjdGVkIGJlaGF2aW9yOiB0aGUgdGV4dCBu b2RlIGlzIHNwbGl0IGF0IHRoZSBjdXJzb3IuIFRoZSBzcGFuIGlzIGNsb25lZCwgYW5kIGV2ZXJ5 dGhpbmcgdGhhdCB3YXMgc3BsaXQgb3V0IGlzIHBsYWNlZCBpbnNpZGUgdGhlIGNsb25lIGluIGEg bmV3IGRpdiB3aGljaCBpcyBhIGNoaWxkIG9mIHRoZSByb290LiBTZWUgYnVnIDYxNTk0LgorfCA8 c3Bhbj4KK3wgICBpZD0id3JhcHBlciIKK3wgICAiRmlyc3QiCit8IDxkaXY+Cit8ICAgPHNwYW4+ Cit8ICAgICAiPCNzZWxlY3Rpb24tY2FyZXQ+wqBsaW5lIgorfCAgICAgPGJyPgorfCAgICAgIlNl Y29uZCBsaW5lIgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0 dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRp bmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJlYTg4N2FjYWE0 ZDM3MTY0MzFjYWY5ZDY4N2I3ODMyMzQzM2IyMDcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwKQEAg LTAsMCArMSwxNSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5PgorPGRpdiBjb250 ZW50ZWRpdGFibGUgaWQ9InJvb3QiPjxzcGFuIGlkPSJ3cmFwcGVyIj5GaXJzdCBsaW5lPGJyPlNl Y29uZCBsaW5lPC9zcGFuPjwvZGl2PgorPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9kdW1w LWFzLW1hcmt1cC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0PgorTWFya3VwLmRlc2NyaXB0aW9uKCJU aGlzIHNldHMgdGhlIHNlbGVjdGlvbiB0byB0aGUgbWlkZGxlIG9mIHRoZSBmaXJzdCBsaW5lLCBh bmQgaGl0cyB0aGUgZW50ZXIga2V5LlxuIgorICAgICsgIkV4cGVjdGVkIGJlaGF2aW9yOiB0aGUg dGV4dCBub2RlIGlzIHNwbGl0IGF0IHRoZSBjdXJzb3IuIFRoZSBzcGFuIGlzIGNsb25lZCwgYW5k IGV2ZXJ5dGhpbmcgIgorICAgICsgInRoYXQgd2FzIHNwbGl0IG91dCBpcyBwbGFjZWQgaW5zaWRl IHRoZSBjbG9uZSBpbiBhIG5ldyBkaXYgd2hpY2ggaXMgYSBjaGlsZCBvZiB0aGUgcm9vdC4gU2Vl IGJ1ZyA2MTU5NC4iKTsKK3ZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CitzZWwuc2V0 UG9zaXRpb24oZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIndyYXBwZXIiKS5maXJzdENoaWxkLCA1 KTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCJJbnNlcnRQYXJhZ3JhcGgiLCBmYWxzZSwgbnVsbCk7 CitNYXJrdXAuZHVtcChyb290KTsKKzwvc2NyaXB0PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGY0 MjkzYmYxOGE3OTZmYjc0ZTE3ZTNmZjUxNDMxMGRkOWM1YzQ1MmYuLjcxMTI5ZjM4Y2IxY2JiZjBk MzRiNDk1ZmI5NjlkNWE1Y2U4MTAzZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAx MS0wNi0xNyAgQW5uaWUgU3VsbGl2YW4gIDxzdWxsaXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUkVHUkVTU0lPTjogSGl0 dGluZyBlbnRlciBpbiB0aGUgbWlkZGxlIG9mIHRoaXMgc3BhbiBjYXVzZXMgdGhlIGN1cnNvciB0 byBnbyB0byB0aGUgZW5kIG9mIHRoZSBzcGFuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02MTU5NAorCisgICAgICAgIFJlbmFtZWQgc3BsaXRUcmVlVG9O b2RlIHRvIHNwbGl0VHJlZSBhbmQgbWFkZSBpdCB0YWtlIGEgcG9zaXRpb24gaW5zdGVhZCBvZiBh IG5vZGUuCisgICAgICAgIFJlZmFjdG9yZWQgY2FsbGVycyB0byBtYWtlIHVzZSBvZiBzcGxpdFRy ZWUoKSBpbnN0ZWFkLiBTb21lIGNhbGxzaXRlcyBjb3VsZCBiZSBzaW1wbGlmaWVkLgorCisgICAg ICAgIFRlc3RzOiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFu Lmh0bWwKKyAgICAgICAgICAgICAgIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxl LW9mLXNwYW4uaHRtbAorCisgICAgICAgICogZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5j cHA6IAorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZSk6 CisgICAgICAgICAgICBJbXBsZW1lbnQgbmV3IGZ1bmN0aW9uLiBMaWtlIHNwbGl0VHJlZVRvTm9k ZSgpLCBidXQgcGlja3Mgc3RhcnQgbm9kZSBiYXNlZCBvbiBwb3NpdGlvbiBzbyB0aGF0IHRleHQg bm9kZXMgYXJlIHNwbGl0IGNvcnJlY3RseS4KKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVk aXRDb21tYW5kLmg6CisgICAgICAgICogZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6Rm9ybWF0QmxvY2tDb21tYW5kOjpmb3JtYXRSYW5nZSk6IENhbGwg bmV3IHNwbGl0VHJlZSgpIG1ldGhvZC4KKyAgICAgICAgKiBlZGl0aW5nL0luZGVudE91dGRlbnRD b21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjppbmRl bnRJbnRvQmxvY2txdW90ZSk6IENhbGwgbmV3IHNwbGl0VHJlZSgpIG1ldGhvZC4KKyAgICAgICAg KFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjpvdXRkZW50UGFyYWdyYXBoKTogVXNlIG5v bi1kZXByZWNhdGVkIGNvbnRhaW5lck5vZGUoKSwgY2FsbCBuZXcgc3BsaXRUcmVlKCkgbWV0aG9k LgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0TGlzdENvbW1hbmQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6SW5zZXJ0TGlzdENvbW1hbmQ6OmRvQXBwbHlGb3JTaW5nbGVQYXJhZ3JhcGgpOiBVc2Ug bm9uLWRlcHJlY2F0ZWQgY29udGFpbmVyTm9kZSgpLgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0 TGlzdENvbW1hbmQ6OnVubGlzdGlmeVBhcmFncmFwaCk6IFJlZmFjdG9yZWQgdG8gY2FsbCBzcGxp dFRyZWUoKSwgcmVkdWNpbmcgdGhlIG5lZWQgZm9yIGxvZ2ljIGFyb3VuZCB3aGVyZSB0byBzcGxp dC4KKyAgICAgICAgKiBlZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZDo6ZG9B cHBseSk6IENhbGwgbmV3IHNwbGl0VHJlZSgpIG1ldGhvZC4KKyAgICAgICAgKiBlZGl0aW5nL1Jl cGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlcGxhY2VTZWxl Y3Rpb25Db21tYW5kOjpkb0FwcGx5KTogQ2FsbCBuZXcgc3BsaXRUcmVlKCkgbWV0aG9kLgorICAg ICAgICAoV2ViQ29yZTo6UmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQ6Omluc2VydEFzTGlzdEl0ZW1z KTogUmVmYWN0b3JlZCB0byBjYWxsIHNwbGl0VHJlZSgpLCB3aGljaCBhdXRvbWF0aWNhbGx5IHNw bGl0cyB0ZXh0IG5vZGUgaW4gdGhlIHJpZ2h0IHBsYWNlLgorICAgICAgICAqIGVkaXRpbmcvaHRt bGVkaXRpbmcuY3BwOiBVcGRhdGVkIGNvbW1lbnRzIHdpdGggbmV3IGZ1bmN0aW9uIG5hbWUKKwog MjAxMS0wNi0xNyAgSmVyIE5vYmxlICA8amVyLm5vYmxlQGFwcGxlLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGEgQ2hhbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv Q29tcG9zaXRlRWRpdENvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3Np dGVFZGl0Q29tbWFuZC5jcHAKaW5kZXggZDkyZDVhNTkyNDhlZDQxNzlkNmM4ZmY5YjZkYzQ1Yjg5 MGJkNjRjOC4uOWU2ZWJkMGU4OGE1MTU4YTczNjZiYjIxOTFlN2FkYjk5ZmViMDY1NCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKQEAgLTQ0 LDYgKzQ0LDcgQEAKICNpbmNsdWRlICJJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmgi CiAjaW5jbHVkZSAiSW5zZXJ0VGV4dENvbW1hbmQuaCIKICNpbmNsdWRlICJNZXJnZUlkZW50aWNh bEVsZW1lbnRzQ29tbWFuZC5oIgorI2luY2x1ZGUgIk5vZGVMaXN0LmgiCiAjaW5jbHVkZSAiUmFu Z2UuaCIKICNpbmNsdWRlICJSZW1vdmVDU1NQcm9wZXJ0eUNvbW1hbmQuaCIKICNpbmNsdWRlICJS ZW1vdmVOb2RlQ29tbWFuZC5oIgpAQCAtMTIyOCwyMCArMTIyOSwyOCBAQCBQb3NpdGlvbiBDb21w b3NpdGVFZGl0Q29tbWFuZDo6cG9zaXRpb25Bdm9pZGluZ1NwZWNpYWxFbGVtZW50Qm91bmRhcnko Y29uc3QgUG9zaQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKLS8vIFNwbGl0cyB0aGUgdHJlZSBw YXJlbnQgYnkgcGFyZW50IHVudGlsIHdlIHJlYWNoIHRoZSBzcGVjaWZpZWQgYW5jZXN0b3IuIFdl IHVzZSBWaXNpYmxlUG9zaXRpb25zCi0vLyB0byBkZXRlcm1pbmUgaWYgdGhlIHNwbGl0IGlzIG5l Y2Vzc2FyeS4gUmV0dXJucyB0aGUgbGFzdCBzcGxpdCBub2RlLgotUGFzc1JlZlB0cjxOb2RlPiBD b21wb3NpdGVFZGl0Q29tbWFuZDo6c3BsaXRUcmVlVG9Ob2RlKE5vZGUqIHN0YXJ0LCBOb2RlKiBl bmQsIGJvb2wgc2hvdWxkU3BsaXRBbmNlc3RvcikKK1Bhc3NSZWZQdHI8Tm9kZT4gQ29tcG9zaXRl RWRpdENvbW1hbmQ6OnNwbGl0VHJlZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIE5vZGUqIGVuZCwg QW5jZXN0b3JTcGxpdFJ1bGUgc3BsaXRSdWxlKQogewotICAgIEFTU0VSVChzdGFydCk7CiAgICAg QVNTRVJUKGVuZCk7Ci0gICAgQVNTRVJUKHN0YXJ0ICE9IGVuZCk7CisgICAgQVNTRVJUKHN0YXJ0 LmNvbnRhaW5lck5vZGUoKSAhPSBlbmQpOwogCi0gICAgUmVmUHRyPE5vZGU+IG5vZGU7Ci0gICAg aWYgKHNob3VsZFNwbGl0QW5jZXN0b3IgJiYgZW5kLT5wYXJlbnROb2RlKCkpCisgICAgaWYgKHNw bGl0UnVsZSA9PSBTcGxpdEVuZCAmJiBlbmQtPnBhcmVudE5vZGUoKSkKICAgICAgICAgZW5kID0g ZW5kLT5wYXJlbnROb2RlKCk7Ci0KICAgICBSZWZQdHI8Tm9kZT4gZW5kTm9kZSA9IGVuZDsKLSAg ICBmb3IgKG5vZGUgPSBzdGFydDsgbm9kZSAmJiBub2RlLT5wYXJlbnROb2RlKCkgIT0gZW5kTm9k ZTsgbm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKSkgeworCisgICAgTm9kZSogc3RhcnROb2RlID0g c3RhcnQuY29udGFpbmVyTm9kZSgpOworICAgIC8vIEZvciB0ZXh0IG5vZGVzLCBoYW5kbGUgdGhl IGNhc2Ugd2hlcmUgdGhlIG9mZnNldCBpcyBpbiB0aGUgbWlkZGxlIG9mIHRoZSBub2RlIG9yIGF0 IHRoZSBlbmQsCisgICAgLy8gbW92aW5nIHRoZSBzdGFydCBub2RlIHRvIHRoZSBiZWdpbm5pbmcg b2YgdGhlIHBvc2l0aW9uLCBzcGxpdHRpbmcgdGhlIG5vZGUgaWYgbmVjZXNzYXJ5LgorICAgIGlm IChzdGFydE5vZGUtPmlzVGV4dE5vZGUoKSkgeworICAgICAgICAvLyBGSVhNRTogc3RhcnROb2Rl IGNhbiBiZSBudWxsIGlmIHRyYXZlcnNlTmV4dE5vZGUgcmV0dXJucyBudWxsLiBXaGF0IHNob3Vs ZCBpdCBiZSBzZXQgdG8gaW4gdGhhdCBjYXNlPworICAgICAgICBpZiAoc3RhcnQub2Zmc2V0SW5D b250YWluZXJOb2RlKCkgPj0gY2FyZXRNYXhPZmZzZXQoc3RhcnQuY29udGFpbmVyTm9kZSgpKSkK KyAgICAgICAgICAgIHN0YXJ0Tm9kZSA9IHN0YXJ0Tm9kZS0+dHJhdmVyc2VOZXh0Tm9kZShlbmQp OworICAgICAgICBlbHNlIGlmIChzdGFydC5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSA+IGNhcmV0 TWluT2Zmc2V0KHN0YXJ0LmNvbnRhaW5lck5vZGUoKSkpCisgICAgICAgICAgICBzcGxpdFRleHRO b2RlKHN0YXRpY19jYXN0PFRleHQqPihzdGFydC5jb250YWluZXJOb2RlKCkpLCBzdGFydC5vZmZz ZXRJbkNvbnRhaW5lck5vZGUoKSk7CisgICAgfQorCisgICAgUmVmUHRyPE5vZGU+IG5vZGU7Cisg ICAgZm9yIChub2RlID0gc3RhcnROb2RlOyBub2RlICYmIG5vZGUtPnBhcmVudE5vZGUoKSAhPSBl bmROb2RlOyBub2RlID0gbm9kZS0+cGFyZW50Tm9kZSgpKSB7CiAgICAgICAgIGlmICghbm9kZS0+ cGFyZW50Tm9kZSgpLT5pc0VsZW1lbnROb2RlKCkpCiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgLy8gRG8gbm90IHNwbGl0IGEgbm9kZSB3aGVuIGRvaW5nIHNvIGludHJvZHVjZXMgYW4gZW1w dHkgbm9kZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQu aAppbmRleCA0ZjIyYTA2ZjI5ZDlhZGNiMmNlYTVlNzg4ZmJiMTZiMDg1Zjk3MDllLi40NDhmNjY2 MGMwYjVlMzcwMjk3MWU4NmYwNzU1Y2Y4ZmJkNzU2NzEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC0xMTYsNyArMTE2LDggQEAgcHJvdGVj dGVkOgogICAgIAogICAgIFBvc2l0aW9uIHBvc2l0aW9uQXZvaWRpbmdTcGVjaWFsRWxlbWVudEJv dW5kYXJ5KGNvbnN0IFBvc2l0aW9uJik7CiAgICAgCi0gICAgUGFzc1JlZlB0cjxOb2RlPiBzcGxp dFRyZWVUb05vZGUoTm9kZSosIE5vZGUqLCBib29sIHNwbGl0QW5jZXN0b3IgPSBmYWxzZSk7Cisg ICAgZW51bSBBbmNlc3RvclNwbGl0UnVsZSB7IERvTm90U3BsaXRFbmQsIFNwbGl0RW5kIH07Cisg ICAgUGFzc1JlZlB0cjxOb2RlPiBzcGxpdFRyZWUoY29uc3QgUG9zaXRpb24mLCBOb2RlKiwgQW5j ZXN0b3JTcGxpdFJ1bGUgPSBEb05vdFNwbGl0RW5kKTsKIAogICAgIFZlY3RvcjxSZWZQdHI8RWRp dENvbW1hbmQ+ID4gbV9jb21tYW5kczsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Gb3Jt YXRCbG9ja0NvbW1hbmQuY3BwCmluZGV4IDc1OWNhMzE3MWU5NmViYjg3MWU3ZWI2NzNhYTQxNTY0 YWE1YzQ5NGUuLmMwMTVhZGYzOWZkNGY2OTJhMTEwZmRlNzYzMWExZTQ0MzQzMzA3ODYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKQEAgLTYxLDcg KzYxLDcgQEAgdm9pZCBGb3JtYXRCbG9ja0NvbW1hbmQ6OmZvcm1hdFNlbGVjdGlvbihjb25zdCBW aXNpYmxlUG9zaXRpb24mIHN0YXJ0T2ZTZWxlY3Rpb24KIHZvaWQgRm9ybWF0QmxvY2tDb21tYW5k Ojpmb3JtYXRSYW5nZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIGNvbnN0IFBvc2l0aW9uJiBlbmQs IGNvbnN0IFBvc2l0aW9uJiBlbmRPZlNlbGVjdGlvbiwgUmVmUHRyPEVsZW1lbnQ+JiBibG9ja05v ZGUpCiB7CiAgICAgTm9kZSogbm9kZVRvU3BsaXRUbyA9IGVuY2xvc2luZ0Jsb2NrVG9TcGxpdFRy ZWVUbyhzdGFydC5kZXByZWNhdGVkTm9kZSgpKTsKLSAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJCbG9j ayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQuZGVw cmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZVRvTm9kZShzdGFydC5kZXByZWNhdGVkTm9kZSgpLCBu b2RlVG9TcGxpdFRvKTsKKyAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5kZXBy ZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA6 IHNwbGl0VHJlZShmaXJzdFBvc2l0aW9uSW5Ob2RlKHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkpLCBu b2RlVG9TcGxpdFRvKTsKICAgICBSZWZQdHI8Tm9kZT4gbm9kZUFmdGVySW5zZXJ0aW9uUG9zaXRp b24gPSBvdXRlckJsb2NrOwogCiAgICAgUmVmUHRyPFJhbmdlPiByYW5nZSA9IFJhbmdlOjpjcmVh dGUoZG9jdW1lbnQoKSwgc3RhcnQsIGVuZE9mU2VsZWN0aW9uKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKaW5kZXggN2VkNGMwY2RiNmVjODY3 Yzg1OWNkNjVmZDExMTk3ZWVkNzk1MzU1MS4uY2FlMmM2NDhiYzZlZjkwNTczM2RmMzhmMzUzMzJj OTQzYjlhYmUyNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRk ZW50Q29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50 Q29tbWFuZC5jcHAKQEAgLTEwMyw3ICsxMDMsNyBAQCB2b2lkIEluZGVudE91dGRlbnRDb21tYW5k OjppbmRlbnRJbnRvQmxvY2txdW90ZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIGNvbnN0IFBvcwog ICAgIGlmICghbm9kZVRvU3BsaXRUbykKICAgICAgICAgcmV0dXJuOwogCi0gICAgUmVmUHRyPE5v ZGU+IG91dGVyQmxvY2sgPSAoc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA9PSBub2RlVG9TcGxpdFRv KSA/IHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkgOiBzcGxpdFRyZWVUb05vZGUoc3RhcnQuZGVwcmVj YXRlZE5vZGUoKSwgbm9kZVRvU3BsaXRUbyk7CisgICAgUmVmUHRyPE5vZGU+IG91dGVyQmxvY2sg PSAoc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA9PSBub2RlVG9TcGxpdFRvKSA/IHN0YXJ0LmRlcHJl Y2F0ZWROb2RlKCkgOiBzcGxpdFRyZWUoZmlyc3RQb3NpdGlvbkluTm9kZShzdGFydC5kZXByZWNh dGVkTm9kZSgpKSwgbm9kZVRvU3BsaXRUbyk7CiAKICAgICBpZiAoIXRhcmdldEJsb2NrcXVvdGUp IHsKICAgICAgICAgLy8gQ3JlYXRlIGEgbmV3IGJsb2NrcXVvdGUgYW5kIGluc2VydCBpdCBhcyBh IGNoaWxkIG9mIHRoZSByb290IGVkaXRhYmxlIGVsZW1lbnQuIFdlIGFjY29tcGxpc2gKQEAgLTE2 NywxMCArMTY3LDEwIEBAIHZvaWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6Om91dGRlbnRQYXJhZ3Jh cGgoKQogCiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgTm9kZSogZW5jbG9zaW5nQmxvY2tG bG93ID0gZW5jbG9zaW5nQmxvY2sodmlzaWJsZVN0YXJ0T2ZQYXJhZ3JhcGguZGVlcEVxdWl2YWxl bnQoKS5kZXByZWNhdGVkTm9kZSgpKTsKKyAgICBOb2RlKiBlbmNsb3NpbmdCbG9ja0Zsb3cgPSBl bmNsb3NpbmdCbG9jayh2aXNpYmxlU3RhcnRPZlBhcmFncmFwaC5kZWVwRXF1aXZhbGVudCgpLmNv bnRhaW5lck5vZGUoKSk7CiAgICAgUmVmUHRyPE5vZGU+IHNwbGl0QmxvY2txdW90ZU5vZGUgPSBl bmNsb3NpbmdOb2RlOwogICAgIGlmIChlbmNsb3NpbmdCbG9ja0Zsb3cgIT0gZW5jbG9zaW5nTm9k ZSkKLSAgICAgICAgc3BsaXRCbG9ja3F1b3RlTm9kZSA9IHNwbGl0VHJlZVRvTm9kZShlbmNsb3Np bmdCbG9ja0Zsb3csIGVuY2xvc2luZ05vZGUsIHRydWUpOworICAgICAgICBzcGxpdEJsb2NrcXVv dGVOb2RlID0gc3BsaXRUcmVlKGZpcnN0UG9zaXRpb25Jbk5vZGUoZW5jbG9zaW5nQmxvY2tGbG93 KSwgZW5jbG9zaW5nTm9kZSwgU3BsaXRFbmQpOwogICAgIGVsc2UgewogICAgICAgICAvLyBXZSBz cGxpdCB0aGUgYmxvY2txdW90ZSBhdCB3aGVyZSB3ZSBzdGFydCBvdXRkZW50aW5nLgogICAgICAg ICBzcGxpdEVsZW1lbnQoc3RhdGljX2Nhc3Q8RWxlbWVudCo+KGVuY2xvc2luZ05vZGUpLCB2aXNp YmxlU3RhcnRPZlBhcmFncmFwaC5kZWVwRXF1aXZhbGVudCgpLmRlcHJlY2F0ZWROb2RlKCkpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRMaXN0Q29tbWFuZC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcAppbmRleCA0NTg1 YjJlODg2NzVkMWVkNTY4ZDg2MWY4NTM3MjUwYWU5OTcxOTBkLi41MmRmMTkxYWIxMzFiOWIwNmMy ZTczNTdiNTU5MDkxZmMwZTI5NTZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0luc2VydExpc3RDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dExpc3RDb21tYW5kLmNwcApAQCAtMTkxLDcgKzE5MSw3IEBAIHZvaWQgSW5zZXJ0TGlzdENvbW1h bmQ6OmRvQXBwbHlGb3JTaW5nbGVQYXJhZ3JhcGgoYm9vbCBmb3JjZUNyZWF0ZUxpc3QsIGNvbnN0 IFF1CiAgICAgLy8gRklYTUU6IFRoaXMgd2lsbCBwcm9kdWNlIHVuZXhwZWN0ZWQgcmVzdWx0cyBm b3IgYSBzZWxlY3Rpb24gdGhhdCBzdGFydHMganVzdCBiZWZvcmUgYQogICAgIC8vIHRhYmxlIGFu ZCBlbmRzIGluc2lkZSB0aGUgZmlyc3QgY2VsbCwgc2VsZWN0aW9uRm9yUGFyYWdyYXBoSXRlcmF0 aW9uIHNob3VsZCBwcm9iYWJseQogICAgIC8vIGJlIHJlbmFtZWQgYW5kIGRlcGxveWVkIGluc2lk ZSBzZXRFbmRpbmdTZWxlY3Rpb24oKS4KLSAgICBOb2RlKiBzZWxlY3Rpb25Ob2RlID0gZW5kaW5n U2VsZWN0aW9uKCkuc3RhcnQoKS5kZXByZWNhdGVkTm9kZSgpOworICAgIE5vZGUqIHNlbGVjdGlv bk5vZGUgPSBlbmRpbmdTZWxlY3Rpb24oKS5zdGFydCgpLmNvbnRhaW5lck5vZGUoKTsKICAgICBO b2RlKiBsaXN0Q2hpbGROb2RlID0gZW5jbG9zaW5nTGlzdENoaWxkKHNlbGVjdGlvbk5vZGUpOwog ICAgIGJvb2wgc3dpdGNoTGlzdFR5cGUgPSBmYWxzZTsKICAgICBpZiAobGlzdENoaWxkTm9kZSkg ewpAQCAtMjUyLDIzICsyNTIsMTUgQEAgdm9pZCBJbnNlcnRMaXN0Q29tbWFuZDo6ZG9BcHBseUZv clNpbmdsZVBhcmFncmFwaChib29sIGZvcmNlQ3JlYXRlTGlzdCwgY29uc3QgUXUKIAogdm9pZCBJ bnNlcnRMaXN0Q29tbWFuZDo6dW5saXN0aWZ5UGFyYWdyYXBoKGNvbnN0IFZpc2libGVQb3NpdGlv biYgb3JpZ2luYWxTdGFydCwgSFRNTEVsZW1lbnQqIGxpc3ROb2RlLCBOb2RlKiBsaXN0Q2hpbGRO b2RlKQogewotICAgIE5vZGUqIG5leHRMaXN0Q2hpbGQ7Ci0gICAgTm9kZSogcHJldmlvdXNMaXN0 Q2hpbGQ7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHN0YXJ0OwogICAgIFZpc2libGVQb3NpdGlvbiBl bmQ7CiAgICAgaWYgKGxpc3RDaGlsZE5vZGUtPmhhc1RhZ05hbWUobGlUYWcpKSB7CiAgICAgICAg IHN0YXJ0ID0gZmlyc3RQb3NpdGlvbkluTm9kZShsaXN0Q2hpbGROb2RlKTsKICAgICAgICAgZW5k ID0gbGFzdFBvc2l0aW9uSW5Ob2RlKGxpc3RDaGlsZE5vZGUpOwotICAgICAgICBuZXh0TGlzdENo aWxkID0gbGlzdENoaWxkTm9kZS0+bmV4dFNpYmxpbmcoKTsKLSAgICAgICAgcHJldmlvdXNMaXN0 Q2hpbGQgPSBsaXN0Q2hpbGROb2RlLT5wcmV2aW91c1NpYmxpbmcoKTsKICAgICB9IGVsc2Ugewog ICAgICAgICAvLyBBIHBhcmFncmFwaCBpcyB2aXN1YWxseSBhIGxpc3QgaXRlbSBtaW51cyBhIGxp c3QgbWFya2VyLiAgVGhlIHBhcmFncmFwaCB3aWxsIGJlIG1vdmVkLgogICAgICAgICBzdGFydCA9 IHN0YXJ0T2ZQYXJhZ3JhcGgob3JpZ2luYWxTdGFydCwgQ2FuU2tpcE92ZXJFZGl0aW5nQm91bmRh cnkpOwogICAgICAgICBlbmQgPSBlbmRPZlBhcmFncmFwaChzdGFydCwgQ2FuU2tpcE92ZXJFZGl0 aW5nQm91bmRhcnkpOwotICAgICAgICBuZXh0TGlzdENoaWxkID0gZW5jbG9zaW5nTGlzdENoaWxk KGVuZC5uZXh0KCkuZGVlcEVxdWl2YWxlbnQoKS5kZXByZWNhdGVkTm9kZSgpLCBsaXN0Tm9kZSk7 Ci0gICAgICAgIEFTU0VSVChuZXh0TGlzdENoaWxkICE9IGxpc3RDaGlsZE5vZGUpOwotICAgICAg ICBwcmV2aW91c0xpc3RDaGlsZCA9IGVuY2xvc2luZ0xpc3RDaGlsZChzdGFydC5wcmV2aW91cygp LmRlZXBFcXVpdmFsZW50KCkuZGVwcmVjYXRlZE5vZGUoKSwgbGlzdE5vZGUpOwotICAgICAgICBB U1NFUlQocHJldmlvdXNMaXN0Q2hpbGQgIT0gbGlzdENoaWxkTm9kZSk7CiAgICAgfQogICAgIC8v IFdoZW4gcmVtb3ZpbmcgYSBsaXN0LCB3ZSBtdXN0IGFsd2F5cyBjcmVhdGUgYSBwbGFjZWhvbGRl ciB0byBhY3QgYXMgYSBwb2ludCBvZiBpbnNlcnRpb24KICAgICAvLyBmb3IgdGhlIGxpc3QgY29u dGVudCBiZWluZyByZW1vdmVkLgpAQCAtMjgxLDI2ICsyNzMsMTggQEAgdm9pZCBJbnNlcnRMaXN0 Q29tbWFuZDo6dW5saXN0aWZ5UGFyYWdyYXBoKGNvbnN0IFZpc2libGVQb3NpdGlvbiYgb3JpZ2lu YWxTdGFydCwKICAgICAgICAgYXBwZW5kTm9kZShwbGFjZWhvbGRlciwgbm9kZVRvSW5zZXJ0KTsK ICAgICB9CiAKLSAgICBpZiAobmV4dExpc3RDaGlsZCAmJiBwcmV2aW91c0xpc3RDaGlsZCkgewot ICAgICAgICAvLyBXZSB3YW50IHRvIHB1bGwgbGlzdENoaWxkTm9kZSBvdXQgb2YgbGlzdE5vZGUs IGFuZCBwbGFjZSBpdCBiZWZvcmUgbmV4dExpc3RDaGlsZCAKLSAgICAgICAgLy8gYW5kIGFmdGVy IHByZXZpb3VzTGlzdENoaWxkLCBzbyB3ZSBzcGxpdCBsaXN0Tm9kZSBhbmQgaW5zZXJ0IGl0IGJl dHdlZW4gdGhlIHR3byBsaXN0cy4gIAotICAgICAgICAvLyBCdXQgdG8gc3BsaXQgbGlzdE5vZGUs IHdlIG11c3QgZmlyc3Qgc3BsaXQgYW5jZXN0b3JzIG9mIGxpc3RDaGlsZE5vZGUgYmV0d2VlbiBp dCBhbmQgbGlzdE5vZGUsCi0gICAgICAgIC8vIGlmIGFueSBleGlzdC4KLSAgICAgICAgLy8gRklY TUU6IFdlIGFwcGVhciB0byBzcGxpdCBhdCBuZXh0TGlzdENoaWxkIGFzIG9wcG9zZWQgdG8gbGlz dENoaWxkTm9kZSBzbyB0aGF0IHdoZW4gd2UgcmVtb3ZlCi0gICAgICAgIC8vIGxpc3RDaGlsZE5v ZGUgYmVsb3cgaW4gbW92ZVBhcmFncmFwaHMsIHByZXZpb3VzTGlzdENoaWxkIHdpbGwgYmUgcmVt b3ZlZCBhbG9uZyB3aXRoIGl0IGlmIGl0IGlzIAotICAgICAgICAvLyB1bnJlbmRlcmVkLiBCdXQg d2Ugb3VnaHQgdG8gcmVtb3ZlIG5leHRMaXN0Q2hpbGQgdG9vLCBpZiBpdCBpcyB1bnJlbmRlcmVk LgotICAgICAgICBzcGxpdEVsZW1lbnQobGlzdE5vZGUsIHNwbGl0VHJlZVRvTm9kZShuZXh0TGlz dENoaWxkLCBsaXN0Tm9kZSkpOwotICAgICAgICBpbnNlcnROb2RlQmVmb3JlKG5vZGVUb0luc2Vy dCwgbGlzdE5vZGUpOwotICAgIH0gZWxzZSBpZiAobmV4dExpc3RDaGlsZCB8fCBsaXN0Q2hpbGRO b2RlLT5wYXJlbnROb2RlKCkgIT0gbGlzdE5vZGUpIHsKLSAgICAgICAgLy8gSnVzdCBiZWNhdXNl IGxpc3RDaGlsZE5vZGUgaGFzIG5vIHByZXZpb3VzTGlzdENoaWxkIGRvZXNuJ3QgbWVhbiB0aGVy ZSBpc24ndCBhbnkgY29udGVudAotICAgICAgICAvLyBpbiBsaXN0Tm9kZSB0aGF0IGNvbWVzIGJl Zm9yZSBsaXN0Q2hpbGROb2RlLCBhcyBsaXN0Q2hpbGROb2RlIGNvdWxkIGhhdmUgYW5jZXN0b3Jz Ci0gICAgICAgIC8vIGJldHdlZW4gaXQgYW5kIGxpc3ROb2RlLiBTbywgd2Ugc3BsaXQgdXAgdG8g bGlzdE5vZGUgYmVmb3JlIGluc2VydGluZyB0aGUgcGxhY2Vob2xkZXIKLSAgICAgICAgLy8gd2hl cmUgd2UncmUgYWJvdXQgdG8gbW92ZSBsaXN0Q2hpbGROb2RlIHRvLgotICAgICAgICBpZiAobGlz dENoaWxkTm9kZS0+cGFyZW50Tm9kZSgpICE9IGxpc3ROb2RlKQotICAgICAgICAgICAgc3BsaXRF bGVtZW50KGxpc3ROb2RlLCBzcGxpdFRyZWVUb05vZGUobGlzdENoaWxkTm9kZSwgbGlzdE5vZGUp LmdldCgpKTsKLSAgICAgICAgaW5zZXJ0Tm9kZUJlZm9yZShub2RlVG9JbnNlcnQsIGxpc3ROb2Rl KTsKLSAgICB9IGVsc2UKKyAgICBSZWZQdHI8Tm9kZT4gc3BsaXRBdCA9IHNwbGl0VHJlZShzdGFy dC5kZWVwRXF1aXZhbGVudCgpLCBsaXN0Tm9kZSk7CisgICAgLy8gVW5sZXNzIHRoaXMgaXMgdGhl IGZpcnN0IG5vZGUgaW4gdGhlIGxpc3QsIHRoZSBsaXN0IG5lZWRzIHRvIGJlIHNwbGl0LgorICAg IGlmICghaXNGaXJzdFZpc2libGVQb3NpdGlvbkluTm9kZShWaXNpYmxlUG9zaXRpb24oZmlyc3RQ b3NpdGlvbkluTm9kZShzcGxpdEF0LmdldCgpKSksIGxpc3ROb2RlKSkKKyAgICAgICAgc3BsaXRF bGVtZW50KGxpc3ROb2RlLCBzcGxpdEF0KTsKKyAgICAvLyBJZiB0aGlzIGlzIHRoZSBvbmx5IG5v ZGUgaW4gdGhlIGxpc3QsIGluc2VydCB0aGUgcGxhY2Vob2xkZXIgYWZ0ZXIgaXQsIHNvIHRoYXQg aWYgc3BsaXRBdAorICAgIC8vIGFuZCB0aGUgbm9kZSBiZWZvcmUgdGhlIHBsYWNlaG9sZGVyIGFy ZSBib3RoIHRleHQgbm9kZXMsIHRoZXkgd2lsbCBub3QgYmUgbWVyZ2VkLiBTZWUKKyAgICAvLyBM YXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL3N3aXRjaC1saXN0LXR5cGUuaHRtbAorICAg IGlmIChpc0ZpcnN0VmlzaWJsZVBvc2l0aW9uSW5Ob2RlKFZpc2libGVQb3NpdGlvbihmaXJzdFBv c2l0aW9uSW5Ob2RlKHNwbGl0QXQuZ2V0KCkpKSwgbGlzdE5vZGUpCisgICAgICAgICYmIGlzTGFz dFZpc2libGVQb3NpdGlvbkluTm9kZShWaXNpYmxlUG9zaXRpb24obGFzdFBvc2l0aW9uSW5Ob2Rl KGxpc3RDaGlsZE5vZGUpKSwgbGlzdE5vZGUpKQogICAgICAgICBpbnNlcnROb2RlQWZ0ZXIobm9k ZVRvSW5zZXJ0LCBsaXN0Tm9kZSk7CisgICAgZWxzZSAKKyAgICAgICAgaW5zZXJ0Tm9kZUJlZm9y ZShub2RlVG9JbnNlcnQsIGxpc3ROb2RlKTsKIAogICAgIFZpc2libGVQb3NpdGlvbiBpbnNlcnRp b25Qb2ludCA9IFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkJlZm9yZU5vZGUocGxhY2Vob2xkZXIu Z2V0KCkpKTsKICAgICBtb3ZlUGFyYWdyYXBocyhzdGFydCwgZW5kLCBpbnNlcnRpb25Qb2ludCwg dHJ1ZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFw aFNlcGFyYXRvckNvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQYXJh Z3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcAppbmRleCBlZjU1NmI1YmY3ZDk1NzM0Yjg1MjJmYTU0 NjMyY2QzOTkyMTNhZjg5Li45MTQ4ZDNiZTI0YzU4ZGVjYjE2NDIwOGY5MDI3MjM3MmE2NGE0ZWE0 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFy YXRvckNvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdy YXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAKQEAgLTM1Niw3ICszNTYsNyBAQCB2b2lkIEluc2VydFBh cmFncmFwaFNlcGFyYXRvckNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICBpZiAoaW5zZXJ0aW9u UG9zaXRpb24uY29udGFpbmVyTm9kZSgpID09IHN0YXJ0QmxvY2spCiAgICAgICAgICAgICBuID0g aW5zZXJ0aW9uUG9zaXRpb24uY29tcHV0ZU5vZGVBZnRlclBvc2l0aW9uKCk7CiAgICAgICAgIGVs c2UgewotICAgICAgICAgICAgc3BsaXRUcmVlVG9Ob2RlKGluc2VydGlvblBvc2l0aW9uLmNvbnRh aW5lck5vZGUoKSwgc3RhcnRCbG9jayk7CisgICAgICAgICAgICBzcGxpdFRyZWUoaW5zZXJ0aW9u UG9zaXRpb24sIHN0YXJ0QmxvY2spOwogCiAgICAgICAgICAgICBmb3IgKG4gPSBzdGFydEJsb2Nr LT5maXJzdENoaWxkKCk7IG47IG4gPSBuLT5uZXh0U2libGluZygpKSB7CiAgICAgICAgICAgICAg ICAgaWYgKGNvbXBhcmVQb3NpdGlvbnMoVmlzaWJsZVBvc2l0aW9uKGluc2VydGlvblBvc2l0aW9u KSwgcG9zaXRpb25CZWZvcmVOb2RlKG4pKSA8PSAwKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZWRpdGluZy9SZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcAppbmRleCA2M2RjMzhjNDQ3NmQ1YjY4 OTI3YThjNGFkM2EyYWNiY2ZjZjcwNGU0Li5iYjNmY2UyYjdmMGM4YWQxZmRlYjRhMGRiMDUyNTUy ZDZmNWZjY2E4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxl Y3Rpb25Db21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxl Y3Rpb25Db21tYW5kLmNwcApAQCAtOTQ2LDcgKzk0Niw3IEBAIHZvaWQgUmVwbGFjZVNlbGVjdGlv bkNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICAvLyBGSVhNRTogaXNJbmxpbmVOb2RlV2l0aFN0 eWxlIGRvZXMgbm90IGNoZWNrIGVkaXRhYmlsaXR5LgogICAgICAgICBpZiAoUmVmUHRyPE5vZGU+ IG5vZGVUb1NwbGl0VG8gPSBoaWdoZXN0RW5jbG9zaW5nTm9kZU9mVHlwZShpbnNlcnRpb25Qb3Ms IGlzSW5saW5lTm9kZVdpdGhTdHlsZSkpIHsKICAgICAgICAgICAgIGlmIChpbnNlcnRpb25Qb3Mu Y29udGFpbmVyTm9kZSgpICE9IG5vZGVUb1NwbGl0VG8pIHsKLSAgICAgICAgICAgICAgICBub2Rl VG9TcGxpdFRvID0gc3BsaXRUcmVlVG9Ob2RlKGluc2VydGlvblBvcy5hbmNob3JOb2RlKCksIG5v ZGVUb1NwbGl0VG8uZ2V0KCksIHRydWUpLmdldCgpOworICAgICAgICAgICAgICAgIG5vZGVUb1Nw bGl0VG8gPSBzcGxpdFRyZWUoaW5zZXJ0aW9uUG9zLCBub2RlVG9TcGxpdFRvLmdldCgpLCBTcGxp dEVuZCkuZ2V0KCk7CiAgICAgICAgICAgICAgICAgaW5zZXJ0aW9uUG9zID0gcG9zaXRpb25JblBh cmVudEJlZm9yZU5vZGUobm9kZVRvU3BsaXRUby5nZXQoKSk7CiAgICAgICAgICAgICB9CiAgICAg ICAgIH0KQEAgLTEyNDgsMTAgKzEyNDgsNyBAQCBOb2RlKiBSZXBsYWNlU2VsZWN0aW9uQ29tbWFu ZDo6aW5zZXJ0QXNMaXN0SXRlbXMoUGFzc1JlZlB0cjxOb2RlPiBsaXN0RWxlbWVudCwgTgogICAg IC8vIElmIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2YgYSBsaXN0IGl0ZW0sIHdlIHNob3VsZCBzcGxp dCBpdCBpbnRvIHR3byBzZXBhcmF0ZQogICAgIC8vIGxpc3QgaXRlbXMgYW5kIGluc2VydCB0aGVz ZSBub2RlcyBiZXR3ZWVuIHRoZW0uCiAgICAgaWYgKGlzTWlkZGxlKSB7Ci0gICAgICAgIGludCB0 ZXh0Tm9kZU9mZnNldCA9IGluc2VydFBvcy5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKTsKLSAgICAg ICAgaWYgKGluc2VydFBvcy5kZXByZWNhdGVkTm9kZSgpLT5pc1RleHROb2RlKCkgJiYgdGV4dE5v ZGVPZmZzZXQgPiAwKQotICAgICAgICAgICAgc3BsaXRUZXh0Tm9kZShzdGF0aWNfY2FzdDxUZXh0 Kj4oaW5zZXJ0UG9zLmRlcHJlY2F0ZWROb2RlKCkpLCB0ZXh0Tm9kZU9mZnNldCk7Ci0gICAgICAg IHNwbGl0VHJlZVRvTm9kZShpbnNlcnRQb3MuZGVwcmVjYXRlZE5vZGUoKSwgbGFzdE5vZGUsIHRy dWUpOworICAgICAgICBzcGxpdFRyZWUoaW5zZXJ0UG9zLCBsYXN0Tm9kZSwgU3BsaXRFbmQpOwog ICAgIH0KIAogICAgIHdoaWxlIChSZWZQdHI8Tm9kZT4gbGlzdEl0ZW0gPSBsaXN0RWxlbWVudC0+ Zmlyc3RDaGlsZCgpKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxl ZGl0aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCmluZGV4 IDhjNDIyNTIyYWNkMjBkNTdhY2U0NjkxY2YyZDBlYTFhZTJkYWM5ZjYuLmNkNzI3ZWE5YzExODE5 ODQ5Mjc1ZDBhZDMxZGMwZGYyZmJkYzNmM2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVk aXRpbmcuY3BwCkBAIC0xODcsNyArMTg3LDcgQEAgRWxlbWVudCogZWRpdGFibGVSb290Rm9yUG9z aXRpb24oY29uc3QgUG9zaXRpb24mIHApCiAKIC8vIEZpbmRzIHRoZSBlbmNsb3NpbmcgZWxlbWVu dCB1bnRpbCB3aGljaCB0aGUgdHJlZSBjYW4gYmUgc3BsaXQuCiAvLyBXaGVuIGEgdXNlciBoaXRz IEVOVEVSLCBoZS9zaGUgd29uJ3QgZXhwZWN0IHRoaXMgZWxlbWVudCB0byBiZSBzcGxpdCBpbnRv IHR3by4KLS8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0 VHJlZVRvTm9kZS4KKy8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9m IHNwbGl0VHJlZS4KIEVsZW1lbnQqIHVuc3BsaXR0YWJsZUVsZW1lbnRGb3JQb3NpdGlvbihjb25z dCBQb3NpdGlvbiYgcCkKIHsKICAgICAvLyBTaW5jZSBlbmNsb3NpbmdOb2RlT2ZUeXBlIHdvbid0 IHNlYXJjaCBiZXlvbmQgdGhlIGhpZ2hlc3Qgcm9vdCBlZGl0YWJsZSBub2RlLAo= 98094 2011-06-21 18:24:31 -0700 2011-06-22 11:44:18 -0700 Patch bug-61594-20110621182430.patch text/plain 22016 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODkzOTMKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhMmU0ZmM4MzQ3ODAyOGFmMmQyNGVl ZGRkNWYzM2ZjMjhkNTk0MmI4Li5kZTVkZDFjMDI1ZTAyMzk5YmY4OGE0ZTIyMTE0MTY3N2U2MmFi MTg1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDYtMjEgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRlZCBuZXcgdGVzdHMgYW5kIHVwZGF0ZWQgcmVzdWx0cyBub3cgdGhhdCBl eHRyYSBlbXB0eSBsaXN0cyBhcmUgbm8gbG9uZ2VyIGJlaW5nIGdlbmVyYXRlZC4KKworICAgICAg ICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvNTc2MzA4Mi1leHBlY3RlZC50eHQ6IEdvdCByaWQgb2Yg ZW1wdHkgPHVsPiBub2RlLgorICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvb3V0ZGVudC1z ZWxlY3Rpb24tZXhwZWN0ZWQudHh0OiBFbXB0eSA8dWw+IG5vZGVzIG5vIGxvbmdlciBiZWluZyBj cmVhdGVkLgorICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJy LWluLXNwYW4tZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWw6IEFkZGVkIG5ldyB0ZXN0IGZyb20g dGVzdCBjYXNlIGluIGJ1Zy4KKyAgICAgICAgKiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5 LW1pZGRsZS1vZi1zcGFuLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9p bnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sOiBBZGRlZCBuZXcgdGVzdCB0 byBlbnN1cmUgcG9zaXRpb24gYXQgc3RhcnQgb2Ygc3BhbiBzdGlsbCB3b3Jrcy4KKwogMjAxMS0w Ni0yMSAgWmhlbnlhbyBNbyAgPHptb0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEtlbm5ldGggUnVzc2VsbC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0Nv bW1hbmQvNTc2MzA4Mi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21t YW5kLzU3NjMwODItZXhwZWN0ZWQudHh0CmluZGV4IDI2N2ViMjBhMTdkNWVhNGQxZmM1ODFkOTA4 NjI3YWQxYTMxOGM4YTUuLmQ5MzFiNTQ2MmIxYjg2NWQ4ZWI4MWMzOGYxMGNkNjIzMjZjY2RmN2Yg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvNTc2MzA4Mi1leHBl Y3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC81NzYzMDgyLWV4 cGVjdGVkLnR4dApAQCAtMyw0ICszLDMgQEAgb3JhbmdlCiBsZW1vbgogb3JhbmdlCiBsZW1vbgot CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL291dGRlbnQtc2Vs ZWN0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvb3V0 ZGVudC1zZWxlY3Rpb24tZXhwZWN0ZWQudHh0CmluZGV4IGEzYWJkYjE1ZDk2MzA0ZGM4ODllMjlj YjJhNWE3ZjdiMTg4Mzg0YjUuLjBhY2I1NTYyNjliYWQwZjI1YTFkODdjNzNlYjdjOTc2NmIwNDA0 NDIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvb3V0ZGVudC1z ZWxlY3Rpb24tZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1h bmQvb3V0ZGVudC1zZWxlY3Rpb24tZXhwZWN0ZWQudHh0CkBAIC0yNiwxOCArMjYsMTIgQEAgbW9y ZSBMb3JlbSEKIHwgICA8YnI+CiB8ICAgIkJheiIKIHwgICA8YnI+Ci18ICAgPHVsPgotfCAgICAg IgotIgogfCAiRG9sb3IiCiB8IDxicj4KIHwgIgogIgogfCAiRGlubmVyIHRpbWU/IgogfCA8YnI+ Ci18IDx1bD4KLXwgICAiCi0iCiB8ICIKIFN1bSEiCiB8IDxicj4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4tZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZv cmUtYnItaW4tc3Bhbi1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2Y0NjJmNDk5MWM2NWUxOTEx NWM2YzY5OTM1NTVmYzFhNGU1MzRkMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Vk aXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4tZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBlbmQgb2Yg dGhlIGZpcnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuCitFeHBlY3RlZCBiZWhhdmlv cjogYSBkaXYgaXMgY3JlYXRlZCBhcm91bmQgdGhlIHNlY29uZCBsaW5lLCBhbmQgdGhlIGN1cnNv ciBpcyBwbGFjZWQgYXQgdGhlIHN0YXJ0IG9mIHRoZSBzZWNvbmQgbGluZS4gU2VlIGJ1ZyA2MTU5 NC4KK3wgPHNwYW4+Cit8ICAgaWQ9IndyYXBwZXIiCit8ICAgIkZpcnN0IGxpbmUiCit8IDxkaXY+ Cit8ICAgPHNwYW4+Cit8ICAgICA8I3NlbGVjdGlvbi1jYXJldD4KK3wgICAgIDxicj4KK3wgICAg ICJTZWNvbmQgbGluZSIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5n L3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcv aW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5l MzVkYTcwZDkxMjA3MzJjYjY3NWQwZWMxZTEzODc5OTI0NWJmMmNkCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4t c3Bhbi5odG1sCkBAIC0wLDAgKzEsMTYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9k eT4KKzxkaXYgY29udGVudGVkaXRhYmxlIGlkPSJyb290Ij48c3BhbiBpZD0id3JhcHBlciI+Rmly c3QgbGluZTxicj5TZWNvbmQgbGluZTwvc3Bhbj48L2Rpdj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9y ZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK01hcmt1cC5k ZXNjcmlwdGlvbigiVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIGVuZCBvZiB0aGUgZmly c3QgbGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS5cbiIKKyAgICArICJFeHBlY3RlZCBiZWhh dmlvcjogYSBkaXYgaXMgY3JlYXRlZCBhcm91bmQgdGhlIHNlY29uZCBsaW5lLCBhbmQgdGhlIGN1 cnNvciBpcyBwbGFjZWQgYXQgdGhlICIKKyAgICArICJzdGFydCBvZiB0aGUgc2Vjb25kIGxpbmUu IFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2Vs LnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIiksIDEpOworZG9j dW1lbnQuZXhlY0NvbW1hbmQoIkluc2VydFBhcmFncmFwaCIsIGZhbHNlLCBudWxsKTsKK01hcmt1 cC5kdW1wKHJvb3QpOworCis8L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Yt c3Bhbi1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDJjOTZkMTBkOTlhZjBiYTMyZmZlNjM4NmJj M2I5NDBjMjk5NDc1YgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5z ZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4tZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEs MTAgQEAKK1RoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBtaWRkbGUgb2YgdGhlIGZpcnN0 IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuCitFeHBlY3RlZCBiZWhhdmlvcjogdGhlIHRl eHQgbm9kZSBpcyBzcGxpdCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQsIGFuZCBl dmVyeXRoaW5nIHRoYXQgd2FzIHNwbGl0IG91dCBpcyBwbGFjZWQgaW5zaWRlIHRoZSBjbG9uZSBp biBhIG5ldyBkaXYgd2hpY2ggaXMgYSBjaGlsZCBvZiB0aGUgcm9vdC4gU2VlIGJ1ZyA2MTU5NC4K K3wgPHNwYW4+Cit8ICAgaWQ9IndyYXBwZXIiCit8ICAgIkZpcnN0IgorfCA8ZGl2PgorfCAgIDxz cGFuPgorfCAgICAgIjwjc2VsZWN0aW9uLWNhcmV0PsKgbGluZSIKK3wgICAgIDxicj4KK3wgICAg ICJTZWNvbmQgbGluZSIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5n L3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4uaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5z ZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4uaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iZWE4ODdh Y2FhNGQzNzE2NDMxY2FmOWQ2ODdiNzgzMjM0MzNiMjA3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1s CkBAIC0wLDAgKzEsMTUgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxkaXYg Y29udGVudGVkaXRhYmxlIGlkPSJyb290Ij48c3BhbiBpZD0id3JhcHBlciI+Rmlyc3QgbGluZTxi cj5TZWNvbmQgbGluZTwvc3Bhbj48L2Rpdj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMv ZHVtcC1hcy1tYXJrdXAuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK01hcmt1cC5kZXNjcmlwdGlv bigiVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmlyc3QgbGlu ZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS5cbiIKKyAgICArICJFeHBlY3RlZCBiZWhhdmlvcjog dGhlIHRleHQgbm9kZSBpcyBzcGxpdCBhdCB0aGUgY3Vyc29yLiBUaGUgc3BhbiBpcyBjbG9uZWQs IGFuZCBldmVyeXRoaW5nICIKKyAgICArICJ0aGF0IHdhcyBzcGxpdCBvdXQgaXMgcGxhY2VkIGlu c2lkZSB0aGUgY2xvbmUgaW4gYSBuZXcgZGl2IHdoaWNoIGlzIGEgY2hpbGQgb2YgdGhlIHJvb3Qu IFNlZSBidWcgNjE1OTQuIik7Cit2YXIgc2VsID0gd2luZG93LmdldFNlbGVjdGlvbigpOworc2Vs LnNldFBvc2l0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ3cmFwcGVyIikuZmlyc3RDaGls ZCwgNSk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgiSW5zZXJ0UGFyYWdyYXBoIiwgZmFsc2UsIG51 bGwpOworTWFya3VwLmR1bXAocm9vdCk7Cis8L3NjcmlwdD4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRl eCAwNmZiNmIxN2VjNGZlZTZjNDZlOGI0MzM2N2NmZDFmMTk4ZmE4NmZlLi5lYmNlYmYxZWM4MDZj YWI4Yjg1Njg2MjdlMjNlYmRlMWUyYjc1MmMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzcgQEAK KzIwMTEtMDYtMjEgIEFubmllIFN1bGxpdmFuICA8c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJFR1JFU1NJT046 IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBvZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJz b3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3BhbgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQKKworICAgICAgICBSZW5hbWVkIHNwbGl0VHJl ZVRvTm9kZSB0byBzcGxpdFRyZWUgYW5kIG1hZGUgaXQgdGFrZSBhIHBvc2l0aW9uIGluc3RlYWQg b2YgYSBub2RlLgorICAgICAgICBSZWZhY3RvcmVkIGNhbGxlcnMgdG8gbWFrZSB1c2Ugb2Ygc3Bs aXRUcmVlKCkgaW5zdGVhZC4gU29tZSBjYWxsc2l0ZXMgY291bGQgYmUgc2ltcGxpZmllZC4KKwor ICAgICAgICBUZXN0czogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4t c3Bhbi5odG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1p ZGRsZS1vZi1zcGFuLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1h bmQuY3BwOiAKKyAgICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21tYW5kOjpzcGxpdFRy ZWUpOiBJbXBsZW1lbnQgbmV3IGZ1bmN0aW9uIHdoaWNoIHJlcGxhY2VzIHNwbGl0VHJlZVRvTm9k ZSgpLCBidXQgcGlja3MKKyAgICAgICAgICAgIHN0YXJ0IG5vZGUgYmFzZWQgb24gcG9zaXRpb24g c28gdGhhdCB0ZXh0IG5vZGVzIGFyZSBzcGxpdCBjb3JyZWN0bHkuCisgICAgICAgICogZWRpdGlu Zy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oOgorICAgICAgICAqIGVkaXRpbmcvRm9ybWF0QmxvY2tD b21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZvcm1hdEJsb2NrQ29tbWFuZDo6Zm9ybWF0 UmFuZ2UpOiBDYWxsIG5ldyBzcGxpdFRyZWUoKSBtZXRob2QuCisgICAgICAgICogZWRpdGluZy9J bmRlbnRPdXRkZW50Q29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbmRlbnRPdXRkZW50 Q29tbWFuZDo6aW5kZW50SW50b0Jsb2NrcXVvdGUpOiBDYWxsIG5ldyBzcGxpdFRyZWUoKSBtZXRo b2QuCisgICAgICAgIChXZWJDb3JlOjpJbmRlbnRPdXRkZW50Q29tbWFuZDo6b3V0ZGVudFBhcmFn cmFwaCk6IFVzZSBub24tZGVwcmVjYXRlZCBjb250YWluZXJOb2RlKCksIGNhbGwgbmV3IHNwbGl0 VHJlZSgpIG1ldGhvZC4KKyAgICAgICAgKiBlZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6Okluc2VydExpc3RDb21tYW5kOjpkb0FwcGx5Rm9yU2luZ2xlUGFy YWdyYXBoKTogVXNlIG5vbi1kZXByZWNhdGVkIGNvbnRhaW5lck5vZGUoKS4KKyAgICAgICAgKFdl YkNvcmU6Okluc2VydExpc3RDb21tYW5kOjp1bmxpc3RpZnlQYXJhZ3JhcGgpOiBSZWZhY3RvcmVk IHRvIGNhbGwgc3BsaXRUcmVlKCksIHJlZHVjaW5nIHRoZSBuZWVkIGZvciBsb2dpYworICAgICAg ICAgICAgYXJvdW5kIHdoZXJlIHRvIHNwbGl0LgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0UGFy YWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRQYXJh Z3JhcGhTZXBhcmF0b3JDb21tYW5kOjpkb0FwcGx5KTogQ2FsbCBuZXcgc3BsaXRUcmVlKCkgbWV0 aG9kLgorICAgICAgICAqIGVkaXRpbmcvUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6UmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQ6OmRvQXBwbHkpOiBDYWxsIG5l dyBzcGxpdFRyZWUoKSBtZXRob2QuCisgICAgICAgIChXZWJDb3JlOjpSZXBsYWNlU2VsZWN0aW9u Q29tbWFuZDo6aW5zZXJ0QXNMaXN0SXRlbXMpOiBSZWZhY3RvcmVkIHRvIGNhbGwgc3BsaXRUcmVl KCksIHdoaWNoIGF1dG9tYXRpY2FsbHkgc3BsaXRzCisgICAgICAgICAgICB0ZXh0IG5vZGUgaW4g dGhlIHJpZ2h0IHBsYWNlLgorICAgICAgICAqIGVkaXRpbmcvaHRtbGVkaXRpbmcuY3BwOiBVcGRh dGVkIGNvbW1lbnRzIHdpdGggbmV3IGZ1bmN0aW9uIG5hbWUKKwogMjAxMS0wNi0yMSAgWmhlbnlh byBNbyAgPHptb0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUnVz c2VsbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENv bW1hbmQuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5j cHAKaW5kZXggMzIxNTFhZjRkNWZhNGM0NWNiNWEwNmMzMmFlMmIwY2U2Yjk4NDNhYy4uOWNhNDEw YzY5ZDgzM2MwY2M5ZmEzZWFkZmE5ZTY2ZTI5ZjMzNGI1OSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKQEAgLTQ0LDYgKzQ0LDcgQEAKICNp bmNsdWRlICJJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmgiCiAjaW5jbHVkZSAiSW5z ZXJ0VGV4dENvbW1hbmQuaCIKICNpbmNsdWRlICJNZXJnZUlkZW50aWNhbEVsZW1lbnRzQ29tbWFu ZC5oIgorI2luY2x1ZGUgIk5vZGVMaXN0LmgiCiAjaW5jbHVkZSAiUmFuZ2UuaCIKICNpbmNsdWRl ICJSZW1vdmVDU1NQcm9wZXJ0eUNvbW1hbmQuaCIKICNpbmNsdWRlICJSZW1vdmVOb2RlQ29tbWFu ZC5oIgpAQCAtMTIzMCwyMCArMTIzMSwyOSBAQCBQb3NpdGlvbiBDb21wb3NpdGVFZGl0Q29tbWFu ZDo6cG9zaXRpb25Bdm9pZGluZ1NwZWNpYWxFbGVtZW50Qm91bmRhcnkoY29uc3QgUG9zaQogICAg IHJldHVybiByZXN1bHQ7CiB9CiAKLS8vIFNwbGl0cyB0aGUgdHJlZSBwYXJlbnQgYnkgcGFyZW50 IHVudGlsIHdlIHJlYWNoIHRoZSBzcGVjaWZpZWQgYW5jZXN0b3IuIFdlIHVzZSBWaXNpYmxlUG9z aXRpb25zCi0vLyB0byBkZXRlcm1pbmUgaWYgdGhlIHNwbGl0IGlzIG5lY2Vzc2FyeS4gUmV0dXJu cyB0aGUgbGFzdCBzcGxpdCBub2RlLgotUGFzc1JlZlB0cjxOb2RlPiBDb21wb3NpdGVFZGl0Q29t bWFuZDo6c3BsaXRUcmVlVG9Ob2RlKE5vZGUqIHN0YXJ0LCBOb2RlKiBlbmQsIGJvb2wgc2hvdWxk U3BsaXRBbmNlc3RvcikKK1Bhc3NSZWZQdHI8Tm9kZT4gQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnNw bGl0VHJlZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIE5vZGUqIGVuZCwgQW5jZXN0b3JTcGxpdFJ1 bGUgc3BsaXRSdWxlKQogewotICAgIEFTU0VSVChzdGFydCk7CiAgICAgQVNTRVJUKGVuZCk7Ci0g ICAgQVNTRVJUKHN0YXJ0ICE9IGVuZCk7CisgICAgQVNTRVJUKHN0YXJ0LmNvbnRhaW5lck5vZGUo KSk7CisgICAgQVNTRVJUKHN0YXJ0LmNvbnRhaW5lck5vZGUoKSAhPSBlbmQpOwogCi0gICAgUmVm UHRyPE5vZGU+IG5vZGU7Ci0gICAgaWYgKHNob3VsZFNwbGl0QW5jZXN0b3IgJiYgZW5kLT5wYXJl bnROb2RlKCkpCisgICAgaWYgKHNwbGl0UnVsZSA9PSBTcGxpdEVuZCAmJiBlbmQtPnBhcmVudE5v ZGUoKSkKICAgICAgICAgZW5kID0gZW5kLT5wYXJlbnROb2RlKCk7Ci0KICAgICBSZWZQdHI8Tm9k ZT4gZW5kTm9kZSA9IGVuZDsKLSAgICBmb3IgKG5vZGUgPSBzdGFydDsgbm9kZSAmJiBub2RlLT5w YXJlbnROb2RlKCkgIT0gZW5kTm9kZTsgbm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKSkgeworCisg ICAgTm9kZSogc3RhcnROb2RlID0gc3RhcnQuY29udGFpbmVyTm9kZSgpOworICAgIGlmIChzdGFy dE5vZGUtPmlzVGV4dE5vZGUoKSkgeworICAgICAgICAvLyBGSVhNRTogc3RhcnROb2RlIGNhbiBi ZSBudWxsIGlmIHRyYXZlcnNlTmV4dE5vZGUgcmV0dXJucyBudWxsLiBXaGF0IHNob3VsZCBpdCBi ZSBzZXQgdG8gaW4gdGhhdCBjYXNlPworICAgICAgICBpZiAoc3RhcnQub2Zmc2V0SW5Db250YWlu ZXJOb2RlKCkgPj0gY2FyZXRNYXhPZmZzZXQoc3RhcnQuY29udGFpbmVyTm9kZSgpKSkgeworICAg ICAgICAgICAgc3RhcnROb2RlID0gc3RhcnROb2RlLT50cmF2ZXJzZU5leHROb2RlKGVuZCk7Cisg ICAgICAgICAgICBpZiAoIXN0YXJ0Tm9kZSkKKyAgICAgICAgICAgICAgcmV0dXJuIHN0YXJ0LmNv bnRhaW5lck5vZGUoKTsKKyAgICAgICAgfSBlbHNlIGlmIChzdGFydC5vZmZzZXRJbkNvbnRhaW5l ck5vZGUoKSA+IGNhcmV0TWluT2Zmc2V0KHN0YXJ0LmNvbnRhaW5lck5vZGUoKSkpCisgICAgICAg ICAgICBzcGxpdFRleHROb2RlKHN0YXRpY19jYXN0PFRleHQqPihzdGFydC5jb250YWluZXJOb2Rl KCkpLCBzdGFydC5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSk7CisgICAgfQorCisgICAgUmVmUHRy PE5vZGU+IG5vZGU7CisgICAgZm9yIChub2RlID0gc3RhcnROb2RlOyBub2RlICYmIG5vZGUtPnBh cmVudE5vZGUoKSAhPSBlbmROb2RlOyBub2RlID0gbm9kZS0+cGFyZW50Tm9kZSgpKSB7CiAgICAg ICAgIGlmICghbm9kZS0+cGFyZW50Tm9kZSgpLT5pc0VsZW1lbnROb2RlKCkpCiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgLy8gRG8gbm90IHNwbGl0IGEgbm9kZSB3aGVuIGRvaW5nIHNvIGlu dHJvZHVjZXMgYW4gZW1wdHkgbm9kZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9z aXRlRWRpdENvbW1hbmQuaAppbmRleCA0ZjIyYTA2ZjI5ZDlhZGNiMmNlYTVlNzg4ZmJiMTZiMDg1 Zjk3MDllLi40NDhmNjY2MGMwYjVlMzcwMjk3MWU4NmYwNzU1Y2Y4ZmJkNzU2NzEyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmgKKysrIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBAIC0xMTYsNyAr MTE2LDggQEAgcHJvdGVjdGVkOgogICAgIAogICAgIFBvc2l0aW9uIHBvc2l0aW9uQXZvaWRpbmdT cGVjaWFsRWxlbWVudEJvdW5kYXJ5KGNvbnN0IFBvc2l0aW9uJik7CiAgICAgCi0gICAgUGFzc1Jl ZlB0cjxOb2RlPiBzcGxpdFRyZWVUb05vZGUoTm9kZSosIE5vZGUqLCBib29sIHNwbGl0QW5jZXN0 b3IgPSBmYWxzZSk7CisgICAgZW51bSBBbmNlc3RvclNwbGl0UnVsZSB7IERvTm90U3BsaXRFbmQs IFNwbGl0RW5kIH07CisgICAgUGFzc1JlZlB0cjxOb2RlPiBzcGxpdFRyZWUoY29uc3QgUG9zaXRp b24mLCBOb2RlKiwgQW5jZXN0b3JTcGxpdFJ1bGUgPSBEb05vdFNwbGl0RW5kKTsKIAogICAgIFZl Y3RvcjxSZWZQdHI8RWRpdENvbW1hbmQ+ID4gbV9jb21tYW5kczsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwCmluZGV4IDc1OWNhMzE3MWU5NmViYjg3 MWU3ZWI2NzNhYTQxNTY0YWE1YzQ5NGUuLmMwMTVhZGYzOWZkNGY2OTJhMTEwZmRlNzYzMWExZTQ0 MzQzMzA3ODYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tD b21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFu ZC5jcHAKQEAgLTYxLDcgKzYxLDcgQEAgdm9pZCBGb3JtYXRCbG9ja0NvbW1hbmQ6OmZvcm1hdFNl bGVjdGlvbihjb25zdCBWaXNpYmxlUG9zaXRpb24mIHN0YXJ0T2ZTZWxlY3Rpb24KIHZvaWQgRm9y bWF0QmxvY2tDb21tYW5kOjpmb3JtYXRSYW5nZShjb25zdCBQb3NpdGlvbiYgc3RhcnQsIGNvbnN0 IFBvc2l0aW9uJiBlbmQsIGNvbnN0IFBvc2l0aW9uJiBlbmRPZlNlbGVjdGlvbiwgUmVmUHRyPEVs ZW1lbnQ+JiBibG9ja05vZGUpCiB7CiAgICAgTm9kZSogbm9kZVRvU3BsaXRUbyA9IGVuY2xvc2lu Z0Jsb2NrVG9TcGxpdFRyZWVUbyhzdGFydC5kZXByZWNhdGVkTm9kZSgpKTsKLSAgICBSZWZQdHI8 Tm9kZT4gb3V0ZXJCbG9jayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0 VG8pID8gc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZVRvTm9kZShzdGFydC5kZXBy ZWNhdGVkTm9kZSgpLCBub2RlVG9TcGxpdFRvKTsKKyAgICBSZWZQdHI8Tm9kZT4gb3V0ZXJCbG9j ayA9IChzdGFydC5kZXByZWNhdGVkTm9kZSgpID09IG5vZGVUb1NwbGl0VG8pID8gc3RhcnQuZGVw cmVjYXRlZE5vZGUoKSA6IHNwbGl0VHJlZShmaXJzdFBvc2l0aW9uSW5Ob2RlKHN0YXJ0LmRlcHJl Y2F0ZWROb2RlKCkpLCBub2RlVG9TcGxpdFRvKTsKICAgICBSZWZQdHI8Tm9kZT4gbm9kZUFmdGVy SW5zZXJ0aW9uUG9zaXRpb24gPSBvdXRlckJsb2NrOwogCiAgICAgUmVmUHRyPFJhbmdlPiByYW5n ZSA9IFJhbmdlOjpjcmVhdGUoZG9jdW1lbnQoKSwgc3RhcnQsIGVuZE9mU2VsZWN0aW9uKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3Bw IGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKaW5kZXgg N2VkNGMwY2RiNmVjODY3Yzg1OWNkNjVmZDExMTk3ZWVkNzk1MzU1MS4uY2FlMmM2NDhiYzZlZjkw NTczM2RmMzhmMzUzMzJjOTQzYjlhYmUyNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKQEAgLTEwMyw3ICsxMDMsNyBAQCB2b2lkIEluZGVu dE91dGRlbnRDb21tYW5kOjppbmRlbnRJbnRvQmxvY2txdW90ZShjb25zdCBQb3NpdGlvbiYgc3Rh cnQsIGNvbnN0IFBvcwogICAgIGlmICghbm9kZVRvU3BsaXRUbykKICAgICAgICAgcmV0dXJuOwog Ci0gICAgUmVmUHRyPE5vZGU+IG91dGVyQmxvY2sgPSAoc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA9 PSBub2RlVG9TcGxpdFRvKSA/IHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkgOiBzcGxpdFRyZWVUb05v ZGUoc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSwgbm9kZVRvU3BsaXRUbyk7CisgICAgUmVmUHRyPE5v ZGU+IG91dGVyQmxvY2sgPSAoc3RhcnQuZGVwcmVjYXRlZE5vZGUoKSA9PSBub2RlVG9TcGxpdFRv KSA/IHN0YXJ0LmRlcHJlY2F0ZWROb2RlKCkgOiBzcGxpdFRyZWUoZmlyc3RQb3NpdGlvbkluTm9k ZShzdGFydC5kZXByZWNhdGVkTm9kZSgpKSwgbm9kZVRvU3BsaXRUbyk7CiAKICAgICBpZiAoIXRh cmdldEJsb2NrcXVvdGUpIHsKICAgICAgICAgLy8gQ3JlYXRlIGEgbmV3IGJsb2NrcXVvdGUgYW5k IGluc2VydCBpdCBhcyBhIGNoaWxkIG9mIHRoZSByb290IGVkaXRhYmxlIGVsZW1lbnQuIFdlIGFj Y29tcGxpc2gKQEAgLTE2NywxMCArMTY3LDEwIEBAIHZvaWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6 Om91dGRlbnRQYXJhZ3JhcGgoKQogCiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgTm9kZSog ZW5jbG9zaW5nQmxvY2tGbG93ID0gZW5jbG9zaW5nQmxvY2sodmlzaWJsZVN0YXJ0T2ZQYXJhZ3Jh cGguZGVlcEVxdWl2YWxlbnQoKS5kZXByZWNhdGVkTm9kZSgpKTsKKyAgICBOb2RlKiBlbmNsb3Np bmdCbG9ja0Zsb3cgPSBlbmNsb3NpbmdCbG9jayh2aXNpYmxlU3RhcnRPZlBhcmFncmFwaC5kZWVw RXF1aXZhbGVudCgpLmNvbnRhaW5lck5vZGUoKSk7CiAgICAgUmVmUHRyPE5vZGU+IHNwbGl0Qmxv Y2txdW90ZU5vZGUgPSBlbmNsb3NpbmdOb2RlOwogICAgIGlmIChlbmNsb3NpbmdCbG9ja0Zsb3cg IT0gZW5jbG9zaW5nTm9kZSkKLSAgICAgICAgc3BsaXRCbG9ja3F1b3RlTm9kZSA9IHNwbGl0VHJl ZVRvTm9kZShlbmNsb3NpbmdCbG9ja0Zsb3csIGVuY2xvc2luZ05vZGUsIHRydWUpOworICAgICAg ICBzcGxpdEJsb2NrcXVvdGVOb2RlID0gc3BsaXRUcmVlKGZpcnN0UG9zaXRpb25Jbk5vZGUoZW5j bG9zaW5nQmxvY2tGbG93KSwgZW5jbG9zaW5nTm9kZSwgU3BsaXRFbmQpOwogICAgIGVsc2Ugewog ICAgICAgICAvLyBXZSBzcGxpdCB0aGUgYmxvY2txdW90ZSBhdCB3aGVyZSB3ZSBzdGFydCBvdXRk ZW50aW5nLgogICAgICAgICBzcGxpdEVsZW1lbnQoc3RhdGljX2Nhc3Q8RWxlbWVudCo+KGVuY2xv c2luZ05vZGUpLCB2aXNpYmxlU3RhcnRPZlBhcmFncmFwaC5kZWVwRXF1aXZhbGVudCgpLmRlcHJl Y2F0ZWROb2RlKCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRM aXN0Q29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5k LmNwcAppbmRleCA0NTg1YjJlODg2NzVkMWVkNTY4ZDg2MWY4NTM3MjUwYWU5OTcxOTBkLi42YmE2 ZTg4ZmJmMTg2MTRiZGI0YWZiMGJiNDFmOWQ0N2I2ODYxNjA3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNwcApAQCAtMTkxLDcgKzE5MSw3IEBAIHZvaWQg SW5zZXJ0TGlzdENvbW1hbmQ6OmRvQXBwbHlGb3JTaW5nbGVQYXJhZ3JhcGgoYm9vbCBmb3JjZUNy ZWF0ZUxpc3QsIGNvbnN0IFF1CiAgICAgLy8gRklYTUU6IFRoaXMgd2lsbCBwcm9kdWNlIHVuZXhw ZWN0ZWQgcmVzdWx0cyBmb3IgYSBzZWxlY3Rpb24gdGhhdCBzdGFydHMganVzdCBiZWZvcmUgYQog ICAgIC8vIHRhYmxlIGFuZCBlbmRzIGluc2lkZSB0aGUgZmlyc3QgY2VsbCwgc2VsZWN0aW9uRm9y UGFyYWdyYXBoSXRlcmF0aW9uIHNob3VsZCBwcm9iYWJseQogICAgIC8vIGJlIHJlbmFtZWQgYW5k IGRlcGxveWVkIGluc2lkZSBzZXRFbmRpbmdTZWxlY3Rpb24oKS4KLSAgICBOb2RlKiBzZWxlY3Rp b25Ob2RlID0gZW5kaW5nU2VsZWN0aW9uKCkuc3RhcnQoKS5kZXByZWNhdGVkTm9kZSgpOworICAg IE5vZGUqIHNlbGVjdGlvbk5vZGUgPSBlbmRpbmdTZWxlY3Rpb24oKS5zdGFydCgpLmNvbnRhaW5l ck5vZGUoKTsKICAgICBOb2RlKiBsaXN0Q2hpbGROb2RlID0gZW5jbG9zaW5nTGlzdENoaWxkKHNl bGVjdGlvbk5vZGUpOwogICAgIGJvb2wgc3dpdGNoTGlzdFR5cGUgPSBmYWxzZTsKICAgICBpZiAo bGlzdENoaWxkTm9kZSkgewpAQCAtMjUyLDIzICsyNTIsMTUgQEAgdm9pZCBJbnNlcnRMaXN0Q29t bWFuZDo6ZG9BcHBseUZvclNpbmdsZVBhcmFncmFwaChib29sIGZvcmNlQ3JlYXRlTGlzdCwgY29u c3QgUXUKIAogdm9pZCBJbnNlcnRMaXN0Q29tbWFuZDo6dW5saXN0aWZ5UGFyYWdyYXBoKGNvbnN0 IFZpc2libGVQb3NpdGlvbiYgb3JpZ2luYWxTdGFydCwgSFRNTEVsZW1lbnQqIGxpc3ROb2RlLCBO b2RlKiBsaXN0Q2hpbGROb2RlKQogewotICAgIE5vZGUqIG5leHRMaXN0Q2hpbGQ7Ci0gICAgTm9k ZSogcHJldmlvdXNMaXN0Q2hpbGQ7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHN0YXJ0OwogICAgIFZp c2libGVQb3NpdGlvbiBlbmQ7CiAgICAgaWYgKGxpc3RDaGlsZE5vZGUtPmhhc1RhZ05hbWUobGlU YWcpKSB7CiAgICAgICAgIHN0YXJ0ID0gZmlyc3RQb3NpdGlvbkluTm9kZShsaXN0Q2hpbGROb2Rl KTsKICAgICAgICAgZW5kID0gbGFzdFBvc2l0aW9uSW5Ob2RlKGxpc3RDaGlsZE5vZGUpOwotICAg ICAgICBuZXh0TGlzdENoaWxkID0gbGlzdENoaWxkTm9kZS0+bmV4dFNpYmxpbmcoKTsKLSAgICAg ICAgcHJldmlvdXNMaXN0Q2hpbGQgPSBsaXN0Q2hpbGROb2RlLT5wcmV2aW91c1NpYmxpbmcoKTsK ICAgICB9IGVsc2UgewogICAgICAgICAvLyBBIHBhcmFncmFwaCBpcyB2aXN1YWxseSBhIGxpc3Qg aXRlbSBtaW51cyBhIGxpc3QgbWFya2VyLiAgVGhlIHBhcmFncmFwaCB3aWxsIGJlIG1vdmVkLgog ICAgICAgICBzdGFydCA9IHN0YXJ0T2ZQYXJhZ3JhcGgob3JpZ2luYWxTdGFydCwgQ2FuU2tpcE92 ZXJFZGl0aW5nQm91bmRhcnkpOwogICAgICAgICBlbmQgPSBlbmRPZlBhcmFncmFwaChzdGFydCwg Q2FuU2tpcE92ZXJFZGl0aW5nQm91bmRhcnkpOwotICAgICAgICBuZXh0TGlzdENoaWxkID0gZW5j bG9zaW5nTGlzdENoaWxkKGVuZC5uZXh0KCkuZGVlcEVxdWl2YWxlbnQoKS5kZXByZWNhdGVkTm9k ZSgpLCBsaXN0Tm9kZSk7Ci0gICAgICAgIEFTU0VSVChuZXh0TGlzdENoaWxkICE9IGxpc3RDaGls ZE5vZGUpOwotICAgICAgICBwcmV2aW91c0xpc3RDaGlsZCA9IGVuY2xvc2luZ0xpc3RDaGlsZChz dGFydC5wcmV2aW91cygpLmRlZXBFcXVpdmFsZW50KCkuZGVwcmVjYXRlZE5vZGUoKSwgbGlzdE5v ZGUpOwotICAgICAgICBBU1NFUlQocHJldmlvdXNMaXN0Q2hpbGQgIT0gbGlzdENoaWxkTm9kZSk7 CiAgICAgfQogICAgIC8vIFdoZW4gcmVtb3ZpbmcgYSBsaXN0LCB3ZSBtdXN0IGFsd2F5cyBjcmVh dGUgYSBwbGFjZWhvbGRlciB0byBhY3QgYXMgYSBwb2ludCBvZiBpbnNlcnRpb24KICAgICAvLyBm b3IgdGhlIGxpc3QgY29udGVudCBiZWluZyByZW1vdmVkLgpAQCAtMjgxLDI2ICsyNzMsMTUgQEAg dm9pZCBJbnNlcnRMaXN0Q29tbWFuZDo6dW5saXN0aWZ5UGFyYWdyYXBoKGNvbnN0IFZpc2libGVQ b3NpdGlvbiYgb3JpZ2luYWxTdGFydCwKICAgICAgICAgYXBwZW5kTm9kZShwbGFjZWhvbGRlciwg bm9kZVRvSW5zZXJ0KTsKICAgICB9CiAKLSAgICBpZiAobmV4dExpc3RDaGlsZCAmJiBwcmV2aW91 c0xpc3RDaGlsZCkgewotICAgICAgICAvLyBXZSB3YW50IHRvIHB1bGwgbGlzdENoaWxkTm9kZSBv dXQgb2YgbGlzdE5vZGUsIGFuZCBwbGFjZSBpdCBiZWZvcmUgbmV4dExpc3RDaGlsZCAKLSAgICAg ICAgLy8gYW5kIGFmdGVyIHByZXZpb3VzTGlzdENoaWxkLCBzbyB3ZSBzcGxpdCBsaXN0Tm9kZSBh bmQgaW5zZXJ0IGl0IGJldHdlZW4gdGhlIHR3byBsaXN0cy4gIAotICAgICAgICAvLyBCdXQgdG8g c3BsaXQgbGlzdE5vZGUsIHdlIG11c3QgZmlyc3Qgc3BsaXQgYW5jZXN0b3JzIG9mIGxpc3RDaGls ZE5vZGUgYmV0d2VlbiBpdCBhbmQgbGlzdE5vZGUsCi0gICAgICAgIC8vIGlmIGFueSBleGlzdC4K LSAgICAgICAgLy8gRklYTUU6IFdlIGFwcGVhciB0byBzcGxpdCBhdCBuZXh0TGlzdENoaWxkIGFz IG9wcG9zZWQgdG8gbGlzdENoaWxkTm9kZSBzbyB0aGF0IHdoZW4gd2UgcmVtb3ZlCi0gICAgICAg IC8vIGxpc3RDaGlsZE5vZGUgYmVsb3cgaW4gbW92ZVBhcmFncmFwaHMsIHByZXZpb3VzTGlzdENo aWxkIHdpbGwgYmUgcmVtb3ZlZCBhbG9uZyB3aXRoIGl0IGlmIGl0IGlzIAotICAgICAgICAvLyB1 bnJlbmRlcmVkLiBCdXQgd2Ugb3VnaHQgdG8gcmVtb3ZlIG5leHRMaXN0Q2hpbGQgdG9vLCBpZiBp dCBpcyB1bnJlbmRlcmVkLgotICAgICAgICBzcGxpdEVsZW1lbnQobGlzdE5vZGUsIHNwbGl0VHJl ZVRvTm9kZShuZXh0TGlzdENoaWxkLCBsaXN0Tm9kZSkpOwotICAgICAgICBpbnNlcnROb2RlQmVm b3JlKG5vZGVUb0luc2VydCwgbGlzdE5vZGUpOwotICAgIH0gZWxzZSBpZiAobmV4dExpc3RDaGls ZCB8fCBsaXN0Q2hpbGROb2RlLT5wYXJlbnROb2RlKCkgIT0gbGlzdE5vZGUpIHsKLSAgICAgICAg Ly8gSnVzdCBiZWNhdXNlIGxpc3RDaGlsZE5vZGUgaGFzIG5vIHByZXZpb3VzTGlzdENoaWxkIGRv ZXNuJ3QgbWVhbiB0aGVyZSBpc24ndCBhbnkgY29udGVudAotICAgICAgICAvLyBpbiBsaXN0Tm9k ZSB0aGF0IGNvbWVzIGJlZm9yZSBsaXN0Q2hpbGROb2RlLCBhcyBsaXN0Q2hpbGROb2RlIGNvdWxk IGhhdmUgYW5jZXN0b3JzCi0gICAgICAgIC8vIGJldHdlZW4gaXQgYW5kIGxpc3ROb2RlLiBTbywg d2Ugc3BsaXQgdXAgdG8gbGlzdE5vZGUgYmVmb3JlIGluc2VydGluZyB0aGUgcGxhY2Vob2xkZXIK LSAgICAgICAgLy8gd2hlcmUgd2UncmUgYWJvdXQgdG8gbW92ZSBsaXN0Q2hpbGROb2RlIHRvLgot ICAgICAgICBpZiAobGlzdENoaWxkTm9kZS0+cGFyZW50Tm9kZSgpICE9IGxpc3ROb2RlKQotICAg ICAgICAgICAgc3BsaXRFbGVtZW50KGxpc3ROb2RlLCBzcGxpdFRyZWVUb05vZGUobGlzdENoaWxk Tm9kZSwgbGlzdE5vZGUpLmdldCgpKTsKLSAgICAgICAgaW5zZXJ0Tm9kZUJlZm9yZShub2RlVG9J bnNlcnQsIGxpc3ROb2RlKTsKLSAgICB9IGVsc2UKKyAgICBSZWZQdHI8Tm9kZT4gc3BsaXRBdCA9 IHNwbGl0VHJlZShzdGFydC5kZWVwRXF1aXZhbGVudCgpLCBsaXN0Tm9kZSk7CisgICAgaWYgKCFp c0ZpcnN0VmlzaWJsZVBvc2l0aW9uSW5Ob2RlKFZpc2libGVQb3NpdGlvbihmaXJzdFBvc2l0aW9u SW5Ob2RlKHNwbGl0QXQuZ2V0KCkpKSwgbGlzdE5vZGUpKQorICAgICAgICBzcGxpdEVsZW1lbnQo bGlzdE5vZGUsIHNwbGl0QXQpOworICAgIC8vIEluc2VydCBhIHBsYWNlaG9sZGVyIHRvIGF2b2lk IHRleHRzIG5vZGVzIG9mIHNwbGl0QXQgYW5kIHRoZSBub2RlIGJlZm9yZSB0aGUgcGxhY2Vob2xk ZXIgd29uJ3QgZ2V0IG1lcmdlZAorICAgIGlmIChpc0ZpcnN0VmlzaWJsZVBvc2l0aW9uSW5Ob2Rl KFZpc2libGVQb3NpdGlvbihmaXJzdFBvc2l0aW9uSW5Ob2RlKHNwbGl0QXQuZ2V0KCkpKSwgbGlz dE5vZGUpCisgICAgICAgICYmIGlzTGFzdFZpc2libGVQb3NpdGlvbkluTm9kZShWaXNpYmxlUG9z aXRpb24obGFzdFBvc2l0aW9uSW5Ob2RlKGxpc3RDaGlsZE5vZGUpKSwgbGlzdE5vZGUpKQogICAg ICAgICBpbnNlcnROb2RlQWZ0ZXIobm9kZVRvSW5zZXJ0LCBsaXN0Tm9kZSk7CisgICAgZWxzZSAK KyAgICAgICAgaW5zZXJ0Tm9kZUJlZm9yZShub2RlVG9JbnNlcnQsIGxpc3ROb2RlKTsKIAogICAg IFZpc2libGVQb3NpdGlvbiBpbnNlcnRpb25Qb2ludCA9IFZpc2libGVQb3NpdGlvbihwb3NpdGlv bkJlZm9yZU5vZGUocGxhY2Vob2xkZXIuZ2V0KCkpKTsKICAgICBtb3ZlUGFyYWdyYXBocyhzdGFy dCwgZW5kLCBpbnNlcnRpb25Qb2ludCwgdHJ1ZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcAppbmRleCBl ZjU1NmI1YmY3ZDk1NzM0Yjg1MjJmYTU0NjMyY2QzOTkyMTNhZjg5Li45MTQ4ZDNiZTI0YzU4ZGVj YjE2NDIwOGY5MDI3MjM3MmE2NGE0ZWE0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0 aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAKQEAgLTM1Niw3 ICszNTYsNyBAQCB2b2lkIEluc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQ6OmRvQXBwbHko KQogICAgICAgICBpZiAoaW5zZXJ0aW9uUG9zaXRpb24uY29udGFpbmVyTm9kZSgpID09IHN0YXJ0 QmxvY2spCiAgICAgICAgICAgICBuID0gaW5zZXJ0aW9uUG9zaXRpb24uY29tcHV0ZU5vZGVBZnRl clBvc2l0aW9uKCk7CiAgICAgICAgIGVsc2UgewotICAgICAgICAgICAgc3BsaXRUcmVlVG9Ob2Rl KGluc2VydGlvblBvc2l0aW9uLmNvbnRhaW5lck5vZGUoKSwgc3RhcnRCbG9jayk7CisgICAgICAg ICAgICBzcGxpdFRyZWUoaW5zZXJ0aW9uUG9zaXRpb24sIHN0YXJ0QmxvY2spOwogCiAgICAgICAg ICAgICBmb3IgKG4gPSBzdGFydEJsb2NrLT5maXJzdENoaWxkKCk7IG47IG4gPSBuLT5uZXh0U2li bGluZygpKSB7CiAgICAgICAgICAgICAgICAgaWYgKGNvbXBhcmVQb3NpdGlvbnMoVmlzaWJsZVBv c2l0aW9uKGluc2VydGlvblBvc2l0aW9uKSwgcG9zaXRpb25CZWZvcmVOb2RlKG4pKSA8PSAwKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9SZXBsYWNlU2VsZWN0aW9uQ29tbWFu ZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNw cAppbmRleCAwOGU0NmU2NTkxY2NkZDQxYzM5OWUxYmVkZDRjNThkMTQwYWU2Mjc4Li4zMDIzN2Nj ODJhNzJmY2U4MjRlZGQ2MzEzZDJhMWNjYWFhM2E1M2FjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcApAQCAtOTQ2LDcgKzk0Niw3 IEBAIHZvaWQgUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICAvLyBG SVhNRTogaXNJbmxpbmVOb2RlV2l0aFN0eWxlIGRvZXMgbm90IGNoZWNrIGVkaXRhYmlsaXR5Lgog ICAgICAgICBpZiAoUmVmUHRyPE5vZGU+IG5vZGVUb1NwbGl0VG8gPSBoaWdoZXN0RW5jbG9zaW5n Tm9kZU9mVHlwZShpbnNlcnRpb25Qb3MsIGlzSW5saW5lTm9kZVdpdGhTdHlsZSkpIHsKICAgICAg ICAgICAgIGlmIChpbnNlcnRpb25Qb3MuY29udGFpbmVyTm9kZSgpICE9IG5vZGVUb1NwbGl0VG8p IHsKLSAgICAgICAgICAgICAgICBub2RlVG9TcGxpdFRvID0gc3BsaXRUcmVlVG9Ob2RlKGluc2Vy dGlvblBvcy5hbmNob3JOb2RlKCksIG5vZGVUb1NwbGl0VG8uZ2V0KCksIHRydWUpLmdldCgpOwor ICAgICAgICAgICAgICAgIG5vZGVUb1NwbGl0VG8gPSBzcGxpdFRyZWUoaW5zZXJ0aW9uUG9zLCBu b2RlVG9TcGxpdFRvLmdldCgpLCBTcGxpdEVuZCkuZ2V0KCk7CiAgICAgICAgICAgICAgICAgaW5z ZXJ0aW9uUG9zID0gcG9zaXRpb25JblBhcmVudEJlZm9yZU5vZGUobm9kZVRvU3BsaXRUby5nZXQo KSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KQEAgLTEyNTAsMTAgKzEyNTAsNyBAQCBOb2Rl KiBSZXBsYWNlU2VsZWN0aW9uQ29tbWFuZDo6aW5zZXJ0QXNMaXN0SXRlbXMoUGFzc1JlZlB0cjxO b2RlPiBwcnBMaXN0RWxlbWVudAogICAgIC8vIElmIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2YgYSBs aXN0IGl0ZW0sIHdlIHNob3VsZCBzcGxpdCBpdCBpbnRvIHR3byBzZXBhcmF0ZQogICAgIC8vIGxp c3QgaXRlbXMgYW5kIGluc2VydCB0aGVzZSBub2RlcyBiZXR3ZWVuIHRoZW0uCiAgICAgaWYgKGlz TWlkZGxlKSB7Ci0gICAgICAgIGludCB0ZXh0Tm9kZU9mZnNldCA9IGluc2VydFBvcy5vZmZzZXRJ bkNvbnRhaW5lck5vZGUoKTsKLSAgICAgICAgaWYgKGluc2VydFBvcy5kZXByZWNhdGVkTm9kZSgp LT5pc1RleHROb2RlKCkgJiYgdGV4dE5vZGVPZmZzZXQgPiAwKQotICAgICAgICAgICAgc3BsaXRU ZXh0Tm9kZShzdGF0aWNfY2FzdDxUZXh0Kj4oaW5zZXJ0UG9zLmRlcHJlY2F0ZWROb2RlKCkpLCB0 ZXh0Tm9kZU9mZnNldCk7Ci0gICAgICAgIHNwbGl0VHJlZVRvTm9kZShpbnNlcnRQb3MuZGVwcmVj YXRlZE5vZGUoKSwgbGFzdE5vZGUsIHRydWUpOworICAgICAgICBzcGxpdFRyZWUoaW5zZXJ0UG9z LCBsYXN0Tm9kZSwgU3BsaXRFbmQpOwogICAgIH0KIAogICAgIHdoaWxlIChSZWZQdHI8Tm9kZT4g bGlzdEl0ZW0gPSBsaXN0RWxlbWVudC0+Zmlyc3RDaGlsZCgpKSB7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvaHRtbGVkaXRpbmcuY3BwCmluZGV4IDhhMzdhMTA3MDYxMjYxNGYxMTZkMDNmMWRmZTNlYzlh ZmM5NjRhZTUuLmUzOGRiOWRjNDJjMDljMzhmZWM0Zjk5YTIxZGUwMDk0Y2NkNzY0YTggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCkBAIC0xODcsNyArMTg3LDcgQEAgRWxl bWVudCogZWRpdGFibGVSb290Rm9yUG9zaXRpb24oY29uc3QgUG9zaXRpb24mIHApCiAKIC8vIEZp bmRzIHRoZSBlbmNsb3NpbmcgZWxlbWVudCB1bnRpbCB3aGljaCB0aGUgdHJlZSBjYW4gYmUgc3Bs aXQuCiAvLyBXaGVuIGEgdXNlciBoaXRzIEVOVEVSLCBoZS9zaGUgd29uJ3QgZXhwZWN0IHRoaXMg ZWxlbWVudCB0byBiZSBzcGxpdCBpbnRvIHR3by4KLS8vIFlvdSBtYXkgcGFzcyBpdCBhcyB0aGUg c2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0VHJlZVRvTm9kZS4KKy8vIFlvdSBtYXkgcGFzcyBpdCBh cyB0aGUgc2Vjb25kIGFyZ3VtZW50IG9mIHNwbGl0VHJlZS4KIEVsZW1lbnQqIHVuc3BsaXR0YWJs ZUVsZW1lbnRGb3JQb3NpdGlvbihjb25zdCBQb3NpdGlvbiYgcCkKIHsKICAgICAvLyBTaW5jZSBl bmNsb3NpbmdOb2RlT2ZUeXBlIHdvbid0IHNlYXJjaCBiZXlvbmQgdGhlIGhpZ2hlc3Qgcm9vdCBl ZGl0YWJsZSBub2RlLAo= 98209 2011-06-22 11:44:24 -0700 2011-06-22 16:19:09 -0700 Alternate approach bug-61594-20110622114423.patch text/plain 6888 sullivan U3VidmVyc2lvbiBSZXZpc2lvbjogODk0NTEKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjM2IxYzQ0MjY4YzUwMWVlMWQ4NjFm ODJmMWEzNjgyNjYzODhlMmNiLi4xZTJkODVmNmFlZjkyYzRkOTZlYTdhOWM1NjRjMWFhM2UyYWFj ZDgwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDYtMjIgIEFubmllIFN1bGxpdmFuICA8 c3VsbGl2YW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJFR1JFU1NJT046IEhpdHRpbmcgZW50ZXIgaW4gdGhlIG1pZGRsZSBv ZiB0aGlzIHNwYW4gY2F1c2VzIHRoZSBjdXJzb3IgdG8gZ28gdG8gdGhlIGVuZCBvZiB0aGUgc3Bh bgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE1OTQK KworICAgICAgICBBZGRzIHR3byBsYXlvdXQgdGVzdHMgdG8gdmVyaWZ5IHRoYXQgaGl0dGluZyBl bnRlciBpbiB0aGUgbWlkZGxlIG9mIHRoZSBzcGFuIHNwbGl0cyB0aGUgc3BhbiBjb3JyZWN0bHkK KyAgICAgICAgYW5kIHBsYWNlcyB0aGUgY3Vyc29yIGluIHRoZSBjb3JyZWN0IHBvc2l0aW9uLgor CisgICAgICAgICogZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1iZWZvcmUtYnItaW4tc3Bh bi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVy bi1rZXktYmVmb3JlLWJyLWluLXNwYW4uaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9p bnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4uaHRt bDogQWRkZWQuCisKIDIwMTEtMDYtMjIgIE1hcmsgUGlsZ3JpbSAgPHBpbGdyaW1AY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVm b3JlLWJyLWluLXNwYW4tZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNmNDYyZjQ5OTFjNjVlMTkx MTVjNmM2OTkzNTU1ZmMxYTRlNTM0ZDAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHNldHMgdGhlIHNlbGVjdGlvbiB0byB0aGUgZW5kIG9m IHRoZSBmaXJzdCBsaW5lLCBhbmQgaGl0cyB0aGUgZW50ZXIga2V5LgorRXhwZWN0ZWQgYmVoYXZp b3I6IGEgZGl2IGlzIGNyZWF0ZWQgYXJvdW5kIHRoZSBzZWNvbmQgbGluZSwgYW5kIHRoZSBjdXJz b3IgaXMgcGxhY2VkIGF0IHRoZSBzdGFydCBvZiB0aGUgc2Vjb25kIGxpbmUuIFNlZSBidWcgNjE1 OTQuCit8IDxzcGFuPgorfCAgIGlkPSJ3cmFwcGVyIgorfCAgICJGaXJzdCBsaW5lIgorfCA8ZGl2 PgorfCAgIDxzcGFuPgorfCAgICAgPCNzZWxlY3Rpb24tY2FyZXQ+Cit8ICAgICA8YnI+Cit8ICAg ICAiU2Vjb25kIGxpbmUiCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGlu Zy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YTFjNDJmZGM4MDA5OTIyMzk2YzRiYWY5YzExODI0OGQ3YTJiMzQyNwotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktYmVmb3JlLWJyLWlu LXNwYW4uaHRtbApAQCAtMCwwICsxLDE1IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJv ZHk+Cis8ZGl2IGNvbnRlbnRlZGl0YWJsZSBpZD0icm9vdCI+PHNwYW4gaWQ9IndyYXBwZXIiPkZp cnN0IGxpbmU8YnI+U2Vjb25kIGxpbmU8L3NwYW4+PC9kaXY+Cis8c2NyaXB0IHNyYz0iLi4vLi4v cmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQ+CitNYXJrdXAu ZGVzY3JpcHRpb24oIlRoaXMgc2V0cyB0aGUgc2VsZWN0aW9uIHRvIHRoZSBlbmQgb2YgdGhlIGZp cnN0IGxpbmUsIGFuZCBoaXRzIHRoZSBlbnRlciBrZXkuXG4iCisgICAgKyAiRXhwZWN0ZWQgYmVo YXZpb3I6IGEgZGl2IGlzIGNyZWF0ZWQgYXJvdW5kIHRoZSBzZWNvbmQgbGluZSwgYW5kIHRoZSBj dXJzb3IgaXMgcGxhY2VkIGF0IHRoZSAiCisgICAgKyAic3RhcnQgb2YgdGhlIHNlY29uZCBsaW5l LiBTZWUgYnVnIDYxNTk0LiIpOwordmFyIHNlbCA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKK3Nl bC5zZXRQb3NpdGlvbihkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgid3JhcHBlciIpLCAxKTsKK2Rv Y3VtZW50LmV4ZWNDb21tYW5kKCJJbnNlcnRQYXJhZ3JhcGgiLCBmYWxzZSwgbnVsbCk7CitNYXJr dXAuZHVtcChyb290KTsKKzwvc2NyaXB0PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZWRpdGluZy9pbnNlcnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1z cGFuLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MmM5NmQxMGQ5OWFmMGJhMzJmZmU2Mzg2YmMz Yjk0MGMyOTk0NzViCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNl cnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwx MCBAQAorVGhpcyBzZXRzIHRoZSBzZWxlY3Rpb24gdG8gdGhlIG1pZGRsZSBvZiB0aGUgZmlyc3Qg bGluZSwgYW5kIGhpdHMgdGhlIGVudGVyIGtleS4KK0V4cGVjdGVkIGJlaGF2aW9yOiB0aGUgdGV4 dCBub2RlIGlzIHNwbGl0IGF0IHRoZSBjdXJzb3IuIFRoZSBzcGFuIGlzIGNsb25lZCwgYW5kIGV2 ZXJ5dGhpbmcgdGhhdCB3YXMgc3BsaXQgb3V0IGlzIHBsYWNlZCBpbnNpZGUgdGhlIGNsb25lIGlu IGEgbmV3IGRpdiB3aGljaCBpcyBhIGNoaWxkIG9mIHRoZSByb290LiBTZWUgYnVnIDYxNTk0Lgor fCA8c3Bhbj4KK3wgICBpZD0id3JhcHBlciIKK3wgICAiRmlyc3QiCit8IDxkaXY+Cit8ICAgPHNw YW4+Cit8ICAgICAiPCNzZWxlY3Rpb24tY2FyZXQ+wqBsaW5lIgorfCAgICAgPGJyPgorfCAgICAg IlNlY29uZCBsaW5lIgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNlcnRpbmcv cmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnNl cnRpbmcvcmV0dXJuLWtleS1taWRkbGUtb2Ytc3Bhbi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJlYTg4N2Fj YWE0ZDM3MTY0MzFjYWY5ZDY4N2I3ODMyMzQzM2IyMDcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9lZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LW1pZGRsZS1vZi1zcGFuLmh0bWwK QEAgLTAsMCArMSwxNSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5PgorPGRpdiBj b250ZW50ZWRpdGFibGUgaWQ9InJvb3QiPjxzcGFuIGlkPSJ3cmFwcGVyIj5GaXJzdCBsaW5lPGJy PlNlY29uZCBsaW5lPC9zcGFuPjwvZGl2PgorPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9k dW1wLWFzLW1hcmt1cC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0PgorTWFya3VwLmRlc2NyaXB0aW9u KCJUaGlzIHNldHMgdGhlIHNlbGVjdGlvbiB0byB0aGUgbWlkZGxlIG9mIHRoZSBmaXJzdCBsaW5l LCBhbmQgaGl0cyB0aGUgZW50ZXIga2V5LlxuIgorICAgICsgIkV4cGVjdGVkIGJlaGF2aW9yOiB0 aGUgdGV4dCBub2RlIGlzIHNwbGl0IGF0IHRoZSBjdXJzb3IuIFRoZSBzcGFuIGlzIGNsb25lZCwg YW5kIGV2ZXJ5dGhpbmcgIgorICAgICsgInRoYXQgd2FzIHNwbGl0IG91dCBpcyBwbGFjZWQgaW5z aWRlIHRoZSBjbG9uZSBpbiBhIG5ldyBkaXYgd2hpY2ggaXMgYSBjaGlsZCBvZiB0aGUgcm9vdC4g U2VlIGJ1ZyA2MTU5NC4iKTsKK3ZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CitzZWwu c2V0UG9zaXRpb24oZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIndyYXBwZXIiKS5maXJzdENoaWxk LCA1KTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCJJbnNlcnRQYXJhZ3JhcGgiLCBmYWxzZSwgbnVs bCk7CitNYXJrdXAuZHVtcChyb290KTsKKzwvc2NyaXB0PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4 IGJhZTMwNTQ3N2UxZDBkZTkyZGJlY2IxMTBlNmY3NWU2YzQ2M2VhOTcuLjBlODRkYjZmYWM3NzY0 Y2VlMTg3YjU2MmQ1NzE5MjA5ZmZjY2NkN2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAor MjAxMS0wNi0yMiAgQW5uaWUgU3VsbGl2YW4gIDxzdWxsaXZhbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUkVHUkVTU0lPTjog SGl0dGluZyBlbnRlciBpbiB0aGUgbWlkZGxlIG9mIHRoaXMgc3BhbiBjYXVzZXMgdGhlIGN1cnNv ciB0byBnbyB0byB0aGUgZW5kIG9mIHRoZSBzcGFuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MTU5NAorCisgICAgICAgIFdoZW4gdGhlIHRyZWUgaXMg c3BsaXQgYXQgdGhlIGN1cnNvciBpbiBJbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLCBp dCBpcyBwb3NzaWJsZSBmb3IgdGhlIHBvc2l0aW9uCisgICAgICAgIHNwbGl0IGF0IHRvIGJlIGF0 IHRoZSBlbmQgb2YgYSB0ZXh0IG5vZGUuIFRoZSBjb2RlIGFzc3VtZXMgdGhlIHBvc2l0aW9uIGlz IGF0IHRoZSBzdGFydCBvZiB0aGUgbm9kZSwgc28KKyAgICAgICAgcGFzcyB0aGUgY29ycmVjdCBu b2RlIGludG8gc3BsaXRUcmVlVG9Ob2RlKCkgaW4gdGhhdCBjYXNlLgorCisgICAgICAgIFRlc3Rz OiBlZGl0aW5nL2luc2VydGluZy9yZXR1cm4ta2V5LWJlZm9yZS1ici1pbi1zcGFuLmh0bWwKKyAg ICAgICAgICAgICAgIGVkaXRpbmcvaW5zZXJ0aW5nL3JldHVybi1rZXktbWlkZGxlLW9mLXNwYW4u aHRtbAorCisgICAgICAgICogZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5k LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQ6 OmRvQXBwbHkpOgorCiAyMDExLTA2LTIyICBNYXJrIFBpbGdyaW0gIDxwaWxncmltQGNocm9taXVt Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcCBi L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5j cHAKaW5kZXggZWY1NTZiNWJmN2Q5NTczNGI4NTIyZmE1NDYzMmNkMzk5MjEzYWY4OS4uYTdiNWJi ODBhYjRjODRjYjA5Y2Y3NTMyYjA0ODZiNjM0ODAxZTA1NCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3Bw CkBAIC0zNTYsNyArMzU2LDExIEBAIHZvaWQgSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFu ZDo6ZG9BcHBseSgpCiAgICAgICAgIGlmIChpbnNlcnRpb25Qb3NpdGlvbi5jb250YWluZXJOb2Rl KCkgPT0gc3RhcnRCbG9jaykKICAgICAgICAgICAgIG4gPSBpbnNlcnRpb25Qb3NpdGlvbi5jb21w dXRlTm9kZUFmdGVyUG9zaXRpb24oKTsKICAgICAgICAgZWxzZSB7Ci0gICAgICAgICAgICBzcGxp dFRyZWVUb05vZGUoaW5zZXJ0aW9uUG9zaXRpb24uY29udGFpbmVyTm9kZSgpLCBzdGFydEJsb2Nr KTsKKyAgICAgICAgICAgIE5vZGUqIHNwbGl0VG8gPSBpbnNlcnRpb25Qb3NpdGlvbi5jb250YWlu ZXJOb2RlKCk7CisgICAgICAgICAgICBpZiAoc3BsaXRUby0+aXNUZXh0Tm9kZSgpICYmIGluc2Vy dGlvblBvc2l0aW9uLm9mZnNldEluQ29udGFpbmVyTm9kZSgpID49IGNhcmV0TWF4T2Zmc2V0KHNw bGl0VG8pKQorICAgICAgICAgICAgICBzcGxpdFRvID0gc3BsaXRUby0+dHJhdmVyc2VOZXh0Tm9k ZShzdGFydEJsb2NrKTsKKyAgICAgICAgICAgIEFTU0VSVChzcGxpdFRvKTsKKyAgICAgICAgICAg IHNwbGl0VHJlZVRvTm9kZShzcGxpdFRvLCBzdGFydEJsb2NrKTsKIAogICAgICAgICAgICAgZm9y IChuID0gc3RhcnRCbG9jay0+Zmlyc3RDaGlsZCgpOyBuOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkg ewogICAgICAgICAgICAgICAgIGlmIChjb21wYXJlUG9zaXRpb25zKFZpc2libGVQb3NpdGlvbihp bnNlcnRpb25Qb3NpdGlvbiksIHBvc2l0aW9uQmVmb3JlTm9kZShuKSkgPD0gMCkK