21680 2008-10-16 15:22:07 -0700 queryCommandValue("BackColor") returns rgb(0,0,0) for elements with transparent background 2010-08-30 17:26:27 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) All All RESOLVED FIXED HasReduction P2 Normal --- 1 linda167 rniwa darin enrica eric jparent justin.garcia ojan rniwa tkent tony webkit.review.bot oldest_to_newest 95625 0 linda167 2008-10-16 15:22:07 -0700 queryCommandValue for "BackColor" always returns rgb(0,0,0) in Safari, no matter what the background color is. This is not only not correct, it's also not in the correct format. The other browsers (Firefox, IE) returns the background color in hex form (ie #FFFFFF). 140965 1 35008 rniwa 2009-08-17 18:32:45 -0700 Created attachment 35008 Demonstrates the bug Not always. Whenever background color is specified in an ancestor of a node, it returns rgba(0,0,0,0). 140969 2 rniwa 2009-08-17 18:44:20 -0700 This bug is caused by PassRefPtr<CSSComputedStyleDeclaration> Frame::selectionComputedStyle(Node*& nodeToRemove) const. I added styleElement->showTreeForThis(); at the end and probed my demo. BODY 0x1ac54250 #text 0x1acf72f0 "\n" DIV 0x1acf9360 STYLE=background: green; SPAN 0x1acf7b10 #text 0x1c61a080 "hello world" #text 0x1ac53740 "\n\n" * P 0x1acf6d60 #text 0x1acf7150 "BackgroundColor: " SPAN 0x1acf6b90 #text 0x1ac28600 "\n\n" This isn't right. P is not even selected. 140973 3 rniwa 2009-08-17 19:14:17 -0700 RefPtr<Range> range(selection()->toNormalizedRange()); After this, range->startPosition() is at P. 141229 4 35075 rniwa 2009-08-18 14:22:14 -0700 Created attachment 35075 demo 141242 5 rniwa 2009-08-18 14:31:05 -0700 My demo had some bug to cause position / range not to show up properly. Now the issue is that computed style returns rgba(0,0,0,0) unless the background color is explicitly specified for that node. We might need to traverse the tree upwards from the selected node to find the background color. But what happens when the node is absolutely positioned? 202278 6 51244 rniwa 2010-03-21 03:19:55 -0700 Created attachment 51244 more tests More test cases: 1. The effective background color is of a parent element 2. The background color is explicitly specified 3. An element is placed with position:absolute and inherits the document's default background. 4. An element is placed with position:absolute on top of another element with an explicit background color. Sadly, all major browsers give different results, and MSIE gives the most reasonable result (passes 1 & 2 and returns white for 3 & 4). But I'm not sure of the expected results for the last two tests (3 & 4). From implementors' perspective, they are quite unreasonable because we need to extract the color value from the rendered image. We need CSS / rendering specialists on deciding what is the most appropriate behavior here. Also, we probably need a test with various alpha values. Consider a situation where an element has alpha=50%. Then the background color will be mixed with that of the parent element's background color. Should we return the effective value? or should we just return the value without alpha? 202866 7 ojan 2010-03-22 18:22:50 -0700 Lets keep this bug focused on the following case: <div style="background-color:blue">foo<span id="select-this">bar</span></div> Dealing with absolute positioning or transparency should be separate, lower priority bugs. 202889 8 rniwa 2010-03-22 19:06:21 -0700 (In reply to comment #7) > Lets keep this bug focused on the following case: > <div style="background-color:blue">foo<span id="select-this">bar</span></div> > > Dealing with absolute positioning or transparency should be separate, lower > priority bugs. Sure. We can file a separate bug for those cases. But we probably still need to consider different values of alpha since the only way to detect this case to look at the computed style and see if the alpha value of the background color is 0. What if alpha=0.5 or other values? We should return rgba(0,0,0, 0.5)? 202895 9 ojan 2010-03-22 19:21:27 -0700 It's not at all clear to me what the correct treatment of transparency and absolute positioning is with respect to background-color. It is clear that it's much lower priority than this bug though. I'm not really convinced that we have to deal with transparency and absolute positioning. If we find ourselves with a site that needs it though, then we can discuss it then with a real use-case in front of us. 248728 10 61003 rniwa 2010-07-08 22:17:24 -0700 Created attachment 61003 tests with multiple background colors Added tests with multiple span of different background colors. 248741 11 rniwa 2010-07-08 22:37:28 -0700 I ran the latest tests on Firefox and Internet Explorer to see their behaviors. Internet Explorer returns rgb(0, 0, 0) for mixed background colors. e.g. <div style='background: green;' id=test><span style='background-color: yellow'>hello</span><span style='background-color: blue'> world</span></div> gives rgb(0,0,0) when #test is selected. In other cases, IE retrieves the effective background color. For <div style='background: green;' id=test><span style='background-color: yellow'>hello</span><span style='background-color: yellow'> world</span></div>, IE returns yellow (in RGB form). Firefox does something somewhat simpler. It retrieves the background color of the node selected, and traverses ancestor nodes while the background color of the selected node is transparent. So <div style='background: green;' id=test><span style='background-color: yellow'>hello</span><span style='background-color: blue'> world</span></div> AND <div style='background: green;' id=test><span style='background-color: yellow'>hello</span><span style='background-color: yellow'> world</span></div> BOTH gives green. It seems like IE is doing a good job in terms of what user would expect but I'm not sure if we should return black in the case of mixed background color. Ojan & Julie, any thoughts on this? Also, during the debugging, I found that CSSComputedStyleDeclaration always returns RGBA (RGB+Alpha value) for CSSPropertyBackgroundColor regardless of whether it's transparent or not. So in the case of a node with background-color: transparent, we still get rgba(0,0,0,0). It seems like we need to special case this value or modify the computed style to return CSSValueTransparent. Does anyone know with whom I should talk about this issue? 249243 12 61087 rniwa 2010-07-09 13:57:57 -0700 Created attachment 61087 merged valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue and added a special case to treat background color This patch merges valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue because selectionStartStylePropertyValue was only used in valueStyle. I added a special case for background color where I check whether the style has transparent background or the current selection is a range. In either cases, new valueStyle will traverse the tree upwards until it gets a computed style with non-transparent background. I could improve the change log so give me some feedback please. 249244 13 webkit.review.bot 2010-07-09 13:58:57 -0700 Attachment 61087 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebCore/editing/EditorCommand.cpp:240: Place brace on its own line for function definitions. [whitespace/braces] [4] WebCore/editing/EditorCommand.cpp:248: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] WebCore/editing/EditorCommand.cpp:247: An else if statement should be written as an if statement when the prior "if" concludes with a return, break, continue or goto statement. [readability/control_flow] [4] WebCore/editing/EditorCommand.cpp:257: Declaration has space between type name and * in Node *nodeToRemove [whitespace/declaration] [3] Total errors found: 4 in 6 files If any of these errors are false positives, please file a bug against check-webkit-style. 249264 14 61094 rniwa 2010-07-09 14:18:54 -0700 Created attachment 61094 fixed style: merged valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue and added a special case to treat background color 249271 15 61094 darin 2010-07-09 14:25:24 -0700 Comment on attachment 61094 fixed style: merged valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue and added a special case to treat background color The special case for background color, climbing the tree and finding backgrounds on other elements, seems strange to me and does not seem like the right way to go. Do other browsers have behavior like this? Instead of "value->getRGBA32Value() == makeRGBA(0, 0, 0, 0)" you should just check for an alpha of 0. Getting selectionStartStylePropertyValue out of the Frame class is a good idea. Putting all this logic into EditorCommand.cpp is not so good. The point of that file is to be a dispatch point for the various editing commands. Any command that has a nontrivial algorithm should be contained in functions in other files. This algorithm in particular is complex and I'm not sure that having it here is good. 249297 16 rniwa 2010-07-09 14:46:35 -0700 Thanks for the feedback! (In reply to comment #15) > (From update of attachment 61094 [details]) > The special case for background color, climbing the tree and finding backgrounds on other elements, seems strange to me and does not seem like the right way to go. Do other browsers have behavior like this? As far as I checked, yes. See the comment #11. We could look at the actual color rendered on the screen as well but that seems bizarre to me. > Instead of "value->getRGBA32Value() == makeRGBA(0, 0, 0, 0)" you should just check for an alpha of 0. I was thinking that as well. I'll add more tests for the cases where alpha=0 but background color is not transparent. > Getting selectionStartStylePropertyValue out of the Frame class is a good idea. Putting all this logic into EditorCommand.cpp is not so good. The point of that file is to be a dispatch point for the various editing commands. Any command that has a nontrivial algorithm should be contained in functions in other files. This algorithm in particular is complex and I'm not sure that having it here is good. Ok, I had a hunch for it. Editor class seems to be a good place to put especially around triStateOfStyleInComputedStyle, selectionHasStyle, etc... 249309 17 ojan 2010-07-09 14:57:28 -0700 (In reply to comment #11) > It seems like IE is doing a good job in terms of what user would expect but I'm not sure if we should return black in the case of mixed background color. Ojan & Julie, any thoughts on this? IE's behavior is clearly best in my opinion. While I agree that it's not ideal to return black in the indeterminate case, it's better than what WebKit/Gecko do. Importantly, document.queryCommandIndeterm('BackColor') in indeterminate cases returns true in IE. So web pages are able to distinguish a black background color from an indeterminate one. It returns false in WebKit/Gecko, which is clearly wrong, although that's a separate bug entirely. > Also, during the debugging, I found that CSSComputedStyleDeclaration always returns RGBA (RGB+Alpha value) for CSSPropertyBackgroundColor regardless of whether it's transparent or not. So in the case of a node with background-color: transparent, we still get rgba(0,0,0,0). It seems like we need to special case this value or modify the computed style to return CSSValueTransparent. Does anyone know with whom I should talk about this issue? I agree that this seems wrong. Again, it's worth checking what IE/Firefox do in this case. 249310 18 eric 2010-07-09 15:03:57 -0700 We need to be careful in these changes to not leak visited link information. :) 249422 19 rniwa 2010-07-09 18:23:55 -0700 (In reply to comment #17) > (In reply to comment #11) > > It seems like IE is doing a good job in terms of what user would expect but I'm not sure if we should return black in the case of mixed background color. Ojan & Julie, any thoughts on this? > > IE's behavior is clearly best in my opinion. While I agree that it's not ideal to return black in the indeterminate case, it's better than what WebKit/Gecko do. Importantly, document.queryCommandIndeterm('BackColor') in indeterminate cases returns true in IE. So web pages are able to distinguish a black background color from an indeterminate one. It returns false in WebKit/Gecko, which is clearly wrong, although that's a separate bug entirely. I agree that returning something different for a mixed value is better than returning the value at the start of selection etc... We might want to talk about this on whatwg.org to get more feedback and eventually get standardized. I also don't think changing it to return black is a good idea at this moment since that's a quite bit of behavior change that could be addressed in another bug. > > Also, during the debugging, I found that CSSComputedStyleDeclaration always returns RGBA (RGB+Alpha value) for CSSPropertyBackgroundColor regardless of whether it's transparent or not. So in the case of a node with background-color: transparent, we still get rgba(0,0,0,0). It seems like we need to special case this value or modify the computed style to return CSSValueTransparent. Does anyone know with whom I should talk about this issue? > > I agree that this seems wrong. Again, it's worth checking what IE/Firefox do in this case. Firefox returns transparent. Need to check IE at home later. Filed as the bug 42017. 249428 20 rniwa 2010-07-09 18:28:57 -0700 (In reply to comment #18) > We need to be careful in these changes to not leak visited link information. :) I assume this was intended for another bug. 249431 21 61136 rniwa 2010-07-09 18:31:32 -0700 Created attachment 61136 fixed per Darin's comment I moved the code to Editor::selectionCSSPropertyValue and made it to check alpha value instead of checking against RGBA(0, 0, 0, 0) per Darin's feedback. 249432 22 rniwa 2010-07-09 18:33:54 -0700 // FIXME: Rather than retrieving the style at the start of the current selection, // we retrieve the style present throughout the selection. should read ... // we should retrieve the style present throughout the selection. 249433 23 61136 darin 2010-07-09 18:34:16 -0700 Comment on attachment 61136 fixed per Darin's comment > + The bug was caused by the fact that the computed style of a transparent node indicates that > + the background color is rgba(0,0,0,0). While this is correct in the accordance to CSS2 because background-color > + is not inherited by default, this doesn't give the desired result for editing purposes. I still don’t agree with this. I don’t think that querying some text on no background should go find the background that’s drawn behind that text. It seems like too high level a concept. 249434 24 61137 rniwa 2010-07-09 18:35:15 -0700 Created attachment 61137 fixed style and FIXME 249438 25 rniwa 2010-07-09 18:56:17 -0700 (In reply to comment #23) > (From update of attachment 61136 [details]) > > + The bug was caused by the fact that the computed style of a transparent node indicates that > > + the background color is rgba(0,0,0,0). While this is correct in the accordance to CSS2 because background-color > > + is not inherited by default, this doesn't give the desired result for editing purposes. > > I still don’t agree with this. I don’t think that querying some text on no background should go find the background that’s drawn behind that text. It seems like too high level a concept. Let me give you an example. Suppose we have <div style="background: yellow;"><span id="test" style="text-decoration: underline;">hello, world</span></div> When a user queries queryCommandValue("backColor") on #test, he/she wouldn't expect it to be rgba(0, 0, 0, 0) but expects it to be "yellow" or rgb(255, 255, 0) because that's what he/she sees. Arguably, I'm not certain what we should do in the case where span was position:absolute or it overflowed beyond the parent element. I added two failing tests in my patch that demonstrates this point. 249464 26 eric 2010-07-09 21:15:54 -0700 (In reply to comment #20) > (In reply to comment #18) > > We need to be careful in these changes to not leak visited link information. :) > > I assume this was intended for another bug. It was intended for this bug. Exposing :visited state is a privacy concern. I'll look in more detail later. Its possible this bug has no privacy implications at all. :) 249471 27 rniwa 2010-07-09 21:39:00 -0700 (In reply to comment #26) > (In reply to comment #20) > > (In reply to comment #18) > > > We need to be careful in these changes to not leak visited link information. :) > > > > I assume this was intended for another bug. > > It was intended for this bug. Exposing :visited state is a privacy concern. I'll look in more detail later. Its possible this bug has no privacy implications at all. :) Oh, I see. Sorry, I misunderstood you. I should look into that. 250787 28 ojan 2010-07-13 15:43:32 -0700 (In reply to comment #23) > (From update of attachment 61136 [details]) > > + The bug was caused by the fact that the computed style of a transparent node indicates that > > + the background color is rgba(0,0,0,0). While this is correct in the accordance to CSS2 because background-color > > + is not inherited by default, this doesn't give the desired result for editing purposes. > > I still don’t agree with this. I don’t think that querying some text on no background should go find the background that’s drawn behind that text. It seems like too high level a concept. execCommand and the queryCommand family of methods are a high level concept though. They should match what the user would expect to see in a rich-text toolbar/menu for the background color of the currently selected text. If they don't do that, then what use do they provide on top of getComputedStyle? This brings us closer to the IE behavior, which is to try to match whatever background color the user sees selected. I think that's correct and matches what rich-text developers expect out of queryCommandValue. 255195 29 rniwa 2010-07-22 21:21:30 -0700 (In reply to comment #26) > (In reply to comment #20) > > (In reply to comment #18) > > > We need to be careful in these changes to not leak visited link information. :) > > > > I assume this was intended for another bug. > > It was intended for this bug. Exposing :visited state is a privacy concern. I'll look in more detail later. Its possible this bug has no privacy implications at all. :) I added a test case for this. 255196 30 rniwa 2010-07-22 21:22:59 -0700 (In reply to comment #23) > (From update of attachment 61136 [details]) > > + The bug was caused by the fact that the computed style of a transparent node indicates that > > + the background color is rgba(0,0,0,0). While this is correct in the accordance to CSS2 because background-color > > + is not inherited by default, this doesn't give the desired result for editing purposes. > > I still don’t agree with this. I don’t think that querying some text on no background should go find the background that’s drawn behind that text. It seems like too high level a concept. @Darin: do you still disagree with my point? I've been trying to reach you on IRC but I haven't been able to find you. 268721 31 darin 2010-08-24 12:42:06 -0700 (In reply to comment #30) > (In reply to comment #23) > > (From update of attachment 61136 [details] [details]) > > > + The bug was caused by the fact that the computed style of a transparent node indicates that > > > + the background color is rgba(0,0,0,0). While this is correct in the accordance to CSS2 because background-color > > > + is not inherited by default, this doesn't give the desired result for editing purposes. > > > > I still don’t agree with this. I don’t think that querying some text on no background should go find the background that’s drawn behind that text. It seems like too high level a concept. > > @Darin: do you still disagree with my point? I've been trying to reach you on IRC but I haven't been able to find you. I still think this could be a problem. When you ask the background color of an element, for example, you don’t get the color drawn behind, you only get the color of the element itself. Similarly, it seems strange that the editing functions are trying to find out what color will be displayed behind the text in cases where the text itself is not supplying the background. While it’s true that execCommand and queryCommand are higher level than getComputedStyle, I’m not sure it’s so high level that it should be folding multiple elements in this fashion. The answer to why they exist is that they are the Internet Explorer editing API and we originally implemented it to be compatible with IE and work with the same websites. But I may not be sufficiently expert here. I’m OK with making a change if we have consensus this will work well. Does any other browser do this sort of thing? 268744 32 rniwa 2010-08-24 13:20:33 -0700 (In reply to comment #31) > I still think this could be a problem. When you ask the background color of an element, for example, you don’t get the color drawn behind, you only get the color of the element itself. Similarly, it seems strange that the editing functions are trying to find out what color will be displayed behind the text in cases where the text itself is not supplying the background. But we often do this in editing code. For example queryCommandState('bold') returns true for all descendes of b tag or node with font-weight: bold and so forth. > But I may not be sufficiently expert here. I’m OK with making a change if we have consensus this will work well. Does any other browser do this sort of thing? As I have implemented in #11, both Internet Explorer and Firefox retrieves the background color of ancestors so my patch will modify the WebKit's behavior to match other browsers. 268754 33 darin 2010-08-24 13:36:50 -0700 (In reply to comment #32) > (In reply to comment #31) > > I still think this could be a problem. When you ask the background color of an element, for example, you don’t get the color drawn behind, you only get the color of the element itself. Similarly, it seems strange that the editing functions are trying to find out what color will be displayed behind the text in cases where the text itself is not supplying the background. > > But we often do this in editing code. For example queryCommandState('bold') returns true for all descendes of b tag or node with font-weight: bold and so forth. I see that case differently. > > But I may not be sufficiently expert here. I’m OK with making a change if we have consensus this will work well. Does any other browser do this sort of thing? > > As I have implemented in #11, both Internet Explorer and Firefox retrieves the background color of ancestors so my patch will modify the WebKit's behavior to match other browsers. OK. 268755 34 darin 2010-08-24 13:38:33 -0700 (In reply to comment #33) > (In reply to comment #32) > > (In reply to comment #31) > > > I still think this could be a problem. When you ask the background color of an element, for example, you don’t get the color drawn behind, you only get the color of the element itself. Similarly, it seems strange that the editing functions are trying to find out what color will be displayed behind the text in cases where the text itself is not supplying the background. > > > > But we often do this in editing code. For example queryCommandState('bold') returns true for all descendes of b tag or node with font-weight: bold and so forth. > > I see that case differently. Here’s why. The boldness is still part of the effective style of the text. It’s not just something the text is drawing on top of, it’s an actual attribute of the text. The background color, however, is not, as I understand it. It’s just something already drawn under the text that the text shows up on top of. For example, the background could also be a video, or a gradient or a piece of an image. I don’t see how the color is different from those, and those definitely would not show up in the queryCommandSate. But if this matches the other browsers, then I guess I have it wrong. 268917 35 linda167 2010-08-24 17:23:47 -0700 (In reply to comment #34) > (In reply to comment #33) > > (In reply to comment #32) > > > (In reply to comment #31) > > > > I still think this could be a problem. When you ask the background color of an element, for example, you don’t get the color drawn behind, you only get the color of the element itself. Similarly, it seems strange that the editing functions are trying to find out what color will be displayed behind the text in cases where the text itself is not supplying the background. > > > > > > But we often do this in editing code. For example queryCommandState('bold') returns true for all descendes of b tag or node with font-weight: bold and so forth. > > > > I see that case differently. > > Here’s why. The boldness is still part of the effective style of the text. It’s not just something the text is drawing on top of, it’s an actual attribute of the text. > > The background color, however, is not, as I understand it. It’s just something already drawn under the text that the text shows up on top of. For example, the background could also be a video, or a gradient or a piece of an image. I don’t see how the color is different from those, and those definitely would not show up in the queryCommandSate. > > But if this matches the other browsers, then I guess I have it wrong. As a consumer, we use queryCommandValue for rich text editor functionalities. If this bug is fixed, we can for example show the background color state for any text in the editor similar to how we can show state for font, font size, bold, etc in our format bar. For example, in Word, you can apply a yellow highlight to a word. The next time you put your cursor in the word and click to apply a highlight, it can show the currently applied background color on it in the palette. 268922 36 darin 2010-08-24 17:26:36 -0700 (In reply to comment #35) > As a consumer, we use queryCommandValue for rich text editor functionalities. If this bug is fixed, we can for example show the background color state for any text in the editor similar to how we can show state for font, font size, bold, etc in our format bar. > > For example, in Word, you can apply a yellow highlight to a word. The next time you put your cursor in the word and click to apply a highlight, it can show the currently applied background color on it in the palette. In more sophisticated layouts I’d expect to be able to change the background color to transparent so I can see whatever’s behind the text. I want to be able to show that background color state in the editor. 270934 37 rniwa 2010-08-27 23:22:51 -0700 (In reply to comment #36) > In more sophisticated layouts I’d expect to be able to change the background color to transparent so I can see whatever’s behind the text. I want to be able to show that background color state in the editor. But for that purpose, the editor can use computedStyle since that would exactly tell them whether or not the node is transparent. Since both Firefox and Internet Explorer traverse ancestors for queryCommandValue('BackColor'), we should do the same. 271201 38 61137 darin 2010-08-29 13:07:18 -0700 Comment on attachment 61137 fixed style and FIXME Looks good. A few problems. > + if (value->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR) { > + Color backgroundColor(value->getRGBA32Value()); > + return backgroundColor.hasAlpha() && !backgroundColor.alpha(); > + } There is no reason to construct a Color here. You can check the alpha value in an RGBA 32-bit value with alphaChannel. There is no reason to call hasAlpha here. hasAlpha is just "alpha != 256" and alpha is "alpha == 0" There's no reason to check both. if (value->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR) return !alphaChannel(value->getRGBA32Value()); > + // FIXME: Rather than retrieving the style at the start of the current selection, > + // we retrieve the style present throughout the selection. > + RefPtr<CSSStyleDeclaration> selectionStyle = m_frame->selectionComputedStyle(nodeToRemove); Is there a reason you need to comment on this, but not fix it here? Is there a test covering this? > + } while (isTransparent(selectionStyle.get())); The function name isTransparent is unclear. I thin the intent is to check if the background color is transparent. That's not the same as saying a style "is transparent". I would call the function hasTransparentBackgroundColor because it doesn't even check if the background is transparent, just if the background *color* is transparent. You could have a non-transparent background image or a transparent background image. It also doesn't return true if the object has no background color at all, which seems like a mistake. Is the algorithm right for those cases? > TriState selectionHasStyle(CSSStyleDeclaration*) const; > + String selectionCSSPropertyValue(int); The int here needs an argument name. It's not clear what an int here is, although I know it's a property ID. I think it's unfortunate to add a new function here and have it be unclear if it means the property value at the start of the selection or throughout the selection. The old code didn't have this lack of clarity; it said "selection start" in its function name. We are adding the lack of clarity now. Lets not! review- because I think this could be easily improved. Sorry it took me so long to get to reviewing this. There are a lot of patches! 271512 39 rniwa 2010-08-30 11:03:53 -0700 (In reply to comment #38) > (From update of attachment 61137 [details]) > Looks good. A few problems. > > > + if (value->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR) { > > + Color backgroundColor(value->getRGBA32Value()); > > + return backgroundColor.hasAlpha() && !backgroundColor.alpha(); > > + } > > There is no reason to construct a Color here. You can check the alpha value in an RGBA 32-bit value with alphaChannel. Thanks for the info. I wonder why I didn't realize that. > There is no reason to call hasAlpha here. hasAlpha is just "alpha != 256" and alpha is "alpha == 0" There's no reason to check both. Ah, good to know. > > + // FIXME: Rather than retrieving the style at the start of the current selection, > > + // we retrieve the style present throughout the selection. > > + RefPtr<CSSStyleDeclaration> selectionStyle = m_frame->selectionComputedStyle(nodeToRemove); > > Is there a reason you need to comment on this, but not fix it here? Is there a test covering this? Oops, that comment was incomplete. I think the current implementation is probably correct for mac because TextEdit retrieves styles at the beginning of selection for styling / toggling purposes. However, in all other platforms (as far as I know), we must determine using the style present throughout the selection. For example, queryCommandValue('bold') should return false if the text has both bolded and unbolded text on non-mac platforms. On mac, it should return true iff the start of selection is bolded. But this is not specific to this bug and will have a large impact on the behaviors of other editing commands. So I'd like to fix it in a separate patch. > > + } while (isTransparent(selectionStyle.get())); > > The function name isTransparent is unclear. I thin the intent is to check if the background color is transparent. That's not the same as saying a style "is transparent". I would call the function hasTransparentBackgroundColor because it doesn't even check if the background is transparent, just if the background *color* is transparent. You could have a non-transparent background image or a transparent background image. It also doesn't return true if the object has no background color at all, which seems like a mistake. Is the algorithm right for those cases? Renamed to hasTransparentBackgroundColor. I think we should ignore background images for the purpose of finding the background color here because we can't reliably obtain "the color" of an image. We always get background color property in this particular usage of hasTransparentBackgroundColor because computed style always has background color property. But you're right that I should probably consider the case where someone calls hasTransparentBackgroundColor with a style declaration without background color. Fixed. > > TriState selectionHasStyle(CSSStyleDeclaration*) const; > > + String selectionCSSPropertyValue(int); > > The int here needs an argument name. It's not clear what an int here is, although I know it's a property ID. Sure, fixed. > I think it's unfortunate to add a new function here and have it be unclear if it means the property value at the start of the selection or throughout the selection. The old code didn't have this lack of clarity; it said "selection start" in its function name. We are adding the lack of clarity now. Lets not! My intention was to move the problem of retrieving the style at the start of selection as supposed to style present throughout the selection into selectionCSSPropertyValue but I guess that'll clutter the code. I renamed to selectionStartCSSPropertyValue and moved FIXME to valueStyle. > review- because I think this could be easily improved. Sorry it took me so long to get to reviewing this. There are a lot of patches! Thanks for the review. It was really nice discussions that took place here. We might want to summarize what we discussed here and post it on whatwg to standardize this behavior. 271513 40 65931 rniwa 2010-08-30 11:06:24 -0700 Created attachment 65931 Patch 271691 41 65931 darin 2010-08-30 15:20:18 -0700 Comment on attachment 65931 Patch > - return frame->selectionStartStylePropertyValue(propertyID); > + // FIXME: Rather than retrieving the style at the start of the current selection, > + // we should retrieve the style present throughout the selection for non-mac platforms. It’s "Mac", not "mac". 271795 42 rniwa 2010-08-30 17:26:27 -0700 Committed r66431: <http://trac.webkit.org/changeset/66431> 35008 2009-08-17 18:32:45 -0700 2009-08-18 14:22:14 -0700 Demonstrates the bug bkc.html text/html 559 rniwa PGh0bWw+Cjxib2R5Pgo8ZGl2IGlkPSJ0ZXN0IiBzdHlsZT0iYmFja2dyb3VuZDogZ3JlZW47Ij48 c3BhbiBjb250ZW50ZWRpdGFibGU9InRydWUiPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PgoKPHA+ QmFja2dyb3VuZENvbG9yOiA8c3BhbiBpZD0iYzEiPjwvc3Bhbj48L3A+Cgo8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+CgppZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQogICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwoKdmFyIGUgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgndGVzdCcpOwoKdmFyIHMgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CnZhciBy ID0gZG9jdW1lbnQuY3JlYXRlUmFuZ2UoKTsKci5zZXRTdGFydChlLCAwKTsKci5zZXRFbmQoZSwg MSk7CnMucmVtb3ZlQWxsUmFuZ2VzKCk7CnMuYWRkUmFuZ2Uocik7CmRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdjMScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKGRvY3VtZW50 LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKSkpOwoKPC9zY3JpcHQ+Cg== 35075 2009-08-18 14:22:14 -0700 2010-03-21 03:19:55 -0700 demo bkc.html text/html 570 rniwa PGh0bWw+Cjxib2R5Pgo8ZGl2IGlkPSJ0ZXN0IiBzdHlsZT0iYmFja2dyb3VuZDogZ3JlZW47IiBj b250ZW50ZWRpdGFibGU9InRydWUiPjxzcGFuPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PgoKPHA+ QmFja2dyb3VuZENvbG9yOiA8c3BhbiBpZD0iYzEiPjwvc3Bhbj48L3A+Cgo8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+CgppZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQogICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwoKdmFyIGUgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgndGVzdCcpOwoKdmFyIHMgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CnZhciBy ID0gZG9jdW1lbnQuY3JlYXRlUmFuZ2UoKTsKci5zZXRTdGFydChlLCAwKTsKci5zZXRFbmQoZSwg MSk7CmUuZm9jdXMoKTsKcy5yZW1vdmVBbGxSYW5nZXMoKTsKcy5hZGRSYW5nZShyKTsKZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ2MxJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5v ZGUoZG9jdW1lbnQucXVlcnlDb21tYW5kVmFsdWUoJ2JhY2tDb2xvcicpKSk7Cgo8L3NjcmlwdD4K 51244 2010-03-21 03:19:55 -0700 2010-07-08 22:17:24 -0700 more tests bug21680.html text/html 2175 rniwa PGh0bWw+DQo8Ym9keSBzdHlsZT0iYmFja2dyb3VuZDogI2NjY2NjYzsiPg0KPHAgaWQ9ImNvbnNv bGUiPjwvcD4NCjxkaXYgaWQ9ImJhY2tncm91bmQiIHN0eWxlPSJwb3NpdGlvbjogYWJzb2x1dGU7 IHRvcDogMjkwcHg7IHdpZHRoOiA1MDBweDsgaGVpZ2h0OjNlbTtiYWNrZ3JvdW5kOiBibGFjazsi PjwvZGl2Pg0KPGRpdiBpZD0iY29udGFpbmVyIiBjb250ZW50ZWRpdGFibGU9InRydWUiPjwvZGl2 Pg0KPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPiANCg0KaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikNCiAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQoN CmZ1bmN0aW9uIGdldENvbG9yKGUpIHsNCglpZiAoZG9jdW1lbnQuc2VsZWN0aW9uKSB7DQoJCXZh ciByID0gZG9jdW1lbnQuc2VsZWN0aW9uLmNyZWF0ZVJhbmdlKCk7DQoJCXIubW92ZVRvRWxlbWVu dFRleHQoZSk7DQogICAgICAgIHIubW92ZVN0YXJ0KCdjaGFyYWN0ZXInLCAxKTsNCiAgICAgICAg ci5tb3ZlRW5kKCdjaGFyYWN0ZXInLCAtMSk7DQoJCXIuc2VsZWN0KCk7DQoJCWJhY2tDb2xvciA9 IGRvY3VtZW50LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKTsNCgkJciA9IChiYWNrQ29s b3IgJiAweEZGKQ0KCQlnID0gKChiYWNrQ29sb3IgPj4gOCkgJiAweEZGKQ0KCQliID0gKChiYWNr Q29sb3IgPj4gMTYpICYgMHhGRikNCgkJcmV0dXJuICdyZ2IoJytyKycsICcrZysnLCAnK2IrJykn Ow0KCX0gZWxzZSB7DQoJCXZhciByID0gZG9jdW1lbnQuY3JlYXRlUmFuZ2UoKTsNCgkJdmFyIHMg PSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7DQogICAgICAgIHIuc2V0U3RhcnQoZS5jaGlsZE5vZGVz WzBdLCAxKTsNCiAgICAgICAgci5zZXRFbmQoZS5jaGlsZE5vZGVzWzBdLCBlLmNoaWxkTm9kZXNb MF0ubGVuZ3RoLTEpOw0KICAgICAgICBzLnJlbW92ZUFsbFJhbmdlcygpOw0KICAgICAgICBzLmFk ZFJhbmdlKHIpOw0KCQlyZXR1cm4gZG9jdW1lbnQucXVlcnlDb21tYW5kVmFsdWUoJ2JhY2tDb2xv cicpOw0KICAgIH0NCn0NCg0KZnVuY3Rpb24gdGVzdChodG1sLCBleHBlY3RlZCkgew0KICAgIHZh ciBjID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOw0KICAgIGMuaW5uZXJI VE1MID0gaHRtbDsNCgl2YXIgYWN0dWFsID0gZ2V0Q29sb3IoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ3Rlc3QnKSk7DQoJdmFyIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29u c29sZScpOw0KCWlmIChhY3R1YWwgPT0gZXhwZWN0ZWQpIHsNCgkJY29uc29sZS5pbm5lckhUTUwg Kz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogZ3JlZW47IGZvbnQtd2VpZ2h0OiBib2xkOyc+UEFTUzwv c3Bhbj4gIitleHBlY3RlZCsiIGZvciAiOw0KCX0gZWxzZSB7DQoJCWNvbnNvbGUuaW5uZXJIVE1M ICs9ICI8c3BhbiBzdHlsZT0nY29sb3I6IHJlZDsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5GQUlMRUQ8 L3NwYW4+IGV4cGVjdGVkICIrZXhwZWN0ZWQrDQoJCQkiIGJ1dCBnb3QgIithY3R1YWwrIiBmb3Ig IjsNCgl9DQogICAgY29uc29sZS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSho dG1sKSk7DQoJY29uc29sZS5pbm5lckhUTUwgKz0gIjxicj4iOw0KICAgIGMuaW5uZXJIVE1MID0g IiI7DQp9DQoNCnRlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gaWQ9 dGVzdD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsNCnRlc3Qo IjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVsbG88c3BhbiBzdHlsZT0nYmFja2dy b3VuZDogYmx1ZTsnIGlkPXRlc3Q+d29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAwLCAyNTUp Jyk7DQp0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5 bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAyMDBweDsnIGlkPXRlc3Q+d29ybGQ8L3NwYW4+ PC9kaXY+IiwgJ3JnYigyMDQsIDIwNCwgMjA0KScpOw0KdGVzdCgiPGRpdiBzdHlsZT0nYmFja2dy b3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7IHRvcDog MzAwcHg7JyBpZD10ZXN0PndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMCknKTsNCg0K PC9zY3JpcHQ+ 61003 2010-07-08 22:17:24 -0700 2010-07-09 13:57:57 -0700 tests with multiple background colors bug21680.html text/html 2914 rniwa PGh0bWw+DQo8Ym9keSBzdHlsZT0iYmFja2dyb3VuZDogI2NjY2NjYzsiPg0KPHAgaWQ9ImNvbnNv bGUiPjwvcD4NCjxkaXYgaWQ9ImJhY2tncm91bmQiIHN0eWxlPSJwb3NpdGlvbjogYWJzb2x1dGU7 IHRvcDogMjkwcHg7IHdpZHRoOiA1MDBweDsgaGVpZ2h0OjNlbTtiYWNrZ3JvdW5kOiBibGFjazsi PjwvZGl2Pg0KPGRpdiBpZD0iY29udGFpbmVyIiBjb250ZW50ZWRpdGFibGU9InRydWUiPjwvZGl2 Pg0KPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPiANCg0KaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikNCiAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQoN CmZ1bmN0aW9uIGdldENvbG9yKGUpIHsNCglpZiAoZG9jdW1lbnQuc2VsZWN0aW9uKSB7DQoJCXZh ciByID0gZG9jdW1lbnQuc2VsZWN0aW9uLmNyZWF0ZVJhbmdlKCk7DQoJCXIubW92ZVRvRWxlbWVu dFRleHQoZSk7DQogICAgICAgIHIubW92ZVN0YXJ0KCdjaGFyYWN0ZXInLCAxKTsNCiAgICAgICAg ci5tb3ZlRW5kKCdjaGFyYWN0ZXInLCAtMSk7DQoJCXIuc2VsZWN0KCk7DQoJCWJhY2tDb2xvciA9 IGRvY3VtZW50LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKTsNCgkJciA9IChiYWNrQ29s b3IgJiAweEZGKQ0KCQlnID0gKChiYWNrQ29sb3IgPj4gOCkgJiAweEZGKQ0KCQliID0gKChiYWNr Q29sb3IgPj4gMTYpICYgMHhGRikNCgkJcmV0dXJuICdyZ2IoJytyKycsICcrZysnLCAnK2IrJykn Ow0KCX0gZWxzZSB7DQoJCXZhciByID0gZG9jdW1lbnQuY3JlYXRlUmFuZ2UoKTsNCgkJdmFyIHMg PSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7DQogICAgICAgIHIuc2V0U3RhcnQoZS5jaGlsZE5vZGVz WzBdLCAxKTsNCiAgICAgICAgci5zZXRFbmQoZS5jaGlsZE5vZGVzWzBdLCBlLmNoaWxkTm9kZXNb MF0ubGVuZ3RoLTEpOw0KICAgICAgICBzLnJlbW92ZUFsbFJhbmdlcygpOw0KICAgICAgICBzLmFk ZFJhbmdlKHIpOw0KCQlyZXR1cm4gZG9jdW1lbnQucXVlcnlDb21tYW5kVmFsdWUoJ2JhY2tDb2xv cicpOw0KICAgIH0NCn0NCg0KZnVuY3Rpb24gdGVzdChodG1sLCBleHBlY3RlZCkgew0KICAgIHZh ciBjID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOw0KICAgIGMuaW5uZXJI VE1MID0gaHRtbDsNCgl2YXIgYWN0dWFsID0gZ2V0Q29sb3IoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ3Rlc3QnKSk7DQoJdmFyIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29u c29sZScpOw0KCWlmIChhY3R1YWwgPT0gZXhwZWN0ZWQpIHsNCgkJY29uc29sZS5pbm5lckhUTUwg Kz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogZ3JlZW47IGZvbnQtd2VpZ2h0OiBib2xkOyc+UEFTUzwv c3Bhbj4gIitleHBlY3RlZCsiIGZvciAiOw0KCX0gZWxzZSB7DQoJCWNvbnNvbGUuaW5uZXJIVE1M ICs9ICI8c3BhbiBzdHlsZT0nY29sb3I6IHJlZDsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5GQUlMRUQ8 L3NwYW4+IGV4cGVjdGVkICIrZXhwZWN0ZWQrDQoJCQkiIGJ1dCBnb3QgIithY3R1YWwrIiBmb3Ig IjsNCgl9DQogICAgY29uc29sZS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSho dG1sKSk7DQoJY29uc29sZS5pbm5lckhUTUwgKz0gIjxicj4iOw0KICAgIGMuaW5uZXJIVE1MID0g IiI7DQp9DQoNCnRlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gaWQ9 dGVzdD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsNCnRlc3Qo IjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHA+aGVsbG88L3A+PHNwYW4gaWQ9dGVz dD53b3JsZDwvc3Bhbj48cD53ZWJraXQ8L3A+PC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7DQp0 ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvIDxzcGFuIHN0eWxlPSdi YWNrZ3JvdW5kLWNvbG9yOiBibHVlOycgaWQ9dGVzdD53b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdi KDAsIDAsIDI1NSknKTsNCnRlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVs bG88c3BhbiBzdHlsZT0ncG9zaXRpb246IGFic29sdXRlOyB0b3A6IDIwMHB4OycgaWQ9dGVzdD53 b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDIwNCwgMjA0LCAyMDQpJyk7DQp0ZXN0KCI8ZGl2IHN0 eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNv bHV0ZTsgdG9wOiAzMDBweDsnIGlkPXRlc3Q+d29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAw LCAwKScpOw0KdGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47JyBpZD10ZXN0Pjxz cGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFuPiB3b3JsZDwv ZGl2PiIsICdyZ2IoMCwgMTI4LCAwKScpOw0KdGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDog Z3JlZW47JyBpZD10ZXN0PjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhl bGxvPC9zcGFuPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3JsZDwv c3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsNCnRlc3QoIjxkaXYgc3R5bGU9J2JhY2tn cm91bmQ6IGdyZWVuOycgaWQ9dGVzdD48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVs bG93Jz5oZWxsbzwvc3Bhbj48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZSc+IHdv cmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMTI4LCAwKScpOw0KdGVzdCgiPGRpdiBzdHlsZT0n YmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVsbG93 JyBpZD10ZXN0PmhlbGxvIHdvcmxkPC9zcGFuPiIsICdyZ2IoMjU1LCAyNTUsIDApJyk7DQoNCjwv c2NyaXB0Pg== 61087 2010-07-09 13:57:57 -0700 2010-07-09 14:18:54 -0700 merged valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue and added a special case to treat background color fix21680 text/plain 12254 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2Mjk4OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTAtMDctMDkgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcXVl cnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIHJldHVybnMgcmdiKDAsMCwwKSBmb3IgZWxlbWVu dHMgd2l0aCB0cmFuc3BhcmVudCBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTY4MAorCisgICAgICAgIFRoZSBidWcgd2FzIGNhdXNl ZCBieSB0aGUgZmFjdCB0aGF0IHRoZSBjb21wdXRlZCBzdHlsZSBvZiBhIHRyYW5zcGFyZW50IG5v ZGUgaW5kaWNhdGVzIHRoYXQKKyAgICAgICAgdGhlIGJhY2tncm91bmQgY29sb3IgaXMgcmdiYSgw LDAsMCwwKS4gV2hpbGUgdGhpcyBpcyBjb3JyZWN0IGluIHRoZSBhY2NvcmRhbmNlIHRvIENTUzIg YmVjYXVzZSBiYWNrZ3JvdW5kLWNvbG9yCisgICAgICAgIGlzIG5vdCBpbmhlcml0ZWQgYnkgZGVm YXVsdCwgdGhpcyBkb2Vzbid0IGdpdmUgdGhlIGRlc2lyZWQgcmVzdWx0IGZvciBlZGl0aW5nIHB1 cnBvc2VzLgorCisgICAgICAgIFRoaXMgcGF0Y2ggbW9kaWZpZXMgdmFsdWVTdHlsZSBpbiBFZGl0 b3JDb21tYW5kLmNwcCB0byB0cmF2ZXJzZSB0aGUgYW5jZXN0b3JzIG9mIHRoZSBjb21tb24gYW5j ZXN0b3IgY29udGFpbmVyCisgICAgICAgIHRvIHJldHJpZXZlIHRoZSBlZmZlY3RpdmUgYmFja2dy b3VuZCBjb2xvciBvZiB0aGUgc2VsZWN0ZWQgcmVnaW9uIHdoZW4gdGhlIG9yaWdpbmFsIGJhY2tn cm91bmQgY29sb3IgaXMgdHJhbnNwYXJlbnQKKyAgICAgICAgb3IgdGhlIHNlbGVjdGlvbiBpcyBy YW5nZS4gQmVjYXVzZSBGcmFtZTo6c2VsZWN0aW9uQ29tcHV0ZWRTdHlsZSByZXR1cm5zIHRoZSBj b21wdXRlZCBzdHlsZSBvZiB0aGUgc3RhcnQgb2YgYSBzZWxlY3Rpb24sCisgICAgICAgIHdlIG5l ZWQgdG8gYXZvaWQgcmV0cmlldmluZyB0aGUgYmFja2dyb3VuZCBjb2xvciB0aGF0IGlzIHByZXNl bnQgb25seSBhdCB0aGUgc3RhcnQgb2YgdGhlIHNlbGVjdGlvbi4KKyAgICAgICAgdmFsdWVTdHls ZSB0cmF2ZXJzZXMgYW5jZXN0b3JzIGFzIGxvbmcgYXMgdGhlIG5vZGUgaXMgdHJhbnNwYXJlbnQu CisgICAgICAgIGlzVHJhbnNwYXJlbnQsIGEgaGVscGVyIGZ1bmN0aW9uIHVzZWQgaW4gdmFsdWVT dHlsZSwgcmV0dXJucyB0cnVlIHdoZW4gYmFja2dyb3VuZCBjb2xvciBpcyB0cmFuc3BhcmVudCBv ciBSR0JBKDAsMCwwLDApCisKKyAgICAgICAgVGhpcyBwYXRjaCBhbHNvIHJlbW92ZXMgc2VsZWN0 aW9uU3RhcnRTdHlsZVByb3BlcnR5VmFsdWUgYW5kIG1pZ3JhdGVzIGl0IGludG8gdmFsdWVTdHls ZSBzaW5jZSBzZWxlY3Rpb25TdGFydFN0eWxlUHJvcGVydHlWYWx1ZQorICAgICAgICB3YXMgb25s eSB1c2VkIGluIHZhbHVlU3R5bGUuCisKKyAgICAgICAgVGVzdDogZWRpdGluZy9leGVjQ29tbWFu ZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbAorCisgICAgICAgICog ZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzVHJhbnNwYXJl bnQpOiBDaGVja3MgaWYgdGhlIGNvbXB1dGVkIHN0eWxlIGluZGljYXRlcyB0aGF0IGFuIGVsZW1l bnQgd2l0aCB0aGF0IHN0eWxlIGlzIHRyYW5zcGFyZW50CisgICAgICAgIChXZWJDb3JlOjp2YWx1 ZVN0eWxlKTogTWlncmF0ZWQgdGhlIGNvbnRlbnRzIG9mIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9w ZXJ0eVZhbHVlIGFuZCBhZGRlZCB0aGUgc3BlY2lhbCBjYXNlIGZvciBiYWNrZ3JvdW5kIGNvbG9y CisgICAgICAgICogcGFnZS9GcmFtZS5jcHA6CisgICAgICAgICogcGFnZS9GcmFtZS5oOgorCiAy MDEwLTA3LTA4ICBUb255IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgTmF0ZSBDaGFwaW4uCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9y Q29tbWFuZC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMjM1LDEwICsyMzUsNTUgQEAgc3RhdGljIFRyaVN0YXRlIHN0 YXRlU3R5bGUoRnJhbWUqIGZyYW1lLAogICAgIHN0eWxlLT5zZXRQcm9wZXJ0eShwcm9wZXJ0eUlE LCBkZXNpcmVkVmFsdWUpOwogICAgIHJldHVybiBmcmFtZS0+ZWRpdG9yKCktPnNlbGVjdGlvbkhh c1N0eWxlKHN0eWxlLmdldCgpKTsKIH0KKyAgICAKK3N0YXRpYyBib29sIGlzVHJhbnNwYXJlbnQo Q1NTU3R5bGVEZWNsYXJhdGlvbiogc3R5bGUpIHsKKyAgICBSZWZQdHI8Q1NTVmFsdWU+IGNzc1Zh bHVlID0gc3R5bGUtPmdldFByb3BlcnR5Q1NTVmFsdWUoQ1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29s b3IpOworCisgICAgaWYgKCFjc3NWYWx1ZS0+aXNQcmltaXRpdmVWYWx1ZSgpKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIHZhbHVlID0gc3RhdGljX2Nhc3Q8 Q1NTUHJpbWl0aXZlVmFsdWUqPihjc3NWYWx1ZS5nZXQoKSk7CisKKyAgICBpZiAodmFsdWUtPnBy aW1pdGl2ZVR5cGUoKSA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1JHQkNPTE9SKQorICAgICAg ICByZXR1cm4gdmFsdWUtPmdldFJHQkEzMlZhbHVlKCkgPT0gMDsKKyAgICBlbHNlIGlmICh2YWx1 ZS0+Z2V0SWRlbnQoKSA9PSBDU1NWYWx1ZVRyYW5zcGFyZW50KQorICAgICAgICByZXR1cm4gdHJ1 ZTsKIAorICAgIHJldHVybiBmYWxzZTsKK30KKyAgICAKIHN0YXRpYyBTdHJpbmcgdmFsdWVTdHls ZShGcmFtZSogZnJhbWUsIGludCBwcm9wZXJ0eUlEKQogewotICAgIHJldHVybiBmcmFtZS0+c2Vs ZWN0aW9uU3RhcnRTdHlsZVByb3BlcnR5VmFsdWUocHJvcGVydHlJRCk7CisgICAgTm9kZSAqbm9k ZVRvUmVtb3ZlOworICAgIC8vIEZJWE1FOiBSYXRoZXIgdGhhbiByZXRyaWV2aW5nIHRoZSBzdHls ZSBhdCB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgc2VsZWN0aW9uLAorICAgIC8vIHdlIHJldHJp ZXZlIHRoZSBzdHlsZSBwcmVzZW50IHRocm91Z2hvdXQgdGhlIHNlbGVjdGlvbi4KKyAgICBSZWZQ dHI8Q1NTU3R5bGVEZWNsYXJhdGlvbj4gc2VsZWN0aW9uU3R5bGUgPSBmcmFtZS0+c2VsZWN0aW9u Q29tcHV0ZWRTdHlsZShub2RlVG9SZW1vdmUpOworICAgIGlmICghc2VsZWN0aW9uU3R5bGUpCisg ICAgICAgIHJldHVybiBTdHJpbmcoKTsKKworICAgIFN0cmluZyB2YWx1ZSA9IHNlbGVjdGlvblN0 eWxlLT5nZXRQcm9wZXJ0eVZhbHVlKHByb3BlcnR5SUQpOworCisgICAgaWYgKG5vZGVUb1JlbW92 ZSkgeworICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICAgICAgbm9kZVRvUmVtb3Zl LT5yZW1vdmUoZWMpOworICAgICAgICBBU1NFUlQoIWVjKTsKKyAgICB9CisKKyAgICAvLyBJZiBi YWNrZ3JvdW5kIGNvbG9yIGlzIHRyYW5zcGFyZW50LCB0cmF2ZXJzZSBwYXJlbnQgbm9kZXMgdW50 aWwgd2UgaGl0IGEgZGlmZmVyZW50IHZhbHVlIG9yIGRvY3VtZW50IHJvb3QKKyAgICAvLyBBbHNv LCBpZiB0aGUgc2VsZWN0aW9uIGlzIGEgcmFuZ2UsIGlnbm9yZSB0aGUgYmFja2dyb3VuZCBjb2xv ciBhdCB0aGUgc3RhcnQgb2Ygc2VsZWN0aW9uLAorICAgIC8vIGFuZCBmaW5kIHRoZSBiYWNrZ3Jv dW5kIGNvbG9yIG9mIHRoZSBjb21tb24gYW5jZXN0b3IuCisgICAgaWYgKHByb3BlcnR5SUQgPT0g Q1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29sb3IgJiYgKGZyYW1lLT5zZWxlY3Rpb24oKS0+aXNSYW5n ZSgpIHx8IGlzVHJhbnNwYXJlbnQoc2VsZWN0aW9uU3R5bGUuZ2V0KCkpKSkgeworICAgICAgICBS ZWZQdHI8UmFuZ2U+IHJhbmdlKGZyYW1lLT5zZWxlY3Rpb24oKS0+dG9Ob3JtYWxpemVkUmFuZ2Uo KSk7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICBOb2RlKiBhbmNlc3Rv ciA9IHJhbmdlLT5jb21tb25BbmNlc3RvckNvbnRhaW5lcihlYyk7CisgICAgICAgIEFTU0VSVChh bmNlc3Rvcik7CisgICAgICAgIGRvIHsKKyAgICAgICAgICAgIHNlbGVjdGlvblN0eWxlID0gY29t cHV0ZWRTdHlsZShhbmNlc3Rvcik7CisgICAgICAgICAgICBhbmNlc3RvciA9IGFuY2VzdG9yLT5w YXJlbnROb2RlKCk7CisgICAgICAgIH0gd2hpbGUgKGlzVHJhbnNwYXJlbnQoc2VsZWN0aW9uU3R5 bGUuZ2V0KCkpKTsKKyAgICAgICAgdmFsdWUgPSBzZWxlY3Rpb25TdHlsZS0+Z2V0UHJvcGVydHlW YWx1ZShDU1NQcm9wZXJ0eUJhY2tncm91bmRDb2xvcik7CisgICAgfQorCisgICAgcmV0dXJuIHZh bHVlOwogfQogCiBzdGF0aWMgVHJpU3RhdGUgc3RhdGVUZXh0V3JpdGluZ0RpcmVjdGlvbihGcmFt ZSogZnJhbWUsIFdyaXRpbmdEaXJlY3Rpb24gZGlyZWN0aW9uKQpJbmRleDogV2ViQ29yZS9wYWdl L0ZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCShyZXZpc2lv biA2MjY2MykKKysrIFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0 LDYgKzM0LDcgQEAKICNpbmNsdWRlICJDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbi5oIgogI2lu Y2x1ZGUgIkNTU1Byb3BlcnR5LmgiCiAjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgorI2lu Y2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKICNpbmNsdWRlICJDYWNoZWRDU1NTdHlsZVNoZWV0 LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCiAjaW5jbHVkZSAiQ2hyb21lQ2xpZW50LmgiCkBAIC03 NjcsMjQgKzc2OCw2IEBAIHZvaWQgRnJhbWU6OmNvbXB1dGVBbmRTZXRUeXBpbmdTdHlsZShDU1MK ICAgICBtX3R5cGluZ1N0eWxlID0gbXV0YWJsZVN0eWxlLnJlbGVhc2UoKTsKIH0KIAotU3RyaW5n IEZyYW1lOjpzZWxlY3Rpb25TdGFydFN0eWxlUHJvcGVydHlWYWx1ZShpbnQgc3R5bGVQcm9wZXJ0 eUlEKSBjb25zdAotewotICAgIE5vZGUgKm5vZGVUb1JlbW92ZTsKLSAgICBSZWZQdHI8Q1NTU3R5 bGVEZWNsYXJhdGlvbj4gc2VsZWN0aW9uU3R5bGUgPSBzZWxlY3Rpb25Db21wdXRlZFN0eWxlKG5v ZGVUb1JlbW92ZSk7Ci0gICAgaWYgKCFzZWxlY3Rpb25TdHlsZSkKLSAgICAgICAgcmV0dXJuIFN0 cmluZygpOwotCi0gICAgU3RyaW5nIHZhbHVlID0gc2VsZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5 VmFsdWUoc3R5bGVQcm9wZXJ0eUlEKTsKLQotICAgIGlmIChub2RlVG9SZW1vdmUpIHsKLSAgICAg ICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7Ci0gICAgICAgIG5vZGVUb1JlbW92ZS0+cmVtb3ZlKGVj KTsKLSAgICAgICAgQVNTRVJUKCFlYyk7Ci0gICAgfQotCi0gICAgcmV0dXJuIHZhbHVlOwotfQot CiBQYXNzUmVmUHRyPENTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbj4gRnJhbWU6OnNlbGVjdGlv bkNvbXB1dGVkU3R5bGUoTm9kZSomIG5vZGVUb1JlbW92ZSkgY29uc3QKIHsKICAgICBub2RlVG9S ZW1vdmUgPSAwOwpJbmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDYyNjYzKQorKysgV2ViQ29yZS9wYWdlL0ZyYW1l LmgJKHdvcmtpbmcgY29weSkKQEAgLTE5Niw3ICsxOTYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgICAgIHZvaWQgc2V0TWFyayhjb25zdCBWaXNpYmxlU2VsZWN0aW9uJik7CiAKICAgICAg ICAgdm9pZCBjb21wdXRlQW5kU2V0VHlwaW5nU3R5bGUoQ1NTU3R5bGVEZWNsYXJhdGlvbiogLCBF ZGl0QWN0aW9uID0gRWRpdEFjdGlvblVuc3BlY2lmaWVkKTsKLSAgICAgICAgU3RyaW5nIHNlbGVj dGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZhbHVlKGludCBzdHlsZVByb3BlcnR5SUQpIGNvbnN0Owog ICAgICAgICB2b2lkIGFwcGx5RWRpdGluZ1N0eWxlVG9Cb2R5RWxlbWVudCgpIGNvbnN0OwogICAg ICAgICB2b2lkIGFwcGx5RWRpdGluZ1N0eWxlVG9FbGVtZW50KEVsZW1lbnQqKSBjb25zdDsKIApJ bmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0No YW5nZUxvZwkocmV2aXNpb24gNjI5ODgpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtp bmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNy0wOSAgUnlvc3VrZSBOaXdhICA8cm5p d2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBxdWVyeUNvbW1hbmRWYWx1ZSgiQmFja0NvbG9yIikgcmV0dXJucyByZ2IoMCwwLDAp IGZvciBlbGVtZW50cyB3aXRoIHRyYW5zcGFyZW50IGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNjgwCisKKyAgICAgICAgVGVzdHMg cXVlcnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIG9uIHZhcmlvdXMgY2FzZXMsIGVzcGVjaWFs bHkgdGhlIGNhc2VzIHdoZXJlIGJhY2tncm91bmQgY29sb3Igb2YKKyAgICAgICAgdGhlIHNlbGVj dGVkIG5vZGUgaXMgdHJhbnNwYXJlbnQgYnV0IHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIGl0cyBh bmNlc3RvciBoYXMgYSBjb2xvci4KKworICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91 bmQtY29sb3IuaHRtbDogQWRkZWQuCisKIDIwMTAtMDctMDkgIFhpYW9tZWkgSmkgIDx4amlAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhdmlkIExldmluLgpJbmRleDogTGF5 b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91 bmQtY29sb3ItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcv ZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSwxMSBAQAorUEFTUyByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0n YmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBpZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48 L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdy ZWVuOyc+PHA+aGVsbG88L3A+PHNwYW4gaWQ9c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+PHA+d2Via2l0 PC9wPjwvZGl2PgorUEFTUyByZ2IoMCwgMCwgMjU1KSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3Vu ZDogZ3JlZW47Jz5oZWxsbyA8c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZTsnIGlk PXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PgorRkFJTEVEIGV4cGVjdGVkIHJnYigyMDQsIDIw NCwgMjA0KSBidXQgZ290IHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5k OiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAyMDBw eDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PgorRkFJTEVEIGV4cGVjdGVkIHJnYigw LCAwLCAwKSBidXQgZ290IHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5k OiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAzMDBw eDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PgorUEFTUyByZ2IoMCwgMTI4LCAwKSBm b3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47JyBpZD1zZWxlY3RlZD48c3BhbiBzdHls ZT0nYmFja2dyb3VuZC1jb2xvcjogeWVsbG93Jz5oZWxsbzwvc3Bhbj4gd29ybGQ8L2Rpdj4KK1BB U1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9 c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3Nw YW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+IHdvcmxkPC9zcGFuPjwv ZGl2PgorUEFTUyByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3Jl ZW47JyBpZD1zZWxlY3RlZD48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVsbG93Jz5o ZWxsbzwvc3Bhbj48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZSc+IHdvcmxkPC9z cGFuPjwvZGl2PgorUEFTUyByZ2IoMjU1LCAyNTUsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3Jv dW5kOiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnIGlkPXNl bGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPgorCisKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcv ZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5k LXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9y Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTggQEAKKzxodG1sPgorPGJvZHkgc3R5bGU9 ImJhY2tncm91bmQ6ICNjY2NjY2M7Ij4KKzxwIGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJi YWNrZ3JvdW5kIiBzdHlsZT0icG9zaXRpb246IGFic29sdXRlOyB0b3A6IDI5MHB4OyB3aWR0aDog NTAwcHg7IGhlaWdodDozZW07YmFja2dyb3VuZDogYmxhY2s7Ij48L2Rpdj4KKzxkaXYgaWQ9ImNv bnRhaW5lciIgY29udGVudGVkaXRhYmxlPSJ0cnVlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0Ij4gCisKK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBnZXRDb2xvcihl KSB7CisgICAgaWYgKGRvY3VtZW50LnNlbGVjdGlvbikgeworICAgICAgICB2YXIgciA9IGRvY3Vt ZW50LnNlbGVjdGlvbi5jcmVhdGVSYW5nZSgpOworICAgICAgICByLm1vdmVUb0VsZW1lbnRUZXh0 KGUpOworICAgICAgICByLnNlbGVjdCgpOworICAgICAgICBiYWNrQ29sb3IgPSBkb2N1bWVudC5x dWVyeUNvbW1hbmRWYWx1ZSgnYmFja0NvbG9yJyk7CisgICAgICAgIHIgPSAoYmFja0NvbG9yICYg MHhGRikKKyAgICAgICAgZyA9ICgoYmFja0NvbG9yID4+IDgpICYgMHhGRikKKyAgICAgICAgYiA9 ICgoYmFja0NvbG9yID4+IDE2KSAmIDB4RkYpCisgICAgICAgIHJldHVybiAncmdiKCcrcisnLCAn K2crJywgJytiKycpJzsKKyAgICB9IGVsc2UgeworICAgICAgICB2YXIgciA9IGRvY3VtZW50LmNy ZWF0ZVJhbmdlKCk7CisgICAgICAgIHZhciBzID0gd2luZG93LmdldFNlbGVjdGlvbigpOworICAg ICAgICByLnNldFN0YXJ0KGUsIDApOworICAgICAgICByLnNldEVuZChlLCBlLmNoaWxkTm9kZXMu bGVuZ3RoKTsKKyAgICAgICAgcy5yZW1vdmVBbGxSYW5nZXMoKTsKKyAgICAgICAgcy5hZGRSYW5n ZShyKTsKKyAgICAgICAgcmV0dXJuIGRvY3VtZW50LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29s b3InKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIHRlc3QoaHRtbCwgZXhwZWN0ZWQpIHsKKyAgICB2 YXIgYyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb250YWluZXInKTsKKyAgICBjLmlubmVy SFRNTCA9IGh0bWw7CisgICAgdmFyIGFjdHVhbCA9IGdldENvbG9yKGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdzZWxlY3RlZCcpKTsKKyAgICB2YXIgY29uc29sZSA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdjb25zb2xlJyk7CisgICAgaWYgKGFjdHVhbCA9PSBleHBlY3RlZCkgeworICAgICAg ICBjb25zb2xlLmlubmVySFRNTCArPSAiPHNwYW4gc3R5bGU9J2NvbG9yOiBncmVlbjsgZm9udC13 ZWlnaHQ6IGJvbGQ7Jz5QQVNTPC9zcGFuPiAiK2V4cGVjdGVkKyIgZm9yICI7CisgICAgfSBlbHNl IHsKKyAgICAgICAgY29uc29sZS5pbm5lckhUTUwgKz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogcmVk OyBmb250LXdlaWdodDogYm9sZDsnPkZBSUxFRDwvc3Bhbj4gZXhwZWN0ZWQgIitleHBlY3RlZCsK KyAgICAgICAgCSIgYnV0IGdvdCAiK2FjdHVhbCsiIGZvciAiOworICAgIH0KKyAgICBjb25zb2xl LmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKGh0bWwpKTsKKyAgICBjb25zb2xl LmlubmVySFRNTCArPSAiPGJyPiI7CisgICAgYy5pbm5lckhUTUwgPSAiIjsKK30KKwordGVzdCgi PGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBpZD1zZWxlY3RlZD5oZWxsbyB3 b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9 J2JhY2tncm91bmQ6IGdyZWVuOyc+PHA+aGVsbG88L3A+PHNwYW4gaWQ9c2VsZWN0ZWQ+d29ybGQ8 L3NwYW4+PHA+d2Via2l0PC9wPjwvZGl2PiIsICdyZ2IoMCwgMTI4LCAwKScpOwordGVzdCgiPGRp diBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbyA8c3BhbiBzdHlsZT0nYmFja2dyb3Vu ZC1jb2xvcjogYmx1ZTsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwg MCwgMjU1KScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxz cGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7IHRvcDogMjAwcHg7JyBpZD1zZWxlY3RlZD53 b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDIwNCwgMjA0LCAyMDQpJyk7Cit0ZXN0KCI8ZGl2IHN0 eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNv bHV0ZTsgdG9wOiAzMDBweDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2Io MCwgMCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2Vs ZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+ IHdvcmxkPC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNr Z3JvdW5kOiBncmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9y OiB5ZWxsb3cnPmhlbGxvPC9zcGFuPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxs b3cnPiB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYg c3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tn cm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQt Y29sb3I6IGJsdWUnPiB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rl c3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2JhY2tncm91 bmQtY29sb3I6IHllbGxvdycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+IiwgJ3JnYigy NTUsIDI1NSwgMCknKTsKKworPC9zY3JpcHQ+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQo= 61094 2010-07-09 14:18:54 -0700 2010-07-09 18:31:32 -0700 fixed style: merged valueStyle in EditorCommand.cpp and Frame::selectionStartStylePropertyValue and added a special case to treat background color fix21680b text/plain 12221 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2Mjk4OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTAtMDctMDkgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcXVl cnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIHJldHVybnMgcmdiKDAsMCwwKSBmb3IgZWxlbWVu dHMgd2l0aCB0cmFuc3BhcmVudCBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTY4MAorCisgICAgICAgIFRoZSBidWcgd2FzIGNhdXNl ZCBieSB0aGUgZmFjdCB0aGF0IHRoZSBjb21wdXRlZCBzdHlsZSBvZiBhIHRyYW5zcGFyZW50IG5v ZGUgaW5kaWNhdGVzIHRoYXQKKyAgICAgICAgdGhlIGJhY2tncm91bmQgY29sb3IgaXMgcmdiYSgw LDAsMCwwKS4gV2hpbGUgdGhpcyBpcyBjb3JyZWN0IGluIHRoZSBhY2NvcmRhbmNlIHRvIENTUzIg YmVjYXVzZSBiYWNrZ3JvdW5kLWNvbG9yCisgICAgICAgIGlzIG5vdCBpbmhlcml0ZWQgYnkgZGVm YXVsdCwgdGhpcyBkb2Vzbid0IGdpdmUgdGhlIGRlc2lyZWQgcmVzdWx0IGZvciBlZGl0aW5nIHB1 cnBvc2VzLgorCisgICAgICAgIFRoaXMgcGF0Y2ggbW9kaWZpZXMgdmFsdWVTdHlsZSBpbiBFZGl0 b3JDb21tYW5kLmNwcCB0byB0cmF2ZXJzZSB0aGUgYW5jZXN0b3JzIG9mIHRoZSBjb21tb24gYW5j ZXN0b3IgY29udGFpbmVyCisgICAgICAgIHRvIHJldHJpZXZlIHRoZSBlZmZlY3RpdmUgYmFja2dy b3VuZCBjb2xvciBvZiB0aGUgc2VsZWN0ZWQgcmVnaW9uIHdoZW4gdGhlIG9yaWdpbmFsIGJhY2tn cm91bmQgY29sb3IgaXMgdHJhbnNwYXJlbnQKKyAgICAgICAgb3IgdGhlIHNlbGVjdGlvbiBpcyBy YW5nZS4gQmVjYXVzZSBGcmFtZTo6c2VsZWN0aW9uQ29tcHV0ZWRTdHlsZSByZXR1cm5zIHRoZSBj b21wdXRlZCBzdHlsZSBvZiB0aGUgc3RhcnQgb2YgYSBzZWxlY3Rpb24sCisgICAgICAgIHdlIG5l ZWQgdG8gYXZvaWQgcmV0cmlldmluZyB0aGUgYmFja2dyb3VuZCBjb2xvciB0aGF0IGlzIHByZXNl bnQgb25seSBhdCB0aGUgc3RhcnQgb2YgdGhlIHNlbGVjdGlvbi4KKyAgICAgICAgdmFsdWVTdHls ZSB0cmF2ZXJzZXMgYW5jZXN0b3JzIGFzIGxvbmcgYXMgdGhlIG5vZGUgaXMgdHJhbnNwYXJlbnQu CisgICAgICAgIGlzVHJhbnNwYXJlbnQsIGEgaGVscGVyIGZ1bmN0aW9uIHVzZWQgaW4gdmFsdWVT dHlsZSwgcmV0dXJucyB0cnVlIHdoZW4gYmFja2dyb3VuZCBjb2xvciBpcyB0cmFuc3BhcmVudCBv ciBSR0JBKDAsMCwwLDApCisKKyAgICAgICAgVGhpcyBwYXRjaCBhbHNvIHJlbW92ZXMgc2VsZWN0 aW9uU3RhcnRTdHlsZVByb3BlcnR5VmFsdWUgYW5kIG1pZ3JhdGVzIGl0IGludG8gdmFsdWVTdHls ZSBzaW5jZSBzZWxlY3Rpb25TdGFydFN0eWxlUHJvcGVydHlWYWx1ZQorICAgICAgICB3YXMgb25s eSB1c2VkIGluIHZhbHVlU3R5bGUuCisKKyAgICAgICAgVGVzdDogZWRpdGluZy9leGVjQ29tbWFu ZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbAorCisgICAgICAgICog ZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzVHJhbnNwYXJl bnQpOiBDaGVja3MgaWYgdGhlIGNvbXB1dGVkIHN0eWxlIGluZGljYXRlcyB0aGF0IGFuIGVsZW1l bnQgd2l0aCB0aGF0IHN0eWxlIGlzIHRyYW5zcGFyZW50CisgICAgICAgIChXZWJDb3JlOjp2YWx1 ZVN0eWxlKTogTWlncmF0ZWQgdGhlIGNvbnRlbnRzIG9mIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9w ZXJ0eVZhbHVlIGFuZCBhZGRlZCB0aGUgc3BlY2lhbCBjYXNlIGZvciBiYWNrZ3JvdW5kIGNvbG9y CisgICAgICAgICogcGFnZS9GcmFtZS5jcHA6CisgICAgICAgICogcGFnZS9GcmFtZS5oOgorCiAy MDEwLTA3LTA4ICBUb255IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgTmF0ZSBDaGFwaW4uCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9y Q29tbWFuZC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMjM1LDEwICsyMzUsNTIgQEAgc3RhdGljIFRyaVN0YXRlIHN0 YXRlU3R5bGUoRnJhbWUqIGZyYW1lLAogICAgIHN0eWxlLT5zZXRQcm9wZXJ0eShwcm9wZXJ0eUlE LCBkZXNpcmVkVmFsdWUpOwogICAgIHJldHVybiBmcmFtZS0+ZWRpdG9yKCktPnNlbGVjdGlvbkhh c1N0eWxlKHN0eWxlLmdldCgpKTsKIH0KKyAgICAKK3N0YXRpYyBib29sIGlzVHJhbnNwYXJlbnQo Q1NTU3R5bGVEZWNsYXJhdGlvbiogc3R5bGUpCit7CisgICAgUmVmUHRyPENTU1ZhbHVlPiBjc3NW YWx1ZSA9IHN0eWxlLT5nZXRQcm9wZXJ0eUNTU1ZhbHVlKENTU1Byb3BlcnR5QmFja2dyb3VuZENv bG9yKTsKKworICAgIGlmICghY3NzVmFsdWUtPmlzUHJpbWl0aXZlVmFsdWUoKSkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIENTU1ByaW1pdGl2ZVZhbHVlKiB2YWx1ZSA9IHN0YXRpY19jYXN0 PENTU1ByaW1pdGl2ZVZhbHVlKj4oY3NzVmFsdWUuZ2V0KCkpOwogCisgICAgcmV0dXJuICh2YWx1 ZS0+cHJpbWl0aXZlVHlwZSgpID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfUkdCQ09MT1IgJiYg dmFsdWUtPmdldFJHQkEzMlZhbHVlKCkgPT0gbWFrZVJHQkEoMCwgMCwgMCwgMCkpCisgICAgICAg IHx8ICh2YWx1ZS0+Z2V0SWRlbnQoKSA9PSBDU1NWYWx1ZVRyYW5zcGFyZW50KTsKK30KKyAgICAK IHN0YXRpYyBTdHJpbmcgdmFsdWVTdHlsZShGcmFtZSogZnJhbWUsIGludCBwcm9wZXJ0eUlEKQog ewotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uU3RhcnRTdHlsZVByb3BlcnR5VmFsdWUocHJv cGVydHlJRCk7CisgICAgTm9kZSogbm9kZVRvUmVtb3ZlOworICAgIC8vIEZJWE1FOiBSYXRoZXIg dGhhbiByZXRyaWV2aW5nIHRoZSBzdHlsZSBhdCB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgc2Vs ZWN0aW9uLAorICAgIC8vIHdlIHJldHJpZXZlIHRoZSBzdHlsZSBwcmVzZW50IHRocm91Z2hvdXQg dGhlIHNlbGVjdGlvbi4KKyAgICBSZWZQdHI8Q1NTU3R5bGVEZWNsYXJhdGlvbj4gc2VsZWN0aW9u U3R5bGUgPSBmcmFtZS0+c2VsZWN0aW9uQ29tcHV0ZWRTdHlsZShub2RlVG9SZW1vdmUpOworICAg IGlmICghc2VsZWN0aW9uU3R5bGUpCisgICAgICAgIHJldHVybiBTdHJpbmcoKTsKKworICAgIFN0 cmluZyB2YWx1ZSA9IHNlbGVjdGlvblN0eWxlLT5nZXRQcm9wZXJ0eVZhbHVlKHByb3BlcnR5SUQp OworCisgICAgaWYgKG5vZGVUb1JlbW92ZSkgeworICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0g MDsKKyAgICAgICAgbm9kZVRvUmVtb3ZlLT5yZW1vdmUoZWMpOworICAgICAgICBBU1NFUlQoIWVj KTsKKyAgICB9CisKKyAgICAvLyBJZiBiYWNrZ3JvdW5kIGNvbG9yIGlzIHRyYW5zcGFyZW50LCB0 cmF2ZXJzZSBwYXJlbnQgbm9kZXMgdW50aWwgd2UgaGl0IGEgZGlmZmVyZW50IHZhbHVlIG9yIGRv Y3VtZW50IHJvb3QKKyAgICAvLyBBbHNvLCBpZiB0aGUgc2VsZWN0aW9uIGlzIGEgcmFuZ2UsIGln bm9yZSB0aGUgYmFja2dyb3VuZCBjb2xvciBhdCB0aGUgc3RhcnQgb2Ygc2VsZWN0aW9uLAorICAg IC8vIGFuZCBmaW5kIHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIHRoZSBjb21tb24gYW5jZXN0b3Iu CisgICAgaWYgKHByb3BlcnR5SUQgPT0gQ1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29sb3IgJiYgKGZy YW1lLT5zZWxlY3Rpb24oKS0+aXNSYW5nZSgpIHx8IGlzVHJhbnNwYXJlbnQoc2VsZWN0aW9uU3R5 bGUuZ2V0KCkpKSkgeworICAgICAgICBSZWZQdHI8UmFuZ2U+IHJhbmdlKGZyYW1lLT5zZWxlY3Rp b24oKS0+dG9Ob3JtYWxpemVkUmFuZ2UoKSk7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAw OworICAgICAgICBOb2RlKiBhbmNlc3RvciA9IHJhbmdlLT5jb21tb25BbmNlc3RvckNvbnRhaW5l cihlYyk7CisgICAgICAgIEFTU0VSVChhbmNlc3Rvcik7CisgICAgICAgIGRvIHsKKyAgICAgICAg ICAgIHNlbGVjdGlvblN0eWxlID0gY29tcHV0ZWRTdHlsZShhbmNlc3Rvcik7CisgICAgICAgICAg ICBhbmNlc3RvciA9IGFuY2VzdG9yLT5wYXJlbnROb2RlKCk7CisgICAgICAgIH0gd2hpbGUgKGlz VHJhbnNwYXJlbnQoc2VsZWN0aW9uU3R5bGUuZ2V0KCkpKTsKKyAgICAgICAgdmFsdWUgPSBzZWxl Y3Rpb25TdHlsZS0+Z2V0UHJvcGVydHlWYWx1ZShDU1NQcm9wZXJ0eUJhY2tncm91bmRDb2xvcik7 CisgICAgfQorCisgICAgcmV0dXJuIHZhbHVlOwogfQogCiBzdGF0aWMgVHJpU3RhdGUgc3RhdGVU ZXh0V3JpdGluZ0RpcmVjdGlvbihGcmFtZSogZnJhbWUsIFdyaXRpbmdEaXJlY3Rpb24gZGlyZWN0 aW9uKQpJbmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BhZ2UvRnJhbWUuY3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvcGFnZS9GcmFtZS5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJDU1NNdXRhYmxl U3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU1Byb3BlcnR5LmgiCiAjaW5jbHVkZSAi Q1NTUHJvcGVydHlOYW1lcy5oIgorI2luY2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKICNpbmNs dWRlICJDYWNoZWRDU1NTdHlsZVNoZWV0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCiAjaW5jbHVk ZSAiQ2hyb21lQ2xpZW50LmgiCkBAIC03NjcsMjQgKzc2OCw2IEBAIHZvaWQgRnJhbWU6OmNvbXB1 dGVBbmRTZXRUeXBpbmdTdHlsZShDU1MKICAgICBtX3R5cGluZ1N0eWxlID0gbXV0YWJsZVN0eWxl LnJlbGVhc2UoKTsKIH0KIAotU3RyaW5nIEZyYW1lOjpzZWxlY3Rpb25TdGFydFN0eWxlUHJvcGVy dHlWYWx1ZShpbnQgc3R5bGVQcm9wZXJ0eUlEKSBjb25zdAotewotICAgIE5vZGUgKm5vZGVUb1Jl bW92ZTsKLSAgICBSZWZQdHI8Q1NTU3R5bGVEZWNsYXJhdGlvbj4gc2VsZWN0aW9uU3R5bGUgPSBz ZWxlY3Rpb25Db21wdXRlZFN0eWxlKG5vZGVUb1JlbW92ZSk7Ci0gICAgaWYgKCFzZWxlY3Rpb25T dHlsZSkKLSAgICAgICAgcmV0dXJuIFN0cmluZygpOwotCi0gICAgU3RyaW5nIHZhbHVlID0gc2Vs ZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUoc3R5bGVQcm9wZXJ0eUlEKTsKLQotICAgIGlm IChub2RlVG9SZW1vdmUpIHsKLSAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7Ci0gICAgICAg IG5vZGVUb1JlbW92ZS0+cmVtb3ZlKGVjKTsKLSAgICAgICAgQVNTRVJUKCFlYyk7Ci0gICAgfQot Ci0gICAgcmV0dXJuIHZhbHVlOwotfQotCiBQYXNzUmVmUHRyPENTU0NvbXB1dGVkU3R5bGVEZWNs YXJhdGlvbj4gRnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5bGUoTm9kZSomIG5vZGVUb1JlbW92 ZSkgY29uc3QKIHsKICAgICBub2RlVG9SZW1vdmUgPSAwOwpJbmRleDogV2ViQ29yZS9wYWdlL0Zy YW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJldmlzaW9uIDYyNjYz KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTE5Niw3ICsxOTYs NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TWFyayhjb25zdCBWaXNp YmxlU2VsZWN0aW9uJik7CiAKICAgICAgICAgdm9pZCBjb21wdXRlQW5kU2V0VHlwaW5nU3R5bGUo Q1NTU3R5bGVEZWNsYXJhdGlvbiogLCBFZGl0QWN0aW9uID0gRWRpdEFjdGlvblVuc3BlY2lmaWVk KTsKLSAgICAgICAgU3RyaW5nIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZhbHVlKGludCBz dHlsZVByb3BlcnR5SUQpIGNvbnN0OwogICAgICAgICB2b2lkIGFwcGx5RWRpdGluZ1N0eWxlVG9C b2R5RWxlbWVudCgpIGNvbnN0OwogICAgICAgICB2b2lkIGFwcGx5RWRpdGluZ1N0eWxlVG9FbGVt ZW50KEVsZW1lbnQqKSBjb25zdDsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNjI5ODgpCisrKyBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0w Ny0wOSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBxdWVyeUNvbW1hbmRWYWx1ZSgiQmFja0Nv bG9yIikgcmV0dXJucyByZ2IoMCwwLDApIGZvciBlbGVtZW50cyB3aXRoIHRyYW5zcGFyZW50IGJh Y2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIxNjgwCisKKyAgICAgICAgVGVzdHMgcXVlcnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIG9u IHZhcmlvdXMgY2FzZXMsIGVzcGVjaWFsbHkgdGhlIGNhc2VzIHdoZXJlIGJhY2tncm91bmQgY29s b3Igb2YKKyAgICAgICAgdGhlIHNlbGVjdGVkIG5vZGUgaXMgdHJhbnNwYXJlbnQgYnV0IHRoZSBi YWNrZ3JvdW5kIGNvbG9yIG9mIGl0cyBhbmNlc3RvciBoYXMgYSBjb2xvci4KKworICAgICAgICAq IGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9y LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9leGVjQ29tbWFuZC9xdWVy eS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbDogQWRkZWQuCisKIDIwMTAtMDct MDkgIFhpYW9tZWkgSmkgIDx4amlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IERhdmlkIExldmluLgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVy eS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3ItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1i YWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9y LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMSBAQAorUEFTUyByZ2IoMCwg MTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBpZD1zZWxl Y3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxk aXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHA+aGVsbG88L3A+PHNwYW4gaWQ9c2VsZWN0 ZWQ+d29ybGQ8L3NwYW4+PHA+d2Via2l0PC9wPjwvZGl2PgorUEFTUyByZ2IoMCwgMCwgMjU1KSBm b3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbyA8c3BhbiBzdHlsZT0nYmFj a2dyb3VuZC1jb2xvcjogYmx1ZTsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PgorRkFJ TEVEIGV4cGVjdGVkIHJnYigyMDQsIDIwNCwgMjA0KSBidXQgZ290IHJnYigwLCAxMjgsIDApIGZv ciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0 aW9uOiBhYnNvbHV0ZTsgdG9wOiAyMDBweDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2 PgorRkFJTEVEIGV4cGVjdGVkIHJnYigwLCAwLCAwKSBidXQgZ290IHJnYigwLCAxMjgsIDApIGZv ciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0 aW9uOiBhYnNvbHV0ZTsgdG9wOiAzMDBweDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2 PgorUEFTUyByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47 JyBpZD1zZWxlY3RlZD48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVsbG93Jz5oZWxs bzwvc3Bhbj4gd29ybGQ8L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9 J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQt Y29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6 IHllbGxvdyc+IHdvcmxkPC9zcGFuPjwvZGl2PgorUEFTUyByZ2IoMCwgMTI4LCAwKSBmb3IgPGRp diBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47JyBpZD1zZWxlY3RlZD48c3BhbiBzdHlsZT0nYmFj a2dyb3VuZC1jb2xvcjogeWVsbG93Jz5oZWxsbzwvc3Bhbj48c3BhbiBzdHlsZT0nYmFja2dyb3Vu ZC1jb2xvcjogYmx1ZSc+IHdvcmxkPC9zcGFuPjwvZGl2PgorUEFTUyByZ2IoMjU1LCAyNTUsIDAp IGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3Jv dW5kLWNvbG9yOiB5ZWxsb3cnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPgorCisKSW5k ZXg6IExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1i YWNrZ3JvdW5kLWNvbG9yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9l eGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFu ZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTgg QEAKKzxodG1sPgorPGJvZHkgc3R5bGU9ImJhY2tncm91bmQ6ICNjY2NjY2M7Ij4KKzxwIGlkPSJj b25zb2xlIj48L3A+Cis8ZGl2IGlkPSJiYWNrZ3JvdW5kIiBzdHlsZT0icG9zaXRpb246IGFic29s dXRlOyB0b3A6IDI5MHB4OyB3aWR0aDogNTAwcHg7IGhlaWdodDozZW07YmFja2dyb3VuZDogYmxh Y2s7Ij48L2Rpdj4KKzxkaXYgaWQ9ImNvbnRhaW5lciIgY29udGVudGVkaXRhYmxlPSJ0cnVlIj48 L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4gCisKK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OworCitmdW5jdGlvbiBnZXRDb2xvcihlKSB7CisgICAgaWYgKGRvY3VtZW50LnNlbGVjdGlvbikg eworICAgICAgICB2YXIgciA9IGRvY3VtZW50LnNlbGVjdGlvbi5jcmVhdGVSYW5nZSgpOworICAg ICAgICByLm1vdmVUb0VsZW1lbnRUZXh0KGUpOworICAgICAgICByLnNlbGVjdCgpOworICAgICAg ICBiYWNrQ29sb3IgPSBkb2N1bWVudC5xdWVyeUNvbW1hbmRWYWx1ZSgnYmFja0NvbG9yJyk7Cisg ICAgICAgIHIgPSAoYmFja0NvbG9yICYgMHhGRikKKyAgICAgICAgZyA9ICgoYmFja0NvbG9yID4+ IDgpICYgMHhGRikKKyAgICAgICAgYiA9ICgoYmFja0NvbG9yID4+IDE2KSAmIDB4RkYpCisgICAg ICAgIHJldHVybiAncmdiKCcrcisnLCAnK2crJywgJytiKycpJzsKKyAgICB9IGVsc2UgeworICAg ICAgICB2YXIgciA9IGRvY3VtZW50LmNyZWF0ZVJhbmdlKCk7CisgICAgICAgIHZhciBzID0gd2lu ZG93LmdldFNlbGVjdGlvbigpOworICAgICAgICByLnNldFN0YXJ0KGUsIDApOworICAgICAgICBy LnNldEVuZChlLCBlLmNoaWxkTm9kZXMubGVuZ3RoKTsKKyAgICAgICAgcy5yZW1vdmVBbGxSYW5n ZXMoKTsKKyAgICAgICAgcy5hZGRSYW5nZShyKTsKKyAgICAgICAgcmV0dXJuIGRvY3VtZW50LnF1 ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIHRlc3Qo aHRtbCwgZXhwZWN0ZWQpIHsKKyAgICB2YXIgYyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdj b250YWluZXInKTsKKyAgICBjLmlubmVySFRNTCA9IGh0bWw7CisgICAgdmFyIGFjdHVhbCA9IGdl dENvbG9yKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZWxlY3RlZCcpKTsKKyAgICB2YXIgY29u c29sZSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJyk7CisgICAgaWYgKGFjdHVh bCA9PSBleHBlY3RlZCkgeworICAgICAgICBjb25zb2xlLmlubmVySFRNTCArPSAiPHNwYW4gc3R5 bGU9J2NvbG9yOiBncmVlbjsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5QQVNTPC9zcGFuPiAiK2V4cGVj dGVkKyIgZm9yICI7CisgICAgfSBlbHNlIHsKKyAgICAgICAgY29uc29sZS5pbm5lckhUTUwgKz0g IjxzcGFuIHN0eWxlPSdjb2xvcjogcmVkOyBmb250LXdlaWdodDogYm9sZDsnPkZBSUxFRDwvc3Bh bj4gZXhwZWN0ZWQgIitleHBlY3RlZCsKKyAgICAgICAgCSIgYnV0IGdvdCAiK2FjdHVhbCsiIGZv ciAiOworICAgIH0KKyAgICBjb25zb2xlLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHRO b2RlKGh0bWwpKTsKKyAgICBjb25zb2xlLmlubmVySFRNTCArPSAiPGJyPiI7CisgICAgYy5pbm5l ckhUTUwgPSAiIjsKK30KKwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48 c3BhbiBpZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwg MCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHA+aGVsbG88L3A+ PHNwYW4gaWQ9c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+PHA+d2Via2l0PC9wPjwvZGl2PiIsICdyZ2Io MCwgMTI4LCAwKScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxs byA8c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZTsnIGlkPXNlbGVjdGVkPndvcmxk PC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMjU1KScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFj a2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7IHRv cDogMjAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDIwNCwgMjA0 LCAyMDQpJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvPHNw YW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAzMDBweDsnIGlkPXNlbGVjdGVkPndv cmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2Jh Y2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29s b3I6IHllbGxvdyc+aGVsbG88L3NwYW4+IHdvcmxkPC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7 Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFu IHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFuPjxzcGFuIHN0eWxl PSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAs IDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2Vs ZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+ PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWUnPiB3b3JsZDwvc3Bhbj48L2Rpdj4i LCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVu Oyc+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdycgaWQ9c2VsZWN0ZWQ+aGVs bG8gd29ybGQ8L3NwYW4+IiwgJ3JnYigyNTUsIDI1NSwgMCknKTsKKworPC9zY3JpcHQ+ClwgTm8g bmV3bGluZSBhdCBlbmQgb2YgZmlsZQo= 61136 2010-07-09 18:31:32 -0700 2010-07-09 18:35:15 -0700 fixed per Darin's comment fix21680c text/plain 13642 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2MzAwMykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzMgQEAKKzIwMTAtMDctMDkgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcXVl cnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIHJldHVybnMgcmdiKDAsMCwwKSBmb3IgZWxlbWVu dHMgd2l0aCB0cmFuc3BhcmVudCBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTY4MAorCisgICAgICAgIFRoZSBidWcgd2FzIGNhdXNl ZCBieSB0aGUgZmFjdCB0aGF0IHRoZSBjb21wdXRlZCBzdHlsZSBvZiBhIHRyYW5zcGFyZW50IG5v ZGUgaW5kaWNhdGVzIHRoYXQKKyAgICAgICAgdGhlIGJhY2tncm91bmQgY29sb3IgaXMgcmdiYSgw LDAsMCwwKS4gV2hpbGUgdGhpcyBpcyBjb3JyZWN0IGluIHRoZSBhY2NvcmRhbmNlIHRvIENTUzIg YmVjYXVzZSBiYWNrZ3JvdW5kLWNvbG9yCisgICAgICAgIGlzIG5vdCBpbmhlcml0ZWQgYnkgZGVm YXVsdCwgdGhpcyBkb2Vzbid0IGdpdmUgdGhlIGRlc2lyZWQgcmVzdWx0IGZvciBlZGl0aW5nIHB1 cnBvc2VzLgorCisgICAgICAgIE1vZGlmaWVkIHZhbHVlU3R5bGUgaW4gRWRpdG9yQ29tbWFuZC5j cHAgdG8gY2FsbCBFZGl0b3I6OnNlbGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUsIGluc3RlYWQgb2Yg RnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5bGUsCisgICAgICAgIHdoaWNoIHRyYXZlcnNlcyBj b21tb24gYW5jZXN0b3JzIG9mIHRoZSBzZWxlY3RlZCByYW5nZSBvciBjYXJldCB0byByZXRyaWV2 ZSB0aGUgZWZmZWN0aXZlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNlbGVjdGVkIHJlZ2lvbgor ICAgICAgICBpbnN0ZWFkIG9mIHRoZSBiYWNrZ3JvdW5kIGNvbG9yIGF0IHRoZSBzdGFydCBvZiB0 aGUgc2VsZWN0aW9uLiBUaGlzIHRha2VzIGVmZmVjdCB3aGVuIHRoZSBvcmlnaW5hbCBiYWNrZ3Jv dW5kIGNvbG9yIGlzIHRyYW5zcGFyZW50CisgICAgICAgIG9yIHRoZSBzZWxlY3Rpb24gaXMgcmFu Z2UgKHRvIGF2b2lkIHBpY2sgdXAgdGhlIGJhY2tncm91bmQgY29sb3Igb25seSBwcmVzZW50IGF0 IHRoZSBzdGFydCBvZiBwYXJhZ3JhcGgpLgorCisgICAgICAgIFJlbW92ZWQgc2VsZWN0aW9uU3Rh cnRTdHlsZVByb3BlcnR5VmFsdWUgYW5kIG1pZ3JhdGVkIGl0IHRvIEVkaXRvcjo6c2VsZWN0aW9u Q1NTUHJvcGVydHlWYWx1ZQorCisgICAgICAgIFRlc3Q6IGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKKworICAgICAgICAqIGVkaXRp bmcvRWRpdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzVHJhbnNwYXJlbnQpOiBDaGVja3Mg d2hldGhlciBhIG5vZGUgd2l0aCB0aGUgc3BlY2lmaWVkIHN0eWxlIGlzIHRyYW5zcGFyZW50IG9y IG5vdAorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVl KTogTWlncmF0ZWQgdGhlIGNvbnRlbnRzIG9mIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZh bHVlIGFuZAorICAgICAgICAgIGFkZGVkIHRoZSBzcGVjaWFsIGNhc2UgZm9yIGJhY2tncm91bmQg Y29sb3IKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5oOiBBZGRlZCB0aGUgcHJvdG90eXBlIGZv ciBzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVlCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnZhbHVlU3R5bGUpOiBjYWxscyBFZGl0b3I6OnNl bGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUKKyAgICAgICAgKiBwYWdlL0ZyYW1lLmNwcDogUmVtb3Zl ZCBzZWxlY3Rpb25Db21wdXRlZFN0eWxlCisgICAgICAgICogcGFnZS9GcmFtZS5oOiBkaXR0bwor CiAyMDEwLTA3LTA5ICBKZXN1cyBTYW5jaGV6LVBhbGVuY2lhICA8amVzdXMucGFsZW5jaWFAb3Bl bmJvc3NhLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlh bnNlbi4KSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvZWRp dGluZy9FZGl0b3IuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04NTUsNiArODU1LDU4IEBAIFRyaVN0 YXRlIEVkaXRvcjo6c2VsZWN0aW9uSGFzU3R5bGUoQ1NTU3QKIAogICAgIHJldHVybiBzdGF0ZTsK IH0KKworc3RhdGljIGJvb2wgaXNUcmFuc3BhcmVudChDU1NTdHlsZURlY2xhcmF0aW9uKiBzdHls ZSkKK3sKKwlSZWZQdHI8Q1NTVmFsdWU+IGNzc1ZhbHVlID0gc3R5bGUtPmdldFByb3BlcnR5Q1NT VmFsdWUoQ1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29sb3IpOworCisJaWYgKCFjc3NWYWx1ZS0+aXNQ cmltaXRpdmVWYWx1ZSgpKQorCQlyZXR1cm4gZmFsc2U7CisJQ1NTUHJpbWl0aXZlVmFsdWUqIHZh bHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihjc3NWYWx1ZS5nZXQoKSk7CisK KwlpZiAodmFsdWUtPnByaW1pdGl2ZVR5cGUoKSA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1JH QkNPTE9SKSB7CisJCUNvbG9yIGJhY2tncm91bmRDb2xvcih2YWx1ZS0+Z2V0UkdCQTMyVmFsdWUo KSk7CisJCXJldHVybiBiYWNrZ3JvdW5kQ29sb3IuaGFzQWxwaGEoKSAmJiBiYWNrZ3JvdW5kQ29s b3IuYWxwaGEoKSA9PSAwOworCX0KKworCXJldHVybiB2YWx1ZS0+Z2V0SWRlbnQoKSA9PSBDU1NW YWx1ZVRyYW5zcGFyZW50OworfQorCitTdHJpbmcgRWRpdG9yOjpzZWxlY3Rpb25DU1NQcm9wZXJ0 eVZhbHVlKGludCBwcm9wZXJ0eUlEKQoreworICAgIE5vZGUqIG5vZGVUb1JlbW92ZTsKKyAgICAv LyBGSVhNRTogUmF0aGVyIHRoYW4gcmV0cmlldmluZyB0aGUgc3R5bGUgYXQgdGhlIHN0YXJ0IG9m IHRoZSBjdXJyZW50IHNlbGVjdGlvbiwKKyAgICAvLyB3ZSByZXRyaWV2ZSB0aGUgc3R5bGUgcHJl c2VudCB0aHJvdWdob3V0IHRoZSBzZWxlY3Rpb24uCisgICAgUmVmUHRyPENTU1N0eWxlRGVjbGFy YXRpb24+IHNlbGVjdGlvblN0eWxlID0gbV9mcmFtZS0+c2VsZWN0aW9uQ29tcHV0ZWRTdHlsZShu b2RlVG9SZW1vdmUpOworICAgIGlmICghc2VsZWN0aW9uU3R5bGUpCisgICAgICAgIHJldHVybiBT dHJpbmcoKTsKKworICAgIFN0cmluZyB2YWx1ZSA9IHNlbGVjdGlvblN0eWxlLT5nZXRQcm9wZXJ0 eVZhbHVlKHByb3BlcnR5SUQpOworCisgICAgaWYgKG5vZGVUb1JlbW92ZSkgeworICAgICAgICBF eGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICAgICAgbm9kZVRvUmVtb3ZlLT5yZW1vdmUoZWMpOwor ICAgICAgICBBU1NFUlQoIWVjKTsKKyAgICB9CisKKyAgICAvLyBJZiBiYWNrZ3JvdW5kIGNvbG9y IGlzIHRyYW5zcGFyZW50LCB0cmF2ZXJzZSBwYXJlbnQgbm9kZXMgdW50aWwgd2UgaGl0IGEgZGlm ZmVyZW50IHZhbHVlIG9yIGRvY3VtZW50IHJvb3QKKyAgICAvLyBBbHNvLCBpZiB0aGUgc2VsZWN0 aW9uIGlzIGEgcmFuZ2UsIGlnbm9yZSB0aGUgYmFja2dyb3VuZCBjb2xvciBhdCB0aGUgc3RhcnQg b2Ygc2VsZWN0aW9uLAorICAgIC8vIGFuZCBmaW5kIHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIHRo ZSBjb21tb24gYW5jZXN0b3IuCisgICAgaWYgKHByb3BlcnR5SUQgPT0gQ1NTUHJvcGVydHlCYWNr Z3JvdW5kQ29sb3IgJiYgKG1fZnJhbWUtPnNlbGVjdGlvbigpLT5pc1JhbmdlKCkgfHwgaXNUcmFu c3BhcmVudChzZWxlY3Rpb25TdHlsZS5nZXQoKSkpKSB7CisgICAgICAgIFJlZlB0cjxSYW5nZT4g cmFuZ2UobV9mcmFtZS0+c2VsZWN0aW9uKCktPnRvTm9ybWFsaXplZFJhbmdlKCkpOworICAgICAg ICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICAgICAgTm9kZSogYW5jZXN0b3IgPSByYW5nZS0+ Y29tbW9uQW5jZXN0b3JDb250YWluZXIoZWMpOworICAgICAgICBBU1NFUlQoYW5jZXN0b3IpOwor ICAgICAgICBkbyB7CisgICAgICAgICAgICBzZWxlY3Rpb25TdHlsZSA9IGNvbXB1dGVkU3R5bGUo YW5jZXN0b3IpOworICAgICAgICAgICAgYW5jZXN0b3IgPSBhbmNlc3Rvci0+cGFyZW50Tm9kZSgp OworICAgICAgICB9IHdoaWxlIChpc1RyYW5zcGFyZW50KHNlbGVjdGlvblN0eWxlLmdldCgpKSk7 CisgICAgICAgIHZhbHVlID0gc2VsZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUoQ1NTUHJv cGVydHlCYWNrZ3JvdW5kQ29sb3IpOworICAgIH0KKworICAgIHJldHVybiB2YWx1ZTsKK30KKwog dm9pZCBFZGl0b3I6OmluZGVudCgpCiB7CiAgICAgYXBwbHlDb21tYW5kKEluZGVudE91dGRlbnRD b21tYW5kOjpjcmVhdGUobV9mcmFtZS0+ZG9jdW1lbnQoKSwgSW5kZW50T3V0ZGVudENvbW1hbmQ6 OkluZGVudCkpOwpJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAkocmV2aXNpb24gNjI2NjMpCisrKyBXZWJDb3JlL2Vk aXRpbmcvRWRpdG9yLmgJKHdvcmtpbmcgY29weSkKQEAgLTExNiw2ICsxMTYsNyBAQCBwdWJsaWM6 CiAgICAgdm9pZCByZXNwb25kVG9DaGFuZ2VkQ29udGVudHMoY29uc3QgVmlzaWJsZVNlbGVjdGlv biYgZW5kaW5nU2VsZWN0aW9uKTsKIAogICAgIFRyaVN0YXRlIHNlbGVjdGlvbkhhc1N0eWxlKENT U1N0eWxlRGVjbGFyYXRpb24qKSBjb25zdDsKKyAgICBTdHJpbmcgc2VsZWN0aW9uQ1NTUHJvcGVy dHlWYWx1ZShpbnQpOwogICAgIGNvbnN0IFNpbXBsZUZvbnREYXRhKiBmb250Rm9yU2VsZWN0aW9u KGJvb2wmKSBjb25zdDsKICAgICBXcml0aW5nRGlyZWN0aW9uIHRleHREaXJlY3Rpb25Gb3JTZWxl Y3Rpb24oYm9vbCYpIGNvbnN0OwogICAgIApJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNv bW1hbmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNw cAkocmV2aXNpb24gNjI2NjMpCisrKyBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTIzOCw3ICsyMzgsNyBAQCBzdGF0aWMgVHJpU3RhdGUgc3RhdGVT dHlsZShGcmFtZSogZnJhbWUsCiAKIHN0YXRpYyBTdHJpbmcgdmFsdWVTdHlsZShGcmFtZSogZnJh bWUsIGludCBwcm9wZXJ0eUlEKQogewotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uU3RhcnRT dHlsZVByb3BlcnR5VmFsdWUocHJvcGVydHlJRCk7CisgICAgcmV0dXJuIGZyYW1lLT5lZGl0b3Io KS0+c2VsZWN0aW9uQ1NTUHJvcGVydHlWYWx1ZShwcm9wZXJ0eUlEKTsKIH0KIAogc3RhdGljIFRy aVN0YXRlIHN0YXRlVGV4dFdyaXRpbmdEaXJlY3Rpb24oRnJhbWUqIGZyYW1lLCBXcml0aW5nRGly ZWN0aW9uIGRpcmVjdGlvbikKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNjI2NjMpCisrKyBXZWJDb3Jl L3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NjcsMjQgKzc2Nyw2IEBAIHZvaWQg RnJhbWU6OmNvbXB1dGVBbmRTZXRUeXBpbmdTdHlsZShDU1MKICAgICBtX3R5cGluZ1N0eWxlID0g bXV0YWJsZVN0eWxlLnJlbGVhc2UoKTsKIH0KIAotU3RyaW5nIEZyYW1lOjpzZWxlY3Rpb25TdGFy dFN0eWxlUHJvcGVydHlWYWx1ZShpbnQgc3R5bGVQcm9wZXJ0eUlEKSBjb25zdAotewotICAgIE5v ZGUgKm5vZGVUb1JlbW92ZTsKLSAgICBSZWZQdHI8Q1NTU3R5bGVEZWNsYXJhdGlvbj4gc2VsZWN0 aW9uU3R5bGUgPSBzZWxlY3Rpb25Db21wdXRlZFN0eWxlKG5vZGVUb1JlbW92ZSk7Ci0gICAgaWYg KCFzZWxlY3Rpb25TdHlsZSkKLSAgICAgICAgcmV0dXJuIFN0cmluZygpOwotCi0gICAgU3RyaW5n IHZhbHVlID0gc2VsZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUoc3R5bGVQcm9wZXJ0eUlE KTsKLQotICAgIGlmIChub2RlVG9SZW1vdmUpIHsKLSAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9 IDA7Ci0gICAgICAgIG5vZGVUb1JlbW92ZS0+cmVtb3ZlKGVjKTsKLSAgICAgICAgQVNTRVJUKCFl Yyk7Ci0gICAgfQotCi0gICAgcmV0dXJuIHZhbHVlOwotfQotCiBQYXNzUmVmUHRyPENTU0NvbXB1 dGVkU3R5bGVEZWNsYXJhdGlvbj4gRnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5bGUoTm9kZSom IG5vZGVUb1JlbW92ZSkgY29uc3QKIHsKICAgICBub2RlVG9SZW1vdmUgPSAwOwpJbmRleDogV2Vi Q29yZS9wYWdlL0ZyYW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHJl dmlzaW9uIDYyNjYzKQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcgY29weSkKQEAg LTE5Niw3ICsxOTYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TWFy ayhjb25zdCBWaXNpYmxlU2VsZWN0aW9uJik7CiAKICAgICAgICAgdm9pZCBjb21wdXRlQW5kU2V0 VHlwaW5nU3R5bGUoQ1NTU3R5bGVEZWNsYXJhdGlvbiogLCBFZGl0QWN0aW9uID0gRWRpdEFjdGlv blVuc3BlY2lmaWVkKTsKLSAgICAgICAgU3RyaW5nIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0 eVZhbHVlKGludCBzdHlsZVByb3BlcnR5SUQpIGNvbnN0OwogICAgICAgICB2b2lkIGFwcGx5RWRp dGluZ1N0eWxlVG9Cb2R5RWxlbWVudCgpIGNvbnN0OwogICAgICAgICB2b2lkIGFwcGx5RWRpdGlu Z1N0eWxlVG9FbGVtZW50KEVsZW1lbnQqKSBjb25zdDsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNjMw MDMpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwx NiBAQAorMjAxMC0wNy0wOSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBxdWVyeUNvbW1hbmRW YWx1ZSgiQmFja0NvbG9yIikgcmV0dXJucyByZ2IoMCwwLDApIGZvciBlbGVtZW50cyB3aXRoIHRy YW5zcGFyZW50IGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIxNjgwCisKKyAgICAgICAgVGVzdHMgcXVlcnlDb21tYW5kVmFsdWUoIkJh Y2tDb2xvciIpIG9uIHZhcmlvdXMgY2FzZXMsIGVzcGVjaWFsbHkgdGhlIGNhc2VzIHdoZXJlIGJh Y2tncm91bmQgY29sb3Igb2YKKyAgICAgICAgdGhlIHNlbGVjdGVkIG5vZGUgaXMgdHJhbnNwYXJl bnQgYnV0IHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIGl0cyBhbmNlc3RvciBoYXMgYSBjb2xvci4K KworICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNr Z3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9leGVj Q29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRtbDogQWRkZWQu CisKIDIwMTAtMDctMDkgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAg IFJldmlld2VkIGJ5IEFkYW0gQmFydGguCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWND b21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xvci1leHBlY3RlZC50eHQK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21t YW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysg TGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tn cm91bmQtY29sb3ItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDEzIEBACitQ QVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPjxz cGFuIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PgorUEFTUyByZ2IoMCwgMTI4 LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48cD5oZWxsbzwvcD48c3Bh biBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48cD53ZWJraXQ8L3A+PC9kaXY+CitQQVNTIHJnYigw LCAwLCAyNTUpIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhlbGxvIDxzcGFu IHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiBibHVlOycgaWQ9c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+ PC9kaXY+CitGQUlMRUQgZXhwZWN0ZWQgcmdiKDIwNCwgMjA0LCAyMDQpIGJ1dCBnb3QgcmdiKDAs IDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVsbG88c3BhbiBz dHlsZT0ncG9zaXRpb246IGFic29sdXRlOyB0b3A6IDIwMHB4OycgaWQ9c2VsZWN0ZWQ+d29ybGQ8 L3NwYW4+PC9kaXY+CitGQUlMRUQgZXhwZWN0ZWQgcmdiKDAsIDAsIDApIGJ1dCBnb3QgcmdiKDAs IDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVsbG88c3BhbiBz dHlsZT0ncG9zaXRpb246IGFic29sdXRlOyB0b3A6IDUwMHB4OycgaWQ9c2VsZWN0ZWQ+d29ybGQ8 L3NwYW4+PC9kaXY+CitQQVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3Jv dW5kOiBncmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5 ZWxsb3cnPmhlbGxvPC9zcGFuPiB3b3JsZDwvZGl2PgorUEFTUyByZ2IoMCwgMTI4LCAwKSBmb3Ig PGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47JyBpZD1zZWxlY3RlZD48c3BhbiBzdHlsZT0n YmFja2dyb3VuZC1jb2xvcjogeWVsbG93Jz5oZWxsbzwvc3Bhbj48c3BhbiBzdHlsZT0nYmFja2dy b3VuZC1jb2xvcjogeWVsbG93Jz4gd29ybGQ8L3NwYW4+PC9kaXY+CitQQVNTIHJnYigwLCAxMjgs IDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFu IHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFuPjxzcGFuIHN0eWxl PSdiYWNrZ3JvdW5kLWNvbG9yOiBibHVlJz4gd29ybGQ8L3NwYW4+PC9kaXY+CitQQVNTIHJnYigy NTUsIDI1NSwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5 bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3Nw YW4+PC9kaXY+CitQQVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5k OiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiByZ2JhKDI1NSwgMjU1LCAw LCAwKTsnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PgorUEFTUyByZ2JhKDI1 NSwgMjU1LCAwLCAwLjQ5NjA5NCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+ PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHJnYmEoMjU1LCAyNTUsIDAsIDAuNSk7JyBp ZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4KKworCkluZGV4OiBMYXlvdXRUZXN0 cy9lZGl0aW5nL2V4ZWNDb21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xv ci5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwJKHJldmlzaW9uIDApCisrKyBM YXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dy b3VuZC1jb2xvci5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYwIEBACis8aHRtbD4KKzxi b2R5IHN0eWxlPSJiYWNrZ3JvdW5kOiAjY2NjY2NjOyI+Cis8cCBpZD0iY29uc29sZSI+PC9wPgor PGRpdiBpZD0iYmFja2dyb3VuZCIgc3R5bGU9InBvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiA0OTBw eDsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6M2VtO2JhY2tncm91bmQ6IGJsYWNrOyI+PC9kaXY+Cis8 ZGl2IGlkPSJjb250YWluZXIiIGNvbnRlbnRlZGl0YWJsZT0idHJ1ZSI+PC9kaXY+Cis8c2NyaXB0 IHR5cGU9InRleHQvamF2YXNjcmlwdCI+IAorCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworZnVuY3Rpb24g Z2V0Q29sb3IoZSkgeworICAgIGlmIChkb2N1bWVudC5zZWxlY3Rpb24pIHsKKyAgICAgICAgdmFy IHIgPSBkb2N1bWVudC5zZWxlY3Rpb24uY3JlYXRlUmFuZ2UoKTsKKyAgICAgICAgci5tb3ZlVG9F bGVtZW50VGV4dChlKTsKKyAgICAgICAgci5zZWxlY3QoKTsKKyAgICAgICAgYmFja0NvbG9yID0g ZG9jdW1lbnQucXVlcnlDb21tYW5kVmFsdWUoJ2JhY2tDb2xvcicpOworICAgICAgICByID0gKGJh Y2tDb2xvciAmIDB4RkYpCisgICAgICAgIGcgPSAoKGJhY2tDb2xvciA+PiA4KSAmIDB4RkYpCisg ICAgICAgIGIgPSAoKGJhY2tDb2xvciA+PiAxNikgJiAweEZGKQorICAgICAgICByZXR1cm4gJ3Jn YignK3IrJywgJytnKycsICcrYisnKSc7CisgICAgfSBlbHNlIHsKKyAgICAgICAgdmFyIHIgPSBk b2N1bWVudC5jcmVhdGVSYW5nZSgpOworICAgICAgICB2YXIgcyA9IHdpbmRvdy5nZXRTZWxlY3Rp b24oKTsKKyAgICAgICAgci5zZXRTdGFydChlLCAwKTsKKyAgICAgICAgci5zZXRFbmQoZSwgZS5j aGlsZE5vZGVzLmxlbmd0aCk7CisgICAgICAgIHMucmVtb3ZlQWxsUmFuZ2VzKCk7CisgICAgICAg IHMuYWRkUmFuZ2Uocik7CisgICAgICAgIHJldHVybiBkb2N1bWVudC5xdWVyeUNvbW1hbmRWYWx1 ZSgnYmFja0NvbG9yJyk7CisgICAgfQorfQorCitmdW5jdGlvbiB0ZXN0KGh0bWwsIGV4cGVjdGVk KSB7CisgICAgdmFyIGMgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVyJyk7Cisg ICAgYy5pbm5lckhUTUwgPSBodG1sOworICAgIHZhciBhY3R1YWwgPSBnZXRDb2xvcihkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnc2VsZWN0ZWQnKSk7CisgICAgdmFyIGNvbnNvbGUgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnY29uc29sZScpOworICAgIGlmIChhY3R1YWwgPT0gZXhwZWN0ZWQp IHsKKyAgICAgICAgY29uc29sZS5pbm5lckhUTUwgKz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogZ3Jl ZW47IGZvbnQtd2VpZ2h0OiBib2xkOyc+UEFTUzwvc3Bhbj4gIitleHBlY3RlZCsiIGZvciAiOwor ICAgIH0gZWxzZSB7CisgICAgICAgIGNvbnNvbGUuaW5uZXJIVE1MICs9ICI8c3BhbiBzdHlsZT0n Y29sb3I6IHJlZDsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5GQUlMRUQ8L3NwYW4+IGV4cGVjdGVkICIr ZXhwZWN0ZWQrCisgICAgICAgIAkiIGJ1dCBnb3QgIithY3R1YWwrIiBmb3IgIjsKKyAgICB9Cisg ICAgY29uc29sZS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShodG1sKSk7Cisg ICAgY29uc29sZS5pbm5lckhUTUwgKz0gIjxicj4iOworICAgIGMuaW5uZXJIVE1MID0gIiI7Cit9 CisKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gaWQ9c2VsZWN0 ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7Cit0ZXN0KCI8 ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPjxwPmhlbGxvPC9wPjxzcGFuIGlkPXNlbGVj dGVkPndvcmxkPC9zcGFuPjxwPndlYmtpdDwvcD48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsK K3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVsbG8gPHNwYW4gc3R5bGU9 J2JhY2tncm91bmQtY29sb3I6IGJsdWU7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4i LCAncmdiKDAsIDAsIDI1NSknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVu Oyc+aGVsbG88c3BhbiBzdHlsZT0ncG9zaXRpb246IGFic29sdXRlOyB0b3A6IDIwMHB4OycgaWQ9 c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigyMDQsIDIwNCwgMjA0KScpOwordGVz dCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3Np dGlvbjogYWJzb2x1dGU7IHRvcDogNTAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rp dj4iLCAncmdiKDAsIDAsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVl bjsnIGlkPXNlbGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhl bGxvPC9zcGFuPiB3b3JsZDwvZGl2PiIsICdyZ2IoMCwgMTI4LCAwKScpOwordGVzdCgiPGRpdiBz dHlsZT0nYmFja2dyb3VuZDogZ3JlZW47JyBpZD1zZWxlY3RlZD48c3BhbiBzdHlsZT0nYmFja2dy b3VuZC1jb2xvcjogeWVsbG93Jz5oZWxsbzwvc3Bhbj48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1j b2xvcjogeWVsbG93Jz4gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7Cit0 ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFuIHN0 eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFuPjxzcGFuIHN0eWxlPSdi YWNrZ3JvdW5kLWNvbG9yOiBibHVlJz4gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAxMjgs IDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPjxzcGFuIHN0eWxl PSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFu PjwvZGl2PiIsICdyZ2IoMjU1LCAyNTUsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3Jv dW5kOiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiByZ2JhKDI1NSwgMjU1 LCAwLCAwKTsnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwg MTI4LCAwKScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBz dHlsZT0nYmFja2dyb3VuZC1jb2xvcjogcmdiYSgyNTUsIDI1NSwgMCwgMC41KTsnIGlkPXNlbGVj dGVkPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2JhKDI1NSwgMjU1LCAwLCAwLjQ5NjA5 NCknKTsKKworPC9zY3JpcHQ+Cg== 61137 2010-07-09 18:35:15 -0700 2010-08-30 11:06:20 -0700 fixed style and FIXME fix21680c text/plain 13674 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2MzAwMykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzMgQEAKKzIwMTAtMDctMDkgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcXVl cnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIHJldHVybnMgcmdiKDAsMCwwKSBmb3IgZWxlbWVu dHMgd2l0aCB0cmFuc3BhcmVudCBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTY4MAorCisgICAgICAgIFRoZSBidWcgd2FzIGNhdXNl ZCBieSB0aGUgZmFjdCB0aGF0IHRoZSBjb21wdXRlZCBzdHlsZSBvZiBhIHRyYW5zcGFyZW50IG5v ZGUgaW5kaWNhdGVzIHRoYXQKKyAgICAgICAgdGhlIGJhY2tncm91bmQgY29sb3IgaXMgcmdiYSgw LDAsMCwwKS4gV2hpbGUgdGhpcyBpcyBjb3JyZWN0IGluIHRoZSBhY2NvcmRhbmNlIHRvIENTUzIg YmVjYXVzZSBiYWNrZ3JvdW5kLWNvbG9yCisgICAgICAgIGlzIG5vdCBpbmhlcml0ZWQgYnkgZGVm YXVsdCwgdGhpcyBkb2Vzbid0IGdpdmUgdGhlIGRlc2lyZWQgcmVzdWx0IGZvciBlZGl0aW5nIHB1 cnBvc2VzLgorCisgICAgICAgIE1vZGlmaWVkIHZhbHVlU3R5bGUgaW4gRWRpdG9yQ29tbWFuZC5j cHAgdG8gY2FsbCBFZGl0b3I6OnNlbGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUsIGluc3RlYWQgb2Yg RnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5bGUsCisgICAgICAgIHdoaWNoIHRyYXZlcnNlcyBj b21tb24gYW5jZXN0b3JzIG9mIHRoZSBzZWxlY3RlZCByYW5nZSBvciBjYXJldCB0byByZXRyaWV2 ZSB0aGUgZWZmZWN0aXZlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNlbGVjdGVkIHJlZ2lvbgor ICAgICAgICBpbnN0ZWFkIG9mIHRoZSBiYWNrZ3JvdW5kIGNvbG9yIGF0IHRoZSBzdGFydCBvZiB0 aGUgc2VsZWN0aW9uLiBUaGlzIHRha2VzIGVmZmVjdCB3aGVuIHRoZSBvcmlnaW5hbCBiYWNrZ3Jv dW5kIGNvbG9yIGlzIHRyYW5zcGFyZW50CisgICAgICAgIG9yIHRoZSBzZWxlY3Rpb24gaXMgcmFu Z2UgKHRvIGF2b2lkIHBpY2sgdXAgdGhlIGJhY2tncm91bmQgY29sb3Igb25seSBwcmVzZW50IGF0 IHRoZSBzdGFydCBvZiBwYXJhZ3JhcGgpLgorCisgICAgICAgIFJlbW92ZWQgc2VsZWN0aW9uU3Rh cnRTdHlsZVByb3BlcnR5VmFsdWUgYW5kIG1pZ3JhdGVkIGl0IHRvIEVkaXRvcjo6c2VsZWN0aW9u Q1NTUHJvcGVydHlWYWx1ZQorCisgICAgICAgIFRlc3Q6IGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKKworICAgICAgICAqIGVkaXRp bmcvRWRpdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzVHJhbnNwYXJlbnQpOiBDaGVja3Mg d2hldGhlciBhIG5vZGUgd2l0aCB0aGUgc3BlY2lmaWVkIHN0eWxlIGlzIHRyYW5zcGFyZW50IG9y IG5vdAorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVl KTogTWlncmF0ZWQgdGhlIGNvbnRlbnRzIG9mIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZh bHVlIGFuZAorICAgICAgICAgIGFkZGVkIHRoZSBzcGVjaWFsIGNhc2UgZm9yIGJhY2tncm91bmQg Y29sb3IKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5oOiBBZGRlZCB0aGUgcHJvdG90eXBlIGZv ciBzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVlCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnZhbHVlU3R5bGUpOiBjYWxscyBFZGl0b3I6OnNl bGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUKKyAgICAgICAgKiBwYWdlL0ZyYW1lLmNwcDogUmVtb3Zl ZCBzZWxlY3Rpb25Db21wdXRlZFN0eWxlCisgICAgICAgICogcGFnZS9GcmFtZS5oOiBkaXR0bwor CiAyMDEwLTA3LTA5ICBKZXN1cyBTYW5jaGV6LVBhbGVuY2lhICA8amVzdXMucGFsZW5jaWFAb3Bl bmJvc3NhLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlh bnNlbi4KSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvZWRp dGluZy9FZGl0b3IuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04NTUsNiArODU1LDU4IEBAIFRyaVN0 YXRlIEVkaXRvcjo6c2VsZWN0aW9uSGFzU3R5bGUoQ1NTU3QKIAogICAgIHJldHVybiBzdGF0ZTsK IH0KKworc3RhdGljIGJvb2wgaXNUcmFuc3BhcmVudChDU1NTdHlsZURlY2xhcmF0aW9uKiBzdHls ZSkKK3sKKyAgICBSZWZQdHI8Q1NTVmFsdWU+IGNzc1ZhbHVlID0gc3R5bGUtPmdldFByb3BlcnR5 Q1NTVmFsdWUoQ1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29sb3IpOworCisgICAgaWYgKCFjc3NWYWx1 ZS0+aXNQcmltaXRpdmVWYWx1ZSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgQ1NTUHJp bWl0aXZlVmFsdWUqIHZhbHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihjc3NW YWx1ZS5nZXQoKSk7CisKKyAgICBpZiAodmFsdWUtPnByaW1pdGl2ZVR5cGUoKSA9PSBDU1NQcmlt aXRpdmVWYWx1ZTo6Q1NTX1JHQkNPTE9SKSB7CisgICAgICAgIENvbG9yIGJhY2tncm91bmRDb2xv cih2YWx1ZS0+Z2V0UkdCQTMyVmFsdWUoKSk7CisgICAgICAgIHJldHVybiBiYWNrZ3JvdW5kQ29s b3IuaGFzQWxwaGEoKSAmJiAhYmFja2dyb3VuZENvbG9yLmFscGhhKCk7CisgICAgfQorCisgICAg cmV0dXJuIHZhbHVlLT5nZXRJZGVudCgpID09IENTU1ZhbHVlVHJhbnNwYXJlbnQ7Cit9CisKK1N0 cmluZyBFZGl0b3I6OnNlbGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUoaW50IHByb3BlcnR5SUQpCit7 CisgICAgTm9kZSogbm9kZVRvUmVtb3ZlOworICAgIC8vIEZJWE1FOiBSYXRoZXIgdGhhbiByZXRy aWV2aW5nIHRoZSBzdHlsZSBhdCB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgc2VsZWN0aW9uLAor ICAgIC8vIHdlIHJldHJpZXZlIHRoZSBzdHlsZSBwcmVzZW50IHRocm91Z2hvdXQgdGhlIHNlbGVj dGlvbi4KKyAgICBSZWZQdHI8Q1NTU3R5bGVEZWNsYXJhdGlvbj4gc2VsZWN0aW9uU3R5bGUgPSBt X2ZyYW1lLT5zZWxlY3Rpb25Db21wdXRlZFN0eWxlKG5vZGVUb1JlbW92ZSk7CisgICAgaWYgKCFz ZWxlY3Rpb25TdHlsZSkKKyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAgU3RyaW5nIHZh bHVlID0gc2VsZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUocHJvcGVydHlJRCk7CisKKyAg ICBpZiAobm9kZVRvUmVtb3ZlKSB7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAg ICAgICBub2RlVG9SZW1vdmUtPnJlbW92ZShlYyk7CisgICAgICAgIEFTU0VSVCghZWMpOworICAg IH0KKworICAgIC8vIElmIGJhY2tncm91bmQgY29sb3IgaXMgdHJhbnNwYXJlbnQsIHRyYXZlcnNl IHBhcmVudCBub2RlcyB1bnRpbCB3ZSBoaXQgYSBkaWZmZXJlbnQgdmFsdWUgb3IgZG9jdW1lbnQg cm9vdAorICAgIC8vIEFsc28sIGlmIHRoZSBzZWxlY3Rpb24gaXMgYSByYW5nZSwgaWdub3JlIHRo ZSBiYWNrZ3JvdW5kIGNvbG9yIGF0IHRoZSBzdGFydCBvZiBzZWxlY3Rpb24sCisgICAgLy8gYW5k IGZpbmQgdGhlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIGNvbW1vbiBhbmNlc3Rvci4KKyAgICBp ZiAocHJvcGVydHlJRCA9PSBDU1NQcm9wZXJ0eUJhY2tncm91bmRDb2xvciAmJiAobV9mcmFtZS0+ c2VsZWN0aW9uKCktPmlzUmFuZ2UoKSB8fCBpc1RyYW5zcGFyZW50KHNlbGVjdGlvblN0eWxlLmdl dCgpKSkpIHsKKyAgICAgICAgUmVmUHRyPFJhbmdlPiByYW5nZShtX2ZyYW1lLT5zZWxlY3Rpb24o KS0+dG9Ob3JtYWxpemVkUmFuZ2UoKSk7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwor ICAgICAgICBOb2RlKiBhbmNlc3RvciA9IHJhbmdlLT5jb21tb25BbmNlc3RvckNvbnRhaW5lcihl Yyk7CisgICAgICAgIEFTU0VSVChhbmNlc3Rvcik7CisgICAgICAgIGRvIHsKKyAgICAgICAgICAg IHNlbGVjdGlvblN0eWxlID0gY29tcHV0ZWRTdHlsZShhbmNlc3Rvcik7CisgICAgICAgICAgICBh bmNlc3RvciA9IGFuY2VzdG9yLT5wYXJlbnROb2RlKCk7CisgICAgICAgIH0gd2hpbGUgKGlzVHJh bnNwYXJlbnQoc2VsZWN0aW9uU3R5bGUuZ2V0KCkpKTsKKyAgICAgICAgdmFsdWUgPSBzZWxlY3Rp b25TdHlsZS0+Z2V0UHJvcGVydHlWYWx1ZShDU1NQcm9wZXJ0eUJhY2tncm91bmRDb2xvcik7Cisg ICAgfQorCisgICAgcmV0dXJuIHZhbHVlOworfQorCiB2b2lkIEVkaXRvcjo6aW5kZW50KCkKIHsK ICAgICBhcHBseUNvbW1hbmQoSW5kZW50T3V0ZGVudENvbW1hbmQ6OmNyZWF0ZShtX2ZyYW1lLT5k b2N1bWVudCgpLCBJbmRlbnRPdXRkZW50Q29tbWFuZDo6SW5kZW50KSk7CkluZGV4OiBXZWJDb3Jl L2VkaXRpbmcvRWRpdG9yLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5o CShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAkod29ya2luZyBj b3B5KQpAQCAtMTE2LDYgKzExNiw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlc3BvbmRUb0NoYW5n ZWRDb250ZW50cyhjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBlbmRpbmdTZWxlY3Rpb24pOwogCiAg ICAgVHJpU3RhdGUgc2VsZWN0aW9uSGFzU3R5bGUoQ1NTU3R5bGVEZWNsYXJhdGlvbiopIGNvbnN0 OworICAgIFN0cmluZyBzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVlKGludCk7CiAgICAgY29uc3Qg U2ltcGxlRm9udERhdGEqIGZvbnRGb3JTZWxlY3Rpb24oYm9vbCYpIGNvbnN0OwogICAgIFdyaXRp bmdEaXJlY3Rpb24gdGV4dERpcmVjdGlvbkZvclNlbGVjdGlvbihib29sJikgY29uc3Q7CiAgICAg CkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdl YkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjM4LDcg KzIzOCw3IEBAIHN0YXRpYyBUcmlTdGF0ZSBzdGF0ZVN0eWxlKEZyYW1lKiBmcmFtZSwKIAogc3Rh dGljIFN0cmluZyB2YWx1ZVN0eWxlKEZyYW1lKiBmcmFtZSwgaW50IHByb3BlcnR5SUQpCiB7Ci0g ICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb25TdGFydFN0eWxlUHJvcGVydHlWYWx1ZShwcm9wZXJ0 eUlEKTsKKyAgICByZXR1cm4gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25DU1NQcm9wZXJ0eVZh bHVlKHByb3BlcnR5SUQpOwogfQogCiBzdGF0aWMgVHJpU3RhdGUgc3RhdGVUZXh0V3JpdGluZ0Rp cmVjdGlvbihGcmFtZSogZnJhbWUsIFdyaXRpbmdEaXJlY3Rpb24gZGlyZWN0aW9uKQpJbmRleDog V2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRnJhbWUu Y3BwCShyZXZpc2lvbiA2MjY2MykKKysrIFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTc2NywyNCArNzY3LDYgQEAgdm9pZCBGcmFtZTo6Y29tcHV0ZUFuZFNldFR5cGlu Z1N0eWxlKENTUwogICAgIG1fdHlwaW5nU3R5bGUgPSBtdXRhYmxlU3R5bGUucmVsZWFzZSgpOwog fQogCi1TdHJpbmcgRnJhbWU6OnNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZhbHVlKGludCBz dHlsZVByb3BlcnR5SUQpIGNvbnN0Ci17Ci0gICAgTm9kZSAqbm9kZVRvUmVtb3ZlOwotICAgIFJl ZlB0cjxDU1NTdHlsZURlY2xhcmF0aW9uPiBzZWxlY3Rpb25TdHlsZSA9IHNlbGVjdGlvbkNvbXB1 dGVkU3R5bGUobm9kZVRvUmVtb3ZlKTsKLSAgICBpZiAoIXNlbGVjdGlvblN0eWxlKQotICAgICAg ICByZXR1cm4gU3RyaW5nKCk7Ci0KLSAgICBTdHJpbmcgdmFsdWUgPSBzZWxlY3Rpb25TdHlsZS0+ Z2V0UHJvcGVydHlWYWx1ZShzdHlsZVByb3BlcnR5SUQpOwotCi0gICAgaWYgKG5vZGVUb1JlbW92 ZSkgewotICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKLSAgICAgICAgbm9kZVRvUmVtb3Zl LT5yZW1vdmUoZWMpOwotICAgICAgICBBU1NFUlQoIWVjKTsKLSAgICB9Ci0KLSAgICByZXR1cm4g dmFsdWU7Ci19Ci0KIFBhc3NSZWZQdHI8Q1NTQ29tcHV0ZWRTdHlsZURlY2xhcmF0aW9uPiBGcmFt ZTo6c2VsZWN0aW9uQ29tcHV0ZWRTdHlsZShOb2RlKiYgbm9kZVRvUmVtb3ZlKSBjb25zdAogewog ICAgIG5vZGVUb1JlbW92ZSA9IDA7CkluZGV4OiBXZWJDb3JlL3BhZ2UvRnJhbWUuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRnJhbWUuaAkocmV2aXNpb24gNjI2NjMpCisrKyBXZWJDb3Jl L3BhZ2UvRnJhbWUuaAkod29ya2luZyBjb3B5KQpAQCAtMTk2LDcgKzE5Niw2IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRNYXJrKGNvbnN0IFZpc2libGVTZWxlY3Rpb24m KTsKIAogICAgICAgICB2b2lkIGNvbXB1dGVBbmRTZXRUeXBpbmdTdHlsZShDU1NTdHlsZURlY2xh cmF0aW9uKiAsIEVkaXRBY3Rpb24gPSBFZGl0QWN0aW9uVW5zcGVjaWZpZWQpOwotICAgICAgICBT dHJpbmcgc2VsZWN0aW9uU3RhcnRTdHlsZVByb3BlcnR5VmFsdWUoaW50IHN0eWxlUHJvcGVydHlJ RCkgY29uc3Q7CiAgICAgICAgIHZvaWQgYXBwbHlFZGl0aW5nU3R5bGVUb0JvZHlFbGVtZW50KCkg Y29uc3Q7CiAgICAgICAgIHZvaWQgYXBwbHlFZGl0aW5nU3R5bGVUb0VsZW1lbnQoRWxlbWVudCop IGNvbnN0OwogCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA2MzAwMykKKysrIExheW91dFRlc3RzL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA3LTA5ICBSeW9zdWtl IE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIHF1ZXJ5Q29tbWFuZFZhbHVlKCJCYWNrQ29sb3IiKSByZXR1cm5z IHJnYigwLDAsMCkgZm9yIGVsZW1lbnRzIHdpdGggdHJhbnNwYXJlbnQgYmFja2dyb3VuZAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2ODAKKworICAg ICAgICBUZXN0cyBxdWVyeUNvbW1hbmRWYWx1ZSgiQmFja0NvbG9yIikgb24gdmFyaW91cyBjYXNl cywgZXNwZWNpYWxseSB0aGUgY2FzZXMgd2hlcmUgYmFja2dyb3VuZCBjb2xvciBvZgorICAgICAg ICB0aGUgc2VsZWN0ZWQgbm9kZSBpcyB0cmFuc3BhcmVudCBidXQgdGhlIGJhY2tncm91bmQgY29s b3Igb2YgaXRzIGFuY2VzdG9yIGhhcyBhIGNvbG9yLgorCisgICAgICAgICogZWRpdGluZy9leGVj Q29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3ItZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL2V4ZWNDb21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFs dWUtYmFja2dyb3VuZC1jb2xvci5odG1sOiBBZGRlZC4KKwogMjAxMC0wNy0wOSAgRXJpYyBTZWlk ZWwgIDxlcmljQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4K SW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1 ZS1iYWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9lZGl0aW5nL2V4ZWNDb21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xv ci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWND b21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xvci1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMgQEAKK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxk aXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gaWQ9c2VsZWN0ZWQ+aGVsbG8gd29y bGQ8L3NwYW4+PC9kaXY+CitQQVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNr Z3JvdW5kOiBncmVlbjsnPjxwPmhlbGxvPC9wPjxzcGFuIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFu PjxwPndlYmtpdDwvcD48L2Rpdj4KK1BBU1MgcmdiKDAsIDAsIDI1NSkgZm9yIDxkaXYgc3R5bGU9 J2JhY2tncm91bmQ6IGdyZWVuOyc+aGVsbG8gPHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6 IGJsdWU7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK0ZBSUxFRCBleHBlY3RlZCBy Z2IoMjA0LCAyMDQsIDIwNCkgYnV0IGdvdCByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0n YmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7 IHRvcDogMjAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK0ZBSUxFRCBleHBl Y3RlZCByZ2IoMCwgMCwgMCkgYnV0IGdvdCByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0n YmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7 IHRvcDogNTAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAs IDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+ PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+IHdvcmxk PC9kaXY+CitQQVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBn cmVlbjsnIGlkPXNlbGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cn PmhlbGxvPC9zcGFuPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3Js ZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tn cm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6 IHllbGxvdyc+aGVsbG88L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWUn PiB3b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDI1NSwgMjU1LCAwKSBmb3IgPGRpdiBzdHls ZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVs bG93JyBpZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAsIDEy OCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2Jh Y2tncm91bmQtY29sb3I6IHJnYmEoMjU1LCAyNTUsIDAsIDApOycgaWQ9c2VsZWN0ZWQ+aGVsbG8g d29ybGQ8L3NwYW4+PC9kaXY+CitQQVNTIHJnYmEoMjU1LCAyNTUsIDAsIDAuNDk2MDk0KSBmb3Ig PGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1j b2xvcjogcmdiYSgyNTUsIDI1NSwgMCwgMC41KTsnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9z cGFuPjwvZGl2PgorCisKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91 bmQtY29sb3IuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0Nv bW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsNjAgQEAKKzxodG1sPgorPGJvZHkgc3R5bGU9ImJhY2tncm91bmQ6ICNj Y2NjY2M7Ij4KKzxwIGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJiYWNrZ3JvdW5kIiBzdHls ZT0icG9zaXRpb246IGFic29sdXRlOyB0b3A6IDQ5MHB4OyB3aWR0aDogNTAwcHg7IGhlaWdodDoz ZW07YmFja2dyb3VuZDogYmxhY2s7Ij48L2Rpdj4KKzxkaXYgaWQ9ImNvbnRhaW5lciIgY29udGVu dGVkaXRhYmxlPSJ0cnVlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4g CisKK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBnZXRDb2xvcihlKSB7CisgICAgaWYgKGRv Y3VtZW50LnNlbGVjdGlvbikgeworICAgICAgICB2YXIgciA9IGRvY3VtZW50LnNlbGVjdGlvbi5j cmVhdGVSYW5nZSgpOworICAgICAgICByLm1vdmVUb0VsZW1lbnRUZXh0KGUpOworICAgICAgICBy LnNlbGVjdCgpOworICAgICAgICBiYWNrQ29sb3IgPSBkb2N1bWVudC5xdWVyeUNvbW1hbmRWYWx1 ZSgnYmFja0NvbG9yJyk7CisgICAgICAgIHIgPSAoYmFja0NvbG9yICYgMHhGRikKKyAgICAgICAg ZyA9ICgoYmFja0NvbG9yID4+IDgpICYgMHhGRikKKyAgICAgICAgYiA9ICgoYmFja0NvbG9yID4+ IDE2KSAmIDB4RkYpCisgICAgICAgIHJldHVybiAncmdiKCcrcisnLCAnK2crJywgJytiKycpJzsK KyAgICB9IGVsc2UgeworICAgICAgICB2YXIgciA9IGRvY3VtZW50LmNyZWF0ZVJhbmdlKCk7Cisg ICAgICAgIHZhciBzID0gd2luZG93LmdldFNlbGVjdGlvbigpOworICAgICAgICByLnNldFN0YXJ0 KGUsIDApOworICAgICAgICByLnNldEVuZChlLCBlLmNoaWxkTm9kZXMubGVuZ3RoKTsKKyAgICAg ICAgcy5yZW1vdmVBbGxSYW5nZXMoKTsKKyAgICAgICAgcy5hZGRSYW5nZShyKTsKKyAgICAgICAg cmV0dXJuIGRvY3VtZW50LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKTsKKyAgICB9Cit9 CisKK2Z1bmN0aW9uIHRlc3QoaHRtbCwgZXhwZWN0ZWQpIHsKKyAgICB2YXIgYyA9IGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCdjb250YWluZXInKTsKKyAgICBjLmlubmVySFRNTCA9IGh0bWw7Cisg ICAgdmFyIGFjdHVhbCA9IGdldENvbG9yKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZWxlY3Rl ZCcpKTsKKyAgICB2YXIgY29uc29sZSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xl Jyk7CisgICAgaWYgKGFjdHVhbCA9PSBleHBlY3RlZCkgeworICAgICAgICBjb25zb2xlLmlubmVy SFRNTCArPSAiPHNwYW4gc3R5bGU9J2NvbG9yOiBncmVlbjsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5Q QVNTPC9zcGFuPiAiK2V4cGVjdGVkKyIgZm9yICI7CisgICAgfSBlbHNlIHsKKyAgICAgICAgY29u c29sZS5pbm5lckhUTUwgKz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogcmVkOyBmb250LXdlaWdodDog Ym9sZDsnPkZBSUxFRDwvc3Bhbj4gZXhwZWN0ZWQgIitleHBlY3RlZCsKKyAgICAgICAgCSIgYnV0 IGdvdCAiK2FjdHVhbCsiIGZvciAiOworICAgIH0KKyAgICBjb25zb2xlLmFwcGVuZENoaWxkKGRv Y3VtZW50LmNyZWF0ZVRleHROb2RlKGh0bWwpKTsKKyAgICBjb25zb2xlLmlubmVySFRNTCArPSAi PGJyPiI7CisgICAgYy5pbm5lckhUTUwgPSAiIjsKK30KKwordGVzdCgiPGRpdiBzdHlsZT0nYmFj a2dyb3VuZDogZ3JlZW47Jz48c3BhbiBpZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rp dj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdy ZWVuOyc+PHA+aGVsbG88L3A+PHNwYW4gaWQ9c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+PHA+d2Via2l0 PC9wPjwvZGl2PiIsICdyZ2IoMCwgMTI4LCAwKScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dy b3VuZDogZ3JlZW47Jz5oZWxsbyA8c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZTsn IGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMjU1KScpOwordGVz dCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3Np dGlvbjogYWJzb2x1dGU7IHRvcDogMjAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rp dj4iLCAncmdiKDIwNCwgMjA0LCAyMDQpJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5k OiBncmVlbjsnPmhlbGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiA1MDBw eDsnIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMCknKTsKK3Rl c3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5 bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+IHdvcmxkPC9kaXY+Iiwg J3JnYigwLCAxMjgsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsn IGlkPXNlbGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxv PC9zcGFuPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3JsZDwvc3Bh bj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91 bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHll bGxvdyc+aGVsbG88L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWUnPiB3 b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9 J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxv dycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigyNTUsIDI1NSwg MCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9 J2JhY2tncm91bmQtY29sb3I6IHJnYmEoMjU1LCAyNTUsIDAsIDApOycgaWQ9c2VsZWN0ZWQ+aGVs bG8gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0 eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiBy Z2JhKDI1NSwgMjU1LCAwLCAwLjUpOycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9k aXY+IiwgJ3JnYmEoMjU1LCAyNTUsIDAsIDAuNDk2MDk0KScpOworCis8L3NjcmlwdD4K 65931 2010-08-30 11:06:24 -0700 2010-08-30 15:20:18 -0700 Patch bug-21680-20100830110623.patch text/plain 13719 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjM5NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzMgQEAKKzIwMTAtMDgtMzAgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcXVl cnlDb21tYW5kVmFsdWUoIkJhY2tDb2xvciIpIHJldHVybnMgcmdiKDAsMCwwKSBmb3IgZWxlbWVu dHMgd2l0aCB0cmFuc3BhcmVudCBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTY4MAorCisgICAgICAgIFRoZSBidWcgd2FzIGNhdXNl ZCBieSB0aGUgZmFjdCB0aGF0IHRoZSBjb21wdXRlZCBzdHlsZSBvZiBhIHRyYW5zcGFyZW50IG5v ZGUgaW5kaWNhdGVzIHRoYXQKKyAgICAgICAgdGhlIGJhY2tncm91bmQgY29sb3IgaXMgcmdiYSgw LDAsMCwwKS4gV2hpbGUgdGhpcyBpcyBjb3JyZWN0IGluIHRoZSBhY2NvcmRhbmNlIHRvIENTUzIg YmVjYXVzZSBiYWNrZ3JvdW5kLWNvbG9yCisgICAgICAgIGlzIG5vdCBpbmhlcml0ZWQgYnkgZGVm YXVsdCwgdGhpcyBkb2Vzbid0IGdpdmUgdGhlIGRlc2lyZWQgcmVzdWx0IGZvciBlZGl0aW5nIHB1 cnBvc2VzLgorCisgICAgICAgIE1vZGlmaWVkIHZhbHVlU3R5bGUgaW4gRWRpdG9yQ29tbWFuZC5j cHAgdG8gY2FsbCBFZGl0b3I6OnNlbGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUsIGluc3RlYWQgb2Yg RnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5bGUsCisgICAgICAgIHdoaWNoIHRyYXZlcnNlcyBj b21tb24gYW5jZXN0b3JzIG9mIHRoZSBzZWxlY3RlZCByYW5nZSBvciBjYXJldCB0byByZXRyaWV2 ZSB0aGUgZWZmZWN0aXZlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNlbGVjdGVkIHJlZ2lvbgor ICAgICAgICBpbnN0ZWFkIG9mIHRoZSBiYWNrZ3JvdW5kIGNvbG9yIGF0IHRoZSBzdGFydCBvZiB0 aGUgc2VsZWN0aW9uLiBUaGlzIHRha2VzIGVmZmVjdCB3aGVuIHRoZSBvcmlnaW5hbCBiYWNrZ3Jv dW5kIGNvbG9yIGlzIHRyYW5zcGFyZW50CisgICAgICAgIG9yIHRoZSBzZWxlY3Rpb24gaXMgcmFu Z2UgKHRvIGF2b2lkIHBpY2sgdXAgdGhlIGJhY2tncm91bmQgY29sb3Igb25seSBwcmVzZW50IGF0 IHRoZSBzdGFydCBvZiBwYXJhZ3JhcGgpLgorCisgICAgICAgIFJlbW92ZWQgc2VsZWN0aW9uU3Rh cnRTdHlsZVByb3BlcnR5VmFsdWUgYW5kIG1pZ3JhdGVkIGl0IHRvIEVkaXRvcjo6c2VsZWN0aW9u Q1NTUHJvcGVydHlWYWx1ZQorCisgICAgICAgIFRlc3Q6IGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVl cnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKKworICAgICAgICAqIGVkaXRp bmcvRWRpdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzVHJhbnNwYXJlbnQpOiBDaGVja3Mg d2hldGhlciBhIG5vZGUgd2l0aCB0aGUgc3BlY2lmaWVkIHN0eWxlIGlzIHRyYW5zcGFyZW50IG9y IG5vdAorICAgICAgICAoV2ViQ29yZTo6RWRpdG9yOjpzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVl KTogTWlncmF0ZWQgdGhlIGNvbnRlbnRzIG9mIHNlbGVjdGlvblN0YXJ0U3R5bGVQcm9wZXJ0eVZh bHVlIGFuZAorICAgICAgICAgIGFkZGVkIHRoZSBzcGVjaWFsIGNhc2UgZm9yIGJhY2tncm91bmQg Y29sb3IKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5oOiBBZGRlZCB0aGUgcHJvdG90eXBlIGZv ciBzZWxlY3Rpb25DU1NQcm9wZXJ0eVZhbHVlCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnZhbHVlU3R5bGUpOiBjYWxscyBFZGl0b3I6OnNl bGVjdGlvbkNTU1Byb3BlcnR5VmFsdWUKKyAgICAgICAgKiBwYWdlL0ZyYW1lLmNwcDogUmVtb3Zl ZCBzZWxlY3Rpb25Db21wdXRlZFN0eWxlCisgICAgICAgICogcGFnZS9GcmFtZS5oOiBkaXR0bwor CiAyMDEwLTA4LTMwICBFcmljIENhcmxzb24gIDxlcmljLmNhcmxzb25AYXBwbGUuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAkocmV2 aXNpb24gNjYzOTUpCisrKyBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAkod29ya2luZyBjb3B5 KQpAQCAtOTE4LDYgKzkxOCw1NiBAQCBUcmlTdGF0ZSBFZGl0b3I6OnNlbGVjdGlvbkhhc1N0eWxl KENTU1N0CiAKICAgICByZXR1cm4gc3RhdGU7CiB9CisKK3N0YXRpYyBib29sIGhhc1RyYW5zcGFy ZW50QmFja2dyb3VuZENvbG9yKENTU1N0eWxlRGVjbGFyYXRpb24qIHN0eWxlKQoreworICAgIFJl ZlB0cjxDU1NWYWx1ZT4gY3NzVmFsdWUgPSBzdHlsZS0+Z2V0UHJvcGVydHlDU1NWYWx1ZShDU1NQ cm9wZXJ0eUJhY2tncm91bmRDb2xvcik7CisgICAgaWYgKCFjc3NWYWx1ZSkKKyAgICAgICAgcmV0 dXJuIHRydWU7CisKKyAgICBpZiAoIWNzc1ZhbHVlLT5pc1ByaW1pdGl2ZVZhbHVlKCkpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSogdmFsdWUgPSBzdGF0aWNf Y2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGNzc1ZhbHVlLmdldCgpKTsKKworICAgIGlmICh2YWx1 ZS0+cHJpbWl0aXZlVHlwZSgpID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfUkdCQ09MT1IpCisg ICAgICAgIHJldHVybiAhYWxwaGFDaGFubmVsKHZhbHVlLT5nZXRSR0JBMzJWYWx1ZSgpKTsKKwor ICAgIHJldHVybiB2YWx1ZS0+Z2V0SWRlbnQoKSA9PSBDU1NWYWx1ZVRyYW5zcGFyZW50OworfQor CitTdHJpbmcgRWRpdG9yOjpzZWxlY3Rpb25TdGFydENTU1Byb3BlcnR5VmFsdWUoaW50IHByb3Bl cnR5SUQpCit7CisgICAgTm9kZSogbm9kZVRvUmVtb3ZlOworICAgIFJlZlB0cjxDU1NTdHlsZURl Y2xhcmF0aW9uPiBzZWxlY3Rpb25TdHlsZSA9IG1fZnJhbWUtPnNlbGVjdGlvbkNvbXB1dGVkU3R5 bGUobm9kZVRvUmVtb3ZlKTsKKyAgICBpZiAoIXNlbGVjdGlvblN0eWxlKQorICAgICAgICByZXR1 cm4gU3RyaW5nKCk7CisKKyAgICBTdHJpbmcgdmFsdWUgPSBzZWxlY3Rpb25TdHlsZS0+Z2V0UHJv cGVydHlWYWx1ZShwcm9wZXJ0eUlEKTsKKworICAgIGlmIChub2RlVG9SZW1vdmUpIHsKKyAgICAg ICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CisgICAgICAgIG5vZGVUb1JlbW92ZS0+cmVtb3ZlKGVj KTsKKyAgICAgICAgQVNTRVJUKCFlYyk7CisgICAgfQorCisgICAgLy8gSWYgYmFja2dyb3VuZCBj b2xvciBpcyB0cmFuc3BhcmVudCwgdHJhdmVyc2UgcGFyZW50IG5vZGVzIHVudGlsIHdlIGhpdCBh IGRpZmZlcmVudCB2YWx1ZSBvciBkb2N1bWVudCByb290CisgICAgLy8gQWxzbywgaWYgdGhlIHNl bGVjdGlvbiBpcyBhIHJhbmdlLCBpZ25vcmUgdGhlIGJhY2tncm91bmQgY29sb3IgYXQgdGhlIHN0 YXJ0IG9mIHNlbGVjdGlvbiwKKyAgICAvLyBhbmQgZmluZCB0aGUgYmFja2dyb3VuZCBjb2xvciBv ZiB0aGUgY29tbW9uIGFuY2VzdG9yLgorICAgIGlmIChwcm9wZXJ0eUlEID09IENTU1Byb3BlcnR5 QmFja2dyb3VuZENvbG9yICYmIChtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+aXNSYW5nZSgpIHx8IGhh c1RyYW5zcGFyZW50QmFja2dyb3VuZENvbG9yKHNlbGVjdGlvblN0eWxlLmdldCgpKSkpIHsKKyAg ICAgICAgUmVmUHRyPFJhbmdlPiByYW5nZShtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+dG9Ob3JtYWxp emVkUmFuZ2UoKSk7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICBOb2Rl KiBhbmNlc3RvciA9IHJhbmdlLT5jb21tb25BbmNlc3RvckNvbnRhaW5lcihlYyk7CisgICAgICAg IEFTU0VSVChhbmNlc3Rvcik7CisgICAgICAgIGRvIHsKKyAgICAgICAgICAgIHNlbGVjdGlvblN0 eWxlID0gY29tcHV0ZWRTdHlsZShhbmNlc3Rvcik7CisgICAgICAgICAgICBhbmNlc3RvciA9IGFu Y2VzdG9yLT5wYXJlbnROb2RlKCk7CisgICAgICAgIH0gd2hpbGUgKGhhc1RyYW5zcGFyZW50QmFj a2dyb3VuZENvbG9yKHNlbGVjdGlvblN0eWxlLmdldCgpKSk7CisgICAgICAgIHZhbHVlID0gc2Vs ZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUoQ1NTUHJvcGVydHlCYWNrZ3JvdW5kQ29sb3Ip OworICAgIH0KKworICAgIHJldHVybiB2YWx1ZTsKK30KKwogdm9pZCBFZGl0b3I6OmluZGVudCgp CiB7CiAgICAgYXBwbHlDb21tYW5kKEluZGVudE91dGRlbnRDb21tYW5kOjpjcmVhdGUobV9mcmFt ZS0+ZG9jdW1lbnQoKSwgSW5kZW50T3V0ZGVudENvbW1hbmQ6OkluZGVudCkpOwpJbmRleDogV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9FZGl0 b3IuaAkocmV2aXNpb24gNjYzOTUpCisrKyBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgJKHdvcmtp bmcgY29weSkKQEAgLTExOSw2ICsxMTksNyBAQCBwdWJsaWM6CiAgICAgdm9pZCByZXNwb25kVG9D aGFuZ2VkQ29udGVudHMoY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgZW5kaW5nU2VsZWN0aW9uKTsK IAogICAgIFRyaVN0YXRlIHNlbGVjdGlvbkhhc1N0eWxlKENTU1N0eWxlRGVjbGFyYXRpb24qKSBj b25zdDsKKyAgICBTdHJpbmcgc2VsZWN0aW9uU3RhcnRDU1NQcm9wZXJ0eVZhbHVlKGludCBwcm9w ZXJ0eUlEKTsKICAgICBjb25zdCBTaW1wbGVGb250RGF0YSogZm9udEZvclNlbGVjdGlvbihib29s JikgY29uc3Q7CiAgICAgV3JpdGluZ0RpcmVjdGlvbiB0ZXh0RGlyZWN0aW9uRm9yU2VsZWN0aW9u KGJvb2wmKSBjb25zdDsKICAgICAKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5k LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHJl dmlzaW9uIDY2Mzk1KQorKysgV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0yMzksNyArMjM5LDkgQEAgc3RhdGljIFRyaVN0YXRlIHN0YXRlU3R5bGUo RnJhbWUqIGZyYW1lLAogCiBzdGF0aWMgU3RyaW5nIHZhbHVlU3R5bGUoRnJhbWUqIGZyYW1lLCBp bnQgcHJvcGVydHlJRCkKIHsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvblN0YXJ0U3R5bGVQ cm9wZXJ0eVZhbHVlKHByb3BlcnR5SUQpOworICAgIC8vIEZJWE1FOiBSYXRoZXIgdGhhbiByZXRy aWV2aW5nIHRoZSBzdHlsZSBhdCB0aGUgc3RhcnQgb2YgdGhlIGN1cnJlbnQgc2VsZWN0aW9uLAor ICAgIC8vIHdlIHNob3VsZCByZXRyaWV2ZSB0aGUgc3R5bGUgcHJlc2VudCB0aHJvdWdob3V0IHRo ZSBzZWxlY3Rpb24gZm9yIG5vbi1tYWMgcGxhdGZvcm1zLgorICAgIHJldHVybiBmcmFtZS0+ZWRp dG9yKCktPnNlbGVjdGlvblN0YXJ0Q1NTUHJvcGVydHlWYWx1ZShwcm9wZXJ0eUlEKTsKIH0KIAog c3RhdGljIFRyaVN0YXRlIHN0YXRlVGV4dFdyaXRpbmdEaXJlY3Rpb24oRnJhbWUqIGZyYW1lLCBX cml0aW5nRGlyZWN0aW9uIGRpcmVjdGlvbikKSW5kZXg6IFdlYkNvcmUvcGFnZS9GcmFtZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAkocmV2aXNpb24gNjYzOTUpCisr KyBXZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NzAsMjQgKzc3MCw2 IEBAIHZvaWQgRnJhbWU6OmNvbXB1dGVBbmRTZXRUeXBpbmdTdHlsZShDU1MKICAgICBtX3R5cGlu Z1N0eWxlID0gbXV0YWJsZVN0eWxlLnJlbGVhc2UoKTsKIH0KIAotU3RyaW5nIEZyYW1lOjpzZWxl Y3Rpb25TdGFydFN0eWxlUHJvcGVydHlWYWx1ZShpbnQgc3R5bGVQcm9wZXJ0eUlEKSBjb25zdAot ewotICAgIE5vZGUgKm5vZGVUb1JlbW92ZTsKLSAgICBSZWZQdHI8Q1NTU3R5bGVEZWNsYXJhdGlv bj4gc2VsZWN0aW9uU3R5bGUgPSBzZWxlY3Rpb25Db21wdXRlZFN0eWxlKG5vZGVUb1JlbW92ZSk7 Ci0gICAgaWYgKCFzZWxlY3Rpb25TdHlsZSkKLSAgICAgICAgcmV0dXJuIFN0cmluZygpOwotCi0g ICAgU3RyaW5nIHZhbHVlID0gc2VsZWN0aW9uU3R5bGUtPmdldFByb3BlcnR5VmFsdWUoc3R5bGVQ cm9wZXJ0eUlEKTsKLQotICAgIGlmIChub2RlVG9SZW1vdmUpIHsKLSAgICAgICAgRXhjZXB0aW9u Q29kZSBlYyA9IDA7Ci0gICAgICAgIG5vZGVUb1JlbW92ZS0+cmVtb3ZlKGVjKTsKLSAgICAgICAg QVNTRVJUKCFlYyk7Ci0gICAgfQotCi0gICAgcmV0dXJuIHZhbHVlOwotfQotCiBQYXNzUmVmUHRy PENTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbj4gRnJhbWU6OnNlbGVjdGlvbkNvbXB1dGVkU3R5 bGUoTm9kZSomIG5vZGVUb1JlbW92ZSkgY29uc3QKIHsKICAgICBub2RlVG9SZW1vdmUgPSAwOwpJ bmRleDogV2ViQ29yZS9wYWdlL0ZyYW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0Zy YW1lLmgJKHJldmlzaW9uIDY2Mzk1KQorKysgV2ViQ29yZS9wYWdlL0ZyYW1lLmgJKHdvcmtpbmcg Y29weSkKQEAgLTE5Nyw3ICsxOTcsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZv aWQgc2V0TWFyayhjb25zdCBWaXNpYmxlU2VsZWN0aW9uJik7CiAKICAgICAgICAgdm9pZCBjb21w dXRlQW5kU2V0VHlwaW5nU3R5bGUoQ1NTU3R5bGVEZWNsYXJhdGlvbiogLCBFZGl0QWN0aW9uID0g RWRpdEFjdGlvblVuc3BlY2lmaWVkKTsKLSAgICAgICAgU3RyaW5nIHNlbGVjdGlvblN0YXJ0U3R5 bGVQcm9wZXJ0eVZhbHVlKGludCBzdHlsZVByb3BlcnR5SUQpIGNvbnN0OwogICAgICAgICB2b2lk IGFwcGx5RWRpdGluZ1N0eWxlVG9Cb2R5RWxlbWVudCgpIGNvbnN0OwogICAgICAgICB2b2lkIGFw cGx5RWRpdGluZ1N0eWxlVG9FbGVtZW50KEVsZW1lbnQqKSBjb25zdDsKIApJbmRleDogTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2 aXNpb24gNjYzOTUpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAg LTEsMyArMSwxNiBAQAorMjAxMC0wOC0zMCAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBxdWVy eUNvbW1hbmRWYWx1ZSgiQmFja0NvbG9yIikgcmV0dXJucyByZ2IoMCwwLDApIGZvciBlbGVtZW50 cyB3aXRoIHRyYW5zcGFyZW50IGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNjgwCisKKyAgICAgICAgVGVzdHMgcXVlcnlDb21tYW5k VmFsdWUoIkJhY2tDb2xvciIpIG9uIHZhcmlvdXMgY2FzZXMsIGVzcGVjaWFsbHkgdGhlIGNhc2Vz IHdoZXJlIGJhY2tncm91bmQgY29sb3Igb2YKKyAgICAgICAgdGhlIHNlbGVjdGVkIG5vZGUgaXMg dHJhbnNwYXJlbnQgYnV0IHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIGl0cyBhbmNlc3RvciBoYXMg YSBjb2xvci4KKworICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12 YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRp dGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRt bDogQWRkZWQuCisKIDIwMTAtMDgtMzAgIEVyaWMgQ2FybHNvbiAgPGVyaWMuY2FybHNvbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5kZXg6IExheW91 dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5k LWNvbG9yLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2V4 ZWNDb21tYW5kL3F1ZXJ5LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xvci1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL3F1ZXJ5 LWNvbW1hbmQtdmFsdWUtYmFja2dyb3VuZC1jb2xvci1leHBlY3RlZC50eHQJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMTMgQEAKK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2Jh Y2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9k aXY+CitQQVNTIHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVl bjsnPjxwPmhlbGxvPC9wPjxzcGFuIGlkPXNlbGVjdGVkPndvcmxkPC9zcGFuPjxwPndlYmtpdDwv cD48L2Rpdj4KK1BBU1MgcmdiKDAsIDAsIDI1NSkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6 IGdyZWVuOyc+aGVsbG8gPHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWU7JyBpZD1z ZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK0ZBSUxFRCBleHBlY3RlZCByZ2IoMjA0LCAyMDQs IDIwNCkgYnV0IGdvdCByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDog Z3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7IHRvcDogMjAwcHg7 JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK0ZBSUxFRCBleHBlY3RlZCByZ2IoMCwg MCwgMCkgYnV0IGdvdCByZ2IoMCwgMTI4LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3VuZDog Z3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1dGU7IHRvcDogNTAwcHg7 JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9y IDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9 J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+IHdvcmxkPC9kaXY+CitQQVNT IHJnYigwLCAxMjgsIDApIGZvciA8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnIGlkPXNl bGVjdGVkPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFu PjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3JsZDwvc3Bhbj48L2Rp dj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVu OycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVs bG88L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWUnPiB3b3JsZDwvc3Bh bj48L2Rpdj4KK1BBU1MgcmdiKDI1NSwgMjU1LCAwKSBmb3IgPGRpdiBzdHlsZT0nYmFja2dyb3Vu ZDogZ3JlZW47Jz48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogeWVsbG93JyBpZD1zZWxl Y3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4KK1BBU1MgcmdiKDAsIDEyOCwgMCkgZm9yIDxk aXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29s b3I6IHJnYmEoMjU1LCAyNTUsIDAsIDApOycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+ PC9kaXY+CitQQVNTIHJnYmEoMjU1LCAyNTUsIDAsIDAuNDk2MDk0KSBmb3IgPGRpdiBzdHlsZT0n YmFja2dyb3VuZDogZ3JlZW47Jz48c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogcmdiYSgy NTUsIDI1NSwgMCwgMC41KTsnIGlkPXNlbGVjdGVkPmhlbGxvIHdvcmxkPC9zcGFuPjwvZGl2Pgor CisKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnktY29tbWFuZC12 YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRp dGluZy9leGVjQ29tbWFuZC9xdWVyeS1jb21tYW5kLXZhbHVlLWJhY2tncm91bmQtY29sb3IuaHRt bAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvcXVlcnkt Y29tbWFuZC12YWx1ZS1iYWNrZ3JvdW5kLWNvbG9yLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNjAgQEAKKzxodG1sPgorPGJvZHkgc3R5bGU9ImJhY2tncm91bmQ6ICNjY2NjY2M7Ij4KKzxw IGlkPSJjb25zb2xlIj48L3A+Cis8ZGl2IGlkPSJiYWNrZ3JvdW5kIiBzdHlsZT0icG9zaXRpb246 IGFic29sdXRlOyB0b3A6IDQ5MHB4OyB3aWR0aDogNTAwcHg7IGhlaWdodDozZW07YmFja2dyb3Vu ZDogYmxhY2s7Ij48L2Rpdj4KKzxkaXYgaWQ9ImNvbnRhaW5lciIgY29udGVudGVkaXRhYmxlPSJ0 cnVlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4gCisKK2lmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCitmdW5jdGlvbiBnZXRDb2xvcihlKSB7CisgICAgaWYgKGRvY3VtZW50LnNlbGVj dGlvbikgeworICAgICAgICB2YXIgciA9IGRvY3VtZW50LnNlbGVjdGlvbi5jcmVhdGVSYW5nZSgp OworICAgICAgICByLm1vdmVUb0VsZW1lbnRUZXh0KGUpOworICAgICAgICByLnNlbGVjdCgpOwor ICAgICAgICBiYWNrQ29sb3IgPSBkb2N1bWVudC5xdWVyeUNvbW1hbmRWYWx1ZSgnYmFja0NvbG9y Jyk7CisgICAgICAgIHIgPSAoYmFja0NvbG9yICYgMHhGRikKKyAgICAgICAgZyA9ICgoYmFja0Nv bG9yID4+IDgpICYgMHhGRikKKyAgICAgICAgYiA9ICgoYmFja0NvbG9yID4+IDE2KSAmIDB4RkYp CisgICAgICAgIHJldHVybiAncmdiKCcrcisnLCAnK2crJywgJytiKycpJzsKKyAgICB9IGVsc2Ug eworICAgICAgICB2YXIgciA9IGRvY3VtZW50LmNyZWF0ZVJhbmdlKCk7CisgICAgICAgIHZhciBz ID0gd2luZG93LmdldFNlbGVjdGlvbigpOworICAgICAgICByLnNldFN0YXJ0KGUsIDApOworICAg ICAgICByLnNldEVuZChlLCBlLmNoaWxkTm9kZXMubGVuZ3RoKTsKKyAgICAgICAgcy5yZW1vdmVB bGxSYW5nZXMoKTsKKyAgICAgICAgcy5hZGRSYW5nZShyKTsKKyAgICAgICAgcmV0dXJuIGRvY3Vt ZW50LnF1ZXJ5Q29tbWFuZFZhbHVlKCdiYWNrQ29sb3InKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9u IHRlc3QoaHRtbCwgZXhwZWN0ZWQpIHsKKyAgICB2YXIgYyA9IGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdjb250YWluZXInKTsKKyAgICBjLmlubmVySFRNTCA9IGh0bWw7CisgICAgdmFyIGFjdHVh bCA9IGdldENvbG9yKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZWxlY3RlZCcpKTsKKyAgICB2 YXIgY29uc29sZSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJyk7CisgICAgaWYg KGFjdHVhbCA9PSBleHBlY3RlZCkgeworICAgICAgICBjb25zb2xlLmlubmVySFRNTCArPSAiPHNw YW4gc3R5bGU9J2NvbG9yOiBncmVlbjsgZm9udC13ZWlnaHQ6IGJvbGQ7Jz5QQVNTPC9zcGFuPiAi K2V4cGVjdGVkKyIgZm9yICI7CisgICAgfSBlbHNlIHsKKyAgICAgICAgY29uc29sZS5pbm5lckhU TUwgKz0gIjxzcGFuIHN0eWxlPSdjb2xvcjogcmVkOyBmb250LXdlaWdodDogYm9sZDsnPkZBSUxF RDwvc3Bhbj4gZXhwZWN0ZWQgIitleHBlY3RlZCsKKyAgICAgICAgCSIgYnV0IGdvdCAiK2FjdHVh bCsiIGZvciAiOworICAgIH0KKyAgICBjb25zb2xlLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0 ZVRleHROb2RlKGh0bWwpKTsKKyAgICBjb25zb2xlLmlubmVySFRNTCArPSAiPGJyPiI7CisgICAg Yy5pbm5lckhUTUwgPSAiIjsKK30KKwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3Jl ZW47Jz48c3BhbiBpZD1zZWxlY3RlZD5oZWxsbyB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDAs IDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHA+aGVs bG88L3A+PHNwYW4gaWQ9c2VsZWN0ZWQ+d29ybGQ8L3NwYW4+PHA+d2Via2l0PC9wPjwvZGl2PiIs ICdyZ2IoMCwgMTI4LCAwKScpOwordGVzdCgiPGRpdiBzdHlsZT0nYmFja2dyb3VuZDogZ3JlZW47 Jz5oZWxsbyA8c3BhbiBzdHlsZT0nYmFja2dyb3VuZC1jb2xvcjogYmx1ZTsnIGlkPXNlbGVjdGVk PndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMjU1KScpOwordGVzdCgiPGRpdiBzdHls ZT0nYmFja2dyb3VuZDogZ3JlZW47Jz5oZWxsbzxzcGFuIHN0eWxlPSdwb3NpdGlvbjogYWJzb2x1 dGU7IHRvcDogMjAwcHg7JyBpZD1zZWxlY3RlZD53b3JsZDwvc3Bhbj48L2Rpdj4iLCAncmdiKDIw NCwgMjA0LCAyMDQpJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnPmhl bGxvPHNwYW4gc3R5bGU9J3Bvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiA1MDBweDsnIGlkPXNlbGVj dGVkPndvcmxkPC9zcGFuPjwvZGl2PiIsICdyZ2IoMCwgMCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5 bGU9J2JhY2tncm91bmQ6IGdyZWVuOycgaWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91 bmQtY29sb3I6IHllbGxvdyc+aGVsbG88L3NwYW4+IHdvcmxkPC9kaXY+IiwgJ3JnYigwLCAxMjgs IDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3JvdW5kOiBncmVlbjsnIGlkPXNlbGVjdGVk PjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPmhlbGxvPC9zcGFuPjxzcGFu IHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiB5ZWxsb3cnPiB3b3JsZDwvc3Bhbj48L2Rpdj4iLCAn cmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOycg aWQ9c2VsZWN0ZWQ+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdyc+aGVsbG88 L3NwYW4+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IGJsdWUnPiB3b3JsZDwvc3Bhbj48 L2Rpdj4iLCAncmdiKDAsIDEyOCwgMCknKTsKK3Rlc3QoIjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6 IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQtY29sb3I6IHllbGxvdycgaWQ9c2VsZWN0 ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYigyNTUsIDI1NSwgMCknKTsKK3Rlc3Qo IjxkaXYgc3R5bGU9J2JhY2tncm91bmQ6IGdyZWVuOyc+PHNwYW4gc3R5bGU9J2JhY2tncm91bmQt Y29sb3I6IHJnYmEoMjU1LCAyNTUsIDAsIDApOycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3Nw YW4+PC9kaXY+IiwgJ3JnYigwLCAxMjgsIDApJyk7Cit0ZXN0KCI8ZGl2IHN0eWxlPSdiYWNrZ3Jv dW5kOiBncmVlbjsnPjxzcGFuIHN0eWxlPSdiYWNrZ3JvdW5kLWNvbG9yOiByZ2JhKDI1NSwgMjU1 LCAwLCAwLjUpOycgaWQ9c2VsZWN0ZWQ+aGVsbG8gd29ybGQ8L3NwYW4+PC9kaXY+IiwgJ3JnYmEo MjU1LCAyNTUsIDAsIDAuNDk2MDk0KScpOworCis8L3NjcmlwdD4K