18994 2008-05-11 01:43:22 -0700 LANG/LC_ALL influences the result of element.style.opacity 2010-10-17 13:07:26 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) All All RESOLVED FIXED Cairo, Gtk P2 Major --- 30238 47467 47493 47538 47584 47664 47714 43832 1 digulla webkit-unassigned adele alp andreas.hocevar ap a.renevier barraclough commit-queue darin dglazkov dysinscr eric evan hausmann jshin kevino krit laszlo.gombos simon.fraser vincent.alquier webkit.review.bot xan.lopez zajec5 zimmermann oldest_to_newest 80112 0 digulla 2008-05-11 01:43:22 -0700 For some reason, the fading of the editingToolbar demo (go to http://webkit.org/demos/editingToolbar/ and click on the text) is broken on my system with r33026. The effect is that the toolbar appears but stops at opacity 0.1. The UI is sluggish after that which indicates an infinite loop. After some prodding at the code in FancyToolbar.js, I'm pretty sure that the bug is somewhere in FancyToolbar.prototype.animateToolbar(). Is there a way to log something to the console so I can figure out why the opacity doesn't change anymore after the first loop? 80118 1 ap 2008-05-11 03:19:26 -0700 I couldn't reproduce with r33029 nightly. 80120 2 digulla 2008-05-11 03:35:32 -0700 I had the same reply from someone from the Qt/Trolltech team. My guess is that there is some incompatibility with my system (openSUSE 10.3, X11 7.2-143.11, libXrender-7.2-65, gcc 4.2 24, NVIDIA-Linux-x86_64-169.09). r33026 and 33030 don't seem to contain changes which might influence this. I'd like to put some log statements into FancyToolbar.prototype.animateToolbar() to see where it clogs. How do I do that? 80129 3 dev+webkit 2008-05-11 06:32:27 -0700 (In reply to comment #2) > I'd like to put some log statements into > FancyToolbar.prototype.animateToolbar() to see where it clogs. How do I do > that? > console.log() will log to the JS console, but depending on which port you're using, that may require some minor work in ChromeClient to actually get logged somewhere. 80131 4 digulla 2008-05-11 08:25:14 -0700 Okay, I found it. On my system, LANG is "de_DE.UTF-8". So I see this in the console: this.toolbarElement.style.opacity=0,1 parseFloat("0,1") returns 0 (it expects "0.1"), so the value stays at "0.1" plus I get a nice busy loop. When I set LANG=C, the example works as expected. So the problem is that float values returned by querying properties are formatted according to the locale. I don't think that this is a good idea. 80168 5 ap 2008-05-12 04:58:32 -0700 These numbers are formatted with vsnprintf in WebCore::String::format(). Should be easy to fix by using vsnprintf_l - but does Linux have this or equivalent functionality? 80211 6 digulla 2008-05-12 12:09:18 -0700 I couldn't find anything :/ I doubt that glibc offers this after finally offering automatic locale specific formatting. Why does the parseDouble() function expect "." even when the locale specifies ","? Also, I wonder what a fix in String::format() would break. Will it work for JavaScript, too? Like: var x = 1.5; var s = "" + x; assert "1.5" == s; My next idea was to set LANG/LC_ALL in the startup script but that would break if someone would embed WebKit in an application. Or we could patch the field "decimal_point" in "struct lconv". But that might introduce even more hideous bugs during embedding, especially when threads are used. Which leads to another question: Might the web developer want to *show* float values to the user? In this case, which locale should be used to format them? C? The locale of the page? The locale in which the browser runs? Argh... a Pandora Bug! If everyone was using String::number(double) to format double values, we could replace "," by "." in there. But that isn't very safe as long as String::format() is not private (someone might try to format double values manually, for example in a more complex format string). The GNU header file locale.h mentions that there is some proof of concept code to allow per-thread locales. But I'm not sure how fast this is (i.e. getting the current locale, replace it with C, set it back after the double value has been formatted). *sigh* It would be easier if style.opacity would simply return a double value :) I'll keep my eyes open for a solution for this but half an hour on Google didn't turn anything really useful up. Maybe ask the glibc maintainers for help? 80217 7 ap 2008-05-12 12:54:15 -0700 (In reply to comment #6) > Why does the parseDouble() function expect "." even when the locale specifies > ","? Well, a script downloaded from the Web can always pass a double as a literal string, so we should worry about that case, too, not just round-tripping. User locale should have no effect on scripts, except for methods that are specifically documented as locale-sensitive. > Also, I wonder what a fix in String::format() would break. On Mac OS X, locale does not affect printf/scanf by default, so such a fix is unlikely to cause any problems. > Will it work for JavaScript, too? No, Platform::String is not used in JavaScriptCore. I am not aware of similar bugs remaining in JavaScriptCore (although there used to be some, see bug 16162). > My next idea was to set LANG/LC_ALL in the startup script but that would break > if someone would embed WebKit in an application. Precisely. > Or we could patch the field "decimal_point" in "struct lconv". But that might > introduce even more hideous bugs during embedding, especially when threads are > used. Ugh, I was assuming that locale was per-thread on Linux, and thought of this as the most promising approach. > Which leads to another question: Might the web developer want to *show* float > values to the user? In this case, which locale should be used to format them? > C? The locale of the page? The locale in which the browser runs? ECMAScript-262 talks about "host environment's current locale" (see e.g. 15.5.4.9), which is what JavaScriptCore does. Other specifications have different approaches, which are not always explicitly spelled out and which we don't always fully implement yet. But let's keep discussion in this bug focused on the specific issue at hand! > I'll keep my eyes open for a solution for this but half an hour on Google > didn't turn anything really useful up. Maybe ask the glibc maintainers for > help? Sounds like a good idea. I would also expect that Qt/gtk/wx have their solutions for this issue, which we could potentially use. 80955 8 ap 2008-05-20 00:03:37 -0700 See also: bug 18985. 81012 9 krit 2008-05-20 12:11:46 -0700 (In reply to comment #6) > I couldn't find anything :/ I doubt that glibc offers this after finally > offering automatic locale specific formatting. > > Why does the parseDouble() function expect "." even when the locale specifies > ","? > > Also, I wonder what a fix in String::format() would break. Will it work for > JavaScript, too? Like: > > var x = 1.5; > var s = "" + x; > assert "1.5" == s; > > My next idea was to set LANG/LC_ALL in the startup script but that would break > if someone would embed WebKit in an application. > > Or we could patch the field "decimal_point" in "struct lconv". But that might > introduce even more hideous bugs during embedding, especially when threads are > used. > > Which leads to another question: Might the web developer want to *show* float > values to the user? In this case, which locale should be used to format them? > C? The locale of the page? The locale in which the browser runs? > > Argh... a Pandora Bug! > > If everyone was using String::number(double) to format double values, we could > replace "," by "." in there. But that isn't very safe as long as > String::format() is not private (someone might try to format double values > manually, for example in a more complex format string). > > The GNU header file locale.h mentions that there is some proof of concept code > to allow per-thread locales. But I'm not sure how fast this is (i.e. getting > the current locale, replace it with C, set it back after the double value has > been formatted). > > *sigh* It would be easier if style.opacity would simply return a double value > :) > > I'll keep my eyes open for a solution for this but half an hour on Google > didn't turn anything really useful up. Maybe ask the glibc maintainers for > help? > It's not only the decimal-point: (from man printf) For some numeric conversions a radix character (‘decimal point’) or thousands’ grouping character is used. The actual character used depends on the LC_NUMERIC part of the locale. The POSIX locale uses ‘.’ as radix character, and does not have a grouping character. Thus, printf("%’.2f", 1234567.89); results in ‘1234567.89’ in the POSIX locale, in ‘1234567,89’ in the nl_NL locale, and in ‘1.234.567,89’ in the da_DK locale. 83449 10 hausmann 2008-06-16 05:40:20 -0700 (In reply to comment #5) > These numbers are formatted with vsnprintf in WebCore::String::format(). Should > be easy to fix by using vsnprintf_l - but does Linux have this or equivalent > functionality? Hmm, as far as I can see the numbers parsed by the lexer of the CSS parser are formatted with WebCore::charactersToDouble. This function, implemented in platform/text/String.cpp uses KJS::strtod for the conversion, which is locale safe. In fact I'm having trouble to reproduce this bug now with trunk. 83462 11 ap 2008-06-16 07:58:14 -0700 See e.g. CSSPrimitiveValue::cssText(), which uses String::format(). I think that this should still be reproducible on Linux. 83915 12 digulla 2008-06-19 13:55:59 -0700 As of rev 34662, the bug is fixed on Linux. Did you add a test case to make sure opacity is never formatted with a comma? 83955 13 krit 2008-06-20 01:31:50 -0700 (In reply to comment #12) > As of rev 34662, the bug is fixed on Linux. I still get the problem, like described in the first comment. And String::format() is a general problem. Some more files where String::format is used with float: FTPDirectoryDocument.cpp PathCairo.cpp SVGUseElement.cpp SVGUseElement: see https://bugs.webkit.org/show_bug.cgi?id=18985 84487 14 hausmann 2008-06-26 10:54:10 -0700 For the Qt port we could implement String::format using QString::vsprintf. 88392 15 hausmann 2008-08-13 06:16:55 -0700 For the Qt port we have switched to the locale-independent QString::vsprintf in String::format in revision 35712 91043 16 ap 2008-09-13 07:28:45 -0700 Eventually, we need a cross-platform solution. Although this doesn't affect Safari, this is still a problem even on Mac OS X for 3rd party clients that may call setlocale(). 91295 17 alp 2008-09-15 18:48:18 -0700 Alexey, could we use the string formatting/parsing features provided by ICU here? This would also have the benefit of working directly in UChars. 91352 18 23471 alp 2008-09-16 07:18:07 -0700 Created attachment 23471 Deprecate String::format() Use UString::from() instead of String::format() in String::number() functions where possible. Start to replace uses of String::format() in WebCore with StringBuilder and direct concatenation. As a side-effect, several incorrect or needless string conversions that were done by String::format() callers are now avoided. String::format() should not be used in new code. Note: These changes need to be checked for regressions with the Mac layout tests before going in. 91355 19 alp 2008-09-16 07:36:42 -0700 This patch converts most, but not all String::format() callers to instead build strings directly. There are still ~50 calls yet to be ported (listed below) though the remaining ones are low-risk (no float/double formatting). It'd be great to drop String::format() completely or move it well out of the way some day since it clearly leads to sloppy code. WebCore/css/CSSParser.cpp: String str = String::format("%06d", (int)(value->fValue+.5)); WebCore/dom/StyledElement.cpp: color = String::format("#%02x%02x%02x", colors[0], colors[1], colors[2]); WebCore/page/Console.cpp: String message = String(title) + String::format(": %.0fms", elapsed); WebCore/storage/DatabaseTracker.cpp: filename = pathByAppendingComponent(originPath, String::format("%016llx.db", seq)); WebCore/storage/DatabaseTracker.cpp: if (!addDatabase(origin, name, String::format("%016llx.db", seq))) WebCore/loader/FTPDirectoryDocument.cpp: return String::format("%.2f KB", static_cast<float>(bytes)/1000); WebCore/loader/FTPDirectoryDocument.cpp: return String::format("%.2f MB", static_cast<float>(bytes)/1000000); WebCore/loader/FTPDirectoryDocument.cpp: return String::format("%.2f GB", static_cast<float>(bytes)/1000000000); WebCore/loader/FTPDirectoryDocument.cpp: timeOfDay = String::format(", %i:%02i AM", hour, fileTime.tm_min); WebCore/loader/FTPDirectoryDocument.cpp: timeOfDay = String::format(", %i:%02i PM", hour, fileTime.tm_min); WebCore/loader/FTPDirectoryDocument.cpp: dateString = String::format("%s %i, %i", months[month], fileTime.tm_mday, fileTime.tm_year); WebCore/loader/FTPDirectoryDocument.cpp: dateString = String::format("%s %i, %i", months[month], fileTime.tm_mday, now.tm_year); WebCore/loader/archive/cf/LegacyWebArchive.cpp: String iframeMarkup = String::format("<iframe frameborder=\"no\" marginwidth=\"0\" marginheight=\"0\" width=\"98%%\" height=\"98%%\" src=\"%s\"></iframe>", WebCore/platform/qt/PlatformKeyboardEventQt.cpp: return String::format("U+%04X", toupper(keyCode)); WebCore/platform/wx/KeyboardEventWx.cpp: return String::format("U+%04X", toupper(keyCode)); WebCore/platform/gtk/KeyEventGtk.cpp: return String::format("U+%04X", gdk_keyval_to_unicode(gdk_keyval_to_upper(keyCode))); WebCore/platform/mac/KeyEventMac.mm: return String::format("U+%04X", toASCIIUpper(c)); WebCore/platform/sql/SQLiteDatabase.cpp: executeCommand(String::format("PRAGMA synchronous = %i", sync)); WebCore/platform/win/ClipboardUtilitiesWin.cpp: append(result, String::format(header, startHTMLOffset, endHTMLOffset, startFragmentOffset, endFragmentOffset).utf8()); WebCore/platform/win/GDIObjectCounter.cpp: init(String::format("%s (%p)", className.latin1().data(), instance)); WebCore/platform/win/Language.cpp: computedDefaultLanguage = String::format("%s-%s", languageName.latin1().data(), countryName.latin1().data()); WebCore/platform/win/KeyEventWin.cpp: return String::format("U+%04X", toASCIIUpper(keyCode)); WebCore/platform/text/String.cpp:String String::format(const char *format, ...) WebCore/platform/text/String.cpp: return String::format("%d", n); WebCore/platform/text/String.cpp: return String::format("%u", n); WebCore/platform/text/String.cpp: return String::format("%ld", n); WebCore/platform/text/String.cpp: return String::format("%lu", n); WebCore/platform/text/String.cpp: return String::format("%I64i", n); WebCore/platform/text/String.cpp: return String::format("%lli", n); WebCore/platform/text/String.cpp: return String::format("%I64u", n); WebCore/platform/text/String.cpp: return String::format("%llu", n); WebCore/platform/text/String.cpp: return String::format("%.6lg", n); WebCore/platform/graphics/cg/ImageBufferCG.cpp: return String::format("data:%s;base64,%s", mimeType.utf8().data(), out.data()); WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm: String text = String::format("%1.2f", frameRate); WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeWin.cpp: String text = String::format("%1.2f", frameRate); WebCore/platform/graphics/cairo/PathCairo.cpp: string += String::format("M %.2f,%.2f", WebCore/platform/graphics/cairo/PathCairo.cpp: string += String::format("L %.2f,%.2f", WebCore/platform/graphics/cairo/PathCairo.cpp: string += String::format("C %.2f,%.2f,%.2f,%.2f,%.2f,%.2f", WebCore/platform/graphics/Color.cpp: return String::format("#%02X%02X%02X%02X", red(), green(), blue(), alpha()); WebCore/platform/graphics/Color.cpp: return String::format("#%02X%02X%02X", red(), green(), blue()); WebCore/rendering/RenderMedia.cpp: return String::format("%02d:%02d:%02d", hours, minutes, seconds); WebCore/rendering/RenderTreeAsText.cpp: String hex = String::format("\\x{%X}", u); WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp: return String::format("%s %s", name.sysname, name.machine); WebKit/win/WebKitStatistics.cpp: append(vector, String::format("%4u", current->second)); WebKit/win/WebCoreSupport/WebInspectorClient.cpp: // FIXME: The series of appends should be replaced with a call to String::format() WebKit/win/WebView.cpp: osVersion = String::format("Windows NT %d.%d", versionInfo.dwMajorVersion, versionInfo.dwMinorVersion); WebKit/win/WebView.cpp: osVersion = String::format("Windows %d.%d", versionInfo.dwMajorVersion, versionInfo.dwMinorVersion); WebKit/win/WebView.cpp: m_userAgentStandard = String::format("Mozilla/5.0 (Windows; U; %s; %s) AppleWebKit/%s (KHTML, like Gecko)%s%s", osVersion().latin1().data(), defaultLanguage().latin1().data(), webKitVersion().latin1().data(), (m_applicationName.length() ? " " : ""), m_applicationName.latin1().data()); 91379 20 23471 darin 2008-09-16 10:06:28 -0700 Comment on attachment 23471 Deprecate String::format() I think it's a great idea to do this and the patch looks great. But we need to make sure the new idiom is at least as fast as the old or faster. If we're going to write new code for many call sites I want to be sure it's designed to be fast enough that we won't have to visit them all again to rewrite them again. + String message = "Unsafe JavaScript attempt to access frame with URL "; + message += targetURL.string(); + message += " from frame with URL "; + message += originURL.string(); + message += ". Domains, protocols and ports must match.\n"; + return message; This is a bad idiom for performance. The String class is very slow to append to, so changing calls that previously used String::format to code that uses String appends is not generally a good idea, unless the code is not at all performance critical. I'm concerned that overall this is going to slow things down. Idioms that are fast are using StringBuffer or Vector<UChar> to create the string and then String::adopt to make a String out of it. - text = String::format("%.6lg%%", m_value.num); + text = String::number(m_value.num) + "%"; Same thing here. Given the String implementation, this is a particularly inefficient idiom and I'd prefer not to add lots of instances of it without considering performance. - String m_errorMessages; + StringBuilder m_errorMessages; This is the right idea! Although I do slightly prefer Vector<UChar> (see below). String String::number(unsigned n) { +#if USE(JSC) + return String(UString::from(n)); +#else return String::format("%u", n); +#endif } The above is not efficient because it involves allocating an unnecessary temporary UString. We need to make these numeric conversions operations efficient. I think we need a form of number formatting that appends to a Vector<UChar> or a StringBuffer or both, and we also want String::number() to be efficient for the occasions where we really do need to create an entire String out of a number. We should consider what we need to do in JavaScriptCore to offer the right kind of efficient numeric conversion for use elsewhere without requiring allocation of a UString for the result. + // TODO: Use UString::from() return String::format("%lu", n); Why is that still a TODO? - String statusLine = String::format("HTTP %lu OK\n", m_resourceResponse.httpStatusCode()); + String statusLine = "HTTP "; + statusLine += String::number(static_cast<unsigned>(m_resourceResponse.httpStatusCode())); + statusLine += " OK\n"; stringBuilder.append(statusLine.characters(), statusLine.length()); Here we need to append right to the stringBuilder local variable, not go out of our way to instead create a String. I also don't understand the reason for the static_cast. That seems wrong. I think we should standardize on either StringBuilder or Vector<UChar> (sorry that there are two!). I personally prefer Vector<UChar> because StringBuilder forces us to allocate separate strings for each piece, whereas Vector<UChar> uses a single buffer. On the other hand, StringBuilder has a more attractive name and is more clearly for this purpose. Maybe we can improve StringBuilder so that it is as efficient as Vector<UChar> when the pieces to append aren't already in WebCore::String objects and then we don't have a difficult choice. Anyway, we would add an operation for appending a formatted number to a Vector<UChar> or StringBuilder. And then convert the String::format call sites to that approach. Sorry, I'm not trying to be difficult; but if we're going to rewrite these I'd really like the new idiom to be as efficient as possible. I hope this doesn't make the task take too long! I'd love to hear your thoughts. 91613 21 alp 2008-09-18 03:08:37 -0700 (In reply to comment #20) > Idioms that are fast are using StringBuffer or Vector<UChar> to create the > string and then String::adopt to make a String out of it. How about using TextStream.h? Although it uses snprintf() now it looks like it has good optimisation potential, as long as code like this isn't objectionable: ts << "text run at (" << run.m_x << "," << run.m_y << ") width " << run.m_width; Right now TextStream is only used by RenderTreeAsText and a couple of places in SVG. If we go this way we'll need to extend TextStream to choose the decimal precision when formatting doubles etc. 91641 22 darin 2008-09-18 09:15:43 -0700 (In reply to comment #21) > How about using TextStream.h? Although it uses snprintf() now it looks like it > has good optimisation potential, as long as code like this isn't objectionable: Yes, that'd be OK. I do worry that we end up with too many different options, between Vector<UChar>, StringBuffer, and TextStream. I was hoping to phase out TextStream. If we can make it efficient and a great option then I think many will like using the stream-style syntax. I don't think the name of TextStream is very clear -- the fact that it's for constructing a string seems subtle. Maybe we can add the streaming syntax to StringBuffer instead? 129928 23 jmalonzo 2009-07-06 04:39:22 -0700 *** Bug 26984 has been marked as a duplicate of this bug. *** 150539 24 evan 2009-09-28 09:41:41 -0700 This came up on the Chrome bug tracker: http://code.google.com/p/chromium/issues/detail?id=22782 Same issue as above. Since we're not the Qt port, String::format is still locale-dependent. I will try to create a layout test for this. 151404 25 40411 evan 2009-09-30 17:36:34 -0700 Created attachment 40411 patch v1 151405 26 evan 2009-09-30 17:37:33 -0700 I've attached a patch for consideration -- it doesn't quite work yet, the style's wrong, but feedback on the general approach is appreciated. I'm new to this WebKit stuff. 151409 27 evan 2009-09-30 17:43:40 -0700 Eric explained to me the multitude of ways in which I fail. I will post a reasonable patch later, please disregard that last one. 152384 28 40646 evan 2009-10-05 11:18:39 -0700 Created attachment 40646 patch 152386 29 evan 2009-10-05 11:20:21 -0700 Ok, please take a look at my new patch. I will now try to verify the test fails on a WebKitGtk build. 152399 30 40648 evan 2009-10-05 11:45:49 -0700 Created attachment 40648 patch 152400 31 40649 evan 2009-10-05 11:48:20 -0700 Created attachment 40649 add a regression test 152401 32 evan 2009-10-05 11:49:34 -0700 Since last review: - eliminated tabs - setLocale -> setPOSIXLocale - reset locale in platform-specific resetter functions rather than in layout test 152459 33 40662 evan 2009-10-05 14:32:36 -0700 Created attachment 40662 add a regression test 152460 34 evan 2009-10-05 14:34:13 -0700 I have now verified this fails on Linux in the expected way. I also upped the locale buffer size on recommendation from kov in #webkit-gtk. I think this is ready to go. 152736 35 40662 eric 2009-10-06 08:35:22 -0700 Comment on attachment 40662 add a regression test I would have wrapped: setlocale(LC_ALL, ""); into some shared: resetToDefaultPOSIXLocale() function or similar. But in general this looks fine. 152798 36 evan 2009-10-06 11:32:35 -0700 Out of curiosity, I ran the existing layout tests from a German (commas for decimals) locale under Chrome on Linux. I had 412 tests fail (but some of them are due to differing plugins on my system vs our tester bots...); many of the locale-caused failures were under svg, but also a random set of others. Here are a few selections, just to give you a feel for it: LayoutTests/fast/text/shadow-translucent-fill.html = FAIL LayoutTests/transforms/2d/transform-2d.html = FAIL LayoutTests/animations/matrix-anim.html = FAIL 152863 37 40662 commit-queue 2009-10-06 14:31:31 -0700 Comment on attachment 40662 add a regression test Rejecting patch 40662 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--quiet', '--exit-after-n-failures=1']" exit_code: 1 Running build-dumprendertree Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Testing 11396 test cases. fast/css/opacity-float.html -> failed Exiting early after 1 failures. 5136 tests run. 90.65s total testing time 5135 test cases (99%) succeeded 1 test case (<1%) had incorrect layout 1 test case (<1%) had stderr output 152890 38 evan 2009-10-06 16:00:25 -0700 It seems the reason this failed is that OS X is vulnerable to the same problem other platforms are. I suspect the reason it hasn't happened in the past is apparently people don't call setlocale() in normal OS X apps. (?) So I think the test can't be checked in until WebKit is setlocale() safe. 152891 39 darin 2009-10-06 16:12:36 -0700 The test can be checked in with an expected failure. 152892 40 40749 evan 2009-10-06 16:32:36 -0700 Created attachment 40749 add a regression test 152894 41 40749 evan 2009-10-06 16:33:08 -0700 Comment on attachment 40749 add a regression test with mac expected-fail baseline 152909 42 40753 evan 2009-10-06 18:04:32 -0700 Created attachment 40753 start patching out CSS floats with a Vector<UChar> 152912 43 40753 evan 2009-10-06 18:06:53 -0700 Comment on attachment 40753 start patching out CSS floats with a Vector<UChar> Hey Darin, Could you take a glance at this and see if it's in the direction of where you were suggesting Alp go? Obviously I'd need to relocate these functions to the appropriate places. Note that dtoa works with chars so we need to do a conversion step when we use it, so appending a letter at a time to the uchar vector doesn't seem so horrible. However, the matrix line that I highlighted in the patch probably does call for some sort of builder class. I looked at the existing classes you mentioned but it's not clear to me what the right thing to do is. 153054 44 40753 darin 2009-10-07 08:44:23 -0700 Comment on attachment 40753 start patching out CSS floats with a Vector<UChar> General direction looks right here. I agree there's no obvious way to use a builder class for the matrix case. Instead, I suggest you write the code out longhand, including some way to reserve the capacity for the string, and then consider how to factor it into some kind of builder afterward. I think we should consider eliminating String::format entirely. 153110 45 40749 commit-queue 2009-10-07 10:48:01 -0700 Comment on attachment 40749 add a regression test Clearing flags on attachment: 40749 Committed r49253: <http://trac.webkit.org/changeset/49253> 153111 46 commit-queue 2009-10-07 10:48:07 -0700 All reviewed patches have been landed. Closing bug. 153116 47 evan 2009-10-07 10:53:30 -0700 Reopening because the commitbot is overzealous -- I just had provided a test. :) 153125 48 eric 2009-10-07 11:21:41 -0700 Yeah, the commit-queue has no concept of "land this and keep the bug open". It assumes a one-patch-per-bug workflow. There is at least bug 28230 filed on this. 153212 49 40828 evan 2009-10-07 16:41:12 -0700 Created attachment 40828 use dtoa directly in CSS units 153213 50 40828 evan 2009-10-07 16:44:49 -0700 Comment on attachment 40828 use dtoa directly in CSS units This fixes both of the tests I recently added, but doesn't resolve this bug completely. I'd prefer to write more failing tests before I speculatively touch other parts of the code. LayoutTests/fast/css/opacity-float.html LayoutTests/fast/css/large-number-round-trip.html Note that this changes the output for a few other tests, which I'll need to regenerate baselines for. The TextStream logging functions have slightly different output requirements than the CSS output ones do. :( The changes will change DumpRenderTree outputs like this: RenderBody {BODY} at (8,8) size 784x584 - RenderBlock {DIV} at (0,0) size 784x152 [textFillColor=#800080] [textStrokeWidth=2.00] + RenderBlock {DIV} at (0,0) size 784x152 [textFillColor=#800080] [textStrokeWidth=2] RenderText {#text} at (0,1) size 755x149 text run at (0,1) width 612: "Purple\x{300} fill, black stroke," text run at (0,77) width 755: "complex text, black underline" - RenderBlock {DIV} at (0,152) size 784x152 [textStrokeColor=#FFA500] [textStrokeWidth=1.33] + RenderBlock {DIV} at (0,152) size 784x152 [textStrokeColor=#FFA500] [textStrokeWidth=1.3] I don't know what you think of that. 153214 51 evan 2009-10-07 16:52:52 -0700 Having thought about this for a day (I've had the patch for a while), I fear that it will be difficult to share code for this appendFloat function; the output required by CSS (max 6 significant digits, no exponents) is different than the output apparently produced by TextStream (min 2 digits after the decimal). I can add more options to appendFloat but maybe that gets us back into performance worry territory. Another option is to just write a specific implementation of it for each call site. 153215 52 40828 darin 2009-10-07 16:54:00 -0700 Comment on attachment 40828 use dtoa directly in CSS units > +void appendDouble(Vector<UChar>& vector, double value, int digits) > +{ > + // From the CSS specification section titled "Integers and real numbers", > + // real numbers are only formatted as [sign] [digits] "." [digits], with > + // no special handling of exponents, NaN, etc. This is a confusing thing to say here. This says what the specification says, but not what the function does. What does this function do for NaN and exponents and such? Should it simply never be called on such numbers? Don't leave us hanging! I think the name of this function should contain the words CSS if the behavior is something driven by the CSS specification. The name appendDouble makes it sound more general-purpose. Or maybe there is a term of art for this type of numeric formatting? Sounds fine for CSS, but doesn't this change the behavior of the TextStream operators? Why is that OK? Do we have test coverage for those? Including edge cases like exponents, infinity, and NAN? > + vector.reserveCapacity(vector.size() + length + 2); Where does the 2 come from here? From reading the code below it looks like you can have a lot more characters than "length" added. Can we do the reserveCapacity completely accurately instead of approximately? Do we have test cases that cover all the branches of the appendDouble function? I'll say review- because of some of the comments above, but this looks really good and on the right track. 153218 53 darin 2009-10-07 16:59:52 -0700 (In reply to comment #51) > I can add more options to appendFloat but maybe that gets us back into > performance worry territory. I'm not too worried about that. More options would probably be OK. It's more of a clarity than performance issue, in my opinion. As far as regression test output is concerned, the best approach is to not change that format if possible so we don't have to revise all our tests. 153488 54 evan 2009-10-08 12:42:36 -0700 Blah, I keep going in circles on this. UString.cpp's concatenate() is almost exactly what I want (it's where I got the dtoa handling from) except that it does exponents and works with UStrings. I could maybe factor that out into something that writes into a char* buffer (which is what it does, then convert to a wide buffer as the last step) but then I'd also need to add special-casing for whether we want exponents or not. To handle the TextStream case fully it also needs to behave differently for significant digits -- it's basically the difference between how %f and %g in printf handle the precision argument. I think I bit off more than I should have in my last patch; I will write a new one that *only* touches the CSS floats (what this bug was initially about) and not float handling in general. Since those floats need special handling (no exponents), it seems reasonable to me to have a special function for it. I think even in that case I'll need new baselines for a bunch of SVG tests where the 10e-6th digit of a float changes by one due to rounding. :( Regarding reserving the correct buffer from the start: I think it could be done, at the cost of uglifying the code a bit. I will write it and see what you think. 153511 55 darin 2009-10-08 13:35:55 -0700 (In reply to comment #54) > I will write a new > one that *only* touches the CSS floats (what this bug was initially about) and > not float handling in general. Since those floats need special handling (no > exponents), it seems reasonable to me to have a special function for it. I > think even in that case I'll need new baselines for a bunch of SVG tests where > the 10e-6th digit of a float changes by one due to rounding. Sounds good. > Regarding reserving the correct buffer from the start: I think it could be > done, at the cost of uglifying the code a bit. I will write it and see what > you think. Thanks for taking a crack at it. Probably not super-important. 153557 56 40916 evan 2009-10-08 15:30:28 -0700 Created attachment 40916 use dtoa directly in CSS units 153558 57 40916 evan 2009-10-08 15:32:28 -0700 Comment on attachment 40916 use dtoa directly in CSS units This is my current plan. Only four tests fail after this patch: all of them are due to the %fs in the matrix printing. The size-reservation code is a bit silly; I wonder if it'd be better to just always reserve 8 characters (the expected number + decimal point + sign) and have CSS where the values are obscene (like 20 digits long) cause us to realloc. 153564 58 darin 2009-10-08 16:37:43 -0700 (In reply to comment #57) > This is my current plan. Only four tests fail after this patch: all of them > are due to the %fs in the matrix printing. Looks good. > The size-reservation code is a bit silly; I wonder if it'd be better to just > always reserve 8 characters (the expected number + decimal point + sign) and > have CSS where the values are obscene (like 20 digits long) cause us to > realloc. I think it would be better. Sorry for steering you wrong before! 153589 59 40923 evan 2009-10-08 19:06:51 -0700 Created attachment 40923 use dtoa directly in CSS units 153594 60 evan 2009-10-08 19:13:44 -0700 Still three tests failing, all under transforms/2d. Two of them are that the last digit in matrices changes by 1. (Rounding error.) The last is transforms/2d/transform-accuracy: transform "rotate(-10deg) rotate(10deg) rotate(360deg) rotate(-360deg) rotate(360deg)" expected "matrix(1, 0, 0, 1, 0, 0)", got "matrix(0.999999, -0.000000000000000244929, 0.000000000000000244929, 0.999999, 0, 0)" : FAIL I think I could maybe introduce a rounding step into the testing library they share to work around it. I think it's a bit sketchy to be doing equality tests on floats. 153595 61 evan 2009-10-08 19:15:15 -0700 (PS: the %fs in the matrix code earlier were a red herring: matrices are printed as a list of CSS floats so this is still the code path they use.) 153596 62 40924 evan 2009-10-08 19:18:03 -0700 Created attachment 40924 use dtoa directly in CSS units 153642 63 krit 2009-10-09 03:11:39 -0700 (In reply to comment #62) > Created an attachment (id=40924) [details] > use dtoa directly in CSS units Maybe I missed something but where did you run the test, on Gtk? Mac? 153688 64 evan 2009-10-09 08:38:15 -0700 (In reply to comment #63) > Maybe I missed something but where did you run the test, on Gtk? Mac? Which test? You mean the ones I rebaselined in the patch? I did them on a Mac. 154115 65 41052 evan 2009-10-12 11:22:07 -0700 Created attachment 41052 stringify CSS units manually to match CSS spec 154116 66 41052 evan 2009-10-12 11:24:35 -0700 Comment on attachment 41052 stringify CSS units manually to match CSS spec I had a flash of inspiration over the weekend. Since we explicitly want to round to 6 figures, we can skip all the dtoa business. New patch is significantly simpler, makes two tests start passing, and I only had to rebaseline one test due to rounding differences. 154122 67 41052 darin 2009-10-12 11:58:35 -0700 Comment on attachment 41052 stringify CSS units manually to match CSS spec Looks good. > + // For compatibility with existing layout tests, we target 6 digits of precision. This seems strange to me, even though we've been discussing this one back and forth. I hope that eventually we can make a choice based on something other than "layout tests". Perhaps the best way to word the comment would be to say "compatibility with what was returned by older versions of WebKit"? > + const int digits = 6; This name is too terse. Maybe it should be digitsAfterDecimalPoint? > + long long rounded = round(fabs(value) * 1000000.0); The best function to use to round a double and put the result in a long long would be llround, not round. What makes long long big enough? If you are trying to avoid overflow, long long is not sufficient for that. There are definitely values that fit in a double that are too large to fit in a long long. How does this handle super-large numbers? Do we have test cases that cover that? > + if (rounded == 0) { > + vector.append('0'); > + return; > + } Need to indent by four spaces here, not two. > + char buf[80]; > + int length = snprintf(buf, sizeof(buf), "%lld", rounded); Since snprintf has rather poor performance, it would be better to use some other code here to convert the integer to a string. Functions like UString::from in JavaScriptCore do this job, and I'd like to see this use a similar function in the String class rather than relying on snprintf. > + // Reserve an estimate of space for the number of digits we anticipate > + // along with a minus sign/initial zero/decimal point. That sounds like length + 3. > + vector.reserveCapacity(vector.size() + 2 + length); And this says 2 + length. Why doesn't the code match the comment? I'd like to see test cases for the edge cases of this code. I worry that this will do the wrong thing for extremely large and extremely small numbers -- test cases could make it clear that the behavior hasn't changed, or that it has improved. I'm going to say review- because I'd at least like you to rename "digits", but please consider the rest of the comments too. 154126 68 41055 evan 2009-10-12 12:10:59 -0700 Created attachment 41055 stringify CSS units manually to match CSS spec 154133 69 evan 2009-10-12 12:21:27 -0700 (In reply to comment #67) > (From update of attachment 41052 [details]) > Looks good. Thank you a ton for your patience and careful reviews. > > > + // For compatibility with existing layout tests, we target 6 digits of precision. > > This seems strange to me, even though we've been discussing this one back and > forth. I hope that eventually we can make a choice based on something other > than "layout tests". Perhaps the best way to word the comment would be to say > "compatibility with what was returned by older versions of WebKit"? Done. > > > + const int digits = 6; > > This name is too terse. Maybe it should be digitsAfterDecimalPoint? Done. > > > + long long rounded = round(fabs(value) * 1000000.0); > > The best function to use to round a double and put the result in a long long > would be llround, not round. Ah, I wasn't even aware of this function. > > What makes long long big enough? If you are trying to avoid overflow, long long > is not sufficient for that. There are definitely values that fit in a double > that are too large to fit in a long long. How does this handle super-large > numbers? Do we have test cases that cover that? It is true. Here's my thinking. One of the test cases I'm fixing here is "large-number-round-trip", which is an old test that predates me discovering this bug. (I checked it in recently since I discovered it was related.) It shows that WebKit currently gets numbers as small as 90010000 (roughly 10e8) wrong. If you're willing to assume a long long is 64 bits (call it 10e19), and my multiply-by-10e6 trick eats 6 of that exponent, I'm making the upper bound around 10e13, which is at least better than where we were before. Since we're talking about CSS units, I don't think that's too bad of a bound; the spec is silent on the bounds of these values. http://www.w3.org/TR/CSS2/syndata.html#value-def-number Using a plain long is 32 bits, or 10e9, which would bound the values to 10e3 after the rounding trick, which is clearly enough. > > + if (rounded == 0) { > > + vector.append('0'); > > + return; > > + } > > Need to indent by four spaces here, not two. This is really embarrassing. I am normally really finicky about this sort of thing. My only excuse is that the other code I work on has 2 space tabs stops. > > > + char buf[80]; > > + int length = snprintf(buf, sizeof(buf), "%lld", rounded); > > Since snprintf has rather poor performance, it would be better to use some > other code here to convert the integer to a string. Functions like > UString::from in JavaScriptCore do this job, and I'd like to see this use a > similar function in the String class rather than relying on snprintf. Oops, I missed this before I uploaded my new patch. Will investigate. > > + // Reserve an estimate of space for the number of digits we anticipate > > + // along with a minus sign/initial zero/decimal point. > > That sounds like length + 3. > > > + vector.reserveCapacity(vector.size() + 2 + length); > > And this says 2 + length. Why doesn't the code match the comment? Overzealous premature optimization (most numbers only have at most two of the three mentioned characteristics). Fixed. > I'd like to see test cases for the edge cases of this code. I worry that this > will do the wrong thing for extremely large and extremely small numbers -- test > cases could make it clear that the behavior hasn't changed, or that it has > improved. The opacity-float test changes try to. Was there anything else you had in mind? Or do you mean testing the failure cases -- when the values exceed the allowed inputs? I will upload a patch fixing the snprintf issue once I figure out a proper solution. (In my defense, the old code used snprintf for floats.) 154137 70 evan 2009-10-12 12:37:54 -0700 (In reply to comment #69) > Using a plain long is 32 bits, or 10e9, which would bound the values to 10e3 > after the rounding trick, which is clearly enough. Er, that should be "clearly *not* enough". 154139 71 darin 2009-10-12 12:49:12 -0700 (In reply to comment #69) > I will upload a patch fixing the snprintf issue once I figure out a proper > solution. (In my defense, the old code used snprintf for floats.) We can do that in a separate step. I don't consider it a show-stopper. 154140 72 darin 2009-10-12 12:51:07 -0700 (In reply to comment #69) > > I'd like to see test cases for the edge cases of this code. I worry that this > > will do the wrong thing for extremely large and extremely small numbers -- test > > cases could make it clear that the behavior hasn't changed, or that it has > > improved. > > The opacity-float test changes try to. Was there anything else you had in > mind? Or do you mean testing the failure cases -- when the values exceed the > allowed inputs? My approach would be to have tests at the various boundaries: highest value that works, lowest that does not work, that sort of thing. Make sure all the code paths are tested, even the less important ones. I think we're OK. Not sure. I didn't re-review the tests. 154164 73 41059 evan 2009-10-12 14:27:40 -0700 Created attachment 41059 stringify CSS units manually to match CSS spec 154165 74 evan 2009-10-12 14:30:18 -0700 In the process of adding more tests, I discovered some bugs, so that was a wise suggestion. I rearranged opacity-float so it's more clear what it's testing (pairs of [expected, input]), so any other suggestions for that are welcome. Should I file a bug about the snprintf thing? I could write an integer->string loop myself, I suppose. My Unix-wizard officemate says there are no POSIX builtins that do this, and volunteered some code. 154168 75 41061 evan 2009-10-12 14:46:55 -0700 Created attachment 41061 stringify CSS units manually to match CSS spec 154169 76 41061 evan 2009-10-12 14:49:20 -0700 Comment on attachment 41061 stringify CSS units manually to match CSS spec Graahhh, now I've confused myself again. Will reinvestigate this failing test. 154171 77 41061 evan 2009-10-12 14:55:56 -0700 Comment on attachment 41061 stringify CSS units manually to match CSS spec Actually, I'm kind of exhausted on this bug. From the printf docs %.6g means you show up to 6 significant digits, but then somehow it doesn't happen when your number very is close to zero and they also arbitrarily chop off trailing digits if they are 0 even when they are significant. This patch passes all the layout tests, but I had to change the precision on one, but I find it hard to care too much about it. 154178 78 41061 darin 2009-10-12 15:23:08 -0700 Comment on attachment 41061 stringify CSS units manually to match CSS spec > -FAIL: read 90010000px back as 9.001e+07px, read again as 0px > +PASS: read 90010000px back as 90010000px, read again as 90010000px This succeeds only because the large number isn't large enough, right? With a still larger number we'd have some other problem. I'd like to have a test showing that we still fail with even larger numbers. > This test verifies that reading a floating-point opacity from CSS attributes gets back a properly-formatted float. Improperly handling locales that cause decimals to be written as commas might break it. > > PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS > +PASS In the future, you should use the script-tests approach to build tests like this. This style of tests that write out more about what they're testing and why they pass that you get automatically from that are superior. A good example of how to do this sort of test is LayoutTests/fast/dom/HTMLFormElement/script-tests/elements-not-in-document.js and you may be able to see from that how this test could have been done that way. > From the printf docs %.6g means you show up to 6 significant digits, but then > somehow it doesn't happen when your number very is close to zero and they also > arbitrarily chop off trailing digits if they are 0 even when they are > significant. This patch passes all the layout tests, but I had to change the > precision on one, but I find it hard to care too much about it. As I understand it, 0.00000123456 is an example with 6 significant digits. Maybe you misunderstood what it meant. But exactly matching "%.6lg" isn't the point. Matching what we used to do is a good idea, but matching other browsers or matching specifications are even more important. I think at this point the patch is OK. Here are areas for future improvement and refinement: - check on how other browsers handle formatting fractional values in CSS; how many digits of precision, etc. - figure out if we want to stick with the 6-digits-of-precision thing forever, or if we should have a different formatting rule - eliminate the use of snprintf -- as I said, JavaScriptCore has a function with the relevant code already, JSC::UString::from, so you could just port that to live in String.cpp - change the test to use script-tests for better clarity - add quite a few more kinds of numbers to the test cases - test all the different types of units -- a test should fail if we made any mistakes in the switch statements r=me 154446 79 evan 2009-10-13 14:51:42 -0700 > > From the printf docs %.6g means you show up to 6 significant digits, but then > > somehow it doesn't happen when your number very is close to zero and they also > > arbitrarily chop off trailing digits if they are 0 even when they are > > significant. This patch passes all the layout tests, but I had to change the > > precision on one, but I find it hard to care too much about it. > > As I understand it, 0.00000123456 is an example with 6 significant digits. > Maybe you misunderstood what it meant. But exactly matching "%.6lg" isn't the > point. Matching what we used to do is a good idea, but matching other browsers > or matching specifications are even more important. That is my understanding of significant digits as well. But from one of my earlier iterations of the patch, I was printing 0.00000000000123456 at the end of some error-accumultating computation; the printf implementation prints 0 for that. See comment #60. This is what prompted my new approach, which chops to 6 digits effectively by rounding to the nearest 10e-6. > - check on how other browsers handle formatting fractional values in CSS; > how many digits of precision, etc. > - figure out if we want to stick with the 6-digits-of-precision thing > forever, or if we should have a different formatting rule Filed https://bugs.webkit.org/show_bug.cgi?id=30341 > - eliminate the use of snprintf -- as I said, JavaScriptCore has a function > with the relevant code already, JSC::UString::from, so you could just port that > to live in String.cpp Filed https://bugs.webkit.org/show_bug.cgi?id=30342 > - change the test to use script-tests for better clarity > - add quite a few more kinds of numbers to the test cases > - test all the different types of units -- a test should fail if we made > any mistakes in the switch statements https://bugs.webkit.org/show_bug.cgi?id=30340 I can't promise I'll fix all of those, but I will try to at least improve the test soon since I'm the one who wrote it. 154449 80 41061 abarth 2009-10-13 14:59:17 -0700 Comment on attachment 41061 stringify CSS units manually to match CSS spec This patch does not have a ChangeLog :) 154452 81 41131 evan 2009-10-13 15:03:30 -0700 Created attachment 41131 stringify CSS units manually to match CSS spec 154453 82 41131 evan 2009-10-13 15:04:07 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec Identical patch to the one Darin r+'d above; now includes ChangeLogs. 154454 83 41131 abarth 2009-10-13 15:06:14 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec Forwarding Darin's r+ to the new patch with a ChangeLog. 154475 84 41131 commit-queue 2009-10-13 16:02:43 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec Rejecting patch 41131 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--quiet', '--exit-after-n-failures=1']" exit_code: 1 Last 500 characters of output: tTests Testing 11429 test cases. http/tests/loading/bad-server-subframe.html -> timed out Sampling process 18462 for 10 seconds with 10 milliseconds of run time between samples Sampling completed, processing symbols... Sample analysis of process 18462 written to file /Users/eseidel/Library/Logs/DumpRenderTree/HangReport.txt Exiting early after 1 failures. 8510 tests run. 552.63s total testing time 8509 test cases (99%) succeeded 1 test case (<1%) timed out 4 test cases (<1%) had stderr output 154476 85 41131 evan 2009-10-13 16:03:54 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec setting cq+ because i believe that failure was flakiness 154477 86 41131 evan 2009-10-13 16:04:18 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec actually, probably needs someone else to set cq+ since i'm not a committer 154528 87 41131 commit-queue 2009-10-13 21:09:11 -0700 Comment on attachment 41131 stringify CSS units manually to match CSS spec Clearing flags on attachment: 41131 Committed r49554: <http://trac.webkit.org/changeset/49554> 154529 88 commit-queue 2009-10-13 21:09:22 -0700 All reviewed patches have been landed. Closing bug. 154532 89 dglazkov 2009-10-13 21:44:45 -0700 Rolled out as http://trac.webkit.org/changeset/49554 due to Win and Chromium compile break. 154579 90 darin 2009-10-14 08:22:47 -0700 Maybe llround is not available on Windows? If so, the fix could be to add it to <wtf/MathExtras.h>. 154580 91 darin 2009-10-14 08:23:20 -0700 I didn't actually look at the Windows failure -- it might not have been llround. 154590 92 evan 2009-10-14 09:29:41 -0700 I think I am going to sit on this patch until I have commit access, since breaking the tree and being unable to revert it myself is not very helpful. If anyone else would like to take up the crusade I welcome your help. Until then, I recommend "export LC_NUMERIC=en_US.UTF-8". ;) 154591 93 evan 2009-10-14 09:34:10 -0700 For future reference, the Windows breakage was: CSSPrimitiveValue.cpp ..\css\CSSPrimitiveValue.cpp(698) : error C3861: 'llround': identifier not found ..\css\CSSPrimitiveValue.cpp(705) : error C3861: 'snprintf': identifier not found I'm trying to find the failed Linux logs but I'm not seeing them; maybe I am getting my failures mixed up. 154650 94 darin 2009-10-14 13:58:40 -0700 Dmitri said “Win and Chromium”. I suspect it was Windows in both cases -- not sure it broke on Linux. 154651 95 dglazkov 2009-10-14 14:02:05 -0700 Right, I don't think it broke anything non-Windows. 154652 96 darin 2009-10-14 14:05:18 -0700 I'll check this in. The fix for snprintf is to include <wtf/StringExtras.h>. The fix for llround is to include <wtf/MathExtras.h> and add llround to MathExtras.h alongside lround. 154659 97 darin 2009-10-14 14:46:06 -0700 http://trac.webkit.org/changeset/49585 154825 98 eric 2009-10-15 10:01:51 -0700 (In reply to comment #84) > (From update of attachment 41131 [details]) > Rejecting patch 41131 from commit-queue. > http/tests/loading/bad-server-subframe.html -> timed out Filed bug 30392 about the false failure. 163654 99 krit 2009-11-14 00:45:44 -0800 We still have this bug on WebKitGtk. I noticed it on http://www.svgbasics.com/radial_gradients.html. Maybe just on SVG's <use> element. Because the example on the first comment works. 163666 100 evan 2009-11-14 08:40:55 -0800 (In reply to comment #99) > We still have this bug on WebKitGtk. I noticed it on > http://www.svgbasics.com/radial_gradients.html. Maybe just on SVG's <use> > element. Because the example on the first comment works. I attempted to split this bug into smaller bugs just so it wouldn't go on forever. See comment 79. Is it a problem with element.style.opacity? 163667 101 krit 2009-11-14 08:53:13 -0800 (In reply to comment #100) > (In reply to comment #99) > > We still have this bug on WebKitGtk. I noticed it on > > http://www.svgbasics.com/radial_gradients.html. Maybe just on SVG's <use> > > element. Because the example on the first comment works. > > I attempted to split this bug into smaller bugs just so it wouldn't go on > forever. See comment 79. Is it a problem with element.style.opacity? You find String::format("translate(%f, %f)", x().value(this), y().value(this)); and some other String::format and String::number in WebCore/SVGUseElement.cpp. This causes the wrong position in this case. But also some animations don't work like: http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-animate-elem-22-b.html http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-animate-elem-29-b.html I can't say what causes the wrong behavior on the SVG animations. 168088 102 adele 2009-12-02 11:17:57 -0800 r49585 caused a regression at ziprealty.com - please see https://bugs.webkit.org/show_bug.cgi?id=32078. 171253 103 adele 2009-12-13 15:02:06 -0800 Reopening. I reverted the change in r52071. I noticed is that the new tests that were added to opacity-float.html didn't pass in Firefox. I wonder if the JS library used in ziprealty.com was expecting wrong behavior. Might be something investigate when re-fixing this bug. 178264 104 krit 2010-01-07 10:57:57 -0800 *** Bug 33322 has been marked as a duplicate of this bug. *** 178266 105 darin 2010-01-07 11:03:09 -0800 We can fix this! We just need to go out of our way to keep behavior changes to a minimum. Someone should take a crack at it. 178282 106 evan 2010-01-07 11:27:19 -0800 Since I'm responsible for most of the noise on this bug, I should probably write up my current thoughts. 1) I attached a page that shows a bunch of cases as comment #2 on https://bugs.webkit.org/show_bug.cgi?id=30341 if you intend to change WebKit's behavior, you should probably check whether you match other browsers using that page, as well as the real website that prompted reverting my previous attempt at this bug. I noticed Firefox is different than WebKit both before and after my change. (But see my comment #5 on there.) 2) glib actually has a function that takes a printf-style format and does a locale-inspecific decimal formatted string. I was curious how it worked: http://www.google.com/codesearch/p?hl=en#RGCD84x9Jg0/trunk/xbmc/lib/libmms/glib-2.20.4/glib/gstrfuncs.c&q=g_ascii_formatd&sa=N&cd=1&ct=rc&l=609 (If that link breaks, it's a code search for g_ascii_formatd.) It works by checking if your locale is one that doesn't use '.' for decimal points, and if so, does a search and replace on the string result of calling printf! This feels like a huge hack but actually doesn't seem so bad to me at this point. 178293 107 digulla 2010-01-07 11:41:34 -0800 Seemed like a little bug when I opened it. This is getting rather silly. So many brains and we can't come up with a solution. Okay, here is one: - Find the source code for atof.c and printf()-style formatting from a version of glibc which either doesn't support a locale or just omit the locale-specific part. - Cut'n'paste. Yeah, it's a pain but it's also only a couple of lines of code. So why bother. - Remove support for the old formatting code in String() to cause compile errors. - Check whether ACID passes. When ACID passes and some internal tests fail, then fix the internal tests. It's bad when some tests fail because items move by a pixel but then, an important feature of the browser doesn't work at all. On top of that, the fixed code should produce the same results as the old one except for the locale specific decimal point. So tests *should* not fail. If they do, then probably something else broke. But the focus should be on fixing this bug. If it breaks old tests, that's unfortunate and probably worth an investigation because it shouldn't (= there is no reason why it should except for rounding errors which probably means that the new code has a bug). But it shouldn't stop the fix. 203390 108 vincent.alquier 2010-03-24 05:50:33 -0700 *** Bug 36485 has been marked as a duplicate of this bug. *** 246209 109 ap 2010-07-02 20:20:49 -0700 *** Bug 41541 has been marked as a duplicate of this bug. *** 248745 110 krit 2010-07-08 22:40:19 -0700 *** Bug 41658 has been marked as a duplicate of this bug. *** 254376 111 ap 2010-07-21 10:04:53 -0700 See also: bug 42755. 291780 112 simon.fraser 2010-10-08 11:31:29 -0700 Gavin is working on some num -> string code that might help here. 292278 113 70394 zimmermann 2010-10-10 04:59:02 -0700 Created attachment 70394 Work in progress Attaching a first work in progress patch, and my plan how I want to fix this problem (and related SVG problems): List of the problems: - String::format() may be localy dependant. - String::number(double) uses String::format("%.6lg") and thus is affected as well Related problems, that affect SVG, is rounding. The String::format() usage truncated, instead of rounding properly to say N significant figures. - TextStream::operator<<(float/double) is affected. - SVGPahtStringBuilder (most prominent area of problems) - SVGPointList/SVGTransformList/SVGAnimatedPropertyTraits (all using String::format) The way I plan to fix this is outlined in the attached "Work in progress" patch. Step #1) Patch String::number(double) to utilize wtf/DecimalNumber (which uses dtoa) to convert the double into a string. Apply some extra operations to make it mimic the String::format("%.6lg") output (cut off trailing zeros 1.5000 -> 1.5, leave integers unchanged 12.000 -> 12) Step #2) Convert all users of String::format() to use String::number() + StringBuilder/Vector<Uchar> based string creation. Step #3) Kill String::format(), and it's platform specific implementations (like Qt did). What do you think? 292280 114 zimmermann 2010-10-10 05:13:26 -0700 When removing String::format(), following code has to change. String::format() users that don't dump floating-point numbers, and can be converted to a String::number() + StringBuilder/Vector<UChar> based solution right now: bindings/js/JSDOMWindowBase.cpp: return String::format("Unsafe JavaScript attempt to access frame with URL %s from frame with URL %s. Domains, protocols and ports must match.\n", bindings/v8/V8Proxy.cpp: String str = String::format("Unsafe JavaScript attempt to access frame " css/CSSOMUtils.cpp: append(appendTo, String::format("\\%x ", c)); dom/Document.cpp: return String::format("%02d/%02d/%04d %02d:%02d:%02d", date.month() + 1, date.monthDay(), date.fullYear(), date.hour(), date.minute(), date.second()); dom/ExceptionBase.cpp: m_message = String::format("%s: %s Exception %d", description.name, description.typeName, description.code); dom/ExceptionBase.cpp: m_message = String::format("%s Exception %d", description.typeName, description.code); dom/StyledElement.cpp: color = String::format("#%02x%02x%02x", colors[0], colors[1], colors[2]); dom/XMLDocumentParser.cpp: m_errorMessages += String::format("warning on line %d at column %d: %s", lineNumber, columnNumber, m); dom/XMLDocumentParser.cpp: m_errorMessages += String::format("error on line %d at column %d: %s", lineNumber, columnNumber, m); html/DateComponents.cpp: return String::format("%02d:%02d", m_hour, m_minute); html/DateComponents.cpp: return String::format("%02d:%02d:%02d", m_hour, m_minute, m_second); html/DateComponents.cpp: return String::format("%02d:%02d:%02d.%03d", m_hour, m_minute, m_second, m_millisecond); html/DateComponents.cpp: return String::format("%04d-%02d-%02d", m_year, m_month + 1, m_monthDay); html/DateComponents.cpp: return String::format("%04d-%02d-%02dT", m_year, m_month + 1, m_monthDay) html/DateComponents.cpp: return String::format("%04d-%02d-%02dT", m_year, m_month + 1, m_monthDay) html/DateComponents.cpp: return String::format("%04d-%02d", m_year, m_month + 1); html/DateComponents.cpp: return String::format("%04d-W%02d", m_year, m_week); html/FTPDirectoryDocument.cpp: timeOfDay = String::format(", %i:%02i AM", hour, fileTime.tm_min); html/FTPDirectoryDocument.cpp: timeOfDay = String::format(", %i:%02i PM", hour, fileTime.tm_min); html/FTPDirectoryDocument.cpp: dateString = String::format("%s %i, %i", months[month], fileTime.tm_mday, fileTime.tm_year); html/FTPDirectoryDocument.cpp: dateString = String::format("%s %i, %i", months[month], fileTime.tm_mday, now.tm_year); inspector/CodeGeneratorInspector.pm: push(@function, " protocolErrors->pushString(String::format(\"Protocol Error: %s handler is not available.\", \"$domain\"));"); inspector/CodeGeneratorInspector.pm: push(@function, " protocolErrors->pushString(String::format(\"Protocol Error: 'arguments' property with type 'object' was not found.\"));"); inspector/CodeGeneratorInspector.pm: push(@function, " protocolErrors->pushString(String::format(\"Protocol Error: Argument '%s' with type '%s' was not found.\", \"$name\", \"$JSONType\"));"); inspector/CodeGeneratorInspector.pm: push(@function, " protocolErrors->pushString(String::format(\"Protocol Error: Argument '%s' has wrong type. It should be '%s'.\", \"$name\", \"$JSONType\"));"); inspector/CodeGeneratorInspector.pm: reportProtocolError(callId, String::format("Protocol Error: Invalid command was received. '%s' wasn't found.", command.utf8().data())); inspector/InspectorController.cpp: String message = String::format("Failed to load resource: the server responded with a status of %u (", response.httpStatusCode()) + response.httpStatusText() + ")"; inspector/InspectorController.cpp: String identifier = title + String::format("@%s:%d", sourceID.utf8().data(), lineNumber); inspector/InspectorController.cpp: String message = String::format("%s: %d", title.utf8().data(), count); inspector/InspectorDebuggerAgent.cpp: return String::format("%s:%d", sourceID.utf8().data(), lineNumber); inspector/InspectorProfilerAgent.cpp: String message = String::format("Profile \"webkit-profile://%s/%s#%d\" finished.", CPUProfileType, encodeWithURLEscapeSequences(title).utf8().data(), profile->uid()); inspector/InspectorProfilerAgent.cpp: String message = String::format("Profile \"webkit-profile://%s/%s#0\" started.", CPUProfileType, encodeWithURLEscapeSequences(title).utf8().data()); inspector/InspectorProfilerAgent.cpp: return String::format("%s.%d", UserInitiatedProfileName, m_currentUserInitiatedProfileNumber); inspector/InspectorProfilerAgent.cpp: String title = String::format("%s.%d", UserInitiatedProfileName, m_nextUserInitiatedHeapSnapshotNumber++); inspector/InspectorValues.cpp: String symbolCode = String::format("\\u%04X", symbol); loader/archive/cf/LegacyWebArchive.cpp: String iframeMarkup = String::format("<iframe frameborder=\"no\" marginwidth=\"0\" marginheight=\"0\" width=\"98%%\" height=\"98%%\" src=\"%s\"></iframe>", loader/CachedResourceLoader.cpp: String::format("Unsafe attempt to load URL %s.", loader/CachedResourceLoader.cpp: String::format("Unsafe attempt to load URL %s from frame with URL %s. " loader/FrameLoader.cpp: String message = String::format("The page at %s displayed insecure content from %s.\n", loader/FrameLoader.cpp: String message = String::format("The page at %s ran insecure content from %s.\n", loader/FrameLoader.cpp: String message = String::format("Unsafe JavaScript attempt to initiate a navigation change for frame with URL %s from frame with URL %s.\n", page/DOMWindow.cpp: String message = String::format("Unable to post message to %s. Recipient has origin %s.\n", page/PrintContext.cpp: return String::format("%d", style->marginLeft().rawValue()); page/PrintContext.cpp: return String::format("%d", style->lineHeight().rawValue()); page/PrintContext.cpp: return String::format("%d", style->fontDescription().computedPixelSize()); page/PrintContext.cpp: return String::format("%s", style->fontDescription().family().family().string().utf8().data()); page/PrintContext.cpp: return String::format("%d %d", style->pageSize().width().rawValue(), style->pageSize().height().rawValue()); page/PrintContext.cpp: return String::format("pageProperty() unimplemented for: %s", propertyName); page/PrintContext.cpp: return String::format("(%d, %d) %d %d %d %d", pageSize.width(), pageSize.height(), marginTop, marginRight, marginBottom, marginLeft); page/XSSAuditor.cpp: String consoleMessage = String::format("Refused to load an object. URL found within request: \"%s\".\n", url.utf8().data()); platform/audio/HRTFElevation.cpp: String resourceName = String::format("IRC_%s_C_R0195_T%03d_P%03d", subjectName.utf8().data(), azimuth, positiveElevation); platform/brew/FileSystemBrew.cpp: return String::format("fs:/~0X%08X/", webViewClassId); platform/brew/PlatformKeyboardEventBrew.cpp: return String::format("U+%04X", toASCIIUpper(keyCode)); platform/cocoa/KeyEventCocoa.mm: return String::format("U+%04X", toASCIIUpper(charCode)); platform/efl/PlatformKeyboardEventEfl.cpp: String key = String::format("F%d", i); platform/efl/PlatformKeyboardEventEfl.cpp: String key = String::format("%c", alphabet[i]); platform/efl/PlatformKeyboardEventEfl.cpp: String key = String::format("%d", i); platform/efl/PlatformKeyboardEventEfl.cpp: String key = String::format("F%d", i); platform/graphics/brew/ImageBrew.cpp: String resourcePath = homeDirectoryPath() + String::format("res/%s.png", name); platform/graphics/cg/ImageBufferCG.cpp: return String::format("data:%s;base64,%s", mimeType.utf8().data(), out.data()); platform/graphics/chromium/FontUtilsChromiumWin.cpp: String fontKey = String::format("%1d:%d:%ls", style, logfont->lfHeight, family); platform/graphics/chromium/GraphicsLayerChromium.cpp: String name = String::format("GraphicsLayerChromium(%p) GraphicsLayer(%p) ", m_layer.get(), this) + inName; platform/graphics/Color.cpp: return String::format("#%02x%02x%02x", red(), green(), blue()); platform/graphics/Color.cpp: return String::format("rgba(%u, %u, %u, 0.0)", red(), green(), blue()); platform/graphics/Color.cpp: return String::format("#%02X%02X%02X%02X", red(), green(), blue(), alpha()); platform/graphics/Color.cpp: return String::format("#%02X%02X%02X", red(), green(), blue()); platform/graphics/efl/ImageEfl.cpp: RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(String::format(DATA_DIR "/webkit-1.0/images/%s.png", name)); platform/graphics/GraphicsLayer.cpp: return String::format("-|transition%c-", property); platform/graphics/gtk/ImageBufferGtk.cpp: return String::format("data:%s;base64,%s", mimeType.utf8().data(), out.data()); platform/graphics/haiku/ImageBufferHaiku.cpp: return String::format("data:%s;base64,%s", mimeType.utf8().data(), platform/graphics/mac/GraphicsLayerCA.mm: return animationName + String::format("_%d_%d", property, index); platform/graphics/mac/GraphicsLayerCA.mm: String longName = String::format("CALayer(%p) GraphicsLayer(%p) ", m_layer.get(), this) + name; platform/graphics/mac/GraphicsLayerCA.mm: String name = String::format("CALayer(%p) GraphicsLayer(%p) ", m_layer.get(), this) + m_name; platform/graphics/qt/ImageBufferQt.cpp: return String::format("data:%s;base64,%s", mimeType.utf8().data(), data.toBase64().data()); platform/graphics/skia/ImageBufferSkia.cpp: return String::format("data:image/png;base64,%s", base64EncodedData.data()); platform/graphics/win/GraphicsLayerCACF.cpp: String longName = String::format("CALayer(%p) GraphicsLayer(%p) ", m_layer.get(), this) + name; platform/graphics/win/GraphicsLayerCACF.cpp: String name = String::format("CALayer(%p) GraphicsLayer(%p) %s", m_layer.get(), this, m_usingTiledLayer ? "[Tiled Layer] " : "") + m_name; platform/graphics/win/WebLayer.cpp: String text = String::format("%d", m_owner->incrementRepaintCount());; platform/gtk/KeyEventGtk.cpp: return String::format("U+%04X", gdk_keyval_to_unicode(gdk_keyval_to_upper(keyCode))); platform/haiku/PlatformKeyboardEventHaiku.cpp: return String::format("U+%04X", toASCIIUpper(singleByte)); platform/network/CredentialStorage.cpp: return url.protocol() + "://" + url.host() + String::format(":%i/", url.port()); platform/qt/PlatformKeyboardEventQt.cpp: return String::format("U+%04X", toupper(keyCode)); platform/sql/SQLiteDatabase.cpp: executeCommand(String::format("PRAGMA synchronous = %i", sync)); platform/sql/SQLiteFileSystem.cpp: fileName = pathByAppendingComponent(dbDir, String::format("%016"PRIx64".db", seq)); platform/sql/SQLiteFileSystem.cpp: return String::format("%016"PRIx64".db", seq); platform/text/wince/TextCodecWinCE.cpp: String cpName = String::format("cp%d", cpInfo.uiCodePage); platform/win/ClipboardUtilitiesWin.cpp: append(result, String::format(header, startHTMLOffset, endHTMLOffset, startFragmentOffset, endFragmentOffset).utf8()); platform/win/GDIObjectCounter.cpp: init(String::format("%s (%p)", className.latin1().data(), instance)); platform/win/KeyEventWin.cpp: return String::format("U+%04X", toASCIIUpper(keyCode)); platform/win/Language.cpp: computedDefaultLanguage = String::format("%s-%s", languageName.latin1().data(), countryName.latin1().data()); platform/wx/KeyboardEventWx.cpp: return String::format("U+%04X", toupper(keyCode)); plugins/PluginStream.cpp: String statusLine = String::format("HTTP %d OK\n", m_resourceResponse.httpStatusCode()); rendering/RenderTheme.cpp: return String::format("%s%02d:%02d:%02d", (time < 0 ? "-" : ""), hours, minutes, seconds); rendering/RenderTheme.cpp: return String::format("%s%01d:%02d:%02d", (time < 0 ? "-" : ""), hours, minutes, seconds); rendering/RenderTheme.cpp: return String::format("%s%02d:%02d", (time < 0 ? "-" : ""), minutes, seconds); rendering/RenderTreeAsText.cpp: String hex = String::format("\\x{%X}", u); svg/SVGUseElement.cpp: text += String::format("SVGElementInstance this=%p, (parentNode=%s (%p), firstChild=%s (%p), correspondingElement=%s (%p), shadowTreeElement=%s (%p), id=%s)\n", svg/SVGUseElement.cpp: text += String::format("Corresponding element is associated with %i instance(s):\n", elementInstances.size()); svg/SVGUseElement.cpp: text += String::format(" -> SVGElementInstance this=%p, (refCount: %i, shadowTreeElement in document? %i)\n", websockets/WebSocket.cpp: builder.append(String::format("\\u%04X", protocol[i])); websockets/WebSocket.cpp: scriptExecutionContext()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, String::format("WebSocket port %d blocked", url.port()), 0, scriptExecutionContext()->securityOrigin()->toString()); websockets/WebSocketChannel.cpp: m_context->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, String::format("WebSocket frame (at %lu bytes) is too long.", static_cast<unsigned long>(newBufferSize)), 0, m_handshake.clientOrigin()); websockets/WebSocketHandshake.cpp: m_context->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, String::format("Unexpected response code: %d", statusCode), 0, clientOrigin()); String::format() users that dump floating-point numbers, and would need my patch for String::number() before they could be converted: css/CSSParser.cpp: String str = String::format("%06d", (int)(value->fValue+.5)); css/CSSPrimitiveValue.cpp: text = String::format("%.6lg%%", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgem", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgex", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgrem", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgpx", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgcm", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgmm", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgin", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgpt", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgpc", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgdeg", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgrad", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lggrad", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgms", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgs", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lghz", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgkhz", m_value.num); css/CSSPrimitiveValue.cpp: text = String::format("%.6lgturn", m_value.num); css/WebKitCSSMatrix.cpp: return String::format("matrix(%f, %f, %f, %f, %f, %f)", css/WebKitCSSMatrix.cpp: return String::format("matrix3d(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", html/FTPDirectoryDocument.cpp: return String::format("%.2f KB", static_cast<float>(bytes)/1000); html/FTPDirectoryDocument.cpp: return String::format("%.2f MB", static_cast<float>(bytes)/1000000); html/FTPDirectoryDocument.cpp: return String::format("%.2f GB", static_cast<float>(bytes)/1000000000); inspector/InspectorValues.cpp: String value = String::format("%f", m_doubleValue); page/Console.cpp: String message = title + String::format(": %.0fms", elapsed); platform/graphics/Color.cpp: return String::format("rgba(%u, %u, %u, %.5f)", red(), green(), blue(), alpha() / 255.0f); platform/graphics/gtk/ImageBufferGtk.cpp: String qualityString = String::format("%f", *quality); platform/graphics/mac/MediaPlayerPrivateQTKit.mm: String text = String::format("%1.2f", frameRate); svg/SVGAnimatedPropertyTraits.h: static String toString(PassType type) { return String::format("%f %f %f %f", type.x(), type.y(), type.width(), type.height()); } svg/SVGTransformList.cpp: return String::format("matrix(%f %f %f %f %f %f)", matrix.a(), matrix.b(), matrix.c(), matrix.d(), matrix.e(), matrix.f()); If my patch is considered good, I'd change the usages of String::format("%f") to the new String::number() implementation combined StringBuilder/Vector<UChar> to replace the String::format() calls. That would be a good first step, fixing this bug, and then later on we can kill String::format(). I've just realized that not all code wants to round to 6 significant figures, some explicitely demand 2 decimals, some code just uses %f. That means my patch has to be adapted to that. The code in FTPDirectoryDocument for example doesn't want to print exponential numbers, never, that is also not handled yet, when using String::number(double). So maybe we want another enum, that precisely describes the conversion mode. enum FloatingPointConversion { RoundToSignificantFigures, RoundToDecimalPlaces, AvoidExponentials }; String String::number(double number, unsigned = RoundToSignificantFigures, unsigned significantFiguresOrDecimalPlaces = 6). The second argument could be used to combine eg. RoundToSiginificantFigures | AvoidExponentials. Enough for today, what do others think? :-) 292319 115 simon.fraser 2010-10-10 10:07:18 -0700 I think it's a good general direction. This bug is related to bug 20674. 292574 116 barraclough 2010-10-11 11:21:34 -0700 Hi Nikolas, I've been looking a bit at strings & number/string conversions lately, and had a couple of comments on this: > Step #3) Kill String::format(), and it's platform specific implementations (like Qt did). Yes! We we absolutely should get rid of this. > Step #2) Convert all users of String::format() to use String::number() + StringBuilder/Vector<Uchar> based string creation. I think there is something slightly better we could do here. StringBuilder is great if you're appending an arbitrary number of strings together, but being able to handle arbitrary amounts of data adds overhead (currently in the form of building the Vector, converting all C-strings to Strings. In the near future we're likely to move from using a rope to an overcapacity based approach, which will remove these cost but possibly add some copying cost instead). So one thing I've been meaning to do for a while is to add a String::cat() method to WTF::String. Logically this would be a varargs function, but in practice since varargs provides no type information & only handles POD data, there would actually be multiple implementations, with methods handling something like 2-to-8 arguments. In a trivial implementation all arguments would be 'const String&'s, and String::cat() could just wrap StringBuilder (rather than using StringBuilder directly) such that the internal implementation can be improved later. A better implementation we could make the arguments to cat be templated such that data could be added to the string without converting all arguments to String format first. We already have this implemented in JavaScriptCore (and since we're close to unifying the string implementations we could ultimately fully share this code), in a set of methods called makeString. These allow an arbitrary mix of UStrings and plain C-strings to be concatenated together, without first converting the C-strings to Strings. > Step #1) Patch String::number(double) to utilize wtf/DecimalNumber (which uses dtoa) to convert the double into a string. Apply some extra operations to make it mimic the String::format("%.6lg") output (cut off trailing zeros 1.5000 -> 1.5, leave integers unchanged 12.000 -> 12) So, the question here is, what do we want String::number() to do? * The rules for number to String conversion are different in different web technology specifications. * SVG has an uncommon requirement, in that it never overflows to an exponential representation. * HTML5 and ECMAScript agree on number-to-string conversion (in that the HTML5 spec requires ECMAScript conversion). My thought here is that we want String::number() to match HTML5/ECMAScript number-to-string conversion. That is to say, like UString::number it should call WTF::numberToString in dtoa.h, which wraps DecimalNumber with appropriate bounds (<10^-6 & >=10^21) spilling to exponential representation. We should probably add a different method specifically for SVG's number-to-string behaviour. This could be a free function within the svg code, taking a double and returning an String. This method should also be able to use DecimalNumber in its implementation, but would likely chose to always call toStringDecimal, rather than toStringExponential. If elsewhere in the code we do require numbers formatted in a specific fashion (with a fixed number of digits, or significant figures) we should add methods to convert with appropriate constraints as necessary. Hopefully we shouldn't need to mimic "%.6lg" behaviour, since this is not spec defined, probably doesn't match other browsers, and as such is hopefully not relied on anywhere. Changing this should probably only fix spec compliance. How does this sound? cheers, G. 292618 117 zimmermann 2010-10-11 12:54:25 -0700 (In reply to comment #116) > Hi Nikolas, > > I've been looking a bit at strings & number/string conversions lately, and had a couple of comments on this: Thanks! > > > Step #3) Kill String::format(), and it's platform specific implementations (like Qt did). > > Yes! We we absolutely should get rid of this. Great. > > > Step #2) Convert all users of String::format() to use String::number() + StringBuilder/Vector<Uchar> based string creation. > > I think there is something slightly better we could do here. StringBuilder is great if you're appending an arbitrary number of strings together, but being able to handle arbitrary amounts of data adds overhead (currently in the form of building the Vector, converting all C-strings to Strings. In the near future we're likely to move from using a rope to an overcapacity based approach, which will remove these cost but possibly add some copying cost instead). > > So one thing I've been meaning to do for a while is to add a String::cat() method to WTF::String. Logically this would be a varargs function, but in practice since varargs provides no type information & only handles POD data, there would actually be multiple implementations, with methods handling something like 2-to-8 arguments. > > In a trivial implementation all arguments would be 'const String&'s, and String::cat() could just wrap StringBuilder (rather than using StringBuilder directly) such that the internal implementation can be improved later. Excellent, that would be really handy. Do you have already started coding this? > > A better implementation we could make the arguments to cat be templated such that data could be added to the string without converting all arguments to String format first. We already have this implemented in JavaScriptCore (and since we're close to unifying the string implementations we could ultimately fully share this code), in a set of methods called makeString. These allow an arbitrary mix of UStrings and plain C-strings to be concatenated together, without first converting the C-strings to Strings. I see, seems like it would be very wise to share the code in wtf/. > > > Step #1) Patch String::number(double) to utilize wtf/DecimalNumber (which uses dtoa) to convert the double into a string. Apply some extra operations to make it mimic the String::format("%.6lg") output (cut off trailing zeros 1.5000 -> 1.5, leave integers unchanged 12.000 -> 12) > > So, the question here is, what do we want String::number() to do? Right. > > * The rules for number to String conversion are different in different web technology specifications. > * SVG has an uncommon requirement, in that it never overflows to an exponential representation. > * HTML5 and ECMAScript agree on number-to-string conversion (in that the HTML5 spec requires ECMAScript conversion). SVGs requirement is uncommon right, but we don't want this for the render path dumps, we definately want exponential numbers in the SVG DRT dumps. > > My thought here is that we want String::number() to match HTML5/ECMAScript number-to-string conversion. That is to say, like UString::number it should call WTF::numberToString in dtoa.h, which wraps DecimalNumber with appropriate bounds (<10^-6 & >=10^21) spilling to exponential representation. Correct. > > We should probably add a different method specifically for SVG's number-to-string behaviour. This could be a free function within the svg code, taking a double and returning an String. This method should also be able to use DecimalNumber in its implementation, but would likely chose to always call toStringDecimal, rather than toStringExponential. I'm not sure if we need a special SVG method, I'd rather prefer an enum that describes how the number conversion should happen. The default should match HTML5/ECMAScript. > > If elsewhere in the code we do require numbers formatted in a specific fashion (with a fixed number of digits, or significant figures) we should add methods to convert with appropriate constraints as necessary. Hopefully we shouldn't need to mimic "%.6lg" behaviour, since this is not spec defined, probably doesn't match other browsers, and as such is hopefully not relied on anywhere. Changing this should probably only fix spec compliance. I tried to mimic the output initially to reduce the DRT changes for SVG, to see wheter the patch would fix the rounding issues between gtk 32bit and 64bit. It's not a requirment to mimic the output of String::format, agreed. > > How does this sound? Excellent! I'm happy to work on this, I hope you already wrote the String::cat stuff? If yes, I'd work on a String::number() implementation (like the one in my attached patch) which gives us more flexibility (add an FloatingPointConversionMode enum, with AvoidExponentials, RoundSiginifcantFigures, RoundDecimalPlaces modes, that can be OR'ed together, etc..) How does this sound? :-) 292649 118 barraclough 2010-10-11 14:18:53 -0700 > > In a trivial implementation all arguments would be 'const String&'s, and String::cat() could just wrap StringBuilder (rather than using StringBuilder directly) such that the internal implementation can be improved later. > Excellent, that would be really handy. Do you have already started coding this? I haven't, but this should be pretty trivial: String String::cat(const String& s1, const String& s2) { StringBuilder builder; builder.append(s1); builder.append(s2); return builder.toSting(); } String String::cat(const String& s1, const String& s2, const String& s3) { StringBuilder builder; builder.append(s1); builder.append(s2); builder.append(s3); return builder.toSting(); } And so on for more more arguments. One problem, I think StringBuilder is currently in WebCore, not WTF, if should move to wtf/text with the rest of the string code. (I have a patch I'm working on to rewrite StringBuilder, so we may conflict a little there, but if you're just moving the code should be easy to resolve for whoever lands second!) > > A better implementation we could make the arguments to cat be templated such that data could be added to the string without converting all arguments to String format first. We already have this implemented in JavaScriptCore (and since we're close to unifying the string implementations we could ultimately fully share this code), in a set of methods called makeString. These allow an arbitrary mix of UStrings and plain C-strings to be concatenated together, without first converting the C-strings to Strings. > I see, seems like it would be very wise to share the code in wtf/. *nod. The only reason this code is currently JSC specific is because it works on UStrings not Strings, and the difference in String::number & UString::number is one of the few remaining issues to resolve before we can remove UString, so this change should get us closer. > > * The rules for number to String conversion are different in different web technology specifications. > > * SVG has an uncommon requirement, in that it never overflows to an exponential representation. > > * HTML5 and ECMAScript agree on number-to-string conversion (in that the HTML5 spec requires ECMAScript conversion). > SVGs requirement is uncommon right, but we don't want this for the render path dumps, we definately want exponential numbers in the SVG DRT dumps. Ah I see, yes okay. so for these cases the HTML5/ECMAScript behaviour should probably be okay? > > We should probably add a different method specifically for SVG's number-to-string behaviour. This could be a free function within the svg code, taking a double and returning an String. This method should also be able to use DecimalNumber in its implementation, but would likely chose to always call toStringDecimal, rather than toStringExponential. > I'm not sure if we need a special SVG method, I'd rather prefer an enum that describes how the number conversion should happen. The default should match HTML5/ECMAScript. > > Excellent! I'm happy to work on this, I hope you already wrote the String::cat stuff? If yes, I'd work on a String::number() implementation (like the one in my attached patch) which gives us more flexibility (add an FloatingPointConversionMode enum, with AvoidExponentials, RoundSiginifcantFigures, RoundDecimalPlaces modes, that can be OR'ed together, etc..) My main concern here would be that UString::number can be a hot function, so it would probably be undesirable to add unnecessary overhead to switch on a parameter to check the conversion type. Also, there may be some subtleties to the requirements of any other conversion functions, so we may be better adding them as we need them. For example, the decimal number conversion uses a fixed size buffer on the stack, which would not be safe to convert large double values to decimal format. To safely use this conversion the simple solution would probably be to truncate values into a range (which I believe is explicitly permitted in the SVG spec, Simon?) – however String::number having this truncation built in would be a little weird and arbirtary. Also, to-fixed methods may require a precision argument. So perhaps it would just be best to switch String::number to have the HTML5/ECMAScript behaviour (matching UString::number) for all uses, for now? 294053 119 zimmermann 2010-10-14 05:05:49 -0700 Linking some bug reports, that I've worked on in order to prepare fixing this bug. 294056 120 zimmermann 2010-10-14 05:15:11 -0700 (In reply to comment #118) Here are some news, for those that don't follow all webkit commits: > > Excellent, that would be really handy. Do you have already started coding this? > > I haven't, but this should be pretty trivial: > > String String::cat(const String& s1, const String& s2) .. This is obsolete now: we have wtf/text/StringConcatenate, solving this problem in an elegant and performant way. > And so on for more more arguments. One problem, I think StringBuilder is currently in WebCore, not WTF, if should move to wtf/text with the rest of the string code. (I have a patch I'm working on to rewrite StringBuilder, so we may conflict a little there, but if you're just moving the code should be easy to resolve for whoever lands second!) StringBuilder lives in wtf/text now, but using the more performant implementation based on runtime/StringBuilder. > > > SVGs requirement is uncommon right, but we don't want this for the render path dumps, we definately want exponential numbers in the SVG DRT dumps. > > Ah I see, yes okay. so for these cases the HTML5/ECMAScript behaviour should probably be okay? Exactly, the only drawback is that each expected.txt file is affected, but I think we can live with that, instead of inventing extra hacks (remove trailing zeros etc..) just for the sake of maintaining compatibility between the new & current DRT dump style. > > Excellent! I'm happy to work on this, I hope you already wrote the String::cat stuff? If yes, I'd work on a String::number() implementation (like the one in my attached patch) which gives us more flexibility (add an FloatingPointConversionMode enum, with AvoidExponentials, RoundSiginifcantFigures, RoundDecimalPlaces modes, that can be OR'ed together, etc..) > > My main concern here would be that UString::number can be a hot function, so it would probably be undesirable to add unnecessary overhead to switch on a parameter to check the conversion type. Also, there may be some subtleties to the requirements of any other conversion functions, so we may be better adding them as we need them. For example, the decimal number conversion uses a fixed size buffer on the stack, which would not be safe to convert large double values to decimal format. To safely use this conversion the simple solution would probably be to truncate values into a range (which I believe is explicitly permitted in the SVG spec, Simon?) – however String::number having this truncation built in would be a little weird and arbirtary. Also, to-fixed methods may require a precision argument. I made up my mind, and think we should have a simple String::number(double) method which serializes the double using the numberToString() method (which uses DecimalNumber) to match the HTML5/ECMAScript default way of doing this. I'm concerned as well to add any extra logic, given the fact we ideally want to switch from UString to WTFString soon. We can add another method, which takes a precision argument, with explicit naming, whenever we need it (String::numberRoundingSignificantFigures(number, 6)) etc.. > > So perhaps it would just be best to switch String::number to have the HTML5/ECMAScript behaviour (matching UString::number) for all uses, for now? Definately. I'm still preparing patches, before I can actually work on fixing String::number. My current plan is: 1) Remove all "simple" String::format usage (no floating-point formatting involved, no pointer dumps) from all of WebCore/WebKit - replace by StringConcatenate (see bug 47664) 2) Identify a common set of missing methods that would be needed to replace the rest of the String::format usages (String::numberAsHex, etc.) 3) Implement them, kill String::format completly. 4) Be happy! :-) 295124 121 webkit.review.bot 2010-10-16 05:44:48 -0700 Attachment 70394 did not build on win: Build output: http://queues.webkit.org/results/4436061 295158 122 70394 simon.fraser 2010-10-16 13:45:30 -0700 Comment on attachment 70394 Work in progress DecimalNumber is the correct approach. See bug 20674. 295201 123 zimmermann 2010-10-17 02:19:37 -0700 (In reply to comment #122) > (From update of attachment 70394 [details]) > DecimalNumber is the correct approach. See bug 20674. Yeah, just as we discussed above. I forgot to clear the r?. 295275 124 simon.fraser 2010-10-17 13:07:26 -0700 Fixed in http://trac.webkit.org/changeset/69928 23471 2008-09-16 07:18:07 -0700 2009-10-06 16:32:27 -0700 Deprecate String::format() string-format.patch text/plain 34861 alp SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNjUwMSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNzIgQEAKKzIwMDgtMDktMTYgIEFscCBUb2tlciAgPGFscEBudWFudGkuY29tPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODk5NAorICAgICAgICBMQU5HL0xDX0FM TCBpbmZsdWVuY2VzIHRoZSByZXN1bHQgb2YgZWxlbWVudC5zdHlsZS5vcGFjaXR5CisKKyAgICAg ICAgVXNlIFVTdHJpbmc6OmZyb20oKSBpbnN0ZWFkIG9mIFN0cmluZzo6Zm9ybWF0KCkgaW4gU3Ry aW5nOjpudW1iZXIoKQorICAgICAgICBmdW5jdGlvbnMgd2hlcmUgcG9zc2libGUuCisKKyAgICAg ICAgU3RhcnQgdG8gcmVwbGFjZSB1c2VzIG9mIFN0cmluZzo6Zm9ybWF0KCkgaW4gV2ViQ29yZSB3 aXRoCisgICAgICAgIFN0cmluZ0J1aWxkZXIgYW5kIGRpcmVjdCBjb25jYXRlbmF0aW9uLgorCisg ICAgICAgIEFzIGEgc2lkZS1lZmZlY3QsIHNldmVyYWwgaW5jb3JyZWN0IG9yIG5lZWRsZXNzIHN0 cmluZyBjb252ZXJzaW9ucworICAgICAgICB0aGF0IHdlcmUgZG9uZSBieSBTdHJpbmc6OmZvcm1h dCgpIGNhbGxlcnMgYXJlIG5vdyBhdm9pZGVkLgorCisgICAgICAgIFN0cmluZzo6Zm9ybWF0KCkg c2hvdWxkIG5vdCBiZSB1c2VkIGluIG5ldyBjb2RlLgorCisgICAgICAgICogYmluZGluZ3MvanMv SlNET01XaW5kb3dCYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkpTRE9NV2luZG93QmFzZTo6 Y3Jvc3NEb21haW5BY2Nlc3NFcnJvck1lc3NhZ2UpOgorICAgICAgICAqIGNzcy9DU1NQcmltaXRp dmVWYWx1ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4 dCk6CisgICAgICAgICogZG9tL0V4Y2VwdGlvbkJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RXhjZXB0aW9uQmFzZTo6RXhjZXB0aW9uQmFzZSk6CisgICAgICAgICogZG9tL1hNTFRva2VuaXpl ci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxUb2tlbml6ZXI6OmhhbmRsZUVycm9yKToKKyAg ICAgICAgKFdlYkNvcmU6OlhNTFRva2VuaXplcjo6aW5zZXJ0RXJyb3JNZXNzYWdlQmxvY2spOgor ICAgICAgICAqIGRvbS9YTUxUb2tlbml6ZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvRG9jTG9hZGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY0xvYWRlcjo6cHJpbnRBY2Nlc3NEZW5pZWRNZXNz YWdlKToKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXI6OnNob3VsZEFsbG93TmF2aWdhdGlvbik6CisgICAgICAgICogcGFnZS9E T01XaW5kb3cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93Ojpwb3N0TWVzc2FnZVRp bWVyRmlyZWQpOgorICAgICAgICAqIHBhZ2UvSW5zcGVjdG9yQ29udHJvbGxlci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpJbnNwZWN0b3JDb250cm9sbGVyOjpjb3VudCk6CisgICAgICAgICogcGxh dGZvcm0vdGV4dC9TdHJpbmcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3RyaW5nOjpudW1iZXIp OgorICAgICAgICAqIHBsdWdpbnMvUGx1Z2luU3RyZWFtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlBsdWdpblN0cmVhbTo6c3RhcnRTdHJlYW0pOgorICAgICAgICAqIHN2Zy9TVkdBbmltYXRlZFRl bXBsYXRlLmg6CisgICAgICAgIChXZWJDb3JlOjopOgorICAgICAgICAqIHN2Zy9TVkdQYXRoU2Vn Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdQYXRoU2VnU2luZ2xlQ29vcmQ6OnRvU3RyaW5nKToK KyAgICAgICAgKiBzdmcvU1ZHUGF0aFNlZ0FyYy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdQ YXRoU2VnQXJjOjp0b1N0cmluZyk6CisgICAgICAgICogc3ZnL1NWR1BhdGhTZWdBcmMuaDoKKyAg ICAgICAgKiBzdmcvU1ZHUGF0aFNlZ0N1cnZldG9DdWJpYy5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpTVkdQYXRoU2VnQ3VydmV0b0N1YmljOjp0b1N0cmluZyk6CisgICAgICAgICogc3ZnL1NWR1Bh dGhTZWdDdXJ2ZXRvQ3ViaWMuaDoKKyAgICAgICAgKiBzdmcvU1ZHUGF0aFNlZ0N1cnZldG9DdWJp Y1Ntb290aC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdQYXRoU2VnQ3VydmV0b0N1YmljU21v b3RoOjp0b1N0cmluZyk6CisgICAgICAgICogc3ZnL1NWR1BhdGhTZWdDdXJ2ZXRvQ3ViaWNTbW9v dGguaDoKKyAgICAgICAgKiBzdmcvU1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0aWMuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6U1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0aWM6OnRvU3RyaW5nKToKKyAg ICAgICAgKiBzdmcvU1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0aWMuaDoKKyAgICAgICAgKiBzdmcv U1ZHUGF0aFNlZ0xpbmV0b0hvcml6b250YWwuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1BhdGhT ZWdMaW5ldG9Ib3Jpem9udGFsOjp0b1N0cmluZyk6CisgICAgICAgICogc3ZnL1NWR1BhdGhTZWdM aW5ldG9WZXJ0aWNhbC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUGF0aFNlZ0xpbmV0b1ZlcnRp Y2FsOjp0b1N0cmluZyk6CisgICAgICAgICogc3ZnL1NWR1BvaW50TGlzdC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpTVkdQb2ludExpc3Q6OnZhbHVlQXNTdHJpbmcpOgorICAgICAgICAqIHN2Zy9T VkdUcmFuc2Zvcm1MaXN0LmNwcDoKKyAgICAgICAgKFNWR1RyYW5zZm9ybUxpc3Q6OnZhbHVlQXNT dHJpbmcpOgorICAgICAgICAqIHN2Zy9TVkdVc2VFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmR1bXBJbnN0YW5jZVRyZWUpOgorICAgICAgICAoV2ViQ29yZTo6U1ZHVXNlRWxlbWVudDo6 YnVpbGRQZW5kaW5nUmVzb3VyY2UpOgorICAgICAgICAoV2ViQ29yZTo6U1ZHVXNlRWxlbWVudDo6 ZXhwYW5kVXNlRWxlbWVudHNJblNoYWRvd1RyZWUpOgorCiAyMDA4LTA5LTE1ICBSb2IgQnVpcyAg PGJ1aXNAa2RlLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljLgpJbmRleDogV2ViQ29y ZS9iaW5kaW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv YmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJD b3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI0 LDcgKzI0LDYgQEAKICNpbmNsdWRlICJKU0RPTVdpbmRvd0Jhc2UuaCIKIAogI2luY2x1ZGUgIkJh c2U2NC5oIgotI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJDb25zb2xlLmgiCiAjaW5j bHVkZSAiRE9NV2luZG93LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgpAQCAtNzgzLDggKzc4Miwx MiBAQCBTdHJpbmcgSlNET01XaW5kb3dCYXNlOjpjcm9zc0RvbWFpbkFjY2VzCiAgICAgICAgIHJl dHVybiBTdHJpbmcoKTsKIAogICAgIC8vIEZJWE1FOiB0aGlzIGVycm9yIG1lc3NhZ2Ugc2hvdWxk IGNvbnRhaW4gbW9yZSBzcGVjaWZpY3Mgb2Ygd2h5IHRoZSBzYW1lIG9yaWdpbiBjaGVjayBoYXMg ZmFpbGVkLgotICAgIHJldHVybiBTdHJpbmc6OmZvcm1hdCgiVW5zYWZlIEphdmFTY3JpcHQgYXR0 ZW1wdCB0byBhY2Nlc3MgZnJhbWUgd2l0aCBVUkwgJXMgZnJvbSBmcmFtZSB3aXRoIFVSTCAlcy4g RG9tYWlucywgcHJvdG9jb2xzIGFuZCBwb3J0cyBtdXN0IG1hdGNoLlxuIiwKLSAgICAgICAgdGFy Z2V0VVJMLnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIG9yaWdpblVSTC5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKKyAgICBTdHJpbmcgbWVzc2FnZSA9ICJVbnNhZmUgSmF2YVNjcmlwdCBhdHRlbXB0 IHRvIGFjY2VzcyBmcmFtZSB3aXRoIFVSTCAiOworICAgIG1lc3NhZ2UgKz0gdGFyZ2V0VVJMLnN0 cmluZygpOworICAgIG1lc3NhZ2UgKz0gIiBmcm9tIGZyYW1lIHdpdGggVVJMICI7CisgICAgbWVz c2FnZSArPSBvcmlnaW5VUkwuc3RyaW5nKCk7CisgICAgbWVzc2FnZSArPSAiLiBEb21haW5zLCBw cm90b2NvbHMgYW5kIHBvcnRzIG11c3QgbWF0Y2guXG4iOworICAgIHJldHVybiBtZXNzYWdlOwog fQogCiB2b2lkIEpTRE9NV2luZG93QmFzZTo6cHJpbnRFcnJvck1lc3NhZ2UoY29uc3QgU3RyaW5n JiBtZXNzYWdlKSBjb25zdApJbmRleDogV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkocmV2aXNp b24gMzY0OTcpCisrKyBXZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTEsNiArMSw3IEBACiAvKgogICogKEMpIDE5OTktMjAwMyBMYXJzIEtub2xsIChr bm9sbEBrZGUub3JnKQogICogQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3LCAy MDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAw OCBBbHAgVG9rZXIgPGFscEBhdG9rZXIuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC02MjMs NTIgKzYyNCw1MiBAQCBTdHJpbmcgQ1NTUHJpbWl0aXZlVmFsdWU6OmNzc1RleHQoKSBjb25zCiAg ICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pOwogICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BFUkNFTlRBR0U6Ci0gICAgICAgICAgICB0ZXh0 ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnJSUiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ID0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pICsgIiUiOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX0VNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZv cm1hdCgiJS42bGdlbSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6 Om51bWJlcihtX3ZhbHVlLm51bSkgKyAiZW0iOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGNhc2UgQ1NTX0VYUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdl eCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51bWJlcihtX3Zh bHVlLm51bSkgKyAiZXgiOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BY OgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3B4IiwgbV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUubnVtKSArICJw eCI7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfQ006Ci0gICAgICAgICAg ICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnY20iLCBtX3ZhbHVlLm51bSk7CisgICAgICAg ICAgICB0ZXh0ID0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pICsgImNtIjsKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19NTToKLSAgICAgICAgICAgIHRleHQgPSBTdHJp bmc6OmZvcm1hdCgiJS42bGdtbSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBT dHJpbmc6Om51bWJlcihtX3ZhbHVlLm51bSkgKyAibW0iOwogICAgICAgICAgICAgYnJlYWs7CiAg ICAgICAgIGNhc2UgQ1NTX0lOOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIl LjZsZ2luIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVy KG1fdmFsdWUubnVtKSArICJpbiI7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBD U1NfUFQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncHQiLCBtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0p ICsgInB0IjsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19QQzoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdwYyIsIG1fdmFsdWUubnVtKTsKKyAg ICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51bWJlcihtX3ZhbHVlLm51bSkgKyAicGMiOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0RFRzoKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdkZWciLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ID0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pICsgImRlZyI7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfUkFEOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 Zm9ybWF0KCIlLjZsZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBTdHJp bmc6Om51bWJlcihtX3ZhbHVlLm51bSkgKyAicmFkIjsKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19HUkFEOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIl LjZsZ2dyYWQiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpudW1i ZXIobV92YWx1ZS5udW0pICsgImdyYWQiOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX01TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21zIiwg bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUu bnVtKSArICJtcyI7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUzoKLSAg ICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdzIiwgbV92YWx1ZS5udW0pOwor ICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUubnVtKSArICJzIjsKICAg ICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19IWjoKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdoeiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBTdHJpbmc6Om51bWJlcihtX3ZhbHVlLm51bSkgKyAiaHoiOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX0tIWjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZv cm1hdCgiJS42bGdraHoiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gU3RyaW5n OjpudW1iZXIobV92YWx1ZS5udW0pICsgImtoeiI7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBDU1NfRElNRU5TSU9OOgogICAgICAgICAgICAgLy8gRklYTUUKSW5kZXg6IFdlYkNv cmUvZG9tL0V4Y2VwdGlvbkJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0V4Y2Vw dGlvbkJhc2UuY3BwCShyZXZpc2lvbiAzNjQ5NykKKysrIFdlYkNvcmUvZG9tL0V4Y2VwdGlvbkJh c2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiw5ICszNiw5IEBAIEV4Y2VwdGlvbkJhc2U6OkV4 Y2VwdGlvbkJhc2UoY29uc3QgRXhjZXAKICAgICAsIG1fbmFtZShkZXNjcmlwdGlvbi5uYW1lKQog ewogICAgIGlmIChkZXNjcmlwdGlvbi5uYW1lKQotICAgICAgICBtX21lc3NhZ2UgPSBTdHJpbmc6 OmZvcm1hdCgiJXM6ICVzIEV4Y2VwdGlvbiAlZCIsIGRlc2NyaXB0aW9uLm5hbWUsIGRlc2NyaXB0 aW9uLnR5cGVOYW1lLCBkZXNjcmlwdGlvbi5jb2RlKTsKLSAgICBlbHNlCi0gICAgICAgIG1fbWVz c2FnZSA9IFN0cmluZzo6Zm9ybWF0KCIlcyBFeGNlcHRpb24gJWQiLCBkZXNjcmlwdGlvbi50eXBl TmFtZSwgZGVzY3JpcHRpb24uY29kZSk7CisgICAgICAgIG1fbWVzc2FnZSA9IFN0cmluZyhkZXNj cmlwdGlvbi5uYW1lKSArICI6ICI7CisKKyAgICBtX21lc3NhZ2UgKz0gU3RyaW5nKGRlc2NyaXB0 aW9uLnR5cGVOYW1lKSArICIgRXhjZXB0aW9uICIgKyBTdHJpbmc6Om51bWJlcihkZXNjcmlwdGlv bi5jb2RlKTsKIH0KIAogU3RyaW5nIEV4Y2VwdGlvbkJhc2U6OnRvU3RyaW5nKCkgY29uc3QKSW5k ZXg6IFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9k b20vWE1MVG9rZW5pemVyLmNwcAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3JlL2RvbS9YTUxU b2tlbml6ZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0 IChDKSAyMDA2IEFsZXhleSBQcm9za3VyeWFrb3YgKGFwQHdlYmtpdC5vcmcpCiAgKiBDb3B5cmln aHQgKEMpIDIwMDcgU2FtdWVsIFdlaW5pZyAoc2FtQHdlYmtpdC5vcmcpCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDcgVHJvbGx0ZWNoIEFTQQorICogQ29weXJpZ2h0IChDKSAyMDA4IEFscCBUb2tlciA8 YWxwQGF0b2tlci5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTEzMDAsMTIgKzEzMDEsMTgg QEAgdm9pZCBYTUxUb2tlbml6ZXI6OmhhbmRsZUVycm9yKEVycm9yVHlwZQogICAgIGlmICh0eXBl ID09IGZhdGFsIHx8IChtX2Vycm9yQ291bnQgPCBtYXhFcnJvcnMgJiYgbV9sYXN0RXJyb3JMaW5l ICE9IGxpbmVOdW1iZXIgJiYgbV9sYXN0RXJyb3JDb2x1bW4gIT0gY29sdW1uTnVtYmVyKSkgewog ICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKICAgICAgICAgICAgIGNhc2Ugd2FybmluZzoKLSAgICAg ICAgICAgICAgICBtX2Vycm9yTWVzc2FnZXMgKz0gU3RyaW5nOjpmb3JtYXQoIndhcm5pbmcgb24g bGluZSAlZCBhdCBjb2x1bW4gJWQ6ICVzIiwgbGluZU51bWJlciwgY29sdW1uTnVtYmVyLCBtKTsK KyAgICAgICAgICAgICAgICBtX2Vycm9yTWVzc2FnZXMuYXBwZW5kKCJ3YXJuaW5nIik7CiAgICAg ICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICBjYXNlIGZhdGFsOgogICAgICAgICAgICAg Y2FzZSBub25GYXRhbDoKLSAgICAgICAgICAgICAgICBtX2Vycm9yTWVzc2FnZXMgKz0gU3RyaW5n Ojpmb3JtYXQoImVycm9yIG9uIGxpbmUgJWQgYXQgY29sdW1uICVkOiAlcyIsIGxpbmVOdW1iZXIs IGNvbHVtbk51bWJlciwgbSk7CisgICAgICAgICAgICAgICAgbV9lcnJvck1lc3NhZ2VzLmFwcGVu ZCgiZXJyb3IiKTsKICAgICAgICAgfQorICAgICAgICBtX2Vycm9yTWVzc2FnZXMuYXBwZW5kKCIg b24gbGluZSAiKTsKKyAgICAgICAgbV9lcnJvck1lc3NhZ2VzLmFwcGVuZChTdHJpbmc6Om51bWJl cihsaW5lTnVtYmVyKSk7CisgICAgICAgIG1fZXJyb3JNZXNzYWdlcy5hcHBlbmQoIiBhdCBjb2x1 bW4gIik7CisgICAgICAgIG1fZXJyb3JNZXNzYWdlcy5hcHBlbmQoU3RyaW5nOjpudW1iZXIoY29s dW1uTnVtYmVyKSk7CisgICAgICAgIG1fZXJyb3JNZXNzYWdlcy5hcHBlbmQoIjogIik7CisgICAg ICAgIG1fZXJyb3JNZXNzYWdlcy5hcHBlbmQobSk7CiAgICAgICAgIAogICAgICAgICBtX2xhc3RF cnJvckxpbmUgPSBsaW5lTnVtYmVyOwogICAgICAgICBtX2xhc3RFcnJvckNvbHVtbiA9IGNvbHVt bk51bWJlcjsKQEAgLTE0OTksNyArMTUwNiw3IEBAIHZvaWQgWE1MVG9rZW5pemVyOjppbnNlcnRF cnJvck1lc3NhZ2VCbG8KICAgICB9CiAjZW5kaWYKIAotICAgIFJlZlB0cjxFbGVtZW50PiByZXBv cnRFbGVtZW50ID0gY3JlYXRlWEhUTUxQYXJzZXJFcnJvckhlYWRlcihkb2MsIG1fZXJyb3JNZXNz YWdlcyk7CisgICAgUmVmUHRyPEVsZW1lbnQ+IHJlcG9ydEVsZW1lbnQgPSBjcmVhdGVYSFRNTFBh cnNlckVycm9ySGVhZGVyKGRvYywgbV9lcnJvck1lc3NhZ2VzLnRvU3RyaW5nKCkpOwogICAgIGRv Y3VtZW50RWxlbWVudC0+aW5zZXJ0QmVmb3JlKHJlcG9ydEVsZW1lbnQsIGRvY3VtZW50RWxlbWVu dC0+Zmlyc3RDaGlsZCgpLCBlYyk7CiAjaWYgRU5BQkxFKFhTTFQpCiAgICAgaWYgKGRvYy0+dHJh bnNmb3JtU291cmNlRG9jdW1lbnQoKSkgewpJbmRleDogV2ViQ29yZS9kb20vWE1MVG9rZW5pemVy LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vWE1MVG9rZW5pemVyLmgJKHJldmlzaW9uIDM2 NDk3KQorKysgV2ViQ29yZS9kb20vWE1MVG9rZW5pemVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTI3 LDYgKzI3LDcgQEAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgogI2luY2x1ZGUg IkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2VnbWVudGVkU3RyaW5nLmgiCisj aW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgogI2luY2x1ZGUgIlN0cmluZ0hhc2guaCIKICNpbmNs dWRlICJUb2tlbml6ZXIuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgpAQCAtMTUzLDcgKzE1 NCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgaW50IG1fZXJyb3JDb3VudDsKICAg ICAgICAgaW50IG1fbGFzdEVycm9yTGluZTsKICAgICAgICAgaW50IG1fbGFzdEVycm9yQ29sdW1u OwotICAgICAgICBTdHJpbmcgbV9lcnJvck1lc3NhZ2VzOworICAgICAgICBTdHJpbmdCdWlsZGVy IG1fZXJyb3JNZXNzYWdlczsKIAogICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRT Y3JpcHQ+IG1fcGVuZGluZ1NjcmlwdDsKICAgICAgICAgUmVmUHRyPEVsZW1lbnQ+IG1fc2NyaXB0 RWxlbWVudDsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9sb2FkZXIvRG9jTG9hZGVyLmNwcAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJD b3JlL2xvYWRlci9Eb2NMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMyw3ICszMyw2IEBA CiAjaW5jbHVkZSAiQ2FjaGVkU2NyaXB0LmgiCiAjaW5jbHVkZSAiQ2FjaGVkWFNMU3R5bGVTaGVl dC5oIgogI2luY2x1ZGUgIkNvbnNvbGUuaCIKLSNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVk ZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJET01XaW5kb3cuaCIKICNpbmNsdWRlICJGcmFtZS5o IgpAQCAtMjExLDEzICsyMTAsMTMgQEAgdm9pZCBEb2NMb2FkZXI6OnByaW50QWNjZXNzRGVuaWVk TWVzc2FnZQogICAgIGlmICghc2V0dGluZ3MgfHwgc2V0dGluZ3MtPnByaXZhdGVCcm93c2luZ0Vu YWJsZWQoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgU3RyaW5nIG1lc3NhZ2UgPSBtX2RvYy0+ dXJsKCkuaXNOdWxsKCkgPwotICAgICAgICBTdHJpbmc6OmZvcm1hdCgiVW5zYWZlIGF0dGVtcHQg dG8gbG9hZCBVUkwgJXMuIiwKLSAgICAgICAgICAgICAgICAgICAgICAgdXJsLnN0cmluZygpLnV0 ZjgoKS5kYXRhKCkpIDoKLSAgICAgICAgU3RyaW5nOjpmb3JtYXQoIlVuc2FmZSBhdHRlbXB0IHRv IGxvYWQgVVJMICVzIGZyb20gZnJhbWUgd2l0aCBVUkwgJXMuICIKLSAgICAgICAgICAgICAgICAg ICAgICAgIkRvbWFpbnMsIHByb3RvY29scyBhbmQgcG9ydHMgbXVzdCBtYXRjaC5cbiIsCi0gICAg ICAgICAgICAgICAgICAgICAgIHVybC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpLAotICAgICAgICAg ICAgICAgICAgICAgICBtX2RvYy0+dXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAg U3RyaW5nIG1lc3NhZ2UgPSAiVW5zYWZlIGF0dGVtcHQgdG8gbG9hZCBVUkwgIiArIHVybC5zdHJp bmcoKTsKKyAgICBpZiAobV9kb2MtPnVybCgpLmlzTnVsbCgpKQorICAgICAgICBtZXNzYWdlICs9 ICIuIjsKKyAgICBlbHNlIHsKKyAgICAgICAgbWVzc2FnZSArPSAiIGZyb20gZnJhbWUgd2l0aCBV UkwgIiArIG1fZG9jLT51cmwoKS5zdHJpbmcoKTsKKyAgICAgICAgbWVzc2FnZSArPSAiLiBEb21h aW5zLCBwcm90b2NvbHMgYW5kIHBvcnRzIG11c3QgbWF0Y2guXG4iOworICAgIH0KIAogICAgIC8v IEZJWE1FOiBwcm92aWRlIGEgcmVhbCBsaW5lIG51bWJlciBhbmQgc291cmNlIFVSTC4KICAgICBm cmFtZSgpLT5kb21XaW5kb3coKS0+Y29uc29sZSgpLT5hZGRNZXNzYWdlKE90aGVyTWVzc2FnZVNv dXJjZSwgRXJyb3JNZXNzYWdlTGV2ZWwsIG1lc3NhZ2UsIDEsIFN0cmluZygpKTsKSW5kZXg6IFdl YkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRl ci9GcmFtZUxvYWRlci5jcHAJKHJldmlzaW9uIDM2NDk3KQorKysgV2ViQ29yZS9sb2FkZXIvRnJh bWVMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNTA2LDggKzI1MDYsMTIgQEAgYm9vbCBG cmFtZUxvYWRlcjo6c2hvdWxkQWxsb3dOYXZpZ2F0aW9uKAogICAgIGlmIChzZXR0aW5ncyAmJiAh c2V0dGluZ3MtPnByaXZhdGVCcm93c2luZ0VuYWJsZWQoKSkgewogICAgICAgICBEb2N1bWVudCog dGFyZ2V0RG9jdW1lbnQgPSB0YXJnZXRGcmFtZS0+ZG9jdW1lbnQoKTsKICAgICAgICAgLy8gRklY TUU6IHRoaXMgZXJyb3IgbWVzc2FnZSBzaG91bGQgY29udGFpbiBtb3JlIHNwZWNpZmljcyBvZiB3 aHkgdGhlIG5hdmlnYXRpb24gY2hhbmdlIGlzIG5vdCBhbGxvd2VkLgotICAgICAgICBTdHJpbmcg bWVzc2FnZSA9IFN0cmluZzo6Zm9ybWF0KCJVbnNhZmUgSmF2YVNjcmlwdCBhdHRlbXB0IHRvIGlu aXRpYXRlIGEgbmF2aWdhdGlvbiBjaGFuZ2UgZm9yIGZyYW1lIHdpdGggVVJMICVzIGZyb20gZnJh bWUgd2l0aCBVUkwgJXMuXG4iLAotICAgICAgICAgICAgdGFyZ2V0RG9jdW1lbnQtPnVybCgpLnN0 cmluZygpLnV0ZjgoKS5kYXRhKCksIGFjdGl2ZURvY3VtZW50LT51cmwoKS5zdHJpbmcoKS51dGY4 KCkuZGF0YSgpKTsKKworICAgICAgICBTdHJpbmcgbWVzc2FnZSA9ICJVbnNhZmUgSmF2YVNjcmlw dCBhdHRlbXB0IHRvIGluaXRpYXRlIGEgbmF2aWdhdGlvbiBjaGFuZ2UgZm9yIGZyYW1lIHdpdGgg VVJMICI7CisgICAgICAgIG1lc3NhZ2UgKz0gdGFyZ2V0RG9jdW1lbnQtPnVybCgpLnN0cmluZygp OworICAgICAgICBtZXNzYWdlICs9ICIgZnJvbSBmcmFtZSB3aXRoIFVSTCAiOworICAgICAgICBt ZXNzYWdlICs9IGFjdGl2ZURvY3VtZW50LT51cmwoKS5zdHJpbmcoKTsKKyAgICAgICAgbWVzc2Fn ZSArPSAiLlxuIjsKIAogICAgICAgICAvLyBGSVhNRTogc2hvdWxkIHdlIHByaW50IHRvIHRoZSBj b25zb2xlIG9mIHRoZSBhY3RpdmVGcmFtZSBhcyB3ZWxsPwogICAgICAgICB0YXJnZXRGcmFtZS0+ ZG9tV2luZG93KCktPmNvbnNvbGUoKS0+YWRkTWVzc2FnZShKU01lc3NhZ2VTb3VyY2UsIEVycm9y TWVzc2FnZUxldmVsLCBtZXNzYWdlLCAxLCBTdHJpbmcoKSk7CkluZGV4OiBXZWJDb3JlL3BhZ2Uv RE9NV2luZG93LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAko cmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAkod29ya2luZyBj b3B5KQpAQCAtMzAsNyArMzAsNiBAQAogI2luY2x1ZGUgIkNTU0NvbXB1dGVkU3R5bGVEZWNsYXJh dGlvbi5oIgogI2luY2x1ZGUgIkNTU1J1bGVMaXN0LmgiCiAjaW5jbHVkZSAiQ1NTU3R5bGVTZWxl Y3Rvci5oIgotI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJDaHJvbWUuaCIKICNpbmNs dWRlICJDb25zb2xlLmgiCiAjaW5jbHVkZSAiRE9NU2VsZWN0aW9uLmgiCkBAIC0zODUsOCArMzg0 LDggQEAgdm9pZCBET01XaW5kb3c6OnBvc3RNZXNzYWdlVGltZXJGaXJlZChQbwogICAgIGlmICh0 aW1lci0+dGFyZ2V0T3JpZ2luKCkpIHsKICAgICAgICAgLy8gQ2hlY2sgdGFyZ2V0IG9yaWdpbiBu b3cgc2luY2UgdGhlIHRhcmdldCBkb2N1bWVudCBtYXkgaGF2ZSBjaGFuZ2VkIHNpbmNlIHRoZSBz aW1lciB3YXMgc2NoZWR1bGVkLgogICAgICAgICBpZiAoIXRpbWVyLT50YXJnZXRPcmlnaW4oKS0+ aXNTYW1lU2NoZW1lSG9zdFBvcnQoZG9jdW1lbnQoKS0+c2VjdXJpdHlPcmlnaW4oKSkpIHsKLSAg ICAgICAgICAgIFN0cmluZyBtZXNzYWdlID0gU3RyaW5nOjpmb3JtYXQoIlVuYWJsZSB0byBwb3N0 IG1lc3NhZ2UgdG8gJXMuIFJlY2lwaWVudCBoYXMgb3JpZ2luICVzLlxuIiwgCi0gICAgICAgICAg ICAgICAgdGltZXItPnRhcmdldE9yaWdpbigpLT50b1N0cmluZygpLnV0ZjgoKS5kYXRhKCksIGRv Y3VtZW50KCktPnNlY3VyaXR5T3JpZ2luKCktPnRvU3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7Cisg ICAgICAgICAgICBTdHJpbmcgbWVzc2FnZSA9ICJVbmFibGUgdG8gcG9zdCBtZXNzYWdlIHRvICIg KyB0aW1lci0+dGFyZ2V0T3JpZ2luKCktPnRvU3RyaW5nKCkgKyAiLiI7CisgICAgICAgICAgICBt ZXNzYWdlICs9ICIgUmVjaXBpZW50IGhhcyBvcmlnaW4gIiArIGRvY3VtZW50KCktPnNlY3VyaXR5 T3JpZ2luKCktPnRvU3RyaW5nKCkgKyAiLlxuIjsKICAgICAgICAgICAgIGNvbnNvbGUoKS0+YWRk TWVzc2FnZShKU01lc3NhZ2VTb3VyY2UsIEVycm9yTWVzc2FnZUxldmVsLCBtZXNzYWdlLCAwLCBT dHJpbmcoKSk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KSW5kZXg6IFdlYkNvcmUv cGFnZS9JbnNwZWN0b3JDb250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2Uv SW5zcGVjdG9yQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDM2NDk3KQorKysgV2ViQ29yZS9wYWdl L0luc3BlY3RvckNvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOSw3ICsyOSw2IEBA CiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9yQ29udHJvbGxlci5oIgog Ci0jaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlLmgiCiAjaW5j bHVkZSAiQ29uc29sZS5oIgogI2luY2x1ZGUgIkRPTVdpbmRvdy5oIgpAQCAtMjU1Myw3ICsyNTUy LDcgQEAgdm9pZCBJbnNwZWN0b3JDb250cm9sbGVyOjpkcmF3Tm9kZUhpZ2hsaQogCiB2b2lkIElu c3BlY3RvckNvbnRyb2xsZXI6OmNvdW50KGNvbnN0IFVTdHJpbmcmIHRpdGxlLCB1bnNpZ25lZCBs aW5lTnVtYmVyLCBjb25zdCBTdHJpbmcmIHNvdXJjZUlEKQogewotICAgIFN0cmluZyBpZGVudGlm aWVyID0gU3RyaW5nKHRpdGxlKSArIFN0cmluZzo6Zm9ybWF0KCJAJXM6JWQiLCBzb3VyY2VJRC51 dGY4KCkuZGF0YSgpLCBsaW5lTnVtYmVyKTsKKyAgICBTdHJpbmcgaWRlbnRpZmllciA9IFN0cmlu Zyh0aXRsZSkgKyAiQCIgKyBzb3VyY2VJRCArICI6IiArIFN0cmluZzo6bnVtYmVyKGxpbmVOdW1i ZXIpOwogICAgIEhhc2hNYXA8U3RyaW5nLCB1bnNpZ25lZD46Oml0ZXJhdG9yIGl0ID0gbV9jb3Vu dHMuZmluZChpZGVudGlmaWVyKTsKICAgICBpbnQgY291bnQ7CiAgICAgaWYgKGl0ID09IG1fY291 bnRzLmVuZCgpKQpAQCAtMjU2NSw3ICsyNTY0LDcgQEAgdm9pZCBJbnNwZWN0b3JDb250cm9sbGVy Ojpjb3VudChjb25zdCBVUwogCiAgICAgbV9jb3VudHMuYWRkKGlkZW50aWZpZXIsIGNvdW50KTsK IAotICAgIFN0cmluZyBtZXNzYWdlID0gU3RyaW5nOjpmb3JtYXQoIiVzOiAlZCIsIHRpdGxlLlVU RjhTdHJpbmcoKS5jX3N0cigpLCBjb3VudCk7CisgICAgU3RyaW5nIG1lc3NhZ2UgPSBTdHJpbmco dGl0bGUpICsgIjogIiArIFN0cmluZzo6bnVtYmVyKGNvdW50KTsKICAgICBhZGRNZXNzYWdlVG9D b25zb2xlKEpTTWVzc2FnZVNvdXJjZSwgTG9nTWVzc2FnZUxldmVsLCBtZXNzYWdlLCBsaW5lTnVt YmVyLCBzb3VyY2VJRCk7CiB9CiAKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vdGV4dC9TdHJpbmcu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vdGV4dC9TdHJpbmcuY3BwCShyZXZp c2lvbiAzNjQ5NykKKysrIFdlYkNvcmUvcGxhdGZvcm0vdGV4dC9TdHJpbmcuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0xLDYgKzEsNyBAQAogLyoKICAqIChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xs QGtkZS5vcmcpCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDgg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA4IEFs cCBUb2tlciA8YWxwQGF0b2tlci5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTMxNCw2ICsz MTUsMTEgQEAgY29uc3QgVUNoYXIqIFN0cmluZzo6Y2hhcmFjdGVyc1dpdGhOdWxsVAogCiBTdHJp bmcgU3RyaW5nOjpmb3JtYXQoY29uc3QgY2hhciAqZm9ybWF0LCAuLi4pCiB7CisgICAgLy8gRklY TUU6IFRoaXMgZnVuY3Rpb24gaXMgZGVwcmVjYXRlZCBhbmQgc2hvdWxkIGV2ZW50dWFsbHkgYmUg cmVtb3ZlZCBmcm9tCisgICAgLy8gdGhlIFN0cmluZyBjbGFzcy4gSXQgcHJvZHVjZXMgaW5jb25z aXN0ZW50IHJlc3VsdHMgYmV0d2VlbiBwbGF0Zm9ybXMgYW5kCisgICAgLy8gZW5jb3VyYWdlcyBu ZWVkbGVzcyAob2Z0ZW4gaW5jb3JyZWN0KSBzdHJpbmcgY29udmVyc2lvbnMgaW4gY2FsbGluZwor ICAgIC8vIGNvZGUuCisKICNpZiBQTEFURk9STShRVCkKICAgICAvLyBVc2UgUVN0cmluZzo6dnNw cmludGYgdG8gYXZvaWQgdGhlIGxvY2FsZSBkZXBlbmRlbnQgZm9ybWF0dGluZyBvZiB2c25wcmlu dGYuCiAgICAgLy8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0 CkBAIC0zNjYsMjYgKzM3Miw0MCBAQCBTdHJpbmcgU3RyaW5nOjpmb3JtYXQoY29uc3QgY2hhciAq Zm9ybWF0CiAKIFN0cmluZyBTdHJpbmc6Om51bWJlcihpbnQgbikKIHsKKyNpZiBVU0UoSlNDKQor ICAgIHJldHVybiBTdHJpbmcoVVN0cmluZzo6ZnJvbShuKSk7CisjZWxzZQogICAgIHJldHVybiBT dHJpbmc6OmZvcm1hdCgiJWQiLCBuKTsKKyNlbmRpZgogfQogCiBTdHJpbmcgU3RyaW5nOjpudW1i ZXIodW5zaWduZWQgbikKIHsKKyNpZiBVU0UoSlNDKQorICAgIHJldHVybiBTdHJpbmcoVVN0cmlu Zzo6ZnJvbShuKSk7CisjZWxzZQogICAgIHJldHVybiBTdHJpbmc6OmZvcm1hdCgiJXUiLCBuKTsK KyNlbmRpZgogfQogCiBTdHJpbmcgU3RyaW5nOjpudW1iZXIobG9uZyBuKQogeworI2lmIFVTRShK U0MpCisgICAgcmV0dXJuIFN0cmluZyhVU3RyaW5nOjpmcm9tKG4pKTsKKyNlbHNlCiAgICAgcmV0 dXJuIFN0cmluZzo6Zm9ybWF0KCIlbGQiLCBuKTsKKyNlbmRpZgogfQogCiBTdHJpbmcgU3RyaW5n OjpudW1iZXIodW5zaWduZWQgbG9uZyBuKQogeworICAgIC8vIFRPRE86IFVzZSBVU3RyaW5nOjpm cm9tKCkKICAgICByZXR1cm4gU3RyaW5nOjpmb3JtYXQoIiVsdSIsIG4pOwogfQogCiBTdHJpbmcg U3RyaW5nOjpudW1iZXIobG9uZyBsb25nIG4pCiB7CisgICAgLy8gVE9ETzogVXNlIFVTdHJpbmc6 OmZyb20oKQogI2lmIFBMQVRGT1JNKFdJTl9PUykKICAgICByZXR1cm4gU3RyaW5nOjpmb3JtYXQo IiVJNjRpIiwgbik7CiAjZWxzZQpAQCAtMzk1LDYgKzQxNSw3IEBAIFN0cmluZyBTdHJpbmc6Om51 bWJlcihsb25nIGxvbmcgbikKIAogU3RyaW5nIFN0cmluZzo6bnVtYmVyKHVuc2lnbmVkIGxvbmcg bG9uZyBuKQogeworICAgIC8vIFRPRE86IFVzZSBVU3RyaW5nOjpmcm9tKCkKICNpZiBQTEFURk9S TShXSU5fT1MpCiAgICAgcmV0dXJuIFN0cmluZzo6Zm9ybWF0KCIlSTY0dSIsIG4pOwogI2Vsc2UK QEAgLTQwNCw3ICs0MjUsMTEgQEAgU3RyaW5nIFN0cmluZzo6bnVtYmVyKHVuc2lnbmVkIGxvbmcg bG9uZwogICAgIAogU3RyaW5nIFN0cmluZzo6bnVtYmVyKGRvdWJsZSBuKQogeworI2lmIFVTRShK U0MpCisgICAgcmV0dXJuIFN0cmluZyhVU3RyaW5nOjpmcm9tKG4pKTsKKyNlbHNlCiAgICAgcmV0 dXJuIFN0cmluZzo6Zm9ybWF0KCIlLjZsZyIsIG4pOworI2VuZGlmCiB9CiAKIGludCBTdHJpbmc6 OnRvSW50U3RyaWN0KGJvb2wqIG9rLCBpbnQgYmFzZSkgY29uc3QKSW5kZXg6IFdlYkNvcmUvcGx1 Z2lucy9QbHVnaW5TdHJlYW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGx1Z2lucy9QbHVn aW5TdHJlYW0uY3BwCShyZXZpc2lvbiAzNjQ5NykKKysrIFdlYkNvcmUvcGx1Z2lucy9QbHVnaW5T dHJlYW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNDIsNyArMTQyLDkgQEAgdm9pZCBQbHVnaW5T dHJlYW06OnN0YXJ0U3RyZWFtKCkKICAgICAgICAgVmVjdG9yPFVDaGFyPiBzdHJpbmdCdWlsZGVy OwogICAgICAgICBTdHJpbmcgc2VwYXJhdG9yKCI6ICIpOwogCi0gICAgICAgIFN0cmluZyBzdGF0 dXNMaW5lID0gU3RyaW5nOjpmb3JtYXQoIkhUVFAgJWx1IE9LXG4iLCBtX3Jlc291cmNlUmVzcG9u c2UuaHR0cFN0YXR1c0NvZGUoKSk7CisgICAgICAgIFN0cmluZyBzdGF0dXNMaW5lID0gIkhUVFAg IjsKKyAgICAgICAgc3RhdHVzTGluZSArPSBTdHJpbmc6Om51bWJlcihzdGF0aWNfY2FzdDx1bnNp Z25lZD4obV9yZXNvdXJjZVJlc3BvbnNlLmh0dHBTdGF0dXNDb2RlKCkpKTsKKyAgICAgICAgc3Rh dHVzTGluZSArPSAiIE9LXG4iOwogCiAgICAgICAgIHN0cmluZ0J1aWxkZXIuYXBwZW5kKHN0YXR1 c0xpbmUuY2hhcmFjdGVycygpLCBzdGF0dXNMaW5lLmxlbmd0aCgpKTsKIApJbmRleDogV2ViQ29y ZS9zdmcvU1ZHQW5pbWF0ZWRUZW1wbGF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3ZnL1NW R0FuaW1hdGVkVGVtcGxhdGUuaAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3JlL3N2Zy9TVkdB bmltYXRlZFRlbXBsYXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyNSw3ICsyMjUsMjEgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB0eXBlZGVmIEZsb2F0UmVjdCBEZWNvcmF0ZWRUeXBl OwogCiAgICAgICAgIHN0YXRpYyBGbG9hdFJlY3QgbnVsbCgpIHsgcmV0dXJuIEZsb2F0UmVjdCgp OyB9Ci0gICAgICAgIHN0YXRpYyBBdG9taWNTdHJpbmcgdG9TdHJpbmcoY29uc3QgRmxvYXRSZWN0 JiB0eXBlKSB7IHJldHVybiBTdHJpbmc6OmZvcm1hdCgiJWYgJWYgJWYgJWYiLCB0eXBlLngoKSwg dHlwZS55KCksIHR5cGUud2lkdGgoKSwgdHlwZS5oZWlnaHQoKSk7IH0KKworICAgICAgICBzdGF0 aWMgQXRvbWljU3RyaW5nIHRvU3RyaW5nKGNvbnN0IEZsb2F0UmVjdCYgdHlwZSkKKyAgICAgICAg eworICAgICAgICAgICAgU3RyaW5nIHZhbHVlOworCisgICAgICAgICAgICB2YWx1ZSArPSBTdHJp bmc6Om51bWJlcih0eXBlLngoKSk7CisgICAgICAgICAgICB2YWx1ZSArPSAiICI7CisgICAgICAg ICAgICB2YWx1ZSArPSBTdHJpbmc6Om51bWJlcih0eXBlLnkoKSk7CisgICAgICAgICAgICB2YWx1 ZSArPSAiICI7CisgICAgICAgICAgICB2YWx1ZSArPSBTdHJpbmc6Om51bWJlcih0eXBlLndpZHRo KCkpOworICAgICAgICAgICAgdmFsdWUgKz0gIiAiOworICAgICAgICAgICAgdmFsdWUgKz0gU3Ry aW5nOjpudW1iZXIodHlwZS5oZWlnaHQoKSk7CisKKyAgICAgICAgICAgIHJldHVybiB2YWx1ZTsK KyAgICAgICAgfQogICAgIH07CiAKICAgICB0ZW1wbGF0ZTw+CkluZGV4OiBXZWJDb3JlL3N2Zy9T VkdQYXRoU2VnLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZy5oCShyZXZp c2lvbiAzNjQ5NykKKysrIFdlYkNvcmUvc3ZnL1NWR1BhdGhTZWcuaAkod29ya2luZyBjb3B5KQpA QCAtODEsNyArODEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0WShm bG9hdCB5KSB7IG1feSA9IHk7IH0KICAgICAgICAgZmxvYXQgeSgpIGNvbnN0IHsgcmV0dXJuIG1f eTsgfQogCi0gICAgICAgIHZpcnR1YWwgU3RyaW5nIHRvU3RyaW5nKCkgY29uc3QgeyByZXR1cm4g cGF0aFNlZ1R5cGVBc0xldHRlcigpICsgU3RyaW5nOjpmb3JtYXQoIiAlLjZsZyAlLjZsZyIsIG1f eCwgbV95KTsgfQorICAgICAgICB2aXJ0dWFsIFN0cmluZyB0b1N0cmluZygpIGNvbnN0IHsgcmV0 dXJuIHBhdGhTZWdUeXBlQXNMZXR0ZXIoKSArICIgIiArIFN0cmluZzo6bnVtYmVyKG1feCkgKyAi ICIgKyBTdHJpbmc6Om51bWJlcihtX3kpOyB9CiAKICAgICBwcml2YXRlOgogICAgICAgICBmbG9h dCBtX3g7CkluZGV4OiBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQXJjLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQXJjLmNwcAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJD b3JlL3N2Zy9TVkdQYXRoU2VnQXJjLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMSw2ICsxLDcgQEAK IC8qCiAgICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2IE5pa29sYXMgWmltbWVybWFu biA8emltbWVybWFubkBrZGUub3JnPgogICAgICAgICAgICAgICAgICAgMjAwNCwgMjAwNSwgMjAw NiwgMjAwOCBSb2IgQnVpcyA8YnVpc0BrZGUub3JnPgorICAgIENvcHlyaWdodCAoQykgMjAwOCBB bHAgVG9rZXIgPGFscEBhdG9rZXIuY29tPgogCiAgICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhl IEtERSBwcm9qZWN0CiAKQEAgLTI0LDYgKzI1LDcgQEAKIAogI2lmIEVOQUJMRShTVkcpCiAjaW5j bHVkZSAiU1ZHUGF0aFNlZ0FyYy5oIgorI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKIAogbmFt ZXNwYWNlIFdlYkNvcmUgewogCkBAIC0zNyw4ICszOSwyOSBAQCBTVkdQYXRoU2VnQXJjUmVsOjpT VkdQYXRoU2VnQXJjUmVsKGZsb2F0CiB7CiB9CiAKK1N0cmluZyBTVkdQYXRoU2VnQXJjOjp0b1N0 cmluZygpIGNvbnN0Cit7CisgICAgU3RyaW5nQnVpbGRlciB2YWx1ZTsKKworICAgIHZhbHVlLmFw cGVuZChwYXRoU2VnVHlwZUFzTGV0dGVyKCkpOworICAgIHZhbHVlLmFwcGVuZCgnICcpOworICAg IHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3IxKSk7CisgICAgdmFsdWUuYXBwZW5kKCcg Jyk7CisgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fcjIpKTsKKyAgICB2YWx1ZS5h cHBlbmQoJyAnKTsKKyAgICB2YWx1ZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV9hbmdsZSkpOwor ICAgIHZhbHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihz dGF0aWNfY2FzdDxpbnQ+KG1fbGFyZ2VBcmNGbGFnKSkpOworICAgIHZhbHVlLmFwcGVuZCgnICcp OworICAgIHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihzdGF0aWNfY2FzdDxpbnQ+KG1fc3dl ZXBGbGFnKSkpOworICAgIHZhbHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVlLmFwcGVuZChTdHJp bmc6Om51bWJlcihtX3gpKTsKKyAgICB2YWx1ZS5hcHBlbmQoJyAnKTsKKyAgICB2YWx1ZS5hcHBl bmQoU3RyaW5nOjpudW1iZXIobV95KSk7CisKKyAgICByZXR1cm4gdmFsdWUudG9TdHJpbmcoKTsK IH0KIAotI2VuZGlmIC8vIEVOQUJMRShTVkcpCit9CiAKLS8vIHZpbTp0cz00Om5vZXQKKyNlbmRp ZiAvLyBFTkFCTEUoU1ZHKQpJbmRleDogV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZ0FyYy5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvc3ZnL1NWR1BhdGhTZWdBcmMuaAkocmV2aXNpb24gMzY0OTcpCisr KyBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQXJjLmgJKHdvcmtpbmcgY29weSkKQEAgLTM0LDcgKzM0 LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBTVkdQYXRoU2VnQXJjKGZsb2F0IHgs IGZsb2F0IHksIGZsb2F0IHIxLCBmbG9hdCByMiwgZmxvYXQgYW5nbGUsIGJvb2wgbGFyZ2VBcmNG bGFnLCBib29sIHN3ZWVwRmxhZykKICAgICAgICAgOiBtX3goeCksIG1feSh5KSwgbV9yMShyMSks IG1fcjIocjIpLCBtX2FuZ2xlKGFuZ2xlKSwgbV9sYXJnZUFyY0ZsYWcobGFyZ2VBcmNGbGFnKSwg bV9zd2VlcEZsYWcoc3dlZXBGbGFnKSB7fQogCi0gICAgICAgIHZpcnR1YWwgU3RyaW5nIHRvU3Ry aW5nKCkgY29uc3QgeyByZXR1cm4gcGF0aFNlZ1R5cGVBc0xldHRlcigpICsgU3RyaW5nOjpmb3Jt YXQoIiAlLjZsZyAlLjZsZyAlLjZsZyAlZCAlZCAlLjZsZyAlLjZsZyIsIG1fcjEsIG1fcjIsIG1f YW5nbGUsIG1fbGFyZ2VBcmNGbGFnLCBtX3N3ZWVwRmxhZywgbV94LCBtX3kpOyB9CisgICAgICAg IHZpcnR1YWwgU3RyaW5nIHRvU3RyaW5nKCkgY29uc3Q7CiAKICAgICAgICAgdm9pZCBzZXRYKGZs b2F0IHgpIHsgbV94ID0geDsgfQogICAgICAgICBmbG9hdCB4KCkgY29uc3QgeyByZXR1cm4gbV94 OyB9CkluZGV4OiBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljLmNwcAkocmV2aXNpb24g MzY0OTcpCisrKyBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMSw2ICsxLDcgQEAKIC8qCiAgICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1 LCAyMDA2IE5pa29sYXMgWmltbWVybWFubiA8emltbWVybWFubkBrZGUub3JnPgogICAgICAgICAg ICAgICAgICAgMjAwNCwgMjAwNSwgMjAwNiwgMjAwOCBSb2IgQnVpcyA8YnVpc0BrZGUub3JnPgor ICAgIENvcHlyaWdodCAoQykgMjAwOCBBbHAgVG9rZXIgPGFscEBhdG9rZXIuY29tPgogCiAgICAg VGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEtERSBwcm9qZWN0CiAKQEAgLTI0LDYgKzI1LDcgQEAK IAogI2lmIEVOQUJMRShTVkcpCiAjaW5jbHVkZSAiU1ZHUGF0aFNlZ0N1cnZldG9DdWJpYy5oIgor I2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0z Nyw4ICszOSwyNyBAQCBTVkdQYXRoU2VnQ3VydmV0b0N1YmljUmVsOjpTVkdQYXRoU2VnQ3VyCiB7 CiB9CiAKK1N0cmluZyBTVkdQYXRoU2VnQ3VydmV0b0N1YmljOjp0b1N0cmluZygpIGNvbnN0Cit7 CisgICAgU3RyaW5nQnVpbGRlciB2YWx1ZTsKKworICAgIHZhbHVlLmFwcGVuZChwYXRoU2VnVHlw ZUFzTGV0dGVyKCkpOworICAgIHZhbHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVlLmFwcGVuZChT dHJpbmc6Om51bWJlcihtX3gxKSk7CisgICAgdmFsdWUuYXBwZW5kKCcgJyk7CisgICAgdmFsdWUu YXBwZW5kKFN0cmluZzo6bnVtYmVyKG1feTEpKTsKKyAgICB2YWx1ZS5hcHBlbmQoJyAnKTsKKyAg ICB2YWx1ZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV94MikpOworICAgIHZhbHVlLmFwcGVuZCgn ICcpOworICAgIHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3kyKSk7CisgICAgdmFsdWUu YXBwZW5kKCcgJyk7CisgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1feCkpOworICAg IHZhbHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3kp KTsKKworICAgIHJldHVybiB2YWx1ZS50b1N0cmluZygpOwogfQogCi0jZW5kaWYgLy8gRU5BQkxF KFNWRykKK30KIAotLy8gdmltOnRzPTQ6bm9ldAorI2VuZGlmIC8vIEVOQUJMRShTVkcpCkluZGV4 OiBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9zdmcvU1ZHUGF0aFNlZ0N1cnZldG9DdWJpYy5oCShyZXZpc2lvbiAzNjQ5NykKKysrIFdl YkNvcmUvc3ZnL1NWR1BhdGhTZWdDdXJ2ZXRvQ3ViaWMuaAkod29ya2luZyBjb3B5KQpAQCAtMzMs NyArMzMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHVibGljOgogICAgICAgICBTVkdQ YXRoU2VnQ3VydmV0b0N1YmljKGZsb2F0IHgsIGZsb2F0IHksIGZsb2F0IHgxLCBmbG9hdCB5MSwg ZmxvYXQgeDIsIGZsb2F0IHkyKSA6IFNWR1BhdGhTZWcoKSAsIG1feCh4KSAsIG1feSh5KSAsIG1f eDEoeDEpICwgbV95MSh5MSkgLCBtX3gyKHgyKSAsIG1feTIoeTIpIHt9CiAKLSAgICAgICAgdmly dHVhbCBTdHJpbmcgdG9TdHJpbmcoKSBjb25zdCB7IHJldHVybiBwYXRoU2VnVHlwZUFzTGV0dGVy KCkgKyBTdHJpbmc6OmZvcm1hdCgiICUuNmxnICUuNmxnICUuNmxnICUuNmxnICUuNmxnICUuNmxn IiwgbV94MSwgbV95MSwgbV94MiwgbV95MiwgbV94LCBtX3kpOyB9CisgICAgICAgIHZpcnR1YWwg U3RyaW5nIHRvU3RyaW5nKCkgY29uc3Q7CiAKICAgICAgICAgdm9pZCBzZXRYKGZsb2F0IHgpIHsg bV94ID0geDsgfQogICAgICAgICBmbG9hdCB4KCkgY29uc3QgeyByZXR1cm4gbV94OyB9CkluZGV4 OiBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoLmNwcAkocmV2aXNp b24gMzY0OTcpCisrKyBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgog I2lmIEVOQUJMRShTVkcpCiAjaW5jbHVkZSAiU1ZHUGF0aFNlZ0N1cnZldG9DdWJpY1Ntb290aC5o IgorI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBA IC0zNiw4ICszNywyMyBAQCBTVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoUmVsOjpTVkdQYXRo CiB7CiB9CiAKK1N0cmluZyBTVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoOjp0b1N0cmluZygp IGNvbnN0Cit7CisgICAgU3RyaW5nQnVpbGRlciB2YWx1ZTsKKworICAgIHZhbHVlLmFwcGVuZChw YXRoU2VnVHlwZUFzTGV0dGVyKCkpOworICAgIHZhbHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVl LmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3gyKSk7CisgICAgdmFsdWUuYXBwZW5kKCcgJyk7Cisg ICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1feTIpKTsKKyAgICB2YWx1ZS5hcHBlbmQo JyAnKTsKKyAgICB2YWx1ZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV94KSk7CisgICAgdmFsdWUu YXBwZW5kKCcgJyk7CisgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1feSkpOworCisg ICAgcmV0dXJuIHZhbHVlLnRvU3RyaW5nKCk7CiB9CiAKLSNlbmRpZiAvLyBFTkFCTEUoU1ZHKQor fQogCi0vLyB2aW06dHM9NDpub2V0CisjZW5kaWYgLy8gRU5BQkxFKFNWRykKSW5kZXg6IFdlYkNv cmUvc3ZnL1NWR1BhdGhTZWdDdXJ2ZXRvQ3ViaWNTbW9vdGguaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b0N1YmljU21vb3RoLmgJKHJldmlzaW9uIDM2NDk3KQor KysgV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZ0N1cnZldG9DdWJpY1Ntb290aC5oCSh3b3JraW5nIGNv cHkpCkBAIC0zNCw3ICszNCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU1ZHUGF0 aFNlZ0N1cnZldG9DdWJpY1Ntb290aChmbG9hdCB4LCBmbG9hdCB5LCBmbG9hdCB4MiwgZmxvYXQg eTIpCiAgICAgICAgIDogU1ZHUGF0aFNlZygpLCBtX3goeCksIG1feSh5KSwgbV94Mih4MiksIG1f eTIoeSkge30KIAotICAgICAgICB2aXJ0dWFsIFN0cmluZyB0b1N0cmluZygpIGNvbnN0IHsgcmV0 dXJuIHBhdGhTZWdUeXBlQXNMZXR0ZXIoKSArIFN0cmluZzo6Zm9ybWF0KCIgJS42bGcgJS42bGcg JS42bGcgJS42bGciLCBtX3gyLCBtX3kyLCBtX3gsIG1feSk7IH0KKyAgICAgICAgdmlydHVhbCBT dHJpbmcgdG9TdHJpbmcoKSBjb25zdDsKIAogICAgICAgICB2b2lkIHNldFgoZmxvYXQgeCkgeyBt X3ggPSB4OyB9CiAgICAgICAgIGZsb2F0IHgoKSBjb25zdCB7IHJldHVybiBtX3g7IH0KSW5kZXg6 IFdlYkNvcmUvc3ZnL1NWR1BhdGhTZWdDdXJ2ZXRvUXVhZHJhdGljLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b1F1YWRyYXRpYy5jcHAJKHJldmlzaW9uIDM2 NDk3KQorKysgV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0aWMuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0yNCw2ICsyNCw3IEBACiAKICNpZiBFTkFCTEUoU1ZHKQogI2luY2x1ZGUg IlNWR1BhdGhTZWdDdXJ2ZXRvUXVhZHJhdGljLmgiCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTM3LDggKzM4LDIzIEBAIFNWR1BhdGhTZWdD dXJ2ZXRvUXVhZHJhdGljUmVsOjpTVkdQYXRoU2UKIHsKIH0KIAorU3RyaW5nIFNWR1BhdGhTZWdD dXJ2ZXRvUXVhZHJhdGljOjp0b1N0cmluZygpIGNvbnN0Cit7CisgICAgU3RyaW5nQnVpbGRlciB2 YWx1ZTsKKworICAgIHZhbHVlLmFwcGVuZChwYXRoU2VnVHlwZUFzTGV0dGVyKCkpOworICAgIHZh bHVlLmFwcGVuZCgnICcpOworICAgIHZhbHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3gxKSk7 CisgICAgdmFsdWUuYXBwZW5kKCcgJyk7CisgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVy KG1feTEpKTsKKyAgICB2YWx1ZS5hcHBlbmQoJyAnKTsKKyAgICB2YWx1ZS5hcHBlbmQoU3RyaW5n OjpudW1iZXIobV94KSk7CisgICAgdmFsdWUuYXBwZW5kKCcgJyk7CisgICAgdmFsdWUuYXBwZW5k KFN0cmluZzo6bnVtYmVyKG1feSkpOworCisgICAgcmV0dXJuIHZhbHVlLnRvU3RyaW5nKCk7CiB9 CiAKLSNlbmRpZiAvLyBFTkFCTEUoU1ZHKQorfQogCi0vLyB2aW06dHM9NDpub2V0CisjZW5kaWYg Ly8gRU5BQkxFKFNWRykKSW5kZXg6IFdlYkNvcmUvc3ZnL1NWR1BhdGhTZWdDdXJ2ZXRvUXVhZHJh dGljLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0 aWMuaAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnQ3VydmV0b1F1 YWRyYXRpYy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNCw3ICszNCw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgU1ZHUGF0aFNlZ0N1cnZldG9RdWFkcmF0aWMoZmxvYXQgeCwgZmxvYXQg eSwgZmxvYXQgeDEsIGZsb2F0IHkxKQogICAgICAgICA6IFNWR1BhdGhTZWcoKSwgbV94KHgpLCBt X3koeSksIG1feDEoeDEpLCBtX3kxKHkxKSB7fQogCi0gICAgICAgIHZpcnR1YWwgU3RyaW5nIHRv U3RyaW5nKCkgY29uc3QgeyByZXR1cm4gcGF0aFNlZ1R5cGVBc0xldHRlcigpICsgU3RyaW5nOjpm b3JtYXQoIiAlLjZsZyAlLjZsZyAlLjZsZyAlLjZsZyIsIG1feDEsIG1feTEsIG1feCwgbV95KTsg fQorICAgICAgICB2aXJ0dWFsIFN0cmluZyB0b1N0cmluZygpIGNvbnN0OwogCiAgICAgICAgIHZv aWQgc2V0WChmbG9hdCB4KSB7IG1feCA9IHg7IH0KICAgICAgICAgZmxvYXQgeCgpIGNvbnN0IHsg cmV0dXJuIG1feDsgfQpJbmRleDogV2ViQ29yZS9zdmcvU1ZHUGF0aFNlZ0xpbmV0b0hvcml6b250 YWwuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N2Zy9TVkdQYXRoU2VnTGluZXRvSG9yaXpvbnRh bC5oCShyZXZpc2lvbiAzNjQ5NykKKysrIFdlYkNvcmUvc3ZnL1NWR1BhdGhTZWdMaW5ldG9Ib3Jp em9udGFsLmgJKHdvcmtpbmcgY29weSkKQEAgLTMzLDcgKzMzLDcgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgIHB1YmxpYzoKICAgICAgICAgU1ZHUGF0aFNlZ0xpbmV0b0hvcml6b250YWwoZmxv YXQgeCkgOiBTVkdQYXRoU2VnKCksIG1feCh4KSB7fQogCi0gICAgICAgIHZpcnR1YWwgU3RyaW5n IHRvU3RyaW5nKCkgY29uc3QgeyByZXR1cm4gcGF0aFNlZ1R5cGVBc0xldHRlcigpICsgU3RyaW5n Ojpmb3JtYXQoIiAlLjZsZyIsIG1feCk7IH0KKyAgICAgICAgdmlydHVhbCBTdHJpbmcgdG9TdHJp bmcoKSBjb25zdCB7IHJldHVybiBwYXRoU2VnVHlwZUFzTGV0dGVyKCkgKyAiICIgKyBTdHJpbmc6 Om51bWJlcihtX3gpOyB9CiAKICAgICAgICAgdm9pZCBzZXRYKGZsb2F0IHgpIHsgbV94ID0geDsg fQogICAgICAgICBmbG9hdCB4KCkgY29uc3QgeyByZXR1cm4gbV94OyB9CkluZGV4OiBXZWJDb3Jl L3N2Zy9TVkdQYXRoU2VnTGluZXRvVmVydGljYWwuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N2 Zy9TVkdQYXRoU2VnTGluZXRvVmVydGljYWwuaAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3Jl L3N2Zy9TVkdQYXRoU2VnTGluZXRvVmVydGljYWwuaAkod29ya2luZyBjb3B5KQpAQCAtMzMsNyAr MzMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHVibGljOgogICAgICAgICBTVkdQYXRo U2VnTGluZXRvVmVydGljYWwoZmxvYXQgeSkgOiBTVkdQYXRoU2VnKCksIG1feSh5KSB7fQogCi0g ICAgICAgIHZpcnR1YWwgU3RyaW5nIHRvU3RyaW5nKCkgY29uc3QgeyByZXR1cm4gcGF0aFNlZ1R5 cGVBc0xldHRlcigpICsgU3RyaW5nOjpmb3JtYXQoIiAlLjZsZyIsIG1feSk7IH0KKyAgICAgICAg dmlydHVhbCBTdHJpbmcgdG9TdHJpbmcoKSBjb25zdCB7IHJldHVybiBwYXRoU2VnVHlwZUFzTGV0 dGVyKCkgKyAiICIgKyBTdHJpbmc6Om51bWJlcihtX3kpOyB9CiAKICAgICAgICAgdm9pZCBzZXRZ KGZsb2F0IHkpIHsgbV95ID0geTsgfQogICAgICAgICBmbG9hdCB5KCkgY29uc3QgeyByZXR1cm4g bV95OyB9CkluZGV4OiBXZWJDb3JlL3N2Zy9TVkdQb2ludExpc3QuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvc3ZnL1NWR1BvaW50TGlzdC5jcHAJKHJldmlzaW9uIDM2NDk3KQorKysgV2ViQ29y ZS9zdmcvU1ZHUG9pbnRMaXN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDksNyArNDksOSBAQCBT dHJpbmcgU1ZHUG9pbnRMaXN0Ojp2YWx1ZUFzU3RyaW5nKCkgY29uCiAgICAgICAgIEZsb2F0UG9p bnQgcG9pbnQgPSBnZXRJdGVtKGksIGVjKTsKICAgICAgICAgQVNTRVJUKGVjID09IDApOwogCi0g ICAgICAgIHJlc3VsdCArPSBTdHJpbmc6OmZvcm1hdCgiJS42bGcgJS42bGciLCBwb2ludC54KCks IHBvaW50LnkoKSk7CisgICAgICAgIHJlc3VsdCArPSBTdHJpbmc6Om51bWJlcihwb2ludC54KCkp OworICAgICAgICByZXN1bHQgKz0gIiAiOworICAgICAgICByZXN1bHQgKz0gU3RyaW5nOjpudW1i ZXIocG9pbnQueSgpKTsKICAgICB9CiAKICAgICByZXR1cm4gcmVzdWx0OwpJbmRleDogV2ViQ29y ZS9zdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZH VHJhbnNmb3JtTGlzdC5jcHAJKHJldmlzaW9uIDM2NDk3KQorKysgV2ViQ29yZS9zdmcvU1ZHVHJh bnNmb3JtTGlzdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI0LDYgKzI0LDcgQEAKIAogI2lmIEVO QUJMRShTVkcpCiAjaW5jbHVkZSAiQWZmaW5lVHJhbnNmb3JtLmgiCisjaW5jbHVkZSAiU3RyaW5n QnVpbGRlci5oIgogI2luY2x1ZGUgIlNWR1RyYW5zZm9ybS5oIgogI2luY2x1ZGUgIlNWR1NWR0Vs ZW1lbnQuaCIKICNpbmNsdWRlICJTVkdUcmFuc2Zvcm1EaXN0YW5jZS5oIgpAQCAtODgsNyArODks MjQgQEAgU3RyaW5nIFNWR1RyYW5zZm9ybUxpc3Q6OnZhbHVlQXNTdHJpbmcoKQogICAgIFNWR1Ry YW5zZm9ybSB0cmFuc2Zvcm0gPSBjb25jYXRlbmF0ZSgpOwogICAgIGlmICh0cmFuc2Zvcm0udHlw ZSgpID09IFNWR1RyYW5zZm9ybTo6U1ZHX1RSQU5TRk9STV9NQVRSSVgpIHsKICAgICAgICAgQWZm aW5lVHJhbnNmb3JtIG1hdHJpeCA9IHRyYW5zZm9ybS5tYXRyaXgoKTsKLSAgICAgICAgcmV0dXJu IFN0cmluZzo6Zm9ybWF0KCJtYXRyaXgoJWYgJWYgJWYgJWYgJWYgJWYpIiwgbWF0cml4LmEoKSwg bWF0cml4LmIoKSwgbWF0cml4LmMoKSwgbWF0cml4LmQoKSwgbWF0cml4LmUoKSwgbWF0cml4LmYo KSk7CisKKyAgICAgICAgU3RyaW5nQnVpbGRlciB2YWx1ZTsKKworICAgICAgICB2YWx1ZS5hcHBl bmQoIm1hdHJpeCgiKTsKKyAgICAgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1hdHJp eC5hKCkpKTsKKyAgICAgICAgdmFsdWUuYXBwZW5kKCcgJyk7CisgICAgICAgIHZhbHVlLmFwcGVu ZChTdHJpbmc6Om51bWJlcihtYXRyaXguYigpKSk7CisgICAgICAgIHZhbHVlLmFwcGVuZCgnICcp OworICAgICAgICB2YWx1ZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIobWF0cml4LmMoKSkpOworICAg ICAgICB2YWx1ZS5hcHBlbmQoJyAnKTsKKyAgICAgICAgdmFsdWUuYXBwZW5kKFN0cmluZzo6bnVt YmVyKG1hdHJpeC5kKCkpKTsKKyAgICAgICAgdmFsdWUuYXBwZW5kKCcgJyk7CisgICAgICAgIHZh bHVlLmFwcGVuZChTdHJpbmc6Om51bWJlcihtYXRyaXguZSgpKSk7CisgICAgICAgIHZhbHVlLmFw cGVuZCgnICcpOworICAgICAgICB2YWx1ZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIobWF0cml4LmYo KSkpOworICAgICAgICB2YWx1ZS5hcHBlbmQoJyknKTsKKworICAgICAgICByZXR1cm4gdmFsdWUu dG9TdHJpbmcoKTsKICAgICB9CiAKICAgICByZXR1cm4gU3RyaW5nKCk7CkluZGV4OiBXZWJDb3Jl L3N2Zy9TVkdVc2VFbGVtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N2Zy9TVkdVc2VF bGVtZW50LmNwcAkocmV2aXNpb24gMzY0OTcpCisrKyBXZWJDb3JlL3N2Zy9TVkdVc2VFbGVtZW50 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjA0LDkgKzIwNCwxNiBAQCB2b2lkIGR1bXBJbnN0YW5j ZVRyZWUodW5zaWduZWQgaW50JiBkZXB0CiAgICAgZm9yICh1bnNpZ25lZCBpbnQgaSA9IDA7IGkg PCBkZXB0aDsgKytpKQogICAgICAgICB0ZXh0ICs9ICIgICI7CiAKLSAgICB0ZXh0ICs9IFN0cmlu Zzo6Zm9ybWF0KCJTVkdFbGVtZW50SW5zdGFuY2UgKHBhcmVudE5vZGU9JXMsIGZpcnN0Q2hpbGQ9 JXMsIGNvcnJlc3BvbmRpbmdFbGVtZW50PSVzLCBpZD0lcylcbiIsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICBwYXJlbnROb2RlTmFtZS5sYXRpbjEoKS5kYXRhKCksIGZpcnN0Q2hpbGROb2Rl TmFtZS5sYXRpbjEoKS5kYXRhKCksIGVsZW1lbnROb2RlTmFtZS5sYXRpbjEoKS5kYXRhKCksIGVs ZW1lbnRJZC5sYXRpbjEoKS5kYXRhKCkpOwotIAorICAgIHRleHQgKz0gIlNWR0VsZW1lbnRJbnN0 YW5jZSAocGFyZW50Tm9kZT0iOworICAgIHRleHQgKz0gcGFyZW50Tm9kZU5hbWU7CisgICAgdGV4 dCArPSAiLCBmaXJzdENoaWxkPSI7CisgICAgdGV4dCArPSBmaXJzdENoaWxkTm9kZU5hbWU7Cisg ICAgdGV4dCArPSAiLCBjb3JyZXNwb25kaW5nRWxlbWVudD0iOworICAgIHRleHQgKz0gZWxlbWVu dE5vZGVOYW1lOworICAgIHRleHQgKz0gIiwgaWQ9IjsKKyAgICB0ZXh0ICs9IGVsZW1lbnRJZDsK KyAgICB0ZXh0ICs9ICIpIjsKKwogICAgIGRlcHRoKys7CiAKICAgICBmb3IgKFNWR0VsZW1lbnRJ bnN0YW5jZSogaW5zdGFuY2UgPSB0YXJnZXRJbnN0YW5jZS0+Zmlyc3RDaGlsZCgpOyBpbnN0YW5j ZTsgaW5zdGFuY2UgPSBpbnN0YW5jZS0+bmV4dFNpYmxpbmcoKSkKQEAgLTMxNSw3ICszMjIsMTEg QEAgdm9pZCBTVkdVc2VFbGVtZW50OjpidWlsZFBlbmRpbmdSZXNvdXJjZQogICAgIC8vIChpLmUu LCByaWdodC1zaWRlKSBvZiB0aGUgdHJhbnNmb3JtIGF0dHJpYnV0ZSBvbiB0aGUgZ2VuZXJhdGVk ICdnJywgd2hlcmUgeAogICAgIC8vIGFuZCB5IHJlcHJlc2VudCB0aGUgdmFsdWVzIG9mIHRoZSB4 IGFuZCB5IGF0dHJpYnV0ZXMgb24gdGhlICd1c2UnIGVsZW1lbnQuIAogICAgIGlmICh4KCkudmFs dWUodGhpcykgIT0gMC4wIHx8IHkoKS52YWx1ZSh0aGlzKSAhPSAwLjApIHsKLSAgICAgICAgU3Ry aW5nIHRyYW5zZm9ybVN0cmluZyA9IFN0cmluZzo6Zm9ybWF0KCJ0cmFuc2xhdGUoJWYsICVmKSIs IHgoKS52YWx1ZSh0aGlzKSwgeSgpLnZhbHVlKHRoaXMpKTsKKyAgICAgICAgU3RyaW5nIHRyYW5z Zm9ybVN0cmluZyA9ICJ0cmFuc2xhdGUoIjsKKyAgICAgICAgdHJhbnNmb3JtU3RyaW5nICs9IFN0 cmluZzo6bnVtYmVyKHgoKS52YWx1ZSh0aGlzKSk7CisgICAgICAgIHRyYW5zZm9ybVN0cmluZyAr PSAiLCAiOworICAgICAgICB0cmFuc2Zvcm1TdHJpbmcgKz0gU3RyaW5nOjpudW1iZXIoeSgpLnZh bHVlKHRoaXMpKTsKKyAgICAgICAgdHJhbnNmb3JtU3RyaW5nICs9ICIpIjsKICAgICAgICAgbV9z aGFkb3dUcmVlUm9vdEVsZW1lbnQtPnNldEF0dHJpYnV0ZShTVkdOYW1lczo6dHJhbnNmb3JtQXR0 ciwgdHJhbnNmb3JtU3RyaW5nKTsKICAgICB9CiAKQEAgLTU4NCwxNCArNTk1LDE4IEBAIHZvaWQg U1ZHVXNlRWxlbWVudDo6ZXhwYW5kVXNlRWxlbWVudHNJblMKICAgICAgICAgICAgIC8vIChpLmUu LCByaWdodC1zaWRlKSBvZiB0aGUgdHJhbnNmb3JtIGF0dHJpYnV0ZSBvbiB0aGUgZ2VuZXJhdGVk ICdnJywgd2hlcmUgeAogICAgICAgICAgICAgLy8gYW5kIHkgcmVwcmVzZW50IHRoZSB2YWx1ZXMg b2YgdGhlIHggYW5kIHkgYXR0cmlidXRlcyBvbiB0aGUgJ3VzZScgZWxlbWVudC4KICAgICAgICAg ICAgIGlmICh1c2UtPngoKS52YWx1ZSh0aGlzKSAhPSAwLjAgfHwgdXNlLT55KCkudmFsdWUodGhp cykgIT0gMC4wKSB7Ci0gICAgICAgICAgICAgICAgaWYgKCFjbG9uZVBhcmVudC0+aGFzQXR0cmli dXRlKFNWR05hbWVzOjp0cmFuc2Zvcm1BdHRyKSkgewotICAgICAgICAgICAgICAgICAgICBTdHJp bmcgdHJhbnNmb3JtU3RyaW5nID0gU3RyaW5nOjpmb3JtYXQoInRyYW5zbGF0ZSglZiwgJWYpIiwg dXNlLT54KCkudmFsdWUodGhpcyksIHVzZS0+eSgpLnZhbHVlKHRoaXMpKTsKLSAgICAgICAgICAg ICAgICAgICAgY2xvbmVQYXJlbnQtPnNldEF0dHJpYnV0ZShTVkdOYW1lczo6dHJhbnNmb3JtQXR0 ciwgdHJhbnNmb3JtU3RyaW5nKTsKLSAgICAgICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAg ICAgICAgICAgICBTdHJpbmcgdHJhbnNmb3JtU3RyaW5nID0gU3RyaW5nOjpmb3JtYXQoIiB0cmFu c2xhdGUoJWYsICVmKSIsIHVzZS0+eCgpLnZhbHVlKHRoaXMpLCB1c2UtPnkoKS52YWx1ZSh0aGlz KSk7CisgICAgICAgICAgICAgICAgU3RyaW5nIHRyYW5zZm9ybVN0cmluZzsKKyAgICAgICAgICAg ICAgICBpZiAoY2xvbmVQYXJlbnQtPmhhc0F0dHJpYnV0ZShTVkdOYW1lczo6dHJhbnNmb3JtQXR0 cikpIHsKICAgICAgICAgICAgICAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiB0cmFuc2Zvcm1B dHRyaWJ1dGUgPSBjbG9uZVBhcmVudC0+Z2V0QXR0cmlidXRlKFNWR05hbWVzOjp0cmFuc2Zvcm1B dHRyKTsKLSAgICAgICAgICAgICAgICAgICAgY2xvbmVQYXJlbnQtPnNldEF0dHJpYnV0ZShTVkdO YW1lczo6dHJhbnNmb3JtQXR0ciwgdHJhbnNmb3JtQXR0cmlidXRlICsgdHJhbnNmb3JtU3RyaW5n KTsgCisgICAgICAgICAgICAgICAgICAgIHRyYW5zZm9ybVN0cmluZyArPSB0cmFuc2Zvcm1BdHRy aWJ1dGU7CisgICAgICAgICAgICAgICAgICAgIHRyYW5zZm9ybVN0cmluZyArPSAiICI7CiAgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIHRyYW5zZm9ybVN0cmluZyArPSAidHJhbnNs YXRlKCI7CisgICAgICAgICAgICAgICAgdHJhbnNmb3JtU3RyaW5nICs9IFN0cmluZzo6bnVtYmVy KHVzZS0+eCgpLnZhbHVlKHRoaXMpKTsKKyAgICAgICAgICAgICAgICB0cmFuc2Zvcm1TdHJpbmcg Kz0gIiwgIjsKKyAgICAgICAgICAgICAgICB0cmFuc2Zvcm1TdHJpbmcgKz0gU3RyaW5nOjpudW1i ZXIodXNlLT55KCkudmFsdWUodGhpcykpOworICAgICAgICAgICAgICAgIHRyYW5zZm9ybVN0cmlu ZyArPSAiKSI7CisgICAgICAgICAgICAgICAgY2xvbmVQYXJlbnQtPnNldEF0dHJpYnV0ZShTVkdO YW1lczo6dHJhbnNmb3JtQXR0ciwgdHJhbnNmb3JtU3RyaW5nKTsKICAgICAgICAgICAgIH0KIAog ICAgICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7Cg== 40411 2009-09-30 17:36:34 -0700 2009-10-05 11:18:35 -0700 patch v1 bug-18994-20090930173633.patch text/plain 6458 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMjc0MjI4Li5lNDExODk0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKwlMYXlvdXQgdGVzdCBmb3IgdmVyaWZ5aW5nIHRoYXQgTENf TlVNRVJJQyBzZXR0aW5nIGRvZXNuJ3QgYWZmZWN0CisJdGhlIHdheSBDU1MgcHJvcGVydGllcyBh cmUgc3RyaW5naWZpZWQuCisJaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sOiBBZGRlZC4KKwog MjAwOS0wOS0yOSAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNp dHktZmxvYXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmI1MTg1YTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0 aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMg Z2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0LgorCitQQVNTCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uMjQzNDgxMQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29w YWNpdHktZmxvYXQuaHRtbApAQCAtMCwwICsxLDIyIEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgIC8vIFB1dCBvdXJzZWx2ZXMgaW4gYSBsb2NhbGUg d2hlcmUgMC45IGlzIHdyaXR0ZW4gYXMgIjAsOSIuCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu c2V0TG9jYWxlKCJwbF9QTC5VVEYtOCIpOworfQorPC9zY3JpcHQ+CisKKzxwPlRoaXMgdGVzdCB2 ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0 dHJpYnV0ZXMKK2dldHMgYmFjayBhIHByb3Blcmx5LWZvcm1hdHRlZCBmbG9hdC48L3A+CisKKzxh IGlkPSd0ZXN0JyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorCis8c2NyaXB0PgordmFyIG9wYWNp dHkgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJp bmcoKTsKK2lmIChvcGFjaXR5ID09ICcwLjknKQorICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7 CitlbHNlCisgICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKKworaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBi L1dlYktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCAzY2QxNDFkLi41ODQ1ZDc0IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTggQEAKKzIwMDktMDktMzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQ SSB0byBMYXlvdXRUZXN0Q29udHJvbGxlciBmb3IgcmUvc2V0dGluZyB0aGUgc3lzdGVtIGxvY2Fs ZS4KKwlodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg5OTQKKworICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAg KExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgIChz ZXRMb2NhbGVDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGlj RnVuY3Rpb25zKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRMb2NhbGUpOgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKwogMjAw OS0wOS0yOSAgRGFuaWVsIEJhdGVzICA8ZGJhdGVzQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgQWRhbSBSb2Jlbi4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA0MDlkNWFiLi41Y2Q5YWNiIDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAK KysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CkBAIC02OSw2ICs2OSw3IEBAIExheW91dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJv bGxlcihjb25zdCBzdGQ6OnN0cmluZyYgdGVzdFBhdGhPclVSTCwgY29uCiAgICAgLCBtX2dsb2Jh bEZsYWcoZmFsc2UpCiAgICAgLCBtX2lzR2VvbG9jYXRpb25QZXJtaXNzaW9uU2V0KGZhbHNlKQog ICAgICwgbV9nZW9sb2NhdGlvblBlcm1pc3Npb24oZmFsc2UpCisgICAgLCBtX29sZExvY2FsZShO VUxMKQogICAgICwgbV90ZXN0UGF0aE9yVVJMKHRlc3RQYXRoT3JVUkwpCiAgICAgLCBtX2V4cGVj dGVkUGl4ZWxIYXNoKGV4cGVjdGVkUGl4ZWxIYXNoKQogewpAQCAtNzI0LDYgKzcyNSwyMCBAQCBz dGF0aWMgSlNWYWx1ZVJlZiBzZXRIYW5kbGVzQXV0aGVudGljYXRpb25DaGFsbGVuZ2VzQ2FsbGJh Y2soSlNDb250ZXh0UmVmIGNvbnRleAogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChj b250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgc2V0TG9jYWxlQ2FsbGJhY2soSlNDb250 ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2Jq ZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwg SlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIC8vIEhhcyBMaW51eCBpbXBsZW1lbnRhdGlv bgorICAgIGlmIChhcmd1bWVudENvdW50IDwgMSkKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtl VW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xs ZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0 ZSh0aGlzT2JqZWN0KSk7CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGxvY2FsZShBZG9w dCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlvbikp OworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgY29udHJvbGxlci0+c2V0TG9jYWxlKGxv Y2FsZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7 Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHNldEljb25EYXRhYmFzZUVuYWJsZWRDYWxsYmFjayhK U0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRo aXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50 c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCiB7CiAgICAgLy8gSGFzIG1hYyAmIHdpbmRvd3Mg aW1wbGVtZW50YXRpb24KQEAgLTExNjcsNiArMTE4Miw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExh eW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJzZXREYXRh YmFzZVF1b3RhIiwgc2V0RGF0YWJhc2VRdW90YUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sIAogICAgICAgICB7 ICJzZXRHZW9sb2NhdGlvblBlcm1pc3Npb24iLCBzZXRHZW9sb2NhdGlvblBlcm1pc3Npb25DYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRl RG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRIYW5kbGVzQXV0aGVudGljYXRpb25DaGFsbGVu Z2VzIiwgc2V0SGFuZGxlc0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlc0NhbGxiYWNrLCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0s CisgICAgICAgIHsgInNldExvY2FsZSIsIHNldExvY2FsZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgInNldEljb25EYXRhYmFzZUVuYWJsZWQiLCBzZXRJY29uRGF0YWJhc2VFbmFibGVkQ2Fs bGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SmF2YVNjcmlwdFByb2ZpbGluZ0VuYWJsZWQi LCBzZXRKYXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgInNldE1haW5GcmFtZUlzRmlyc3RSZXNwb25kZXIiLCBzZXRNYWluRnJhbWVJc0ZpcnN0UmVz cG9uZGVyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKQEAgLTEyNTIsMyArMTI2OCwxNCBAQCB2b2lkIExheW91 dFRlc3RDb250cm9sbGVyOjpzZXRHZW9sb2NhdGlvblBlcm1pc3Npb24oYm9vbCBhbGxvdykKICAg ICBtX2lzR2VvbG9jYXRpb25QZXJtaXNzaW9uU2V0ID0gdHJ1ZTsKICAgICBtX2dlb2xvY2F0aW9u UGVybWlzc2lvbiA9IGFsbG93OwogfQorCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRM b2NhbGUoSlNTdHJpbmdSZWYgbG9jYWxlKQoreworICAgIGNoYXIgbG9jYWxlQnVmWzEwXTsKKyAg ICBKU1N0cmluZ0dldFVURjhDU3RyaW5nKGxvY2FsZSwgbG9jYWxlQnVmLCBzaXplb2YobG9jYWxl QnVmKSk7CisKKyAgICBjaGFyKiBvbGRMb2NhbGUgPSBzZXRsb2NhbGUoTENfQUxMLCBsb2NhbGVC dWYpOworCisgICAgaWYgKG1fb2xkTG9jYWxlKQorICAgICAgICBtX29sZExvY2FsZSA9IG9sZExv Y2FsZTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oCmluZGV4IGZhODFhY2IuLmIyNWY4YWMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaApAQCAtMjAzLDYgKzIwMyw4IEBA IHB1YmxpYzoKICAgICBib29sIGlzR2VvbG9jYXRpb25QZXJtaXNzaW9uU2V0KCkgY29uc3QgeyBy ZXR1cm4gbV9pc0dlb2xvY2F0aW9uUGVybWlzc2lvblNldDsgfQogICAgIGJvb2wgZ2VvbG9jYXRp b25QZXJtaXNzaW9uKCkgY29uc3QgeyByZXR1cm4gbV9nZW9sb2NhdGlvblBlcm1pc3Npb247IH0K IAorICAgIHZvaWQgc2V0TG9jYWxlKEpTU3RyaW5nUmVmIGxvY2FsZSk7CisKIHByaXZhdGU6CiAg ICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBBc1BERjsKQEAgLTIzNiw2ICsy MzgsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9nZW9sb2NhdGlvblBlcm1pc3Npb247CiAgICAg Ym9vbCBtX2hhbmRsZXNBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXM7CiAKKyAgICBjaGFyKiBtX29s ZExvY2FsZTsKKwogICAgIHN0ZDo6c3RyaW5nIG1fYXV0aGVudGljYXRpb25Vc2VybmFtZTsKICAg ICBzdGQ6OnN0cmluZyBtX2F1dGhlbnRpY2F0aW9uUGFzc3dvcmQ7IAogICAgIHN0ZDo6c3RyaW5n IG1fdGVzdFBhdGhPclVSTDs= 40646 2009-10-05 11:18:39 -0700 2009-10-05 11:46:27 -0700 patch bug-18994-20091005111838.patch text/plain 5878 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMjc0MjI4Li5lNDExODk0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKwlMYXlvdXQgdGVzdCBmb3IgdmVyaWZ5aW5nIHRoYXQgTENf TlVNRVJJQyBzZXR0aW5nIGRvZXNuJ3QgYWZmZWN0CisJdGhlIHdheSBDU1MgcHJvcGVydGllcyBh cmUgc3RyaW5naWZpZWQuCisJaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sOiBBZGRlZC4KKwog MjAwOS0wOS0yOSAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNp dHktZmxvYXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmY2NWFkMWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0 aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMg Z2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0LiBJbXByb3Blcmx5IGhhbmRsaW5n IGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdo dCBicmVhayBpdC4KKworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3Bh Y2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRhNDdiOTkKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwKQEAgLTAsMCAr MSwyNiBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAg ICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAvLyBQdXQgb3Vyc2Vs dmVzIGluIGEgbG9jYWxlIHdoZXJlIDAuOSBpcyB3cml0dGVuIGFzICIwLDkiLgorICAgIGxheW91 dFRlc3RDb250cm9sbGVyLnNldExvY2FsZSgicGxfUEwuVVRGLTgiKTsKK30KKzwvc2NyaXB0Pgor Cis8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmctcG9pbnQgb3Bh Y2l0eSBmcm9tIENTUworYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBwcm9wZXJseS1mb3JtYXR0ZWQg ZmxvYXQuICBJbXByb3Blcmx5IGhhbmRsaW5nCitsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1hbHMg dG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsKK2l0LjwvcD4KKworPGEgaWQ9J3Rl c3QnIHN0eWxlPSdvcGFjaXR5Oi45Jz48L2E+CisKKzxzY3JpcHQ+Cit2YXIgb3BhY2l0eSA9IGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0Jykuc3R5bGUub3BhY2l0eS50b1N0cmluZygpOwor aWYgKG9wYWNpdHkgPT0gJzAuOScpCisgICAgZG9jdW1lbnQud3JpdGUoJ1BBU1MnKTsKK2Vsc2UK KyAgICBkb2N1bWVudC53cml0ZSgnRkFJTDogJyArIG9wYWNpdHkpOworCitpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNldExvY2FsZSgi Iik7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktp dFRvb2xzL0NoYW5nZUxvZwppbmRleCAzY2QxNDFkLi44NTM2ODMxIDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTYgQEAKKzIwMDktMDktMzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQSSB0byBM YXlvdXRUZXN0Q29udHJvbGxlciBmb3IgcmUvc2V0dGluZyB0aGUgc3lzdGVtIGxvY2FsZS4KKwlo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg5OTQKKworICAgICAgICAq IER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKHNldExv Y2FsZUNhbGxiYWNrKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5j dGlvbnMpOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldExvY2FsZSk6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKwogMjAwOS0wOS0y OSAgRGFuaWVsIEJhdGVzICA8ZGJhdGVzQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgQWRhbSBSb2Jlbi4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA0MDlkNWFiLi44YjY4NGI4IDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC03 MjQsNiArNzI0LDE5IEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNldEhhbmRsZXNBdXRoZW50aWNhdGlv bkNoYWxsZW5nZXNDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4CiAgICAgcmV0dXJuIEpTVmFs dWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiBzZXRMb2Nh bGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpT T2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVl UmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3Vt ZW50Q291bnQgPCAxKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4 dCk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0 PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsK KyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gbG9jYWxlKEFkb3B0LCBKU1ZhbHVlVG9TdHJp bmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEq ZXhjZXB0aW9uKTsKKyAgICBjb250cm9sbGVyLT5zZXRMb2NhbGUobG9jYWxlLmdldCgpKTsKKwor ICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKK30KKwogc3RhdGljIEpT VmFsdWVSZWYgc2V0SWNvbkRhdGFiYXNlRW5hYmxlZENhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250 ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90 IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYq IGV4Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjICYgd2luZG93cyBpbXBsZW1lbnRhdGlvbgpA QCAtMTE2Nyw2ICsxMTgwLDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgInNldERhdGFiYXNlUXVvdGEiLCBzZXRE YXRhYmFzZVF1b3RhQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwgCiAgICAgICAgIHsgInNldEdlb2xvY2F0aW9u UGVybWlzc2lvbiIsIHNldEdlb2xvY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgInNldEhhbmRsZXNBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXMiLCBzZXRIYW5kbGVz QXV0aGVudGljYXRpb25DaGFsbGVuZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAic2V0 TG9jYWxlIiwgc2V0TG9jYWxlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SWNvbkRh dGFiYXNlRW5hYmxlZCIsIHNldEljb25EYXRhYmFzZUVuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJzZXRKYXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZCIsIHNldEphdmFTY3JpcHRQ cm9maWxpbmdFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0TWFpbkZyYW1l SXNGaXJzdFJlc3BvbmRlciIsIHNldE1haW5GcmFtZUlzRmlyc3RSZXNwb25kZXJDYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LApAQCAtMTI1MiwzICsxMjY2LDEwIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnNldEdlb2xvY2F0aW9uUGVybWlzc2lvbihib29sIGFsbG93KQogICAgIG1faXNHZW9sb2NhdGlv blBlcm1pc3Npb25TZXQgPSB0cnVlOwogICAgIG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uID0gYWxs b3c7CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldExvY2FsZShKU1N0cmluZ1Jl ZiBsb2NhbGUpCit7CisgICAgY2hhciBsb2NhbGVCdWZbMTBdOworICAgIEpTU3RyaW5nR2V0VVRG OENTdHJpbmcobG9jYWxlLCBsb2NhbGVCdWYsIHNpemVvZihsb2NhbGVCdWYpKTsKKyAgICBzZXRs b2NhbGUoTENfQUxMLCBsb2NhbGVCdWYpOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggZmE4MWFjYi4uOTA2MzJhOSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CkBAIC0yMDMsNiArMjAzLDggQEAgcHVibGljOgogICAgIGJvb2wgaXNHZW9sb2NhdGlvblBlcm1p c3Npb25TZXQoKSBjb25zdCB7IHJldHVybiBtX2lzR2VvbG9jYXRpb25QZXJtaXNzaW9uU2V0OyB9 CiAgICAgYm9vbCBnZW9sb2NhdGlvblBlcm1pc3Npb24oKSBjb25zdCB7IHJldHVybiBtX2dlb2xv Y2F0aW9uUGVybWlzc2lvbjsgfQogCisgICAgdm9pZCBzZXRMb2NhbGUoSlNTdHJpbmdSZWYgbG9j YWxlKTsKKwogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzVGV4dDsKICAgICBib29sIG1fZHVt cEFzUERGOw== 40648 2009-10-05 11:45:49 -0700 2009-10-05 11:48:52 -0700 patch bug-18994-20091005114547.patch text/plain 7973 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMjc0MjI4Li5jZmQ0NzBmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGF5b3V0IHRlc3QgZm9yIHZlcmlmeWluZyB0 aGF0IExDX05VTUVSSUMgc2V0dGluZyBkb2Vzbid0IGFmZmVjdAorICAgICAgICB0aGUgd2F5IENT UyBwcm9wZXJ0aWVzIGFyZSBzdHJpbmdpZmllZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1m bG9hdC5odG1sOiBBZGRlZC4KKwogMjAwOS0wOS0yOSAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY2NWFkMWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAK K1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5 IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0 LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBiZSB3 cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KKworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9j c3Mvb3BhY2l0eS1mbG9hdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu Ljk5OGE0OTEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0Lmh0bWwKQEAgLTAsMCArMSwyMyBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7 CisKKyAgICAvLyBQdXQgb3Vyc2VsdmVzIGluIGEgbG9jYWxlIHdoZXJlIDAuOSBpcyB3cml0dGVu IGFzICIwLDkiLgorICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNldExvY2FsZSgicGxfUEwuVVRG LTgiKTsKK30KKzwvc2NyaXB0PgorCis8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5n IGEgZmxvYXRpbmctcG9pbnQgb3BhY2l0eSBmcm9tIENTUworYXR0cmlidXRlcyBnZXRzIGJhY2sg YSBwcm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuICBJbXByb3Blcmx5IGhhbmRsaW5nCitsb2NhbGVz IHRoYXQgY2F1c2UgZGVjaW1hbHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsK K2l0LjwvcD4KKworPGEgaWQ9J3Rlc3QnIHN0eWxlPSdvcGFjaXR5Oi45Jz48L2E+CisKKzxzY3Jp cHQ+Cit2YXIgb3BhY2l0eSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0Jykuc3R5bGUu b3BhY2l0eS50b1N0cmluZygpOworaWYgKG9wYWNpdHkgPT0gJzAuOScpCisgICAgZG9jdW1lbnQu d3JpdGUoJ1BBU1MnKTsKK2Vsc2UKKyAgICBkb2N1bWVudC53cml0ZSgnRkFJTDogJyArIG9wYWNp dHkpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJL aXRUb29scy9DaGFuZ2VMb2cKaW5kZXggM2NkMTQxZC4uNWU2NDUzNCAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsx LDE2IEBACisyMDA5LTA5LTMwICBFdmFuIE1hcnRpbiAgPGV2YW5AY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBBUEkgdG8g TGF5b3V0VGVzdENvbnRyb2xsZXIgZm9yIHJlL3NldHRpbmcgdGhlIHN5c3RlbSBsb2NhbGUuCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODk5NAorCisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAg ICAoc2V0TG9jYWxlQ2FsbGJhY2spOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0 YXRpY0Z1bmN0aW9ucyk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0TG9jYWxl KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOgorCiAy MDA5LTA5LTI5ICBEYW5pZWwgQmF0ZXMgIDxkYmF0ZXNAd2Via2l0Lm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGFtIFJvYmVuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IDQwOWQ1YWIuLjhiNjg0YjggMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5j cHAKQEAgLTcyNCw2ICs3MjQsMTkgQEAgc3RhdGljIEpTVmFsdWVSZWYgc2V0SGFuZGxlc0F1dGhl bnRpY2F0aW9uQ2hhbGxlbmdlc0NhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXgKICAgICByZXR1 cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVm IHNldExvY2FsZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5j dGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0 IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBp ZiAoYXJndW1lbnRDb3VudCA8IDEpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5l ZChjb250ZXh0KTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gc3Rh dGljX2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09i amVjdCkpOworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBsb2NhbGUoQWRvcHQsIEpTVmFs dWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAgICBB U1NFUlQoISpleGNlcHRpb24pOworICAgIGNvbnRyb2xsZXItPnNldExvY2FsZShsb2NhbGUuZ2V0 KCkpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBz dGF0aWMgSlNWYWx1ZVJlZiBzZXRJY29uRGF0YWJhc2VFbmFibGVkQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0 LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNW YWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgJiB3aW5kb3dzIGltcGxlbWVu dGF0aW9uCkBAIC0xMTY3LDYgKzExODAsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAic2V0RGF0YWJhc2VRdW90 YSIsIHNldERhdGFiYXNlUXVvdGFDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25s eSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LCAKICAgICAgICAgeyAic2V0R2Vv bG9jYXRpb25QZXJtaXNzaW9uIiwgc2V0R2VvbG9jYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKICAgICAgICAgeyAic2V0SGFuZGxlc0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlcyIsIHNl dEhhbmRsZXNBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAg ICB7ICJzZXRMb2NhbGUiLCBzZXRMb2NhbGVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVS ZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJz ZXRJY29uRGF0YWJhc2VFbmFibGVkIiwgc2V0SWNvbkRhdGFiYXNlRW5hYmxlZENhbGxiYWNrLCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVs ZXRlIH0sCiAgICAgICAgIHsgInNldEphdmFTY3JpcHRQcm9maWxpbmdFbmFibGVkIiwgc2V0SmF2 YVNjcmlwdFByb2ZpbGluZ0VuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRN YWluRnJhbWVJc0ZpcnN0UmVzcG9uZGVyIiwgc2V0TWFpbkZyYW1lSXNGaXJzdFJlc3BvbmRlckNh bGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1 dGVEb250RGVsZXRlIH0sCkBAIC0xMjUyLDMgKzEyNjYsMTAgQEAgdm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0R2VvbG9jYXRpb25QZXJtaXNzaW9uKGJvb2wgYWxsb3cpCiAgICAgbV9pc0dl b2xvY2F0aW9uUGVybWlzc2lvblNldCA9IHRydWU7CiAgICAgbV9nZW9sb2NhdGlvblBlcm1pc3Np b24gPSBhbGxvdzsKIH0KKwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0TG9jYWxlKEpT U3RyaW5nUmVmIGxvY2FsZSkKK3sKKyAgICBjaGFyIGxvY2FsZUJ1ZlsxMF07CisgICAgSlNTdHJp bmdHZXRVVEY4Q1N0cmluZyhsb2NhbGUsIGxvY2FsZUJ1Ziwgc2l6ZW9mKGxvY2FsZUJ1ZikpOwor ICAgIHNldGxvY2FsZShMQ19BTEwsIGxvY2FsZUJ1Zik7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCBmYTgxYWNiLi45MDYz MmE5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmgKQEAgLTIwMyw2ICsyMDMsOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc0dlb2xvY2F0 aW9uUGVybWlzc2lvblNldCgpIGNvbnN0IHsgcmV0dXJuIG1faXNHZW9sb2NhdGlvblBlcm1pc3Np b25TZXQ7IH0KICAgICBib29sIGdlb2xvY2F0aW9uUGVybWlzc2lvbigpIGNvbnN0IHsgcmV0dXJu IG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uOyB9CiAKKyAgICB2b2lkIHNldExvY2FsZShKU1N0cmlu Z1JlZiBsb2NhbGUpOworCiBwcml2YXRlOgogICAgIGJvb2wgbV9kdW1wQXNUZXh0OwogICAgIGJv b2wgbV9kdW1wQXNQREY7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9n dGsvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1 bXBSZW5kZXJUcmVlLmNwcAppbmRleCA1NDY4YTRmLi42ZWNkNzc0IDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTMzNCw2ICsz MzQsOCBAQCBzdGF0aWMgdm9pZCByZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKCkKICAg ICBnX29iamVjdF9zZXQoR19PQkpFQ1QoaW5zcGVjdG9yKSwgImphdmFzY3JpcHQtcHJvZmlsaW5n LWVuYWJsZWQiLCBGQUxTRSwgTlVMTCk7CiAKICAgICB3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vz c193aGl0ZV9saXN0cygpOworCisgICAgc2V0bG9jYWxlKExDX0FMTCwgIiIpOwogfQogCiB2b2lk IGR1bXAoKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBS ZW5kZXJUcmVlLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJU cmVlLm1tCmluZGV4IDdmOTRhMzMuLjViMzQ5ZDMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAgLTQ0MSw2ICs0NDEsOCBAQCBzdGF0 aWMgdm9pZCByZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKCkKICAgICAgICAgW3ByZWZl cmVuY2VzIHNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkOllFU107CiAKICAgICBbW05T SFRUUENvb2tpZVN0b3JhZ2Ugc2hhcmVkSFRUUENvb2tpZVN0b3JhZ2VdIHNldENvb2tpZUFjY2Vw dFBvbGljeTpOU0hUVFBDb29raWVBY2NlcHRQb2xpY3lPbmx5RnJvbU1haW5Eb2N1bWVudERvbWFp bl07CisKKyAgICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CiB9CiAKIC8vIENhbGxlZCBvbmNlIG9u IER1bXBSZW5kZXJUcmVlIHN0YXJ0dXAuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggZjkzMjA0ZS4uZDFiNmE4NCAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCisrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtMjYw LDYgKzI2MCw4IEBAIHZvaWQgRHVtcFJlbmRlclRyZWU6OnJlc2V0VG9Db25zaXN0ZW50U3RhdGVC ZWZvcmVUZXN0aW5nKCkKIAogICAgIG1fY29udHJvbGxlci0+cmVzZXQoKTsKICAgICBRV2ViU2Vj dXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworCisgICAgc2V0bG9j YWxlKExDX0FMTCwgIiIpOwogfQogCiB2b2lkIER1bXBSZW5kZXJUcmVlOjpvcGVuKGNvbnN0IFFV cmwmIGF1cmwpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVt cFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5k ZXJUcmVlLmNwcAppbmRleCBlNDdjN2U4Li40ZmY0NWEyIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTc0Myw2ICs3NDMsOCBA QCBzdGF0aWMgdm9pZCByZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKElXZWJQcmVmZXJl bmNlcyogcHJlZmVyZW5jZXMpCiAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0T2ZmbGluZVdlYkFw cGxpY2F0aW9uQ2FjaGVFbmFibGVkKFRSVUUpOwogICAgIH0KICAgICBzZXRBbHdheXNBY2NlcHRD b29raWVzKGZhbHNlKTsKKworICAgIHNldGxvY2FsZShMQ19BTEwsICIiKTsKIH0KIAogc3RhdGlj IHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCk= 40649 2009-10-05 11:48:20 -0700 2009-10-05 14:33:21 -0700 add a regression test bug-18994-20091005114819.patch text/plain 8008 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMjc0MjI4Li5jZmQ0NzBmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGF5b3V0IHRlc3QgZm9yIHZlcmlmeWluZyB0 aGF0IExDX05VTUVSSUMgc2V0dGluZyBkb2Vzbid0IGFmZmVjdAorICAgICAgICB0aGUgd2F5IENT UyBwcm9wZXJ0aWVzIGFyZSBzdHJpbmdpZmllZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1m bG9hdC5odG1sOiBBZGRlZC4KKwogMjAwOS0wOS0yOSAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY2NWFkMWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAK K1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5 IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0 LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBiZSB3 cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KKworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9j c3Mvb3BhY2l0eS1mbG9hdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjBlZjA0NTYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0Lmh0bWwKQEAgLTAsMCArMSwyMyBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7 CisKKyAgICAvLyBQdXQgb3Vyc2VsdmVzIGluIGEgbG9jYWxlIHdoZXJlIDAuOSBpcyB3cml0dGVu IGFzICIwLDkiLgorICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNldFBPU0lYTG9jYWxlKCJwbF9Q TC5VVEYtOCIpOworfQorPC9zY3JpcHQ+CisKKzxwPlRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJl YWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTCithdHRyaWJ1dGVzIGdldHMg YmFjayBhIHByb3Blcmx5LWZvcm1hdHRlZCBmbG9hdC4gIEltcHJvcGVybHkgaGFuZGxpbmcKK2xv Y2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBi cmVhaworaXQuPC9wPgorCis8YSBpZD0ndGVzdCcgc3R5bGU9J29wYWNpdHk6LjknPjwvYT4KKwor PHNjcmlwdD4KK3ZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKS5z dHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7CitpZiAob3BhY2l0eSA9PSAnMC45JykKKyAgICBkb2N1 bWVudC53cml0ZSgnUEFTUycpOworZWxzZQorICAgIGRvY3VtZW50LndyaXRlKCdGQUlMOiAnICsg b3BhY2l0eSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBi L1dlYktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCAzY2QxNDFkLi41ZTY0NTM0IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMDktMDktMzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQ SSB0byBMYXlvdXRUZXN0Q29udHJvbGxlciBmb3IgcmUvc2V0dGluZyB0aGUgc3lzdGVtIGxvY2Fs ZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0 CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6Cisg ICAgICAgIChzZXRMb2NhbGVDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxl cjo6c3RhdGljRnVuY3Rpb25zKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRM b2NhbGUpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6 CisKIDIwMDktMDktMjkgIERhbmllbCBCYXRlcyAgPGRiYXRlc0B3ZWJraXQub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNDA5ZDVhYi4uYTY2OWVjZiAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmNwcApAQCAtNzI0LDYgKzcyNCwxOSBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRIYW5kbGVz QXV0aGVudGljYXRpb25DaGFsbGVuZ2VzQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleAogICAg IHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFs dWVSZWYgc2V0UE9TSVhMb2NhbGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmpl Y3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENv dW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24p Cit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgPCAxKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJv bGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2 YXRlKHRoaXNPYmplY3QpKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gbG9jYWxlKEFk b3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9u KSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBjb250cm9sbGVyLT5zZXRQT1NJWExv Y2FsZShsb2NhbGUuZ2V0KCkpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNv bnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRJY29uRGF0YWJhc2VFbmFibGVkQ2Fs bGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVj dFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBh cmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgJiB3 aW5kb3dzIGltcGxlbWVudGF0aW9uCkBAIC0xMTY3LDYgKzExODAsNyBAQCBKU1N0YXRpY0Z1bmN0 aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAi c2V0RGF0YWJhc2VRdW90YSIsIHNldERhdGFiYXNlUXVvdGFDYWxsYmFjaywga0pTUHJvcGVydHlB dHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LCAKICAg ICAgICAgeyAic2V0R2VvbG9jYXRpb25QZXJtaXNzaW9uIiwgc2V0R2VvbG9jYXRpb25QZXJtaXNz aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SGFuZGxlc0F1dGhlbnRpY2F0aW9u Q2hhbGxlbmdlcyIsIHNldEhhbmRsZXNBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXNDYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LAorICAgICAgICB7ICJzZXRQT1NJWExvY2FsZSIsIHNldFBPU0lYTG9jYWxlQ2FsbGJh Y2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURv bnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SWNvbkRhdGFiYXNlRW5hYmxlZCIsIHNldEljb25E YXRhYmFzZUVuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtK U1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRKYXZhU2NyaXB0 UHJvZmlsaW5nRW5hYmxlZCIsIHNldEphdmFTY3JpcHRQcm9maWxpbmdFbmFibGVkQ2FsbGJhY2ss IGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnRE ZWxldGUgfSwKICAgICAgICAgeyAic2V0TWFpbkZyYW1lSXNGaXJzdFJlc3BvbmRlciIsIHNldE1h aW5GcmFtZUlzRmlyc3RSZXNwb25kZXJDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApAQCAtMTI1MiwzICsxMjY2 LDEwIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldEdlb2xvY2F0aW9uUGVybWlzc2lv bihib29sIGFsbG93KQogICAgIG1faXNHZW9sb2NhdGlvblBlcm1pc3Npb25TZXQgPSB0cnVlOwog ICAgIG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uID0gYWxsb3c7CiB9CisKK3ZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OnNldFBPU0lYTG9jYWxlKEpTU3RyaW5nUmVmIGxvY2FsZSkKK3sKKyAgICBj aGFyIGxvY2FsZUJ1ZlsxMF07CisgICAgSlNTdHJpbmdHZXRVVEY4Q1N0cmluZyhsb2NhbGUsIGxv Y2FsZUJ1Ziwgc2l6ZW9mKGxvY2FsZUJ1ZikpOworICAgIHNldGxvY2FsZShMQ19BTEwsIGxvY2Fs ZUJ1Zik7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaAppbmRleCBmYTgxYWNiLi5jNzUwODI0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTIwMyw2ICsyMDMsOCBA QCBwdWJsaWM6CiAgICAgYm9vbCBpc0dlb2xvY2F0aW9uUGVybWlzc2lvblNldCgpIGNvbnN0IHsg cmV0dXJuIG1faXNHZW9sb2NhdGlvblBlcm1pc3Npb25TZXQ7IH0KICAgICBib29sIGdlb2xvY2F0 aW9uUGVybWlzc2lvbigpIGNvbnN0IHsgcmV0dXJuIG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uOyB9 CiAKKyAgICB2b2lkIHNldFBPU0lYTG9jYWxlKEpTU3RyaW5nUmVmIGxvY2FsZSk7CisKIHByaXZh dGU6CiAgICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBBc1BERjsKZGlmZiAt LWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4 IDU0NjhhNGYuLjZlY2Q3NzQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv Z3RrL0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtMzM0LDYgKzMzNCw4IEBAIHN0YXRpYyB2b2lkIHJl c2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoKQogICAgIGdfb2JqZWN0X3NldChHX09CSkVD VChpbnNwZWN0b3IpLCAiamF2YXNjcmlwdC1wcm9maWxpbmctZW5hYmxlZCIsIEZBTFNFLCBOVUxM KTsKIAogICAgIHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3RzKCk7CisKKyAg ICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CiB9CiAKIHZvaWQgZHVtcCgpCmRpZmYgLS1naXQgYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0gYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KaW5kZXggN2Y5NGEzMy4u NWIzNDlkMyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBS ZW5kZXJUcmVlLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVu ZGVyVHJlZS5tbQpAQCAtNDQxLDYgKzQ0MSw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0RGVmYXVsdHNU b0NvbnNpc3RlbnRWYWx1ZXMoKQogICAgICAgICBbcHJlZmVyZW5jZXMgc2V0QWNjZWxlcmF0ZWRD b21wb3NpdGluZ0VuYWJsZWQ6WUVTXTsKIAogICAgIFtbTlNIVFRQQ29va2llU3RvcmFnZSBzaGFy ZWRIVFRQQ29va2llU3RvcmFnZV0gc2V0Q29va2llQWNjZXB0UG9saWN5Ok5TSFRUUENvb2tpZUFj Y2VwdFBvbGljeU9ubHlGcm9tTWFpbkRvY3VtZW50RG9tYWluXTsKKworICAgIHNldGxvY2FsZShM Q19BTEwsICIiKTsKIH0KIAogLy8gQ2FsbGVkIG9uY2Ugb24gRHVtcFJlbmRlclRyZWUgc3RhcnR1 cC4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJU cmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNw cAppbmRleCBmOTMyMDRlLi5kMWI2YTg0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC0yNjAsNiArMjYwLDggQEAgdm9pZCBEdW1w UmVuZGVyVHJlZTo6cmVzZXRUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogCiAgICAg bV9jb250cm9sbGVyLT5yZXNldCgpOwogICAgIFFXZWJTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmln aW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CisKKyAgICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CiB9CiAK IHZvaWQgRHVtcFJlbmRlclRyZWU6Om9wZW4oY29uc3QgUVVybCYgYXVybCkKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IGU0N2M3 ZTguLjRmZjQ1YTIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9E dW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1 bXBSZW5kZXJUcmVlLmNwcApAQCAtNzQzLDYgKzc0Myw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0RGVm YXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoSVdlYlByZWZlcmVuY2VzKiBwcmVmZXJlbmNlcykKICAg ICAgICAgcHJlZnNQcml2YXRlLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQo VFJVRSk7CiAgICAgfQogICAgIHNldEFsd2F5c0FjY2VwdENvb2tpZXMoZmFsc2UpOworCisgICAg c2V0bG9jYWxlKExDX0FMTCwgIiIpOwogfQogCiBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0Nv bnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQ== 40662 2009-10-05 14:32:36 -0700 2009-10-06 16:32:32 -0700 add a regression test bug-18994-20091005143235.patch text/plain 8016 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkNjQyYzUyLi5kNjk3OTZlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGF5b3V0IHRlc3QgZm9yIHZlcmlmeWluZyB0 aGF0IExDX05VTUVSSUMgc2V0dGluZyBkb2Vzbid0IGFmZmVjdAorICAgICAgICB0aGUgd2F5IENT UyBwcm9wZXJ0aWVzIGFyZSBzdHJpbmdpZmllZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1m bG9hdC5odG1sOiBBZGRlZC4KKwogMjAwOS0xMC0wNSAgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5z ZW4gIDxrZW5uZXRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyc3RhbXBlZCBieSBTaW1v biBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxv YXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjY1YWQxZgotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0 ZWQudHh0CkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBh IGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBw cm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0 IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0Lgor CitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGVmMDQ1NgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQuaHRtbApAQCAtMCwwICsxLDIzIEBACis8c2Ny aXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIC8vIFB1dCBvdXJzZWx2ZXMgaW4gYSBsb2Nh bGUgd2hlcmUgMC45IGlzIHdyaXR0ZW4gYXMgIjAsOSIuCisgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuc2V0UE9TSVhMb2NhbGUoInBsX1BMLlVURi04Iik7Cit9Cis8L3NjcmlwdD4KKworPHA+VGhp cyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBhIGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJv bSBDU1MKK2F0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0LiAg SW1wcm9wZXJseSBoYW5kbGluZworbG9jYWxlcyB0aGF0IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdy aXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrCitpdC48L3A+CisKKzxhIGlkPSd0ZXN0JyBzdHls ZT0nb3BhY2l0eTouOSc+PC9hPgorCis8c2NyaXB0PgordmFyIG9wYWNpdHkgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsKK2lmIChvcGFj aXR5ID09ICcwLjknKQorICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7CitlbHNlCisgICAgZG9j dW1lbnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDgwZTkx MmIuLjg3MmMxZjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJL aXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAwOS0wOS0zMCAgRXZhbiBNYXJ0 aW4gIDxldmFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgQVBJIHRvIExheW91dFRlc3RDb250cm9sbGVyIGZvciByZS9z ZXR0aW5nIHRoZSBzeXN0ZW0gbG9jYWxlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTg5OTQKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKHNldExvY2FsZUNhbGxiYWNrKToKKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAoTGF5 b3V0VGVzdENvbnRyb2xsZXI6OnNldExvY2FsZSk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUv TGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKwogMjAwOS0xMC0wNSAgVmFkaW0gWmVpdGxpbiAgPHZh ZGltQHd4d2lkZ2V0cy5vcmc+CiAKICAgICAgICAgQWRkZWQgLS13eC1jb21waWxlci1wcmVmaXgg d2FmIG9wdGlvbiB0byBhbGxvdyBidWlsZGluZyB3eFdlYktpdCB3aXRoCmRpZmYgLS1naXQgYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNTEy NTNmMy4uMWYzNDMyNSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmNwcApAQCAtNzI0LDYgKzcyNCwxOSBAQCBzdGF0aWMgSlNWYWx1 ZVJlZiBzZXRIYW5kbGVzQXV0aGVudGljYXRpb25DaGFsbGVuZ2VzQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleAogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0K IAorc3RhdGljIEpTVmFsdWVSZWYgc2V0UE9TSVhMb2NhbGVDYWxsYmFjayhKU0NvbnRleHRSZWYg Y29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNp emVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVl UmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgPCAxKQorICAgICAgICBy ZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBMYXlvdXRUZXN0Q29u dHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4o SlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmlu Z1JlZj4gbG9jYWxlKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50 c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBjb250cm9s bGVyLT5zZXRQT1NJWExvY2FsZShsb2NhbGUuZ2V0KCkpOworCisgICAgcmV0dXJuIEpTVmFsdWVN YWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRJY29uRGF0 YWJhc2VFbmFibGVkQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1 bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29u c3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAg IC8vIEhhcyBtYWMgJiB3aW5kb3dzIGltcGxlbWVudGF0aW9uCkBAIC0xMTk1LDYgKzEyMDgsNyBA QCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25z KCkKICAgICAgICAgeyAic2V0RGF0YWJhc2VRdW90YSIsIHNldERhdGFiYXNlUXVvdGFDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LCAKICAgICAgICAgeyAic2V0R2VvbG9jYXRpb25QZXJtaXNzaW9uIiwgc2V0R2Vv bG9jYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SGFuZGxl c0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlcyIsIHNldEhhbmRsZXNBdXRoZW50aWNhdGlvbkNoYWxs ZW5nZXNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJzZXRQT1NJWExvY2FsZSIsIHNldFBP U0lYTG9jYWxlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0SWNvbkRhdGFiYXNlRW5h YmxlZCIsIHNldEljb25EYXRhYmFzZUVuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJzZXRKYXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZCIsIHNldEphdmFTY3JpcHRQcm9maWxpbmdF bmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0TWFpbkZyYW1lSXNGaXJzdFJl c3BvbmRlciIsIHNldE1haW5GcmFtZUlzRmlyc3RSZXNwb25kZXJDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApA QCAtMTI4MSwzICsxMjk1LDEwIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldEdlb2xv Y2F0aW9uUGVybWlzc2lvbihib29sIGFsbG93KQogICAgIG1faXNHZW9sb2NhdGlvblBlcm1pc3Np b25TZXQgPSB0cnVlOwogICAgIG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uID0gYWxsb3c7CiB9CisK K3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBPU0lYTG9jYWxlKEpTU3RyaW5nUmVmIGxv Y2FsZSkKK3sKKyAgICBjaGFyIGxvY2FsZUJ1ZlszMl07CisgICAgSlNTdHJpbmdHZXRVVEY4Q1N0 cmluZyhsb2NhbGUsIGxvY2FsZUJ1Ziwgc2l6ZW9mKGxvY2FsZUJ1ZikpOworICAgIHNldGxvY2Fs ZShMQ19BTEwsIGxvY2FsZUJ1Zik7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCAwMmY1ZGRiLi43YzgyOWVmIDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAg LTIwNyw2ICsyMDcsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBjbG9zZVdlYkluc3BlY3RvcigpOwog ICAgIHZvaWQgZXZhbHVhdGVJbldlYkluc3BlY3Rvcihsb25nIGNhbGxJZCwgSlNTdHJpbmdSZWYg c2NyaXB0KTsKIAorICAgIHZvaWQgc2V0UE9TSVhMb2NhbGUoSlNTdHJpbmdSZWYgbG9jYWxlKTsK KwogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzUERGOwogICAgIGJvb2wgbV9kdW1wQXNUZXh0 OwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJU cmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5j cHAKaW5kZXggNTQ2OGE0Zi4uNmVjZDc3NCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC0zMzQsNiArMzM0LDggQEAgc3RhdGlj IHZvaWQgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpCiAgICAgZ19vYmplY3Rfc2V0 KEdfT0JKRUNUKGluc3BlY3RvciksICJqYXZhc2NyaXB0LXByb2ZpbGluZy1lbmFibGVkIiwgRkFM U0UsIE5VTEwpOwogCiAgICAgd2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMo KTsKKworICAgIHNldGxvY2FsZShMQ19BTEwsICIiKTsKIH0KIAogdm9pZCBkdW1wKCkKZGlmZiAt LWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCA4 ZDc5YzZlLi4wYzMzMzgxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L0R1bXBSZW5kZXJUcmVlLm1tCkBAIC00NDMsNiArNDQzLDggQEAgc3RhdGljIHZvaWQgcmVzZXRE ZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpCiAgICAgICAgIFtwcmVmZXJlbmNlcyBzZXRBY2Nl bGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZDpZRVNdOwogCiAgICAgW1tOU0hUVFBDb29raWVTdG9y YWdlIHNoYXJlZEhUVFBDb29raWVTdG9yYWdlXSBzZXRDb29raWVBY2NlcHRQb2xpY3k6TlNIVFRQ Q29va2llQWNjZXB0UG9saWN5T25seUZyb21NYWluRG9jdW1lbnREb21haW5dOworCisgICAgc2V0 bG9jYWxlKExDX0FMTCwgIiIpOwogfQogCiAvLyBDYWxsZWQgb25jZSBvbiBEdW1wUmVuZGVyVHJl ZSBzdGFydHVwLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVt cFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRl clRyZWUuY3BwCmluZGV4IGE2ZjFmNTcuLjdhODhlZWIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTI4NCw2ICsyODQsOCBAQCB2 b2lkIER1bXBSZW5kZXJUcmVlOjpyZXNldFRvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygp CiAKICAgICBtX2NvbnRyb2xsZXItPnJlc2V0KCk7CiAgICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpy ZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKKworICAgIHNldGxvY2FsZShMQ19BTEwsICIi KTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZTo6b3Blbihjb25zdCBRVXJsJiBhdXJsKQpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNw cCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKaW5k ZXggZTQ3YzdlOC4uNGZmNDVhMiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCkBAIC03NDMsNiArNzQzLDggQEAgc3RhdGljIHZvaWQg cmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcyhJV2ViUHJlZmVyZW5jZXMqIHByZWZlcmVu Y2VzKQogICAgICAgICBwcmVmc1ByaXZhdGUtPnNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hl RW5hYmxlZChUUlVFKTsKICAgICB9CiAgICAgc2V0QWx3YXlzQWNjZXB0Q29va2llcyhmYWxzZSk7 CisKKyAgICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CiB9CiAKIHN0YXRpYyB2b2lkIHJlc2V0V2Vi Vmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygp 40749 2009-10-06 16:32:36 -0700 2009-10-07 10:54:24 -0700 add a regression test bug-18994-20091006163235.patch text/plain 8439 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4ZGNlOGExLi43YzU5ZjZiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDkt MzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGF5b3V0IHRlc3QgZm9yIHZlcmlmeWluZyB0 aGF0IExDX05VTUVSSUMgc2V0dGluZyBkb2Vzbid0IGFmZmVjdAorICAgICAgICB0aGUgd2F5IENT UyBwcm9wZXJ0aWVzIGFyZSBzdHJpbmdpZmllZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1m bG9hdC5odG1sOiBBZGRlZC4KKwogMjAwOS0xMC0wNiAgU2ltb24gRnJhc2VyICA8c2ltb24uZnJh c2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBNYXJrIFJvd2UuCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY2NWFkMWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMg QEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFj aXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZs b2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBi ZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KKworUEFTUwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjBlZjA0NTYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFj aXR5LWZsb2F0Lmh0bWwKQEAgLTAsMCArMSwyMyBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7CisKKyAgICAvLyBQdXQgb3Vyc2VsdmVzIGluIGEgbG9jYWxlIHdoZXJlIDAuOSBpcyB3cml0 dGVuIGFzICIwLDkiLgorICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNldFBPU0lYTG9jYWxlKCJw bF9QTC5VVEYtOCIpOworfQorPC9zY3JpcHQ+CisKKzxwPlRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0 IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTCithdHRyaWJ1dGVzIGdl dHMgYmFjayBhIHByb3Blcmx5LWZvcm1hdHRlZCBmbG9hdC4gIEltcHJvcGVybHkgaGFuZGxpbmcK K2xvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdo dCBicmVhaworaXQuPC9wPgorCis8YSBpZD0ndGVzdCcgc3R5bGU9J29wYWNpdHk6LjknPjwvYT4K KworPHNjcmlwdD4KK3ZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3Qn KS5zdHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7CitpZiAob3BhY2l0eSA9PSAnMC45JykKKyAgICBk b2N1bWVudC53cml0ZSgnUEFTUycpOworZWxzZQorICAgIGRvY3VtZW50LndyaXRlKCdGQUlMOiAn ICsgb3BhY2l0eSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iODE5ODNkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBhIGZsb2F0 aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBwcm9wZXJs eS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0IGNhdXNl IGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0LgorCitGQUlM OiAwLDkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0No YW5nZUxvZwppbmRleCBjMzMzMDNhLi4yODQyN2NjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIw MDktMDktMzAgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQSSB0byBMYXlvdXRUZXN0 Q29udHJvbGxlciBmb3IgcmUvc2V0dGluZyB0aGUgc3lzdGVtIGxvY2FsZS4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChzZXRMb2Nh bGVDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rp b25zKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRMb2NhbGUpOgorICAgICAg ICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisKIDIwMDktMTAtMDYg IE1hcmsgUm93ZSAgPG1yb3dlQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1v biBGcmFzZXIuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5jcHAKaW5kZXggNTEyNTNmMy4uMWYzNDMyNSAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcApAQCAtNzI0LDYg KzcyNCwxOSBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRIYW5kbGVzQXV0aGVudGljYXRpb25DaGFs bGVuZ2VzQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleAogICAgIHJldHVybiBKU1ZhbHVlTWFr ZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgc2V0UE9TSVhMb2Nh bGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpT T2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVl UmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3Vt ZW50Q291bnQgPCAxKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4 dCk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0 PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsK KyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gbG9jYWxlKEFkb3B0LCBKU1ZhbHVlVG9TdHJp bmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEq ZXhjZXB0aW9uKTsKKyAgICBjb250cm9sbGVyLT5zZXRQT1NJWExvY2FsZShsb2NhbGUuZ2V0KCkp OworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0 aWMgSlNWYWx1ZVJlZiBzZXRJY29uRGF0YWJhc2VFbmFibGVkQ2FsbGJhY2soSlNDb250ZXh0UmVm IGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBz aXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1 ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgJiB3aW5kb3dzIGltcGxlbWVudGF0 aW9uCkBAIC0xMTk1LDYgKzEyMDgsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAic2V0RGF0YWJhc2VRdW90YSIs IHNldERhdGFiYXNlUXVvdGFDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LCAKICAgICAgICAgeyAic2V0R2VvbG9j YXRpb25QZXJtaXNzaW9uIiwgc2V0R2VvbG9jYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2ssIGtKU1By b3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUg fSwKICAgICAgICAgeyAic2V0SGFuZGxlc0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlcyIsIHNldEhh bmRsZXNBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7 ICJzZXRQT1NJWExvY2FsZSIsIHNldFBPU0lYTG9jYWxlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAic2V0SWNvbkRhdGFiYXNlRW5hYmxlZCIsIHNldEljb25EYXRhYmFzZUVuYWJsZWRDYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRl RG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRKYXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZCIs IHNldEphdmFTY3JpcHRQcm9maWxpbmdFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmli dXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAg eyAic2V0TWFpbkZyYW1lSXNGaXJzdFJlc3BvbmRlciIsIHNldE1haW5GcmFtZUlzRmlyc3RSZXNw b25kZXJDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LApAQCAtMTI4MSwzICsxMjk1LDEwIEBAIHZvaWQgTGF5b3V0 VGVzdENvbnRyb2xsZXI6OnNldEdlb2xvY2F0aW9uUGVybWlzc2lvbihib29sIGFsbG93KQogICAg IG1faXNHZW9sb2NhdGlvblBlcm1pc3Npb25TZXQgPSB0cnVlOwogICAgIG1fZ2VvbG9jYXRpb25Q ZXJtaXNzaW9uID0gYWxsb3c7CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBP U0lYTG9jYWxlKEpTU3RyaW5nUmVmIGxvY2FsZSkKK3sKKyAgICBjaGFyIGxvY2FsZUJ1ZlszMl07 CisgICAgSlNTdHJpbmdHZXRVVEY4Q1N0cmluZyhsb2NhbGUsIGxvY2FsZUJ1Ziwgc2l6ZW9mKGxv Y2FsZUJ1ZikpOworICAgIHNldGxvY2FsZShMQ19BTEwsIGxvY2FsZUJ1Zik7Cit9CmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCAw MmY1ZGRiLi43YzgyOWVmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTIwNyw2ICsyMDcsOCBAQCBwdWJsaWM6CiAgICAgdm9p ZCBjbG9zZVdlYkluc3BlY3RvcigpOwogICAgIHZvaWQgZXZhbHVhdGVJbldlYkluc3BlY3Rvcihs b25nIGNhbGxJZCwgSlNTdHJpbmdSZWYgc2NyaXB0KTsKIAorICAgIHZvaWQgc2V0UE9TSVhMb2Nh bGUoSlNTdHJpbmdSZWYgbG9jYWxlKTsKKwogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzUERG OwogICAgIGJvb2wgbV9kdW1wQXNUZXh0OwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggNTQ2OGE0Zi4uNmVjZDc3NCAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBA IC0zMzQsNiArMzM0LDggQEAgc3RhdGljIHZvaWQgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZh bHVlcygpCiAgICAgZ19vYmplY3Rfc2V0KEdfT0JKRUNUKGluc3BlY3RvciksICJqYXZhc2NyaXB0 LXByb2ZpbGluZy1lbmFibGVkIiwgRkFMU0UsIE5VTEwpOwogCiAgICAgd2Via2l0X3Jlc2V0X29y aWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKKworICAgIHNldGxvY2FsZShMQ19BTEwsICIiKTsK IH0KIAogdm9pZCBkdW1wKCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9E dW1wUmVuZGVyVHJlZS5tbQppbmRleCA4ZDc5YzZlLi4wYzMzMzgxIDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC00NDMsNiArNDQz LDggQEAgc3RhdGljIHZvaWQgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpCiAgICAg ICAgIFtwcmVmZXJlbmNlcyBzZXRBY2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZDpZRVNdOwog CiAgICAgW1tOU0hUVFBDb29raWVTdG9yYWdlIHNoYXJlZEhUVFBDb29raWVTdG9yYWdlXSBzZXRD b29raWVBY2NlcHRQb2xpY3k6TlNIVFRQQ29va2llQWNjZXB0UG9saWN5T25seUZyb21NYWluRG9j dW1lbnREb21haW5dOworCisgICAgc2V0bG9jYWxlKExDX0FMTCwgIiIpOwogfQogCiAvLyBDYWxs ZWQgb25jZSBvbiBEdW1wUmVuZGVyVHJlZSBzdGFydHVwLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IGM1YTEwMTUuLjgzNjI2YWMg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVl LmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5j cHAKQEAgLTI4Niw2ICsyODYsOCBAQCB2b2lkIER1bXBSZW5kZXJUcmVlOjpyZXNldFRvQ29uc2lz dGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAKICAgICBtX2NvbnRyb2xsZXItPnJlc2V0KCk7CiAg ICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKKwor ICAgIHNldGxvY2FsZShMQ19BTEwsICIiKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZTo6b3Bl bihjb25zdCBRVXJsJiBhdXJsKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggZTQ3YzdlOC4uNGZmNDVhMiAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCkBAIC03NDMs NiArNzQzLDggQEAgc3RhdGljIHZvaWQgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcyhJ V2ViUHJlZmVyZW5jZXMqIHByZWZlcmVuY2VzKQogICAgICAgICBwcmVmc1ByaXZhdGUtPnNldE9m ZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChUUlVFKTsKICAgICB9CiAgICAgc2V0QWx3 YXlzQWNjZXB0Q29va2llcyhmYWxzZSk7CisKKyAgICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CiB9 CiAKIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGlu Zygp 40753 2009-10-06 18:04:32 -0700 2009-10-07 16:41:06 -0700 start patching out CSS floats with a Vector<UChar> bug-18994-20091006180431.patch text/plain 7357 evan ZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcCBiL1dlYkNvcmUv Y3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAppbmRleCAxZjJjOWNhLi5kZjEwYjBhIDEwMDY0NAot LS0gYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKKysrIGIvV2ViQ29yZS9jc3Mv Q1NTUHJpbWl0aXZlVmFsdWUuY3BwCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSAiQ1NTVmFs dWVLZXl3b3Jkcy5oIgogI2luY2x1ZGUgIkNvbG9yLmgiCiAjaW5jbHVkZSAiQ291bnRlci5oIgor I2luY2x1ZGUgImR0b2EuaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCiAjaW5jbHVkZSAi Tm9kZS5oIgogI2luY2x1ZGUgIlBhaXIuaCIKQEAgLTY4NCw2ICs2ODUsNTMgQEAgaW50IENTU1By aW1pdGl2ZVZhbHVlOjpnZXRJZGVudCgpCiAgICAgcmV0dXJuIG1fdmFsdWUuaWRlbnQ7CiB9CiAK K3ZvaWQgYXBwZW5kRmxvYXQoVmVjdG9yPFVDaGFyPiogb3V0cHV0LCBkb3VibGUgdmFsdWUsIGlu dCBwcmVjaXNpb24pIHsKKyAgICAvLyBGcm9tIHRoZSBDU1Mgc3BlY2lmaWNhdGlvbiBzZWN0aW9u IHRpdGxlZCAiSW50ZWdlcnMgYW5kIHJlYWwgbnVtYmVycyIsCisgICAgLy8gcmVhbCBudW1iZXJz IGFyZSBvbmx5IGZvcm1hdHRlZCBhcyBbc2lnbl0gW2RpZ2l0c10gIi4iIFtkaWdpdHNdLCB3aXRo CisgICAgLy8gbm8gc3BlY2lhbCBoYW5kbGluZyBvZiBleHBvbmVudHMsIE5hTiwgZXRjLgorICAg IGNoYXIgYnVmWzgwXTsKKyAgICBpbnQgZGVjaW1hbFBvaW50OworICAgIGludCBzaWduOworICAg IFdURjo6ZHRvYShidWYsIHZhbHVlLCAwLCAmZGVjaW1hbFBvaW50LCAmc2lnbiwgTlVMTCk7Cisg ICAgaW50IGxlbmd0aCA9IHN0YXRpY19jYXN0PGludD4oc3RybGVuKGJ1ZikpOworCisgICAgb3V0 cHV0LT5yZXNlcnZlQ2FwYWNpdHkob3V0cHV0LT5zaXplKCkgKyBsZW5ndGggKyAyKTsKKworICAg IGlmIChzaWduKQorICAgICAgICBvdXRwdXQtPmFwcGVuZCgnLScpOworCisgICAgaWYgKGRlY2lt YWxQb2ludCA8PSAwKSB7CisgICAgICAgIC8vIE9ubHkgZGlnaXRzIGFmdGVyIHRoZSBkZWNpbWFs IHBvaW50LgorICAgICAgICBvdXRwdXQtPmFwcGVuZCgnMCcpOworICAgICAgICBvdXRwdXQtPmFw cGVuZCgnLicpOworICAgICAgICBmb3IgKGludCBpID0gZGVjaW1hbFBvaW50OyBpIDwgMDsgaSsr KQorICAgICAgICAgICAgb3V0cHV0LT5hcHBlbmQoJzAnKTsKKyAgICAgICAgZm9yIChpbnQgaSA9 IDA7IGkgPCBtaW4obGVuZ3RoLCBwcmVjaXNpb24pOyBpKyspCisgICAgICAgICAgICBvdXRwdXQt PmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSBpZiAobGVuZ3RoIDw9IGRlY2ltYWxQb2ludCkg eworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBiZWZvcmUgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAg ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCisgICAgICAgICAgICBvdXRwdXQt PmFwcGVuZChidWZbaV0pOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGRlY2ltYWxQb2lu dCAtIGxlbmd0aDsgaSsrKQorICAgICAgICAgICAgb3V0cHV0LT5hcHBlbmQoJzAnKTsKKyAgICB9 IGVsc2UgeworICAgICAgICAvLyBEaWdpdHMgYmVmb3JlIGFuZCBhZnRlciB0aGUgZGVjaW1hbCBw b2ludC4KKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBkZWNpbWFsUG9pbnQ7IGkrKykKKyAg ICAgICAgICAgIG91dHB1dC0+YXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIG91dHB1dC0+YXBwZW5k KCcuJyk7CisgICAgICAgIGZvciAoaW50IGkgPSBkZWNpbWFsUG9pbnQ7IGkgPCBtaW4oZGVjaW1h bFBvaW50ICsgMSArIHByZWNpc2lvbiwgbGVuZ3RoKTsgaSsrKQorICAgICAgICAgICAgb3V0cHV0 LT5hcHBlbmQoYnVmW2ldKTsKKyAgICB9Cit9CisKK3N0YXRpYyBTdHJpbmcgZm9ybWF0V2l0aFVu aXRzKGRvdWJsZSB2YWx1ZSwgY29uc3QgY2hhciogdW5pdHMpIHsKKyAgICBWZWN0b3I8VUNoYXI+ IHJlc3VsdDsKKyAgICBhcHBlbmRGbG9hdCgmcmVzdWx0LCB2YWx1ZSwgNik7CisgICAgZm9yIChp bnQgaSA9IDA7IHVuaXRzW2ldOyBpKyspCisgICAgICAgIHJlc3VsdC5hcHBlbmQodW5pdHNbaV0p OworICAgIHJldHVybiBTdHJpbmc6OmFkb3B0KHJlc3VsdCk7Cit9CisKIFN0cmluZyBDU1NQcmlt aXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNvbnN0CiB7CiAgICAgLy8gRklYTUU6IHJldHVybiB0aGUg b3JpZ2luYWwgdmFsdWUgaW5zdGVhZCBvZiBhIGdlbmVyYXRlZCBvbmUgKGUuZy4gY29sb3IKQEAg LTY5NSw2MSArNzQzLDYxIEBAIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNv bnN0CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTlVNQkVSOgogICAgICAg ICBjYXNlIENTU19QQVJTRVJfSU5URUdFUjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51 bWJlcihtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1f dmFsdWUubnVtLCAiIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEVS Q0VOVEFHRToKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGclJSIsIG1f dmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5u dW0sICIlIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRU1TOgotICAg ICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2VtIiwgbV92YWx1ZS5udW0pOwor ICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImVtIik7CiAg ICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRVhTOgotICAgICAgICAgICAgdGV4 dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2V4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAg dGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImV4Iik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfUkVNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6 OmZvcm1hdCgiJS42bGdyZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9y bWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicmVtIik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfUFg6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxncHgiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAicHgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19DTToKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdjbSIsIG1fdmFs dWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0s ICJjbSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX01NOgotICAgICAg ICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21tIiwgbV92YWx1ZS5udW0pOworICAg ICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIm1tIik7CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfSU46Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxnaW4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0 ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiaW4iKTsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19QVDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1h dCgiJS42bGdwdCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRo VW5pdHMobV92YWx1ZS5udW0sICJwdCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX1BDOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3BjIiwg bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVl Lm51bSwgInBjIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfREVHOgot ICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2RlZyIsIG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJkZWci KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SQUQ6Ci0gICAgICAgICAg ICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncmFkIiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInJhZCIpOwogICAgICAg ICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0dSQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxnZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJncmFkIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpm b3JtYXQoIiUuNmxnbXMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0 V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAibXMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAg ICBjYXNlIENTU19TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3Mi LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAicyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0haOgot ICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2h6IiwgbV92YWx1ZS5udW0p OworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImh6Iik7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfS0haOgotICAgICAgICAgICAg dGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2toeiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAg ICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJraHoiKTsKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19UVVJOOgotICAgICAgICAgICAgdGV4dCA9IFN0 cmluZzo6Zm9ybWF0KCIlLjZsZ3R1cm4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0 ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAidHVybiIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX0RJTUVOU0lPTjoKICAgICAgICAgICAgIC8vIEZJWE1FCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2Nzcy9XZWJLaXRDU1NNYXRyaXguY3BwIGIvV2ViQ29yZS9jc3Mv V2ViS2l0Q1NTTWF0cml4LmNwcAppbmRleCBhYWY1YzNkLi5jNzliYzIxIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2Nzcy9XZWJLaXRDU1NNYXRyaXguY3BwCisrKyBiL1dlYkNvcmUvY3NzL1dlYktpdENT U01hdHJpeC5jcHAKQEAgLTE3NCw3ICsxNzQsNyBAQCBTdHJpbmcgV2ViS2l0Q1NTTWF0cml4Ojp0 b1N0cmluZygpIGNvbnN0CiB7CiAgICAgLy8gRklYTUUgLSBOZWVkIHRvIGVuc3VyZSB2YWxpZCBD U1MgZmxvYXRpbmcgcG9pbnQgdmFsdWVzIChodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjA2NzQpCiAgICAgaWYgKG1fbWF0cml4LmlzQWZmaW5lKCkpCi0gICAgICAgIHJl dHVybiBTdHJpbmc6OmZvcm1hdCgibWF0cml4KCVmLCAlZiwgJWYsICVmLCAlZiwgJWYpIiwKKyAg ICAgICAgcmV0dXJuIFN0cmluZzo6Zm9ybWF0KCJtYXRyaXgoJWYsICVmLCAlZiwgJWYsICVmLCAl ZikiLCAgLy8gbW9kaWZ5aW5nIHRoaXMgbGluZSBzbyBpdCBzaG93cyB1cCBpbiB0aGUgZGlmZgog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX21hdHJpeC5hKCksIG1fbWF0cml4LmIo KSwgbV9tYXRyaXguYygpLCBtX21hdHJpeC5kKCksIG1fbWF0cml4LmUoKSwgbV9tYXRyaXguZigp KTsKICAgICByZXR1cm4gU3RyaW5nOjpmb3JtYXQoIm1hdHJpeDNkKCVmLCAlZiwgJWYsICVmLCAl ZiwgJWYsICVmLCAlZiwgJWYsICVmLCAlZiwgJWYsICVmLCAlZiwgJWYsICVmKSIsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgbV9tYXRyaXgubTExKCksIG1fbWF0cml4Lm0xMigpLCBtX21h dHJpeC5tMTMoKSwgbV9tYXRyaXgubTE0KCksCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L3RleHQvVGV4dFN0cmVhbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dFN0cmVhbS5j cHAKaW5kZXggZWI0YmFlNy4uYjE1NTMxMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90 ZXh0L1RleHRTdHJlYW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0U3RyZWFt LmNwcApAQCAtNjYsMTggKzY2LDIwIEBAIFRleHRTdHJlYW0mIFRleHRTdHJlYW06Om9wZXJhdG9y PDwodW5zaWduZWQgbG9uZyBpKQogICAgIHJldHVybiAqdGhpcyA8PCBidWZmZXI7CiB9CiAKKy8v IFRoaXMgaXMgb2J2aW91c2x5IG5vdCBhY2NlcHRhYmxlLCBidXQgcmF0aGVyIGEgcXVpY2sgaGFj ayB0byBtYWtlIHRoZQorLy8gRHVtcFJlbmRlclRyZWUgb3V0cHV0IGNvcnJlY3QuCitleHRlcm4g dm9pZCBhcHBlbmRGbG9hdChWZWN0b3I8VUNoYXI+KiBvdXRwdXQsIGRvdWJsZSB2YWx1ZSwgaW50 IHByZWNpc2lvbik7CisKIFRleHRTdHJlYW0mIFRleHRTdHJlYW06Om9wZXJhdG9yPDwoZmxvYXQg ZikKIHsKLSAgICBjaGFyIGJ1ZmZlcltwcmludEJ1ZmZlclNpemVdOwotICAgIHNucHJpbnRmKGJ1 ZmZlciwgc2l6ZW9mKGJ1ZmZlcikgLSAxLCAiJS4yZiIsIGYpOwotICAgIHJldHVybiAqdGhpcyA8 PCBidWZmZXI7CisgICAgYXBwZW5kRmxvYXQoJm1fdGV4dCwgZiwgMik7CisgICAgcmV0dXJuICp0 aGlzOwogfQogCiBUZXh0U3RyZWFtJiBUZXh0U3RyZWFtOjpvcGVyYXRvcjw8KGRvdWJsZSBkKQog ewotICAgIGNoYXIgYnVmZmVyW3ByaW50QnVmZmVyU2l6ZV07Ci0gICAgc25wcmludGYoYnVmZmVy LCBzaXplb2YoYnVmZmVyKSAtIDEsICIlLjJmIiwgZCk7Ci0gICAgcmV0dXJuICp0aGlzIDw8IGJ1 ZmZlcjsKKyAgICBhcHBlbmRGbG9hdCgmbV90ZXh0LCBkLCAyKTsKKyAgICByZXR1cm4gKnRoaXM7 CiB9CiAKIFRleHRTdHJlYW0mIFRleHRTdHJlYW06Om9wZXJhdG9yPDwoY29uc3QgY2hhciogc3Ry aW5nKQ== 40828 2009-10-07 16:41:12 -0700 2009-10-08 15:30:22 -0700 use dtoa directly in CSS units bug-18994-20091007164110.patch text/plain 6965 evan ZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcCBiL1dlYkNvcmUv Y3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAppbmRleCAxZjJjOWNhLi43NDg5ODhkIDEwMDY0NAot LS0gYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKKysrIGIvV2ViQ29yZS9jc3Mv Q1NTUHJpbWl0aXZlVmFsdWUuY3BwCkBAIC02ODQsNiArNjg0LDE1IEBAIGludCBDU1NQcmltaXRp dmVWYWx1ZTo6Z2V0SWRlbnQoKQogICAgIHJldHVybiBtX3ZhbHVlLmlkZW50OwogfQogCitzdGF0 aWMgU3RyaW5nIGZvcm1hdFdpdGhVbml0cyhkb3VibGUgdmFsdWUsIGNvbnN0IGNoYXIqIHVuaXRz KQoreworICAgIFZlY3RvcjxVQ2hhcj4gcmVzdWx0OworICAgIGFwcGVuZERvdWJsZShyZXN1bHQs IHZhbHVlLCA2KTsKKyAgICBmb3IgKGludCBpID0gMDsgdW5pdHNbaV07IGkrKykKKyAgICAgICAg cmVzdWx0LmFwcGVuZCh1bml0c1tpXSk7CisgICAgcmV0dXJuIFN0cmluZzo6YWRvcHQocmVzdWx0 KTsKK30KKwogU3RyaW5nIENTU1ByaW1pdGl2ZVZhbHVlOjpjc3NUZXh0KCkgY29uc3QKIHsKICAg ICAvLyBGSVhNRTogcmV0dXJuIHRoZSBvcmlnaW5hbCB2YWx1ZSBpbnN0ZWFkIG9mIGEgZ2VuZXJh dGVkIG9uZSAoZS5nLiBjb2xvcgpAQCAtNjk1LDYxICs3MDQsNjEgQEAgU3RyaW5nIENTU1ByaW1p dGl2ZVZhbHVlOjpjc3NUZXh0KCkgY29uc3QKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBj YXNlIENTU19OVU1CRVI6CiAgICAgICAgIGNhc2UgQ1NTX1BBUlNFUl9JTlRFR0VSOgotICAgICAg ICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICIiKTsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19QRVJDRU5UQUdFOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZyUlIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIiUiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19FTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxnZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAiZW0iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19FWFM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZXgiLCBtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVt LCAiZXgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SRU1TOgotICAg ICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3JlbSIsIG1fdmFsdWUubnVtKTsK KyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJyZW0iKTsK ICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19QWDoKLSAgICAgICAgICAgIHRl eHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdweCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAg IHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJweCIpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0NNOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 Zm9ybWF0KCIlLjZsZ2NtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1h dFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImNtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBDU1NfTU06Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxn bW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1f dmFsdWUubnVtLCAibW0iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19J TjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdpbiIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJp biIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BUOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3B0IiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInB0Iik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3Ry aW5nOjpmb3JtYXQoIiUuNmxncGMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0g Zm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicGMiKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19ERUc6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxnZGVnIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhV bml0cyhtX3ZhbHVlLm51bSwgImRlZyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX1JBRDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdyYWQi LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAicmFkIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfR1JB RDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdncmFkIiwgbV92YWx1 ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwg ImdyYWQiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19NUzoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdtcyIsIG1fdmFsdWUubnVtKTsKKyAg ICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJtcyIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1M6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxncyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQg PSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJzIik7CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgY2FzZSBDU1NfSFo6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxnaHoiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVu aXRzKG1fdmFsdWUubnVtLCAiaHoiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNl IENTU19LSFo6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxna2h6Iiwg bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVl Lm51bSwgImtoeiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1RVUk46 Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxndHVybiIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJ0 dXJuIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRElNRU5TSU9OOgog ICAgICAgICAgICAgLy8gRklYTUUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9Q bGF0Zm9ybVN0cmluZy5oIGIvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1BsYXRmb3JtU3RyaW5nLmgK aW5kZXggOGQxOWMxNy4uZjIyYmJjMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0 L1BsYXRmb3JtU3RyaW5nLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1BsYXRmb3JtU3Ry aW5nLmgKQEAgLTM5Myw3ICszOTMsNyBAQCBpbmxpbmUgdm9pZCBhcHBlbmROdW1iZXIoVmVjdG9y PFVDaGFyPiYgdmVjdG9yLCB1bnNpZ25lZCBjaGFyIG51bWJlcikKICAgICB9CiB9CiAKLQordm9p ZCBhcHBlbmREb3VibGUoVmVjdG9yPFVDaGFyPiYgdmVjdG9yLCBkb3VibGUgdmFsdWUsIGludCBk aWdpdHMpOwogCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gdXRmOEJ1ZmZlcihjb25zdCBTdHJp bmcmKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1N0cmluZy5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL3RleHQvU3RyaW5nLmNwcAppbmRleCBiZWYyNjc0Li44OTNhOTg3IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvU3RyaW5nLmNwcAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL3RleHQvU3RyaW5nLmNwcApAQCAtOTA1LDYgKzkwNSw0NiBAQCBmbG9hdCBjaGFy YWN0ZXJzVG9GbG9hdChjb25zdCBVQ2hhciogZGF0YSwgc2l6ZV90IGxlbmd0aCwgYm9vbCogb2sp CiAgICAgcmV0dXJuIG5hcnJvd1ByZWNpc2lvblRvRmxvYXQoY2hhcmFjdGVyc1RvRG91YmxlKGRh dGEsIGxlbmd0aCwgb2spKTsKIH0KIAordm9pZCBhcHBlbmREb3VibGUoVmVjdG9yPFVDaGFyPiYg dmVjdG9yLCBkb3VibGUgdmFsdWUsIGludCBkaWdpdHMpCit7CisgICAgLy8gRnJvbSB0aGUgQ1NT IHNwZWNpZmljYXRpb24gc2VjdGlvbiB0aXRsZWQgIkludGVnZXJzIGFuZCByZWFsIG51bWJlcnMi LAorICAgIC8vIHJlYWwgbnVtYmVycyBhcmUgb25seSBmb3JtYXR0ZWQgYXMgW3NpZ25dIFtkaWdp dHNdICIuIiBbZGlnaXRzXSwgd2l0aAorICAgIC8vIG5vIHNwZWNpYWwgaGFuZGxpbmcgb2YgZXhw b25lbnRzLCBOYU4sIGV0Yy4KKyAgICBjaGFyIGJ1Zls4MF07CisgICAgaW50IGRlY2ltYWxQb2lu dDsKKyAgICBpbnQgc2lnbjsKKyAgICBXVEY6OmR0b2EoYnVmLCB2YWx1ZSwgMCwgJmRlY2ltYWxQ b2ludCwgJnNpZ24sIE5VTEwpOworICAgIGludCBsZW5ndGggPSBzdGF0aWNfY2FzdDxpbnQ+KHN0 cmxlbihidWYpKTsKKworICAgIHZlY3Rvci5yZXNlcnZlQ2FwYWNpdHkodmVjdG9yLnNpemUoKSAr IGxlbmd0aCArIDIpOworCisgICAgaWYgKHNpZ24pCisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy0n KTsKKworICAgIGlmIChkZWNpbWFsUG9pbnQgPD0gMCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0 cyBhZnRlciB0aGUgZGVjaW1hbCBwb2ludC4KKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOwor ICAgICAgICB2ZWN0b3IuYXBwZW5kKCcuJyk7CisgICAgICAgIGZvciAoaW50IGkgPSBkZWNpbWFs UG9pbnQ7IGkgPCAwOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAg ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbWluKGxlbmd0aCwgZGlnaXRzKTsgaSsrKQorICAgICAg ICAgICAgdmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSBpZiAobGVuZ3RoIDw9IGRl Y2ltYWxQb2ludCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBiZWZvcmUgdGhlIGRlY2ltYWwg cG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCisgICAgICAg ICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwg ZGVjaW1hbFBvaW50IC0gbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKCcw Jyk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gRGlnaXRzIGJlZm9yZSBhbmQgYWZ0ZXIgdGhl IGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZGVjaW1hbFBvaW50 OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIHZlY3Rv ci5hcHBlbmQoJy4nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IGRlY2ltYWxQb2ludDsgaSA8IG1p bihkaWdpdHMsIGxlbmd0aCk7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBlbmQoYnVmW2ld KTsKKyAgICB9Cit9CisKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiB1dGY4QnVmZmVyKGNvbnN0 IFN0cmluZyYgc3RyaW5nKQogewogICAgIC8vIEFsbG9jYXRlIGEgYnVmZmVyIGJpZyBlbm91Z2gg dG8gaG9sZCBhbGwgdGhlIGNoYXJhY3RlcnMuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L3RleHQvVGV4dFN0cmVhbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dFN0cmVhbS5j cHAKaW5kZXggZWI0YmFlNy4uMjY0M2QzNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90 ZXh0L1RleHRTdHJlYW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0U3RyZWFt LmNwcApAQCAtNjgsMTYgKzY4LDE0IEBAIFRleHRTdHJlYW0mIFRleHRTdHJlYW06Om9wZXJhdG9y PDwodW5zaWduZWQgbG9uZyBpKQogCiBUZXh0U3RyZWFtJiBUZXh0U3RyZWFtOjpvcGVyYXRvcjw8 KGZsb2F0IGYpCiB7Ci0gICAgY2hhciBidWZmZXJbcHJpbnRCdWZmZXJTaXplXTsKLSAgICBzbnBy aW50ZihidWZmZXIsIHNpemVvZihidWZmZXIpIC0gMSwgIiUuMmYiLCBmKTsKLSAgICByZXR1cm4g KnRoaXMgPDwgYnVmZmVyOworICAgIGFwcGVuZERvdWJsZShtX3RleHQsIGYsIDIpOworICAgIHJl dHVybiAqdGhpczsKIH0KIAogVGV4dFN0cmVhbSYgVGV4dFN0cmVhbTo6b3BlcmF0b3I8PChkb3Vi bGUgZCkKIHsKLSAgICBjaGFyIGJ1ZmZlcltwcmludEJ1ZmZlclNpemVdOwotICAgIHNucHJpbnRm KGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlcikgLSAxLCAiJS4yZiIsIGQpOwotICAgIHJldHVybiAqdGhp cyA8PCBidWZmZXI7CisgICAgYXBwZW5kRG91YmxlKG1fdGV4dCwgZCwgMik7CisgICAgcmV0dXJu ICp0aGlzOwogfQogCiBUZXh0U3RyZWFtJiBUZXh0U3RyZWFtOjpvcGVyYXRvcjw8KGNvbnN0IGNo YXIqIHN0cmluZyk= 40916 2009-10-08 15:30:28 -0700 2009-10-08 19:06:46 -0700 use dtoa directly in CSS units bug-18994-20091008153027.patch text/plain 9519 evan ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cAppbmRleCBkOTRkY2ZhLi45Yjk3Mjk2IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUuZXhwCkBAIC0zNDUsNiArMzQ1LDcgQEAgX19aTjNXVEY4Q29sbGF0 b3JDMUVQS2MKIF9fWk4zV1RGOENvbGxhdG9yRDFFdgogX19aTjNXVEY4ZmFzdEZyZWVFUHYKIF9f Wk4zV1RGOUJ5dGVBcnJheTZjcmVhdGVFbQorX19aTjNXVEY0ZHRvYUVQY2RpUGlTMV9QUzBfCiBf X1pOSzNKU0MxMEpTRnVuY3Rpb24yM2lzSG9zdEZ1bmN0aW9uTm9uSW5saW5lRXYKIF9fWk5LM0pT QzExSW50ZXJwcmV0ZXIxNHJldHJpZXZlQ2FsbGVyRVBOU185RXhlY1N0YXRlRVBOU18xNkludGVy bmFsRnVuY3Rpb25FCiBfX1pOSzNKU0MxMUludGVycHJldGVyMThyZXRyaWV2ZUxhc3RDYWxsZXJF UE5TXzlFeGVjU3RhdGVFUmlSbFJOU183VVN0cmluZ0VSTlNfN0pTVmFsdWVFICAKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlwLWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlwLWV4cGVj dGVkLnR4dAppbmRleCBjOWM2ZGMxLi40ODc5NTQ0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9m YXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0CkBAIC0x ICsxIEBACi1GQUlMOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5LjAwMWUrMDdweCwgcmVhZCBh Z2FpbiBhcyAwcHgKK1BBU1M6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFzIDkwMDEwMDAwcHgsIHJl YWQgYWdhaW4gYXMgOTAwMTAwMDBweApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mv b3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5 LWZsb2F0LWV4cGVjdGVkLnR4dAppbmRleCBmNjVhZDFmLi4yZGY4ODkxIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAtMSwzICsxLDkg QEAKIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFj aXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZs b2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBi ZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KIAogUEFTUworUEFTUworUEFTUwor UEFTUworUEFTUworUEFTUworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFj aXR5LWZsb2F0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwK aW5kZXggMGVmMDQ1Ni4uNTE3NjZhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mv b3BhY2l0eS1mbG9hdC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxv YXQuaHRtbApAQCAtMTIsMTIgKzEyLDMwIEBAIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVy bHktZm9ybWF0dGVkIGZsb2F0LiAgSW1wcm9wZXJseSBoYW5kbGluZwogbG9jYWxlcyB0aGF0IGNh dXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrCiBpdC48L3A+ CiAKLTxhIGlkPSd0ZXN0JyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9J3Rlc3QxJyBz dHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9J3Rlc3QyJyBzdHlsZT0nb3BhY2l0eTo5NDMy MDAwMCc+PC9hPgorPGEgaWQ9J3Rlc3QzJyBzdHlsZT0nb3BhY2l0eTowLjAwMDAyMSc+PC9hPgor PGEgaWQ9J3Rlc3Q0JyBzdHlsZT0nb3BhY2l0eTo1MC4wMic+PC9hPgorPGEgaWQ9J3Rlc3Q1JyBz dHlsZT0nb3BhY2l0eTotMTAuMSc+PC9hPgorPGEgaWQ9J3Rlc3Q2JyBzdHlsZT0nb3BhY2l0eTow LjUnPjwvYT4KIAogPHNjcmlwdD4KLXZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ3Rlc3QnKS5zdHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7Ci1pZiAob3BhY2l0eSA9PSAnMC45 JykKLSAgICBkb2N1bWVudC53cml0ZSgnUEFTUycpOwotZWxzZQotICAgIGRvY3VtZW50LndyaXRl KCdGQUlMOiAnICsgb3BhY2l0eSk7CitmdW5jdGlvbiBkb1Rlc3QobmFtZSwgZXhwZWN0ZWQpIHsK KyAgICB2YXIgb3BhY2l0eSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG5hbWUpLnN0eWxlLm9w YWNpdHkudG9TdHJpbmcoKTsKKyAgICBpZiAob3BhY2l0eSA9PSBleHBlY3RlZCkKKyAgICAgICAg ZG9jdW1lbnQud3JpdGUoJ1BBU1MnKTsKKyAgICBlbHNlCisgICAgICAgIGRvY3VtZW50LndyaXRl KCdGQUlMOiBleHBlY3RlZCAnICsgZXhwZWN0ZWQgKyAnLCBnb3QgJyArIG9wYWNpdHkpOworICAg IGRvY3VtZW50LndyaXRlKCc8YnI+Jyk7Cit9Citkb1Rlc3QoJ3Rlc3QxJywgJzAuOScpOworZG9U ZXN0KCd0ZXN0MicsICc5NDMyMDAwMCcpOworZG9UZXN0KCd0ZXN0MycsICcwLjAwMDAyMScpOwor ZG9UZXN0KCd0ZXN0NCcsICc1MC4wMicpOworZG9UZXN0KCd0ZXN0NScsICctMTAuMScpOworCisv LyBWZXJpZnkgdGhhdCBpbnZhbGlkIHZhbHVlcyBsaWtlIE5hTiBuZXZlciBldmVuIG1ha2UgaXQg aW50byB0aGUgQ1NTIHZhbHVlcy4KKy8vIEkuZS4sIHRoZSBuZXh0IGxpbmUgc2hvdWxkIG5vdCBh ZmZlY3QgdGhlIG9wYWNpdHkgdmFsdWUuCitkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdDYn KS5zdHlsZS5vcGFjaXR5ID0gMSAvIDA7Citkb1Rlc3QoJ3Rlc3Q2JywgJzAuNScpOwogPC9zY3Jp cHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZmFzdC9jc3Mvb3BhY2l0 eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZmFzdC9jc3Mv b3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IGI4MTk4M2QuLjAwMDAwMDAKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2Zhc3QvY3Nz L29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMyArMCwwIEBA Ci1UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmctcG9pbnQgb3BhY2l0 eSBmcm9tIENTUyBhdHRyaWJ1dGVzIGdldHMgYmFjayBhIHByb3Blcmx5LWZvcm1hdHRlZCBmbG9h dC4gSW1wcm9wZXJseSBoYW5kbGluZyBsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1hbHMgdG8gYmUg d3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsgaXQuCi0KLUZBSUw6IDAsOQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwIGIvV2ViQ29yZS9jc3MvQ1NTUHJp bWl0aXZlVmFsdWUuY3BwCmluZGV4IDFmMmM5Y2EuLmM2NjFmOTcgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9DU1NQcmltaXRp dmVWYWx1ZS5jcHAKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJSZWN0LmgiCiAjaW5jbHVk ZSAiUmVuZGVyU3R5bGUuaCIKICNpbmNsdWRlIDx3dGYvQVNDSUlDVHlwZS5oPgorI2luY2x1ZGUg PHd0Zi9kdG9hLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiAjaWYgRU5BQkxF KERBU0hCT0FSRF9TVVBQT1JUKQpAQCAtNjg0LDYgKzY4NSw2NyBAQCBpbnQgQ1NTUHJpbWl0aXZl VmFsdWU6OmdldElkZW50KCkKICAgICByZXR1cm4gbV92YWx1ZS5pZGVudDsKIH0KIAorCitzdGF0 aWMgdm9pZCBhcHBlbmRDU1NEb3VibGUoVmVjdG9yPFVDaGFyPiYgdmVjdG9yLCBkb3VibGUgdmFs dWUpCit7CisgICAgLy8gRnJvbSB0aGUgQ1NTIHNwZWNpZmljYXRpb24gc2VjdGlvbiB0aXRsZWQg IkludGVnZXJzIGFuZCByZWFsIG51bWJlcnMiLAorICAgIC8vIHJlYWwgbnVtYmVycyBhcmUgb25s eSBmb3JtYXR0ZWQgYXMgW3NpZ25dIFtkaWdpdHNdICIuIiBbZGlnaXRzXS4KKyAgICAvLyBUaGlz IGRpZmZlcnMgZnJvbSBwcmludGYtc3R5bGUgZm9ybWF0dGluZyBpbiB0aGF0IGV4cG9uZW50cyAo ZS5nLiAxLjNlMDYpCisgICAgLy8gYXJlIG5vdCBhbGxvd2VkLiAgU2luY2UgTmFOL2luZiBhcmUg YWxzbyBub3QgdmFsaWQgQ1NTIHZhbHVlcyB0aGlzCisgICAgLy8gZnVuY3Rpb24gZG9lc24ndCBo YW5kbGUgdGhlbS4KKyAgICBjb25zdCBpbnQgZGlnaXRzID0gNjsKKyAgICBjaGFyIGJ1Zls4MF07 CisgICAgaW50IGRlY2ltYWxQb2ludDsKKyAgICBpbnQgc2lnbjsKKyAgICBXVEY6OmR0b2EoYnVm LCB2YWx1ZSwgMCwgJmRlY2ltYWxQb2ludCwgJnNpZ24sIE5VTEwpOworICAgIGludCBsZW5ndGgg PSBzdGF0aWNfY2FzdDxpbnQ+KHN0cmxlbihidWYpKTsKKworICAgIGlmIChkZWNpbWFsUG9pbnQg PD0gMCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBhZnRlciB0aGUgZGVjaW1hbCBwb2ludC4K KyAgICAgICAgdmVjdG9yLnJlc2VydmVDYXBhY2l0eSh2ZWN0b3Iuc2l6ZSgpICsgKHNpZ24gPyAx IDogMCkgKyAyICsgLWRlY2ltYWxQb2ludCArIG1pbihsZW5ndGgsIGRpZ2l0cykpOworCisgICAg ICAgIGlmIChzaWduKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZCgnLScpOworICAgICAgICB2 ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy4nKTsKKyAgICAgICAg Zm9yIChpbnQgaSA9IGRlY2ltYWxQb2ludDsgaSA8IDA7IGkrKykKKyAgICAgICAgICAgIHZlY3Rv ci5hcHBlbmQoJzAnKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBtaW4obGVuZ3RoLCBk aWdpdHMpOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgfSBl bHNlIGlmIChsZW5ndGggPD0gZGVjaW1hbFBvaW50KSB7CisgICAgICAgIC8vIE9ubHkgZGlnaXRz IGJlZm9yZSB0aGUgZGVjaW1hbCBwb2ludC4KKyAgICAgICAgdmVjdG9yLnJlc2VydmVDYXBhY2l0 eSh2ZWN0b3Iuc2l6ZSgpICsgKHNpZ24gPyAxIDogMCkgKyBkZWNpbWFsUG9pbnQpOworCisgICAg ICAgIGlmIChzaWduKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZCgnLScpOworICAgICAgICBm b3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVu ZChidWZbaV0pOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGRlY2ltYWxQb2ludCAtIGxl bmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgIH0gZWxzZSB7 CisgICAgICAgIC8vIERpZ2l0cyBiZWZvcmUgYW5kIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50Lgor ICAgICAgICB2ZWN0b3IucmVzZXJ2ZUNhcGFjaXR5KHZlY3Rvci5zaXplKCkgKyAoc2lnbiA/IDEg OiAwKSArIDEgKyBtaW4oZGlnaXRzLCBsZW5ndGgpKTsKKworICAgICAgICBpZiAoc2lnbikKKyAg ICAgICAgICAgIHZlY3Rvci5hcHBlbmQoJy0nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkg PCBkZWNpbWFsUG9pbnQ7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsK KyAgICAgICAgdmVjdG9yLmFwcGVuZCgnLicpOworICAgICAgICBmb3IgKGludCBpID0gZGVjaW1h bFBvaW50OyBpIDwgbWluKGRpZ2l0cywgbGVuZ3RoKTsgaSsrKQorICAgICAgICAgICAgdmVjdG9y LmFwcGVuZChidWZbaV0pOworICAgIH0KK30KKworc3RhdGljIFN0cmluZyBmb3JtYXRXaXRoVW5p dHMoZG91YmxlIHZhbHVlLCBjb25zdCBjaGFyKiB1bml0cykKK3sKKyAgICBWZWN0b3I8VUNoYXI+ IHJlc3VsdDsKKyAgICBhcHBlbmRDU1NEb3VibGUocmVzdWx0LCB2YWx1ZSk7CisgICAgcmVzdWx0 LnJlc2VydmVDYXBhY2l0eShyZXN1bHQuc2l6ZSgpICsgc3RybGVuKHVuaXRzKSk7CisgICAgZm9y IChpbnQgaSA9IDA7IHVuaXRzW2ldOyBpKyspCisgICAgICAgIHJlc3VsdC5hcHBlbmQodW5pdHNb aV0pOworICAgIHJldHVybiBTdHJpbmc6OmFkb3B0KHJlc3VsdCk7Cit9CisKIFN0cmluZyBDU1NQ cmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNvbnN0CiB7CiAgICAgLy8gRklYTUU6IHJldHVybiB0 aGUgb3JpZ2luYWwgdmFsdWUgaW5zdGVhZCBvZiBhIGdlbmVyYXRlZCBvbmUgKGUuZy4gY29sb3IK QEAgLTY5NSw2MSArNzU3LDYxIEBAIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgp IGNvbnN0CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTlVNQkVSOgogICAg ICAgICBjYXNlIENTU19QQVJTRVJfSU5URUdFUjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6 Om51bWJlcihtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAiIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1Nf UEVSQ0VOVEFHRToKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGclJSIs IG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1 ZS5udW0sICIlIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRU1TOgot ICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2VtIiwgbV92YWx1ZS5udW0p OworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImVtIik7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRVhTOgotICAgICAgICAgICAg dGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2V4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAg ICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImV4Iik7CiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUkVNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJp bmc6OmZvcm1hdCgiJS42bGdyZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0g Zm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicmVtIik7CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgY2FzZSBDU1NfUFg6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxncHgiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVu aXRzKG1fdmFsdWUubnVtLCAicHgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNl IENTU19DTToKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdjbSIsIG1f dmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5u dW0sICJjbSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX01NOgotICAg ICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21tIiwgbV92YWx1ZS5udW0pOwor ICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIm1tIik7CiAg ICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfSU46Ci0gICAgICAgICAgICB0ZXh0 ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnaW4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiaW4iKTsKICAgICAgICAgICAgIGJy ZWFrOwogICAgICAgICBjYXNlIENTU19QVDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZv cm1hdCgiJS42bGdwdCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRX aXRoVW5pdHMobV92YWx1ZS5udW0sICJwdCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGNhc2UgQ1NTX1BDOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3Bj IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3Zh bHVlLm51bSwgInBjIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfREVH OgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2RlZyIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJk ZWciKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SQUQ6Ci0gICAgICAg ICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncmFkIiwgbV92YWx1ZS5udW0pOworICAg ICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInJhZCIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0dSQUQ6Ci0gICAgICAgICAgICB0ZXh0 ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAg IHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJncmFkIik7CiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5n Ojpmb3JtYXQoIiUuNmxnbXMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9y bWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAibXMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZs Z3MiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1f dmFsdWUubnVtLCAicyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0ha OgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2h6IiwgbV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImh6 Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfS0haOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2toeiIsIG1fdmFsdWUubnVtKTsKKyAgICAg ICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJraHoiKTsKICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19UVVJOOgotICAgICAgICAgICAgdGV4dCA9 IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3R1cm4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAidHVybiIpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0RJTUVOU0lPTjoKICAgICAgICAgICAgIC8vIEZJWE1F 40923 2009-10-08 19:06:51 -0700 2009-10-08 19:17:58 -0700 use dtoa directly in CSS units bug-18994-20091008190650.patch text/plain 10438 evan ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cAppbmRleCBkOTRkY2ZhLi45Yjk3Mjk2IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUuZXhwCkBAIC0zNDUsNiArMzQ1LDcgQEAgX19aTjNXVEY4Q29sbGF0 b3JDMUVQS2MKIF9fWk4zV1RGOENvbGxhdG9yRDFFdgogX19aTjNXVEY4ZmFzdEZyZWVFUHYKIF9f Wk4zV1RGOUJ5dGVBcnJheTZjcmVhdGVFbQorX19aTjNXVEY0ZHRvYUVQY2RpUGlTMV9QUzBfCiBf X1pOSzNKU0MxMEpTRnVuY3Rpb24yM2lzSG9zdEZ1bmN0aW9uTm9uSW5saW5lRXYKIF9fWk5LM0pT QzExSW50ZXJwcmV0ZXIxNHJldHJpZXZlQ2FsbGVyRVBOU185RXhlY1N0YXRlRVBOU18xNkludGVy bmFsRnVuY3Rpb25FCiBfX1pOSzNKU0MxMUludGVycHJldGVyMThyZXRyaWV2ZUxhc3RDYWxsZXJF UE5TXzlFeGVjU3RhdGVFUmlSbFJOU183VVN0cmluZ0VSTlNfN0pTVmFsdWVFICAKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2dldENvbXB1dGVkU3R5bGUvZ2V0Q29tcHV0ZWRTdHls ZS10cmFuc2Zvcm0uaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2dldENvbXB1dGVkU3R5bGUv Z2V0Q29tcHV0ZWRTdHlsZS10cmFuc2Zvcm0uaHRtbAppbmRleCA0NWU2ODY3Li5kMDg0NmFhIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9nZXRDb21wdXRlZFN0eWxlL2dldENvbXB1 dGVkU3R5bGUtdHJhbnNmb3JtLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvZ2V0Q29t cHV0ZWRTdHlsZS9nZXRDb21wdXRlZFN0eWxlLXRyYW5zZm9ybS5odG1sCkBAIC00NSw2ICs0NSw4 IEBACiAgICAgICAgIHRlc3RCb3guc3R5bGUud2Via2l0VHJhbnNmb3JtID0gY3VyVGVzdC50cmFu c2Zvcm07CiAgICAgICAgIC8vIHJlYWQgYmFjayBjb21wdXRlZCBzdHlsZQogICAgICAgICB2YXIg b2xkVHJhbnNmb3JtID0gd2luZG93LmdldENvbXB1dGVkU3R5bGUodGVzdEJveCkud2Via2l0VHJh bnNmb3JtOworICAgICAgICAvLyBzZXQgdGhlIHRyYW5zZm9ybSB0byBzb21ldGhpbmcgZWxzZSBp biBjYXNlIHRoZSBsaW5lIGFmdGVyIGZhaWxzCisgICAgICAgIHRlc3RCb3guc3R5bGUud2Via2l0 VHJhbnNmb3JtID0gJ21hdHJpeCgxLCAxLCAxLCAxLCAxLCAxKSc7CiAgICAgICAgIC8vIHNldCB0 aGF0IG1hdHJpeCgpIGJhY2sgb24gdGhlIGVsZW1lbnQKICAgICAgICAgdGVzdEJveC5zdHlsZS53 ZWJraXRUcmFuc2Zvcm0gPSBvbGRUcmFuc2Zvcm07CiAgICAgICAgIC8vIHJlYWQgYmFjayBjb21w dXRlZCBzdHlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVy LXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVt YmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0CmluZGV4IGM5YzZkYzEuLjQ4Nzk1NDQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlwLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJp cC1leHBlY3RlZC50eHQKQEAgLTEgKzEgQEAKLUZBSUw6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFz IDkuMDAxZSswN3B4LCByZWFkIGFnYWluIGFzIDBweAorUEFTUzogcmVhZCA5MDAxMDAwMHB4IGJh Y2sgYXMgOTAwMTAwMDBweCwgcmVhZCBhZ2FpbiBhcyA5MDAxMDAwMHB4CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CmluZGV4IGY2NWFkMWYuLjJk Zjg4OTEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhw ZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0 ZWQudHh0CkBAIC0xLDMgKzEsOSBAQAogVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBh IGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBw cm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0 IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0Lgog CiBQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3Nz L29wYWNpdHktZmxvYXQuaHRtbAppbmRleCAwZWYwNDU2Li41MTc2NmFiIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCkBAIC0xMiwxMiArMTIsMzAgQEAgYXR0cmlidXRl cyBnZXRzIGJhY2sgYSBwcm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuICBJbXByb3Blcmx5IGhhbmRs aW5nCiBsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1hbHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMg bWlnaHQgYnJlYWsKIGl0LjwvcD4KIAotPGEgaWQ9J3Rlc3QnIHN0eWxlPSdvcGFjaXR5Oi45Jz48 L2E+Cis8YSBpZD0ndGVzdDEnIHN0eWxlPSdvcGFjaXR5Oi45Jz48L2E+Cis8YSBpZD0ndGVzdDIn IHN0eWxlPSdvcGFjaXR5Ojk0MzIwMDAwJz48L2E+Cis8YSBpZD0ndGVzdDMnIHN0eWxlPSdvcGFj aXR5OjAuMDAwMDIxJz48L2E+Cis8YSBpZD0ndGVzdDQnIHN0eWxlPSdvcGFjaXR5OjUwLjAyJz48 L2E+Cis8YSBpZD0ndGVzdDUnIHN0eWxlPSdvcGFjaXR5Oi0xMC4xJz48L2E+Cis8YSBpZD0ndGVz dDYnIHN0eWxlPSdvcGFjaXR5OjAuNSc+PC9hPgogCiA8c2NyaXB0PgotdmFyIG9wYWNpdHkgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsK LWlmIChvcGFjaXR5ID09ICcwLjknKQotICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ci1lbHNl Ci0gICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKK2Z1bmN0aW9uIGRvVGVz dChuYW1lLCBleHBlY3RlZCkgeworICAgIHZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQobmFtZSkuc3R5bGUub3BhY2l0eS50b1N0cmluZygpOworICAgIGlmIChvcGFjaXR5ID09 IGV4cGVjdGVkKQorICAgICAgICBkb2N1bWVudC53cml0ZSgnUEFTUycpOworICAgIGVsc2UKKyAg ICAgICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6IGV4cGVjdGVkICcgKyBleHBlY3RlZCArICcsIGdv dCAnICsgb3BhY2l0eSk7CisgICAgZG9jdW1lbnQud3JpdGUoJzxicj4nKTsKK30KK2RvVGVzdCgn dGVzdDEnLCAnMC45Jyk7Citkb1Rlc3QoJ3Rlc3QyJywgJzk0MzIwMDAwJyk7Citkb1Rlc3QoJ3Rl c3QzJywgJzAuMDAwMDIxJyk7Citkb1Rlc3QoJ3Rlc3Q0JywgJzUwLjAyJyk7Citkb1Rlc3QoJ3Rl c3Q1JywgJy0xMC4xJyk7CisKKy8vIFZlcmlmeSB0aGF0IGludmFsaWQgdmFsdWVzIGxpa2UgTmFO IG5ldmVyIGV2ZW4gbWFrZSBpdCBpbnRvIHRoZSBDU1MgdmFsdWVzLgorLy8gSS5lLiwgdGhlIG5l eHQgbGluZSBzaG91bGQgbm90IGFmZmVjdCB0aGUgb3BhY2l0eSB2YWx1ZS4KK2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCd0ZXN0NicpLnN0eWxlLm9wYWNpdHkgPSAxIC8gMDsKK2RvVGVzdCgndGVz dDYnLCAnMC41Jyk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggYjgxOTgzZC4uMDAwMDAwMAotLS0gYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9tYWMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKKysrIC9kZXYv bnVsbApAQCAtMSwzICswLDAgQEAKLVRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBm bG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJv cGVybHktZm9ybWF0dGVkIGZsb2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBj YXVzZSBkZWNpbWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KLQot RkFJTDogMCw5CmRpZmYgLS1naXQgYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAg Yi9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKaW5kZXggMWYyYzljYS4uNjkwZjBh MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCisrKyBiL1dl YkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1 ZGUgIlJlY3QuaCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgPHd0Zi9BU0NJ SUNUeXBlLmg+CisjaW5jbHVkZSA8d3RmL2R0b2EuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0 cmFzLmg+CiAKICNpZiBFTkFCTEUoREFTSEJPQVJEX1NVUFBPUlQpCkBAIC02ODQsNiArNjg1LDcy IEBAIGludCBDU1NQcmltaXRpdmVWYWx1ZTo6Z2V0SWRlbnQoKQogICAgIHJldHVybiBtX3ZhbHVl LmlkZW50OwogfQogCisKK3N0YXRpYyB2b2lkIGFwcGVuZENTU0RvdWJsZShWZWN0b3I8VUNoYXI+ JiB2ZWN0b3IsIGRvdWJsZSB2YWx1ZSkKK3sKKyAgICAvLyBGcm9tIHRoZSBDU1Mgc3BlY2lmaWNh dGlvbiBzZWN0aW9uIHRpdGxlZCAiSW50ZWdlcnMgYW5kIHJlYWwgbnVtYmVycyIsCisgICAgLy8g cmVhbCBudW1iZXJzIGFyZSBvbmx5IGZvcm1hdHRlZCBhcyBbc2lnbl0gW2RpZ2l0c10gIi4iIFtk aWdpdHNdLgorICAgIC8vIFRoaXMgZGlmZmVycyBmcm9tIHByaW50Zi1zdHlsZSBmb3JtYXR0aW5n IGluIHRoYXQgZXhwb25lbnRzIChlLmcuIDEuM2UwNikKKyAgICAvLyBhcmUgbm90IGFsbG93ZWQu ICBTaW5jZSBOYU4vaW5mIGFyZSBhbHNvIG5vdCB2YWxpZCBDU1MgdmFsdWVzIHRoaXMKKyAgICAv LyBmdW5jdGlvbiBkb2Vzbid0IGhhbmRsZSB0aGVtLgorICAgIGNvbnN0IGludCBkaWdpdHMgPSA2 OworICAgIGNoYXIgYnVmWzgwXTsKKyAgICBpbnQgZGVjaW1hbFBvaW50OworICAgIGludCBzaWdu OworICAgIFdURjo6ZHRvYShidWYsIHZhbHVlLCAwLCAmZGVjaW1hbFBvaW50LCAmc2lnbiwgTlVM TCk7CisgICAgaW50IGxlbmd0aCA9IHN0YXRpY19jYXN0PGludD4oc3RybGVuKGJ1ZikpOworCisg ICAgLy8gV2UgYXJlIG1hdGNoaW5nIHByaW50ZigiJWciKSdzIGJlaGF2aW9yIGFuZCBtdXN0IHRy aW0gdHJhaWxpbmcgemVyb3MsCisgICAgLy8gcmVnYXJkbGVzcyBvZiB3aGV0aGVyIHRoZXkncmUg c2lnbmlmaWNhbnQuCisgICAgaWYgKGRlY2ltYWxQb2ludCA8PSAwIHx8IGxlbmd0aCA+IGRlY2lt YWxQb2ludCkgeworICAgICAgICBsZW5ndGggPSBtaW4obGVuZ3RoLCBkaWdpdHMpOworICAgICAg ICB3aGlsZSAobGVuZ3RoID4gMCAmJiBidWZbbGVuZ3RoIC0gMV0gPT0gJzAnKQorICAgICAgICAg ICAgbGVuZ3RoLS07CisgICAgfQorCisKKyAgICAvLyBSZXNlcnZlIGFuIGVzdGltYXRlIG9mIHNw YWNlIGZvciB0aGUgbnVtYmVyIG9mIGRpZ2l0cyB3ZSBhbnRpY2lwYXRlCisgICAgLy8gYWxvbmcg d2l0aCBhIG1pbnVzIHNpZ24vaW5pdGlhbCB6ZXJvL2RlY2ltYWwgcG9pbnQuCisgICAgdmVjdG9y LnJlc2VydmVDYXBhY2l0eSh2ZWN0b3Iuc2l6ZSgpICsgMiArIG1pbihsZW5ndGgsIGRpZ2l0cykp OworCisgICAgaWYgKHNpZ24pCisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy0nKTsKKworICAgIGlm IChkZWNpbWFsUG9pbnQgPD0gMCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBhZnRlciB0aGUg ZGVjaW1hbCBwb2ludC4KKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgICB2ZWN0 b3IuYXBwZW5kKCcuJyk7CisgICAgICAgIGZvciAoaW50IGkgPSBkZWNpbWFsUG9pbnQ7IGkgPCAw OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAgICAgIGZvciAoaW50 IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1Zltp XSk7CisKKyAgICB9IGVsc2UgaWYgKGxlbmd0aCA8PSBkZWNpbWFsUG9pbnQpIHsKKyAgICAgICAg Ly8gT25seSBkaWdpdHMgYmVmb3JlIHRoZSBkZWNpbWFsIHBvaW50LgorICAgICAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZb aV0pOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGRlY2ltYWxQb2ludCAtIGxlbmd0aDsg aSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgIH0gZWxzZSB7CisgICAg ICAgIC8vIERpZ2l0cyBiZWZvcmUgYW5kIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LgorICAgICAg ICBmb3IgKGludCBpID0gMDsgaSA8IGRlY2ltYWxQb2ludDsgaSsrKQorICAgICAgICAgICAgdmVj dG9yLmFwcGVuZChidWZbaV0pOworICAgICAgICB2ZWN0b3IuYXBwZW5kKCcuJyk7CisgICAgICAg IGZvciAoaW50IGkgPSBkZWNpbWFsUG9pbnQ7IGkgPCBsZW5ndGg7IGkrKykKKyAgICAgICAgICAg IHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsKKyAgICB9Cit9CisKK3N0YXRpYyBTdHJpbmcgZm9ybWF0 V2l0aFVuaXRzKGRvdWJsZSB2YWx1ZSwgY29uc3QgY2hhciogdW5pdHMpCit7CisgICAgVmVjdG9y PFVDaGFyPiByZXN1bHQ7CisgICAgYXBwZW5kQ1NTRG91YmxlKHJlc3VsdCwgdmFsdWUpOworICAg IHJlc3VsdC5yZXNlcnZlQ2FwYWNpdHkocmVzdWx0LnNpemUoKSArIHN0cmxlbih1bml0cykpOwor ICAgIGZvciAoaW50IGkgPSAwOyB1bml0c1tpXTsgaSsrKQorICAgICAgICByZXN1bHQuYXBwZW5k KHVuaXRzW2ldKTsKKyAgICByZXR1cm4gU3RyaW5nOjphZG9wdChyZXN1bHQpOworfQorCiBTdHJp bmcgQ1NTUHJpbWl0aXZlVmFsdWU6OmNzc1RleHQoKSBjb25zdAogewogICAgIC8vIEZJWE1FOiBy ZXR1cm4gdGhlIG9yaWdpbmFsIHZhbHVlIGluc3RlYWQgb2YgYSBnZW5lcmF0ZWQgb25lIChlLmcu IGNvbG9yCkBAIC02OTUsNjEgKzc2Miw2MSBAQCBTdHJpbmcgQ1NTUHJpbWl0aXZlVmFsdWU6OmNz c1RleHQoKSBjb25zdAogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX05VTUJF UjoKICAgICAgICAgY2FzZSBDU1NfUEFSU0VSX0lOVEVHRVI6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdp dGhVbml0cyhtX3ZhbHVlLm51bSwgIiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX1BFUkNFTlRBR0U6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxnJSUiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAiJSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NT X0VNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdlbSIsIG1fdmFs dWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0s ICJlbSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0VYUzoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdleCIsIG1fdmFsdWUubnVtKTsKKyAg ICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJleCIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1JFTVM6Ci0gICAgICAgICAgICB0ZXh0 ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncmVtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAg dGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInJlbSIpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BYOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 Zm9ybWF0KCIlLjZsZ3B4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1h dFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInB4Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBDU1NfQ006Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxn Y20iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1f dmFsdWUubnVtLCAiY20iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19N TToKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdtbSIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJt bSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0lOOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2luIiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImluIik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUFQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3Ry aW5nOjpmb3JtYXQoIiUuNmxncHQiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0g Zm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicHQiKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19QQzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgi JS42bGdwYyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5p dHMobV92YWx1ZS5udW0sICJwYyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2Ug Q1NTX0RFRzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdkZWciLCBt X3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUu bnVtLCAiZGVnIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUkFEOgot ICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3JhZCIsIG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJyYWQi KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19HUkFEOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2dyYWQiLCBtX3ZhbHVlLm51bSk7CisgICAg ICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiZ3JhZCIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX01TOgotICAgICAgICAgICAgdGV4dCA9 IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21zIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4 dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIm1zIik7CiAgICAgICAgICAgICBicmVh azsKICAgICAgICAgY2FzZSBDU1NfUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1h dCgiJS42bGdzIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhV bml0cyhtX3ZhbHVlLm51bSwgInMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNl IENTU19IWjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdoeiIsIG1f dmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5u dW0sICJoeiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0tIWjoKLSAg ICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdraHoiLCBtX3ZhbHVlLm51bSk7 CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAia2h6Iik7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfVFVSTjoKLSAgICAgICAgICAg IHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGd0dXJuIiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInR1cm4iKTsKICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19ESU1FTlNJT046CiAgICAgICAgICAgICAv LyBGSVhNRQ== 40924 2009-10-08 19:18:03 -0700 2009-10-12 11:22:01 -0700 use dtoa directly in CSS units bug-18994-20091008191802.patch text/plain 10419 evan ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cAppbmRleCBkOTRkY2ZhLi45Yjk3Mjk2IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUuZXhwCkBAIC0zNDUsNiArMzQ1LDcgQEAgX19aTjNXVEY4Q29sbGF0 b3JDMUVQS2MKIF9fWk4zV1RGOENvbGxhdG9yRDFFdgogX19aTjNXVEY4ZmFzdEZyZWVFUHYKIF9f Wk4zV1RGOUJ5dGVBcnJheTZjcmVhdGVFbQorX19aTjNXVEY0ZHRvYUVQY2RpUGlTMV9QUzBfCiBf X1pOSzNKU0MxMEpTRnVuY3Rpb24yM2lzSG9zdEZ1bmN0aW9uTm9uSW5saW5lRXYKIF9fWk5LM0pT QzExSW50ZXJwcmV0ZXIxNHJldHJpZXZlQ2FsbGVyRVBOU185RXhlY1N0YXRlRVBOU18xNkludGVy bmFsRnVuY3Rpb25FCiBfX1pOSzNKU0MxMUludGVycHJldGVyMThyZXRyaWV2ZUxhc3RDYWxsZXJF UE5TXzlFeGVjU3RhdGVFUmlSbFJOU183VVN0cmluZ0VSTlNfN0pTVmFsdWVFICAKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2dldENvbXB1dGVkU3R5bGUvZ2V0Q29tcHV0ZWRTdHls ZS10cmFuc2Zvcm0uaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2dldENvbXB1dGVkU3R5bGUv Z2V0Q29tcHV0ZWRTdHlsZS10cmFuc2Zvcm0uaHRtbAppbmRleCA0NWU2ODY3Li5kMDg0NmFhIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9nZXRDb21wdXRlZFN0eWxlL2dldENvbXB1 dGVkU3R5bGUtdHJhbnNmb3JtLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvZ2V0Q29t cHV0ZWRTdHlsZS9nZXRDb21wdXRlZFN0eWxlLXRyYW5zZm9ybS5odG1sCkBAIC00NSw2ICs0NSw4 IEBACiAgICAgICAgIHRlc3RCb3guc3R5bGUud2Via2l0VHJhbnNmb3JtID0gY3VyVGVzdC50cmFu c2Zvcm07CiAgICAgICAgIC8vIHJlYWQgYmFjayBjb21wdXRlZCBzdHlsZQogICAgICAgICB2YXIg b2xkVHJhbnNmb3JtID0gd2luZG93LmdldENvbXB1dGVkU3R5bGUodGVzdEJveCkud2Via2l0VHJh bnNmb3JtOworICAgICAgICAvLyBzZXQgdGhlIHRyYW5zZm9ybSB0byBzb21ldGhpbmcgZWxzZSBp biBjYXNlIHRoZSBsaW5lIGFmdGVyIGZhaWxzCisgICAgICAgIHRlc3RCb3guc3R5bGUud2Via2l0 VHJhbnNmb3JtID0gJ21hdHJpeCgxLCAxLCAxLCAxLCAxLCAxKSc7CiAgICAgICAgIC8vIHNldCB0 aGF0IG1hdHJpeCgpIGJhY2sgb24gdGhlIGVsZW1lbnQKICAgICAgICAgdGVzdEJveC5zdHlsZS53 ZWJraXRUcmFuc2Zvcm0gPSBvbGRUcmFuc2Zvcm07CiAgICAgICAgIC8vIHJlYWQgYmFjayBjb21w dXRlZCBzdHlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVy LXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVt YmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0CmluZGV4IGM5YzZkYzEuLjQ4Nzk1NDQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlwLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJp cC1leHBlY3RlZC50eHQKQEAgLTEgKzEgQEAKLUZBSUw6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFz IDkuMDAxZSswN3B4LCByZWFkIGFnYWluIGFzIDBweAorUEFTUzogcmVhZCA5MDAxMDAwMHB4IGJh Y2sgYXMgOTAwMTAwMDBweCwgcmVhZCBhZ2FpbiBhcyA5MDAxMDAwMHB4CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CmluZGV4IGY2NWFkMWYuLjJk Zjg4OTEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhw ZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0 ZWQudHh0CkBAIC0xLDMgKzEsOSBAQAogVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBh IGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBw cm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0 IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0Lgog CiBQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvY3Nz L29wYWNpdHktZmxvYXQuaHRtbAppbmRleCAwZWYwNDU2Li41MTc2NmFiIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCkBAIC0xMiwxMiArMTIsMzAgQEAgYXR0cmlidXRl cyBnZXRzIGJhY2sgYSBwcm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuICBJbXByb3Blcmx5IGhhbmRs aW5nCiBsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1hbHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMg bWlnaHQgYnJlYWsKIGl0LjwvcD4KIAotPGEgaWQ9J3Rlc3QnIHN0eWxlPSdvcGFjaXR5Oi45Jz48 L2E+Cis8YSBpZD0ndGVzdDEnIHN0eWxlPSdvcGFjaXR5Oi45Jz48L2E+Cis8YSBpZD0ndGVzdDIn IHN0eWxlPSdvcGFjaXR5Ojk0MzIwMDAwJz48L2E+Cis8YSBpZD0ndGVzdDMnIHN0eWxlPSdvcGFj aXR5OjAuMDAwMDIxJz48L2E+Cis8YSBpZD0ndGVzdDQnIHN0eWxlPSdvcGFjaXR5OjUwLjAyJz48 L2E+Cis8YSBpZD0ndGVzdDUnIHN0eWxlPSdvcGFjaXR5Oi0xMC4xJz48L2E+Cis8YSBpZD0ndGVz dDYnIHN0eWxlPSdvcGFjaXR5OjAuNSc+PC9hPgogCiA8c2NyaXB0PgotdmFyIG9wYWNpdHkgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsK LWlmIChvcGFjaXR5ID09ICcwLjknKQotICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ci1lbHNl Ci0gICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKK2Z1bmN0aW9uIGRvVGVz dChuYW1lLCBleHBlY3RlZCkgeworICAgIHZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQobmFtZSkuc3R5bGUub3BhY2l0eS50b1N0cmluZygpOworICAgIGlmIChvcGFjaXR5ID09 IGV4cGVjdGVkKQorICAgICAgICBkb2N1bWVudC53cml0ZSgnUEFTUycpOworICAgIGVsc2UKKyAg ICAgICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6IGV4cGVjdGVkICcgKyBleHBlY3RlZCArICcsIGdv dCAnICsgb3BhY2l0eSk7CisgICAgZG9jdW1lbnQud3JpdGUoJzxicj4nKTsKK30KK2RvVGVzdCgn dGVzdDEnLCAnMC45Jyk7Citkb1Rlc3QoJ3Rlc3QyJywgJzk0MzIwMDAwJyk7Citkb1Rlc3QoJ3Rl c3QzJywgJzAuMDAwMDIxJyk7Citkb1Rlc3QoJ3Rlc3Q0JywgJzUwLjAyJyk7Citkb1Rlc3QoJ3Rl c3Q1JywgJy0xMC4xJyk7CisKKy8vIFZlcmlmeSB0aGF0IGludmFsaWQgdmFsdWVzIGxpa2UgTmFO IG5ldmVyIGV2ZW4gbWFrZSBpdCBpbnRvIHRoZSBDU1MgdmFsdWVzLgorLy8gSS5lLiwgdGhlIG5l eHQgbGluZSBzaG91bGQgbm90IGFmZmVjdCB0aGUgb3BhY2l0eSB2YWx1ZS4KK2RvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCd0ZXN0NicpLnN0eWxlLm9wYWNpdHkgPSAxIC8gMDsKK2RvVGVzdCgndGVz dDYnLCAnMC41Jyk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggYjgxOTgzZC4uMDAwMDAwMAotLS0gYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9tYWMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKKysrIC9kZXYv bnVsbApAQCAtMSwzICswLDAgQEAKLVRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBm bG9hdGluZy1wb2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJv cGVybHktZm9ybWF0dGVkIGZsb2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBj YXVzZSBkZWNpbWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KLQot RkFJTDogMCw5CmRpZmYgLS1naXQgYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAg Yi9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKaW5kZXggMWYyYzljYS4uOTUwYzQz NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCisrKyBiL1dl YkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1 ZGUgIlJlY3QuaCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgPHd0Zi9BU0NJ SUNUeXBlLmg+CisjaW5jbHVkZSA8d3RmL2R0b2EuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0 cmFzLmg+CiAKICNpZiBFTkFCTEUoREFTSEJPQVJEX1NVUFBPUlQpCkBAIC02ODQsNiArNjg1LDY5 IEBAIGludCBDU1NQcmltaXRpdmVWYWx1ZTo6Z2V0SWRlbnQoKQogICAgIHJldHVybiBtX3ZhbHVl LmlkZW50OwogfQogCitzdGF0aWMgdm9pZCBhcHBlbmRDU1NEb3VibGUoVmVjdG9yPFVDaGFyPiYg dmVjdG9yLCBkb3VibGUgdmFsdWUpCit7CisgICAgLy8gRnJvbSB0aGUgQ1NTIHNwZWNpZmljYXRp b24gc2VjdGlvbiB0aXRsZWQgIkludGVnZXJzIGFuZCByZWFsIG51bWJlcnMiLAorICAgIC8vIHJl YWwgbnVtYmVycyBhcmUgb25seSBmb3JtYXR0ZWQgYXMgW3NpZ25dIFtkaWdpdHNdICIuIiBbZGln aXRzXS4KKyAgICAvLyBUaGlzIGRpZmZlcnMgZnJvbSBwcmludGYtc3R5bGUgZm9ybWF0dGluZyBp biB0aGF0IGV4cG9uZW50cyAoZS5nLiAxLjNlMDYpCisgICAgLy8gYXJlIG5vdCBhbGxvd2VkLiAg U2luY2UgTmFOL2luZiBhcmUgYWxzbyBub3QgdmFsaWQgQ1NTIHZhbHVlcyB0aGlzCisgICAgLy8g ZnVuY3Rpb24gZG9lc24ndCBoYW5kbGUgdGhlbS4KKyAgICBjb25zdCBpbnQgZGlnaXRzID0gNjsK KyAgICBjaGFyIGJ1Zls4MF07CisgICAgaW50IGRlY2ltYWxQb2ludDsKKyAgICBpbnQgc2lnbjsK KyAgICBXVEY6OmR0b2EoYnVmLCB2YWx1ZSwgMCwgJmRlY2ltYWxQb2ludCwgJnNpZ24sIE5VTEwp OworICAgIGludCBsZW5ndGggPSBzdGF0aWNfY2FzdDxpbnQ+KHN0cmxlbihidWYpKTsKKworICAg IC8vIFdlIGFyZSBtYXRjaGluZyBwcmludGYoIiVnIikncyBiZWhhdmlvciBhbmQgbXVzdCB0cmlt IHRyYWlsaW5nIHplcm9zLAorICAgIC8vIHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGV5J3JlIHNp Z25pZmljYW50LgorICAgIGlmIChkZWNpbWFsUG9pbnQgPD0gMCB8fCBsZW5ndGggPiBkZWNpbWFs UG9pbnQpIHsKKyAgICAgICAgbGVuZ3RoID0gbWluKGxlbmd0aCwgZGlnaXRzKTsKKyAgICAgICAg d2hpbGUgKGxlbmd0aCA+IDAgJiYgYnVmW2xlbmd0aCAtIDFdID09ICcwJykKKyAgICAgICAgICAg IGxlbmd0aC0tOworICAgIH0KKworICAgIC8vIFJlc2VydmUgYW4gZXN0aW1hdGUgb2Ygc3BhY2Ug Zm9yIHRoZSBudW1iZXIgb2YgZGlnaXRzIHdlIGFudGljaXBhdGUKKyAgICAvLyBhbG9uZyB3aXRo IGEgbWludXMgc2lnbi9pbml0aWFsIHplcm8vZGVjaW1hbCBwb2ludC4KKyAgICB2ZWN0b3IucmVz ZXJ2ZUNhcGFjaXR5KHZlY3Rvci5zaXplKCkgKyAyICsgbGVuZ3RoKTsKKworICAgIGlmIChzaWdu KQorICAgICAgICB2ZWN0b3IuYXBwZW5kKCctJyk7CisKKyAgICBpZiAoZGVjaW1hbFBvaW50IDw9 IDApIHsKKyAgICAgICAgLy8gT25seSBkaWdpdHMgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuCisg ICAgICAgIHZlY3Rvci5hcHBlbmQoJzAnKTsKKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnLicpOwor ICAgICAgICBmb3IgKGludCBpID0gZGVjaW1hbFBvaW50OyBpIDwgMDsgaSsrKQorICAgICAgICAg ICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0 aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSBp ZiAobGVuZ3RoIDw9IGRlY2ltYWxQb2ludCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBiZWZv cmUgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3Ro OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIGZvciAo aW50IGkgPSAwOyBpIDwgZGVjaW1hbFBvaW50IC0gbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2 ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gRGlnaXRzIGJlZm9y ZSBhbmQgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBp IDwgZGVjaW1hbFBvaW50OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7 CisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy4nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IGRlY2lt YWxQb2ludDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZb aV0pOworICAgIH0KK30KKworc3RhdGljIFN0cmluZyBmb3JtYXRXaXRoVW5pdHMoZG91YmxlIHZh bHVlLCBjb25zdCBjaGFyKiB1bml0cykKK3sKKyAgICBWZWN0b3I8VUNoYXI+IHJlc3VsdDsKKyAg ICBhcHBlbmRDU1NEb3VibGUocmVzdWx0LCB2YWx1ZSk7CisgICAgcmVzdWx0LnJlc2VydmVDYXBh Y2l0eShyZXN1bHQuc2l6ZSgpICsgc3RybGVuKHVuaXRzKSk7CisgICAgZm9yIChpbnQgaSA9IDA7 IHVuaXRzW2ldOyBpKyspCisgICAgICAgIHJlc3VsdC5hcHBlbmQodW5pdHNbaV0pOworICAgIHJl dHVybiBTdHJpbmc6OmFkb3B0KHJlc3VsdCk7Cit9CisKIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1 ZTo6Y3NzVGV4dCgpIGNvbnN0CiB7CiAgICAgLy8gRklYTUU6IHJldHVybiB0aGUgb3JpZ2luYWwg dmFsdWUgaW5zdGVhZCBvZiBhIGdlbmVyYXRlZCBvbmUgKGUuZy4gY29sb3IKQEAgLTY5NSw2MSAr NzU5LDYxIEBAIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNvbnN0CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTlVNQkVSOgogICAgICAgICBjYXNlIENT U19QQVJTRVJfSU5URUdFUjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51bWJlcihtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVt LCAiIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEVSQ0VOVEFHRToK LSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGclJSIsIG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICIlIik7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRU1TOgotICAgICAgICAgICAg dGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2VtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAg ICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImVtIik7CiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRVhTOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2V4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImV4Iik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfUkVNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgi JS42bGdyZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVu aXRzKG1fdmFsdWUubnVtLCAicmVtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2Fz ZSBDU1NfUFg6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncHgiLCBt X3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUu bnVtLCAicHgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19DTToKLSAg ICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdjbSIsIG1fdmFsdWUubnVtKTsK KyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJjbSIpOwog ICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX01NOgotICAgICAgICAgICAgdGV4 dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21tIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAg dGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIm1tIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfSU46Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpm b3JtYXQoIiUuNmxnaW4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0 V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiaW4iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAg ICBjYXNlIENTU19QVDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdw dCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92 YWx1ZS5udW0sICJwdCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BD OgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3BjIiwgbV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInBj Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfREVHOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2RlZyIsIG1fdmFsdWUubnVtKTsKKyAgICAg ICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJkZWciKTsKICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxncmFkIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4 dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInJhZCIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX0dSQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpm b3JtYXQoIiUuNmxnZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3Jt YXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJncmFkIik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxnbXMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAibXMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3MiLCBtX3ZhbHVl Lm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAi cyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0haOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2h6IiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImh6Iik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfS0haOgotICAgICAgICAgICAgdGV4dCA9IFN0 cmluZzo6Zm9ybWF0KCIlLjZsZ2toeiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQg PSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJraHoiKTsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19UVVJOOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9y bWF0KCIlLjZsZ3R1cm4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0 V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAidHVybiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAg ICAgIGNhc2UgQ1NTX0RJTUVOU0lPTjoKICAgICAgICAgICAgIC8vIEZJWE1F 41052 2009-10-12 11:22:07 -0700 2009-10-12 12:10:52 -0700 stringify CSS units manually to match CSS spec bug-18994-20091012112205.patch text/plain 13938 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlw LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10 cmlwLWV4cGVjdGVkLnR4dAppbmRleCBjOWM2ZGMxLi40ODc5NTQ0IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQu dHh0CkBAIC0xICsxIEBACi1GQUlMOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5LjAwMWUrMDdw eCwgcmVhZCBhZ2FpbiBhcyAwcHgKK1BBU1M6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFzIDkwMDEw MDAwcHgsIHJlYWQgYWdhaW4gYXMgOTAwMTAwMDBweApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAppbmRleCBmNjVhZDFmLi4yZGY4ODkxIDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAt MSwzICsxLDkgQEAKIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1w b2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9y bWF0dGVkIGZsb2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNp bWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KIAogUEFTUworUEFT UworUEFTUworUEFTUworUEFTUworUEFTUworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZs b2F0Lmh0bWwKaW5kZXggMGVmMDQ1Ni4uNTE3NjZhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29w YWNpdHktZmxvYXQuaHRtbApAQCAtMTIsMTIgKzEyLDMwIEBAIGF0dHJpYnV0ZXMgZ2V0cyBiYWNr IGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0LiAgSW1wcm9wZXJseSBoYW5kbGluZwogbG9jYWxl cyB0aGF0IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFr CiBpdC48L3A+CiAKLTxhIGlkPSd0ZXN0JyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9 J3Rlc3QxJyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9J3Rlc3QyJyBzdHlsZT0nb3Bh Y2l0eTo5NDMyMDAwMCc+PC9hPgorPGEgaWQ9J3Rlc3QzJyBzdHlsZT0nb3BhY2l0eTowLjAwMDAy MSc+PC9hPgorPGEgaWQ9J3Rlc3Q0JyBzdHlsZT0nb3BhY2l0eTo1MC4wMic+PC9hPgorPGEgaWQ9 J3Rlc3Q1JyBzdHlsZT0nb3BhY2l0eTotMTAuMSc+PC9hPgorPGEgaWQ9J3Rlc3Q2JyBzdHlsZT0n b3BhY2l0eTowLjUnPjwvYT4KIAogPHNjcmlwdD4KLXZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ3Rlc3QnKS5zdHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7Ci1pZiAob3BhY2l0 eSA9PSAnMC45JykKLSAgICBkb2N1bWVudC53cml0ZSgnUEFTUycpOwotZWxzZQotICAgIGRvY3Vt ZW50LndyaXRlKCdGQUlMOiAnICsgb3BhY2l0eSk7CitmdW5jdGlvbiBkb1Rlc3QobmFtZSwgZXhw ZWN0ZWQpIHsKKyAgICB2YXIgb3BhY2l0eSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG5hbWUp LnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsKKyAgICBpZiAob3BhY2l0eSA9PSBleHBlY3RlZCkK KyAgICAgICAgZG9jdW1lbnQud3JpdGUoJ1BBU1MnKTsKKyAgICBlbHNlCisgICAgICAgIGRvY3Vt ZW50LndyaXRlKCdGQUlMOiBleHBlY3RlZCAnICsgZXhwZWN0ZWQgKyAnLCBnb3QgJyArIG9wYWNp dHkpOworICAgIGRvY3VtZW50LndyaXRlKCc8YnI+Jyk7Cit9Citkb1Rlc3QoJ3Rlc3QxJywgJzAu OScpOworZG9UZXN0KCd0ZXN0MicsICc5NDMyMDAwMCcpOworZG9UZXN0KCd0ZXN0MycsICcwLjAw MDAyMScpOworZG9UZXN0KCd0ZXN0NCcsICc1MC4wMicpOworZG9UZXN0KCd0ZXN0NScsICctMTAu MScpOworCisvLyBWZXJpZnkgdGhhdCBpbnZhbGlkIHZhbHVlcyBsaWtlIE5hTiBuZXZlciBldmVu IG1ha2UgaXQgaW50byB0aGUgQ1NTIHZhbHVlcy4KKy8vIEkuZS4sIHRoZSBuZXh0IGxpbmUgc2hv dWxkIG5vdCBhZmZlY3QgdGhlIG9wYWNpdHkgdmFsdWUuCitkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgndGVzdDYnKS5zdHlsZS5vcGFjaXR5ID0gMSAvIDA7Citkb1Rlc3QoJ3Rlc3Q2JywgJzAuNScp OwogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZmFzdC9j c3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IGI4MTk4M2QuLjAwMDAwMDAKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFj L2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CisrKyAvZGV2L251bGwKQEAgLTEs MyArMCwwIEBACi1UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmctcG9p bnQgb3BhY2l0eSBmcm9tIENTUyBhdHRyaWJ1dGVzIGdldHMgYmFjayBhIHByb3Blcmx5LWZvcm1h dHRlZCBmbG9hdC4gSW1wcm9wZXJseSBoYW5kbGluZyBsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1h bHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsgaXQuCi0KLUZBSUw6IDAsOQpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zv cm1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQt dHJhbnNmb3Jtcy1leHBlY3RlZC50eHQKaW5kZXggNTU4M2JkMC4uMDlkYTkwMSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5z Zm9ybXMtZXhwZWN0ZWQudHh0CkBAIC03LDExICs3LDExIEBAIHRyYW5zZm9ybSAic2tldygxMmRl ZykiIGV4cGVjdGVkICJtYXRyaXgoMSwgMCwgMC4yMTI1NTcsIDEsIDAsIDApIiA6IFBBU1MKIHRy YW5zZm9ybSAibWF0cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwg NTAsIDIwKSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwg MC45NzgxNDgsIDUwLCAyMCkiIDogUEFTUwogdHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBw eCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0w LjIwNzkxMiwgMC45NzgxNDgsIDUwLCAyMCkiIDogUEFTUwogdHJhbnNmb3JtICJyb3RhdGUoMTJk ZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4y MDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDQ0Ljc0OTEsIDI5Ljk1ODUpIiA6IFBBU1MKLXRy YW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSIg ZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA0 NC43NDkxLCAyOS45NTg1KSIgOiBQQVNTCi10cmFuc2Zvcm0gInNjYWxlKDEuNCkgcm90YXRlKDEy ZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAu MjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDYyLjY0ODgsIDQxLjk0MikiIDogUEFTUwotdHJh bnNmb3JtICJzY2FsZSgxLjQpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIiBl eHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDcw LCAyOCkiIDogUEFTUwotdHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEy ZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0 MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgMzkuNjA0NCwgNjguOTA3NCkiIDogUEFT UwotdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgx LjQpIHRyYW5zbGF0ZSgtODBweCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEw cHgpIHNjYWxlKDAuNykgc2tld1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBw eCkgc2NhbGUoMS40LCAxLjgpIiBleHBlY3RlZCAibWF0cml4KDEuMjA1MTcsIDAuMTQ4MjA3LCAw LjI1ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMxKSIgOiBQQVNTCit0cmFuc2Zvcm0gInJv dGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJt YXRyaXgoMS4zNjk0LCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQsIDQ0Ljc0OTEsIDI5Ljk1 ODUpIiA6IFBBU1MKK3RyYW5zZm9ybSAic2NhbGUoMS40KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0 ZSg1MHB4LCAyMHB4KSAiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0LCAwLjI5MTA3NiwgLTAuMjkx MDc2LCAxLjM2OTQsIDYyLjY0ODgsIDQxLjk0MTkpIiA6IFBBU1MKK3RyYW5zZm9ybSAic2NhbGUo MS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1hdHJp eCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NCwgNzAsIDI4KSIgOiBQQVNTCit0 cmFuc2Zvcm0gInRyYW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZVko NTBweCkgc2NhbGUoMS40KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4y OTEwNzYsIDEuMzY5NCwgMzkuNjA0NCwgNjguOTA3MykiIDogUEFTUwordHJhbnNmb3JtICJyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpIHRyYW5zbGF0ZSgtODBw eCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgpIHNjYWxlKDAuNykgc2tl d1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkgc2NhbGUoMS40LCAxLjgp IiBleHBlY3RlZCAibWF0cml4KDEuMjA1MTYsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNCwg LTEzLjM4NDcsIDg1LjMwOTkpIiA6IFBBU1MKIHRyYW5zZm9ybSAiLHJvdGF0ZSgxMmRlZykgdHJh bnNsYXRlKDUwcHgsIDIwcHgpIiBleHBlY3RlZCAibm9uZSIgOiBQQVNTCiB0cmFuc2Zvcm0gInJv dGF0ZSgxMmRlZyksIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm5vbmUiIDogUEFT UwogdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpICsgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIiBleHBl Y3RlZCAibm9uZSIgOiBQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJk L2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMuaHRtbCBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQv Y29tcG91bmQtMmQtdHJhbnNmb3Jtcy5odG1sCmluZGV4IDE2MDAzYzMuLjkwMTg2MDQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jtcy5o dG1sCisrKyBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jt cy5odG1sCkBAIC00NiwxNCArNDYsMTQgQEAKICAgICAgIHsgJ3RyYW5zZm9ybScgOiAncm90YXRl KDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCknLCAgICAgICAgICAncmVzdWx0JyA6ICdtYXRy aXgoMC45NzgxNDgsIDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA0NC43NDkxLCAyOS45 NTg1KScgfSwKIAogICAgICAgLy8gdGhyZWUgZnVuY3Rpb25zCi0gICAgICB7ICd0cmFuc2Zvcm0n IDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxlKDEuNCknLCAgICdy ZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA0 NC43NDkxLCAyOS45NTg1KScgfSwKLSAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSBy b3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSAnLCAgJ3Jlc3VsdCcgOiAnbWF0cml4 KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDYyLjY0ODgsIDQxLjk0Mikn IH0sCi0gICAgICB7ICd0cmFuc2Zvcm0nIDogJ3NjYWxlKDEuNCkgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIHJvdGF0ZSgxMmRlZyknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3 NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA3MCwgMjgpJyB9LAotICAgICAgeyAndHJhbnNmb3JtJyA6 ICd0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNj YWxlKDEuNCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkx MDc2LCAxLjM2OTQxLCAzOS42MDQ0LCA2OC45MDc0KScgfSwKKyAgICAgIHsgJ3RyYW5zZm9ybScg OiAncm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KScsICAgJ3Jl c3VsdCcgOiAnbWF0cml4KDEuMzY5NCwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA0NC43 NDkxLCAyOS45NTg1KScgfSwKKyAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSByb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSAnLCAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEu MzY5NCwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA2Mi42NDg4LCA0MS45NDE5KScgfSwK KyAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkg cm90YXRlKDEyZGVnKScsICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NCwgMC4yOTEwNzYsIC0w LjI5MTA3NiwgMS4zNjk0LCA3MCwgMjgpJyB9LAorICAgICAgeyAndHJhbnNmb3JtJyA6ICd0cmFu c2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEu NCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEu MzY5NCwgMzkuNjA0NCwgNjguOTA3MyknIH0sCiAKICAgICAgIC8vIGxvdHMgb2YgZnVuY3Rpb25z CiAgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIHNjYWxlKDEuNCkgdHJhbnNsYXRlKC04MHB4LCA0MHB4KSBza2V3KDM0ZGVnKSB0cmFuc2xh dGUoMTBweCwgMTBweCkgc2NhbGUoMC43KSBza2V3WSgtMjVkZWcpIHJvdGF0ZSgyMWRlZykgdHJh bnNsYXRlWCg1MHB4KSBzY2FsZSgxLjQsIDEuOCknLCAKLSAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0 cml4KDEuMjA1MTcsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMx KScgfSwKKyAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMjA1MTYsIDAuMTQ4MjA3LCAwLjI1 ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMwOTkpJyB9LAogICAgICAgICAKICAgICAgIC8v IGludmFsaWQgY29tcG91bmQgZnVuY3Rpb25zCiAgICAgICB7ICd0cmFuc2Zvcm0nIDogJyxyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KScsICdyZXN1bHQnIDogJ25vbmUnIH0sIC8v IGhhcyBjb21tYQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3Bw IGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCmluZGV4IDFmMmM5Y2EuLjk0NzA0 MjMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAorKysgYi9X ZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKQEAgLTY4NCw2ICs2ODQsNzMgQEAgaW50 IENTU1ByaW1pdGl2ZVZhbHVlOjpnZXRJZGVudCgpCiAgICAgcmV0dXJuIG1fdmFsdWUuaWRlbnQ7 CiB9CiAKK3N0YXRpYyB2b2lkIGFwcGVuZENTU0RvdWJsZShWZWN0b3I8VUNoYXI+JiB2ZWN0b3Is IGRvdWJsZSB2YWx1ZSkKK3sKKyAgICAvLyBGcm9tIHRoZSBDU1Mgc3BlY2lmaWNhdGlvbiBzZWN0 aW9uIHRpdGxlZCAiSW50ZWdlcnMgYW5kIHJlYWwgbnVtYmVycyIsCisgICAgLy8gcmVhbCBudW1i ZXJzIGFyZSBvbmx5IGZvcm1hdHRlZCBhcyBbc2lnbl0gW2RpZ2l0c10gIi4iIFtkaWdpdHNdLgor ICAgIC8vIFRoaXMgZGlmZmVycyBmcm9tIHByaW50Zi1zdHlsZSBmb3JtYXR0aW5nIGluIHRoYXQg ZXhwb25lbnRzIChlLmcuIDEuM2UwNikKKyAgICAvLyBhcmUgbm90IGFsbG93ZWQuICBTaW5jZSBO YU4vaW5mIGFyZSBhbHNvIG5vdCB2YWxpZCBDU1MgdmFsdWVzIHRoaXMKKyAgICAvLyBmdW5jdGlv biBkb2Vzbid0IGhhbmRsZSB0aGVtLgorCisgICAgLy8gRm9yIGNvbXBhdGliaWxpdHkgd2l0aCBl eGlzdGluZyBsYXlvdXQgdGVzdHMsIHdlIHRhcmdldCA2IGRpZ2l0cyBvZiBwcmVjaXNpb24uCisg ICAgY29uc3QgaW50IGRpZ2l0cyA9IDY7CisgICAgbG9uZyBsb25nIHJvdW5kZWQgPSByb3VuZChm YWJzKHZhbHVlKSAqIDEwMDAwMDAuMCk7CisgICAgaWYgKHJvdW5kZWQgPT0gMCkgeworICAgICAg dmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGNoYXIgYnVm WzgwXTsKKyAgICBpbnQgbGVuZ3RoID0gc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVsbGQi LCByb3VuZGVkKTsKKyAgICBpbnQgZGVjaW1hbFBvaW50ID0gbGVuZ3RoIC0gNjsKKworICAgIC8v IFdlIGFyZSBtYXRjaGluZyBwcmludGYoIiVnIikncyBiZWhhdmlvciBhbmQgbXVzdCB0cmltIHRy YWlsaW5nIHplcm9zLAorICAgIC8vIHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGV5J3JlIHNpZ25p ZmljYW50LgorICAgIGxlbmd0aCA9IG1pbihsZW5ndGgsIGRpZ2l0cyk7CisgICAgd2hpbGUgKGxl bmd0aCA+IDAgJiYgYnVmW2xlbmd0aCAtIDFdID09ICcwJykKKyAgICAgICAgbGVuZ3RoLS07CisK KyAgICAvLyBSZXNlcnZlIGFuIGVzdGltYXRlIG9mIHNwYWNlIGZvciB0aGUgbnVtYmVyIG9mIGRp Z2l0cyB3ZSBhbnRpY2lwYXRlCisgICAgLy8gYWxvbmcgd2l0aCBhIG1pbnVzIHNpZ24vaW5pdGlh bCB6ZXJvL2RlY2ltYWwgcG9pbnQuCisgICAgdmVjdG9yLnJlc2VydmVDYXBhY2l0eSh2ZWN0b3Iu c2l6ZSgpICsgMiArIGxlbmd0aCk7CisKKyAgICBpZiAodmFsdWUgPCAwKQorICAgICAgICB2ZWN0 b3IuYXBwZW5kKCctJyk7CisKKyAgICBpZiAoZGVjaW1hbFBvaW50IDw9IDApIHsKKyAgICAgICAg Ly8gT25seSBkaWdpdHMgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAgICAgIHZlY3Rvci5h cHBlbmQoJzAnKTsKKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnLicpOworICAgICAgICBmb3IgKGlu dCBpID0gZGVjaW1hbFBvaW50OyBpIDwgMDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVu ZCgnMCcpOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAg ICAgICAgdmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSBpZiAobGVuZ3RoIDw9IGRl Y2ltYWxQb2ludCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBiZWZvcmUgdGhlIGRlY2ltYWwg cG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCisgICAgICAg ICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwg ZGVjaW1hbFBvaW50IC0gbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKCcw Jyk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gRGlnaXRzIGJlZm9yZSBhbmQgYWZ0ZXIgdGhl IGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZGVjaW1hbFBvaW50 OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIHZlY3Rv ci5hcHBlbmQoJy4nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IGRlY2ltYWxQb2ludDsgaSA8IGxl bmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0KK30K Kworc3RhdGljIFN0cmluZyBmb3JtYXRXaXRoVW5pdHMoZG91YmxlIHZhbHVlLCBjb25zdCBjaGFy KiB1bml0cykKK3sKKyAgICBWZWN0b3I8VUNoYXI+IHJlc3VsdDsKKyAgICBhcHBlbmRDU1NEb3Vi bGUocmVzdWx0LCB2YWx1ZSk7CisgICAgcmVzdWx0LnJlc2VydmVDYXBhY2l0eShyZXN1bHQuc2l6 ZSgpICsgc3RybGVuKHVuaXRzKSk7CisgICAgZm9yIChpbnQgaSA9IDA7IHVuaXRzW2ldOyBpKysp CisgICAgICAgIHJlc3VsdC5hcHBlbmQodW5pdHNbaV0pOworICAgIHJldHVybiBTdHJpbmc6OmFk b3B0KHJlc3VsdCk7Cit9CisKIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNv bnN0CiB7CiAgICAgLy8gRklYTUU6IHJldHVybiB0aGUgb3JpZ2luYWwgdmFsdWUgaW5zdGVhZCBv ZiBhIGdlbmVyYXRlZCBvbmUgKGUuZy4gY29sb3IKQEAgLTY5NSw2MSArNzYyLDYxIEBAIFN0cmlu ZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNvbnN0CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgY2FzZSBDU1NfTlVNQkVSOgogICAgICAgICBjYXNlIENTU19QQVJTRVJfSU5URUdF UjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51bWJlcihtX3ZhbHVlLm51bSk7CisgICAg ICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiIik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEVSQ0VOVEFHRToKLSAgICAgICAgICAgIHRl eHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGclJSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAg IHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICIlIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfRU1TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 Zm9ybWF0KCIlLjZsZ2VtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1h dFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImVtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBDU1NfRVhTOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZs Z2V4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyht X3ZhbHVlLm51bSwgImV4Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1Nf UkVNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdyZW0iLCBtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVt LCAicmVtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUFg6Ci0gICAg ICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncHgiLCBtX3ZhbHVlLm51bSk7Cisg ICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicHgiKTsKICAg ICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19DTToKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdjbSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJjbSIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX01NOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9y bWF0KCIlLjZsZ21tIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdp dGhVbml0cyhtX3ZhbHVlLm51bSwgIm1tIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAg Y2FzZSBDU1NfSU46Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnaW4i LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAiaW4iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19QVDoK LSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdwdCIsIG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJwdCIp OwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BDOgotICAgICAgICAgICAg dGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3BjIiwgbV92YWx1ZS5udW0pOworICAgICAgICAg ICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInBjIik7CiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfREVHOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2RlZyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBm b3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJkZWciKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19SQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxncmFkIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhV bml0cyhtX3ZhbHVlLm51bSwgInJhZCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX0dSQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZ3Jh ZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92 YWx1ZS5udW0sICJncmFkIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1Nf TVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnbXMiLCBtX3ZhbHVl Lm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAi bXMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19TOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3MiLCBtX3ZhbHVlLm51bSk7CisgICAgICAg ICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicyIpOwogICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0haOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2h6IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImh6Iik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfS0haOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIl LjZsZ2toeiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5p dHMobV92YWx1ZS5udW0sICJraHoiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNl IENTU19UVVJOOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3R1cm4i LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAidHVybiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0RJ TUVOU0lPTjoKICAgICAgICAgICAgIC8vIEZJWE1F 41055 2009-10-12 12:10:59 -0700 2009-10-12 14:27:32 -0700 stringify CSS units manually to match CSS spec bug-18994-20091012121058.patch text/plain 14010 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlw LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10 cmlwLWV4cGVjdGVkLnR4dAppbmRleCBjOWM2ZGMxLi40ODc5NTQ0IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQu dHh0CkBAIC0xICsxIEBACi1GQUlMOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5LjAwMWUrMDdw eCwgcmVhZCBhZ2FpbiBhcyAwcHgKK1BBU1M6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFzIDkwMDEw MDAwcHgsIHJlYWQgYWdhaW4gYXMgOTAwMTAwMDBweApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAppbmRleCBmNjVhZDFmLi4yZGY4ODkxIDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAt MSwzICsxLDkgQEAKIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1w b2ludCBvcGFjaXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9y bWF0dGVkIGZsb2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNp bWFscyB0byBiZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KIAogUEFTUworUEFT UworUEFTUworUEFTUworUEFTUworUEFTUworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZs b2F0Lmh0bWwKaW5kZXggMGVmMDQ1Ni4uNTE3NjZhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL29w YWNpdHktZmxvYXQuaHRtbApAQCAtMTIsMTIgKzEyLDMwIEBAIGF0dHJpYnV0ZXMgZ2V0cyBiYWNr IGEgcHJvcGVybHktZm9ybWF0dGVkIGZsb2F0LiAgSW1wcm9wZXJseSBoYW5kbGluZwogbG9jYWxl cyB0aGF0IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFr CiBpdC48L3A+CiAKLTxhIGlkPSd0ZXN0JyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9 J3Rlc3QxJyBzdHlsZT0nb3BhY2l0eTouOSc+PC9hPgorPGEgaWQ9J3Rlc3QyJyBzdHlsZT0nb3Bh Y2l0eTo5NDMyMDAwMCc+PC9hPgorPGEgaWQ9J3Rlc3QzJyBzdHlsZT0nb3BhY2l0eTowLjAwMDAy MSc+PC9hPgorPGEgaWQ9J3Rlc3Q0JyBzdHlsZT0nb3BhY2l0eTo1MC4wMic+PC9hPgorPGEgaWQ9 J3Rlc3Q1JyBzdHlsZT0nb3BhY2l0eTotMTAuMSc+PC9hPgorPGEgaWQ9J3Rlc3Q2JyBzdHlsZT0n b3BhY2l0eTowLjUnPjwvYT4KIAogPHNjcmlwdD4KLXZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ3Rlc3QnKS5zdHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7Ci1pZiAob3BhY2l0 eSA9PSAnMC45JykKLSAgICBkb2N1bWVudC53cml0ZSgnUEFTUycpOwotZWxzZQotICAgIGRvY3Vt ZW50LndyaXRlKCdGQUlMOiAnICsgb3BhY2l0eSk7CitmdW5jdGlvbiBkb1Rlc3QobmFtZSwgZXhw ZWN0ZWQpIHsKKyAgICB2YXIgb3BhY2l0eSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG5hbWUp LnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsKKyAgICBpZiAob3BhY2l0eSA9PSBleHBlY3RlZCkK KyAgICAgICAgZG9jdW1lbnQud3JpdGUoJ1BBU1MnKTsKKyAgICBlbHNlCisgICAgICAgIGRvY3Vt ZW50LndyaXRlKCdGQUlMOiBleHBlY3RlZCAnICsgZXhwZWN0ZWQgKyAnLCBnb3QgJyArIG9wYWNp dHkpOworICAgIGRvY3VtZW50LndyaXRlKCc8YnI+Jyk7Cit9Citkb1Rlc3QoJ3Rlc3QxJywgJzAu OScpOworZG9UZXN0KCd0ZXN0MicsICc5NDMyMDAwMCcpOworZG9UZXN0KCd0ZXN0MycsICcwLjAw MDAyMScpOworZG9UZXN0KCd0ZXN0NCcsICc1MC4wMicpOworZG9UZXN0KCd0ZXN0NScsICctMTAu MScpOworCisvLyBWZXJpZnkgdGhhdCBpbnZhbGlkIHZhbHVlcyBsaWtlIE5hTiBuZXZlciBldmVu IG1ha2UgaXQgaW50byB0aGUgQ1NTIHZhbHVlcy4KKy8vIEkuZS4sIHRoZSBuZXh0IGxpbmUgc2hv dWxkIG5vdCBhZmZlY3QgdGhlIG9wYWNpdHkgdmFsdWUuCitkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgndGVzdDYnKS5zdHlsZS5vcGFjaXR5ID0gMSAvIDA7Citkb1Rlc3QoJ3Rlc3Q2JywgJzAuNScp OwogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZmFzdC9j c3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IGI4MTk4M2QuLjAwMDAwMDAKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFj L2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CisrKyAvZGV2L251bGwKQEAgLTEs MyArMCwwIEBACi1UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmctcG9p bnQgb3BhY2l0eSBmcm9tIENTUyBhdHRyaWJ1dGVzIGdldHMgYmFjayBhIHByb3Blcmx5LWZvcm1h dHRlZCBmbG9hdC4gSW1wcm9wZXJseSBoYW5kbGluZyBsb2NhbGVzIHRoYXQgY2F1c2UgZGVjaW1h bHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsgaXQuCi0KLUZBSUw6IDAsOQpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zv cm1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQt dHJhbnNmb3Jtcy1leHBlY3RlZC50eHQKaW5kZXggNTU4M2JkMC4uMDlkYTkwMSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5z Zm9ybXMtZXhwZWN0ZWQudHh0CkBAIC03LDExICs3LDExIEBAIHRyYW5zZm9ybSAic2tldygxMmRl ZykiIGV4cGVjdGVkICJtYXRyaXgoMSwgMCwgMC4yMTI1NTcsIDEsIDAsIDApIiA6IFBBU1MKIHRy YW5zZm9ybSAibWF0cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwg NTAsIDIwKSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwg MC45NzgxNDgsIDUwLCAyMCkiIDogUEFTUwogdHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBw eCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0w LjIwNzkxMiwgMC45NzgxNDgsIDUwLCAyMCkiIDogUEFTUwogdHJhbnNmb3JtICJyb3RhdGUoMTJk ZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4y MDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDQ0Ljc0OTEsIDI5Ljk1ODUpIiA6IFBBU1MKLXRy YW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSIg ZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA0 NC43NDkxLCAyOS45NTg1KSIgOiBQQVNTCi10cmFuc2Zvcm0gInNjYWxlKDEuNCkgcm90YXRlKDEy ZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAu MjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDYyLjY0ODgsIDQxLjk0MikiIDogUEFTUwotdHJh bnNmb3JtICJzY2FsZSgxLjQpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIiBl eHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDcw LCAyOCkiIDogUEFTUwotdHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEy ZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0 MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgMzkuNjA0NCwgNjguOTA3NCkiIDogUEFT UwotdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgx LjQpIHRyYW5zbGF0ZSgtODBweCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEw cHgpIHNjYWxlKDAuNykgc2tld1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBw eCkgc2NhbGUoMS40LCAxLjgpIiBleHBlY3RlZCAibWF0cml4KDEuMjA1MTcsIDAuMTQ4MjA3LCAw LjI1ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMxKSIgOiBQQVNTCit0cmFuc2Zvcm0gInJv dGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJt YXRyaXgoMS4zNjk0LCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQsIDQ0Ljc0OTEsIDI5Ljk1 ODUpIiA6IFBBU1MKK3RyYW5zZm9ybSAic2NhbGUoMS40KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0 ZSg1MHB4LCAyMHB4KSAiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0LCAwLjI5MTA3NiwgLTAuMjkx MDc2LCAxLjM2OTQsIDYyLjY0ODgsIDQxLjk0MTkpIiA6IFBBU1MKK3RyYW5zZm9ybSAic2NhbGUo MS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1hdHJp eCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NCwgNzAsIDI4KSIgOiBQQVNTCit0 cmFuc2Zvcm0gInRyYW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZVko NTBweCkgc2NhbGUoMS40KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4y OTEwNzYsIDEuMzY5NCwgMzkuNjA0NCwgNjguOTA3MykiIDogUEFTUwordHJhbnNmb3JtICJyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpIHRyYW5zbGF0ZSgtODBw eCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgpIHNjYWxlKDAuNykgc2tl d1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkgc2NhbGUoMS40LCAxLjgp IiBleHBlY3RlZCAibWF0cml4KDEuMjA1MTYsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNCwg LTEzLjM4NDcsIDg1LjMwOTkpIiA6IFBBU1MKIHRyYW5zZm9ybSAiLHJvdGF0ZSgxMmRlZykgdHJh bnNsYXRlKDUwcHgsIDIwcHgpIiBleHBlY3RlZCAibm9uZSIgOiBQQVNTCiB0cmFuc2Zvcm0gInJv dGF0ZSgxMmRlZyksIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm5vbmUiIDogUEFT UwogdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpICsgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIiBleHBl Y3RlZCAibm9uZSIgOiBQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJk L2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMuaHRtbCBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQv Y29tcG91bmQtMmQtdHJhbnNmb3Jtcy5odG1sCmluZGV4IDE2MDAzYzMuLjkwMTg2MDQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jtcy5o dG1sCisrKyBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jt cy5odG1sCkBAIC00NiwxNCArNDYsMTQgQEAKICAgICAgIHsgJ3RyYW5zZm9ybScgOiAncm90YXRl KDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCknLCAgICAgICAgICAncmVzdWx0JyA6ICdtYXRy aXgoMC45NzgxNDgsIDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA0NC43NDkxLCAyOS45 NTg1KScgfSwKIAogICAgICAgLy8gdGhyZWUgZnVuY3Rpb25zCi0gICAgICB7ICd0cmFuc2Zvcm0n IDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxlKDEuNCknLCAgICdy ZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA0 NC43NDkxLCAyOS45NTg1KScgfSwKLSAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSBy b3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSAnLCAgJ3Jlc3VsdCcgOiAnbWF0cml4 KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDYyLjY0ODgsIDQxLjk0Mikn IH0sCi0gICAgICB7ICd0cmFuc2Zvcm0nIDogJ3NjYWxlKDEuNCkgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIHJvdGF0ZSgxMmRlZyknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3 NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA3MCwgMjgpJyB9LAotICAgICAgeyAndHJhbnNmb3JtJyA6 ICd0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNj YWxlKDEuNCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkx MDc2LCAxLjM2OTQxLCAzOS42MDQ0LCA2OC45MDc0KScgfSwKKyAgICAgIHsgJ3RyYW5zZm9ybScg OiAncm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KScsICAgJ3Jl c3VsdCcgOiAnbWF0cml4KDEuMzY5NCwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA0NC43 NDkxLCAyOS45NTg1KScgfSwKKyAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSByb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSAnLCAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEu MzY5NCwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA2Mi42NDg4LCA0MS45NDE5KScgfSwK KyAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkg cm90YXRlKDEyZGVnKScsICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NCwgMC4yOTEwNzYsIC0w LjI5MTA3NiwgMS4zNjk0LCA3MCwgMjgpJyB9LAorICAgICAgeyAndHJhbnNmb3JtJyA6ICd0cmFu c2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEu NCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEu MzY5NCwgMzkuNjA0NCwgNjguOTA3MyknIH0sCiAKICAgICAgIC8vIGxvdHMgb2YgZnVuY3Rpb25z CiAgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIHNjYWxlKDEuNCkgdHJhbnNsYXRlKC04MHB4LCA0MHB4KSBza2V3KDM0ZGVnKSB0cmFuc2xh dGUoMTBweCwgMTBweCkgc2NhbGUoMC43KSBza2V3WSgtMjVkZWcpIHJvdGF0ZSgyMWRlZykgdHJh bnNsYXRlWCg1MHB4KSBzY2FsZSgxLjQsIDEuOCknLCAKLSAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0 cml4KDEuMjA1MTcsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMx KScgfSwKKyAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMjA1MTYsIDAuMTQ4MjA3LCAwLjI1 ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1LjMwOTkpJyB9LAogICAgICAgICAKICAgICAgIC8v IGludmFsaWQgY29tcG91bmQgZnVuY3Rpb25zCiAgICAgICB7ICd0cmFuc2Zvcm0nIDogJyxyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KScsICdyZXN1bHQnIDogJ25vbmUnIH0sIC8v IGhhcyBjb21tYQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3Bw IGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCmluZGV4IDFmMmM5Y2EuLjUyNDRl M2YgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAorKysgYi9X ZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKQEAgLTY4NCw2ICs2ODQsNzQgQEAgaW50 IENTU1ByaW1pdGl2ZVZhbHVlOjpnZXRJZGVudCgpCiAgICAgcmV0dXJuIG1fdmFsdWUuaWRlbnQ7 CiB9CiAKK3N0YXRpYyB2b2lkIGFwcGVuZENTU0RvdWJsZShWZWN0b3I8VUNoYXI+JiB2ZWN0b3Is IGRvdWJsZSB2YWx1ZSkKK3sKKyAgICAvLyBGcm9tIHRoZSBDU1Mgc3BlY2lmaWNhdGlvbiBzZWN0 aW9uIHRpdGxlZCAiSW50ZWdlcnMgYW5kIHJlYWwgbnVtYmVycyIsCisgICAgLy8gcmVhbCBudW1i ZXJzIGFyZSBvbmx5IGZvcm1hdHRlZCBhcyBbc2lnbl0gW2RpZ2l0c10gIi4iIFtkaWdpdHNdLgor ICAgIC8vIFRoaXMgZGlmZmVycyBmcm9tIHByaW50Zi1zdHlsZSBmb3JtYXR0aW5nIGluIHRoYXQg ZXhwb25lbnRzIChlLmcuIDEuM2UwNikKKyAgICAvLyBhcmUgbm90IGFsbG93ZWQuICBTaW5jZSBO YU4vaW5mIGFyZSBhbHNvIG5vdCB2YWxpZCBDU1MgdmFsdWVzIHRoaXMKKyAgICAvLyBmdW5jdGlv biBkb2Vzbid0IGhhbmRsZSB0aGVtLgorCisgICAgLy8gRm9yIGNvbXBhdGliaWxpdHkgd2l0aCB3 aGF0IHdhcyByZXR1cm5lZCBieSBvbGRlciB2ZXJzaW9ucyBvZgorICAgIC8vIFdlYktpdCwgd2Ug dGFyZ2V0IDYgZGlnaXRzIG9mIHByZWNpc2lvbi4KKyAgICBjb25zdCBpbnQgZGlnaXRzQWZ0ZXJE ZWNpbWFsUG9pbnQgPSA2OworICAgIGxvbmcgbG9uZyByb3VuZGVkID0gbGxyb3VuZChmYWJzKHZh bHVlKSAqIDEwMDAwMDAuMCk7CisgICAgaWYgKHJvdW5kZWQgPT0gMCkgeworICAgICAgICB2ZWN0 b3IuYXBwZW5kKCcwJyk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBjaGFyIGJ1Zls4 MF07CisgICAgaW50IGxlbmd0aCA9IHNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlbGxkIiwg cm91bmRlZCk7CisgICAgaW50IGRlY2ltYWxQb2ludCA9IGxlbmd0aCAtIDY7CisKKyAgICAvLyBX ZSBhcmUgbWF0Y2hpbmcgcHJpbnRmKCIlZyIpJ3MgYmVoYXZpb3IgYW5kIG11c3QgdHJpbSB0cmFp bGluZyB6ZXJvcywKKyAgICAvLyByZWdhcmRsZXNzIG9mIHdoZXRoZXIgdGhleSdyZSBzaWduaWZp Y2FudC4KKyAgICBsZW5ndGggPSBtaW4obGVuZ3RoLCBkaWdpdHNBZnRlckRlY2ltYWxQb2ludCk7 CisgICAgd2hpbGUgKGxlbmd0aCA+IDAgJiYgYnVmW2xlbmd0aCAtIDFdID09ICcwJykKKyAgICAg ICAgbGVuZ3RoLS07CisKKyAgICAvLyBSZXNlcnZlIGFuIGVzdGltYXRlIG9mIHNwYWNlIGZvciB0 aGUgbnVtYmVyIG9mIGRpZ2l0cyB3ZSBhbnRpY2lwYXRlCisgICAgLy8gYWxvbmcgd2l0aCBhIG1p bnVzIHNpZ24vaW5pdGlhbCB6ZXJvL2RlY2ltYWwgcG9pbnQuCisgICAgdmVjdG9yLnJlc2VydmVD YXBhY2l0eSh2ZWN0b3Iuc2l6ZSgpICsgMyArIGxlbmd0aCk7CisKKyAgICBpZiAodmFsdWUgPCAw KQorICAgICAgICB2ZWN0b3IuYXBwZW5kKCctJyk7CisKKyAgICBpZiAoZGVjaW1hbFBvaW50IDw9 IDApIHsKKyAgICAgICAgLy8gT25seSBkaWdpdHMgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuCisg ICAgICAgIHZlY3Rvci5hcHBlbmQoJzAnKTsKKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnLicpOwor ICAgICAgICBmb3IgKGludCBpID0gZGVjaW1hbFBvaW50OyBpIDwgMDsgaSsrKQorICAgICAgICAg ICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0 aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSBp ZiAobGVuZ3RoIDw9IGRlY2ltYWxQb2ludCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBiZWZv cmUgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3Ro OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgICAgIGZvciAo aW50IGkgPSAwOyBpIDwgZGVjaW1hbFBvaW50IC0gbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2 ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gRGlnaXRzIGJlZm9y ZSBhbmQgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBp IDwgZGVjaW1hbFBvaW50OyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7 CisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy4nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9IGRlY2lt YWxQb2ludDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZb aV0pOworICAgIH0KK30KKworc3RhdGljIFN0cmluZyBmb3JtYXRXaXRoVW5pdHMoZG91YmxlIHZh bHVlLCBjb25zdCBjaGFyKiB1bml0cykKK3sKKyAgICBWZWN0b3I8VUNoYXI+IHJlc3VsdDsKKyAg ICBhcHBlbmRDU1NEb3VibGUocmVzdWx0LCB2YWx1ZSk7CisgICAgcmVzdWx0LnJlc2VydmVDYXBh Y2l0eShyZXN1bHQuc2l6ZSgpICsgc3RybGVuKHVuaXRzKSk7CisgICAgZm9yIChpbnQgaSA9IDA7 IHVuaXRzW2ldOyBpKyspCisgICAgICAgIHJlc3VsdC5hcHBlbmQodW5pdHNbaV0pOworICAgIHJl dHVybiBTdHJpbmc6OmFkb3B0KHJlc3VsdCk7Cit9CisKIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1 ZTo6Y3NzVGV4dCgpIGNvbnN0CiB7CiAgICAgLy8gRklYTUU6IHJldHVybiB0aGUgb3JpZ2luYWwg dmFsdWUgaW5zdGVhZCBvZiBhIGdlbmVyYXRlZCBvbmUgKGUuZy4gY29sb3IKQEAgLTY5NSw2MSAr NzYzLDYxIEBAIFN0cmluZyBDU1NQcmltaXRpdmVWYWx1ZTo6Y3NzVGV4dCgpIGNvbnN0CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTlVNQkVSOgogICAgICAgICBjYXNlIENT U19QQVJTRVJfSU5URUdFUjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6Om51bWJlcihtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVt LCAiIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEVSQ0VOVEFHRToK LSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGclJSIsIG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICIlIik7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRU1TOgotICAgICAgICAgICAg dGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2VtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAg ICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImVtIik7CiAgICAgICAgICAg ICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRVhTOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2V4IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImV4Iik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfUkVNUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgi JS42bGdyZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVu aXRzKG1fdmFsdWUubnVtLCAicmVtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2Fz ZSBDU1NfUFg6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncHgiLCBt X3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUu bnVtLCAicHgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19DTToKLSAg ICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdjbSIsIG1fdmFsdWUubnVtKTsK KyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJjbSIpOwog ICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX01NOgotICAgICAgICAgICAgdGV4 dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ21tIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAg dGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIm1tIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfSU46Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpm b3JtYXQoIiUuNmxnaW4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0 V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiaW4iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAg ICBjYXNlIENTU19QVDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdw dCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92 YWx1ZS5udW0sICJwdCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BD OgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3BjIiwgbV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInBj Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfREVHOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2RlZyIsIG1fdmFsdWUubnVtKTsKKyAgICAg ICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJkZWciKTsKICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxncmFkIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4 dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInJhZCIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX0dSQUQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpm b3JtYXQoIiUuNmxnZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3Jt YXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJncmFkIik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxnbXMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAibXMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3MiLCBtX3ZhbHVl Lm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAi cyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0haOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2h6IiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImh6Iik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfS0haOgotICAgICAgICAgICAgdGV4dCA9IFN0 cmluZzo6Zm9ybWF0KCIlLjZsZ2toeiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQg PSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJraHoiKTsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19UVVJOOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9y bWF0KCIlLjZsZ3R1cm4iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0 V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAidHVybiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAg ICAgIGNhc2UgQ1NTX0RJTUVOU0lPTjoKICAgICAgICAgICAgIC8vIEZJWE1F 41059 2009-10-12 14:27:40 -0700 2009-10-12 14:46:49 -0700 stringify CSS units manually to match CSS spec bug-18994-20091012142738.patch text/plain 13928 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlw LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10 cmlwLWV4cGVjdGVkLnR4dAppbmRleCBjOWM2ZGMxLi40ODc5NTQ0IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQu dHh0CkBAIC0xICsxIEBACi1GQUlMOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5LjAwMWUrMDdw eCwgcmVhZCBhZ2FpbiBhcyAwcHgKK1BBU1M6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFzIDkwMDEw MDAwcHgsIHJlYWQgYWdhaW4gYXMgOTAwMTAwMDBweApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAppbmRleCBmNjVhZDFmLi43OTVhMmM1IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAt MSwzICsxLDE3IEBACiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmct cG9pbnQgb3BhY2l0eSBmcm9tIENTUyBhdHRyaWJ1dGVzIGdldHMgYmFjayBhIHByb3Blcmx5LWZv cm1hdHRlZCBmbG9hdC4gSW1wcm9wZXJseSBoYW5kbGluZyBsb2NhbGVzIHRoYXQgY2F1c2UgZGVj aW1hbHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsgaXQuCiAKIFBBU1MKK1BB U1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MK K1BBU1MKK1BBU1MKK1BBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3Bh Y2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1s CmluZGV4IDBlZjA0NTYuLjg0MDVhZWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3Nz L29wYWNpdHktZmxvYXQuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZs b2F0Lmh0bWwKQEAgLTE1LDkgKzE1LDM0IEBAIGl0LjwvcD4KIDxhIGlkPSd0ZXN0JyBzdHlsZT0n b3BhY2l0eTouOSc+PC9hPgogCiA8c2NyaXB0PgotdmFyIG9wYWNpdHkgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsKLWlmIChvcGFjaXR5 ID09ICcwLjknKQotICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ci1lbHNlCi0gICAgZG9jdW1l bnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKK3ZhciB0ZXN0ID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3Rlc3QnKTsKKworZnVuY3Rpb24gZG9UZXN0KGV4cGVjdGVkLCBpbnB1dCkgewor ICAgIHRlc3Quc3R5bGUub3BhY2l0eSA9IGlucHV0OworICAgIHZhciBvcGFjaXR5ID0gdGVzdC5z dHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7CisgICAgaWYgKG9wYWNpdHkgPT0gZXhwZWN0ZWQpCisg ICAgICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7CisgICAgZWxzZQorICAgICAgICBkb2N1bWVu dC53cml0ZSgnRkFJTDogZXhwZWN0ZWQgJyArIGV4cGVjdGVkICsgJywgZ290ICcgKyBvcGFjaXR5 KTsKKyAgICBkb2N1bWVudC53cml0ZSgnPGJyPicpOworfQorCit2YXIgdGVzdHMgPSBbWycwLjkn LCAnMC45J10sCisgICAgICAgICAgICAgWyc5ODc2NTQzMjE5OCcsICc5ODc2NTQzMjE5OCddLAor ICAgICAgICAgICAgIFsnOTg3MDAwMCcsICc5ODcwMDAwJ10sCisgICAgICAgICAgICAgWycwLjAw MDMyMScsICcwLjAwMDMyMSddLAorICAgICAgICAgICAgIFsnNTAuMDInLCAnNTAuMDInXSwKKyAg ICAgICAgICAgICAvLyBDaGVjayB3ZSBjbGlwIHByZWNpc2lvbiB0byBzaXggZGVjaW1hbHMuCisg ICAgICAgICAgICAgWycxMjM0LjU2Nzg5MScsICcxMjM0LjU2Nzg5MTIzNCddXTsKK2ZvciAodmFy IGkgPSAwOyBpIDwgdGVzdHMubGVuZ3RoOyBpKyspCisgICAgZG9UZXN0KHRlc3RzW2ldWzBdLCB0 ZXN0c1tpXVsxXSk7CisKKy8vIFRlc3QgYSB0b28tc21hbGwgdmFsdWUuCitkb1Rlc3QoJzAnLCAn MC4wMDAwMDAxJyk7CisvLyBUZXN0IHRoYXQgYSBiZXlvbmQtcHJlY2lzaW9uIGRpZ2l0IHdpbGwg YmUgcm91bmRlZCBpbi4KK2RvVGVzdCgnMC4wMDAwMDEnLCAnMC4wMDAwMDA5Jyk7CisKKy8vIFJ1 biB0aGUgdGVzdCBsaXN0IGFnYWluIHdpdGggbmVnYXRpdmVzLgorZm9yICh2YXIgaSA9IDA7IGkg PCB0ZXN0cy5sZW5ndGg7IGkrKykKKyAgICBkb1Rlc3QoJy0nICsgdGVzdHNbaV1bMF0sICctJyAr IHRlc3RzW2ldWzFdKTsKIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vbWFjL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiODE5ODNkLi4wMDAwMDAwCi0tLSBhL0xheW91dFRlc3Rz L3BsYXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAorKysgL2Rl di9udWxsCkBAIC0xLDMgKzAsMCBAQAotVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBh IGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBw cm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0 IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0Lgot Ci1GQUlMOiAwLDkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91 bmQtMmQtdHJhbnNmb3Jtcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJk L2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMtZXhwZWN0ZWQudHh0CmluZGV4IDU1ODNiZDAuLjA5ZGE5 MDEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJh bnNmb3Jtcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21w b3VuZC0yZC10cmFuc2Zvcm1zLWV4cGVjdGVkLnR4dApAQCAtNywxMSArNywxMSBAQCB0cmFuc2Zv cm0gInNrZXcoMTJkZWcpIiBleHBlY3RlZCAibWF0cml4KDEsIDAsIDAuMjEyNTU3LCAxLCAwLCAw KSIgOiBQQVNTCiB0cmFuc2Zvcm0gIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkx MiwgMC45NzgxNDgsIDUwLCAyMCkiIGV4cGVjdGVkICJtYXRyaXgoMC45NzgxNDgsIDAuMjA3OTEy LCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA1MCwgMjApIiA6IFBBU1MKIHRyYW5zZm9ybSAidHJhbnNs YXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykiIGV4cGVjdGVkICJtYXRyaXgoMC45NzgxNDgs IDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA1MCwgMjApIiA6IFBBU1MKIHRyYW5zZm9y bSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkiIGV4cGVjdGVkICJtYXRyaXgo MC45NzgxNDgsIDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA0NC43NDkxLCAyOS45NTg1 KSIgOiBQQVNTCi10cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgp IHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3 NiwgMS4zNjk0MSwgNDQuNzQ5MSwgMjkuOTU4NSkiIDogUEFTUwotdHJhbnNmb3JtICJzY2FsZSgx LjQpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpICIgZXhwZWN0ZWQgIm1hdHJp eCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA2Mi42NDg4LCA0MS45NDIp IiA6IFBBU1MKLXRyYW5zZm9ybSAic2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90 YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2 LCAxLjM2OTQxLCA3MCwgMjgpIiA6IFBBU1MKLXRyYW5zZm9ybSAidHJhbnNsYXRlKDUwcHgsIDIw cHgpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlWSg1MHB4KSBzY2FsZSgxLjQpIiBleHBlY3RlZCAi bWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDM5LjYwNDQsIDY4 LjkwNzQpIiA6IFBBU1MKLXRyYW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwg MjBweCkgc2NhbGUoMS40KSB0cmFuc2xhdGUoLTgwcHgsIDQwcHgpIHNrZXcoMzRkZWcpIHRyYW5z bGF0ZSgxMHB4LCAxMHB4KSBzY2FsZSgwLjcpIHNrZXdZKC0yNWRlZykgcm90YXRlKDIxZGVnKSB0 cmFuc2xhdGVYKDUwcHgpIHNjYWxlKDEuNCwgMS44KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjIwNTE3 LCAwLjE0ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQsIC0xMy4zODQ3LCA4NS4zMSkiIDogUEFTUwor dHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQp IiBleHBlY3RlZCAibWF0cml4KDEuMzY5NCwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA0 NC43NDkxLCAyOS45NTg1KSIgOiBQQVNTCit0cmFuc2Zvcm0gInNjYWxlKDEuNCkgcm90YXRlKDEy ZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NCwgMC4y OTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0LCA2Mi42NDg4LCA0MS45NDE5KSIgOiBQQVNTCit0cmFu c2Zvcm0gInNjYWxlKDEuNCkgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykiIGV4 cGVjdGVkICJtYXRyaXgoMS4zNjk0LCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQsIDcwLCAy OCkiIDogUEFTUwordHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVn KSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0LCAw LjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQsIDM5LjYwNDQsIDY4LjkwNzMpIiA6IFBBU1MKK3Ry YW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSB0 cmFuc2xhdGUoLTgwcHgsIDQwcHgpIHNrZXcoMzRkZWcpIHRyYW5zbGF0ZSgxMHB4LCAxMHB4KSBz Y2FsZSgwLjcpIHNrZXdZKC0yNWRlZykgcm90YXRlKDIxZGVnKSB0cmFuc2xhdGVYKDUwcHgpIHNj YWxlKDEuNCwgMS44KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjIwNTE2LCAwLjE0ODIwNywgMC4yNTg5 ODcsIDIuMDQwMDQsIC0xMy4zODQ3LCA4NS4zMDk5KSIgOiBQQVNTCiB0cmFuc2Zvcm0gIixyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm5vbmUiIDogUEFTUwog dHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpLCB0cmFuc2xhdGUoNTBweCwgMjBweCkiIGV4cGVjdGVk ICJub25lIiA6IFBBU1MKIHRyYW5zZm9ybSAicm90YXRlKDEyZGVnKSArIHRyYW5zbGF0ZSg1MHB4 LCAyMHB4KSIgZXhwZWN0ZWQgIm5vbmUiIDogUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv dHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLmh0bWwgYi9MYXlvdXRUZXN0cy90 cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMuaHRtbAppbmRleCAxNjAwM2MzLi45 MDE4NjA0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJk LXRyYW5zZm9ybXMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5k LTJkLXRyYW5zZm9ybXMuaHRtbApAQCAtNDYsMTQgKzQ2LDE0IEBACiAgICAgICB7ICd0cmFuc2Zv cm0nIDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpJywgICAgICAgICAgJ3Jl c3VsdCcgOiAnbWF0cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwg NDQuNzQ5MSwgMjkuOTU4NSknIH0sCiAKICAgICAgIC8vIHRocmVlIGZ1bmN0aW9ucwotICAgICAg eyAndHJhbnNmb3JtJyA6ICdyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2Fs ZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3 NiwgMS4zNjk0MSwgNDQuNzQ5MSwgMjkuOTU4NSknIH0sCi0gICAgICB7ICd0cmFuc2Zvcm0nIDog J3NjYWxlKDEuNCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgJywgICdyZXN1 bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA2Mi42 NDg4LCA0MS45NDIpJyB9LAotICAgICAgeyAndHJhbnNmb3JtJyA6ICdzY2FsZSgxLjQpIHRyYW5z bGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4z Njk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgNzAsIDI4KScgfSwKLSAgICAgIHsg J3RyYW5zZm9ybScgOiAndHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykgdHJhbnNs YXRlWSg1MHB4KSBzY2FsZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0MSwgMC4y OTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgMzkuNjA0NCwgNjguOTA3NCknIH0sCisgICAgICB7 ICd0cmFuc2Zvcm0nIDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxl KDEuNCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYs IDEuMzY5NCwgNDQuNzQ5MSwgMjkuOTU4NSknIH0sCisgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3Nj YWxlKDEuNCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgJywgICdyZXN1bHQn IDogJ21hdHJpeCgxLjM2OTQsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NCwgNjIuNjQ4OCwg NDEuOTQxOSknIH0sCisgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3NjYWxlKDEuNCkgdHJhbnNsYXRl KDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZyknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQs IDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NCwgNzAsIDI4KScgfSwKKyAgICAgIHsgJ3RyYW5z Zm9ybScgOiAndHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlWSg1 MHB4KSBzY2FsZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0LCAwLjI5MTA3Niwg LTAuMjkxMDc2LCAxLjM2OTQsIDM5LjYwNDQsIDY4LjkwNzMpJyB9LAogCiAgICAgICAvLyBsb3Rz IG9mIGZ1bmN0aW9ucwogICAgICAgeyAndHJhbnNmb3JtJyA6ICdyb3RhdGUoMTJkZWcpIHRyYW5z bGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpIHRyYW5zbGF0ZSgtODBweCwgNDBweCkgc2tldygz NGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgpIHNjYWxlKDAuNykgc2tld1koLTI1ZGVnKSByb3Rh dGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkgc2NhbGUoMS40LCAxLjgpJywgCi0gICAgICAgICdy ZXN1bHQnIDogJ21hdHJpeCgxLjIwNTE3LCAwLjE0ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQsIC0x My4zODQ3LCA4NS4zMSknIH0sCisgICAgICAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjIwNTE2LCAw LjE0ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQsIC0xMy4zODQ3LCA4NS4zMDk5KScgfSwKICAgICAg ICAgCiAgICAgICAvLyBpbnZhbGlkIGNvbXBvdW5kIGZ1bmN0aW9ucwogICAgICAgeyAndHJhbnNm b3JtJyA6ICcscm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCknLCAncmVzdWx0JyA6 ICdub25lJyB9LCAvLyBoYXMgY29tbWEKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1ByaW1p dGl2ZVZhbHVlLmNwcCBiL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAppbmRleCAx ZjJjOWNhLi5iZjM3N2U1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1 ZS5jcHAKKysrIGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCkBAIC02ODQsNiAr Njg0LDcxIEBAIGludCBDU1NQcmltaXRpdmVWYWx1ZTo6Z2V0SWRlbnQoKQogICAgIHJldHVybiBt X3ZhbHVlLmlkZW50OwogfQogCitzdGF0aWMgdm9pZCBhcHBlbmRDU1NEb3VibGUoVmVjdG9yPFVD aGFyPiYgdmVjdG9yLCBkb3VibGUgdmFsdWUpCit7CisgICAgLy8gRnJvbSB0aGUgQ1NTIHNwZWNp ZmljYXRpb24gc2VjdGlvbiB0aXRsZWQgIkludGVnZXJzIGFuZCByZWFsIG51bWJlcnMiLAorICAg IC8vIHJlYWwgbnVtYmVycyBhcmUgb25seSBmb3JtYXR0ZWQgYXMgW3NpZ25dIFtkaWdpdHNdICIu IiBbZGlnaXRzXS4KKyAgICAvLyBUaGlzIGRpZmZlcnMgZnJvbSBwcmludGYtc3R5bGUgZm9ybWF0 dGluZyBpbiB0aGF0IGV4cG9uZW50cyAoZS5nLiAxLjNlMDYpCisgICAgLy8gYXJlIG5vdCBhbGxv d2VkLiAgU2luY2UgTmFOL2luZiBhcmUgYWxzbyBub3QgdmFsaWQgQ1NTIHZhbHVlcyB0aGlzCisg ICAgLy8gZnVuY3Rpb24gZG9lc24ndCBoYW5kbGUgdGhlbS4KKworICAgIC8vIEZvciBjb21wYXRp YmlsaXR5IHdpdGggd2hhdCB3YXMgcmV0dXJuZWQgYnkgb2xkZXIgdmVyc2lvbnMgb2YKKyAgICAv LyBXZWJLaXQsIHdlIHRhcmdldCA2IGRpZ2l0cyBvZiBwcmVjaXNpb24uCisgICAgY29uc3QgaW50 IGRpZ2l0c0FmdGVyRGVjaW1hbFBvaW50ID0gNjsKKyAgICBsb25nIGxvbmcgcm91bmRlZCA9IGxs cm91bmQoZmFicyh2YWx1ZSkgKiAxMDAwMDAwLjApOworICAgIGlmIChyb3VuZGVkID09IDApIHsK KyAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgY2hhciBidWZbMjRdOworICAgIGludCBsZW5ndGggPSBzbnByaW50ZihidWYsIHNpemVvZihi dWYpLCAiJWxsZCIsIHJvdW5kZWQpOworICAgIGludCBkZWNpbWFsUG9pbnQgPSBsZW5ndGggLSBk aWdpdHNBZnRlckRlY2ltYWxQb2ludDsKKworICAgIC8vIFdlIGFyZSBtYXRjaGluZyBwcmludGYo IiVnIikncyBiZWhhdmlvciBhbmQgbXVzdCB0cmltIHRyYWlsaW5nIHplcm9zLAorICAgIC8vIHJl Z2FyZGxlc3Mgb2Ygd2hldGhlciB0aGV5J3JlIHNpZ25pZmljYW50LgorICAgIHdoaWxlIChsZW5n dGggPiAwICYmIGxlbmd0aCA+IGRlY2ltYWxQb2ludCAmJiBidWZbbGVuZ3RoIC0gMV0gPT0gJzAn KQorICAgICAgICBsZW5ndGgtLTsKKworICAgIC8vIFJlc2VydmUgYW4gZXN0aW1hdGUgb2Ygc3Bh Y2UgZm9yIHRoZSBudW1iZXIgb2YgZGlnaXRzIHdlIGFudGljaXBhdGUKKyAgICAvLyBhbG9uZyB3 aXRoIGEgbWludXMgc2lnbi9pbml0aWFsIHplcm8vZGVjaW1hbCBwb2ludC4KKyAgICB2ZWN0b3Iu cmVzZXJ2ZUNhcGFjaXR5KHZlY3Rvci5zaXplKCkgKyAzICsgbGVuZ3RoKTsKKworICAgIGlmICh2 YWx1ZSA8IDApCisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy0nKTsKKworICAgIGlmIChkZWNpbWFs UG9pbnQgPD0gMCkgeworICAgICAgICAvLyBPbmx5IGRpZ2l0cyBhZnRlciB0aGUgZGVjaW1hbCBw b2ludC4KKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnMCcpOworICAgICAgICB2ZWN0b3IuYXBwZW5k KCcuJyk7CisgICAgICAgIGZvciAoaW50IGkgPSBkZWNpbWFsUG9pbnQ7IGkgPCAwOyBpKyspCisg ICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKCcwJyk7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBp IDwgbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAg fSBlbHNlIGlmIChsZW5ndGggPD0gZGVjaW1hbFBvaW50KSB7CisgICAgICAgIC8vIE9ubHkgZGln aXRzIGJlZm9yZSB0aGUgZGVjaW1hbCBwb2ludC4KKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkg PCBsZW5ndGg7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsKKyAgICB9 IGVsc2UgeworICAgICAgICAvLyBEaWdpdHMgYmVmb3JlIGFuZCBhZnRlciB0aGUgZGVjaW1hbCBw b2ludC4KKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBkZWNpbWFsUG9pbnQ7IGkrKykKKyAg ICAgICAgICAgIHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsKKyAgICAgICAgdmVjdG9yLmFwcGVuZCgn LicpOworICAgICAgICBmb3IgKGludCBpID0gZGVjaW1hbFBvaW50OyBpIDwgbGVuZ3RoOyBpKysp CisgICAgICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgfQorfQorCitzdGF0aWMg U3RyaW5nIGZvcm1hdFdpdGhVbml0cyhkb3VibGUgdmFsdWUsIGNvbnN0IGNoYXIqIHVuaXRzKQor eworICAgIFZlY3RvcjxVQ2hhcj4gcmVzdWx0OworICAgIGFwcGVuZENTU0RvdWJsZShyZXN1bHQs IHZhbHVlKTsKKyAgICByZXN1bHQucmVzZXJ2ZUNhcGFjaXR5KHJlc3VsdC5zaXplKCkgKyBzdHJs ZW4odW5pdHMpKTsKKyAgICBmb3IgKGludCBpID0gMDsgdW5pdHNbaV07IGkrKykKKyAgICAgICAg cmVzdWx0LmFwcGVuZCh1bml0c1tpXSk7CisgICAgcmV0dXJuIFN0cmluZzo6YWRvcHQocmVzdWx0 KTsKK30KKwogU3RyaW5nIENTU1ByaW1pdGl2ZVZhbHVlOjpjc3NUZXh0KCkgY29uc3QKIHsKICAg ICAvLyBGSVhNRTogcmV0dXJuIHRoZSBvcmlnaW5hbCB2YWx1ZSBpbnN0ZWFkIG9mIGEgZ2VuZXJh dGVkIG9uZSAoZS5nLiBjb2xvcgpAQCAtNjk1LDYxICs3NjAsNjEgQEAgU3RyaW5nIENTU1ByaW1p dGl2ZVZhbHVlOjpjc3NUZXh0KCkgY29uc3QKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBj YXNlIENTU19OVU1CRVI6CiAgICAgICAgIGNhc2UgQ1NTX1BBUlNFUl9JTlRFR0VSOgotICAgICAg ICAgICAgdGV4dCA9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICIiKTsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19QRVJDRU5UQUdFOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZyUlIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgIiUiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19FTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxnZW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAiZW0iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19FWFM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZXgiLCBtX3Zh bHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVt LCAiZXgiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19SRU1TOgotICAg ICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3JlbSIsIG1fdmFsdWUubnVtKTsK KyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJyZW0iKTsK ICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19QWDoKLSAgICAgICAgICAgIHRl eHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdweCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAg IHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJweCIpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0NNOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 Zm9ybWF0KCIlLjZsZ2NtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1h dFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImNtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBDU1NfTU06Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxn bW0iLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1f dmFsdWUubnVtLCAibW0iKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19J TjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdpbiIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJp biIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BUOgotICAgICAgICAg ICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3B0IiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInB0Iik7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUEM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3Ry aW5nOjpmb3JtYXQoIiUuNmxncGMiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0g Zm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicGMiKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19ERUc6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxnZGVnIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhV bml0cyhtX3ZhbHVlLm51bSwgImRlZyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNh c2UgQ1NTX1JBRDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdyYWQi LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAicmFkIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfR1JB RDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdncmFkIiwgbV92YWx1 ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwg ImdyYWQiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19NUzoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdtcyIsIG1fdmFsdWUubnVtKTsKKyAg ICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJtcyIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1M6Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxncyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQg PSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJzIik7CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgY2FzZSBDU1NfSFo6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQo IiUuNmxnaHoiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVu aXRzKG1fdmFsdWUubnVtLCAiaHoiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNl IENTU19LSFo6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxna2h6Iiwg bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVl Lm51bSwgImtoeiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1RVUk46 Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxndHVybiIsIG1fdmFsdWUu bnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJ0 dXJuIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfRElNRU5TSU9OOgog ICAgICAgICAgICAgLy8gRklYTUU= 41061 2009-10-12 14:46:55 -0700 2009-10-13 15:03:23 -0700 stringify CSS units manually to match CSS spec bug-18994-20091012144654.patch text/plain 14534 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlw LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvY3NzL2xhcmdlLW51bWJlci1yb3VuZC10 cmlwLWV4cGVjdGVkLnR4dAppbmRleCBjOWM2ZGMxLi40ODc5NTQ0IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFyZ2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQu dHh0CkBAIC0xICsxIEBACi1GQUlMOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5LjAwMWUrMDdw eCwgcmVhZCBhZ2FpbiBhcyAwcHgKK1BBU1M6IHJlYWQgOTAwMTAwMDBweCBiYWNrIGFzIDkwMDEw MDAwcHgsIHJlYWQgYWdhaW4gYXMgOTAwMTAwMDBweApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAppbmRleCBmNjVhZDFmLi43OTVhMmM1IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApAQCAt MSwzICsxLDE3IEBACiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCByZWFkaW5nIGEgZmxvYXRpbmct cG9pbnQgb3BhY2l0eSBmcm9tIENTUyBhdHRyaWJ1dGVzIGdldHMgYmFjayBhIHByb3Blcmx5LWZv cm1hdHRlZCBmbG9hdC4gSW1wcm9wZXJseSBoYW5kbGluZyBsb2NhbGVzIHRoYXQgY2F1c2UgZGVj aW1hbHMgdG8gYmUgd3JpdHRlbiBhcyBjb21tYXMgbWlnaHQgYnJlYWsgaXQuCiAKIFBBU1MKK1BB U1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MKK1BBU1MK K1BBU1MKK1BBU1MKK1BBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3Bh Y2l0eS1mbG9hdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1s CmluZGV4IDBlZjA0NTYuLjg0MDVhZWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvY3Nz L29wYWNpdHktZmxvYXQuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZs b2F0Lmh0bWwKQEAgLTE1LDkgKzE1LDM0IEBAIGl0LjwvcD4KIDxhIGlkPSd0ZXN0JyBzdHlsZT0n b3BhY2l0eTouOSc+PC9hPgogCiA8c2NyaXB0PgotdmFyIG9wYWNpdHkgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgndGVzdCcpLnN0eWxlLm9wYWNpdHkudG9TdHJpbmcoKTsKLWlmIChvcGFjaXR5 ID09ICcwLjknKQotICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ci1lbHNlCi0gICAgZG9jdW1l bnQud3JpdGUoJ0ZBSUw6ICcgKyBvcGFjaXR5KTsKK3ZhciB0ZXN0ID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3Rlc3QnKTsKKworZnVuY3Rpb24gZG9UZXN0KGV4cGVjdGVkLCBpbnB1dCkgewor ICAgIHRlc3Quc3R5bGUub3BhY2l0eSA9IGlucHV0OworICAgIHZhciBvcGFjaXR5ID0gdGVzdC5z dHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7CisgICAgaWYgKG9wYWNpdHkgPT0gZXhwZWN0ZWQpCisg ICAgICAgIGRvY3VtZW50LndyaXRlKCdQQVNTJyk7CisgICAgZWxzZQorICAgICAgICBkb2N1bWVu dC53cml0ZSgnRkFJTDogZXhwZWN0ZWQgJyArIGV4cGVjdGVkICsgJywgZ290ICcgKyBvcGFjaXR5 KTsKKyAgICBkb2N1bWVudC53cml0ZSgnPGJyPicpOworfQorCit2YXIgdGVzdHMgPSBbWycwLjkn LCAnMC45J10sCisgICAgICAgICAgICAgWyc5ODc2NTQzMjE5OCcsICc5ODc2NTQzMjE5OCddLAor ICAgICAgICAgICAgIFsnOTg3MDAwMCcsICc5ODcwMDAwJ10sCisgICAgICAgICAgICAgWycwLjAw MDMyMScsICcwLjAwMDMyMSddLAorICAgICAgICAgICAgIFsnNTAuMDInLCAnNTAuMDInXSwKKyAg ICAgICAgICAgICAvLyBDaGVjayB3ZSBjbGlwIHByZWNpc2lvbiB0byBzaXggZGVjaW1hbHMuCisg ICAgICAgICAgICAgWycxMjM0LjU2Nzg5MScsICcxMjM0LjU2Nzg5MTIzNCddXTsKK2ZvciAodmFy IGkgPSAwOyBpIDwgdGVzdHMubGVuZ3RoOyBpKyspCisgICAgZG9UZXN0KHRlc3RzW2ldWzBdLCB0 ZXN0c1tpXVsxXSk7CisKKy8vIFRlc3QgYSB0b28tc21hbGwgdmFsdWUuCitkb1Rlc3QoJzAnLCAn MC4wMDAwMDAxJyk7CisvLyBUZXN0IHRoYXQgYSBiZXlvbmQtcHJlY2lzaW9uIGRpZ2l0IHdpbGwg YmUgcm91bmRlZCBpbi4KK2RvVGVzdCgnMC4wMDAwMDEnLCAnMC4wMDAwMDA5Jyk7CisKKy8vIFJ1 biB0aGUgdGVzdCBsaXN0IGFnYWluIHdpdGggbmVnYXRpdmVzLgorZm9yICh2YXIgaSA9IDA7IGkg PCB0ZXN0cy5sZW5ndGg7IGkrKykKKyAgICBkb1Rlc3QoJy0nICsgdGVzdHNbaV1bMF0sICctJyAr IHRlc3RzW2ldWzFdKTsKIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vbWFjL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQtZXhwZWN0ZWQudHh0CmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiODE5ODNkLi4wMDAwMDAwCi0tLSBhL0xheW91dFRlc3Rz L3BsYXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dAorKysgL2Rl di9udWxsCkBAIC0xLDMgKzAsMCBAQAotVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBh IGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBDU1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBw cm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJvcGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0 IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4gYXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0Lgot Ci1GQUlMOiAwLDkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91 bmQtMmQtdHJhbnNmb3Jtcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJk L2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMtZXhwZWN0ZWQudHh0CmluZGV4IDU1ODNiZDAuLjBmNTI3 MTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJh bnNmb3Jtcy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21w b3VuZC0yZC10cmFuc2Zvcm1zLWV4cGVjdGVkLnR4dApAQCAtNiwxMiArNiwxMiBAQCB0cmFuc2Zv cm0gInNjYWxlKDEuNykiIGV4cGVjdGVkICJtYXRyaXgoMS43LCAwLCAwLCAxLjcsIDAsIDApIiA6 IFBBU1MKIHRyYW5zZm9ybSAic2tldygxMmRlZykiIGV4cGVjdGVkICJtYXRyaXgoMSwgMCwgMC4y MTI1NTcsIDEsIDAsIDApIiA6IFBBU1MKIHRyYW5zZm9ybSAibWF0cml4KDAuOTc4MTQ4LCAwLjIw NzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwgNTAsIDIwKSIgZXhwZWN0ZWQgIm1hdHJpeCgwLjk3 ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDUwLCAyMCkiIDogUEFTUwogdHJh bnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0ZWQgIm1h dHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDUwLCAyMCkiIDog UEFTUwotdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhw ZWN0ZWQgIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDQ0 Ljc0OTEsIDI5Ljk1ODUpIiA6IFBBU1MKLXRyYW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xh dGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQxLCAwLjI5 MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA0NC43NDkxLCAyOS45NTg1KSIgOiBQQVNTCi10cmFu c2Zvcm0gInNjYWxlKDEuNCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgIiBl eHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDYy LjY0ODgsIDQxLjk0MikiIDogUEFTUwotdHJhbnNmb3JtICJzY2FsZSgxLjQpIHRyYW5zbGF0ZSg1 MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NDEsIDAuMjkx MDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDcwLCAyOCkiIDogUEFTUwotdHJhbnNmb3JtICJ0cmFu c2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEu NCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0 MSwgMzkuNjA0NCwgNjguOTA3NCkiIDogUEFTUwotdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpIHRy YW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpIHRyYW5zbGF0ZSgtODBweCwgNDBweCkgc2tl dygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgpIHNjYWxlKDAuNykgc2tld1koLTI1ZGVnKSBy b3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkgc2NhbGUoMS40LCAxLjgpIiBleHBlY3RlZCAi bWF0cml4KDEuMjA1MTcsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNCwgLTEzLjM4NDcsIDg1 LjMxKSIgOiBQQVNTCit0cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIiBleHBlY3RlZCAibWF0cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3 ODE0OCwgNDQuNzQ5MTQ2LCAyOS45NTg1MzcpIiA6IFBBU1MKK3RyYW5zZm9ybSAicm90YXRlKDEy ZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSIgZXhwZWN0ZWQgIm1hdHJpeCgx LjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MDcsIDQ0Ljc0OTE0NiwgMjkuOTU4 NTM3KSIgOiBQQVNTCit0cmFuc2Zvcm0gInNjYWxlKDEuNCkgcm90YXRlKDEyZGVnKSB0cmFuc2xh dGUoNTBweCwgMjBweCkgIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NDA3LCAwLjI5MTA3NiwgLTAu MjkxMDc2LCAxLjM2OTQwNywgNjIuNjQ4ODA1LCA0MS45NDE5NTEpIiA6IFBBU1MKK3RyYW5zZm9y bSAic2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVnKSIgZXhwZWN0 ZWQgIm1hdHJpeCgxLjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MDcsIDcwLCAy OCkiIDogUEFTUwordHJhbnNmb3JtICJ0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEyZGVn KSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MDcs IDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDA3LCAzOS42MDQ0MTUsIDY4LjkwNzM4KSIgOiBQ QVNTCit0cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxl KDEuNCkgdHJhbnNsYXRlKC04MHB4LCA0MHB4KSBza2V3KDM0ZGVnKSB0cmFuc2xhdGUoMTBweCwg MTBweCkgc2NhbGUoMC43KSBza2V3WSgtMjVkZWcpIHJvdGF0ZSgyMWRlZykgdHJhbnNsYXRlWCg1 MHB4KSBzY2FsZSgxLjQsIDEuOCkiIGV4cGVjdGVkICJtYXRyaXgoMS4yMDUxNjYsIDAuMTQ4MjA3 LCAwLjI1ODk4NywgMi4wNDAwNDQsIC0xMy4zODQ3MjMsIDg1LjMwOTk2NykiIDogUEFTUwogdHJh bnNmb3JtICIscm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkiIGV4cGVjdGVkICJu b25lIiA6IFBBU1MKIHRyYW5zZm9ybSAicm90YXRlKDEyZGVnKSwgdHJhbnNsYXRlKDUwcHgsIDIw cHgpIiBleHBlY3RlZCAibm9uZSIgOiBQQVNTCiB0cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgKyB0 cmFuc2xhdGUoNTBweCwgMjBweCkiIGV4cGVjdGVkICJub25lIiA6IFBBU1MKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jtcy5odG1sIGIv TGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLmh0bWwKaW5k ZXggMTYwMDNjMy4uN2FhNjY5MSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8y ZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvdHJhbnNmb3Jt cy8yZC9jb21wb3VuZC0yZC10cmFuc2Zvcm1zLmh0bWwKQEAgLTQzLDE3ICs0MywxNyBAQAogICAg ICAgCiAgICAgICAvLyB0d28gZnVuY3Rpb25zCiAgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3RyYW5z bGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpJywgICAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0 cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwgNTAsIDIwKScgfSwK LSAgICAgIHsgJ3RyYW5zZm9ybScgOiAncm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBw eCknLCAgICAgICAgICAncmVzdWx0JyA6ICdtYXRyaXgoMC45NzgxNDgsIDAuMjA3OTEyLCAtMC4y MDc5MTIsIDAuOTc4MTQ4LCA0NC43NDkxLCAyOS45NTg1KScgfSwKKyAgICAgIHsgJ3RyYW5zZm9y bScgOiAncm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCknLCAgICAgICAgICAncmVz dWx0JyA6ICdtYXRyaXgoMC45NzgxNDgsIDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA0 NC43NDkxNDYsIDI5Ljk1ODUzNyknIH0sCiAKICAgICAgIC8vIHRocmVlIGZ1bmN0aW9ucwotICAg ICAgeyAndHJhbnNmb3JtJyA6ICdyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBz Y2FsZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5 MTA3NiwgMS4zNjk0MSwgNDQuNzQ5MSwgMjkuOTU4NSknIH0sCi0gICAgICB7ICd0cmFuc2Zvcm0n IDogJ3NjYWxlKDEuNCkgcm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgJywgICdy ZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA2 Mi42NDg4LCA0MS45NDIpJyB9LAotICAgICAgeyAndHJhbnNmb3JtJyA6ICdzY2FsZSgxLjQpIHRy YW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpJywgICAncmVzdWx0JyA6ICdtYXRyaXgo MS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgNzAsIDI4KScgfSwKLSAgICAg IHsgJ3RyYW5zZm9ybScgOiAndHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykgdHJh bnNsYXRlWSg1MHB4KSBzY2FsZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0MSwg MC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgMzkuNjA0NCwgNjguOTA3NCknIH0sCisgICAg ICB7ICd0cmFuc2Zvcm0nIDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNj YWxlKDEuNCknLCAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5 MTA3NiwgMS4zNjk0MDcsIDQ0Ljc0OTE0NiwgMjkuOTU4NTM3KScgfSwKKyAgICAgIHsgJ3RyYW5z Zm9ybScgOiAnc2NhbGUoMS40KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSAn LCAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NDA3LCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2 OTQwNywgNjIuNjQ4ODA1LCA0MS45NDE5NTEpJyB9LAorICAgICAgeyAndHJhbnNmb3JtJyA6ICdz Y2FsZSgxLjQpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpJywgICAncmVzdWx0 JyA6ICdtYXRyaXgoMS4zNjk0MDcsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDA3LCA3MCwg MjgpJyB9LAorICAgICAgeyAndHJhbnNmb3JtJyA6ICd0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90 YXRlKDEyZGVnKSB0cmFuc2xhdGVZKDUwcHgpIHNjYWxlKDEuNCknLCAgICdyZXN1bHQnIDogJ21h dHJpeCgxLjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MDcsIDM5LjYwNDQxNSwg NjguOTA3MzgpJyB9LAogCiAgICAgICAvLyBsb3RzIG9mIGZ1bmN0aW9ucwogICAgICAgeyAndHJh bnNmb3JtJyA6ICdyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQp IHRyYW5zbGF0ZSgtODBweCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgp IHNjYWxlKDAuNykgc2tld1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkg c2NhbGUoMS40LCAxLjgpJywgCi0gICAgICAgICdyZXN1bHQnIDogJ21hdHJpeCgxLjIwNTE3LCAw LjE0ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQsIC0xMy4zODQ3LCA4NS4zMSknIH0sCisgICAgICAg ICdyZXN1bHQnIDogJ21hdHJpeCgxLjIwNTE2NiwgMC4xNDgyMDcsIDAuMjU4OTg3LCAyLjA0MDA0 NCwgLTEzLjM4NDcyMywgODUuMzA5OTY3KScgfSwKICAgICAgICAgCiAgICAgICAvLyBpbnZhbGlk IGNvbXBvdW5kIGZ1bmN0aW9ucwogICAgICAgeyAndHJhbnNmb3JtJyA6ICcscm90YXRlKDEyZGVn KSB0cmFuc2xhdGUoNTBweCwgMjBweCknLCAncmVzdWx0JyA6ICdub25lJyB9LCAvLyBoYXMgY29t bWEKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcCBiL1dlYkNv cmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAppbmRleCAxZjJjOWNhLi5iZjM3N2U1IDEwMDY0 NAotLS0gYS9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKKysrIGIvV2ViQ29yZS9j c3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCkBAIC02ODQsNiArNjg0LDcxIEBAIGludCBDU1NQcmlt aXRpdmVWYWx1ZTo6Z2V0SWRlbnQoKQogICAgIHJldHVybiBtX3ZhbHVlLmlkZW50OwogfQogCitz dGF0aWMgdm9pZCBhcHBlbmRDU1NEb3VibGUoVmVjdG9yPFVDaGFyPiYgdmVjdG9yLCBkb3VibGUg dmFsdWUpCit7CisgICAgLy8gRnJvbSB0aGUgQ1NTIHNwZWNpZmljYXRpb24gc2VjdGlvbiB0aXRs ZWQgIkludGVnZXJzIGFuZCByZWFsIG51bWJlcnMiLAorICAgIC8vIHJlYWwgbnVtYmVycyBhcmUg b25seSBmb3JtYXR0ZWQgYXMgW3NpZ25dIFtkaWdpdHNdICIuIiBbZGlnaXRzXS4KKyAgICAvLyBU aGlzIGRpZmZlcnMgZnJvbSBwcmludGYtc3R5bGUgZm9ybWF0dGluZyBpbiB0aGF0IGV4cG9uZW50 cyAoZS5nLiAxLjNlMDYpCisgICAgLy8gYXJlIG5vdCBhbGxvd2VkLiAgU2luY2UgTmFOL2luZiBh cmUgYWxzbyBub3QgdmFsaWQgQ1NTIHZhbHVlcyB0aGlzCisgICAgLy8gZnVuY3Rpb24gZG9lc24n dCBoYW5kbGUgdGhlbS4KKworICAgIC8vIEZvciBjb21wYXRpYmlsaXR5IHdpdGggd2hhdCB3YXMg cmV0dXJuZWQgYnkgb2xkZXIgdmVyc2lvbnMgb2YKKyAgICAvLyBXZWJLaXQsIHdlIHRhcmdldCA2 IGRpZ2l0cyBvZiBwcmVjaXNpb24uCisgICAgY29uc3QgaW50IGRpZ2l0c0FmdGVyRGVjaW1hbFBv aW50ID0gNjsKKyAgICBsb25nIGxvbmcgcm91bmRlZCA9IGxscm91bmQoZmFicyh2YWx1ZSkgKiAx MDAwMDAwLjApOworICAgIGlmIChyb3VuZGVkID09IDApIHsKKyAgICAgICAgdmVjdG9yLmFwcGVu ZCgnMCcpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgY2hhciBidWZbMjRdOworICAg IGludCBsZW5ndGggPSBzbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJWxsZCIsIHJvdW5kZWQp OworICAgIGludCBkZWNpbWFsUG9pbnQgPSBsZW5ndGggLSBkaWdpdHNBZnRlckRlY2ltYWxQb2lu dDsKKworICAgIC8vIFdlIGFyZSBtYXRjaGluZyBwcmludGYoIiVnIikncyBiZWhhdmlvciBhbmQg bXVzdCB0cmltIHRyYWlsaW5nIHplcm9zLAorICAgIC8vIHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0 aGV5J3JlIHNpZ25pZmljYW50LgorICAgIHdoaWxlIChsZW5ndGggPiAwICYmIGxlbmd0aCA+IGRl Y2ltYWxQb2ludCAmJiBidWZbbGVuZ3RoIC0gMV0gPT0gJzAnKQorICAgICAgICBsZW5ndGgtLTsK KworICAgIC8vIFJlc2VydmUgYW4gZXN0aW1hdGUgb2Ygc3BhY2UgZm9yIHRoZSBudW1iZXIgb2Yg ZGlnaXRzIHdlIGFudGljaXBhdGUKKyAgICAvLyBhbG9uZyB3aXRoIGEgbWludXMgc2lnbi9pbml0 aWFsIHplcm8vZGVjaW1hbCBwb2ludC4KKyAgICB2ZWN0b3IucmVzZXJ2ZUNhcGFjaXR5KHZlY3Rv ci5zaXplKCkgKyAzICsgbGVuZ3RoKTsKKworICAgIGlmICh2YWx1ZSA8IDApCisgICAgICAgIHZl Y3Rvci5hcHBlbmQoJy0nKTsKKworICAgIGlmIChkZWNpbWFsUG9pbnQgPD0gMCkgeworICAgICAg ICAvLyBPbmx5IGRpZ2l0cyBhZnRlciB0aGUgZGVjaW1hbCBwb2ludC4KKyAgICAgICAgdmVjdG9y LmFwcGVuZCgnMCcpOworICAgICAgICB2ZWN0b3IuYXBwZW5kKCcuJyk7CisgICAgICAgIGZvciAo aW50IGkgPSBkZWNpbWFsUG9pbnQ7IGkgPCAwOyBpKyspCisgICAgICAgICAgICB2ZWN0b3IuYXBw ZW5kKCcwJyk7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCisgICAg ICAgICAgICB2ZWN0b3IuYXBwZW5kKGJ1ZltpXSk7CisgICAgfSBlbHNlIGlmIChsZW5ndGggPD0g ZGVjaW1hbFBvaW50KSB7CisgICAgICAgIC8vIE9ubHkgZGlnaXRzIGJlZm9yZSB0aGUgZGVjaW1h bCBwb2ludC4KKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW5ndGg7IGkrKykKKyAgICAg ICAgICAgIHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBE aWdpdHMgYmVmb3JlIGFuZCBhZnRlciB0aGUgZGVjaW1hbCBwb2ludC4KKyAgICAgICAgZm9yIChp bnQgaSA9IDA7IGkgPCBkZWNpbWFsUG9pbnQ7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBl bmQoYnVmW2ldKTsKKyAgICAgICAgdmVjdG9yLmFwcGVuZCgnLicpOworICAgICAgICBmb3IgKGlu dCBpID0gZGVjaW1hbFBvaW50OyBpIDwgbGVuZ3RoOyBpKyspCisgICAgICAgICAgICB2ZWN0b3Iu YXBwZW5kKGJ1ZltpXSk7CisgICAgfQorfQorCitzdGF0aWMgU3RyaW5nIGZvcm1hdFdpdGhVbml0 cyhkb3VibGUgdmFsdWUsIGNvbnN0IGNoYXIqIHVuaXRzKQoreworICAgIFZlY3RvcjxVQ2hhcj4g cmVzdWx0OworICAgIGFwcGVuZENTU0RvdWJsZShyZXN1bHQsIHZhbHVlKTsKKyAgICByZXN1bHQu cmVzZXJ2ZUNhcGFjaXR5KHJlc3VsdC5zaXplKCkgKyBzdHJsZW4odW5pdHMpKTsKKyAgICBmb3Ig KGludCBpID0gMDsgdW5pdHNbaV07IGkrKykKKyAgICAgICAgcmVzdWx0LmFwcGVuZCh1bml0c1tp XSk7CisgICAgcmV0dXJuIFN0cmluZzo6YWRvcHQocmVzdWx0KTsKK30KKwogU3RyaW5nIENTU1By aW1pdGl2ZVZhbHVlOjpjc3NUZXh0KCkgY29uc3QKIHsKICAgICAvLyBGSVhNRTogcmV0dXJuIHRo ZSBvcmlnaW5hbCB2YWx1ZSBpbnN0ZWFkIG9mIGEgZ2VuZXJhdGVkIG9uZSAoZS5nLiBjb2xvcgpA QCAtNjk1LDYxICs3NjAsNjEgQEAgU3RyaW5nIENTU1ByaW1pdGl2ZVZhbHVlOjpjc3NUZXh0KCkg Y29uc3QKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19OVU1CRVI6CiAgICAg ICAgIGNhc2UgQ1NTX1BBUlNFUl9JTlRFR0VSOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6 bnVtYmVyKG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMo bV92YWx1ZS5udW0sICIiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19Q RVJDRU5UQUdFOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZyUlIiwg bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVl Lm51bSwgIiUiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19FTVM6Ci0g ICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZW0iLCBtX3ZhbHVlLm51bSk7 CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiZW0iKTsK ICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19FWFM6Ci0gICAgICAgICAgICB0 ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZXgiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAg ICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiZXgiKTsKICAgICAgICAgICAg IGJyZWFrOwogICAgICAgICBjYXNlIENTU19SRU1TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ3JlbSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBm b3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJyZW0iKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19QWDoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgi JS42bGdweCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5p dHMobV92YWx1ZS5udW0sICJweCIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2Ug Q1NTX0NNOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ2NtIiwgbV92 YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51 bSwgImNtIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfTU06Ci0gICAg ICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnbW0iLCBtX3ZhbHVlLm51bSk7Cisg ICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAibW0iKTsKICAg ICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19JTjoKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdpbiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJpbiIpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgQ1NTX1BUOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9y bWF0KCIlLjZsZ3B0IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdp dGhVbml0cyhtX3ZhbHVlLm51bSwgInB0Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAg Y2FzZSBDU1NfUEM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxncGMi LCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFs dWUubnVtLCAicGMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19ERUc6 Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnZGVnIiwgbV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImRl ZyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1JBRDoKLSAgICAgICAg ICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdyYWQiLCBtX3ZhbHVlLm51bSk7CisgICAg ICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAicmFkIik7CiAgICAg ICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfR1JBRDoKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdncmFkIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAg dGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImdyYWQiKTsKICAgICAgICAgICAg IGJyZWFrOwogICAgICAgICBjYXNlIENTU19NUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6 OmZvcm1hdCgiJS42bGdtcyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3Jt YXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJtcyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAg ICAgIGNhc2UgQ1NTX1M6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxn cyIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92 YWx1ZS5udW0sICJzIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfSFo6 Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnaHoiLCBtX3ZhbHVlLm51 bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiaHoi KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19LSFo6Ci0gICAgICAgICAg ICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxna2h6IiwgbV92YWx1ZS5udW0pOworICAgICAg ICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImtoeiIpOwogICAgICAg ICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1RVUk46Ci0gICAgICAgICAgICB0ZXh0ID0g U3RyaW5nOjpmb3JtYXQoIiUuNmxndHVybiIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRl eHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJ0dXJuIik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfRElNRU5TSU9OOgogICAgICAgICAgICAgLy8gRklYTUU= 41131 2009-10-13 15:03:30 -0700 2010-06-11 10:28:45 -0700 stringify CSS units manually to match CSS spec bug-18994-20091013150328.patch text/plain 16180 evan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBhNzk5ZDY3Li4yMzUwMGMyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMDktMTAt MTMgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRmxvYXQgZm9ybWF0dGluZyBjaGFuZ2VzIGFm ZmVjdCB0aHJlZSB0ZXN0czoKKyAgICAgICAgLSBsYXJnZS1udW1iZXItcm91bmQtdHJpcCBub3cg cGFzc2VzCisgICAgICAgIC0gb3BhY2l0eS1mbG9hdCBub3cgcGFzc2VzIGFuZCBoYXMgbW9yZSB0 ZXN0IGNhc2VzCisgICAgICAgIC0gY29tcG91bmQtMmQtdHJhbnNmb3JtcyBvdXRwdXQgdHdlYWtl ZCBzbGlnaHRseQorICAgICAgICAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE4OTk0CisKKyAgICAgICAgKiBmYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91 bmQtdHJpcC1leHBlY3RlZC50eHQ6CisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1l eHBlY3RlZC50eHQ6CisgICAgICAgICogZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sOgorICAg ICAgICAqIHBsYXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dDog UmVtb3ZlZC4KKyAgICAgICAgKiB0cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMt ZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHRyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNm b3Jtcy5odG1sOgorCiAyMDA5LTEwLTA3ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9mYXN0L2Nzcy9sYXJnZS1udW1iZXItcm91bmQtdHJpcC1leHBlY3RlZC50eHQKaW5k ZXggYzljNmRjMS4uNDg3OTU0NCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9jc3MvbGFy Z2UtbnVtYmVyLXJvdW5kLXRyaXAtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv Y3NzL2xhcmdlLW51bWJlci1yb3VuZC10cmlwLWV4cGVjdGVkLnR4dApAQCAtMSArMSBAQAotRkFJ TDogcmVhZCA5MDAxMDAwMHB4IGJhY2sgYXMgOS4wMDFlKzA3cHgsIHJlYWQgYWdhaW4gYXMgMHB4 CitQQVNTOiByZWFkIDkwMDEwMDAwcHggYmFjayBhcyA5MDAxMDAwMHB4LCByZWFkIGFnYWluIGFz IDkwMDEwMDAwcHgKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxv YXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBl Y3RlZC50eHQKaW5kZXggZjY1YWQxZi4uNzk1YTJjNSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9jc3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKQEAgLTEsMyArMSwxNyBAQAogVGhpcyB0 ZXN0IHZlcmlmaWVzIHRoYXQgcmVhZGluZyBhIGZsb2F0aW5nLXBvaW50IG9wYWNpdHkgZnJvbSBD U1MgYXR0cmlidXRlcyBnZXRzIGJhY2sgYSBwcm9wZXJseS1mb3JtYXR0ZWQgZmxvYXQuIEltcHJv cGVybHkgaGFuZGxpbmcgbG9jYWxlcyB0aGF0IGNhdXNlIGRlY2ltYWxzIHRvIGJlIHdyaXR0ZW4g YXMgY29tbWFzIG1pZ2h0IGJyZWFrIGl0LgogCiBQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNT CitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCitQQVNTCisK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvY3NzL29wYWNpdHktZmxvYXQuaHRtbAppbmRleCAwZWYwNDU2Li44NDA1 YWViIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2Nzcy9vcGFjaXR5LWZsb2F0Lmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9jc3Mvb3BhY2l0eS1mbG9hdC5odG1sCkBAIC0xNSw5ICsx NSwzNCBAQCBpdC48L3A+CiA8YSBpZD0ndGVzdCcgc3R5bGU9J29wYWNpdHk6LjknPjwvYT4KIAog PHNjcmlwdD4KLXZhciBvcGFjaXR5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKS5z dHlsZS5vcGFjaXR5LnRvU3RyaW5nKCk7Ci1pZiAob3BhY2l0eSA9PSAnMC45JykKLSAgICBkb2N1 bWVudC53cml0ZSgnUEFTUycpOwotZWxzZQotICAgIGRvY3VtZW50LndyaXRlKCdGQUlMOiAnICsg b3BhY2l0eSk7Cit2YXIgdGVzdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0Jyk7CisK K2Z1bmN0aW9uIGRvVGVzdChleHBlY3RlZCwgaW5wdXQpIHsKKyAgICB0ZXN0LnN0eWxlLm9wYWNp dHkgPSBpbnB1dDsKKyAgICB2YXIgb3BhY2l0eSA9IHRlc3Quc3R5bGUub3BhY2l0eS50b1N0cmlu ZygpOworICAgIGlmIChvcGFjaXR5ID09IGV4cGVjdGVkKQorICAgICAgICBkb2N1bWVudC53cml0 ZSgnUEFTUycpOworICAgIGVsc2UKKyAgICAgICAgZG9jdW1lbnQud3JpdGUoJ0ZBSUw6IGV4cGVj dGVkICcgKyBleHBlY3RlZCArICcsIGdvdCAnICsgb3BhY2l0eSk7CisgICAgZG9jdW1lbnQud3Jp dGUoJzxicj4nKTsKK30KKwordmFyIHRlc3RzID0gW1snMC45JywgJzAuOSddLAorICAgICAgICAg ICAgIFsnOTg3NjU0MzIxOTgnLCAnOTg3NjU0MzIxOTgnXSwKKyAgICAgICAgICAgICBbJzk4NzAw MDAnLCAnOTg3MDAwMCddLAorICAgICAgICAgICAgIFsnMC4wMDAzMjEnLCAnMC4wMDAzMjEnXSwK KyAgICAgICAgICAgICBbJzUwLjAyJywgJzUwLjAyJ10sCisgICAgICAgICAgICAgLy8gQ2hlY2sg d2UgY2xpcCBwcmVjaXNpb24gdG8gc2l4IGRlY2ltYWxzLgorICAgICAgICAgICAgIFsnMTIzNC41 Njc4OTEnLCAnMTIzNC41Njc4OTEyMzQnXV07Citmb3IgKHZhciBpID0gMDsgaSA8IHRlc3RzLmxl bmd0aDsgaSsrKQorICAgIGRvVGVzdCh0ZXN0c1tpXVswXSwgdGVzdHNbaV1bMV0pOworCisvLyBU ZXN0IGEgdG9vLXNtYWxsIHZhbHVlLgorZG9UZXN0KCcwJywgJzAuMDAwMDAwMScpOworLy8gVGVz dCB0aGF0IGEgYmV5b25kLXByZWNpc2lvbiBkaWdpdCB3aWxsIGJlIHJvdW5kZWQgaW4uCitkb1Rl c3QoJzAuMDAwMDAxJywgJzAuMDAwMDAwOScpOworCisvLyBSdW4gdGhlIHRlc3QgbGlzdCBhZ2Fp biB3aXRoIG5lZ2F0aXZlcy4KK2ZvciAodmFyIGkgPSAwOyBpIDwgdGVzdHMubGVuZ3RoOyBpKysp CisgICAgZG9UZXN0KCctJyArIHRlc3RzW2ldWzBdLCAnLScgKyB0ZXN0c1tpXVsxXSk7CiA8L3Nj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9mYXN0L2Nzcy9vcGFj aXR5LWZsb2F0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9mYXN0L2Nz cy9vcGFjaXR5LWZsb2F0LWV4cGVjdGVkLnR4dApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggYjgxOTgzZC4uMDAwMDAwMAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZmFzdC9j c3Mvb3BhY2l0eS1mbG9hdC1leHBlY3RlZC50eHQKKysrIC9kZXYvbnVsbApAQCAtMSwzICswLDAg QEAKLVRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHJlYWRpbmcgYSBmbG9hdGluZy1wb2ludCBvcGFj aXR5IGZyb20gQ1NTIGF0dHJpYnV0ZXMgZ2V0cyBiYWNrIGEgcHJvcGVybHktZm9ybWF0dGVkIGZs b2F0LiBJbXByb3Blcmx5IGhhbmRsaW5nIGxvY2FsZXMgdGhhdCBjYXVzZSBkZWNpbWFscyB0byBi ZSB3cml0dGVuIGFzIGNvbW1hcyBtaWdodCBicmVhayBpdC4KLQotRkFJTDogMCw5CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvdHJhbnNmb3Jtcy8yZC9jb21wb3VuZC0yZC10cmFuc2Zv cm1zLWV4cGVjdGVkLnR4dAppbmRleCA1NTgzYmQwLi4wZjUyNzE2IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy90cmFuc2Zvcm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMtZXhwZWN0ZWQudHh0 CisrKyBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jtcy1l eHBlY3RlZC50eHQKQEAgLTYsMTIgKzYsMTIgQEAgdHJhbnNmb3JtICJzY2FsZSgxLjcpIiBleHBl Y3RlZCAibWF0cml4KDEuNywgMCwgMCwgMS43LCAwLCAwKSIgOiBQQVNTCiB0cmFuc2Zvcm0gInNr ZXcoMTJkZWcpIiBleHBlY3RlZCAibWF0cml4KDEsIDAsIDAuMjEyNTU3LCAxLCAwLCAwKSIgOiBQ QVNTCiB0cmFuc2Zvcm0gIm1hdHJpeCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwgMC45 NzgxNDgsIDUwLCAyMCkiIGV4cGVjdGVkICJtYXRyaXgoMC45NzgxNDgsIDAuMjA3OTEyLCAtMC4y MDc5MTIsIDAuOTc4MTQ4LCA1MCwgMjApIiA6IFBBU1MKIHRyYW5zZm9ybSAidHJhbnNsYXRlKDUw cHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykiIGV4cGVjdGVkICJtYXRyaXgoMC45NzgxNDgsIDAuMjA3 OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA1MCwgMjApIiA6IFBBU1MKLXRyYW5zZm9ybSAicm90 YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkiIGV4cGVjdGVkICJtYXRyaXgoMC45Nzgx NDgsIDAuMjA3OTEyLCAtMC4yMDc5MTIsIDAuOTc4MTQ4LCA0NC43NDkxLCAyOS45NTg1KSIgOiBQ QVNTCi10cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIHNjYWxl KDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4z Njk0MSwgNDQuNzQ5MSwgMjkuOTU4NSkiIDogUEFTUwotdHJhbnNmb3JtICJzY2FsZSgxLjQpIHJv dGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpICIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2 OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQxLCA2Mi42NDg4LCA0MS45NDIpIiA6IFBB U1MKLXRyYW5zZm9ybSAic2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90YXRlKDEy ZGVnKSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjM2OTQxLCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2 OTQxLCA3MCwgMjgpIiA6IFBBU1MKLXRyYW5zZm9ybSAidHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJv dGF0ZSgxMmRlZykgdHJhbnNsYXRlWSg1MHB4KSBzY2FsZSgxLjQpIiBleHBlY3RlZCAibWF0cml4 KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDM5LjYwNDQsIDY4LjkwNzQp IiA6IFBBU1MKLXRyYW5zZm9ybSAicm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkg c2NhbGUoMS40KSB0cmFuc2xhdGUoLTgwcHgsIDQwcHgpIHNrZXcoMzRkZWcpIHRyYW5zbGF0ZSgx MHB4LCAxMHB4KSBzY2FsZSgwLjcpIHNrZXdZKC0yNWRlZykgcm90YXRlKDIxZGVnKSB0cmFuc2xh dGVYKDUwcHgpIHNjYWxlKDEuNCwgMS44KSIgZXhwZWN0ZWQgIm1hdHJpeCgxLjIwNTE3LCAwLjE0 ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQsIC0xMy4zODQ3LCA4NS4zMSkiIDogUEFTUwordHJhbnNm b3JtICJyb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm1hdHJp eCgwLjk3ODE0OCwgMC4yMDc5MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDQ0Ljc0OTE0NiwgMjku OTU4NTM3KSIgOiBQQVNTCit0cmFuc2Zvcm0gInJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgs IDIwcHgpIHNjYWxlKDEuNCkiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MDcsIDAuMjkxMDc2LCAt MC4yOTEwNzYsIDEuMzY5NDA3LCA0NC43NDkxNDYsIDI5Ljk1ODUzNykiIDogUEFTUwordHJhbnNm b3JtICJzY2FsZSgxLjQpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpICIgZXhw ZWN0ZWQgIm1hdHJpeCgxLjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MDcsIDYy LjY0ODgwNSwgNDEuOTQxOTUxKSIgOiBQQVNTCit0cmFuc2Zvcm0gInNjYWxlKDEuNCkgdHJhbnNs YXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykiIGV4cGVjdGVkICJtYXRyaXgoMS4zNjk0MDcs IDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDA3LCA3MCwgMjgpIiA6IFBBU1MKK3RyYW5zZm9y bSAidHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlWSg1MHB4KSBz Y2FsZSgxLjQpIiBleHBlY3RlZCAibWF0cml4KDEuMzY5NDA3LCAwLjI5MTA3NiwgLTAuMjkxMDc2 LCAxLjM2OTQwNywgMzkuNjA0NDE1LCA2OC45MDczOCkiIDogUEFTUwordHJhbnNmb3JtICJyb3Rh dGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpIHRyYW5zbGF0ZSgtODBw eCwgNDBweCkgc2tldygzNGRlZykgdHJhbnNsYXRlKDEwcHgsIDEwcHgpIHNjYWxlKDAuNykgc2tl d1koLTI1ZGVnKSByb3RhdGUoMjFkZWcpIHRyYW5zbGF0ZVgoNTBweCkgc2NhbGUoMS40LCAxLjgp IiBleHBlY3RlZCAibWF0cml4KDEuMjA1MTY2LCAwLjE0ODIwNywgMC4yNTg5ODcsIDIuMDQwMDQ0 LCAtMTMuMzg0NzIzLCA4NS4zMDk5NjcpIiA6IFBBU1MKIHRyYW5zZm9ybSAiLHJvdGF0ZSgxMmRl ZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpIiBleHBlY3RlZCAibm9uZSIgOiBQQVNTCiB0cmFuc2Zv cm0gInJvdGF0ZSgxMmRlZyksIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSIgZXhwZWN0ZWQgIm5vbmUi IDogUEFTUwogdHJhbnNmb3JtICJyb3RhdGUoMTJkZWcpICsgdHJhbnNsYXRlKDUwcHgsIDIwcHgp IiBleHBlY3RlZCAibm9uZSIgOiBQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy90cmFuc2Zv cm1zLzJkL2NvbXBvdW5kLTJkLXRyYW5zZm9ybXMuaHRtbCBiL0xheW91dFRlc3RzL3RyYW5zZm9y bXMvMmQvY29tcG91bmQtMmQtdHJhbnNmb3Jtcy5odG1sCmluZGV4IDE2MDAzYzMuLjdhYTY2OTEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJhbnNm b3Jtcy5odG1sCisrKyBiL0xheW91dFRlc3RzL3RyYW5zZm9ybXMvMmQvY29tcG91bmQtMmQtdHJh bnNmb3Jtcy5odG1sCkBAIC00MywxNyArNDMsMTcgQEAKICAgICAgIAogICAgICAgLy8gdHdvIGZ1 bmN0aW9ucwogICAgICAgeyAndHJhbnNmb3JtJyA6ICd0cmFuc2xhdGUoNTBweCwgMjBweCkgcm90 YXRlKDEyZGVnKScsICAgICAgICAgICdyZXN1bHQnIDogJ21hdHJpeCgwLjk3ODE0OCwgMC4yMDc5 MTIsIC0wLjIwNzkxMiwgMC45NzgxNDgsIDUwLCAyMCknIH0sCi0gICAgICB7ICd0cmFuc2Zvcm0n IDogJ3JvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpJywgICAgICAgICAgJ3Jlc3Vs dCcgOiAnbWF0cml4KDAuOTc4MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwgNDQu NzQ5MSwgMjkuOTU4NSknIH0sCisgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3JvdGF0ZSgxMmRlZykg dHJhbnNsYXRlKDUwcHgsIDIwcHgpJywgICAgICAgICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDAuOTc4 MTQ4LCAwLjIwNzkxMiwgLTAuMjA3OTEyLCAwLjk3ODE0OCwgNDQuNzQ5MTQ2LCAyOS45NTg1Mzcp JyB9LAogCiAgICAgICAvLyB0aHJlZSBmdW5jdGlvbnMKLSAgICAgIHsgJ3RyYW5zZm9ybScgOiAn cm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KScsICAgJ3Jlc3Vs dCcgOiAnbWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDEsIDQ0Ljc0 OTEsIDI5Ljk1ODUpJyB9LAotICAgICAgeyAndHJhbnNmb3JtJyA6ICdzY2FsZSgxLjQpIHJvdGF0 ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIwcHgpICcsICAncmVzdWx0JyA6ICdtYXRyaXgoMS4z Njk0MSwgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MSwgNjIuNjQ4OCwgNDEuOTQyKScgfSwK LSAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSB0cmFuc2xhdGUoNTBweCwgMjBweCkg cm90YXRlKDEyZGVnKScsICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAt MC4yOTEwNzYsIDEuMzY5NDEsIDcwLCAyOCknIH0sCi0gICAgICB7ICd0cmFuc2Zvcm0nIDogJ3Ry YW5zbGF0ZSg1MHB4LCAyMHB4KSByb3RhdGUoMTJkZWcpIHRyYW5zbGF0ZVkoNTBweCkgc2NhbGUo MS40KScsICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NDEsIDAuMjkxMDc2LCAtMC4yOTEwNzYs IDEuMzY5NDEsIDM5LjYwNDQsIDY4LjkwNzQpJyB9LAorICAgICAgeyAndHJhbnNmb3JtJyA6ICdy b3RhdGUoMTJkZWcpIHRyYW5zbGF0ZSg1MHB4LCAyMHB4KSBzY2FsZSgxLjQpJywgICAncmVzdWx0 JyA6ICdtYXRyaXgoMS4zNjk0MDcsIDAuMjkxMDc2LCAtMC4yOTEwNzYsIDEuMzY5NDA3LCA0NC43 NDkxNDYsIDI5Ljk1ODUzNyknIH0sCisgICAgICB7ICd0cmFuc2Zvcm0nIDogJ3NjYWxlKDEuNCkg cm90YXRlKDEyZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgJywgICdyZXN1bHQnIDogJ21hdHJp eCgxLjM2OTQwNywgMC4yOTEwNzYsIC0wLjI5MTA3NiwgMS4zNjk0MDcsIDYyLjY0ODgwNSwgNDEu OTQxOTUxKScgfSwKKyAgICAgIHsgJ3RyYW5zZm9ybScgOiAnc2NhbGUoMS40KSB0cmFuc2xhdGUo NTBweCwgMjBweCkgcm90YXRlKDEyZGVnKScsICAgJ3Jlc3VsdCcgOiAnbWF0cml4KDEuMzY5NDA3 LCAwLjI5MTA3NiwgLTAuMjkxMDc2LCAxLjM2OTQwNywgNzAsIDI4KScgfSwKKyAgICAgIHsgJ3Ry YW5zZm9ybScgOiAndHJhbnNsYXRlKDUwcHgsIDIwcHgpIHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRl WSg1MHB4KSBzY2FsZSgxLjQpJywgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4zNjk0MDcsIDAuMjkx MDc2LCAtMC4yOTEwNzYsIDEuMzY5NDA3LCAzOS42MDQ0MTUsIDY4LjkwNzM4KScgfSwKIAogICAg ICAgLy8gbG90cyBvZiBmdW5jdGlvbnMKICAgICAgIHsgJ3RyYW5zZm9ybScgOiAncm90YXRlKDEy ZGVnKSB0cmFuc2xhdGUoNTBweCwgMjBweCkgc2NhbGUoMS40KSB0cmFuc2xhdGUoLTgwcHgsIDQw cHgpIHNrZXcoMzRkZWcpIHRyYW5zbGF0ZSgxMHB4LCAxMHB4KSBzY2FsZSgwLjcpIHNrZXdZKC0y NWRlZykgcm90YXRlKDIxZGVnKSB0cmFuc2xhdGVYKDUwcHgpIHNjYWxlKDEuNCwgMS44KScsIAot ICAgICAgICAncmVzdWx0JyA6ICdtYXRyaXgoMS4yMDUxNywgMC4xNDgyMDcsIDAuMjU4OTg3LCAy LjA0MDA0LCAtMTMuMzg0NywgODUuMzEpJyB9LAorICAgICAgICAncmVzdWx0JyA6ICdtYXRyaXgo MS4yMDUxNjYsIDAuMTQ4MjA3LCAwLjI1ODk4NywgMi4wNDAwNDQsIC0xMy4zODQ3MjMsIDg1LjMw OTk2NyknIH0sCiAgICAgICAgIAogICAgICAgLy8gaW52YWxpZCBjb21wb3VuZCBmdW5jdGlvbnMK ICAgICAgIHsgJ3RyYW5zZm9ybScgOiAnLHJvdGF0ZSgxMmRlZykgdHJhbnNsYXRlKDUwcHgsIDIw cHgpJywgJ3Jlc3VsdCcgOiAnbm9uZScgfSwgLy8gaGFzIGNvbW1hCmRpZmYgLS1naXQgYS9XZWJD b3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDJiNDViMDMuLmYzYWFkYTkg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTcgQEAKKzIwMDktMTAtMTMgIEV2YW4gTWFydGluICA8ZXZhbkBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3Ry aW5naWZ5IENTUyB1bml0cyBtYW51YWxseSAod2l0aG91dCBwcmludGYpIHRvIG1ha2UgdGhlIGZv cm1hdHRpbmcKKyAgICAgICAgbG9jYWxlLWluc2Vuc2l0aXZlIGFuZCBvYmV5IENTUyBzcGVjIHdp dGggcmVzcGVjdCB0byBsYXJnZSB2YWx1ZXMuCisgICAgICAgIAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg5OTQKKworICAgICAgICAqIGNzcy9DU1NQ cmltaXRpdmVWYWx1ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjphcHBlbmRDU1NEb3VibGUpOgor ICAgICAgICAoV2ViQ29yZTo6Zm9ybWF0V2l0aFVuaXRzKToKKyAgICAgICAgKFdlYkNvcmU6OkNT U1ByaW1pdGl2ZVZhbHVlOjpjc3NUZXh0KToKKwogMjAwOS0xMC0wNyAgQWFyb24gQm9vZG1hbiAg PGFhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwIGIvV2ViQ29yZS9jc3Mv Q1NTUHJpbWl0aXZlVmFsdWUuY3BwCmluZGV4IDFmMmM5Y2EuLmJmMzc3ZTUgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9DU1NQ cmltaXRpdmVWYWx1ZS5jcHAKQEAgLTY4NCw2ICs2ODQsNzEgQEAgaW50IENTU1ByaW1pdGl2ZVZh bHVlOjpnZXRJZGVudCgpCiAgICAgcmV0dXJuIG1fdmFsdWUuaWRlbnQ7CiB9CiAKK3N0YXRpYyB2 b2lkIGFwcGVuZENTU0RvdWJsZShWZWN0b3I8VUNoYXI+JiB2ZWN0b3IsIGRvdWJsZSB2YWx1ZSkK K3sKKyAgICAvLyBGcm9tIHRoZSBDU1Mgc3BlY2lmaWNhdGlvbiBzZWN0aW9uIHRpdGxlZCAiSW50 ZWdlcnMgYW5kIHJlYWwgbnVtYmVycyIsCisgICAgLy8gcmVhbCBudW1iZXJzIGFyZSBvbmx5IGZv cm1hdHRlZCBhcyBbc2lnbl0gW2RpZ2l0c10gIi4iIFtkaWdpdHNdLgorICAgIC8vIFRoaXMgZGlm ZmVycyBmcm9tIHByaW50Zi1zdHlsZSBmb3JtYXR0aW5nIGluIHRoYXQgZXhwb25lbnRzIChlLmcu IDEuM2UwNikKKyAgICAvLyBhcmUgbm90IGFsbG93ZWQuICBTaW5jZSBOYU4vaW5mIGFyZSBhbHNv IG5vdCB2YWxpZCBDU1MgdmFsdWVzIHRoaXMKKyAgICAvLyBmdW5jdGlvbiBkb2Vzbid0IGhhbmRs ZSB0aGVtLgorCisgICAgLy8gRm9yIGNvbXBhdGliaWxpdHkgd2l0aCB3aGF0IHdhcyByZXR1cm5l ZCBieSBvbGRlciB2ZXJzaW9ucyBvZgorICAgIC8vIFdlYktpdCwgd2UgdGFyZ2V0IDYgZGlnaXRz IG9mIHByZWNpc2lvbi4KKyAgICBjb25zdCBpbnQgZGlnaXRzQWZ0ZXJEZWNpbWFsUG9pbnQgPSA2 OworICAgIGxvbmcgbG9uZyByb3VuZGVkID0gbGxyb3VuZChmYWJzKHZhbHVlKSAqIDEwMDAwMDAu MCk7CisgICAgaWYgKHJvdW5kZWQgPT0gMCkgeworICAgICAgICB2ZWN0b3IuYXBwZW5kKCcwJyk7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBjaGFyIGJ1ZlsyNF07CisgICAgaW50IGxl bmd0aCA9IHNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlbGxkIiwgcm91bmRlZCk7CisgICAg aW50IGRlY2ltYWxQb2ludCA9IGxlbmd0aCAtIGRpZ2l0c0FmdGVyRGVjaW1hbFBvaW50OworCisg ICAgLy8gV2UgYXJlIG1hdGNoaW5nIHByaW50ZigiJWciKSdzIGJlaGF2aW9yIGFuZCBtdXN0IHRy aW0gdHJhaWxpbmcgemVyb3MsCisgICAgLy8gcmVnYXJkbGVzcyBvZiB3aGV0aGVyIHRoZXkncmUg c2lnbmlmaWNhbnQuCisgICAgd2hpbGUgKGxlbmd0aCA+IDAgJiYgbGVuZ3RoID4gZGVjaW1hbFBv aW50ICYmIGJ1ZltsZW5ndGggLSAxXSA9PSAnMCcpCisgICAgICAgIGxlbmd0aC0tOworCisgICAg Ly8gUmVzZXJ2ZSBhbiBlc3RpbWF0ZSBvZiBzcGFjZSBmb3IgdGhlIG51bWJlciBvZiBkaWdpdHMg d2UgYW50aWNpcGF0ZQorICAgIC8vIGFsb25nIHdpdGggYSBtaW51cyBzaWduL2luaXRpYWwgemVy by9kZWNpbWFsIHBvaW50LgorICAgIHZlY3Rvci5yZXNlcnZlQ2FwYWNpdHkodmVjdG9yLnNpemUo KSArIDMgKyBsZW5ndGgpOworCisgICAgaWYgKHZhbHVlIDwgMCkKKyAgICAgICAgdmVjdG9yLmFw cGVuZCgnLScpOworCisgICAgaWYgKGRlY2ltYWxQb2ludCA8PSAwKSB7CisgICAgICAgIC8vIE9u bHkgZGlnaXRzIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LgorICAgICAgICB2ZWN0b3IuYXBwZW5k KCcwJyk7CisgICAgICAgIHZlY3Rvci5hcHBlbmQoJy4nKTsKKyAgICAgICAgZm9yIChpbnQgaSA9 IGRlY2ltYWxQb2ludDsgaSA8IDA7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBlbmQoJzAn KTsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW5ndGg7IGkrKykKKyAgICAgICAgICAg IHZlY3Rvci5hcHBlbmQoYnVmW2ldKTsKKyAgICB9IGVsc2UgaWYgKGxlbmd0aCA8PSBkZWNpbWFs UG9pbnQpIHsKKyAgICAgICAgLy8gT25seSBkaWdpdHMgYmVmb3JlIHRoZSBkZWNpbWFsIHBvaW50 LgorICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQorICAgICAgICAgICAg dmVjdG9yLmFwcGVuZChidWZbaV0pOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIERpZ2l0cyBi ZWZvcmUgYW5kIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LgorICAgICAgICBmb3IgKGludCBpID0g MDsgaSA8IGRlY2ltYWxQb2ludDsgaSsrKQorICAgICAgICAgICAgdmVjdG9yLmFwcGVuZChidWZb aV0pOworICAgICAgICB2ZWN0b3IuYXBwZW5kKCcuJyk7CisgICAgICAgIGZvciAoaW50IGkgPSBk ZWNpbWFsUG9pbnQ7IGkgPCBsZW5ndGg7IGkrKykKKyAgICAgICAgICAgIHZlY3Rvci5hcHBlbmQo YnVmW2ldKTsKKyAgICB9Cit9CisKK3N0YXRpYyBTdHJpbmcgZm9ybWF0V2l0aFVuaXRzKGRvdWJs ZSB2YWx1ZSwgY29uc3QgY2hhciogdW5pdHMpCit7CisgICAgVmVjdG9yPFVDaGFyPiByZXN1bHQ7 CisgICAgYXBwZW5kQ1NTRG91YmxlKHJlc3VsdCwgdmFsdWUpOworICAgIHJlc3VsdC5yZXNlcnZl Q2FwYWNpdHkocmVzdWx0LnNpemUoKSArIHN0cmxlbih1bml0cykpOworICAgIGZvciAoaW50IGkg PSAwOyB1bml0c1tpXTsgaSsrKQorICAgICAgICByZXN1bHQuYXBwZW5kKHVuaXRzW2ldKTsKKyAg ICByZXR1cm4gU3RyaW5nOjphZG9wdChyZXN1bHQpOworfQorCiBTdHJpbmcgQ1NTUHJpbWl0aXZl VmFsdWU6OmNzc1RleHQoKSBjb25zdAogewogICAgIC8vIEZJWE1FOiByZXR1cm4gdGhlIG9yaWdp bmFsIHZhbHVlIGluc3RlYWQgb2YgYSBnZW5lcmF0ZWQgb25lIChlLmcuIGNvbG9yCkBAIC02OTUs NjEgKzc2MCw2MSBAQCBTdHJpbmcgQ1NTUHJpbWl0aXZlVmFsdWU6OmNzc1RleHQoKSBjb25zdAog ICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX05VTUJFUjoKICAgICAgICAgY2Fz ZSBDU1NfUEFSU0VSX0lOVEVHRVI6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpudW1iZXIo bV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVl Lm51bSwgIiIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1BFUkNFTlRB R0U6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnJSUiLCBtX3ZhbHVl Lm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAi JSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0VNUzoKLSAgICAgICAg ICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdlbSIsIG1fdmFsdWUubnVtKTsKKyAgICAg ICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJlbSIpOwogICAgICAg ICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0VYUzoKLSAgICAgICAgICAgIHRleHQgPSBT dHJpbmc6OmZvcm1hdCgiJS42bGdleCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQg PSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJleCIpOwogICAgICAgICAgICAgYnJlYWs7 CiAgICAgICAgIGNhc2UgQ1NTX1JFTVM6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3Jt YXQoIiUuNmxncmVtIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdp dGhVbml0cyhtX3ZhbHVlLm51bSwgInJlbSIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGNhc2UgQ1NTX1BYOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3B4 IiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3Zh bHVlLm51bSwgInB4Iik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfQ006 Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUuNmxnY20iLCBtX3ZhbHVlLm51 bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiY20i KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19NTToKLSAgICAgICAgICAg IHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdtbSIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAg ICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJtbSIpOwogICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0lOOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2luIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgImluIik7CiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfUFQ6Ci0gICAgICAgICAgICB0ZXh0ID0gU3RyaW5nOjpmb3JtYXQoIiUu NmxncHQiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRz KG1fdmFsdWUubnVtLCAicHQiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19QQzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdwYyIsIG1fdmFs dWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0s ICJwYyIpOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0RFRzoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdkZWciLCBtX3ZhbHVlLm51bSk7Cisg ICAgICAgICAgICB0ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiZGVnIik7CiAg ICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUkFEOgotICAgICAgICAgICAgdGV4 dCA9IFN0cmluZzo6Zm9ybWF0KCIlLjZsZ3JhZCIsIG1fdmFsdWUubnVtKTsKKyAgICAgICAgICAg IHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJyYWQiKTsKICAgICAgICAgICAg IGJyZWFrOwogICAgICAgICBjYXNlIENTU19HUkFEOgotICAgICAgICAgICAgdGV4dCA9IFN0cmlu Zzo6Zm9ybWF0KCIlLjZsZ2dyYWQiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0ZXh0ID0g Zm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAiZ3JhZCIpOwogICAgICAgICAgICAgYnJlYWs7 CiAgICAgICAgIGNhc2UgQ1NTX01TOgotICAgICAgICAgICAgdGV4dCA9IFN0cmluZzo6Zm9ybWF0 KCIlLjZsZ21zIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhV bml0cyhtX3ZhbHVlLm51bSwgIm1zIik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2Fz ZSBDU1NfUzoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdzIiwgbV92 YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZvcm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51 bSwgInMiKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19IWjoKLSAgICAg ICAgICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiJS42bGdoeiIsIG1fdmFsdWUubnVtKTsKKyAg ICAgICAgICAgIHRleHQgPSBmb3JtYXRXaXRoVW5pdHMobV92YWx1ZS5udW0sICJoeiIpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0tIWjoKLSAgICAgICAgICAgIHRleHQg PSBTdHJpbmc6OmZvcm1hdCgiJS42bGdraHoiLCBtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ID0gZm9ybWF0V2l0aFVuaXRzKG1fdmFsdWUubnVtLCAia2h6Iik7CiAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBDU1NfVFVSTjoKLSAgICAgICAgICAgIHRleHQgPSBTdHJpbmc6 OmZvcm1hdCgiJS42bGd0dXJuIiwgbV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCA9IGZv cm1hdFdpdGhVbml0cyhtX3ZhbHVlLm51bSwgInR1cm4iKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIENTU19ESU1FTlNJT046CiAgICAgICAgICAgICAvLyBGSVhNRQ== 70394 2010-10-10 04:59:02 -0700 2010-10-16 13:45:29 -0700 Work in progress StringNumber.diff text/plain 2065 zimmermann SW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmNwcAkocmV2aXNpb24gNjk0NjQp CisrKyBKYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0yNSwxMCArMjUsMTAgQEAKICNpbmNsdWRlIDxsaW1pdHM+CiAjaW5jbHVkZSA8c3RkYXJn Lmg+CiAjaW5jbHVkZSA8d3RmL0FTQ0lJQ1R5cGUuaD4KKyNpbmNsdWRlIDx3dGYvRGVjaW1hbE51 bWJlci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvU3Ry aW5nRXh0cmFzLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgotI2luY2x1ZGUgPHd0Zi9kdG9h Lmg+CiAjaW5jbHVkZSA8d3RmL3VuaWNvZGUvVVRGOC5oPgogI2luY2x1ZGUgPHd0Zi91bmljb2Rl L1VuaWNvZGUuaD4KIApAQCAtNDUzLDkgKzQ1Myw0MyBAQCBTdHJpbmcgU3RyaW5nOjpudW1iZXIo dW5zaWduZWQgbG9uZyBsb25nCiAjZW5kaWYKIH0KICAgICAKLVN0cmluZyBTdHJpbmc6Om51bWJl cihkb3VibGUgbikKK1N0cmluZyBTdHJpbmc6Om51bWJlcihkb3VibGUgbnVtYmVyKQogewotICAg IHJldHVybiBTdHJpbmc6OmZvcm1hdCgiJS42bGciLCBuKTsKKyAgICAvLyBNaW1pY3MgdGhlIG91 dHB1dCBvZiBTdHJpbmc6OmZvcm1hdCgiJS42bGciLCBuKSwgYnV0IGFwcGxpZXMgcm91bmRpbmcg dG8gNiBzaWduaWZpY2FudCBmaWd1cmVzLgorICAgIHN0YXRpYyBjb25zdCBpbnQgc19zaWduaWZp Y2FudEZpZ3VyZXMgPSA2OworICAgIE51bWJlclRvU3RyaW5nQnVmZmVyIGJ1ZmZlcjsKKworICAg IERlY2ltYWxOdW1iZXIgZGVjaW1hbE51bWJlcihudW1iZXIsIFJvdW5kaW5nU2lnbmlmaWNhbnRG aWd1cmVzLCBzX3NpZ25pZmljYW50RmlndXJlcyk7CisgICAgaWYgKGRlY2ltYWxOdW1iZXIuZXhw b25lbnQoKSA8IC1zX3NpZ25pZmljYW50RmlndXJlcyB8fCBkZWNpbWFsTnVtYmVyLmV4cG9uZW50 KCkgPiBzX3NpZ25pZmljYW50RmlndXJlcykgeworICAgICAgICB1bnNpZ25lZCBsZW5ndGggPSBk ZWNpbWFsTnVtYmVyLnRvU3RyaW5nRXhwb25lbnRpYWwoYnVmZmVyKTsKKyAgICAgICAgcmV0dXJu IFN0cmluZyhidWZmZXIsIGxlbmd0aCk7CisgICAgfQorCisgICAgdW5zaWduZWQgbGVuZ3RoID0g ZGVjaW1hbE51bWJlci50b1N0cmluZ0RlY2ltYWwoYnVmZmVyKTsKKyAgICBBU1NFUlQobGVuZ3Ro ID4gMCk7CisKKyAgICAvLyBMb29rdXAgZmxvYXRpbmcgcG9pbnQgc2VwZXJhdG9yLgorICAgIHVu c2lnbmVkIHNlcGVyYXRvclBvc2l0aW9uID0gMDsKKyAgICBmb3IgKDsgc2VwZXJhdG9yUG9zaXRp b24gPCBsZW5ndGg7ICsrc2VwZXJhdG9yUG9zaXRpb24pIHsKKyAgICAgICAgaWYgKGJ1ZmZlcltz ZXBlcmF0b3JQb3NpdGlvbl0gPT0gJy4nKQorICAgICAgICAgICAgYnJlYWs7CisgICAgfQorCisg ICAgQVNTRVJUKHNlcGVyYXRvclBvc2l0aW9uIDwgbGVuZ3RoKTsKKworICAgIC8vIFdlIHdhbnQg dG8gdXNlIHRoZSBEZWNpbWFsTnVtYmVyIHJvdW5kaW5nIGZhY2lsaXRpZXMsIGJ1dCBjdXQgb2Zm CisgICAgLy8gdW5uY2Vzc2FyeSB0cmFpbGluZyB6ZXJvcyB0byBtaW5pbWl6ZSB0aGUgbGVuZ3Ro IG9mIHRoZSBzdHJpbmdzLgorICAgIHVuc2lnbmVkIHBvc2l0aW9uID0gbGVuZ3RoIC0gMTsKKyAg ICBmb3IgKDsgcG9zaXRpb24gPiBzZXBlcmF0b3JQb3NpdGlvbiA7IC0tcG9zaXRpb24pIHsKKyAg ICAgICAgaWYgKGJ1ZmZlcltwb3NpdGlvbl0gIT0gJzAnKQorICAgICAgICAgICAgYnJlYWs7Cisg ICAgfQorCisgICAgbGVuZ3RoID0gcG9zaXRpb247CisgICAgaWYgKHBvc2l0aW9uICE9IHNlcGVy YXRvclBvc2l0aW9uKQorICAgICAgICArK2xlbmd0aDsKKworICAgIHJldHVybiBTdHJpbmcoYnVm ZmVyLCBsZW5ndGgpOwogfQogCiBpbnQgU3RyaW5nOjp0b0ludFN0cmljdChib29sKiBvaywgaW50 IGJhc2UpIGNvbnN0Cg==