23946 2009-02-13 00:31:48 -0800 WebKit does not enumerate over CSS properties in HTMLElement.style 2011-12-12 07:17:19 -0800 1 1 1 Unclassified WebKit DOM 525.x (Safari 3.2) PC OS X 10.5 RESOLVED FIXED InRadar P2 Normal --- 1 lea apavlov abarth apavlov ap darin japhet joepeck kling macpherson mathias me ojan sam simon.fraser webkit.review.bot oldest_to_newest 109633 0 lea 2009-02-13 00:31:48 -0800 I was surprised that I couldn't find this bug already reported. Anyway, here goes: Webkit based browsers (like Apple Safari and Google Chrome) do not list the supported CSS properties when enumerating over the style object of an element. They don't even list the CSS properties that have been set. However, the condition (property in element.style) returns true if the property is supported. I guess for some reason the CSS properties have the dontEnum flag? In all non-webkit browsers the test case works as expected. 109634 1 27644 lea 2009-02-13 00:32:44 -0800 Created attachment 27644 Testcase for bug #23946 109636 2 27644 lea 2009-02-13 01:04:18 -0800 Comment on attachment 27644 Testcase for bug #23946 ><!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> ><HTML><HEAD> > > ><META content="text/html; charset=iso-8859-7" http-equiv="Content-Type"/> ><TITLE>Test case for webkit bug</TITLE> > ></HEAD><BODY style="border: 3px solid white; padding: 20px; background: beige none repeat scroll 0% 0%; -moz-background-clip: -moz-initial; -moz-background-origin: -moz-initial; -moz-background-inline-policy: -moz-initial; width: 600px; -moz-border-radius-topleft: 20px; -moz-border-radius-topright: 20px; -moz-border-radius-bottomright: 20px; -moz-border-radius-bottomleft: 20px;" linkifying="true" linkifycurrent="0" linkifymax="0"> ><DIV style="overflow: auto; height: 400px;"> ><SCRIPT type="text/javascript"> > for (var i in document.body.style) document.write(i + ' '); ></SCRIPT>0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 length cssText getPropertyValue getPropertyCSSValue removeProperty getPropertyPriority setProperty item parentRule azimuth background backgroundAttachment backgroundColor backgroundImage backgroundPosition backgroundRepeat border borderCollapse borderColor borderSpacing borderStyle borderTop borderRight borderBottom borderLeft borderTopColor borderRightColor borderBottomColor borderLeftColor borderTopStyle borderRightStyle borderBottomStyle borderLeftStyle borderTopWidth borderRightWidth borderBottomWidth borderLeftWidth borderWidth bottom captionSide clear clip color content counterIncrement counterReset cue cueAfter cueBefore cursor direction display elevation emptyCells cssFloat font fontFamily fontSize fontSizeAdjust fontStretch fontStyle fontVariant fontWeight height left letterSpacing lineHeight listStyle listStyleImage listStylePosition listStyleType margin marginTop marginRight marginBottom marginLeft markerOffset marks maxHeight maxWidth minHeight minWidth orphans outline outlineColor outlineStyle outlineWidth overflow padding paddingTop paddingRight paddingBottom paddingLeft page pageBreakAfter pageBreakBefore pageBreakInside pause pauseAfter pauseBefore pitch pitchRange position quotes richness right size speak speakHeader speakNumeral speakPunctuation speechRate stress tableLayout textAlign textDecoration textIndent textShadow textTransform top unicodeBidi verticalAlign visibility voiceFamily volume whiteSpace widows width wordSpacing zIndex MozAppearance MozBackgroundClip MozBackgroundInlinePolicy MozBackgroundOrigin MozBinding MozBorderBottomColors MozBorderLeftColors MozBorderRightColors MozBorderTopColors MozBorderRadius MozBorderRadiusTopleft MozBorderRadiusTopright MozBorderRadiusBottomleft MozBorderRadiusBottomright MozBoxAlign MozBoxDirection MozBoxFlex MozBoxOrient MozBoxOrdinalGroup MozBoxPack MozBoxSizing MozColumnCount MozColumnWidth MozColumnGap MozFloatEdge MozForceBrokenImageIcon MozImageRegion MozMarginEnd MozMarginStart MozOpacity MozOutline MozOutlineColor MozOutlineRadius MozOutlineRadiusTopleft MozOutlineRadiusTopright MozOutlineRadiusBottomleft MozOutlineRadiusBottomright MozOutlineStyle MozOutlineWidth MozOutlineOffset MozPaddingEnd MozPaddingStart MozUserFocus MozUserInput MozUserModify MozUserSelect opacity outlineOffset overflowX overflowY imeMode MozBorderEnd MozBorderEndColor MozBorderEndStyle MozBorderEndWidth MozBorderStart MozBorderStartColor MozBorderStartStyle MozBorderStartWidth ></DIV> ><SCRIPT type="text/javascript"> > document.write("'margin' in document.body.style is " + ('margin' in document.body.style)); ></SCRIPT>'margin' in document.body.style is true ></BODY><html:div xmlns:html="http://www.w3.org/1999/xhtml" id="_firebugConsole" style="display: none;" FirebugVersion="1.3X.3b1"/></HTML> 109637 3 27644 lea 2009-02-13 01:06:52 -0800 Comment on attachment 27644 Testcase for bug #23946 The script file that is included in the <head> is completely irrelevant with the bug testcase and was just forgotten there by accident. I can't seem to find a way to replace this attachment with a corrected file. 109650 4 mrowe 2009-02-13 01:53:30 -0800 <rdar://problem/6584331> 213315 5 ap 2010-04-16 11:20:32 -0700 *** Bug 37570 has been marked as a duplicate of this bug. *** 509121 6 116607 apavlov 2011-11-25 05:47:30 -0800 Created attachment 116607 Patch 510062 7 116607 ap 2011-11-28 12:15:06 -0800 Comment on attachment 116607 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=116607&action=review > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:203 > + for (unsigned i = 0, length = static_cast<CSSStyleDeclaration*>(thisObject->impl())->length(); i < length; ++i) > + propertyNames.add(Identifier::from(exec, i)); It would be good to also test that we return these indices here. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:207 > + Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode); > + > + for (int i = 0; i < numCSSProperties; ++i) > + propertyNames.add(Identifier(exec, stringToUString(jsPropertyNameStrings[i]))); What tests that base properties and ones from jsPropertyNameStrings come in this order? > LayoutTests/fast/css/style-enumerate-properties.html:15 > + for (var p in document.body.style) { > + if (p.indexOf("border") === 0) > + document.write(p + " "); This test will fail whenever we add another property starting with "border". Please add explicit pass/fail criteria, so that a person looking at failure results wouldn't be confused. 510453 8 apavlov 2011-11-28 20:50:18 -0800 (In reply to comment #7) > (From update of attachment 116607 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=116607&action=review > > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:203 > > + for (unsigned i = 0, length = static_cast<CSSStyleDeclaration*>(thisObject->impl())->length(); i < length; ++i) > > + propertyNames.add(Identifier::from(exec, i)); > > It would be good to also test that we return these indices here. Will do. > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:207 > > + Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode); > > + > > + for (int i = 0; i < numCSSProperties; ++i) > > + propertyNames.add(Identifier(exec, stringToUString(jsPropertyNameStrings[i]))); > > What tests that base properties and ones from jsPropertyNameStrings come in this order? I'm afraid I don't quite understand what you mean by "this order". Do you mean that we should test the fact that the proper object properties/methods go first and then the JS property names? AFAIK the specification does not mandate any order on the getOwnPropertyNames() result, so these might as well be swapped without any loss of consistency. > > LayoutTests/fast/css/style-enumerate-properties.html:15 > > + for (var p in document.body.style) { > > + if (p.indexOf("border") === 0) > > + document.write(p + " "); > > This test will fail whenever we add another property starting with "border". Please add explicit pass/fail criteria, so that a person looking at failure results wouldn't be confused. You are correct, I was going to check the full set of properties first, but then came up with the same idea and decided to confine the set to border-related properties. In general, no longhand property list can be considered stable. Do you think it is sufficient to only check the presence of a couple of well-known properties in the style? 510459 9 ap 2011-11-28 21:04:46 -0800 > I'm afraid I don't quite understand what you mean by "this order". What I mean is: what test will fail is the quoted lined were swapped? We presumably aim to be compatible with Firefox here. > Do you think it is sufficient to only check the presence of a couple of well-known properties in the style? I asked to spell out pass/fail criteria in test output (in a element), so that it would be easy to understand why the test "failed" in the future. Checking for ac couple of well-known properties seems fine, too. 510610 10 116923 apavlov 2011-11-29 01:52:12 -0800 Created attachment 116923 Patch 510654 11 apavlov 2011-11-29 03:05:52 -0800 (In reply to comment #9) > > I'm afraid I don't quite understand what you mean by "this order". > > What I mean is: what test will fail is the quoted lined were swapped? We presumably aim to be compatible with Firefox here. I get the point now. In Firefox, the numeric properties go first, then the CSS-mapped ones, but in no particular ("partially sorted") order, then the rest. I have changed the binding code to follow this. > > Do you think it is sufficient to only check the presence of a couple of well-known properties in the style? > > I asked to spell out pass/fail criteria in test output (in a element), so that it would be easy to understand why the test "failed" in the future. Checking for ac couple of well-known properties seems fine, too. Done. 510808 12 ap 2011-11-29 08:53:19 -0800 Looks good to me. One thing I'm slightly surprised about is that a new generated list of names was needed - we certainly do a lot with these property names already. Perhaps someone else CC'ed on this bug could do another review pass. 511166 13 116923 darin 2011-11-29 15:47:45 -0800 Comment on attachment 116923 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=116923&action=review > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:202 > + for (unsigned i = 0, length = static_cast<CSSStyleDeclaration*>(thisObject->impl())->length(); i < length; ++i) The typecast is not needed here. The result of thisObject->impl() is already a CSSStyleDeclaration. I’m not sure why the generated code included it. The initialization of length here is not consistent with our usual style. We normally would just do it separately outside the loop. I wonder if we should do this more often, or frown on it. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:203 > + propertyNames.add(Identifier::from(exec, i)); This is terribly inefficient, but since it’s the same idiom already used and is also used for JavaScript arrays then I suppose it’s what we want for now at least. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:206 > + for (int i = 0; i < numCSSProperties; ++i) > + propertyNames.add(Identifier(exec, stringToUString(jsPropertyNameStrings[i]))); These are const char*, not WTF strings, the call to stringToUString can and should omitted. The use of stringToUString forces additional unneeded memory allocation. Exposing the names in the order they appeared in the CSSPropertyNames.in source file does not seem like a good idea. We should expose them in some order that is consistent and does not reflect the peculiarities of our source code. I would suggest alphabetical order if we can’t think of anything else. If we actually want this to be efficient we should be creating an array of identifiers one time only and then reusing the same identifiers in the future. Converting from const char* every time doesn’t seem helpful. > Source/WebCore/bindings/v8/custom/V8CSSStyleDeclarationCustom.cpp:159 > + // We know that "filter" is present in the list but should not be provided in the enumeration. > + // See a comment in the V8CSSStyleDeclaration::namedPropertyGetter() implementation. I don’t understand why this special rule to omit filter is in V8 but not in the other JavaScript binding, especially considering the comment in namedPropertyGetter implies it is there. I don’t understand why there is no test for it. I suspect this rule about "filter" was removed long ago but was left behind in V8 for not good reason. > Source/WebCore/css/makeprop.pl:166 > + $name =~ s/(\S)-(.)/$1@{[uc($2)]}/g; > + $name =~ s/^-//; > + print HEADER "\"$name\",\n"; > +} > +print HEADER "};\n"; I think it would be better to not change the contents of this file at all. Instead we could use the existing array of const char* and the first time it’s needed we could build an array of JSC::Identifier one time inside the bindings code and then reuse that each time instead of doing it over and over again. If we do want to keep this, then I suggest we sort the array here, since we only use it for enumeration and so the order is not important. I think (.)-(.) would work fine; I don’t think you need the \S there. > LayoutTests/fast/css/style-enumerate-properties-expected.txt:3 > +Test for https://bugs.webkit.org/show_bug.cgi?id=23946 Webkit does not enumerate over CSS properties in HTMLElement.style - checks that the style contains exactly one numeric property "0" (for "text-decoration") and named properties "textDecoration", "border", "font", and "cssText". > + > +PASSED Tests should show what they are testing, not just say PASSED. > LayoutTests/fast/css/style-enumerate-properties.html:25 > + if (!(p in style)) { > + console.textContent = "Property '" + p + "' not found!"; > + return; > + } Better style would be to use the shouldBe macros and do shouldBe for each property so the test output would show what it’s testing. This test does not cover the order of the properties. It should. This test does not cover any properties with more then two words in their names, and it should. > LayoutTests/fast/css/style-enumerate-properties.html:34 > + Webkit does not enumerate over CSS properties in HTMLElement.style - checks that the style contains exactly one numeric property "0" (for "text-decoration") and named properties "textDecoration", "border", "font", and "cssText". WebKit has a capital K in its name. > LayoutTests/fast/dom/script-tests/domListEnumeration.js:176 > +// More properties can be added soon. Plus, Chromium hides the "filter" property. This comment is more confusing than helpful. It’s not clear how either of these is relevant to the next line of code. I realize that you are justifying the use of >= rather than == for the test, but only because I am reading the whole patch. The comment alone does not make it clear. > LayoutTests/fast/dom/script-tests/domListEnumeration.js:177 > +shouldBeGreaterThanOrEqual("resultArray.length", "376"); Where did the 376 number come from? Is it right even if SVG is turned off? I think you should just not check the resultArray’s length at all. 511672 14 apavlov 2011-11-30 05:50:40 -0800 Thanks for the profound review, Darin. Attaching a fixed patch shortly. (In reply to comment #13) > (From update of attachment 116923 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=116923&action=review > > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:202 > > + for (unsigned i = 0, length = static_cast<CSSStyleDeclaration*>(thisObject->impl())->length(); i < length; ++i) > > The typecast is not needed here. The result of thisObject->impl() is already a CSSStyleDeclaration. I’m not sure why the generated code included it. Fixed. > The initialization of length here is not consistent with our usual style. We normally would just do it separately outside the loop. I wonder if we should do this more often, or frown on it. Initialized length outside the loop for now, yet I'm not sure if the length computation should be extracted into a variable at all, given that usually the length is on the order of hundreds and this method gets invoked relatively rarely. > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:203 > > + propertyNames.add(Identifier::from(exec, i)); > > This is terribly inefficient, but since it’s the same idiom already used and is also used for JavaScript arrays then I suppose it’s what we want for now at least. Agreed, and since I'm not that familiar with JSC, I can't think of anything better. > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:206 > > + for (int i = 0; i < numCSSProperties; ++i) > > + propertyNames.add(Identifier(exec, stringToUString(jsPropertyNameStrings[i]))); > > These are const char*, not WTF strings, the call to stringToUString can and should omitted. The use of stringToUString forces additional unneeded memory allocation. Fixed. > Exposing the names in the order they appeared in the CSSPropertyNames.in source file does not seem like a good idea. We should expose them in some order that is consistent and does not reflect the peculiarities of our source code. I would suggest alphabetical order if we can’t think of anything else. > > If we actually want this to be efficient we should be creating an array of identifiers one time only and then reusing the same identifiers in the future. Converting from const char* every time doesn’t seem helpful. Implemented caching of UStrings, yet caching of Identifiers seems impossible to me, as they require an ExecState/global state to get constructed. I'd be grateful if you could give me an insight on this. > > Source/WebCore/bindings/v8/custom/V8CSSStyleDeclarationCustom.cpp:159 > > + // We know that "filter" is present in the list but should not be provided in the enumeration. > > + // See a comment in the V8CSSStyleDeclaration::namedPropertyGetter() implementation. > > I don’t understand why this special rule to omit filter is in V8 but not in the other JavaScript binding, especially considering the comment in namedPropertyGetter implies it is there. I don’t understand why there is no test for it. I suspect this rule about "filter" was removed long ago but was left behind in V8 for not good reason. Good catch. I will fix this in another change shortly, given that the CSS filters are getting the momentum. But I don't feel like fixing this in this (orthogonal) change is a good idea, and I don't want to break the code consistency (the "filter" property will be there in the list but will evaluate to undefined). > > Source/WebCore/css/makeprop.pl:166 > > + $name =~ s/(\S)-(.)/$1@{[uc($2)]}/g; > > + $name =~ s/^-//; > > + print HEADER "\"$name\",\n"; > > +} > > +print HEADER "};\n"; > > I think it would be better to not change the contents of this file at all. Instead we could use the existing array of const char* and the first time it’s needed we could build an array of JSC::Identifier one time inside the bindings code and then reuse that each time instead of doing it over and over again. I believe we should do all transformations we can at build time, especially given that Perl has great capabilities for regexp operations. > If we do want to keep this, then I suggest we sort the array here, since we only use it for enumeration and so the order is not important. Sorting implemented. > I think (.)-(.) would work fine; I don’t think you need the \S there. Thanks, fixed. > > LayoutTests/fast/css/style-enumerate-properties-expected.txt:3 > > +Test for https://bugs.webkit.org/show_bug.cgi?id=23946 Webkit does not enumerate over CSS properties in HTMLElement.style - checks that the style contains exactly one numeric property "0" (for "text-decoration") and named properties "textDecoration", "border", "font", and "cssText". > > + > > +PASSED > > Tests should show what they are testing, not just say PASSED. Made use of shouldBe which is quite verbose. > > LayoutTests/fast/css/style-enumerate-properties.html:25 > > + if (!(p in style)) { > > + console.textContent = "Property '" + p + "' not found!"; > > + return; > > + } > > Better style would be to use the shouldBe macros and do shouldBe for each property so the test output would show what it’s testing. Done. > This test does not cover the order of the properties. It should. I'm not sure how to check this best. For now, the test checks that the first 100 CSS-mapped properties are sorted alphabetically, but I'm not sure this is the right approach. Any ideas are welcome. > This test does not cover any properties with more then two words in their names, and it should. Fixed. > > LayoutTests/fast/css/style-enumerate-properties.html:34 > > + Webkit does not enumerate over CSS properties in HTMLElement.style - checks that the style contains exactly one numeric property "0" (for "text-decoration") and named properties "textDecoration", "border", "font", and "cssText". > > WebKit has a capital K in its name. Fixed bug name. > > LayoutTests/fast/dom/script-tests/domListEnumeration.js:176 > > +// More properties can be added soon. Plus, Chromium hides the "filter" property. > > This comment is more confusing than helpful. It’s not clear how either of these is relevant to the next line of code. I realize that you are justifying the use of >= rather than == for the test, but only because I am reading the whole patch. The comment alone does not make it clear. > > > LayoutTests/fast/dom/script-tests/domListEnumeration.js:177 > > +shouldBeGreaterThanOrEqual("resultArray.length", "376"); > > Where did the 376 number come from? Is it right even if SVG is turned off? I think you should just not check the resultArray’s length at all. Removed this check altogether. 511674 15 117178 apavlov 2011-11-30 05:53:23 -0800 Created attachment 117178 Patch 512542 16 117354 apavlov 2011-11-30 23:50:57 -0800 Created attachment 117354 Patch 516673 17 apavlov 2011-12-07 09:22:39 -0800 @reviewers: anyone to have a look please? The comments have been addressed. 516674 18 117354 darin 2011-12-07 09:29:11 -0800 Comment on attachment 117354 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=117354&action=review Looks good. I’d still like to see a little more refinement. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:211 > + DEFINE_STATIC_LOCAL(Vector<UString>, jsPropertyNames, ()); > + if (jsPropertyNames.isEmpty()) { > + jsPropertyNames.reserveInitialCapacity(numCSSProperties); > + for (int i = 0; i < numCSSProperties; ++i) > + jsPropertyNames.append(UString(jsPropertyNameStrings[i])); > + } This should be Identifier[numCSSProperties], not Vector<UString>. The Identifier constructor takes a JSGlobalData*, not an ExecState*. The ExecState* constructor is just a convenience cover that uses the ExecState to find the JSGlobalData. All WebCore use of JavaScript shares a single JSGlobalData; to oversimplify, it’s basically a per-thread data structure. So it’s safe to construct this array only once with whatever ExecState you have that one time. And there is no reason to use a Vector for something we are not going to resize. Also, since we are doing this only one time, we could consider writing the code to convert the CSS style of property name string into the JavaScript binding style and avoid having a separate table. 517359 19 118379 apavlov 2011-12-08 06:20:09 -0800 Created attachment 118379 [PATCH] Implemented Identifier caching 517390 20 118385 apavlov 2011-12-08 07:11:06 -0800 Created attachment 118385 [PATCH] Restored property name sorting 518194 21 118549 apavlov 2011-12-09 02:22:17 -0800 Created attachment 118549 [PATCH] Update JSC exports to fix compilability on Win and Mac 518310 22 118549 darin 2011-12-09 10:00:09 -0800 Comment on attachment 118549 [PATCH] Update JSC exports to fix compilability on Win and Mac View in context: https://bugs.webkit.org/attachment.cgi?id=118549&action=review Seems OK to land like this. Still room for improvement either before or after landing. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:206 > + static Identifier* jsPropertyIdentifiers = 0; I don’t think you need the "js" prefix on this variable name. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:211 > + std::sort(jsPropertyNames.begin(), jsPropertyNames.end(), stringCompare); Our usual style in WebKit code is to put "using namespace std" at the top of the file rather than qualifying function names at the call site. > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:217 > + for (int i = 0; i < numCSSProperties; ++i) { > + String jsPropertyName = jsPropertyNames.at(i); > + jsPropertyIdentifiers[i] = Identifier(&exec->globalData(), jsPropertyName.characters(), jsPropertyName.length()); > + } The idiom here is slightly peculiar and unnecessarily inefficient. I would have written this: for (int i = 0; i < numCSSProperties; ++i) jsPropertyIdentifiers[i] = Identifier(exec, jsPropertyNames[i].impl()); This would use the buffers already allocated for the strings rather than reallocating each one. Since this is one-time code, it’s not critical, but I think my version of the code is already more readable because it’s more brief. > Source/WebCore/css/makeprop.pl:119 > +String getJSPropertyName(const char* cssPropertyName) We normally try to avoid abbreviations and use words for variable names. This function uses the names p, isFirstChar, ch, and nextCh, all of which are abbreviations. > Source/WebCore/css/makeprop.pl:121 > + StringBuilder result; Since the maximum length of any property name is known at compile time, this could just use a local char array and construct the String from that. It need not use StringBuilder at all. > Source/WebCore/css/makeprop.pl:123 > + bool isFirstChar = true; There is no need for the isFirstChar boolean. You can do the same check by comparing p - 2 with cssPropertyName inside the loop. > Source/WebCore/css/makeprop.pl:124 > + while (char ch = *(p++)) { Since *p++ is idiomatic, I think it’s better to leave off the parentheses. > Source/WebCore/css/makeprop.pl:129 > + ch = !isFirstChar ? (nextCh - 0x20) : nextCh; Just doing the - 0x20 here is not really all that great. I would suggest using toASCIILower instead for clarity even though it’s slightly less efficient. > Source/WebCore/css/makeprop.pl:149 > +#include <wtf/text/WTFString.h> If you move the inline function out of the header file then you can just forward-declare instead of including this header. > Source/WebCore/css/makeprop.pl:185 > +String getJSPropertyName(const char*); The use of get in this function name is consistent with the function above, but not normal WebKit naming. It’s strange to have this take a const char*. I would be more logical to have it take a CSSPropertyID to match the function above it. If it’s only going to take const char* then there is no good reason to put the code here auto-generated, and it can instead go into a normal source file. > Source/WebCore/css/makeprop.pl:186 > +static inline bool stringCompare(const String& first, const String& second) { return codePointCompare(first, second) < 0; } This function does not belong here. A basic string comparison function like this should be in WTFString.h. Also, it should have a name making clear how it differs from other functions. I suggest including the words “less than” in the function name. A function in a header file, even an inline one, should not be marked “static”. That should be left off so it will get external linkage. 518312 23 118549 darin 2011-12-09 10:02:15 -0800 Comment on attachment 118549 [PATCH] Update JSC exports to fix compilability on Win and Mac View in context: https://bugs.webkit.org/attachment.cgi?id=118549&action=review >> Source/WebCore/css/makeprop.pl:185 >> +String getJSPropertyName(const char*); > > The use of get in this function name is consistent with the function above, but not normal WebKit naming. > > It’s strange to have this take a const char*. I would be more logical to have it take a CSSPropertyID to match the function above it. If it’s only going to take const char* then there is no good reason to put the code here auto-generated, and it can instead go into a normal source file. The normal source file I would suggest as a home for this would be CSSStyleDeclaration.h/cpp. 519134 24 apavlov 2011-12-12 04:45:50 -0800 (In reply to comment #22) > (From update of attachment 118549 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=118549&action=review > > Seems OK to land like this. Still room for improvement either before or after landing. > > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:206 > > + static Identifier* jsPropertyIdentifiers = 0; > > I don’t think you need the "js" prefix on this variable name. Fixed > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:211 > > + std::sort(jsPropertyNames.begin(), jsPropertyNames.end(), stringCompare); > > Our usual style in WebKit code is to put "using namespace std" at the top of the file rather than qualifying function names at the call site. Fixed > > Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp:217 > > + for (int i = 0; i < numCSSProperties; ++i) { > > + String jsPropertyName = jsPropertyNames.at(i); > > + jsPropertyIdentifiers[i] = Identifier(&exec->globalData(), jsPropertyName.characters(), jsPropertyName.length()); > > + } > > The idiom here is slightly peculiar and unnecessarily inefficient. I would have written this: > > for (int i = 0; i < numCSSProperties; ++i) > jsPropertyIdentifiers[i] = Identifier(exec, jsPropertyNames[i].impl()); > > This would use the buffers already allocated for the strings rather than reallocating each one. Since this is one-time code, it’s not critical, but I think my version of the code is already more readable because it’s more brief. Fixed > > Source/WebCore/css/makeprop.pl:119 > > +String getJSPropertyName(const char* cssPropertyName) > > We normally try to avoid abbreviations and use words for variable names. This function uses the names p, isFirstChar, ch, and nextCh, all of which are abbreviations. Fixed > > Source/WebCore/css/makeprop.pl:121 > > + StringBuilder result; > > Since the maximum length of any property name is known at compile time, this could just use a local char array and construct the String from that. It need not use StringBuilder at all. Fixed > > Source/WebCore/css/makeprop.pl:123 > > + bool isFirstChar = true; > > There is no need for the isFirstChar boolean. You can do the same check by comparing p - 2 with cssPropertyName inside the loop. Fixed > > Source/WebCore/css/makeprop.pl:124 > > + while (char ch = *(p++)) { > > Since *p++ is idiomatic, I think it’s better to leave off the parentheses. Fixed > > Source/WebCore/css/makeprop.pl:129 > > + ch = !isFirstChar ? (nextCh - 0x20) : nextCh; > > Just doing the - 0x20 here is not really all that great. I would suggest using toASCIILower instead for clarity even though it’s slightly less efficient. Fixed (toASCIIUpper) > > Source/WebCore/css/makeprop.pl:149 > > +#include <wtf/text/WTFString.h> > > If you move the inline function out of the header file then you can just forward-declare instead of including this header. Fixed > > Source/WebCore/css/makeprop.pl:185 > > +String getJSPropertyName(const char*); > > The use of get in this function name is consistent with the function above, but not normal WebKit naming. When in doubt, use the style found around... These can be fixed together if need be. > It’s strange to have this take a const char*. I would be more logical to have it take a CSSPropertyID to match the function above it. If it’s only going to take const char* then there is no good reason to put the code here auto-generated, and it can instead go into a normal source file. Using CSSPropertyID instead of const char* (and hence, not moving it into CSSStyleDeclaration.*) > > Source/WebCore/css/makeprop.pl:186 > > +static inline bool stringCompare(const String& first, const String& second) { return codePointCompare(first, second) < 0; } > > This function does not belong here. A basic string comparison function like this should be in WTFString.h. Also, it should have a name making clear how it differs from other functions. I suggest including the words “less than” in the function name. Placed codePointCompareLessThan into WTFString.h. > A function in a header file, even an inline one, should not be marked “static”. That should be left off so it will get external linkage. Sorry, fixed. Will land shortly with these fixes applied. 519145 25 apavlov 2011-12-12 05:24:56 -0800 Committed r102570: <http://trac.webkit.org/changeset/102570> 519167 26 apavlov 2011-12-12 06:46:43 -0800 Committed r102578: <http://trac.webkit.org/changeset/102578> 519177 27 apavlov 2011-12-12 07:17:19 -0800 (In reply to comment #26) > Committed r102578: <http://trac.webkit.org/changeset/102578> This is the effective commit, as r102570 was reverted due to a SnowLeopard builder breakage. 27644 2009-02-13 00:32:44 -0800 2009-02-13 00:32:44 -0800 Testcase for bug #23946 test.html text/html 819 lea PCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFs Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25h bC5kdGQiPg0KPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPg0KPGhl YWQ+DQo8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsg Y2hhcnNldD1pc28tODg1OS03IiAvPg0KPHRpdGxlPlRlc3QgY2FzZSBmb3Igd2Via2l0IGJ1Zzwv dGl0bGU+DQoNCjxzY3JpcHQgc3JjPSJqQXNzZXQvakFzc2V0LmpzIj48L3NjcmlwdD4NCjwvaGVh ZD4NCg0KPGJvZHkgc3R5bGU9ImJhY2tncm91bmQ6YmVpZ2U7DQoJCXdpZHRoOjYwMHB4Ow0KCQli b3JkZXI6M3B4IHNvbGlkIHdoaXRlOw0KCQlwYWRkaW5nOjIwcHg7DQoJCS13ZWJraXQtYm9yZGVy LXJhZGl1czoyMHB4Ow0KCQktbW96LWJvcmRlci1yYWRpdXM6MjBweDsiPg0KPGRpdiBzdHlsZT0i b3ZlcmZsb3c6YXV0bzsgaGVpZ2h0OjQwMHB4OyI+DQo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNj cmlwdCI+DQoJZm9yICh2YXIgaSBpbiBkb2N1bWVudC5ib2R5LnN0eWxlKSBkb2N1bWVudC53cml0 ZShpICsgJzxiciAvPicpOw0KPC9zY3JpcHQ+DQo8L2Rpdj4NCjxzY3JpcHQgdHlwZT0idGV4dC9q YXZhc2NyaXB0Ij4NCglkb2N1bWVudC53cml0ZSgiJ21hcmdpbicgaW4gZG9jdW1lbnQuYm9keS5z dHlsZSBpcyAiICsgKCdtYXJnaW4nIGluIGRvY3VtZW50LmJvZHkuc3R5bGUpKTsNCjwvc2NyaXB0 Pg0KPC9ib2R5Pg0KPC9odG1sPg0K 116607 2011-11-25 05:47:30 -0800 2011-11-29 01:52:01 -0800 Patch bug-23946-20111125174728.patch text/plain 11295 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxMTM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjQ2OTk5MDhkOWE5NjE3 NWNkMTBkNjNjNjVkMWE2MDFmYzFhNDFjZC4uNGMxMDJjZGEwMTYwYTQ3NmI4ZTExZjI5MGQ4ZWM5 NDdlZDQ2NjdhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2Via2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBHZW5lcmF0ZSBh IGxpc3Qgb2YgSlMtc3R5bGUgQ1NTIHByb3BlcnR5IG5hbWVzLgorCiAyMDExLTExLTI0ICBBbmRy ZXkgS29zeWFrb3YgIDxjYXNlcUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3Rv cjogcHJvdmlkZSBjb250ZXh0IG1lbnUgaXRlbXMgdG8gb3BlbiByZXNvdXJjZXMgdXNpbmcgZXh0 ZW5zaW9ucwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHls ZURlY2xhcmF0aW9uQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTQ1NT U3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXggODZkYzY0ZmU2Y2YxMWJhYjNkOGJiNTk4 ZTU5ZmUxYzFlZjEyYTk5Yi4uYzMxNDU2M2Q4ZDY1ODAyNDliZmU2YWY2MjNlZjZiNzcwYTQ3MDYz NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xh cmF0aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0 eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJD U1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVl LmgiCisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlLmgi CiAjaW5jbHVkZSAiSlNDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkpTTm9kZS5oIgpAQCAtMTM5LDgg KzE0MCw2IEBAIGJvb2wgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpjYW5HZXRJdGVtc0Zvck5hbWUo RXhlY1N0YXRlKiwgQ1NTU3R5bGVEZWNsYXJhdGlvbiosCiAgICAgcmV0dXJuIGlzQ1NTUHJvcGVy dHlOYW1lKHByb3BlcnR5TmFtZSk7CiB9CiAKLS8vIEZJWE1FOiBZb3UgY2FuIGdldCB0aGVzZSBw cm9wZXJ0aWVzLCBhbmQgc2V0IHRoZW0gKHNlZSBwdXREZWxlZ2F0ZSBiZWxvdyksCi0vLyBidXQg eW91IHNob3VsZCBhbHNvIGJlIGFibGUgdG8gZW51bWVyYXRlIHRoZW0uCiBKU1ZhbHVlIEpTQ1NT U3R5bGVEZWNsYXJhdGlvbjo6bmFtZUdldHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgc2xv dEJhc2UsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5TmFtZSkKIHsKICAgICBKU0NTU1N0eWxl RGVjbGFyYXRpb24qIHRoaXNPYmogPSBzdGF0aWNfY2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24q Pihhc09iamVjdChzbG90QmFzZSkpOwpAQCAtMTk1LDQgKzE5NCwxNyBAQCBKU1ZhbHVlIEpTQ1NT U3R5bGVEZWNsYXJhdGlvbjo6Z2V0UHJvcGVydHlDU1NWYWx1ZShFeGVjU3RhdGUqIGV4ZWMpCiAg ICAgcmV0dXJuIHRvSlMoZXhlYywgZ2xvYmFsT2JqZWN0KCksIFdURjo6Z2V0UHRyKGNzc1ZhbHVl KSk7CiB9CiAKK3ZvaWQgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVz KEpTT2JqZWN0KiBvYmplY3QsIEV4ZWNTdGF0ZSogZXhlYywgUHJvcGVydHlOYW1lQXJyYXkmIHBy b3BlcnR5TmFtZXMsIEVudW1lcmF0aW9uTW9kZSBtb2RlKQoreworICAgIEpTQ1NTU3R5bGVEZWNs YXJhdGlvbiogdGhpc09iamVjdCA9IGpzQ2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24qPihvYmpl Y3QpOworICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5IRVJJVFModGhpc09iamVjdCwgJnNfaW5mbyk7 CisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwLCBsZW5ndGggPSBzdGF0aWNfY2FzdDxDU1NTdHls ZURlY2xhcmF0aW9uKj4odGhpc09iamVjdC0+aW1wbCgpKS0+bGVuZ3RoKCk7IGkgPCBsZW5ndGg7 ICsraSkKKyAgICAgICAgcHJvcGVydHlOYW1lcy5hZGQoSWRlbnRpZmllcjo6ZnJvbShleGVjLCBp KSk7CisgICAgQmFzZTo6Z2V0T3duUHJvcGVydHlOYW1lcyh0aGlzT2JqZWN0LCBleGVjLCBwcm9w ZXJ0eU5hbWVzLCBtb2RlKTsKKworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVy dGllczsgKytpKQorICAgICAgICBwcm9wZXJ0eU5hbWVzLmFkZChJZGVudGlmaWVyKGV4ZWMsIHN0 cmluZ1RvVVN0cmluZyhqc1Byb3BlcnR5TmFtZVN0cmluZ3NbaV0pKSk7Cit9CisKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1 c3RvbS9WOENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXggYWQ2 ZDI5MDcyZWNkNTlhYWQwYzg4ODU4NWEzM2M2NjkyZjg2MGViOC4uOTZhMWQ1OGViZWFkOTQ5ZGU2 MjNjMjJiODU0ZGIyMWFhMGYzZDAxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5j cHAKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJWOENTU1N0eWxlRGVjbGFyYXRpb24uaCIK IAogI2luY2x1ZGUgIkNTU1BhcnNlci5oIgorI2luY2x1ZGUgIkNTU1Byb3BlcnR5TmFtZXMuaCIK ICNpbmNsdWRlICJDU1NTdHlsZURlY2xhcmF0aW9uLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWUuaCIK ICNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgpAQCAtMTUyLDYgKzE1MywyOCBAQCBzdGF0 aWMgQ1NTUHJvcGVydHlJbmZvKiBjc3NQcm9wZXJ0eUluZm8odjg6OkhhbmRsZTx2ODo6U3RyaW5n PnY4UHJvcGVydHlOYW1lKQogICAgIHJldHVybiBwcm9wSW5mbzsKIH0KIAordjg6OkhhbmRsZTx2 ODo6QXJyYXk+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUVudW1lcmF0b3Io Y29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sKKyAgICAvLyBXZSBrbm93IHRoYXQgImZp bHRlciIgaXMgcHJlc2VudCBpbiB0aGUgbGlzdCBidXQgc2hvdWxkIG5vdCBiZSBwcm92aWRlZCBp biB0aGUgZW51bWVyYXRpb24uCisgICAgdjg6OkhhbmRsZTx2ODo6QXJyYXk+IHByb3BlcnRpZXMg PSB2ODo6QXJyYXk6Ok5ldyhudW1DU1NQcm9wZXJ0aWVzIC0gMSk7CisgICAgREVGSU5FX1NUQVRJ Q19MT0NBTChTdHJpbmcsIGZpbHRlclN0cmluZywgKCJmaWx0ZXIiKSk7CisgICAgZm9yIChpbnQg aSA9IDA7IGkgPCBudW1DU1NQcm9wZXJ0aWVzOyArK2kpIHsKKyAgICAgICAgU3RyaW5nIGtleSA9 IGpzUHJvcGVydHlOYW1lU3RyaW5nc1tpXTsKKyAgICAgICAgQVNTRVJUKCFrZXkuaXNOdWxsKCkp OworCisgICAgICAgIGlmIChrZXkgIT0gZmlsdGVyU3RyaW5nKQorICAgICAgICAgICAgcHJvcGVy dGllcy0+U2V0KHY4OjpJbnRlZ2VyOjpOZXcoaSksIHY4U3RyaW5nKGtleSkpOworICAgIH0KKwor ICAgIHJldHVybiBwcm9wZXJ0aWVzOworfQorCit2ODo6SGFuZGxlPHY4OjpJbnRlZ2VyPiBWOENT U1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSh2ODo6TG9jYWw8djg6OlN0cmlu Zz4gdjhOYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBpbmZvKQoreworICAgIElOQ19TVEFU UygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFtZWRQcm9wZXJ0eVF1ZXJ5Iik7CisgICAgcmV0 dXJuIHY4OjpJbnRlZ2VyOjpOZXcodjg6Ok5vbmUpOworfQorCiB2ODo6SGFuZGxlPHY4OjpWYWx1 ZT4gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKHY4OjpMb2NhbDx2 ODo6U3RyaW5nPiBuYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBpbmZvKQogewogICAgIElO Q19TVEFUUygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFtZWRQcm9wZXJ0eUdldHRlciIpOwpA QCAtMTYwLDE0ICsxODMsMTMgQEAgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4Q1NTU3R5bGVEZWNs YXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUdldHRlcih2ODo6TG9jYWw8djg6OlMKICAgICAgICAgcmV0 dXJuIG5vdEhhbmRsZWRCeUludGVyY2VwdG9yKCk7CiAKICAgICAvLyBTZWFyY2ggdGhlIHN0eWxl IGRlY2xhcmF0aW9uLgotICAgIENTU1N0eWxlRGVjbGFyYXRpb24qIGltcCA9IFY4Q1NTU3R5bGVE ZWNsYXJhdGlvbjo6dG9OYXRpdmUoaW5mby5Ib2xkZXIoKSk7CiAgICAgQ1NTUHJvcGVydHlJbmZv KiBwcm9wSW5mbyA9IGNzc1Byb3BlcnR5SW5mbyhuYW1lKTsKIAogICAgIC8vIERvIG5vdCBoYW5k bGUgbm9uLXByb3BlcnR5IG5hbWVzLgogICAgIGlmICghcHJvcEluZm8pCiAgICAgICAgIHJldHVy biBub3RIYW5kbGVkQnlJbnRlcmNlcHRvcigpOwogCi0KKyAgICBDU1NTdHlsZURlY2xhcmF0aW9u KiBpbXAgPSBWOENTU1N0eWxlRGVjbGFyYXRpb246OnRvTmF0aXZlKGluZm8uSG9sZGVyKCkpOwog ICAgIFJlZlB0cjxDU1NWYWx1ZT4gY3NzVmFsdWUgPSBpbXAtPmdldFByb3BlcnR5Q1NTVmFsdWUo cHJvcEluZm8tPnByb3BJRCk7CiAgICAgaWYgKGNzc1ZhbHVlKSB7CiAgICAgICAgIGlmIChwcm9w SW5mby0+aGFkUGl4ZWxPclBvc1ByZWZpeCAmJgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv Y3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsIGIvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxl RGVjbGFyYXRpb24uaWRsCmluZGV4IDJmYTYwOWIxMDFjNGYzNTU2NDUwNzZiYmJiNDc2ZDVkNjkz MzViNDguLmQxYjQ3MGY4NzQ4Y2YyOTlhZmM1MWFmNGE2MzNiNDM0NmI3MmY0OWQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwKQEAgLTI3LDYgKzI3LDcgQEAg bW9kdWxlIGNzcyB7CiAgICAgICAgIERlbGVnYXRpbmdQdXRGdW5jdGlvbiwKICAgICAgICAgSGFz TmFtZUdldHRlciwKICAgICAgICAgSGFzSW5kZXhHZXR0ZXIsCisgICAgICAgIEN1c3RvbUdldFBy b3BlcnR5TmFtZXMsCiAgICAgICAgIFY4RGVwZW5kZW50TGlmZXRpbWUKICAgICBdIENTU1N0eWxl RGVjbGFyYXRpb24gewogICAgICAgICAgICAgICAgICBhdHRyaWJ1dGUgW0NvbnZlcnROdWxsU3Ry aW5nVG89TnVsbCwgQ29udmVydE51bGxUb051bGxTdHJpbmddIERPTVN0cmluZyAgICAgICAgY3Nz VGV4dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsIGIvU291cmNl L1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsCmluZGV4IDQ1YWY3MTMzZTY5YTBjZjRiMTVlZGJhYjdk NTJkNjc3MDY1MjRjZmYuLjQwMTlkYmMwZWJkMWFkZmExODhjMzFiOWMzMzY4YWM3NDI1NzBkYTIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9jc3MvbWFrZXByb3AucGwKQEAgLTE1Nyw2ICsxNTcsMTQgQEAgZm9yZWFjaCBteSAk bmFtZSAoQG5hbWVzKSB7CiB9CiBwcmludCBIRUFERVIgIn07XG4iOwogCitwcmludCBIRUFERVIg ImNvbnN0IGNoYXIqIGNvbnN0IGpzUHJvcGVydHlOYW1lU3RyaW5nc1skbnVtXSA9IHtcbiI7Citm b3JlYWNoIG15ICRuYW1lIChAbmFtZXMpIHsKKyAgJG5hbWUgPX4gcy8oXFMpLSguKS8kMUB7W3Vj KCQyKV19L2c7CisgICRuYW1lID1+IHMvXi0vLzsKKyAgcHJpbnQgSEVBREVSICJcIiRuYW1lXCIs XG4iOworfQorcHJpbnQgSEVBREVSICJ9O1xuIjsKKwogcHJpbnQgSEVBREVSIDw8ICJFT0YiOwog CiBjb25zdCBjaGFyKiBnZXRQcm9wZXJ0eU5hbWUoQ1NTUHJvcGVydHlJRCk7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggZGQ3 Nzg0YTlhNjZlMDk2ZWJkZTc4YmI1YmU5MmZkOWNmNDQ5OGM4Yi4uM2NmM2QwNzczMzQwZWRmNGE1 MGNjYjI1MTQxNmVkNzIxMzM4ZDBiNSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDExLTExLTI1 ICBBbGV4YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2Vi a2l0IGRvZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50 LnN0eWxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y Mzk0NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog ZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sOiBBZGRl ZC4KKyAgICAgICAgKiBmYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0Ogor ICAgICAgICAqIGZhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51bWVyYXRpb24uanM6CisK IDIwMTEtMTEtMjMgIFBhdmVsIFBvZGl2aWxvdiAgPHBvZGl2aWxvdkBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgV2ViIEluc3BlY3RvcjogYWRkIGludGVncmF0aW9uIHRlc3QgZm9yIGNvbXBpbGVy IHNvdXJjZSBtYXBzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51 bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5 bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg4N2QyYWEw MTAxOWI1ZDQzOGJlZmQwMjRiNDUwMDdjYmQ2NWY1ZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3RlZC50eHQK QEAgLTAsMCArMSwzNiBAQAorVGVzdCBmb3IgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIzOTQ2IFdlYmtpdCBkb2VzIG5vdCBlbnVtZXJhdGUgb3ZlciBDU1MgcHJvcGVy dGllcyBpbiBIVE1MRWxlbWVudC5zdHlsZS4KKworYm9yZGVyCitib3JkZXJCb3R0b20KK2JvcmRl ckJvdHRvbUNvbG9yCitib3JkZXJCb3R0b21MZWZ0UmFkaXVzCitib3JkZXJCb3R0b21SaWdodFJh ZGl1cworYm9yZGVyQm90dG9tU3R5bGUKK2JvcmRlckJvdHRvbVdpZHRoCitib3JkZXJDb2xsYXBz ZQorYm9yZGVyQ29sb3IKK2JvcmRlckltYWdlCitib3JkZXJJbWFnZU91dHNldAorYm9yZGVySW1h Z2VSZXBlYXQKK2JvcmRlckltYWdlU2xpY2UKK2JvcmRlckltYWdlU291cmNlCitib3JkZXJJbWFn ZVdpZHRoCitib3JkZXJMZWZ0Citib3JkZXJMZWZ0Q29sb3IKK2JvcmRlckxlZnRTdHlsZQorYm9y ZGVyTGVmdFdpZHRoCitib3JkZXJSYWRpdXMKK2JvcmRlclJpZ2h0Citib3JkZXJSaWdodENvbG9y Citib3JkZXJSaWdodFN0eWxlCitib3JkZXJSaWdodFdpZHRoCitib3JkZXJTcGFjaW5nCitib3Jk ZXJTdHlsZQorYm9yZGVyVG9wCitib3JkZXJUb3BDb2xvcgorYm9yZGVyVG9wTGVmdFJhZGl1cwor Ym9yZGVyVG9wUmlnaHRSYWRpdXMKK2JvcmRlclRvcFN0eWxlCitib3JkZXJUb3BXaWR0aAorYm9y ZGVyV2lkdGgKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVy YXRlLXByb3BlcnRpZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0 ZS1wcm9wZXJ0aWVzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTAzYThjZGQ4ZWNjY2FkNzAzM2ZkZDc0Njk0 NDMxNDUxMjM4NDQ2MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0 eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPGhlYWQ+Cisg ICAgPHNjcmlwdD4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAg ICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICA8L3Njcmlw dD4KKzwvaGVhZD4KKzxib2R5PgorICAgIDxwPgorICAgICAgICBUZXN0IGZvciA8aT48YSBocmVm PSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDYiPmh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0NjwvYT4KKyAgICAgICAgV2Via2l0 IGRvZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0 eWxlPC9pPi4KKyAgICA8L3A+CisgICAgPHNjcmlwdD4KKyAgICAgICAgZm9yICh2YXIgcCBpbiBk b2N1bWVudC5ib2R5LnN0eWxlKSB7CisgICAgICAgICAgICBpZiAocC5pbmRleE9mKCJib3JkZXIi KSA9PT0gMCkKKyAgICAgICAgICAgICAgICBkb2N1bWVudC53cml0ZShwICsgIjxiciAvPiIpOwor ICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA3MjJiYTA3OTcx OWE0NmNmYjUwNDQ5MmE3NjVhZTMxMGExNmJmOGE1Li40NTViNWI5YTU0OTY5MDIzNDk5YWY5YTEw NzIyZGVlMGY1MmI5ZjFlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21MaXN0 RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxp c3RFbnVtZXJhdGlvbi1leHBlY3RlZC50eHQKQEAgLTY2LDcgKzY2LDcgQEAgUEFTUyByZXN1bHRB cnJheVsyXS5pIGlzICcyJwogUEFTUyByZXN1bHRBcnJheVsyXS5pdGVtIGlzIGNzc1J1bGVMaXN0 Lml0ZW0oMikKIAogW29iamVjdCBDU1NTdHlsZURlY2xhcmF0aW9uXQotUEFTUyByZXN1bHRBcnJh eS5sZW5ndGggaXMgMTQKK1BBU1MgcmVzdWx0QXJyYXkubGVuZ3RoIGlzID49IDM3NgogUEFTUyBy ZXN1bHRBcnJheVswXS5pIGlzICcwJwogUEFTUyByZXN1bHRBcnJheVswXS5pdGVtIGlzIGNzc1N0 eWxlRGVjbGFyYXRpb24uaXRlbSgwKQogUEFTUyByZXN1bHRBcnJheVsxXS5pIGlzICcxJwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJh dGlvbi5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51bWVy YXRpb24uanMKaW5kZXggYTA5OWM4MzU2M2Y4M2UwMGQ1MzQ2ZmM4YzM3NmI4Y2JkZmM1Y2M5Ni4u ZmIxMGVmNDNkYjUxMjQ3ODYyNzhlMjJlNGUxZTk0MGMxYWMyNmY2NSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcworKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpz CkBAIC0xNzMsNyArMTczLDggQEAgc2hvdWxkQmUoInJlc3VsdEFycmF5WzJdLml0ZW0iLCAiY3Nz UnVsZUxpc3QuaXRlbSgyKSIpOwogLy9kZWJ1Zyhlc2NhcGVIVE1MKGRvY3VtZW50LmdldEVsZW1l bnRzQnlUYWdOYW1lKCdzdHlsZScpKSk7CiB2YXIgY3NzU3R5bGVEZWNsYXJhdGlvbiA9IGRvY3Vt ZW50LnN0eWxlU2hlZXRzWzJdLmNzc1J1bGVzWzBdLnN0eWxlOwogcmVzdWx0QXJyYXkgPSBpdGVy YXRlTGlzdChjc3NTdHlsZURlY2xhcmF0aW9uKTsKLXNob3VsZEJlKCJyZXN1bHRBcnJheS5sZW5n dGgiLCAiMTQiKTsKKy8vIE1vcmUgcHJvcGVydGllcyBjYW4gYmUgYWRkZWQgc29vbi4gUGx1cywg Q2hyb21pdW0gaGlkZXMgdGhlICJmaWx0ZXIiIHByb3BlcnR5Lgorc2hvdWxkQmVHcmVhdGVyVGhh bk9yRXF1YWwoInJlc3VsdEFycmF5Lmxlbmd0aCIsICIzNzYiKTsKIHNob3VsZEJlKCJyZXN1bHRB cnJheVswXS5pIiwgIicwJyIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzBdLml0ZW0iLCAiY3Nz U3R5bGVEZWNsYXJhdGlvbi5pdGVtKDApIik7CiBzaG91bGRCZSgicmVzdWx0QXJyYXlbMV0uaSIs ICInMSciKTsK 116923 2011-11-29 01:52:12 -0800 2011-11-30 05:53:13 -0800 Patch bug-23946-20111129135210.patch text/plain 11751 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxMzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWVmOWRmYTBlNjlkZDVk ZjY3ZjVjYWIzNmMwYjY3OTlmZjE4YjQyZS4uNzc1M2RmY2UyOGM3NjBlY2NhNGFhMDdjMzRlYTcw OTg1ZTQyYTZkMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2Via2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBHZW5lcmF0ZSBh IGxpc3Qgb2YgSlMtc3R5bGUgQ1NTIHByb3BlcnR5IG5hbWVzLgorCiAyMDExLTExLTI5ICBTZWFu IFdhbmcgIDxYdWV3ZW4uV2FuZ0B0b3JjaG1vYmlsZS5jb20uY24+CiAKICAgICAgICAgVXBzdHJl YW0gQmxhY2tCZXJyeSBwb3J0aW5nIG9mIHBsYXRmb3JtL2ltYWdlLWRlY29kZXJzCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0 b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0aW9u Q3VzdG9tLmNwcAppbmRleCA4NmRjNjRmZTZjZjExYmFiM2Q4YmI1OThlNTlmZTFjMWVmMTJhOTli Li45MjA2YTg5MWY1NjZjOTRkMmRkZjkxZTBjMDdjNWVjYjVhYjM5NDAwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTQ1NTU3R5bGVEZWNsYXJhdGlvbkN1 c3RvbS5jcHAKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkNTU011dGFibGVTdHlsZURl Y2xhcmF0aW9uLmgiCiAjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFsdWUuaCIKKyNpbmNsdWRlICJD U1NQcm9wZXJ0eU5hbWVzLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWUuaCIKICNpbmNsdWRlICJKU0NT U1ZhbHVlLmgiCiAjaW5jbHVkZSAiSlNOb2RlLmgiCkBAIC0xMzksOCArMTQwLDYgQEAgYm9vbCBK U0NTU1N0eWxlRGVjbGFyYXRpb246OmNhbkdldEl0ZW1zRm9yTmFtZShFeGVjU3RhdGUqLCBDU1NT dHlsZURlY2xhcmF0aW9uKiwKICAgICByZXR1cm4gaXNDU1NQcm9wZXJ0eU5hbWUocHJvcGVydHlO YW1lKTsKIH0KIAotLy8gRklYTUU6IFlvdSBjYW4gZ2V0IHRoZXNlIHByb3BlcnRpZXMsIGFuZCBz ZXQgdGhlbSAoc2VlIHB1dERlbGVnYXRlIGJlbG93KSwKLS8vIGJ1dCB5b3Ugc2hvdWxkIGFsc28g YmUgYWJsZSB0byBlbnVtZXJhdGUgdGhlbS4KIEpTVmFsdWUgSlNDU1NTdHlsZURlY2xhcmF0aW9u OjpuYW1lR2V0dGVyKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSBzbG90QmFzZSwgY29uc3QgSWRl bnRpZmllciYgcHJvcGVydHlOYW1lKQogewogICAgIEpTQ1NTU3R5bGVEZWNsYXJhdGlvbiogdGhp c09iaiA9IHN0YXRpY19jYXN0PEpTQ1NTU3R5bGVEZWNsYXJhdGlvbio+KGFzT2JqZWN0KHNsb3RC YXNlKSk7CkBAIC0xOTUsNCArMTk0LDE4IEBAIEpTVmFsdWUgSlNDU1NTdHlsZURlY2xhcmF0aW9u OjpnZXRQcm9wZXJ0eUNTU1ZhbHVlKEV4ZWNTdGF0ZSogZXhlYykKICAgICByZXR1cm4gdG9KUyhl eGVjLCBnbG9iYWxPYmplY3QoKSwgV1RGOjpnZXRQdHIoY3NzVmFsdWUpKTsKIH0KIAordm9pZCBK U0NTU1N0eWxlRGVjbGFyYXRpb246OmdldE93blByb3BlcnR5TmFtZXMoSlNPYmplY3QqIG9iamVj dCwgRXhlY1N0YXRlKiBleGVjLCBQcm9wZXJ0eU5hbWVBcnJheSYgcHJvcGVydHlOYW1lcywgRW51 bWVyYXRpb25Nb2RlIG1vZGUpCit7CisgICAgSlNDU1NTdHlsZURlY2xhcmF0aW9uKiB0aGlzT2Jq ZWN0ID0ganNDYXN0PEpTQ1NTU3R5bGVEZWNsYXJhdGlvbio+KG9iamVjdCk7CisgICAgQVNTRVJU X0dDX09CSkVDVF9JTkhFUklUUyh0aGlzT2JqZWN0LCAmc19pbmZvKTsKKworICAgIGZvciAodW5z aWduZWQgaSA9IDAsIGxlbmd0aCA9IHN0YXRpY19jYXN0PENTU1N0eWxlRGVjbGFyYXRpb24qPih0 aGlzT2JqZWN0LT5pbXBsKCkpLT5sZW5ndGgoKTsgaSA8IGxlbmd0aDsgKytpKQorICAgICAgICBw cm9wZXJ0eU5hbWVzLmFkZChJZGVudGlmaWVyOjpmcm9tKGV4ZWMsIGkpKTsKKworICAgIGZvciAo aW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVydGllczsgKytpKQorICAgICAgICBwcm9wZXJ0eU5h bWVzLmFkZChJZGVudGlmaWVyKGV4ZWMsIHN0cmluZ1RvVVN0cmluZyhqc1Byb3BlcnR5TmFtZVN0 cmluZ3NbaV0pKSk7CisKKyAgICBCYXNlOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKHRoaXNPYmplY3Qs IGV4ZWMsIHByb3BlcnR5TmFtZXMsIG1vZGUpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhDU1NTdHls ZURlY2xhcmF0aW9uQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3Rv bS9WOENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCmluZGV4IGFkNmQyOTA3MmVjZDU5YWFk MGM4ODg1ODVhMzNjNjY5MmY4NjBlYjguLjJhMTE3ZmUxYzdkNzliNTA5ZGRlZGQ5MDUwM2M3OGY5 MjE1NzQ1YzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9W OENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL3Y4L2N1c3RvbS9WOENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0zMiw2ICsz Miw3IEBACiAjaW5jbHVkZSAiVjhDU1NTdHlsZURlY2xhcmF0aW9uLmgiCiAKICNpbmNsdWRlICJD U1NQYXJzZXIuaCIKKyNpbmNsdWRlICJDU1NQcm9wZXJ0eU5hbWVzLmgiCiAjaW5jbHVkZSAiQ1NT U3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlLmgiCiAjaW5jbHVkZSAiQ1NT UHJpbWl0aXZlVmFsdWUuaCIKQEAgLTE1Miw2ICsxNTMsMjkgQEAgc3RhdGljIENTU1Byb3BlcnR5 SW5mbyogY3NzUHJvcGVydHlJbmZvKHY4OjpIYW5kbGU8djg6OlN0cmluZz52OFByb3BlcnR5TmFt ZSkKICAgICByZXR1cm4gcHJvcEluZm87CiB9CiAKK3Y4OjpIYW5kbGU8djg6OkFycmF5PiBWOENT U1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlFbnVtZXJhdG9yKGNvbnN0IHY4OjpBY2Nl c3NvckluZm8mIGluZm8pCit7CisgICAgLy8gV2Uga25vdyB0aGF0ICJmaWx0ZXIiIGlzIHByZXNl bnQgaW4gdGhlIGxpc3QgYnV0IHNob3VsZCBub3QgYmUgcHJvdmlkZWQgaW4gdGhlIGVudW1lcmF0 aW9uLgorICAgIC8vIFNlZSBhIGNvbW1lbnQgaW4gdGhlIFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6 bmFtZWRQcm9wZXJ0eUdldHRlcigpIGltcGxlbWVudGF0aW9uLgorICAgIHY4OjpIYW5kbGU8djg6 OkFycmF5PiBwcm9wZXJ0aWVzID0gdjg6OkFycmF5OjpOZXcobnVtQ1NTUHJvcGVydGllcyAtIDEp OworICAgIERFRklORV9TVEFUSUNfTE9DQUwoU3RyaW5nLCBmaWx0ZXJTdHJpbmcsICgiZmlsdGVy IikpOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVydGllczsgKytpKSB7Cisg ICAgICAgIFN0cmluZyBrZXkgPSBqc1Byb3BlcnR5TmFtZVN0cmluZ3NbaV07CisgICAgICAgIEFT U0VSVCgha2V5LmlzTnVsbCgpKTsKKworICAgICAgICBpZiAoa2V5ICE9IGZpbHRlclN0cmluZykK KyAgICAgICAgICAgIHByb3BlcnRpZXMtPlNldCh2ODo6SW50ZWdlcjo6TmV3KGkpLCB2OFN0cmlu ZyhrZXkpKTsKKyAgICB9CisKKyAgICByZXR1cm4gcHJvcGVydGllczsKK30KKwordjg6OkhhbmRs ZTx2ODo6SW50ZWdlcj4gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5UXVlcnko djg6OkxvY2FsPHY4OjpTdHJpbmc+IHY4TmFtZSwgY29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5m bykKK3sKKyAgICBJTkNfU1RBVFMoIkRPTS5DU1NTdHlsZURlY2xhcmF0aW9uLk5hbWVkUHJvcGVy dHlRdWVyeSIpOworICAgIHJldHVybiB2ODo6SW50ZWdlcjo6TmV3KHY4OjpOb25lKTsKK30KKwog djg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0 eUdldHRlcih2ODo6TG9jYWw8djg6OlN0cmluZz4gbmFtZSwgY29uc3Qgdjg6OkFjY2Vzc29ySW5m byYgaW5mbykKIHsKICAgICBJTkNfU1RBVFMoIkRPTS5DU1NTdHlsZURlY2xhcmF0aW9uLk5hbWVk UHJvcGVydHlHZXR0ZXIiKTsKQEAgLTE2MCwxNCArMTg0LDEzIEBAIHY4OjpIYW5kbGU8djg6OlZh bHVlPiBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlHZXR0ZXIodjg6OkxvY2Fs PHY4OjpTCiAgICAgICAgIHJldHVybiBub3RIYW5kbGVkQnlJbnRlcmNlcHRvcigpOwogCiAgICAg Ly8gU2VhcmNoIHRoZSBzdHlsZSBkZWNsYXJhdGlvbi4KLSAgICBDU1NTdHlsZURlY2xhcmF0aW9u KiBpbXAgPSBWOENTU1N0eWxlRGVjbGFyYXRpb246OnRvTmF0aXZlKGluZm8uSG9sZGVyKCkpOwog ICAgIENTU1Byb3BlcnR5SW5mbyogcHJvcEluZm8gPSBjc3NQcm9wZXJ0eUluZm8obmFtZSk7CiAK ICAgICAvLyBEbyBub3QgaGFuZGxlIG5vbi1wcm9wZXJ0eSBuYW1lcy4KICAgICBpZiAoIXByb3BJ bmZvKQogICAgICAgICByZXR1cm4gbm90SGFuZGxlZEJ5SW50ZXJjZXB0b3IoKTsKIAotCisgICAg Q1NTU3R5bGVEZWNsYXJhdGlvbiogaW1wID0gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjp0b05hdGl2 ZShpbmZvLkhvbGRlcigpKTsKICAgICBSZWZQdHI8Q1NTVmFsdWU+IGNzc1ZhbHVlID0gaW1wLT5n ZXRQcm9wZXJ0eUNTU1ZhbHVlKHByb3BJbmZvLT5wcm9wSUQpOwogICAgIGlmIChjc3NWYWx1ZSkg ewogICAgICAgICBpZiAocHJvcEluZm8tPmhhZFBpeGVsT3JQb3NQcmVmaXggJiYKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbCBiL1NvdXJjZS9X ZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbAppbmRleCAyZmE2MDliMTAxYzRmMzU1 NjQ1MDc2YmJiYjQ3NmQ1ZDY5MzM1YjQ4Li5kMWI0NzBmODc0OGNmMjk5YWZjNTFhZjRhNjMzYjQz NDZiNzJmNDlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJh dGlvbi5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRs CkBAIC0yNyw2ICsyNyw3IEBAIG1vZHVsZSBjc3MgewogICAgICAgICBEZWxlZ2F0aW5nUHV0RnVu Y3Rpb24sCiAgICAgICAgIEhhc05hbWVHZXR0ZXIsCiAgICAgICAgIEhhc0luZGV4R2V0dGVyLAor ICAgICAgICBDdXN0b21HZXRQcm9wZXJ0eU5hbWVzLAogICAgICAgICBWOERlcGVuZGVudExpZmV0 aW1lCiAgICAgXSBDU1NTdHlsZURlY2xhcmF0aW9uIHsKICAgICAgICAgICAgICAgICAgYXR0cmli dXRlIFtDb252ZXJ0TnVsbFN0cmluZ1RvPU51bGwsIENvbnZlcnROdWxsVG9OdWxsU3RyaW5nXSBE T01TdHJpbmcgICAgICAgIGNzc1RleHQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9t YWtlcHJvcC5wbCBiL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbAppbmRleCA0NWFmNzEz M2U2OWEwY2Y0YjE1ZWRiYWI3ZDUyZDY3NzA2NTI0Y2ZmLi40MDE5ZGJjMGViZDFhZGZhMTg4YzMx YjljMzM2OGFjNzQyNTcwZGEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9jc3MvbWFrZXBy b3AucGwKKysrIGIvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsCkBAIC0xNTcsNiArMTU3 LDE0IEBAIGZvcmVhY2ggbXkgJG5hbWUgKEBuYW1lcykgewogfQogcHJpbnQgSEVBREVSICJ9O1xu IjsKIAorcHJpbnQgSEVBREVSICJjb25zdCBjaGFyKiBjb25zdCBqc1Byb3BlcnR5TmFtZVN0cmlu Z3NbJG51bV0gPSB7XG4iOworZm9yZWFjaCBteSAkbmFtZSAoQG5hbWVzKSB7CisgICRuYW1lID1+ IHMvKFxTKS0oLikvJDFAe1t1YygkMildfS9nOworICAkbmFtZSA9fiBzL14tLy87CisgIHByaW50 IEhFQURFUiAiXCIkbmFtZVwiLFxuIjsKK30KK3ByaW50IEhFQURFUiAifTtcbiI7CisKIHByaW50 IEhFQURFUiA8PCAiRU9GIjsKIAogY29uc3QgY2hhciogZ2V0UHJvcGVydHlOYW1lKENTU1Byb3Bl cnR5SUQpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCmluZGV4IDRmMTMzZWFkZGJlMzc1NWU4YTVlMzU1YzEzNGRkN2FiNTU0YTVlMWMu LjBjOTU0OTkwNmJiZDNkMTdhODMyOTc0MGI1YjFjODkwNjZjMGQwZGIgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNSBAQAorMjAxMS0xMS0yNSAgQWxleGFuZGVyIFBhdmxvdiAgPGFwYXZsb3ZAY2hyb21pdW0u b3JnPgorCisgICAgICAgIFdlYmtpdCBkb2VzIG5vdCBlbnVtZXJhdGUgb3ZlciBDU1MgcHJvcGVy dGllcyBpbiBIVE1MRWxlbWVudC5zdHlsZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIGZhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXBy b3BlcnRpZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0 aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlz dEVudW1lcmF0aW9uLmpzOgorCiAyMDExLTExLTI5ICBQaGlsaXBwZSBOb3JtYW5kICA8cG5vcm1h bmRAaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCB1bnNraXAgZml4ZWQgZmxha3kg dGVzdCBhZnRlciByMTAxMzI2LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5 bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9j c3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjI2 Mzk3MGE4OWEwNDljODM5ZTZhZTQwMDE3ODliY2M4NTQ3ZTcxODMKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwzIEBACitUZXN0IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjM5NDYgV2Via2l0IGRvZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBw cm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxlIC0gY2hlY2tzIHRoYXQgdGhlIHN0eWxlIGNv bnRhaW5zIGV4YWN0bHkgb25lIG51bWVyaWMgcHJvcGVydHkgIjAiIChmb3IgInRleHQtZGVjb3Jh dGlvbiIpIGFuZCBuYW1lZCBwcm9wZXJ0aWVzICJ0ZXh0RGVjb3JhdGlvbiIsICJib3JkZXIiLCAi Zm9udCIsIGFuZCAiY3NzVGV4dCIuCisKK1BBU1NFRApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjJhZDQw NzQ4ZDg5OTAwMGIyZWZlZWUxMjRiN2VmMWJjZjNmYjg2YgotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0bWwKQEAgLTAs MCArMSwzNyBAQAorPGhlYWQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKKworZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgICAgICAgIHZhciBzdHlsZSA9IGRv Y3VtZW50LmJvZHkuc3R5bGU7CisgICAgICAgIHZhciBjb25zb2xlID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImNvbnNvbGUiKTsKKyAgICAgICAgaWYgKHN0eWxlLmxlbmd0aCAhPT0gMSkgewor ICAgICAgICAgICAgY29uc29sZS50ZXh0Q29udGVudCA9ICJMZW5ndGg6IGV4cGVjdGVkIDEsIGZv dW5kICIgKyBzdHlsZS5sZW5ndGg7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAg ICAgICAgdmFyIGV4cGVjdGVkUHJvcGVydGllcyA9IHsKKyAgICAgICAgICAgICIwIjogdHJ1ZSwK KyAgICAgICAgICAgICJ0ZXh0RGVjb3JhdGlvbiI6IHRydWUsCisgICAgICAgICAgICAiYm9yZGVy IjogdHJ1ZSwKKyAgICAgICAgICAgICJmb250IjogdHJ1ZSwKKyAgICAgICAgICAgICJjc3NUZXh0 IjogdHJ1ZQorICAgICAgICB9OworICAgICAgICBmb3IgKHAgaW4gZXhwZWN0ZWRQcm9wZXJ0aWVz KSB7CisgICAgICAgICAgaWYgKCEocCBpbiBzdHlsZSkpIHsKKyAgICAgICAgICAgICAgICBjb25z b2xlLnRleHRDb250ZW50ID0gIlByb3BlcnR5ICciICsgcCArICInIG5vdCBmb3VuZCEiOworICAg ICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBj b25zb2xlLnRleHRDb250ZW50ID0gIlBBU1NFRCI7Cit9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+ Cis8Ym9keSBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOiB1bmRlcmxpbmUiIG9ubG9hZD0icnVuVGVz dCgpIj4KKyAgICA8cD4KKyAgICAgICAgVGVzdCBmb3IgPGk+PGEgaHJlZj0iaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzOTQ2Ij5odHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDY8L2E+CisgICAgICAgIFdlYmtpdCBkb2VzIG5vdCBlbnVt ZXJhdGUgb3ZlciBDU1MgcHJvcGVydGllcyBpbiBIVE1MRWxlbWVudC5zdHlsZTwvaT4gLSBjaGVj a3MgdGhhdCB0aGUgc3R5bGUgY29udGFpbnMgZXhhY3RseSBvbmUgbnVtZXJpYyBwcm9wZXJ0eSAi MCIgKGZvciAidGV4dC1kZWNvcmF0aW9uIikgYW5kIG5hbWVkIHByb3BlcnRpZXMgInRleHREZWNv cmF0aW9uIiwgImJvcmRlciIsICJmb250IiwgYW5kICJjc3NUZXh0Ii4KKyAgICA8L3A+CisgICAg PGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8L2JvZHk+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA3MjJiYTA3OTcx OWE0NmNmYjUwNDQ5MmE3NjVhZTMxMGExNmJmOGE1Li40NTViNWI5YTU0OTY5MDIzNDk5YWY5YTEw NzIyZGVlMGY1MmI5ZjFlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21MaXN0 RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxp c3RFbnVtZXJhdGlvbi1leHBlY3RlZC50eHQKQEAgLTY2LDcgKzY2LDcgQEAgUEFTUyByZXN1bHRB cnJheVsyXS5pIGlzICcyJwogUEFTUyByZXN1bHRBcnJheVsyXS5pdGVtIGlzIGNzc1J1bGVMaXN0 Lml0ZW0oMikKIAogW29iamVjdCBDU1NTdHlsZURlY2xhcmF0aW9uXQotUEFTUyByZXN1bHRBcnJh eS5sZW5ndGggaXMgMTQKK1BBU1MgcmVzdWx0QXJyYXkubGVuZ3RoIGlzID49IDM3NgogUEFTUyBy ZXN1bHRBcnJheVswXS5pIGlzICcwJwogUEFTUyByZXN1bHRBcnJheVswXS5pdGVtIGlzIGNzc1N0 eWxlRGVjbGFyYXRpb24uaXRlbSgwKQogUEFTUyByZXN1bHRBcnJheVsxXS5pIGlzICcxJwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJh dGlvbi5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51bWVy YXRpb24uanMKaW5kZXggYTA5OWM4MzU2M2Y4M2UwMGQ1MzQ2ZmM4YzM3NmI4Y2JkZmM1Y2M5Ni4u ZmIxMGVmNDNkYjUxMjQ3ODYyNzhlMjJlNGUxZTk0MGMxYWMyNmY2NSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcworKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpz CkBAIC0xNzMsNyArMTczLDggQEAgc2hvdWxkQmUoInJlc3VsdEFycmF5WzJdLml0ZW0iLCAiY3Nz UnVsZUxpc3QuaXRlbSgyKSIpOwogLy9kZWJ1Zyhlc2NhcGVIVE1MKGRvY3VtZW50LmdldEVsZW1l bnRzQnlUYWdOYW1lKCdzdHlsZScpKSk7CiB2YXIgY3NzU3R5bGVEZWNsYXJhdGlvbiA9IGRvY3Vt ZW50LnN0eWxlU2hlZXRzWzJdLmNzc1J1bGVzWzBdLnN0eWxlOwogcmVzdWx0QXJyYXkgPSBpdGVy YXRlTGlzdChjc3NTdHlsZURlY2xhcmF0aW9uKTsKLXNob3VsZEJlKCJyZXN1bHRBcnJheS5sZW5n dGgiLCAiMTQiKTsKKy8vIE1vcmUgcHJvcGVydGllcyBjYW4gYmUgYWRkZWQgc29vbi4gUGx1cywg Q2hyb21pdW0gaGlkZXMgdGhlICJmaWx0ZXIiIHByb3BlcnR5Lgorc2hvdWxkQmVHcmVhdGVyVGhh bk9yRXF1YWwoInJlc3VsdEFycmF5Lmxlbmd0aCIsICIzNzYiKTsKIHNob3VsZEJlKCJyZXN1bHRB cnJheVswXS5pIiwgIicwJyIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzBdLml0ZW0iLCAiY3Nz U3R5bGVEZWNsYXJhdGlvbi5pdGVtKDApIik7CiBzaG91bGRCZSgicmVzdWx0QXJyYXlbMV0uaSIs ICInMSciKTsK 117178 2011-11-30 05:53:23 -0800 2011-11-30 23:50:47 -0800 Patch bug-23946-20111130175320.patch text/plain 13509 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxNDU5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggY2JkMjgwZjgwMjI2MjM2 ZTNhOTkwYjdkNDdjZmE0ZDMyMjAzYmRhMy4uYzlkMzMzYjBlOTY5M2IxZGUwYWE4ZDZkZGI2ZThm ZWRlYTMzODE1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2Via2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBHZW5lcmF0ZSBh IGxpc3Qgb2YgSlMtc3R5bGUgQ1NTIHByb3BlcnR5IG5hbWVzLgorCiAyMDExLTExLTMwICBBbGV4 YW5kcnUgQ2hpY3VsaXRhICA8YWNoaWN1QGFkb2JlLmNvbT4KIAogICAgICAgICBGaWx0ZXJPcGVy YXRpb24qIHNob3VsZCBzdGF5IGluIHJlbmRlcmluZy9zdHlsZSwgYmVjYXVzZSBpdCBpcyBkaXJl Y3RseSByZWZlcmVuY2VkIGZyb20gUmVuZGVyU3R5bGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTQ1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCmluZGV4 IDg2ZGM2NGZlNmNmMTFiYWIzZDhiYjU5OGU1OWZlMWMxZWYxMmE5OWIuLjNmMzI5NDM5YmFiNTUz MGY0OTZlMzU3YmRlMDA2ZDcyMzMyMmU4OTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTQ1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcApAQCAtMjgs NiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQ1NTTXV0YWJsZVN0eWxlRGVjbGFyYXRpb24uaCIKICNp bmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIkNTU1Byb3BlcnR5TmFtZXMu aCIKICNpbmNsdWRlICJDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkpTQ1NTVmFsdWUuaCIKICNpbmNs dWRlICJKU05vZGUuaCIKQEAgLTEzOSw4ICsxNDAsNiBAQCBib29sIEpTQ1NTU3R5bGVEZWNsYXJh dGlvbjo6Y2FuR2V0SXRlbXNGb3JOYW1lKEV4ZWNTdGF0ZSosIENTU1N0eWxlRGVjbGFyYXRpb24q LAogICAgIHJldHVybiBpc0NTU1Byb3BlcnR5TmFtZShwcm9wZXJ0eU5hbWUpOwogfQogCi0vLyBG SVhNRTogWW91IGNhbiBnZXQgdGhlc2UgcHJvcGVydGllcywgYW5kIHNldCB0aGVtIChzZWUgcHV0 RGVsZWdhdGUgYmVsb3cpLAotLy8gYnV0IHlvdSBzaG91bGQgYWxzbyBiZSBhYmxlIHRvIGVudW1l cmF0ZSB0aGVtLgogSlNWYWx1ZSBKU0NTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVHZXR0ZXIoRXhl Y1N0YXRlKiBleGVjLCBKU1ZhbHVlIHNsb3RCYXNlLCBjb25zdCBJZGVudGlmaWVyJiBwcm9wZXJ0 eU5hbWUpCiB7CiAgICAgSlNDU1NTdHlsZURlY2xhcmF0aW9uKiB0aGlzT2JqID0gc3RhdGljX2Nh c3Q8SlNDU1NTdHlsZURlY2xhcmF0aW9uKj4oYXNPYmplY3Qoc2xvdEJhc2UpKTsKQEAgLTE5NSw0 ICsxOTQsMjYgQEAgSlNWYWx1ZSBKU0NTU1N0eWxlRGVjbGFyYXRpb246OmdldFByb3BlcnR5Q1NT VmFsdWUoRXhlY1N0YXRlKiBleGVjKQogICAgIHJldHVybiB0b0pTKGV4ZWMsIGdsb2JhbE9iamVj dCgpLCBXVEY6OmdldFB0cihjc3NWYWx1ZSkpOwogfQogCit2b2lkIEpTQ1NTU3R5bGVEZWNsYXJh dGlvbjo6Z2V0T3duUHJvcGVydHlOYW1lcyhKU09iamVjdCogb2JqZWN0LCBFeGVjU3RhdGUqIGV4 ZWMsIFByb3BlcnR5TmFtZUFycmF5JiBwcm9wZXJ0eU5hbWVzLCBFbnVtZXJhdGlvbk1vZGUgbW9k ZSkKK3sKKyAgICBKU0NTU1N0eWxlRGVjbGFyYXRpb24qIHRoaXNPYmplY3QgPSBqc0Nhc3Q8SlND U1NTdHlsZURlY2xhcmF0aW9uKj4ob2JqZWN0KTsKKyAgICBBU1NFUlRfR0NfT0JKRUNUX0lOSEVS SVRTKHRoaXNPYmplY3QsICZzX2luZm8pOworCisgICAgdW5zaWduZWQgbGVuZ3RoID0gdGhpc09i amVjdC0+aW1wbCgpLT5sZW5ndGgoKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGVu Z3RoOyArK2kpCisgICAgICAgIHByb3BlcnR5TmFtZXMuYWRkKElkZW50aWZpZXI6OmZyb20oZXhl YywgaSkpOworCisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChWZWN0b3I8VVN0cmluZz4sIGpzUHJv cGVydHlOYW1lcywgKCkpOworICAgIGlmIChqc1Byb3BlcnR5TmFtZXMuaXNFbXB0eSgpKSB7Cisg ICAgICAgIGpzUHJvcGVydHlOYW1lcy5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KG51bUNTU1Byb3Bl cnRpZXMpOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IG51bUNTU1Byb3BlcnRpZXM7ICsr aSkKKyAgICAgICAgICAgIGpzUHJvcGVydHlOYW1lcy5hcHBlbmQoVVN0cmluZyhqc1Byb3BlcnR5 TmFtZVN0cmluZ3NbaV0pKTsKKyAgICB9CisKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IG51bUNT U1Byb3BlcnRpZXM7ICsraSkKKyAgICAgICAgcHJvcGVydHlOYW1lcy5hZGQoSWRlbnRpZmllcihl eGVjLCBqc1Byb3BlcnR5TmFtZXMuYXQoaSkpKTsKKworICAgIEJhc2U6OmdldE93blByb3BlcnR5 TmFtZXModGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lcywgbW9kZSk7Cit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4 L2N1c3RvbS9WOENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXgg YWQ2ZDI5MDcyZWNkNTlhYWQwYzg4ODU4NWEzM2M2NjkyZjg2MGViOC4uYzIzYzgwNmIxNTU0NjYx ODI2ZThiNGU4NzUwY2YzZmQxYWNmNmM2MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3Rv bS5jcHAKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJWOENTU1N0eWxlRGVjbGFyYXRpb24u aCIKIAogI2luY2x1ZGUgIkNTU1BhcnNlci5oIgorI2luY2x1ZGUgIkNTU1Byb3BlcnR5TmFtZXMu aCIKICNpbmNsdWRlICJDU1NTdHlsZURlY2xhcmF0aW9uLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWUu aCIKICNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgpAQCAtMTUyLDYgKzE1MywzOSBAQCBz dGF0aWMgQ1NTUHJvcGVydHlJbmZvKiBjc3NQcm9wZXJ0eUluZm8odjg6OkhhbmRsZTx2ODo6U3Ry aW5nPnY4UHJvcGVydHlOYW1lKQogICAgIHJldHVybiBwcm9wSW5mbzsKIH0KIAordjg6OkhhbmRs ZTx2ODo6QXJyYXk+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUVudW1lcmF0 b3IoY29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sKKyAgICAvLyBXZSBrbm93IHRoYXQg ImZpbHRlciIgaXMgcHJlc2VudCBpbiB0aGUgbGlzdCBidXQgc2hvdWxkIG5vdCBiZSBwcm92aWRl ZCBpbiB0aGUgZW51bWVyYXRpb24uCisgICAgLy8gU2VlIGEgY29tbWVudCBpbiB0aGUgVjhDU1NT dHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKCkgaW1wbGVtZW50YXRpb24uCisg ICAgLy8gRklYTUU6IHRoaXMgc2hvdWxkIGJlIHJlbW92ZWQgKHNlZSBidWcgNzM0MjYpLgorICAg IGNvbnN0IGludCBlZmZlY3RpdmVOdW1DU1NQcm9wZXJ0aWVzID0gbnVtQ1NTUHJvcGVydGllcyAt IDE7CisgICAgdjg6OkhhbmRsZTx2ODo6QXJyYXk+IHByb3BlcnRpZXMgPSB2ODo6QXJyYXk6Ok5l dyhlZmZlY3RpdmVOdW1DU1NQcm9wZXJ0aWVzKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFN0 cmluZywgZmlsdGVyU3RyaW5nLCAoImZpbHRlciIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FM KFZlY3RvcjxTdHJpbmc+LCBwcm9wZXJ0eU5hbWVzLCAoKSk7CisKKyAgICBpZiAocHJvcGVydHlO YW1lcy5pc0VtcHR5KCkpIHsKKyAgICAgICAgcHJvcGVydHlOYW1lcy5yZXNlcnZlSW5pdGlhbENh cGFjaXR5KGVmZmVjdGl2ZU51bUNTU1Byb3BlcnRpZXMpOworICAgICAgICBmb3IgKGludCBpID0g MDsgaSA8IGVmZmVjdGl2ZU51bUNTU1Byb3BlcnRpZXMgOyArK2kpCisgICAgICAgICAgICBwcm9w ZXJ0eU5hbWVzLmFwcGVuZChqc1Byb3BlcnR5TmFtZVN0cmluZ3NbaV0pOworICAgIH0KKworICAg IGZvciAoaW50IGkgPSAwOyBpIDwgZWZmZWN0aXZlTnVtQ1NTUHJvcGVydGllczsgKytpKSB7Cisg ICAgICAgIFN0cmluZyBrZXkgPSBwcm9wZXJ0eU5hbWVzLmF0KGkpOworICAgICAgICBBU1NFUlQo IWtleS5pc051bGwoKSk7CisKKyAgICAgICAgaWYgKGtleSAhPSBmaWx0ZXJTdHJpbmcpCisgICAg ICAgICAgICBwcm9wZXJ0aWVzLT5TZXQodjg6OkludGVnZXI6Ok5ldyhpKSwgdjhTdHJpbmcoa2V5 KSk7CisgICAgfQorCisgICAgcmV0dXJuIHByb3BlcnRpZXM7Cit9CisKK3Y4OjpIYW5kbGU8djg6 OkludGVnZXI+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eVF1ZXJ5KHY4OjpM b2NhbDx2ODo6U3RyaW5nPiB2OE5hbWUsIGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGluZm8pCit7 CisgICAgSU5DX1NUQVRTKCJET00uQ1NTU3R5bGVEZWNsYXJhdGlvbi5OYW1lZFByb3BlcnR5UXVl cnkiKTsKKyAgICByZXR1cm4gdjg6OkludGVnZXI6Ok5ldyh2ODo6Tm9uZSk7Cit9CisKIHY4OjpI YW5kbGU8djg6OlZhbHVlPiBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlHZXR0 ZXIodjg6OkxvY2FsPHY4OjpTdHJpbmc+IG5hbWUsIGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGlu Zm8pCiB7CiAgICAgSU5DX1NUQVRTKCJET00uQ1NTU3R5bGVEZWNsYXJhdGlvbi5OYW1lZFByb3Bl cnR5R2V0dGVyIik7CkBAIC0xNjAsMTQgKzE5NCwxMyBAQCB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4g VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKHY4OjpMb2NhbDx2ODo6 UwogICAgICAgICByZXR1cm4gbm90SGFuZGxlZEJ5SW50ZXJjZXB0b3IoKTsKIAogICAgIC8vIFNl YXJjaCB0aGUgc3R5bGUgZGVjbGFyYXRpb24uCi0gICAgQ1NTU3R5bGVEZWNsYXJhdGlvbiogaW1w ID0gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjp0b05hdGl2ZShpbmZvLkhvbGRlcigpKTsKICAgICBD U1NQcm9wZXJ0eUluZm8qIHByb3BJbmZvID0gY3NzUHJvcGVydHlJbmZvKG5hbWUpOwogCiAgICAg Ly8gRG8gbm90IGhhbmRsZSBub24tcHJvcGVydHkgbmFtZXMuCiAgICAgaWYgKCFwcm9wSW5mbykK ICAgICAgICAgcmV0dXJuIG5vdEhhbmRsZWRCeUludGVyY2VwdG9yKCk7CiAKLQorICAgIENTU1N0 eWxlRGVjbGFyYXRpb24qIGltcCA9IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6dG9OYXRpdmUoaW5m by5Ib2xkZXIoKSk7CiAgICAgUmVmUHRyPENTU1ZhbHVlPiBjc3NWYWx1ZSA9IGltcC0+Z2V0UHJv cGVydHlDU1NWYWx1ZShwcm9wSW5mby0+cHJvcElEKTsKICAgICBpZiAoY3NzVmFsdWUpIHsKICAg ICAgICAgaWYgKHByb3BJbmZvLT5oYWRQaXhlbE9yUG9zUHJlZml4ICYmCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwgYi9Tb3VyY2UvV2ViQ29y ZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwKaW5kZXggMmZhNjA5YjEwMWM0ZjM1NTY0NTA3 NmJiYmI0NzZkNWQ2OTMzNWI0OC4uZDFiNDcwZjg3NDhjZjI5OWFmYzUxYWY0YTYzM2I0MzQ2Yjcy ZjQ5ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlRGVjbGFyYXRpb24u aWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbApAQCAt MjcsNiArMjcsNyBAQCBtb2R1bGUgY3NzIHsKICAgICAgICAgRGVsZWdhdGluZ1B1dEZ1bmN0aW9u LAogICAgICAgICBIYXNOYW1lR2V0dGVyLAogICAgICAgICBIYXNJbmRleEdldHRlciwKKyAgICAg ICAgQ3VzdG9tR2V0UHJvcGVydHlOYW1lcywKICAgICAgICAgVjhEZXBlbmRlbnRMaWZldGltZQog ICAgIF0gQ1NTU3R5bGVEZWNsYXJhdGlvbiB7CiAgICAgICAgICAgICAgICAgIGF0dHJpYnV0ZSBb Q29udmVydE51bGxTdHJpbmdUbz1OdWxsLCBDb252ZXJ0TnVsbFRvTnVsbFN0cmluZ10gRE9NU3Ry aW5nICAgICAgICBjc3NUZXh0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9jc3MvbWFrZXBy b3AucGwgYi9Tb3VyY2UvV2ViQ29yZS9jc3MvbWFrZXByb3AucGwKaW5kZXggNDVhZjcxMzNlNjlh MGNmNGIxNWVkYmFiN2Q1MmQ2NzcwNjUyNGNmZi4uZjJkYjhjMzQ4Yjc1Njc4MjM4ZDU3ZDJjMmY4 ODAwNDhmYjE2M2E5MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBs CisrKyBiL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbApAQCAtMTU1LDYgKzE1NSwyMSBA QCBwcmludCBIRUFERVIgImNvbnN0IGNoYXIqIGNvbnN0IHByb3BlcnR5TmFtZVN0cmluZ3NbJG51 bV0gPSB7XG4iOwogZm9yZWFjaCBteSAkbmFtZSAoQG5hbWVzKSB7CiAgIHByaW50IEhFQURFUiAi XCIkbmFtZVwiLFxuIjsKIH0KK3ByaW50IEhFQURFUiAifTtcblxuIjsKKworbXkgQGpzTmFtZXMg PSAoKTsKK2ZvcmVhY2ggbXkgJG5hbWUgKEBuYW1lcykgeworICAkbmFtZSA9fiBzLyguKS0oLikv JDFAe1t1YygkMildfS9nOworICAkbmFtZSA9fiBzL14tLy87CisgIHB1c2goQGpzTmFtZXMsICRu YW1lKTsKK30KKworQGpzTmFtZXMgPSBzb3J0KEBqc05hbWVzKTsKKworcHJpbnQgSEVBREVSICJj b25zdCBjaGFyKiBjb25zdCBqc1Byb3BlcnR5TmFtZVN0cmluZ3NbJG51bV0gPSB7XG4iOworZm9y ZWFjaCBteSAkanNOYW1lIChAanNOYW1lcykgeworICBwcmludCBIRUFERVIgIlwiJGpzTmFtZVwi LFxuIjsKK30KIHByaW50IEhFQURFUiAifTtcbiI7CiAKIHByaW50IEhFQURFUiA8PCAiRU9GIjsK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiYzlhZDQwZmYwNmFkOTcyYTdjMmU3Yzg0OTJjY2Q0NDY4NWY0YTlkLi42MTA3ODMw ZWNlOGZkODBlMDAwYmNiZjBjOGQxY2M2M2Y0NzA5MDRkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMTEtMjUgIEFsZXhhbmRlciBQYXZsb3YgIDxhcGF2bG92QGNocm9taXVtLm9yZz4KKwor ICAgICAgICBXZWJraXQgZG9lcyBub3QgZW51bWVyYXRlIG92ZXIgQ1NTIHByb3BlcnRpZXMgaW4g SFRNTEVsZW1lbnQuc3R5bGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIzOTQ2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3RlZC50 eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVz Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL2RvbUxpc3RFbnVtZXJhdGlvbi1leHBl Y3RlZC50eHQ6CisgICAgICAgICogZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJh dGlvbi5qczoKKwogMjAxMS0xMS0zMCAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxp YS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgc2tpcCB0ZXN0cyBvbiBHVEsgcHJlc2VudGlu ZyAxcHggZGlmZmVyZW5jZXMgc2luY2UgcjEwMTM0Mi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4zMWY4OTg5Y2JkYTA4ZDdjODcyZTc2MDM4ZjdmYTNkMDlhOTE2ZjljCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3Bl cnRpZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdCBtYWtlcyBzdXJl IHRoYXQgQ1NTU3R5bGVEZWNsYXJhdGlvbiBlbnVtZXJhdGVzIEphdmFTY3JpcHQgcHJvcGVydGll cyBmb3IgZGVmaW5lZCBhbmQgbm9uLWRlZmluZWQgQ1NTIHByb3BlcnRpZXMsIGluZGV4ZWQgcHJv cGVydGllcywgYW5kIHByb3BlcnRpZXMgZGVmaW5lZCBvbiB0aGUgcHJvdG90eXBlLiBTZWUgQnVn IDIzOTQ2LgorUEFTUyBkb2N1bWVudC5ib2R5LnN0eWxlLmxlbmd0aCBpcyAyCitQQVNTICcwJyBp biBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJzEnIGluIGRvY3VtZW50LmJvZHku c3R5bGUgaXMgdHJ1ZQorUEFTUyAndGV4dERlY29yYXRpb24nIGluIGRvY3VtZW50LmJvZHkuc3R5 bGUgaXMgdHJ1ZQorUEFTUyAnYm9yZGVyVG9wQ29sb3InIGluIGRvY3VtZW50LmJvZHkuc3R5bGUg aXMgdHJ1ZQorUEFTUyAnYm9yZGVyJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BB U1MgJ2ZvbnQnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAnY3NzVGV4dCcg aW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICdnZXRQcm9wZXJ0eUNTU1ZhbHVl JyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgVGhlIENTUyBwcm9wZXJ0eSBv cmRlciBpcyBjb3JyZWN0CitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1Qg Q09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVy YXRlLXByb3BlcnRpZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0 ZS1wcm9wZXJ0aWVzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uN2U4MjhiOWYyY2I0ZmJjY2NhZDdmZDljNzhm MGE3MjZjZDUyNjM2YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0 eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0bWwKQEAgLTAsMCArMSw0NiBAQAorPGhlYWQ+Cisg ICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ CisgICAgPHNjcmlwdD4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworCisgICAg PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOiB1bmRlcmxp bmU7IGJvcmRlci10b3AtY29sb3I6IGdyZWVuIj4KKyAgICA8ZGl2IGlkPSJkZXNjcmlwdGlvbiI+ VGhpcyB0ZXN0IG1ha2VzIHN1cmUgdGhhdCBDU1NTdHlsZURlY2xhcmF0aW9uIGVudW1lcmF0ZXMg SmF2YVNjcmlwdCBwcm9wZXJ0aWVzIGZvciBkZWZpbmVkIGFuZCBub24tZGVmaW5lZCBDU1MgcHJv cGVydGllcywgaW5kZXhlZCBwcm9wZXJ0aWVzLCBhbmQgcHJvcGVydGllcyBkZWZpbmVkIG9uIHRo ZSBwcm90b3R5cGUuIFNlZSA8YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjM5NDYiPkJ1ZyAyMzk0NjwvYT4uPC9kaXY+CisgICAgPGRpdiBpZD0iY29uc29s ZSI+PC9kaXY+CisgICAgPHNjcmlwdD4KKyAgICAgICAgc2hvdWxkQmUoImRvY3VtZW50LmJvZHku c3R5bGUubGVuZ3RoIiwgIjIiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInMCcgaW4gZG9jdW1l bnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIicxJyBpbiBkb2N1bWVudC5i b2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ3RleHREZWNvcmF0aW9uJyBpbiBk b2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2JvcmRlclRvcENv bG9yJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2Jv cmRlcicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIidm b250JyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2Nz c1RleHQnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCIn Z2V0UHJvcGVydHlDU1NWYWx1ZScgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworCisgICAgICAg IC8vIFRlc3QgQ1NTIHByb3BlcnR5IG9yZGVyLgorICAgICAgICB2YXIgc3RhcnRlZDsKKyAgICAg ICAgdmFyIGNzc1Byb3BlcnR5Q291bnQgPSAwOworICAgICAgICB2YXIgcHJldmlvdXM7CisgICAg ICAgIGZvciAodmFyIHAgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSkgeworICAgICAgICAgICAgaWYg KHAgPT09ICJhbGlnbm1lbnRCYXNlbGluZSIpCisgICAgICAgICAgICAgICAgc3RhcnRlZCA9IHRy dWU7CisgICAgICAgICAgICBpZiAoIXN0YXJ0ZWQpCisgICAgICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgICAgICBpZiAocHJldmlvdXMgJiYgcHJldmlvdXMgPj0gcCkgeworICAgICAgICAg ICAgICAgIHRlc3RGYWlsZWQoIkludmFsaWQgQ1NTLW1hcHBlZCBwcm9wZXJ0eSBvcmRlcjogJyIg KyBwICsgIicgYWZ0ZXIgJyIgKyBwcmV2aW91cyArICInIik7CisgICAgICAgICAgICAgICAgYnJl YWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBpZiAoKytjc3NQcm9wZXJ0eUNvdW50IDw9 IDEwMCkKKyAgICAgICAgICAgICAgICBwcmV2aW91cyA9IHA7CisgICAgICAgICAgICBlbHNlIHsK KyAgICAgICAgICAgICAgICB0ZXN0UGFzc2VkKCJUaGUgQ1NTIHByb3BlcnR5IG9yZGVyIGlzIGNv cnJlY3QiKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgIDwvc2NyaXB0PgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL2RvbUxpc3RFbnVtZXJhdGlvbi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0CmluZGV4IDcyMmJhMDc5NzE5YTQ2 Y2ZiNTA0NDkyYTc2NWFlMzEwYTE2YmY4YTUuLjljYTk3ZWM1NzU5MTA1NDA4MTQ1ZjNkYzg5MmFh YjA5MzBkM2M3OTggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxpc3RFbnVt ZXJhdGlvbi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vZG9tTGlzdEVu dW1lcmF0aW9uLWV4cGVjdGVkLnR4dApAQCAtNjYsNyArNjYsNiBAQCBQQVNTIHJlc3VsdEFycmF5 WzJdLmkgaXMgJzInCiBQQVNTIHJlc3VsdEFycmF5WzJdLml0ZW0gaXMgY3NzUnVsZUxpc3QuaXRl bSgyKQogCiBbb2JqZWN0IENTU1N0eWxlRGVjbGFyYXRpb25dCi1QQVNTIHJlc3VsdEFycmF5Lmxl bmd0aCBpcyAxNAogUEFTUyByZXN1bHRBcnJheVswXS5pIGlzICcwJwogUEFTUyByZXN1bHRBcnJh eVswXS5pdGVtIGlzIGNzc1N0eWxlRGVjbGFyYXRpb24uaXRlbSgwKQogUEFTUyByZXN1bHRBcnJh eVsxXS5pIGlzICcxJwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRl c3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10 ZXN0cy9kb21MaXN0RW51bWVyYXRpb24uanMKaW5kZXggYTA5OWM4MzU2M2Y4M2UwMGQ1MzQ2ZmM4 YzM3NmI4Y2JkZmM1Y2M5Ni4uN2E5ODc1NTE3YWYyMjk5ZGExODE3M2MzZGU1YzFiYjg4MDFhNjEx ZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RF bnVtZXJhdGlvbi5qcworKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9t TGlzdEVudW1lcmF0aW9uLmpzCkBAIC0xNzMsNyArMTczLDYgQEAgc2hvdWxkQmUoInJlc3VsdEFy cmF5WzJdLml0ZW0iLCAiY3NzUnVsZUxpc3QuaXRlbSgyKSIpOwogLy9kZWJ1Zyhlc2NhcGVIVE1M KGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCdzdHlsZScpKSk7CiB2YXIgY3NzU3R5bGVE ZWNsYXJhdGlvbiA9IGRvY3VtZW50LnN0eWxlU2hlZXRzWzJdLmNzc1J1bGVzWzBdLnN0eWxlOwog cmVzdWx0QXJyYXkgPSBpdGVyYXRlTGlzdChjc3NTdHlsZURlY2xhcmF0aW9uKTsKLXNob3VsZEJl KCJyZXN1bHRBcnJheS5sZW5ndGgiLCAiMTQiKTsKIHNob3VsZEJlKCJyZXN1bHRBcnJheVswXS5p IiwgIicwJyIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzBdLml0ZW0iLCAiY3NzU3R5bGVEZWNs YXJhdGlvbi5pdGVtKDApIik7CiBzaG91bGRCZSgicmVzdWx0QXJyYXlbMV0uaSIsICInMSciKTsK 117354 2011-11-30 23:50:57 -0800 2011-12-08 06:19:59 -0800 Patch bug-23946-20111201115055.patch text/plain 13451 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxNjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjc5ZTBiNzk4NDBlMDMx ZDAzODlkMjczYTUxMjNiMzUzMjMxOTQ2OC4uY2Q3ZmVmZWQ4N2I1NzVlNjNkZGVlYzUwM2NhMGY3 YmVjM2MxMzJiZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViS2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBHZW5lcmF0ZSBh IGxpc3Qgb2YgSlMtc3R5bGUgQ1NTIHByb3BlcnR5IG5hbWVzLgorCiAyMDExLTExLTMwICBMZW8g WWFuZyAgPGxlby55YW5nQHRvcmNobW9iaWxlLmNvbS5jbj4KIAogICAgICAgICBVcHN0cmVhbSBw bGF0Zm9ybS9uZXR3b3JrL2JsYWNrYmVycnkvTmV0d29ya1N0YXRlTm90aWZpZXJCbGFja0JlcnJ5 LmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURl Y2xhcmF0aW9uQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTQ1NTU3R5 bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXggODZkYzY0ZmU2Y2YxMWJhYjNkOGJiNTk4ZTU5 ZmUxYzFlZjEyYTk5Yi4uM2YzMjk0MzliYWI1NTMwZjQ5NmUzNTdiZGUwMDZkNzIzMzIyZTg5MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0 aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxl RGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJDU1NN dXRhYmxlU3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgi CisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlLmgiCiAj aW5jbHVkZSAiSlNDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkpTTm9kZS5oIgpAQCAtMTM5LDggKzE0 MCw2IEBAIGJvb2wgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpjYW5HZXRJdGVtc0Zvck5hbWUoRXhl Y1N0YXRlKiwgQ1NTU3R5bGVEZWNsYXJhdGlvbiosCiAgICAgcmV0dXJuIGlzQ1NTUHJvcGVydHlO YW1lKHByb3BlcnR5TmFtZSk7CiB9CiAKLS8vIEZJWE1FOiBZb3UgY2FuIGdldCB0aGVzZSBwcm9w ZXJ0aWVzLCBhbmQgc2V0IHRoZW0gKHNlZSBwdXREZWxlZ2F0ZSBiZWxvdyksCi0vLyBidXQgeW91 IHNob3VsZCBhbHNvIGJlIGFibGUgdG8gZW51bWVyYXRlIHRoZW0uCiBKU1ZhbHVlIEpTQ1NTU3R5 bGVEZWNsYXJhdGlvbjo6bmFtZUdldHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgc2xvdEJh c2UsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5TmFtZSkKIHsKICAgICBKU0NTU1N0eWxlRGVj bGFyYXRpb24qIHRoaXNPYmogPSBzdGF0aWNfY2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24qPihh c09iamVjdChzbG90QmFzZSkpOwpAQCAtMTk1LDQgKzE5NCwyNiBAQCBKU1ZhbHVlIEpTQ1NTU3R5 bGVEZWNsYXJhdGlvbjo6Z2V0UHJvcGVydHlDU1NWYWx1ZShFeGVjU3RhdGUqIGV4ZWMpCiAgICAg cmV0dXJuIHRvSlMoZXhlYywgZ2xvYmFsT2JqZWN0KCksIFdURjo6Z2V0UHRyKGNzc1ZhbHVlKSk7 CiB9CiAKK3ZvaWQgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKEpT T2JqZWN0KiBvYmplY3QsIEV4ZWNTdGF0ZSogZXhlYywgUHJvcGVydHlOYW1lQXJyYXkmIHByb3Bl cnR5TmFtZXMsIEVudW1lcmF0aW9uTW9kZSBtb2RlKQoreworICAgIEpTQ1NTU3R5bGVEZWNsYXJh dGlvbiogdGhpc09iamVjdCA9IGpzQ2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24qPihvYmplY3Qp OworICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5IRVJJVFModGhpc09iamVjdCwgJnNfaW5mbyk7CisK KyAgICB1bnNpZ25lZCBsZW5ndGggPSB0aGlzT2JqZWN0LT5pbXBsKCktPmxlbmd0aCgpOworICAg IGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkKKyAgICAgICAgcHJvcGVydHlO YW1lcy5hZGQoSWRlbnRpZmllcjo6ZnJvbShleGVjLCBpKSk7CisKKyAgICBERUZJTkVfU1RBVElD X0xPQ0FMKFZlY3RvcjxVU3RyaW5nPiwganNQcm9wZXJ0eU5hbWVzLCAoKSk7CisgICAgaWYgKGpz UHJvcGVydHlOYW1lcy5pc0VtcHR5KCkpIHsKKyAgICAgICAganNQcm9wZXJ0eU5hbWVzLnJlc2Vy dmVJbml0aWFsQ2FwYWNpdHkobnVtQ1NTUHJvcGVydGllcyk7CisgICAgICAgIGZvciAoaW50IGkg PSAwOyBpIDwgbnVtQ1NTUHJvcGVydGllczsgKytpKQorICAgICAgICAgICAganNQcm9wZXJ0eU5h bWVzLmFwcGVuZChVU3RyaW5nKGpzUHJvcGVydHlOYW1lU3RyaW5nc1tpXSkpOworICAgIH0KKwor ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVydGllczsgKytpKQorICAgICAgICBw cm9wZXJ0eU5hbWVzLmFkZChJZGVudGlmaWVyKGV4ZWMsIGpzUHJvcGVydHlOYW1lcy5hdChpKSkp OworCisgICAgQmFzZTo6Z2V0T3duUHJvcGVydHlOYW1lcyh0aGlzT2JqZWN0LCBleGVjLCBwcm9w ZXJ0eU5hbWVzLCBtb2RlKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhDU1NTdHls ZURlY2xhcmF0aW9uQ3VzdG9tLmNwcAppbmRleCBhZDZkMjkwNzJlY2Q1OWFhZDBjODg4NTg1YTMz YzY2OTJmODYwZWI4Li5jMjNjODA2YjE1NTQ2NjE4MjZlOGI0ZTg3NTBjZjNmZDFhY2Y2YzYwIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhDU1NTdHlsZURl Y2xhcmF0aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0 b20vVjhDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2lu Y2x1ZGUgIlY4Q1NTU3R5bGVEZWNsYXJhdGlvbi5oIgogCiAjaW5jbHVkZSAiQ1NTUGFyc2VyLmgi CisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2luY2x1ZGUgIkNTU1N0eWxlRGVjbGFy YXRpb24uaCIKICNpbmNsdWRlICJDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZh bHVlLmgiCkBAIC0xNTIsNiArMTUzLDM5IEBAIHN0YXRpYyBDU1NQcm9wZXJ0eUluZm8qIGNzc1By b3BlcnR5SW5mbyh2ODo6SGFuZGxlPHY4OjpTdHJpbmc+djhQcm9wZXJ0eU5hbWUpCiAgICAgcmV0 dXJuIHByb3BJbmZvOwogfQogCit2ODo6SGFuZGxlPHY4OjpBcnJheT4gVjhDU1NTdHlsZURlY2xh cmF0aW9uOjpuYW1lZFByb3BlcnR5RW51bWVyYXRvcihjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBp bmZvKQoreworICAgIC8vIFdlIGtub3cgdGhhdCAiZmlsdGVyIiBpcyBwcmVzZW50IGluIHRoZSBs aXN0IGJ1dCBzaG91bGQgbm90IGJlIHByb3ZpZGVkIGluIHRoZSBlbnVtZXJhdGlvbi4KKyAgICAv LyBTZWUgYSBjb21tZW50IGluIHRoZSBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVy dHlHZXR0ZXIoKSBpbXBsZW1lbnRhdGlvbi4KKyAgICAvLyBGSVhNRTogdGhpcyBzaG91bGQgYmUg cmVtb3ZlZCAoc2VlIGJ1ZyA3MzQyNikuCisgICAgY29uc3QgaW50IGVmZmVjdGl2ZU51bUNTU1By b3BlcnRpZXMgPSBudW1DU1NQcm9wZXJ0aWVzIC0gMTsKKyAgICB2ODo6SGFuZGxlPHY4OjpBcnJh eT4gcHJvcGVydGllcyA9IHY4OjpBcnJheTo6TmV3KGVmZmVjdGl2ZU51bUNTU1Byb3BlcnRpZXMp OworICAgIERFRklORV9TVEFUSUNfTE9DQUwoU3RyaW5nLCBmaWx0ZXJTdHJpbmcsICgiZmlsdGVy IikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoVmVjdG9yPFN0cmluZz4sIHByb3BlcnR5TmFt ZXMsICgpKTsKKworICAgIGlmIChwcm9wZXJ0eU5hbWVzLmlzRW1wdHkoKSkgeworICAgICAgICBw cm9wZXJ0eU5hbWVzLnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoZWZmZWN0aXZlTnVtQ1NTUHJvcGVy dGllcyk7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZWZmZWN0aXZlTnVtQ1NTUHJvcGVy dGllcyA7ICsraSkKKyAgICAgICAgICAgIHByb3BlcnR5TmFtZXMuYXBwZW5kKGpzUHJvcGVydHlO YW1lU3RyaW5nc1tpXSk7CisgICAgfQorCisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBlZmZlY3Rp dmVOdW1DU1NQcm9wZXJ0aWVzOyArK2kpIHsKKyAgICAgICAgU3RyaW5nIGtleSA9IHByb3BlcnR5 TmFtZXMuYXQoaSk7CisgICAgICAgIEFTU0VSVCgha2V5LmlzTnVsbCgpKTsKKworICAgICAgICBp ZiAoa2V5ICE9IGZpbHRlclN0cmluZykKKyAgICAgICAgICAgIHByb3BlcnRpZXMtPlNldCh2ODo6 SW50ZWdlcjo6TmV3KGkpLCB2OFN0cmluZyhrZXkpKTsKKyAgICB9CisKKyAgICByZXR1cm4gcHJv cGVydGllczsKK30KKwordjg6OkhhbmRsZTx2ODo6SW50ZWdlcj4gVjhDU1NTdHlsZURlY2xhcmF0 aW9uOjpuYW1lZFByb3BlcnR5UXVlcnkodjg6OkxvY2FsPHY4OjpTdHJpbmc+IHY4TmFtZSwgY29u c3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sKKyAgICBJTkNfU1RBVFMoIkRPTS5DU1NTdHls ZURlY2xhcmF0aW9uLk5hbWVkUHJvcGVydHlRdWVyeSIpOworICAgIHJldHVybiB2ODo6SW50ZWdl cjo6TmV3KHY4OjpOb25lKTsKK30KKwogdjg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4Q1NTU3R5bGVE ZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUdldHRlcih2ODo6TG9jYWw8djg6OlN0cmluZz4gbmFt ZSwgY29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKIHsKICAgICBJTkNfU1RBVFMoIkRPTS5D U1NTdHlsZURlY2xhcmF0aW9uLk5hbWVkUHJvcGVydHlHZXR0ZXIiKTsKQEAgLTE2MCwxNCArMTk0 LDEzIEBAIHY4OjpIYW5kbGU8djg6OlZhbHVlPiBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVk UHJvcGVydHlHZXR0ZXIodjg6OkxvY2FsPHY4OjpTCiAgICAgICAgIHJldHVybiBub3RIYW5kbGVk QnlJbnRlcmNlcHRvcigpOwogCiAgICAgLy8gU2VhcmNoIHRoZSBzdHlsZSBkZWNsYXJhdGlvbi4K LSAgICBDU1NTdHlsZURlY2xhcmF0aW9uKiBpbXAgPSBWOENTU1N0eWxlRGVjbGFyYXRpb246OnRv TmF0aXZlKGluZm8uSG9sZGVyKCkpOwogICAgIENTU1Byb3BlcnR5SW5mbyogcHJvcEluZm8gPSBj c3NQcm9wZXJ0eUluZm8obmFtZSk7CiAKICAgICAvLyBEbyBub3QgaGFuZGxlIG5vbi1wcm9wZXJ0 eSBuYW1lcy4KICAgICBpZiAoIXByb3BJbmZvKQogICAgICAgICByZXR1cm4gbm90SGFuZGxlZEJ5 SW50ZXJjZXB0b3IoKTsKIAotCisgICAgQ1NTU3R5bGVEZWNsYXJhdGlvbiogaW1wID0gVjhDU1NT dHlsZURlY2xhcmF0aW9uOjp0b05hdGl2ZShpbmZvLkhvbGRlcigpKTsKICAgICBSZWZQdHI8Q1NT VmFsdWU+IGNzc1ZhbHVlID0gaW1wLT5nZXRQcm9wZXJ0eUNTU1ZhbHVlKHByb3BJbmZvLT5wcm9w SUQpOwogICAgIGlmIChjc3NWYWx1ZSkgewogICAgICAgICBpZiAocHJvcEluZm8tPmhhZFBpeGVs T3JQb3NQcmVmaXggJiYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURl Y2xhcmF0aW9uLmlkbCBiL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlk bAppbmRleCAyZmE2MDliMTAxYzRmMzU1NjQ1MDc2YmJiYjQ3NmQ1ZDY5MzM1YjQ4Li5kMWI0NzBm ODc0OGNmMjk5YWZjNTFhZjRhNjMzYjQzNDZiNzJmNDlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvY3Nz L0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsCkBAIC0yNyw2ICsyNyw3IEBAIG1vZHVsZSBjc3Mgewog ICAgICAgICBEZWxlZ2F0aW5nUHV0RnVuY3Rpb24sCiAgICAgICAgIEhhc05hbWVHZXR0ZXIsCiAg ICAgICAgIEhhc0luZGV4R2V0dGVyLAorICAgICAgICBDdXN0b21HZXRQcm9wZXJ0eU5hbWVzLAog ICAgICAgICBWOERlcGVuZGVudExpZmV0aW1lCiAgICAgXSBDU1NTdHlsZURlY2xhcmF0aW9uIHsK ICAgICAgICAgICAgICAgICAgYXR0cmlidXRlIFtDb252ZXJ0TnVsbFN0cmluZ1RvPU51bGwsIENv bnZlcnROdWxsVG9OdWxsU3RyaW5nXSBET01TdHJpbmcgICAgICAgIGNzc1RleHQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbCBiL1NvdXJjZS9XZWJDb3JlL2Nzcy9t YWtlcHJvcC5wbAppbmRleCA0NWFmNzEzM2U2OWEwY2Y0YjE1ZWRiYWI3ZDUyZDY3NzA2NTI0Y2Zm Li5mMmRiOGMzNDhiNzU2NzgyMzhkNTdkMmMyZjg4MDA0OGZiMTYzYTkwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9jc3MvbWFrZXByb3AucGwKKysrIGIvU291cmNlL1dlYkNvcmUvY3NzL21h a2Vwcm9wLnBsCkBAIC0xNTUsNiArMTU1LDIxIEBAIHByaW50IEhFQURFUiAiY29uc3QgY2hhciog Y29uc3QgcHJvcGVydHlOYW1lU3RyaW5nc1skbnVtXSA9IHtcbiI7CiBmb3JlYWNoIG15ICRuYW1l IChAbmFtZXMpIHsKICAgcHJpbnQgSEVBREVSICJcIiRuYW1lXCIsXG4iOwogfQorcHJpbnQgSEVB REVSICJ9O1xuXG4iOworCitteSBAanNOYW1lcyA9ICgpOworZm9yZWFjaCBteSAkbmFtZSAoQG5h bWVzKSB7CisgICRuYW1lID1+IHMvKC4pLSguKS8kMUB7W3VjKCQyKV19L2c7CisgICRuYW1lID1+ IHMvXi0vLzsKKyAgcHVzaChAanNOYW1lcywgJG5hbWUpOworfQorCitAanNOYW1lcyA9IHNvcnQo QGpzTmFtZXMpOworCitwcmludCBIRUFERVIgImNvbnN0IGNoYXIqIGNvbnN0IGpzUHJvcGVydHlO YW1lU3RyaW5nc1skbnVtXSA9IHtcbiI7Citmb3JlYWNoIG15ICRqc05hbWUgKEBqc05hbWVzKSB7 CisgIHByaW50IEhFQURFUiAiXCIkanNOYW1lXCIsXG4iOworfQogcHJpbnQgSEVBREVSICJ9O1xu IjsKIAogcHJpbnQgSEVBREVSIDw8ICJFT0YiOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDEyZDk3YWI4MjdkMWZjMzIwN2Fi ZTg2ZjlmZjA4OWYyZTViZGQxNTcuLjAxMmZjOTBlNDA4OTZmNTQ4Mjc1NTAyODcyN2EzMzk2YTJm N2M2ZDEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMS0xMS0zMCAgQWxleGFuZGVyIFBhdmxv diAgPGFwYXZsb3ZAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFdlYktpdCBkb2VzIG5vdCBlbnVt ZXJhdGUgb3ZlciBDU1MgcHJvcGVydGllcyBpbiBIVE1MRWxlbWVudC5zdHlsZQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDYKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvY3NzL3N0eWxlLWVu dW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9j c3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFz dC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L2Rv bS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpzOgorCiAyMDExLTExLTMwICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkLiBDaHJv bWl1bSByZWJhc2VsaW5lcyBmb3Igc3ZnIHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjMxZjg5ODljYmRhMDhkN2M4NzJlNzYwMzhmN2ZhM2QwOWE5MTZmOWMKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVy dGllcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNSBAQAorVGhpcyB0ZXN0IG1ha2VzIHN1cmUg dGhhdCBDU1NTdHlsZURlY2xhcmF0aW9uIGVudW1lcmF0ZXMgSmF2YVNjcmlwdCBwcm9wZXJ0aWVz IGZvciBkZWZpbmVkIGFuZCBub24tZGVmaW5lZCBDU1MgcHJvcGVydGllcywgaW5kZXhlZCBwcm9w ZXJ0aWVzLCBhbmQgcHJvcGVydGllcyBkZWZpbmVkIG9uIHRoZSBwcm90b3R5cGUuIFNlZSBCdWcg MjM5NDYuCitQQVNTIGRvY3VtZW50LmJvZHkuc3R5bGUubGVuZ3RoIGlzIDIKK1BBU1MgJzAnIGlu IGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAnMScgaW4gZG9jdW1lbnQuYm9keS5z dHlsZSBpcyB0cnVlCitQQVNTICd0ZXh0RGVjb3JhdGlvbicgaW4gZG9jdW1lbnQuYm9keS5zdHls ZSBpcyB0cnVlCitQQVNTICdib3JkZXJUb3BDb2xvcicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBp cyB0cnVlCitQQVNTICdib3JkZXInIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFT UyAnZm9udCcgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICdjc3NUZXh0JyBp biBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJ2dldFByb3BlcnR5Q1NTVmFsdWUn IGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyBUaGUgQ1NTIHByb3BlcnR5IG9y ZGVyIGlzIGNvcnJlY3QKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBD T01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJh dGUtcHJvcGVydGllcy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRl LXByb3BlcnRpZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ZTgyOGI5ZjJjYjRmYmNjY2FkN2ZkOWM3OGYw YTcyNmNkNTI2MzZhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5 bGUtZW51bWVyYXRlLXByb3BlcnRpZXMuaHRtbApAQCAtMCwwICsxLDQ2IEBACis8aGVhZD4KKyAg ICA8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4K KyAgICA8c2NyaXB0PgorICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisKKyAgICA8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246IHVuZGVybGlu ZTsgYm9yZGVyLXRvcC1jb2xvcjogZ3JlZW4iPgorICAgIDxkaXYgaWQ9ImRlc2NyaXB0aW9uIj5U aGlzIHRlc3QgbWFrZXMgc3VyZSB0aGF0IENTU1N0eWxlRGVjbGFyYXRpb24gZW51bWVyYXRlcyBK YXZhU2NyaXB0IHByb3BlcnRpZXMgZm9yIGRlZmluZWQgYW5kIG5vbi1kZWZpbmVkIENTUyBwcm9w ZXJ0aWVzLCBpbmRleGVkIHByb3BlcnRpZXMsIGFuZCBwcm9wZXJ0aWVzIGRlZmluZWQgb24gdGhl IHByb3RvdHlwZS4gU2VlIDxhIGhyZWY9Imh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMzk0NiI+QnVnIDIzOTQ2PC9hPi48L2Rpdj4KKyAgICA8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KKyAgICA8c2NyaXB0PgorICAgICAgICBzaG91bGRCZSgiZG9jdW1lbnQuYm9keS5z dHlsZS5sZW5ndGgiLCAiMiIpOworICAgICAgICBzaG91bGRCZVRydWUoIicwJyBpbiBkb2N1bWVu dC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJzEnIGluIGRvY3VtZW50LmJv ZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCIndGV4dERlY29yYXRpb24nIGluIGRv Y3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInYm9yZGVyVG9wQ29s b3InIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInYm9y ZGVyJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2Zv bnQnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInY3Nz VGV4dCcgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIidn ZXRQcm9wZXJ0eUNTU1ZhbHVlJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisKKyAgICAgICAg Ly8gVGVzdCBDU1MgcHJvcGVydHkgb3JkZXIuCisgICAgICAgIHZhciBzdGFydGVkOworICAgICAg ICB2YXIgY3NzUHJvcGVydHlDb3VudCA9IDA7CisgICAgICAgIHZhciBwcmV2aW91czsKKyAgICAg ICAgZm9yICh2YXIgcCBpbiBkb2N1bWVudC5ib2R5LnN0eWxlKSB7CisgICAgICAgICAgICBpZiAo cCA9PT0gImFsaWdubWVudEJhc2VsaW5lIikKKyAgICAgICAgICAgICAgICBzdGFydGVkID0gdHJ1 ZTsKKyAgICAgICAgICAgIGlmICghc3RhcnRlZCkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgICAgIGlmIChwcmV2aW91cyAmJiBwcmV2aW91cyA+PSBwKSB7CisgICAgICAgICAg ICAgICAgdGVzdEZhaWxlZCgiSW52YWxpZCBDU1MtbWFwcGVkIHByb3BlcnR5IG9yZGVyOiAnIiAr IHAgKyAiJyBhZnRlciAnIiArIHByZXZpb3VzICsgIiciKTsKKyAgICAgICAgICAgICAgICBicmVh azsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIGlmICgrK2Nzc1Byb3BlcnR5Q291bnQgPD0g MTAwKQorICAgICAgICAgICAgICAgIHByZXZpb3VzID0gcDsKKyAgICAgICAgICAgIGVsc2Ugewor ICAgICAgICAgICAgICAgIHRlc3RQYXNzZWQoIlRoZSBDU1MgcHJvcGVydHkgb3JkZXIgaXMgY29y cmVjdCIpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgPC9zY3JpcHQ+CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL2RvbUxpc3RFbnVtZXJhdGlvbi1leHBlY3RlZC50eHQKaW5kZXggNzIyYmEwNzk3MTlhNDZj ZmI1MDQ0OTJhNzY1YWUzMTBhMTZiZjhhNS4uOWNhOTdlYzU3NTkxMDU0MDgxNDVmM2RjODkyYWFi MDkzMGQzYzc5OCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vZG9tTGlzdEVudW1l cmF0aW9uLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21MaXN0RW51 bWVyYXRpb24tZXhwZWN0ZWQudHh0CkBAIC02Niw3ICs2Niw2IEBAIFBBU1MgcmVzdWx0QXJyYXlb Ml0uaSBpcyAnMicKIFBBU1MgcmVzdWx0QXJyYXlbMl0uaXRlbSBpcyBjc3NSdWxlTGlzdC5pdGVt KDIpCiAKIFtvYmplY3QgQ1NTU3R5bGVEZWNsYXJhdGlvbl0KLVBBU1MgcmVzdWx0QXJyYXkubGVu Z3RoIGlzIDE0CiBQQVNTIHJlc3VsdEFycmF5WzBdLmkgaXMgJzAnCiBQQVNTIHJlc3VsdEFycmF5 WzBdLml0ZW0gaXMgY3NzU3R5bGVEZWNsYXJhdGlvbi5pdGVtKDApCiBQQVNTIHJlc3VsdEFycmF5 WzFdLmkgaXMgJzEnCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVz dHMvZG9tTGlzdEVudW1lcmF0aW9uLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRl c3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcwppbmRleCBhMDk5YzgzNTYzZjgzZTAwZDUzNDZmYzhj Mzc2YjhjYmRmYzVjYzk2Li43YTk4NzU1MTdhZjIyOTlkYTE4MTczYzNkZTVjMWJiODgwMWE2MTFl IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVu dW1lcmF0aW9uLmpzCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21M aXN0RW51bWVyYXRpb24uanMKQEAgLTE3Myw3ICsxNzMsNiBAQCBzaG91bGRCZSgicmVzdWx0QXJy YXlbMl0uaXRlbSIsICJjc3NSdWxlTGlzdC5pdGVtKDIpIik7CiAvL2RlYnVnKGVzY2FwZUhUTUwo ZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoJ3N0eWxlJykpKTsKIHZhciBjc3NTdHlsZURl Y2xhcmF0aW9uID0gZG9jdW1lbnQuc3R5bGVTaGVldHNbMl0uY3NzUnVsZXNbMF0uc3R5bGU7CiBy ZXN1bHRBcnJheSA9IGl0ZXJhdGVMaXN0KGNzc1N0eWxlRGVjbGFyYXRpb24pOwotc2hvdWxkQmUo InJlc3VsdEFycmF5Lmxlbmd0aCIsICIxNCIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzBdLmki LCAiJzAnIik7CiBzaG91bGRCZSgicmVzdWx0QXJyYXlbMF0uaXRlbSIsICJjc3NTdHlsZURlY2xh cmF0aW9uLml0ZW0oMCkiKTsKIHNob3VsZEJlKCJyZXN1bHRBcnJheVsxXS5pIiwgIicxJyIpOwo= 118379 2011-12-08 06:20:09 -0800 2011-12-08 07:10:56 -0800 [PATCH] Implemented Identifier caching bug-23946-20111208182007.patch text/plain 14453 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyMzMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2ZkYTQzZWNlYWUyNmUx NjExZDQwZmVmNTEwNWUwYmU5ZmEyNWIyMC4uZWNhMDE5ODdmZjk1ODg4Mzc5OGIxZGZmZDhmYjA1 Nzk2ZDAyNjQ4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViS2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBHZW5lcmF0ZSBh IGxpc3Qgb2YgSlMtc3R5bGUgQ1NTIHByb3BlcnR5IG5hbWVzLgorCiAyMDExLTEyLTA4ICBTaGVy aWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmll d2VkLCByb2xsaW5nIG91dCByMTAyMzIxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0pTQ1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXggMjkwNGU0 YmRiMTBmZDQ5OWZjYmI2NjZhZDY2ZTI4ZDA2ZWZlYTUzMy4uZjgyMWEyNTJiMTBmZDMyOTUzZGY4 ZjVlNjI5ZGQxMzQ2NjdhYjZmOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0yOCw2ICsyOCw3 IEBACiAKICNpbmNsdWRlICJDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUg IkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2lu Y2x1ZGUgIkNTU1ZhbHVlLmgiCiAjaW5jbHVkZSAiSlNDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkpT Tm9kZS5oIgpAQCAtMTM5LDggKzE0MCw2IEBAIGJvb2wgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpj YW5HZXRJdGVtc0Zvck5hbWUoRXhlY1N0YXRlKiwgQ1NTU3R5bGVEZWNsYXJhdGlvbiosCiAgICAg cmV0dXJuIGlzQ1NTUHJvcGVydHlOYW1lKHByb3BlcnR5TmFtZSk7CiB9CiAKLS8vIEZJWE1FOiBZ b3UgY2FuIGdldCB0aGVzZSBwcm9wZXJ0aWVzLCBhbmQgc2V0IHRoZW0gKHNlZSBwdXREZWxlZ2F0 ZSBiZWxvdyksCi0vLyBidXQgeW91IHNob3VsZCBhbHNvIGJlIGFibGUgdG8gZW51bWVyYXRlIHRo ZW0uCiBKU1ZhbHVlIEpTQ1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZUdldHRlcihFeGVjU3RhdGUq IGV4ZWMsIEpTVmFsdWUgc2xvdEJhc2UsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5TmFtZSkK IHsKICAgICBKU0NTU1N0eWxlRGVjbGFyYXRpb24qIHRoaXNPYmogPSBzdGF0aWNfY2FzdDxKU0NT U1N0eWxlRGVjbGFyYXRpb24qPihhc09iamVjdChzbG90QmFzZSkpOwpAQCAtMTk1LDQgKzE5NCwy OSBAQCBKU1ZhbHVlIEpTQ1NTU3R5bGVEZWNsYXJhdGlvbjo6Z2V0UHJvcGVydHlDU1NWYWx1ZShF eGVjU3RhdGUqIGV4ZWMpCiAgICAgcmV0dXJuIHRvSlMoZXhlYywgZ2xvYmFsT2JqZWN0KCksIFdU Rjo6Z2V0UHRyKGNzc1ZhbHVlKSk7CiB9CiAKK3ZvaWQgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpn ZXRPd25Qcm9wZXJ0eU5hbWVzKEpTT2JqZWN0KiBvYmplY3QsIEV4ZWNTdGF0ZSogZXhlYywgUHJv cGVydHlOYW1lQXJyYXkmIHByb3BlcnR5TmFtZXMsIEVudW1lcmF0aW9uTW9kZSBtb2RlKQorewor ICAgIEpTQ1NTU3R5bGVEZWNsYXJhdGlvbiogdGhpc09iamVjdCA9IGpzQ2FzdDxKU0NTU1N0eWxl RGVjbGFyYXRpb24qPihvYmplY3QpOworICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5IRVJJVFModGhp c09iamVjdCwgJnNfaW5mbyk7CisKKyAgICB1bnNpZ25lZCBsZW5ndGggPSB0aGlzT2JqZWN0LT5p bXBsKCktPmxlbmd0aCgpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsr aSkKKyAgICAgICAgcHJvcGVydHlOYW1lcy5hZGQoSWRlbnRpZmllcjo6ZnJvbShleGVjLCBpKSk7 CisKKworICAgIHN0YXRpYyBJZGVudGlmaWVyKiBqc1Byb3BlcnR5TmFtZXMgPSAwOworICAgIGlm ICghanNQcm9wZXJ0eU5hbWVzKSB7CisgICAgICAgIGpzUHJvcGVydHlOYW1lcyA9IG5ldyBJZGVu dGlmaWVyW251bUNTU1Byb3BlcnRpZXNdOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IG51 bUNTU1Byb3BlcnRpZXM7ICsraSkgeworICAgICAgICAgICAgU3RyaW5nIGpzUHJvcGVydHlOYW1l ID0gZ2V0SlNQcm9wZXJ0eU5hbWUocHJvcGVydHlOYW1lU3RyaW5nc1tpXSk7CisgICAgICAgICAg ICBqc1Byb3BlcnR5TmFtZXNbaV0gPSBJZGVudGlmaWVyKCZleGVjLT5nbG9iYWxEYXRhKCksIGpz UHJvcGVydHlOYW1lLmNoYXJhY3RlcnMoKSwganNQcm9wZXJ0eU5hbWUubGVuZ3RoKCkpOworICAg ICAgICB9CisgICAgfQorCisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1DU1NQcm9wZXJ0aWVz OyArK2kpCisgICAgICAgIHByb3BlcnR5TmFtZXMuYWRkKGpzUHJvcGVydHlOYW1lc1tpXSk7CisK KyAgICBCYXNlOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKHRoaXNPYmplY3QsIGV4ZWMsIHByb3BlcnR5 TmFtZXMsIG1vZGUpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhDU1NTdHlsZURlY2xhcmF0aW9uQ3Vz dG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOENTU1N0eWxlRGVj bGFyYXRpb25DdXN0b20uY3BwCmluZGV4IDY0M2YwZmVhMDAyZDhmZmUwMDhmOTE2ODRkZjk1ZDI3 ZjdlMTJlNGIuLjRlMjJmNjllNDI1NWViYmEyNjZlMjU1NjdkMWQwODg2MzQ4NmZkYjAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOENTU1N0eWxlRGVjbGFy YXRpb25DdXN0b20uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9W OENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVk ZSAiVjhDU1NTdHlsZURlY2xhcmF0aW9uLmgiCiAKICNpbmNsdWRlICJDU1NQYXJzZXIuaCIKKyNp bmNsdWRlICJDU1NQcm9wZXJ0eU5hbWVzLmgiCiAjaW5jbHVkZSAiQ1NTU3R5bGVEZWNsYXJhdGlv bi5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlLmgiCiAjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFsdWUu aCIKQEAgLTE1Miw2ICsxNTMsNDEgQEAgc3RhdGljIENTU1Byb3BlcnR5SW5mbyogY3NzUHJvcGVy dHlJbmZvKHY4OjpIYW5kbGU8djg6OlN0cmluZz52OFByb3BlcnR5TmFtZSkKICAgICByZXR1cm4g cHJvcEluZm87CiB9CiAKK3Y4OjpIYW5kbGU8djg6OkFycmF5PiBWOENTU1N0eWxlRGVjbGFyYXRp b246Om5hbWVkUHJvcGVydHlFbnVtZXJhdG9yKGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGluZm8p Cit7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIGZpbHRlclN0cmluZywgKCJmaWx0 ZXIiKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChWZWN0b3I8U3RyaW5nPiwgcHJvcGVydHlO YW1lcywgKCkpOworICAgIHN0YXRpYyB1bnNpZ25lZCBwcm9wZXJ0eU5hbWVzTGVuZ3RoID0gMDsK KworICAgIGlmIChwcm9wZXJ0eU5hbWVzLmlzRW1wdHkoKSkgeworICAgICAgICBwcm9wZXJ0eU5h bWVzLnJlc2VydmVJbml0aWFsQ2FwYWNpdHkobnVtQ1NTUHJvcGVydGllcyAtIDEpOworICAgICAg ICBmb3IgKGludCBpID0gMDsgaSA8IG51bUNTU1Byb3BlcnRpZXM7ICsraSkgeworICAgICAgICAg ICAgU3RyaW5nIGpzUHJvcGVydHlOYW1lID0gZ2V0SlNQcm9wZXJ0eU5hbWUocHJvcGVydHlOYW1l U3RyaW5nc1tpXSk7CisgICAgICAgICAgICAvLyBUaGUgImZpbHRlciIgcHJvcGVydHkgaXMgcHJl c2VudCBpbiB0aGUgbGlzdCBidXQgc2hvdWxkIG5vdCBiZSBwcm92aWRlZCBpbiB0aGUgZW51bWVy YXRpb24uCisgICAgICAgICAgICAvLyBTZWUgYSBjb21tZW50IGluIHRoZSBWOENTU1N0eWxlRGVj bGFyYXRpb246Om5hbWVkUHJvcGVydHlHZXR0ZXIoKSBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAg ICAgIC8vIEZJWE1FOiB0aGlzIHNob3VsZCBiZSByZW1vdmVkIChzZWUgYnVnIDczNDI2KS4KKyAg ICAgICAgICAgIGlmIChqc1Byb3BlcnR5TmFtZSAhPSBmaWx0ZXJTdHJpbmcpCisgICAgICAgICAg ICAgICAgcHJvcGVydHlOYW1lcy5hcHBlbmQoanNQcm9wZXJ0eU5hbWUpOworICAgICAgICB9Cisg ICAgICAgIHByb3BlcnR5TmFtZXNMZW5ndGggPSBwcm9wZXJ0eU5hbWVzLnNpemUoKTsKKyAgICB9 CisKKyAgICB2ODo6SGFuZGxlPHY4OjpBcnJheT4gcHJvcGVydGllcyA9IHY4OjpBcnJheTo6TmV3 KHByb3BlcnR5TmFtZXNMZW5ndGgpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBwcm9w ZXJ0eU5hbWVzTGVuZ3RoOyArK2kpIHsKKyAgICAgICAgU3RyaW5nIGtleSA9IHByb3BlcnR5TmFt ZXMuYXQoaSk7CisgICAgICAgIEFTU0VSVCgha2V5LmlzTnVsbCgpKTsKKyAgICAgICAgcHJvcGVy dGllcy0+U2V0KHY4OjpJbnRlZ2VyOjpOZXcoaSksIHY4U3RyaW5nKGtleSkpOworICAgIH0KKwor ICAgIHJldHVybiBwcm9wZXJ0aWVzOworfQorCit2ODo6SGFuZGxlPHY4OjpJbnRlZ2VyPiBWOENT U1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSh2ODo6TG9jYWw8djg6OlN0cmlu Zz4gdjhOYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBpbmZvKQoreworICAgIElOQ19TVEFU UygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFtZWRQcm9wZXJ0eVF1ZXJ5Iik7CisgICAgcmV0 dXJuIHY4OjpJbnRlZ2VyOjpOZXcodjg6Ok5vbmUpOworfQorCiB2ODo6SGFuZGxlPHY4OjpWYWx1 ZT4gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKHY4OjpMb2NhbDx2 ODo6U3RyaW5nPiBuYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBpbmZvKQogewogICAgIElO Q19TVEFUUygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFtZWRQcm9wZXJ0eUdldHRlciIpOwpA QCAtMTYwLDE0ICsxOTYsMTMgQEAgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4Q1NTU3R5bGVEZWNs YXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUdldHRlcih2ODo6TG9jYWw8djg6OlMKICAgICAgICAgcmV0 dXJuIG5vdEhhbmRsZWRCeUludGVyY2VwdG9yKCk7CiAKICAgICAvLyBTZWFyY2ggdGhlIHN0eWxl IGRlY2xhcmF0aW9uLgotICAgIENTU1N0eWxlRGVjbGFyYXRpb24qIGltcCA9IFY4Q1NTU3R5bGVE ZWNsYXJhdGlvbjo6dG9OYXRpdmUoaW5mby5Ib2xkZXIoKSk7CiAgICAgQ1NTUHJvcGVydHlJbmZv KiBwcm9wSW5mbyA9IGNzc1Byb3BlcnR5SW5mbyhuYW1lKTsKIAogICAgIC8vIERvIG5vdCBoYW5k bGUgbm9uLXByb3BlcnR5IG5hbWVzLgogICAgIGlmICghcHJvcEluZm8pCiAgICAgICAgIHJldHVy biBub3RIYW5kbGVkQnlJbnRlcmNlcHRvcigpOwogCi0KKyAgICBDU1NTdHlsZURlY2xhcmF0aW9u KiBpbXAgPSBWOENTU1N0eWxlRGVjbGFyYXRpb246OnRvTmF0aXZlKGluZm8uSG9sZGVyKCkpOwog ICAgIFJlZlB0cjxDU1NWYWx1ZT4gY3NzVmFsdWUgPSBpbXAtPmdldFByb3BlcnR5Q1NTVmFsdWUo cHJvcEluZm8tPnByb3BJRCk7CiAgICAgaWYgKGNzc1ZhbHVlKSB7CiAgICAgICAgIGlmIChwcm9w SW5mby0+aGFkUGl4ZWxPclBvc1ByZWZpeCAmJgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv Y3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsIGIvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxl RGVjbGFyYXRpb24uaWRsCmluZGV4IDJmYTYwOWIxMDFjNGYzNTU2NDUwNzZiYmJiNDc2ZDVkNjkz MzViNDguLmQxYjQ3MGY4NzQ4Y2YyOTlhZmM1MWFmNGE2MzNiNDM0NmI3MmY0OWQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwKQEAgLTI3LDYgKzI3LDcgQEAg bW9kdWxlIGNzcyB7CiAgICAgICAgIERlbGVnYXRpbmdQdXRGdW5jdGlvbiwKICAgICAgICAgSGFz TmFtZUdldHRlciwKICAgICAgICAgSGFzSW5kZXhHZXR0ZXIsCisgICAgICAgIEN1c3RvbUdldFBy b3BlcnR5TmFtZXMsCiAgICAgICAgIFY4RGVwZW5kZW50TGlmZXRpbWUKICAgICBdIENTU1N0eWxl RGVjbGFyYXRpb24gewogICAgICAgICAgICAgICAgICBhdHRyaWJ1dGUgW0NvbnZlcnROdWxsU3Ry aW5nVG89TnVsbCwgQ29udmVydE51bGxUb051bGxTdHJpbmddIERPTVN0cmluZyAgICAgICAgY3Nz VGV4dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsIGIvU291cmNl L1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsCmluZGV4IDQ1YWY3MTMzZTY5YTBjZjRiMTVlZGJhYjdk NTJkNjc3MDY1MjRjZmYuLjg2MzYxYzlkODcyNDQ0ODI2NDg3NDVmMDM2MDgyYjI1NzY3NDkzOTEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9jc3MvbWFrZXByb3AucGwKQEAgLTYyLDkgKzYyLDExIEBAIG9wZW4gR1BFUkYsICI+ Q1NTUHJvcGVydHlOYW1lcy5ncGVyZiIgfHwgZGllICJDb3VsZCBub3Qgb3BlbiBDU1NQcm9wZXJ0 eU5hbWVzLmdwCiBwcmludCBHUEVSRiA8PCAiRU9GIjsKICV7CiAvKiBUaGlzIGZpbGUgaXMgYXV0 b21hdGljYWxseSBnZW5lcmF0ZWQgZnJvbSBDU1NQcm9wZXJ0eU5hbWVzLmluIGJ5IG1ha2Vwcm9w LCBkbyBub3QgZWRpdCAqLworI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgXCJDU1NQcm9w ZXJ0eU5hbWVzLmhcIgogI2luY2x1ZGUgXCJIYXNoVG9vbHMuaFwiCiAjaW5jbHVkZSA8c3RyaW5n Lmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAlfQpAQCAtMTE0LDYgKzExNiwyNCBAQCBjb25zdCBjaGFyKiBnZXRQcm9wZXJ0eU5h bWUoQ1NTUHJvcGVydHlJRCBpZCkKICAgICByZXR1cm4gcHJvcGVydHlOYW1lU3RyaW5nc1tpbmRl eF07CiB9CiAKK1N0cmluZyBnZXRKU1Byb3BlcnR5TmFtZShjb25zdCBjaGFyKiBjc3NQcm9wZXJ0 eU5hbWUpCit7CisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgY29uc3QgY2hhciogcCA9 IGNzc1Byb3BlcnR5TmFtZTsKKyAgICBib29sIGlzRmlyc3RDaGFyID0gdHJ1ZTsKKyAgICB3aGls ZSAoY2hhciBjaCA9ICoocCsrKSkgeworICAgICAgICBpZiAoY2ggPT0gJy0nKSB7CisgICAgICAg ICAgICBjaGFyIG5leHRDaCA9ICoocCsrKTsKKyAgICAgICAgICAgIGlmICghbmV4dENoKQorICAg ICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2ggPSAhaXNGaXJzdENoYXIgPyAobmV4 dENoIC0gMHgyMCkgOiBuZXh0Q2g7CisgICAgICAgIH0KKyAgICAgICAgcmVzdWx0LmFwcGVuZChj aCk7CisgICAgICAgIGlzRmlyc3RDaGFyID0gZmFsc2U7CisgICAgfQorICAgIHJldHVybiByZXN1 bHQudG9TdHJpbmcoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogRU9GCiAKQEAgLTEy Niw2ICsxNDYsOCBAQCBwcmludCBIRUFERVIgPDwgIkVPRiI7CiAKICNpbmNsdWRlIDxzdHJpbmcu aD4KIAorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKIGVudW0gQ1NTUHJvcGVydHlJRCB7CkBAIC0xNjAsNiArMTgyLDcgQEAgcHJpbnQgSEVB REVSICJ9O1xuIjsKIHByaW50IEhFQURFUiA8PCAiRU9GIjsKIAogY29uc3QgY2hhciogZ2V0UHJv cGVydHlOYW1lKENTU1Byb3BlcnR5SUQpOworU3RyaW5nIGdldEpTUHJvcGVydHlOYW1lKGNvbnN0 IGNoYXIqKTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggNjgxNjc5NDdmNGM1 ZTQ0MWM4MDVkZDU1MWU0NWNkOGI4ZjM2OGM4MC4uNTg1M2IxOWJiNTc3ZmU2ZTE0ZDIwNTRhYmU5 ODIzNTlkYWEyYmMxZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDExLTExLTMwICBBbGV4YW5k ZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViS2l0IGRvZXMg bm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxlCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0NgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmFzdC9jc3Mv c3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0OgorICAgICAgICAq IGZhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51bWVyYXRpb24uanM6CisKIDIwMTEtMTIt MDggIFRha2FzaGkgVG95b3NoaW1hICA8dG95b3NoaW1AY2hyb21pdW0ub3JnPgogCiAgICAgICAg IEZpeCBmYWlsZWQgbGF5b3V0IHRlc3QsIGJ1ZmZlcmVkQW1vdW50LWFmdGVyLWNsb3NlLWluLWJ1 c3kuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRl LXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51 bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjMxZjg5ODljYmRhMDhk N2M4NzJlNzYwMzhmN2ZhM2QwOWE5MTZmOWMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwxNSBAQAorVGhpcyB0ZXN0IG1ha2VzIHN1cmUgdGhhdCBDU1NTdHlsZURlY2xhcmF0aW9u IGVudW1lcmF0ZXMgSmF2YVNjcmlwdCBwcm9wZXJ0aWVzIGZvciBkZWZpbmVkIGFuZCBub24tZGVm aW5lZCBDU1MgcHJvcGVydGllcywgaW5kZXhlZCBwcm9wZXJ0aWVzLCBhbmQgcHJvcGVydGllcyBk ZWZpbmVkIG9uIHRoZSBwcm90b3R5cGUuIFNlZSBCdWcgMjM5NDYuCitQQVNTIGRvY3VtZW50LmJv ZHkuc3R5bGUubGVuZ3RoIGlzIDIKK1BBU1MgJzAnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMg dHJ1ZQorUEFTUyAnMScgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICd0ZXh0 RGVjb3JhdGlvbicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICdib3JkZXJU b3BDb2xvcicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICdib3JkZXInIGlu IGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAnZm9udCcgaW4gZG9jdW1lbnQuYm9k eS5zdHlsZSBpcyB0cnVlCitQQVNTICdjc3NUZXh0JyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIGlz IHRydWUKK1BBU1MgJ2dldFByb3BlcnR5Q1NTVmFsdWUnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUg aXMgdHJ1ZQorUEFTUyBUaGUgQ1NTIHByb3BlcnR5IG9yZGVyIGlzIGNvcnJlY3QKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMuaHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi43ZTgyOGI5ZjJjYjRmYmNjY2FkN2ZkOWM3OGYwYTcyNmNkNTI2MzZhCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMu aHRtbApAQCAtMCwwICsxLDQ2IEBACis8aGVhZD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVz b3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0PgorICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisKKyAgICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 IHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246IHVuZGVybGluZTsgYm9yZGVyLXRvcC1jb2xvcjogZ3Jl ZW4iPgorICAgIDxkaXYgaWQ9ImRlc2NyaXB0aW9uIj5UaGlzIHRlc3QgbWFrZXMgc3VyZSB0aGF0 IENTU1N0eWxlRGVjbGFyYXRpb24gZW51bWVyYXRlcyBKYXZhU2NyaXB0IHByb3BlcnRpZXMgZm9y IGRlZmluZWQgYW5kIG5vbi1kZWZpbmVkIENTUyBwcm9wZXJ0aWVzLCBpbmRleGVkIHByb3BlcnRp ZXMsIGFuZCBwcm9wZXJ0aWVzIGRlZmluZWQgb24gdGhlIHByb3RvdHlwZS4gU2VlIDxhIGhyZWY9 Imh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0NiI+QnVnIDIzOTQ2 PC9hPi48L2Rpdj4KKyAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8c2NyaXB0Pgor ICAgICAgICBzaG91bGRCZSgiZG9jdW1lbnQuYm9keS5zdHlsZS5sZW5ndGgiLCAiMiIpOworICAg ICAgICBzaG91bGRCZVRydWUoIicwJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAg IHNob3VsZEJlVHJ1ZSgiJzEnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hv dWxkQmVUcnVlKCIndGV4dERlY29yYXRpb24nIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAg ICAgICAgc2hvdWxkQmVUcnVlKCInYm9yZGVyVG9wQ29sb3InIGluIGRvY3VtZW50LmJvZHkuc3R5 bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInYm9yZGVyJyBpbiBkb2N1bWVudC5ib2R5LnN0 eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2ZvbnQnIGluIGRvY3VtZW50LmJvZHkuc3R5 bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInY3NzVGV4dCcgaW4gZG9jdW1lbnQuYm9keS5z dHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIidnZXRQcm9wZXJ0eUNTU1ZhbHVlJyBpbiBk b2N1bWVudC5ib2R5LnN0eWxlIik7CisKKyAgICAgICAgLy8gVGVzdCBDU1MgcHJvcGVydHkgb3Jk ZXIuCisgICAgICAgIHZhciBzdGFydGVkOworICAgICAgICB2YXIgY3NzUHJvcGVydHlDb3VudCA9 IDA7CisgICAgICAgIHZhciBwcmV2aW91czsKKyAgICAgICAgZm9yICh2YXIgcCBpbiBkb2N1bWVu dC5ib2R5LnN0eWxlKSB7CisgICAgICAgICAgICBpZiAocCA9PT0gImFsaWdubWVudEJhc2VsaW5l IikKKyAgICAgICAgICAgICAgICBzdGFydGVkID0gdHJ1ZTsKKyAgICAgICAgICAgIGlmICghc3Rh cnRlZCkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlmIChwcmV2aW91 cyAmJiBwcmV2aW91cyA+PSBwKSB7CisgICAgICAgICAgICAgICAgdGVzdEZhaWxlZCgiSW52YWxp ZCBDU1MtbWFwcGVkIHByb3BlcnR5IG9yZGVyOiAnIiArIHAgKyAiJyBhZnRlciAnIiArIHByZXZp b3VzICsgIiciKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIGlmICgrK2Nzc1Byb3BlcnR5Q291bnQgPD0gMTAwKQorICAgICAgICAgICAgICAgIHBy ZXZpb3VzID0gcDsKKyAgICAgICAgICAgIGVsc2UgeworICAgICAgICAgICAgICAgIHRlc3RQYXNz ZWQoIlRoZSBDU1MgcHJvcGVydHkgb3JkZXIgaXMgY29ycmVjdCIpOworICAgICAgICAgICAgICAg IGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgPC9zY3JpcHQ+CisgICAgPHNj cmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9u LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxpc3RFbnVtZXJhdGlvbi1l eHBlY3RlZC50eHQKaW5kZXggNzIyYmEwNzk3MTlhNDZjZmI1MDQ0OTJhNzY1YWUzMTBhMTZiZjhh NS4uOWNhOTdlYzU3NTkxMDU0MDgxNDVmM2RjODkyYWFiMDkzMGQzYzc5OCAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0CkBA IC02Niw3ICs2Niw2IEBAIFBBU1MgcmVzdWx0QXJyYXlbMl0uaSBpcyAnMicKIFBBU1MgcmVzdWx0 QXJyYXlbMl0uaXRlbSBpcyBjc3NSdWxlTGlzdC5pdGVtKDIpCiAKIFtvYmplY3QgQ1NTU3R5bGVE ZWNsYXJhdGlvbl0KLVBBU1MgcmVzdWx0QXJyYXkubGVuZ3RoIGlzIDE0CiBQQVNTIHJlc3VsdEFy cmF5WzBdLmkgaXMgJzAnCiBQQVNTIHJlc3VsdEFycmF5WzBdLml0ZW0gaXMgY3NzU3R5bGVEZWNs YXJhdGlvbi5pdGVtKDApCiBQQVNTIHJlc3VsdEFycmF5WzFdLmkgaXMgJzEnCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpz IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5q cwppbmRleCBhMDk5YzgzNTYzZjgzZTAwZDUzNDZmYzhjMzc2YjhjYmRmYzVjYzk2Li43YTk4NzU1 MTdhZjIyOTlkYTE4MTczYzNkZTVjMWJiODgwMWE2MTFlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpzCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51bWVyYXRpb24uanMKQEAgLTE3 Myw3ICsxNzMsNiBAQCBzaG91bGRCZSgicmVzdWx0QXJyYXlbMl0uaXRlbSIsICJjc3NSdWxlTGlz dC5pdGVtKDIpIik7CiAvL2RlYnVnKGVzY2FwZUhUTUwoZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRh Z05hbWUoJ3N0eWxlJykpKTsKIHZhciBjc3NTdHlsZURlY2xhcmF0aW9uID0gZG9jdW1lbnQuc3R5 bGVTaGVldHNbMl0uY3NzUnVsZXNbMF0uc3R5bGU7CiByZXN1bHRBcnJheSA9IGl0ZXJhdGVMaXN0 KGNzc1N0eWxlRGVjbGFyYXRpb24pOwotc2hvdWxkQmUoInJlc3VsdEFycmF5Lmxlbmd0aCIsICIx NCIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzBdLmkiLCAiJzAnIik7CiBzaG91bGRCZSgicmVz dWx0QXJyYXlbMF0uaXRlbSIsICJjc3NTdHlsZURlY2xhcmF0aW9uLml0ZW0oMCkiKTsKIHNob3Vs ZEJlKCJyZXN1bHRBcnJheVsxXS5pIiwgIicxJyIpOwo= 118385 2011-12-08 07:11:06 -0800 2011-12-09 02:22:05 -0800 [PATCH] Restored property name sorting bug-23946-20111208191104.patch text/plain 14998 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyMzMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2ZkYTQzZWNlYWUyNmUx NjExZDQwZmVmNTEwNWUwYmU5ZmEyNWIyMC4uNTA0OWM4M2RiMDBiOGUzNTRkZmU5Zjc0YzBiODc3 ZWZiYTI0YmM5YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4 YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViS2l0IGRv ZXMgbm90IGVudW1lcmF0ZSBvdmVyIENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxl CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0Ngor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hh bmdlIGdlbmVyYXRlcyBhIGxpc3Qgb2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJv cGVydGllcyBhbmQgYWxsb3dzIHRvIGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAi aW4iIG9wZXJhdG9yIG9uIHRoZSBDU1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAg ICBUZXN0OiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTog QWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlv bkN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5h bWVkUHJvcGVydHlFbnVtZXJhdG9yKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0 eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6VjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFs bCBkcml2ZS1ieSBvcHRpbWl6YXRpb24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24p LgorICAgICAgICAqIGNzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHBy b3BlcnR5IGVudW1lcmF0b3IuCisgICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBBZGQgYSBmdW5j dGlvbiB0byBjb252ZXJ0IENTUyBwcm9wZXJ0eSBuYW1lcyBpbnRvIEpTIG9uZXMsIGFuZCBhIHN0 cmluZyBjb21wYXJhdG9yLgorCiAyMDExLTEyLTA4ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZp ZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTAy MzIxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURl Y2xhcmF0aW9uQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTQ1NTU3R5 bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5kZXggMjkwNGU0YmRiMTBmZDQ5OWZjYmI2NjZhZDY2 ZTI4ZDA2ZWZlYTUzMy4uMTU2ZmVmMjZhMWJmMzkzMTQ4M2Q2NWRmZmU5NmY3YmUyZGE1ZTE0YSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0 aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxl RGVjbGFyYXRpb25DdXN0b20uY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJDU1NN dXRhYmxlU3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgi CisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlLmgiCiAj aW5jbHVkZSAiSlNDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkpTTm9kZS5oIgpAQCAtMTM5LDggKzE0 MCw2IEBAIGJvb2wgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpjYW5HZXRJdGVtc0Zvck5hbWUoRXhl Y1N0YXRlKiwgQ1NTU3R5bGVEZWNsYXJhdGlvbiosCiAgICAgcmV0dXJuIGlzQ1NTUHJvcGVydHlO YW1lKHByb3BlcnR5TmFtZSk7CiB9CiAKLS8vIEZJWE1FOiBZb3UgY2FuIGdldCB0aGVzZSBwcm9w ZXJ0aWVzLCBhbmQgc2V0IHRoZW0gKHNlZSBwdXREZWxlZ2F0ZSBiZWxvdyksCi0vLyBidXQgeW91 IHNob3VsZCBhbHNvIGJlIGFibGUgdG8gZW51bWVyYXRlIHRoZW0uCiBKU1ZhbHVlIEpTQ1NTU3R5 bGVEZWNsYXJhdGlvbjo6bmFtZUdldHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgc2xvdEJh c2UsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5TmFtZSkKIHsKICAgICBKU0NTU1N0eWxlRGVj bGFyYXRpb24qIHRoaXNPYmogPSBzdGF0aWNfY2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24qPihh c09iamVjdChzbG90QmFzZSkpOwpAQCAtMTk1LDQgKzE5NCwzMyBAQCBKU1ZhbHVlIEpTQ1NTU3R5 bGVEZWNsYXJhdGlvbjo6Z2V0UHJvcGVydHlDU1NWYWx1ZShFeGVjU3RhdGUqIGV4ZWMpCiAgICAg cmV0dXJuIHRvSlMoZXhlYywgZ2xvYmFsT2JqZWN0KCksIFdURjo6Z2V0UHRyKGNzc1ZhbHVlKSk7 CiB9CiAKK3ZvaWQgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKEpT T2JqZWN0KiBvYmplY3QsIEV4ZWNTdGF0ZSogZXhlYywgUHJvcGVydHlOYW1lQXJyYXkmIHByb3Bl cnR5TmFtZXMsIEVudW1lcmF0aW9uTW9kZSBtb2RlKQoreworICAgIEpTQ1NTU3R5bGVEZWNsYXJh dGlvbiogdGhpc09iamVjdCA9IGpzQ2FzdDxKU0NTU1N0eWxlRGVjbGFyYXRpb24qPihvYmplY3Qp OworICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5IRVJJVFModGhpc09iamVjdCwgJnNfaW5mbyk7CisK KyAgICB1bnNpZ25lZCBsZW5ndGggPSB0aGlzT2JqZWN0LT5pbXBsKCktPmxlbmd0aCgpOworICAg IGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkKKyAgICAgICAgcHJvcGVydHlO YW1lcy5hZGQoSWRlbnRpZmllcjo6ZnJvbShleGVjLCBpKSk7CisKKyAgICBzdGF0aWMgSWRlbnRp ZmllcioganNQcm9wZXJ0eUlkZW50aWZpZXJzID0gMDsKKyAgICBpZiAoIWpzUHJvcGVydHlJZGVu dGlmaWVycykgeworICAgICAgICBWZWN0b3I8U3RyaW5nLCBudW1DU1NQcm9wZXJ0aWVzPiBqc1By b3BlcnR5TmFtZXM7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVydGll czsgKytpKQorICAgICAgICAgICAganNQcm9wZXJ0eU5hbWVzLmFwcGVuZChnZXRKU1Byb3BlcnR5 TmFtZShwcm9wZXJ0eU5hbWVTdHJpbmdzW2ldKSk7CisgICAgICAgIHN0ZDo6c29ydChqc1Byb3Bl cnR5TmFtZXMuYmVnaW4oKSwganNQcm9wZXJ0eU5hbWVzLmVuZCgpLCBzdHJpbmdDb21wYXJlKTsK KworICAgICAgICBqc1Byb3BlcnR5SWRlbnRpZmllcnMgPSBuZXcgSWRlbnRpZmllcltudW1DU1NQ cm9wZXJ0aWVzXTsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1DU1NQcm9wZXJ0aWVz OyArK2kpIHsKKyAgICAgICAgICAgIFN0cmluZyBqc1Byb3BlcnR5TmFtZSA9IGpzUHJvcGVydHlO YW1lcy5hdChpKTsKKyAgICAgICAgICAgIGpzUHJvcGVydHlJZGVudGlmaWVyc1tpXSA9IElkZW50 aWZpZXIoJmV4ZWMtPmdsb2JhbERhdGEoKSwganNQcm9wZXJ0eU5hbWUuY2hhcmFjdGVycygpLCBq c1Byb3BlcnR5TmFtZS5sZW5ndGgoKSk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBmb3IgKGlu dCBpID0gMDsgaSA8IG51bUNTU1Byb3BlcnRpZXM7ICsraSkKKyAgICAgICAgcHJvcGVydHlOYW1l cy5hZGQoanNQcm9wZXJ0eUlkZW50aWZpZXJzW2ldKTsKKworICAgIEJhc2U6OmdldE93blByb3Bl cnR5TmFtZXModGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lcywgbW9kZSk7Cit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L3Y4L2N1c3RvbS9WOENTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKaW5k ZXggNjQzZjBmZWEwMDJkOGZmZTAwOGY5MTY4NGRmOTVkMjdmN2UxMmU0Yi4uMjcyNmIyNzliNDU2 MzMxMTMyYzEwN2NiMDVlOWUyYTdlMTE3YWNmMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1 c3RvbS5jcHAKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJWOENTU1N0eWxlRGVjbGFyYXRp b24uaCIKIAogI2luY2x1ZGUgIkNTU1BhcnNlci5oIgorI2luY2x1ZGUgIkNTU1Byb3BlcnR5TmFt ZXMuaCIKICNpbmNsdWRlICJDU1NTdHlsZURlY2xhcmF0aW9uLmgiCiAjaW5jbHVkZSAiQ1NTVmFs dWUuaCIKICNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgpAQCAtMTUyLDYgKzE1Myw0MiBA QCBzdGF0aWMgQ1NTUHJvcGVydHlJbmZvKiBjc3NQcm9wZXJ0eUluZm8odjg6OkhhbmRsZTx2ODo6 U3RyaW5nPnY4UHJvcGVydHlOYW1lKQogICAgIHJldHVybiBwcm9wSW5mbzsKIH0KIAordjg6Okhh bmRsZTx2ODo6QXJyYXk+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUVudW1l cmF0b3IoY29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sKKyAgICB0eXBlZGVmIFZlY3Rv cjxTdHJpbmcsIG51bUNTU1Byb3BlcnRpZXMgLSAxPiBQcmVBbGxvY2F0ZWRQcm9wZXJ0eVZlY3Rv cjsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFByZUFsbG9jYXRlZFByb3BlcnR5VmVjdG9yLCBw cm9wZXJ0eU5hbWVzLCAoKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIGZpbHRl clN0cmluZywgKCJmaWx0ZXIiKSk7CisgICAgc3RhdGljIHVuc2lnbmVkIHByb3BlcnR5TmFtZXNM ZW5ndGggPSAwOworCisgICAgaWYgKHByb3BlcnR5TmFtZXMuaXNFbXB0eSgpKSB7CisgICAgICAg IGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJvcGVydGllczsgKytpKSB7CisgICAgICAgICAg ICBTdHJpbmcganNQcm9wZXJ0eU5hbWUgPSBnZXRKU1Byb3BlcnR5TmFtZShwcm9wZXJ0eU5hbWVT dHJpbmdzW2ldKTsKKyAgICAgICAgICAgIC8vIFRoZSAiZmlsdGVyIiBwcm9wZXJ0eSBpcyBwcmVz ZW50IGluIHRoZSBsaXN0IGJ1dCBzaG91bGQgbm90IGJlIHByb3ZpZGVkIGluIHRoZSBlbnVtZXJh dGlvbi4KKyAgICAgICAgICAgIC8vIFNlZSBhIGNvbW1lbnQgaW4gdGhlIFY4Q1NTU3R5bGVEZWNs YXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUdldHRlcigpIGltcGxlbWVudGF0aW9uLgorICAgICAgICAg ICAgLy8gRklYTUU6IHRoaXMgc2hvdWxkIGJlIHJlbW92ZWQgKHNlZSBidWcgNzM0MjYpLgorICAg ICAgICAgICAgaWYgKGpzUHJvcGVydHlOYW1lICE9IGZpbHRlclN0cmluZykKKyAgICAgICAgICAg ICAgICBwcm9wZXJ0eU5hbWVzLmFwcGVuZChqc1Byb3BlcnR5TmFtZSk7CisgICAgICAgIH0KKyAg ICAgICAgc3RkOjpzb3J0KHByb3BlcnR5TmFtZXMuYmVnaW4oKSwgcHJvcGVydHlOYW1lcy5lbmQo KSwgc3RyaW5nQ29tcGFyZSk7CisgICAgICAgIHByb3BlcnR5TmFtZXNMZW5ndGggPSBwcm9wZXJ0 eU5hbWVzLnNpemUoKTsKKyAgICB9CisKKyAgICB2ODo6SGFuZGxlPHY4OjpBcnJheT4gcHJvcGVy dGllcyA9IHY4OjpBcnJheTo6TmV3KHByb3BlcnR5TmFtZXNMZW5ndGgpOworICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBwcm9wZXJ0eU5hbWVzTGVuZ3RoOyArK2kpIHsKKyAgICAgICAgU3Ry aW5nIGtleSA9IHByb3BlcnR5TmFtZXMuYXQoaSk7CisgICAgICAgIEFTU0VSVCgha2V5LmlzTnVs bCgpKTsKKyAgICAgICAgcHJvcGVydGllcy0+U2V0KHY4OjpJbnRlZ2VyOjpOZXcoaSksIHY4U3Ry aW5nKGtleSkpOworICAgIH0KKworICAgIHJldHVybiBwcm9wZXJ0aWVzOworfQorCit2ODo6SGFu ZGxlPHY4OjpJbnRlZ2VyPiBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlRdWVy eSh2ODo6TG9jYWw8djg6OlN0cmluZz4gdjhOYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBp bmZvKQoreworICAgIElOQ19TVEFUUygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFtZWRQcm9w ZXJ0eVF1ZXJ5Iik7CisgICAgcmV0dXJuIHY4OjpJbnRlZ2VyOjpOZXcodjg6Ok5vbmUpOworfQor CiB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4gVjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3Bl cnR5R2V0dGVyKHY4OjpMb2NhbDx2ODo6U3RyaW5nPiBuYW1lLCBjb25zdCB2ODo6QWNjZXNzb3JJ bmZvJiBpbmZvKQogewogICAgIElOQ19TVEFUUygiRE9NLkNTU1N0eWxlRGVjbGFyYXRpb24uTmFt ZWRQcm9wZXJ0eUdldHRlciIpOwpAQCAtMTYwLDE0ICsxOTcsMTMgQEAgdjg6OkhhbmRsZTx2ODo6 VmFsdWU+IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eUdldHRlcih2ODo6TG9j YWw8djg6OlMKICAgICAgICAgcmV0dXJuIG5vdEhhbmRsZWRCeUludGVyY2VwdG9yKCk7CiAKICAg ICAvLyBTZWFyY2ggdGhlIHN0eWxlIGRlY2xhcmF0aW9uLgotICAgIENTU1N0eWxlRGVjbGFyYXRp b24qIGltcCA9IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6dG9OYXRpdmUoaW5mby5Ib2xkZXIoKSk7 CiAgICAgQ1NTUHJvcGVydHlJbmZvKiBwcm9wSW5mbyA9IGNzc1Byb3BlcnR5SW5mbyhuYW1lKTsK IAogICAgIC8vIERvIG5vdCBoYW5kbGUgbm9uLXByb3BlcnR5IG5hbWVzLgogICAgIGlmICghcHJv cEluZm8pCiAgICAgICAgIHJldHVybiBub3RIYW5kbGVkQnlJbnRlcmNlcHRvcigpOwogCi0KKyAg ICBDU1NTdHlsZURlY2xhcmF0aW9uKiBpbXAgPSBWOENTU1N0eWxlRGVjbGFyYXRpb246OnRvTmF0 aXZlKGluZm8uSG9sZGVyKCkpOwogICAgIFJlZlB0cjxDU1NWYWx1ZT4gY3NzVmFsdWUgPSBpbXAt PmdldFByb3BlcnR5Q1NTVmFsdWUocHJvcEluZm8tPnByb3BJRCk7CiAgICAgaWYgKGNzc1ZhbHVl KSB7CiAgICAgICAgIGlmIChwcm9wSW5mby0+aGFkUGl4ZWxPclBvc1ByZWZpeCAmJgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsIGIvU291cmNl L1dlYkNvcmUvY3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsCmluZGV4IDJmYTYwOWIxMDFjNGYz NTU2NDUwNzZiYmJiNDc2ZDVkNjkzMzViNDguLmQxYjQ3MGY4NzQ4Y2YyOTlhZmM1MWFmNGE2MzNi NDM0NmI3MmY0OWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xh cmF0aW9uLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5p ZGwKQEAgLTI3LDYgKzI3LDcgQEAgbW9kdWxlIGNzcyB7CiAgICAgICAgIERlbGVnYXRpbmdQdXRG dW5jdGlvbiwKICAgICAgICAgSGFzTmFtZUdldHRlciwKICAgICAgICAgSGFzSW5kZXhHZXR0ZXIs CisgICAgICAgIEN1c3RvbUdldFByb3BlcnR5TmFtZXMsCiAgICAgICAgIFY4RGVwZW5kZW50TGlm ZXRpbWUKICAgICBdIENTU1N0eWxlRGVjbGFyYXRpb24gewogICAgICAgICAgICAgICAgICBhdHRy aWJ1dGUgW0NvbnZlcnROdWxsU3RyaW5nVG89TnVsbCwgQ29udmVydE51bGxUb051bGxTdHJpbmdd IERPTVN0cmluZyAgICAgICAgY3NzVGV4dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvY3Nz L21ha2Vwcm9wLnBsIGIvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsCmluZGV4IDQ1YWY3 MTMzZTY5YTBjZjRiMTVlZGJhYjdkNTJkNjc3MDY1MjRjZmYuLjRjOGZlZWE1YzdmNDEwZThhZTJl ZTg5NTAyNjJiOTkwMmQ3NGViMGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Nzcy9tYWtl cHJvcC5wbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9jc3MvbWFrZXByb3AucGwKQEAgLTYyLDkgKzYy LDExIEBAIG9wZW4gR1BFUkYsICI+Q1NTUHJvcGVydHlOYW1lcy5ncGVyZiIgfHwgZGllICJDb3Vs ZCBub3Qgb3BlbiBDU1NQcm9wZXJ0eU5hbWVzLmdwCiBwcmludCBHUEVSRiA8PCAiRU9GIjsKICV7 CiAvKiBUaGlzIGZpbGUgaXMgYXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZnJvbSBDU1NQcm9wZXJ0 eU5hbWVzLmluIGJ5IG1ha2Vwcm9wLCBkbyBub3QgZWRpdCAqLworI2luY2x1ZGUgImNvbmZpZy5o IgogI2luY2x1ZGUgXCJDU1NQcm9wZXJ0eU5hbWVzLmhcIgogI2luY2x1ZGUgXCJIYXNoVG9vbHMu aFwiCiAjaW5jbHVkZSA8c3RyaW5nLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRl ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAlfQpAQCAtMTE0LDYgKzExNiwyNCBAQCBjb25z dCBjaGFyKiBnZXRQcm9wZXJ0eU5hbWUoQ1NTUHJvcGVydHlJRCBpZCkKICAgICByZXR1cm4gcHJv cGVydHlOYW1lU3RyaW5nc1tpbmRleF07CiB9CiAKK1N0cmluZyBnZXRKU1Byb3BlcnR5TmFtZShj b25zdCBjaGFyKiBjc3NQcm9wZXJ0eU5hbWUpCit7CisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7 CisgICAgY29uc3QgY2hhciogcCA9IGNzc1Byb3BlcnR5TmFtZTsKKyAgICBib29sIGlzRmlyc3RD aGFyID0gdHJ1ZTsKKyAgICB3aGlsZSAoY2hhciBjaCA9ICoocCsrKSkgeworICAgICAgICBpZiAo Y2ggPT0gJy0nKSB7CisgICAgICAgICAgICBjaGFyIG5leHRDaCA9ICoocCsrKTsKKyAgICAgICAg ICAgIGlmICghbmV4dENoKQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2gg PSAhaXNGaXJzdENoYXIgPyAobmV4dENoIC0gMHgyMCkgOiBuZXh0Q2g7CisgICAgICAgIH0KKyAg ICAgICAgcmVzdWx0LmFwcGVuZChjaCk7CisgICAgICAgIGlzRmlyc3RDaGFyID0gZmFsc2U7Cisg ICAgfQorICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogRU9GCiAKQEAgLTEyNiw2ICsxNDYsOCBAQCBwcmludCBIRUFERVIgPDwgIkVPRiI7 CiAKICNpbmNsdWRlIDxzdHJpbmcuaD4KIAorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5o PgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGVudW0gQ1NTUHJvcGVydHlJRCB7CkBAIC0xNjAs NiArMTgyLDggQEAgcHJpbnQgSEVBREVSICJ9O1xuIjsKIHByaW50IEhFQURFUiA8PCAiRU9GIjsK IAogY29uc3QgY2hhciogZ2V0UHJvcGVydHlOYW1lKENTU1Byb3BlcnR5SUQpOworU3RyaW5nIGdl dEpTUHJvcGVydHlOYW1lKGNvbnN0IGNoYXIqKTsKK3N0YXRpYyBpbmxpbmUgYm9vbCBzdHJpbmdD b21wYXJlKGNvbnN0IFN0cmluZyYgZmlyc3QsIGNvbnN0IFN0cmluZyYgc2Vjb25kKSB7IHJldHVy biBjb2RlUG9pbnRDb21wYXJlKGZpcnN0LCBzZWNvbmQpIDwgMDsgfQogCiB9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRl c3RzL0NoYW5nZUxvZwppbmRleCA2ODE2Nzk0N2Y0YzVlNDQxYzgwNWRkNTUxZTQ1Y2Q4YjhmMzY4 YzgwLi41ODUzYjE5YmI1NzdmZTZlMTRkMjA1NGFiZTk4MjM1OWRhYTJiYzFlIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTUgQEAKKzIwMTEtMTEtMzAgIEFsZXhhbmRlciBQYXZsb3YgIDxhcGF2bG92QGNocm9t aXVtLm9yZz4KKworICAgICAgICBXZWJLaXQgZG9lcyBub3QgZW51bWVyYXRlIG92ZXIgQ1NTIHBy b3BlcnRpZXMgaW4gSFRNTEVsZW1lbnQuc3R5bGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIzOTQ2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGll cy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL3N0eWxlLWVudW1lcmF0 ZS1wcm9wZXJ0aWVzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL2RvbUxpc3RFbnVt ZXJhdGlvbi1leHBlY3RlZC50eHQ6CisgICAgICAgICogZmFzdC9kb20vc2NyaXB0LXRlc3RzL2Rv bUxpc3RFbnVtZXJhdGlvbi5qczoKKwogMjAxMS0xMi0wOCAgVGFrYXNoaSBUb3lvc2hpbWEgIDx0 b3lvc2hpbUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgRml4IGZhaWxlZCBsYXlvdXQgdGVzdCwg YnVmZmVyZWRBbW91bnQtYWZ0ZXItY2xvc2UtaW4tYnVzeS5odG1sCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMzFmODk4OWNiZGEwOGQ3Yzg3MmU3NjAzOGY3ZmEzZDA5YTkxNmY5 YwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0 ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3QgbWFr ZXMgc3VyZSB0aGF0IENTU1N0eWxlRGVjbGFyYXRpb24gZW51bWVyYXRlcyBKYXZhU2NyaXB0IHBy b3BlcnRpZXMgZm9yIGRlZmluZWQgYW5kIG5vbi1kZWZpbmVkIENTUyBwcm9wZXJ0aWVzLCBpbmRl eGVkIHByb3BlcnRpZXMsIGFuZCBwcm9wZXJ0aWVzIGRlZmluZWQgb24gdGhlIHByb3RvdHlwZS4g U2VlIEJ1ZyAyMzk0Ni4KK1BBU1MgZG9jdW1lbnQuYm9keS5zdHlsZS5sZW5ndGggaXMgMgorUEFT UyAnMCcgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTICcxJyBpbiBkb2N1bWVu dC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJ3RleHREZWNvcmF0aW9uJyBpbiBkb2N1bWVudC5i b2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJ2JvcmRlclRvcENvbG9yJyBpbiBkb2N1bWVudC5ib2R5 LnN0eWxlIGlzIHRydWUKK1BBU1MgJ2JvcmRlcicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0 cnVlCitQQVNTICdmb250JyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJ2Nz c1RleHQnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAnZ2V0UHJvcGVydHlD U1NWYWx1ZScgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSBpcyB0cnVlCitQQVNTIFRoZSBDU1MgcHJv cGVydHkgb3JkZXIgaXMgY29ycmVjdAorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQor CitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxl LWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9zdHlsZS1l bnVtZXJhdGUtcHJvcGVydGllcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlODI4YjlmMmNiNGZiY2NjYWQ3 ZmQ5Yzc4ZjBhNzI2Y2Q1MjYzNmEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2Nzcy9zdHlsZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCkBAIC0wLDAgKzEsNDYgQEAKKzxo ZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwv c2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisK KworICAgIDwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgc3R5bGU9InRleHQtZGVjb3JhdGlvbjog dW5kZXJsaW5lOyBib3JkZXItdG9wLWNvbG9yOiBncmVlbiI+CisgICAgPGRpdiBpZD0iZGVzY3Jp cHRpb24iPlRoaXMgdGVzdCBtYWtlcyBzdXJlIHRoYXQgQ1NTU3R5bGVEZWNsYXJhdGlvbiBlbnVt ZXJhdGVzIEphdmFTY3JpcHQgcHJvcGVydGllcyBmb3IgZGVmaW5lZCBhbmQgbm9uLWRlZmluZWQg Q1NTIHByb3BlcnRpZXMsIGluZGV4ZWQgcHJvcGVydGllcywgYW5kIHByb3BlcnRpZXMgZGVmaW5l ZCBvbiB0aGUgcHJvdG90eXBlLiBTZWUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIzOTQ2Ij5CdWcgMjM5NDY8L2E+LjwvZGl2PgorICAgIDxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorICAgIDxzY3JpcHQ+CisgICAgICAgIHNob3VsZEJlKCJkb2N1bWVu dC5ib2R5LnN0eWxlLmxlbmd0aCIsICIyIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJzAnIGlu IGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInMScgaW4gZG9j dW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIid0ZXh0RGVjb3JhdGlv bicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIidib3Jk ZXJUb3BDb2xvcicgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRy dWUoIidib3JkZXInIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVU cnVlKCInZm9udCcgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRy dWUoIidjc3NUZXh0JyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJl VHJ1ZSgiJ2dldFByb3BlcnR5Q1NTVmFsdWUnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUiKTsKKwor ICAgICAgICAvLyBUZXN0IENTUyBwcm9wZXJ0eSBvcmRlci4KKyAgICAgICAgdmFyIHN0YXJ0ZWQ7 CisgICAgICAgIHZhciBjc3NQcm9wZXJ0eUNvdW50ID0gMDsKKyAgICAgICAgdmFyIHByZXZpb3Vz OworICAgICAgICBmb3IgKHZhciBwIGluIGRvY3VtZW50LmJvZHkuc3R5bGUpIHsKKyAgICAgICAg ICAgIGlmIChwID09PSAiYWxpZ25tZW50QmFzZWxpbmUiKQorICAgICAgICAgICAgICAgIHN0YXJ0 ZWQgPSB0cnVlOworICAgICAgICAgICAgaWYgKCFzdGFydGVkKQorICAgICAgICAgICAgICAgIGNv bnRpbnVlOworICAgICAgICAgICAgaWYgKHByZXZpb3VzICYmIHByZXZpb3VzID49IHApIHsKKyAg ICAgICAgICAgICAgICB0ZXN0RmFpbGVkKCJJbnZhbGlkIENTUy1tYXBwZWQgcHJvcGVydHkgb3Jk ZXI6ICciICsgcCArICInIGFmdGVyICciICsgcHJldmlvdXMgKyAiJyIpOworICAgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICAgICAgaWYgKCsrY3NzUHJvcGVydHlD b3VudCA8PSAxMDApCisgICAgICAgICAgICAgICAgcHJldmlvdXMgPSBwOworICAgICAgICAgICAg ZWxzZSB7CisgICAgICAgICAgICAgICAgdGVzdFBhc3NlZCgiVGhlIENTUyBwcm9wZXJ0eSBvcmRl ciBpcyBjb3JyZWN0Iik7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKyAgICA8L3NjcmlwdD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9kb21MaXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA3MjJiYTA3 OTcxOWE0NmNmYjUwNDQ5MmE3NjVhZTMxMGExNmJmOGE1Li45Y2E5N2VjNTc1OTEwNTQwODE0NWYz ZGM4OTJhYWIwOTMwZDNjNzk4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21M aXN0RW51bWVyYXRpb24tZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL2Rv bUxpc3RFbnVtZXJhdGlvbi1leHBlY3RlZC50eHQKQEAgLTY2LDcgKzY2LDYgQEAgUEFTUyByZXN1 bHRBcnJheVsyXS5pIGlzICcyJwogUEFTUyByZXN1bHRBcnJheVsyXS5pdGVtIGlzIGNzc1J1bGVM aXN0Lml0ZW0oMikKIAogW29iamVjdCBDU1NTdHlsZURlY2xhcmF0aW9uXQotUEFTUyByZXN1bHRB cnJheS5sZW5ndGggaXMgMTQKIFBBU1MgcmVzdWx0QXJyYXlbMF0uaSBpcyAnMCcKIFBBU1MgcmVz dWx0QXJyYXlbMF0uaXRlbSBpcyBjc3NTdHlsZURlY2xhcmF0aW9uLml0ZW0oMCkKIFBBU1MgcmVz dWx0QXJyYXlbMV0uaSBpcyAnMScKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3Nj cmlwdC10ZXN0cy9kb21MaXN0RW51bWVyYXRpb24uanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9z Y3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpzCmluZGV4IGEwOTljODM1NjNmODNlMDBk NTM0NmZjOGMzNzZiOGNiZGZjNWNjOTYuLjdhOTg3NTUxN2FmMjI5OWRhMTgxNzNjM2RlNWMxYmI4 ODAxYTYxMWUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9k b21MaXN0RW51bWVyYXRpb24uanMKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRl c3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcwpAQCAtMTczLDcgKzE3Myw2IEBAIHNob3VsZEJlKCJy ZXN1bHRBcnJheVsyXS5pdGVtIiwgImNzc1J1bGVMaXN0Lml0ZW0oMikiKTsKIC8vZGVidWcoZXNj YXBlSFRNTChkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgnc3R5bGUnKSkpOwogdmFyIGNz c1N0eWxlRGVjbGFyYXRpb24gPSBkb2N1bWVudC5zdHlsZVNoZWV0c1syXS5jc3NSdWxlc1swXS5z dHlsZTsKIHJlc3VsdEFycmF5ID0gaXRlcmF0ZUxpc3QoY3NzU3R5bGVEZWNsYXJhdGlvbik7Ci1z aG91bGRCZSgicmVzdWx0QXJyYXkubGVuZ3RoIiwgIjE0Iik7CiBzaG91bGRCZSgicmVzdWx0QXJy YXlbMF0uaSIsICInMCciKTsKIHNob3VsZEJlKCJyZXN1bHRBcnJheVswXS5pdGVtIiwgImNzc1N0 eWxlRGVjbGFyYXRpb24uaXRlbSgwKSIpOwogc2hvdWxkQmUoInJlc3VsdEFycmF5WzFdLmkiLCAi JzEnIik7Cg== 118549 2011-12-09 02:22:17 -0800 2011-12-09 10:02:15 -0800 [PATCH] Update JSC exports to fix compilability on Win and Mac bug-23946-20111209142214.patch text/plain 18852 apavlov U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyMzMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBm YjkwMDE4ODNlYTFiZjU3OTE5MWMwYzIwMWIzMjY4ZGM2NGNkY2IxLi5mNjU2MTUxOWY5NWNmZjA0 YmQzOWI2OWEzMzQ3N2JhYTI5ZTAyOTQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAxMS0xMi0wOSAgQWxleGFuZGVyIFBhdmxvdiAgPGFwYXZsb3ZAY2hyb21p dW0ub3JnPgorCisgICAgICAgIFdlYktpdCBkb2VzIG5vdCBlbnVtZXJhdGUgb3ZlciBDU1MgcHJv cGVydGllcyBpbiBIVE1MRWxlbWVudC5zdHlsZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgYSBmZXcgZXhwb3J0cyB0byBmb2xsb3cgdGhlIEpTQ1NT U3R5bGVEZWNsYXJhdGlvbi5jcHAgY2hhbmdlcworCisgICAgICAgICogSmF2YVNjcmlwdENvcmUu ZXhwOgorICAgICAgICAqIEphdmFTY3JpcHRDb3JlLnZjcHJvai9KYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS5kZWY6CisKIDIwMTEtMTItMDcgIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxl LmNvbT4KIAogICAgICAgICBERkcgQ1NFIHNob3VsZCBrbm93IHRoYXQgQ2hlY2tGdW5jdGlvbiBp cyBwdXJlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKaW5kZXggM2ZkYTQzZWNlYWUyNmUxNjExZDQwZmVmNTEwNWUwYmU5ZmEy NWIyMC4uNTA0OWM4M2RiMDBiOGUzNTRkZmU5Zjc0YzBiODc3ZWZiYTI0YmM5YyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI0IEBACisyMDExLTExLTI1ICBBbGV4YW5kZXIgUGF2bG92ICA8YXBhdmxv dkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViS2l0IGRvZXMgbm90IGVudW1lcmF0ZSBvdmVy IENTUyBwcm9wZXJ0aWVzIGluIEhUTUxFbGVtZW50LnN0eWxlCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzk0NgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgY2hhbmdlIGdlbmVyYXRlcyBhIGxpc3Qg b2YgSmF2YVNjcmlwdCBtaXJyb3JzIG9mIHRoZSBDU1MgcHJvcGVydGllcyBhbmQgYWxsb3dzIHRv IGVudW1lcmF0ZSB0aGVtCisgICAgICAgIHVzaW5nIHRoZSAiaW4iIG9wZXJhdG9yIG9uIHRoZSBD U1NTdHlsZURlY2xhcmF0aW9uIG9iamVjdC4KKworICAgICAgICBUZXN0OiBmYXN0L2Nzcy9zdHls ZS1lbnVtZXJhdGUtcHJvcGVydGllcy5odG1sCisKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU0NT U1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwOgorICAgICAgICAoV2ViQ29yZTo6SlNDU1NTdHls ZURlY2xhcmF0aW9uOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKTogQWRkZWQuCisgICAgICAgICogYmlu ZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlFbnVtZXJhdG9y KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVk UHJvcGVydHlRdWVyeSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VjhDU1NTdHlsZURlY2xh cmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKTogQSBzbWFsbCBkcml2ZS1ieSBvcHRpbWl6YXRp b24gKGxvY2FsIGluaXRpYWxpemF0aW9uIG1vdmVkIGRvd24pLgorICAgICAgICAqIGNzcy9DU1NT dHlsZURlY2xhcmF0aW9uLmlkbDogVXNlIGEgY3VzdG9tIHByb3BlcnR5IGVudW1lcmF0b3IuCisg ICAgICAgICogY3NzL21ha2Vwcm9wLnBsOiBBZGQgYSBmdW5jdGlvbiB0byBjb252ZXJ0IENTUyBw cm9wZXJ0eSBuYW1lcyBpbnRvIEpTIG9uZXMsIGFuZCBhIHN0cmluZyBjb21wYXJhdG9yLgorCiAy MDExLTEyLTA4ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTAyMzIxLgpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKaW5kZXggYzkzMTQ4MTNkMjVlMTVkNzY0M2JhNDNkZTU2 MWMwODJjZDdmM2I3NS4uZTc5OTYyZmU2ZDZiNjk0ZGVjOTA1ZTVkYmNjMWU2ZjFmNTE1Zjg4NyAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZXhwCkBAIC0xNTUsNiArMTU1 LDcgQEAgX19aTjNKU0MxMlJlZ0V4cE9iamVjdDZzX2luZm9FCiBfX1pOM0pTQzEyUmVnRXhwT2Jq ZWN0QzFFUE5TXzE0SlNHbG9iYWxPYmplY3RFUE5TXzlTdHJ1Y3R1cmVFUE5TXzZSZWdFeHBFCiBf X1pOM0pTQzEyU2FtcGxpbmdUb29sNXNldHVwRXYKIF9fWk4zSlNDMTJTbWFsbFN0cmluZ3MxN2Ny ZWF0ZUVtcHR5U3RyaW5nRVBOU18xMkpTR2xvYmFsRGF0YUUKK19fWk4zSlNDMTJTbWFsbFN0cmlu Z3MyNHNpbmdsZUNoYXJhY3RlclN0cmluZ1JlcEVoCiBfX1pOM0pTQzEyU21hbGxTdHJpbmdzMjdj cmVhdGVTaW5nbGVDaGFyYWN0ZXJTdHJpbmdFUE5TXzEySlNHbG9iYWxEYXRhRWgKIF9fWk4zSlND MTJTdHJpbmdPYmplY3QxNGZpbmlzaENyZWF0aW9uRVJOU18xMkpTR2xvYmFsRGF0YUVQTlNfOEpT U3RyaW5nRQogX19aTjNKU0MxMlN0cmluZ09iamVjdDZzX2luZm9FCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFTY3JpcHRDb3JlL0ph dmFTY3JpcHRDb3JlLmRlZiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS52 Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmCmluZGV4IDdjNTJmNWRiMjYx MzJmYjdlMzE4OTUxZjA4Y2Q2ZDVmNzNkZGIyNTkuLmZiOTA1OWNjNmVkOGIwYTc2OTk1NGZlNDUx MzQ1NmE2Y2FhNWQ2ZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2Ny aXB0Q29yZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUv SmF2YVNjcmlwdENvcmUuZGVmCkBAIC01Myw2ICs1Myw3IEBAIEVYUE9SVFMKICAgICA/YWN0aXZp dHlDYWxsYmFja0BIZWFwQEpTQ0BAUUFFUEFWR0NBY3Rpdml0eUNhbGxiYWNrQDJAWFoKICAgICA/ YWRkQEF0b21pY1N0cmluZ0BXVEZAQENBP0FWPyRQYXNzUmVmUHRyQFZTdHJpbmdJbXBsQFdURkBA QDJAUEJEQFoKICAgICA/YWRkQElkZW50aWZpZXJASlNDQEBTQT9BVj8kUGFzc1JlZlB0ckBWU3Ry aW5nSW1wbEBXVEZAQEBXVEZAQFBBVkV4ZWNTdGF0ZUAyQFBCREBaCisgICAgP2FkZEBJZGVudGlm aWVyQEpTQ0BAQ0E/QVY/JFBhc3NSZWZQdHJAVlN0cmluZ0ltcGxAV1RGQEBAV1RGQEBQQVZKU0ds b2JhbERhdGFAMkBQQVZTdHJpbmdJbXBsQDRAQFoKICAgICA/YWRkQFByb3BlcnR5TmFtZUFycmF5 QEpTQ0BAUUFFWFBBVlN0cmluZ0ltcGxAV1RGQEBAWgogICAgID9hZGRCeXRlc0BNRDVAV1RGQEBR QUVYUEJFSUBaCiAgICAgP2FkZEJ5dGVzQFNIQTFAV1RGQEBRQUVYUEJFSUBaCkBAIC02Miw2ICs2 Myw3IEBAIEVYUE9SVFMKICAgICA/YWRkUHJvcGVydHlUcmFuc2l0aW9uVG9FeGlzdGluZ1N0cnVj dHVyZUBTdHJ1Y3R1cmVASlNDQEBTQVBBVjEyQFBBVjEyQEFCVklkZW50aWZpZXJAMkBJUEFWSlND ZWxsQDJAQUFJQFoKICAgICA/YWRkUHJvcGVydHlXaXRob3V0VHJhbnNpdGlvbkBTdHJ1Y3R1cmVA SlNDQEBRQUVJQUFWSlNHbG9iYWxEYXRhQDJAQUJWSWRlbnRpZmllckAyQElQQVZKU0NlbGxAMkBA WgogICAgID9hZGRTbG93Q2FzZUBJZGVudGlmaWVyQEpTQ0BAQ0E/QVY/JFBhc3NSZWZQdHJAVlN0 cmluZ0ltcGxAV1RGQEBAV1RGQEBQQVZFeGVjU3RhdGVAMkBQQVZTdHJpbmdJbXBsQDRAQFoKKyAg ICA/YWRkU2xvd0Nhc2VASWRlbnRpZmllckBKU0NAQENBP0FWPyRQYXNzUmVmUHRyQFZTdHJpbmdJ bXBsQFdURkBAQFdURkBAUEFWSlNHbG9iYWxEYXRhQDJAUEFWU3RyaW5nSW1wbEA0QEBaCiAgICAg P2FkZFN0YXRpY0dsb2JhbHNASlNHbG9iYWxPYmplY3RASlNDQEBJQUVYUEFVR2xvYmFsUHJvcGVy dHlJbmZvQDEyQEhAWgogICAgID9hbGxvY2F0ZVByb3BlcnR5U3RvcmFnZUBKU09iamVjdEBKU0NA QFFBRVhBQVZKU0dsb2JhbERhdGFAMkBJSUBaCiAgICAgP2FsbG9jYXRlU2xvd0Nhc2VAQWxsb2Nh dGlvblNwYWNlQEpTQ0BAQUFFUEFYQUFVU2l6ZUNsYXNzQE1hcmtlZFNwYWNlQDJAQFoKQEAgLTEz MSw3ICsxMzMsNyBAQCBFWFBPUlRTCiAgICAgP2N1cnJlbnRUaHJlYWRAV1RGQEBZQUlYWgogICAg ID9jdXJyZW50VGhyZWFkSXNIb2xkaW5nTG9ja0BKU0xvY2tASlNDQEBTQV9OWFoKICAgICA/Y3Vy cmVudFRpbWVAV1RGQEBZQU5YWgotCT9leGVjdXRlQFBhcmFsbGVsRW52aXJvbm1lbnRAV1RGQEBR QUVYUEFYQFoKKyAgICA/ZXhlY3V0ZUBQYXJhbGxlbEVudmlyb25tZW50QFdURkBAUUFFWFBBWEBa CiAgICAgP2RhdGFAQ1N0cmluZ0BXVEZAQFFCRVBCRFhaCiAgICAgP2RhdGVUb0RheXNGcm9tMTk3 MEBXVEZAQFlBTkhISEBaCiAgICAgP2RheUluTW9udGhGcm9tRGF5SW5ZZWFyQFdURkBAWUFISF9O QFoKQEAgLTMxMyw2ICszMTUsNyBAQCBFWFBPUlRTCiAgICAgP3NldHRlckBQcm9wZXJ0eURlc2Ny aXB0b3JASlNDQEBRQkU/QVZKU1ZhbHVlQDJAWFoKICAgICA/c2hyaW5rVG9GaXRAU3RyaW5nQnVp bGRlckBXVEZAQFFBRVhYWgogICAgID9zaWduYWxAVGhyZWFkQ29uZGl0aW9uQFdURkBAUUFFWFha CisgICAgP3NpbmdsZUNoYXJhY3RlclN0cmluZ1JlcEBTbWFsbFN0cmluZ3NASlNDQEBRQUVQQVZT dHJpbmdJbXBsQFdURkBARUBaCiAgICAgP3NpemVASGVhcEBKU0NAQFFBRUlYWgogICAgID9zbG93 QXBwZW5kQE1hcmtlZEFyZ3VtZW50QnVmZmVyQEpTQ0BAQUFFWFZKU1ZhbHVlQDJAQFoKICAgICA/ c2xvd1ZhbGlkYXRlQ2VsbEBKU0NAQFlBWFBBVkpTQ2VsbEAxQEBaCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNw cAppbmRleCAyOTA0ZTRiZGIxMGZkNDk5ZmNiYjY2NmFkNjZlMjhkMDZlZmVhNTMzLi4xNTZmZWYy NmExYmYzOTMxNDgzZDY1ZGZmZTk2ZjdiZTJkYTVlMTRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU0NTU1N0eWxlRGVjbGFyYXRpb25DdXN0b20uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTQ1NTU3R5bGVEZWNsYXJhdGlvbkN1c3RvbS5jcHAK QEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkNTU011dGFibGVTdHlsZURlY2xhcmF0aW9u LmgiCiAjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFsdWUuaCIKKyNpbmNsdWRlICJDU1NQcm9wZXJ0 eU5hbWVzLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWUuaCIKICNpbmNsdWRlICJKU0NTU1ZhbHVlLmgi CiAjaW5jbHVkZSAiSlNOb2RlLmgiCkBAIC0xMzksOCArMTQwLDYgQEAgYm9vbCBKU0NTU1N0eWxl RGVjbGFyYXRpb246OmNhbkdldEl0ZW1zRm9yTmFtZShFeGVjU3RhdGUqLCBDU1NTdHlsZURlY2xh cmF0aW9uKiwKICAgICByZXR1cm4gaXNDU1NQcm9wZXJ0eU5hbWUocHJvcGVydHlOYW1lKTsKIH0K IAotLy8gRklYTUU6IFlvdSBjYW4gZ2V0IHRoZXNlIHByb3BlcnRpZXMsIGFuZCBzZXQgdGhlbSAo c2VlIHB1dERlbGVnYXRlIGJlbG93KSwKLS8vIGJ1dCB5b3Ugc2hvdWxkIGFsc28gYmUgYWJsZSB0 byBlbnVtZXJhdGUgdGhlbS4KIEpTVmFsdWUgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lR2V0 dGVyKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSBzbG90QmFzZSwgY29uc3QgSWRlbnRpZmllciYg cHJvcGVydHlOYW1lKQogewogICAgIEpTQ1NTU3R5bGVEZWNsYXJhdGlvbiogdGhpc09iaiA9IHN0 YXRpY19jYXN0PEpTQ1NTU3R5bGVEZWNsYXJhdGlvbio+KGFzT2JqZWN0KHNsb3RCYXNlKSk7CkBA IC0xOTUsNCArMTk0LDMzIEBAIEpTVmFsdWUgSlNDU1NTdHlsZURlY2xhcmF0aW9uOjpnZXRQcm9w ZXJ0eUNTU1ZhbHVlKEV4ZWNTdGF0ZSogZXhlYykKICAgICByZXR1cm4gdG9KUyhleGVjLCBnbG9i YWxPYmplY3QoKSwgV1RGOjpnZXRQdHIoY3NzVmFsdWUpKTsKIH0KIAordm9pZCBKU0NTU1N0eWxl RGVjbGFyYXRpb246OmdldE93blByb3BlcnR5TmFtZXMoSlNPYmplY3QqIG9iamVjdCwgRXhlY1N0 YXRlKiBleGVjLCBQcm9wZXJ0eU5hbWVBcnJheSYgcHJvcGVydHlOYW1lcywgRW51bWVyYXRpb25N b2RlIG1vZGUpCit7CisgICAgSlNDU1NTdHlsZURlY2xhcmF0aW9uKiB0aGlzT2JqZWN0ID0ganND YXN0PEpTQ1NTU3R5bGVEZWNsYXJhdGlvbio+KG9iamVjdCk7CisgICAgQVNTRVJUX0dDX09CSkVD VF9JTkhFUklUUyh0aGlzT2JqZWN0LCAmc19pbmZvKTsKKworICAgIHVuc2lnbmVkIGxlbmd0aCA9 IHRoaXNPYmplY3QtPmltcGwoKS0+bGVuZ3RoKCk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsg aSA8IGxlbmd0aDsgKytpKQorICAgICAgICBwcm9wZXJ0eU5hbWVzLmFkZChJZGVudGlmaWVyOjpm cm9tKGV4ZWMsIGkpKTsKKworICAgIHN0YXRpYyBJZGVudGlmaWVyKiBqc1Byb3BlcnR5SWRlbnRp ZmllcnMgPSAwOworICAgIGlmICghanNQcm9wZXJ0eUlkZW50aWZpZXJzKSB7CisgICAgICAgIFZl Y3RvcjxTdHJpbmcsIG51bUNTU1Byb3BlcnRpZXM+IGpzUHJvcGVydHlOYW1lczsKKyAgICAgICAg Zm9yIChpbnQgaSA9IDA7IGkgPCBudW1DU1NQcm9wZXJ0aWVzOyArK2kpCisgICAgICAgICAgICBq c1Byb3BlcnR5TmFtZXMuYXBwZW5kKGdldEpTUHJvcGVydHlOYW1lKHByb3BlcnR5TmFtZVN0cmlu Z3NbaV0pKTsKKyAgICAgICAgc3RkOjpzb3J0KGpzUHJvcGVydHlOYW1lcy5iZWdpbigpLCBqc1By b3BlcnR5TmFtZXMuZW5kKCksIHN0cmluZ0NvbXBhcmUpOworCisgICAgICAgIGpzUHJvcGVydHlJ ZGVudGlmaWVycyA9IG5ldyBJZGVudGlmaWVyW251bUNTU1Byb3BlcnRpZXNdOworICAgICAgICBm b3IgKGludCBpID0gMDsgaSA8IG51bUNTU1Byb3BlcnRpZXM7ICsraSkgeworICAgICAgICAgICAg U3RyaW5nIGpzUHJvcGVydHlOYW1lID0ganNQcm9wZXJ0eU5hbWVzLmF0KGkpOworICAgICAgICAg ICAganNQcm9wZXJ0eUlkZW50aWZpZXJzW2ldID0gSWRlbnRpZmllcigmZXhlYy0+Z2xvYmFsRGF0 YSgpLCBqc1Byb3BlcnR5TmFtZS5jaGFyYWN0ZXJzKCksIGpzUHJvcGVydHlOYW1lLmxlbmd0aCgp KTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbnVtQ1NTUHJv cGVydGllczsgKytpKQorICAgICAgICBwcm9wZXJ0eU5hbWVzLmFkZChqc1Byb3BlcnR5SWRlbnRp ZmllcnNbaV0pOworCisgICAgQmFzZTo6Z2V0T3duUHJvcGVydHlOYW1lcyh0aGlzT2JqZWN0LCBl eGVjLCBwcm9wZXJ0eU5hbWVzLCBtb2RlKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4Q1NTU3R5bGVE ZWNsYXJhdGlvbkN1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20v VjhDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcAppbmRleCA2NDNmMGZlYTAwMmQ4ZmZlMDA4 ZjkxNjg0ZGY5NWQyN2Y3ZTEyZTRiLi4yNzI2YjI3OWI0NTYzMzExMzJjMTA3Y2IwNWU5ZTJhN2Ux MTdhY2YzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhD U1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy92OC9jdXN0b20vVjhDU1NTdHlsZURlY2xhcmF0aW9uQ3VzdG9tLmNwcApAQCAtMzIsNiArMzIs NyBAQAogI2luY2x1ZGUgIlY4Q1NTU3R5bGVEZWNsYXJhdGlvbi5oIgogCiAjaW5jbHVkZSAiQ1NT UGFyc2VyLmgiCisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgogI2luY2x1ZGUgIkNTU1N0 eWxlRGVjbGFyYXRpb24uaCIKICNpbmNsdWRlICJDU1NWYWx1ZS5oIgogI2luY2x1ZGUgIkNTU1By aW1pdGl2ZVZhbHVlLmgiCkBAIC0xNTIsNiArMTUzLDQyIEBAIHN0YXRpYyBDU1NQcm9wZXJ0eUlu Zm8qIGNzc1Byb3BlcnR5SW5mbyh2ODo6SGFuZGxlPHY4OjpTdHJpbmc+djhQcm9wZXJ0eU5hbWUp CiAgICAgcmV0dXJuIHByb3BJbmZvOwogfQogCit2ODo6SGFuZGxlPHY4OjpBcnJheT4gVjhDU1NT dHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5RW51bWVyYXRvcihjb25zdCB2ODo6QWNjZXNz b3JJbmZvJiBpbmZvKQoreworICAgIHR5cGVkZWYgVmVjdG9yPFN0cmluZywgbnVtQ1NTUHJvcGVy dGllcyAtIDE+IFByZUFsbG9jYXRlZFByb3BlcnR5VmVjdG9yOworICAgIERFRklORV9TVEFUSUNf TE9DQUwoUHJlQWxsb2NhdGVkUHJvcGVydHlWZWN0b3IsIHByb3BlcnR5TmFtZXMsICgpKTsKKyAg ICBERUZJTkVfU1RBVElDX0xPQ0FMKFN0cmluZywgZmlsdGVyU3RyaW5nLCAoImZpbHRlciIpKTsK KyAgICBzdGF0aWMgdW5zaWduZWQgcHJvcGVydHlOYW1lc0xlbmd0aCA9IDA7CisKKyAgICBpZiAo cHJvcGVydHlOYW1lcy5pc0VtcHR5KCkpIHsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBu dW1DU1NQcm9wZXJ0aWVzOyArK2kpIHsKKyAgICAgICAgICAgIFN0cmluZyBqc1Byb3BlcnR5TmFt ZSA9IGdldEpTUHJvcGVydHlOYW1lKHByb3BlcnR5TmFtZVN0cmluZ3NbaV0pOworICAgICAgICAg ICAgLy8gVGhlICJmaWx0ZXIiIHByb3BlcnR5IGlzIHByZXNlbnQgaW4gdGhlIGxpc3QgYnV0IHNo b3VsZCBub3QgYmUgcHJvdmlkZWQgaW4gdGhlIGVudW1lcmF0aW9uLgorICAgICAgICAgICAgLy8g U2VlIGEgY29tbWVudCBpbiB0aGUgVjhDU1NTdHlsZURlY2xhcmF0aW9uOjpuYW1lZFByb3BlcnR5 R2V0dGVyKCkgaW1wbGVtZW50YXRpb24uCisgICAgICAgICAgICAvLyBGSVhNRTogdGhpcyBzaG91 bGQgYmUgcmVtb3ZlZCAoc2VlIGJ1ZyA3MzQyNikuCisgICAgICAgICAgICBpZiAoanNQcm9wZXJ0 eU5hbWUgIT0gZmlsdGVyU3RyaW5nKQorICAgICAgICAgICAgICAgIHByb3BlcnR5TmFtZXMuYXBw ZW5kKGpzUHJvcGVydHlOYW1lKTsKKyAgICAgICAgfQorICAgICAgICBzdGQ6OnNvcnQocHJvcGVy dHlOYW1lcy5iZWdpbigpLCBwcm9wZXJ0eU5hbWVzLmVuZCgpLCBzdHJpbmdDb21wYXJlKTsKKyAg ICAgICAgcHJvcGVydHlOYW1lc0xlbmd0aCA9IHByb3BlcnR5TmFtZXMuc2l6ZSgpOworICAgIH0K KworICAgIHY4OjpIYW5kbGU8djg6OkFycmF5PiBwcm9wZXJ0aWVzID0gdjg6OkFycmF5OjpOZXco cHJvcGVydHlOYW1lc0xlbmd0aCk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHByb3Bl cnR5TmFtZXNMZW5ndGg7ICsraSkgeworICAgICAgICBTdHJpbmcga2V5ID0gcHJvcGVydHlOYW1l cy5hdChpKTsKKyAgICAgICAgQVNTRVJUKCFrZXkuaXNOdWxsKCkpOworICAgICAgICBwcm9wZXJ0 aWVzLT5TZXQodjg6OkludGVnZXI6Ok5ldyhpKSwgdjhTdHJpbmcoa2V5KSk7CisgICAgfQorCisg ICAgcmV0dXJuIHByb3BlcnRpZXM7Cit9CisKK3Y4OjpIYW5kbGU8djg6OkludGVnZXI+IFY4Q1NT U3R5bGVEZWNsYXJhdGlvbjo6bmFtZWRQcm9wZXJ0eVF1ZXJ5KHY4OjpMb2NhbDx2ODo6U3RyaW5n PiB2OE5hbWUsIGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGluZm8pCit7CisgICAgSU5DX1NUQVRT KCJET00uQ1NTU3R5bGVEZWNsYXJhdGlvbi5OYW1lZFByb3BlcnR5UXVlcnkiKTsKKyAgICByZXR1 cm4gdjg6OkludGVnZXI6Ok5ldyh2ODo6Tm9uZSk7Cit9CisKIHY4OjpIYW5kbGU8djg6OlZhbHVl PiBWOENTU1N0eWxlRGVjbGFyYXRpb246Om5hbWVkUHJvcGVydHlHZXR0ZXIodjg6OkxvY2FsPHY4 OjpTdHJpbmc+IG5hbWUsIGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGluZm8pCiB7CiAgICAgSU5D X1NUQVRTKCJET00uQ1NTU3R5bGVEZWNsYXJhdGlvbi5OYW1lZFByb3BlcnR5R2V0dGVyIik7CkBA IC0xNjAsMTQgKzE5NywxMyBAQCB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4gVjhDU1NTdHlsZURlY2xh cmF0aW9uOjpuYW1lZFByb3BlcnR5R2V0dGVyKHY4OjpMb2NhbDx2ODo6UwogICAgICAgICByZXR1 cm4gbm90SGFuZGxlZEJ5SW50ZXJjZXB0b3IoKTsKIAogICAgIC8vIFNlYXJjaCB0aGUgc3R5bGUg ZGVjbGFyYXRpb24uCi0gICAgQ1NTU3R5bGVEZWNsYXJhdGlvbiogaW1wID0gVjhDU1NTdHlsZURl Y2xhcmF0aW9uOjp0b05hdGl2ZShpbmZvLkhvbGRlcigpKTsKICAgICBDU1NQcm9wZXJ0eUluZm8q IHByb3BJbmZvID0gY3NzUHJvcGVydHlJbmZvKG5hbWUpOwogCiAgICAgLy8gRG8gbm90IGhhbmRs ZSBub24tcHJvcGVydHkgbmFtZXMuCiAgICAgaWYgKCFwcm9wSW5mbykKICAgICAgICAgcmV0dXJu IG5vdEhhbmRsZWRCeUludGVyY2VwdG9yKCk7CiAKLQorICAgIENTU1N0eWxlRGVjbGFyYXRpb24q IGltcCA9IFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6dG9OYXRpdmUoaW5mby5Ib2xkZXIoKSk7CiAg ICAgUmVmUHRyPENTU1ZhbHVlPiBjc3NWYWx1ZSA9IGltcC0+Z2V0UHJvcGVydHlDU1NWYWx1ZShw cm9wSW5mby0+cHJvcElEKTsKICAgICBpZiAoY3NzVmFsdWUpIHsKICAgICAgICAgaWYgKHByb3BJ bmZvLT5oYWRQaXhlbE9yUG9zUHJlZml4ICYmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9j c3MvQ1NTU3R5bGVEZWNsYXJhdGlvbi5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9jc3MvQ1NTU3R5bGVE ZWNsYXJhdGlvbi5pZGwKaW5kZXggMmZhNjA5YjEwMWM0ZjM1NTY0NTA3NmJiYmI0NzZkNWQ2OTMz NWI0OC4uZDFiNDcwZjg3NDhjZjI5OWFmYzUxYWY0YTYzM2I0MzQ2YjcyZjQ5ZCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvY3NzL0NTU1N0eWxlRGVjbGFyYXRpb24uaWRsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2Nzcy9DU1NTdHlsZURlY2xhcmF0aW9uLmlkbApAQCAtMjcsNiArMjcsNyBAQCBt b2R1bGUgY3NzIHsKICAgICAgICAgRGVsZWdhdGluZ1B1dEZ1bmN0aW9uLAogICAgICAgICBIYXNO YW1lR2V0dGVyLAogICAgICAgICBIYXNJbmRleEdldHRlciwKKyAgICAgICAgQ3VzdG9tR2V0UHJv cGVydHlOYW1lcywKICAgICAgICAgVjhEZXBlbmRlbnRMaWZldGltZQogICAgIF0gQ1NTU3R5bGVE ZWNsYXJhdGlvbiB7CiAgICAgICAgICAgICAgICAgIGF0dHJpYnV0ZSBbQ29udmVydE51bGxTdHJp bmdUbz1OdWxsLCBDb252ZXJ0TnVsbFRvTnVsbFN0cmluZ10gRE9NU3RyaW5nICAgICAgICBjc3NU ZXh0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9jc3MvbWFrZXByb3AucGwgYi9Tb3VyY2Uv V2ViQ29yZS9jc3MvbWFrZXByb3AucGwKaW5kZXggNDVhZjcxMzNlNjlhMGNmNGIxNWVkYmFiN2Q1 MmQ2NzcwNjUyNGNmZi4uNGM4ZmVlYTVjN2Y0MTBlOGFlMmVlODk1MDI2MmI5OTAyZDc0ZWIwYSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvY3NzL21ha2Vwcm9wLnBsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2Nzcy9tYWtlcHJvcC5wbApAQCAtNjIsOSArNjIsMTEgQEAgb3BlbiBHUEVSRiwgIj5D U1NQcm9wZXJ0eU5hbWVzLmdwZXJmIiB8fCBkaWUgIkNvdWxkIG5vdCBvcGVuIENTU1Byb3BlcnR5 TmFtZXMuZ3AKIHByaW50IEdQRVJGIDw8ICJFT0YiOwogJXsKIC8qIFRoaXMgZmlsZSBpcyBhdXRv bWF0aWNhbGx5IGdlbmVyYXRlZCBmcm9tIENTU1Byb3BlcnR5TmFtZXMuaW4gYnkgbWFrZXByb3As IGRvIG5vdCBlZGl0ICovCisjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSBcIkNTU1Byb3Bl cnR5TmFtZXMuaFwiCiAjaW5jbHVkZSBcIkhhc2hUb29scy5oXCIKICNpbmNsdWRlIDxzdHJpbmcu aD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKICV9CkBAIC0xMTQsNiArMTE2LDI0IEBAIGNvbnN0IGNoYXIqIGdldFByb3BlcnR5TmFt ZShDU1NQcm9wZXJ0eUlEIGlkKQogICAgIHJldHVybiBwcm9wZXJ0eU5hbWVTdHJpbmdzW2luZGV4 XTsKIH0KIAorU3RyaW5nIGdldEpTUHJvcGVydHlOYW1lKGNvbnN0IGNoYXIqIGNzc1Byb3BlcnR5 TmFtZSkKK3sKKyAgICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICBjb25zdCBjaGFyKiBwID0g Y3NzUHJvcGVydHlOYW1lOworICAgIGJvb2wgaXNGaXJzdENoYXIgPSB0cnVlOworICAgIHdoaWxl IChjaGFyIGNoID0gKihwKyspKSB7CisgICAgICAgIGlmIChjaCA9PSAnLScpIHsKKyAgICAgICAg ICAgIGNoYXIgbmV4dENoID0gKihwKyspOworICAgICAgICAgICAgaWYgKCFuZXh0Q2gpCisgICAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICBjaCA9ICFpc0ZpcnN0Q2hhciA/IChuZXh0 Q2ggLSAweDIwKSA6IG5leHRDaDsKKyAgICAgICAgfQorICAgICAgICByZXN1bHQuYXBwZW5kKGNo KTsKKyAgICAgICAgaXNGaXJzdENoYXIgPSBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHJlc3Vs dC50b1N0cmluZygpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiBFT0YKIApAQCAtMTI2 LDYgKzE0Niw4IEBAIHByaW50IEhFQURFUiA8PCAiRU9GIjsKIAogI2luY2x1ZGUgPHN0cmluZy5o PgogCisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAogZW51bSBDU1NQcm9wZXJ0eUlEIHsKQEAgLTE2MCw2ICsxODIsOCBAQCBwcmludCBIRUFE RVIgIn07XG4iOwogcHJpbnQgSEVBREVSIDw8ICJFT0YiOwogCiBjb25zdCBjaGFyKiBnZXRQcm9w ZXJ0eU5hbWUoQ1NTUHJvcGVydHlJRCk7CitTdHJpbmcgZ2V0SlNQcm9wZXJ0eU5hbWUoY29uc3Qg Y2hhciopOworc3RhdGljIGlubGluZSBib29sIHN0cmluZ0NvbXBhcmUoY29uc3QgU3RyaW5nJiBm aXJzdCwgY29uc3QgU3RyaW5nJiBzZWNvbmQpIHsgcmV0dXJuIGNvZGVQb2ludENvbXBhcmUoZmly c3QsIHNlY29uZCkgPCAwOyB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIApkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDY4 MTY3OTQ3ZjRjNWU0NDFjODA1ZGQ1NTFlNDVjZDhiOGYzNjhjODAuLjU4NTNiMTliYjU3N2ZlNmUx NGQyMDU0YWJlOTgyMzU5ZGFhMmJjMWUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxv ZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMS0xMS0z MCAgQWxleGFuZGVyIFBhdmxvdiAgPGFwYXZsb3ZAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFdl YktpdCBkb2VzIG5vdCBlbnVtZXJhdGUgb3ZlciBDU1MgcHJvcGVydGllcyBpbiBIVE1MRWxlbWVu dC5zdHlsZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjM5NDYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IGZhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMuaHRtbDogQWRk ZWQuCisgICAgICAgICogZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVjdGVkLnR4dDoK KyAgICAgICAgKiBmYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9uLmpzOgor CiAyMDExLTEyLTA4ICBUYWthc2hpIFRveW9zaGltYSAgPHRveW9zaGltQGNocm9taXVtLm9yZz4K IAogICAgICAgICBGaXggZmFpbGVkIGxheW91dCB0ZXN0LCBidWZmZXJlZEFtb3VudC1hZnRlci1j bG9zZS1pbi1idXN5Lmh0bWwKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxl LWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3Nz L3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zMWY4 OTg5Y2JkYTA4ZDdjODcyZTc2MDM4ZjdmYTNkMDlhOTE2ZjljCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdCBtYWtlcyBzdXJlIHRoYXQgQ1NTU3R5bGVE ZWNsYXJhdGlvbiBlbnVtZXJhdGVzIEphdmFTY3JpcHQgcHJvcGVydGllcyBmb3IgZGVmaW5lZCBh bmQgbm9uLWRlZmluZWQgQ1NTIHByb3BlcnRpZXMsIGluZGV4ZWQgcHJvcGVydGllcywgYW5kIHBy b3BlcnRpZXMgZGVmaW5lZCBvbiB0aGUgcHJvdG90eXBlLiBTZWUgQnVnIDIzOTQ2LgorUEFTUyBk b2N1bWVudC5ib2R5LnN0eWxlLmxlbmd0aCBpcyAyCitQQVNTICcwJyBpbiBkb2N1bWVudC5ib2R5 LnN0eWxlIGlzIHRydWUKK1BBU1MgJzEnIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQor UEFTUyAndGV4dERlY29yYXRpb24nIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFT UyAnYm9yZGVyVG9wQ29sb3InIGluIGRvY3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAn Ym9yZGVyJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgJ2ZvbnQnIGluIGRv Y3VtZW50LmJvZHkuc3R5bGUgaXMgdHJ1ZQorUEFTUyAnY3NzVGV4dCcgaW4gZG9jdW1lbnQuYm9k eS5zdHlsZSBpcyB0cnVlCitQQVNTICdnZXRQcm9wZXJ0eUNTU1ZhbHVlJyBpbiBkb2N1bWVudC5i b2R5LnN0eWxlIGlzIHRydWUKK1BBU1MgVGhlIENTUyBwcm9wZXJ0eSBvcmRlciBpcyBjb3JyZWN0 CitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvc3R5bGUtZW51bWVyYXRlLXByb3BlcnRpZXMu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1wcm9wZXJ0aWVzLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uN2U4MjhiOWYyY2I0ZmJjY2NhZDdmZDljNzhmMGE3MjZjZDUyNjM2YQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL3N0eWxlLWVudW1lcmF0ZS1w cm9wZXJ0aWVzLmh0bWwKQEAgLTAsMCArMSw0NiBAQAorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9 Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4K KyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworCisgICAgPC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keSBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOiB1bmRlcmxpbmU7IGJvcmRlci10b3At Y29sb3I6IGdyZWVuIj4KKyAgICA8ZGl2IGlkPSJkZXNjcmlwdGlvbiI+VGhpcyB0ZXN0IG1ha2Vz IHN1cmUgdGhhdCBDU1NTdHlsZURlY2xhcmF0aW9uIGVudW1lcmF0ZXMgSmF2YVNjcmlwdCBwcm9w ZXJ0aWVzIGZvciBkZWZpbmVkIGFuZCBub24tZGVmaW5lZCBDU1MgcHJvcGVydGllcywgaW5kZXhl ZCBwcm9wZXJ0aWVzLCBhbmQgcHJvcGVydGllcyBkZWZpbmVkIG9uIHRoZSBwcm90b3R5cGUuIFNl ZSA8YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM5NDYi PkJ1ZyAyMzk0NjwvYT4uPC9kaXY+CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisgICAg PHNjcmlwdD4KKyAgICAgICAgc2hvdWxkQmUoImRvY3VtZW50LmJvZHkuc3R5bGUubGVuZ3RoIiwg IjIiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInMCcgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIp OworICAgICAgICBzaG91bGRCZVRydWUoIicxJyBpbiBkb2N1bWVudC5ib2R5LnN0eWxlIik7Cisg ICAgICAgIHNob3VsZEJlVHJ1ZSgiJ3RleHREZWNvcmF0aW9uJyBpbiBkb2N1bWVudC5ib2R5LnN0 eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2JvcmRlclRvcENvbG9yJyBpbiBkb2N1bWVu dC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2JvcmRlcicgaW4gZG9jdW1l bnQuYm9keS5zdHlsZSIpOworICAgICAgICBzaG91bGRCZVRydWUoIidmb250JyBpbiBkb2N1bWVu dC5ib2R5LnN0eWxlIik7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiJ2Nzc1RleHQnIGluIGRvY3Vt ZW50LmJvZHkuc3R5bGUiKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCInZ2V0UHJvcGVydHlDU1NW YWx1ZScgaW4gZG9jdW1lbnQuYm9keS5zdHlsZSIpOworCisgICAgICAgIC8vIFRlc3QgQ1NTIHBy b3BlcnR5IG9yZGVyLgorICAgICAgICB2YXIgc3RhcnRlZDsKKyAgICAgICAgdmFyIGNzc1Byb3Bl cnR5Q291bnQgPSAwOworICAgICAgICB2YXIgcHJldmlvdXM7CisgICAgICAgIGZvciAodmFyIHAg aW4gZG9jdW1lbnQuYm9keS5zdHlsZSkgeworICAgICAgICAgICAgaWYgKHAgPT09ICJhbGlnbm1l bnRCYXNlbGluZSIpCisgICAgICAgICAgICAgICAgc3RhcnRlZCA9IHRydWU7CisgICAgICAgICAg ICBpZiAoIXN0YXJ0ZWQpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBp ZiAocHJldmlvdXMgJiYgcHJldmlvdXMgPj0gcCkgeworICAgICAgICAgICAgICAgIHRlc3RGYWls ZWQoIkludmFsaWQgQ1NTLW1hcHBlZCBwcm9wZXJ0eSBvcmRlcjogJyIgKyBwICsgIicgYWZ0ZXIg JyIgKyBwcmV2aW91cyArICInIik7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAg ICB9CisgICAgICAgICAgICBpZiAoKytjc3NQcm9wZXJ0eUNvdW50IDw9IDEwMCkKKyAgICAgICAg ICAgICAgICBwcmV2aW91cyA9IHA7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgICAg ICB0ZXN0UGFzc2VkKCJUaGUgQ1NTIHByb3BlcnR5IG9yZGVyIGlzIGNvcnJlY3QiKTsKKyAgICAg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIDwvc2NyaXB0 PgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3Nj cmlwdD4KKzwvYm9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxpc3RF bnVtZXJhdGlvbi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kb21MaXN0RW51 bWVyYXRpb24tZXhwZWN0ZWQudHh0CmluZGV4IDcyMmJhMDc5NzE5YTQ2Y2ZiNTA0NDkyYTc2NWFl MzEwYTE2YmY4YTUuLjljYTk3ZWM1NzU5MTA1NDA4MTQ1ZjNkYzg5MmFhYjA5MzBkM2M3OTggMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RvbUxpc3RFbnVtZXJhdGlvbi1leHBlY3Rl ZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vZG9tTGlzdEVudW1lcmF0aW9uLWV4cGVj dGVkLnR4dApAQCAtNjYsNyArNjYsNiBAQCBQQVNTIHJlc3VsdEFycmF5WzJdLmkgaXMgJzInCiBQ QVNTIHJlc3VsdEFycmF5WzJdLml0ZW0gaXMgY3NzUnVsZUxpc3QuaXRlbSgyKQogCiBbb2JqZWN0 IENTU1N0eWxlRGVjbGFyYXRpb25dCi1QQVNTIHJlc3VsdEFycmF5Lmxlbmd0aCBpcyAxNAogUEFT UyByZXN1bHRBcnJheVswXS5pIGlzICcwJwogUEFTUyByZXN1bHRBcnJheVswXS5pdGVtIGlzIGNz c1N0eWxlRGVjbGFyYXRpb24uaXRlbSgwKQogUEFTUyByZXN1bHRBcnJheVsxXS5pIGlzICcxJwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVt ZXJhdGlvbi5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NjcmlwdC10ZXN0cy9kb21MaXN0RW51 bWVyYXRpb24uanMKaW5kZXggYTA5OWM4MzU2M2Y4M2UwMGQ1MzQ2ZmM4YzM3NmI4Y2JkZmM1Y2M5 Ni4uN2E5ODc1NTE3YWYyMjk5ZGExODE3M2MzZGU1YzFiYjg4MDFhNjExZSAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vc2NyaXB0LXRlc3RzL2RvbUxpc3RFbnVtZXJhdGlvbi5qcwor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zY3JpcHQtdGVzdHMvZG9tTGlzdEVudW1lcmF0aW9u LmpzCkBAIC0xNzMsNyArMTczLDYgQEAgc2hvdWxkQmUoInJlc3VsdEFycmF5WzJdLml0ZW0iLCAi Y3NzUnVsZUxpc3QuaXRlbSgyKSIpOwogLy9kZWJ1Zyhlc2NhcGVIVE1MKGRvY3VtZW50LmdldEVs ZW1lbnRzQnlUYWdOYW1lKCdzdHlsZScpKSk7CiB2YXIgY3NzU3R5bGVEZWNsYXJhdGlvbiA9IGRv Y3VtZW50LnN0eWxlU2hlZXRzWzJdLmNzc1J1bGVzWzBdLnN0eWxlOwogcmVzdWx0QXJyYXkgPSBp dGVyYXRlTGlzdChjc3NTdHlsZURlY2xhcmF0aW9uKTsKLXNob3VsZEJlKCJyZXN1bHRBcnJheS5s ZW5ndGgiLCAiMTQiKTsKIHNob3VsZEJlKCJyZXN1bHRBcnJheVswXS5pIiwgIicwJyIpOwogc2hv dWxkQmUoInJlc3VsdEFycmF5WzBdLml0ZW0iLCAiY3NzU3R5bGVEZWNsYXJhdGlvbi5pdGVtKDAp Iik7CiBzaG91bGRCZSgicmVzdWx0QXJyYXlbMV0uaSIsICInMSciKTsK