53031 2011-01-24 11:34:44 -0800 isContentEditable is not working properly with document.designMode 2011-05-02 13:36:48 -0700 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 53437 54050 54052 1 cshu cshu amla70 commit-queue darin enrica hyatt rniwa simon.fraser oldest_to_newest 339133 0 cshu 2011-01-24 11:34:44 -0800 isContentEditable should not change if its or its ancestor's contentEditable is set, no matter whether document.designMode is enabled or not. 339149 1 79950 cshu 2011-01-24 11:45:05 -0800 Created attachment 79950 fix patch 339153 2 79950 rniwa 2011-01-24 11:53:48 -0800 Comment on attachment 79950 fix patch View in context: https://bugs.webkit.org/attachment.cgi?id=79950&action=review > Source/WebCore/html/HTMLElement.cpp:660 > + for (const ContainerNode* p = this; p; p = p->parentNode()) { Please don't one-letter variable name. > Source/WebCore/html/HTMLElement.cpp:667 > + if (p->isHTMLElement()) { > + const HTMLElement* htmlParent = static_cast<const HTMLElement*>(p); > + if (htmlParent->contentEditable() != "inherit") { > + isContentEditableSet = true; > + break; > + } > + } htmlParent is used only once. We don't need to declare this local variable here. Please do: if (p->isHTMLElement() && tatic_cast<const HTMLElement*>(p)->contentEditable() != "inherit") { isCOntentEditableSet = true; break; } Also, it's still very expensive to compare strings here. The last time I checked, isContentEditable was in our hot path, and it's crucial that we keep this function fast. I can't r+ this patch unless we come up with more efficient way of figuring this out. 339155 3 79950 darin 2011-01-24 11:55:41 -0800 Comment on attachment 79950 fix patch View in context: https://bugs.webkit.org/attachment.cgi?id=79950&action=review I am confused about this patch. Is editability actually wrong, or just the value of the isContentEditable function? I suspect this change is incorrect, but I don’t have enough information to be sure. Also, this change has a high risk of causing a major performance regression. Changing the isContentEditable function to an operation that is O(depth of tree) and that calls the contentEditable function, which allocates a new string object each time it is called, might cause a significant slowdown of many editing operations. > Source/WebCore/html/HTMLElement.cpp:660 > + for (const ContainerNode* p = this; p; p = p->parentNode()) { Please use a word for the name of the local variable, such as parent or node, rather than the letter p. > Source/WebCore/html/HTMLElement.cpp:665 > + isContentEditableSet = true; > + break; If the semantics of this function is correct, then the implementation can be simplified by just doing a return true here. There is no need to use for the boolean local variable. Or we could factor this loop out into a separate helper function. 339156 4 79950 darin 2011-01-24 11:55:56 -0800 Comment on attachment 79950 fix patch Restoring the review-. 339197 5 cshu 2011-01-24 12:27:24 -0800 Thanks so much for the review, Niwa and Darin. Please see my comments for non-trial issues. > I am confused about this patch. Is editability actually wrong, or just the value of the isContentEditable function? I suspect this change is incorrect, but I don’t have enough information to be sure. I think editability was wrong. I ran all editing tests after my change but nothing regressed though. > Also, this change has a high risk of causing a major performance regression. Changing the isContentEditable function to an operation that is O(depth of tree) and that calls the contentEditable function, which allocates a new string object each time it is called, might cause a significant slowdown of many editing operations. > Also, it's still very expensive to compare strings here. The last time I checked, isContentEditable was in our hot path, and it's crucial that we keep this function fast. I can't r+ this patch unless we come up with more efficient way of figuring this out. Right. I had this concern, too. Based on the existing implementation, which uses usermodify, I think when contenteditable is "inherit" along the tree, no usermodify data should be created and the code then checks frame's designmode. I will try if this can be done. 339198 6 cshu 2011-01-24 12:28:30 -0800 > Thanks so much for the review, Niwa and Darin. Please see my comments for non-trial issues. I mean, non-trivial. :) 339256 7 darin 2011-01-24 14:09:35 -0800 (In reply to comment #5) > > I am confused about this patch. Is editability actually wrong, or just the value of the isContentEditable function? I suspect this change is incorrect, but I don’t have enough information to be sure. > > I think editability was wrong. I ran all editing tests after my change but nothing regressed though. If we think we’re fixing a bug, but no test results change, then we have insufficient coverage. We need tests that cover actual editability if that is something being fixed here. > Right. I had this concern, too. Based on the existing implementation, which uses usermodify, I think when contenteditable is "inherit" along the tree, no usermodify data should be created and the code then checks frame's designmode. > I will try if this can be done. Yes, that’s the kind of fix that would fit in with the current implementation much better. 339259 8 cshu 2011-01-24 14:15:07 -0800 I am thinking about two approaches: 1. Update the default render style userModify (it was read_only initially) to read_write inside Document::setDesignMode(). 2. Use an "inherit" value for usermodify initially. If the code reads usermodify to be "inherit", it continue to check document::inDesignMode(). Actually, I see desingMode itself is a type of InheritedBool. Do they make sense? 339272 9 darin 2011-01-24 14:30:12 -0800 (In reply to comment #8) > 1. Update the default render style userModify (it was read_only initially) to read_write inside Document::setDesignMode(). > 2. Use an "inherit" value for usermodify initially. If the code reads usermodify to be "inherit", it continue to check document::inDesignMode(). Actually, I see desingMode itself is a type of InheritedBool. All CSS styles support inheritance. You don’t need to add an inherit value to a style, because that’s just how CSS works. We should ask a CSS expert the right way to have the design mode of a document change the style of the top level element inside the document. 341569 10 80469 cshu 2011-01-28 11:33:04 -0800 Created attachment 80469 fix patch This patch is work-in-progress. I noticed it caused a regression on editing/deleting/5168598.html. However, I am not sure if it's actually a good thing. --- /tmp/layout-test-results/editing/deleting/5168598-expected.txt 2011-01-28 14:31:13.000000000 -0500 +++ /tmp/layout-test-results/editing/deleting/5168598-actual.txt 2011-01-28 14:31:13.000000000 -0500 @@ -17,5 +17,4 @@ RenderText {#text} at (0,0) size 0x0 layer at (13,83) size 119x13 RenderBlock {DIV} at (3,3) size 119x13 - RenderBR {BR} at (1,0) size 0x13 -caret: position 0 of child 0 {BR} of child 0 {DIV} of child 3 {INPUT} of body +caret: position 0 of child 0 {DIV} of child 3 {INPUT} of body 342791 11 80675 cshu 2011-01-31 13:40:24 -0800 Created attachment 80675 fix patch 2 344600 12 rniwa 2011-02-03 02:04:46 -0800 Looking at time profiles I posted on https://bugs.webkit.org/show_bug.cgi?id=53649, this patch might improve WebKit's performance a lot. 344678 13 80675 rniwa 2011-02-03 06:47:36 -0800 Comment on attachment 80675 fix patch 2 View in context: https://bugs.webkit.org/attachment.cgi?id=80675&action=review > Source/WebCore/html/HTMLElement.cpp:-660 > - if (document()->frame() && document()->frame()->isContentEditable()) > - return true; > - This will eliminate calls to EditorClient's clientIsEditable() method. I think we should per the bug 53649 but if we're removing the call here then we should be consistent across the code base. I used Google codesearch and found that clientIsEditable() is called in exactly two places: 1. Frame::isContentEditable - called by AccessibilityRenderObject::isReadOnly 2. DragController::operationForLoad I think we should get rid of Frame's isContentEditable method entirely and discontinue the support for EditorClient::clientIsEditable() since it's our No.1 performance bottleneck. But you should probably make EditorClient change a separate patch because it's going to be large and will involve lots of ports. I checked several major port's EditorClient but most of clientIsEditable implementation was to return a boolean member variable so removing clientIsEditable is unlikely to break things. 344681 14 cshu 2011-02-03 06:53:10 -0800 (In reply to comment #12) > Looking at time profiles I posted on https://bugs.webkit.org/show_bug.cgi?id=53649, this patch might improve WebKit's performance a lot. I believe so. isContentEditable is called so frequently that I see it's triggered multiple times on each repaint. Even worse, frame()->isContentEditable() will traverse through the entire branch and most of time, does nothing. 344686 15 rniwa 2011-02-03 06:56:41 -0800 (In reply to comment #14) > I believe so. isContentEditable is called so frequently that I see it's triggered multiple times on each repaint. Even worse, frame()->isContentEditable() will traverse through the entire branch and most of time, does nothing. Right, it's quite horrible. Would you mind removing Frame::isContentEditable and adding a FIXME to EditorClient::clientIsEditable? 344688 16 cshu 2011-02-03 07:01:37 -0800 (In reply to comment #15) > (In reply to comment #14) > > I believe so. isContentEditable is called so frequently that I see it's triggered multiple times on each repaint. Even worse, frame()->isContentEditable() will traverse through the entire branch and most of time, does nothing. > > Right, it's quite horrible. Would you mind removing Frame::isContentEditable and adding a FIXME to EditorClient::clientIsEditable? I will be happy to work on the follow-up patches. How's this plan sound: 1. land this patch that fixes the designmode. 2. cleanup Frame::isContentEditable; 3. Work on 52058 (renaming Node::isContentEditible). 4. improve/fix clientIsEditable and other related issues. 344710 17 80675 rniwa 2011-02-03 07:51:36 -0800 Comment on attachment 80675 fix patch 2 (In reply to comment #16) > (In reply to comment #15) > > Right, it's quite horrible. Would you mind removing Frame::isContentEditable and adding a FIXME to EditorClient::clientIsEditable? > > I will be happy to work on the follow-up patches. How's this plan sound: > 1. land this patch that fixes the designmode. > 2. cleanup Frame::isContentEditable; > 3. Work on 52058 (renaming Node::isContentEditible). > 4. improve/fix clientIsEditable and other related issues. Unfortunately, it can't be a followup. In this patch, you're eliminating the call to clientIsEditable and breaking the feature. So unless we completely unsupport this feature, our implementation becomes inconsistent. I suggest the following steps: 1. Land this patch after removing Frame::isContentEditable and fixing its call sites all in one patch 2. Remove EditorClient::clientIsEditable And 1 and 2 can't be broken down into smaller pieces. Alternatively, you can do: 1. Get rid of Frame::isContentEditable and remove EditorClient::clientIsEditable 2. Land this patch But this might be challenging since we seem to rely on Frame::isContentEditable for design-mode behavior. 344712 18 cshu 2011-02-03 07:53:54 -0800 Thanks so much for the suggestion. I will work on the next patch. > Unfortunately, it can't be a followup. In this patch, you're eliminating the call to clientIsEditable and breaking the feature. So unless we completely unsupport this feature, our implementation becomes inconsistent. I suggest the following steps: > > 1. Land this patch after removing Frame::isContentEditable and fixing its call sites all in one patch > 2. Remove EditorClient::clientIsEditable > > And 1 and 2 can't be broken down into smaller pieces. Alternatively, you can do: > > 1. Get rid of Frame::isContentEditable and remove EditorClient::clientIsEditable > 2. Land this patch > > But this might be challenging since we seem to rely on Frame::isContentEditable for design-mode behavior. 347799 19 81715 cshu 2011-02-08 16:33:17 -0800 Created attachment 81715 fix patch 3 347830 20 81715 rniwa 2011-02-08 17:17:43 -0800 Comment on attachment 81715 fix patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=81715&action=review Could you also test a case where you set contenteditable programmatically? (i.e. div.contenteditable = false / true). r- for style issues. > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-allinherit.html:19 > +<div id="div1"> > + <div> > + <div id="div"></div> > + </div> > +</div> > +<div id="div2"> > + <div> > + <p id="p"></p> > + </div> Why do we need div1/div2 and empty divs? id's div1 and div2 can be eliminated since we're not referencing them anywhere. Please simplify the markup so that it doesn't clutter the test needlessly. > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-ancestor.html:11 > +<div id="div1" contentEditable="false"> div1 is not a descriptive name. How about parent_of_div? > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-ancestor.html:16 > +<div id="div2" contentEditable="true"> Ditto. parent_of_p? 347831 21 81715 rniwa 2011-02-08 17:18:25 -0800 Comment on attachment 81715 fix patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=81715&action=review > Source/WebCore/page/Frame.cpp:-557 > - if (m_editor.clientIsEditable()) > - return true; Could you also file a follow up bug to remove contentIsEditable from EditorClient? 347851 22 rniwa 2011-02-08 17:35:48 -0800 (In reply to comment #21) > (From update of attachment 81715 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=81715&action=review > > > Source/WebCore/page/Frame.cpp:-557 > > - if (m_editor.clientIsEditable()) > > - return true; > > Could you also file a follow up bug to remove contentIsEditable from EditorClient? Nvm. Filed https://bugs.webkit.org/show_bug.cgi?id=54050 myself. 347866 23 cshu 2011-02-08 17:52:33 -0800 > > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-allinherit.html:19 > > +<div id="div1"> > > + <div> > > + <div id="div"></div> > > + </div> > > +</div> > > +<div id="div2"> > > + <div> > > + <p id="p"></p> > > + </div> > > Why do we need div1/div2 and empty divs? id's div1 and div2 can be eliminated since we're not referencing them anywhere. Please simplify the markup so that it doesn't clutter the test needlessly. Div1/div2 are used to call hide on them at the end of the test. Empty divs are used for making the tree a bit deeper. But I can remove the empty divs. 347937 24 81715 rniwa 2011-02-08 21:05:44 -0800 Comment on attachment 81715 fix patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=81715&action=review > Source/WebCore/dom/Document.cpp:4020 > m_designMode = value; > + if (renderer()) { > + renderer()->style()->setUserModify((value == on) ? READ_WRITE : READ_ONLY); > + recalcStyle(Inherit); > + } One more concern. What if we created an iframe and set designmode true (when renderer still doesn't exist for the document), and then inserted the iframe into the document? Will designmode be still on? 348208 25 cshu 2011-02-09 07:08:31 -0800 > > Source/WebCore/dom/Document.cpp:4020 > > m_designMode = value; > > + if (renderer()) { > > + renderer()->style()->setUserModify((value == on) ? READ_WRITE : READ_ONLY); > > + recalcStyle(Inherit); > > + } > > One more concern. What if we created an iframe and set designmode true (when renderer still doesn't exist for the document), and then inserted the iframe into the document? Will designmode be still on? Designmode should be on in this case. However, the usermodify style may not sync up. I can work on this case further in a followup patch. In another way, if we remove the -webkit-user-modify support, this should not be a problem any more. 348217 26 81810 cshu 2011-02-09 07:22:16 -0800 Created attachment 81810 fix patch 4 348219 27 rniwa 2011-02-09 07:23:45 -0800 (In reply to comment #25) > > One more concern. What if we created an iframe and set designmode true (when renderer still doesn't exist for the document), and then inserted the iframe into the document? Will designmode be still on? > > Designmode should be on in this case. However, the usermodify style may not sync up. I can work on this case further in a followup patch. In another way, if we remove the -webkit-user-modify support, this should not be a problem any more. What I'm suspecting is that this patch may introduce a regression. I'm not speaking of the value returned by isContentEditable. I'm saying that WebKit might mistakenly think that the document is not editable or more precisely that WebKit may not store the necessarily information to infer that the document is editable if we landed your patch because we no longer call EditorClient::contentIsEditable. To fix this problem, you'll probably need to call setUserModify when the document's renderer is attached. 348238 28 cshu 2011-02-09 07:52:45 -0800 > To fix this problem, you'll probably need to call setUserModify when the document's renderer is attached. Would it be ok to address this in a follow-up patch? The code change may be simple but I have to come up with a set of test cases. 348625 29 rniwa 2011-02-09 15:12:45 -0800 (In reply to comment #28) > > To fix this problem, you'll probably need to call setUserModify when the document's renderer is attached. > > Would it be ok to address this in a follow-up patch? The code change may be simple but I have to come up with a set of test cases. The answer to that question depends on whether or not this patch will cause a regression. My suspicion is that it does in which case you can't do it in a follow-up patch. 348818 30 rniwa 2011-02-09 22:36:13 -0800 (In reply to comment #29) > The answer to that question depends on whether or not this patch will cause a regression. My suspicion is that it does in which case you can't do it in a follow-up patch. Ok, I think my concern was a false alarm. > > > Source/WebCore/dom/Document.cpp:4020 > > > m_designMode = value; > > > + if (renderer()) { > > > + renderer()->style()->setUserModify((value == on) ? READ_WRITE : READ_ONLY); > > > + recalcStyle(Inherit); > > > + } > > > > One more concern. What if we created an iframe and set designmode true (when renderer still doesn't exist for the document), and then inserted the iframe into the document? Will designmode be still on? > > Designmode should be on in this case. However, the usermodify style may not sync up. I can work on this case further in a followup patch. In another way, if we remove the -webkit-user-modify support, this should not be a problem any more. We should add ASSERT(renderer()) right above the if statement. It's still nice to have an early exit in the case our assumption that the document's renderer always exists was false. 349390 31 82050 cshu 2011-02-10 14:41:01 -0800 Created attachment 82050 fix patch 5 new patch based on rniwa's comments. 349406 32 82050 darin 2011-02-10 14:52:11 -0800 Comment on attachment 82050 fix patch 5 View in context: https://bugs.webkit.org/attachment.cgi?id=82050&action=review Sorry I didn’t get a chance to look at this before. > Source/WebCore/dom/Document.cpp:4033 > + ASSERT(renderer()); > + if (renderer()) { > + renderer()->style()->setUserModify((value == on) ? READ_WRITE : READ_ONLY); > + recalcStyle(Inherit); > + } This is not the right way to make style depend on something. This logic should go into CSSStyleSelector::styleForDocument instead of here. Reaching right in and tweaking the style isn’t the way to do it. It’s also wrong to call recalcStyle synchronously. Instead we should be calling scheduleForcedStyleRecalc here, and calling it only if the new value is different from m_designMode. 349436 33 cshu 2011-02-10 15:28:05 -0800 > > Source/WebCore/dom/Document.cpp:4033 > > + ASSERT(renderer()); > > + if (renderer()) { > > + renderer()->style()->setUserModify((value == on) ? READ_WRITE : READ_ONLY); > > + recalcStyle(Inherit); > > + } > > This is not the right way to make style depend on something. This logic should go into CSSStyleSelector::styleForDocument instead of here. Reaching right in and tweaking the style isn’t the way to do it. > > It’s also wrong to call recalcStyle synchronously. Instead we should be calling scheduleForcedStyleRecalc here, and calling it only if the new value is different from m_designMode. Thanks for showing the right way to do this, Darin. I have tried and found it results a similar issue with other setContentEditable test cases that the render style wasn't be updated before the execution of the next js statement. This must be due to the async call to recalcStyle. But if this is the current behavior, I may have to submit it as it is? 349501 34 rniwa 2011-02-10 16:39:10 -0800 (In reply to comment #33) > > This is not the right way to make style depend on something. This logic should go into CSSStyleSelector::styleForDocument instead of here. Reaching right in and tweaking the style isn’t the way to do it. > > > > It’s also wrong to call recalcStyle synchronously. Instead we should be calling scheduleForcedStyleRecalc here, and calling it only if the new value is different from m_designMode. > > Thanks for showing the right way to do this, Darin. I have tried and found it results a similar issue with other setContentEditable test cases that the render style wasn't be updated before the execution of the next js statement. This must be due to the async call to recalcStyle. But if this is the current behavior, I may have to submit it as it is? I think that means you need to fix the other bug first. 349544 35 cshu 2011-02-10 17:53:06 -0800 > I think that means you need to fix the other bug first. That means we have to remove the support of -webkit-user-modify. Do we really want to do that? 349574 36 rniwa 2011-02-10 19:12:48 -0800 (In reply to comment #35) > > I think that means you need to fix the other bug first. > > That means we have to remove the support of -webkit-user-modify. Do we really want to do that? I think we should just have two versions of isContentEditable just as Darin suggested. 349735 37 cshu 2011-02-11 06:05:56 -0800 (In reply to comment #36) > (In reply to comment #35) > > > I think that means you need to fix the other bug first. > > > > That means we have to remove the support of -webkit-user-modify. Do we really want to do that? > > I think we should just have two versions of isContentEditable just as Darin suggested. Right, looks like we should do that first. It would be massive change so I planned to do later. 379840 38 cshu 2011-04-05 13:41:12 -0700 I am trying to make the test cases in "fix patch 5" work. The test cases require that contentEditable attribute should overwrite the documentDesignMode setting. But when it's not there, the editability depends on designMode. The current implementation in Node::rendererIsEditable seems wrong. It always checks inDesignMode first, which will ignore local contentEditable. But even if we check local renderstyle first, we still don't know if userModify() is set to be false by setContentEditable or by default. To make the render-style approach work, I think we have to utilize the Inherit value. In HTMLElement::setContentEditable function, the code indeed tries to call addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueInherit). However, the code is broken because the integer value of CSSValueInherit does not map to EUserModify. See the code below: template<> inline CSSPrimitiveValue::operator EUserModify() const { return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly); } I think we should fix this. Do I make myself clear? Any ideas on an alternative approach? Thanks! 380249 39 rniwa 2011-04-06 03:22:00 -0700 (In reply to comment #38) > The current implementation in Node::rendererIsEditable seems wrong. It always checks inDesignMode first, which will ignore local contentEditable. But even if we check local renderstyle first, we still don't know if userModify() is set to be false by setContentEditable or by default. Is this behavior spec-ed somewhere? It'll be nice to be able to cite the part of spec that mandates this behavior. > To make the render-style approach work, I think we have to utilize the Inherit value. In HTMLElement::setContentEditable function, the code indeed tries to call addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueInherit). However, the code is broken because the integer value of CSSValueInherit does not map to EUserModify. See the code below: > template<> inline CSSPrimitiveValue::operator EUserModify() const > { > return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly); > } > > I think we should fix this. Sounds good to me. 380303 40 cshu 2011-04-06 06:12:39 -0700 > Is this behavior spec-ed somewhere? It'll be nice to be able to cite the part of spec that mandates this behavior. I had some comments in the ChangeLog. The exact cite is too long and contains other stuff. Check this out: http://dev.w3.org/html5/spec/Overview.html#attr-contenteditable "Specifically, if an HTML element has a contenteditable attribute set to the true state, or it has its contenteditable attribute set to the inherit state and if its nearest ancestor HTML element with the contenteditable attribute set to a state other than the inherit state has its attribute set to the true state, or if it and its ancestors all have their contenteditable attribute set to the inherit state but the Document has designMode enabled, then the UA must treat the element as editable (as described below)." "Otherwise, either the HTML element has a contenteditable attribute set to the false state, or its contenteditable attribute is set to the inherit state and its nearest ancestor HTML element with the contenteditable attribute set to a state other than the inherit state has its attribute set to the false state, or all its ancestors have their contenteditable attribute set to the inherit state and the Document itself has designMode disabled; either way, the element is not editable." > > I think we should fix this. > > Sounds good to me. Good. 380327 41 rniwa 2011-04-06 07:08:00 -0700 Thank you for the clarification, Chang. Now that I understand the correct behavior, we should proceed with your proposed design changes. 380334 42 cshu 2011-04-06 07:13:27 -0700 (In reply to comment #41) > Thank you for the clarification, Chang. Now that I understand the correct behavior, we should proceed with your proposed design changes. Thanks for the support! 381323 43 88632 cshu 2011-04-07 07:28:16 -0700 Created attachment 88632 fix patch: new patch after dependencies have been resolved. 383652 44 88632 rniwa 2011-04-11 16:20:28 -0700 Comment on attachment 88632 fix patch: new patch after dependencies have been resolved. View in context: https://bugs.webkit.org/attachment.cgi?id=88632&action=review > Source/WebCore/css/CSSComputedStyleDeclaration.cpp:1229 > + if (style->userModify() == INHERIT) > + return primitiveValueCache->createValue(node->document()->inDesignMode() ? READ_WRITE : READ_ONLY); I don't think this is what you want. As Darin suggested you should set the value in CSSStyleSelector::styleForDocument and things should work just as expected. > Source/WebCore/css/CSSPrimitiveValueMappings.h:1824 > + case INHERIT: > + m_value.ident = CSSValueInherit; > + break; I don't think this is right. > Source/WebCore/css/CSSPrimitiveValueMappings.h:1831 > + if (m_value.ident == CSSValueInherit) > + return INHERIT; Ditto. > Source/WebCore/dom/Node.cpp:720 > - if (document()->inDesignMode() || (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable())) > + if (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable()) Removing this call is good because if you modify CSSStyleSelector::styleForDocument, then the value will automatically be inherited. > Source/WebCore/dom/Node.cpp:737 > + case INHERIT: > + return document()->inDesignMode(); Then you don't need this work-around. 384073 45 cshu 2011-04-12 09:43:35 -0700 Thanks for the review. I will work on the new approach soon. (In reply to comment #44) > (From update of attachment 88632 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=88632&action=review > > > Source/WebCore/css/CSSComputedStyleDeclaration.cpp:1229 > > + if (style->userModify() == INHERIT) > > + return primitiveValueCache->createValue(node->document()->inDesignMode() ? READ_WRITE : READ_ONLY); > > I don't think this is what you want. As Darin suggested you should set the value in CSSStyleSelector::styleForDocument and things should work just as expected. > > > Source/WebCore/css/CSSPrimitiveValueMappings.h:1824 > > + case INHERIT: > > + m_value.ident = CSSValueInherit; > > + break; > > I don't think this is right. > > > Source/WebCore/css/CSSPrimitiveValueMappings.h:1831 > > + if (m_value.ident == CSSValueInherit) > > + return INHERIT; > > Ditto. > > > Source/WebCore/dom/Node.cpp:720 > > - if (document()->inDesignMode() || (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable())) > > + if (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable()) > > Removing this call is good because if you modify CSSStyleSelector::styleForDocument, then the value will automatically be inherited. > > > Source/WebCore/dom/Node.cpp:737 > > + case INHERIT: > > + return document()->inDesignMode(); > > Then you don't need this work-around. 384311 46 89262 cshu 2011-04-12 13:34:06 -0700 Created attachment 89262 new patch #2 384614 47 89262 rniwa 2011-04-12 18:57:28 -0700 Comment on attachment 89262 new patch #2 View in context: https://bugs.webkit.org/attachment.cgi?id=89262&action=review The patch looks better than the last one but I don't know enough about layout/style code to know if your change is correct. > Source/WebCore/css/CSSStyleSelector.cpp:1268 > + if (document->inDesignMode() && documentStyle->userModify() != READ_WRITE) Do we really need to check documentStyle->userModify() != READ_WRITE? That seems like a non-standard thing to do here. > Source/WebCore/dom/Document.cpp:4068 > + scheduleForcedStyleRecalc(); I'm not sure if this is the correct function to call. Also, don't we need to update styles of subframes? 384836 48 cshu 2011-04-13 06:33:25 -0700 > > Source/WebCore/css/CSSStyleSelector.cpp:1268 > > + if (document->inDesignMode() && documentStyle->userModify() != READ_WRITE) > > Do we really need to check documentStyle->userModify() != READ_WRITE? That seems like a non-standard thing to do here. Just want to check if we really have to change the value. > > Source/WebCore/dom/Document.cpp:4068 > > + scheduleForcedStyleRecalc(); > > I'm not sure if this is the correct function to call. Also, don't we need to update styles of subframes? From the code, it looks that only the "forced" one will trigger a styleForDocument recalculation. For subframes, I think document.designmode is per document, so it's per frame? Anyway, let's see if any other reviewers want to comment. Thanks! 384913 49 rniwa 2011-04-13 08:40:14 -0700 (In reply to comment #48) > > > Source/WebCore/css/CSSStyleSelector.cpp:1268 > > > + if (document->inDesignMode() && documentStyle->userModify() != READ_WRITE) > > > > Do we really need to check documentStyle->userModify() != READ_WRITE? That seems like a non-standard thing to do here. > > Just want to check if we really have to change the value. I don't think we need to. If it's the same value, then there's no harm in changing it to the same value. > > > Source/WebCore/dom/Document.cpp:4068 > > > + scheduleForcedStyleRecalc(); > > > > I'm not sure if this is the correct function to call. Also, don't we need to update styles of subframes? > > From the code, it looks that only the "forced" one will trigger a styleForDocument recalculation. For subframes, I think document.designmode is per document, so it's per frame? No. See http://trac.webkit.org/browser/trunk/Source/WebCore/dom/Document.cpp?rev=83349#L4075 385033 50 rniwa 2011-04-13 11:23:22 -0700 Per discussion with smfr on IRC, you should probably use SyntheticStyleChange and call style recalc on all subframes. 385039 51 cshu 2011-04-13 11:32:01 -0700 > Per discussion with smfr on IRC, you should probably use SyntheticStyleChange and call style recalc on all subframes. Great, will try. 385916 52 cshu 2011-04-14 11:45:27 -0700 (In reply to comment #50) > Per discussion with smfr on IRC, you should probably use SyntheticStyleChange and call style recalc on all subframes. I replaced scheduleForcedStyleRecalc with setNeedsStyleRecalc(SyntheticStyleChange) in Document::setDesignMode, but it didn't work for me. From the code inside function Document::recalcStyle(), calling it with Force is the only way to trigger CSSStyleSelector::styleForDocument(). 389397 53 90374 cshu 2011-04-20 11:50:05 -0700 Created attachment 90374 fix patch: WIP This is a work-in-progress patch. It crashes editing/style/iframe-onload-crash-mac.html because of an infinite loop. 389641 54 90448 rniwa 2011-04-20 16:49:12 -0700 Created attachment 90448 fixed the crashing tests 389643 55 rniwa 2011-04-20 16:51:56 -0700 (In reply to comment #54) > Created an attachment (id=90448) [details] > fixed the crashing tests ojan and I investigated this test and concluded that the test is inherently wrong and we need to fix the test to avoid infinite recursion. I have set a limit of 16 recursions in the test and fixed one place in ApplyStyleCommand to avoid an assertion failure (DOM mutation events can change the editability and the code wasn't accounting this). I'm the original author of the test and confirmed that the original bug reproduces with the modified test. 389708 56 cshu 2011-04-20 18:02:59 -0700 (In reply to comment #55) > (In reply to comment #54) > > Created an attachment (id=90448) [details] [details] > > fixed the crashing tests > > ojan and I investigated this test and concluded that the test is inherently wrong and we need to fix the test to avoid infinite recursion. I have set a limit of 16 recursions in the test and fixed one place in ApplyStyleCommand to avoid an assertion failure (DOM mutation events can change the editability and the code wasn't accounting this). I'm the original author of the test and confirmed that the original bug reproduces with the modified test. Thanks, Ryosuke, for fixing the test and the code. I suggest we take out the updated test cases and ApplyStyleCommand fix in a separate patch and probably put in for a new bug. The code in Document.cpp in your patch has a redundant call to stylerecalc and my new tests are missing. 390414 57 rniwa 2011-04-21 15:53:13 -0700 (In reply to comment #56) > Thanks, Ryosuke, for fixing the test and the code. I suggest we take out the updated test cases and ApplyStyleCommand fix in a separate patch and probably put in for a new bug. The code in Document.cpp in your patch has a redundant call to stylerecalc and my new tests are missing. On my second thought, you need to include my change in your patch because the problem I'm fixing won't reproduce without your change. It seems odd to fix a problem that doesn't exist in a separate patch. 390531 58 cshu 2011-04-21 18:44:49 -0700 That makes sense, too. I will take care of it, thanks. > On my second thought, you need to include my change in your patch because the problem I'm fixing won't reproduce without your change. It seems odd to fix a problem that doesn't exist in a separate patch. 390763 59 90704 cshu 2011-04-22 06:57:03 -0700 Created attachment 90704 fix patch: merged Ryosuke's code. 390949 60 90704 eric 2011-04-22 12:06:28 -0700 Comment on attachment 90704 fix patch: merged Ryosuke's code. View in context: https://bugs.webkit.org/attachment.cgi?id=90704&action=review > Source/WebCore/dom/Document.cpp:4037 > + for (Frame* frame = m_frame; frame && frame->document(); frame = frame->tree()->traverseNext(m_frame)) So this will work on all subframes? Will this end up recalcing style on parent frames as well? > LayoutTests/editing/style/iframe-onload-crash-mac.html:10 > +if (document.counter) > + document.counter++; > +else > + document.counter = 1; I don't understand what the purpose of these counters are. > LayoutTests/editing/style/iframe-onload-crash-win.html:10 > +if (document.counter) > + document.counter++; > +else > + document.counter = 1; Huh? 390959 61 cshu 2011-04-22 12:14:44 -0700 > > + for (Frame* frame = m_frame; frame && frame->document(); frame = frame->tree()->traverseNext(m_frame)) > > So this will work on all subframes? Will this end up recalcing style on parent frames as well? Yes, We have to do this because DesignMode inherits from parent frames. No, traverseNext(m_frame) makes sure traversing happens within m_frame. > > LayoutTests/editing/style/iframe-onload-crash-mac.html:10 > > +if (document.counter) > > + document.counter++; > > +else > > + document.counter = 1; > > I don't understand what the purpose of these counters are. The test cases will trigger an infinite loop because the execCommand() in the test will reload the frame which calls these execCommand() again and again. 390963 62 90704 rniwa 2011-04-22 12:18:40 -0700 Comment on attachment 90704 fix patch: merged Ryosuke's code. View in context: https://bugs.webkit.org/attachment.cgi?id=90704&action=review >> LayoutTests/editing/style/iframe-onload-crash-mac.html:10 >> + document.counter = 1; > > I don't understand what the purpose of these counters are. Without this counter, the test falls into an infinite loop because this function is called on load event of an iframe and it moves iframe (removes & appends back) in editing commands. We didn't have this problem before this patch due to the bug this patch is fixing. 394757 63 90704 eric 2011-04-28 14:36:05 -0700 Comment on attachment 90704 fix patch: merged Ryosuke's code. View in context: https://bugs.webkit.org/attachment.cgi?id=90704&action=review > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-expected.txt:10 > + > + > + > + > + > + What's with the gigantic whitespace blob? > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-expected.txt:36 > + > + > + > + Here too. 394762 64 90704 eric 2011-04-28 14:38:30 -0700 Comment on attachment 90704 fix patch: merged Ryosuke's code. This seems fine. 394769 65 cshu 2011-04-28 14:47:07 -0700 (In reply to comment #63) > (From update of attachment 90704 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=90704&action=review > > > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-expected.txt:10 > > + > > + > > + > > + > > + > > + > > What's with the gigantic whitespace blob? > > > LayoutTests/fast/dom/HTMLElement/iscontenteditable-designmodeon-expected.txt:36 > > + > > + > > + > > + > > Here too. I didn't see these comments before I did cq+. The white spaces were created because of the <div>s and <p>s. 394949 66 commit-queue 2011-04-28 17:08:20 -0700 The commit-queue encountered the following flaky tests while processing attachment 90704: fast/workers/storage/use-same-database-in-page-and-workers.html bug 50995 (author: dumi@chromium.org) The commit-queue is continuing to process your patch. 394952 67 90704 commit-queue 2011-04-28 17:10:45 -0700 Comment on attachment 90704 fix patch: merged Ryosuke's code. Clearing flags on attachment: 90704 Committed r85267: <http://trac.webkit.org/changeset/85267> 394953 68 commit-queue 2011-04-28 17:10:54 -0700 All reviewed patches have been landed. Closing bug. 396607 69 rniwa 2011-05-02 13:36:48 -0700 *** Bug 22036 has been marked as a duplicate of this bug. *** 79950 2011-01-24 11:45:05 -0800 2011-01-28 11:33:04 -0800 fix patch 53031_1.patch text/plain 8714 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2NTM2KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDEtMjQgIENoYW5nIFNo dSAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIGNoZWNrIGZyYW1lJ3Mg aXNDb250ZW50RWRpdGFibGUsIGkuZS4sIGRlc2lnbk1vZGUsCisgICAgICAgIG9ubHkgd2hlbiBp dHMgYW5kIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJsZSBhcmUgImluaGVyaXQiLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMwMzEKKworICAg ICAgICBUZXN0czogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLWFuY2VzdG9yLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCisKKyAgICAgICAgKiBodG1sL0hU TUxFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxFbGVtZW50Ojppc0NvbnRlbnRF ZGl0YWJsZSk6CisKIDIwMTEtMDEtMjQgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUu Y29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE5hdGUgQ2hhcGluLgpJbmRleDogU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MRWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRWxlbWVudC5jcHAJKHJldmlzaW9uIDc2NTI4KQorKysgU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY1NSw4ICs2NTUsMjAgQEAg Ym9vbCBIVE1MRWxlbWVudDo6c3VwcG9ydHNGb2N1cygpIGNvbnN0CiAKIGJvb2wgSFRNTEVsZW1l bnQ6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QgCiB7Ci0gICAgaWYgKGRvY3VtZW50KCktPmZy YW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+aXNDb250ZW50RWRpdGFibGUoKSkKLSAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQo KS0+ZnJhbWUoKS0+aXNDb250ZW50RWRpdGFibGUoKSkgeworICAgICAgICBib29sIGlzQ29udGVu dEVkaXRhYmxlU2V0ID0gZmFsc2U7CisgICAgICAgIGZvciAoY29uc3QgQ29udGFpbmVyTm9kZSog cCA9IHRoaXM7IHA7IHAgPSBwLT5wYXJlbnROb2RlKCkpIHsKKyAgICAgICAgICAgIGlmIChwLT5p c0hUTUxFbGVtZW50KCkpIHsKKyAgICAgICAgICAgICAgICBjb25zdCBIVE1MRWxlbWVudCogaHRt bFBhcmVudCA9IHN0YXRpY19jYXN0PGNvbnN0IEhUTUxFbGVtZW50Kj4ocCk7CisgICAgICAgICAg ICAgICAgaWYgKGh0bWxQYXJlbnQtPmNvbnRlbnRFZGl0YWJsZSgpICE9ICJpbmhlcml0Iikgewor ICAgICAgICAgICAgICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZVNldCA9IHRydWU7CisgICAgICAg ICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorICAgICAgICBpZiAoIWlzQ29udGVudEVkaXRhYmxlU2V0KQorICAgICAgICAgICAg cmV0dXJuIHRydWU7CisgICAgfQogCiAgICAgLy8gSWRlYWxseSB3ZSdkIGNhbGwgQVNTRVJUIW5l ZWRzU3R5bGVSZWNhbGMoKSkgaGVyZSwgYnV0CiAgICAgLy8gQ29udGFpbmVyTm9kZTo6c2V0Rm9j dXMoKSBjYWxscyBzZXROZWVkc1N0eWxlUmVjYWxjKCksIHNvIHRoZSBhc3NlcnRpb24KSW5kZXg6 IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VM b2cJKHJldmlzaW9uIDc2NTM2KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTEtMDEtMjQgIENoYW5nIFNodSAgPGNoYW5nLnNodUBu b2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgQWRkZWQgdGVzdHMgZm9yIHRoZSBidWcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQorCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUt ZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRl c2lnbm1vZGVvbi5odG1sOiBBZGRlZC4KKwogMjAxMS0wMS0yNCAgQW5kcmVpIFBvcGVzY3UgIDxh bmRyZWlwQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTmF0ZSBDaGFwaW4uCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1h bmNlc3Rvci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI0IEBACitpc0NvbnRlbnRFZGl0YWJs ZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgYW5jZXN0b3IncyBjb250ZW50RWRpdGFibGUgaXMg c2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Ig bm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3Nh Z2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKworCitkb2N1bWVudC5k ZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29u dGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVk U3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlz ICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVk aXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlz Q29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwg IiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0 ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisK KworCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1h bmNlc3Rvci5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVs ZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWwJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNDEgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4K KzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qt c3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8ZGl2IGlk PSJkaXYxIiBjb250ZW50RWRpdGFibGU9ImZhbHNlIj4KKyAgICA8ZGl2PgorICAgICAgICA8ZGl2 IGlkPSJkaXYiPjwvZGl2PgorICAgIDwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJkaXYyIiBjb250 ZW50RWRpdGFibGU9InRydWUiPgorICAgIDxkaXY+CisgICAgICAgIDxwIGlkPSJwIj48L3A+Cisg ICAgPC9kaXY+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignaXNDb250ZW50RWRpdGFi bGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGFuY2VzdG9yXCdzIGNvbnRlbnRFZGl0YWJsZSBp cyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBv ciBub3QuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKwor c2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUn LCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIp LmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1 dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIp JywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi cCIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJl KCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtp dC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2MSIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5kb3cuc3VjY2Vzc2Z1bGx5 UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNl cy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9k ZW9uLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwy NiBAQAoraXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGNvbnRlbnRF ZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMg ZW5hYmxlZCBvciBub3QuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAi UEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisK K2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJmYWxzZSIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiZmFsc2Ui CitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBp cyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0 eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlz ICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJs ZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRF ZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQ cm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRl c2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM1IEBACis8IURPQ1RZUEUg aHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMv cmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAg aWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJy ZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0iZGl2IiBjb250ZW50RWRpdGFibGU9ImZhbHNlIj48L2Rp dj4KKzxwIGlkPSJwIiBjb250ZW50RWRpdGFibGU9InRydWUiPjwvcD4KKzxzY3JpcHQ+CitkZXNj cmlwdGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGNvbnRl bnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUg aXMgZW5hYmxlZCBvciBub3QuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9 ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRB dHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImZhbHNlIicpOworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImZhbHNlIicpOwor c2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJs ZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIp LmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5Iicp OworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRBdHRyaWJ1dGUo ImNvbnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnInRydWUiJyk7CitzaG91bGRCZSgnZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7Citz aG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUo Ii13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5kb3cuc3VjY2Vzc2Z1 bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291 cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 80469 2011-01-28 11:33:04 -0800 2011-01-31 13:40:24 -0800 fix patch 53031_2.patch text/plain 10269 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAkocmV2aXNpb24gNzY5NDIpCisrKyBTb3VyY2Uv V2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MTAwLDYgKzQxMDAs MTAgQEAgdm9pZCBEb2N1bWVudDo6c2V0VHJhbnNmb3JtU291cmNlKFBhc3NPdwogdm9pZCBEb2N1 bWVudDo6c2V0RGVzaWduTW9kZShJbmhlcml0ZWRCb29sIHZhbHVlKQogewogICAgIG1fZGVzaWdu TW9kZSA9IHZhbHVlOworICAgIGlmIChyZW5kZXJlcigpKSB7CisgICAgICAgIHJlbmRlcmVyKCkt PnN0eWxlKCktPnNldFVzZXJNb2RpZnkoKHZhbHVlID09IG9uKSA/IFJFQURfV1JJVEUgOiBSRUFE X09OTFkpOworICAgICAgICByZWNhbGNTdHlsZShJbmhlcml0KTsKKyAgICB9CiB9CiAKIERvY3Vt ZW50OjpJbmhlcml0ZWRCb29sIERvY3VtZW50OjpnZXREZXNpZ25Nb2RlKCkgY29uc3QKSW5kZXg6 IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCShyZXZpc2lvbiA3Njk0MikKKysrIFNvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02NTUsOSAr NjU1LDYgQEAgYm9vbCBIVE1MRWxlbWVudDo6c3VwcG9ydHNGb2N1cygpIGNvbnN0CiAKIGJvb2wg SFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QgCiB7Ci0gICAgaWYgKGRvY3Vt ZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+aXNDb250ZW50RWRpdGFibGUo KSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICAvLyBJZGVhbGx5IHdlJ2QgY2FsbCBBU1NF UlQhbmVlZHNTdHlsZVJlY2FsYygpKSBoZXJlLCBidXQKICAgICAvLyBDb250YWluZXJOb2RlOjpz ZXRGb2N1cygpIGNhbGxzIHNldE5lZWRzU3R5bGVSZWNhbGMoKSwgc28gdGhlIGFzc2VydGlvbgog ICAgIC8vIHdvdWxkIGZpcmUgaW4gdGhlIG1pZGRsZSBvZiBEb2N1bWVudDo6c2V0Rm9jdXNlZE5v ZGUoKS4KQEAgLTY3NCw5ICs2NzEsNiBAQCBib29sIEhUTUxFbGVtZW50Ojppc0NvbnRlbnRFZGl0 YWJsZSgpIGNvCiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVudFJpY2hseUVkaXRhYmxlKCkg Y29uc3QKIHsKLSAgICBpZiAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgpLT5mcmFt ZSgpLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLQogICAgIGlm ICghcmVuZGVyZXIoKSkgewogICAgICAgICBpZiAocGFyZW50Tm9kZSgpKQogICAgICAgICAgICAg cmV0dXJuIHBhcmVudE5vZGUoKS0+aXNDb250ZW50RWRpdGFibGUoKTsKSW5kZXg6IExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1h bGxpbmhlcml0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1l eHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxl bWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQgQEAKK0NvbnRlbnQgc2hvdWxkIGJlIGVkaXRh YmxlIGlmIGl0cyBhbmQgaXRzIGFuY2VzdG9yJ3MgY29udGVudEVkaXRhYmxlIG5vdCBzZXQsIGFu ZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCisKKworCisKK2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQ QVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0 cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFs dWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFT UyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtp dC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVy aXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9p c2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUt ZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MSBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0 IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBz cmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+ Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9w PgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdjEiPgorICAgIDxkaXY+Cisg ICAgICAgIDxkaXYgaWQ9ImRpdiI+PC9kaXY+CisgICAgPC9kaXY+Cis8L2Rpdj4KKzxkaXYgaWQ9 ImRpdjIiPgorICAgIDxkaXY+CisgICAgICAgIDxwIGlkPSJwIj48L3A+CisgICAgPC9kaXY+Cis8 L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignQ29udGVudCBzaG91bGQgYmUgZWRpdGFibGUg aWYgaXRzIGFuZCBpdHMgYW5jZXN0b3JcJ3MgY29udGVudEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBk b2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQu ZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3No b3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVl KCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK3Nob3VsZEJlKCdk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCIn KTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRh YmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIiku Z2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicp OworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MSIpLnN0eWxlLmRpc3BsYXk9ICdub25l JzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUn OworCit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9k ZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNCBAQAor aXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGFuY2VzdG9yJ3MgY29u dGVudEVkaXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9k ZSBpcyBlbmFibGVkIG9yIG5vdC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVz IG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKKwor CisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdp bmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQt dXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IikgaXMgInJlYWQtd3JpdGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKwor VEVTVCBDT01QTEVURQorCisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxl bWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNl c3Rvci5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQxIEBACis8IURPQ1RZUEUgaHRtbD4K KzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRl c2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQi PjwvZGl2PgorPGRpdiBpZD0iZGl2MSIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+CisgICAgPGRp dj4KKyAgICAgICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKyAgICA8L2Rpdj4KKzwvZGl2PgorPGRp diBpZD0iZGl2MiIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj4KKyAgICA8ZGl2PgorICAgICAgICA8 cCBpZD0icCI+PC9wPgorICAgIDwvZGl2PgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24o J2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvclwncyBj b250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25N b2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2V2YWxBbmRMb2coJ2RvY3VtZW50LmRlc2lnbk1v ZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iiku Y29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUo J3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJr aXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91 bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0 cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3Bl cnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjEiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2lu ZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIu Li8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwv aHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4 cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMjYgQEAKK2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdl IGlmIGl0cyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVu dC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBz ZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVU RSIuCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBp cyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRp dGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXND b250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2 LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9u bHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuZ2V0QXR0cmlidXRlKCJjb250 ZW50RWRpdGFibGUiKSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAi KS5jb250ZW50RWRpdGFibGUgaXMgInRydWUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJy ZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09N UExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0 bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2Nv bnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwz NSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+ PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYgaWQ9ImRpdiIgY29udGVudEVkaXRh YmxlPSJmYWxzZSI+PC9kaXY+Cis8cCBpZD0icCIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj48L3A+ Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hh bmdlIGlmIGl0cyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1 bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2V2YWxBbmRMb2coJ2RvY3Vt ZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSInKTsK K3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxl JywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iiku aXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0 ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikn LCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJw IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVlIicpOworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicp Oworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFi bGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5n ZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7 CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7 Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKwor d2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4K 80675 2011-01-31 13:40:24 -0800 2011-02-08 16:33:17 -0800 fix patch 2 53031_2.patch text/plain 12602 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc3MTU1KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTEtMDEtMzEgIENoYW5nIFNo dSAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6Ly9kZXYudzMub3JnL2h0 bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJsZSkKKyAgICAgICAgaW5k aWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgcmVsaWVzIG9uIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5jZXN0b3JzJyBjb250ZW50 ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisgICAgICAgIFRvIGFjaGll dmUgdGhpcywgd2UgdXBkYXRlIHRoZSB1c2VybW9kaWZ5IHByb3BlcnR5IG9mIHRvcC1sZXZlbCBy ZW5kZXIgc3R5bGUgd2hlbgorICAgICAgICBzZXR0aW5nIGRlc2lnbk1vZGUgaW4gZG9jdW1lbnQu CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQor CisgICAgICAgIFRlc3RzOiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAorICAg ICAgICAgICAgICAgZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLmh0bWwKKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEb2N1bWVudDo6c2V0RGVzaWduTW9kZSk6CisgICAgICAgICogaHRtbC9IVE1MRWxlbWVu dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRWxlbWVudDo6aXNDb250ZW50RWRpdGFibGUp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTEVsZW1lbnQ6OmlzQ29udGVudFJpY2hseUVkaXRhYmxl KToKKwogMjAxMS0wMS0zMSAgdGFrYW5vIHRha3VtaSAgPHRha2Fub0BhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNw cAkocmV2aXNpb24gNzcxNTUpCisrKyBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC00MTAwLDYgKzQxMDAsMTAgQEAgdm9pZCBEb2N1bWVudDo6c2V0VHJh bnNmb3JtU291cmNlKFBhc3NPdwogdm9pZCBEb2N1bWVudDo6c2V0RGVzaWduTW9kZShJbmhlcml0 ZWRCb29sIHZhbHVlKQogewogICAgIG1fZGVzaWduTW9kZSA9IHZhbHVlOworICAgIGlmIChyZW5k ZXJlcigpKSB7CisgICAgICAgIHJlbmRlcmVyKCktPnN0eWxlKCktPnNldFVzZXJNb2RpZnkoKHZh bHVlID09IG9uKSA/IFJFQURfV1JJVEUgOiBSRUFEX09OTFkpOworICAgICAgICByZWNhbGNTdHls ZShJbmhlcml0KTsKKyAgICB9CiB9CiAKIERvY3VtZW50OjpJbmhlcml0ZWRCb29sIERvY3VtZW50 OjpnZXREZXNpZ25Nb2RlKCkgY29uc3QKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVs ZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQu Y3BwCShyZXZpc2lvbiA3NzE1NSkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC02NTUsOSArNjU1LDYgQEAgYm9vbCBIVE1MRWxlbWVudDo6 c3VwcG9ydHNGb2N1cygpIGNvbnN0CiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRh YmxlKCkgY29uc3QgCiB7Ci0gICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQo KS0+ZnJhbWUoKS0+aXNDb250ZW50RWRpdGFibGUoKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0K ICAgICAvLyBJZGVhbGx5IHdlJ2QgY2FsbCBBU1NFUlQhbmVlZHNTdHlsZVJlY2FsYygpKSBoZXJl LCBidXQKICAgICAvLyBDb250YWluZXJOb2RlOjpzZXRGb2N1cygpIGNhbGxzIHNldE5lZWRzU3R5 bGVSZWNhbGMoKSwgc28gdGhlIGFzc2VydGlvbgogICAgIC8vIHdvdWxkIGZpcmUgaW4gdGhlIG1p ZGRsZSBvZiBEb2N1bWVudDo6c2V0Rm9jdXNlZE5vZGUoKS4KQEAgLTY3NCw5ICs2NzEsNiBAQCBi b29sIEhUTUxFbGVtZW50Ojppc0NvbnRlbnRFZGl0YWJsZSgpIGNvCiAKIGJvb2wgSFRNTEVsZW1l bnQ6OmlzQ29udGVudFJpY2hseUVkaXRhYmxlKCkgY29uc3QKIHsKLSAgICBpZiAoZG9jdW1lbnQo KS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQot ICAgICAgICByZXR1cm4gdHJ1ZTsKLQogICAgIGlmICghcmVuZGVyZXIoKSkgewogICAgICAgICBp ZiAocGFyZW50Tm9kZSgpKQogICAgICAgICAgICAgcmV0dXJuIHBhcmVudE5vZGUoKS0+aXNDb250 ZW50RWRpdGFibGUoKTsKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDc3MTU1KQorKysgTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDEtMzEgIENo YW5nIFNodSAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgdGVzdCBjYXNlcyBmb3IgY2hlY2tpbmcgaXND b250ZW50RWRpdGFibGUgd2l0aCBkZXNpZ25Nb2RlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMwMzEKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxF bGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9y LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWw6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29u dGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sOiBBZGRlZC4KKwogMjAxMS0wMS0zMSAgQWxl amFuZHJvIEcuIENhc3RybyAgPGFsZXhAaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnJldmlld2Vk IGFkZGVkIG5ldyBleHBlY3RlZCByZXN1bHRzIGZvciBHVEsrLgpJbmRleDogTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGlu aGVyaXQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNCBAQAorQ29udGVudCBzaG91bGQgYmUgZWRpdGFibGUg aWYgaXRzIGFuZCBpdHMgYW5jZXN0b3IncyBjb250ZW50RWRpdGFibGUgbm90IHNldCwgYW5kIGRv Y3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2Vl IGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUi LgorCisKKworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRydWUK K1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgi LXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorUEFTUyBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdp bmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVz ZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5o dG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29u dGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQxIEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhy ZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0i Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxi b2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8 ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0iZGl2MSI+CisgICAgPGRpdj4KKyAgICAg ICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKyAgICA8L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0iZGl2 MiI+CisgICAgPGRpdj4KKyAgICAgICAgPHAgaWQ9InAiPjwvcD4KKyAgICA8L2Rpdj4KKzwvZGl2 PgorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdDb250ZW50IHNob3VsZCBiZSBlZGl0YWJsZSBpZiBp dHMgYW5kIGl0cyBhbmNlc3RvclwncyBjb250ZW50RWRpdGFibGUgbm90IHNldCwgYW5kIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZC4nKQorCitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNp Z25Nb2RlID0gIm9uIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp diIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxk QmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13 ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOwor c2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUn LCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQ cm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisK K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYxIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOwor ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisK K3dpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRl c2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YW5jZXN0b3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI0IEBACitpc0Nv bnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgYW5jZXN0b3IncyBjb250ZW50 RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlz IGVuYWJsZWQgb3Igbm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2Yg IlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKwor Citkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiZGl2IikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93 LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2Vy LW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJw IikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1 dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBp cyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNU IENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRl c2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9y Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDEgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0 bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMv anMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3Jp cHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9k aXY+Cis8ZGl2IGlkPSJkaXYxIiBjb250ZW50RWRpdGFibGU9ImZhbHNlIj4KKyAgICA8ZGl2Pgor ICAgICAgICA8ZGl2IGlkPSJkaXYiPjwvZGl2PgorICAgIDwvZGl2PgorPC9kaXY+Cis8ZGl2IGlk PSJkaXYyIiBjb250ZW50RWRpdGFibGU9InRydWUiPgorICAgIDxkaXY+CisgICAgICAgIDxwIGlk PSJwIj48L3A+CisgICAgPC9kaXY+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignaXND b250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGFuY2VzdG9yXCdzIGNvbnRl bnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUg aXMgZW5hYmxlZCBvciBub3QuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9 ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250 ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2lu ZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11 c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJl KCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUn KTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlW YWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZGl2MSIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5kb3cu c3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s PgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFi bGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tZXhwZWN0 ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQv aXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwyNiBAQAoraXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYg aXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRl c2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBh IHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4K KworCisKKworCisKK2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJm YWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJs ZSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRl bnRFZGl0YWJsZSBpcyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIi KS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIK K1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRF ZGl0YWJsZSIpIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNv bnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAi KS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxl KHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQt d3JpdGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorCisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVu dGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM1IEBA Cis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQi IGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4K Kzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+ Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0iZGl2IiBjb250ZW50RWRpdGFibGU9 ImZhbHNlIj48L2Rpdj4KKzxwIGlkPSJwIiBjb250ZW50RWRpdGFibGU9InRydWUiPjwvcD4KKzxz Y3JpcHQ+CitkZXNjcmlwdGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2Ug aWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50 LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQu ZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImZhbHNlIicpOworc2hv dWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAn ImZhbHNlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0Nv bnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICci cmVhZC1vbmx5IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5n ZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91bGRCZSgnZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnInRydWUiJyk7Citz aG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZScs ICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFBy b3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKwor ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5k b3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9o dG1sPgo= 81715 2011-02-08 16:33:17 -0800 2011-02-09 07:22:16 -0800 fix patch 3 53031_3.patch text/plain 15477 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc3OTgzKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMDItMDggIFNodSBDaGFu ZyAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6Ly9kZXYudzMub3JnL2h0 bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJsZSkKKyAgICAgICAgaW5k aWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgcmVsaWVzIG9uIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5jZXN0b3JzJyBjb250ZW50 ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisgICAgICAgIFRvIGFjaGll dmUgdGhpcywgd2UgdXBkYXRlIHRoZSB1c2VybW9kaWZ5IHByb3BlcnR5IG9mIHRvcC1sZXZlbCBy ZW5kZXIgc3R5bGUgd2hlbgorICAgICAgICBzZXR0aW5nIGRlc2lnbk1vZGUgaW4gZG9jdW1lbnQu CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQor CisgICAgICAgIFRlc3RzOiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAorICAg ICAgICAgICAgICAgZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLmh0bWwKKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojppc1JlYWRPbmx5KTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudDo6c2V0RGVzaWduTW9kZSk6CisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9s bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbkZyb21Ob25lKTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGh0bWwvSFRNTEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxF bGVtZW50Ojppc0NvbnRlbnRSaWNobHlFZGl0YWJsZSk6CisgICAgICAgICogcGFnZS9GcmFtZS5j cHA6IHJlbW92ZSB0aGUgaXNDb250ZW50RWRpdGFibGUgc3VwcG9ydCBoZXJlLgorICAgICAgICAq IHBhZ2UvRnJhbWUuaDoKKwogMjAxMS0wMi0wOCAgTGV2aSBXZWludHJhdWIgIDxsZXZpd0BjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgUnlvc3VrZSBOaXdhLgpJbmRleDogU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiA3Nzk3MCkKKysrIFNvdXJjZS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTY2MiwxMiArNjYyLDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc1JlYWRP bgogICAgICAgICBIVE1MRWxlbWVudCogYm9keSA9IGRvY3VtZW50LT5ib2R5KCk7CiAgICAgICAg IGlmIChib2R5ICYmIGJvZHktPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgICAgICByZXR1 cm4gZmFsc2U7Ci0gICAgICAgIAotICAgICAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudC0+ZnJh bWUoKTsKLSAgICAgICAgaWYgKCFmcmFtZSkKLSAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAg ICAgICAKLSAgICAgICAgcmV0dXJuICFmcmFtZS0+aXNDb250ZW50RWRpdGFibGUoKTsKKworICAg ICAgICByZXR1cm4gIWRvY3VtZW50LT5pbkRlc2lnbk1vZGUoKTsKICAgICB9CiAKICAgICBpZiAo bV9yZW5kZXJlci0+aXNCb3hNb2RlbE9iamVjdCgpKSB7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9k b20vRG9jdW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAJKHJldmlzaW9uIDc3OTcwKQorKysgU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtNDAxNCw2ICs0MDE0LDEwIEBAIHZvaWQgRG9jdW1lbnQ6OnNl dFRyYW5zZm9ybVNvdXJjZShQYXNzT3cKIHZvaWQgRG9jdW1lbnQ6OnNldERlc2lnbk1vZGUoSW5o ZXJpdGVkQm9vbCB2YWx1ZSkKIHsKICAgICBtX2Rlc2lnbk1vZGUgPSB2YWx1ZTsKKyAgICBpZiAo cmVuZGVyZXIoKSkgeworICAgICAgICByZW5kZXJlcigpLT5zdHlsZSgpLT5zZXRVc2VyTW9kaWZ5 KCh2YWx1ZSA9PSBvbikgPyBSRUFEX1dSSVRFIDogUkVBRF9PTkxZKTsKKyAgICAgICAgcmVjYWxj U3R5bGUoSW5oZXJpdCk7CisgICAgfQogfQogCiBEb2N1bWVudDo6SW5oZXJpdGVkQm9vbCBEb2N1 bWVudDo6Z2V0RGVzaWduTW9kZSgpIGNvbnN0CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9lZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDc3OTcwKQorKysgU291cmNl L1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpA QCAtMTc2Nyw3ICsxNzY3LDcgQEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rp b25GcgogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKICAg ICBib29sIGNhcmV0QnJvd3NpbmcgPSBtX2ZyYW1lLT5zZXR0aW5ncygpICYmIG1fZnJhbWUtPnNl dHRpbmdzKCktPmNhcmV0QnJvd3NpbmdFbmFibGVkKCk7Ci0gICAgaWYgKCFpc05vbmUoKSB8fCAh KG1fZnJhbWUtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgY2FyZXRCcm93c2luZykpCisgICAgaWYg KCFpc05vbmUoKSB8fCAhKGRvY3VtZW50LT5pbkRlc2lnbk1vZGUoKSB8fCBjYXJldEJyb3dzaW5n KSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgTm9kZSogbm9kZSA9IGRvY3VtZW50LT5kb2N1bWVu dEVsZW1lbnQoKTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCShyZXZpc2lv biA3Nzk3MCkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC02NTUsOSArNjU1LDYgQEAgYm9vbCBIVE1MRWxlbWVudDo6c3VwcG9ydHNGb2N1 cygpIGNvbnN0CiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3Qg CiB7Ci0gICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ aXNDb250ZW50RWRpdGFibGUoKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICAvLyBJZGVh bGx5IHdlJ2QgY2FsbCBBU1NFUlQhbmVlZHNTdHlsZVJlY2FsYygpKSBoZXJlLCBidXQKICAgICAv LyBDb250YWluZXJOb2RlOjpzZXRGb2N1cygpIGNhbGxzIHNldE5lZWRzU3R5bGVSZWNhbGMoKSwg c28gdGhlIGFzc2VydGlvbgogICAgIC8vIHdvdWxkIGZpcmUgaW4gdGhlIG1pZGRsZSBvZiBEb2N1 bWVudDo6c2V0Rm9jdXNlZE5vZGUoKS4KQEAgLTY3NCw5ICs2NzEsNiBAQCBib29sIEhUTUxFbGVt ZW50Ojppc0NvbnRlbnRFZGl0YWJsZSgpIGNvCiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVu dFJpY2hseUVkaXRhYmxlKCkgY29uc3QKIHsKLSAgICBpZiAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAm JiBkb2N1bWVudCgpLT5mcmFtZSgpLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQotICAgICAgICByZXR1 cm4gdHJ1ZTsKLQogICAgIGlmICghcmVuZGVyZXIoKSkgewogICAgICAgICBpZiAocGFyZW50Tm9k ZSgpKQogICAgICAgICAgICAgcmV0dXJuIHBhcmVudE5vZGUoKS0+aXNDb250ZW50RWRpdGFibGUo KTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCShyZXZpc2lvbiA3Nzk3MCkKKysrIFNvdXJjZS9X ZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NTEsMTMgKzU1MSw2IEBA IHZvaWQgRnJhbWU6OmluamVjdFVzZXJTY3JpcHRzRm9yV29ybGQoRE8KICAgICB9CiB9CiAKLWJv b2wgRnJhbWU6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QKLXsKLSAgICBpZiAobV9lZGl0b3Iu Y2xpZW50SXNFZGl0YWJsZSgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICByZXR1cm4gbV9k b2MtPmluRGVzaWduTW9kZSgpOwotfQotCiAjaWZuZGVmIE5ERUJVRwogc3RhdGljIEhhc2hTZXQ8 RnJhbWUqPiYga2VlcEFsaXZlU2V0KCkKIHsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9u IDc3OTcwKQorKysgU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBA IC0xODIsOCArMTgyLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBEcmFnSW1hZ2VS ZWYgbm9kZUltYWdlKE5vZGUqKTsKICAgICAgICAgRHJhZ0ltYWdlUmVmIGRyYWdJbWFnZUZvclNl bGVjdGlvbigpOwogCi0gICAgICAgIGJvb2wgaXNDb250ZW50RWRpdGFibGUoKSBjb25zdDsgLy8g aWYgdHJ1ZSwgZXZlcnl0aGluZyBpbiBmcmFtZSBpcyBlZGl0YWJsZQotCiAgICAgICAgIFZpc2li bGVQb3NpdGlvbiB2aXNpYmxlUG9zaXRpb25Gb3JQb2ludChjb25zdCBJbnRQb2ludCYgZnJhbWVQ b2ludCk7CiAgICAgICAgIERvY3VtZW50KiBkb2N1bWVudEF0UG9pbnQoY29uc3QgSW50UG9pbnQm IHdpbmRvd1BvaW50KTsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNzc5ODMpCisrKyBMYXlvdXRUZXN0 cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAxMS0wMi0wOCAg U2h1IENoYW5nICA8Y2hhbmcuc2h1QG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGZvciBjaGVja2luZyBp c0NvbnRlbnRFZGl0YWJsZSB3aXRoIGRlc2lnbk1vZGUuCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQorCisgICAgICAgICogZmFzdC9kb20vSFRN TEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRl ZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0 b3ItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9p c2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbDogQWRkZWQuCisgICAg ICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9u LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWw6IEFkZGVkLgorCiAyMDExLTAyLTA4ICBN YXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnNraXAg YSBzZXJpZXMgb2YgdGVzdHMgdGhhdCBzZWVtIHRvIGJlIHBhc3NpbmcgbG9jYWxseS4gQWxzbyB1 bnNraXAKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQgQEAKK0Nv bnRlbnQgc2hvdWxkIGJlIGVkaXRhYmxlIGlmIGl0cyBhbmQgaXRzIGFuY2VzdG9yJ3MgY29udGVu dEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuCisK K09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZv bGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKK2RvY3VtZW50LmRlc2lnbk1v ZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRp dGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5p c0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRp diwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13 cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUg aXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50 RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQ QVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJ bmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUt ZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5o ZXJpdC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw0MSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgor PGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5q cyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgor PGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYgaWQ9 ImRpdjEiPgorICAgIDxkaXY+CisgICAgICAgIDxkaXYgaWQ9ImRpdiI+PC9kaXY+CisgICAgPC9k aXY+Cis8L2Rpdj4KKzxkaXYgaWQ9ImRpdjIiPgorICAgIDxkaXY+CisgICAgICAgIDxwIGlkPSJw Ij48L3A+CisgICAgPC9kaXY+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignQ29udGVu dCBzaG91bGQgYmUgZWRpdGFibGUgaWYgaXRzIGFuZCBpdHMgYW5jZXN0b3JcJ3MgY29udGVudEVk aXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuJykKKwor ZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQi Jyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVk aXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3Jp dGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRF ZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0 Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlm eSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MSIp LnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIiku c3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1 ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBv c3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9y LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxl bWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250 ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSwyNCBAQAoraXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2Ug aWYgaXRzIGFuY2VzdG9yJ3MgY29udGVudEVkaXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRo ZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkIG9yIG5vdC4KKworT24gc3VjY2Vzcywg eW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRF U1QgQ09NUExFVEUiLgorCisKKworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BB U1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5o ZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRh YmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFBy b3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIK K1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0 cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVl KCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BBU1Mgc3VjY2Vzc2Z1 bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCkluZGV4OiBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YW5jZXN0b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxl bWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRh YmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQx IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hl ZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVh ZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48 L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0iZGl2MSIgY29udGVudEVkaXRh YmxlPSJmYWxzZSI+CisgICAgPGRpdj4KKyAgICAgICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKyAg ICA8L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0iZGl2MiIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj4K KyAgICA8ZGl2PgorICAgICAgICA8cCBpZD0icCI+PC9wPgorICAgIDwvZGl2PgorPC9kaXY+Cis8 c2NyaXB0PgorZGVzY3JpcHRpb24oJ2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdl IGlmIGl0cyBhbmNlc3RvclwncyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hl dGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2V2YWxBbmRM b2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hv dWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScs ICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdl dFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOwor CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUn LCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5p c0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVk U3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICci cmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjEiKS5zdHlsZS5k aXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLnN0eWxlLmRp c3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3Nj cmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48 L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1l eHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjYgQEAKK2lzQ29udGVudEVkaXRh YmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBt YXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LgorCitP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2Rl ID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRl KCJjb250ZW50RWRpdGFibGUiKSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93 LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2Vy LW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJw IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUgaXMgInRydWUiCitQQVNTIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFT UyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtp dC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFk PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9w PgorPGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYg aWQ9ImRpdiIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+PC9kaXY+Cis8cCBpZD0icCIgY29udGVu dEVkaXRhYmxlPSJ0cnVlIj48L3A+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ2lzQ29udGVudEVk aXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBu byBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90Licp CisKK2V2YWxBbmRMb2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJl KCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRp dGFibGUiKScsJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3Vs ZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCIt d2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScs JyJ0cnVlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVu dEVkaXRhYmxlJywgJyJ0cnVlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRD b21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5z dHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLnN0eWxl LmRpc3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8 L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0Lmpz Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 81810 2011-02-09 07:22:16 -0800 2011-02-10 14:41:01 -0800 fix patch 4 53031_4.patch text/plain 18263 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc4MDUxKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMDItMDkgIFNodSBDaGFu ZyAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6Ly9kZXYudzMub3JnL2h0 bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJsZSkKKyAgICAgICAgaW5k aWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgcmVsaWVzIG9uIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5jZXN0b3JzJyBjb250ZW50 ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisgICAgICAgIFRvIGFjaGll dmUgdGhpcywgd2UgdXBkYXRlIHRoZSB1c2VybW9kaWZ5IHByb3BlcnR5IG9mIHRvcC1sZXZlbCBy ZW5kZXIgc3R5bGUgd2hlbgorICAgICAgICBzZXR0aW5nIGRlc2lnbk1vZGUgaW4gZG9jdW1lbnQu CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQor CisgICAgICAgIFRlc3RzOiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAorICAg ICAgICAgICAgICAgZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLmh0bWwKKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojppc1JlYWRPbmx5KTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudDo6c2V0RGVzaWduTW9kZSk6CisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9s bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbkZyb21Ob25lKTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGh0bWwvSFRNTEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxF bGVtZW50Ojppc0NvbnRlbnRSaWNobHlFZGl0YWJsZSk6CisgICAgICAgICogcGFnZS9GcmFtZS5j cHA6IHJlbW92ZSB0aGUgaXNDb250ZW50RWRpdGFibGUgc3VwcG9ydCBoZXJlLgorICAgICAgICAq IHBhZ2UvRnJhbWUuaDoKKwogMjAxMS0wMi0wNyAgQ2hyaXMgTWFycmluICA8Y21hcnJpbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpJbmRleDogU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuY3BwCShyZXZpc2lvbiA3ODA1MSkKKysrIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY2 MiwxMiArNjYyLDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc1JlYWRPbgog ICAgICAgICBIVE1MRWxlbWVudCogYm9keSA9IGRvY3VtZW50LT5ib2R5KCk7CiAgICAgICAgIGlm IChib2R5ICYmIGJvZHktPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgICAgIAotICAgICAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUo KTsKLSAgICAgICAgaWYgKCFmcmFtZSkKLSAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAgICAg ICAKLSAgICAgICAgcmV0dXJuICFmcmFtZS0+aXNDb250ZW50RWRpdGFibGUoKTsKKworICAgICAg ICByZXR1cm4gIWRvY3VtZW50LT5pbkRlc2lnbk1vZGUoKTsKICAgICB9CiAKICAgICBpZiAobV9y ZW5kZXJlci0+aXNCb3hNb2RlbE9iamVjdCgpKSB7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAJKHJldmlzaW9uIDc4MDUxKQorKysgU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAko d29ya2luZyBjb3B5KQpAQCAtNDAxNCw2ICs0MDE0LDEwIEBAIHZvaWQgRG9jdW1lbnQ6OnNldFRy YW5zZm9ybVNvdXJjZShQYXNzT3cKIHZvaWQgRG9jdW1lbnQ6OnNldERlc2lnbk1vZGUoSW5oZXJp dGVkQm9vbCB2YWx1ZSkKIHsKICAgICBtX2Rlc2lnbk1vZGUgPSB2YWx1ZTsKKyAgICBpZiAocmVu ZGVyZXIoKSkgeworICAgICAgICByZW5kZXJlcigpLT5zdHlsZSgpLT5zZXRVc2VyTW9kaWZ5KCh2 YWx1ZSA9PSBvbikgPyBSRUFEX1dSSVRFIDogUkVBRF9PTkxZKTsKKyAgICAgICAgcmVjYWxjU3R5 bGUoSW5oZXJpdCk7CisgICAgfQogfQogCiBEb2N1bWVudDo6SW5oZXJpdGVkQm9vbCBEb2N1bWVu dDo6Z2V0RGVzaWduTW9kZSgpIGNvbnN0CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2VkaXRp bmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDc4MDUxKQorKysgU291cmNlL1dl YkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MTc2Nyw3ICsxNzY3LDcgQEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb25G cgogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKICAgICBi b29sIGNhcmV0QnJvd3NpbmcgPSBtX2ZyYW1lLT5zZXR0aW5ncygpICYmIG1fZnJhbWUtPnNldHRp bmdzKCktPmNhcmV0QnJvd3NpbmdFbmFibGVkKCk7Ci0gICAgaWYgKCFpc05vbmUoKSB8fCAhKG1f ZnJhbWUtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgY2FyZXRCcm93c2luZykpCisgICAgaWYgKCFp c05vbmUoKSB8fCAhKGRvY3VtZW50LT5pbkRlc2lnbk1vZGUoKSB8fCBjYXJldEJyb3dzaW5nKSkK ICAgICAgICAgcmV0dXJuOwogCiAgICAgTm9kZSogbm9kZSA9IGRvY3VtZW50LT5kb2N1bWVudEVs ZW1lbnQoKTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCShyZXZpc2lvbiA3 ODA1MSkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC02NTUsOSArNjU1LDYgQEAgYm9vbCBIVE1MRWxlbWVudDo6c3VwcG9ydHNGb2N1cygp IGNvbnN0CiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QgCiB7 Ci0gICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+aXND b250ZW50RWRpdGFibGUoKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICAvLyBJZGVhbGx5 IHdlJ2QgY2FsbCBBU1NFUlQhbmVlZHNTdHlsZVJlY2FsYygpKSBoZXJlLCBidXQKICAgICAvLyBD b250YWluZXJOb2RlOjpzZXRGb2N1cygpIGNhbGxzIHNldE5lZWRzU3R5bGVSZWNhbGMoKSwgc28g dGhlIGFzc2VydGlvbgogICAgIC8vIHdvdWxkIGZpcmUgaW4gdGhlIG1pZGRsZSBvZiBEb2N1bWVu dDo6c2V0Rm9jdXNlZE5vZGUoKS4KQEAgLTY3NCw5ICs2NzEsNiBAQCBib29sIEhUTUxFbGVtZW50 Ojppc0NvbnRlbnRFZGl0YWJsZSgpIGNvCiAKIGJvb2wgSFRNTEVsZW1lbnQ6OmlzQ29udGVudFJp Y2hseUVkaXRhYmxlKCkgY29uc3QKIHsKLSAgICBpZiAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBk b2N1bWVudCgpLT5mcmFtZSgpLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQotICAgICAgICByZXR1cm4g dHJ1ZTsKLQogICAgIGlmICghcmVuZGVyZXIoKSkgewogICAgICAgICBpZiAocGFyZW50Tm9kZSgp KQogICAgICAgICAgICAgcmV0dXJuIHBhcmVudE5vZGUoKS0+aXNDb250ZW50RWRpdGFibGUoKTsK SW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCShyZXZpc2lvbiA3ODA1MSkKKysrIFNvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NTEsMTMgKzU1MSw2IEBAIHZv aWQgRnJhbWU6OmluamVjdFVzZXJTY3JpcHRzRm9yV29ybGQoRE8KICAgICB9CiB9CiAKLWJvb2wg RnJhbWU6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QKLXsKLSAgICBpZiAobV9lZGl0b3IuY2xp ZW50SXNFZGl0YWJsZSgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICByZXR1cm4gbV9kb2Mt PmluRGVzaWduTW9kZSgpOwotfQotCiAjaWZuZGVmIE5ERUJVRwogc3RhdGljIEhhc2hTZXQ8RnJh bWUqPiYga2VlcEFsaXZlU2V0KCkKIHsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDc4 MDUxKQorKysgU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0x ODIsOCArMTgyLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBEcmFnSW1hZ2VSZWYg bm9kZUltYWdlKE5vZGUqKTsKICAgICAgICAgRHJhZ0ltYWdlUmVmIGRyYWdJbWFnZUZvclNlbGVj dGlvbigpOwogCi0gICAgICAgIGJvb2wgaXNDb250ZW50RWRpdGFibGUoKSBjb25zdDsgLy8gaWYg dHJ1ZSwgZXZlcnl0aGluZyBpbiBmcmFtZSBpcyBlZGl0YWJsZQotCiAgICAgICAgIFZpc2libGVQ b3NpdGlvbiB2aXNpYmxlUG9zaXRpb25Gb3JQb2ludChjb25zdCBJbnRQb2ludCYgZnJhbWVQb2lu dCk7CiAgICAgICAgIERvY3VtZW50KiBkb2N1bWVudEF0UG9pbnQoY29uc3QgSW50UG9pbnQmIHdp bmRvd1BvaW50KTsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNzgwNTEpCisrKyBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAxMS0wMi0wOSAgU2h1 IENoYW5nICA8Y2hhbmcuc2h1QG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGZvciBjaGVja2luZyBpc0Nv bnRlbnRFZGl0YWJsZSB3aXRoIGRlc2lnbk1vZGUuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQorCisgICAgICAgICogZmFzdC9kb20vSFRNTEVs ZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0 YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3It ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2Nv bnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbDogQWRkZWQuCisgICAgICAg ICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250 ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWw6IEFkZGVkLgorCiAyMDExLTAyLTA5ICBTaGlu aWNoaXJvIEhhbWFqaSAgPGhhbWFqaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ2hyb21pdW0g ZXhwZWN0YXRpb25zIHVwZGF0ZS4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVkLnR4 dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMjQgQEAKK0NvbnRlbnQgc2hvdWxkIGJlIGVkaXRhYmxlIGlmIGl0cyBhbmQgaXRzIGFu Y2VzdG9yJ3MgY29udGVudEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2Rl IGlzIGVuYWJsZWQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFT UyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKK2Rv Y3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJk aXYiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2Rp ZnkiKSBpcyAicmVhZC13cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5j b250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJy ZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09N UExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVy aXQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNyBAQAorPCFET0NUWVBFIGh0bWw+Cis8 aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNv dXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNl cy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNj cmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48 L2Rpdj4KKzxkaXYgaWQ9InBhcmVudF9vZl9kaXYiPgorICAgIDxkaXYgaWQ9ImRpdiI+PC9kaXY+ Cis8L2Rpdj4KKzxkaXYgaWQ9InBhcmVudF9vZl9wIj4KKyAgICA8cCBpZD0icCI+PC9wPgorPC9k aXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ0NvbnRlbnQgc2hvdWxkIGJlIGVkaXRhYmxlIGlm IGl0cyBhbmQgaXRzIGFuY2VzdG9yXCdzIGNvbnRlbnRFZGl0YWJsZSBub3Qgc2V0LCBhbmQgZG9j dW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkLicpCisKK2V2YWxBbmRMb2coJ2RvY3VtZW50LmRl c2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7CitzaG91 bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgi LXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitzaG91bGRCZSgnZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7 CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJs ZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdl dFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsK KworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhcmVudF9vZl9kaXYiKS5zdHlsZS5kaXNwbGF5 PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX3AiKS5zdHlsZS5k aXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9z Y3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+ PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0 ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lz Y29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0 YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDMyIEBACitpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMg YW5jZXN0b3IncyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1 bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2ls bCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01Q TEVURSIuCisKKworCisKKworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJp dCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxl IGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3Bl cnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIK K1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5pc0NvbnRlbnRFZGl0YWJsZSBp cyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVy dHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFT UyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRydWUK K1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13 ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgicDIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdp bmRvdy5nZXRDb21wdXRlZFN0eWxlKHAyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11 c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBp cyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0 bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250 ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWwJKHJldmlzaW9uIDApCisrKyBM YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25t b2Rlb24tYW5jZXN0b3IuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1NiBAQAorPCFET0NU WVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIu Li8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4K KzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBp ZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYgaWQ9InBhcmVudF9vZl9kaXYiIGNvbnRlbnRFZGl0YWJs ZT0iZmFsc2UiPgorICAgIDxkaXYgaWQ9ImRpdiI+PC9kaXY+Cis8L2Rpdj4KKzxkaXYgaWQ9InBh cmVudF9vZl9kaXYyIj4KKyAgICA8ZGl2IGlkPSJkaXYyIj48L2Rpdj4KKzwvZGl2PgorPGRpdiBp ZD0icGFyZW50X29mX3AiIGNvbnRlbnRFZGl0YWJsZT0idHJ1ZSI+CisgICAgPHAgaWQ9InAiPjwv cD4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX3AyIj4KKyAgICA8cCBpZD0icDIiPjwvcD4K KzwvZGl2PgorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQg bm90IGNoYW5nZSBpZiBpdHMgYW5jZXN0b3JcJ3MgY29udGVudEVkaXRhYmxlIGlzIHNldCwgbm8g bWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkIG9yIG5vdC4nKQor Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX2RpdjIiKS5jb250ZW50RWRpdGFi bGUgPSBmYWxzZTsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfcDIiKS5jb250 ZW50RWRpdGFibGUgPSB0cnVlOworCitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNpZ25Nb2RlID0g Im9uIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRl bnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5k b3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVz ZXItbW9kaWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXYyIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxk QmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUnLCAn ZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisK K3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZScs ICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlz Q29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJy ZWFkLXdyaXRlIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIiku Y29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQt dXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInBhcmVudF9vZl9kaXYiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFyZW50X29mX2RpdjIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX3AiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7 Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX3AyIikuc3R5bGUuZGlzcGxheT0g J25vbmUnOworCit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0Pgor PHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNiBAQAoraXNDb250ZW50RWRpdGFibGUgc2hv dWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3 aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0g Im9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJj b250ZW50RWRpdGFibGUiKSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5jb250ZW50RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93Lmdl dENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1v ZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYy IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAiZmFsc2UiCitQQVNTIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29udGVudEVkaXRhYmxlIGlzICJmYWxzZSIKK1BB U1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBm YWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVydHlW YWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJwIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAi dHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUg aXMgInRydWUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRp dGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJv cGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorUEFTUyBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJs ZSIpIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50 RWRpdGFibGUgaXMgInRydWUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlz Q29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3Jp dGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQor CisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRl ZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDUyIEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhy ZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0i Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxi b2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8 ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0iZGl2IiBjb250ZW50RWRpdGFibGU9ImZh bHNlIj48L2Rpdj4KKzxkaXYgaWQ9ImRpdjIiPjwvZGl2PgorPHAgaWQ9InAiIGNvbnRlbnRFZGl0 YWJsZT0idHJ1ZSI+PC9wPgorPHAgaWQ9InAyIj48L3A+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24o J2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBjb250ZW50RWRpdGFi bGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJs ZWQgb3Igbm90LicpCisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29udGVudEVk aXRhYmxlID0gZmFsc2U7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRp dGFibGUgPSB0cnVlOworCitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIicp OworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmdldEF0dHJpYnV0 ZSgiY29udGVudEVkaXRhYmxlIiknLCciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZScsICciZmFsc2UiJyk7CitzaG91bGRC ZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2Zh bHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJv cGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3No b3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmdldEF0dHJpYnV0ZSgiY29u dGVudEVkaXRhYmxlIiknLCciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFibGUnLCAnImZhbHNlIicpOworc2hvdWxkQmUoJ2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2Un KTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVy dHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3Vs ZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVk aXRhYmxlIiknLCcidHJ1ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi cCIpLmNvbnRlbnRFZGl0YWJsZScsICcidHJ1ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11 c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInAyIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVl IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0 YWJsZScsICcidHJ1ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIi KS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1 dGVkU3R5bGUocDIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikn LCAnInJlYWQtd3JpdGUiJyk7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5zdHls ZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLnN0eWxl LmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuc3R5bGUuZGlz cGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuc3R5bGUuZGlzcGxh eT0gJ25vbmUnOworCit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgo= 82050 2011-02-10 14:41:01 -0800 2011-04-07 07:28:16 -0700 fix patch 5 53031_5.patch text/plain 18351 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc4MjI3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMDItMDkgIFNodSBDaGFu ZyAgPGNoYW5nLnNodUBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6Ly9kZXYudzMub3JnL2h0 bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJsZSkKKyAgICAgICAgaW5k aWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUgcmVsaWVzIG9uIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5jZXN0b3JzJyBjb250ZW50 ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisgICAgICAgIFRvIGFjaGll dmUgdGhpcywgd2UgdXBkYXRlIHRoZSB1c2VybW9kaWZ5IHByb3BlcnR5IG9mIHRvcC1sZXZlbCBy ZW5kZXIgc3R5bGUgd2hlbgorICAgICAgICBzZXR0aW5nIGRlc2lnbk1vZGUgaW4gZG9jdW1lbnQu CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQor CisgICAgICAgIFRlc3RzOiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAorICAg ICAgICAgICAgICAgZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLmh0bWwKKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojppc1JlYWRPbmx5KTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudDo6c2V0RGVzaWduTW9kZSk6CisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9s bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbkZyb21Ob25lKTogcmVtb3ZlIGRlcGVuZGVuY3kgb24gRnJhbWU6OmlzQ29udGVudEVkaXRh YmxlLgorICAgICAgICAqIGh0bWwvSFRNTEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTEVsZW1lbnQ6OmlzQ29udGVudEVkaXRhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxF bGVtZW50Ojppc0NvbnRlbnRSaWNobHlFZGl0YWJsZSk6CisgICAgICAgICogcGFnZS9GcmFtZS5j cHA6IHJlbW92ZSB0aGUgaXNDb250ZW50RWRpdGFibGUgc3VwcG9ydCBoZXJlLgorICAgICAgICAq IHBhZ2UvRnJhbWUuaDoKKwogMjAxMS0wMi0xMCAgQW5kcmFzIEJlY3NpICA8YWJlY3NpQHdlYmtp dC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgQ3NhYmEgT3N6dHJvZ29uw6FjLgpJ bmRleDogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiA3ODIyNykKKysrIFNvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTY2MiwxMiArNjYyLDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojppc1JlYWRPbgogICAgICAgICBIVE1MRWxlbWVudCogYm9keSA9IGRvY3VtZW50LT5ib2R5KCk7 CiAgICAgICAgIGlmIChib2R5ICYmIGJvZHktPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgIAotICAgICAgICBGcmFtZSogZnJhbWUgPSBkb2N1 bWVudC0+ZnJhbWUoKTsKLSAgICAgICAgaWYgKCFmcmFtZSkKLSAgICAgICAgICAgIHJldHVybiB0 cnVlOwotICAgICAgICAKLSAgICAgICAgcmV0dXJuICFmcmFtZS0+aXNDb250ZW50RWRpdGFibGUo KTsKKworICAgICAgICByZXR1cm4gIWRvY3VtZW50LT5pbkRlc2lnbk1vZGUoKTsKICAgICB9CiAK ICAgICBpZiAobV9yZW5kZXJlci0+aXNCb3hNb2RlbE9iamVjdCgpKSB7CkluZGV4OiBTb3VyY2Uv V2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5jcHAJKHJldmlzaW9uIDc4MjI3KQorKysgU291cmNlL1dlYkNvcmUvZG9tL0Rv Y3VtZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDAyNiw2ICs0MDI2LDExIEBAIHZvaWQgRG9j dW1lbnQ6OnNldFRyYW5zZm9ybVNvdXJjZShQYXNzT3cKIHZvaWQgRG9jdW1lbnQ6OnNldERlc2ln bk1vZGUoSW5oZXJpdGVkQm9vbCB2YWx1ZSkKIHsKICAgICBtX2Rlc2lnbk1vZGUgPSB2YWx1ZTsK KyAgICBBU1NFUlQocmVuZGVyZXIoKSk7CisgICAgaWYgKHJlbmRlcmVyKCkpIHsKKyAgICAgICAg cmVuZGVyZXIoKS0+c3R5bGUoKS0+c2V0VXNlck1vZGlmeSgodmFsdWUgPT0gb24pID8gUkVBRF9X UklURSA6IFJFQURfT05MWSk7CisgICAgICAgIHJlY2FsY1N0eWxlKEluaGVyaXQpOworICAgIH0K IH0KIAogRG9jdW1lbnQ6OkluaGVyaXRlZEJvb2wgRG9jdW1lbnQ6OmdldERlc2lnbk1vZGUoKSBj b25zdApJbmRleDogU291cmNlL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xs ZXIuY3BwCShyZXZpc2lvbiA3ODIyNykKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0 aW9uQ29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE3NjcsNyArMTc2Nyw3IEBAIHZv aWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uRnIKIAogICAgIERvY3VtZW50KiBk b2N1bWVudCA9IG1fZnJhbWUtPmRvY3VtZW50KCk7CiAgICAgYm9vbCBjYXJldEJyb3dzaW5nID0g bV9mcmFtZS0+c2V0dGluZ3MoKSAmJiBtX2ZyYW1lLT5zZXR0aW5ncygpLT5jYXJldEJyb3dzaW5n RW5hYmxlZCgpOwotICAgIGlmICghaXNOb25lKCkgfHwgIShtX2ZyYW1lLT5pc0NvbnRlbnRFZGl0 YWJsZSgpIHx8IGNhcmV0QnJvd3NpbmcpKQorICAgIGlmICghaXNOb25lKCkgfHwgIShkb2N1bWVu dC0+aW5EZXNpZ25Nb2RlKCkgfHwgY2FyZXRCcm93c2luZykpCiAgICAgICAgIHJldHVybjsKIAog ICAgIE5vZGUqIG5vZGUgPSBkb2N1bWVudC0+ZG9jdW1lbnRFbGVtZW50KCk7CkluZGV4OiBTb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxFbGVtZW50LmNwcAkocmV2aXNpb24gNzgyMjcpCisrKyBTb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjU1LDkgKzY1NSw2 IEBAIGJvb2wgSFRNTEVsZW1lbnQ6OnN1cHBvcnRzRm9jdXMoKSBjb25zdAogCiBib29sIEhUTUxF bGVtZW50Ojppc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0IAogewotICAgIGlmIChkb2N1bWVudCgp LT5mcmFtZSgpICYmIGRvY3VtZW50KCktPmZyYW1lKCktPmlzQ29udGVudEVkaXRhYmxlKCkpCi0g ICAgICAgIHJldHVybiB0cnVlOwotCiAgICAgLy8gSWRlYWxseSB3ZSdkIGNhbGwgQVNTRVJUIW5l ZWRzU3R5bGVSZWNhbGMoKSkgaGVyZSwgYnV0CiAgICAgLy8gQ29udGFpbmVyTm9kZTo6c2V0Rm9j dXMoKSBjYWxscyBzZXROZWVkc1N0eWxlUmVjYWxjKCksIHNvIHRoZSBhc3NlcnRpb24KICAgICAv LyB3b3VsZCBmaXJlIGluIHRoZSBtaWRkbGUgb2YgRG9jdW1lbnQ6OnNldEZvY3VzZWROb2RlKCku CkBAIC02NzQsOSArNjcxLDYgQEAgYm9vbCBIVE1MRWxlbWVudDo6aXNDb250ZW50RWRpdGFibGUo KSBjbwogCiBib29sIEhUTUxFbGVtZW50Ojppc0NvbnRlbnRSaWNobHlFZGl0YWJsZSgpIGNvbnN0 CiB7Ci0gICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ aXNDb250ZW50RWRpdGFibGUoKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICBpZiAoIXJl bmRlcmVyKCkpIHsKICAgICAgICAgaWYgKHBhcmVudE5vZGUoKSkKICAgICAgICAgICAgIHJldHVy biBwYXJlbnROb2RlKCktPmlzQ29udGVudEVkaXRhYmxlKCk7CkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1l LmNwcAkocmV2aXNpb24gNzgyMjcpCisrKyBTb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAko d29ya2luZyBjb3B5KQpAQCAtNTUxLDEzICs1NTEsNiBAQCB2b2lkIEZyYW1lOjppbmplY3RVc2Vy U2NyaXB0c0ZvcldvcmxkKERPCiAgICAgfQogfQogCi1ib29sIEZyYW1lOjppc0NvbnRlbnRFZGl0 YWJsZSgpIGNvbnN0Ci17Ci0gICAgaWYgKG1fZWRpdG9yLmNsaWVudElzRWRpdGFibGUoKSkKLSAg ICAgICAgcmV0dXJuIHRydWU7Ci0gICAgcmV0dXJuIG1fZG9jLT5pbkRlc2lnbk1vZGUoKTsKLX0K LQogI2lmbmRlZiBOREVCVUcKIHN0YXRpYyBIYXNoU2V0PEZyYW1lKj4mIGtlZXBBbGl2ZVNldCgp CiB7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCShyZXZpc2lvbiA3ODIyNykKKysrIFNvdXJjZS9XZWJD b3JlL3BhZ2UvRnJhbWUuaAkod29ya2luZyBjb3B5KQpAQCAtMTgyLDggKzE4Miw2IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgRHJhZ0ltYWdlUmVmIG5vZGVJbWFnZShOb2RlKik7CiAg ICAgICAgIERyYWdJbWFnZVJlZiBkcmFnSW1hZ2VGb3JTZWxlY3Rpb24oKTsKIAotICAgICAgICBi b29sIGlzQ29udGVudEVkaXRhYmxlKCkgY29uc3Q7IC8vIGlmIHRydWUsIGV2ZXJ5dGhpbmcgaW4g ZnJhbWUgaXMgZWRpdGFibGUKLQogICAgICAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVBvc2l0 aW9uRm9yUG9pbnQoY29uc3QgSW50UG9pbnQmIGZyYW1lUG9pbnQpOwogICAgICAgICBEb2N1bWVu dCogZG9jdW1lbnRBdFBvaW50KGNvbnN0IEludFBvaW50JiB3aW5kb3dQb2ludCk7CiAKSW5kZXg6 IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VM b2cJKHJldmlzaW9uIDc4MjI3KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDItMDkgIFNodSBDaGFuZyAgPGNoYW5nLnNodUBu b2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgQWRkZWQgdGVzdCBjYXNlcyBmb3IgY2hlY2tpbmcgaXNDb250ZW50RWRpdGFibGUgd2l0aCBk ZXNpZ25Nb2RlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NTMwMzEKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRh YmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFs bGluaGVyaXQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLWFuY2VzdG9yLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1v ZGVvbi5odG1sOiBBZGRlZC4KKwogMjAxMS0wMi0xMCAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3Jt YW5kQGlnYWxpYS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCBza2lwIGZhaWxpbmcgZmFzdC90 ZXh0L2ludGVybmF0aW9uYWwvaGluZGktd2hpdGVzcGFjZS5odG1sIHRlc3Qgb24gR1RLCkluZGV4 OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFs bGluaGVyaXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQt ZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI0IEBACitDb250ZW50IHNob3Vs ZCBiZSBlZGl0YWJsZSBpZiBpdHMgYW5kIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJsZSBu b3Qgc2V0LCBhbmQgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkLgorCitPbiBzdWNjZXNz LCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAi VEVTVCBDT01QTEVURSIuCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgor UEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlIGlzICJp bmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRp dGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQ cm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCitQQVNT IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0 IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlz IHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFs dWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVv bi1hbGxpbmhlcml0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVu dGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMzcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0i c3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0 PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNv bnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2Zf ZGl2Ij4KKyAgICA8ZGl2IGlkPSJkaXYiPjwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRf b2ZfcCI+CisgICAgPHAgaWQ9InAiPjwvcD4KKzwvZGl2PgorPHNjcmlwdD4KK2Rlc2NyaXB0aW9u KCdDb250ZW50IHNob3VsZCBiZSBlZGl0YWJsZSBpZiBpdHMgYW5kIGl0cyBhbmNlc3RvclwncyBj b250ZW50RWRpdGFibGUgbm90IHNldCwgYW5kIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxl ZC4nKQorCitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIicpOworCitzaG91 bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZScsICci aW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXND b250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICci cmVhZC13cml0ZSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIiku Y29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dp bmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVz ZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwYXJlbnRfb2ZfZGl2Iikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInBhcmVudF9vZl9wIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5kb3cu c3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s PgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFi bGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9y LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMiBAQAoraXNDb250ZW50RWRp dGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGFuY2VzdG9yJ3MgY29udGVudEVkaXRhYmxl IGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVk IG9yIG5vdC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBt ZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKKworCisKKworCisKK2Rv Y3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJk aXYiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0 Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9k aWZ5IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIi KS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENv bXB1dGVkU3R5bGUoZGl2MiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2Rp ZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNv bnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJl YWQtd3JpdGUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0 YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXND b250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwg IiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0 ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisK KworCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1h bmNlc3Rvci5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVs ZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWwJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNTYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4K KzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qt c3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8ZGl2IGlk PSJwYXJlbnRfb2ZfZGl2IiBjb250ZW50RWRpdGFibGU9ImZhbHNlIj4KKyAgICA8ZGl2IGlkPSJk aXYiPjwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2ZfZGl2MiI+CisgICAgPGRpdiBp ZD0iZGl2MiI+PC9kaXY+Cis8L2Rpdj4KKzxkaXYgaWQ9InBhcmVudF9vZl9wIiBjb250ZW50RWRp dGFibGU9InRydWUiPgorICAgIDxwIGlkPSJwIj48L3A+Cis8L2Rpdj4KKzxkaXYgaWQ9InBhcmVu dF9vZl9wMiI+CisgICAgPHAgaWQ9InAyIj48L3A+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlw dGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2UgaWYgaXRzIGFuY2VzdG9y XCdzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRl c2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuJykKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InBhcmVudF9vZl9kaXYyIikuY29udGVudEVkaXRhYmxlID0gZmFsc2U7Citkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFyZW50X29mX3AyIikuY29udGVudEVkaXRhYmxlID0gdHJ1ZTsKKworZXZh bEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7 CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRh YmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAi IikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHki Jyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRF ZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiZGl2MiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93 LmdldENvbXB1dGVkU3R5bGUoZGl2MiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNl ci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgn ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7 CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFs dWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJp dCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5pc0NvbnRlbnRF ZGl0YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3Jp dGUiJyk7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfZGl2Iikuc3R5bGUu ZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhcmVudF9vZl9kaXYy Iikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhcmVu dF9vZl9wIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InBhcmVudF9vZl9wMiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nlc3Nm dWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNv dXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6 IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2ln bm1vZGVvbi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVu dGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMzYgQEAKK2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBjb250 ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2Rl IGlzIGVuYWJsZWQgb3Igbm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisK KworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImRpdiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgImZhbHNl IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlIGlz ICJmYWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVk aXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdl dFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFT UyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVk aXRhYmxlIikgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIp LmNvbnRlbnRFZGl0YWJsZSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1 dGVkU3R5bGUoZGl2MiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnki KSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmdldEF0 dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgInRydWUiCitQQVNTIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93 LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1t b2RpZnkiKSBpcyAicmVhZC13cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAy IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlIGlzICJ0cnVlIgorUEFTUyBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQ QVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdl YmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBh cnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50 ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw1MiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxo ZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+ PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxk aXYgaWQ9ImRpdiIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+PC9kaXY+Cis8ZGl2IGlkPSJkaXYy Ij48L2Rpdj4KKzxwIGlkPSJwIiBjb250ZW50RWRpdGFibGU9InRydWUiPjwvcD4KKzxwIGlkPSJw MiI+PC9wPgorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQg bm90IGNoYW5nZSBpZiBpdHMgY29udGVudEVkaXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRo ZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkIG9yIG5vdC4nKQorCitkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSA9IGZhbHNlOworZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlID0gdHJ1ZTsKKworZXZhbEFuZExv ZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImZh bHNlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50 RWRpdGFibGUnLCAnImZhbHNlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5n ZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1t b2RpZnkiKScsICcicmVhZC1vbmx5IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdjIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImZhbHNlIicp Oworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29udGVudEVkaXRh YmxlJywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 MiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENv bXB1dGVkU3R5bGUoZGl2MiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2Rp ZnkiKScsICcicmVhZC1vbmx5IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInAiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91 bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnInRy dWUiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRF ZGl0YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwg IiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0 ZSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmdldEF0dHJp YnV0ZSgiY29udGVudEVkaXRhYmxlIiknLCcidHJ1ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUnLCAnInRydWUiJyk7CitzaG91bGRC ZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1 ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAyLCAiIikuZ2V0UHJvcGVy dHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgicCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJwMiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nl c3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 88632 2011-04-07 07:28:16 -0700 2011-04-12 13:34:06 -0700 fix patch: new patch after dependencies have been resolved. 53031_6.patch text/plain 19882 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzMTY5KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTEtMDQtMDcgIENoYW5nIFNo dSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3 aXRoIGRvY3VtZW50LmRlc2lnbk1vZGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6 Ly9kZXYudzMub3JnL2h0bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJs ZSkKKyAgICAgICAgaW5kaWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUg cmVsaWVzIG9uIGRvY3VtZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5j ZXN0b3JzJyBjb250ZW50ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisK KyAgICAgICAgQSBuZXcgSU5IRVJJVCB2YWx1ZSBpcyBhZGRlZCB0byB1c2VybW9kaWZ5IGZvciBp dHMgZGVmYXVsdCB2YWx1ZS4gSG93ZXZlciwgb25seSB0aGUgcm9vdAorICAgICAgICBub2RlIG1h eSBoYXZlIGl0cyBvd24gcmVuZGVyIHN0eWxlIGhhdmluZyB0aGlzIHZhbHVlLiBBbGwgb3RoZXIg bm9kZXMgc2hvdWxkIGluaGVyaXQgdGhlaXIKKyAgICAgICAgcGFyZW50cycgdXNlcm1vZGlmeSBv ciBzZXQgbG9jYWxseSB0byBhIHZhbHVlIG90aGVyIHRoYW4gSU5IRVJJVC4gVGh1cywgd2hlbiBh IHVzZXJtb2RpZnkoKQorICAgICAgICByZXR1cm5zIElOSEVSSVQsIHRoZSBkb2N1bWVudCgpLT5p bkRlc2lnbk1vZGUoKSBzaG91bGQgYmUgdXNlZCBpbnN0ZWFkLgorCisgICAgICAgIFRlc3RzOiBm YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5o ZXJpdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRl ZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwKKworICAg ICAgICAqIGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRpb24uY3BwOgorICAgICAgICAoV2Vi Q29yZTo6Q1NTQ29tcHV0ZWRTdHlsZURlY2xhcmF0aW9uOjpnZXRQcm9wZXJ0eUNTU1ZhbHVlKToK KyAgICAgICAgKiBjc3MvQ1NTUHJpbWl0aXZlVmFsdWVNYXBwaW5ncy5oOgorICAgICAgICAoV2Vi Q29yZTo6Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU1ByaW1pdGl2ZVZhbHVlKToKKyAgICAgICAgKFdl YkNvcmU6OkNTU1ByaW1pdGl2ZVZhbHVlOjpvcGVyYXRvciBFVXNlck1vZGlmeSk6CisgICAgICAg ICogZG9tL05vZGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6cmVuZGVyZXJJc0VkaXRh YmxlKToKKyAgICAgICAgKiBodG1sL0hUTUxFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxFbGVtZW50OjpzZXRDb250ZW50RWRpdGFibGUpOgorICAgICAgICAqIHJlbmRlcmluZy9z dHlsZS9SZW5kZXJTdHlsZUNvbnN0YW50cy5oOgorICAgICAgICAqIHJlbmRlcmluZy9zdHlsZS9T dHlsZVJhcmVJbmhlcml0ZWREYXRhLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlN0eWxlUmFyZUlu aGVyaXRlZERhdGE6OlN0eWxlUmFyZUluaGVyaXRlZERhdGEpOgorCiAyMDExLTA0LTA3ICBSeW9z dWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVyaWMg U2VpZGVsLgpJbmRleDogU291cmNlL1dlYkNvcmUvY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJh dGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvY3NzL0NTU0NvbXB1dGVkU3R5 bGVEZWNsYXJhdGlvbi5jcHAJKHJldmlzaW9uIDgzMDQwKQorKysgU291cmNlL1dlYkNvcmUvY3Nz L0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEyMjUs NiArMTIyNSw4IEBAIFBhc3NSZWZQdHI8Q1NTVmFsdWU+IENTU0NvbXB1dGVkU3R5bGVEZWMKICAg ICAgICAgY2FzZSBDU1NQcm9wZXJ0eVdlYmtpdE1hcnF1ZWVTdHlsZToKICAgICAgICAgICAgIHJl dHVybiBwcmltaXRpdmVWYWx1ZUNhY2hlLT5jcmVhdGVWYWx1ZShzdHlsZS0+bWFycXVlZUJlaGF2 aW9yKCkpOwogICAgICAgICBjYXNlIENTU1Byb3BlcnR5V2Via2l0VXNlck1vZGlmeToKKyAgICAg ICAgICAgIGlmIChzdHlsZS0+dXNlck1vZGlmeSgpID09IElOSEVSSVQpCisgICAgICAgICAgICAg ICAgcmV0dXJuIHByaW1pdGl2ZVZhbHVlQ2FjaGUtPmNyZWF0ZVZhbHVlKG5vZGUtPmRvY3VtZW50 KCktPmluRGVzaWduTW9kZSgpID8gUkVBRF9XUklURSA6IFJFQURfT05MWSk7CiAgICAgICAgICAg ICByZXR1cm4gcHJpbWl0aXZlVmFsdWVDYWNoZS0+Y3JlYXRlVmFsdWUoc3R5bGUtPnVzZXJNb2Rp ZnkoKSk7CiAgICAgICAgIGNhc2UgQ1NTUHJvcGVydHlNYXhIZWlnaHQ6IHsKICAgICAgICAgICAg IGNvbnN0IExlbmd0aCYgbWF4SGVpZ2h0ID0gc3R5bGUtPm1heEhlaWdodCgpOwpJbmRleDogU291 cmNlL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlTWFwcGluZ3MuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWVNYXBwaW5ncy5oCShyZXZpc2lv biA4MzA0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZU1hcHBpbmdz LmgJKHdvcmtpbmcgY29weSkKQEAgLTE4MTksMTEgKzE4MTksMTYgQEAgdGVtcGxhdGU8PiBpbmxp bmUgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTUwogICAgICAgICBjYXNlIFJFQURfV1JJVEVfUExBSU5U RVhUX09OTFk6CiAgICAgICAgICAgICBtX3ZhbHVlLmlkZW50ID0gQ1NTVmFsdWVSZWFkV3JpdGVQ bGFpbnRleHRPbmx5OwogICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgSU5IRVJJVDoK KyAgICAgICAgICAgIG1fdmFsdWUuaWRlbnQgPSBDU1NWYWx1ZUluaGVyaXQ7CisgICAgICAgICAg ICBicmVhazsKICAgICB9CiB9CiAKIHRlbXBsYXRlPD4gaW5saW5lIENTU1ByaW1pdGl2ZVZhbHVl OjpvcGVyYXRvciBFVXNlck1vZGlmeSgpIGNvbnN0CiB7CisgICAgaWYgKG1fdmFsdWUuaWRlbnQg PT0gQ1NTVmFsdWVJbmhlcml0KQorICAgICAgICByZXR1cm4gSU5IRVJJVDsKICAgICByZXR1cm4g c3RhdGljX2Nhc3Q8RVVzZXJNb2RpZnk+KG1fdmFsdWUuaWRlbnQgLSBDU1NWYWx1ZVJlYWRPbmx5 KTsKIH0KIApJbmRleDogU291cmNlL1dlYkNvcmUvZG9tL05vZGUuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAkocmV2aXNpb24gODMwNDApCisrKyBTb3VyY2Uv V2ViQ29yZS9kb20vTm9kZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTcxNyw3ICs3MTcsNyBAQCBi b29sIE5vZGU6OmlzQ29udGVudEVkaXRhYmxlKCkgY29uc3QKIAogYm9vbCBOb2RlOjpyZW5kZXJl cklzRWRpdGFibGUoRWRpdGFibGVMZXZlbCBlZGl0YWJsZUxldmVsKSBjb25zdAogewotICAgIGlm IChkb2N1bWVudCgpLT5pbkRlc2lnbk1vZGUoKSB8fCAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBk b2N1bWVudCgpLT5mcmFtZSgpLT5wYWdlKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+cGFnZSgp LT5pc0VkaXRhYmxlKCkpKQorICAgIGlmIChkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50 KCktPmZyYW1lKCktPnBhZ2UoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5wYWdlKCktPmlzRWRp dGFibGUoKSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyBJZGVhbGx5IHdlJ2QgY2Fs bCBBU1NFUlQoIW5lZWRzU3R5bGVSZWNhbGMoKSkgaGVyZSwgYnV0CkBAIC03MjUsNyArNzI1LDcg QEAgYm9vbCBOb2RlOjpyZW5kZXJlcklzRWRpdGFibGUoRWRpdGFibGVMZQogICAgIC8vIHdvdWxk IGZpcmUgaW4gdGhlIG1pZGRsZSBvZiBEb2N1bWVudDo6c2V0Rm9jdXNlZE5vZGUoKS4KIAogICAg IGZvciAoY29uc3QgTm9kZSogbm9kZSA9IHRoaXM7IG5vZGU7IG5vZGUgPSBub2RlLT5wYXJlbnRO b2RlKCkpIHsKLSAgICAgICAgaWYgKChub2RlLT5pc0hUTUxFbGVtZW50KCkgfHwgbm9kZS0+aXNE b2N1bWVudE5vZGUoKSkgJiYgbm9kZS0+cmVuZGVyZXIoKSkgeworICAgICAgICBpZiAobm9kZS0+ aXNIVE1MRWxlbWVudCgpICYmIG5vZGUtPnJlbmRlcmVyKCkpIHsKICAgICAgICAgICAgIHN3aXRj aCAobm9kZS0+cmVuZGVyZXIoKS0+c3R5bGUoKS0+dXNlck1vZGlmeSgpKSB7CiAgICAgICAgICAg ICBjYXNlIFJFQURfT05MWToKICAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC03MzMs MTMgKzczMywxMyBAQCBib29sIE5vZGU6OnJlbmRlcmVySXNFZGl0YWJsZShFZGl0YWJsZUxlCiAg ICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgICAgICAgICBjYXNlIFJFQURfV1JJVEVf UExBSU5URVhUX09OTFk6CiAgICAgICAgICAgICAgICAgcmV0dXJuIGVkaXRhYmxlTGV2ZWwgIT0g UmljaGx5RWRpdGFibGU7CisgICAgICAgICAgICBjYXNlIElOSEVSSVQ6CisgICAgICAgICAgICAg ICAgcmV0dXJuIGRvY3VtZW50KCktPmluRGVzaWduTW9kZSgpOwogICAgICAgICAgICAgfQotICAg ICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci0gICAgICAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIGRvY3Vt ZW50KCktPmluRGVzaWduTW9kZSgpOwogfQogCiBib29sIE5vZGU6OnNob3VsZFVzZUlucHV0TWV0 aG9kKCkgY29uc3QKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCShyZXZpc2lv biA4MzA0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC02ODMsNyArNjgzLDcgQEAgdm9pZCBIVE1MRWxlbWVudDo6c2V0Q29udGVudEVk aXRhYmxlKEF0dAogICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3Bl cnR5V2Via2l0TmJzcE1vZGUsIGZhbHNlKTsKICAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQ cm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdExpbmVCcmVhaywgZmFsc2UpOwogICAgIH0gZWxzZSBp ZiAoZXF1YWxJZ25vcmluZ0Nhc2UoZW5hYmxlZCwgImluaGVyaXQiKSkgewotICAgICAgICBhZGRD U1NQcm9wZXJ0eShhdHRyLCBDU1NQcm9wZXJ0eVdlYmtpdFVzZXJNb2RpZnksIENTU1ZhbHVlSW5o ZXJpdCk7CisgICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlX ZWJraXRVc2VyTW9kaWZ5LCBmYWxzZSk7CiAgICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJv cGVydHkoQ1NTUHJvcGVydHlXb3JkV3JhcCwgZmFsc2UpOwogICAgICAgICBhdHRyLT5kZWNsKCkt PnJlbW92ZVByb3BlcnR5KENTU1Byb3BlcnR5V2Via2l0TmJzcE1vZGUsIGZhbHNlKTsKICAgICAg ICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdExpbmVCcmVh aywgZmFsc2UpOwpJbmRleDogU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0 eWxlQ29uc3RhbnRzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N0 eWxlL1JlbmRlclN0eWxlQ29uc3RhbnRzLmgJKHJldmlzaW9uIDgzMDQwKQorKysgU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlQ29uc3RhbnRzLmgJKHdvcmtpbmcgY29w eSkKQEAgLTE2Niw3ICsxNjYsNyBAQCBlbnVtIEVUZXh0U2VjdXJpdHkgewogLy8gQ1NTMyBVc2Vy IE1vZGlmeSBQcm9wZXJ0aWVzCiAKIGVudW0gRVVzZXJNb2RpZnkgewotICAgIFJFQURfT05MWSwg UkVBRF9XUklURSwgUkVBRF9XUklURV9QTEFJTlRFWFRfT05MWQorICAgIFJFQURfT05MWSwgUkVB RF9XUklURSwgUkVBRF9XUklURV9QTEFJTlRFWFRfT05MWSwgSU5IRVJJVAogfTsKIAogLy8gQ1NT MyBVc2VyIERyYWcgVmFsdWVzCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUv U3R5bGVSYXJlSW5oZXJpdGVkRGF0YS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL3N0eWxlL1N0eWxlUmFyZUluaGVyaXRlZERhdGEuY3BwCShyZXZpc2lvbiA4MzA0 MCkKKysrIFNvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9TdHlsZVJhcmVJbmhlcml0ZWRE YXRhLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzgsNyArMzgsNyBAQCBTdHlsZVJhcmVJbmhlcml0 ZWREYXRhOjpTdHlsZVJhcmVJbmhlcml0CiAgICAgLCB3aWRvd3MoUmVuZGVyU3R5bGU6OmluaXRp YWxXaWRvd3MoKSkKICAgICAsIG9ycGhhbnMoUmVuZGVyU3R5bGU6OmluaXRpYWxPcnBoYW5zKCkp CiAgICAgLCB0ZXh0U2VjdXJpdHkoUmVuZGVyU3R5bGU6OmluaXRpYWxUZXh0U2VjdXJpdHkoKSkK LSAgICAsIHVzZXJNb2RpZnkoUkVBRF9PTkxZKQorICAgICwgdXNlck1vZGlmeShJTkhFUklUKQog ICAgICwgd29yZEJyZWFrKFJlbmRlclN0eWxlOjppbml0aWFsV29yZEJyZWFrKCkpCiAgICAgLCB3 b3JkV3JhcChSZW5kZXJTdHlsZTo6aW5pdGlhbFdvcmRXcmFwKCkpCiAgICAgLCBuYnNwTW9kZShO Qk5PUk1BTCkKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzMTY5KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDQtMDcgIENoYW5nIFNo dSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGZvciBjaGVja2luZyBpc0NvbnRlbnRFZGl0 YWJsZSB3aXRoIGRlc2lnbk1vZGUuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD01MzAzMQorCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtZXhwZWN0ZWQudHh0OiBBZGRl ZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M RWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0 YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFi bGUtZGVzaWdubW9kZW9uLmh0bWw6IEFkZGVkLgorCiAyMDExLTA0LTA3ICBLZW50IFRhbXVyYSAg PHRrZW50QGNocm9taXVtLm9yZz4KIAogICAgICAgICBbQ2hyb21pdW1dIE1vdmUgTGVvcGFyZC1z cGVjaWZpYyBpbWFnZXMgdG8gY2hyb21pdW0tbWFjLWxlb3BhcmQsIGFuZApJbmRleDogTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9u LWFsbGluaGVyaXQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0 LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxF bGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNCBAQAorQ29udGVudCBzaG91bGQgYmUgZWRp dGFibGUgaWYgaXRzIGFuZCBpdHMgYW5jZXN0b3IncyBjb250ZW50RWRpdGFibGUgbm90IHNldCwg YW5kIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZC4KKworT24gc3VjY2VzcywgeW91IHdp bGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09N UExFVEUiLgorCisKKworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1MgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIK K1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlIGlz IHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlW YWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorUEFTUyBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQ QVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Vi a2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFy c2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5o ZXJpdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM3 IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hl ZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVh ZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48 L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX2RpdiI+Cisg ICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX3AiPgor ICAgIDxwIGlkPSJwIj48L3A+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignQ29udGVu dCBzaG91bGQgYmUgZWRpdGFibGUgaWYgaXRzIGFuZCBpdHMgYW5jZXN0b3JcJ3MgY29udGVudEVk aXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuJykKKwor ZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUoJ2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQi Jyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVk aXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3Jp dGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRF ZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0 Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlm eSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50 X29mX2RpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwYXJlbnRfb2ZfcCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nlc3Nm dWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNv dXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6 IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2ln bm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2Vz dG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3Rl ZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzIgQEAKK2lzQ29udGVudEVkaXRhYmxlIHNo b3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQs IG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3Qu CisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMs IGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKKworCitkb2N1bWVudC5k ZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29u dGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVk U3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlz ICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29udGVu dEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 MiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMg InJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRp dGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXND b250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAi IikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRl IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUgaXMg ImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVk aXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIsICIiKS5nZXRQ cm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3Iu aHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lz Y29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDU2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNz cyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3Nj cmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlk PSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0icGFyZW50 X29mX2RpdiIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+CisgICAgPGRpdiBpZD0iZGl2Ij48L2Rp dj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX2RpdjIiPgorICAgIDxkaXYgaWQ9ImRpdjIi PjwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2ZfcCIgY29udGVudEVkaXRhYmxlPSJ0 cnVlIj4KKyAgICA8cCBpZD0icCI+PC9wPgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2ZfcDIi PgorICAgIDxwIGlkPSJwMiI+PC9wPgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ2lz Q29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvclwncyBjb250 ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2Rl IGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRf b2ZfZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSA9IGZhbHNlOworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInBhcmVudF9vZl9wMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2YWxBbmRMb2co J2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxk QmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdm YWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFBy b3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOworCitz aG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFibGUn LCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIi KS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21w dXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxk QmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Vi a2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7Citz aG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFibGUn LCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAyLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOwor Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX2RpdiIpLnN0eWxlLmRpc3BsYXk9 ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfZGl2MiIpLnN0eWxl LmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfcCIp LnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRf b2ZfcDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNzZnVsbHlQYXJz ZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pz LXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM2IEBA Citpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgY29udGVudEVkaXRh YmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFi bGVkIG9yIG5vdC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNT IiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKKworCisKKworCisK K2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJmYWxzZSIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiZmFsc2Ui CitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBp cyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0 eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIp IGlzICJmYWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250ZW50 RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIp LmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxl KGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJl YWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRBdHRyaWJ1dGUo ImNvbnRlbnRFZGl0YWJsZSIpIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21w dXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikg aXMgInJlYWQtd3JpdGUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmdldEF0 dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgInRydWUiCitQQVNTIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5k b3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNl ci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxl LWRlc2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsNTIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxs aW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5 bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMi Pjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8ZGl2IGlkPSJk aXYiIGNvbnRlbnRFZGl0YWJsZT0iZmFsc2UiPjwvZGl2PgorPGRpdiBpZD0iZGl2MiI+PC9kaXY+ Cis8cCBpZD0icCIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj48L3A+Cis8cCBpZD0icDIiPjwvcD4K KzxzY3JpcHQ+CitkZXNjcmlwdGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFu Z2UgaWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3Vt ZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuJykKKworZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFibGUgPSBmYWxzZTsKK2RvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2YWxBbmRMb2coJ2RvY3Vt ZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSInKTsK K3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxl JywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iiku aXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0 ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikn LCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJk aXYyIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSInKTsKK3Nob3Vs ZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0YWJsZScsICci ZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5pc0Nv bnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAn InJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIiku Z2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVlIicpOworc2hvdWxkQmUoJ2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicpOwor c2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUn LCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQ cm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisK K3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5nZXRBdHRyaWJ1dGUoImNv bnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicpOworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3No b3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUo Ii13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNzZnVsbHlQ YXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 89262 2011-04-12 13:34:06 -0700 2011-04-20 11:50:05 -0700 new patch #2 53031_7.patch text/plain 20699 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzNjI3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTEtMDQtMTIgIENoYW5nIFNo dSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3 aXRoIGRvY3VtZW50LmRlc2lnbk1vZGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6 Ly9kZXYudzMub3JnL2h0bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJs ZSkKKyAgICAgICAgaW5kaWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUg cmVsaWVzIG9uIGRvY3VtZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5j ZXN0b3JzJyBjb250ZW50ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisK KyAgICAgICAgU3luYyBkb2N1bWVudCByZW5kZXIgc3R5bGUgYWZ0ZXIgZG9jdW1lbnQuZGVzaWdu TW9kZSBpcyBjaGFuZ2VkLgorICAgICAgICBBbHNvIHJlbW92ZWQgdGhlIGNvZGUgdGhhdCBkb2Vz IHVubmVjZXNzYXJ5IGFuZCBpbmNvcnJlY3QgaGFuZGxpbmcgZm9yIGNvbnRlbnRlZGl0YWJsZQor ICAgICAgICBhdHRyaWJ1dGUgd2l0aCAiaW5oZXJpdCIgdmFsdWUuCisKKyAgICAgICAgVGVzdHM6 IGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxp bmhlcml0Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVu dGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCisgICAgICAgICAgICAgICBmYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAorCisg ICAgICAgICogY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q1NT U3R5bGVTZWxlY3Rvcjo6c3R5bGVGb3JEb2N1bWVudCk6CisgICAgICAgICogZG9tL0RvY3VtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpzZXREZXNpZ25Nb2RlKToKKyAgICAg ICAgKiBkb20vTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb2RlOjpyZW5kZXJlcklzRWRp dGFibGUpOgorICAgICAgICAqIGh0bWwvSFRNTEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTEVsZW1lbnQ6OnNldENvbnRlbnRFZGl0YWJsZSk6CisKIDIwMTEtMDQtMTIgIFJ5b3N1 a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBT ZWlkZWwuCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwCShyZXZp c2lvbiA4MzM5NikKKysrIFNvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMTI2NCw3ICsxMjY0LDEyIEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5 bGU+IENTU1N0eWxlU2VsZWN0b3IKICAgICBkb2N1bWVudFN0eWxlLT5zZXRWaXN1YWxseU9yZGVy ZWQoZG9jdW1lbnQtPnZpc3VhbGx5T3JkZXJlZCgpKTsKICAgICBkb2N1bWVudFN0eWxlLT5zZXRa b29tKGZyYW1lID8gZnJhbWUtPnBhZ2Vab29tRmFjdG9yKCkgOiAxKTsKICAgICBkb2N1bWVudFN0 eWxlLT5zZXRQYWdlU2NhbGVUcmFuc2Zvcm0oZnJhbWUgPyBmcmFtZS0+cGFnZVNjYWxlRmFjdG9y KCkgOiAxKTsKLSAgICAKKworICAgIGlmIChkb2N1bWVudC0+aW5EZXNpZ25Nb2RlKCkgJiYgZG9j dW1lbnRTdHlsZS0+dXNlck1vZGlmeSgpICE9IFJFQURfV1JJVEUpCisgICAgICAgIGRvY3VtZW50 U3R5bGUtPnNldFVzZXJNb2RpZnkoUkVBRF9XUklURSk7CisgICAgZWxzZSBpZiAoIWRvY3VtZW50 LT5pbkRlc2lnbk1vZGUoKSAmJiBkb2N1bWVudFN0eWxlLT51c2VyTW9kaWZ5KCkgIT0gUkVBRF9P TkxZKQorICAgICAgICBkb2N1bWVudFN0eWxlLT5zZXRVc2VyTW9kaWZ5KFJFQURfT05MWSk7CisK ICAgICBFbGVtZW50KiBkb2NFbGVtZW50ID0gZG9jdW1lbnQtPmRvY3VtZW50RWxlbWVudCgpOwog ICAgIFJlbmRlck9iamVjdCogZG9jRWxlbWVudFJlbmRlcmVyID0gZG9jRWxlbWVudCA/IGRvY0Vs ZW1lbnQtPnJlbmRlcmVyKCkgOiAwOwogICAgIGlmIChkb2NFbGVtZW50UmVuZGVyZXIpIHsKSW5k ZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAkocmV2aXNpb24gODMzOTYpCisrKyBTb3VyY2UvV2Vi Q29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MDY1LDYgKzQwNjUsNyBA QCB2b2lkIERvY3VtZW50OjpzZXRUcmFuc2Zvcm1Tb3VyY2UoUGFzc093CiB2b2lkIERvY3VtZW50 OjpzZXREZXNpZ25Nb2RlKEluaGVyaXRlZEJvb2wgdmFsdWUpCiB7CiAgICAgbV9kZXNpZ25Nb2Rl ID0gdmFsdWU7CisgICAgc2NoZWR1bGVGb3JjZWRTdHlsZVJlY2FsYygpOwogfQogCiBEb2N1bWVu dDo6SW5oZXJpdGVkQm9vbCBEb2N1bWVudDo6Z2V0RGVzaWduTW9kZSgpIGNvbnN0CkluZGV4OiBT b3VyY2UvV2ViQ29yZS9kb20vTm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv ZG9tL05vZGUuY3BwCShyZXZpc2lvbiA4MzM5NikKKysrIFNvdXJjZS9XZWJDb3JlL2RvbS9Ob2Rl LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNzY5LDcgKzc2OSw3IEBAIGJvb2wgTm9kZTo6aXNDb250 ZW50RWRpdGFibGUoKSBjb25zdAogCiBib29sIE5vZGU6OnJlbmRlcmVySXNFZGl0YWJsZShFZGl0 YWJsZUxldmVsIGVkaXRhYmxlTGV2ZWwpIGNvbnN0CiB7Ci0gICAgaWYgKGRvY3VtZW50KCktPmlu RGVzaWduTW9kZSgpIHx8IChkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50KCktPmZyYW1l KCktPnBhZ2UoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5wYWdlKCktPmlzRWRpdGFibGUoKSkp CisgICAgaWYgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+cGFn ZSgpICYmIGRvY3VtZW50KCktPmZyYW1lKCktPnBhZ2UoKS0+aXNFZGl0YWJsZSgpKQogICAgICAg ICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIElkZWFsbHkgd2UnZCBjYWxsIEFTU0VSVCghbmVlZHNT dHlsZVJlY2FsYygpKSBoZXJlLCBidXQKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVs ZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQu Y3BwCShyZXZpc2lvbiA4MzM5NikKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC02ODIsMTEgKzY4Miw2IEBAIHZvaWQgSFRNTEVsZW1lbnQ6 OnNldENvbnRlbnRFZGl0YWJsZShBdHQKICAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9w ZXJ0eShDU1NQcm9wZXJ0eVdvcmRXcmFwLCBmYWxzZSk7CiAgICAgICAgIGF0dHItPmRlY2woKS0+ cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJraXROYnNwTW9kZSwgZmFsc2UpOwogICAgICAg ICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3BlcnR5V2Via2l0TGluZUJyZWFr LCBmYWxzZSk7Ci0gICAgfSBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZShlbmFibGVkLCAiaW5o ZXJpdCIpKSB7Ci0gICAgICAgIGFkZENTU1Byb3BlcnR5KGF0dHIsIENTU1Byb3BlcnR5V2Via2l0 VXNlck1vZGlmeSwgQ1NTVmFsdWVJbmhlcml0KTsKLSAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1v dmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdvcmRXcmFwLCBmYWxzZSk7Ci0gICAgICAgIGF0dHItPmRl Y2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJraXROYnNwTW9kZSwgZmFsc2UpOwot ICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3BlcnR5V2Via2l0TGlu ZUJyZWFrLCBmYWxzZSk7CiAgICAgfSBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZShlbmFibGVk LCAicGxhaW50ZXh0LW9ubHkiKSkgewogICAgICAgICBhZGRDU1NQcm9wZXJ0eShhdHRyLCBDU1NQ cm9wZXJ0eVdlYmtpdFVzZXJNb2RpZnksIENTU1ZhbHVlUmVhZFdyaXRlUGxhaW50ZXh0T25seSk7 CiAgICAgICAgIGFkZENTU1Byb3BlcnR5KGF0dHIsIENTU1Byb3BlcnR5V29yZFdyYXAsIENTU1Zh bHVlQnJlYWtXb3JkKTsKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzNjI3KQorKysgTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDQtMTIgIENo YW5nIFNodSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGZvciBjaGVja2luZyBpc0NvbnRl bnRFZGl0YWJsZSB3aXRoIGRlc2lnbk1vZGUuIEFsc28gYWRkZWQKKyAgICAgICAgYSBuZXcgdGVz dCBjYXNlIGZvciBzZXR0aW5nIGNvbnRlbnRlZGl0YWJsZSBhdHRyaWJ1dGUgdG8gImluaGVyaXQi IGFzIHRoZQorICAgICAgICBvcmlnaW5hbCBjb2RlIHdpbGwgY2F1c2UgYSBjcmFzaC4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAg ICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4cGVjdGVkLnR4 dDoKKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLmh0 bWw6CisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVz aWdubW9kZW9uLWFsbGluaGVyaXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJp dC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRl ZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YW5jZXN0b3IuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNj b250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0 bWw6IEFkZGVkLgorCiAyMDExLTA0LTExICBBYmhpc2hlayBBcnlhICA8aW5mZXJub0BjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4KSW5kZXg6IExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJpbmctZXhwZWN0ZWQudHh0 Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52 YWxpZC1zdHJpbmctZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA4MzM5NikKKysrIExheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJpbmctZXhwZWN0ZWQudHh0CSh3 b3JraW5nIGNvcHkpCkBAIC02LDEwICs2LDE1IEBAIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBh IHNlcmllcyBvZiAiUEEKIAogCiAKLVBBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIp LmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgImFiYyIKLVBBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKLVBBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNl Ci1QQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUo Ii13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorCitQQVNTIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAiYWJj IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAi aW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5pc0NvbnRlbnRFZGl0 YWJsZSBpcyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkLCAiIikuZ2V0UHJv cGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxl IikgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmNvbnRl bnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQy IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5 bGUoZDIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJl YWQtb25seSIKIAogUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQogCkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLmh0bWwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvYXR0ci1pbnZhbGlk LXN0cmluZy5odG1sCShyZXZpc2lvbiA4MzM5NikKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJpbmcuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtOCwx NiArOCwyMyBAQAogPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+CiA8ZGl2IGlkPSJjb25zb2xlIj48 L3A+CiA8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgotPGRpdiBpZD0iZGl2IiBjb250ZW50RWRpdGFi bGU9ImFiYyI+PC9kaXY+Cis8ZGl2IGlkPSJkIiBjb250ZW50RWRpdGFibGU9ImFiYyI+PC9kaXY+ Cis8ZGl2IGlkPSJkMiIgY29udGVudEVkaXRhYmxlPSJpbmhlcml0Ij48L2Rpdj4KIDxzY3JpcHQ+ CiBkZXNjcmlwdGlvbignV2hlbiBjb250ZW50RWRpdGFibGUgYXR0cmlidXRlIGlzIGludmFsaWQg c3RyaW5nLCBlbGVtZW50LmNvbnRlbnRFZGl0YWJsZSByZXR1cm5zICJpbmhlcml0Ii4nKQogCi1z aG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmdldEF0dHJpYnV0ZSgiY29u dGVudEVkaXRhYmxlIiknLCciYWJjIicpOwotc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7Ci1zaG91bGRCZSgnZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7 Ci1zaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlW YWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CitzaG91bGRCZSgn ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJs ZSIpJywnImFiYyInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZCIpLmNv bnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiZCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2lu ZG93LmdldENvbXB1dGVkU3R5bGUoZCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNl ci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOwogCi1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2Iikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkMiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIiknLCciaW5oZXJpdCIn KTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5jb250ZW50RWRpdGFi bGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQy IikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29t cHV0ZWRTdHlsZShkMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnki KScsICcicmVhZC1vbmx5IicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZCIpLnN0eWxl LmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLnN0eWxlLmRp c3BsYXk9ICdub25lJzsKIAogd2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CiA8L3Nj cmlwdD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVk aXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YWxsaW5oZXJpdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQgQEAKK0Nv bnRlbnQgc2hvdWxkIGJlIGVkaXRhYmxlIGlmIGl0cyBhbmQgaXRzIGFuY2VzdG9yJ3MgY29udGVu dEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuCisK K09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZv bGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKK2RvY3VtZW50LmRlc2lnbk1v ZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRp dGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5p c0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRp diwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13 cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUg aXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50 RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorCitQ QVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKworCisKKwpJ bmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUt ZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5o ZXJpdC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSwzNyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgor PGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5q cyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgor PGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxkaXYgaWQ9 InBhcmVudF9vZl9kaXYiPgorICAgIDxkaXYgaWQ9ImRpdiI+PC9kaXY+Cis8L2Rpdj4KKzxkaXYg aWQ9InBhcmVudF9vZl9wIj4KKyAgICA8cCBpZD0icCI+PC9wPgorPC9kaXY+Cis8c2NyaXB0Pgor ZGVzY3JpcHRpb24oJ0NvbnRlbnQgc2hvdWxkIGJlIGVkaXRhYmxlIGlmIGl0cyBhbmQgaXRzIGFu Y2VzdG9yXCdzIGNvbnRlbnRFZGl0YWJsZSBub3Qgc2V0LCBhbmQgZG9jdW1lbnQuZGVzaWduTW9k ZSBpcyBlbmFibGVkLicpCisKK2V2YWxBbmRMb2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24i Jyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVk aXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93Lmdl dENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1v ZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZScsICd0cnVlJyk7Citz aG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUo Ii13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInBhcmVudF9vZl9kaXYiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX3AiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7 CisKK3dpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2Jv ZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2Nv bnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxl LWRlc2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMyIEBACitp c0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgYW5jZXN0b3IncyBjb250 ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2Rl IGlzIGVuYWJsZWQgb3Igbm90LgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisK KworCisKKworZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNT IHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJr aXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiaW5oZXJpdCIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdjIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBmYWxzZQorUEFTUyB3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtp dC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93Lmdl dENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2Rp ZnkiKSBpcyAicmVhZC13cml0ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIiku Y29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicDIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRl ZFN0eWxlKHAyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlz ICJyZWFkLXdyaXRlIgorCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1Qg Q09NUExFVEUKKworCisKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQv aXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWwKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVz aWdubW9kZW9uLWFuY2VzdG9yLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3Iu aHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1NiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRt bD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9q cy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlw dGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9wPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rp dj4KKzxkaXYgaWQ9InBhcmVudF9vZl9kaXYiIGNvbnRlbnRFZGl0YWJsZT0iZmFsc2UiPgorICAg IDxkaXYgaWQ9ImRpdiI+PC9kaXY+Cis8L2Rpdj4KKzxkaXYgaWQ9InBhcmVudF9vZl9kaXYyIj4K KyAgICA8ZGl2IGlkPSJkaXYyIj48L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX3Ai IGNvbnRlbnRFZGl0YWJsZT0idHJ1ZSI+CisgICAgPHAgaWQ9InAiPjwvcD4KKzwvZGl2PgorPGRp diBpZD0icGFyZW50X29mX3AyIj4KKyAgICA8cCBpZD0icDIiPjwvcD4KKzwvZGl2PgorPHNjcmlw dD4KK2Rlc2NyaXB0aW9uKCdpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBp dHMgYW5jZXN0b3JcJ3MgY29udGVudEVkaXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIg ZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkIG9yIG5vdC4nKQorCitkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFyZW50X29mX2RpdjIiKS5jb250ZW50RWRpdGFibGUgPSBmYWxzZTsKK2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfcDIiKS5jb250ZW50RWRpdGFibGUgPSB0 cnVlOworCitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIicpOworCitzaG91 bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZScsICci aW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXND b250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAn InJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYy IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3Vs ZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgi LXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3VsZEJlKCdkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsK K3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxl JywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOwor CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxl JywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIp LmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0 ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScs ICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhcmVudF9vZl9k aXYiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFy ZW50X29mX2RpdjIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicGFyZW50X29mX3AiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFyZW50X29mX3AyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3aW5k b3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9o dG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSwzNiBAQAoraXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBjaGFuZ2Ug aWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50 LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRF Ii4KKworCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUi KSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50 RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iiku aXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUo ZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFk LW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuZ2V0QXR0cmlidXRl KCJjb250ZW50RWRpdGFibGUiKSBpcyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYyIikuY29udGVudEVkaXRhYmxlIGlzICJmYWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImRpdjIiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBmYWxzZQorUEFTUyB3aW5k b3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11 c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKSBpcyAidHJ1ZSIKK1BBU1MgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50RWRpdGFibGUgaXMgInRydWUiCitQQVNT IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQor UEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdl YmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdyaXRlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgicDIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJ0cnVlIgor UEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUgaXMgInRy dWUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVkaXRhYmxl IGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIsICIiKS5nZXRQcm9wZXJ0 eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKworCkluZGV4OiBM YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25t b2Rlb24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVu dC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAkocmV2aXNpb24gMCkKKysrIExh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1v ZGVvbi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDUyIEBACis8IURPQ1RZUEUgaHRtbD4K KzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRl c2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQi PjwvZGl2PgorPGRpdiBpZD0iZGl2IiBjb250ZW50RWRpdGFibGU9ImZhbHNlIj48L2Rpdj4KKzxk aXYgaWQ9ImRpdjIiPjwvZGl2PgorPHAgaWQ9InAiIGNvbnRlbnRFZGl0YWJsZT0idHJ1ZSI+PC9w PgorPHAgaWQ9InAyIj48L3A+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ2lzQ29udGVudEVkaXRh YmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBt YXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisK K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29udGVudEVkaXRhYmxlID0gZmFsc2U7 Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUgPSB0cnVlOwor CitldmFsQW5kTG9nKCdkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIicpOworCitzaG91bGRCZSgn ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRh YmxlIiknLCciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp diIpLmNvbnRlbnRFZGl0YWJsZScsICciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRC ZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdl YmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikn LCciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5j b250ZW50RWRpdGFibGUnLCAnImZhbHNlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYyIikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYyLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtp dC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLW9ubHkiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicCIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIiknLCcidHJ1 ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0 YWJsZScsICcidHJ1ZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIp LmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0 ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywg JyJyZWFkLXdyaXRlIicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAy IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVlIicpOworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZScsICcidHJ1ZSIn KTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5pc0NvbnRlbnRFZGl0 YWJsZScsICd0cnVlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIsICIi KS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUi Jyk7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5zdHlsZS5kaXNwbGF5PSAnbm9u ZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLnN0eWxlLmRpc3BsYXk9ICdub25l JzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOwor ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworCit3 aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9 Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgo= 90374 2011-04-20 11:50:05 -0700 2011-04-20 16:49:08 -0700 fix patch: WIP 53031_8.patch text/plain 23191 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDg0Mjk3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTEtMDQtMTkgIENoYW5nIFNo dSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3 aXRoIGRvY3VtZW50LmRlc2lnbk1vZGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6 Ly9kZXYudzMub3JnL2h0bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJs ZSkKKyAgICAgICAgaW5kaWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUg cmVsaWVzIG9uIGRvY3VtZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5j ZXN0b3JzJyBjb250ZW50ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisK KyAgICAgICAgU3luYyBkb2N1bWVudCByZW5kZXIgc3R5bGUgYWZ0ZXIgZG9jdW1lbnQuZGVzaWdu TW9kZSBpcyBjaGFuZ2VkLgorICAgICAgICBBbHNvIHJlbW92ZWQgdGhlIGNvZGUgdGhhdCBkb2Vz IHVubmVjZXNzYXJ5IGFuZCBpbmNvcnJlY3QgaGFuZGxpbmcgZm9yIGNvbnRlbnRlZGl0YWJsZQor ICAgICAgICBhdHRyaWJ1dGUgd2l0aCAiaW5oZXJpdCIgdmFsdWUuCisKKyAgICAgICAgVGVzdHM6 IGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxp bmhlcml0LXN1YmZyYW1lLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVv bi1hbmNlc3Rvci5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2Nv bnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24uaHRtbAorCisgICAgICAgICogY3NzL0NTU1N0eWxl U2VsZWN0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q1NTU3R5bGVTZWxlY3Rvcjo6c3R5bGVG b3JEb2N1bWVudCk6CisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkRvY3VtZW50OjpzZXREZXNpZ25Nb2RlKToKKyAgICAgICAgKiBkb20vTm9kZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpOb2RlOjpyZW5kZXJlcklzRWRpdGFibGUpOgorICAgICAgICAqIGh0 bWwvSFRNTEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEVsZW1lbnQ6OnNldENv bnRlbnRFZGl0YWJsZSk6CisKIDIwMTEtMDQtMTkgIEJldGggRGFraW4gIDxiZGFraW5AYXBwbGUu Y29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hY2llaiBTdGFjaG93aWFrLgpJbmRleDogU291 cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNwcAkocmV2aXNpb24gODQyOTcpCisrKyBT b3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTExOTQsNyArMTE5NCw5IEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IENTU1N0eWxlU2VsZWN0 b3IKICAgICBkb2N1bWVudFN0eWxlLT5zZXRWaXN1YWxseU9yZGVyZWQoZG9jdW1lbnQtPnZpc3Vh bGx5T3JkZXJlZCgpKTsKICAgICBkb2N1bWVudFN0eWxlLT5zZXRab29tKGZyYW1lID8gZnJhbWUt PnBhZ2Vab29tRmFjdG9yKCkgOiAxKTsKICAgICBkb2N1bWVudFN0eWxlLT5zZXRQYWdlU2NhbGVU cmFuc2Zvcm0oZnJhbWUgPyBmcmFtZS0+cGFnZVNjYWxlRmFjdG9yKCkgOiAxKTsKLSAgICAKKwor ICAgIGRvY3VtZW50U3R5bGUtPnNldFVzZXJNb2RpZnkoZG9jdW1lbnQtPmluRGVzaWduTW9kZSgp ID8gUkVBRF9XUklURSA6IFJFQURfT05MWSk7CisKICAgICBFbGVtZW50KiBkb2NFbGVtZW50ID0g ZG9jdW1lbnQtPmRvY3VtZW50RWxlbWVudCgpOwogICAgIFJlbmRlck9iamVjdCogZG9jRWxlbWVu dFJlbmRlcmVyID0gZG9jRWxlbWVudCA/IGRvY0VsZW1lbnQtPnJlbmRlcmVyKCkgOiAwOwogICAg IGlmIChkb2NFbGVtZW50UmVuZGVyZXIpIHsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAko cmV2aXNpb24gODQyOTcpCisrKyBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC00MDM0LDYgKzQwMzQsMTIgQEAgdm9pZCBEb2N1bWVudDo6c2V0VHJhbnNm b3JtU291cmNlKFBhc3NPdwogdm9pZCBEb2N1bWVudDo6c2V0RGVzaWduTW9kZShJbmhlcml0ZWRC b29sIHZhbHVlKQogewogICAgIG1fZGVzaWduTW9kZSA9IHZhbHVlOworLy8gICAgZm9yIChGcmFt ZSogZnJhbWUgPSBtX2ZyYW1lOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJz ZU5leHQobV9mcmFtZSkpCisvLyAgICAgICAgaWYgKGZyYW1lLT5kb2N1bWVudCgpKQorLy8gICAg ICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+cmVjYWxjU3R5bGUoRm9yY2UpOworLy8gICAgICAg ICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+c2NoZWR1bGVGb3JjZWRTdHlsZVJlY2FsYygpOworICAg IHNjaGVkdWxlRm9yY2VkU3R5bGVSZWNhbGMoKTsKK3ByaW50Zigic2V0RGVzaWduTW9kZVxuIik7 CiB9CiAKIERvY3VtZW50OjpJbmhlcml0ZWRCb29sIERvY3VtZW50OjpnZXREZXNpZ25Nb2RlKCkg Y29uc3QKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViQ29yZS9kb20vTm9kZS5jcHAJKHJldmlzaW9uIDg0Mjk3KQorKysgU291cmNlL1dl YkNvcmUvZG9tL05vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NjUsNyArNzY1LDcgQEAgYm9v bCBOb2RlOjppc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0CiAKIGJvb2wgTm9kZTo6cmVuZGVyZXJJ c0VkaXRhYmxlKEVkaXRhYmxlTGV2ZWwgZWRpdGFibGVMZXZlbCkgY29uc3QKIHsKLSAgICBpZiAo ZG9jdW1lbnQoKS0+aW5EZXNpZ25Nb2RlKCkgfHwgKGRvY3VtZW50KCktPmZyYW1lKCkgJiYgZG9j dW1lbnQoKS0+ZnJhbWUoKS0+cGFnZSgpICYmIGRvY3VtZW50KCktPmZyYW1lKCktPnBhZ2UoKS0+ aXNFZGl0YWJsZSgpKSkKKyAgICBpZiAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgp LT5mcmFtZSgpLT5wYWdlKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+cGFnZSgpLT5pc0VkaXRh YmxlKCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gSWRlYWxseSB3ZSdkIGNhbGwg QVNTRVJUKCFuZWVkc1N0eWxlUmVjYWxjKCkpIGhlcmUsIGJ1dApJbmRleDogU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MRWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRWxlbWVudC5jcHAJKHJldmlzaW9uIDg0Mjk3KQorKysgU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY4MiwxMSArNjgyLDYgQEAgdm9p ZCBIVE1MRWxlbWVudDo6c2V0Q29udGVudEVkaXRhYmxlKEF0dAogICAgICAgICBhdHRyLT5kZWNs KCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3BlcnR5V29yZFdyYXAsIGZhbHNlKTsKICAgICAgICAg YXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdE5ic3BNb2RlLCBm YWxzZSk7CiAgICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlX ZWJraXRMaW5lQnJlYWssIGZhbHNlKTsKLSAgICB9IGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNl KGVuYWJsZWQsICJpbmhlcml0IikpIHsKLSAgICAgICAgYWRkQ1NTUHJvcGVydHkoYXR0ciwgQ1NT UHJvcGVydHlXZWJraXRVc2VyTW9kaWZ5LCBDU1NWYWx1ZUluaGVyaXQpOwotICAgICAgICBhdHRy LT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3BlcnR5V29yZFdyYXAsIGZhbHNlKTsKLSAg ICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdE5ic3BN b2RlLCBmYWxzZSk7Ci0gICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJv cGVydHlXZWJraXRMaW5lQnJlYWssIGZhbHNlKTsKICAgICB9IGVsc2UgaWYgKGVxdWFsSWdub3Jp bmdDYXNlKGVuYWJsZWQsICJwbGFpbnRleHQtb25seSIpKSB7CiAgICAgICAgIGFkZENTU1Byb3Bl cnR5KGF0dHIsIENTU1Byb3BlcnR5V2Via2l0VXNlck1vZGlmeSwgQ1NTVmFsdWVSZWFkV3JpdGVQ bGFpbnRleHRPbmx5KTsKICAgICAgICAgYWRkQ1NTUHJvcGVydHkoYXR0ciwgQ1NTUHJvcGVydHlX b3JkV3JhcCwgQ1NTVmFsdWVCcmVha1dvcmQpOwpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gODQyOTcpCisr KyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyMyBAQAor MjAxMS0wNC0xOSAgQ2hhbmcgU2h1ICA8Y3NodUB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHRlc3QgY2FzZXMgZm9yIGNo ZWNraW5nIGlzQ29udGVudEVkaXRhYmxlIHdpdGggZGVzaWduTW9kZS4gQWxzbyBhZGRlZAorICAg ICAgICBhIG5ldyB0ZXN0IGNhc2UgZm9yIHNldHRpbmcgY29udGVudGVkaXRhYmxlIGF0dHJpYnV0 ZSB0byAiaW5oZXJpdCIgYXMgdGhlCisgICAgICAgIG9yaWdpbmFsIGNvZGUgd2lsbCBjYXVzZSBh IGNyYXNoLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NTMwMzEKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJp bmctZXhwZWN0ZWQudHh0OgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52 YWxpZC1zdHJpbmcuaHRtbDoKKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1v ZGVvbi1hbGxpbmhlcml0LXN1YmZyYW1lLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICog ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGlu aGVyaXQtc3ViZnJhbWUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1l bnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbDogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdu bW9kZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20v SFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxl LWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sOiBBZGRlZC4KKwog MjAxMS0wNC0xOSAgQmV0aCBEYWtpbiAgPGJkYWtpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgTWFjaWVqIFN0YWNob3dpYWsuCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4 cGVjdGVkLnR4dAkocmV2aXNpb24gODQyOTcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M RWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpA QCAtNiwxMCArNiwxNSBAQCBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB CiAKIAogCi1QQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUo ImNvbnRlbnRFZGl0YWJsZSIpIGlzICJhYmMiCi1QQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCi1QQVNTIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBmYWxzZQotUEFTUyB3aW5kb3cu Z2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXIt bW9kaWZ5IikgaXMgInJlYWQtb25seSIKKworUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZCIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgImFiYyIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNT IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkIikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UK K1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUoZCwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13 ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiZDIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJpbmhlcml0 IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5jb250ZW50RWRpdGFibGUgaXMg ImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmlzQ29udGVudEVk aXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGQyLCAiIikuZ2V0 UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHkiCiAKIFBB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIApJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTEVsZW1lbnQvYXR0ci1pbnZhbGlkLXN0cmluZy5odG1sCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJpbmcuaHRtbAko cmV2aXNpb24gODQyOTcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRy LWludmFsaWQtc3RyaW5nLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTgsMTYgKzgsMjMgQEAKIDxw IGlkPSJkZXNjcmlwdGlvbiI+PC9wPgogPGRpdiBpZD0iY29uc29sZSI+PC9wPgogPGRpdiBpZD0i cmVzdWx0Ij48L2Rpdj4KLTxkaXYgaWQ9ImRpdiIgY29udGVudEVkaXRhYmxlPSJhYmMiPjwvZGl2 PgorPGRpdiBpZD0iZCIgY29udGVudEVkaXRhYmxlPSJhYmMiPjwvZGl2PgorPGRpdiBpZD0iZDIi IGNvbnRlbnRFZGl0YWJsZT0iaW5oZXJpdCI+PC9kaXY+CiA8c2NyaXB0PgogZGVzY3JpcHRpb24o J1doZW4gY29udGVudEVkaXRhYmxlIGF0dHJpYnV0ZSBpcyBpbnZhbGlkIHN0cmluZywgZWxlbWVu dC5jb250ZW50RWRpdGFibGUgcmV0dXJucyAiaW5oZXJpdCIuJykKIAotc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIp JywnImFiYyInKTsKLXNob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29u dGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOwotc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOwotc2hvdWxkQmUoJ3dp bmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQt dXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJhYmMiJyk7 CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5jb250ZW50RWRpdGFibGUn LCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5p c0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRl ZFN0eWxlKGQsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAn InJlYWQtb25seSInKTsKIAotZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRp c3BsYXk9ICdub25lJzsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5n ZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImluaGVyaXQiJyk7CitzaG91bGRCZSgn ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQyIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0 IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmlzQ29udGVudEVk aXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5bGUoZDIs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtb25s eSInKTsKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5zdHlsZS5kaXNwbGF5PSAnbm9u ZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7 CiAKIHdpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwogPC9zY3JpcHQ+CkluZGV4OiBM YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25t b2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGlu aGVyaXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI0IEBACitDb250ZW50IHNob3VsZCBi ZSBlZGl0YWJsZSBpZiBpdHMgYW5kIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJsZSBub3Qg c2V0LCBhbmQgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkLgorCitPbiBzdWNjZXNzLCB5 b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVT VCBDT01QTEVURSIuCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgorUEFT UyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlIGlzICJpbmhl cml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFi bGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9w ZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCitQQVNTIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0Igor UEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlIGlzIHRy dWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5VmFsdWUo Ii13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNzZnVs bHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1h bGxpbmhlcml0LXN1YmZyYW1lLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxs aW5oZXJpdC1zdWJmcmFtZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxs aW5oZXJpdC1zdWJmcmFtZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTkg QEAKK2RvY3VtZW50LmRlc2lnbk1vZGUgaW5oZXJpdHMgZnJvbSBwYXJlbnQgZG9jdW1lbnRzLgor CitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBm b2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKworUEFTUyBzdWNjZXNzZnVsbHlQ YXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKK2RvY3VtZW50LmRlc2lnbk1v ZGUgPSAib24iCitQQVNTIHN1YkRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50 RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIHN1YkRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJk aXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0 LXN1YmZyYW1lLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVs ZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtc3ViZnJhbWUu aHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lz Y29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LXN1YmZyYW1lLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMzAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVh ZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRl c3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1w cmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwv cD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8c2Ny aXB0PgorZGVzY3JpcHRpb24oJ2RvY3VtZW50LmRlc2lnbk1vZGUgaW5oZXJpdHMgZnJvbSBwYXJl bnQgZG9jdW1lbnRzLicpCisKK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICAgIGV2YWxBbmRMb2co J2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKKyAgICBzdWJEb2N1bWVudCA9IGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJzdWJmcmFtZSIpLmNvbnRlbnREb2N1bWVudDsKKyAgICBzaG91 bGRCZSgnc3ViRG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZScs ICciaW5oZXJpdCInKTsKKyAgICBzaG91bGRCZSgnc3ViRG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo ImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKKworICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJzdWJmcmFtZSIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK30KKword2luZG93 LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzxpZnJhbWUgaWQ9InN1 YmZyYW1lIiBvbmxvYWQ9InJ1blRlc3QoKSIgc3JjPSJkYXRhOnRleHQvaHRtbCw8ZGl2IGlkPSdk aXYnPjwvZGl2PiI+PC9pZnJhbWU+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxs aW5oZXJpdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0 YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDM3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxl c2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2Ny aXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwv aGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xl Ij48L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX2RpdiI+ CisgICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX3Ai PgorICAgIDxwIGlkPSJwIj48L3A+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignQ29u dGVudCBzaG91bGQgYmUgZWRpdGFibGUgaWYgaXRzIGFuZCBpdHMgYW5jZXN0b3JcJ3MgY29udGVu dEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJsZWQuJykK KworZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVy aXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlzQ29udGVu dEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShk aXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQt d3JpdGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmNvbnRl bnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cu Z2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1v ZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFy ZW50X29mX2RpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJwYXJlbnRfb2ZfcCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2luZG93LnN1Y2Nl c3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5k ZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRl c2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFu Y2VzdG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzIgQEAKK2lzQ29udGVudEVkaXRhYmxl IHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJsZSBpcyBz ZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBu b3QuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKKworCitkb2N1bWVu dC5kZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2Iiku Y29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1 dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIp IGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuY29u dGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2MiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRl ZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikg aXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5jb250ZW50 RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIiku aXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShw LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLXdy aXRlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUg aXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVu dEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIsICIiKS5n ZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCisK K1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKwor CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJs ZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0 b3IuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50 L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDU2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGlu ayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxl LmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2 IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0icGFy ZW50X29mX2RpdiIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+CisgICAgPGRpdiBpZD0iZGl2Ij48 L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX2RpdjIiPgorICAgIDxkaXYgaWQ9ImRp djIiPjwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2ZfcCIgY29udGVudEVkaXRhYmxl PSJ0cnVlIj4KKyAgICA8cCBpZD0icCI+PC9wPgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2Zf cDIiPgorICAgIDxwIGlkPSJwMiI+PC9wPgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24o J2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvclwncyBj b250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5kZXNpZ25N b2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJl bnRfb2ZfZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSA9IGZhbHNlOworZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInBhcmVudF9vZl9wMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2YWxBbmRM b2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hv dWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScs ICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdl dFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOwor CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFi bGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp djIiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRD b21wdXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9k aWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScpOworc2hv dWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCIt d2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVyaXQiJyk7 CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFi bGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAyLCAiIiku Z2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicp OworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX2RpdiIpLnN0eWxlLmRpc3Bs YXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfZGl2MiIpLnN0 eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2Zf cCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJl bnRfb2ZfcDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNzZnVsbHlQ YXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxF bGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0 YWJsZS1kZXNpZ25tb2Rlb24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM2 IEBACitpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgY29udGVudEVk aXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBl bmFibGVkIG9yIG5vdC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQ QVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKKworCisKKwor CisKK2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJmYWxzZSIKK1BB U1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAiZmFs c2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJs ZSBpcyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9w ZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJs ZSIpIGlzICJmYWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250 ZW50RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 MiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0 eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMg InJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRBdHRyaWJ1 dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IikgaXMgInJlYWQtd3JpdGUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmdl dEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgInRydWUiCitQQVNTIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQt dXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQg aXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRh YmxlLWRlc2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNTIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4K KzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qt c3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8ZGl2IGlk PSJkaXYiIGNvbnRlbnRFZGl0YWJsZT0iZmFsc2UiPjwvZGl2PgorPGRpdiBpZD0iZGl2MiI+PC9k aXY+Cis8cCBpZD0icCIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj48L3A+Cis8cCBpZD0icDIiPjwv cD4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxkIG5vdCBj aGFuZ2UgaWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRv Y3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuJykKKworZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFibGUgPSBmYWxzZTsKK2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2YWxBbmRMb2coJ2Rv Y3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSIn KTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRh YmxlJywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 IikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29t cHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJkaXYyIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSInKTsKK3No b3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0YWJsZScs ICciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5p c0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRl ZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5Iikn LCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJw IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVlIicpOworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicp Oworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFi bGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5n ZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7 CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5nZXRBdHRyaWJ1dGUo ImNvbnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicpOworc2hvdWxkQmUoJ2Rv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsK K3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFs dWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInAiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgicDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNzZnVs bHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 90448 2011-04-20 16:49:12 -0700 2011-04-22 06:57:03 -0700 fixed the crashing tests bug-53031-20110420164911.patch text/plain 8370 rniwa SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDg0NDM2KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDQtMjAgIFJ5b3N1a2Ug Tml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgaXNDb250ZW50RWRpdGFibGUgaXMgbm90IHdvcmtpbmcgcHJvcGVy bHkgd2l0aCBkb2N1bWVudC5kZXNpZ25Nb2RlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01MzAzMQorCisgICAgICAgICogY3NzL0NTU1N0eWxlU2VsZWN0 b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q1NTU3R5bGVTZWxlY3Rvcjo6c3R5bGVGb3JEb2N1 bWVudCk6CisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRv Y3VtZW50OjpzZXREZXNpZ25Nb2RlKToKKyAgICAgICAgKiBkb20vTm9kZS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpOb2RlOjpyZW5kZXJlcklzRWRpdGFibGUpOgorICAgICAgICAqIGVkaXRpbmcv QXBwbHlTdHlsZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXBwbHlTdHlsZUNvbW1h bmQ6OnN1cnJvdW5kTm9kZVJhbmdlV2l0aEVsZW1lbnQpOgorICAgICAgICAqIGh0bWwvSFRNTEVs ZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEVsZW1lbnQ6OnNldENvbnRlbnRFZGl0 YWJsZSk6CisKIDIwMTEtMDQtMjAgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFJ5b3N1a2UgTml3YS4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2Nz cy9DU1NTdHlsZVNlbGVjdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9jc3Mv Q1NTU3R5bGVTZWxlY3Rvci5jcHAJKHJldmlzaW9uIDg0Mjk2KQorKysgU291cmNlL1dlYkNvcmUv Y3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTk0LDcgKzExOTQs OCBAQCBQYXNzUmVmUHRyPFJlbmRlclN0eWxlPiBDU1NTdHlsZVNlbGVjdG9yCiAgICAgZG9jdW1l bnRTdHlsZS0+c2V0VmlzdWFsbHlPcmRlcmVkKGRvY3VtZW50LT52aXN1YWxseU9yZGVyZWQoKSk7 CiAgICAgZG9jdW1lbnRTdHlsZS0+c2V0Wm9vbShmcmFtZSA/IGZyYW1lLT5wYWdlWm9vbUZhY3Rv cigpIDogMSk7CiAgICAgZG9jdW1lbnRTdHlsZS0+c2V0UGFnZVNjYWxlVHJhbnNmb3JtKGZyYW1l ID8gZnJhbWUtPnBhZ2VTY2FsZUZhY3RvcigpIDogMSk7Ci0gICAgCisgICAgZG9jdW1lbnRTdHls ZS0+c2V0VXNlck1vZGlmeShkb2N1bWVudC0+aW5EZXNpZ25Nb2RlKCkgPyBSRUFEX1dSSVRFIDog UkVBRF9PTkxZKTsKKwogICAgIEVsZW1lbnQqIGRvY0VsZW1lbnQgPSBkb2N1bWVudC0+ZG9jdW1l bnRFbGVtZW50KCk7CiAgICAgUmVuZGVyT2JqZWN0KiBkb2NFbGVtZW50UmVuZGVyZXIgPSBkb2NF bGVtZW50ID8gZG9jRWxlbWVudC0+cmVuZGVyZXIoKSA6IDA7CiAgICAgaWYgKGRvY0VsZW1lbnRS ZW5kZXJlcikgewpJbmRleDogU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCShyZXZpc2lvbiA4NDI5NikK KysrIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQw MzQsNiArNDAzNCwxMiBAQCB2b2lkIERvY3VtZW50OjpzZXRUcmFuc2Zvcm1Tb3VyY2UoUGFzc093 CiB2b2lkIERvY3VtZW50OjpzZXREZXNpZ25Nb2RlKEluaGVyaXRlZEJvb2wgdmFsdWUpCiB7CiAg ICAgbV9kZXNpZ25Nb2RlID0gdmFsdWU7CisKKyAgICBmb3IgKEZyYW1lKiBmcmFtZSA9IG1fZnJh bWU7IGZyYW1lOyBmcmFtZSA9IGZyYW1lLT50cmVlKCktPnRyYXZlcnNlTmV4dChtX2ZyYW1lKSkg eworICAgICAgICBpZiAoZnJhbWUtPmRvY3VtZW50KCkpCisgICAgICAgICAgICBmcmFtZS0+ZG9j dW1lbnQoKS0+cmVjYWxjU3R5bGUoRm9yY2UpOworICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+ c2NoZWR1bGVGb3JjZWRTdHlsZVJlY2FsYygpOworICAgIH0KIH0KIAogRG9jdW1lbnQ6OkluaGVy aXRlZEJvb2wgRG9jdW1lbnQ6OmdldERlc2lnbk1vZGUoKSBjb25zdApJbmRleDogU291cmNlL1dl YkNvcmUvZG9tL05vZGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9Ob2Rl LmNwcAkocmV2aXNpb24gODQyOTYpCisrKyBTb3VyY2UvV2ViQ29yZS9kb20vTm9kZS5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTc2NSw3ICs3NjUsNyBAQCBib29sIE5vZGU6OmlzQ29udGVudEVkaXRh YmxlKCkgY29uc3QKIAogYm9vbCBOb2RlOjpyZW5kZXJlcklzRWRpdGFibGUoRWRpdGFibGVMZXZl bCBlZGl0YWJsZUxldmVsKSBjb25zdAogewotICAgIGlmIChkb2N1bWVudCgpLT5pbkRlc2lnbk1v ZGUoKSB8fCAoZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5wYWdl KCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+cGFnZSgpLT5pc0VkaXRhYmxlKCkpKQorICAgIGlm IChkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50KCktPmZyYW1lKCktPnBhZ2UoKSAmJiBk b2N1bWVudCgpLT5mcmFtZSgpLT5wYWdlKCktPmlzRWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJu IHRydWU7CiAKICAgICAvLyBJZGVhbGx5IHdlJ2QgY2FsbCBBU1NFUlQoIW5lZWRzU3R5bGVSZWNh bGMoKSkgaGVyZSwgYnV0CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0FwcGx5U3R5bGVD b21tYW5kLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0FwcGx5U3R5 bGVDb21tYW5kLmNwcAkocmV2aXNpb24gODQyOTYpCisrKyBTb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0FwcGx5U3R5bGVDb21tYW5kLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMxNiw4ICsxMzE2LDEw IEBAIHZvaWQgQXBwbHlTdHlsZUNvbW1hbmQ6OnN1cnJvdW5kTm9kZVJhbmcKICAgICBSZWZQdHI8 Tm9kZT4gbm9kZSA9IHN0YXJ0Tm9kZTsKICAgICB3aGlsZSAobm9kZSkgewogICAgICAgICBSZWZQ dHI8Tm9kZT4gbmV4dCA9IG5vZGUtPm5leHRTaWJsaW5nKCk7Ci0gICAgICAgIHJlbW92ZU5vZGUo bm9kZSk7Ci0gICAgICAgIGFwcGVuZE5vZGUobm9kZSwgZWxlbWVudCk7CisgICAgICAgIGlmIChu b2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKSB7CisgICAgICAgICAgICByZW1vdmVOb2RlKG5vZGUp OworICAgICAgICAgICAgYXBwZW5kTm9kZShub2RlLCBlbGVtZW50KTsKKyAgICAgICAgfQogICAg ICAgICBpZiAobm9kZSA9PSBlbmROb2RlKQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIG5v ZGUgPSBuZXh0OwpJbmRleDogU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRWxlbWVudC5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRWxlbWVudC5jcHAJKHJldmlzaW9u IDg0Mjk2KQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRWxlbWVudC5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTY4MiwxMSArNjgyLDYgQEAgdm9pZCBIVE1MRWxlbWVudDo6c2V0Q29udGVudEVk aXRhYmxlKEF0dAogICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENTU1Byb3Bl cnR5V29yZFdyYXAsIGZhbHNlKTsKICAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0 eShDU1NQcm9wZXJ0eVdlYmtpdE5ic3BNb2RlLCBmYWxzZSk7CiAgICAgICAgIGF0dHItPmRlY2wo KS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJraXRMaW5lQnJlYWssIGZhbHNlKTsKLSAg ICB9IGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKGVuYWJsZWQsICJpbmhlcml0IikpIHsKLSAg ICAgICAgYWRkQ1NTUHJvcGVydHkoYXR0ciwgQ1NTUHJvcGVydHlXZWJraXRVc2VyTW9kaWZ5LCBD U1NWYWx1ZUluaGVyaXQpOwotICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5KENT U1Byb3BlcnR5V29yZFdyYXAsIGZhbHNlKTsKLSAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQ cm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdE5ic3BNb2RlLCBmYWxzZSk7Ci0gICAgICAgIGF0dHIt PmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJraXRMaW5lQnJlYWssIGZhbHNl KTsKICAgICB9IGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKGVuYWJsZWQsICJwbGFpbnRleHQt b25seSIpKSB7CiAgICAgICAgIGFkZENTU1Byb3BlcnR5KGF0dHIsIENTU1Byb3BlcnR5V2Via2l0 VXNlck1vZGlmeSwgQ1NTVmFsdWVSZWFkV3JpdGVQbGFpbnRleHRPbmx5KTsKICAgICAgICAgYWRk Q1NTUHJvcGVydHkoYXR0ciwgQ1NTUHJvcGVydHlXb3JkV3JhcCwgQ1NTVmFsdWVCcmVha1dvcmQp OwpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L0NoYW5nZUxvZwkocmV2aXNpb24gODQ0MzYpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdv cmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNC0yMCAgUnlvc3VrZSBOaXdhICA8 cm5pd2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3aXRo IGRvY3VtZW50LmRlc2lnbk1vZGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAgICAgKiBlZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxv YWQtY3Jhc2gtbWFjLmh0bWw6CisgICAgICAgICogZWRpdGluZy9zdHlsZS9pZnJhbWUtb25sb2Fk LWNyYXNoLXVuaXguaHRtbDoKKyAgICAgICAgKiBlZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQt Y3Jhc2gtd2luLmh0bWw6CisKIDIwMTEtMDQtMjAgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVt Lm9yZz4KIAogICAgICAgICBVcGRhdGUgMiBtb3JlIHRlc3RzIHRoYXQgYXJlIG1pc3NpbmcgcG5n IGZpbGVzLgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9zdHlsZS9pZnJhbWUtb25sb2FkLWNy YXNoLW1hYy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvc3R5bGUvaWZy YW1lLW9ubG9hZC1jcmFzaC1tYWMuaHRtbAkocmV2aXNpb24gODQyOTYpCisrKyBMYXlvdXRUZXN0 cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQtY3Jhc2gtbWFjLmh0bWwJKHdvcmtpbmcgY29w eSkKQEAgLTQsOSArNCwxNiBAQCBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuc2V0RWRpdGluZ0JlaGF2aW9yKCdtYWMnKTsKIH0KIAot ZG9jdW1lbnQuZGVzaWduTW9kZT0nb24nOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3NlbGVjdGFs bCcpOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2l0YWxpYycpOwotZG9jdW1lbnQuZXhlY0NvbW1h bmQoJ1JlbW92ZUZvcm1hdCcpOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2luc2VydGh0bWwnLCBm YWxzZSk7Ci1kb2N1bWVudC5ib2R5LmlubmVySFRNTD0nUEFTUyc7Ij54CitpZiAoZG9jdW1lbnQu Y291bnRlcikKKyAgICBkb2N1bWVudC5jb3VudGVyKys7CitlbHNlCisgICAgZG9jdW1lbnQuY291 bnRlciA9IDE7CisKK2lmIChkb2N1bWVudC5jb3VudGVyIDw9IDE2KSB7CisgICAgZG9jdW1lbnQu ZGVzaWduTW9kZT0nb24nOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdzZWxlY3RhbGwnKTsK KyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnaXRhbGljJyk7CisgICAgZG9jdW1lbnQuZXhlY0Nv bW1hbmQoJ1JlbW92ZUZvcm1hdCcpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdpbnNlcnRo dG1sJywgZmFsc2UpOworICAgIGRvY3VtZW50LmJvZHkuaW5uZXJIVE1MPSdQQVNTJzsKK30gIj54 CkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQtY3Jhc2gtdW5p eC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvc3R5bGUvaWZyYW1lLW9u bG9hZC1jcmFzaC11bml4Lmh0bWwJKHJldmlzaW9uIDg0Mjk2KQorKysgTGF5b3V0VGVzdHMvZWRp dGluZy9zdHlsZS9pZnJhbWUtb25sb2FkLWNyYXNoLXVuaXguaHRtbAkod29ya2luZyBjb3B5KQpA QCAtNCw5ICs0LDE2IEBAIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5zZXRFZGl0aW5nQmVoYXZpb3IoJ3VuaXgnKTsKIH0KIAotZG9j dW1lbnQuZGVzaWduTW9kZT0nb24nOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3NlbGVjdGFsbCcp OwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2l0YWxpYycpOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQo J1JlbW92ZUZvcm1hdCcpOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2luc2VydGh0bWwnLCBmYWxz ZSk7Ci1kb2N1bWVudC5ib2R5LmlubmVySFRNTD0nUEFTUyc7Ij54CitpZiAoZG9jdW1lbnQuY291 bnRlcikKKyAgICBkb2N1bWVudC5jb3VudGVyKys7CitlbHNlCisgICAgZG9jdW1lbnQuY291bnRl ciA9IDE7CisKK2lmIChkb2N1bWVudC5jb3VudGVyIDw9IDE2KSB7CisgICAgZG9jdW1lbnQuZGVz aWduTW9kZT0nb24nOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdzZWxlY3RhbGwnKTsKKyAg ICBkb2N1bWVudC5leGVjQ29tbWFuZCgnaXRhbGljJyk7CisgICAgZG9jdW1lbnQuZXhlY0NvbW1h bmQoJ1JlbW92ZUZvcm1hdCcpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdpbnNlcnRodG1s JywgZmFsc2UpOworICAgIGRvY3VtZW50LmJvZHkuaW5uZXJIVE1MPSdQQVNTJzsKK30gIj54Cklu ZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQtY3Jhc2gtd2luLmh0 bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9zdHlsZS9pZnJhbWUtb25sb2Fk LWNyYXNoLXdpbi5odG1sCShyZXZpc2lvbiA4NDI5NikKKysrIExheW91dFRlc3RzL2VkaXRpbmcv c3R5bGUvaWZyYW1lLW9ubG9hZC1jcmFzaC13aW4uaHRtbAkod29ya2luZyBjb3B5KQpAQCAtNCw5 ICs0LDE2IEBAIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5zZXRFZGl0aW5nQmVoYXZpb3IoJ3dpbicpOwogfQogCi1kb2N1bWVudC5k ZXNpZ25Nb2RlPSdvbic7Ci1kb2N1bWVudC5leGVjQ29tbWFuZCgnc2VsZWN0YWxsJyk7Ci1kb2N1 bWVudC5leGVjQ29tbWFuZCgnaXRhbGljJyk7Ci1kb2N1bWVudC5leGVjQ29tbWFuZCgnUmVtb3Zl Rm9ybWF0Jyk7Ci1kb2N1bWVudC5leGVjQ29tbWFuZCgnaW5zZXJ0aHRtbCcsIGZhbHNlKTsKLWRv Y3VtZW50LmJvZHkuaW5uZXJIVE1MPSdQQVNTJzsiPngKK2lmIChkb2N1bWVudC5jb3VudGVyKQor ICAgIGRvY3VtZW50LmNvdW50ZXIrKzsKK2Vsc2UKKyAgICBkb2N1bWVudC5jb3VudGVyID0gMTsK KworaWYgKGRvY3VtZW50LmNvdW50ZXIgPD0gMTYpIHsKKyAgICBkb2N1bWVudC5kZXNpZ25Nb2Rl PSdvbic7CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3NlbGVjdGFsbCcpOworICAgIGRvY3Vt ZW50LmV4ZWNDb21tYW5kKCdpdGFsaWMnKTsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnUmVt b3ZlRm9ybWF0Jyk7CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2luc2VydGh0bWwnLCBmYWxz ZSk7CisgICAgZG9jdW1lbnQuYm9keS5pbm5lckhUTUw9J1BBU1MnOworfSAiPngK 90704 2011-04-22 06:57:03 -0700 2011-04-28 17:10:45 -0700 fix patch: merged Ryosuke's code. 53031_8.patch text/plain 27187 cshu SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDg0NjI0KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTEtMDQtMjIgIENoYW5nIFNo dSAgPGNzaHVAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3 aXRoIGRvY3VtZW50LmRlc2lnbk1vZGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTUzMDMxCisKKyAgICAgICAgVGhlIHNwZWNpZmljYXRpb24gKGh0dHA6 Ly9kZXYudzMub3JnL2h0bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCNhdHRyLWNvbnRlbnRlZGl0YWJs ZSkKKyAgICAgICAgaW5kaWNhdGVzIHRoYXQgdGhlIGVsZW1lbnQuaXNDb250ZW50RWRpdGFibGUg cmVsaWVzIG9uIGRvY3VtZW50LmRlc2lnbk1vZGUgaWYgaXRzCisgICAgICAgIGFuZCBpdHMgYW5j ZXN0b3JzJyBjb250ZW50ZWRpdGFibGUgYXR0cmlidXRlcyBhcmUgc2V0IHRvIGluaGVyaXQuCisK KyAgICAgICAgMS4gU3luYyBkb2N1bWVudCByZW5kZXIgc3R5bGUgYWZ0ZXIgZG9jdW1lbnQuZGVz aWduTW9kZSBpcyBjaGFuZ2VkLgorICAgICAgICAyLiBSZW1vdmVkIHRoZSBjb2RlIHRoYXQgZG9l cyB1bm5lY2Vzc2FyeSBhbmQgaW5jb3JyZWN0IGhhbmRsaW5nIGZvciBjb250ZW50ZWRpdGFibGUK KyAgICAgICAgYXR0cmlidXRlIHdpdGggImluaGVyaXQiIHZhbHVlLgorICAgICAgICAzLiBSeW9z dWtlIE5pd2EgYWxzbyBoZWxwZWQgdG8gZml4IHRoZSBjb2RlIGluIEFwcGx5U3R5bGVDb21tYW5k IHRoYXQgY2F1c2VzIGFuIGFzc2VydGlvbi4KKworICAgICAgICBUZXN0czogZmFzdC9kb20vSFRN TEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtc3ViZnJh bWUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRp dGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9k b20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFuY2VzdG9yLmh0 bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxl LWRlc2lnbm1vZGVvbi5odG1sCisKKyAgICAgICAgKiBjc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpDU1NTdHlsZVNlbGVjdG9yOjpzdHlsZUZvckRvY3VtZW50KToK KyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OnNldERlc2lnbk1vZGUpOgorICAgICAgICAqIGRvbS9Ob2RlLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6Ok5vZGU6OnJlbmRlcmVySXNFZGl0YWJsZSk6CisgICAgICAgICogZWRpdGluZy9BcHBseVN0 eWxlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBcHBseVN0eWxlQ29tbWFuZDo6c3Vy cm91bmROb2RlUmFuZ2VXaXRoRWxlbWVudCk6CisgICAgICAgICogaHRtbC9IVE1MRWxlbWVudC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRWxlbWVudDo6c2V0Q29udGVudEVkaXRhYmxlKToK KwogMjAxMS0wNC0yMiAgQW5kcmV5IEtvc3lha292ICA8Y2FzZXFAY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFBhdmVsIEZlbGRtYW4uCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9j c3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvY3Nz L0NTU1N0eWxlU2VsZWN0b3IuY3BwCShyZXZpc2lvbiA4NDI5NykKKysrIFNvdXJjZS9XZWJDb3Jl L2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE5NCw3ICsxMTk0 LDggQEAgUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gQ1NTU3R5bGVTZWxlY3RvcgogICAgIGRvY3Vt ZW50U3R5bGUtPnNldFZpc3VhbGx5T3JkZXJlZChkb2N1bWVudC0+dmlzdWFsbHlPcmRlcmVkKCkp OwogICAgIGRvY3VtZW50U3R5bGUtPnNldFpvb20oZnJhbWUgPyBmcmFtZS0+cGFnZVpvb21GYWN0 b3IoKSA6IDEpOwogICAgIGRvY3VtZW50U3R5bGUtPnNldFBhZ2VTY2FsZVRyYW5zZm9ybShmcmFt ZSA/IGZyYW1lLT5wYWdlU2NhbGVGYWN0b3IoKSA6IDEpOwotICAgIAorICAgIGRvY3VtZW50U3R5 bGUtPnNldFVzZXJNb2RpZnkoZG9jdW1lbnQtPmluRGVzaWduTW9kZSgpID8gUkVBRF9XUklURSA6 IFJFQURfT05MWSk7CisKICAgICBFbGVtZW50KiBkb2NFbGVtZW50ID0gZG9jdW1lbnQtPmRvY3Vt ZW50RWxlbWVudCgpOwogICAgIFJlbmRlck9iamVjdCogZG9jRWxlbWVudFJlbmRlcmVyID0gZG9j RWxlbWVudCA/IGRvY0VsZW1lbnQtPnJlbmRlcmVyKCkgOiAwOwogICAgIGlmIChkb2NFbGVtZW50 UmVuZGVyZXIpIHsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAkocmV2aXNpb24gODQyOTcp CisrKyBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00 MDM0LDYgKzQwMzQsOCBAQCB2b2lkIERvY3VtZW50OjpzZXRUcmFuc2Zvcm1Tb3VyY2UoUGFzc093 CiB2b2lkIERvY3VtZW50OjpzZXREZXNpZ25Nb2RlKEluaGVyaXRlZEJvb2wgdmFsdWUpCiB7CiAg ICAgbV9kZXNpZ25Nb2RlID0gdmFsdWU7CisgICAgZm9yIChGcmFtZSogZnJhbWUgPSBtX2ZyYW1l OyBmcmFtZSAmJiBmcmFtZS0+ZG9jdW1lbnQoKTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2 ZXJzZU5leHQobV9mcmFtZSkpCisgICAgICAgIGZyYW1lLT5kb2N1bWVudCgpLT5zY2hlZHVsZUZv cmNlZFN0eWxlUmVjYWxjKCk7CiB9CiAKIERvY3VtZW50OjpJbmhlcml0ZWRCb29sIERvY3VtZW50 OjpnZXREZXNpZ25Nb2RlKCkgY29uc3QKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9kb20vTm9kZS5jcHAJKHJldmlzaW9uIDg0 Mjk3KQorKysgU291cmNlL1dlYkNvcmUvZG9tL05vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03 NjUsNyArNzY1LDcgQEAgYm9vbCBOb2RlOjppc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0CiAKIGJv b2wgTm9kZTo6cmVuZGVyZXJJc0VkaXRhYmxlKEVkaXRhYmxlTGV2ZWwgZWRpdGFibGVMZXZlbCkg Y29uc3QKIHsKLSAgICBpZiAoZG9jdW1lbnQoKS0+aW5EZXNpZ25Nb2RlKCkgfHwgKGRvY3VtZW50 KCktPmZyYW1lKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+cGFnZSgpICYmIGRvY3VtZW50KCkt PmZyYW1lKCktPnBhZ2UoKS0+aXNFZGl0YWJsZSgpKSkKKyAgICBpZiAoZG9jdW1lbnQoKS0+ZnJh bWUoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5wYWdlKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUo KS0+cGFnZSgpLT5pc0VkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8g SWRlYWxseSB3ZSdkIGNhbGwgQVNTRVJUKCFuZWVkc1N0eWxlUmVjYWxjKCkpIGhlcmUsIGJ1dApJ bmRleDogU291cmNlL1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAJKHJl dmlzaW9uIDg0Mjk3KQorKysgU291cmNlL1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFu ZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEzMTYsOCArMTMxNiwxMCBAQCB2b2lkIEFwcGx5U3R5 bGVDb21tYW5kOjpzdXJyb3VuZE5vZGVSYW5nCiAgICAgUmVmUHRyPE5vZGU+IG5vZGUgPSBzdGFy dE5vZGU7CiAgICAgd2hpbGUgKG5vZGUpIHsKICAgICAgICAgUmVmUHRyPE5vZGU+IG5leHQgPSBu b2RlLT5uZXh0U2libGluZygpOwotICAgICAgICByZW1vdmVOb2RlKG5vZGUpOwotICAgICAgICBh cHBlbmROb2RlKG5vZGUsIGVsZW1lbnQpOworICAgICAgICBpZiAobm9kZS0+aXNDb250ZW50RWRp dGFibGUoKSkgeworICAgICAgICAgICAgcmVtb3ZlTm9kZShub2RlKTsKKyAgICAgICAgICAgIGFw cGVuZE5vZGUobm9kZSwgZWxlbWVudCk7CisgICAgICAgIH0KICAgICAgICAgaWYgKG5vZGUgPT0g ZW5kTm9kZSkKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBub2RlID0gbmV4dDsKSW5kZXg6 IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCShyZXZpc2lvbiA4NDI5NykKKysrIFNvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02ODIsMTEg KzY4Miw2IEBAIHZvaWQgSFRNTEVsZW1lbnQ6OnNldENvbnRlbnRFZGl0YWJsZShBdHQKICAgICAg ICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdvcmRXcmFwLCBmYWxz ZSk7CiAgICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJr aXROYnNwTW9kZSwgZmFsc2UpOwogICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVByb3BlcnR5 KENTU1Byb3BlcnR5V2Via2l0TGluZUJyZWFrLCBmYWxzZSk7Ci0gICAgfSBlbHNlIGlmIChlcXVh bElnbm9yaW5nQ2FzZShlbmFibGVkLCAiaW5oZXJpdCIpKSB7Ci0gICAgICAgIGFkZENTU1Byb3Bl cnR5KGF0dHIsIENTU1Byb3BlcnR5V2Via2l0VXNlck1vZGlmeSwgQ1NTVmFsdWVJbmhlcml0KTsK LSAgICAgICAgYXR0ci0+ZGVjbCgpLT5yZW1vdmVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdvcmRXcmFw LCBmYWxzZSk7Ci0gICAgICAgIGF0dHItPmRlY2woKS0+cmVtb3ZlUHJvcGVydHkoQ1NTUHJvcGVy dHlXZWJraXROYnNwTW9kZSwgZmFsc2UpOwotICAgICAgICBhdHRyLT5kZWNsKCktPnJlbW92ZVBy b3BlcnR5KENTU1Byb3BlcnR5V2Via2l0TGluZUJyZWFrLCBmYWxzZSk7CiAgICAgfSBlbHNlIGlm IChlcXVhbElnbm9yaW5nQ2FzZShlbmFibGVkLCAicGxhaW50ZXh0LW9ubHkiKSkgewogICAgICAg ICBhZGRDU1NQcm9wZXJ0eShhdHRyLCBDU1NQcm9wZXJ0eVdlYmtpdFVzZXJNb2RpZnksIENTU1Zh bHVlUmVhZFdyaXRlUGxhaW50ZXh0T25seSk7CiAgICAgICAgIGFkZENTU1Byb3BlcnR5KGF0dHIs IENTU1Byb3BlcnR5V29yZFdyYXAsIENTU1ZhbHVlQnJlYWtXb3JkKTsKSW5kZXg6IExheW91dFRl c3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlz aW9uIDg0NjI0KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0x LDMgKzEsMjkgQEAKKzIwMTEtMDQtMjIgIENoYW5nIFNodSAgPGNzaHVAd2Via2l0Lm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBpc0NvbnRlbnRF ZGl0YWJsZSBpcyBub3Qgd29ya2luZyBwcm9wZXJseSB3aXRoIGRvY3VtZW50LmRlc2lnbk1vZGUK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMDMxCisK KyAgICAgICAgMS4gQWRkZWQgdGVzdCBjYXNlcyBmb3IgY2hlY2tpbmcgaXNDb250ZW50RWRpdGFi bGUgd2l0aCBkZXNpZ25Nb2RlLgorICAgICAgICAyLiBBZGRlZCBhIG5ldyB0ZXN0IGNhc2UgZm9y IHNldHRpbmcgY29udGVudGVkaXRhYmxlIGF0dHJpYnV0ZSB0byAiaW5oZXJpdCIgYXMgdGhlCisg ICAgICAgIG9yaWdpbmFsIGNvZGUgd2lsbCBjYXVzZSBhIGNyYXNoLgorICAgICAgICAzLiBSeW9z dWtlIE5pd2EgYWxzbyBoZWxwZWQgdG8gZml4IHRlc3QgY2FzZXMgdW5kZXIgZWRpdGluZy9zdHls ZSB0aGF0IGNhdXNlIGluZmluaXRlIGxvb3AuCisKKyAgICAgICAgKiBlZGl0aW5nL3N0eWxlL2lm cmFtZS1vbmxvYWQtY3Jhc2gtbWFjLmh0bWw6CisgICAgICAgICogZWRpdGluZy9zdHlsZS9pZnJh bWUtb25sb2FkLWNyYXNoLXVuaXguaHRtbDoKKyAgICAgICAgKiBlZGl0aW5nL3N0eWxlL2lmcmFt ZS1vbmxvYWQtY3Jhc2gtd2luLmh0bWw6CisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQv YXR0ci1pbnZhbGlkLXN0cmluZy1leHBlY3RlZC50eHQ6CisgICAgICAgICogZmFzdC9kb20vSFRN TEVsZW1lbnQvYXR0ci1pbnZhbGlkLXN0cmluZy5odG1sOgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LWV4cGVj dGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50 ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtc3ViZnJhbWUtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1zdWJmcmFtZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5o ZXJpdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3ItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAg ICAgICAgKiBmYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYW5jZXN0b3IuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQv aXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9u Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA0LTIyICBNaWtoYWlsIE5hZ2Fub3YgIDxtbmFnYW5vdkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgUGF2ZWwgRmVsZG1hbi4KSW5kZXg6 IExheW91dFRlc3RzL2VkaXRpbmcvc3R5bGUvaWZyYW1lLW9ubG9hZC1jcmFzaC1tYWMuaHRtbAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQtY3Jh c2gtbWFjLmh0bWwJKHJldmlzaW9uIDg0Mjk3KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9zdHls ZS9pZnJhbWUtb25sb2FkLWNyYXNoLW1hYy5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC00LDkgKzQs MTYgQEAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewogICAgIGxheW91dFRlc3RD b250cm9sbGVyLnNldEVkaXRpbmdCZWhhdmlvcignbWFjJyk7CiB9CiAKLWRvY3VtZW50LmRlc2ln bk1vZGU9J29uJzsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdzZWxlY3RhbGwnKTsKLWRvY3VtZW50 LmV4ZWNDb21tYW5kKCdpdGFsaWMnKTsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdSZW1vdmVGb3Jt YXQnKTsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdpbnNlcnRodG1sJywgZmFsc2UpOwotZG9jdW1l bnQuYm9keS5pbm5lckhUTUw9J1BBU1MnOyI+eAoraWYgKGRvY3VtZW50LmNvdW50ZXIpCisgICAg ZG9jdW1lbnQuY291bnRlcisrOworZWxzZQorICAgIGRvY3VtZW50LmNvdW50ZXIgPSAxOworCitp ZiAoZG9jdW1lbnQuY291bnRlciA8PSAxNikgeworICAgIGRvY3VtZW50LmRlc2lnbk1vZGU9J29u JzsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnc2VsZWN0YWxsJyk7CisgICAgZG9jdW1lbnQu ZXhlY0NvbW1hbmQoJ2l0YWxpYycpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdSZW1vdmVG b3JtYXQnKTsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnaW5zZXJ0aHRtbCcsIGZhbHNlKTsK KyAgICBkb2N1bWVudC5ib2R5LmlubmVySFRNTD0nUEFTUyc7Cit9ICI+eApJbmRleDogTGF5b3V0 VGVzdHMvZWRpdGluZy9zdHlsZS9pZnJhbWUtb25sb2FkLWNyYXNoLXVuaXguaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1vbmxvYWQtY3Jhc2gtdW5p eC5odG1sCShyZXZpc2lvbiA4NDI5NykKKysrIExheW91dFRlc3RzL2VkaXRpbmcvc3R5bGUvaWZy YW1lLW9ubG9hZC1jcmFzaC11bml4Lmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTQsOSArNCwxNiBA QCBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuc2V0RWRpdGluZ0JlaGF2aW9yKCd1bml4Jyk7CiB9CiAKLWRvY3VtZW50LmRlc2lnbk1v ZGU9J29uJzsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdzZWxlY3RhbGwnKTsKLWRvY3VtZW50LmV4 ZWNDb21tYW5kKCdpdGFsaWMnKTsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdSZW1vdmVGb3JtYXQn KTsKLWRvY3VtZW50LmV4ZWNDb21tYW5kKCdpbnNlcnRodG1sJywgZmFsc2UpOwotZG9jdW1lbnQu Ym9keS5pbm5lckhUTUw9J1BBU1MnOyI+eAoraWYgKGRvY3VtZW50LmNvdW50ZXIpCisgICAgZG9j dW1lbnQuY291bnRlcisrOworZWxzZQorICAgIGRvY3VtZW50LmNvdW50ZXIgPSAxOworCitpZiAo ZG9jdW1lbnQuY291bnRlciA8PSAxNikgeworICAgIGRvY3VtZW50LmRlc2lnbk1vZGU9J29uJzsK KyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnc2VsZWN0YWxsJyk7CisgICAgZG9jdW1lbnQuZXhl Y0NvbW1hbmQoJ2l0YWxpYycpOworICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdSZW1vdmVGb3Jt YXQnKTsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFuZCgnaW5zZXJ0aHRtbCcsIGZhbHNlKTsKKyAg ICBkb2N1bWVudC5ib2R5LmlubmVySFRNTD0nUEFTUyc7Cit9ICI+eApJbmRleDogTGF5b3V0VGVz dHMvZWRpdGluZy9zdHlsZS9pZnJhbWUtb25sb2FkLWNyYXNoLXdpbi5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2VkaXRpbmcvc3R5bGUvaWZyYW1lLW9ubG9hZC1jcmFzaC13aW4uaHRt bAkocmV2aXNpb24gODQyOTcpCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL3N0eWxlL2lmcmFtZS1v bmxvYWQtY3Jhc2gtd2luLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTQsOSArNCwxNiBAQCBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu c2V0RWRpdGluZ0JlaGF2aW9yKCd3aW4nKTsKIH0KIAotZG9jdW1lbnQuZGVzaWduTW9kZT0nb24n OwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3NlbGVjdGFsbCcpOwotZG9jdW1lbnQuZXhlY0NvbW1h bmQoJ2l0YWxpYycpOwotZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ1JlbW92ZUZvcm1hdCcpOwotZG9j dW1lbnQuZXhlY0NvbW1hbmQoJ2luc2VydGh0bWwnLCBmYWxzZSk7Ci1kb2N1bWVudC5ib2R5Lmlu bmVySFRNTD0nUEFTUyc7Ij54CitpZiAoZG9jdW1lbnQuY291bnRlcikKKyAgICBkb2N1bWVudC5j b3VudGVyKys7CitlbHNlCisgICAgZG9jdW1lbnQuY291bnRlciA9IDE7CisKK2lmIChkb2N1bWVu dC5jb3VudGVyIDw9IDE2KSB7CisgICAgZG9jdW1lbnQuZGVzaWduTW9kZT0nb24nOworICAgIGRv Y3VtZW50LmV4ZWNDb21tYW5kKCdzZWxlY3RhbGwnKTsKKyAgICBkb2N1bWVudC5leGVjQ29tbWFu ZCgnaXRhbGljJyk7CisgICAgZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ1JlbW92ZUZvcm1hdCcpOwor ICAgIGRvY3VtZW50LmV4ZWNDb21tYW5kKCdpbnNlcnRodG1sJywgZmFsc2UpOworICAgIGRvY3Vt ZW50LmJvZHkuaW5uZXJIVE1MPSdQQVNTJzsKK30gIj54CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4cGVjdGVkLnR4dAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3Ry aW5nLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gODQyOTcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MRWxlbWVudC9hdHRyLWludmFsaWQtc3RyaW5nLWV4cGVjdGVkLnR4dAkod29ya2luZyBj b3B5KQpAQCAtNiwxMCArNiwxNSBAQCBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBCiAKIAogCi1QQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRy aWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJhYmMiCi1QQVNTIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCi1QQVNTIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyBmYWxzZQotUEFTUyB3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0 LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIKKworUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZCIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgImFiYyIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5jb250ZW50RWRpdGFibGUgaXMgImluaGVyaXQi CitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkIikuaXNDb250ZW50RWRpdGFibGUgaXMg ZmFsc2UKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUoZCwgIiIpLmdldFByb3BlcnR5VmFs dWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC1vbmx5IgorUEFTUyBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZDIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJp bmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5jb250ZW50RWRpdGFi bGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmlzQ29u dGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGQyLCAi IikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJyZWFkLW9ubHki CiAKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIApJbmRleDogTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvYXR0ci1pbnZhbGlkLXN0cmluZy5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2F0dHItaW52YWxpZC1zdHJpbmcu aHRtbAkocmV2aXNpb24gODQyOTcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVu dC9hdHRyLWludmFsaWQtc3RyaW5nLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTgsMTYgKzgsMjMg QEAKIDxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgogPGRpdiBpZD0iY29uc29sZSI+PC9wPgogPGRp diBpZD0icmVzdWx0Ij48L2Rpdj4KLTxkaXYgaWQ9ImRpdiIgY29udGVudEVkaXRhYmxlPSJhYmMi PjwvZGl2PgorPGRpdiBpZD0iZCIgY29udGVudEVkaXRhYmxlPSJhYmMiPjwvZGl2PgorPGRpdiBp ZD0iZDIiIGNvbnRlbnRFZGl0YWJsZT0iaW5oZXJpdCI+PC9kaXY+CiA8c2NyaXB0PgogZGVzY3Jp cHRpb24oJ1doZW4gY29udGVudEVkaXRhYmxlIGF0dHJpYnV0ZSBpcyBpbnZhbGlkIHN0cmluZywg ZWxlbWVudC5jb250ZW50RWRpdGFibGUgcmV0dXJucyAiaW5oZXJpdCIuJykKIAotc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0 YWJsZSIpJywnImFiYyInKTsKLXNob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2 IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOwotc2hvdWxkQmUoJ2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOwotc2hvdWxk QmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13 ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5IicpOworc2hvdWxkQmUoJ2RvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJkIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJh YmMiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5jb250ZW50RWRp dGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo ImQiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRD b21wdXRlZFN0eWxlKGQsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IiknLCAnInJlYWQtb25seSInKTsKIAotZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLnN0 eWxlLmRpc3BsYXk9ICdub25lJzsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZDIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnImluaGVyaXQiJyk7CitzaG91 bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQyIikuY29udGVudEVkaXRhYmxlJywgJyJp bmhlcml0IicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkMiIpLmlzQ29u dGVudEVkaXRhYmxlJywgJ2ZhbHNlJyk7CitzaG91bGRCZSgnd2luZG93LmdldENvbXB1dGVkU3R5 bGUoZDIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJl YWQtb25seSInKTsKKworZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImQiKS5zdHlsZS5kaXNwbGF5 PSAnbm9uZSc7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZDIiKS5zdHlsZS5kaXNwbGF5PSAn bm9uZSc7CiAKIHdpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwogPC9zY3JpcHQ+Cklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1k ZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9u LWFsbGluaGVyaXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVy aXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI0IEBACitDb250ZW50IHNo b3VsZCBiZSBlZGl0YWJsZSBpZiBpdHMgYW5kIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJs ZSBub3Qgc2V0LCBhbmQgZG9jdW1lbnQuZGVzaWduTW9kZSBpcyBlbmFibGVkLgorCitPbiBzdWNj ZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBi eSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKworCitkb2N1bWVudC5kZXNpZ25Nb2RlID0gIm9u IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlIGlz ICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuaXNDb250ZW50 RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5n ZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCitQ QVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlIGlzICJpbmhl cml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxl IGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCwgIiIpLmdldFByb3BlcnR5 VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNj ZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1v ZGVvbi1hbGxpbmhlcml0LXN1YmZyYW1lLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYWxsaW5oZXJpdC1zdWJmcmFtZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYWxsaW5oZXJpdC1zdWJmcmFtZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMTkgQEAKK2RvY3VtZW50LmRlc2lnbk1vZGUgaW5oZXJpdHMgZnJvbSBwYXJlbnQgZG9jdW1l bnRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3Nh Z2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworCisKKworUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKK2RvY3VtZW50LmRl c2lnbk1vZGUgPSAib24iCitQQVNTIHN1YkRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5j b250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIHN1YkRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCisKSW5kZXg6IExheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxp bmhlcml0LXN1YmZyYW1lLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLWFsbGluaGVyaXQtc3Vi ZnJhbWUuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVt ZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0LXN1YmZyYW1lLmh0 bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRp b24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+ Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ2RvY3VtZW50LmRlc2lnbk1vZGUgaW5oZXJpdHMgZnJv bSBwYXJlbnQgZG9jdW1lbnRzLicpCisKK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICAgIGV2YWxB bmRMb2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKKyAgICBzdWJEb2N1bWVudCA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdWJmcmFtZSIpLmNvbnRlbnREb2N1bWVudDsKKyAg ICBzaG91bGRCZSgnc3ViRG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0 YWJsZScsICciaW5oZXJpdCInKTsKKyAgICBzaG91bGRCZSgnc3ViRG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoImRpdiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKKworICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJzdWJmcmFtZSIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK30KKwor d2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzxpZnJhbWUg aWQ9InN1YmZyYW1lIiBvbmxvYWQ9InJ1blRlc3QoKSIgc3JjPSJkYXRhOnRleHQvaHRtbCw8ZGl2 IGlkPSdkaXYnPjwvZGl2PiI+PC9pZnJhbWU+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rl b24tYWxsaW5oZXJpdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbGxpbmhlcml0Lmh0bWwJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tYWxsaW5oZXJpdC5odG1sCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDM3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9 InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3Njcmlw dD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJj b25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBpZD0icGFyZW50X29m X2RpdiI+CisgICAgPGRpdiBpZD0iZGl2Ij48L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50 X29mX3AiPgorICAgIDxwIGlkPSJwIj48L3A+Cis8L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlv bignQ29udGVudCBzaG91bGQgYmUgZWRpdGFibGUgaWYgaXRzIGFuZCBpdHMgYW5jZXN0b3JcJ3Mg Y29udGVudEVkaXRhYmxlIG5vdCBzZXQsIGFuZCBkb2N1bWVudC5kZXNpZ25Nb2RlIGlzIGVuYWJs ZWQuJykKKworZXZhbEFuZExvZygnZG9jdW1lbnQuZGVzaWduTW9kZSA9ICJvbiInKTsKKworc2hv dWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5jb250ZW50RWRpdGFibGUnLCAn ImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmlz Q29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAn InJlYWQtd3JpdGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicCIp LmNvbnRlbnRFZGl0YWJsZScsICciaW5oZXJpdCInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3RydWUnKTsKK3Nob3VsZEJlKCd3 aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11 c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdyaXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicGFyZW50X29mX2RpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwYXJlbnRfb2ZfcCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKKword2luZG93 LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRh YmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9k ZW9uLWFuY2VzdG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rv ci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzIgQEAKK2lzQ29udGVudEVk aXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3RvcidzIGNvbnRlbnRFZGl0YWJs ZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxl ZCBvciBub3QuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIg bWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCisKKworCisKKworCitk b2N1bWVudC5kZXNpZ25Nb2RlID0gIm9uIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi ZGl2IikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUgaXMgZmFsc2UKK1BBU1Mgd2luZG93Lmdl dENvbXB1dGVkU3R5bGUoZGl2LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1v ZGlmeSIpIGlzICJyZWFkLW9ubHkiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYy IikuY29udGVudEVkaXRhYmxlIGlzICJpbmhlcml0IgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiZGl2MiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9k aWZ5IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5j b250ZW50RWRpdGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRT dHlsZShwLCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpIGlzICJy ZWFkLXdyaXRlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRp dGFibGUgaXMgImluaGVyaXQiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlz Q29udGVudEVkaXRhYmxlIGlzIHRydWUKK1BBU1Mgd2luZG93LmdldENvbXB1dGVkU3R5bGUocDIs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtd3Jp dGUiCisKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQor CisKKworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRl ZGl0YWJsZS1kZXNpZ25tb2Rlb24tYW5jZXN0b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24t YW5jZXN0b3IuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxF bGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1hbmNlc3Rvci5odG1sCShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDU2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+ Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+ Cis8ZGl2IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2PgorPGRpdiBp ZD0icGFyZW50X29mX2RpdiIgY29udGVudEVkaXRhYmxlPSJmYWxzZSI+CisgICAgPGRpdiBpZD0i ZGl2Ij48L2Rpdj4KKzwvZGl2PgorPGRpdiBpZD0icGFyZW50X29mX2RpdjIiPgorICAgIDxkaXYg aWQ9ImRpdjIiPjwvZGl2PgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJlbnRfb2ZfcCIgY29udGVudEVk aXRhYmxlPSJ0cnVlIj4KKyAgICA8cCBpZD0icCI+PC9wPgorPC9kaXY+Cis8ZGl2IGlkPSJwYXJl bnRfb2ZfcDIiPgorICAgIDxwIGlkPSJwMiI+PC9wPgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3Jp cHRpb24oJ2lzQ29udGVudEVkaXRhYmxlIHNob3VsZCBub3QgY2hhbmdlIGlmIGl0cyBhbmNlc3Rv clwncyBjb250ZW50RWRpdGFibGUgaXMgc2V0LCBubyBtYXR0ZXIgd2hldGhlciBkb2N1bWVudC5k ZXNpZ25Nb2RlIGlzIGVuYWJsZWQgb3Igbm90LicpCisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwYXJlbnRfb2ZfZGl2MiIpLmNvbnRlbnRFZGl0YWJsZSA9IGZhbHNlOworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInBhcmVudF9vZl9wMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2 YWxBbmRMb2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0Iicp Oworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRFZGl0 YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKGRpdiwg IiIpLmdldFByb3BlcnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC1vbmx5 IicpOworCitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250ZW50 RWRpdGFibGUnLCAnImluaGVyaXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImRpdjIiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRv dy5nZXRDb21wdXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVz ZXItbW9kaWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJpbmhlcml0IicpOworc2hvdWxkQmUo J2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50RWRpdGFibGUnLCAndHJ1ZScp Oworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZh bHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3JpdGUiJyk7CisKK3Nob3VsZEJl KCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5jb250ZW50RWRpdGFibGUnLCAnImluaGVy aXQiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50 RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAy LCAiIikuZ2V0UHJvcGVydHlWYWx1ZSgiLXdlYmtpdC11c2VyLW1vZGlmeSIpJywgJyJyZWFkLXdy aXRlIicpOworCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFyZW50X29mX2RpdiIpLnN0eWxl LmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJlbnRfb2ZfZGl2 MiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwYXJl bnRfb2ZfcCIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJwYXJlbnRfb2ZfcDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNjZXNz ZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVz b3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4 OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRlbnRlZGl0YWJsZS1kZXNp Z25tb2Rlb24tZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRWxlbWVudC9pc2NvbnRl bnRlZGl0YWJsZS1kZXNpZ25tb2Rlb24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDM2IEBACitpc0NvbnRlbnRFZGl0YWJsZSBzaG91bGQgbm90IGNoYW5nZSBpZiBpdHMgY29u dGVudEVkaXRhYmxlIGlzIHNldCwgbm8gbWF0dGVyIHdoZXRoZXIgZG9jdW1lbnQuZGVzaWduTW9k ZSBpcyBlbmFibGVkIG9yIG5vdC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVz IG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKKwor CisKKworCisKK2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iCitQQVNTIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJkaXYiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJmYWxz ZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLmNvbnRlbnRFZGl0YWJsZSBp cyAiZmFsc2UiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJkaXYiKS5pc0NvbnRlbnRF ZGl0YWJsZSBpcyBmYWxzZQorUEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5n ZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IikgaXMgInJlYWQtb25seSIKK1BB U1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIiKS5nZXRBdHRyaWJ1dGUoImNvbnRlbnRF ZGl0YWJsZSIpIGlzICJmYWxzZSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdjIi KS5jb250ZW50RWRpdGFibGUgaXMgImZhbHNlIgorUEFTUyBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiZGl2MiIpLmlzQ29udGVudEVkaXRhYmxlIGlzIGZhbHNlCitQQVNTIHdpbmRvdy5nZXRDb21w dXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5 IikgaXMgInJlYWQtb25seSIKK1BBU1MgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5nZXRB dHRyaWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpIGlzICJ0cnVlIgorUEFTUyBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicCIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1MgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAiKS5pc0NvbnRlbnRFZGl0YWJsZSBpcyB0cnVlCitQQVNTIHdpbmRv dy5nZXRDb21wdXRlZFN0eWxlKHAsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXIt bW9kaWZ5IikgaXMgInJlYWQtd3JpdGUiCitQQVNTIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJw MiIpLmdldEF0dHJpYnV0ZSgiY29udGVudEVkaXRhYmxlIikgaXMgInRydWUiCitQQVNTIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSBpcyAidHJ1ZSIKK1BBU1Mg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAyIikuaXNDb250ZW50RWRpdGFibGUgaXMgdHJ1ZQor UEFTUyB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3BlcnR5VmFsdWUoIi13 ZWJraXQtdXNlci1tb2RpZnkiKSBpcyAicmVhZC13cml0ZSIKKworUEFTUyBzdWNjZXNzZnVsbHlQ YXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworCisKSW5kZXg6IExheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVudGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1s Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxFbGVtZW50L2lzY29udGVu dGVkaXRhYmxlLWRlc2lnbm1vZGVvbi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEVsZW1lbnQvaXNjb250ZW50ZWRpdGFibGUtZGVzaWdubW9kZW9uLmh0bWwJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8 aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3VyY2VzL2pz LXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24i PjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8 ZGl2IGlkPSJkaXYiIGNvbnRlbnRFZGl0YWJsZT0iZmFsc2UiPjwvZGl2PgorPGRpdiBpZD0iZGl2 MiI+PC9kaXY+Cis8cCBpZD0icCIgY29udGVudEVkaXRhYmxlPSJ0cnVlIj48L3A+Cis8cCBpZD0i cDIiPjwvcD4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbignaXNDb250ZW50RWRpdGFibGUgc2hvdWxk IG5vdCBjaGFuZ2UgaWYgaXRzIGNvbnRlbnRFZGl0YWJsZSBpcyBzZXQsIG5vIG1hdHRlciB3aGV0 aGVyIGRvY3VtZW50LmRlc2lnbk1vZGUgaXMgZW5hYmxlZCBvciBub3QuJykKKworZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImRpdjIiKS5jb250ZW50RWRpdGFibGUgPSBmYWxzZTsKK2RvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJwMiIpLmNvbnRlbnRFZGl0YWJsZSA9IHRydWU7CisKK2V2YWxBbmRM b2coJ2RvY3VtZW50LmRlc2lnbk1vZGUgPSAib24iJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiZGl2IikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJm YWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2IikuY29udGVu dEVkaXRhYmxlJywgJyJmYWxzZSInKTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiZGl2IikuaXNDb250ZW50RWRpdGFibGUnLCAnZmFsc2UnKTsKK3Nob3VsZEJlKCd3aW5kb3cu Z2V0Q29tcHV0ZWRTdHlsZShkaXYsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXIt bW9kaWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJkaXYyIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJmYWxzZSIn KTsKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZGl2MiIpLmNvbnRlbnRFZGl0 YWJsZScsICciZmFsc2UiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRp djIiKS5pc0NvbnRlbnRFZGl0YWJsZScsICdmYWxzZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRD b21wdXRlZFN0eWxlKGRpdjIsICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9k aWZ5IiknLCAnInJlYWQtb25seSInKTsKKworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJwIikuZ2V0QXR0cmlidXRlKCJjb250ZW50RWRpdGFibGUiKScsJyJ0cnVlIicpOworc2hv dWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuY29udGVudEVkaXRhYmxlJywgJyJ0 cnVlIicpOworc2hvdWxkQmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwIikuaXNDb250ZW50 RWRpdGFibGUnLCAndHJ1ZScpOworc2hvdWxkQmUoJ3dpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHAs ICIiKS5nZXRQcm9wZXJ0eVZhbHVlKCItd2Via2l0LXVzZXItbW9kaWZ5IiknLCAnInJlYWQtd3Jp dGUiJyk7CisKK3Nob3VsZEJlKCdkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDIiKS5nZXRBdHRy aWJ1dGUoImNvbnRlbnRFZGl0YWJsZSIpJywnInRydWUiJyk7CitzaG91bGRCZSgnZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInAyIikuY29udGVudEVkaXRhYmxlJywgJyJ0cnVlIicpOworc2hvdWxk QmUoJ2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMiIpLmlzQ29udGVudEVkaXRhYmxlJywgJ3Ry dWUnKTsKK3Nob3VsZEJlKCd3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwMiwgIiIpLmdldFByb3Bl cnR5VmFsdWUoIi13ZWJraXQtdXNlci1tb2RpZnkiKScsICcicmVhZC13cml0ZSInKTsKKworZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImRpdiIpLnN0eWxlLmRpc3BsYXk9ICdub25lJzsKK2RvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJkaXYyIikuc3R5bGUuZGlzcGxheT0gJ25vbmUnOworZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7Citkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicDIiKS5zdHlsZS5kaXNwbGF5PSAnbm9uZSc7CisKK3dpbmRvdy5zdWNj ZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMv cmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg==