181196 2017-12-30 20:10:03 -0800 SVG lighting colors need to be converted into linearSRGB 2018-05-09 08:23:47 -0700 1 1 1 Unclassified WebKit SVG WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 181142 181147 181203 1 simon.fraser simon.fraser darin dbates dino ews-watchlist kondapallykalyan simon.fraser thorton webkit-bug-importer zimmermann oldest_to_newest 1384991 0 330263 simon.fraser 2017-12-30 20:10:03 -0800 Created attachment 330263 Testcase Attached test case shows that light colors are not correctly converted between sRGB and linearRGB. It should match a rect with a green fill. 1384993 1 330264 simon.fraser 2017-12-30 20:59:22 -0800 Created attachment 330264 Patch 1385012 2 330264 dbates 2017-12-31 19:08:14 -0800 Comment on attachment 330264 Patch All of the math and constants feels like magic. Is there any source we can reference for these algorithms? Can we use more universal initializer syntax (i.e. {} initialization)? 1385069 3 simon.fraser 2018-01-01 12:29:17 -0800 https://trac.webkit.org/r226315 1385230 4 webkit-bug-importer 2018-01-02 13:18:15 -0800 <rdar://problem/36261359> 1386613 5 330264 darin 2018-01-07 23:24:47 -0800 Comment on attachment 330264 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=330264&action=review > Source/WebCore/platform/graphics/ColorUtilities.cpp:47 > + if (c < 0.0031308) > + return 12.92 * c; > + > + return clampTo<float>(1.055 * powf(c, 1.0 / 2.4) - 0.055, 0, 1); I know you moved this code, but I never carefully reviewed it when it was in the transformColorSpace function. This code is doing a *lot* of conversion to double because all the constants here are doubles; if we want float constants we should use 1.0f rather than 1.0 for all six of these. But maybe we are converting to double intentionally because I do see the call to clampTo<float>? What I don’t understand, though, then is why we are using doubles in the first if statement as well, and also why we are using powf rather than the double version of pow if we are intended to do the arithmetic as doubles. Even if we do want the float version, std::pow is what we would normally use in C++ code; that’s overloaded based on the type of the arguments. I’d like to see some tests for these functions in API tests to make sure they are doing exactly what we want. > Source/WebCore/platform/graphics/ColorUtilities.cpp:55 > + if (c <= 0.04045) > + return c / 12.92; > + > + return clampTo<float>(powf((c + 0.055) / 1.055, 2.4), 0, 1); Ditto. > Source/WebCore/platform/graphics/ColorUtilities.cpp:58 > +Color linearToSRGBColor(const Color& color) This is a very peculiar function. In modern Color the Color contains information about what its current color space is. It’s not OK to have a non-Extended Color that is not actually sRGB. We should use something other than Color for that. We should discuss how to fix this from a design point of view. I suppose it can wait until I do my Color class improvements, which might take a while. 1386741 6 simon.fraser 2018-01-08 08:31:49 -0800 (In reply to Darin Adler from comment #5) > Comment on attachment 330264 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330264&action=review > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:47 > > + if (c < 0.0031308) > > + return 12.92 * c; > > + > > + return clampTo<float>(1.055 * powf(c, 1.0 / 2.4) - 0.055, 0, 1); > > I know you moved this code, but I never carefully reviewed it when it was in > the transformColorSpace function. > > This code is doing a *lot* of conversion to double because all the constants > here are doubles; if we want float constants we should use 1.0f rather than > 1.0 for all six of these. But maybe we are converting to double > intentionally because I do see the call to clampTo<float>? What I don’t > understand, though, then is why we are using doubles in the first if > statement as well, and also why we are using powf rather than the double > version of pow if we are intended to do the arithmetic as doubles. > > Even if we do want the float version, std::pow is what we would normally use > in C++ code; that’s overloaded based on the type of the arguments. > > I’d like to see some tests for these functions in API tests to make sure > they are doing exactly what we want. > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:55 > > + if (c <= 0.04045) > > + return c / 12.92; > > + > > + return clampTo<float>(powf((c + 0.055) / 1.055, 2.4), 0, 1); > > Ditto. These should probably just do float math. > > Source/WebCore/platform/graphics/ColorUtilities.cpp:58 > > +Color linearToSRGBColor(const Color& color) > > This is a very peculiar function. In modern Color the Color contains > information about what its current color space is. It’s not OK to have a > non-Extended Color that is not actually sRGB. We should use something other > than Color for that. We should discuss how to fix this from a design point > of view. I suppose it can wait until I do my Color class improvements, which > might take a while. I had the same thought when writing the, but ignored the voices in the back of my head! This could return FloatComponents or something. 1386889 7 330730 simon.fraser 2018-01-08 13:33:10 -0800 Created attachment 330730 Patch 1387266 8 330730 darin 2018-01-09 08:17:28 -0800 Comment on attachment 330730 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=330730&action=review > Source/WebCore/platform/graphics/ColorUtilities.cpp:53 > + return clampTo<float>(1.055f * powf(c, 1.0f / 2.4f) - 0.055f, 0, 1); Should use std::pow instead of powf. > Source/WebCore/platform/graphics/ColorUtilities.cpp:61 > + return clampTo<float>(powf((c + 0.055f) / 1.055f, 2.4f), 0, 1); Should use std::pow instead of powf. > Source/WebCore/platform/graphics/filters/FELighting.cpp:299 > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.x() * 255.0f), > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.y() * 255.0f), > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.z() * 255.0f) Shouldn’t this round instead of clamping? I’d also like to see us use a shared function for this. The function colorFloatToRGBAByte inside Color.cpp is the one I mean, although that may not be the right location nor name for it. 1387313 9 simon.fraser 2018-01-09 10:28:55 -0800 (In reply to Darin Adler from comment #8) > Comment on attachment 330730 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330730&action=review > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:53 > > + return clampTo<float>(1.055f * powf(c, 1.0f / 2.4f) - 0.055f, 0, 1); > > Should use std::pow instead of powf. > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:61 > > + return clampTo<float>(powf((c + 0.055f) / 1.055f, 2.4f), 0, 1); > > Should use std::pow instead of powf. > > > Source/WebCore/platform/graphics/filters/FELighting.cpp:299 > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.x() * 255.0f), > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.y() * 255.0f), > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.z() * 255.0f) > > Shouldn’t this round instead of clamping? For lighting, the spec doesn't say. For feTurbulence, it does say that you just multiply by 255 then clamp. I'll try to figure out what other browsers do. > I’d also like to see us use a > shared function for this. The function colorFloatToRGBAByte inside Color.cpp > is the one I mean, although that may not be the right location nor name for > it. Will look. 1422261 10 simon.fraser 2018-05-09 08:23:47 -0700 (In reply to Darin Adler from comment #8) > Comment on attachment 330730 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330730&action=review > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:53 > > + return clampTo<float>(1.055f * powf(c, 1.0f / 2.4f) - 0.055f, 0, 1); > > Should use std::pow instead of powf. > > > Source/WebCore/platform/graphics/ColorUtilities.cpp:61 > > + return clampTo<float>(powf((c + 0.055f) / 1.055f, 2.4f), 0, 1); > > Should use std::pow instead of powf. Both fixed. > > Source/WebCore/platform/graphics/filters/FELighting.cpp:299 > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.x() * 255.0f), > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.y() * 255.0f), > > + static_cast<uint8_t>(lightStrength * lightingData.colorVector.z() * 255.0f) > > Shouldn’t this round instead of clamping? I’d also like to see us use a > shared function for this. The function colorFloatToRGBAByte inside Color.cpp > is the one I mean, although that may not be the right location nor name for > it. I didn't change this; Filters code multiples by 255 in various places, and they all need review. 330263 2017-12-30 20:10:03 -0800 2017-12-30 20:10:03 -0800 Testcase fePointLight-color.svg image/svg+xml 430 simon.fraser PHN2ZyB3aWR0aD0iNDgwcHgiIGhlaWdodD0iNjAwcHgiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9y Zy8yMDAwL3N2ZyI+CjxkZWZzPgogICAgPGZpbHRlciBpZD0iZmlsdGVyIiBmaWx0ZXJVbml0cz0i b2JqZWN0Qm91bmRpbmdCb3giIHg9IjAiIHk9IjAiIHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUi PgogICAgICAgIDxmZURpZmZ1c2VMaWdodGluZyBsaWdodGluZy1jb2xvcj0icmdiKDAsIDEyOCwg MDApIj4KICAgICAgICAgICAgPGZlUG9pbnRMaWdodCB4PSIyMDAiIHk9IjIwMCIgej0iMjAwMDAw MDAiIC8+CiAgICAgICAgPC9mZURpZmZ1c2VMaWdodGluZz4KICAgIDwvZmlsdGVyPgo8L2RlZnM+ CjxyZWN0IGlkPSJ0YXJnZXQiIHg9IjAiIHk9IjAwIiB3aWR0aD0iNDAwIiBoZWlnaHQ9IjQwMCIg ZmlsdGVyPSJ1cmwoI2ZpbHRlcikiLz4KPC9zdmc+Cg== 330264 2017-12-30 20:59:22 -0800 2018-01-08 13:33:21 -0800 Patch bug-181196-20171230205921.patch text/plain 9338 simon.fraser U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2MTUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2Q0YmZmMzk4MWM5M2Rj ZjUxYjc3N2JjMjQwZTYzMzE3YTdmMWUxOS4uYjgwY2EyMzRkYzRjMzFlODQwMjJiZDhmMGM2NmUx ZmE1MmMzNTE1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE3LTEyLTMwICBTaW1v biBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgorCisgICAgICAgIFNWRyBsaWdodGlu ZyBjb2xvcnMgbmVlZCB0byBiZSBjb252ZXJ0ZWQgaW50byBsaW5lYXJTUkdCCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODExOTYKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTVkcgZmlsdGVycywgbGlrZSBm ZUxpZ2h0aW5nLCB0aGF0IHBva2UgdmFsdWVzIGRpcmVjdGx5IGludG8gYnVmZmVycyByYXRoZXIg dGhhbiBnb2luZworICAgICAgICB0aHJvdWdoIENHIGxpa2UgZmVGbG9vZCwgbmVlZCB0byBjb252 ZXJ0IGNvbG9ycyBpbnRvIHRoZSBvcGVyYXRpbmcgY29sb3Igc3BhY2UuIFNvIGFkZAorICAgICAg ICBjb252ZXJzaW9uIGZ1bmN0aW9ucyB0byBnbyBiZXR3ZWVuIGxpbmVhciBhbmQgc1JHQiBjb2xv cnMsIGFuZCB1c2UgdGhlc2UgaW4gZmVMaWdodGluZywKKyAgICAgICAgYW5kIGluIEltYWdlQnVm ZmVyICh3aGljaCBpcyBvbmx5IHVzZWQgZm9yIG5vbi1DRyBwbGF0Zm9ybXMpLgorCisgICAgICAg IFRlc3RzOiBzdmcvZmlsdGVycy9mZVNwb3RMaWdodC1jb2xvci5zdmcKKworICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL0NvbG9yVXRpbGl0aWVzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Omxp bmVhclRvU1JHQkNvbG9yQ29tcG9uZW50KToKKyAgICAgICAgKFdlYkNvcmU6OnNSR0JUb0xpbmVh ckNvbG9yQ29tcG9uZW50KToKKyAgICAgICAgKFdlYkNvcmU6OmxpbmVhclRvU1JHQkNvbG9yKToK KyAgICAgICAgKFdlYkNvcmU6OnNSR0JUb0xpbmVhckNvbG9yKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L0ltYWdlQnVmZmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlQnVmZmVyOjp0cmFuc2Zv cm1Db2xvclNwYWNlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZFTGln aHRpbmcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RkVMaWdodGluZzo6ZHJhd0xpZ2h0aW5nKToK KwogMjAxNy0xMi0xOSAgSmVyIE5vYmxlICA8amVyLm5vYmxlQGFwcGxlLmNvbT4KIAogICAgICAg ICBQbGF5aW5nIG1lZGlhIGVsZW1lbnRzIHdoaWNoIGNhbGwgInBhdXNlKCk7IHBsYXkoKSIgd2ls bCBoYXZlIHRoZSBwbGF5IHByb21pc2UgcmVqZWN0ZWQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5jcHAKaW5kZXggMTIxODFkN2ViMWY5 NzY2Y2VmZTUyMzY5OWRmYWYwZmNkNDkzMTE2Ny4uZTU2YTVmNzJiMzdmNzI0YzE3NGJkMjU1NjIy OWY0NzkxYWYxZTQ5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvQ29sb3JVdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL0NvbG9yVXRpbGl0aWVzLmNwcApAQCAtMjYsNiArMjYsOSBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIkNvbG9yVXRpbGl0aWVzLmgiCiAKKyNpbmNsdWRlICJDb2xvci5oIgor I2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogQ29s b3JDb21wb25lbnRzOjpDb2xvckNvbXBvbmVudHMoY29uc3QgRmxvYXRDb21wb25lbnRzJiBmbG9h dENvbXBvbmVudHMpCkBAIC0zNiw0ICszOSw0MiBAQCBDb2xvckNvbXBvbmVudHM6OkNvbG9yQ29t cG9uZW50cyhjb25zdCBGbG9hdENvbXBvbmVudHMmIGZsb2F0Q29tcG9uZW50cykKICAgICBjb21w b25lbnRzWzNdID0gY2xhbXBlZENvbG9yQ29tcG9uZW50KGZsb2F0Q29tcG9uZW50cy5jb21wb25l bnRzWzNdKTsKIH0KIAorZmxvYXQgbGluZWFyVG9TUkdCQ29sb3JDb21wb25lbnQoZmxvYXQgYykK K3sKKyAgICBpZiAoYyA8IDAuMDAzMTMwOCkKKyAgICAgICAgcmV0dXJuIDEyLjkyICogYzsKKwor ICAgIHJldHVybiBjbGFtcFRvPGZsb2F0PigxLjA1NSAqIHBvd2YoYywgMS4wIC8gMi40KSAtIDAu MDU1LCAwLCAxKTsKK30KKworZmxvYXQgc1JHQlRvTGluZWFyQ29sb3JDb21wb25lbnQoZmxvYXQg YykKK3sKKyAgICBpZiAoYyA8PSAwLjA0MDQ1KQorICAgICAgICByZXR1cm4gYyAvIDEyLjkyOwor CisgICAgcmV0dXJuIGNsYW1wVG88ZmxvYXQ+KHBvd2YoKGMgKyAwLjA1NSkgLyAxLjA1NSwgMi40 KSwgMCwgMSk7Cit9CisKK0NvbG9yIGxpbmVhclRvU1JHQkNvbG9yKGNvbnN0IENvbG9yJiBjb2xv cikKK3sKKyAgICBmbG9hdCByLCBnLCBiLCBhOworICAgIGNvbG9yLmdldFJHQkEociwgZywgYiwg YSk7CisgICAgciA9IGxpbmVhclRvU1JHQkNvbG9yQ29tcG9uZW50KHIpOworICAgIGcgPSBsaW5l YXJUb1NSR0JDb2xvckNvbXBvbmVudChnKTsKKyAgICBiID0gbGluZWFyVG9TUkdCQ29sb3JDb21w b25lbnQoYik7CisKKyAgICByZXR1cm4gQ29sb3IociwgZywgYiwgYSk7Cit9CisKK0NvbG9yIHNS R0JUb0xpbmVhckNvbG9yKGNvbnN0IENvbG9yJiBjb2xvcikKK3sKKyAgICBmbG9hdCByLCBnLCBi LCBhOworICAgIGNvbG9yLmdldFJHQkEociwgZywgYiwgYSk7CisgICAgciA9IHNSR0JUb0xpbmVh ckNvbG9yQ29tcG9uZW50KHIpOworICAgIGcgPSBzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudChn KTsKKyAgICBiID0gc1JHQlRvTGluZWFyQ29sb3JDb21wb25lbnQoYik7CisKKyAgICByZXR1cm4g Q29sb3IociwgZywgYiwgYSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0NvbG9yVXRpbGl0aWVzLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5oCmluZGV4IDMz MmY3MThjZDRhYjM5OTU4NzI5NzAwNDBjY2RkOWE0ZDkxNjI3Y2EuLjU0NTczZDc0MDQ1NGYzZWIy MThmMDNiMDQ3ZTM4OGI2ZDkyMWQxM2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL0NvbG9yVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvQ29sb3JVdGlsaXRpZXMuaApAQCAtMjUsNiArMjUsNyBAQAogCiAjcHJhZ21h IG9uY2UKIAorI2luY2x1ZGUgIkNvbG9yLmgiCiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1 ZGUgPG1hdGguaD4KIApAQCAtMTQ3LDUgKzE0OCwxMiBAQCBpbmxpbmUgdW5zaWduZWQgYnl0ZU9m ZnNldE9mUGl4ZWwodW5zaWduZWQgeCwgdW5zaWduZWQgeSwgdW5zaWduZWQgcm93Qnl0ZXMpCiAg ICAgcmV0dXJuIHggKiBieXRlc1BlclBpeGVsICsgeSAqIHJvd0J5dGVzOwogfQogCisvLyAwLTEg Y29tcG9uZW50cywgcmVzdWx0IGlzIGNsYW1wZWQuCitmbG9hdCBsaW5lYXJUb1NSR0JDb2xvckNv bXBvbmVudChmbG9hdCk7CitmbG9hdCBzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudChmbG9hdCk7 CisgICAgCitDb2xvciBsaW5lYXJUb1NSR0JDb2xvcihjb25zdCBDb2xvciYpOworQ29sb3Igc1JH QlRvTGluZWFyQ29sb3IoY29uc3QgQ29sb3ImKTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9JbWFnZUJ1ZmZl ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9JbWFnZUJ1ZmZlci5jcHAK aW5kZXggYTU2ZmQ4MjgyMmNjOTAwYjQyMDNkM2NjZGIwNTMwMDRkOGY4MjdkNi4uNDE0NWIyYjhm MWU0NjdkZTRkMmQ2ZTNiMjM4NTIzZGE4NTZmNmU4OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW1hZ2VCdWZmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL0ltYWdlQnVmZmVyLmNwcApAQCAtMjgsNiArMjgsNyBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkltYWdlQnVmZmVyLmgiCiAKKyNpbmNsdWRlICJD b2xvclV0aWxpdGllcy5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2luY2x1ZGUg IkludFJlY3QuaCIKICNpbmNsdWRlIDx3dGYvTWF0aEV4dHJhcy5oPgpAQCAtMTM1LDkgKzEzNiw3 IEBAIHZvaWQgSW1hZ2VCdWZmZXI6OnRyYW5zZm9ybUNvbG9yU3BhY2UoQ29sb3JTcGFjZSBzcmND b2xvclNwYWNlLCBDb2xvclNwYWNlIGRzdENvCiAgICAgICAgICAgICBzdGQ6OmFycmF5PHVpbnQ4 X3QsIDI1Nj4gYXJyYXk7CiAgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgMjU2 OyBpKyspIHsKICAgICAgICAgICAgICAgICBmbG9hdCBjb2xvciA9IGkgLyAyNTUuMGY7Ci0gICAg ICAgICAgICAgICAgY29sb3IgPSAoY29sb3IgPD0gMC4wNDA0NWYgPyBjb2xvciAvIDEyLjkyZiA6 IHBvdygoY29sb3IgKyAwLjA1NWYpIC8gMS4wNTVmLCAyLjRmKSk7Ci0gICAgICAgICAgICAgICAg Y29sb3IgPSBzdGQ6Om1heCgwLjBmLCBjb2xvcik7Ci0gICAgICAgICAgICAgICAgY29sb3IgPSBz dGQ6Om1pbigxLjBmLCBjb2xvcik7CisgICAgICAgICAgICAgICAgY29sb3IgPSBzUkdCVG9MaW5l YXJDb2xvckNvbXBvbmVudChjb2xvcik7CiAgICAgICAgICAgICAgICAgYXJyYXlbaV0gPSBzdGF0 aWNfY2FzdDx1aW50OF90Pihyb3VuZChjb2xvciAqIDI1NSkpOwogICAgICAgICAgICAgfQogICAg ICAgICAgICAgcmV0dXJuIGFycmF5OwpAQCAtMTQ4LDkgKzE0Nyw3IEBAIHZvaWQgSW1hZ2VCdWZm ZXI6OnRyYW5zZm9ybUNvbG9yU3BhY2UoQ29sb3JTcGFjZSBzcmNDb2xvclNwYWNlLCBDb2xvclNw YWNlIGRzdENvCiAgICAgICAgICAgICBzdGQ6OmFycmF5PHVpbnQ4X3QsIDI1Nj4gYXJyYXk7CiAg ICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgMjU2OyBpKyspIHsKICAgICAgICAg ICAgICAgICBmbG9hdCBjb2xvciA9IGkgLyAyNTUuMGY7Ci0gICAgICAgICAgICAgICAgY29sb3Ig PSAocG93Zihjb2xvciwgMS4wZiAvIDIuNGYpICogMS4wNTVmKSAtIDAuMDU1ZjsKLSAgICAgICAg ICAgICAgICBjb2xvciA9IHN0ZDo6bWF4KDAuMGYsIGNvbG9yKTsKLSAgICAgICAgICAgICAgICBj b2xvciA9IHN0ZDo6bWluKDEuMGYsIGNvbG9yKTsKKyAgICAgICAgICAgICAgICBjb2xvciA9IGxp bmVhclRvU1JHQkNvbG9yQ29tcG9uZW50KGNvbG9yKTsKICAgICAgICAgICAgICAgICBhcnJheVtp XSA9IHN0YXRpY19jYXN0PHVpbnQ4X3Q+KHJvdW5kKGNvbG9yICogMjU1KSk7CiAgICAgICAgICAg ICB9CiAgICAgICAgICAgICByZXR1cm4gYXJyYXk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZFTGlnaHRpbmcuY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZmlsdGVycy9GRUxpZ2h0aW5nLmNwcAppbmRleCAzMWUzMGY1 YzNlNzlhNmRjNmU2NDRkOGIxN2QyOGUxZDg3Y2IwZjk4Li40NDg2NWFmNmNmMDExMmI4NDA3MWNi Nzg2MjVmZjhhZGY4Y2RlOTJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9maWx0ZXJzL0ZFTGlnaHRpbmcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVMaWdodGluZy5jcHAKQEAgLTI3LDYgKzI3LDcgQEAKICNp bmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJGRUxpZ2h0aW5nLmgiCiAKKyNpbmNsdWRlICJD b2xvclV0aWxpdGllcy5oIgogI2luY2x1ZGUgIkZFTGlnaHRpbmdORU9OLmgiCiAjaW5jbHVkZSA8 d3RmL1BhcmFsbGVsSm9icy5oPgogCkBAIC0zOTcsNyArMzk4LDkgQEAgYm9vbCBGRUxpZ2h0aW5n OjpkcmF3TGlnaHRpbmcoVWludDhDbGFtcGVkQXJyYXkmIHBpeGVscywgaW50IHdpZHRoLCBpbnQg aGVpZ2h0KQogICAgIGRhdGEud2lkdGhNdWx0aXBsaWVkQnlQaXhlbFNpemUgPSB3aWR0aCAqIGNQ aXhlbFNpemU7CiAgICAgZGF0YS53aWR0aERlY3JlYXNlZEJ5T25lID0gd2lkdGggLSAxOwogICAg IGRhdGEuaGVpZ2h0RGVjcmVhc2VkQnlPbmUgPSBoZWlnaHQgLSAxOwotICAgIHBhaW50aW5nRGF0 YS5pbnRpYWxMaWdodGluZ0RhdGEuY29sb3JWZWN0b3IgPSBGbG9hdFBvaW50M0QobV9saWdodGlu Z0NvbG9yLnJlZCgpLCBtX2xpZ2h0aW5nQ29sb3IuZ3JlZW4oKSwgbV9saWdodGluZ0NvbG9yLmJs dWUoKSk7CisgICAgCisgICAgQ29sb3IgbGlnaHRDb2xvciA9IChvcGVyYXRpbmdDb2xvclNwYWNl KCkgPT0gQ29sb3JTcGFjZUxpbmVhclJHQikgPyBzUkdCVG9MaW5lYXJDb2xvcihtX2xpZ2h0aW5n Q29sb3IpIDogbV9saWdodGluZ0NvbG9yOworICAgIHBhaW50aW5nRGF0YS5pbnRpYWxMaWdodGlu Z0RhdGEuY29sb3JWZWN0b3IgPSBGbG9hdFBvaW50M0QobGlnaHRDb2xvci5yZWQoKSwgbGlnaHRD b2xvci5ncmVlbigpLCBsaWdodENvbG9yLmJsdWUoKSk7CiAgICAgbV9saWdodFNvdXJjZS0+aW5p dFBhaW50aW5nRGF0YShwYWludGluZ0RhdGEpOwogCiAgICAgLy8gVG9wIGxlZnQuCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg NTM2ZDU2Y2MyYTg5YjY0ODFlYTQ3NTc4MWJlYTc3OWIzMzZlYjY2Ni4uMzhiODdjZWQ4NTAwNjJm MjZmODM4ZDI3ZjYyN2I3MGNlNTQyMzExMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE3LTEy LTMwICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgorCisgICAgICAgIFNW RyBsaWdodGluZyBjb2xvcnMgbmVlZCB0byBiZSBjb252ZXJ0ZWQgaW50byBsaW5lYXJTUkdCCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODExOTYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBDb21wYXJlIGEg ZmFyLWF3YXkgZ3JlZW4gc3BvdGxpZ2h0IHdpdGggYSBncmVlbiBmbG9vZC4gRm9yIHNvbWUgcmVh c29uIChhIGJ1Zz8pCisgICAgICAgIHRoZSBib3R0b20gcmlnaHQgcGl4ZWwgYWx3YXlzIGhhcyB0 aGUgd3JvbmcgY29sb3IsIHNvIG1hc2sgaXQgb3V0LgorCisgICAgICAgICogc3ZnL2ZpbHRlcnMv ZmVTcG90TGlnaHQtY29sb3ItZXhwZWN0ZWQuc3ZnOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvZmls dGVycy9mZVNwb3RMaWdodC1jb2xvci5zdmc6IEFkZGVkLgorCiAyMDE3LTEyLTE5ICBKZXIgTm9i bGUgIDxqZXIubm9ibGVAYXBwbGUuY29tPgogCiAgICAgICAgIFBsYXlpbmcgbWVkaWEgZWxlbWVu dHMgd2hpY2ggY2FsbCAicGF1c2UoKTsgcGxheSgpIiB3aWxsIGhhdmUgdGhlIHBsYXkgcHJvbWlz ZSByZWplY3RlZC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3N2Zy9maWx0ZXJzL2ZlU3BvdExp Z2h0LWNvbG9yLWV4cGVjdGVkLnN2ZyBiL0xheW91dFRlc3RzL3N2Zy9maWx0ZXJzL2ZlU3BvdExp Z2h0LWNvbG9yLWV4cGVjdGVkLnN2ZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NGQ3MDIwZGZjMDc1YjRlYzE3Y2I0 YzUyNDIwMTdmNDNhNzRlMTIzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvc3ZnL2Zp bHRlcnMvZmVTcG90TGlnaHQtY29sb3ItZXhwZWN0ZWQuc3ZnCkBAIC0wLDAgKzEsMTAgQEAKKzxz dmcgd2lkdGg9IjQ4MHB4IiBoZWlnaHQ9IjYwMHB4IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciPgorPGRlZnM+CisgICAgPGZpbHRlciBpZD0iZmlsdGVyIiBmaWx0ZXJVbml0cz0i b2JqZWN0Qm91bmRpbmdCb3giIHg9IjAiIHk9IjAiIHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUi PgorICAgICAgICA8ZmVGbG9vZCBmbG9vZC1jb2xvcj0icmdiKDAsIDEyOCwgMCkiLz4KKyAgICA8 L2ZpbHRlcj4KKzwvZGVmcz4KKzxyZWN0IHg9IjAiIHk9IjAwIiB3aWR0aD0iNDAwIiBoZWlnaHQ9 IjQwMCIgZmlsdGVyPSJ1cmwoI2ZpbHRlcikiLz4KKzwhLS0gTWFzayBvdXQgYSBzbWFsbCBkaWZm ZXJlbmNlIGluIHRoZSBib3R0b20gcmlnaHQgY29ybmVyIC0tPgorPHJlY3QgeD0iMzg1IiB5PSIz ODUiIHdpZHRoPSIyMCIgaGVpZ2h0PSIyMCIgZmlsbD0iYmxhY2siLz4KKzwvc3ZnPgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvc3ZnL2ZpbHRlcnMvZmVTcG90TGlnaHQtY29sb3Iuc3ZnIGIvTGF5 b3V0VGVzdHMvc3ZnL2ZpbHRlcnMvZmVTcG90TGlnaHQtY29sb3Iuc3ZnCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU5 MGFhNmU1ZjQ1MTZhZDAwN2ViMzQxYWZhNGUxNTNhYTExZTQ4YjUKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9zdmcvZmlsdGVycy9mZVNwb3RMaWdodC1jb2xvci5zdmcKQEAgLTAsMCAr MSwxMiBAQAorPHN2ZyB3aWR0aD0iNDgwcHgiIGhlaWdodD0iNjAwcHgiIHhtbG5zPSJodHRwOi8v d3d3LnczLm9yZy8yMDAwL3N2ZyI+Cis8ZGVmcz4KKyAgICA8ZmlsdGVyIGlkPSJmaWx0ZXIiIGZp bHRlclVuaXRzPSJvYmplY3RCb3VuZGluZ0JveCIgeD0iMCIgeT0iMCIgd2lkdGg9IjEwMCUiIGhl aWdodD0iMTAwJSI+CisgICAgICAgIDxmZURpZmZ1c2VMaWdodGluZyBsaWdodGluZy1jb2xvcj0i cmdiKDAsIDEyOCwgMCkiPgorICAgICAgICAgICAgPGZlU3BvdExpZ2h0IHg9IjIwMCIgeT0iMjAw IiB6PSI1MDAwMDAwMDAiIC8+CisgICAgICAgIDwvZmVEaWZmdXNlTGlnaHRpbmc+CisgICAgPC9m aWx0ZXI+Cis8L2RlZnM+Cis8cmVjdCB4PSIwIiB5PSIwIiB3aWR0aD0iNDAwIiBoZWlnaHQ9IjQw MCIgZmlsdGVyPSJ1cmwoI2ZpbHRlcikiLz4KKzwhLS0gTWFzayBvdXQgYSBzbWFsbCBkaWZmZXJl bmNlIGluIHRoZSBib3R0b20gcmlnaHQgY29ybmVyIC0tPgorPHJlY3QgeD0iMzg1IiB5PSIzODUi IHdpZHRoPSIyMCIgaGVpZ2h0PSIyMCIgZmlsbD0iYmxhY2siLz4KKzwvc3ZnPgo= 330730 2018-01-08 13:33:10 -0800 2018-01-09 08:19:47 -0800 Patch bug-181196-20180108133309.patch text/plain 6671 simon.fraser U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2NTE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDk5MTA0MDFkOWE3ZmE4 NjQ5M2VmODQxMTQxYzkzN2Y4ZTZjN2FmNy4uMGJlZWQ1ZjhkYzdlY2Q5N2NkZmM4NWY5ODZhMjg4 OWYzNDY4NmYzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDE4LTAxLTA4ICBTaW1v biBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgorCisgICAgICAgIFNWRyBsaWdodGlu ZyBjb2xvcnMgbmVlZCB0byBiZSBjb252ZXJ0ZWQgaW50byBsaW5lYXJTUkdCCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODExOTYKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRyZXNzIHBvc3QtY29tbWl0 IGNvbW1lbnRzLiBEb24ndCBtYWtlIGEgQ29sb3IgdGhhdCBjb250YWlucyBsaW5lYXJSR0IgY29t cG9uZW50cywKKyAgICAgICAgYnV0IHVzZSBGbG9hdENvbXBvbmVudHMgaW5zdGVhZC4gU2luY2Ug dGhlc2UgRmxvYXRDb21wb25lbnRzIGFyZSBpbiB0aGUgMC0xIHJhbmdlLAorICAgICAgICBGRUxp Z2h0aW5nOjpzZXRQaXhlbEludGVybmFsKCkgbmVlZHMgdG8gbXVsdGlwbHkgYnkgMjU1IHNpbmNl IHRoZSBvdXRwdXQgcGl4ZWxzIGFyZQorICAgICAgICA4LWJpdCAwLTI1NS4KKyAgICAgICAgCisg ICAgICAgIENoYW5nZSBsaW5lYXJUb1NSR0JDb2xvckNvbXBvbmVudCgpIGFuZCBzUkdCVG9MaW5l YXJDb2xvckNvbXBvbmVudCgpIHRvIGRvIG1hdGggaW4KKyAgICAgICAgZmxvYXRzIHdpdGhvdXQg cHJvbW90aW5nIHRvIGRvdWJsZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9Db2xv clV0aWxpdGllcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGbG9hdENvbXBvbmVudHM6OkZsb2F0 Q29tcG9uZW50cyk6CisgICAgICAgIChXZWJDb3JlOjpsaW5lYXJUb1NSR0JDb2xvckNvbXBvbmVu dCk6CisgICAgICAgIChXZWJDb3JlOjpzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpzUkdCQ29sb3JUb0xpbmVhckNvbXBvbmVudHMpOgorICAgICAgICAoV2Vi Q29yZTo6bGluZWFyVG9TUkdCQ29sb3IpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6c1JH QlRvTGluZWFyQ29sb3IpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0Nv bG9yVXRpbGl0aWVzLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZmlsdGVycy9GRUxp Z2h0aW5nLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZFTGlnaHRpbmc6OnNldFBpeGVsSW50ZXJu YWwpOgorICAgICAgICAoV2ViQ29yZTo6RkVMaWdodGluZzo6ZHJhd0xpZ2h0aW5nKToKKwogMjAx OC0wMS0wOCAgWmFsYW4gQnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAgICAgICAgIFtSZW5k ZXJUcmVlQnVpbGRlcl0gTW92ZSBSZW5kZXJCbG9jayBhZGRDaGlsZCBsb2dpYyB0byBSZW5kZXJU cmVlQnVpbGRlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Q29sb3JVdGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQ29s b3JVdGlsaXRpZXMuY3BwCmluZGV4IDNmOTE3Nzc4NGE2NDI3YjRmNWFlNjJhNTkwYzk1MTFiZjU2 MDZhODMuLjE1ZDdkMDQyYWFiMzU3ZTkxNWYwMGYxMGVlMTYzYjJlZjJiZWYxZDcgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0NvbG9yVXRpbGl0aWVzLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5jcHAK QEAgLTMxLDYgKzMxLDExIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorRmxvYXRDb21wb25l bnRzOjpGbG9hdENvbXBvbmVudHMoY29uc3QgQ29sb3ImIGNvbG9yKQoreworICAgIGNvbG9yLmdl dFJHQkEoY29tcG9uZW50c1swXSwgY29tcG9uZW50c1sxXSwgY29tcG9uZW50c1syXSwgY29tcG9u ZW50c1szXSk7Cit9CisKIENvbG9yQ29tcG9uZW50czo6Q29sb3JDb21wb25lbnRzKGNvbnN0IEZs b2F0Q29tcG9uZW50cyYgZmxvYXRDb21wb25lbnRzKQogewogICAgIGNvbXBvbmVudHNbMF0gPSBj bGFtcGVkQ29sb3JDb21wb25lbnQoZmxvYXRDb21wb25lbnRzLmNvbXBvbmVudHNbMF0pOwpAQCAt NDIsNDAgKzQ3LDMwIEBAIENvbG9yQ29tcG9uZW50czo6Q29sb3JDb21wb25lbnRzKGNvbnN0IEZs b2F0Q29tcG9uZW50cyYgZmxvYXRDb21wb25lbnRzKQogLy8gVGhlc2UgYXJlIHRoZSBzdGFuZGFy ZCBzUkdCIDwtPiBsaW5lYXJSR0IgY29udmVyc2lvbiBmdW5jdGlvbnMgKGh0dHBzOi8vZW4ud2lr aXBlZGlhLm9yZy93aWtpL1NSR0IpLgogZmxvYXQgbGluZWFyVG9TUkdCQ29sb3JDb21wb25lbnQo ZmxvYXQgYykKIHsKLSAgICBpZiAoYyA8IDAuMDAzMTMwOCkKLSAgICAgICAgcmV0dXJuIDEyLjky ICogYzsKKyAgICBpZiAoYyA8IDAuMDAzMTMwOGYpCisgICAgICAgIHJldHVybiAxMi45MmYgKiBj OwogCi0gICAgcmV0dXJuIGNsYW1wVG88ZmxvYXQ+KDEuMDU1ICogcG93ZihjLCAxLjAgLyAyLjQp IC0gMC4wNTUsIDAsIDEpOworICAgIHJldHVybiBjbGFtcFRvPGZsb2F0PigxLjA1NWYgKiBwb3dm KGMsIDEuMGYgLyAyLjRmKSAtIDAuMDU1ZiwgMCwgMSk7CiB9CiAKIGZsb2F0IHNSR0JUb0xpbmVh ckNvbG9yQ29tcG9uZW50KGZsb2F0IGMpCiB7Ci0gICAgaWYgKGMgPD0gMC4wNDA0NSkKLSAgICAg ICAgcmV0dXJuIGMgLyAxMi45MjsKLQotICAgIHJldHVybiBjbGFtcFRvPGZsb2F0Pihwb3dmKChj ICsgMC4wNTUpIC8gMS4wNTUsIDIuNCksIDAsIDEpOwotfQotCi1Db2xvciBsaW5lYXJUb1NSR0JD b2xvcihjb25zdCBDb2xvciYgY29sb3IpCi17Ci0gICAgZmxvYXQgciwgZywgYiwgYTsKLSAgICBj b2xvci5nZXRSR0JBKHIsIGcsIGIsIGEpOwotICAgIHIgPSBsaW5lYXJUb1NSR0JDb2xvckNvbXBv bmVudChyKTsKLSAgICBnID0gbGluZWFyVG9TUkdCQ29sb3JDb21wb25lbnQoZyk7Ci0gICAgYiA9 IGxpbmVhclRvU1JHQkNvbG9yQ29tcG9uZW50KGIpOworICAgIGlmIChjIDw9IDAuMDQwNDVmKQor ICAgICAgICByZXR1cm4gYyAvIDEyLjkyZjsKIAotICAgIHJldHVybiBDb2xvcihyLCBnLCBiLCBh KTsKKyAgICByZXR1cm4gY2xhbXBUbzxmbG9hdD4ocG93ZigoYyArIDAuMDU1ZikgLyAxLjA1NWYs IDIuNGYpLCAwLCAxKTsKIH0KIAotQ29sb3Igc1JHQlRvTGluZWFyQ29sb3IoY29uc3QgQ29sb3Im IGNvbG9yKQorRmxvYXRDb21wb25lbnRzIHNSR0JDb2xvclRvTGluZWFyQ29tcG9uZW50cyhjb25z dCBDb2xvciYgY29sb3IpCiB7CiAgICAgZmxvYXQgciwgZywgYiwgYTsKICAgICBjb2xvci5nZXRS R0JBKHIsIGcsIGIsIGEpOwotICAgIHIgPSBzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudChyKTsK LSAgICBnID0gc1JHQlRvTGluZWFyQ29sb3JDb21wb25lbnQoZyk7Ci0gICAgYiA9IHNSR0JUb0xp bmVhckNvbG9yQ29tcG9uZW50KGIpOwotCi0gICAgcmV0dXJuIENvbG9yKHIsIGcsIGIsIGEpOwor ICAgIHJldHVybiB7CisgICAgICAgIHNSR0JUb0xpbmVhckNvbG9yQ29tcG9uZW50KHIpLAorICAg ICAgICBzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudChnKSwKKyAgICAgICAgc1JHQlRvTGluZWFy Q29sb3JDb21wb25lbnQoYiksCisgICAgICAgIGEKKyAgICB9OwogfQogCiB9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9D b2xvclV0aWxpdGllcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQ29sb3JV dGlsaXRpZXMuaAppbmRleCA1NDU3M2Q3NDA0NTRmM2ViMjE4ZjAzYjA0N2UzODhiNmQ5MjFkMTNm Li5iMmFlYjViZGVhZTM0NTdkNDhhNjBhNDk5YTI5MTMwNzlmMDQ1N2FiIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Db2xvclV0aWxpdGllcy5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0NvbG9yVXRpbGl0aWVzLmgKQEAgLTQwLDYg KzQwLDggQEAgc3RydWN0IEZsb2F0Q29tcG9uZW50cyB7CiAgICAgICAgIGNvbXBvbmVudHNbM10g PSBkOwogICAgIH0KIAorICAgIEZsb2F0Q29tcG9uZW50cyhjb25zdCBDb2xvciYpOworCiAgICAg RmxvYXRDb21wb25lbnRzJiBvcGVyYXRvcis9KGNvbnN0IEZsb2F0Q29tcG9uZW50cyYgcmhzKQog ICAgIHsKICAgICAgICAgY29tcG9uZW50c1swXSArPSByaHMuY29tcG9uZW50c1swXTsKQEAgLTE1 MSw5ICsxNTMsOCBAQCBpbmxpbmUgdW5zaWduZWQgYnl0ZU9mZnNldE9mUGl4ZWwodW5zaWduZWQg eCwgdW5zaWduZWQgeSwgdW5zaWduZWQgcm93Qnl0ZXMpCiAvLyAwLTEgY29tcG9uZW50cywgcmVz dWx0IGlzIGNsYW1wZWQuCiBmbG9hdCBsaW5lYXJUb1NSR0JDb2xvckNvbXBvbmVudChmbG9hdCk7 CiBmbG9hdCBzUkdCVG9MaW5lYXJDb2xvckNvbXBvbmVudChmbG9hdCk7Ci0gICAgCi1Db2xvciBs aW5lYXJUb1NSR0JDb2xvcihjb25zdCBDb2xvciYpOwotQ29sb3Igc1JHQlRvTGluZWFyQ29sb3Io Y29uc3QgQ29sb3ImKTsKKworRmxvYXRDb21wb25lbnRzIHNSR0JDb2xvclRvTGluZWFyQ29tcG9u ZW50cyhjb25zdCBDb2xvciYpOwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVMaWdodGluZy5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZFTGlnaHRpbmcu Y3BwCmluZGV4IDAwZDUzZjVhMzNjM2UyNzI1ODkwMTg2NThlZmZiMGYyOTg4OGRjOTYuLmM2YmZj MDE3OWFhMmFjODM1NmI0NTZjMTZmZTg3ZmUyNjExMzgwZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVMaWdodGluZy5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZmlsdGVycy9GRUxpZ2h0aW5nLmNwcApAQCAt Mjk0LDkgKzI5NCw5IEBAIHZvaWQgRkVMaWdodGluZzo6c2V0UGl4ZWxJbnRlcm5hbChpbnQgb2Zm c2V0LCBjb25zdCBMaWdodGluZ0RhdGEmIGRhdGEsIGNvbnN0IExpCiAgICAgICAgIGxpZ2h0U3Ry ZW5ndGggPSAwOwogCiAgICAgdWludDhfdCBwaXhlbFZhbHVlWzNdID0gewotICAgICAgICBzdGF0 aWNfY2FzdDx1aW50OF90PihsaWdodFN0cmVuZ3RoICogbGlnaHRpbmdEYXRhLmNvbG9yVmVjdG9y LngoKSksCi0gICAgICAgIHN0YXRpY19jYXN0PHVpbnQ4X3Q+KGxpZ2h0U3RyZW5ndGggKiBsaWdo dGluZ0RhdGEuY29sb3JWZWN0b3IueSgpKSwKLSAgICAgICAgc3RhdGljX2Nhc3Q8dWludDhfdD4o bGlnaHRTdHJlbmd0aCAqIGxpZ2h0aW5nRGF0YS5jb2xvclZlY3Rvci56KCkpCisgICAgICAgIHN0 YXRpY19jYXN0PHVpbnQ4X3Q+KGxpZ2h0U3RyZW5ndGggKiBsaWdodGluZ0RhdGEuY29sb3JWZWN0 b3IueCgpICogMjU1LjBmKSwKKyAgICAgICAgc3RhdGljX2Nhc3Q8dWludDhfdD4obGlnaHRTdHJl bmd0aCAqIGxpZ2h0aW5nRGF0YS5jb2xvclZlY3Rvci55KCkgKiAyNTUuMGYpLAorICAgICAgICBz dGF0aWNfY2FzdDx1aW50OF90PihsaWdodFN0cmVuZ3RoICogbGlnaHRpbmdEYXRhLmNvbG9yVmVj dG9yLnooKSAqIDI1NS4wZikKICAgICB9OwogICAgIAogICAgIGRhdGEucGl4ZWxzLT5zZXRSYW5n ZShwaXhlbFZhbHVlLCAzLCBvZmZzZXQpOwpAQCAtMzk5LDggKzM5OSw4IEBAIGJvb2wgRkVMaWdo dGluZzo6ZHJhd0xpZ2h0aW5nKFVpbnQ4Q2xhbXBlZEFycmF5JiBwaXhlbHMsIGludCB3aWR0aCwg aW50IGhlaWdodCkKICAgICBkYXRhLndpZHRoRGVjcmVhc2VkQnlPbmUgPSB3aWR0aCAtIDE7CiAg ICAgZGF0YS5oZWlnaHREZWNyZWFzZWRCeU9uZSA9IGhlaWdodCAtIDE7CiAgICAgCi0gICAgQ29s b3IgbGlnaHRDb2xvciA9IChvcGVyYXRpbmdDb2xvclNwYWNlKCkgPT0gQ29sb3JTcGFjZUxpbmVh clJHQikgPyBzUkdCVG9MaW5lYXJDb2xvcihtX2xpZ2h0aW5nQ29sb3IpIDogbV9saWdodGluZ0Nv bG9yOwotICAgIHBhaW50aW5nRGF0YS5pbml0aWFsTGlnaHRpbmdEYXRhLmNvbG9yVmVjdG9yID0g RmxvYXRQb2ludDNEKGxpZ2h0Q29sb3IucmVkKCksIGxpZ2h0Q29sb3IuZ3JlZW4oKSwgbGlnaHRD b2xvci5ibHVlKCkpOworICAgIEZsb2F0Q29tcG9uZW50cyBsaWdodENvbG9yID0gKG9wZXJhdGlu Z0NvbG9yU3BhY2UoKSA9PSBDb2xvclNwYWNlTGluZWFyUkdCKSA/IHNSR0JDb2xvclRvTGluZWFy Q29tcG9uZW50cyhtX2xpZ2h0aW5nQ29sb3IpIDogRmxvYXRDb21wb25lbnRzKG1fbGlnaHRpbmdD b2xvcik7CisgICAgcGFpbnRpbmdEYXRhLmluaXRpYWxMaWdodGluZ0RhdGEuY29sb3JWZWN0b3Ig PSBGbG9hdFBvaW50M0QobGlnaHRDb2xvci5jb21wb25lbnRzWzBdLCBsaWdodENvbG9yLmNvbXBv bmVudHNbMV0sIGxpZ2h0Q29sb3IuY29tcG9uZW50c1syXSk7CiAgICAgbV9saWdodFNvdXJjZS0+ aW5pdFBhaW50aW5nRGF0YSgqdGhpcywgcGFpbnRpbmdEYXRhKTsKIAogICAgIC8vIFRvcCBsZWZ0 Lgo=