55552 2011-03-01 22:49:02 -0800 Text selection changes unexpectedly when dragging out of the <input> 2011-04-15 16:23:13 -0700 1 1 1 Unclassified WebKit Text 528+ (Nightly build) PC All RESOLVED FIXED P2 Normal --- 57921 57923 52986 1 pkasting aboxhall aboxhall caseq commit-queue dglazkov jparent mitz noel.gordon ojan patrick rniwa oldest_to_newest 360597 0 pkasting 2011-03-01 22:49:02 -0800 Visit http://www.shacknews.com/search?type=4 . Type anything into the "Search for:" box. Now click down in the middle of your text, drag left to select the beginning, and keep dragging out of the <input> and into the page to the left. Also try moving your mouse up and down at various x coordinates. I expect the selection to be pretty stable, not unexpectedly reverse itself half the time. I could swear I filed this already, but I can't find it. In any case this happens on a lot of sites and drive me bananas. Please tell me someone has time to look into it :( 367362 1 noel.gordon 2011-03-14 17:02:59 -0700 test case: click in the middle and drag out to the right to see the unexpected selection change. 367363 2 85744 noel.gordon 2011-03-14 17:04:22 -0700 Created attachment 85744 test case 369445 3 aboxhall 2011-03-17 17:57:57 -0700 I've been digging around this a little, and it seems like the problem might be related to the fact that the contentHeight and contentWidth of the input field are (incorrectly?) set to 0 and 1008, respectively. This causes RenderBox::positionForPoint to incorrectly calculate the relative position of the mouse cursor once the mouse drags out of the input field. 377658 4 87828 aboxhall 2011-03-31 23:45:30 -0700 Created attachment 87828 Patch 377660 5 aboxhall 2011-03-31 23:48:24 -0700 First pass patch; feedback welcome. After a few blind alleys it turned out to be simplest to just modify updateSelectionForMouseDrag to translate the selection end-point into a local point within the editable element, in the case where the mouse had dragged out of it, since the selection can't extend beyond the editable element anyway. 377661 6 mitz 2011-03-31 23:59:07 -0700 I think this is bug 12593. 377662 7 mitz 2011-03-31 23:59:16 -0700 I think this is bug 12593. 377862 8 pkasting 2011-04-01 09:44:33 -0700 (In reply to comment #6) > I think this is bug 12593. Could be. The description there is a little vague and it lacks the attachments from the Radar bug. If they're the same, maybe that bug should be duped against this since there's a patch here? I dunno. 378392 9 87828 rniwa 2011-04-02 08:30:21 -0700 Comment on attachment 87828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=87828&action=review > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:17 > +} else This else clause needs to have curly brackets. > Source/WebCore/page/EventHandler.cpp:640 > + IntPoint realLocalPoint(localPoint); I don't think realLocalPoint is a descriptive name. What does "real" mean? Also, I think we normally use assignment operator rather than copy constructor when declaring a local variable. So the preferred way of writing this will be: IntPoint realLocalPoint = localPoint. > Source/WebCore/page/EventHandler.cpp:654 > + if (editableElement && !editableElement->contains(targetNode)) { > + targetNode = editableElement; > > - // Don't modify the selection if we're not on a node. > - if (targetPosition.isNull()) > - return; > + FloatPoint absolutePoint = targetRenderer->localToAbsolute(FloatPoint(realLocalPoint)); > + > + targetRenderer = targetNode->renderer(); > + if (!targetRenderer) > + return; > > + realLocalPoint = roundedIntPoint(targetRenderer->absoluteToLocal(absolutePoint)); > + } It's odd that we fix localPoint in updateSelectionForMouseDrag rather than in its call site. We should fix it in handleMouseDraggedEvent instead. > Source/WebCore/page/EventHandler.cpp:658 > + VisiblePosition targetPosition(targetRenderer->positionForPoint(realLocalPoint)); Ditto about copy constructor. 378394 10 87828 rniwa 2011-04-02 08:37:15 -0700 Comment on attachment 87828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=87828&action=review r- because you're missing LayoutTests/ChangeLog > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:14 > + eventSender.mouseDown(); > + x = floatedEditable.offsetLeft + floatedEditable.offsetWidth + 5; > + eventSender.mouseMoveTo(x, y); > + eventSender.mouseUp(); I believe you need to add leapForward between mouseDown and mouseUp or otherwise this test becomes flaky. > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:27 > + return el.isContentEditable ? window.getSelection().baseOffset : el.selectionStart; Please do not use arbitrary abbreviations like "el". > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:15 > +To test manually, drag from the middle of the editable div to the > +right, into the non-floated text. The selection should go to the end > +of the input element and not jump to the beginning. Are you trying to fit everything in 80 columns? No need to do that here. > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:19 > +<p id="result"> > +</p> > +<pre id="console"></pre> Can't we have just one pre/p? It seems silly to have two separate elements for automated / manual test. > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:20 > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> We don't normally specify type attribute. > LayoutTests/editing/selection/select-out-of-floated-input.html:22 > +<p id="result"> > +</p> > +<pre id="console"></pre> > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> Ditto. > LayoutTests/editing/selection/select-out-of-floated-textarea.html:22 > +<p id="result"> > +</p> > +<pre id="console"></pre> > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> Ditto. 378600 11 88024 aboxhall 2011-04-03 17:30:18 -0700 Created attachment 88024 Patch 378601 12 aboxhall 2011-04-03 17:31:21 -0700 (In reply to comment #9) > (From update of attachment 87828 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=87828&action=review > > > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:17 > > +} else > > This else clause needs to have curly brackets. Done. > > Source/WebCore/page/EventHandler.cpp:640 > > + IntPoint realLocalPoint(localPoint); > > I don't think realLocalPoint is a descriptive name. What does "real" mean? Also, I think we normally use assignment operator rather than copy constructor when declaring a local variable. So the preferred way of writing this will be: > IntPoint realLocalPoint = localPoint. Renamed to finalPoint, and used assignment. > > Source/WebCore/page/EventHandler.cpp:654 > > + if (editableElement && !editableElement->contains(targetNode)) { > > + targetNode = editableElement; > > > > - // Don't modify the selection if we're not on a node. > > - if (targetPosition.isNull()) > > - return; > > + FloatPoint absolutePoint = targetRenderer->localToAbsolute(FloatPoint(realLocalPoint)); > > + > > + targetRenderer = targetNode->renderer(); > > + if (!targetRenderer) > > + return; > > > > + realLocalPoint = roundedIntPoint(targetRenderer->absoluteToLocal(absolutePoint)); > > + } > > It's odd that we fix localPoint in updateSelectionForMouseDrag rather than in its call site. We should fix it in handleMouseDraggedEvent instead. I don't understand why... the point only needs to be re-interpreted in the case where a selection is being updated and the mouse has been dragged outside of the editable element in which it began. To me it seems like a good fit to do this in the updateSelectionForMouseDrag function. Also, handleMouseDraggedEvent has two branches which call updateSelectionForMouseDrag, with two different points as arguments, so I'd need to modify both of them. > > Source/WebCore/page/EventHandler.cpp:658 > > + VisiblePosition targetPosition(targetRenderer->positionForPoint(realLocalPoint)); > > Ditto about copy constructor. Done. (In reply to comment #10) > (From update of attachment 87828 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=87828&action=review > > r- because you're missing LayoutTests/ChangeLog > > > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:14 > > + eventSender.mouseDown(); > > + x = floatedEditable.offsetLeft + floatedEditable.offsetWidth + 5; > > + eventSender.mouseMoveTo(x, y); > > + eventSender.mouseUp(); > > I believe you need to add leapForward between mouseDown and mouseUp or otherwise this test becomes flaky. Why is that? I haven't observed any flaky behaviour in running it. > > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:27 > > + return el.isContentEditable ? window.getSelection().baseOffset : el.selectionStart; > > Please do not use arbitrary abbreviations like "el". Ok. > > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:15 > > +To test manually, drag from the middle of the editable div to the > > +right, into the non-floated text. The selection should go to the end > > +of the input element and not jump to the beginning. > > Are you trying to fit everything in 80 columns? No need to do that here. I find it easier to read wrapped text than text that flows off the page; is there a preferable width to wrap it to? > > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:19 > > +<p id="result"> > > +</p> > > +<pre id="console"></pre> > > Can't we have just one pre/p? It seems silly to have two separate elements for automated / manual test. I think this simplifies separating out the success/fail handling and the logging. The result div is used in the manual test as well (although obviously it's not 100% reliable if you don't follow the written instructions). > > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:20 > > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> > > We don't normally specify type attribute. Ok. > > LayoutTests/editing/selection/select-out-of-floated-input.html:22 > > +<p id="result"> > > +</p> > > +<pre id="console"></pre> > > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> > > Ditto. Done. > > LayoutTests/editing/selection/select-out-of-floated-textarea.html:22 > > +<p id="result"> > > +</p> > > +<pre id="console"></pre> > > +<script type="text/javascript" src="resources/select-out-of-floated-editable.js"></script> > > Ditto. Done. 378652 13 rniwa 2011-04-03 22:20:20 -0700 (In reply to comment #12) > > > Source/WebCore/page/EventHandler.cpp:654 > > It's odd that we fix localPoint in updateSelectionForMouseDrag rather than in its call site. We should fix it in handleMouseDraggedEvent instead. > > I don't understand why... the point only needs to be re-interpreted in the case where a selection is being updated and the mouse has been dragged outside of the editable element in which it began. To me it seems like a good fit to do this in the updateSelectionForMouseDrag function. Also, handleMouseDraggedEvent has two branches which call updateSelectionForMouseDrag, with two different points as arguments, so I'd need to modify both of them. The problem is that updateSelectionForMouseDrag explicitly takes a node and localPoint. It's a really bad API to let a function take a node and a local point and then modify the node & local point inside the function. So much of editing code has been hacked around like this and it really reduces the readability and maintainability of code because when I see the calls to updateSelectionForMouseDrag, I'd assume that selection is updated with respect to the node and local rect I passed in. On my second thought, I think the best way to resolve this is to change the signature of updateSelectionForMouseDrag to MouseEventWithHitTestResults(HitTestResult). That way, we're not explicitly passing a node & localRect so it doesn't look magical. > > > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:14 > > > + eventSender.mouseDown(); > > > + x = floatedEditable.offsetLeft + floatedEditable.offsetWidth + 5; > > > + eventSender.mouseMoveTo(x, y); > > > + eventSender.mouseUp(); > > > > I believe you need to add leapForward between mouseDown and mouseUp or otherwise this test becomes flaky. > > Why is that? I haven't observed any flaky behaviour in running it. You may not observe flakiness locally but some bots might. Sadly, many existing tests do this and are flaky on some bots :( > > > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:15 > > > +To test manually, drag from the middle of the editable div to the > > > +right, into the non-floated text. The selection should go to the end > > > +of the input element and not jump to the beginning. > > > > Are you trying to fit everything in 80 columns? No need to do that here. > > I find it easier to read wrapped text than text that flows off the page; is there a preferable width to wrap it to? Historically, I don't think we ever wrap text inside HTML files (except maybe at the end of sentence). > > > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:19 > > > +<p id="result"> > > > +</p> > > > +<pre id="console"></pre> > > > > Can't we have just one pre/p? It seems silly to have two separate elements for automated / manual test. > > I think this simplifies separating out the success/fail handling and the logging. The result div is used in the manual test as well (although obviously it's not 100% reliable if you don't follow the written instructions). Huh... it seems odd to have these two elements when only either one is used. Can we auto-generate them instead then? By the way, this bug might be a duplicate of the bug 52986. 378654 14 88024 rniwa 2011-04-03 22:21:16 -0700 Comment on attachment 88024 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88024&action=review > Source/WebCore/page/EventHandler.cpp:655 > - VisiblePosition targetPosition(targetRenderer->positionForPoint(localPoint)); > + IntPoint finalPoint = localPoint; > + > + VisibleSelection newSelection = m_frame->selection()->selection(); > + Element* editableElement = newSelection.rootEditableElement(); > + if (editableElement && !editableElement->contains(targetNode)) { > + targetNode = editableElement; > > - // Don't modify the selection if we're not on a node. > - if (targetPosition.isNull()) > - return; > + FloatPoint absolutePoint = targetRenderer->localToAbsolute(FloatPoint(finalPoint)); > + > + targetRenderer = targetNode->renderer(); > + if (!targetRenderer) > + return; > > + finalPoint = roundedIntPoint(targetRenderer->absoluteToLocal(absolutePoint)); > + } > + Please extract this code as a function. 379348 15 rniwa 2011-04-04 23:02:24 -0700 *** Bug 52986 has been marked as a duplicate of this bug. *** 379385 16 88192 rniwa 2011-04-05 02:11:08 -0700 Created attachment 88192 test for the bug 52986 Hi Alice, Here's DRT test for the bug 52986. Please add it to your patch. 379387 17 rniwa 2011-04-05 02:12:20 -0700 When I was writing this test, I realized that the bug 52986 does not reproduce when there's non-editable content above or below the editable div. I'd greatly appreciate it if you could figure out why that's the case. 382967 18 ojan 2011-04-10 17:07:23 -0700 (In reply to comment #17) > When I was writing this test, I realized that the bug 52986 does not reproduce when there's non-editable content above or below the editable div. I'd greatly appreciate it if you could figure out why that's the case. This bug doesn't look like a duplicate to me. Although, it's not clear to me what's causing bug 52986. Have you confirmed it's fixed by Alice's patch? We shouldn't dupe this until we're sure it's the same root cause. 382968 19 88024 ojan 2011-04-10 17:09:59 -0700 Comment on attachment 88024 Patch Removing this from the review queue per the above comment and till bug 57923 gets committed. 382969 20 aboxhall 2011-04-10 17:10:32 -0700 (In reply to comment #19) > (From update of attachment 88024 [details]) > Removing this from the review queue per the above comment and till bug 57923 gets committed. I'm not sure that it's a duplicate, but both Ryosuke and Noel have verified that it's fixed by this change. 382978 21 rniwa 2011-04-10 17:38:53 -0700 (In reply to comment #18) > (In reply to comment #17) > > When I was writing this test, I realized that the bug 52986 does not reproduce when there's non-editable content above or below the editable div. I'd greatly appreciate it if you could figure out why that's the case. > > This bug doesn't look like a duplicate to me. Although, it's not clear to me what's causing bug 52986. Have you confirmed it's fixed by Alice's patch? We shouldn't dupe this until we're sure it's the same root cause. It is a duplicate. We're not passing a node inside editable region to the SelectionController. The reason we can't reproduce this bug when there are content above or blow the editable region is probably due to the canonicalization. 382980 22 rniwa 2011-04-10 17:39:28 -0700 (In reply to comment #21) > It is a duplicate. We're not passing a node inside editable region to the SelectionController. The reason we can't reproduce this bug when there are content above or blow the editable region is probably due to the canonicalization. Or rather how we fix up positions in SelectionController when the root editable element doesn't match. 383041 23 88970 aboxhall 2011-04-10 23:32:18 -0700 Created attachment 88970 Patch 383258 24 88970 rniwa 2011-04-11 10:39:10 -0700 Comment on attachment 88970 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88970&action=review Okay, I like the patch in general but there are few nits I want you to address before landing this patch. I'd say r- for now given that you're not a committer yet. > LayoutTests/ChangeLog:38 > + > +2011-04-03 Alice Boxhall <aboxhall@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Text selection changes unexpectedly when dragging out of the &lt;input&gt; > + https://bugs.webkit.org/show_bug.cgi?id=55552 > + > + Tests that dragging outside of a contenteditable, input or textarea selects to the end of the > + element, rather than jumping back to the beginning. > + > + * editing/selection/resources/select-out-of-floated-editable.js: Added. > + * editing/selection/select-out-of-floated-contenteditable-expected.txt: Added. > + * editing/selection/select-out-of-floated-contenteditable.html: Added. > + * editing/selection/select-out-of-floated-input-expected.txt: Added. > + * editing/selection/select-out-of-floated-input.html: Added. > + * editing/selection/select-out-of-floated-textarea-expected.txt: Added. > + * editing/selection/select-out-of-floated-textarea.html: Added. > + You have two change log entires. Please fix. > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:12 > + x = floatedEditable.offsetLeft + floatedEditable.offsetWidth + 5; You need to call leap forward here. > LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:37 > + : floatedEditable.value; I don't think we normally align after tertiary operator like this. Please do: var inputText = floatedEditable.isContentEditable ? floatedEditable.textContent : floatedEditable.value; > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:5 > +<style> > + div { float: left; } > + p { padding-top: 1em; } > +</style> I don't know why we need to specify these as style rules. p already has some margins and you can specify float: left in the inline style declaration. > LayoutTests/editing/selection/select-out-of-floated-contenteditable.html:19 > +<p id="result"> > +</p> > +<pre id="console"></pre> Nit: It seems odd that you have <p> and </p> on a separate line even though it's empty and right beneath it, you have <pre></pre>. > Source/WebCore/ChangeLog:15 > + (WebCore::targetPositionForSelectionEndpoint): When dragging from an editable element, check that > + the endpoint is not outside the element. If it is, translate the point into a local point within the > + editable element. Nit: I don't think we intend in change log like this. Please align the start of each line to (. Also, it's odd that line break exists between an article and the noun that immediately follows it. We usually truncate a line at more natural places between "within" and "the" or between "local point" and "within" > Source/WebCore/page/EventHandler.cpp:634 > + // If selecting out of an editable element, translate the endpoint into a local point within the > + // editable element, to avoid confusing behaviour which can occur when dragging into a node which is > + // earlier in the DOM. Nit: this comment is too verbose. We can either omit the comment entirely or simply state that we're respecting editing boundary. We certainly don't need to say that we're translating the endpoint to a local point within the editable element because that's self-evident from the code. "avoid confusing behavior when dragging out of an editable element" will be better but we need to be a little more specific than "confusing". 383276 25 88970 pkasting 2011-04-11 10:56:07 -0700 Comment on attachment 88970 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88970&action=review >> LayoutTests/editing/selection/resources/select-out-of-floated-editable.js:37 >> + : floatedEditable.value; > > I don't think we normally align after tertiary operator like this. Please do: > var inputText = floatedEditable.isContentEditable ? floatedEditable.textContent > : floatedEditable.value; I have actually seen this style. However, I think breaking after the '?', or not breaking at all, might be best. 383818 26 89157 aboxhall 2011-04-11 22:30:24 -0700 Created attachment 89157 Patch 383824 27 89157 rniwa 2011-04-11 22:39:01 -0700 Comment on attachment 89157 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=89157&action=review > Source/WebCore/page/EventHandler.cpp:633 > + // Avoid selection changing direction when dragging out of an editable element into > + // an element which comes earlier in the DOM. Mn... this is the description of the bug you're solving but I don't think that'll necessarily address the all cases where we reach this code path. i.e. I think you're solving more general problem here than what comment explains and that's kind of misleading. 383828 28 aboxhall 2011-04-11 22:59:56 -0700 (In reply to comment #27) > (From update of attachment 89157 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=89157&action=review > > > Source/WebCore/page/EventHandler.cpp:633 > > + // Avoid selection changing direction when dragging out of an editable element into > > + // an element which comes earlier in the DOM. > > Mn... this is the description of the bug you're solving but I don't think that'll necessarily address the all cases where we reach this code path. i.e. I think you're solving more general problem here than what comment explains and that's kind of misleading. True, although I don't think it suffices to say "respect editing boundaries" either, since that happens elsewhere. Will have a think -- happy to take the comment off altogether, but I think it's worth clarifying why this is necessary here. 383832 29 aboxhall 2011-04-11 23:06:30 -0700 (In reply to comment #28) > (In reply to comment #27) > > (From update of attachment 89157 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=89157&action=review > > > > > Source/WebCore/page/EventHandler.cpp:633 > > > + // Avoid selection changing direction when dragging out of an editable element into > > > + // an element which comes earlier in the DOM. > > > > Mn... this is the description of the bug you're solving but I don't think that'll necessarily address the all cases where we reach this code path. i.e. I think you're solving more general problem here than what comment explains and that's kind of misleading. > > True, although I don't think it suffices to say "respect editing boundaries" either, since that happens elsewhere. Will have a think -- happy to take the comment off altogether, but I think it's worth clarifying why this is necessary here. How about: // When dragging out of an editable element, the selection cannot cross the editing boundary, // so it doesn't make sense to calculate a selection endpoint outside the editable element. 383843 30 89157 rniwa 2011-04-11 23:50:36 -0700 Comment on attachment 89157 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=89157&action=review >>>> Source/WebCore/page/EventHandler.cpp:633 >>>> + // an element which comes earlier in the DOM. >>> >>> Mn... this is the description of the bug you're solving but I don't think that'll necessarily address the all cases where we reach this code path. i.e. I think you're solving more general problem here than what comment explains and that's kind of misleading. >> >> True, although I don't think it suffices to say "respect editing boundaries" either, since that happens elsewhere. Will have a think -- happy to take the comment off altogether, but I think it's worth clarifying why this is necessary here. > > How about: > // When dragging out of an editable element, the selection cannot cross the editing boundary, > // so it doesn't make sense to calculate a selection endpoint outside the editable element. okay, that explains why we don't use the old end point but doesn't explain why we use editable root as new end point. I'd say something along the line of "use the root editable element as the end point when dragging out of the element because selection cannot cross the editing boundary." To be more explicitly, I say something like working around issues in adjustSelectionToAvoidCrossingEditingBoundaries but then you need to start talking about how it affects selection, etc... and it'll be too verbose again. 384178 31 ojan 2011-04-12 11:22:03 -0700 (In reply to comment #30) > To be more explicitly, I say something like working around issues in adjustSelectionToAvoidCrossingEditingBoundaries but then you need to start talking about how it affects selection, etc... and it'll be too verbose again. The bug this patch was originally for isn't about adjustSelectionToAvoidCrossingEditingBoundaries. It's that there are cases where we set the selection at the start of the container node when there are floats involved instead of at the end. You get similarly weird selections if you ignore editing, but in the absence of editing, there's nothing better we can do (and in fact we match Firefox). Alice's last comments seems fine to me. 384193 32 rniwa 2011-04-12 11:36:58 -0700 (In reply to comment #31) > The bug this patch was originally for isn't about adjustSelectionToAvoidCrossingEditingBoundaries. It's that there are cases where we set the selection at the start of the container node when there are floats involved instead of at the end. You get similarly weird selections if you ignore editing, but in the absence of editing, there's nothing better we can do (and in fact we match Firefox). Sure, but I don't think it's important what this bug or patch was for because the comment is added to the code and not to the change log entry. Having said that, I'm fine with Alice's last comment as well (in the sense that I don't mind r+ing it) although I still feel like we can improve it more. 384589 33 89322 aboxhall 2011-04-12 18:09:03 -0700 Created attachment 89322 Patch 384594 34 89322 rniwa 2011-04-12 18:19:55 -0700 Comment on attachment 89322 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=89322&action=review > Source/WebCore/page/EventHandler.cpp:638 > + FloatPoint absolutePoint = targetNode->renderer()->localToAbsolute(FloatPoint(selectionEndPoint)); > + > + selectionEndPoint = roundedIntPoint(selectionEndNode->renderer()->absoluteToLocal(absolutePoint)); > + } > + > + return selectionEndNode->renderer()->positionForPoint(selectionEndPoint); Oops, these nodes may not have renderers. 385492 35 89526 aboxhall 2011-04-13 21:04:39 -0700 Created attachment 89526 Patch 385493 36 aboxhall 2011-04-13 21:07:09 -0700 (In reply to comment #34) > (From update of attachment 89322 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=89322&action=review > > > Source/WebCore/page/EventHandler.cpp:638 > > + FloatPoint absolutePoint = targetNode->renderer()->localToAbsolute(FloatPoint(selectionEndPoint)); > > + > > + selectionEndPoint = roundedIntPoint(selectionEndNode->renderer()->absoluteToLocal(absolutePoint)); > > + } > > + > > + return selectionEndNode->renderer()->positionForPoint(selectionEndPoint); > > Oops, these nodes may not have renderers. Fixed. (In reply to comment #32) > (In reply to comment #31) > > The bug this patch was originally for isn't about adjustSelectionToAvoidCrossingEditingBoundaries. It's that there are cases where we set the selection at the start of the container node when there are floats involved instead of at the end. You get similarly weird selections if you ignore editing, but in the absence of editing, there's nothing better we can do (and in fact we match Firefox). > > Sure, but I don't think it's important what this bug or patch was for because the comment is added to the code and not to the change log entry. Having said that, I'm fine with Alice's last comment as well (in the sense that I don't mind r+ing it) although I still feel like we can improve it more. Comment removed. 385494 37 89526 rniwa 2011-04-13 21:20:50 -0700 Comment on attachment 89526 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=89526&action=review > Source/WebCore/page/EventHandler.cpp:641 > + return selectionEndNode->renderer()->positionForPoint(selectionEndPoint); You need to check renderer here as well. > Source/WebCore/page/EventHandler.cpp:658 > if (!targetRenderer) > return; You should remove this early exit. 385497 38 89527 aboxhall 2011-04-13 21:41:46 -0700 Created attachment 89527 Patch 385499 39 aboxhall 2011-04-13 21:42:25 -0700 (In reply to comment #37) > (From update of attachment 89526 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=89526&action=review > > > Source/WebCore/page/EventHandler.cpp:641 > > + return selectionEndNode->renderer()->positionForPoint(selectionEndPoint); > > You need to check renderer here as well. Done. > > Source/WebCore/page/EventHandler.cpp:658 > > if (!targetRenderer) > > return; > > You should remove this early exit. Done (and removed that local variable too, as it wasn't used anywhere). 385513 40 89527 rniwa 2011-04-13 22:09:03 -0700 Comment on attachment 89527 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=89527&action=review > Source/WebCore/page/EventHandler.cpp:660 > + VisibleSelection newSelection = m_frame->selection()->selection(); > + VisiblePosition targetPosition = selectionExtentRespectingEditingBoundary(newSelection, hitTestResult.localPoint(), target); You can just pass m_frame->selection()->selection() here since you're not modifying newSelection. That'll avoid copying VisibleSelection needlessly when we're bailing out early. Please make this change and I'll cq+ it. 386119 41 89672 aboxhall 2011-04-14 15:41:39 -0700 Created attachment 89672 Patch 386565 42 89672 commit-queue 2011-04-15 06:45:13 -0700 Comment on attachment 89672 Patch Clearing flags on attachment: 89672 Committed r83967: <http://trac.webkit.org/changeset/83967> 386566 43 commit-queue 2011-04-15 06:45:20 -0700 All reviewed patches have been landed. Closing bug. 386712 44 caseq 2011-04-15 10:19:34 -0700 This caused somewhat strange change of chromium expectations to certain other selection tests: http://test-results.appspot.com/dashboards/flakiness_dashboard.html#showLargeExpectations=true&showExpectations=true&group=%40ToT%20-%20chromium.org&tests=editing%2Fselection%2Fselect-from-textfield-outwards.html%2Cfast%2Fforms%2Finput-text-drag-down.html Does anyone have an idea whether this is safe to rebaseline? 386733 45 ojan 2011-04-15 10:35:21 -0700 (In reply to comment #44) > This caused somewhat strange change of chromium expectations to certain other selection tests: > > http://test-results.appspot.com/dashboards/flakiness_dashboard.html#showLargeExpectations=true&showExpectations=true&group=%40ToT%20-%20chromium.org&tests=editing%2Fselection%2Fselect-from-textfield-outwards.html%2Cfast%2Fforms%2Finput-text-drag-down.html > > Does anyone have an idea whether this is safe to rebaseline? From a quick look at the failures and what the tests are doing, I can't tell if this is fixing a bug or causing one. :) Alice, mind taking a closer look? 386736 46 rniwa 2011-04-15 10:43:21 -0700 Also see https://bugs.webkit.org/show_bug.cgi?id=55552. Looking at the chromium result, the test has regressed. But I'm now sure if it's a bug in WebKit or a bug in the tests. Will take a look later. 386953 47 rniwa 2011-04-15 14:44:30 -0700 I meant to say see https://bugs.webkit.org/show_bug.cgi?id=58664. 387008 48 aboxhall 2011-04-15 16:23:13 -0700 (In reply to comment #46) > Also see https://bugs.webkit.org/show_bug.cgi?id=55552. > > Looking at the chromium result, the test has regressed. But I'm now sure if it's a bug in WebKit or a bug in the tests. Will take a look later. I'm without a workstation till Monday, as our team is moving desks over the weekend. Will take a look on Monday when things are up and running again. 85744 2011-03-14 17:04:22 -0700 2011-03-14 17:04:22 -0700 test case test-case.html text/html 93 noel.gordon PCFET0NUWVBFIGh0bWw+CjxzdHlsZT4KICBkaXYgeyBmbG9hdDogbGVmdDsgfQo8L3N0eWxlPgo8 ZGl2PgogPGlucHV0IHR5cGU9InRleHQiPgo8L2Rpdj4KCgoK 87828 2011-03-31 23:45:30 -0700 2011-04-03 17:30:12 -0700 Patch bug-55552-20110401174527.patch text/plain 10156 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODI2NTcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9yZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1m bG9hdGVkLWVkaXRhYmxlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjlmNjhmNTQ4YmVmOGI4OWQ5YjYzODJlODdl MmRjYjZmZGEwNTY2NmMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3Nl bGVjdGlvbi9yZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzCkBAIC0w LDAgKzEsNDcgQEAKK2Z1bmN0aW9uIGxvZyhtc2cpIHsKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1zZyAr ICdcbicpKTsKK30KKworaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlciAmJiB3aW5kb3cu ZXZlbnRTZW5kZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisK KyAgICB2YXIgeCA9IGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRMZWZ0ICsgKGZsb2F0ZWRFZGl0YWJs ZS5vZmZzZXRXaWR0aCAvIDIpOworICAgIHZhciB5ID0gZmxvYXRlZEVkaXRhYmxlLm9mZnNldFRv cCArIChmbG9hdGVkRWRpdGFibGUub2Zmc2V0SGVpZ2h0IC8gMik7CisgICAgZXZlbnRTZW5kZXIu bW91c2VNb3ZlVG8oeCwgeSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgeCA9 IGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRMZWZ0ICsgZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRo ICsgNTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4LCB5KTsKKyAgICBldmVudFNlbmRl ci5tb3VzZVVwKCk7CisKKyAgICBjaGVja1NlbGVjdGlvbigpOworfSBlbHNlCisgICAgd2luZG93 Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAgICAgICB3aW5kb3cuc2V0VGltZW91dChmdW5j dGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5wdXQgc2VsZWN0aW9uIHN0YXJ0OiAnICsgZ2V0 U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKSArICcsIGVuZDogJyArCisgICAgICAgICAg ICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSkpOworICAgICAgICAgICAgY2hl Y2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7ICAvLyBXaXRob3V0IGEgdGltZW91dCB0aGUg c2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmludGVkCisgICAgfQorCitmdW5jdGlvbiBnZXRT ZWxlY3Rpb25TdGFydChlbCkgeworICAgIHJldHVybiBlbC5pc0NvbnRlbnRFZGl0YWJsZSA/IHdp bmRvdy5nZXRTZWxlY3Rpb24oKS5iYXNlT2Zmc2V0IDogZWwuc2VsZWN0aW9uU3RhcnQ7Cit9CisK K2Z1bmN0aW9uIGdldFNlbGVjdGlvbkVuZChlbCkgeworICAgIHJldHVybiBlbC5pc0NvbnRlbnRF ZGl0YWJsZSA/IHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5leHRlbnRPZmZzZXQgOiBlbC5zZWxlY3Rp b25FbmQ7Cit9CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1dFRl eHQgPSBmbG9hdGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFibGUu dGV4dENvbnRlbnQKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDogZmxvYXRlZEVkaXRhYmxlLnZhbHVlOworICAgIHZhciBpbnB1dFRleHRMZW5n dGggPSBpbnB1dFRleHQubGVuZ3RoOworICAgIHZhciBzZWxlY3Rpb25TdGFydCA9IGdldFNlbGVj dGlvblN0YXJ0KGZsb2F0ZWRFZGl0YWJsZSk7CisgICAgdmFyIHNlbGVjdGlvbkVuZCA9IGdldFNl bGVjdGlvbkVuZChmbG9hdGVkRWRpdGFibGUpOworCisgICAgdmFyIHNlbGVjdGlvblN0YXJ0c0Zy b21NaWRkbGUgPSBzZWxlY3Rpb25TdGFydCA+IDAgJiYgc2VsZWN0aW9uU3RhcnQgPCBpbnB1dFRl eHRMZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvbkdvZXNUb0VuZCA9IHNlbGVjdGlvbkVuZCA9PSBp bnB1dFRleHRMZW5ndGg7CisgICAgaWYgKHNlbGVjdGlvblN0YXJ0c0Zyb21NaWRkbGUgJiYgc2Vs ZWN0aW9uR29lc1RvRW5kKQorICAgICAgICByZXN1bHQuaW5uZXJIVE1MID0gJzxzcGFuIHN0eWxl PSJwYWRkaW5nOiA1cHg7IGJhY2tncm91bmQtY29sb3I6IGdyZWVuIj5TVUNDRVNTPC9zcGFuPic7 CisgICAgZWxzZQorICAgICAgICByZXN1bHQuaW5uZXJIVE1MID0gJzxzcGFuIHN0eWxlPSJwYWRk aW5nOiA1cHg7IGJhY2tncm91bmQtY29sb3I6IHJlZCI+RkFJTDwvc3Bhbj4nOworfQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVk LWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4xY2M4N2VhNTg5ZDU3Zjg2YzcwOWRjNTE3Zjc5MmExOWRjMWM5MTRjCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitT b21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuIERyYWcgZnJvbSB0aGUgbWlkZGxlLiBTb21lIGZs b2F0ZWQgdGV4dCBpbiBhIGRpdi4gU29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCitUbyB0ZXN0 IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgZWRpdGFibGUgZGl2IHRvIHRo ZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQg Z28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJl Z2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcv c2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUuaHRtbCBiL0xh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50 ZWRpdGFibGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zMTUxMjA4OTM3MGM3NmE4Y2RkMjgxMTUzMGYyZWI0 ODdkMGY1MWFkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sCkBAIC0wLDAgKzEs MjEgQEAKKzwhRE9DVFlQRSBodG1sPgorPHN0eWxlPgorICBkaXYgeyBmbG9hdDogbGVmdDsgfQor ICBwIHsgcGFkZGluZy10b3A6IDFlbTsgfQorPC9zdHlsZT4KK1NvbWUgdGV4dCBiZWZvcmUgdGhl IGZsb2F0cy4KKzxkaXYgY29udGVudGVkaXRhYmxlPXRydWUgaWQ9ImZsb2F0ZWRFZGl0YWJsZSI+ RHJhZyBmcm9tIHRoZSBtaWRkbGUuPC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAwJSI+Cisg IFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhl IGZsb2F0cy4KKzxwPgorVG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2Yg dGhlIGVkaXRhYmxlIGRpdiB0byB0aGUKK3JpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0 LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kCitvZiB0aGUgaW5wdXQgZWxlbWVu dCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKzwvcD4KKzxwIGlkPSJyZXN1bHQiPgor PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNj cmlwdCIgc3JjPSJyZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzIj48 L3NjcmlwdD4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2Vs ZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZGMxMzY2NTVkZGEwNDY1NjgxMDFhNGNiMmIxZDMyMmQ5MDE2MzBlZgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitTb21lIHRleHQgYmVm b3JlIHRoZSBmbG9hdHMuIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRleHQgYWZ0 ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9m IHRoZSBpbnB1dCBlbGVtZW50IHRvIHRoZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4 dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVu dCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1p bnB1dC5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1m bG9hdGVkLWlucHV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmVkZDYxM2Q0NzU2MWU2MzcyNjc2OWY2YTEw Nzc4NTFlMDM1NjQ3OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sCkBAIC0wLDAgKzEsMjMgQEAK KzwhRE9DVFlQRSBodG1sPgorPHN0eWxlPgorICBkaXYgeyBmbG9hdDogbGVmdDsgfQorICBwIHsg cGFkZGluZy10b3A6IDFlbTsgfQorPC9zdHlsZT4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0 cy4KKzxkaXY+CisgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iZmxvYXRlZEVkaXRhYmxlIiB2YWx1 ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEw MCUiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4KKzwvZGl2PgorU29tZSB0ZXh0IGFm dGVyIHRoZSBmbG9hdHMuCis8cD4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlk ZGxlIG9mIHRoZSBpbnB1dCBlbGVtZW50IHRvIHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9h dGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1 dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJl c3VsdCI+Cis8L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0IiBzcmM9InJlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFi bGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NTdlYTFjYjY2YjVmYTA2YzdjNzJjNmI5YTE3NGRjOThi ZTUyNTQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v c2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDYg QEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29tZSBmbG9hdGVkIHRleHQgaW4gYSBk aXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBtYW51YWxseSwgZHJhZyBm cm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRoZSByaWdodCwgaW50byB0aGUgbm9u LWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZCBvZiB0aGUg aW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKworU1VDQ0VTUwor CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v c2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMmE2MGUxMGVm MjBlOWM3MDc5ZmFjZjBkZjE5OTlhYTIzNGU4OTBkYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5o dG1sCkBAIC0wLDAgKzEsMjMgQEAKKzwhRE9DVFlQRSBodG1sPgorPHN0eWxlPgorICBkaXYgeyBm bG9hdDogbGVmdDsgfQorICBwIHsgcGFkZGluZy10b3A6IDFlbTsgfQorPC9zdHlsZT4KK1NvbWUg dGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXY+CisgIDx0ZXh0YXJlYSByb3dzPSIxIiBpZD0i ZmxvYXRlZEVkaXRhYmxlIj5EcmFnIGZyb20gdGhlIG1pZGRsZS48L3RleHRhcmVhPgorPC9kaXY+ Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAwJSI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2 LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwPgorVG8gdGVzdCBtYW51 YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRoZQorcmlnaHQs IGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRo ZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5n LgorPC9wPgorPHAgaWQ9InJlc3VsdCI+Cis8L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4K KzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9InJlc291cmNlcy9zZWxlY3Qtb3V0 LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjM3M2Vk ZTgzYjM4MjU3YmYxNWZjNjk2OThmZjNmNTE2YjdiZDhlMC4uOGUyZjIzOTVkMTI3ODdkMzA4NWI2 OGM5NDZhZDNlMmZlYjUzNDA3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDExLTAz LTMxICBBbGljZSBCb3hoYWxsICA8YWJveGhhbGxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRleHQgc2VsZWN0aW9uIGNoYW5n ZXMgdW5leHBlY3RlZGx5IHdoZW4gZHJhZ2dpbmcgb3V0IG9mIHRoZSAmbHQ7aW5wdXQmZ3Q7Cisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01NTU1MgorCisg ICAgICAgIFRlc3Q6IGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1 dC5odG1sCisKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyk6IFdoZW4gZHJh Z2dpbmcgZnJvbSBhbiBlZGl0YWJsZSBlbGVtZW50LCBjaGVjayB0aGF0CisgICAgICAgICAgICB0 aGUgZW5kcG9pbnQgaXMgbm90IG91dHNpZGUgdGhlIGVsZW1lbnQuIElmIGl0IGlzLCB0cmFuc2xh dGUgdGhlIHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4gdGhlCisgICAgICAgICAgICBl ZGl0YWJsZSBlbGVtZW50LgorCiAyMDExLTAzLTMxICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZp ZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByODI2 NTIuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggYjFmNjlkNTQ2NWFiZWIz N2FmYmJjN2ZhNGJiNTljNjg2NWE5MGM2Ni4uOTMzMTk4MGEwMzViYTNkZDM1ZTA1NTZiOGY1ZTky ZGQ2YzU2MmRkZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtNjM3LDE1 ICs2MzcsMjkgQEAgdm9pZCBFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJh ZyhOb2RlKiB0YXJnZXROb2RlLCBjb25zdCBJbnRQb2ludCYKICAgICBpZiAoIXRhcmdldFJlbmRl cmVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBWaXNpYmxlUG9zaXRpb24gdGFyZ2V0UG9zaXRp b24odGFyZ2V0UmVuZGVyZXItPnBvc2l0aW9uRm9yUG9pbnQobG9jYWxQb2ludCkpOworICAgIElu dFBvaW50IHJlYWxMb2NhbFBvaW50KGxvY2FsUG9pbnQpOworICAgIAorICAgIFZpc2libGVTZWxl Y3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpOwor ICAgIEVsZW1lbnQqIGVkaXRhYmxlRWxlbWVudCA9IG5ld1NlbGVjdGlvbi5yb290RWRpdGFibGVF bGVtZW50KCk7CisgICAgaWYgKGVkaXRhYmxlRWxlbWVudCAmJiAhZWRpdGFibGVFbGVtZW50LT5j b250YWlucyh0YXJnZXROb2RlKSkgeworICAgICAgICB0YXJnZXROb2RlID0gZWRpdGFibGVFbGVt ZW50OwogCi0gICAgLy8gRG9uJ3QgbW9kaWZ5IHRoZSBzZWxlY3Rpb24gaWYgd2UncmUgbm90IG9u IGEgbm9kZS4KLSAgICBpZiAodGFyZ2V0UG9zaXRpb24uaXNOdWxsKCkpCi0gICAgICAgIHJldHVy bjsKKyAgICAgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvaW50ID0gdGFyZ2V0UmVuZGVyZXItPmxv Y2FsVG9BYnNvbHV0ZShGbG9hdFBvaW50KHJlYWxMb2NhbFBvaW50KSk7CisgICAgICAgIAorICAg ICAgICB0YXJnZXRSZW5kZXJlciA9IHRhcmdldE5vZGUtPnJlbmRlcmVyKCk7CisgICAgICAgIGlm ICghdGFyZ2V0UmVuZGVyZXIpCisgICAgICAgICAgICByZXR1cm47CiAKKyAgICAgICAgcmVhbExv Y2FsUG9pbnQgPSByb3VuZGVkSW50UG9pbnQodGFyZ2V0UmVuZGVyZXItPmFic29sdXRlVG9Mb2Nh bChhYnNvbHV0ZVBvaW50KSk7CisgICAgfQorICAgIAogICAgIC8vIFJlc3RhcnQgdGhlIHNlbGVj dGlvbiBpZiB0aGlzIGlzIHRoZSBmaXJzdCBtb3VzZSBtb3ZlLiBUaGlzIHdvcmsgaXMgdXN1YWxs eQogICAgIC8vIGRvbmUgaW4gaGFuZGxlTW91c2VQcmVzc0V2ZW50LCBidXQgbm90IGlmIHRoZSBt b3VzZSBwcmVzcyB3YXMgb24gYW4gZXhpc3Rpbmcgc2VsZWN0aW9uLgotICAgIFZpc2libGVTZWxl Y3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpOwor ICAgIFZpc2libGVQb3NpdGlvbiB0YXJnZXRQb3NpdGlvbih0YXJnZXRSZW5kZXJlci0+cG9zaXRp b25Gb3JQb2ludChyZWFsTG9jYWxQb2ludCkpOworCisgICAgLy8gRG9uJ3QgbW9kaWZ5IHRoZSBz ZWxlY3Rpb24gaWYgd2UncmUgbm90IG9uIGEgbm9kZS4KKyAgICBpZiAodGFyZ2V0UG9zaXRpb24u aXNOdWxsKCkpCisgICAgICAgIHJldHVybjsKIAogI2lmIEVOQUJMRShTVkcpCiAgICAgLy8gU3Bl Y2lhbCBjYXNlIHRvIGxpbWl0IHNlbGVjdGlvbiB0byB0aGUgY29udGFpbmluZyBibG9jayBmb3Ig U1ZHIHRleHQuCg== 88024 2011-04-03 17:30:18 -0700 2011-04-10 23:32:10 -0700 Patch bug-55552-20110404103016.patch text/plain 11516 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODI3OTUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhMGUyY2M4MjA4NDVhY2I3YTAxMDdl ZGFlYmVlZGQ3MjI4OGYyMmVkLi41ZGM2ZmUyODc0ZjU2MDc5YWRlMmY3ZDk4NzliOTAwMzNiN2Nm ZjY5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDQtMDMgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlICZsdDtpbnB1dCZndDsKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFn Z2luZyBvdXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxl Y3RzIHRvIHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBp bmcgYmFjayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24v cmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qczogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0 YWJsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAg ICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1m bG9hdGVkLWlucHV0Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1s OiBBZGRlZC4KKwogMjAxMS0wNC0wMyAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgog CiAgICAgICAgIFRyeSB0byBtYWtlIHRoaXMgdGVzdCBtb3JlIHJvYnVzdC4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtZWRpdGFibGUuanMgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9yZXNvdXJj ZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZlNmQ5Mzk5 Njk5YzIyZWZjYTA4MTA5YTkzODJlYjk5NzExNjU0MmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9yZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVk LWVkaXRhYmxlLmpzCkBAIC0wLDAgKzEsNDggQEAKK2Z1bmN0aW9uIGxvZyhtc2cpIHsKKyAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNy ZWF0ZVRleHROb2RlKG1zZyArICdcbicpKTsKK30KKworaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlciAmJiB3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7CisKKyAgICB2YXIgeCA9IGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRMZWZ0 ICsgKGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRXaWR0aCAvIDIpOworICAgIHZhciB5ID0gZmxvYXRl ZEVkaXRhYmxlLm9mZnNldFRvcCArIChmbG9hdGVkRWRpdGFibGUub2Zmc2V0SGVpZ2h0IC8gMik7 CisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oeCwgeSk7CisgICAgZXZlbnRTZW5kZXIubW91 c2VEb3duKCk7CisgICAgeCA9IGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRMZWZ0ICsgZmxvYXRlZEVk aXRhYmxlLm9mZnNldFdpZHRoICsgNTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4LCB5 KTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7CisKKyAgICBjaGVja1NlbGVjdGlvbigpOwor fSBlbHNlIHsKKyAgICB3aW5kb3cub25tb3VzZXVwID0gZnVuY3Rpb24oKSB7CisgICAgICAgIHdp bmRvdy5zZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgbG9nKCdJbnB1dCBzZWxl Y3Rpb24gc3RhcnQ6ICcgKyBnZXRTZWxlY3Rpb25TdGFydChmbG9hdGVkRWRpdGFibGUpICsgJywg ZW5kOiAnICsKKyAgICAgICAgICAgICAgICBnZXRTZWxlY3Rpb25FbmQoZmxvYXRlZEVkaXRhYmxl KSk7CisgICAgICAgICAgICBjaGVja1NlbGVjdGlvbigpOworICAgICAgICB9LCAwKTsgIC8vIFdp dGhvdXQgYSB0aW1lb3V0IHRoZSBzZWxlY3Rpb24gaXMgaW5hY2N1cmF0ZWx5IHByaW50ZWQKKyAg ICB9Cit9CisKK2Z1bmN0aW9uIGdldFNlbGVjdGlvblN0YXJ0KGVsZW1lbnQpIHsKKyAgICByZXR1 cm4gZWxlbWVudC5pc0NvbnRlbnRFZGl0YWJsZSA/IHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5iYXNl T2Zmc2V0IDogZWxlbWVudC5zZWxlY3Rpb25TdGFydDsKK30KKworZnVuY3Rpb24gZ2V0U2VsZWN0 aW9uRW5kKGVsZW1lbnQpIHsKKyAgICByZXR1cm4gZWxlbWVudC5pc0NvbnRlbnRFZGl0YWJsZSA/ IHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5leHRlbnRPZmZzZXQgOiBlbGVtZW50LnNlbGVjdGlvbkVu ZDsKK30KKworZnVuY3Rpb24gY2hlY2tTZWxlY3Rpb24oKSB7CisgICAgdmFyIGlucHV0VGV4dCA9 IGZsb2F0ZWRFZGl0YWJsZS5pc0NvbnRlbnRFZGl0YWJsZSA/IGZsb2F0ZWRFZGl0YWJsZS50ZXh0 Q29udGVudAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIGlucHV0VGV4dExlbmd0aCA9 IGlucHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvblN0YXJ0ID0gZ2V0U2VsZWN0aW9u U3RhcnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2VsZWN0aW9uRW5kID0gZ2V0U2VsZWN0 aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIgc2VsZWN0aW9uU3RhcnRzRnJvbU1p ZGRsZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rpb25TdGFydCA8IGlucHV0VGV4dExl bmd0aDsKKyAgICB2YXIgc2VsZWN0aW9uR29lc1RvRW5kID0gc2VsZWN0aW9uRW5kID09IGlucHV0 VGV4dExlbmd0aDsKKyAgICBpZiAoc2VsZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSAmJiBzZWxlY3Rp b25Hb2VzVG9FbmQpCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5bGU9InBh ZGRpbmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW4iPlNVQ0NFU1M8L3NwYW4+JzsKKyAg ICBlbHNlCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5bGU9InBhZGRpbmc6 IDVweDsgYmFja2dyb3VuZC1jb2xvcjogcmVkIj5GQUlMPC9zcGFuPic7Cit9CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29u dGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9u L3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjFjYzg3ZWE1ODlkNTdmODZjNzA5ZGM1MTdmNzkyYTE5ZGMxYzkxNGMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUg dGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gRHJhZyBmcm9tIHRoZSBtaWRkbGUuIFNvbWUgZmxvYXRl ZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFu dWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBlZGl0YWJsZSBkaXYgdG8gdGhlIHJp Z2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0 byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5u aW5nLgorCitTVUNDRVNTCisKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0 YWJsZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNjZmFmM2JhNTI5Y2YyMzVlNzY2NzBkMWI4ZjRlMzQ4OGEw ZWY1NjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9z ZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWwKQEAgLTAsMCArMSwyMSBA QAorPCFET0NUWVBFIGh0bWw+Cis8c3R5bGU+CisgIGRpdiB7IGZsb2F0OiBsZWZ0OyB9CisgIHAg eyBwYWRkaW5nLXRvcDogMWVtOyB9Cis8L3N0eWxlPgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxv YXRzLgorPGRpdiBjb250ZW50ZWRpdGFibGU9dHJ1ZSBpZD0iZmxvYXRlZEVkaXRhYmxlIj5EcmFn IGZyb20gdGhlIG1pZGRsZS48L2Rpdj4KKzxkaXYgc3R5bGU9IndpZHRoOiAxMDAlIj4KKyAgU29t ZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuCis8L2Rpdj4KK1NvbWUgdGV4dCBhZnRlciB0aGUgZmxv YXRzLgorPHA+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUg ZWRpdGFibGUgZGl2IHRvIHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRo ZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFu ZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+Cis8L3A+ Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2VsZWN0 LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzIj48L3NjcmlwdD4KKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGMxMzY2NTVkZGEwNDY1Njgx MDFhNGNiMmIxZDMyMmQ5MDE2MzBlZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Vk aXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSw2IEBACitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuIFNvbWUgZmxvYXRl ZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFu dWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBpbnB1dCBlbGVtZW50IHRvIHRoZSBy aWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28g dG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lu bmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYjg2MWM1YTY4YmRhMzE5ZmQ0YTljNDNlMjA0MGU5Y2U1ODFmMTg4MQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1pbnB1dC5odG1sCkBAIC0wLDAgKzEsMjMgQEAKKzwhRE9DVFlQRSBodG1sPgorPHN0eWxlPgor ICBkaXYgeyBmbG9hdDogbGVmdDsgfQorICBwIHsgcGFkZGluZy10b3A6IDFlbTsgfQorPC9zdHls ZT4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXY+CisgIDxpbnB1dCB0eXBlPSJ0 ZXh0IiBpZD0iZmxvYXRlZEVkaXRhYmxlIiB2YWx1ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4K KzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCUiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBp biBhIGRpdi4KKzwvZGl2PgorU29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cD4KK1RvIHRl c3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBpbnB1dCBlbGVtZW50IHRv IHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hv dWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0 aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+Cis8L3A+Cis8cHJlIGlkPSJjb25z b2xlIj48L3ByZT4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVk LWVkaXRhYmxlLmpzIj48L3NjcmlwdD4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGlu Zy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0 YXJlYS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODU3ZWExY2I2NmI1ZmEwNmM3YzcyYzZiOWEx NzRkYzk4YmU1MjU0MwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS1leHBlY3RlZC50eHQKQEAgLTAs MCArMSw2IEBACitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuIFNvbWUgZmxvYXRlZCB0ZXh0 IGluIGEgZGl2LiBTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHks IGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSB0ZXh0YXJlYSB0byB0aGUgcmlnaHQsIGludG8g dGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQg b2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCisKK1NV Q0NFU1MKKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxl Y3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE3 NzdhNTgzMTZlZWYzNTE4NTUzNGE0ODdlMzA5ZmY1NTQ5MTZlMmYKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4 dGFyZWEuaHRtbApAQCAtMCwwICsxLDIzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxzdHlsZT4KKyAg ZGl2IHsgZmxvYXQ6IGxlZnQ7IH0KKyAgcCB7IHBhZGRpbmctdG9wOiAxZW07IH0KKzwvc3R5bGU+ CitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8ZGl2PgorICA8dGV4dGFyZWEgcm93cz0i MSIgaWQ9ImZsb2F0ZWRFZGl0YWJsZSI+RHJhZyBmcm9tIHRoZSBtaWRkbGUuPC90ZXh0YXJlYT4K KzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCUiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBp biBhIGRpdi4KKzwvZGl2PgorU29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cD4KK1RvIHRl c3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSB0ZXh0YXJlYSB0byB0aGUK K3JpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBn byB0byB0aGUgZW5kCitvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJl Z2lubmluZy4KKzwvcD4KKzxwIGlkPSJyZXN1bHQiPgorPC9wPgorPHByZSBpZD0iY29uc29sZSI+ PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0 YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBkMzMzYmYyNWMyNzJlNThkY2JiYTU1 ZTQ4NGNlMGVlZDVhNTBmNzFjLi41NzA5MWJhOTM5NDYyMGJiNDQ1YmY1N2RiZjhiY2I3Yzk2ZmQw OWQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDQtMDQgIEFsaWNlIEJveGhh bGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkg d2hlbiBkcmFnZ2luZyBvdXQgb2YgdGhlICZsdDtpbnB1dCZndDsKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHM6IGVk aXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUuaHRt bAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVk LWlucHV0Lmh0bWwKKyAgICAgICAgICAgICAgIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCisKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1v dXNlRHJhZyk6IFdoZW4gZHJhZ2dpbmcgZnJvbSBhbiBlZGl0YWJsZSBlbGVtZW50LCBjaGVjayB0 aGF0CisgICAgICAgICAgICB0aGUgZW5kcG9pbnQgaXMgbm90IG91dHNpZGUgdGhlIGVsZW1lbnQu IElmIGl0IGlzLCB0cmFuc2xhdGUgdGhlIHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4g dGhlCisgICAgICAgICAgICBlZGl0YWJsZSBlbGVtZW50LgorCiAyMDExLTA0LTAzICBEYW4gQmVy bnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFjaWVqIFN0 YWNob3dpYWsuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggMTA0NmMwNGE0 ZjRkNjQyZjY3NjNhZjIyY2Y2OWRkNTM4ZjZmNzQ5Ni4uMjFkZGVlNTIxMTc3NDI4ZTg4N2FiMjQ5 Mzk5MjdiYWRkZDk5ZTNkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhh bmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAt NjM3LDE1ICs2MzcsMjkgQEAgdm9pZCBFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1v dXNlRHJhZyhOb2RlKiB0YXJnZXROb2RlLCBjb25zdCBJbnRQb2ludCYKICAgICBpZiAoIXRhcmdl dFJlbmRlcmVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBWaXNpYmxlUG9zaXRpb24gdGFyZ2V0 UG9zaXRpb24odGFyZ2V0UmVuZGVyZXItPnBvc2l0aW9uRm9yUG9pbnQobG9jYWxQb2ludCkpOwor ICAgIEludFBvaW50IGZpbmFsUG9pbnQgPSBsb2NhbFBvaW50OworICAgIAorICAgIFZpc2libGVT ZWxlY3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigp OworICAgIEVsZW1lbnQqIGVkaXRhYmxlRWxlbWVudCA9IG5ld1NlbGVjdGlvbi5yb290RWRpdGFi bGVFbGVtZW50KCk7CisgICAgaWYgKGVkaXRhYmxlRWxlbWVudCAmJiAhZWRpdGFibGVFbGVtZW50 LT5jb250YWlucyh0YXJnZXROb2RlKSkgeworICAgICAgICB0YXJnZXROb2RlID0gZWRpdGFibGVF bGVtZW50OwogCi0gICAgLy8gRG9uJ3QgbW9kaWZ5IHRoZSBzZWxlY3Rpb24gaWYgd2UncmUgbm90 IG9uIGEgbm9kZS4KLSAgICBpZiAodGFyZ2V0UG9zaXRpb24uaXNOdWxsKCkpCi0gICAgICAgIHJl dHVybjsKKyAgICAgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvaW50ID0gdGFyZ2V0UmVuZGVyZXIt PmxvY2FsVG9BYnNvbHV0ZShGbG9hdFBvaW50KGZpbmFsUG9pbnQpKTsKKyAgICAgICAgCisgICAg ICAgIHRhcmdldFJlbmRlcmVyID0gdGFyZ2V0Tm9kZS0+cmVuZGVyZXIoKTsKKyAgICAgICAgaWYg KCF0YXJnZXRSZW5kZXJlcikKKyAgICAgICAgICAgIHJldHVybjsKIAorICAgICAgICBmaW5hbFBv aW50ID0gcm91bmRlZEludFBvaW50KHRhcmdldFJlbmRlcmVyLT5hYnNvbHV0ZVRvTG9jYWwoYWJz b2x1dGVQb2ludCkpOworICAgIH0KKyAgICAKICAgICAvLyBSZXN0YXJ0IHRoZSBzZWxlY3Rpb24g aWYgdGhpcyBpcyB0aGUgZmlyc3QgbW91c2UgbW92ZS4gVGhpcyB3b3JrIGlzIHVzdWFsbHkKICAg ICAvLyBkb25lIGluIGhhbmRsZU1vdXNlUHJlc3NFdmVudCwgYnV0IG5vdCBpZiB0aGUgbW91c2Ug cHJlc3Mgd2FzIG9uIGFuIGV4aXN0aW5nIHNlbGVjdGlvbi4KLSAgICBWaXNpYmxlU2VsZWN0aW9u IG5ld1NlbGVjdGlvbiA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rpb24oKTsKKyAgICBW aXNpYmxlUG9zaXRpb24gdGFyZ2V0UG9zaXRpb24gPSB0YXJnZXRSZW5kZXJlci0+cG9zaXRpb25G b3JQb2ludChmaW5hbFBvaW50KTsKKworICAgIC8vIERvbid0IG1vZGlmeSB0aGUgc2VsZWN0aW9u IGlmIHdlJ3JlIG5vdCBvbiBhIG5vZGUuCisgICAgaWYgKHRhcmdldFBvc2l0aW9uLmlzTnVsbCgp KQorICAgICAgICByZXR1cm47CiAKICNpZiBFTkFCTEUoU1ZHKQogICAgIC8vIFNwZWNpYWwgY2Fz ZSB0byBsaW1pdCBzZWxlY3Rpb24gdG8gdGhlIGNvbnRhaW5pbmcgYmxvY2sgZm9yIFNWRyB0ZXh0 Lgo= 88192 2011-04-05 02:11:08 -0700 2011-04-05 02:11:08 -0700 test for the bug 52986 select-test.html text/html 2181 rniwa PCFET0NUWVBFIGh0bWw+CjxodG1sPgo8Ym9keT4KPHAgaWQ9ImRlc2NyaXB0aW9uIj5UaGlzIHRl c3QgZW5zdXJlcyB0aGF0IHdoZW4gZWRpdGFibGUgdGV4dCBpcyBzZWxlY3RlZCBieSBhIGRyYWcg dGhhdCBlbmRzIG91dHNpZGUgb2YgdGhlIGVkaXRhYmxlIHJlZ2lvbiwgc2VsZWN0aW9uIGlzIGV4 dGVuZGVkIHRvIHRoZSBlaXRoZXIgZW5kIG9mIHRoZSB0ZXh0LiBTZWUgdGhlIDxhIGhyZWY9Imh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01Mjk4NiI+YnVnIDUyOTg2PC9h PiBmb3IgbW9yZSBkZXRhaWxzLjwvcD4KPGRpdiBpZD0idGVzdCIgY29udGVudGVkaXRhYmxlIHN0 eWxlPSJ3aWR0aDogMjAwcHg7IG1hcmdpbjogMjBweDsgYm9yZGVyOiBzb2xpZCAxcHg7IGZvbnQt c2l6ZTogeC1sYXJnZTsiPmhlbGxvIHdvcmxkPC9kaXY+CjxzY3JpcHQ+CgpmdW5jdGlvbiBzZWxl Y3RUZXh0QnlEcmFnKGRpdiwgZW5kWCwgZW5kWSkgewogICAgd2luZG93LmdldFNlbGVjdGlvbigp LnJlbW92ZUFsbFJhbmdlcygpOwoKICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKGRpdi5vZmZz ZXRMZWZ0ICsgKGRpdi5vZmZzZXRXaWR0aCAvIDIpICwgZGl2Lm9mZnNldFRvcCArIChkaXYub2Zm c2V0SGVpZ2h0IC8gMikpOwogICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CgogICAgZXZlbnRT ZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKCiAgICAvLyBXaXRob3V0IHRoaXMsIGRyYWcgZG9lc24n dCBzdGFydCBzZWxlY3Rpb24uCiAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyhkaXYub2Zmc2V0 TGVmdCArIChkaXYub2Zmc2V0V2lkdGggLyAzKSAsIGRpdi5vZmZzZXRUb3AgKyAoZGl2Lm9mZnNl dEhlaWdodCAvIDMpKTsKICAgIGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOwoKICAgIGV2ZW50U2Vu ZGVyLmxlYXBGb3J3YXJkKDIwMCk7CgogICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZW5kWCwg ZW5kWSk7CiAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cn0KCnZhciBsb2cgPSAnJzsKCmZ1bmN0 aW9uIGFzc2VydEVxdWFsKGFjdHVhbCwgZXhwZWN0ZWQpIHsKICAgIGlmIChhY3R1YWwgPT0gZXhw ZWN0ZWQpCiAgICAgICAgbG9nICs9ICdQQVNTJzsKICAgIGVsc2UKICAgICAgICBsb2cgKz0gJ0ZB SUwgLSBleHBlY3RlZCAnICsgZXhwZWN0ZWQgKyAnIGJ1dCBnb3QgJyArIGFjdHVhbDsKICAgIGxv ZyArPSAnXG4nOwp9CgppZiAoIXdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlciB8fCAhd2luZG93 LmV2ZW50U2VuZGVyKQogICAgZG9jdW1lbnQud3JpdGVsbigiVGhpcyB0ZXN0IHJlcXVpcmVzIGV2 ZW50U2VuZGVyIHNpbmNlIHRoZSBidWcgZG9lcyBub3QgcmVwcm9kdWNlIHJlbGlhYmx5IHdoZW4g dGVzdGVkIG1hbnVhbGx5LiIpOwplbHNlIHsKICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKICAgIHZhciBkZXNjcmlwdGlvbiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdk ZXNjcmlwdGlvbicpOwogICAgZGVzY3JpcHRpb24uc3R5bGUuZGlzcGxheSA9ICdub25lJzsKCiAg ICB2YXIgZGl2ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsKCiAgICBsb2cgKz0g J0RyYWdnaW5nIHRvIHRoZSBsZWZ0OiAnOwogICAgc2VsZWN0VGV4dEJ5RHJhZyhkaXYsIGRpdi5v ZmZzZXRMZWZ0IC0gMTAsIGRpdi5vZmZzZXRUb3AgLSAxMCk7CiAgICBhc3NlcnRFcXVhbCh3aW5k b3cuZ2V0U2VsZWN0aW9uKCkuZ2V0UmFuZ2VBdCgwKS5zdGFydE9mZnNldCwgMCk7CgogICAgbG9n ICs9ICdEcmFnZ2luZyB0byB0aGUgbGVmdDogJzsKICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBk aXYub2Zmc2V0TGVmdCArIDMwMCwgZGl2Lm9mZnNldFRvcCArIDEwMCk7CiAgICBhc3NlcnRFcXVh bCh3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZ2V0UmFuZ2VBdCgwKS5lbmRPZmZzZXQsIGRpdi5pbm5l clRleHQubGVuZ3RoKTsKCiAgICAvLyBIYXZpbmcgdGhlIGxvZyBpbiBET00gd2lsbCBpbnRlcmZl cmUgd2l0aCB0aGUgdGVzdCBzbyBhcHBlbmQgaXQgYXQgbGFzdC4KICAgIHZhciBjb25zb2xlID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgncHJlJyk7CiAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENo aWxkKGNvbnNvbGUpOwogICAgY29uc29sZS5pbm5lckhUTUwgPSBsb2c7Cn0KCjwvc2NyaXB0Pgo8 L2JvZHk+CjwvaHRtbD4K 88970 2011-04-10 23:32:18 -0700 2011-04-11 22:30:17 -0700 Patch bug-55552-20110411163215.patch text/plain 13282 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM0MTYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZjBiNGM1MTEzZGMyMTU1ZTQwYzAz MzZlZTA0MjQ0OTEwNmVhZDRlLi5lYjhmNWFmZTg5YjUzNzczMzMwZDIxMWE2NzRmNmVlYjg3NmRi NWZmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsNDEgQEAKKzIwMTEtMDQtMTAgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9y ZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzOiBBZGRlZC4KKyAgICAg ICAgKGxvZyk6CisgICAgICAgIChlbHNlLndpbmRvdy5vbm1vdXNldXApOgorICAgICAgICAoZ2V0 U2VsZWN0aW9uU3RhcnQpOgorICAgICAgICAoZ2V0U2VsZWN0aW9uRW5kKToKKyAgICAgICAgKGNo ZWNrU2VsZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9m LWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICog ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbDogQWRkZWQuCisgICAgICAgICog ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1m bG9hdGVkLXRleHRhcmVhLmh0bWw6IEFkZGVkLgorCisyMDExLTA0LTAzICBBbGljZSBCb3hoYWxs ICA8YWJveGhhbGxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFRleHQgc2VsZWN0aW9uIGNoYW5nZXMgdW5leHBlY3RlZGx5IHdo ZW4gZHJhZ2dpbmcgb3V0IG9mIHRoZSAmbHQ7aW5wdXQmZ3Q7CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01NTU1MgorCisgICAgICAgIFRlc3RzIHRoYXQg ZHJhZ2dpbmcgb3V0c2lkZSBvZiBhIGNvbnRlbnRlZGl0YWJsZSwgaW5wdXQgb3IgdGV4dGFyZWEg c2VsZWN0cyB0byB0aGUgZW5kIG9mIHRoZQorICAgICAgICBlbGVtZW50LCByYXRoZXIgdGhhbiBq dW1waW5nIGJhY2sgdG8gdGhlIGJlZ2lubmluZy4KKworICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanM6IEFkZGVkLgor ICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50 ZWRpdGFibGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlv bi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWw6IEFkZGVkLgorICAg ICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZmxvYXRlZC1pbnB1dC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlv bi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAg ICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEu aHRtbDogQWRkZWQuCisKIDIwMTEtMDQtMTAgIE1pa2UgTGF3dGhlciAgPG1pa2VsYXd0aGVyQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBPamFuIFZhZmFpLgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vcmVzb3VyY2VzL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291 cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmU2ZDkz OTk2OTljMjJlZmNhMDgxMDlhOTM4MmViOTk3MTE2NTQyZgotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0OCBAQAorZnVuY3Rpb24gbG9nKG1zZykgeworICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQu Y3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQorCitpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikgeworICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4ID0gZmxvYXRlZEVkaXRhYmxlLm9mZnNldExl ZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRoIC8gMik7CisgICAgdmFyIHkgPSBmbG9h dGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0ZWRFZGl0YWJsZS5vZmZzZXRIZWlnaHQgLyAy KTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4LCB5KTsKKyAgICBldmVudFNlbmRlci5t b3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVkaXRhYmxlLm9mZnNldExlZnQgKyBmbG9hdGVk RWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgs IHkpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlVXAoKTsKKworICAgIGNoZWNrU2VsZWN0aW9uKCk7 Cit9IGVsc2UgeworICAgIHdpbmRvdy5vbm1vdXNldXAgPSBmdW5jdGlvbigpIHsKKyAgICAgICAg d2luZG93LnNldFRpbWVvdXQoZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBsb2coJ0lucHV0IHNl bGVjdGlvbiBzdGFydDogJyArIGdldFNlbGVjdGlvblN0YXJ0KGZsb2F0ZWRFZGl0YWJsZSkgKyAn LCBlbmQ6ICcgKworICAgICAgICAgICAgICAgIGdldFNlbGVjdGlvbkVuZChmbG9hdGVkRWRpdGFi bGUpKTsKKyAgICAgICAgICAgIGNoZWNrU2VsZWN0aW9uKCk7CisgICAgICAgIH0sIDApOyAgLy8g V2l0aG91dCBhIHRpbWVvdXQgdGhlIHNlbGVjdGlvbiBpcyBpbmFjY3VyYXRlbHkgcHJpbnRlZAor ICAgIH0KK30KKworZnVuY3Rpb24gZ2V0U2VsZWN0aW9uU3RhcnQoZWxlbWVudCkgeworICAgIHJl dHVybiBlbGVtZW50LmlzQ29udGVudEVkaXRhYmxlID8gd2luZG93LmdldFNlbGVjdGlvbigpLmJh c2VPZmZzZXQgOiBlbGVtZW50LnNlbGVjdGlvblN0YXJ0OworfQorCitmdW5jdGlvbiBnZXRTZWxl Y3Rpb25FbmQoZWxlbWVudCkgeworICAgIHJldHVybiBlbGVtZW50LmlzQ29udGVudEVkaXRhYmxl ID8gd2luZG93LmdldFNlbGVjdGlvbigpLmV4dGVudE9mZnNldCA6IGVsZW1lbnQuc2VsZWN0aW9u RW5kOworfQorCitmdW5jdGlvbiBjaGVja1NlbGVjdGlvbigpIHsKKyAgICB2YXIgaW5wdXRUZXh0 ID0gZmxvYXRlZEVkaXRhYmxlLmlzQ29udGVudEVkaXRhYmxlID8gZmxvYXRlZEVkaXRhYmxlLnRl eHRDb250ZW50CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICA6IGZsb2F0ZWRFZGl0YWJsZS52YWx1ZTsKKyAgICB2YXIgaW5wdXRUZXh0TGVuZ3Ro ID0gaW5wdXRUZXh0Lmxlbmd0aDsKKyAgICB2YXIgc2VsZWN0aW9uU3RhcnQgPSBnZXRTZWxlY3Rp b25TdGFydChmbG9hdGVkRWRpdGFibGUpOworICAgIHZhciBzZWxlY3Rpb25FbmQgPSBnZXRTZWxl Y3Rpb25FbmQoZmxvYXRlZEVkaXRhYmxlKTsKKworICAgIHZhciBzZWxlY3Rpb25TdGFydHNGcm9t TWlkZGxlID0gc2VsZWN0aW9uU3RhcnQgPiAwICYmIHNlbGVjdGlvblN0YXJ0IDwgaW5wdXRUZXh0 TGVuZ3RoOworICAgIHZhciBzZWxlY3Rpb25Hb2VzVG9FbmQgPSBzZWxlY3Rpb25FbmQgPT0gaW5w dXRUZXh0TGVuZ3RoOworICAgIGlmIChzZWxlY3Rpb25TdGFydHNGcm9tTWlkZGxlICYmIHNlbGVj dGlvbkdvZXNUb0VuZCkKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8c3BhbiBzdHlsZT0i cGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVlbiI+U1VDQ0VTUzwvc3Bhbj4nOwor ICAgIGVsc2UKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8c3BhbiBzdHlsZT0icGFkZGlu ZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZBSUw8L3NwYW4+JzsKK30KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1j b250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uMWNjODdlYTU4OWQ1N2Y4NmM3MDlkYzUxN2Y3OTJhMTlkYzFjOTE0YwotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1jb250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29t ZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLiBEcmFnIGZyb20gdGhlIG1pZGRsZS4gU29tZSBmbG9h dGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBt YW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIGVkaXRhYmxlIGRpdiB0byB0aGUg cmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdv IHRvIHRoZSBlbmQgb2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdp bm5pbmcuCisKK1NVQ0NFU1MKKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3Nl bGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWwgYi9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVk aXRhYmxlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2NmYWYzYmE1MjljZjIzNWU3NjY3MGQxYjhmNGUzNDg4 YTBlZjU2OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9u L3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUuaHRtbApAQCAtMCwwICsxLDIx IEBACis8IURPQ1RZUEUgaHRtbD4KKzxzdHlsZT4KKyAgZGl2IHsgZmxvYXQ6IGxlZnQ7IH0KKyAg cCB7IHBhZGRpbmctdG9wOiAxZW07IH0KKzwvc3R5bGU+CitTb21lIHRleHQgYmVmb3JlIHRoZSBm bG9hdHMuCis8ZGl2IGNvbnRlbnRlZGl0YWJsZT10cnVlIGlkPSJmbG9hdGVkRWRpdGFibGUiPkRy YWcgZnJvbSB0aGUgbWlkZGxlLjwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCUiPgorICBT b21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4KKzwvZGl2PgorU29tZSB0ZXh0IGFmdGVyIHRoZSBm bG9hdHMuCis8cD4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRo ZSBlZGl0YWJsZSBkaXYgdG8gdGhlCityaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4g VGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZAorb2YgdGhlIGlucHV0IGVsZW1lbnQg YW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCis8L3A+Cis8cCBpZD0icmVzdWx0Ij4KKzwv cD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zZWxl Y3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kYzEzNjY1NWRkYTA0NjU2 ODEwMWE0Y2IyYjFkMzIyZDkwMTYzMGVmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29tZSBmbG9h dGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBt YW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIGlucHV0IGVsZW1lbnQgdG8gdGhl IHJpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBn byB0byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVn aW5uaW5nLgorCitTVUNDRVNTCisKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9z ZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5iODYxYzVhNjhiZGEzMTlmZDRhOWM0M2UyMDQwZTljZTU4MWYxODgxCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9h dGVkLWlucHV0Lmh0bWwKQEAgLTAsMCArMSwyMyBAQAorPCFET0NUWVBFIGh0bWw+Cis8c3R5bGU+ CisgIGRpdiB7IGZsb2F0OiBsZWZ0OyB9CisgIHAgeyBwYWRkaW5nLXRvcDogMWVtOyB9Cis8L3N0 eWxlPgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLgorPGRpdj4KKyAgPGlucHV0IHR5cGU9 InRleHQiIGlkPSJmbG9hdGVkRWRpdGFibGUiIHZhbHVlPSJEcmFnIGZyb20gdGhlIG1pZGRsZS4i PgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAwJSI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0 IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwPgorVG8g dGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIGlucHV0IGVsZW1lbnQg dG8gdGhlCityaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBz aG91bGQgZ28gdG8gdGhlIGVuZAorb2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBqdW1wIHRv IHRoZSBiZWdpbm5pbmcuCis8L3A+Cis8cCBpZD0icmVzdWx0Ij4KKzwvcD4KKzxwcmUgaWQ9ImNv bnNvbGUiPjwvcHJlPgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRl eHRhcmVhLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NTdlYTFjYjY2YjVmYTA2YzdjNzJjNmI5 YTE3NGRjOThiZTUyNTQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9z ZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApAQCAt MCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29tZSBmbG9hdGVkIHRl eHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBtYW51YWxs eSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRoZSByaWdodCwgaW50 byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVu ZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKwor U1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9z ZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YTc3N2E1ODMxNmVlZjM1MTg1NTM0YTQ4N2UzMDlmZjU1NDkxNmUyZgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10 ZXh0YXJlYS5odG1sCkBAIC0wLDAgKzEsMjMgQEAKKzwhRE9DVFlQRSBodG1sPgorPHN0eWxlPgor ICBkaXYgeyBmbG9hdDogbGVmdDsgfQorICBwIHsgcGFkZGluZy10b3A6IDFlbTsgfQorPC9zdHls ZT4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXY+CisgIDx0ZXh0YXJlYSByb3dz PSIxIiBpZD0iZmxvYXRlZEVkaXRhYmxlIj5EcmFnIGZyb20gdGhlIG1pZGRsZS48L3RleHRhcmVh PgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAwJSI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0 IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwPgorVG8g dGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRo ZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxk IGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUg YmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+Cis8L3A+Cis8cHJlIGlkPSJjb25zb2xl Ij48L3ByZT4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1mbG9hdGVkLWVk aXRhYmxlLmpzIj48L3NjcmlwdD4KKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDlkMjA3NGY5YzVlOGJiMmQ5ZmZi NmNkNTk5NmYzYjA0ODk0OTMzZjguLmJjZGU1NWQ5YTc1NjIwZWE1MTczMmNiNTI5YjI1MGNjODUz YjRjZGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMS0wNC0xMCAgQWxpY2UgQm94 aGFsbCAgPGFib3hoYWxsQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUZXh0IHNlbGVjdGlvbiBjaGFuZ2VzIHVuZXhwZWN0ZWRs eSB3aGVuIGRyYWdnaW5nIG91dCBvZiB0aGUgJmx0O2lucHV0Jmd0OworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTU1NTIKKworICAgICAgICBUZXN0czog ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5o dG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtaW5wdXQuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91 dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKKworICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9p bnQpOiBXaGVuIGRyYWdnaW5nIGZyb20gYW4gZWRpdGFibGUgZWxlbWVudCwgY2hlY2sgdGhhdAor ICAgICAgICAgICAgdGhlIGVuZHBvaW50IGlzIG5vdCBvdXRzaWRlIHRoZSBlbGVtZW50LiBJZiBp dCBpcywgdHJhbnNsYXRlIHRoZSBwb2ludCBpbnRvIGEgbG9jYWwgcG9pbnQgd2l0aGluIHRoZQor ICAgICAgICAgICAgZWRpdGFibGUgZWxlbWVudC4KKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFu ZGxlcjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKTogQ2FsbCB0YXJnZXRQb3NpdGlvbkZv clNlbGVjdGlvbkVuZHBvaW50KCkgdG8KKyAgICAgICAgICAgIGNhbGN1bGF0ZSB0aGUgc2VsZWN0 aW9uIGVuZHBvaW50LgorCiAyMDExLTA0LTEwICBNaWtlIExhd3RoZXIgIDxtaWtlbGF3dGhlckBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCBjMzkzZTFmNzZiNDhjM2NjZDAzNjJiNDEzMzBk OWYzZWM4MmQ0MjkyLi45ZTEyY2UyN2RkY2Y4MGNiM2MyZDI5N2U3YTljNWE5MTE2NDhmMjU5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC02MjIsNiArNjIyLDI1IEBAIHZv aWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWcoKQogICAgIHVwZGF0 ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyhyZXN1bHQpOwogfQogCitzdGF0aWMgVmlzaWJsZVBvc2l0 aW9uIHRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9pbnQoY29uc3QgVmlzaWJsZVNlbGVj dGlvbiYgc2VsZWN0aW9uLCBjb25zdCBJbnRQb2ludCYgbG9jYWxQb2ludCwgTm9kZSogdGFyZ2V0 Tm9kZSkKK3sKKyAgICBFbGVtZW50KiBlZGl0YWJsZUVsZW1lbnQgPSBzZWxlY3Rpb24ucm9vdEVk aXRhYmxlRWxlbWVudCgpOworICAgIEludFBvaW50IHNlbGVjdGlvbkVuZFBvaW50ID0gbG9jYWxQ b2ludDsKKyAgICBOb2RlKiBzZWxlY3Rpb25FbmROb2RlID0gdGFyZ2V0Tm9kZTsKKworICAgIGlm IChlZGl0YWJsZUVsZW1lbnQgJiYgIWVkaXRhYmxlRWxlbWVudC0+Y29udGFpbnModGFyZ2V0Tm9k ZSkpIHsKKyAgICAgICAgLy8gSWYgc2VsZWN0aW5nIG91dCBvZiBhbiBlZGl0YWJsZSBlbGVtZW50 LCB0cmFuc2xhdGUgdGhlIGVuZHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4gdGhlIAor ICAgICAgICAvLyBlZGl0YWJsZSBlbGVtZW50LCB0byBhdm9pZCBjb25mdXNpbmcgYmVoYXZpb3Vy IHdoaWNoIGNhbiBvY2N1ciB3aGVuIGRyYWdnaW5nIGludG8gYSBub2RlIHdoaWNoIGlzCisgICAg ICAgIC8vIGVhcmxpZXIgaW4gdGhlIERPTS4KKyAgICAgICAgc2VsZWN0aW9uRW5kTm9kZSA9IGVk aXRhYmxlRWxlbWVudDsKKyAgICAgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvaW50ID0gdGFyZ2V0 Tm9kZS0+cmVuZGVyZXIoKS0+bG9jYWxUb0Fic29sdXRlKEZsb2F0UG9pbnQoc2VsZWN0aW9uRW5k UG9pbnQpKTsKKworICAgICAgICBzZWxlY3Rpb25FbmRQb2ludCA9IHJvdW5kZWRJbnRQb2ludChz ZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpLT5hYnNvbHV0ZVRvTG9jYWwoYWJzb2x1dGVQb2lu dCkpOworICAgIH0KKworICAgIHJldHVybiBzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpLT5w b3NpdGlvbkZvclBvaW50KHNlbGVjdGlvbkVuZFBvaW50KTsKK30KKwogdm9pZCBFdmVudEhhbmRs ZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyhjb25zdCBIaXRUZXN0UmVzdWx0JiBoaXRU ZXN0UmVzdWx0KQogewogICAgIGlmICghbV9tb3VzZURvd25NYXlTdGFydFNlbGVjdCkKQEAgLTYz OCwxNiArNjU3LDEzIEBAIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3Vz ZURyYWcoY29uc3QgSGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJlc3VsCiAgICAgaWYgKCF0YXJnZXRS ZW5kZXJlcikKICAgICAgICAgcmV0dXJuOwogCi0gICAgVmlzaWJsZVBvc2l0aW9uIHRhcmdldFBv c2l0aW9uID0gdGFyZ2V0UmVuZGVyZXItPnBvc2l0aW9uRm9yUG9pbnQoaGl0VGVzdFJlc3VsdC5s b2NhbFBvaW50KCkpOworICAgIFZpc2libGVTZWxlY3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFt ZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpOworICAgIFZpc2libGVQb3NpdGlvbiB0YXJnZXRQ b3NpdGlvbiA9IHRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9pbnQobmV3U2VsZWN0aW9u LCBoaXRUZXN0UmVzdWx0LmxvY2FsUG9pbnQoKSwgdGFyZ2V0KTsKIAogICAgIC8vIERvbid0IG1v ZGlmeSB0aGUgc2VsZWN0aW9uIGlmIHdlJ3JlIG5vdCBvbiBhIG5vZGUuCiAgICAgaWYgKHRhcmdl dFBvc2l0aW9uLmlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBSZXN0YXJ0IHRo ZSBzZWxlY3Rpb24gaWYgdGhpcyBpcyB0aGUgZmlyc3QgbW91c2UgbW92ZS4gVGhpcyB3b3JrIGlz IHVzdWFsbHkKLSAgICAvLyBkb25lIGluIGhhbmRsZU1vdXNlUHJlc3NFdmVudCwgYnV0IG5vdCBp ZiB0aGUgbW91c2UgcHJlc3Mgd2FzIG9uIGFuIGV4aXN0aW5nIHNlbGVjdGlvbi4KLSAgICBWaXNp YmxlU2VsZWN0aW9uIG5ld1NlbGVjdGlvbiA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rp b24oKTsKLQogI2lmIEVOQUJMRShTVkcpCiAgICAgLy8gU3BlY2lhbCBjYXNlIHRvIGxpbWl0IHNl bGVjdGlvbiB0byB0aGUgY29udGFpbmluZyBibG9jayBmb3IgU1ZHIHRleHQuCiAgICAgLy8gRklY TUU6IElzbid0IHRoZXJlIGEgYmV0dGVyIG5vbi1TVkctc3BlY2lmaWMgd2F5IHRvIGRvIHRoaXM/ Cg== 89157 2011-04-11 22:30:24 -0700 2011-04-12 18:08:56 -0700 Patch bug-55552-20110412153021.patch text/plain 12515 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM0MTYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZjBiNGM1MTEzZGMyMTU1ZTQwYzAz MzZlZTA0MjQ0OTEwNmVhZDRlLi45MjFmNjA5OWYwY2FiMGE1ZTQ5ZDk0ZGRlYzMzODIxNDk0YmNm N2I3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFnZ2luZyBv dXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxlY3RzIHRv IHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBpbmcgYmFj ayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Qtb3V0LW9mLWVk aXRhYmxlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Qtb3V0 LW9mLWVkaXRhYmxlLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Jl c291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanM6IEFkZGVkLgorICAgICAg ICAobG9nKToKKyAgICAgICAgKGVsc2Uud2luZG93Lm9ubW91c2V1cCk6CisgICAgICAgIChnZXRT ZWxlY3Rpb25TdGFydCk6CisgICAgICAgIChnZXRTZWxlY3Rpb25FbmQpOgorICAgICAgICAoY2hl Y2tTZWxlY3Rpb24pOgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1jb250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBl ZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxv YXRlZC1pbnB1dC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBl ZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtdGV4dGFyZWEuaHRtbDogQWRkZWQuCisKIDIwMTEtMDQtMTAgIE1pa2UgTGF3dGhlciAg PG1pa2VsYXd0aGVyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBPamFuIFZh ZmFpLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vcmVzb3VyY2Vz L3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRlc3RzL2VkaXRpbmcv c2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZWQyMThlNTJiNzQ2NTBlN2E5YjMzYzAxNWE1ZmYyOGE3OTQwODA1YgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxl Y3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0OCBAQAorZnVuY3Rpb24g bG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5k Q2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQorCitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikgeworICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4ID0gZmxvYXRlZEVk aXRhYmxlLm9mZnNldExlZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRoIC8gMik7Cisg ICAgdmFyIHkgPSBmbG9hdGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0ZWRFZGl0YWJsZS5v ZmZzZXRIZWlnaHQgLyAyKTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4LCB5KTsKKyAg ICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVkaXRhYmxlLm9mZnNl dExlZnQgKyBmbG9hdGVkRWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAgIGV2ZW50U2VuZGVy Lm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3YXJkKDEwMCk7Cisg ICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworCisgICAgY2hlY2tTZWxlY3Rpb24oKTsKK30gZWxz ZSB7CisgICAgd2luZG93Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAgICAgICB3aW5kb3cu c2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5wdXQgc2VsZWN0aW9u IHN0YXJ0OiAnICsgZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKSArICcsIGVuZDog JyArCisgICAgICAgICAgICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSkpOwor ICAgICAgICAgICAgY2hlY2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7ICAvLyBXaXRob3V0 IGEgdGltZW91dCB0aGUgc2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmludGVkCisgICAgfQor fQorCitmdW5jdGlvbiBnZXRTZWxlY3Rpb25TdGFydChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVs ZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuYmFzZU9mZnNl dCA6IGVsZW1lbnQuc2VsZWN0aW9uU3RhcnQ7Cit9CisKK2Z1bmN0aW9uIGdldFNlbGVjdGlvbkVu ZChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5k b3cuZ2V0U2VsZWN0aW9uKCkuZXh0ZW50T2Zmc2V0IDogZWxlbWVudC5zZWxlY3Rpb25FbmQ7Cit9 CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1dFRleHQgPSBmbG9h dGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFibGUudGV4dENvbnRl bnQgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIGlucHV0VGV4dExlbmd0aCA9IGlu cHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvblN0YXJ0ID0gZ2V0U2VsZWN0aW9uU3Rh cnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2VsZWN0aW9uRW5kID0gZ2V0U2VsZWN0aW9u RW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIgc2VsZWN0aW9uU3RhcnRzRnJvbU1pZGRs ZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rpb25TdGFydCA8IGlucHV0VGV4dExlbmd0 aDsKKyAgICB2YXIgc2VsZWN0aW9uR29lc1RvRW5kID0gc2VsZWN0aW9uRW5kID09IGlucHV0VGV4 dExlbmd0aDsKKyAgICBpZiAoc2VsZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSAmJiBzZWxlY3Rpb25H b2VzVG9FbmQpCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5bGU9InBhZGRp bmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW4iPlNVQ0NFU1M8L3NwYW4+JzsKKyAgICBl bHNlCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5bGU9InBhZGRpbmc6IDVw eDsgYmFja2dyb3VuZC1jb2xvcjogcmVkIj5GQUlMPC9zcGFuPic7Cit9CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVu dGVkaXRhYmxlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjFjYzg3ZWE1ODlkNTdmODZjNzA5ZGM1MTdmNzkyYTE5ZGMxYzkxNGMKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4 dCBiZWZvcmUgdGhlIGZsb2F0cy4gRHJhZyBmcm9tIHRoZSBtaWRkbGUuIFNvbWUgZmxvYXRlZCB0 ZXh0IGluIGEgZGl2LiBTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFs bHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBlZGl0YWJsZSBkaXYgdG8gdGhlIHJpZ2h0 LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0 aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5n LgorCitTVUNDRVNTCisKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJs ZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmI2ZGE0ODAyYTQwZTU5ZTZlYzRmODRkNDg3NzljYjVjZmRjZmFk M2QKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxl Y3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAor PCFET0NUWVBFIGh0bWw+CitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8ZGl2IGNvbnRl bnRlZGl0YWJsZT10cnVlIGlkPSJmbG9hdGVkRWRpdGFibGUiIHN0eWxlPSJmbG9hdDogbGVmdDsi PgorICBEcmFnIGZyb20gdGhlIG1pZGRsZS4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEw MCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+ CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRvcDogMWVt OyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgZWRpdGFi bGUgZGl2IHRvIHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxl Y3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3Qg anVtcCB0byB0aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBp ZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1lZGl0YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQt aW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRjMTM2NjU1ZGRhMDQ2NTY4MTAxYTRjYjJi MWQzMjJkOTAxNjMwZWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3Nl bGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAg KzEsNiBAQAorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLiBTb21lIGZsb2F0ZWQgdGV4dCBp biBhIGRpdi4gU29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCitUbyB0ZXN0IG1hbnVhbGx5LCBk cmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgaW5wdXQgZWxlbWVudCB0byB0aGUgcmlnaHQsIGlu dG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBl bmQgb2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCisK K1NVQ0NFU1MKKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9z ZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJmM2Y0 ZTUzZTI3YWY3MTQzZjg4MDY3NmVkM2M1MWMwZjYzZjIzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQu aHRtbApAQCAtMCwwICsxLDE4IEBACis8IURPQ1RZUEUgaHRtbD4KK1NvbWUgdGV4dCBiZWZvcmUg dGhlIGZsb2F0cy4KKzxkaXYgc3R5bGU9ImZsb2F0OiBsZWZ0OyI+CisgIDxpbnB1dCB0eXBlPSJ0 ZXh0IiBpZD0iZmxvYXRlZEVkaXRhYmxlIiB2YWx1ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4K KzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUg ZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0 cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFn IGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgaW5wdXQgZWxlbWVudCB0byB0aGUKK3JpZ2h0LCBpbnRv IHRoZSBub24tZmxvYXRlZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5k CitvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKzwv cD4KKzxwIGlkPSJyZXN1bHQiPjwvcD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlw dCBzcmM9InJlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2Ny aXB0PgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qt b3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi44NTdlYTFjYjY2YjVmYTA2YzdjNzJjNmI5YTE3NGRjOThiZTUyNTQzCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4 dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29tZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4 dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRk bGUgb2YgdGhlIHRleHRhcmVhIHRvIHRoZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4 dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVu dCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10 ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDBmYjhjYTkyNTYzMzVlYzM5NTUx YjA5ZGQ5NTA5YzM4NmE1YzhiNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCkBAIC0wLDAg KzEsMTggQEAKKzwhRE9DVFlQRSBodG1sPgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLgor PGRpdiBzdHlsZT0iZmxvYXQ6IGxlZnQ7Ij4KKyAgPHRleHRhcmVhIHJvd3M9IjEiIGlkPSJmbG9h dGVkRWRpdGFibGUiPkRyYWcgZnJvbSB0aGUgbWlkZGxlLjwvdGV4dGFyZWE+Cis8L2Rpdj4KKzxk aXYgc3R5bGU9IndpZHRoOiAxMDAlOyBmbG9hdDogbGVmdDsiPgorICBTb21lIGZsb2F0ZWQgdGV4 dCBpbiBhIGRpdi4KKzwvZGl2PgorU29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cCBzdHls ZT0icGFkZGluZy10b3A6IDFlbTsiPgorVG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBt aWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVk IHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBl bGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3Vs dCI+PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2Vz L3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpp bmRleCA5ZDIwNzRmOWM1ZThiYjJkOWZmYjZjZDU5OTZmM2IwNDg5NDkzM2Y4Li5mZjA3OTIxNjIw MTRhMjA1YjJhODg0NWU0NzRhZjc5MTQxOGZjMDkzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIg QEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGV4dCBzZWxl Y3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBkcmFnZ2luZyBvdXQgb2YgdGhlICZsdDtp bnB1dCZndDsKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTU1NTUyCisKKyAgICAgICAgVGVzdHM6IGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZWRpdGFibGUuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91 dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sCisgICAgICAgICAgICAgICBlZGl0aW5n L3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbAorICAgICAgICAgICAg ICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwK KworICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRh cmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9pbnQpOiBXaGVuIGRyYWdnaW5nIGZyb20gYW4g ZWRpdGFibGUgZWxlbWVudCwgY2hlY2sgdGhhdAorICAgICAgICB0aGUgZW5kcG9pbnQgaXMgbm90 IG91dHNpZGUgdGhlIGVsZW1lbnQuIElmIGl0IGlzLCB0cmFuc2xhdGUgdGhlIHBvaW50IGludG8g YSBsb2NhbCBwb2ludCB3aXRoaW4KKyAgICAgICAgdGhlIGVkaXRhYmxlIGVsZW1lbnQuCisgICAg ICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyk6 IENhbGwgdGFyZ2V0UG9zaXRpb25Gb3JTZWxlY3Rpb25FbmRwb2ludCgpIHRvCisgICAgICAgIGNh bGN1bGF0ZSB0aGUgc2VsZWN0aW9uIGVuZHBvaW50LgorCiAyMDExLTA0LTEwICBNaWtlIExhd3Ro ZXIgIDxtaWtlbGF3dGhlckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgT2ph biBWYWZhaS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCBjMzkzZTFmNzZi NDhjM2NjZDAzNjJiNDEzMzBkOWYzZWM4MmQ0MjkyLi5kMWM2YzYzZWY1NDA1OTQwZTFmMTU5MmJi NzE0YzRiNmNlMDk4NjZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFu ZGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC02 MjIsNiArNjIyLDI0IEBAIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3Vz ZURyYWcoKQogICAgIHVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyhyZXN1bHQpOwogfQogCitz dGF0aWMgVmlzaWJsZVBvc2l0aW9uIHRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9pbnQo Y29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBjb25zdCBJbnRQb2ludCYgbG9jYWxQ b2ludCwgTm9kZSogdGFyZ2V0Tm9kZSkKK3sKKyAgICBFbGVtZW50KiBlZGl0YWJsZUVsZW1lbnQg PSBzZWxlY3Rpb24ucm9vdEVkaXRhYmxlRWxlbWVudCgpOworICAgIEludFBvaW50IHNlbGVjdGlv bkVuZFBvaW50ID0gbG9jYWxQb2ludDsKKyAgICBOb2RlKiBzZWxlY3Rpb25FbmROb2RlID0gdGFy Z2V0Tm9kZTsKKworICAgIGlmIChlZGl0YWJsZUVsZW1lbnQgJiYgIWVkaXRhYmxlRWxlbWVudC0+ Y29udGFpbnModGFyZ2V0Tm9kZSkpIHsKKyAgICAgICAgLy8gQXZvaWQgc2VsZWN0aW9uIGNoYW5n aW5nIGRpcmVjdGlvbiB3aGVuIGRyYWdnaW5nIG91dCBvZiBhbiBlZGl0YWJsZSBlbGVtZW50IGlu dG8KKyAgICAgICAgLy8gYW4gZWxlbWVudCB3aGljaCBjb21lcyBlYXJsaWVyIGluIHRoZSBET00u CisgICAgICAgIHNlbGVjdGlvbkVuZE5vZGUgPSBlZGl0YWJsZUVsZW1lbnQ7CisgICAgICAgIEZs b2F0UG9pbnQgYWJzb2x1dGVQb2ludCA9IHRhcmdldE5vZGUtPnJlbmRlcmVyKCktPmxvY2FsVG9B YnNvbHV0ZShGbG9hdFBvaW50KHNlbGVjdGlvbkVuZFBvaW50KSk7CisKKyAgICAgICAgc2VsZWN0 aW9uRW5kUG9pbnQgPSByb3VuZGVkSW50UG9pbnQoc2VsZWN0aW9uRW5kTm9kZS0+cmVuZGVyZXIo KS0+YWJzb2x1dGVUb0xvY2FsKGFic29sdXRlUG9pbnQpKTsKKyAgICB9CisKKyAgICByZXR1cm4g c2VsZWN0aW9uRW5kTm9kZS0+cmVuZGVyZXIoKS0+cG9zaXRpb25Gb3JQb2ludChzZWxlY3Rpb25F bmRQb2ludCk7Cit9CisKIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3Vz ZURyYWcoY29uc3QgSGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJlc3VsdCkKIHsKICAgICBpZiAoIW1f bW91c2VEb3duTWF5U3RhcnRTZWxlY3QpCkBAIC02MzgsMTYgKzY1NiwxMyBAQCB2b2lkIEV2ZW50 SGFuZGxlcjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKGNvbnN0IEhpdFRlc3RSZXN1bHQm IGhpdFRlc3RSZXN1bAogICAgIGlmICghdGFyZ2V0UmVuZGVyZXIpCiAgICAgICAgIHJldHVybjsK IAotICAgIFZpc2libGVQb3NpdGlvbiB0YXJnZXRQb3NpdGlvbiA9IHRhcmdldFJlbmRlcmVyLT5w b3NpdGlvbkZvclBvaW50KGhpdFRlc3RSZXN1bHQubG9jYWxQb2ludCgpKTsKKyAgICBWaXNpYmxl U2VsZWN0aW9uIG5ld1NlbGVjdGlvbiA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rpb24o KTsKKyAgICBWaXNpYmxlUG9zaXRpb24gdGFyZ2V0UG9zaXRpb24gPSB0YXJnZXRQb3NpdGlvbkZv clNlbGVjdGlvbkVuZHBvaW50KG5ld1NlbGVjdGlvbiwgaGl0VGVzdFJlc3VsdC5sb2NhbFBvaW50 KCksIHRhcmdldCk7CiAKICAgICAvLyBEb24ndCBtb2RpZnkgdGhlIHNlbGVjdGlvbiBpZiB3ZSdy ZSBub3Qgb24gYSBub2RlLgogICAgIGlmICh0YXJnZXRQb3NpdGlvbi5pc051bGwoKSkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgLy8gUmVzdGFydCB0aGUgc2VsZWN0aW9uIGlmIHRoaXMgaXMgdGhl IGZpcnN0IG1vdXNlIG1vdmUuIFRoaXMgd29yayBpcyB1c3VhbGx5Ci0gICAgLy8gZG9uZSBpbiBo YW5kbGVNb3VzZVByZXNzRXZlbnQsIGJ1dCBub3QgaWYgdGhlIG1vdXNlIHByZXNzIHdhcyBvbiBh biBleGlzdGluZyBzZWxlY3Rpb24uCi0gICAgVmlzaWJsZVNlbGVjdGlvbiBuZXdTZWxlY3Rpb24g PSBtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+c2VsZWN0aW9uKCk7Ci0KICNpZiBFTkFCTEUoU1ZHKQog ICAgIC8vIFNwZWNpYWwgY2FzZSB0byBsaW1pdCBzZWxlY3Rpb24gdG8gdGhlIGNvbnRhaW5pbmcg YmxvY2sgZm9yIFNWRyB0ZXh0LgogICAgIC8vIEZJWE1FOiBJc24ndCB0aGVyZSBhIGJldHRlciBu b24tU1ZHLXNwZWNpZmljIHdheSB0byBkbyB0aGlzPwo= 89322 2011-04-12 18:09:03 -0700 2011-04-13 21:04:32 -0700 Patch bug-55552-20110413110901.patch text/plain 15562 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM2NzQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZWZjZjg5MzEyZjQ3ZWIwNGU3YmE0 NDkxZDNmMzdjMjA0ZjRmNGQ3Li5hOTc3ZTUzZWZiMWRjMmQ5YmZhNTk2YTUyZTY2NGQ4NDE2Nzkw MWI5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFnZ2luZyBv dXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxlY3RzIHRv IHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBpbmcgYmFj ayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vcmVzb3Vy Y2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qczogQWRkZWQuCisgICAgICAgIChs b2cpOgorICAgICAgICAoZWxzZS53aW5kb3cub25tb3VzZXVwKToKKyAgICAgICAgKGdldFNlbGVj dGlvblN0YXJ0KToKKyAgICAgICAgKGdldFNlbGVjdGlvbkVuZCk6CisgICAgICAgIChjaGVja1Nl bGVjdGlvbik6CisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0 YWJsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQ6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1jb250ZW50ZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC10ZXh0YXJlYS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sOiBBZGRlZC4KKwogMjAxMS0w NC0xMiAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtR dF0gaHR0cC90ZXN0cy9taXNjL2Zhdmljb24tbG9hZHMtd2l0aC1pY29uLWxvYWRpbmctb3ZlcnJp ZGUuaHRtbCBmYWlscwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v cmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRlc3Rz L2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFi bGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZWQyMThlNTJiNzQ2NTBlN2E5YjMzYzAxNWE1ZmYyOGE3OTQwODA1 YgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291 cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0OCBAQAor ZnVuY3Rpb24gbG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xl JykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQor CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikg eworICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4ID0g ZmxvYXRlZEVkaXRhYmxlLm9mZnNldExlZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRo IC8gMik7CisgICAgdmFyIHkgPSBmbG9hdGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0ZWRF ZGl0YWJsZS5vZmZzZXRIZWlnaHQgLyAyKTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4 LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVkaXRh YmxlLm9mZnNldExlZnQgKyBmbG9hdGVkRWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAgIGV2 ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3YXJk KDEwMCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworCisgICAgY2hlY2tTZWxlY3Rpb24o KTsKK30gZWxzZSB7CisgICAgd2luZG93Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAgICAg ICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5wdXQg c2VsZWN0aW9uIHN0YXJ0OiAnICsgZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKSAr ICcsIGVuZDogJyArCisgICAgICAgICAgICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0 YWJsZSkpOworICAgICAgICAgICAgY2hlY2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7ICAv LyBXaXRob3V0IGEgdGltZW91dCB0aGUgc2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmludGVk CisgICAgfQorfQorCitmdW5jdGlvbiBnZXRTZWxlY3Rpb25TdGFydChlbGVtZW50KSB7CisgICAg cmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCku YmFzZU9mZnNldCA6IGVsZW1lbnQuc2VsZWN0aW9uU3RhcnQ7Cit9CisKK2Z1bmN0aW9uIGdldFNl bGVjdGlvbkVuZChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFi bGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZXh0ZW50T2Zmc2V0IDogZWxlbWVudC5zZWxlY3Rp b25FbmQ7Cit9CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1dFRl eHQgPSBmbG9hdGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFibGUu dGV4dENvbnRlbnQgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIGlucHV0VGV4dExl bmd0aCA9IGlucHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvblN0YXJ0ID0gZ2V0U2Vs ZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2VsZWN0aW9uRW5kID0gZ2V0 U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIgc2VsZWN0aW9uU3RhcnRz RnJvbU1pZGRsZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rpb25TdGFydCA8IGlucHV0 VGV4dExlbmd0aDsKKyAgICB2YXIgc2VsZWN0aW9uR29lc1RvRW5kID0gc2VsZWN0aW9uRW5kID09 IGlucHV0VGV4dExlbmd0aDsKKyAgICBpZiAoc2VsZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSAmJiBz ZWxlY3Rpb25Hb2VzVG9FbmQpCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5 bGU9InBhZGRpbmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW4iPlNVQ0NFU1M8L3NwYW4+ JzsKKyAgICBlbHNlCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNwYW4gc3R5bGU9InBh ZGRpbmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogcmVkIj5GQUlMPC9zcGFuPic7Cit9CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRh YmxlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1v dXQtb2YtZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmEzNmY3YTNkMDhmY2U2ZDA5 MThiZDA1NTYxYTNiMmMzNDVmYTUxYzgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLWV4cGVjdGVkLnR4dApAQCAt MCwwICsxLDQgQEAKK2hlbGxvIHdvcmxkCitEcmFnZ2luZyB0byB0aGUgbGVmdDogUEFTUworRHJh Z2dpbmcgdG8gdGhlIGxlZnQ6IFBBU1MKK1RoaXMgdGVzdCByZXF1aXJlcyBldmVudFNlbmRlciBz aW5jZSB0aGUgYnVnIGRvZXMgbm90IHJlcHJvZHVjZSByZWxpYWJseSB3aGVuIHRlc3RlZCBtYW51 YWxseS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1v dXQtb2YtZWRpdGFibGUuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZWRpdGFibGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wNTcwN2ZmYmI2YWE0MGM5NWM2NDZj MjI3ZWMwNTVlMDZhMDE3NzkxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0YWJsZS5odG1sCkBAIC0wLDAgKzEsNjEgQEAK KzwhRE9DVFlQRSBodG1sPiAKKzxodG1sPiAKKzxib2R5PiAKKzxwIGlkPSJkZXNjcmlwdGlvbiI+ VGhpcyB0ZXN0IGVuc3VyZXMgdGhhdCB3aGVuIGVkaXRhYmxlIHRleHQgaXMgc2VsZWN0ZWQgYnkg YSBkcmFnIHRoYXQgZW5kcyBvdXRzaWRlIG9mIHRoZSBlZGl0YWJsZSByZWdpb24sIHNlbGVjdGlv biBpcyBleHRlbmRlZCB0byB0aGUgZWl0aGVyIGVuZCBvZiB0aGUgdGV4dC4gU2VlIHRoZSA8YSBo cmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTI5ODYiPmJ1ZyA1 Mjk4NjwvYT4gZm9yIG1vcmUgZGV0YWlscy48L3A+IAorPGRpdiBpZD0idGVzdCIgY29udGVudGVk aXRhYmxlIHN0eWxlPSJ3aWR0aDogMjAwcHg7IG1hcmdpbjogMjBweDsgYm9yZGVyOiBzb2xpZCAx cHg7IGZvbnQtc2l6ZTogeC1sYXJnZTsiPmhlbGxvIHdvcmxkPC9kaXY+IAorPHNjcmlwdD4gCisg CitmdW5jdGlvbiBzZWxlY3RUZXh0QnlEcmFnKGRpdiwgZW5kWCwgZW5kWSkgeworICAgIHdpbmRv dy5nZXRTZWxlY3Rpb24oKS5yZW1vdmVBbGxSYW5nZXMoKTsKKyAKKyAgICBldmVudFNlbmRlci5t b3VzZU1vdmVUbyhkaXYub2Zmc2V0TGVmdCArIChkaXYub2Zmc2V0V2lkdGggLyAyKSAsIGRpdi5v ZmZzZXRUb3AgKyAoZGl2Lm9mZnNldEhlaWdodCAvIDIpKTsKKyAgICBldmVudFNlbmRlci5tb3Vz ZURvd24oKTsKKyAKKyAgICBldmVudFNlbmRlci5sZWFwRm9yd2FyZCgyMDApOworIAorICAgIC8v IFdpdGhvdXQgdGhpcywgZHJhZyBkb2Vzbid0IHN0YXJ0IHNlbGVjdGlvbi4KKyAgICBldmVudFNl bmRlci5tb3VzZU1vdmVUbyhkaXYub2Zmc2V0TGVmdCArIChkaXYub2Zmc2V0V2lkdGggLyAzKSAs IGRpdi5vZmZzZXRUb3AgKyAoZGl2Lm9mZnNldEhlaWdodCAvIDMpKTsKKyAgICBldmVudFNlbmRl ci5tb3VzZURvd24oKTsKKyAKKyAgICBldmVudFNlbmRlci5sZWFwRm9yd2FyZCgyMDApOworIAor ICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKGVuZFgsIGVuZFkpOworICAgIGV2ZW50U2VuZGVy Lm1vdXNlVXAoKTsKK30KKyAKK3ZhciBsb2cgPSAnJzsKKyAKK2Z1bmN0aW9uIGFzc2VydEVxdWFs KGFjdHVhbCwgZXhwZWN0ZWQpIHsKKyAgICBpZiAoYWN0dWFsID09IGV4cGVjdGVkKQorICAgICAg ICBsb2cgKz0gJ1BBU1MnOworICAgIGVsc2UKKyAgICAgICAgbG9nICs9ICdGQUlMIC0gZXhwZWN0 ZWQgJyArIGV4cGVjdGVkICsgJyBidXQgZ290ICcgKyBhY3R1YWw7CisgICAgbG9nICs9ICdcbic7 Cit9CisgCitpZiAoIXdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlciB8fCAhd2luZG93LmV2ZW50 U2VuZGVyKQorICAgIGRvY3VtZW50LndyaXRlbG4oIlRoaXMgdGVzdCByZXF1aXJlcyBldmVudFNl bmRlciBzaW5jZSB0aGUgYnVnIGRvZXMgbm90IHJlcHJvZHVjZSByZWxpYWJseSB3aGVuIHRlc3Rl ZCBtYW51YWxseS4iKTsKK2Vsc2UgeworICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKyAgICB2YXIgZGVzY3JpcHRpb24gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZGVz Y3JpcHRpb24nKTsKKyAgICBkZXNjcmlwdGlvbi5zdHlsZS5kaXNwbGF5ID0gJ25vbmUnOworIAor ICAgIHZhciBkaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpOworIAorICAgIGxv ZyArPSAnRHJhZ2dpbmcgdG8gdGhlIGxlZnQ6ICc7CisgICAgc2VsZWN0VGV4dEJ5RHJhZyhkaXYs IGRpdi5vZmZzZXRMZWZ0IC0gMTAsIGRpdi5vZmZzZXRUb3AgLSAxMCk7CisgICAgYXNzZXJ0RXF1 YWwod2luZG93LmdldFNlbGVjdGlvbigpLmdldFJhbmdlQXQoMCkuc3RhcnRPZmZzZXQsIDApOwor IAorICAgIGxvZyArPSAnRHJhZ2dpbmcgdG8gdGhlIGxlZnQ6ICc7CisgICAgc2VsZWN0VGV4dEJ5 RHJhZyhkaXYsIGRpdi5vZmZzZXRMZWZ0ICsgMzAwLCBkaXYub2Zmc2V0VG9wICsgMTAwKTsKKyAg ICBhc3NlcnRFcXVhbCh3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZ2V0UmFuZ2VBdCgwKS5lbmRPZmZz ZXQsIGRpdi5pbm5lclRleHQubGVuZ3RoKTsKKyAKKyAgICAvLyBIYXZpbmcgdGhlIGxvZyBpbiBE T00gd2lsbCBpbnRlcmZlcmUgd2l0aCB0aGUgdGVzdCBzbyBhcHBlbmQgaXQgYXQgbGFzdC4KKyAg ICB2YXIgY29uc29sZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3ByZScpOworICAgIGRvY3Vt ZW50LmJvZHkuYXBwZW5kQ2hpbGQoY29uc29sZSk7CisgICAgY29uc29sZS5pbm5lckhUTUwgPSBs b2c7Cit9CisgCis8L3NjcmlwdD4gCis8L2JvZHk+IAorPC9odG1sPiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250ZW50 ZWRpdGFibGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2Vs ZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uMWNjODdlYTU4OWQ1N2Y4NmM3MDlkYzUxN2Y3OTJhMTlkYzFjOTE0YwotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1jb250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29tZSB0ZXh0 IGJlZm9yZSB0aGUgZmxvYXRzLiBEcmFnIGZyb20gdGhlIG1pZGRsZS4gU29tZSBmbG9hdGVkIHRl eHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8gdGVzdCBtYW51YWxs eSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIGVkaXRhYmxlIGRpdiB0byB0aGUgcmlnaHQs IGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRo ZSBlbmQgb2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcu CisKK1NVQ0NFU1MKKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlv bi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWwgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxl Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYjZkYTQ4MDJhNDBlNTllNmVjNGY4NGQ0ODc3OWNiNWNmZGNmYWQz ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZmxvYXRlZC1jb250ZW50ZWRpdGFibGUuaHRtbApAQCAtMCwwICsxLDE4IEBACis8 IURPQ1RZUEUgaHRtbD4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXYgY29udGVu dGVkaXRhYmxlPXRydWUgaWQ9ImZsb2F0ZWRFZGl0YWJsZSIgc3R5bGU9ImZsb2F0OiBsZWZ0OyI+ CisgIERyYWcgZnJvbSB0aGUgbWlkZGxlLgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAw JTsgZmxvYXQ6IGxlZnQ7Ij4KKyAgU29tZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuCis8L2Rpdj4K K1NvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorPHAgc3R5bGU9InBhZGRpbmctdG9wOiAxZW07 Ij4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBlZGl0YWJs ZSBkaXYgdG8gdGhlCityaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVj dGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZAorb2YgdGhlIGlucHV0IGVsZW1lbnQgYW5kIG5vdCBq dW1wIHRvIHRoZSBiZWdpbm5pbmcuCis8L3A+Cis8cCBpZD0icmVzdWx0Ij48L3A+Cis8cHJlIGlk PSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2VsZWN0LW91dC1vZi1m bG9hdGVkLWVkaXRhYmxlLmpzIj48L3NjcmlwdD4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1p bnB1dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGMxMzY2NTVkZGEwNDY1NjgxMDFhNGNiMmIx ZDMyMmQ5MDE2MzBlZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSw2IEBACitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuIFNvbWUgZmxvYXRlZCB0ZXh0IGlu IGEgZGl2LiBTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHksIGRy YWcgZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBpbnB1dCBlbGVtZW50IHRvIHRoZSByaWdodCwgaW50 byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVu ZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKwor U1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmYzZjRl NTNlMjdhZjcxNDNmODgwNjc2ZWQzYzUxYzBmNjNmMjNlNQotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5o dG1sCkBAIC0wLDAgKzEsMTggQEAKKzwhRE9DVFlQRSBodG1sPgorU29tZSB0ZXh0IGJlZm9yZSB0 aGUgZmxvYXRzLgorPGRpdiBzdHlsZT0iZmxvYXQ6IGxlZnQ7Ij4KKyAgPGlucHV0IHR5cGU9InRl eHQiIGlkPSJmbG9hdGVkRWRpdGFibGUiIHZhbHVlPSJEcmFnIGZyb20gdGhlIG1pZGRsZS4iPgor PC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDogMTAwJTsgZmxvYXQ6IGxlZnQ7Ij4KKyAgU29tZSBm bG9hdGVkIHRleHQgaW4gYSBkaXYuCis8L2Rpdj4KK1NvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRz LgorPHAgc3R5bGU9InBhZGRpbmctdG9wOiAxZW07Ij4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcg ZnJvbSB0aGUgbWlkZGxlIG9mIHRoZSBpbnB1dCBlbGVtZW50IHRvIHRoZQorcmlnaHQsIGludG8g dGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQK K29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorPC9w PgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0 IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyI+PC9zY3Jp cHQ+CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1v dXQtb2YtZmxvYXRlZC10ZXh0YXJlYS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjg1N2VhMWNiNjZiNWZhMDZjN2M3MmM2YjlhMTc0ZGM5OGJlNTI1NDMKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9m LWZsb2F0ZWQtdGV4dGFyZWEtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29tZSB0ZXh0 IGJlZm9yZSB0aGUgZmxvYXRzLiBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4gU29tZSB0ZXh0 IGFmdGVyIHRoZSBmbG9hdHMuCitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRs ZSBvZiB0aGUgdGV4dGFyZWEgdG8gdGhlIHJpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0 LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVtZW50 IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorCitTVUNDRVNTCisKKwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRl eHRhcmVhLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9m LWZsb2F0ZWQtdGV4dGFyZWEuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kMGZiOGNhOTI1NjMzNWVjMzk1NTFi MDlkZDk1MDljMzg2YTVjOGI0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKQEAgLTAsMCAr MSwxOCBAQAorPCFET0NUWVBFIGh0bWw+CitTb21lIHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8 ZGl2IHN0eWxlPSJmbG9hdDogbGVmdDsiPgorICA8dGV4dGFyZWEgcm93cz0iMSIgaWQ9ImZsb2F0 ZWRFZGl0YWJsZSI+RHJhZyBmcm9tIHRoZSBtaWRkbGUuPC90ZXh0YXJlYT4KKzwvZGl2PgorPGRp diBzdHlsZT0id2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0 IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwIHN0eWxl PSJwYWRkaW5nLXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1p ZGRsZSBvZiB0aGUgdGV4dGFyZWEgdG8gdGhlCityaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQg dGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQgZ28gdG8gdGhlIGVuZAorb2YgdGhlIGlucHV0IGVs ZW1lbnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCis8L3A+Cis8cCBpZD0icmVzdWx0 Ij48L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMv c2VsZWN0LW91dC1vZi1mbG9hdGVkLWVkaXRhYmxlLmpzIj48L3NjcmlwdD4KKwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDEyYzQxODE4ZjFiMzgzY2FjZTliYTI0Nzk2NTY1MmQ1N2IyYTVkNTUuLmI0MzNmNzNkMGI2 ZDYxY2YxYjRlMjA5MzIwMWYxNjA3MThkZGYyNjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBA QAorMjAxMS0wNC0xMSAgQWxpY2UgQm94aGFsbCAgPGFib3hoYWxsQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXh0IHNlbGVj dGlvbiBjaGFuZ2VzIHVuZXhwZWN0ZWRseSB3aGVuIGRyYWdnaW5nIG91dCBvZiB0aGUgPGlucHV0 PgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTU1NTIK KworICAgICAgICBUZXN0czogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0YWJs ZS5odG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtY29udGVudGVkaXRhYmxlLmh0bWwKKyAgICAgICAgICAgICAgIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC5odG1sCisgICAgICAgICAgICAgICBlZGl0 aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEuaHRtbAorCisgICAg ICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6dGFyZ2V0UG9z aXRpb25Gb3JTZWxlY3Rpb25FbmRwb2ludCk6IFdoZW4gZHJhZ2dpbmcgZnJvbSBhbiBlZGl0YWJs ZSBlbGVtZW50LCBjaGVjayB0aGF0CisgICAgICAgIHRoZSBlbmRwb2ludCBpcyBub3Qgb3V0c2lk ZSB0aGUgZWxlbWVudC4gSWYgaXQgaXMsIHRyYW5zbGF0ZSB0aGUgcG9pbnQgaW50byBhIGxvY2Fs IHBvaW50IHdpdGhpbgorICAgICAgICB0aGUgZWRpdGFibGUgZWxlbWVudC4KKyAgICAgICAgKFdl YkNvcmU6OkV2ZW50SGFuZGxlcjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKTogQ2FsbCB0 YXJnZXRQb3NpdGlvbkZvclNlbGVjdGlvbkVuZHBvaW50KCkgdG8KKyAgICAgICAgY2FsY3VsYXRl IHRoZSBzZWxlY3Rpb24gZW5kcG9pbnQuCisKIDIwMTEtMDQtMTIgIEFkcmllbm5lIFdhbGtlciAg PGVubmVAZ29vZ2xlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBKYW1lcyBSb2JpbnNvbi4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCAzYTdiNzdjZDMyNjc5ODVkZTAz MjBmMjY2Njk5MjBmZTdhZjAxOWI2Li5mZGU5NjFiY2MwMzdjOWRhYzNhOGUxOWRmMjBmODk5OTdh OTlhNWMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC02MjIsNiArNjIy LDIyIEBAIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWcoKQog ICAgIHVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyhyZXN1bHQpOwogfQogCitzdGF0aWMgVmlz aWJsZVBvc2l0aW9uIHNlbGVjdGlvbkV4dGVudFJlc3BlY3RpbmdFZGl0aW5nQm91bmRhcnkoY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBjb25zdCBJbnRQb2ludCYgbG9jYWxQb2lu dCwgTm9kZSogdGFyZ2V0Tm9kZSkKK3sKKyAgICBFbGVtZW50KiBlZGl0YWJsZUVsZW1lbnQgPSBz ZWxlY3Rpb24ucm9vdEVkaXRhYmxlRWxlbWVudCgpOworICAgIEludFBvaW50IHNlbGVjdGlvbkVu ZFBvaW50ID0gbG9jYWxQb2ludDsKKyAgICBOb2RlKiBzZWxlY3Rpb25FbmROb2RlID0gdGFyZ2V0 Tm9kZTsKKworICAgIGlmIChlZGl0YWJsZUVsZW1lbnQgJiYgIWVkaXRhYmxlRWxlbWVudC0+Y29u dGFpbnModGFyZ2V0Tm9kZSkpIHsKKyAgICAgICAgc2VsZWN0aW9uRW5kTm9kZSA9IGVkaXRhYmxl RWxlbWVudDsKKyAgICAgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvaW50ID0gdGFyZ2V0Tm9kZS0+ cmVuZGVyZXIoKS0+bG9jYWxUb0Fic29sdXRlKEZsb2F0UG9pbnQoc2VsZWN0aW9uRW5kUG9pbnQp KTsKKworICAgICAgICBzZWxlY3Rpb25FbmRQb2ludCA9IHJvdW5kZWRJbnRQb2ludChzZWxlY3Rp b25FbmROb2RlLT5yZW5kZXJlcigpLT5hYnNvbHV0ZVRvTG9jYWwoYWJzb2x1dGVQb2ludCkpOwor ICAgIH0KKworICAgIHJldHVybiBzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpLT5wb3NpdGlv bkZvclBvaW50KHNlbGVjdGlvbkVuZFBvaW50KTsKK30KKwogdm9pZCBFdmVudEhhbmRsZXI6OnVw ZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyhjb25zdCBIaXRUZXN0UmVzdWx0JiBoaXRUZXN0UmVz dWx0KQogewogICAgIGlmICghbV9tb3VzZURvd25NYXlTdGFydFNlbGVjdCkKQEAgLTYzOCwxNiAr NjU0LDEzIEBAIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWco Y29uc3QgSGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJlc3VsCiAgICAgaWYgKCF0YXJnZXRSZW5kZXJl cikKICAgICAgICAgcmV0dXJuOwogCi0gICAgVmlzaWJsZVBvc2l0aW9uIHRhcmdldFBvc2l0aW9u ID0gdGFyZ2V0UmVuZGVyZXItPnBvc2l0aW9uRm9yUG9pbnQoaGl0VGVzdFJlc3VsdC5sb2NhbFBv aW50KCkpOworICAgIFZpc2libGVTZWxlY3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2Vs ZWN0aW9uKCktPnNlbGVjdGlvbigpOworICAgIFZpc2libGVQb3NpdGlvbiB0YXJnZXRQb3NpdGlv biA9IHNlbGVjdGlvbkV4dGVudFJlc3BlY3RpbmdFZGl0aW5nQm91bmRhcnkobmV3U2VsZWN0aW9u LCBoaXRUZXN0UmVzdWx0LmxvY2FsUG9pbnQoKSwgdGFyZ2V0KTsKIAogICAgIC8vIERvbid0IG1v ZGlmeSB0aGUgc2VsZWN0aW9uIGlmIHdlJ3JlIG5vdCBvbiBhIG5vZGUuCiAgICAgaWYgKHRhcmdl dFBvc2l0aW9uLmlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBSZXN0YXJ0IHRo ZSBzZWxlY3Rpb24gaWYgdGhpcyBpcyB0aGUgZmlyc3QgbW91c2UgbW92ZS4gVGhpcyB3b3JrIGlz IHVzdWFsbHkKLSAgICAvLyBkb25lIGluIGhhbmRsZU1vdXNlUHJlc3NFdmVudCwgYnV0IG5vdCBp ZiB0aGUgbW91c2UgcHJlc3Mgd2FzIG9uIGFuIGV4aXN0aW5nIHNlbGVjdGlvbi4KLSAgICBWaXNp YmxlU2VsZWN0aW9uIG5ld1NlbGVjdGlvbiA9IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rp b24oKTsKLQogI2lmIEVOQUJMRShTVkcpCiAgICAgLy8gU3BlY2lhbCBjYXNlIHRvIGxpbWl0IHNl bGVjdGlvbiB0byB0aGUgY29udGFpbmluZyBibG9jayBmb3IgU1ZHIHRleHQuCiAgICAgLy8gRklY TUU6IElzbid0IHRoZXJlIGEgYmV0dGVyIG5vbi1TVkctc3BlY2lmaWMgd2F5IHRvIGRvIHRoaXM/ Cg== 89526 2011-04-13 21:04:39 -0700 2011-04-13 21:41:39 -0700 Patch bug-55552-20110414140437.patch text/plain 15510 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM2NzQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZWZjZjg5MzEyZjQ3ZWIwNGU3YmE0 NDkxZDNmMzdjMjA0ZjRmNGQ3Li5hOTc3ZTUzZWZiMWRjMmQ5YmZhNTk2YTUyZTY2NGQ4NDE2Nzkw MWI5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFnZ2luZyBv dXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxlY3RzIHRv IHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBpbmcgYmFj ayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vcmVzb3Vy Y2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qczogQWRkZWQuCisgICAgICAgIChs b2cpOgorICAgICAgICAoZWxzZS53aW5kb3cub25tb3VzZXVwKToKKyAgICAgICAgKGdldFNlbGVj dGlvblN0YXJ0KToKKyAgICAgICAgKGdldFNlbGVjdGlvbkVuZCk6CisgICAgICAgIChjaGVja1Nl bGVjdGlvbik6CisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0 YWJsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQ6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1jb250ZW50ZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC10ZXh0YXJlYS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sOiBBZGRlZC4KKwogMjAxMS0w NC0xMiAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtR dF0gaHR0cC90ZXN0cy9taXNjL2Zhdmljb24tbG9hZHMtd2l0aC1pY29uLWxvYWRpbmctb3ZlcnJp ZGUuaHRtbCBmYWlscwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v cmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRlc3Rz L2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFi bGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZmI0YzlkYzVlNzQ1OThlOGNjYzllNDQ2N2NhOTU1M2YxODJjNzEx ZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291 cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0NyBAQAor ZnVuY3Rpb24gbG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xl JykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQor CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikg eworICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4ID0g ZmxvYXRlZEVkaXRhYmxlLm9mZnNldExlZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRo IC8gMik7CisgICAgdmFyIHkgPSBmbG9hdGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0ZWRF ZGl0YWJsZS5vZmZzZXRIZWlnaHQgLyAyKTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4 LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVkaXRh YmxlLm9mZnNldExlZnQgKyBmbG9hdGVkRWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAgIGV2 ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3YXJk KDI1MCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworCisgICAgY2hlY2tTZWxlY3Rpb24o KTsKK30gZWxzZSB7CisgICAgd2luZG93Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAgICAg ICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5wdXQg c2VsZWN0aW9uIHN0YXJ0OiAnICsgZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKSAr ICcsIGVuZDogJyArCisgICAgICAgICAgICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0 YWJsZSkpOworICAgICAgICAgICAgY2hlY2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7ICAv LyBXaXRob3V0IGEgdGltZW91dCB0aGUgc2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmludGVk CisgICAgfQorfQorCitmdW5jdGlvbiBnZXRTZWxlY3Rpb25TdGFydChlbGVtZW50KSB7CisgICAg cmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCku YmFzZU9mZnNldCA6IGVsZW1lbnQuc2VsZWN0aW9uU3RhcnQ7Cit9CisKK2Z1bmN0aW9uIGdldFNl bGVjdGlvbkVuZChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFi bGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZXh0ZW50T2Zmc2V0IDogZWxlbWVudC5zZWxlY3Rp b25FbmQ7Cit9CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1dFRl eHQgPSBmbG9hdGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFibGUu dGV4dENvbnRlbnQgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIHNlbGVjdGlvblN0 YXJ0ID0gZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2VsZWN0 aW9uRW5kID0gZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIgc2Vs ZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rpb25T dGFydCA8IGlucHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvbkdvZXNUb0VuZCA9IHNl bGVjdGlvbkVuZCA9PSBpbnB1dFRleHQubGVuZ3RoOworICAgIGlmIChzZWxlY3Rpb25TdGFydHNG cm9tTWlkZGxlICYmIHNlbGVjdGlvbkdvZXNUb0VuZCkKKyAgICAgICAgcmVzdWx0LmlubmVySFRN TCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVlbiI+ U1VDQ0VTUzwvc3Bhbj4nOworICAgIGVsc2UKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8 c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZBSUw8L3Nw YW4+JzsKK30KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZWRpdGFibGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0YWJsZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOGRh ODNiYTYzNWY2ZDc1ODdmNzQ5ZDAxZGFkNzBlYzFlZmY4YWI4YgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAoraGVsbG8gd29ybGQKK0RyYWdnaW5nIHRvIHRoZSBs ZWZ0OiBQQVNTCitEcmFnZ2luZyB0byB0aGUgbGVmdDogUEFTUworCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0bWwgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uMDU3MDdmZmJiNmFhNDBjOTVjNjQ2YzIyN2VjMDU1ZTA2YTAxNzc5MQotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZWRpdGFibGUuaHRtbApAQCAtMCwwICsxLDYxIEBACis8IURPQ1RZUEUgaHRtbD4gCis8aHRt bD4gCis8Ym9keT4gCis8cCBpZD0iZGVzY3JpcHRpb24iPlRoaXMgdGVzdCBlbnN1cmVzIHRoYXQg d2hlbiBlZGl0YWJsZSB0ZXh0IGlzIHNlbGVjdGVkIGJ5IGEgZHJhZyB0aGF0IGVuZHMgb3V0c2lk ZSBvZiB0aGUgZWRpdGFibGUgcmVnaW9uLCBzZWxlY3Rpb24gaXMgZXh0ZW5kZWQgdG8gdGhlIGVp dGhlciBlbmQgb2YgdGhlIHRleHQuIFNlZSB0aGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTUyOTg2Ij5idWcgNTI5ODY8L2E+IGZvciBtb3JlIGRldGFp bHMuPC9wPiAKKzxkaXYgaWQ9InRlc3QiIGNvbnRlbnRlZGl0YWJsZSBzdHlsZT0id2lkdGg6IDIw MHB4OyBtYXJnaW46IDIwcHg7IGJvcmRlcjogc29saWQgMXB4OyBmb250LXNpemU6IHgtbGFyZ2U7 Ij5oZWxsbyB3b3JsZDwvZGl2PiAKKzxzY3JpcHQ+IAorIAorZnVuY3Rpb24gc2VsZWN0VGV4dEJ5 RHJhZyhkaXYsIGVuZFgsIGVuZFkpIHsKKyAgICB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkucmVtb3Zl QWxsUmFuZ2VzKCk7CisgCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2Lm9mZnNldExl ZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMikgLCBkaXYub2Zmc2V0VG9wICsgKGRpdi5vZmZzZXRI ZWlnaHQgLyAyKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisgICAgZXZlbnRT ZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICAvLyBXaXRob3V0IHRoaXMsIGRyYWcgZG9l c24ndCBzdGFydCBzZWxlY3Rpb24uCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2Lm9m ZnNldExlZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMykgLCBkaXYub2Zmc2V0VG9wICsgKGRpdi5v ZmZzZXRIZWlnaHQgLyAzKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisgICAg ZXZlbnRTZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICBldmVudFNlbmRlci5tb3VzZU1v dmVUbyhlbmRYLCBlbmRZKTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cit9CisgCit2YXIg bG9nID0gJyc7CisgCitmdW5jdGlvbiBhc3NlcnRFcXVhbChhY3R1YWwsIGV4cGVjdGVkKSB7Cisg ICAgaWYgKGFjdHVhbCA9PSBleHBlY3RlZCkKKyAgICAgICAgbG9nICs9ICdQQVNTJzsKKyAgICBl bHNlCisgICAgICAgIGxvZyArPSAnRkFJTCAtIGV4cGVjdGVkICcgKyBleHBlY3RlZCArICcgYnV0 IGdvdCAnICsgYWN0dWFsOworICAgIGxvZyArPSAnXG4nOworfQorIAoraWYgKCF3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIgfHwgIXdpbmRvdy5ldmVudFNlbmRlcikKKyAgICBkb2N1bWVudC53 cml0ZWxuKCJUaGlzIHRlc3QgcmVxdWlyZXMgZXZlbnRTZW5kZXIgc2luY2UgdGhlIGJ1ZyBkb2Vz IG5vdCByZXByb2R1Y2UgcmVsaWFibHkgd2hlbiB0ZXN0ZWQgbWFudWFsbHkuIik7CitlbHNlIHsK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgdmFyIGRlc2NyaXB0 aW9uID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Rlc2NyaXB0aW9uJyk7CisgICAgZGVzY3Jp cHRpb24uc3R5bGUuZGlzcGxheSA9ICdub25lJzsKKyAKKyAgICB2YXIgZGl2ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdnaW5nIHRvIHRoZSBs ZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0TGVmdCAtIDEwLCBk aXYub2Zmc2V0VG9wIC0gMTApOworICAgIGFzc2VydEVxdWFsKHdpbmRvdy5nZXRTZWxlY3Rpb24o KS5nZXRSYW5nZUF0KDApLnN0YXJ0T2Zmc2V0LCAwKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdnaW5n IHRvIHRoZSBsZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0TGVm dCArIDMwMCwgZGl2Lm9mZnNldFRvcCArIDEwMCk7CisgICAgYXNzZXJ0RXF1YWwod2luZG93Lmdl dFNlbGVjdGlvbigpLmdldFJhbmdlQXQoMCkuZW5kT2Zmc2V0LCBkaXYuaW5uZXJUZXh0Lmxlbmd0 aCk7CisgCisgICAgLy8gSGF2aW5nIHRoZSBsb2cgaW4gRE9NIHdpbGwgaW50ZXJmZXJlIHdpdGgg dGhlIHRlc3Qgc28gYXBwZW5kIGl0IGF0IGxhc3QuCisgICAgdmFyIGNvbnNvbGUgPSBkb2N1bWVu dC5jcmVhdGVFbGVtZW50KCdwcmUnKTsKKyAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGNv bnNvbGUpOworICAgIGNvbnNvbGUuaW5uZXJIVE1MID0gbG9nOworfQorIAorPC9zY3JpcHQ+IAor PC9ib2R5PiAKKzwvaHRtbD4gCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250 ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFjYzg3ZWE1ODlkNTdmODZjNzA5 ZGM1MTdmNzkyYTE5ZGMxYzkxNGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gRHJh ZyBmcm9tIHRoZSBtaWRkbGUuIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRleHQg YWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxl IG9mIHRoZSBlZGl0YWJsZSBkaXYgdG8gdGhlIHJpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0 ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVt ZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorCitTVUNDRVNTCisKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVk LWNvbnRlbnRlZGl0YWJsZS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2Vs ZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI2ZGE0 ODAyYTQwZTU5ZTZlYzRmODRkNDg3NzljYjVjZmRjZmFkM2QKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVu dGVkaXRhYmxlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPCFET0NUWVBFIGh0bWw+CitTb21lIHRl eHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8ZGl2IGNvbnRlbnRlZGl0YWJsZT10cnVlIGlkPSJmbG9h dGVkRWRpdGFibGUiIHN0eWxlPSJmbG9hdDogbGVmdDsiPgorICBEcmFnIGZyb20gdGhlIG1pZGRs ZS4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNv bWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZs b2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBk cmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgZWRpdGFibGUgZGl2IHRvIHRoZQorcmlnaHQsIGlu dG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBl bmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgor PC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyI+PC9z Y3JpcHQ+CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmRjMTM2NjU1ZGRhMDQ2NTY4MTAxYTRjYjJiMWQzMjJkOTAxNjMwZWYKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29tZSB0ZXh0IGJlZm9y ZSB0aGUgZmxvYXRzLiBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4gU29tZSB0ZXh0IGFmdGVy IHRoZSBmbG9hdHMuCitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0 aGUgaW5wdXQgZWxlbWVudCB0byB0aGUgcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQu IFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQgb2YgdGhlIGlucHV0IGVsZW1lbnQg YW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCisKK1NVQ0NFU1MKKworCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5w dXQuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxv YXRlZC1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJmM2Y0ZTUzZTI3YWY3MTQzZjg4MDY3NmVkM2M1 MWMwZjYzZjIzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbApAQCAtMCwwICsxLDE4IEBACis8 IURPQ1RZUEUgaHRtbD4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXYgc3R5bGU9 ImZsb2F0OiBsZWZ0OyI+CisgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iZmxvYXRlZEVkaXRhYmxl IiB2YWx1ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lk dGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2Lgor PC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRv cDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUg aW5wdXQgZWxlbWVudCB0byB0aGUKK3JpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBU aGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kCitvZiB0aGUgaW5wdXQgZWxlbWVudCBh bmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKzwvcD4KKzxwIGlkPSJyZXN1bHQiPjwvcD4K KzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zZWxlY3Qt b3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NTdlYTFjYjY2YjVm YTA2YzdjNzJjNmI5YTE3NGRjOThiZTUyNTQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29t ZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8g dGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRo ZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQg Z28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJl Z2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcv c2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZDBmYjhjYTkyNTYzMzVlYzM5NTUxYjA5ZGQ5NTA5YzM4NmE1YzhiNAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCkBAIC0wLDAgKzEsMTggQEAKKzwhRE9DVFlQRSBodG1s PgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLgorPGRpdiBzdHlsZT0iZmxvYXQ6IGxlZnQ7 Ij4KKyAgPHRleHRhcmVhIHJvd3M9IjEiIGlkPSJmbG9hdGVkRWRpdGFibGUiPkRyYWcgZnJvbSB0 aGUgbWlkZGxlLjwvdGV4dGFyZWE+Cis8L2Rpdj4KKzxkaXYgc3R5bGU9IndpZHRoOiAxMDAlOyBm bG9hdDogbGVmdDsiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4KKzwvZGl2PgorU29t ZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cCBzdHlsZT0icGFkZGluZy10b3A6IDFlbTsiPgor VG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRv IHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hv dWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0 aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29s ZSI+PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1l ZGl0YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAxMmM0MTgxOGYxYjM4M2NhY2U5 YmEyNDc5NjU2NTJkNTdiMmE1ZDU1Li5iNDMzZjczZDBiNmQ2MWNmMWI0ZTIwOTMyMDFmMTYwNzE4 ZGRmMjYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJv eGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVk bHkgd2hlbiBkcmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHM6IGVkaXRp bmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbAorICAgICAgICAgICAgICAg ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5o dG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtaW5wdXQuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91 dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKKworICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9p bnQpOiBXaGVuIGRyYWdnaW5nIGZyb20gYW4gZWRpdGFibGUgZWxlbWVudCwgY2hlY2sgdGhhdAor ICAgICAgICB0aGUgZW5kcG9pbnQgaXMgbm90IG91dHNpZGUgdGhlIGVsZW1lbnQuIElmIGl0IGlz LCB0cmFuc2xhdGUgdGhlIHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4KKyAgICAgICAg dGhlIGVkaXRhYmxlIGVsZW1lbnQuCisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnVw ZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyk6IENhbGwgdGFyZ2V0UG9zaXRpb25Gb3JTZWxlY3Rp b25FbmRwb2ludCgpIHRvCisgICAgICAgIGNhbGN1bGF0ZSB0aGUgc2VsZWN0aW9uIGVuZHBvaW50 LgorCiAyMDExLTA0LTEyICBBZHJpZW5uZSBXYWxrZXIgIDxlbm5lQGdvb2dsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFu ZGxlci5jcHAKaW5kZXggM2E3Yjc3Y2QzMjY3OTg1ZGUwMzIwZjI2NjY5OTIwZmU3YWYwMTliNi4u NjRmNWY3MDhkN2FjNDZmYmY5NjZjMDc3OGYxNDk1NTA1M2M2ZDYyNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtNjIyLDYgKzYyMiwyNSBAQCB2b2lkIEV2ZW50SGFuZGxl cjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKCkKICAgICB1cGRhdGVTZWxlY3Rpb25Gb3JN b3VzZURyYWcocmVzdWx0KTsKIH0KIAorc3RhdGljIFZpc2libGVQb3NpdGlvbiBzZWxlY3Rpb25F eHRlbnRSZXNwZWN0aW5nRWRpdGluZ0JvdW5kYXJ5KGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNl bGVjdGlvbiwgY29uc3QgSW50UG9pbnQmIGxvY2FsUG9pbnQsIE5vZGUqIHRhcmdldE5vZGUpCit7 CisgICAgSW50UG9pbnQgc2VsZWN0aW9uRW5kUG9pbnQgPSBsb2NhbFBvaW50OworICAgIEVsZW1l bnQqIGVkaXRhYmxlRWxlbWVudCA9IHNlbGVjdGlvbi5yb290RWRpdGFibGVFbGVtZW50KCk7Cisg ICAgTm9kZSogc2VsZWN0aW9uRW5kTm9kZSA9IHRhcmdldE5vZGU7CisKKyAgICBpZiAoZWRpdGFi bGVFbGVtZW50ICYmICFlZGl0YWJsZUVsZW1lbnQtPmNvbnRhaW5zKHRhcmdldE5vZGUpKSB7Cisg ICAgICAgIHNlbGVjdGlvbkVuZE5vZGUgPSBlZGl0YWJsZUVsZW1lbnQ7CisKKyAgICAgICAgaWYg KCFzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpKQorICAgICAgICAgICAgcmV0dXJuIFZpc2li bGVQb3NpdGlvbigpOworCisgICAgICAgIEZsb2F0UG9pbnQgYWJzb2x1dGVQb2ludCA9IHRhcmdl dE5vZGUtPnJlbmRlcmVyKCktPmxvY2FsVG9BYnNvbHV0ZShGbG9hdFBvaW50KHNlbGVjdGlvbkVu ZFBvaW50KSk7CisgICAgICAgIHNlbGVjdGlvbkVuZFBvaW50ID0gcm91bmRlZEludFBvaW50KHNl bGVjdGlvbkVuZE5vZGUtPnJlbmRlcmVyKCktPmFic29sdXRlVG9Mb2NhbChhYnNvbHV0ZVBvaW50 KSk7CisgICAgfQorCisgICAgcmV0dXJuIHNlbGVjdGlvbkVuZE5vZGUtPnJlbmRlcmVyKCktPnBv c2l0aW9uRm9yUG9pbnQoc2VsZWN0aW9uRW5kUG9pbnQpOworfQorCiB2b2lkIEV2ZW50SGFuZGxl cjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKGNvbnN0IEhpdFRlc3RSZXN1bHQmIGhpdFRl c3RSZXN1bHQpCiB7CiAgICAgaWYgKCFtX21vdXNlRG93bk1heVN0YXJ0U2VsZWN0KQpAQCAtNjM4 LDE2ICs2NTcsMTMgQEAgdm9pZCBFdmVudEhhbmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNl RHJhZyhjb25zdCBIaXRUZXN0UmVzdWx0JiBoaXRUZXN0UmVzdWwKICAgICBpZiAoIXRhcmdldFJl bmRlcmVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBWaXNpYmxlUG9zaXRpb24gdGFyZ2V0UG9z aXRpb24gPSB0YXJnZXRSZW5kZXJlci0+cG9zaXRpb25Gb3JQb2ludChoaXRUZXN0UmVzdWx0Lmxv Y2FsUG9pbnQoKSk7CisgICAgVmlzaWJsZVNlbGVjdGlvbiBuZXdTZWxlY3Rpb24gPSBtX2ZyYW1l LT5zZWxlY3Rpb24oKS0+c2VsZWN0aW9uKCk7CisgICAgVmlzaWJsZVBvc2l0aW9uIHRhcmdldFBv c2l0aW9uID0gc2VsZWN0aW9uRXh0ZW50UmVzcGVjdGluZ0VkaXRpbmdCb3VuZGFyeShuZXdTZWxl Y3Rpb24sIGhpdFRlc3RSZXN1bHQubG9jYWxQb2ludCgpLCB0YXJnZXQpOwogCiAgICAgLy8gRG9u J3QgbW9kaWZ5IHRoZSBzZWxlY3Rpb24gaWYgd2UncmUgbm90IG9uIGEgbm9kZS4KICAgICBpZiAo dGFyZ2V0UG9zaXRpb24uaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8vIFJlc3Rh cnQgdGhlIHNlbGVjdGlvbiBpZiB0aGlzIGlzIHRoZSBmaXJzdCBtb3VzZSBtb3ZlLiBUaGlzIHdv cmsgaXMgdXN1YWxseQotICAgIC8vIGRvbmUgaW4gaGFuZGxlTW91c2VQcmVzc0V2ZW50LCBidXQg bm90IGlmIHRoZSBtb3VzZSBwcmVzcyB3YXMgb24gYW4gZXhpc3Rpbmcgc2VsZWN0aW9uLgotICAg IFZpc2libGVTZWxlY3Rpb24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNl bGVjdGlvbigpOwotCiAjaWYgRU5BQkxFKFNWRykKICAgICAvLyBTcGVjaWFsIGNhc2UgdG8gbGlt aXQgc2VsZWN0aW9uIHRvIHRoZSBjb250YWluaW5nIGJsb2NrIGZvciBTVkcgdGV4dC4KICAgICAv LyBGSVhNRTogSXNuJ3QgdGhlcmUgYSBiZXR0ZXIgbm9uLVNWRy1zcGVjaWZpYyB3YXkgdG8gZG8g dGhpcz8K 89527 2011-04-13 21:41:46 -0700 2011-04-14 15:41:32 -0700 Patch bug-55552-20110414144143.patch text/plain 15706 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM2NzQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkZWZjZjg5MzEyZjQ3ZWIwNGU3YmE0 NDkxZDNmMzdjMjA0ZjRmNGQ3Li5hOTc3ZTUzZWZiMWRjMmQ5YmZhNTk2YTUyZTY2NGQ4NDE2Nzkw MWI5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFnZ2luZyBv dXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxlY3RzIHRv IHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBpbmcgYmFj ayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vcmVzb3Vy Y2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qczogQWRkZWQuCisgICAgICAgIChs b2cpOgorICAgICAgICAoZWxzZS53aW5kb3cub25tb3VzZXVwKToKKyAgICAgICAgKGdldFNlbGVj dGlvblN0YXJ0KToKKyAgICAgICAgKGdldFNlbGVjdGlvbkVuZCk6CisgICAgICAgIChjaGVja1Nl bGVjdGlvbik6CisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0 YWJsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQ6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1jb250ZW50ZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC10ZXh0YXJlYS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sOiBBZGRlZC4KKwogMjAxMS0w NC0xMiAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtR dF0gaHR0cC90ZXN0cy9taXNjL2Zhdmljb24tbG9hZHMtd2l0aC1pY29uLWxvYWRpbmctb3ZlcnJp ZGUuaHRtbCBmYWlscwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v cmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRlc3Rz L2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFi bGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZmI0YzlkYzVlNzQ1OThlOGNjYzllNDQ2N2NhOTU1M2YxODJjNzEx ZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291 cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0NyBAQAor ZnVuY3Rpb24gbG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xl JykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQor CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikg eworICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4ID0g ZmxvYXRlZEVkaXRhYmxlLm9mZnNldExlZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdpZHRo IC8gMik7CisgICAgdmFyIHkgPSBmbG9hdGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0ZWRF ZGl0YWJsZS5vZmZzZXRIZWlnaHQgLyAyKTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4 LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVkaXRh YmxlLm9mZnNldExlZnQgKyBmbG9hdGVkRWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAgIGV2 ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3YXJk KDI1MCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworCisgICAgY2hlY2tTZWxlY3Rpb24o KTsKK30gZWxzZSB7CisgICAgd2luZG93Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAgICAg ICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5wdXQg c2VsZWN0aW9uIHN0YXJ0OiAnICsgZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKSAr ICcsIGVuZDogJyArCisgICAgICAgICAgICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0 YWJsZSkpOworICAgICAgICAgICAgY2hlY2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7ICAv LyBXaXRob3V0IGEgdGltZW91dCB0aGUgc2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmludGVk CisgICAgfQorfQorCitmdW5jdGlvbiBnZXRTZWxlY3Rpb25TdGFydChlbGVtZW50KSB7CisgICAg cmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCku YmFzZU9mZnNldCA6IGVsZW1lbnQuc2VsZWN0aW9uU3RhcnQ7Cit9CisKK2Z1bmN0aW9uIGdldFNl bGVjdGlvbkVuZChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFi bGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZXh0ZW50T2Zmc2V0IDogZWxlbWVudC5zZWxlY3Rp b25FbmQ7Cit9CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1dFRl eHQgPSBmbG9hdGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFibGUu dGV4dENvbnRlbnQgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIHNlbGVjdGlvblN0 YXJ0ID0gZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2VsZWN0 aW9uRW5kID0gZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIgc2Vs ZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rpb25T dGFydCA8IGlucHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvbkdvZXNUb0VuZCA9IHNl bGVjdGlvbkVuZCA9PSBpbnB1dFRleHQubGVuZ3RoOworICAgIGlmIChzZWxlY3Rpb25TdGFydHNG cm9tTWlkZGxlICYmIHNlbGVjdGlvbkdvZXNUb0VuZCkKKyAgICAgICAgcmVzdWx0LmlubmVySFRN TCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVlbiI+ U1VDQ0VTUzwvc3Bhbj4nOworICAgIGVsc2UKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8 c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZBSUw8L3Nw YW4+JzsKK30KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZWRpdGFibGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0YWJsZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOGRh ODNiYTYzNWY2ZDc1ODdmNzQ5ZDAxZGFkNzBlYzFlZmY4YWI4YgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAoraGVsbG8gd29ybGQKK0RyYWdnaW5nIHRvIHRoZSBs ZWZ0OiBQQVNTCitEcmFnZ2luZyB0byB0aGUgbGVmdDogUEFTUworCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0bWwgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uMDU3MDdmZmJiNmFhNDBjOTVjNjQ2YzIyN2VjMDU1ZTA2YTAxNzc5MQotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZWRpdGFibGUuaHRtbApAQCAtMCwwICsxLDYxIEBACis8IURPQ1RZUEUgaHRtbD4gCis8aHRt bD4gCis8Ym9keT4gCis8cCBpZD0iZGVzY3JpcHRpb24iPlRoaXMgdGVzdCBlbnN1cmVzIHRoYXQg d2hlbiBlZGl0YWJsZSB0ZXh0IGlzIHNlbGVjdGVkIGJ5IGEgZHJhZyB0aGF0IGVuZHMgb3V0c2lk ZSBvZiB0aGUgZWRpdGFibGUgcmVnaW9uLCBzZWxlY3Rpb24gaXMgZXh0ZW5kZWQgdG8gdGhlIGVp dGhlciBlbmQgb2YgdGhlIHRleHQuIFNlZSB0aGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTUyOTg2Ij5idWcgNTI5ODY8L2E+IGZvciBtb3JlIGRldGFp bHMuPC9wPiAKKzxkaXYgaWQ9InRlc3QiIGNvbnRlbnRlZGl0YWJsZSBzdHlsZT0id2lkdGg6IDIw MHB4OyBtYXJnaW46IDIwcHg7IGJvcmRlcjogc29saWQgMXB4OyBmb250LXNpemU6IHgtbGFyZ2U7 Ij5oZWxsbyB3b3JsZDwvZGl2PiAKKzxzY3JpcHQ+IAorIAorZnVuY3Rpb24gc2VsZWN0VGV4dEJ5 RHJhZyhkaXYsIGVuZFgsIGVuZFkpIHsKKyAgICB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkucmVtb3Zl QWxsUmFuZ2VzKCk7CisgCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2Lm9mZnNldExl ZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMikgLCBkaXYub2Zmc2V0VG9wICsgKGRpdi5vZmZzZXRI ZWlnaHQgLyAyKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisgICAgZXZlbnRT ZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICAvLyBXaXRob3V0IHRoaXMsIGRyYWcgZG9l c24ndCBzdGFydCBzZWxlY3Rpb24uCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2Lm9m ZnNldExlZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMykgLCBkaXYub2Zmc2V0VG9wICsgKGRpdi5v ZmZzZXRIZWlnaHQgLyAzKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisgICAg ZXZlbnRTZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICBldmVudFNlbmRlci5tb3VzZU1v dmVUbyhlbmRYLCBlbmRZKTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cit9CisgCit2YXIg bG9nID0gJyc7CisgCitmdW5jdGlvbiBhc3NlcnRFcXVhbChhY3R1YWwsIGV4cGVjdGVkKSB7Cisg ICAgaWYgKGFjdHVhbCA9PSBleHBlY3RlZCkKKyAgICAgICAgbG9nICs9ICdQQVNTJzsKKyAgICBl bHNlCisgICAgICAgIGxvZyArPSAnRkFJTCAtIGV4cGVjdGVkICcgKyBleHBlY3RlZCArICcgYnV0 IGdvdCAnICsgYWN0dWFsOworICAgIGxvZyArPSAnXG4nOworfQorIAoraWYgKCF3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIgfHwgIXdpbmRvdy5ldmVudFNlbmRlcikKKyAgICBkb2N1bWVudC53 cml0ZWxuKCJUaGlzIHRlc3QgcmVxdWlyZXMgZXZlbnRTZW5kZXIgc2luY2UgdGhlIGJ1ZyBkb2Vz IG5vdCByZXByb2R1Y2UgcmVsaWFibHkgd2hlbiB0ZXN0ZWQgbWFudWFsbHkuIik7CitlbHNlIHsK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgdmFyIGRlc2NyaXB0 aW9uID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Rlc2NyaXB0aW9uJyk7CisgICAgZGVzY3Jp cHRpb24uc3R5bGUuZGlzcGxheSA9ICdub25lJzsKKyAKKyAgICB2YXIgZGl2ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdnaW5nIHRvIHRoZSBs ZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0TGVmdCAtIDEwLCBk aXYub2Zmc2V0VG9wIC0gMTApOworICAgIGFzc2VydEVxdWFsKHdpbmRvdy5nZXRTZWxlY3Rpb24o KS5nZXRSYW5nZUF0KDApLnN0YXJ0T2Zmc2V0LCAwKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdnaW5n IHRvIHRoZSBsZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0TGVm dCArIDMwMCwgZGl2Lm9mZnNldFRvcCArIDEwMCk7CisgICAgYXNzZXJ0RXF1YWwod2luZG93Lmdl dFNlbGVjdGlvbigpLmdldFJhbmdlQXQoMCkuZW5kT2Zmc2V0LCBkaXYuaW5uZXJUZXh0Lmxlbmd0 aCk7CisgCisgICAgLy8gSGF2aW5nIHRoZSBsb2cgaW4gRE9NIHdpbGwgaW50ZXJmZXJlIHdpdGgg dGhlIHRlc3Qgc28gYXBwZW5kIGl0IGF0IGxhc3QuCisgICAgdmFyIGNvbnNvbGUgPSBkb2N1bWVu dC5jcmVhdGVFbGVtZW50KCdwcmUnKTsKKyAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGNv bnNvbGUpOworICAgIGNvbnNvbGUuaW5uZXJIVE1MID0gbG9nOworfQorIAorPC9zY3JpcHQ+IAor PC9ib2R5PiAKKzwvaHRtbD4gCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1jb250 ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFjYzg3ZWE1ODlkNTdmODZjNzA5 ZGM1MTdmNzkyYTE5ZGMxYzkxNGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gRHJh ZyBmcm9tIHRoZSBtaWRkbGUuIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRleHQg YWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlkZGxl IG9mIHRoZSBlZGl0YWJsZSBkaXYgdG8gdGhlIHJpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0 ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBlbGVt ZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorCitTVUNDRVNTCisKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVk LWNvbnRlbnRlZGl0YWJsZS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2Vs ZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI2ZGE0 ODAyYTQwZTU5ZTZlYzRmODRkNDg3NzljYjVjZmRjZmFkM2QKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVu dGVkaXRhYmxlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPCFET0NUWVBFIGh0bWw+CitTb21lIHRl eHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8ZGl2IGNvbnRlbnRlZGl0YWJsZT10cnVlIGlkPSJmbG9h dGVkRWRpdGFibGUiIHN0eWxlPSJmbG9hdDogbGVmdDsiPgorICBEcmFnIGZyb20gdGhlIG1pZGRs ZS4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNv bWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZs b2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBk cmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgZWRpdGFibGUgZGl2IHRvIHRoZQorcmlnaHQsIGlu dG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBl bmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgor PC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyI+PC9z Y3JpcHQ+CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVj dC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmRjMTM2NjU1ZGRhMDQ2NTY4MTAxYTRjYjJiMWQzMjJkOTAxNjMwZWYKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29tZSB0ZXh0IGJlZm9y ZSB0aGUgZmxvYXRzLiBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4gU29tZSB0ZXh0IGFmdGVy IHRoZSBmbG9hdHMuCitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0 aGUgaW5wdXQgZWxlbWVudCB0byB0aGUgcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQu IFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQgb2YgdGhlIGlucHV0IGVsZW1lbnQg YW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCisKK1NVQ0NFU1MKKworCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5w dXQuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxv YXRlZC1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJmM2Y0ZTUzZTI3YWY3MTQzZjg4MDY3NmVkM2M1 MWMwZjYzZjIzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVj dGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbApAQCAtMCwwICsxLDE4IEBACis8 IURPQ1RZUEUgaHRtbD4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXYgc3R5bGU9 ImZsb2F0OiBsZWZ0OyI+CisgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iZmxvYXRlZEVkaXRhYmxl IiB2YWx1ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lk dGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2Lgor PC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRv cDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUg aW5wdXQgZWxlbWVudCB0byB0aGUKK3JpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0LiBU aGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kCitvZiB0aGUgaW5wdXQgZWxlbWVudCBh bmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKzwvcD4KKzxwIGlkPSJyZXN1bHQiPjwvcD4K KzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zZWxlY3Qt b3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFyZWEt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1v Zi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NTdlYTFjYjY2YjVm YTA2YzdjNzJjNmI5YTE3NGRjOThiZTUyNTQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4gU29t ZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgorVG8g dGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRvIHRo ZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91bGQg Z28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhlIGJl Z2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcv c2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVz dHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZDBmYjhjYTkyNTYzMzVlYzM5NTUxYjA5ZGQ5NTA5YzM4NmE1YzhiNAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQt b2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCkBAIC0wLDAgKzEsMTggQEAKKzwhRE9DVFlQRSBodG1s PgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLgorPGRpdiBzdHlsZT0iZmxvYXQ6IGxlZnQ7 Ij4KKyAgPHRleHRhcmVhIHJvd3M9IjEiIGlkPSJmbG9hdGVkRWRpdGFibGUiPkRyYWcgZnJvbSB0 aGUgbWlkZGxlLjwvdGV4dGFyZWE+Cis8L2Rpdj4KKzxkaXYgc3R5bGU9IndpZHRoOiAxMDAlOyBm bG9hdDogbGVmdDsiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4KKzwvZGl2PgorU29t ZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cCBzdHlsZT0icGFkZGluZy10b3A6IDFlbTsiPgor VG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRv IHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hv dWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0 aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29s ZSI+PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1l ZGl0YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAxMmM0MTgxOGYxYjM4M2NhY2U5 YmEyNDc5NjU2NTJkNTdiMmE1ZDU1Li5iNDMzZjczZDBiNmQ2MWNmMWI0ZTIwOTMyMDFmMTYwNzE4 ZGRmMjYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTEtMDQtMTEgIEFsaWNlIEJv eGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVk bHkgd2hlbiBkcmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHM6IGVkaXRp bmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbAorICAgICAgICAgICAgICAg ZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5o dG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0 ZWQtaW5wdXQuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91 dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKKworICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRhcmdldFBvc2l0aW9uRm9yU2VsZWN0aW9uRW5kcG9p bnQpOiBXaGVuIGRyYWdnaW5nIGZyb20gYW4gZWRpdGFibGUgZWxlbWVudCwgY2hlY2sgdGhhdAor ICAgICAgICB0aGUgZW5kcG9pbnQgaXMgbm90IG91dHNpZGUgdGhlIGVsZW1lbnQuIElmIGl0IGlz LCB0cmFuc2xhdGUgdGhlIHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4KKyAgICAgICAg dGhlIGVkaXRhYmxlIGVsZW1lbnQuCisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnVw ZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyk6IENhbGwgdGFyZ2V0UG9zaXRpb25Gb3JTZWxlY3Rp b25FbmRwb2ludCgpIHRvCisgICAgICAgIGNhbGN1bGF0ZSB0aGUgc2VsZWN0aW9uIGVuZHBvaW50 LgorCiAyMDExLTA0LTEyICBBZHJpZW5uZSBXYWxrZXIgIDxlbm5lQGdvb2dsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFu ZGxlci5jcHAKaW5kZXggM2E3Yjc3Y2QzMjY3OTg1ZGUwMzIwZjI2NjY5OTIwZmU3YWYwMTliNi4u YWVmYmI1ZWJmNWE0ZTE1MWI4NWFhYjJkYTM3NWNkM2M2ZjVjNDBkMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtNjIyLDYgKzYyMiwyOCBAQCB2b2lkIEV2ZW50SGFuZGxl cjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKCkKICAgICB1cGRhdGVTZWxlY3Rpb25Gb3JN b3VzZURyYWcocmVzdWx0KTsKIH0KIAorc3RhdGljIFZpc2libGVQb3NpdGlvbiBzZWxlY3Rpb25F eHRlbnRSZXNwZWN0aW5nRWRpdGluZ0JvdW5kYXJ5KGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNl bGVjdGlvbiwgY29uc3QgSW50UG9pbnQmIGxvY2FsUG9pbnQsIE5vZGUqIHRhcmdldE5vZGUpCit7 CisgICAgSW50UG9pbnQgc2VsZWN0aW9uRW5kUG9pbnQgPSBsb2NhbFBvaW50OworICAgIEVsZW1l bnQqIGVkaXRhYmxlRWxlbWVudCA9IHNlbGVjdGlvbi5yb290RWRpdGFibGVFbGVtZW50KCk7Cisg ICAgTm9kZSogc2VsZWN0aW9uRW5kTm9kZSA9IHRhcmdldE5vZGU7CisKKyAgICBpZiAoZWRpdGFi bGVFbGVtZW50ICYmICFlZGl0YWJsZUVsZW1lbnQtPmNvbnRhaW5zKHRhcmdldE5vZGUpKSB7Cisg ICAgICAgIHNlbGVjdGlvbkVuZE5vZGUgPSBlZGl0YWJsZUVsZW1lbnQ7CisKKyAgICAgICAgaWYg KCFzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpKQorICAgICAgICAgICAgcmV0dXJuIFZpc2li bGVQb3NpdGlvbigpOworCisgICAgICAgIEZsb2F0UG9pbnQgYWJzb2x1dGVQb2ludCA9IHRhcmdl dE5vZGUtPnJlbmRlcmVyKCktPmxvY2FsVG9BYnNvbHV0ZShGbG9hdFBvaW50KHNlbGVjdGlvbkVu ZFBvaW50KSk7CisgICAgICAgIHNlbGVjdGlvbkVuZFBvaW50ID0gcm91bmRlZEludFBvaW50KHNl bGVjdGlvbkVuZE5vZGUtPnJlbmRlcmVyKCktPmFic29sdXRlVG9Mb2NhbChhYnNvbHV0ZVBvaW50 KSk7CisgICAgfQorCisgICAgaWYgKCFzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpKQorICAg ICAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9uKCk7CisKKyAgICByZXR1cm4gc2VsZWN0aW9uRW5k Tm9kZS0+cmVuZGVyZXIoKS0+cG9zaXRpb25Gb3JQb2ludChzZWxlY3Rpb25FbmRQb2ludCk7Cit9 CisKIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWcoY29uc3Qg SGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJlc3VsdCkKIHsKICAgICBpZiAoIW1fbW91c2VEb3duTWF5 U3RhcnRTZWxlY3QpCkBAIC02MzQsMjAgKzY1NiwxMyBAQCB2b2lkIEV2ZW50SGFuZGxlcjo6dXBk YXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKGNvbnN0IEhpdFRlc3RSZXN1bHQmIGhpdFRlc3RSZXN1 bAogICAgIGlmICghY2FuTW91c2VEcmFnRXh0ZW5kU2VsZWN0KHRhcmdldCkpCiAgICAgICAgIHJl dHVybjsKIAotICAgIFJlbmRlck9iamVjdCogdGFyZ2V0UmVuZGVyZXIgPSB0YXJnZXQtPnJlbmRl cmVyKCk7Ci0gICAgaWYgKCF0YXJnZXRSZW5kZXJlcikKLSAgICAgICAgcmV0dXJuOwotCi0gICAg VmlzaWJsZVBvc2l0aW9uIHRhcmdldFBvc2l0aW9uID0gdGFyZ2V0UmVuZGVyZXItPnBvc2l0aW9u Rm9yUG9pbnQoaGl0VGVzdFJlc3VsdC5sb2NhbFBvaW50KCkpOworICAgIFZpc2libGVTZWxlY3Rp b24gbmV3U2VsZWN0aW9uID0gbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNlbGVjdGlvbigpOworICAg IFZpc2libGVQb3NpdGlvbiB0YXJnZXRQb3NpdGlvbiA9IHNlbGVjdGlvbkV4dGVudFJlc3BlY3Rp bmdFZGl0aW5nQm91bmRhcnkobmV3U2VsZWN0aW9uLCBoaXRUZXN0UmVzdWx0LmxvY2FsUG9pbnQo KSwgdGFyZ2V0KTsKIAogICAgIC8vIERvbid0IG1vZGlmeSB0aGUgc2VsZWN0aW9uIGlmIHdlJ3Jl IG5vdCBvbiBhIG5vZGUuCiAgICAgaWYgKHRhcmdldFBvc2l0aW9uLmlzTnVsbCgpKQogICAgICAg ICByZXR1cm47CiAKLSAgICAvLyBSZXN0YXJ0IHRoZSBzZWxlY3Rpb24gaWYgdGhpcyBpcyB0aGUg Zmlyc3QgbW91c2UgbW92ZS4gVGhpcyB3b3JrIGlzIHVzdWFsbHkKLSAgICAvLyBkb25lIGluIGhh bmRsZU1vdXNlUHJlc3NFdmVudCwgYnV0IG5vdCBpZiB0aGUgbW91c2UgcHJlc3Mgd2FzIG9uIGFu IGV4aXN0aW5nIHNlbGVjdGlvbi4KLSAgICBWaXNpYmxlU2VsZWN0aW9uIG5ld1NlbGVjdGlvbiA9 IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZWxlY3Rpb24oKTsKLQogI2lmIEVOQUJMRShTVkcpCiAg ICAgLy8gU3BlY2lhbCBjYXNlIHRvIGxpbWl0IHNlbGVjdGlvbiB0byB0aGUgY29udGFpbmluZyBi bG9jayBmb3IgU1ZHIHRleHQuCiAgICAgLy8gRklYTUU6IElzbid0IHRoZXJlIGEgYmV0dGVyIG5v bi1TVkctc3BlY2lmaWMgd2F5IHRvIGRvIHRoaXM/Cg== 89672 2011-04-14 15:41:39 -0700 2011-04-15 06:45:13 -0700 Patch bug-55552-20110415084136.patch text/plain 15163 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogODM4MTEKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA1MWQ5MzExYWExMzBlNTk2OGQzOTY1 MGVkOTU2NTgwOTY1NGY3Y2IzLi42NGVkYjc5NTg0NzdjZWE1YTQyNTFmMGM5MDU5NzFkNmIzMDE1 M2M2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTEtMDQtMTQgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVjdGVkbHkgd2hlbiBk cmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHMgdGhhdCBkcmFnZ2luZyBv dXRzaWRlIG9mIGEgY29udGVudGVkaXRhYmxlLCBpbnB1dCBvciB0ZXh0YXJlYSBzZWxlY3RzIHRv IHRoZSBlbmQgb2YgdGhlCisgICAgICAgIGVsZW1lbnQsIHJhdGhlciB0aGFuIGp1bXBpbmcgYmFj ayB0byB0aGUgYmVnaW5uaW5nLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vcmVzb3Vy Y2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qczogQWRkZWQuCisgICAgICAgIChs b2cpOgorICAgICAgICAoZWxzZS53aW5kb3cub25tb3VzZXVwKToKKyAgICAgICAgKGdldFNlbGVj dGlvblN0YXJ0KToKKyAgICAgICAgKGdldFNlbGVjdGlvbkVuZCk6CisgICAgICAgIChjaGVja1Nl bGVjdGlvbik6CisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0 YWJsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxl Y3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS1leHBlY3RlZC50eHQ6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1jb250ZW50ZWRpdGFibGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rp b24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWlucHV0Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC10ZXh0YXJlYS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0 aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sOiBBZGRlZC4KKwogMjAxMS0w NC0xMyAgT2xpdmVyIEh1bnQgIDxvbGl2ZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEdlb2ZmIEdhcmVuLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vcmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyBiL0xheW91dFRl c3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jlc291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRp dGFibGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZmI0YzlkYzVlNzQ1OThlOGNjYzllNDQ2N2NhOTU1M2YxODJj NzExZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Jl c291cmNlcy9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMKQEAgLTAsMCArMSw0NyBA QAorZnVuY3Rpb24gbG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25z b2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOwor fQorCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRl cikgeworICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZhciB4 ID0gZmxvYXRlZEVkaXRhYmxlLm9mZnNldExlZnQgKyAoZmxvYXRlZEVkaXRhYmxlLm9mZnNldFdp ZHRoIC8gMik7CisgICAgdmFyIHkgPSBmbG9hdGVkRWRpdGFibGUub2Zmc2V0VG9wICsgKGZsb2F0 ZWRFZGl0YWJsZS5vZmZzZXRIZWlnaHQgLyAyKTsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVU byh4LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICB4ID0gZmxvYXRlZEVk aXRhYmxlLm9mZnNldExlZnQgKyBmbG9hdGVkRWRpdGFibGUub2Zmc2V0V2lkdGggKyA1OworICAg IGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3 YXJkKDI1MCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworCisgICAgY2hlY2tTZWxlY3Rp b24oKTsKK30gZWxzZSB7CisgICAgd2luZG93Lm9ubW91c2V1cCA9IGZ1bmN0aW9uKCkgeworICAg ICAgICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxvZygnSW5w dXQgc2VsZWN0aW9uIHN0YXJ0OiAnICsgZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxl KSArICcsIGVuZDogJyArCisgICAgICAgICAgICAgICAgZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRF ZGl0YWJsZSkpOworICAgICAgICAgICAgY2hlY2tTZWxlY3Rpb24oKTsKKyAgICAgICAgfSwgMCk7 ICAvLyBXaXRob3V0IGEgdGltZW91dCB0aGUgc2VsZWN0aW9uIGlzIGluYWNjdXJhdGVseSBwcmlu dGVkCisgICAgfQorfQorCitmdW5jdGlvbiBnZXRTZWxlY3Rpb25TdGFydChlbGVtZW50KSB7Cisg ICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9u KCkuYmFzZU9mZnNldCA6IGVsZW1lbnQuc2VsZWN0aW9uU3RhcnQ7Cit9CisKK2Z1bmN0aW9uIGdl dFNlbGVjdGlvbkVuZChlbGVtZW50KSB7CisgICAgcmV0dXJuIGVsZW1lbnQuaXNDb250ZW50RWRp dGFibGUgPyB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuZXh0ZW50T2Zmc2V0IDogZWxlbWVudC5zZWxl Y3Rpb25FbmQ7Cit9CisKK2Z1bmN0aW9uIGNoZWNrU2VsZWN0aW9uKCkgeworICAgIHZhciBpbnB1 dFRleHQgPSBmbG9hdGVkRWRpdGFibGUuaXNDb250ZW50RWRpdGFibGUgPyBmbG9hdGVkRWRpdGFi bGUudGV4dENvbnRlbnQgOiBmbG9hdGVkRWRpdGFibGUudmFsdWU7CisgICAgdmFyIHNlbGVjdGlv blN0YXJ0ID0gZ2V0U2VsZWN0aW9uU3RhcnQoZmxvYXRlZEVkaXRhYmxlKTsKKyAgICB2YXIgc2Vs ZWN0aW9uRW5kID0gZ2V0U2VsZWN0aW9uRW5kKGZsb2F0ZWRFZGl0YWJsZSk7CisKKyAgICB2YXIg c2VsZWN0aW9uU3RhcnRzRnJvbU1pZGRsZSA9IHNlbGVjdGlvblN0YXJ0ID4gMCAmJiBzZWxlY3Rp b25TdGFydCA8IGlucHV0VGV4dC5sZW5ndGg7CisgICAgdmFyIHNlbGVjdGlvbkdvZXNUb0VuZCA9 IHNlbGVjdGlvbkVuZCA9PSBpbnB1dFRleHQubGVuZ3RoOworICAgIGlmIChzZWxlY3Rpb25TdGFy dHNGcm9tTWlkZGxlICYmIHNlbGVjdGlvbkdvZXNUb0VuZCkKKyAgICAgICAgcmVzdWx0LmlubmVy SFRNTCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVl biI+U1VDQ0VTUzwvc3Bhbj4nOworICAgIGVsc2UKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9 ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZBSUw8 L3NwYW4+JzsKK30KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZWRpdGFibGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9z ZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1lZGl0YWJsZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u OGRhODNiYTYzNWY2ZDc1ODdmNzQ5ZDAxZGFkNzBlYzFlZmY4YWI4YgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAoraGVsbG8gd29ybGQKK0RyYWdnaW5nIHRvIHRo ZSBsZWZ0OiBQQVNTCitEcmFnZ2luZyB0byB0aGUgbGVmdDogUEFTUworCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0bWwg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWVkaXRhYmxlLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMDU3MDdmZmJiNmFhNDBjOTVjNjQ2YzIyN2VjMDU1ZTA2YTAxNzc5MQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1v dXQtb2YtZWRpdGFibGUuaHRtbApAQCAtMCwwICsxLDYxIEBACis8IURPQ1RZUEUgaHRtbD4gCis8 aHRtbD4gCis8Ym9keT4gCis8cCBpZD0iZGVzY3JpcHRpb24iPlRoaXMgdGVzdCBlbnN1cmVzIHRo YXQgd2hlbiBlZGl0YWJsZSB0ZXh0IGlzIHNlbGVjdGVkIGJ5IGEgZHJhZyB0aGF0IGVuZHMgb3V0 c2lkZSBvZiB0aGUgZWRpdGFibGUgcmVnaW9uLCBzZWxlY3Rpb24gaXMgZXh0ZW5kZWQgdG8gdGhl IGVpdGhlciBlbmQgb2YgdGhlIHRleHQuIFNlZSB0aGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUyOTg2Ij5idWcgNTI5ODY8L2E+IGZvciBtb3JlIGRl dGFpbHMuPC9wPiAKKzxkaXYgaWQ9InRlc3QiIGNvbnRlbnRlZGl0YWJsZSBzdHlsZT0id2lkdGg6 IDIwMHB4OyBtYXJnaW46IDIwcHg7IGJvcmRlcjogc29saWQgMXB4OyBmb250LXNpemU6IHgtbGFy Z2U7Ij5oZWxsbyB3b3JsZDwvZGl2PiAKKzxzY3JpcHQ+IAorIAorZnVuY3Rpb24gc2VsZWN0VGV4 dEJ5RHJhZyhkaXYsIGVuZFgsIGVuZFkpIHsKKyAgICB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkucmVt b3ZlQWxsUmFuZ2VzKCk7CisgCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2Lm9mZnNl dExlZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMikgLCBkaXYub2Zmc2V0VG9wICsgKGRpdi5vZmZz ZXRIZWlnaHQgLyAyKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisgICAgZXZl bnRTZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICAvLyBXaXRob3V0IHRoaXMsIGRyYWcg ZG9lc24ndCBzdGFydCBzZWxlY3Rpb24uCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oZGl2 Lm9mZnNldExlZnQgKyAoZGl2Lm9mZnNldFdpZHRoIC8gMykgLCBkaXYub2Zmc2V0VG9wICsgKGRp di5vZmZzZXRIZWlnaHQgLyAzKSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgCisg ICAgZXZlbnRTZW5kZXIubGVhcEZvcndhcmQoMjAwKTsKKyAKKyAgICBldmVudFNlbmRlci5tb3Vz ZU1vdmVUbyhlbmRYLCBlbmRZKTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cit9CisgCit2 YXIgbG9nID0gJyc7CisgCitmdW5jdGlvbiBhc3NlcnRFcXVhbChhY3R1YWwsIGV4cGVjdGVkKSB7 CisgICAgaWYgKGFjdHVhbCA9PSBleHBlY3RlZCkKKyAgICAgICAgbG9nICs9ICdQQVNTJzsKKyAg ICBlbHNlCisgICAgICAgIGxvZyArPSAnRkFJTCAtIGV4cGVjdGVkICcgKyBleHBlY3RlZCArICcg YnV0IGdvdCAnICsgYWN0dWFsOworICAgIGxvZyArPSAnXG4nOworfQorIAoraWYgKCF3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIgfHwgIXdpbmRvdy5ldmVudFNlbmRlcikKKyAgICBkb2N1bWVu dC53cml0ZWxuKCJUaGlzIHRlc3QgcmVxdWlyZXMgZXZlbnRTZW5kZXIgc2luY2UgdGhlIGJ1ZyBk b2VzIG5vdCByZXByb2R1Y2UgcmVsaWFibHkgd2hlbiB0ZXN0ZWQgbWFudWFsbHkuIik7CitlbHNl IHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgdmFyIGRlc2Ny aXB0aW9uID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Rlc2NyaXB0aW9uJyk7CisgICAgZGVz Y3JpcHRpb24uc3R5bGUuZGlzcGxheSA9ICdub25lJzsKKyAKKyAgICB2YXIgZGl2ID0gZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdnaW5nIHRvIHRo ZSBsZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0TGVmdCAtIDEw LCBkaXYub2Zmc2V0VG9wIC0gMTApOworICAgIGFzc2VydEVxdWFsKHdpbmRvdy5nZXRTZWxlY3Rp b24oKS5nZXRSYW5nZUF0KDApLnN0YXJ0T2Zmc2V0LCAwKTsKKyAKKyAgICBsb2cgKz0gJ0RyYWdn aW5nIHRvIHRoZSBsZWZ0OiAnOworICAgIHNlbGVjdFRleHRCeURyYWcoZGl2LCBkaXYub2Zmc2V0 TGVmdCArIDMwMCwgZGl2Lm9mZnNldFRvcCArIDEwMCk7CisgICAgYXNzZXJ0RXF1YWwod2luZG93 LmdldFNlbGVjdGlvbigpLmdldFJhbmdlQXQoMCkuZW5kT2Zmc2V0LCBkaXYuaW5uZXJUZXh0Lmxl bmd0aCk7CisgCisgICAgLy8gSGF2aW5nIHRoZSBsb2cgaW4gRE9NIHdpbGwgaW50ZXJmZXJlIHdp dGggdGhlIHRlc3Qgc28gYXBwZW5kIGl0IGF0IGxhc3QuCisgICAgdmFyIGNvbnNvbGUgPSBkb2N1 bWVudC5jcmVhdGVFbGVtZW50KCdwcmUnKTsKKyAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxk KGNvbnNvbGUpOworICAgIGNvbnNvbGUuaW5uZXJIVE1MID0gbG9nOworfQorIAorPC9zY3JpcHQ+ IAorPC9ib2R5PiAKKzwvaHRtbD4gCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3Nl bGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1j b250ZW50ZWRpdGFibGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFjYzg3ZWE1ODlkNTdmODZj NzA5ZGM1MTdmNzkyYTE5ZGMxYzkxNGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29udGVudGVkaXRhYmxlLWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4g RHJhZyBmcm9tIHRoZSBtaWRkbGUuIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LiBTb21lIHRl eHQgYWZ0ZXIgdGhlIGZsb2F0cy4KK1RvIHRlc3QgbWFudWFsbHksIGRyYWcgZnJvbSB0aGUgbWlk ZGxlIG9mIHRoZSBlZGl0YWJsZSBkaXYgdG8gdGhlIHJpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRl ZCB0ZXh0LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kIG9mIHRoZSBpbnB1dCBl bGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5nLgorCitTVUNDRVNTCisKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9h dGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24v c2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJsZS5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI2 ZGE0ODAyYTQwZTU5ZTZlYzRmODRkNDg3NzljYjVjZmRjZmFkM2QKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtY29u dGVudGVkaXRhYmxlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPCFET0NUWVBFIGh0bWw+CitTb21l IHRleHQgYmVmb3JlIHRoZSBmbG9hdHMuCis8ZGl2IGNvbnRlbnRlZGl0YWJsZT10cnVlIGlkPSJm bG9hdGVkRWRpdGFibGUiIHN0eWxlPSJmbG9hdDogbGVmdDsiPgorICBEcmFnIGZyb20gdGhlIG1p ZGRsZS4KKzwvZGl2PgorPGRpdiBzdHlsZT0id2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+Cisg IFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhl IGZsb2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5nLXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5 LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0aGUgZWRpdGFibGUgZGl2IHRvIHRoZQorcmlnaHQs IGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRo ZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0byB0aGUgYmVnaW5uaW5n LgorPC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8 c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC1lZGl0YWJsZS5qcyI+ PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1vdXQtb2YtZmxvYXRlZC1pbnB1dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmRjMTM2NjU1ZGRhMDQ2NTY4MTAxYTRjYjJiMWQzMjJkOTAxNjMwZWYKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9m LWZsb2F0ZWQtaW5wdXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorU29tZSB0ZXh0IGJl Zm9yZSB0aGUgZmxvYXRzLiBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4gU29tZSB0ZXh0IGFm dGVyIHRoZSBmbG9hdHMuCitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBv ZiB0aGUgaW5wdXQgZWxlbWVudCB0byB0aGUgcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRl eHQuIFRoZSBzZWxlY3Rpb24gc2hvdWxkIGdvIHRvIHRoZSBlbmQgb2YgdGhlIGlucHV0IGVsZW1l bnQgYW5kIG5vdCBqdW1wIHRvIHRoZSBiZWdpbm5pbmcuCisKK1NVQ0NFU1MKKworCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQt aW5wdXQuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2Yt ZmxvYXRlZC1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJmM2Y0ZTUzZTI3YWY3MTQzZjg4MDY3NmVk M2M1MWMwZjYzZjIzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3Nl bGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtaW5wdXQuaHRtbApAQCAtMCwwICsxLDE4IEBA Cis8IURPQ1RZUEUgaHRtbD4KK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4KKzxkaXYgc3R5 bGU9ImZsb2F0OiBsZWZ0OyI+CisgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iZmxvYXRlZEVkaXRh YmxlIiB2YWx1ZT0iRHJhZyBmcm9tIHRoZSBtaWRkbGUuIj4KKzwvZGl2PgorPGRpdiBzdHlsZT0i d2lkdGg6IDEwMCU7IGZsb2F0OiBsZWZ0OyI+CisgIFNvbWUgZmxvYXRlZCB0ZXh0IGluIGEgZGl2 LgorPC9kaXY+CitTb21lIHRleHQgYWZ0ZXIgdGhlIGZsb2F0cy4KKzxwIHN0eWxlPSJwYWRkaW5n LXRvcDogMWVtOyI+CitUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIGZyb20gdGhlIG1pZGRsZSBvZiB0 aGUgaW5wdXQgZWxlbWVudCB0byB0aGUKK3JpZ2h0LCBpbnRvIHRoZSBub24tZmxvYXRlZCB0ZXh0 LiBUaGUgc2VsZWN0aW9uIHNob3VsZCBnbyB0byB0aGUgZW5kCitvZiB0aGUgaW5wdXQgZWxlbWVu dCBhbmQgbm90IGp1bXAgdG8gdGhlIGJlZ2lubmluZy4KKzwvcD4KKzxwIGlkPSJyZXN1bHQiPjwv cD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zZWxl Y3Qtb3V0LW9mLWZsb2F0ZWQtZWRpdGFibGUuanMiPjwvc2NyaXB0PgorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZsb2F0ZWQtdGV4dGFy ZWEtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91 dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NTdlYTFjYjY2 YjVmYTA2YzdjNzJjNmI5YTE3NGRjOThiZTUyNTQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDYgQEAKK1NvbWUgdGV4dCBiZWZvcmUgdGhlIGZsb2F0cy4g U29tZSBmbG9hdGVkIHRleHQgaW4gYSBkaXYuIFNvbWUgdGV4dCBhZnRlciB0aGUgZmxvYXRzLgor VG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVhIHRv IHRoZSByaWdodCwgaW50byB0aGUgbm9uLWZsb2F0ZWQgdGV4dC4gVGhlIHNlbGVjdGlvbiBzaG91 bGQgZ28gdG8gdGhlIGVuZCBvZiB0aGUgaW5wdXQgZWxlbWVudCBhbmQgbm90IGp1bXAgdG8gdGhl IGJlZ2lubmluZy4KKworU1VDQ0VTUworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZDBmYjhjYTkyNTYzMzVlYzM5NTUxYjA5ZGQ5NTA5YzM4NmE1YzhiNAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1v dXQtb2YtZmxvYXRlZC10ZXh0YXJlYS5odG1sCkBAIC0wLDAgKzEsMTggQEAKKzwhRE9DVFlQRSBo dG1sPgorU29tZSB0ZXh0IGJlZm9yZSB0aGUgZmxvYXRzLgorPGRpdiBzdHlsZT0iZmxvYXQ6IGxl ZnQ7Ij4KKyAgPHRleHRhcmVhIHJvd3M9IjEiIGlkPSJmbG9hdGVkRWRpdGFibGUiPkRyYWcgZnJv bSB0aGUgbWlkZGxlLjwvdGV4dGFyZWE+Cis8L2Rpdj4KKzxkaXYgc3R5bGU9IndpZHRoOiAxMDAl OyBmbG9hdDogbGVmdDsiPgorICBTb21lIGZsb2F0ZWQgdGV4dCBpbiBhIGRpdi4KKzwvZGl2Pgor U29tZSB0ZXh0IGFmdGVyIHRoZSBmbG9hdHMuCis8cCBzdHlsZT0icGFkZGluZy10b3A6IDFlbTsi PgorVG8gdGVzdCBtYW51YWxseSwgZHJhZyBmcm9tIHRoZSBtaWRkbGUgb2YgdGhlIHRleHRhcmVh IHRvIHRoZQorcmlnaHQsIGludG8gdGhlIG5vbi1mbG9hdGVkIHRleHQuIFRoZSBzZWxlY3Rpb24g c2hvdWxkIGdvIHRvIHRoZSBlbmQKK29mIHRoZSBpbnB1dCBlbGVtZW50IGFuZCBub3QganVtcCB0 byB0aGUgYmVnaW5uaW5nLgorPC9wPgorPHAgaWQ9InJlc3VsdCI+PC9wPgorPHByZSBpZD0iY29u c29sZSI+PC9wcmU+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL3NlbGVjdC1vdXQtb2YtZmxvYXRl ZC1lZGl0YWJsZS5qcyI+PC9zY3JpcHQ+CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBlZWNmNWU5ZDYwODM1Yjg5 MDk4MDBmZGZmNTBmNWMwMTE3MDJlOTAwLi41YjBmYTlkNjM4ZjIxOTc4MTY4NjhjZmY2YzhiN2Rk NWM2NDBlYzI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTEtMDQtMTQgIEFsaWNl IEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGV4dCBzZWxlY3Rpb24gY2hhbmdlcyB1bmV4cGVj dGVkbHkgd2hlbiBkcmFnZ2luZyBvdXQgb2YgdGhlIDxpbnB1dD4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU1NTUyCisKKyAgICAgICAgVGVzdHM6IGVk aXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1vdXQtb2YtZWRpdGFibGUuaHRtbAorICAgICAgICAgICAg ICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LW91dC1vZi1mbG9hdGVkLWNvbnRlbnRlZGl0YWJs ZS5odG1sCisgICAgICAgICAgICAgICBlZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3Qtb3V0LW9mLWZs b2F0ZWQtaW5wdXQuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0 LW91dC1vZi1mbG9hdGVkLXRleHRhcmVhLmh0bWwKKworICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnNlbGVjdGlvbkV4dGVudFJlc3BlY3RpbmdFZGl0 aW5nQm91bmRhcnkpOiBXaGVuIGRyYWdnaW5nIGZyb20gYW4gZWRpdGFibGUgZWxlbWVudCwgY2hl Y2sgdGhhdAorICAgICAgICB0aGUgZW5kcG9pbnQgaXMgbm90IG91dHNpZGUgdGhlIGVsZW1lbnQu IElmIGl0IGlzLCB0cmFuc2xhdGUgdGhlIHBvaW50IGludG8gYSBsb2NhbCBwb2ludCB3aXRoaW4K KyAgICAgICAgdGhlIGVkaXRhYmxlIGVsZW1lbnQuCisgICAgICAgIChXZWJDb3JlOjpFdmVudEhh bmRsZXI6OnVwZGF0ZVNlbGVjdGlvbkZvck1vdXNlRHJhZyk6IENhbGwgdGFyZ2V0UG9zaXRpb25G b3JTZWxlY3Rpb25FbmRwb2ludCgpIHRvCisgICAgICAgIGNhbGN1bGF0ZSB0aGUgc2VsZWN0aW9u IGVuZHBvaW50LgorCiAyMDExLTA0LTEzICBPbGl2ZXIgSHVudCAgPG9saXZlckBhcHBsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR2VvZmYgR2FyZW4uCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50 SGFuZGxlci5jcHAKaW5kZXggNTAxNWZmOTliYjkxZWQ2MGYyZmFkYmJmZTZmOTIxZDRhNDJiNTJj MC4uOTY3YTJlYWI5N2JmYzhiMDk3YjVjOGU1YzllNDk1YzM4MTcwMGY5MyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtNjIyLDYgKzYyMiwyOCBAQCB2b2lkIEV2ZW50SGFu ZGxlcjo6dXBkYXRlU2VsZWN0aW9uRm9yTW91c2VEcmFnKCkKICAgICB1cGRhdGVTZWxlY3Rpb25G b3JNb3VzZURyYWcocmVzdWx0KTsKIH0KIAorc3RhdGljIFZpc2libGVQb3NpdGlvbiBzZWxlY3Rp b25FeHRlbnRSZXNwZWN0aW5nRWRpdGluZ0JvdW5kYXJ5KGNvbnN0IFZpc2libGVTZWxlY3Rpb24m IHNlbGVjdGlvbiwgY29uc3QgSW50UG9pbnQmIGxvY2FsUG9pbnQsIE5vZGUqIHRhcmdldE5vZGUp Cit7CisgICAgSW50UG9pbnQgc2VsZWN0aW9uRW5kUG9pbnQgPSBsb2NhbFBvaW50OworICAgIEVs ZW1lbnQqIGVkaXRhYmxlRWxlbWVudCA9IHNlbGVjdGlvbi5yb290RWRpdGFibGVFbGVtZW50KCk7 CisgICAgTm9kZSogc2VsZWN0aW9uRW5kTm9kZSA9IHRhcmdldE5vZGU7CisKKyAgICBpZiAoZWRp dGFibGVFbGVtZW50ICYmICFlZGl0YWJsZUVsZW1lbnQtPmNvbnRhaW5zKHRhcmdldE5vZGUpKSB7 CisgICAgICAgIHNlbGVjdGlvbkVuZE5vZGUgPSBlZGl0YWJsZUVsZW1lbnQ7CisKKyAgICAgICAg aWYgKCFzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpKQorICAgICAgICAgICAgcmV0dXJuIFZp c2libGVQb3NpdGlvbigpOworCisgICAgICAgIEZsb2F0UG9pbnQgYWJzb2x1dGVQb2ludCA9IHRh cmdldE5vZGUtPnJlbmRlcmVyKCktPmxvY2FsVG9BYnNvbHV0ZShGbG9hdFBvaW50KHNlbGVjdGlv bkVuZFBvaW50KSk7CisgICAgICAgIHNlbGVjdGlvbkVuZFBvaW50ID0gcm91bmRlZEludFBvaW50 KHNlbGVjdGlvbkVuZE5vZGUtPnJlbmRlcmVyKCktPmFic29sdXRlVG9Mb2NhbChhYnNvbHV0ZVBv aW50KSk7CisgICAgfQorCisgICAgaWYgKCFzZWxlY3Rpb25FbmROb2RlLT5yZW5kZXJlcigpKQor ICAgICAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9uKCk7CisKKyAgICByZXR1cm4gc2VsZWN0aW9u RW5kTm9kZS0+cmVuZGVyZXIoKS0+cG9zaXRpb25Gb3JQb2ludChzZWxlY3Rpb25FbmRQb2ludCk7 Cit9CisKIHZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWcoY29u c3QgSGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJlc3VsdCkKIHsKICAgICBpZiAoIW1fbW91c2VEb3du TWF5U3RhcnRTZWxlY3QpCkBAIC02MzQsMTEgKzY1Niw3IEBAIHZvaWQgRXZlbnRIYW5kbGVyOjp1 cGRhdGVTZWxlY3Rpb25Gb3JNb3VzZURyYWcoY29uc3QgSGl0VGVzdFJlc3VsdCYgaGl0VGVzdFJl c3VsCiAgICAgaWYgKCFjYW5Nb3VzZURyYWdFeHRlbmRTZWxlY3QodGFyZ2V0KSkKICAgICAgICAg cmV0dXJuOwogCi0gICAgUmVuZGVyT2JqZWN0KiB0YXJnZXRSZW5kZXJlciA9IHRhcmdldC0+cmVu ZGVyZXIoKTsKLSAgICBpZiAoIXRhcmdldFJlbmRlcmVyKQotICAgICAgICByZXR1cm47Ci0KLSAg ICBWaXNpYmxlUG9zaXRpb24gdGFyZ2V0UG9zaXRpb24gPSB0YXJnZXRSZW5kZXJlci0+cG9zaXRp b25Gb3JQb2ludChoaXRUZXN0UmVzdWx0LmxvY2FsUG9pbnQoKSk7CisgICAgVmlzaWJsZVBvc2l0 aW9uIHRhcmdldFBvc2l0aW9uID0gc2VsZWN0aW9uRXh0ZW50UmVzcGVjdGluZ0VkaXRpbmdCb3Vu ZGFyeShtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+c2VsZWN0aW9uKCksIGhpdFRlc3RSZXN1bHQubG9j YWxQb2ludCgpLCB0YXJnZXQpOwogCiAgICAgLy8gRG9uJ3QgbW9kaWZ5IHRoZSBzZWxlY3Rpb24g aWYgd2UncmUgbm90IG9uIGEgbm9kZS4KICAgICBpZiAodGFyZ2V0UG9zaXRpb24uaXNOdWxsKCkp Cg==