136956 2014-09-19 10:57:00 -0700 Tweak and tighten SVG font converter 2014-09-29 09:27:40 -0700 1 1 1 Unclassified WebKit SVG 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 darin darin ap commit-queue d-r fmalita gyuyoung.kim mitz mmaxfield pdr schenney sergio zimmermann oldest_to_newest 1036160 0 darin 2014-09-19 10:57:00 -0700 Tweak and tighten SVG font converter 1036162 1 238379 darin 2014-09-19 11:10:48 -0700 Created attachment 238379 Patch 1036164 2 darin 2014-09-19 11:11:26 -0700 Myles, I made a few tweaks to the code you landed recently. Could you take a look? 1036211 3 238379 mmaxfield 2014-09-19 14:48:34 -0700 Comment on attachment 238379 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238379&action=review > Source/WebCore/svg/SVGToOTFFontConversion.cpp:325 > + char panoseBytes[10]; Maximum value of 0xFF means this should be unsigned (though if we're just going to append this later, it might not matter) > Source/WebCore/svg/SVGToOTFFontConversion.cpp:327 > + Vector<String> strings; This probably should have a better name than "strings". Perhaps panoseSegments? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:330 > + for (auto& string : strings) { Similar to above (though it's definitely better than "s"). > Source/WebCore/svg/SVGToOTFFontConversion.cpp:334 > + panoseBytes[numPanoseBytes++] = value; no break here? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:-374 > -static void appendCFFValidString(Vector<char>& output, const String& string) I feel that "valid" sets up a precondition to the function. Removing the word is fine, but I think that having some way of documenting the precondition would be beneficial. (The string must be valid because we're down casting the UChars to chars in the Vector::append() function) > Source/WebCore/svg/SVGToOTFFontConversion.cpp:422 > + const unsigned sizeOfTopIndex = 45 + (weight.isNull() ? 0 : 6); You want to write out empty strings into the font? I suppose philosophically if the string is present but empty in the SVG font, it makes sense for it to be present but empty in the OTF font? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:-468 > - if (!weight.isEmpty()) { I wish we could collapse all of these String::isEmpty() calls into a single call and re-use the result, but I'm not sure if it would actually be beneficial. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:506 > + write16(result, m_fontElement.fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()); So much better! However, when I actually do use the missing glyph info for this, I'll want to predicate this fallback based on whether or not parsing failed, which means I'll have to reintroduce some of this deleted code soon. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:508 > + auto tableSizeOffset = result.size(); Conceptually this would be simpler if you moved this result.size() call after the line below that writes the placeholder. That way you wouldn't need the "- 2". > Source/WebCore/svg/SVGToOTFFontConversion.cpp:509 > + write16(result, 0); // Place to write table size. nit: s/Place/Placeholder/ > Source/WebCore/svg/SVGToOTFFontConversion.cpp:512 > + if (int16_t verticalOriginY = glyph->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()) { Probably should clamp this to a the range of an int16_t. Outputting the origin regardless of parsing success seems iffy to me. This make an assumption that the toInt() behavior returns the same value as an unknown vertical origin, which might not be correct based on the underlying platform implementation. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:518 > + overwrite16(result, tableSizeOffset, (result.size() - tableSizeOffset - 2) / 4); Shouldn't we assert that result.size() - tableSizeOffset % 4 == 0? (Assuming that you move the tableSizeOffset after the table size placeholder) > Source/WebCore/svg/SVGToOTFFontConversion.cpp:523 > vector.append(-1); // 0xFF I'm surprised you didn't change this to vector.append(0xFF) > Source/WebCore/svg/SVGToOTFFontConversion.cpp:538 > // FIXME: We probably want the initial moveto to use horiz-origin-x and horiz-origin-y, unless we're vertical No period for this comment? ;-) > Source/WebCore/svg/SVGToOTFFontConversion.cpp:561 > + void writePoint(FloatPoint destination) Good observation (that this is possible)! > Source/WebCore/svg/SVGToOTFFontConversion.cpp:-599 > - // FIXME: This can be made way faster We can still make this faster by not computing deltas in writePoint() if we are handed deltas in the first place. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:627 > + // FIXME: Shouldn't this be isNull? Is there a reason to handle an empty string attribute the same as a missing attribute? I gave my argument above about writing empty strings to the font. I suppose in this case, however, an empty string would result in the same result. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:628 > // FIXME: Why is this different than what we do below when parsing fails. Good thought. It seems to me that the parsing fails code path is straight up broken right now. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:710 > if (segment == "bold") { I should probably make these a case insensitive compare > Source/WebCore/svg/SVGToOTFFontConversion.cpp:713 > + // Are we intentionally implementing a "last one wins" rule? Nope. The spec doesn't define what to do in this case. We might as well break here. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:718 > + // FIXME: Do we want to truncate, or would it be better to round? The spec only defines multiples of 100 as technically valid, so either way is probably fine. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:726 > + for (auto& segment : segments) { Seems like this could be joined up with the loop above it. I feel pretty sheepish for making two separate loops... > Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:169 > + EXPECT_EQ(false, ok); There's no EXPECT_FALSE? > Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:192 > + EXPECT_EQ(-2147483648, String("-2147483648").toInt(&ok)); Might want to test if the string appears to be larger than the largest int or smaller than the smallest int > Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:212 > + EXPECT_EQ(true, ok); I don't know if it's out of scope, but it would be interesting to see what happens with things like unmatched surrogates or invalid UTF-16, or multi-byte code points. Also might want to test if "4x8" gets parsed to 4 or 8 (perhaps similarly with "4x8x") > Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:246 > + // FIXME: This is an inconsistency with toInt, which always guarantees :( > Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:260 > + EXPECT_EQ(false, ok); Might also want to test decimal places or things like -3e6 Same with larger than the largest double / smaller than the smallest double Is the assumption that toFloat() will work the same way as toDouble()? 1036212 4 mmaxfield 2014-09-19 14:48:50 -0700 unofficial r=me 1036344 5 238379 darin 2014-09-21 10:28:40 -0700 Comment on attachment 238379 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238379&action=review >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:325 >> + char panoseBytes[10]; > > Maximum value of 0xFF means this should be unsigned (though if we're just going to append this later, it might not matter) It’s true that the maximum value is 0xFF, but not true that we need to use the type "unsigned char" here because of that. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:327 >> + Vector<String> strings; > > This probably should have a better name than "strings". Perhaps panoseSegments? I’m not sure that a more specific name would be better. This is a very local variable and I don’t think they need globally unique names, but, sure, I’ll consider panoseSegments, even though it seems a bit wordy. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:334 >> + panoseBytes[numPanoseBytes++] = value; > > no break here? We definitely don’t want to break here. We need to do this 10 times, not 1 time. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-374 >> -static void appendCFFValidString(Vector<char>& output, const String& string) > > I feel that "valid" sets up a precondition to the function. Removing the word is fine, but I think that having some way of documenting the precondition would be beneficial. (The string must be valid because we're down casting the UChars to chars in the Vector::append() function) Hmm, it seems like you are saying that removing the word is not fine, even though you say “removing the word is fine”. Not sure what to do. I agree that the string being valid is a precondition of the function, but not that calling the function appendCFFValidString makes that clear. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:422 >> + const unsigned sizeOfTopIndex = 45 + (weight.isNull() ? 0 : 6); > > You want to write out empty strings into the font? I suppose philosophically if the string is present but empty in the SVG font, it makes sense for it to be present but empty in the OTF font? I have no idea if empty strings come up in practice. But, this code is to handle the case where no weight is specified, and that is handled with the null value, not empty value. Checking for empty value is not obviously bad, but it’s not really helpful either. I see no reason that an empty string would not be allowed, but also no reason that an empty string would be helpful or valuable either. Generally it’s bad coding style to check for a null value with isEmpty; it’s slower and does more work. And I don’t think we should do that unless we really think it’s a valuable thing to do that for an empty string. I believe we are doing this just because the isEmpty function is handy and also easy to confuse with isNull. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-468 >> - if (!weight.isEmpty()) { > > I wish we could collapse all of these String::isEmpty() calls into a single call and re-use the result, but I'm not sure if it would actually be beneficial. Well, for isEmpty there’s a tiny chance that would compiler to tighter code. For isNull it likely wouldn’t because it’s just a simple null pointer check, and I’m not sure checking a boolean local variable would be better. Should decide based on code readability, not performance optimization. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:506 >> + write16(result, m_fontElement.fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()); > > So much better! However, when I actually do use the missing glyph info for this, I'll want to predicate this fallback based on whether or not parsing failed, which means I'll have to reintroduce some of this deleted code soon. If you do that, you should figure out exactly what you mean by “parsing failed”. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:508 >> + auto tableSizeOffset = result.size(); > > Conceptually this would be simpler if you moved this result.size() call after the line below that writes the placeholder. That way you wouldn't need the "- 2". We use tableSizeOffset twice below. If I moved this after the line below then I’d have to use tableOffsetSize - 2 in the first place i use it. I don’t think that’s conceptually simpler. We could have two offsets, but I’m not sure that would be better. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:509 >> + write16(result, 0); // Place to write table size. > > nit: s/Place/Placeholder/ I meant “place”, not “placeholder”. I agree that the zero is a “placeholder”, but the place I am putting the zero is a “place”. So I chose this on purpose. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:512 >> + if (int16_t verticalOriginY = glyph->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()) { > > Probably should clamp this to a the range of an int16_t. > > Outputting the origin regardless of parsing success seems iffy to me. This make an assumption that the toInt() behavior returns the same value as an unknown vertical origin, which might not be correct based on the underlying platform implementation. Why is clamping to the range of an int16_t the right thing to do? Should a large value turn into 32767? Should a small value turn into -32768? What makes that useful behavior? I agree that simply truncating into an int16_t isn’t right, but I don’t know why clamping is right. The “iffy” thing you are referring to doesn’t exist. The code does not write out an origin when parsing fails. When parsing fails we get a zero and the if statement evaluates to false. On a separate note, I don’t know what an “unknown vertical origin” is. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:518 >> + overwrite16(result, tableSizeOffset, (result.size() - tableSizeOffset - 2) / 4); > > Shouldn't we assert that result.size() - tableSizeOffset % 4 == 0? (Assuming that you move the tableSizeOffset after the table size placeholder) Sure it would be OK to add an assertion, but I don’t think the assertion is all that valuable. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:523 >> vector.append(-1); // 0xFF > > I'm surprised you didn't change this to vector.append(0xFF) Good point, I will change that. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:538 >> // FIXME: We probably want the initial moveto to use horiz-origin-x and horiz-origin-y, unless we're vertical > > No period for this comment? ;-) There were a lot of comments in this file. I didn’t get to every one! >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-599 >> - // FIXME: This can be made way faster > > We can still make this faster by not computing deltas in writePoint() if we are handed deltas in the first place. Maybe, but I’m not sure that “faster” is a meaningful issue here. I think the memory allocation in this overall operation is likely far more expensive than the floating point math. I don’t think this particular optimization opportunity is so valuable that we need to comment on it. Note also that if we are passed deltas, we still need to do math on two of them to convert them to deltas relative to each other, not deltas related to the start point. I don’t think there’s a compelling need to change this unless it’s producing incorrect results or really does measure as a significant performance cost. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:627 >> + // FIXME: Shouldn't this be isNull? Is there a reason to handle an empty string attribute the same as a missing attribute? > > I gave my argument above about writing empty strings to the font. I suppose in this case, however, an empty string would result in the same result. I am not sure it’s really a correct argument. Why is empty string handled specially, but not, say, a string containing a single space in it? >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:628 >> + // FIXME: Why is this different than what we do below when parsing fails. > > Good thought. It seems to me that the parsing fails code path is straight up broken right now. OK. I think we need unit tests for this code. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:710 >> + if (segment == "bold") { > > I should probably make these a case insensitive compare Well, maybe. All depends on what the SVG specification says. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:713 >> + // Are we intentionally implementing a "last one wins" rule? > > Nope. The spec doesn't define what to do in this case. We might as well break here. We should come up with a good rule. I suppose “first wins” is better than “last wins”. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:718 >> + // FIXME: Do we want to truncate, or would it be better to round? > > The spec only defines multiples of 100 as technically valid, so either way is probably fine. We need to define the behavior we want to implement for invalid values. We can’t write code that does three different things, so lets chose one. We could treat such values as invalid, or truncate them, or round them, or possibly do something else. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:726 >> + for (auto& segment : segments) { > > Seems like this could be joined up with the loop above it. I feel pretty sheepish for making two separate loops... Good point. I thought the loop was parsing two different strings. Note that joining the loops means not doing “break”, since we want to find both "bold" and "italic". >> Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:169 >> + EXPECT_EQ(false, ok); > > There's no EXPECT_FALSE? Maybe there is, dunno. >> Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:192 >> + EXPECT_EQ(-2147483648, String("-2147483648").toInt(&ok)); > > Might want to test if the string appears to be larger than the largest int or smaller than the smallest int That is tested here already. 2147483648 (just before this test) is larger than the largest and -2147483649 (just after this test) is smaller than the smallest. Unless you mean something different? >> Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:212 >> + EXPECT_EQ(true, ok); > > I don't know if it's out of scope, but it would be interesting to see what happens with things like unmatched surrogates or invalid UTF-16, or multi-byte code points. > > Also might want to test if "4x8" gets parsed to 4 or 8 (perhaps similarly with "4x8x") Sure, we could add lots more tests. This just scratches the surface. >> Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:260 >> + EXPECT_EQ(false, ok); > > Might also want to test decimal places or things like -3e6 > > Same with larger than the largest double / smaller than the smallest double > > Is the assumption that toFloat() will work the same way as toDouble()? Sure we can add more tests. I didn’t write tests for toFloat yet. It’s trickier because there is no toFloat function; it just calls toDouble and then casts to a float. That means it’s going to do the wrong things for numbers that fit in a double but not in a float. 1036624 6 238379 mmaxfield 2014-09-22 17:11:05 -0700 Comment on attachment 238379 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238379&action=review >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:325 >>> + char panoseBytes[10]; >> >> Maximum value of 0xFF means this should be unsigned (though if we're just going to append this later, it might not matter) > > It’s true that the maximum value is 0xFF, but not true that we need to use the type "unsigned char" here because of that. Okay. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:334 >>> + panoseBytes[numPanoseBytes++] = value; >> >> no break here? > > We definitely don’t want to break here. We need to do this 10 times, not 1 time. Whoops; please disregard this comment. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-374 >>> -static void appendCFFValidString(Vector<char>& output, const String& string) >> >> I feel that "valid" sets up a precondition to the function. Removing the word is fine, but I think that having some way of documenting the precondition would be beneficial. (The string must be valid because we're down casting the UChars to chars in the Vector::append() function) > > Hmm, it seems like you are saying that removing the word is not fine, even though you say “removing the word is fine”. Not sure what to do. I agree that the string being valid is a precondition of the function, but not that calling the function appendCFFValidString makes that clear. I meant to say that it would be beneficial to document that the input to this function should be valid, regardless of what the mechanism for that documentation is. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:422 >>> + const unsigned sizeOfTopIndex = 45 + (weight.isNull() ? 0 : 6); >> >> You want to write out empty strings into the font? I suppose philosophically if the string is present but empty in the SVG font, it makes sense for it to be present but empty in the OTF font? > > I have no idea if empty strings come up in practice. But, this code is to handle the case where no weight is specified, and that is handled with the null value, not empty value. Checking for empty value is not obviously bad, but it’s not really helpful either. I see no reason that an empty string would not be allowed, but also no reason that an empty string would be helpful or valuable either. > > Generally it’s bad coding style to check for a null value with isEmpty; it’s slower and does more work. And I don’t think we should do that unless we really think it’s a valuable thing to do that for an empty string. I believe we are doing this just because the isEmpty function is handy and also easy to confuse with isNull. Originally, I was thinking that specifying 'font-weight=""' should be treated the same as not having specified the attribute at all. However, I think your arguments are correct; please disregard this comment. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-468 >>> - if (!weight.isEmpty()) { >> >> I wish we could collapse all of these String::isEmpty() calls into a single call and re-use the result, but I'm not sure if it would actually be beneficial. > > Well, for isEmpty there’s a tiny chance that would compiler to tighter code. For isNull it likely wouldn’t because it’s just a simple null pointer check, and I’m not sure checking a boolean local variable would be better. Should decide based on code readability, not performance optimization. That's right; this comment was regarding code readability, not performance. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:506 >>> + write16(result, m_fontElement.fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()); >> >> So much better! However, when I actually do use the missing glyph info for this, I'll want to predicate this fallback based on whether or not parsing failed, which means I'll have to reintroduce some of this deleted code soon. > > If you do that, you should figure out exactly what you mean by “parsing failed”. We've already addressed this in https://bugs.webkit.org/show_bug.cgi?id=136971 >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:508 >>> + auto tableSizeOffset = result.size(); >> >> Conceptually this would be simpler if you moved this result.size() call after the line below that writes the placeholder. That way you wouldn't need the "- 2". > > We use tableSizeOffset twice below. If I moved this after the line below then I’d have to use tableOffsetSize - 2 in the first place i use it. I don’t think that’s conceptually simpler. We could have two offsets, but I’m not sure that would be better. You're right. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:509 >>> + write16(result, 0); // Place to write table size. >> >> nit: s/Place/Placeholder/ > > I meant “place”, not “placeholder”. I agree that the zero is a “placeholder”, but the place I am putting the zero is a “place”. So I chose this on purpose. Okay. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:512 >>> + if (int16_t verticalOriginY = glyph->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()) { >> >> Probably should clamp this to a the range of an int16_t. >> >> Outputting the origin regardless of parsing success seems iffy to me. This make an assumption that the toInt() behavior returns the same value as an unknown vertical origin, which might not be correct based on the underlying platform implementation. > > Why is clamping to the range of an int16_t the right thing to do? Should a large value turn into 32767? Should a small value turn into -32768? What makes that useful behavior? I agree that simply truncating into an int16_t isn’t right, but I don’t know why clamping is right. > > The “iffy” thing you are referring to doesn’t exist. The code does not write out an origin when parsing fails. When parsing fails we get a zero and the if statement evaluates to false. > > On a separate note, I don’t know what an “unknown vertical origin” is. Regarding clamping: given a value that is out of the range of representable values in the output font, clamping will get us as close as possible to the value specified in the input font. Modulus is almost certainly worse. Regarding "iffy"ness: I'm interested in the case where the vert-origin-y value fails to parse. In the original code, no such entry would be written out in the font for it (since no pair would be appended to origins). In this new code, if parsing fails, you write out a 0 entry to the font, which could end up meaning something different to the platform's font parsing engine. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:518 >>> + overwrite16(result, tableSizeOffset, (result.size() - tableSizeOffset - 2) / 4); >> >> Shouldn't we assert that result.size() - tableSizeOffset % 4 == 0? (Assuming that you move the tableSizeOffset after the table size placeholder) > > Sure it would be OK to add an assertion, but I don’t think the assertion is all that valuable. I think it would be valuable as a consistency check for tableSizeOffset. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:-599 >>> - // FIXME: This can be made way faster >> >> We can still make this faster by not computing deltas in writePoint() if we are handed deltas in the first place. > > Maybe, but I’m not sure that “faster” is a meaningful issue here. I think the memory allocation in this overall operation is likely far more expensive than the floating point math. I don’t think this particular optimization opportunity is so valuable that we need to comment on it. > > Note also that if we are passed deltas, we still need to do math on two of them to convert them to deltas relative to each other, not deltas related to the start point. I don’t think there’s a compelling need to change this unless it’s producing incorrect results or really does measure as a significant performance cost. You are right. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:627 >>> + // FIXME: Shouldn't this be isNull? Is there a reason to handle an empty string attribute the same as a missing attribute? >> >> I gave my argument above about writing empty strings to the font. I suppose in this case, however, an empty string would result in the same result. > > I am not sure it’s really a correct argument. Why is empty string handled specially, but not, say, a string containing a single space in it? Instead of adding a comment, please go ahead and change it to isNull(). >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:628 >>> + // FIXME: Why is this different than what we do below when parsing fails. >> >> Good thought. It seems to me that the parsing fails code path is straight up broken right now. > > OK. I think we need unit tests for this code. Yep! Coming soon :) >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:710 >>> + if (segment == "bold") { >> >> I should probably make these a case insensitive compare > > Well, maybe. All depends on what the SVG specification says. SVG says the font-weight property has the "Same syntax and semantics as the ‘font-weight’ descriptor within an @font-face rule." http://www.w3.org/TR/SVG/fonts.html#FontFaceElementFontWeightAttribute CSS says "All CSS syntax is case-insensitive within the ASCII range" http://www.w3.org/TR/CSS2/syndata.html#characters >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:713 >>> + // Are we intentionally implementing a "last one wins" rule? >> >> Nope. The spec doesn't define what to do in this case. We might as well break here. > > We should come up with a good rule. I suppose “first wins” is better than “last wins”. "First wins" is probably better. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:718 >>> + // FIXME: Do we want to truncate, or would it be better to round? >> >> The spec only defines multiples of 100 as technically valid, so either way is probably fine. > > We need to define the behavior we want to implement for invalid values. We can’t write code that does three different things, so lets chose one. We could treat such values as invalid, or truncate them, or round them, or possibly do something else. Rounding is probably best. >>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:726 >>> + for (auto& segment : segments) { >> >> Seems like this could be joined up with the loop above it. I feel pretty sheepish for making two separate loops... > > Good point. I thought the loop was parsing two different strings. > > Note that joining the loops means not doing “break”, since we want to find both "bold" and "italic". After looking at the spec, this loop ::should:: be parsing two different strings. This one should be parsing the "font-style" attribute. >>> Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp:192 >>> + EXPECT_EQ(-2147483648, String("-2147483648").toInt(&ok)); >> >> Might want to test if the string appears to be larger than the largest int or smaller than the smallest int > > That is tested here already. 2147483648 (just before this test) is larger than the largest and -2147483649 (just after this test) is smaller than the smallest. > > Unless you mean something different? Oh, whoops. I had assumed that that is INT_MAX and INT_MIN. 1037135 7 238379 darin 2014-09-24 20:36:59 -0700 Comment on attachment 238379 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238379&action=review >>>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:512 >>>> + if (int16_t verticalOriginY = glyph->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()) { >>> >>> Probably should clamp this to a the range of an int16_t. >>> >>> Outputting the origin regardless of parsing success seems iffy to me. This make an assumption that the toInt() behavior returns the same value as an unknown vertical origin, which might not be correct based on the underlying platform implementation. >> >> Why is clamping to the range of an int16_t the right thing to do? Should a large value turn into 32767? Should a small value turn into -32768? What makes that useful behavior? I agree that simply truncating into an int16_t isn’t right, but I don’t know why clamping is right. >> >> The “iffy” thing you are referring to doesn’t exist. The code does not write out an origin when parsing fails. When parsing fails we get a zero and the if statement evaluates to false. >> >> On a separate note, I don’t know what an “unknown vertical origin” is. > > Regarding clamping: given a value that is out of the range of representable values in the output font, clamping will get us as close as possible to the value specified in the input font. Modulus is almost certainly worse. > > Regarding "iffy"ness: I'm interested in the case where the vert-origin-y value fails to parse. In the original code, no such entry would be written out in the font for it (since no pair would be appended to origins). In this new code, if parsing fails, you write out a 0 entry to the font, which could end up meaning something different to the platform's font parsing engine. That’s incorrect. In the new code, if the parsing fails, verticalOriginY is zero and the code doesn’t write anything. 1037234 8 238379 mmaxfield 2014-09-25 08:49:40 -0700 Comment on attachment 238379 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238379&action=review >>>>> Source/WebCore/svg/SVGToOTFFontConversion.cpp:512 >>>>> + if (int16_t verticalOriginY = glyph->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt()) { >>>> >>>> Probably should clamp this to a the range of an int16_t. >>>> >>>> Outputting the origin regardless of parsing success seems iffy to me. This make an assumption that the toInt() behavior returns the same value as an unknown vertical origin, which might not be correct based on the underlying platform implementation. >>> >>> Why is clamping to the range of an int16_t the right thing to do? Should a large value turn into 32767? Should a small value turn into -32768? What makes that useful behavior? I agree that simply truncating into an int16_t isn’t right, but I don’t know why clamping is right. >>> >>> The “iffy” thing you are referring to doesn’t exist. The code does not write out an origin when parsing fails. When parsing fails we get a zero and the if statement evaluates to false. >>> >>> On a separate note, I don’t know what an “unknown vertical origin” is. >> >> Regarding clamping: given a value that is out of the range of representable values in the output font, clamping will get us as close as possible to the value specified in the input font. Modulus is almost certainly worse. >> >> Regarding "iffy"ness: I'm interested in the case where the vert-origin-y value fails to parse. In the original code, no such entry would be written out in the font for it (since no pair would be appended to origins). In this new code, if parsing fails, you write out a 0 entry to the font, which could end up meaning something different to the platform's font parsing engine. > > That’s incorrect. In the new code, if the parsing fails, verticalOriginY is zero and the code doesn’t write anything. You're right; however, the reverse problem is now true: vertical origins that are specified as 0 don't get written out. 1037604 9 238753 darin 2014-09-26 19:38:26 -0700 Created attachment 238753 Patch 1037814 10 darin 2014-09-28 16:27:00 -0700 (In reply to comment #8) > You're right; however, the reverse problem is now true: vertical origins that are specified as 0 don't get written out. That's not a change in behavior. The code before my patch is already checking for zero and not writing out vertical origins based on that. It says: if (ok && verticalOriginY) If that is wrong, I’d be happy to fix it. But I assumed it was intentional. 1037867 11 mmaxfield 2014-09-28 19:41:09 -0700 (In reply to comment #10) > (In reply to comment #8) > > You're right; however, the reverse problem is now true: vertical origins that are specified as 0 don't get written out. > > That's not a change in behavior. The code before my patch is already checking for zero and not writing out vertical origins based on that. It says: > > if (ok && verticalOriginY) > > If that is wrong, I’d be happy to fix it. But I assumed it was intentional. You're right! Though this behavior is wrong: any vertical origin that is specified (in a way that we can parse as a number) should be specified in the output. Because the problem isn't actually in this patch, I can fix this in a subsequent patch if you like. 1037872 12 238753 mmaxfield 2014-09-28 20:09:28 -0700 Comment on attachment 238753 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238753&action=review > Source/WebCore/svg/SVGToOTFFontConversion.cpp:84 > + , charString(WTF::move(charString)) Will this actually work? It looks like charString is getting copied in to the function anyway - this is only saving the copy from the function to the member variable. Or are constructor initializer lists special? Making the charString an rvalue reference might help with readability in either case. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:334 > + int value = m_fontElement.fastGetAttribute(SVGNames::horiz_adv_xAttr).toInt(&ok); Instead of getting the attribute, you can use m_fontFaceElement->horizontalAdvanceX() > Source/WebCore/svg/SVGToOTFFontConversion.cpp:871 > + m_glyphs.append(GlyphData(WTF::move(path), glyphElement, horizontalAdvance, verticalAdvance, m_boundingBox, codepoint)); I think it would be beneficial to only have one argument and conditionally use downcast<>(), rather than having two arguments that mean almost the same thing but are subtly different. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:913 > + // Indicate error by leaving the glyphs vector empty. A comment at all might not be necessary; it's pretty obvious what's going on. Up to you. 1037873 13 mmaxfield 2014-09-28 20:10:02 -0700 r=me 1037943 14 238753 darin 2014-09-29 08:38:32 -0700 Comment on attachment 238753 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238753&action=review Myles said r=me but didn’t change the review state to +. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:84 >> + , charString(WTF::move(charString)) > > Will this actually work? It looks like charString is getting copied in to the function anyway - this is only saving the copy from the function to the member variable. Or are constructor initializer lists special? Making the charString an rvalue reference might help with readability in either case. Yes, it will work. The caller moves into the argument, the function moves into the data member. You can’t see the move at the call site here, but it’s there. Changing this to an rvalue reference would also be fine with me. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:334 >> + int value = m_fontElement.fastGetAttribute(SVGNames::horiz_adv_xAttr).toInt(&ok); > > Instead of getting the attribute, you can use m_fontFaceElement->horizontalAdvanceX() That would be a big change. For one, it returns a float, not an integer, for another, it returns 0 if there is no font element, and doesn’t provide a separate “is OK” flag. If you want to make that change, you’ll need to do it. It’s not just refactoring. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:871 >> + m_glyphs.append(GlyphData(WTF::move(path), glyphElement, horizontalAdvance, verticalAdvance, m_boundingBox, codepoint)); > > I think it would be beneficial to only have one argument and conditionally use downcast<>(), rather than having two arguments that mean almost the same thing but are subtly different. Which two arguments are you talking about? Is this comment about the processGlyphElement function below? I actually think the current design of that function is great, but sure you could check at runtime instead of compile time if you prefer. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:913 >> + // Indicate error by leaving the glyphs vector empty. > > A comment at all might not be necessary; it's pretty obvious what's going on. Up to you. OK, I’ll omit that comment. 1037952 15 ap 2014-09-29 09:14:49 -0700 > Myles said r=me but didn’t change the review state to +. Myles is not an official reviewer yet. I considered giving a rubber-stamp, but given how little I understand about this patch, that seemed silly. Perhaps Mitz could weigh in. 1037954 16 darin 2014-09-29 09:27:04 -0700 Committed r174063: <http://trac.webkit.org/changeset/174063> 1037955 17 darin 2014-09-29 09:27:40 -0700 Oops, I landed it without a review then. Given this is new code and not yet turned on, I think this is OK. 238379 2014-09-19 11:10:48 -0700 2014-09-26 19:38:22 -0700 Patch bug-136956-20140919111046.patch text/plain 37054 darin U3VidmVyc2lvbiBSZXZpc2lvbjogMTczNzYxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmQ3NzYxYWIzMzY3YWRi YjlhM2I3OWYyYjc4MGVjZjYwZTk2MzVmMy4uNThjMDEzN2Q1OWU3MzZkNGJlZDA1MTljZDdlNjNm N2VjOTkzYmViOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYxIEBACisyMDE0LTA5LTE5ICBEYXJp biBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KKworICAgICAgICBUd2VhayBhbmQgdGlnaHRlbiBT VkcgZm9udCBjb252ZXJ0ZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEzNjk1NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogc3ZnL1NWR1RvT1RGRm9udENvbnZlcnNpb24uY3BwOiBGaXhlZCBjb3B5cmln aHQgZGF0ZS4KKyAgICAgICAgKFdlYkNvcmU6Om92ZXJ3cml0ZTMyKTogQ2hhbmdlZCB0byB1c2Ug bm9ybWFsIHN1YnNjcmlwdGluZyBmb3IgY2xhcml0eS4KKyAgICAgICAgKFdlYkNvcmU6Om92ZXJ3 cml0ZTE2KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OkdseXBoRGF0YTo6R2x5cGhEYXRhKTogQWRkZWQgYSBtb3ZlCisgICAgICAgIHRvIG1ha2UgY29u c3RydWN0aW5nIGVhY2ggR2x5cGhEYXRhIGxlc3MgZXhwZW5zaXZlLiBSZW1vdmVkICJrIiBwcmVm aXgKKyAgICAgICAgZnJvbSBzb21lIHNvbnN0YW50cy4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1Rv T1RGRm9udENvbnZlcnRlcjo6YXBwZW5kQ01BUFRhYmxlKTogUmVtb3ZlZCBzb21lIHN0cmF5Cisg ICAgICAgIGNvbnN0IHRoYXQgZG9uJ3QgaGF2ZSBhbnkgZWZmZWN0LgorICAgICAgICAoV2ViQ29y ZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRIRUFEVGFibGUpOiBBcHBlbmQgdGhlIG1h Z2ljCisgICAgICAgIG51bWJlciBpbiBhIG1vcmUgc3RyYWlnaHRmb3J3YXJkIHdheS4KKyAgICAg ICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEhFQVRhYmxlKTogTWFk ZSBzb21lIG1pbm9yCisgICAgICAgIHN0eWxlIGNoYW5nZXMgYW5kIGltcHJvdmVkIHNvbWUgY29t bWVudHMuIFJlbW92ZWQgc29tZSB1bm5lZWRlZCBzZWNvbmQKKyAgICAgICAgYXJndW1lbnRzIHRv IGNsYW1wVG8gZnVuY3Rpb24gdGVtcGxhdGUgaW52b2NhdGlvbnMuCisgICAgICAgIChXZWJDb3Jl OjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEhNVFhUYWJsZSk6IFJlbW92ZWQgdW5uZWVk ZWQKKyAgICAgICAgc2Vjb25kIGFyZ3VtZW50cyB0byBjbGFtcFRvIGludm9jYXRpb25zLgorICAg ICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRPUzJUYWJsZSk6IE1h ZGUgc29tZSBtaW5vcgorICAgICAgICBzdHlsZSBjaGFuZ2VzIGFuZCB0aWdodGVuZWQgdXAgY29k ZSB0aGF0IGRpZCBwYXJzaW5nIGEgYml0LgorICAgICAgICAoV2ViQ29yZTo6YXBwZW5kQ0ZGU3Ry aW5nKTogUmVuYW1lZCB0byByZW1vdmUgdGhlIHJlZHVuZGFudCB3b3JkCisgICAgICAgICJ2YWxp ZCIuIEl0J3MgdHJ1ZSB0aGF0IHRoaXMgZnVuY3Rpb24gd29ya3Mgb24gYSBzdHJpbmcgdGhhdCBp cyBhbHJlYWR5CisgICAgICAgIGtub3duIHRvIGJlIHZhbGlkLCBidXQgaW5jbHVkaW5nIHRoZSB3 b3JkIGluIHRoZSBmdW5jdGlvbiBuYW1lIGlzbid0CisgICAgICAgIGFsbCB0aGF0IGhlbHBmdWwg aW4gYSBzbWFsbCBjb250ZXh0IGxpa2UgdGhpcy4gQSBtb3JlIGJyb2FkbHkgZXhwb3NlZAorICAg ICAgICBmdW5jdGlvbiBtaWdodCBuZWVkIGEgbG9uZ2VyIG5hbWUsIGFuZCBpZiBzbyB3ZSB3b3Vs ZCBwcm9iYWJseSBjYWxsCisgICAgICAgIGl0IGFwcGVuZFZhbGlkQ0ZGU3RyaW5nLCBub3QgYXBw ZW5kQ0ZGVmFsaWRTdHJpbmcuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0 ZXI6OmFwcGVuZENGRlRhYmxlKTogTWFkZSB2YXJpb3VzIHR3ZWFrcywKKyAgICAgICAgaW5jbHVk aW5nIG1vcmUgc3BlY2lmaWMgb2YgbnVsbCBmb3IgdGhlICJubyB3ZWlnaHQiIHZhbHVlIGluc3Rl YWQgb2YKKyAgICAgICAgZWl0aGVyIGVtcHR5IG9yIG51bGwuCisgICAgICAgIChXZWJDb3JlOjpT VkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZFZPUkdUYWJsZSk6IFNpbXBsaWZpZWQgc29tZSBv ZgorICAgICAgICB0aGUgbnVtZXJpYyBwYXJzaW5nLCBzaW5jZSB0b0ludCBpcyBndWFyYW50ZWVk IHRvIHJldHVybiAwIHdoZW4gaXQgYWxzbworICAgICAgICB3b3VsZCByZXR1cm4gImZhbHNlIiBm b3Igb2suCisgICAgICAgIChXZWJDb3JlOjp3cml0ZUNGRkVuY29kZWROdW1iZXIpOiBEb24ndCB1 c2UgcG93ZiBqdXN0IHRvIG11bHRpcGx5IGJ5CisgICAgICAgIDJeMTYuIEl0J3MgcHJldHR5IGVh c3kgdG8gZG8gdGhhdCB3aXRoIHBsYWluIG9sZCBtdWx0aXBsaWNhdGlvbi4KKyAgICAgICAgKFdl YkNvcmU6OkNGRkJ1aWxkZXI6OkNGRkJ1aWxkZXIpOiBSZW5hbWVkIG1fZmlyc3RQb2ludCB0bwor ICAgICAgICBtX2hhc0JvdW5kaW5nQm94LgorICAgICAgICAoV2ViQ29yZTo6Q0ZGQnVpbGRlcjo6 Ym91bmRpbmdCb3gpOiBNYWRlIHRoaXMgcHVibGljIGFuZCBjb25zdCBhbmQgbWFkZQorICAgICAg ICB0aGUgcmVzdCBvZiB0aGUgY2xhc3MgcHJpdmF0ZS4KKyAgICAgICAgKFdlYkNvcmU6OkNGRkJ1 aWxkZXI6OnVwZGF0ZUJvdW5kaW5nQm94KTogVXNlZCBlYXJseSByZXR1cm4gYW5kIHJldmlzZWQK KyAgICAgICAgdG8gdXNlIG1faGFzQm91bmRpbmdCb3guCisgICAgICAgIChXZWJDb3JlOjpDRkZC dWlsZGVyOjp3cml0ZVBvaW50KTogQWRkZWQuIFVzZWQgdG8ga2VlcCB0aGUgb3RoZXIKKyAgICAg ICAgZnVuY3Rpb25zIGJlbG93IHNtYWxsZXIuCisgICAgICAgIChXZWJDb3JlOjpDRkZCdWlsZGVy Ojptb3ZlVG8pOiBNYXJrZWQgdmlydHVhbCBhbmQgc2ltcGxpZmllZCB1c2luZyB3cml0ZVBvaW50 LgorICAgICAgICBNaWdodCBmaW5kIGEgd2F5IHRvIHNpbXBsaWZ5IGV2ZW4gZnVydGhlciBieSB0 ZWFjaGluZyB3cml0ZVBvaW50IGFib3V0CisgICAgICAgIHRoZSBQYXRoQ29vcmRpbmF0ZU1vZGUu CisgICAgICAgIChXZWJDb3JlOjpDRkZCdWlsZGVyOjpsaW5lVG8pOiBEaXR0by4KKyAgICAgICAg KFdlYkNvcmU6OkNGRkJ1aWxkZXI6OmN1cnZlVG9DdWJpYyk6IERpdHRvLiBBbHNvIHJlbW92ZWQg Y29tbWVudCB0aGF0IHNhaWQKKyAgICAgICAgdGhlIGZ1bmN0aW9uIGNvdWxkIGJlIGZhc3Rlci4g Tm90IHN1cmUgdGhhdCdzIGltcG9ydGFudCB0byBzdGF0ZSBsaWtlIHRoaXMuCisgICAgICAgIChX ZWJDb3JlOjp0cmFuc2NvZGVHbHlwaFBhdGhzKTogVHdlYWtlZCBmb3JtYXR0aW5nIGEgYml0Lgor ICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpTVkdUb09URkZvbnRDb252 ZXJ0ZXIpOiBUd2Vha2VkIGxvZ2ljIGEgYml0LgorICAgICAgICAoV2ViQ29yZTo6aXNGb3VyQnl0 ZUFsaWduZWQpOiBGaXhlZCBtaW5vciBmb3JtYXR0aW5nIGlzc3VlLgorICAgICAgICAoV2ViQ29y ZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRUYWJsZSk6IFVwZGF0ZWQgZm9yIG5hbWUg Y2hhbmdlcy4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6Y29udmVy dFNWR1RvT1RGRm9udCk6IERpdHRvLgorCiAyMDE0LTA5LTE5ICBDaHJpcyBEdW1leiAgPGNkdW1l ekBhcHBsZS5jb20+CiAKICAgICAgICAgT3B0aW1pemUgTWFya3VwQWNjdW11bGF0b3I6OmFwcGVu ZFRleHQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RvT1RGRm9udENvbnZl cnNpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RvT1RGRm9udENvbnZlcnNpb24uY3Bw CmluZGV4IDY4YjBiNGYzNDRkOGEwNzBkYjI5YzNjNTAwNTFmMzNiYWIxNzkzZGQuLjA2NTZhZDhl ZWMxNWZiMGRjYTI3ZDg3NGFkNWRkM2I2OGNiMGM0MDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdUb09URkZvbnRDb252ZXJzaW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9z dmcvU1ZHVG9PVEZGb250Q29udmVyc2lvbi5jcHAKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29w eXJpZ2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHly aWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTU0LDEwICs1NCwxNyBAQCBzdGF0aWMgaW5saW5lIHZv aWQgd3JpdGUxNihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgdWludDE2X3QgdmFsdWUpCiBzdGF0aWMg aW5saW5lIHZvaWQgb3ZlcndyaXRlMzIoVmVjdG9yPGNoYXI+JiB2ZWN0b3IsIHVuc2lnbmVkIGxv Y2F0aW9uLCB1aW50MzJfdCB2YWx1ZSkKIHsKICAgICBBU1NFUlQodmVjdG9yLnNpemUoKSA+PSBs b2NhdGlvbiArIDQpOwotICAgICoodmVjdG9yLmRhdGEoKSArIGxvY2F0aW9uKSA9IHZhbHVlID4+ IDI0OwotICAgICoodmVjdG9yLmRhdGEoKSArIGxvY2F0aW9uICsgMSkgPSB2YWx1ZSA+PiAxNjsK LSAgICAqKHZlY3Rvci5kYXRhKCkgKyBsb2NhdGlvbiArIDIpID0gdmFsdWUgPj4gODsKLSAgICAq KHZlY3Rvci5kYXRhKCkgKyBsb2NhdGlvbiArIDMpID0gdmFsdWU7CisgICAgdmVjdG9yW2xvY2F0 aW9uXSA9IHZhbHVlID4+IDI0OworICAgIHZlY3Rvcltsb2NhdGlvbiArIDFdID0gdmFsdWUgPj4g MTY7CisgICAgdmVjdG9yW2xvY2F0aW9uICsgMl0gPSB2YWx1ZSA+PiA4OworICAgIHZlY3Rvclts b2NhdGlvbiArIDNdID0gdmFsdWU7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBvdmVyd3JpdGUx NihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgdW5zaWduZWQgbG9jYXRpb24sIHVpbnQxNl90IHZhbHVl KQoreworICAgIEFTU0VSVCh2ZWN0b3Iuc2l6ZSgpID49IGxvY2F0aW9uICsgMik7CisgICAgdmVj dG9yW2xvY2F0aW9uXSA9IHZhbHVlID4+IDg7CisgICAgdmVjdG9yW2xvY2F0aW9uICsgMV0gPSB2 YWx1ZTsKIH0KIAogY2xhc3MgU1ZHVG9PVEZGb250Q29udmVydGVyIHsKQEAgLTY2LDExICs3Mywx MCBAQCBwdWJsaWM6CiAgICAgVmVjdG9yPGNoYXI+IGNvbnZlcnRTVkdUb09URkZvbnQoKTsKIAog cHJpdmF0ZToKLSAgICB0eXBlZGVmIHVpbnQxNl90IFNJRDsgLy8gU3RyaW5nIElECiAgICAgc3Ry dWN0IEdseXBoRGF0YSB7CiAgICAgICAgIEdseXBoRGF0YShWZWN0b3I8Y2hhcj4gY2hhclN0cmlu ZywgY29uc3QgU1ZHR2x5cGhFbGVtZW50KiBnbHlwaEVsZW1lbnQsIGZsb2F0IGFkdmFuY2UsIEZs b2F0UmVjdCBib3VuZGluZ0JveCwgdWludDE2X3QgY29kZXBvaW50KQogICAgICAgICAgICAgOiBi b3VuZGluZ0JveChib3VuZGluZ0JveCkKLSAgICAgICAgICAgICwgY2hhclN0cmluZyhjaGFyU3Ry aW5nKQorICAgICAgICAgICAgLCBjaGFyU3RyaW5nKFdURjo6bW92ZShjaGFyU3RyaW5nKSkKICAg ICAgICAgICAgICwgZ2x5cGhFbGVtZW50KGdseXBoRWxlbWVudCkKICAgICAgICAgICAgICwgYWR2 YW5jZShhZHZhbmNlKQogICAgICAgICAgICAgLCBjb2RlcG9pbnQoY29kZXBvaW50KQpAQCAtODMs OCArODksOCBAQCBwcml2YXRlOgogICAgICAgICB1aW50MTZfdCBjb2RlcG9pbnQ7CiAgICAgfTsK IAotICAgIHN0YXRpYyBjb25zdCBzaXplX3Qga1NORlRIZWFkZXJTaXplID0gMTI7Ci0gICAgc3Rh dGljIGNvbnN0IHNpemVfdCBrRGlyZWN0b3J5RW50cnlTaXplID0gMTY7CisgICAgc3RhdGljIGNv bnN0IHNpemVfdCBoZWFkZXJTaXplID0gMTI7CisgICAgc3RhdGljIGNvbnN0IHNpemVfdCBkaXJl Y3RvcnlFbnRyeVNpemUgPSAxNjsKIAogICAgIHR5cGVkZWYgdm9pZCAoU1ZHVG9PVEZGb250Q29u dmVydGVyOjoqRm9udEFwcGVuZGluZ0Z1bmN0aW9uKShWZWN0b3I8Y2hhcj4gJikgY29uc3Q7CiAg ICAgdm9pZCBhcHBlbmRUYWJsZShjb25zdCBjaGFyIGlkZW50aWZpZXJbNF0sIFZlY3RvcjxjaGFy PiYsIEZvbnRBcHBlbmRpbmdGdW5jdGlvbik7CkBAIC0xNDYsMTEgKzE1MiwxMSBAQCB2b2lkIFNW R1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kQ01BUFRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0 KSBjb25zdAogICAgIHdyaXRlMTYocmVzdWx0LCBlbnRyeVNlbGVjdG9yKTsKICAgICB3cml0ZTE2 KHJlc3VsdCwgKDIgKiBzZWdDb3VudCkgLSBzZWFyY2hSYW5nZSk7CiAKLSAgICBmb3IgKGNvbnN0 IGF1dG8mIGdseXBoIDogbV9nbHlwaHMpCisgICAgZm9yIChhdXRvJiBnbHlwaCA6IG1fZ2x5cGhz KQogICAgICAgICB3cml0ZTE2KHJlc3VsdCwgZ2x5cGguY29kZXBvaW50KTsgLy8gRW5kQ29kZQog ICAgIHdyaXRlMTYocmVzdWx0LCAweEZGRkYpOyAvLyAiVG8gZW5zdXJlIHRoYXQgdGhlIHNlYXJj aCB3aWxsIHRlcm1pbmF0ZSwgdGhlIGZpbmFsIGVuZENvZGUgdmFsdWUgbXVzdCBiZSAweEZGRkYu IgogICAgIHdyaXRlMTYocmVzdWx0LCAwKTsgLy8gUmVzZXJ2ZWQKLSAgICBmb3IgKGNvbnN0IGF1 dG8mIGdseXBoIDogbV9nbHlwaHMpCisgICAgZm9yIChhdXRvJiBnbHlwaCA6IG1fZ2x5cGhzKQog ICAgICAgICB3cml0ZTE2KHJlc3VsdCwgZ2x5cGguY29kZXBvaW50KTsgLy8gc3RhcnRDb2RlCiAg ICAgd3JpdGUxNihyZXN1bHQsIDB4RkZGRik7CiAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8 IG1fZ2x5cGhzLnNpemUoKTsgKytpKSB7CkBAIC0xNjcsMTIgKzE3Myw4IEBAIHZvaWQgU1ZHVG9P VEZGb250Q29udmVydGVyOjphcHBlbmRIRUFEVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNv bnN0CiB7CiAgICAgd3JpdGUzMihyZXN1bHQsIDB4MDAwMTAwMDApOyAvLyBWZXJzaW9uCiAgICAg d3JpdGUzMihyZXN1bHQsIDB4MDAwMTAwMDApOyAvLyBSZXZpc2lvbgotICAgIHdyaXRlMzIocmVz dWx0LCAwKTsgLy8gQ2hlY2tzdW0gYWRqdXN0bWVudAotICAgIC8vIE1hZ2ljIG51bWJlci4gIlNl dCB0byAweDVGMEYzQ0Y1IgotICAgIHJlc3VsdC5hcHBlbmQoMHg1Rik7Ci0gICAgcmVzdWx0LmFw cGVuZCgweDBGKTsKLSAgICByZXN1bHQuYXBwZW5kKDB4M0MpOwotICAgIHJlc3VsdC5hcHBlbmQo LTB4MEIpOyAvLyBXcmFwYXJvdW5kCisgICAgd3JpdGUzMihyZXN1bHQsIDApOyAvLyBDaGVja3N1 bSBhZGp1c3RtZW50IHBsYWNlaG9sZGVyOyB0byBiZSBvdmVyd3JpdHRlbiBieSB0aGUgY2FsbGVy LgorICAgIHdyaXRlMzIocmVzdWx0LCAweDVGMEYzQ0Y1KTsgLy8gTWFnaWMgbnVtYmVyLgogICAg IHdyaXRlMTYocmVzdWx0LCAoMSA8PCA5KSB8IDEpOwogCiAgICAgdWludDE2X3QgdW5pdHNQZXJF bSA9IG1fZm9udEZhY2VFbGVtZW50ID8gbV9mb250RmFjZUVsZW1lbnQtPnVuaXRzUGVyRW0oKSA6 IDA7CkBAIC0xOTMsNyArMTk1LDcgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVu ZEhFQURUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICB3cml0ZTE2KHJlc3Vs dCwgMCk7IC8vIEdseXBoIGRhdGEgZm9ybWF0CiB9CiAKLS8vIEFzc3VtcHRpb246IFQyIGNhbiBo b2xkIGV2ZXJ5IHZhbHVlIHRoYXQgYSBUMSBjYW4gaG9sZAorLy8gQXNzdW1wdGlvbjogVDIgY2Fu IGhvbGQgZXZlcnkgdmFsdWUgdGhhdCBhIFQxIGNhbiBob2xkLgogdGVtcGxhdGUgPHR5cGVuYW1l IFQxLCB0eXBlbmFtZSBUMj4KIHN0YXRpYyBpbmxpbmUgVDEgY2xhbXBUbyhUMiB4KQogewpAQCAt MjA0LDM1ICsyMDYsMzcgQEAgc3RhdGljIGlubGluZSBUMSBjbGFtcFRvKFQyIHgpCiAKIHZvaWQg U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRISEVBVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1 bHQpIGNvbnN0CiB7Ci0gICAgdWludDE2X3QgdW5pdHNQZXJFbSA9IDA7Ci0gICAgaW50MTZfdCBh c2NlbnQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludDE2X3Q+OjptYXgoKTsKLSAgICBpbnQxNl90 IGRlc2NlbnQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludDE2X3Q+OjptYXgoKTsKLSAgICBpZiAo bV9mb250RmFjZUVsZW1lbnQpIHsKKyAgICB1aW50MTZfdCB1bml0c1BlckVtOworICAgIGludDE2 X3QgYXNjZW50OworICAgIGludDE2X3QgZGVzY2VudDsKKyAgICBpZiAoIW1fZm9udEZhY2VFbGVt ZW50KSB7CisgICAgICAgIHVuaXRzUGVyRW0gPSAwOworICAgICAgICBhc2NlbnQgPSBzdGQ6Om51 bWVyaWNfbGltaXRzPGludDE2X3Q+OjptYXgoKTsKKyAgICAgICAgZGVzY2VudCA9IHN0ZDo6bnVt ZXJpY19saW1pdHM8aW50MTZfdD46Om1heCgpOworICAgIH0gZWxzZSB7CiAgICAgICAgIHVuaXRz UGVyRW0gPSBtX2ZvbnRGYWNlRWxlbWVudC0+dW5pdHNQZXJFbSgpOwogICAgICAgICBhc2NlbnQg PSBtX2ZvbnRGYWNlRWxlbWVudC0+YXNjZW50KCk7CiAgICAgICAgIGRlc2NlbnQgPSBtX2ZvbnRG YWNlRWxlbWVudC0+ZGVzY2VudCgpOwotICAgIH0KIAotICAgIC8vIE1hbnkgcGxhdGZvcm1zIHdp bGwgYXNzdW1lIHRoYXQgYSAwIGFzY2VudCBvciBkZXNjZW50IG1lYW5zIHRoYXQgdGhlIHBsYXRm b3JtIHNob3VsZCBzeW50aGVzaXplIGEgZm9udAotICAgIC8vIGJhc2VkIG9uIGEgaGV1cmlzdGlj LiBIb3dldmVyLCBtYW55IFNWRyBmb250cyBsZWdpdGltaXRlbHkgaGF2ZSBhIDAgYXNjZW50IG9y IGRlc2NlbnQuIFRoZXJlZm9yZSwKLSAgICAvLyB3ZSBzaG91bGQgc3BlY2lmeSBhIHNpbmdsZSBG VW5pdCBpbnN0ZWFkLCB3aGljaCBpcyBhcyBjbG9zZSBhcyB3ZSBjYW4gZ2V0IHRvIDAgd2l0aG91 dCBhY3R1YWxseSBiZWluZwotICAgIC8vIGl0LgotICAgIGlmICghYXNjZW50KQotICAgICAgICBh c2NlbnQgPSAxOwotICAgIGlmICghZGVzY2VudCkKLSAgICAgICAgZGVzY2VudCA9IDE7CisgICAg ICAgIC8vIFNvbWUgcGxhdGZvcm1zLCBpbmNsdWRpbmcgT1MgWCwgdXNlIDAgYXNjZW50IGFuZCBk ZXNjZW50IHRvIG1lYW4gdGhhdCB0aGUgcGxhdGZvcm0gc2hvdWxkIHN5bnRoZXNpemUKKyAgICAg ICAgLy8gYSB2YWx1ZSBiYXNlZCBvbiBhIGhldXJpc3RpYy4gSG93ZXZlciwgU1ZHIGZvbnRzIGNh biBsZWdpdGltYXRlbHkgaGF2ZSAwIGZvciBhc2NlbnQgb3IgZGVzY2VudC4KKyAgICAgICAgLy8g U3BlY2lmaW5nIGEgc2luZ2xlIEZVbml0IGluc3RlYWQgZ2V0cyB1cyBhcyBjbG9zZSB0byAwIGFz IHdlIGNhbiB3aXRob3V0IHRyaWdnZXJpbmcgdGhlIHN5bnRoZXNpcy4KKyAgICAgICAgaWYgKCFh c2NlbnQpCisgICAgICAgICAgICBhc2NlbnQgPSAxOworICAgICAgICBpZiAoIWRlc2NlbnQpCisg ICAgICAgICAgICBkZXNjZW50ID0gMTsKKyAgICB9CiAKICAgICB3cml0ZTMyKHJlc3VsdCwgMHgw MDAxMDAwMCk7IC8vIFZlcnNpb24KICAgICB3cml0ZTE2KHJlc3VsdCwgYXNjZW50KTsKICAgICB3 cml0ZTE2KHJlc3VsdCwgZGVzY2VudCk7Ci0gICAgLy8gV2ViS2l0J3MgU1ZHIGNvZGVwYXRoIGhh cmRjb2RlcyB0aGUgbGluZSBnYXAgdG8gYmUgMS8xMHRoIG9mIHRoZSBmb250IHNpemUgKHNlZSBy Mjk3MTkpLiBNYXRjaGluZyB0aGF0Ci0gICAgLy8gYWxsb3dzIHVzIHRvIGhhdmUgY29uc2lzdGVu dCByZW5kZXJpbmdzIGJldHdlZW4gdGhlIHR3byBwYXRocy4KLSAgICB3cml0ZTE2KHJlc3VsdCwg dW5pdHNQZXJFbSAvIDEwKTsgLy8gTGluZSBnYXAKLSAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBU bzx1aW50MTZfdCwgZmxvYXQ+KG1fYWR2YW5jZVdpZHRoTWF4KSk7Ci0gICAgd3JpdGUxNihyZXN1 bHQsIGNsYW1wVG88aW50MTZfdCwgZmxvYXQ+KG1fYm91bmRpbmdCb3gueCgpKSk7IC8vIE1pbmlt dW0gbGVmdCBzaWRlIGJlYXJpbmcKLSAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBUbzxpbnQxNl90 LCBmbG9hdD4obV9taW5SaWdodFNpZGVCZWFyaW5nKSk7IC8vIE1pbmltdW0gcmlnaHQgc2lkZSBi ZWFyaW5nCi0gICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdCwgZmxvYXQ+KG1fYm91 bmRpbmdCb3gubWF4WCgpKSk7IC8vIFggbWF4aW11bSBleHRlbnQKLSAgICAvLyBXZWJLaXQgZHJh d3MgdGhlIGNhcmV0CisgICAgLy8gV2ViS2l0IFNWRyBmb250IHJlbmRlcmluZyBoYXMgaGFyZCBj b2RlZCB0aGUgbGluZSBnYXAgdG8gYmUgMS8xMHRoIG9mIHRoZSBmb250IHNpemUgc2luY2UgMjAw OCAoc2VlIHIyOTcxOSkuCisgICAgd3JpdGUxNihyZXN1bHQsICh1bml0c1BlckVtICsgNSkgLyAx MCk7IC8vIExpbmUgZ2FwCisgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88dWludDE2X3Q+KG1f YWR2YW5jZVdpZHRoTWF4KSk7CisgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdD4o bV9ib3VuZGluZ0JveC54KCkpKTsgLy8gTWluaW11bSBsZWZ0IHNpZGUgYmVhcmluZworICAgIHdy aXRlMTYocmVzdWx0LCBjbGFtcFRvPGludDE2X3Q+KG1fbWluUmlnaHRTaWRlQmVhcmluZykpOyAv LyBNaW5pbXVtIHJpZ2h0IHNpZGUgYmVhcmluZworICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRv PGludDE2X3Q+KG1fYm91bmRpbmdCb3gubWF4WCgpKSk7IC8vIFggbWF4aW11bSBleHRlbnQKKyAg ICAvLyBTaW5jZSBXZWJLaXQgZHJhd3MgdGhlIGNhcmV0IGFuZCBpZ25vcmVzIHRoZSBmb2xsb3dp bmcgdmFsdWVzLCBpdCBkb2Vzbid0IG1hdHRlciB3aGF0IHdlIHNldCB0aGVtIHRvLgogICAgIHdy aXRlMTYocmVzdWx0LCAxKTsgLy8gVmVydGljYWwgY2FyZXQKICAgICB3cml0ZTE2KHJlc3VsdCwg MCk7IC8vIFZlcnRpY2FsIGNhcmV0CiAgICAgd3JpdGUxNihyZXN1bHQsIDApOyAvLyAiU2V0IHZh bHVlIHRvIDAgZm9yIG5vbi1zbGFudGVkIGZvbnRzIgpAQCAtMjQ0LDkgKzI0OCw5IEBAIHZvaWQg U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRISEVBVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1 bHQpIGNvbnN0CiAKIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRITVRYVGFibGUo VmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiB7Ci0gICAgZm9yIChjb25zdCBhdXRvJiBnbHlw aCA6IG1fZ2x5cGhzKSB7Ci0gICAgICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPHVpbnQxNl90 LCBmbG9hdD4oZ2x5cGguYWR2YW5jZSkpOwotICAgICAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBU bzxpbnQxNl90LCBmbG9hdD4oZ2x5cGguYm91bmRpbmdCb3gueCgpKSk7CisgICAgZm9yIChhdXRv JiBnbHlwaCA6IG1fZ2x5cGhzKSB7CisgICAgICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPHVp bnQxNl90PihnbHlwaC5hZHZhbmNlKSk7CisgICAgICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRv PGludDE2X3Q+KGdseXBoLmJvdW5kaW5nQm94LngoKSkpOwogICAgIH0KIH0KIApAQCAtMjg4LDE0 ICsyOTIsMTYgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZE5BTUVUYWJsZShW ZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKIAogdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OmFwcGVuZE9TMlRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogewotICAgIC8vIEZJ WE1FOiBXZSBjYW4gbG9vayBhdCB0aGUgbWlzc2luZyBnbHlwaCBpbmZvIGZvciB0aGlzCi0gICAg dWludDE2X3QgdW5pdHNQZXJFbSA9IG1fZm9udEZhY2VFbGVtZW50ID8gbV9mb250RmFjZUVsZW1l bnQtPnVuaXRzUGVyRW0oKSA6IDA7Ci0gICAgaW50MTZfdCBhdmVyYWdlQWR2YW5jZSA9IHVuaXRz UGVyRW0gLyAyOwotICAgIGF1dG8mIGF0dHJpYnV0ZSA9IG1fZm9udEVsZW1lbnQuZmFzdEdldEF0 dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKTsKLSAgICBib29sIG9rID0gdHJ1ZTsK LSAgICBpbnQgdmFsdWUgPSBhdHRyaWJ1dGUudG9JbnQoJm9rKTsKKyAgICBpbnQxNl90IGF2ZXJh Z2VBZHZhbmNlOworICAgIGJvb2wgb2s7CisgICAgaW50IHZhbHVlID0gbV9mb250RWxlbWVudC5m YXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjpob3Jpel9hZHZfeEF0dHIpLnRvSW50KCZvayk7CiAg ICAgaWYgKG9rKQotICAgICAgICBhdmVyYWdlQWR2YW5jZSA9IGNsYW1wVG88aW50MTZfdCwgaW50 Pih2YWx1ZSk7CisgICAgICAgIGF2ZXJhZ2VBZHZhbmNlID0gY2xhbXBUbzxpbnQxNl90Pih2YWx1 ZSk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIEZJWE1FOiBXZSBjYW4gbG9vayBhdCB0aGUgbWlz c2luZyBnbHlwaCBpbmZvIGZvciB0aGlzLgorICAgICAgICB1aW50MTZfdCB1bml0c1BlckVtID0g bV9mb250RmFjZUVsZW1lbnQgPyBtX2ZvbnRGYWNlRWxlbWVudC0+dW5pdHNQZXJFbSgpIDogMDsK KyAgICAgICAgYXZlcmFnZUFkdmFuY2UgPSB1bml0c1BlckVtIC8gMjsKKyAgICB9CiAKICAgICB3 cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnNpb24KICAgICB3cml0ZTE2KHJlc3VsdCwgYXZlcmFn ZUFkdmFuY2UpOwpAQCAtMzE1LDI3ICszMjEsMjMgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0 ZXI6OmFwcGVuZE9TMlRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogICAgIHdyaXRl MTYocmVzdWx0LCAwKTsgLy8gU3RyaWtlb3V0IFBvc2l0aW9uCiAgICAgd3JpdGUxNihyZXN1bHQs IDApOyAvLyBObyBjbGFzc2lmaWNhdGlvbgogCi0gICAgVmVjdG9yPHVuc2lnbmVkIGNoYXI+IHNw ZWNpZmllZFBhbm9zZTsKKyAgICB1bnNpZ25lZCBudW1QYW5vc2VCeXRlcyA9IDA7CisgICAgY2hh ciBwYW5vc2VCeXRlc1sxMF07CiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KSB7Ci0gICAgICAg IGNvbnN0IGF1dG8mIGF0dHJpYnV0ZSA9IG1fZm9udEZhY2VFbGVtZW50LT5mYXN0R2V0QXR0cmli dXRlKFNWR05hbWVzOjpwYW5vc2VfMUF0dHIpOwotICAgICAgICBWZWN0b3I8U3RyaW5nPiBzcGxp dDsKLSAgICAgICAgU3RyaW5nKGF0dHJpYnV0ZSkuc3BsaXQoIiAiLCBzcGxpdCk7Ci0gICAgICAg IGlmIChzcGxpdC5zaXplKCkgPT0gMTApIHsKLSAgICAgICAgICAgIGZvciAoY29uc3QgYXV0byYg cyA6IHNwbGl0KSB7Ci0gICAgICAgICAgICAgICAgYm9vbCBvayA9IHRydWU7Ci0gICAgICAgICAg ICAgICAgaW50IHZhbHVlID0gcy50b0ludCgmb2spOwotICAgICAgICAgICAgICAgIGlmICghb2sg fHwgdmFsdWUgPCAwIHx8IHZhbHVlID4gMHhGRikgewotICAgICAgICAgICAgICAgICAgICBzcGVj aWZpZWRQYW5vc2UuY2xlYXIoKTsKLSAgICAgICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAg ICAgICAgICAgfQotICAgICAgICAgICAgICAgIHNwZWNpZmllZFBhbm9zZS5hcHBlbmQoc3RhdGlj X2Nhc3Q8dW5zaWduZWQgY2hhcj4odmFsdWUpKTsKKyAgICAgICAgVmVjdG9yPFN0cmluZz4gc3Ry aW5nczsKKyAgICAgICAgbV9mb250RmFjZUVsZW1lbnQtPmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFt ZXM6OnBhbm9zZV8xQXR0cikuc3RyaW5nKCkuc3BsaXQoJyAnLCBzdHJpbmdzKTsKKyAgICAgICAg aWYgKHN0cmluZ3Muc2l6ZSgpID09IDEwKSB7CisgICAgICAgICAgICBmb3IgKGF1dG8mIHN0cmlu ZyA6IHN0cmluZ3MpIHsKKyAgICAgICAgICAgICAgICBib29sIG9rOworICAgICAgICAgICAgICAg IGludCB2YWx1ZSA9IHN0cmluZy50b0ludCgmb2spOworICAgICAgICAgICAgICAgIGlmIChvayAm JiB2YWx1ZSA+PSAwICYmIHZhbHVlIDw9IDB4RkYpCisgICAgICAgICAgICAgICAgICAgIHBhbm9z ZUJ5dGVzW251bVBhbm9zZUJ5dGVzKytdID0gdmFsdWU7CiAgICAgICAgICAgICB9CiAgICAgICAg IH0KICAgICB9Ci0KLSAgICBpZiAoc3BlY2lmaWVkUGFub3NlLnNpemUoKSA9PSAxMCkgewotICAg ICAgICBmb3IgKGNoYXIgYyA6IHNwZWNpZmllZFBhbm9zZSkKLSAgICAgICAgICAgIHJlc3VsdC5h cHBlbmQoYyk7CisgICAgaWYgKG51bVBhbm9zZUJ5dGVzID09IDEwKSB7CisgICAgICAgIGZvciAo Y2hhciBieXRlIDogcGFub3NlQnl0ZXMpCisgICAgICAgICAgICByZXN1bHQuYXBwZW5kKGJ5dGUp OwogICAgIH0gZWxzZSB7CiAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMTA7ICsraSkKICAg ICAgICAgICAgIHJlc3VsdC5hcHBlbmQoMCk7IC8vIFBBTk9TRTogQW55CkBAIC0zNzEsNyArMzcz LDcgQEAgc3RhdGljIGJvb2wgaXNWYWxpZFN0cmluZ0ZvckNGRihjb25zdCBTdHJpbmcmIHN0cmlu ZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQgYXBwZW5kQ0ZGVmFsaWRTdHJp bmcoVmVjdG9yPGNoYXI+JiBvdXRwdXQsIGNvbnN0IFN0cmluZyYgc3RyaW5nKQorc3RhdGljIHZv aWQgYXBwZW5kQ0ZGU3RyaW5nKFZlY3RvcjxjaGFyPiYgb3V0cHV0LCBjb25zdCBTdHJpbmcmIHN0 cmluZykKIHsKICAgICBBU1NFUlQoaXNWYWxpZFN0cmluZ0ZvckNGRihzdHJpbmcpKTsKICAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgc3RyaW5nLmxlbmd0aCgpOyArK2kpCkBAIC0zODEsNiAr MzgzLDcgQEAgc3RhdGljIHZvaWQgYXBwZW5kQ0ZGVmFsaWRTdHJpbmcoVmVjdG9yPGNoYXI+JiBv dXRwdXQsIGNvbnN0IFN0cmluZyYgc3RyaW5nKQogdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OmFwcGVuZENGRlRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogewogICAgIGF1dG8g c3RhcnRpbmdPZmZzZXQgPSByZXN1bHQuc2l6ZSgpOworCiAgICAgLy8gSGVhZGVyCiAgICAgcmVz dWx0LmFwcGVuZCgxKTsgLy8gTWFqb3IgdmVyc2lvbgogICAgIHJlc3VsdC5hcHBlbmQoMCk7IC8v IE1pbm9yIHZlcnNpb24KQEAgLTM5MCw3ICszOTMsNyBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZl cnRlcjo6YXBwZW5kQ0ZGVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgLy8g TmFtZSBJTkRFWAogICAgIFN0cmluZyBmb250TmFtZTsKICAgICBpZiAobV9mb250RmFjZUVsZW1l bnQpIHsKLSAgICAgICAgLy8gRklYTUU6IGZvbnRGYW1pbHkoKSBoZXJlIG1pZ2h0IG5vdCBiZSBx dWl0ZSB3aGF0IEkgd2FudAorICAgICAgICAvLyBGSVhNRTogZm9udEZhbWlseSgpIGhlcmUgbWln aHQgbm90IGJlIHF1aXRlIHdoYXQgd2Ugd2FudC4KICAgICAgICAgU3RyaW5nIHBvdGVudGlhbEZv bnROYW1lID0gbV9mb250RmFtaWx5OwogICAgICAgICBpZiAoaXNWYWxpZFN0cmluZ0ZvckNGRihw b3RlbnRpYWxGb250TmFtZSkpCiAgICAgICAgICAgICBmb250TmFtZSA9IHBvdGVudGlhbEZvbnRO YW1lOwpAQCAtMzk5LDcgKzQwMiw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBl bmRDRkZUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICByZXN1bHQuYXBwZW5k KDQpOyAvLyBPZmZzZXRzIGluIHRoaXMgSU5ERVggYXJlIDQgYnl0ZXMgbG9uZwogICAgIHdyaXRl MzIocmVzdWx0LCAxKTsgLy8gMS1pbmRleCBvZmZzZXQgb2YgbmFtZSBkYXRhCiAgICAgd3JpdGUz MihyZXN1bHQsIGZvbnROYW1lLmxlbmd0aCgpICsgMSk7IC8vIDEtaW5kZXggb2Zmc2V0IGp1c3Qg cGFzdCBlbmQgb2YgbmFtZSBkYXRhCi0gICAgYXBwZW5kQ0ZGVmFsaWRTdHJpbmcocmVzdWx0LCBm b250TmFtZSk7CisgICAgYXBwZW5kQ0ZGU3RyaW5nKHJlc3VsdCwgZm9udE5hbWUpOwogCiAgICAg U3RyaW5nIHdlaWdodDsKICAgICBpZiAobV9mb250RmFjZUVsZW1lbnQpIHsKQEAgLTQxNiw3ICs0 MTksNyBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kQ0ZGVGFibGUoVmVjdG9y PGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgY29uc3QgY2hhciBjaGFyc2V0SW5kZXhLZXkgPSAx NTsKICAgICBjb25zdCBjaGFyIGNoYXJzdHJpbmdzSW5kZXhLZXkgPSAxNzsKICAgICBjb25zdCB1 aW50MzJfdCB1c2VyRGVmaW5lZFN0cmluZ1N0YXJ0SW5kZXggPSAzOTE7Ci0gICAgY29uc3QgdW5z aWduZWQgc2l6ZU9mVG9wSW5kZXggPSA0NSArICh3ZWlnaHQuaXNFbXB0eSgpID8gMCA6IDYpOwor ICAgIGNvbnN0IHVuc2lnbmVkIHNpemVPZlRvcEluZGV4ID0gNDUgKyAod2VpZ2h0LmlzTnVsbCgp ID8gMCA6IDYpOwogCiAgICAgLy8gVG9wIERJQ1QgSU5ERVguCiAgICAgd3JpdGUxNihyZXN1bHQs IDEpOyAvLyBJTkRFWCBjb250YWlucyAxIGVsZW1lbnQKQEAgLTQzNCwxOSArNDM3LDE5IEBAIHZv aWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRDRkZUYWJsZShWZWN0b3I8Y2hhcj4mIHJl c3VsdCkgY29uc3QKICAgICByZXN1bHQuYXBwZW5kKG9wZXJhbmQzMkJpdCk7CiAgICAgd3JpdGUz MihyZXN1bHQsIHVzZXJEZWZpbmVkU3RyaW5nU3RhcnRJbmRleCk7CiAgICAgcmVzdWx0LmFwcGVu ZChmYW1pbHlOYW1lS2V5KTsKLSAgICBpZiAoIXdlaWdodC5pc0VtcHR5KCkpIHsKKyAgICBpZiAo IXdlaWdodC5pc051bGwoKSkgewogICAgICAgICByZXN1bHQuYXBwZW5kKG9wZXJhbmQzMkJpdCk7 CiAgICAgICAgIHdyaXRlMzIocmVzdWx0LCB1c2VyRGVmaW5lZFN0cmluZ1N0YXJ0SW5kZXggKyAx KTsKICAgICAgICAgcmVzdWx0LmFwcGVuZCh3ZWlnaHRLZXkpOwogICAgIH0KICAgICByZXN1bHQu YXBwZW5kKG9wZXJhbmQzMkJpdCk7Ci0gICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJf dCwgZmxvYXQ+KG1fYm91bmRpbmdCb3gueCgpKSk7CisgICAgd3JpdGUzMihyZXN1bHQsIGNsYW1w VG88aW50MzJfdD4obV9ib3VuZGluZ0JveC54KCkpKTsKICAgICByZXN1bHQuYXBwZW5kKG9wZXJh bmQzMkJpdCk7Ci0gICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJfdCwgZmxvYXQ+KG1f Ym91bmRpbmdCb3gubWF4WCgpKSk7CisgICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJf dD4obV9ib3VuZGluZ0JveC5tYXhYKCkpKTsKICAgICByZXN1bHQuYXBwZW5kKG9wZXJhbmQzMkJp dCk7Ci0gICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJfdCwgZmxvYXQ+KG1fYm91bmRp bmdCb3gueSgpKSk7CisgICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJfdD4obV9ib3Vu ZGluZ0JveC55KCkpKTsKICAgICByZXN1bHQuYXBwZW5kKG9wZXJhbmQzMkJpdCk7Ci0gICAgd3Jp dGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJfdCwgZmxvYXQ+KG1fYm91bmRpbmdCb3gubWF4WSgp KSk7CisgICAgd3JpdGUzMihyZXN1bHQsIGNsYW1wVG88aW50MzJfdD4obV9ib3VuZGluZ0JveC5t YXhZKCkpKTsKICAgICByZXN1bHQuYXBwZW5kKGZvbnRCQm94S2V5KTsKICAgICByZXN1bHQuYXBw ZW5kKG9wZXJhbmQzMkJpdCk7CiAgICAgdW5zaWduZWQgY2hhcnNldE9mZnNldExvY2F0aW9uID0g cmVzdWx0LnNpemUoKTsKQEAgLTQ1OSwxOCArNDYyLDE4IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29u dmVydGVyOjphcHBlbmRDRkZUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICBB U1NFUlQocmVzdWx0LnNpemUoKSA9PSB0b3BEaWN0U3RhcnQgKyBzaXplT2ZUb3BJbmRleCk7CiAK ICAgICAvLyBTdHJpbmcgSU5ERVgKLSAgICB3cml0ZTE2KHJlc3VsdCwgMSArICh3ZWlnaHQuaXNF bXB0eSgpID8gMCA6IDEpKTsgLy8gTnVtYmVyIG9mIGVsZW1lbnRzIGluIElOREVYCisgICAgd3Jp dGUxNihyZXN1bHQsIDEgKyAod2VpZ2h0LmlzTnVsbCgpID8gMCA6IDEpKTsgLy8gTnVtYmVyIG9m IGVsZW1lbnRzIGluIElOREVYCiAgICAgcmVzdWx0LmFwcGVuZCg0KTsgLy8gT2Zmc2V0cyBpbiB0 aGlzIElOREVYIGFyZSA0IGJ5dGVzIGxvbmcKICAgICB1aW50MzJfdCBvZmZzZXQgPSAxOwogICAg IHdyaXRlMzIocmVzdWx0LCBvZmZzZXQpOwogICAgIG9mZnNldCArPSBmb250TmFtZS5sZW5ndGgo KTsKICAgICB3cml0ZTMyKHJlc3VsdCwgb2Zmc2V0KTsKLSAgICBpZiAoIXdlaWdodC5pc0VtcHR5 KCkpIHsKKyAgICBpZiAoIXdlaWdodC5pc051bGwoKSkgewogICAgICAgICBvZmZzZXQgKz0gd2Vp Z2h0Lmxlbmd0aCgpOwogICAgICAgICB3cml0ZTMyKHJlc3VsdCwgb2Zmc2V0KTsKICAgICB9Ci0g ICAgYXBwZW5kQ0ZGVmFsaWRTdHJpbmcocmVzdWx0LCBmb250TmFtZSk7Ci0gICAgYXBwZW5kQ0ZG VmFsaWRTdHJpbmcocmVzdWx0LCB3ZWlnaHQpOworICAgIGFwcGVuZENGRlN0cmluZyhyZXN1bHQs IGZvbnROYW1lKTsKKyAgICBhcHBlbmRDRkZTdHJpbmcocmVzdWx0LCB3ZWlnaHQpOwogCiAgICAg d3JpdGUxNihyZXN1bHQsIDApOyAvLyBFbXB0eSBzdWJyb3V0aW5lIElOREVYCiAKQEAgLTQ5OSw0 MiArNTAyLDI2IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWT1JHVGFibGUo VmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgd3JpdGUxNihyZXN1bHQsIDEpOyAvLyBN YWpvciB2ZXJzaW9uCiAgICAgd3JpdGUxNihyZXN1bHQsIDApOyAvLyBNaW5vciB2ZXJzaW9uCiAK LSAgICAvLyBGSVhNRTogV2UgY2FuIHVzZSB0aGUgbWlzc2luZyBnbHlwaCBpbmZvIGZvciB0aGlz Ci0gICAgaW50MTZfdCBkZWZhdWx0VmVydGljYWxPcmlnaW5ZID0gMDsKLSAgICBhdXRvJiBhdHRy aWJ1dGUgPSBtX2ZvbnRFbGVtZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnZlcnRfb3Jp Z2luX3lBdHRyKTsKLSAgICBpZiAoYXR0cmlidXRlICE9IG51bGxBdG9tICYmIGF0dHJpYnV0ZS5p czhCaXQoKSkgewotICAgICAgICBib29sIG9rOwotICAgICAgICBpbnQgdmVydGljYWxPcmlnaW5Z ID0gYXR0cmlidXRlLnRvSW50KCZvayk7Ci0gICAgICAgIGlmIChvayAmJiB2ZXJ0aWNhbE9yaWdp blkpCi0gICAgICAgICAgICBkZWZhdWx0VmVydGljYWxPcmlnaW5ZID0gdmVydGljYWxPcmlnaW5Z OwotICAgIH0KLSAgICB3cml0ZTE2KHJlc3VsdCwgZGVmYXVsdFZlcnRpY2FsT3JpZ2luWSk7Cisg ICAgLy8gRklYTUU6IFdlIGNhbiB1c2UgdGhlIG1pc3NpbmcgZ2x5cGggaW5mbyBmb3IgdGhpcy4K KyAgICB3cml0ZTE2KHJlc3VsdCwgbV9mb250RWxlbWVudC5mYXN0R2V0QXR0cmlidXRlKFNWR05h bWVzOjp2ZXJ0X29yaWdpbl95QXR0cikudG9JbnQoKSk7CiAKLSAgICBWZWN0b3I8c3RkOjpwYWly PHVpbnQxNl90LCBpbnQxNl90Pj4gb3JpZ2luczsKKyAgICBhdXRvIHRhYmxlU2l6ZU9mZnNldCA9 IHJlc3VsdC5zaXplKCk7CisgICAgd3JpdGUxNihyZXN1bHQsIDApOyAvLyBQbGFjZSB0byB3cml0 ZSB0YWJsZSBzaXplLgogICAgIGZvciAodWludDE2X3QgaSA9IDA7IGkgPCBtX2dseXBocy5zaXpl KCk7ICsraSkgewotICAgICAgICBpZiAobV9nbHlwaHNbaV0uZ2x5cGhFbGVtZW50KSB7Ci0gICAg ICAgICAgICBhdXRvJiBhdHRyaWJ1dGUgPSBtX2dseXBoc1tpXS5nbHlwaEVsZW1lbnQtPmZhc3RH ZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnZlcnRfb3JpZ2luX3lBdHRyKTsKLSAgICAgICAgICAgIGlm IChhdHRyaWJ1dGUgIT0gbnVsbEF0b20gJiYgYXR0cmlidXRlLmlzOEJpdCgpKSB7Ci0gICAgICAg ICAgICAgICAgYm9vbCBvazsKLSAgICAgICAgICAgICAgICBpbnQxNl90IHZlcnRpY2FsT3JpZ2lu WSA9IGF0dHJpYnV0ZS50b0ludCgmb2spOwotICAgICAgICAgICAgICAgIGlmIChvayAmJiB2ZXJ0 aWNhbE9yaWdpblkpCi0gICAgICAgICAgICAgICAgICAgIG9yaWdpbnMuYXBwZW5kKHN0ZDo6bWFr ZV9wYWlyKGksIHZlcnRpY2FsT3JpZ2luWSkpOworICAgICAgICBpZiAoYXV0byogZ2x5cGggPSBt X2dseXBoc1tpXS5nbHlwaEVsZW1lbnQpIHsKKyAgICAgICAgICAgIGlmIChpbnQxNl90IHZlcnRp Y2FsT3JpZ2luWSA9IGdseXBoLT5mYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjp2ZXJ0X29yaWdp bl95QXR0cikudG9JbnQoKSkgeworICAgICAgICAgICAgICAgIHdyaXRlMTYocmVzdWx0LCBpKTsK KyAgICAgICAgICAgICAgICB3cml0ZTE2KHJlc3VsdCwgdmVydGljYWxPcmlnaW5ZKTsKICAgICAg ICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgICB3cml0ZTE2KHJlc3VsdCwgb3JpZ2lucy5z aXplKCkpOwotCi0gICAgZm9yIChjb25zdCBhdXRvJiBwIDogb3JpZ2lucykgewotICAgICAgICB3 cml0ZTE2KHJlc3VsdCwgcC5maXJzdCk7Ci0gICAgICAgIHdyaXRlMTYocmVzdWx0LCBwLnNlY29u ZCk7Ci0gICAgfQorICAgIG92ZXJ3cml0ZTE2KHJlc3VsdCwgdGFibGVTaXplT2Zmc2V0LCAocmVz dWx0LnNpemUoKSAtIHRhYmxlU2l6ZU9mZnNldCAtIDIpIC8gNCk7CiB9CiAKIHN0YXRpYyB2b2lk IHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgZmxvYXQgbnVtYmVy KQogewotICAgIGludCByYXcgPSBudW1iZXIgKiBwb3dmKDIsIDE2KTsKICAgICB2ZWN0b3IuYXBw ZW5kKC0xKTsgLy8gMHhGRgotICAgIHdyaXRlMzIodmVjdG9yLCByYXcpOworICAgIHdyaXRlMzIo dmVjdG9yLCBudW1iZXIgKiAweDEwMDAwKTsKIH0KIAogc3RhdGljIGNvbnN0IGNoYXIgckxpbmVU byA9IDB4MDU7CkBAIC01NDYsNyArNTMzLDcgQEAgY2xhc3MgQ0ZGQnVpbGRlciA6IHB1YmxpYyBT VkdQYXRoQnVpbGRlciB7CiBwdWJsaWM6CiAgICAgQ0ZGQnVpbGRlcihWZWN0b3I8Y2hhcj4mIGNm ZkRhdGEsIGZsb2F0IHdpZHRoKQogICAgICAgICA6IG1fY2ZmRGF0YShjZmZEYXRhKQotICAgICAg ICAsIG1fZmlyc3RQb2ludCh0cnVlKQorICAgICAgICAsIG1faGFzQm91bmRpbmdCb3goZmFsc2Up CiAgICAgewogICAgICAgICAvLyBGSVhNRTogV2UgcHJvYmFibHkgd2FudCB0aGUgaW5pdGlhbCBt b3ZldG8gdG8gdXNlIGhvcml6LW9yaWdpbi14IGFuZCBob3Jpei1vcmlnaW4teSwgdW5sZXNzIHdl J3JlIHZlcnRpY2FsCiAgICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIHdp ZHRoKTsKQEAgLTU1NSw0OCArNTQyLDU2IEBAIHB1YmxpYzoKICAgICAgICAgbV9jZmZEYXRhLmFw cGVuZChyTW92ZVRvKTsKICAgICB9CiAKLSAgICB2b2lkIHVwZGF0ZUZvckNvbnN0aXR1ZW50UG9p bnQoRmxvYXRQb2ludCB4KQorICAgIEZsb2F0UmVjdCBib3VuZGluZ0JveCgpIGNvbnN0CiAgICAg ewotICAgICAgICBpZiAobV9maXJzdFBvaW50KQotICAgICAgICAgICAgbV9ib3VuZGluZ0JveCA9 IEZsb2F0UmVjdCh4LCBGbG9hdFNpemUoKSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgIG1f Ym91bmRpbmdCb3guZXh0ZW5kKHgpOwotICAgICAgICBtX2ZpcnN0UG9pbnQgPSBmYWxzZTsKKyAg ICAgICAgcmV0dXJuIG1fYm91bmRpbmdCb3g7CiAgICAgfQogCi0gICAgdm9pZCBtb3ZlVG8oY29u c3QgRmxvYXRQb2ludCYgdGFyZ2V0UG9pbnQsIGJvb2wgY2xvc2VkLCBQYXRoQ29vcmRpbmF0ZU1v ZGUgbW9kZSkgb3ZlcnJpZGUKK3ByaXZhdGU6CisgICAgdm9pZCB1cGRhdGVCb3VuZGluZ0JveChG bG9hdFBvaW50IHBvaW50KQogICAgIHsKLSAgICAgICAgRmxvYXRQb2ludCBkZXN0aW5hdGlvbiA9 IG1vZGUgPT0gQWJzb2x1dGVDb29yZGluYXRlcyA/IHRhcmdldFBvaW50IDogbV9jdXJyZW50ICsg dGFyZ2V0UG9pbnQ7Ci0gICAgICAgIHVwZGF0ZUZvckNvbnN0aXR1ZW50UG9pbnQoZGVzdGluYXRp b24pOworICAgICAgICBpZiAoIW1faGFzQm91bmRpbmdCb3gpIHsKKyAgICAgICAgICAgIG1fYm91 bmRpbmdCb3ggPSBGbG9hdFJlY3QocG9pbnQsIEZsb2F0U2l6ZSgpKTsKKyAgICAgICAgICAgIG1f aGFzQm91bmRpbmdCb3ggPSB0cnVlOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9Cisg ICAgICAgIG1fYm91bmRpbmdCb3guZXh0ZW5kKHBvaW50KTsKKyAgICB9CisKKyAgICB2b2lkIHdy aXRlUG9pbnQoRmxvYXRQb2ludCBkZXN0aW5hdGlvbikKKyAgICB7CisgICAgICAgIHVwZGF0ZUJv dW5kaW5nQm94KGRlc3RpbmF0aW9uKTsKKwogICAgICAgICBGbG9hdFNpemUgZGVsdGEgPSBkZXN0 aW5hdGlvbiAtIG1fY3VycmVudDsKKyAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2Zm RGF0YSwgZGVsdGEud2lkdGgoKSk7CisgICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2Nm ZkRhdGEsIGRlbHRhLmhlaWdodCgpKTsKIAorICAgICAgICBtX2N1cnJlbnQgPSBkZXN0aW5hdGlv bjsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgbW92ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHRh cmdldFBvaW50LCBib29sIGNsb3NlZCwgUGF0aENvb3JkaW5hdGVNb2RlIG1vZGUpIG92ZXJyaWRl CisgICAgewogICAgICAgICBpZiAoY2xvc2VkICYmIG1fY2ZmRGF0YS5zaXplKCkpCiAgICAgICAg ICAgICBjbG9zZVBhdGgoKTsKIAotICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZE YXRhLCBkZWx0YS53aWR0aCgpKTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2Zm RGF0YSwgZGVsdGEuaGVpZ2h0KCkpOworICAgICAgICBGbG9hdFBvaW50IGRlc3RpbmF0aW9uID0g bW9kZSA9PSBBYnNvbHV0ZUNvb3JkaW5hdGVzID8gdGFyZ2V0UG9pbnQgOiBtX2N1cnJlbnQgKyB0 YXJnZXRQb2ludDsKKworICAgICAgICB3cml0ZVBvaW50KGRlc3RpbmF0aW9uKTsKICAgICAgICAg bV9jZmZEYXRhLmFwcGVuZChyTW92ZVRvKTsKIAotICAgICAgICBtX2N1cnJlbnQgPSBkZXN0aW5h dGlvbjsKICAgICAgICAgbV9zdGFydGluZ1BvaW50ID0gbV9jdXJyZW50OwogICAgIH0KIAotICAg IHZvaWQgbGluZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHRhcmdldFBvaW50LCBQYXRoQ29vcmRpbmF0 ZU1vZGUgbW9kZSkgb3ZlcnJpZGUKKyAgICB2aXJ0dWFsIHZvaWQgbGluZVRvKGNvbnN0IEZsb2F0 UG9pbnQmIHRhcmdldFBvaW50LCBQYXRoQ29vcmRpbmF0ZU1vZGUgbW9kZSkgb3ZlcnJpZGUKICAg ICB7CiAgICAgICAgIEZsb2F0UG9pbnQgZGVzdGluYXRpb24gPSBtb2RlID09IEFic29sdXRlQ29v cmRpbmF0ZXMgPyB0YXJnZXRQb2ludCA6IG1fY3VycmVudCArIHRhcmdldFBvaW50OwotICAgICAg ICB1cGRhdGVGb3JDb25zdGl0dWVudFBvaW50KGRlc3RpbmF0aW9uKTsKLSAgICAgICAgRmxvYXRT aXplIGRlbHRhID0gZGVzdGluYXRpb24gLSBtX2N1cnJlbnQ7CiAKLSAgICAgICAgd3JpdGVDRkZF bmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgZGVsdGEud2lkdGgoKSk7Ci0gICAgICAgIHdyaXRlQ0ZG RW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIGRlbHRhLmhlaWdodCgpKTsKKyAgICAgICAgd3JpdGVQ b2ludChkZXN0aW5hdGlvbik7CiAgICAgICAgIG1fY2ZmRGF0YS5hcHBlbmQockxpbmVUbyk7Ci0K LSAgICAgICAgbV9jdXJyZW50ID0gZGVzdGluYXRpb247CiAgICAgfQogCi0gICAgdm9pZCBjdXJ2 ZVRvQ3ViaWMoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQxLCBjb25zdCBGbG9hdFBvaW50JiBwb2lu dDIsIGNvbnN0IEZsb2F0UG9pbnQmIHRhcmdldFBvaW50LCBQYXRoQ29vcmRpbmF0ZU1vZGUgbW9k ZSkgb3ZlcnJpZGUKKyAgICB2aXJ0dWFsIHZvaWQgY3VydmVUb0N1YmljKGNvbnN0IEZsb2F0UG9p bnQmIHBvaW50MSwgY29uc3QgRmxvYXRQb2ludCYgcG9pbnQyLCBjb25zdCBGbG9hdFBvaW50JiB0 YXJnZXRQb2ludCwgUGF0aENvb3JkaW5hdGVNb2RlIG1vZGUpIG92ZXJyaWRlCiAgICAgewotICAg ICAgICAvLyBGSVhNRTogVGhpcyBjYW4gYmUgbWFkZSB3YXkgZmFzdGVyCiAgICAgICAgIEZsb2F0 UG9pbnQgZGVzdGluYXRpb24xID0gcG9pbnQxOwogICAgICAgICBGbG9hdFBvaW50IGRlc3RpbmF0 aW9uMiA9IHBvaW50MjsKICAgICAgICAgRmxvYXRQb2ludCBkZXN0aW5hdGlvbjMgPSB0YXJnZXRQ b2ludDsKQEAgLTYwNSw0NiArNjAwLDMyIEBAIHB1YmxpYzoKICAgICAgICAgICAgIGRlc3RpbmF0 aW9uMiArPSBtX2N1cnJlbnQ7CiAgICAgICAgICAgICBkZXN0aW5hdGlvbjMgKz0gbV9jdXJyZW50 OwogICAgICAgICB9Ci0gICAgICAgIHVwZGF0ZUZvckNvbnN0aXR1ZW50UG9pbnQoZGVzdGluYXRp b24xKTsKLSAgICAgICAgdXBkYXRlRm9yQ29uc3RpdHVlbnRQb2ludChkZXN0aW5hdGlvbjIpOwot ICAgICAgICB1cGRhdGVGb3JDb25zdGl0dWVudFBvaW50KGRlc3RpbmF0aW9uMyk7Ci0gICAgICAg IEZsb2F0U2l6ZSBkZWx0YTMgPSBkZXN0aW5hdGlvbjMgLSBkZXN0aW5hdGlvbjI7Ci0gICAgICAg IEZsb2F0U2l6ZSBkZWx0YTIgPSBkZXN0aW5hdGlvbjIgLSBkZXN0aW5hdGlvbjE7Ci0gICAgICAg IEZsb2F0U2l6ZSBkZWx0YTEgPSBkZXN0aW5hdGlvbjEgLSBtX2N1cnJlbnQ7Ci0KLSAgICAgICAg d3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgZGVsdGExLndpZHRoKCkpOwotICAgICAg ICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBkZWx0YTEuaGVpZ2h0KCkpOwotICAg ICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBkZWx0YTIud2lkdGgoKSk7Ci0g ICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIGRlbHRhMi5oZWlnaHQoKSk7 Ci0gICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIGRlbHRhMy53aWR0aCgp KTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgZGVsdGEzLmhlaWdo dCgpKTsKLSAgICAgICAgbV9jZmZEYXRhLmFwcGVuZChyckN1cnZlVG8pOwogCi0gICAgICAgIG1f Y3VycmVudCA9IGRlc3RpbmF0aW9uMzsKKyAgICAgICAgd3JpdGVQb2ludChkZXN0aW5hdGlvbjEp OworICAgICAgICB3cml0ZVBvaW50KGRlc3RpbmF0aW9uMik7CisgICAgICAgIHdyaXRlUG9pbnQo ZGVzdGluYXRpb24zKTsKKyAgICAgICAgbV9jZmZEYXRhLmFwcGVuZChyckN1cnZlVG8pOwogICAg IH0KIAotICAgIHZvaWQgY2xvc2VQYXRoKCkgb3ZlcnJpZGUKKyAgICB2aXJ0dWFsIHZvaWQgY2xv c2VQYXRoKCkgb3ZlcnJpZGUKICAgICB7CiAgICAgICAgIGlmIChtX2N1cnJlbnQgIT0gbV9zdGFy dGluZ1BvaW50KQogICAgICAgICAgICAgbGluZVRvKG1fc3RhcnRpbmdQb2ludCwgQWJzb2x1dGVD b29yZGluYXRlcyk7CiAgICAgfQogCi0gICAgRmxvYXRSZWN0IGJvdW5kaW5nQm94KCkKLSAgICB7 Ci0gICAgICAgIHJldHVybiBtX2JvdW5kaW5nQm94OwotICAgIH0KLQotcHJpdmF0ZToKICAgICBW ZWN0b3I8Y2hhcj4mIG1fY2ZmRGF0YTsKICAgICBGbG9hdFBvaW50IG1fc3RhcnRpbmdQb2ludDsK ICAgICBGbG9hdFJlY3QgbV9ib3VuZGluZ0JveDsKLSAgICBib29sIG1fZmlyc3RQb2ludDsKKyAg ICBib29sIG1faGFzQm91bmRpbmdCb3g7CiB9OwogCiBzdGF0aWMgVmVjdG9yPGNoYXI+IHRyYW5z Y29kZUdseXBoUGF0aHMoZmxvYXQgd2lkdGgsIGNvbnN0IFNWR0dseXBoRWxlbWVudCYgZ2x5cGhF bGVtZW50LCBGbG9hdFJlY3QmIGJvdW5kaW5nQm94KQogewogICAgIFZlY3RvcjxjaGFyPiByZXN1 bHQ7Ci0gICAgY29uc3QgYXV0byYgZEF0dHJpYnV0ZSA9IGdseXBoRWxlbWVudC5mYXN0R2V0QXR0 cmlidXRlKFNWR05hbWVzOjpkQXR0cik7CisKKyAgICBhdXRvJiBkQXR0cmlidXRlID0gZ2x5cGhF bGVtZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OmRBdHRyKTsKKyAgICAvLyBGSVhNRTog U2hvdWxkbid0IHRoaXMgYmUgaXNOdWxsPyBJcyB0aGVyZSBhIHJlYXNvbiB0byBoYW5kbGUgYW4g ZW1wdHkgc3RyaW5nIGF0dHJpYnV0ZSB0aGUgc2FtZSBhcyBhIG1pc3NpbmcgYXR0cmlidXRlPwor ICAgIC8vIEZJWE1FOiBXaHkgaXMgdGhpcyBkaWZmZXJlbnQgdGhhbiB3aGF0IHdlIGRvIGJlbG93 IHdoZW4gcGFyc2luZyBmYWlscy4KICAgICBpZiAoZEF0dHJpYnV0ZS5pc0VtcHR5KCkpIHsKICAg ICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKHJlc3VsdCwgd2lkdGgpOwogICAgICAgICB3cml0 ZUNGRkVuY29kZWROdW1iZXIocmVzdWx0LCAwKTsKQEAgLTY1NiwxMCArNjM3LDEwIEBAIHN0YXRp YyBWZWN0b3I8Y2hhcj4gdHJhbnNjb2RlR2x5cGhQYXRocyhmbG9hdCB3aWR0aCwgY29uc3QgU1ZH R2x5cGhFbGVtZW50JiBnbHlwCiAKICAgICBDRkZCdWlsZGVyIGJ1aWxkZXIocmVzdWx0LCB3aWR0 aCk7CiAgICAgU1ZHUGF0aFN0cmluZ1NvdXJjZSBzb3VyY2UoZEF0dHJpYnV0ZSk7CisKICAgICBT VkdQYXRoUGFyc2VyIHBhcnNlcjsKICAgICBwYXJzZXIuc2V0Q3VycmVudFNvdXJjZSgmc291cmNl KTsKICAgICBwYXJzZXIuc2V0Q3VycmVudENvbnN1bWVyKCZidWlsZGVyKTsKLQogICAgIGJvb2wg b2sgPSBwYXJzZXIucGFyc2VQYXRoRGF0YUZyb21Tb3VyY2UoTm9ybWFsaXplZFBhcnNpbmcpOwog ICAgIHBhcnNlci5jbGVhbnVwKCk7CiAKQEAgLTY3NSwxNyArNjU2LDIwIEBAIHN0YXRpYyBWZWN0 b3I8Y2hhcj4gdHJhbnNjb2RlR2x5cGhQYXRocyhmbG9hdCB3aWR0aCwgY29uc3QgU1ZHR2x5cGhF bGVtZW50JiBnbHlwCiBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OlNWR1RvT1RGRm9udENvbnZlcnRl cihjb25zdCBTVkdGb250RWxlbWVudCYgZm9udEVsZW1lbnQpCiAgICAgOiBtX2ZvbnRFbGVtZW50 KGZvbnRFbGVtZW50KQogICAgICwgbV9mb250RmFjZUVsZW1lbnQoY2hpbGRyZW5PZlR5cGU8U1ZH Rm9udEZhY2VFbGVtZW50PihtX2ZvbnRFbGVtZW50KS5maXJzdCgpKQotICAgICwgbV9hZHZhbmNl V2lkdGhNYXgoMCkKICAgICAsIG1fbWluUmlnaHRTaWRlQmVhcmluZyhzdGQ6Om51bWVyaWNfbGlt aXRzPGZsb2F0Pjo6bWF4KCkpCiAgICAgLCBtX3RhYmxlc0FwcGVuZGVkQ291bnQoMCkKICAgICAs IG1fd2VpZ2h0KDUpCiAgICAgLCBtX2l0YWxpYyhmYWxzZSkKIHsKLSAgICBib29sIG9rID0gdHJ1 ZTsKKyAgICBib29sIG9rOwogICAgIGZsb2F0IGRlZmF1bHRBZHZhbmNlID0gZm9udEVsZW1lbnQu ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKS50b0Zsb2F0KCZvayk7 Ci0gICAgaWYgKCFvaykKKyAgICBpZiAoIW9rKSB7CisgICAgICAgIC8vIEZJWE1FOiBUaGlzIGNv ZGUgb25seSBtYXR0ZXJzIHdoZW4gdGhlcmUgaXMgdHJhaWxpbmcganVuayBhZnRlciBhIG51bWJl ci4KKyAgICAgICAgLy8gVGhlIHRvSW50IGZ1bmN0aW9uIHNpbGVudGx5IGlnbm9yZXMgc3VjaCB0 cmFpbGluZyBqdW5rLCBidXQgdGhpcyBjb2RlIGhlcmUKKyAgICAgICAgLy8gZXhwbGljaXRseSB0 cmVhdHMgIjF4IiBhcyAiMCIgcmF0aGVyIHRoYW4gYXMgIjEiLgogICAgICAgICBkZWZhdWx0QWR2 YW5jZSA9IDA7Ci0gICAgbV9hZHZhbmNlV2lkdGhNYXggPSBzdGQ6Om1heChtX2FkdmFuY2VXaWR0 aE1heCwgZGVmYXVsdEFkdmFuY2UpOworICAgIH0KKyAgICBtX2FkdmFuY2VXaWR0aE1heCA9IHN0 ZDo6bWF4KDAuZiwgZGVmYXVsdEFkdmFuY2UpOwogCiAgICAgLy8gRklYTUU6IFVzZSB0aGUgbWlz c2luZ0dseXBoIGluZm8KICAgICBWZWN0b3I8Y2hhciwgMT4gbm90ZGVmQ2hhclN0cmluZzsKQEAg LTY5NiwxNCArNjgwLDE0IEBAIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6U1ZHVG9PVEZGb250Q29u dmVydGVyKGNvbnN0IFNWR0ZvbnRFbGVtZW50JiBmb250RWxlbWVudCkKICAgICAgICAgYXV0byYg dW5pY29kZUF0dHJpYnV0ZSA9IGdseXBoLmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnVuaWNv ZGVBdHRyKTsKICAgICAgICAgLy8gT25seSBzdXBwb3J0IEJhc2ljIE11bHRpbGluZ3VhbCBQbGFu ZSB3L28gbGlnYXR1cmVzIGZvciBub3cKICAgICAgICAgaWYgKHVuaWNvZGVBdHRyaWJ1dGUubGVu Z3RoKCkgPT0gMSkgewotICAgICAgICAgICAgYm9vbCBvayA9IHRydWU7CisgICAgICAgICAgICBi b29sIG9rOwogICAgICAgICAgICAgZmxvYXQgZWZmZWN0aXZlQWR2YW5jZSA9IGdseXBoLmZhc3RH ZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6Omhvcml6X2Fkdl94QXR0cikudG9GbG9hdCgmb2spOwogICAg ICAgICAgICAgaWYgKCFvaykKICAgICAgICAgICAgICAgICBlZmZlY3RpdmVBZHZhbmNlID0gZGVm YXVsdEFkdmFuY2U7CiAgICAgICAgICAgICBtX2FkdmFuY2VXaWR0aE1heCA9IHN0ZDo6bWF4KG1f YWR2YW5jZVdpZHRoTWF4LCBlZmZlY3RpdmVBZHZhbmNlKTsKIAogICAgICAgICAgICAgRmxvYXRS ZWN0IGdseXBoQm91bmRpbmdCb3g7Ci0gICAgICAgICAgICBjb25zdCBhdXRvJiBwYXRoID0gdHJh bnNjb2RlR2x5cGhQYXRocyhlZmZlY3RpdmVBZHZhbmNlLCBnbHlwaCwgZ2x5cGhCb3VuZGluZ0Jv eCk7CisgICAgICAgICAgICBhdXRvIHBhdGggPSB0cmFuc2NvZGVHbHlwaFBhdGhzKGVmZmVjdGl2 ZUFkdmFuY2UsIGdseXBoLCBnbHlwaEJvdW5kaW5nQm94KTsKICAgICAgICAgICAgIGlmIChpbml0 aWFsR2x5cGgpCiAgICAgICAgICAgICAgICAgbV9ib3VuZGluZ0JveCA9IGdseXBoQm91bmRpbmdC b3g7CiAgICAgICAgICAgICBlbHNlCkBAIC03MTEsNDMgKzY5NSw1MCBAQCBTVkdUb09URkZvbnRD b252ZXJ0ZXI6OlNWR1RvT1RGRm9udENvbnZlcnRlcihjb25zdCBTVkdGb250RWxlbWVudCYgZm9u dEVsZW1lbnQpCiAgICAgICAgICAgICBtX21pblJpZ2h0U2lkZUJlYXJpbmcgPSBzdGQ6Om1pbiht X21pblJpZ2h0U2lkZUJlYXJpbmcsIGVmZmVjdGl2ZUFkdmFuY2UgLSBnbHlwaEJvdW5kaW5nQm94 Lm1heFgoKSk7CiAgICAgICAgICAgICBpbml0aWFsR2x5cGggPSBmYWxzZTsKIAotICAgICAgICAg ICAgbV9nbHlwaHMuYXBwZW5kKEdseXBoRGF0YShwYXRoLCAmZ2x5cGgsIGVmZmVjdGl2ZUFkdmFu Y2UsIGdseXBoQm91bmRpbmdCb3gsIHVuaWNvZGVBdHRyaWJ1dGVbMF0pKTsKKyAgICAgICAgICAg IG1fZ2x5cGhzLmFwcGVuZChHbHlwaERhdGEoV1RGOjptb3ZlKHBhdGgpLCAmZ2x5cGgsIGVmZmVj dGl2ZUFkdmFuY2UsIGdseXBoQm91bmRpbmdCb3gsIHVuaWNvZGVBdHRyaWJ1dGVbMF0pKTsKICAg ICAgICAgfQogICAgIH0KICAgICBzdGQ6OnNvcnQobV9nbHlwaHMuYmVnaW4oKSwgbV9nbHlwaHMu ZW5kKCksIFtdKGNvbnN0IEdseXBoRGF0YSYgZGF0YTEsIGNvbnN0IEdseXBoRGF0YSYgZGF0YTIp IHsKICAgICAgICAgcmV0dXJuIGRhdGExLmNvZGVwb2ludCA8IGRhdGEyLmNvZGVwb2ludDsKICAg ICB9KTsKIAotICAgIC8vIEZJWE1FOiBIYW5kbGUgY29tbWFzCisgICAgLy8gRklYTUU6IEhhbmRs ZSBjb21tYXMuCiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KSB7Ci0gICAgICAgIGF1dG8mIGZv bnRXZWlnaHRBdHRyaWJ1dGUgPSBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShT VkdOYW1lczo6Zm9udF93ZWlnaHRBdHRyKTsKLSAgICAgICAgVmVjdG9yPFN0cmluZz4gc3BsaXQ7 Ci0gICAgICAgIGZvbnRXZWlnaHRBdHRyaWJ1dGUuc3RyaW5nKCkuc3BsaXQoIiAiLCBzcGxpdCk7 Ci0gICAgICAgIGZvciAoY29uc3QgYXV0byYgc2VnbWVudCA6IHNwbGl0KSB7Ci0gICAgICAgICAg ICBpZiAoc2VnbWVudCA9PSAiYm9sZCIpCisgICAgICAgIFZlY3RvcjxTdHJpbmc+IHNlZ21lbnRz OworICAgICAgICBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6 Zm9udF93ZWlnaHRBdHRyKS5zdHJpbmcoKS5zcGxpdCgnICcsIHNlZ21lbnRzKTsKKyAgICAgICAg Zm9yIChhdXRvJiBzZWdtZW50IDogc2VnbWVudHMpIHsKKyAgICAgICAgICAgIGlmIChzZWdtZW50 ID09ICJib2xkIikgewogICAgICAgICAgICAgICAgIG1fd2VpZ2h0ID0gNzsKLSAgICAgICAgICAg IGJvb2wgb2sgPSB0cnVlOwotICAgICAgICAgICAgaW50IHZhbHVlID0gc2VnbWVudC50b0ludCgm b2spOwotICAgICAgICAgICAgaWYgKG9rICYmIHZhbHVlID49IDAgJiYgdmFsdWUgPCAxMDAwKQot ICAgICAgICAgICAgICAgIG1fd2VpZ2h0ID0gdmFsdWUgLyAxMDA7CisgICAgICAgICAgICAgICAg Ly8gRklYTUU6IFdoeSBkbyB3ZSBrZWVwIGxvb2tpbmcgYXQgc3Vic2VxdWVudCB3b3Jkcz8KKyAg ICAgICAgICAgICAgICAvLyBBcmUgd2UgaW50ZW50aW9uYWxseSBpbXBsZW1lbnRpbmcgYSAibGFz dCBvbmUgd2lucyIgcnVsZT8KKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAg Ym9vbCBvazsKKyAgICAgICAgICAgICAgICBpbnQgdmFsdWUgPSBzZWdtZW50LnRvSW50KCZvayk7 CisgICAgICAgICAgICAgICAgaWYgKG9rICYmIHZhbHVlID49IDAgJiYgdmFsdWUgPCAxMDAwKSB7 CisgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBEbyB3ZSB3YW50IHRvIHRydW5jYXRlLCBv ciB3b3VsZCBpdCBiZSBiZXR0ZXIgdG8gcm91bmQ/CisgICAgICAgICAgICAgICAgICAgIG1fd2Vp Z2h0ID0gdmFsdWUgLyAxMDA7CisgICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBXaHkgZG8g d2Uga2VlcCBsb29raW5nIGF0IHN1YnNlcXVlbnQgd29yZHM/CisgICAgICAgICAgICAgICAgICAg IC8vIEFyZSB3ZSBpbnRlbnRpb25hbGx5IGltcGxlbWVudGluZyBhICJsYXN0IG9uZSB3aW5zIiBy dWxlPworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KICAgICAgICAgfQotICAgICAg ICBjb25zdCBhdXRvJiBmb250U3R5bGVBdHRyaWJ1dGUgPSBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFz dEdldEF0dHJpYnV0ZShTVkdOYW1lczo6Zm9udF93ZWlnaHRBdHRyKTsKLSAgICAgICAgc3BsaXQu Y2xlYXIoKTsKLSAgICAgICAgU3RyaW5nKGZvbnRTdHlsZUF0dHJpYnV0ZSkuc3BsaXQoIiAiLCBz cGxpdCk7Ci0gICAgICAgIGZvciAoY29uc3QgYXV0byYgcyA6IHNwbGl0KSB7Ci0gICAgICAgICAg ICBpZiAocyA9PSAiaXRhbGljIiB8fCBzID09ICJvYmxpcXVlIikKKyAgICAgICAgbV9mb250RmFj ZUVsZW1lbnQtPmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OmZvbnRfd2VpZ2h0QXR0cikuc3Ry aW5nKCkuc3BsaXQoJyAnLCBzZWdtZW50cyk7CisgICAgICAgIGZvciAoYXV0byYgc2VnbWVudCA6 IHNlZ21lbnRzKSB7CisgICAgICAgICAgICBpZiAoc2VnbWVudCA9PSAiaXRhbGljIiB8fCBzZWdt ZW50ID09ICJvYmxpcXVlIikgewogICAgICAgICAgICAgICAgIG1faXRhbGljID0gdHJ1ZTsKKyAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIAot ICAgIC8vIE1pZ2h0IG5vdCBiZSBxdWl0ZSB3aGF0IEkgd2FudAorICAgIC8vIE1pZ2h0IG5vdCBi ZSBxdWl0ZSB3aGF0IHdlIHdhbnQuCiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KQogICAgICAg ICBtX2ZvbnRGYW1pbHkgPSBtX2ZvbnRGYWNlRWxlbWVudC0+Zm9udEZhbWlseSgpOwogfQogCiBz dGF0aWMgaW5saW5lIGJvb2wgaXNGb3VyQnl0ZUFsaWduZWQoc2l6ZV90IHgpCiB7Ci0gICAgcmV0 dXJuICEoeCAmIHNpemVvZih1aW50MzJfdCktMSk7CisgICAgcmV0dXJuICEoeCAmIHNpemVvZih1 aW50MzJfdCkgLSAxKTsKIH0KIAogc3RhdGljIHVpbnQzMl90IGNhbGN1bGF0ZUNoZWNrc3VtKGNv bnN0IFZlY3RvcjxjaGFyPiYgdGFibGUsIHNpemVfdCBzdGFydGluZ09mZnNldCwgc2l6ZV90IGVu ZGluZ09mZnNldCkKQEAgLTc3Myw3ICs3NjQsNyBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRl cjo6YXBwZW5kVGFibGUoY29uc3QgY2hhciBpZGVudGlmaWVyWzRdLCBWZWN0b3I8Y2hhcj4mCiAg ICAgd2hpbGUgKCFpc0ZvdXJCeXRlQWxpZ25lZChvdXRwdXQuc2l6ZSgpKSkKICAgICAgICAgb3V0 cHV0LmFwcGVuZCgwKTsKICAgICBBU1NFUlQoaXNGb3VyQnl0ZUFsaWduZWQob3V0cHV0LnNpemUo KSkpOwotICAgIHNpemVfdCBkaXJlY3RvcnlFbnRyeU9mZnNldCA9IGtTTkZUSGVhZGVyU2l6ZSAr IG1fdGFibGVzQXBwZW5kZWRDb3VudCAqIGtEaXJlY3RvcnlFbnRyeVNpemU7CisgICAgc2l6ZV90 IGRpcmVjdG9yeUVudHJ5T2Zmc2V0ID0gaGVhZGVyU2l6ZSArIG1fdGFibGVzQXBwZW5kZWRDb3Vu dCAqIGRpcmVjdG9yeUVudHJ5U2l6ZTsKICAgICBvdXRwdXRbZGlyZWN0b3J5RW50cnlPZmZzZXRd ID0gaWRlbnRpZmllclswXTsKICAgICBvdXRwdXRbZGlyZWN0b3J5RW50cnlPZmZzZXQgKyAxXSA9 IGlkZW50aWZpZXJbMV07CiAgICAgb3V0cHV0W2RpcmVjdG9yeUVudHJ5T2Zmc2V0ICsgMl0gPSBp ZGVudGlmaWVyWzJdOwpAQCAtNzg3LDYgKzc3OCw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVy dGVyOjphcHBlbmRUYWJsZShjb25zdCBjaGFyIGlkZW50aWZpZXJbNF0sIFZlY3RvcjxjaGFyPiYK IFZlY3RvcjxjaGFyPiBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmNvbnZlcnRTVkdUb09URkZvbnQo KQogewogICAgIFZlY3RvcjxjaGFyPiByZXN1bHQ7CisKICAgICBpZiAobV9nbHlwaHMuc2l6ZSgp ID4gMHhGRkZGIHx8ICFtX2dseXBocy5zaXplKCkpCiAgICAgICAgIHJldHVybiByZXN1bHQ7CiAK QEAgLTgwNiwxMCArNzk4LDEwIEBAIFZlY3RvcjxjaGFyPiBTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OmNvbnZlcnRTVkdUb09URkZvbnQoKQogICAgIHdyaXRlMTYocmVzdWx0LCBlbnRyeVNlbGVjdG9y KTsKICAgICB3cml0ZTE2KHJlc3VsdCwgbnVtVGFibGVzICogMTYgLSBzZWFyY2hSYW5nZSk7CiAK LSAgICBBU1NFUlQocmVzdWx0LnNpemUoKSA9PSBrU05GVEhlYWRlclNpemUpOworICAgIEFTU0VS VChyZXN1bHQuc2l6ZSgpID09IGhlYWRlclNpemUpOwogCiAgICAgLy8gTGVhdmUgc3BhY2UgZm9y IHRoZSBEaXJlY3RvcnkgRW50cmllcwotICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwga0RpcmVj dG9yeUVudHJ5U2l6ZSAqIG51bVRhYmxlczsgKytpKQorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgZGlyZWN0b3J5RW50cnlTaXplICogbnVtVGFibGVzOyArK2kpCiAgICAgICAgIHJlc3VsdC5h cHBlbmQoMCk7CiAKICAgICAvLyBGSVhNRTogSW1wbGVtZW50IG1vcmUgdGFibGVzLCBsaWtlIHZo ZWEgYW5kIHZtdHggKGFuZCBrZXJuISkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCA5ZTE0NmFiZDBhZWQ2ODRiMTQxYzFjZmY3NjE5ZDJkZDBhOGUz MTAwLi5kZmEwOTFhOGQwYTBmMGU0N2VlNDI1ZDk4MDMxMWIzZWEwZjZkYjQyIDEwMDY0NAotLS0g YS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAK KzIwMTQtMDktMTkgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgorCisgICAgICAgIFR3 ZWFrIGFuZCB0aWdodGVuIFNWRyBmb250IGNvbnZlcnRlcgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2OTU2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSSB3YXMgaW52ZXN0aWdhdGluZyBiZWhhdmlvciBv ZiBTdHJpbmc6OnRvSW50LCBTdHJpbmc6OnRvRG91YmxlLCBhbmQKKyAgICAgICAgU3RyaW5nOjp0 b0Zsb2F0IGZvciB2YXJpb3VzIGZhaWx1cmUgY2FzZXMsIGFuZCBkZWNpZGVkIHRvIHN0YXJ0IHNv bWUKKyAgICAgICAgdW5pdCB0ZXN0cyBmb3IgdGhvc2UgZnVuY3Rpb25zIGhlcmUuCisKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XVEZTdHJpbmcuY3BwOgorICAgICAgICAoVGVz dFdlYktpdEFQSTo6VEVTVCk6IEFkZGRlZCBhIGZpcnN0IHNtYWxsIGJpdCBvZiBTdHJpbmdUb0lu dCBhbmQKKyAgICAgICAgU3RyaW5nVG9Eb3VibGUgdGVzdGluZy4KKwogMjAxNC0wOS0xOSAgWW91 ZW5uIEZhYmxldCAgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgogCiAgICAgICAgIFdUUiBh bmQgRFJUIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNoYWxsZW5nZUluRnJhbWUgc2hvdWxkIHBy aW50IG1lc3NhZ2VzIGNvbnNpc3RlbnRseQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XVEYvV1RGU3RyaW5nLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RG L1dURlN0cmluZy5jcHAKaW5kZXggYTM5NWY3OTc0NGY2MzAyMmQ2ZjNmMzVjYjA2YmFkZDBkMmIw ZjY2Mi4uZjQwZTZhZjUxMDJjNjdiMGNhYzdmOGQyMzk1N2YxYjFhNGQ1ZmQ1YiAxMDA2NDQKLS0t IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvV1RGU3RyaW5nLmNwcAorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XVEZTdHJpbmcuY3BwCkBAIC0xNjAsNCArMTYwLDEw NCBAQCBURVNUKFdURiwgU3RyaW5nSXNvbGF0ZWRDb3B5KQogICAgIEFTU0VSVF9GQUxTRShvcmln aW5hbC5pbXBsKCkgPT0gY29weS5pbXBsKCkpOwogfQogCitURVNUKFdURiwgU3RyaW5nVG9JbnQp Cit7CisgICAgYm9vbCBvazsKKworICAgIEVYUEVDVF9FUSgwLCBTdHJpbmcoKS50b0ludCgpKTsK KyAgICBFWFBFQ1RfRVEoMCwgU3RyaW5nKCkudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZh bHNlLCBvayk7CisKKyAgICBFWFBFQ1RfRVEoMCwgZW1wdHlTdHJpbmcoKS50b0ludCgpKTsKKyAg ICBFWFBFQ1RfRVEoMCwgZW1wdHlTdHJpbmcoKS50b0ludCgmb2spKTsKKyAgICBFWFBFQ1RfRVEo ZmFsc2UsIG9rKTsKKworICAgIEVYUEVDVF9FUSgwLCBTdHJpbmcoIjAiKS50b0ludCgpKTsKKyAg ICBFWFBFQ1RfRVEoMCwgU3RyaW5nKCIwIikudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIG9rKTsKKworICAgIEVYUEVDVF9FUSgxLCBTdHJpbmcoIjEiKS50b0ludCgpKTsKKyAgICBF WFBFQ1RfRVEoMSwgU3RyaW5nKCIxIikudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRydWUs IG9rKTsKKworICAgIEVYUEVDVF9FUSgyMTQ3NDgzNjQ3LCBTdHJpbmcoIjIxNDc0ODM2NDciKS50 b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMjE0NzQ4MzY0NywgU3RyaW5nKCIyMTQ3NDgzNjQ3Iiku dG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIG9rKTsKKworICAgIEVYUEVDVF9FUSgw LCBTdHJpbmcoIjIxNDc0ODM2NDgiKS50b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMCwgU3RyaW5n KCIyMTQ3NDgzNjQ4IikudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBvayk7CisK KyAgICBFWFBFQ1RfRVEoLTIxNDc0ODM2NDgsIFN0cmluZygiLTIxNDc0ODM2NDgiKS50b0ludCgp KTsKKyAgICBFWFBFQ1RfRVEoLTIxNDc0ODM2NDgsIFN0cmluZygiLTIxNDc0ODM2NDgiKS50b0lu dCgmb2spKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgb2spOworCisgICAgRVhQRUNUX0VRKDAsIFN0 cmluZygiLTIxNDc0ODM2NDkiKS50b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMCwgU3RyaW5nKCIt MjE0NzQ4MzY0OSIpLnRvSW50KCZvaykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisg ICAgLy8gZmFpbCBpZiB3ZSBzZWUgbGVhZGluZyBqdW5rCisgICAgRVhQRUNUX0VRKDAsIFN0cmlu ZygieDEiKS50b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMCwgU3RyaW5nKCJ4MSIpLnRvSW50KCZv aykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgLy8gc3VjY2VlZCBpZiB3ZSBz ZWUgbGVhZGluZyBzcGFjZXMKKyAgICBFWFBFQ1RfRVEoMSwgU3RyaW5nKCIgMSIpLnRvSW50KCkp OworICAgIEVYUEVDVF9FUSgxLCBTdHJpbmcoIiAxIikudG9JbnQoJm9rKSk7CisgICAgRVhQRUNU X0VRKHRydWUsIG9rKTsKKworICAgIC8vIHNpbGVudGx5IGlnbm9yZSB0cmFpbGluZyBqdW5rCisg ICAgRVhQRUNUX0VRKDEsIFN0cmluZygiMXgiKS50b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMSwg U3RyaW5nKCIxeCIpLnRvSW50KCZvaykpOworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7Cit9CisK K1RFU1QoV1RGLCBTdHJpbmdUb0RvdWJsZSkKK3sKKyAgICBib29sIG9rOworCisgICAgRVhQRUNU X0VRKDAuMCwgU3RyaW5nKCkudG9Eb3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDAuMCwgU3RyaW5n KCkudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBvayk7CisKKyAgICBFWFBF Q1RfRVEoMC4wLCBlbXB0eVN0cmluZygpLnRvRG91YmxlKCkpOworICAgIEVYUEVDVF9FUSgwLjAs IGVtcHR5U3RyaW5nKCkudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBvayk7 CisKKyAgICBFWFBFQ1RfRVEoMC4wLCBTdHJpbmcoIjAiKS50b0RvdWJsZSgpKTsKKyAgICBFWFBF Q1RfRVEoMC4wLCBTdHJpbmcoIjAiKS50b0RvdWJsZSgmb2spKTsKKyAgICBFWFBFQ1RfRVEodHJ1 ZSwgb2spOworCisgICAgRVhQRUNUX0VRKDEuMCwgU3RyaW5nKCIxIikudG9Eb3VibGUoKSk7Cisg ICAgRVhQRUNUX0VRKDEuMCwgU3RyaW5nKCIxIikudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNU X0VRKHRydWUsIG9rKTsKKworICAgIC8vIGZhaWwgaWYgd2Ugc2VlIGxlYWRpbmcganVuaworICAg IEVYUEVDVF9FUSgwLjAsIFN0cmluZygieDEiKS50b0RvdWJsZSgpKTsKKyAgICBFWFBFQ1RfRVEo MC4wLCBTdHJpbmcoIngxIikudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBv ayk7CisKKyAgICAvLyBzdWNjZWVkIGlmIHdlIHNlZSBsZWFkaW5nIHNwYWNlcworICAgIEVYUEVD VF9FUSgxLjAsIFN0cmluZygiIDEiKS50b0RvdWJsZSgpKTsKKyAgICBFWFBFQ1RfRVEoMS4wLCBT dHJpbmcoIiAxIikudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIG9rKTsKKwor ICAgIC8vIGlnbm9yZSB0cmFpbGluZyBqdW5rLCBidXQgcmV0dXJuIGZhbHNlIGZvciAib2siCisg ICAgLy8gRklYTUU6IFRoaXMgaXMgYW4gaW5jb25zaXN0ZW5jeSB3aXRoIHRvSW50LCB3aGljaCBh bHdheXMgZ3VhcmFudGVlcworICAgIC8vIGl0IHdpbGwgcmV0dXJuIDAgaWYgaXQncyBhbHNvIGdv aW5nIHRvIHJldHVybiBmYWxzZSBmb3Igb2suCisgICAgRVhQRUNUX0VRKDEuMCwgU3RyaW5nKCIx eCIpLnRvRG91YmxlKCkpOworICAgIEVYUEVDVF9FUSgxLjAsIFN0cmluZygiMXgiKS50b0RvdWJs ZSgmb2spKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIG9rKTsKKworICAgIC8vIHBhcnNlIG9ubHkg bnVtYmVycywgbm90IHNwZWNpYWwgdmFsdWVzIHN1Y2ggYXMgImluZmluaXR5IgorICAgIEVYUEVD VF9FUSgwLjAsIFN0cmluZygiaW5maW5pdHkiKS50b0RvdWJsZSgpKTsKKyAgICBFWFBFQ1RfRVEo MC4wLCBTdHJpbmcoImluZmluaXR5IikudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZh bHNlLCBvayk7CisKKyAgICAvLyBwYXJzZSBvbmx5IG51bWJlcnMsIG5vdCBzcGVjaWFsIHZhbHVl cyBzdWNoIGFzICJuYW4iCisgICAgRVhQRUNUX0VRKDAuMCwgU3RyaW5nKCJuYW4iKS50b0RvdWJs ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMC4wLCBTdHJpbmcoIm5hbiIpLnRvRG91YmxlKCZvaykpOwor ICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0 QVBJCg== 238753 2014-09-26 19:38:26 -0700 2014-09-29 08:38:31 -0700 Patch bug-136956-20140926193826.patch text/plain 52931 darin U3VidmVyc2lvbiBSZXZpc2lvbjogMTc0MDMxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTM0ODFjMDk1MWNlMzk2 OGEzZjkwM2U1NDMwMDAwYTY0NDRiNmUwYS4uZDk4MTM0MTk0OGEwZjEwNjk5OWNhNjdlYjA4Yzg4 NWY3ODE4ZTljZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDk2IEBACisyMDE0LTA5LTI2ICBEYXJp biBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KKworICAgICAgICBUd2VhayBhbmQgdGlnaHRlbiBT VkcgZm9udCBjb252ZXJ0ZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEzNjk1NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogc3ZnL1NWR1RvT1RGRm9udENvbnZlcnNpb24uY3BwOiBGaXhlZCBjb3B5cmln aHQgZGF0ZS4KKyAgICAgICAgKFdlYkNvcmU6Om92ZXJ3cml0ZTMyKTogQ2hhbmdlZCB0byB1c2Ug bm9ybWFsIHN1YnNjcmlwdGluZyBmb3IgY2xhcml0eS4KKyAgICAgICAgKFdlYkNvcmU6Om92ZXJ3 cml0ZTE2KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OkdseXBoRGF0YTo6R2x5cGhEYXRhKTogQWRkZWQgYSBtb3ZlCisgICAgICAgIHRvIG1ha2UgY29u c3RydWN0aW5nIGVhY2ggR2x5cGhEYXRhIGxlc3MgZXhwZW5zaXZlLgorICAgICAgICAoV2ViQ29y ZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpLZXJuaW5nRGF0YSk6IFJlbW92ZWQgdGhlIDwgb3Bl cmF0b3IKKyAgICAgICAgc2luY2UgaXQgdGhlIHN0cnVjdCBjb250YWlucyBtb3JlIHRoYW4gd2hh dCB3ZSB3YW50IHRvIHNvcnQgaXQgYnksIHNvIGl0J3MKKyAgICAgICAgbm90IGVsZWdhbnQgdG8g YnVpbGQgdGhlIHNvcnRpbmcgcnVsZSBpbnRvIHRoZSBzdHJ1Y3QuCisgICAgICAgIChXZWJDb3Jl OjpTVkdUb09URkZvbnRDb252ZXJ0ZXIpOiBSZW1vdmVkICJrIiBwcmVmaXggZnJvbSBzb21lIGNv bnN0YW50cy4KKyAgICAgICAgUmVwbGFjZWQgbWFueSBmdW5jdGlvbiB0ZW1wbGF0ZXMgd2l0aCBu b24tdGVtcGxhdGUgZnVuY3Rpb25zLiBDaGFuZ2VkCisgICAgICAgIGtleSB0eXBlIGZvciBtX2Nv ZGVwb2ludFRvSW5kZXhNYXAgdG8gVUNoYXIzMi4KKyAgICAgICAgKFdlYkNvcmU6OmludGVncmFs TG9nMik6IFR3ZWFrZWQgZm9ybWF0dGluZy4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9u dENvbnZlcnRlcjo6YXBwZW5kQ01BUFRhYmxlKTogUmVtb3ZlZCBhIHN0cmF5CisgICAgICAgIGNh c3QgdGhhdCBkb2Vzbid0IGhhdmUgYW55IGVmZmVjdC4gVXNlIHRoZSBHbHlwaCB0eXBlIHRvIGlu ZGV4IG1fZ2x5cGhzLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjph cHBlbmRIRUFEVGFibGUpOiBBcHBlbmQgdGhlIG1hZ2ljCisgICAgICAgIG51bWJlciBpbiBhIG1v cmUgc3RyYWlnaHRmb3J3YXJkIHdheS4KKyAgICAgICAgKFdlYkNvcmU6OmNsYW1wVG8pOiBUd2Vh ayBmb3JtYXR0aW5nIG9mIHRoZSB0ZW1wbGF0ZSBmdW5jdGlvbi4KKyAgICAgICAgKFdlYkNvcmU6 OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEhFQVRhYmxlKTogTWFkZSBzb21lIG1pbm9y CisgICAgICAgIHN0eWxlIGNoYW5nZXMgYW5kIGltcHJvdmVkIHNvbWUgY29tbWVudHMuCisgICAg ICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZE9TMlRhYmxlKTogTWFk ZSBzb21lIG1pbm9yCisgICAgICAgIHN0eWxlIGNoYW5nZXMgYW5kIHRpZ2h0ZW5lZCB1cCBjb2Rl IHRoYXQgZGlkIHBhcnNpbmcgYSBiaXQsIHJlbW92aW5nIHRoZQorICAgICAgICBkeW5hbWljYWxs eSBhbGxvY2F0ZWQgYXJyYXkgZm9yIHRoZSBmaXhlZCBsZW5ndGggUGFub3NlIG51bWJlci4KKyAg ICAgICAgQWxzbyB1c2UgZmlyc3QgYW5kIGxhc3QgaW5zdGVhZCBvZiBoYW5kLWNvZGVkIHZlcnNp b25zIG9mIHRob3NlLgorICAgICAgICAoV2ViQ29yZTo6YXBwZW5kVmFsaWRDRkZTdHJpbmcpOiBS ZW5hbWVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRD RkZUYWJsZSk6IE1hZGUgdmFyaW91cyB0d2Vha3MsCisgICAgICAgIGluY2x1ZGluZyBtb3JlIHNw ZWNpZmljIG9mIG51bGwgZm9yIHRoZSAibm8gd2VpZ2h0IiB2YWx1ZSBpbnN0ZWFkIG9mCisgICAg ICAgIGVpdGhlciBlbXB0eSBvciBudWxsLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250 Q29udmVydGVyOjphcHBlbmRWT1JHVGFibGUpOiBTaW1wbGlmaWVkIHNvbWUgb2YKKyAgICAgICAg dGhlIG51bWVyaWMgcGFyc2luZywgc2luY2UgdG9JbnQgaXMgZ3VhcmFudGVlZCB0byByZXR1cm4g MCB3aGVuIGl0IGFsc28KKyAgICAgICAgd291bGQgcmV0dXJuICJmYWxzZSIgZm9yIG9rLiBBbHNv IGdvdCByaWQgb2YgYSBsb2NhbCB2ZWN0b3IgYW5kIGluc3RlYWQKKyAgICAgICAganVzdCBmaXhl ZCB1cCB0aGUgc2l6ZSBvZiB0aGUgdGFibGUgYWZ0ZXJ3YXJkLgorICAgICAgICAoV2ViQ29yZTo6 U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWSEVBVGFibGUpOiBUd2Vha2VkIGNvbW1lbnQu CisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFkZENvZGVwb2ludFJh bmdlcyk6IFVzZSBpc1ZhbGlkS2V5CisgICAgICAgIGluc3RlYWQgb2YgYSBsb2NhbCBoYXJkY29k ZWQgcnVsZSB0byBjaGVjayBoYXNoIHRhYmxlIGtleSB2YWxpZGl0eS4KKyAgICAgICAgQ2hlY2sg Zm9yIHplcm8gaW4gdGhlIHJlc3VsdCBvZiBnZXQgcmF0aGVyIHRoYW4gdXNpbmcgZmluZCBvbiB0 aGUgSGFzaE1hcC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YWRk Q29kZXBvaW50UmFuZ2VzKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRD b252ZXJ0ZXI6OmFkZEdseXBoTmFtZXMpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1Rv T1RGRm9udENvbnZlcnRlcjo6YWRkS2VybmluZ1BhaXIpOiBBZGRlZC4gRmFjdG9yZWQgb3V0IGZy b20KKyAgICAgICAgYXBwZW5kS0VSTlN1YnRhYmxlIHRvIHJlZHVjZSB0ZW1wbGF0ZSBibG9hdCBh bmQgaW1wcm92ZSBjbGFyaXR5LgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVy dGVyOjphcHBlbmRLRVJOU3VidGFibGUpOiBUd2Vha2VkIGZvcm1hdHRpbmcuCisgICAgICAgIE1v dmVkIHRoZSBidWxrIG9mIHRoZSBmdW5jdGlvbiBpbnRvIG5vbi10ZW1wbGF0ZSBmdW5jdGlvbi4K KyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6ZmluaXNoQXBwZW5kaW5n S0VSTlN1YnRhYmxlKTogQWRkZWQuCisgICAgICAgIE5vbi10ZW1wbGF0ZSBwYXJ0IG9mIGFwcGVu ZEtFUk5TdWJ0YWJsZS4gQWxzbyBjaGFuZ2VkIHN0ZDo6c29ydCB0byBzdXBwbHkKKyAgICAgICAg Y3VzdG9tIGNvbXBhcmlzb24gZnVuY3Rpb24gcmF0aGVyIHRoYW4gdHJ5aW5nIHRvIHVzZSB0aGUg PCBvcGVyYXRvciBkaXJlY3RseQorICAgICAgICBvbiBLZXJuaW5nRGF0YS4KKyAgICAgICAgKFdl YkNvcmU6OndyaXRlQ0ZGRW5jb2RlZE51bWJlcik6IERvbid0IHVzZSBwb3dmIGp1c3QgdG8gbXVs dGlwbHkgYnkKKyAgICAgICAgMl4xNi4gSXQncyBwcmV0dHkgZWFzeSB0byBkbyB0aGF0IHdpdGgg cGxhaW4gb2xkIG11bHRpcGxpY2F0aW9uLgorICAgICAgICAoV2ViQ29yZTo6Q0ZGQnVpbGRlcjo6 Q0ZGQnVpbGRlcik6IFJlbmFtZWQgbV9maXJzdFBvaW50IHRvCisgICAgICAgIG1faGFzQm91bmRp bmdCb3guCisgICAgICAgIChXZWJDb3JlOjpDRkZCdWlsZGVyOjpib3VuZGluZ0JveCk6IE1hZGUg dGhpcyBwdWJsaWMgYW5kIGNvbnN0IGFuZCBtYWRlCisgICAgICAgIHRoZSByZXN0IG9mIHRoZSBj bGFzcyBwcml2YXRlLgorICAgICAgICAoV2ViQ29yZTo6Q0ZGQnVpbGRlcjo6dXBkYXRlQm91bmRp bmdCb3gpOiBVc2VkIGVhcmx5IHJldHVybiBhbmQgcmV2aXNlZAorICAgICAgICB0byB1c2UgbV9o YXNCb3VuZGluZ0JveC4KKyAgICAgICAgKFdlYkNvcmU6OkNGRkJ1aWxkZXI6OndyaXRlUG9pbnQp OiBBZGRlZC4gVXNlZCB0byBrZWVwIHRoZSBvdGhlcgorICAgICAgICBmdW5jdGlvbnMgYmVsb3cg c21hbGxlci4KKyAgICAgICAgKFdlYkNvcmU6OkNGRkJ1aWxkZXI6Om1vdmVUbyk6IE1hcmtlZCB2 aXJ0dWFsIGFuZCBzaW1wbGlmaWVkIHVzaW5nIHdyaXRlUG9pbnQuCisgICAgICAgIE1pZ2h0IGZp bmQgYSB3YXkgdG8gc2ltcGxpZnkgZXZlbiBmdXJ0aGVyIGJ5IHRlYWNoaW5nIHdyaXRlUG9pbnQg YWJvdXQKKyAgICAgICAgdGhlIFBhdGhDb29yZGluYXRlTW9kZS4KKyAgICAgICAgKFdlYkNvcmU6 OkNGRkJ1aWxkZXI6OmxpbmVUbyk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6Q0ZGQnVpbGRl cjo6Y3VydmVUb0N1YmljKTogRGl0dG8uIEFsc28gcmVtb3ZlZCBjb21tZW50IHRoYXQgc2FpZAor ICAgICAgICB0aGUgZnVuY3Rpb24gY291bGQgYmUgZmFzdGVyLiBOb3Qgc3VyZSB0aGF0J3MgaW1w b3J0YW50IHRvIHN0YXRlIGxpa2UgdGhpcy4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9u dENvbnZlcnRlcjo6dHJhbnNjb2RlR2x5cGhQYXRocyk6IENoYW5nZWQgaW50byBhCisgICAgICAg IG5vbi10ZW1wbGF0ZSBmdW5jdGlvbi4gVHdlYWtlZCBsb2dpYyBhbmQgZm9ybWF0dGluZyBhIGJp dC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6cHJvY2Vzc0dseXBo RWxlbWVudCk6IENoYW5nZWQgaW50byBhCisgICAgICAgIG5vbi10ZW1wbGF0ZSBmdW5jdGlvbi4g TW92ZWQgdGhlIGNvZGUgZnJvbSBhcHBlbmRHbHlwaERhdGEgaW4gaGVyZS4KKyAgICAgICAgVXNl IFdURjo6bW92ZSBzbyB3ZSBkb24ndCBjb3B5IHRoZSBnbHlwaCBwYXRocyB3aGVuIGNyZWF0aW5n IGEgR2x5cGhEYXRhLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpT VkdUb09URkZvbnRDb252ZXJ0ZXIpOiBVcGRhdGVkIGEgYml0IGZvcgorICAgICAgICBmdW5jdGlv biBjaGFuZ2VzIGFib3ZlLiBDaGFuZ2VkIGNvZGUgdG8gdXNlIGlzVmFsaWRLZXkgdG8gY2hlY2sg aWYgd2UgY2FuCisgICAgICAgIGFkZCB0byBtX2NvZGVwb2ludFRvSW5kZXhNYXAuIFBhcnNlIGZv bnQtc3R5bGUgcmF0aGVyIHRoYW4gcGFyc2luZworICAgICAgICBmb250LXdlaWdodCB0d2ljZS4g Um91bmQgd2VpZ2h0cyBpbnN0ZWFkIG9mIHRydW5jYXRpbmcgdGhlbS4gQ2hhbmdlIHJ1bGUKKyAg ICAgICAgdG8gImZpcnN0IHdpbnMiIGluc3RlYWQgb2YgImxhc3Qgd2lucyIgd2hlbiB0aGVyZSBh cmUgbXVsdGlwbGUgc2VnbWVudHMuCisgICAgICAgIFJlbW92ZWQgb25lIHZhZ3VlIGFuZCBub24t aGVscGZ1bCBjb21tZW50LgorICAgICAgICAoV2ViQ29yZTo6aXNGb3VyQnl0ZUFsaWduZWQpOiBG aXhlZCBtaW5vciBmb3JtYXR0aW5nIGlzc3VlIGJ5IG1ha2luZyB0aGUKKyAgICAgICAgZnVuY3Rp b24gbm9uLWFic3RyYWN0LiBObyByZWFzb24gbm90IHRvIGhhcmQtY29kZSB0aGUgbnVtYmVyIDMg d2hlbiB0aGUKKyAgICAgICAgbnVtYmVyIGZvdXIgYXBwZWFycyBpbiB0aGUgZnVuY3Rpb24gbmFt ZS4KKyAgICAgICAgKFdlYkNvcmU6OmNhbGN1bGF0ZUNoZWNrc3VtKTogUmVtb3ZlZCB1bm5lZWRl ZCBjb21tZW50IGFib3V0IHdoeSB0aGUKKyAgICAgICAgY2hlY2tzdW0gaXMgbGl0dGxlLWVuZGlh bjsgc2luY2UgdGhpcyBjYW1lIGZyb20gV2luZG93cyBkb2N1bWVudGF0aW9uIHRoZXJlCisgICAg ICAgIGlzIG5vIGRvdWJ0IHRoYXQgbGl0dGxlLWVuZGlhbiBpcyBjb3JyZWN0LCBzbyB3ZSBkb24n dCBuZWVkIGEgY29tbWVudCBjcmVhdGluZworICAgICAgICBmZWFyLCB1bmNlcnRhaW50eSwgYW5k IGRvdWJ0LiBJZiB0aGUgY2hlY2tzdW0gY29tcHV0YXRpb24gaXMgd3JvbmcsIGl0IHNob3VsZAor ICAgICAgICBiZWNvbWUgb2J2aW91cyB0aGF0IHdlIGhhdmUgYSBiYWQgY2hlY2tzdW0uIEFsc28g Y2hhbmdlZCB0aGUgZm9yIGxvb3AgdG8gdXNlCisgICAgICAgIGl0cyBvd24gbG9vcCB2YXJpYWJs ZSBpbnN0ZWFkIG9mIGNoYW5naW5nIHN0YXJ0aW5nT2Zmc2V0LCB3aGljaCBpcyBub3QgbG9naWNh bC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kVGFibGUp OiBVcGRhdGVkIGZvciBuYW1lIGNoYW5nZXMuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZv bnRDb252ZXJ0ZXI6OmNvbnZlcnRTVkdUb09URkZvbnQpOiBEaXR0by4gQWxzbyBzdHJlYW1saW5l ZAorICAgICAgICB0aGUgY2hlY2tzdW0gY29kZSBhIGxpdHRsZS4gVGhlIGNvbW1lbnQgc3RpbGwg aXMgYSBsaXR0bGUgcGVjdWxpYXI7IEkgd2FzCisgICAgICAgIHRlbXB0ZWQgdG8gdGFrZSBpdCBv dXQuCisKIDIwMTQtMDktMjYgIENocmlzdG9waGUgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgog CiAgICAgICAgIFN0b3AgdXNpbmcgbGVnYWN5IE5PREVfVFlQRV9DQVNUUygpIG1hY3JvIGZvciBI VE1MIEVsZW1lbnRzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVG9PVEZGb250 Q29udmVyc2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVG9PVEZGb250Q29udmVyc2lv bi5jcHAKaW5kZXggN2ZhNjE2MWViZDU2YmM2OWQyMjcxYzZjZTUzMmQyNmU2NTVhYzgyZC4uZDBi OTRhNGFjMDU0OTdlNGM2MDA1MDQ0MGE2ZmQwMjdhYzJjYzc0NyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvc3ZnL1NWR1RvT1RGRm9udENvbnZlcnNpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdUb09URkZvbnRDb252ZXJzaW9uLmNwcApAQCAtMSw1ICsxLDUgQEAKIC8qCi0g KiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog Q29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtNTcsMTAgKzU3LDE3IEBAIHN0YXRpYyBpbmxp bmUgdm9pZCB3cml0ZTE2KFZlY3RvcjxjaGFyPiYgdmVjdG9yLCB1aW50MTZfdCB2YWx1ZSkKIHN0 YXRpYyBpbmxpbmUgdm9pZCBvdmVyd3JpdGUzMihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgdW5zaWdu ZWQgbG9jYXRpb24sIHVpbnQzMl90IHZhbHVlKQogewogICAgIEFTU0VSVCh2ZWN0b3Iuc2l6ZSgp ID49IGxvY2F0aW9uICsgNCk7Ci0gICAgKih2ZWN0b3IuZGF0YSgpICsgbG9jYXRpb24pID0gdmFs dWUgPj4gMjQ7Ci0gICAgKih2ZWN0b3IuZGF0YSgpICsgbG9jYXRpb24gKyAxKSA9IHZhbHVlID4+ IDE2OwotICAgICoodmVjdG9yLmRhdGEoKSArIGxvY2F0aW9uICsgMikgPSB2YWx1ZSA+PiA4Owot ICAgICoodmVjdG9yLmRhdGEoKSArIGxvY2F0aW9uICsgMykgPSB2YWx1ZTsKKyAgICB2ZWN0b3Jb bG9jYXRpb25dID0gdmFsdWUgPj4gMjQ7CisgICAgdmVjdG9yW2xvY2F0aW9uICsgMV0gPSB2YWx1 ZSA+PiAxNjsKKyAgICB2ZWN0b3JbbG9jYXRpb24gKyAyXSA9IHZhbHVlID4+IDg7CisgICAgdmVj dG9yW2xvY2F0aW9uICsgM10gPSB2YWx1ZTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG92ZXJ3 cml0ZTE2KFZlY3RvcjxjaGFyPiYgdmVjdG9yLCB1bnNpZ25lZCBsb2NhdGlvbiwgdWludDE2X3Qg dmFsdWUpCit7CisgICAgQVNTRVJUKHZlY3Rvci5zaXplKCkgPj0gbG9jYXRpb24gKyAyKTsKKyAg ICB2ZWN0b3JbbG9jYXRpb25dID0gdmFsdWUgPj4gODsKKyAgICB2ZWN0b3JbbG9jYXRpb24gKyAx XSA9IHZhbHVlOwogfQogCiBjbGFzcyBTVkdUb09URkZvbnRDb252ZXJ0ZXIgewpAQCAtNjksMTIg Kzc2LDEyIEBAIHB1YmxpYzoKICAgICBWZWN0b3I8Y2hhcj4gY29udmVydFNWR1RvT1RGRm9udCgp OwogCiBwcml2YXRlOgotICAgIHR5cGVkZWYgdWludDE2X3QgU0lEOyAvLyBTdHJpbmcgSUQKICAg ICB0eXBlZGVmIFVDaGFyIENvZGVwb2ludDsgLy8gRklYTUU6IE9ubHkgc3VwcG9ydCBCTVAgZm9y IG5vdworCiAgICAgc3RydWN0IEdseXBoRGF0YSB7CiAgICAgICAgIEdseXBoRGF0YShWZWN0b3I8 Y2hhcj4gY2hhclN0cmluZywgY29uc3QgU1ZHR2x5cGhFbGVtZW50KiBnbHlwaEVsZW1lbnQsIGZs b2F0IGhvcml6b250YWxBZHZhbmNlLCBmbG9hdCB2ZXJ0aWNhbEFkdmFuY2UsIEZsb2F0UmVjdCBi b3VuZGluZ0JveCwgQ29kZXBvaW50IGNvZGVwb2ludCkKICAgICAgICAgICAgIDogYm91bmRpbmdC b3goYm91bmRpbmdCb3gpCi0gICAgICAgICAgICAsIGNoYXJTdHJpbmcoY2hhclN0cmluZykKKyAg ICAgICAgICAgICwgY2hhclN0cmluZyhXVEY6Om1vdmUoY2hhclN0cmluZykpCiAgICAgICAgICAg ICAsIGdseXBoRWxlbWVudChnbHlwaEVsZW1lbnQpCiAgICAgICAgICAgICAsIGhvcml6b250YWxB ZHZhbmNlKGhvcml6b250YWxBZHZhbmNlKQogICAgICAgICAgICAgLCB2ZXJ0aWNhbEFkdmFuY2Uo dmVydGljYWxBZHZhbmNlKQpAQCAtOTYsMjMgKzEwMywxNSBAQCBwcml2YXRlOgogICAgICAgICAg ICAgLCBhZGp1c3RtZW50KGFkanVzdG1lbnQpCiAgICAgICAgIHsKICAgICAgICAgfQotICAgICAg ICBib29sIG9wZXJhdG9yPChjb25zdCBLZXJuaW5nRGF0YSYgb3RoZXIpIGNvbnN0Ci0gICAgICAg IHsKLSAgICAgICAgICAgIHJldHVybiBnbHlwaDEgPCBvdGhlci5nbHlwaDEgfHwgKGdseXBoMSA9 PSBvdGhlci5nbHlwaDEgJiYgZ2x5cGgyIDwgb3RoZXIuZ2x5cGgyKTsKLSAgICAgICAgfQogICAg ICAgICB1aW50MTZfdCBnbHlwaDE7CiAgICAgICAgIHVpbnQxNl90IGdseXBoMjsKICAgICAgICAg aW50MTZfdCBhZGp1c3RtZW50OwogICAgIH07CiAKLSAgICBzdGF0aWMgY29uc3Qgc2l6ZV90IGtT TkZUSGVhZGVyU2l6ZSA9IDEyOwotICAgIHN0YXRpYyBjb25zdCBzaXplX3Qga0RpcmVjdG9yeUVu dHJ5U2l6ZSA9IDE2OwotCisgICAgc3RhdGljIGNvbnN0IHNpemVfdCBoZWFkZXJTaXplID0gMTI7 CisgICAgc3RhdGljIGNvbnN0IHNpemVfdCBkaXJlY3RvcnlFbnRyeVNpemUgPSAxNjsKIAotICAg IHRlbXBsYXRlIDx0eXBlbmFtZSBUPgotICAgIHZvaWQgYXBwZW5kR2x5cGhEYXRhKGNvbnN0IFZl Y3RvcjxjaGFyPiYgcGF0aCwgY29uc3QgVCogZWxlbWVudCwgZmxvYXQgaG9yaXpvbnRhbEFkdmFu Y2UsIGZsb2F0IHZlcnRpY2FsQWR2YW5jZSwgY29uc3QgRmxvYXRSZWN0JiBib3VuZGluZ0JveCwg Q29kZXBvaW50IGNvZGVwb2ludCk7Ci0gICAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+Ci0gICAgdm9p ZCBwcm9jZXNzR2x5cGhFbGVtZW50KGNvbnN0IFQmIGVsZW1lbnQsIGZsb2F0IGRlZmF1bHRIb3Jp em9udGFsQWR2YW5jZSwgZmxvYXQgZGVmYXVsdFZlcnRpY2FsQWR2YW5jZSwgQ29kZXBvaW50LCBi b29sJiBpbml0aWFsR2x5cGgpOworICAgIHZvaWQgcHJvY2Vzc0dseXBoRWxlbWVudChjb25zdCBT VkdFbGVtZW50JiBnbHlwaE9yTWlzc2luZ0dseXBoRWxlbWVudCwgY29uc3QgU1ZHR2x5cGhFbGVt ZW50KiwgZmxvYXQgZGVmYXVsdEhvcml6b250YWxBZHZhbmNlLCBmbG9hdCBkZWZhdWx0VmVydGlj YWxBZHZhbmNlLCBDb2RlcG9pbnQsIGJvb2wmIGluaXRpYWxHbHlwaCk7CiAKICAgICB0eXBlZGVm IHZvaWQgKFNWR1RvT1RGRm9udENvbnZlcnRlcjo6KkZvbnRBcHBlbmRpbmdGdW5jdGlvbikoVmVj dG9yPGNoYXI+ICYpIGNvbnN0OwogICAgIHZvaWQgYXBwZW5kVGFibGUoY29uc3QgY2hhciBpZGVu dGlmaWVyWzRdLCBWZWN0b3I8Y2hhcj4mLCBGb250QXBwZW5kaW5nRnVuY3Rpb24pOwpAQCAtMTMw LDIwICsxMjksMTggQEAgcHJpdmF0ZToKICAgICB2b2lkIGFwcGVuZENGRlRhYmxlKFZlY3Rvcjxj aGFyPiYpIGNvbnN0OwogICAgIHZvaWQgYXBwZW5kVk9SR1RhYmxlKFZlY3RvcjxjaGFyPiYpIGNv bnN0OwogCi0gICAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+Ci0gICAgVmVjdG9yPGNoYXI+IHRyYW5z Y29kZUdseXBoUGF0aHMoZmxvYXQgd2lkdGgsIGNvbnN0IFQmIGdseXBoRWxlbWVudCwgRmxvYXRS ZWN0JiBib3VuZGluZ0JveCkgY29uc3Q7CisgICAgVmVjdG9yPGNoYXI+IHRyYW5zY29kZUdseXBo UGF0aHMoZmxvYXQgd2lkdGgsIGNvbnN0IFNWR0VsZW1lbnQmIGdseXBoT3JNaXNzaW5nR2x5cGhF bGVtZW50LCBGbG9hdFJlY3QmIGJvdW5kaW5nQm94KSBjb25zdDsKIAogICAgIHZvaWQgYWRkQ29k ZXBvaW50UmFuZ2VzKGNvbnN0IFVuaWNvZGVSYW5nZXMmLCBIYXNoU2V0PHVpbnQxNl90PiYgZ2x5 cGhTZXQpIGNvbnN0OwogICAgIHZvaWQgYWRkQ29kZXBvaW50cyhjb25zdCBIYXNoU2V0PFN0cmlu Zz4mIGNvZGVwb2ludHMsIEhhc2hTZXQ8dWludDE2X3Q+JiBnbHlwaFNldCkgY29uc3Q7CiAgICAg dm9pZCBhZGRHbHlwaE5hbWVzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYgZ2x5cGhOYW1lcywgSGFz aFNldDx1aW50MTZfdD4mIGdseXBoU2V0KSBjb25zdDsKLSAgICB0ZW1wbGF0ZSA8dHlwZW5hbWUg VD4KLSAgICBWZWN0b3I8S2VybmluZ0RhdGE+IGNvbXB1dGVLZXJuaW5nRGF0YShib29sIChUOjoq YnVpbGRLZXJuaW5nUGFpcikoU1ZHS2VybmluZ1BhaXImKSBjb25zdCkgY29uc3Q7Ci0gICAgdGVt cGxhdGUgPHR5cGVuYW1lIFQ+Ci0gICAgc2l6ZV90IGFwcGVuZEtFUk5TdWJ0YWJsZShWZWN0b3I8 Y2hhcj4mIHJlc3VsdCwgYm9vbCAoVDo6KmJ1aWxkS2VybmluZ1BhaXIpKFNWR0tlcm5pbmdQYWly JikgY29uc3QsIHVpbnQxNl90IGNvdmVyYWdlKSBjb25zdDsKKyAgICB2b2lkIGFkZEtlcm5pbmdQ YWlyKFZlY3RvcjxLZXJuaW5nRGF0YT4mLCBjb25zdCBTVkdLZXJuaW5nUGFpciYpIGNvbnN0Owor ICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IHNpemVfdCBhcHBlbmRLRVJOU3VidGFibGUoVmVjdG9y PGNoYXI+JiByZXN1bHQsIGJvb2wgKFQ6OipidWlsZEtlcm5pbmdQYWlyKShTVkdLZXJuaW5nUGFp ciYpIGNvbnN0LCB1aW50MTZfdCBjb3ZlcmFnZSkgY29uc3Q7CisgICAgc2l6ZV90IGZpbmlzaEFw cGVuZGluZ0tFUk5TdWJ0YWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCwgVmVjdG9yPEtlcm5pbmdE YXRhPiwgdWludDE2X3QgY292ZXJhZ2UpIGNvbnN0OwogCiAgICAgVmVjdG9yPEdseXBoRGF0YT4g bV9nbHlwaHM7CiAgICAgSGFzaE1hcDxTdHJpbmcsIEdseXBoPiBtX2dseXBoTmFtZVRvSW5kZXhN YXA7IC8vIFNWRyAxLjE6ICJJdCBpcyByZWNvbW1lbmRlZCB0aGF0IGdseXBoIG5hbWVzIGJlIHVu aXF1ZSB3aXRoaW4gYSBmb250LiIKLSAgICBIYXNoTWFwPENvZGVwb2ludCwgR2x5cGg+IG1fY29k ZXBvaW50VG9JbmRleE1hcDsgLy8gRklYTUU6IFRoZXJlIG1pZ2h0IGJlIG1hbnkgZ2x5cGhzIHRo YXQgbWFwIHRvIGEgc2luZ2xlIGNvZGVwb2ludC4KKyAgICBIYXNoTWFwPFVDaGFyMzIsIEdseXBo PiBtX2NvZGVwb2ludFRvSW5kZXhNYXA7IC8vIEZJWE1FOiBUaGVyZSBtaWdodCBiZSBtYW55IGds eXBocyB0aGF0IG1hcCB0byBhIHNpbmdsZSBjb2RlcG9pbnQuCiAgICAgRmxvYXRSZWN0IG1fYm91 bmRpbmdCb3g7CiAgICAgY29uc3QgU1ZHRm9udEVsZW1lbnQmIG1fZm9udEVsZW1lbnQ7CiAgICAg Y29uc3QgU1ZHRm9udEZhY2VFbGVtZW50KiBtX2ZvbnRGYWNlRWxlbWVudDsKQEAgLTE2Nyw3ICsx NjQsOCBAQCBzdGF0aWMgdWludDE2X3Qgcm91bmREb3duVG9Qb3dlck9mVHdvKHVpbnQxNl90IHgp CiAgICAgcmV0dXJuICh4ID4+IDEpICsgMTsKIH0KIAotc3RhdGljIHVpbnQxNl90IGludGVncmFs TG9nMih1aW50MTZfdCB4KSB7CitzdGF0aWMgdWludDE2X3QgaW50ZWdyYWxMb2cyKHVpbnQxNl90 IHgpCit7CiAgICAgdWludDE2X3QgcmVzdWx0ID0gMDsKICAgICB3aGlsZSAoeCA+Pj0gMSkKICAg ICAgICAgKytyZXN1bHQ7CkBAIC0yMDQsOSArMjAyLDkgQEAgdm9pZCBTVkdUb09URkZvbnRDb252 ZXJ0ZXI6OmFwcGVuZENNQVBUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICBm b3IgKGF1dG8mIGdseXBoIDogbV9nbHlwaHMpCiAgICAgICAgIHdyaXRlMTYocmVzdWx0LCBnbHlw aC5jb2RlcG9pbnQpOyAvLyBzdGFydENvZGUKICAgICB3cml0ZTE2KHJlc3VsdCwgMHhGRkZGKTsK LSAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9nbHlwaHMuc2l6ZSgpOyArK2kpIHsKKyAg ICBmb3IgKEdseXBoIGkgPSAwOyBpIDwgbV9nbHlwaHMuc2l6ZSgpOyArK2kpIHsKICAgICAgICAg Ly8gTm90ZSB0aGF0IHRoaXMgdmFsdWUgY2FuIGJlICJuZWdhdGl2ZSwiIGJ1dCB0aGF0IGlzIG9r YXkgYmVjYXVzZSB3cmFwcGluZyBpcyBkZWZpbmVkIGFuZCBleHBlY3RlZCBoZXJlCi0gICAgICAg IHdyaXRlMTYocmVzdWx0LCBzdGF0aWNfY2FzdDx1aW50MTZfdD4oaSkgLSBtX2dseXBoc1tpXS5j b2RlcG9pbnQpOyAvLyBpZERlbHRhCisgICAgICAgIHdyaXRlMTYocmVzdWx0LCBpIC0gbV9nbHlw aHNbaV0uY29kZXBvaW50KTsgLy8gaWREZWx0YQogICAgIH0KICAgICB3cml0ZTE2KHJlc3VsdCwg MSk7CiAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fZ2x5cGhzLnNpemUoKTsgKytpKQpA QCAtMjE4LDEyICsyMTYsOCBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEVB RFRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogewogICAgIHdyaXRlMzIocmVzdWx0 LCAweDAwMDEwMDAwKTsgLy8gVmVyc2lvbgogICAgIHdyaXRlMzIocmVzdWx0LCAweDAwMDEwMDAw KTsgLy8gUmV2aXNpb24KLSAgICB3cml0ZTMyKHJlc3VsdCwgMCk7IC8vIENoZWNrc3VtIGFkanVz dG1lbnQKLSAgICAvLyBNYWdpYyBudW1iZXIuICJTZXQgdG8gMHg1RjBGM0NGNSIKLSAgICByZXN1 bHQuYXBwZW5kKDB4NUYpOwotICAgIHJlc3VsdC5hcHBlbmQoMHgwRik7Ci0gICAgcmVzdWx0LmFw cGVuZCgweDNDKTsKLSAgICByZXN1bHQuYXBwZW5kKC0weDBCKTsgLy8gV3JhcGFyb3VuZAorICAg IHdyaXRlMzIocmVzdWx0LCAwKTsgLy8gQ2hlY2tzdW0gcGxhY2Vob2xkZXI7IHRvIGJlIG92ZXJ3 cml0dGVuIGJ5IHRoZSBjYWxsZXIuCisgICAgd3JpdGUzMihyZXN1bHQsIDB4NUYwRjNDRjUpOyAv LyBNYWdpYyBudW1iZXIuCiAgICAgd3JpdGUxNihyZXN1bHQsICgxIDw8IDkpIHwgMSk7CiAKICAg ICB3cml0ZTE2KHJlc3VsdCwgbV91bml0c1BlckVtKTsKQEAgLTI0Miw5ICsyMzYsOCBAQCB2b2lk IFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEVBRFRhYmxlKFZlY3RvcjxjaGFyPiYgcmVz dWx0KSBjb25zdAogICAgIHdyaXRlMTYocmVzdWx0LCAwKTsgLy8gR2x5cGggZGF0YSBmb3JtYXQK IH0KIAotLy8gQXNzdW1wdGlvbjogVDIgY2FuIGhvbGQgZXZlcnkgdmFsdWUgdGhhdCBhIFQxIGNh biBob2xkCi10ZW1wbGF0ZSA8dHlwZW5hbWUgVDEsIHR5cGVuYW1lIFQyPgotc3RhdGljIGlubGlu ZSBUMSBjbGFtcFRvKFQyIHgpCisvLyBBc3N1bXB0aW9uOiBUMiBjYW4gaG9sZCBldmVyeSB2YWx1 ZSB0aGF0IGEgVDEgY2FuIGhvbGQuCit0ZW1wbGF0ZTx0eXBlbmFtZSBUMSwgdHlwZW5hbWUgVDI+ IHN0YXRpYyBpbmxpbmUgVDEgY2xhbXBUbyhUMiB4KQogewogICAgIHggPSBzdGQ6Om1pbih4LCBz dGF0aWNfY2FzdDxUMj4oc3RkOjpudW1lcmljX2xpbWl0czxUMT46Om1heCgpKSk7CiAgICAgeCA9 IHN0ZDo6bWF4KHgsIHN0YXRpY19jYXN0PFQyPihzdGQ6Om51bWVyaWNfbGltaXRzPFQxPjo6bWlu KCkpKTsKQEAgLTI1MywzMyArMjQ2LDM0IEBAIHN0YXRpYyBpbmxpbmUgVDEgY2xhbXBUbyhUMiB4 KQogCiB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEhFQVRhYmxlKFZlY3Rvcjxj aGFyPiYgcmVzdWx0KSBjb25zdAogewotICAgIGludDE2X3QgYXNjZW50ID0gc3RkOjpudW1lcmlj X2xpbWl0czxpbnQxNl90Pjo6bWF4KCk7Ci0gICAgaW50MTZfdCBkZXNjZW50ID0gc3RkOjpudW1l cmljX2xpbWl0czxpbnQxNl90Pjo6bWF4KCk7Ci0gICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KSB7 CisgICAgaW50MTZfdCBhc2NlbnQ7CisgICAgaW50MTZfdCBkZXNjZW50OworICAgIGlmICghbV9m b250RmFjZUVsZW1lbnQpIHsKKyAgICAgICAgYXNjZW50ID0gc3RkOjpudW1lcmljX2xpbWl0czxp bnQxNl90Pjo6bWF4KCk7CisgICAgICAgIGRlc2NlbnQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGlu dDE2X3Q+OjptYXgoKTsKKyAgICB9IGVsc2UgewogICAgICAgICBhc2NlbnQgPSBtX2ZvbnRGYWNl RWxlbWVudC0+YXNjZW50KCk7CiAgICAgICAgIGRlc2NlbnQgPSBtX2ZvbnRGYWNlRWxlbWVudC0+ ZGVzY2VudCgpOwotICAgIH0KIAotICAgIC8vIE1hbnkgcGxhdGZvcm1zIHdpbGwgYXNzdW1lIHRo YXQgYSAwIGFzY2VudCBvciBkZXNjZW50IG1lYW5zIHRoYXQgdGhlIHBsYXRmb3JtIHNob3VsZCBz eW50aGVzaXplIGEgZm9udAotICAgIC8vIGJhc2VkIG9uIGEgaGV1cmlzdGljLiBIb3dldmVyLCBt YW55IFNWRyBmb250cyBsZWdpdGltaXRlbHkgaGF2ZSBhIDAgYXNjZW50IG9yIGRlc2NlbnQuIFRo ZXJlZm9yZSwKLSAgICAvLyB3ZSBzaG91bGQgc3BlY2lmeSBhIHNpbmdsZSBGVW5pdCBpbnN0ZWFk LCB3aGljaCBpcyBhcyBjbG9zZSBhcyB3ZSBjYW4gZ2V0IHRvIDAgd2l0aG91dCBhY3R1YWxseSBi ZWluZwotICAgIC8vIGl0LgotICAgIGlmICghYXNjZW50KQotICAgICAgICBhc2NlbnQgPSAxOwot ICAgIGlmICghZGVzY2VudCkKLSAgICAgICAgZGVzY2VudCA9IDE7CisgICAgICAgIC8vIFNvbWUg cGxhdGZvcm1zLCBpbmNsdWRpbmcgT1MgWCwgdXNlIDAgYXNjZW50IGFuZCBkZXNjZW50IHRvIG1l YW4gdGhhdCB0aGUgcGxhdGZvcm0gc2hvdWxkIHN5bnRoZXNpemUKKyAgICAgICAgLy8gYSB2YWx1 ZSBiYXNlZCBvbiBhIGhldXJpc3RpYy4gSG93ZXZlciwgU1ZHIGZvbnRzIGNhbiBsZWdpdGltYXRl bHkgaGF2ZSAwIGZvciBhc2NlbnQgb3IgZGVzY2VudC4KKyAgICAgICAgLy8gU3BlY2lmaW5nIGEg c2luZ2xlIEZVbml0IGdldHMgdXMgYXMgY2xvc2UgdG8gMCBhcyB3ZSBjYW4gd2l0aG91dCB0cmln Z2VyaW5nIHRoZSBzeW50aGVzaXMuCisgICAgICAgIGlmICghYXNjZW50KQorICAgICAgICAgICAg YXNjZW50ID0gMTsKKyAgICAgICAgaWYgKCFkZXNjZW50KQorICAgICAgICAgICAgZGVzY2VudCA9 IDE7CisgICAgfQogCiAgICAgd3JpdGUzMihyZXN1bHQsIDB4MDAwMTAwMDApOyAvLyBWZXJzaW9u CiAgICAgd3JpdGUxNihyZXN1bHQsIGFzY2VudCk7CiAgICAgd3JpdGUxNihyZXN1bHQsIGRlc2Nl bnQpOwotICAgIC8vIFdlYktpdCdzIFNWRyBjb2RlcGF0aCBoYXJkY29kZXMgdGhlIGxpbmUgZ2Fw IHRvIGJlIDEvMTB0aCBvZiB0aGUgZm9udCBzaXplIChzZWUgcjI5NzE5KS4gTWF0Y2hpbmcgdGhh dAotICAgIC8vIGFsbG93cyB1cyB0byBoYXZlIGNvbnNpc3RlbnQgcmVuZGVyaW5ncyBiZXR3ZWVu IHRoZSB0d28gcGF0aHMuCisgICAgLy8gV2ViS2l0IFNWRyBmb250IHJlbmRlcmluZyBoYXMgaGFy ZCBjb2RlZCB0aGUgbGluZSBnYXAgdG8gYmUgMS8xMHRoIG9mIHRoZSBmb250IHNpemUgc2luY2Ug MjAwOCAoc2VlIHIyOTcxOSkuCiAgICAgd3JpdGUxNihyZXN1bHQsIG1fdW5pdHNQZXJFbSAvIDEw KTsgLy8gTGluZSBnYXAKICAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBUbzx1aW50MTZfdD4obV9h ZHZhbmNlV2lkdGhNYXgpKTsKICAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBUbzxpbnQxNl90Piht X2JvdW5kaW5nQm94LngoKSkpOyAvLyBNaW5pbXVtIGxlZnQgc2lkZSBiZWFyaW5nCiAgICAgd3Jp dGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdD4obV9taW5SaWdodFNpZGVCZWFyaW5nKSk7IC8v IE1pbmltdW0gcmlnaHQgc2lkZSBiZWFyaW5nCiAgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88 aW50MTZfdD4obV9ib3VuZGluZ0JveC5tYXhYKCkpKTsgLy8gWCBtYXhpbXVtIGV4dGVudAotICAg IC8vIFdlYktpdCBkcmF3cyB0aGUgY2FyZXQKKyAgICAvLyBTaW5jZSBXZWJLaXQgZHJhd3MgdGhl IGNhcmV0IGFuZCBpZ25vcmVzIHRoZSBmb2xsb3dpbmcgdmFsdWVzLCBpdCBkb2Vzbid0IG1hdHRl ciB3aGF0IHdlIHNldCB0aGVtIHRvLgogICAgIHdyaXRlMTYocmVzdWx0LCAxKTsgLy8gVmVydGlj YWwgY2FyZXQKICAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnRpY2FsIGNhcmV0CiAgICAg d3JpdGUxNihyZXN1bHQsIDApOyAvLyAiU2V0IHZhbHVlIHRvIDAgZm9yIG5vbi1zbGFudGVkIGZv bnRzIgpAQCAtMzM2LDE2ICszMzAsMTIgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFw cGVuZE5BTUVUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKIHZvaWQgU1ZHVG9PVEZG b250Q29udmVydGVyOjphcHBlbmRPUzJUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QK IHsKICAgICBpbnQxNl90IGF2ZXJhZ2VBZHZhbmNlID0gbV91bml0c1BlckVtOwotICAgIGF1dG8m IGF0dHJpYnV0ZSA9IG1fZm9udEVsZW1lbnQuZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9y aXpfYWR2X3hBdHRyKTsKICAgICBib29sIG9rOwotICAgIGludCB2YWx1ZSA9IGF0dHJpYnV0ZS50 b0ludCgmb2spOworICAgIGludCB2YWx1ZSA9IG1fZm9udEVsZW1lbnQuZmFzdEdldEF0dHJpYnV0 ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKS50b0ludCgmb2spOworICAgIGlmICghb2sgJiYg bV9taXNzaW5nR2x5cGhFbGVtZW50KQorICAgICAgICB2YWx1ZSA9IG1fbWlzc2luZ0dseXBoRWxl bWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKS50b0ludCgm b2spOwogICAgIGlmIChvaykKICAgICAgICAgYXZlcmFnZUFkdmFuY2UgPSBjbGFtcFRvPGludDE2 X3Q+KHZhbHVlKTsKLSAgICBlbHNlIGlmIChtX21pc3NpbmdHbHlwaEVsZW1lbnQpIHsKLSAgICAg ICAgaW50IHZhbHVlID0gbV9taXNzaW5nR2x5cGhFbGVtZW50LT5mYXN0R2V0QXR0cmlidXRlKFNW R05hbWVzOjpob3Jpel9hZHZfeEF0dHIpLnRvSW50KCZvayk7Ci0gICAgICAgIGlmIChvaykKLSAg ICAgICAgICAgIGF2ZXJhZ2VBZHZhbmNlID0gY2xhbXBUbzxpbnQxNl90Pih2YWx1ZSk7Ci0gICAg fQogCiAgICAgd3JpdGUxNihyZXN1bHQsIDApOyAvLyBWZXJzaW9uCiAgICAgd3JpdGUxNihyZXN1 bHQsIGF2ZXJhZ2VBZHZhbmNlKTsKQEAgLTM2NSwzOCArMzU1LDMxIEBAIHZvaWQgU1ZHVG9PVEZG b250Q29udmVydGVyOjphcHBlbmRPUzJUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QK ICAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFN0cmlrZW91dCBQb3NpdGlvbgogICAgIHdyaXRl MTYocmVzdWx0LCAwKTsgLy8gTm8gY2xhc3NpZmljYXRpb24KIAotICAgIFZlY3Rvcjx1bnNpZ25l ZCBjaGFyPiBzcGVjaWZpZWRQYW5vc2U7CisgICAgdW5zaWduZWQgbnVtUGFub3NlQnl0ZXMgPSAw OworICAgIGNvbnN0IHVuc2lnbmVkIHBhbm9zZVNpemUgPSAxMDsKKyAgICBjaGFyIHBhbm9zZUJ5 dGVzW3Bhbm9zZVNpemVdOwogICAgIGlmIChtX2ZvbnRGYWNlRWxlbWVudCkgewotICAgICAgICBh dXRvJiBhdHRyaWJ1dGUgPSBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdO YW1lczo6cGFub3NlXzFBdHRyKTsKLSAgICAgICAgVmVjdG9yPFN0cmluZz4gc3BsaXQ7Ci0gICAg ICAgIFN0cmluZyhhdHRyaWJ1dGUpLnNwbGl0KCIgIiwgc3BsaXQpOwotICAgICAgICBpZiAoc3Bs aXQuc2l6ZSgpID09IDEwKSB7Ci0gICAgICAgICAgICBmb3IgKGF1dG8mIHMgOiBzcGxpdCkgewot ICAgICAgICAgICAgICAgIGJvb2wgb2sgPSB0cnVlOwotICAgICAgICAgICAgICAgIGludCB2YWx1 ZSA9IHMudG9JbnQoJm9rKTsKLSAgICAgICAgICAgICAgICBpZiAoIW9rIHx8IHZhbHVlIDwgMCB8 fCB2YWx1ZSA+IDB4RkYpIHsKLSAgICAgICAgICAgICAgICAgICAgc3BlY2lmaWVkUGFub3NlLmNs ZWFyKCk7Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgICAgIH0KLSAg ICAgICAgICAgICAgICBzcGVjaWZpZWRQYW5vc2UuYXBwZW5kKHN0YXRpY19jYXN0PHVuc2lnbmVk IGNoYXI+KHZhbHVlKSk7CisgICAgICAgIFZlY3RvcjxTdHJpbmc+IHNlZ21lbnRzOworICAgICAg ICBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6cGFub3NlXzFB dHRyKS5zdHJpbmcoKS5zcGxpdCgnICcsIHNlZ21lbnRzKTsKKyAgICAgICAgaWYgKHNlZ21lbnRz LnNpemUoKSA9PSBwYW5vc2VTaXplKSB7CisgICAgICAgICAgICBmb3IgKGF1dG8mIHNlZ21lbnQg OiBzZWdtZW50cykgeworICAgICAgICAgICAgICAgIGJvb2wgb2s7CisgICAgICAgICAgICAgICAg aW50IHZhbHVlID0gc2VnbWVudC50b0ludCgmb2spOworICAgICAgICAgICAgICAgIGlmIChvayAm JiB2YWx1ZSA+PSAwICYmIHZhbHVlIDw9IDB4RkYpCisgICAgICAgICAgICAgICAgICAgIHBhbm9z ZUJ5dGVzW251bVBhbm9zZUJ5dGVzKytdID0gdmFsdWU7CiAgICAgICAgICAgICB9CiAgICAgICAg IH0KICAgICB9Ci0KLSAgICBpZiAoc3BlY2lmaWVkUGFub3NlLnNpemUoKSA9PSAxMCkgewotICAg ICAgICBmb3IgKGNoYXIgYyA6IHNwZWNpZmllZFBhbm9zZSkKLSAgICAgICAgICAgIHJlc3VsdC5h cHBlbmQoYyk7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCAxMDsg KytpKQotICAgICAgICAgICAgcmVzdWx0LmFwcGVuZCgwKTsgLy8gUEFOT1NFOiBBbnkKLSAgICB9 CisgICAgaWYgKG51bVBhbm9zZUJ5dGVzICE9IHBhbm9zZVNpemUpCisgICAgICAgIG1lbXNldChw YW5vc2VCeXRlcywgMCwgcGFub3NlU2l6ZSk7CisgICAgcmVzdWx0LmFwcGVuZChwYW5vc2VCeXRl cywgcGFub3NlU2l6ZSk7CiAKICAgICBmb3IgKGludCBpID0gMDsgaSA8IDQ7ICsraSkKICAgICAg ICAgd3JpdGUzMihyZXN1bHQsIDApOyAvLyAiQml0IGFzc2lnbm1lbnRzIGFyZSBwZW5kaW5nLiBT ZXQgdG8gMCIKICAgICB3cml0ZTMyKHJlc3VsdCwgMHg1NDRCNDI1Nyk7IC8vIEZvbnQgVmVuZG9y LiAiV0JLVCIKICAgICB3cml0ZTE2KHJlc3VsdCwgKG1fd2VpZ2h0ID49IDcgPyAxIDw8IDUgOiAw KSB8IChtX2l0YWxpYyA/IDEgOiAwKSk7IC8vIEZvbnQgUGF0dGVybnMuCi0gICAgd3JpdGUxNihy ZXN1bHQsIG1fZ2x5cGhzWzBdLmNvZGVwb2ludCk7IC8vIEZpcnN0IHVuaWNvZGUgaW5kZXgKLSAg ICB3cml0ZTE2KHJlc3VsdCwgbV9nbHlwaHNbbV9nbHlwaHMuc2l6ZSgpIC0gMV0uY29kZXBvaW50 KTsgLy8gTGFzdCB1bmljb2RlIGluZGV4CisgICAgd3JpdGUxNihyZXN1bHQsIG1fZ2x5cGhzLmZp cnN0KCkuY29kZXBvaW50KTsgLy8gRmlyc3QgdW5pY29kZSBpbmRleAorICAgIHdyaXRlMTYocmVz dWx0LCBtX2dseXBocy5sYXN0KCkuY29kZXBvaW50KTsgLy8gTGFzdCB1bmljb2RlIGluZGV4CiB9 CiAKIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRQT1NUVGFibGUoVmVjdG9yPGNo YXI+JiByZXN1bHQpIGNvbnN0CkBAIC00MjEsNyArNDA0LDcgQEAgc3RhdGljIGJvb2wgaXNWYWxp ZFN0cmluZ0ZvckNGRihjb25zdCBTdHJpbmcmIHN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0K IAotc3RhdGljIHZvaWQgYXBwZW5kQ0ZGVmFsaWRTdHJpbmcoVmVjdG9yPGNoYXI+JiBvdXRwdXQs IGNvbnN0IFN0cmluZyYgc3RyaW5nKQorc3RhdGljIHZvaWQgYXBwZW5kVmFsaWRDRkZTdHJpbmco VmVjdG9yPGNoYXI+JiBvdXRwdXQsIGNvbnN0IFN0cmluZyYgc3RyaW5nKQogewogICAgIEFTU0VS VChpc1ZhbGlkU3RyaW5nRm9yQ0ZGKHN0cmluZykpOwogICAgIGZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCBzdHJpbmcubGVuZ3RoKCk7ICsraSkKQEAgLTQzMSw2ICs0MTQsNyBAQCBzdGF0aWMgdm9p ZCBhcHBlbmRDRkZWYWxpZFN0cmluZyhWZWN0b3I8Y2hhcj4mIG91dHB1dCwgY29uc3QgU3RyaW5n JiBzdHJpbmcpCiB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kQ0ZGVGFibGUoVmVj dG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiB7CiAgICAgYXV0byBzdGFydGluZ09mZnNldCA9IHJl c3VsdC5zaXplKCk7CisKICAgICAvLyBIZWFkZXIKICAgICByZXN1bHQuYXBwZW5kKDEpOyAvLyBN YWpvciB2ZXJzaW9uCiAgICAgcmVzdWx0LmFwcGVuZCgwKTsgLy8gTWlub3IgdmVyc2lvbgpAQCAt NDQwLDcgKzQyNCw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRDRkZUYWJs ZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICAvLyBOYW1lIElOREVYCiAgICAgU3Ry aW5nIGZvbnROYW1lOwogICAgIGlmIChtX2ZvbnRGYWNlRWxlbWVudCkgewotICAgICAgICAvLyBG SVhNRTogZm9udEZhbWlseSgpIGhlcmUgbWlnaHQgbm90IGJlIHF1aXRlIHdoYXQgSSB3YW50Cisg ICAgICAgIC8vIEZJWE1FOiBmb250RmFtaWx5KCkgaGVyZSBtaWdodCBub3QgYmUgcXVpdGUgd2hh dCB3ZSB3YW50LgogICAgICAgICBTdHJpbmcgcG90ZW50aWFsRm9udE5hbWUgPSBtX2ZvbnRGYW1p bHk7CiAgICAgICAgIGlmIChpc1ZhbGlkU3RyaW5nRm9yQ0ZGKHBvdGVudGlhbEZvbnROYW1lKSkK ICAgICAgICAgICAgIGZvbnROYW1lID0gcG90ZW50aWFsRm9udE5hbWU7CkBAIC00NDksNyArNDMz LDcgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZENGRlRhYmxlKFZlY3Rvcjxj aGFyPiYgcmVzdWx0KSBjb25zdAogICAgIHJlc3VsdC5hcHBlbmQoNCk7IC8vIE9mZnNldHMgaW4g dGhpcyBJTkRFWCBhcmUgNCBieXRlcyBsb25nCiAgICAgd3JpdGUzMihyZXN1bHQsIDEpOyAvLyAx LWluZGV4IG9mZnNldCBvZiBuYW1lIGRhdGEKICAgICB3cml0ZTMyKHJlc3VsdCwgZm9udE5hbWUu bGVuZ3RoKCkgKyAxKTsgLy8gMS1pbmRleCBvZmZzZXQganVzdCBwYXN0IGVuZCBvZiBuYW1lIGRh dGEKLSAgICBhcHBlbmRDRkZWYWxpZFN0cmluZyhyZXN1bHQsIGZvbnROYW1lKTsKKyAgICBhcHBl bmRWYWxpZENGRlN0cmluZyhyZXN1bHQsIGZvbnROYW1lKTsKIAogICAgIFN0cmluZyB3ZWlnaHQ7 CiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KSB7CkBAIC00NTgsNiArNDQyLDggQEAgdm9pZCBT VkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZENGRlRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0 KSBjb25zdAogICAgICAgICAgICAgd2VpZ2h0ID0gcG90ZW50aWFsV2VpZ2h0OwogICAgIH0KIAor ICAgIGJvb2wgaGFzV2VpZ2h0ID0gIXdlaWdodC5pc051bGwoKTsKKwogICAgIGNvbnN0IGNoYXIg b3BlcmFuZDMyQml0ID0gMjk7CiAgICAgY29uc3QgY2hhciBmdWxsTmFtZUtleSA9IDI7CiAgICAg Y29uc3QgY2hhciBmYW1pbHlOYW1lS2V5ID0gMzsKQEAgLTQ2Niw3ICs0NTIsNyBAQCB2b2lkIFNW R1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kQ0ZGVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQp IGNvbnN0CiAgICAgY29uc3QgY2hhciBjaGFyc2V0SW5kZXhLZXkgPSAxNTsKICAgICBjb25zdCBj aGFyIGNoYXJzdHJpbmdzSW5kZXhLZXkgPSAxNzsKICAgICBjb25zdCB1aW50MzJfdCB1c2VyRGVm aW5lZFN0cmluZ1N0YXJ0SW5kZXggPSAzOTE7Ci0gICAgY29uc3QgdW5zaWduZWQgc2l6ZU9mVG9w SW5kZXggPSA0NSArICh3ZWlnaHQuaXNFbXB0eSgpID8gMCA6IDYpOworICAgIGNvbnN0IHVuc2ln bmVkIHNpemVPZlRvcEluZGV4ID0gNDUgKyAoaGFzV2VpZ2h0ID8gNiA6IDApOwogCiAgICAgLy8g VG9wIERJQ1QgSU5ERVguCiAgICAgd3JpdGUxNihyZXN1bHQsIDEpOyAvLyBJTkRFWCBjb250YWlu cyAxIGVsZW1lbnQKQEAgLTQ4NCw3ICs0NzAsNyBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRl cjo6YXBwZW5kQ0ZGVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgcmVzdWx0 LmFwcGVuZChvcGVyYW5kMzJCaXQpOwogICAgIHdyaXRlMzIocmVzdWx0LCB1c2VyRGVmaW5lZFN0 cmluZ1N0YXJ0SW5kZXgpOwogICAgIHJlc3VsdC5hcHBlbmQoZmFtaWx5TmFtZUtleSk7Ci0gICAg aWYgKCF3ZWlnaHQuaXNFbXB0eSgpKSB7CisgICAgaWYgKGhhc1dlaWdodCkgewogICAgICAgICBy ZXN1bHQuYXBwZW5kKG9wZXJhbmQzMkJpdCk7CiAgICAgICAgIHdyaXRlMzIocmVzdWx0LCB1c2Vy RGVmaW5lZFN0cmluZ1N0YXJ0SW5kZXggKyAxKTsKICAgICAgICAgcmVzdWx0LmFwcGVuZCh3ZWln aHRLZXkpOwpAQCAtNTA5LDI1ICs0OTUsMjUgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OmFwcGVuZENGRlRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogICAgIEFTU0VSVChy ZXN1bHQuc2l6ZSgpID09IHRvcERpY3RTdGFydCArIHNpemVPZlRvcEluZGV4KTsKIAogICAgIC8v IFN0cmluZyBJTkRFWAotICAgIHdyaXRlMTYocmVzdWx0LCAxICsgKHdlaWdodC5pc0VtcHR5KCkg PyAwIDogMSkpOyAvLyBOdW1iZXIgb2YgZWxlbWVudHMgaW4gSU5ERVgKKyAgICB3cml0ZTE2KHJl c3VsdCwgMSArIChoYXNXZWlnaHQgPyAxIDogMCkpOyAvLyBOdW1iZXIgb2YgZWxlbWVudHMgaW4g SU5ERVgKICAgICByZXN1bHQuYXBwZW5kKDQpOyAvLyBPZmZzZXRzIGluIHRoaXMgSU5ERVggYXJl IDQgYnl0ZXMgbG9uZwogICAgIHVpbnQzMl90IG9mZnNldCA9IDE7CiAgICAgd3JpdGUzMihyZXN1 bHQsIG9mZnNldCk7CiAgICAgb2Zmc2V0ICs9IGZvbnROYW1lLmxlbmd0aCgpOwogICAgIHdyaXRl MzIocmVzdWx0LCBvZmZzZXQpOwotICAgIGlmICghd2VpZ2h0LmlzRW1wdHkoKSkgeworICAgIGlm IChoYXNXZWlnaHQpIHsKICAgICAgICAgb2Zmc2V0ICs9IHdlaWdodC5sZW5ndGgoKTsKICAgICAg ICAgd3JpdGUzMihyZXN1bHQsIG9mZnNldCk7CiAgICAgfQotICAgIGFwcGVuZENGRlZhbGlkU3Ry aW5nKHJlc3VsdCwgZm9udE5hbWUpOwotICAgIGFwcGVuZENGRlZhbGlkU3RyaW5nKHJlc3VsdCwg d2VpZ2h0KTsKKyAgICBhcHBlbmRWYWxpZENGRlN0cmluZyhyZXN1bHQsIGZvbnROYW1lKTsKKyAg ICBhcHBlbmRWYWxpZENGRlN0cmluZyhyZXN1bHQsIHdlaWdodCk7CiAKICAgICB3cml0ZTE2KHJl c3VsdCwgMCk7IC8vIEVtcHR5IHN1YnJvdXRpbmUgSU5ERVgKIAogICAgIC8vIENoYXJzZXQgaW5m bwogICAgIG92ZXJ3cml0ZTMyKHJlc3VsdCwgY2hhcnNldE9mZnNldExvY2F0aW9uLCByZXN1bHQu c2l6ZSgpIC0gc3RhcnRpbmdPZmZzZXQpOwogICAgIHJlc3VsdC5hcHBlbmQoMCk7Ci0gICAgZm9y ICh1bnNpZ25lZCBpID0gMTsgaSA8IG1fZ2x5cGhzLnNpemUoKTsgKytpKQorICAgIGZvciAoR2x5 cGggaSA9IDE7IGkgPCBtX2dseXBocy5zaXplKCk7ICsraSkKICAgICAgICAgd3JpdGUxNihyZXN1 bHQsIGkpOwogCiAgICAgLy8gQ2hhclN0cmluZ3MgSU5ERVgKQEAgLTU1NSwyNCArNTQxLDE4IEBA IHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWT1JHVGFibGUoVmVjdG9yPGNoYXI+ JiByZXN1bHQpIGNvbnN0CiAgICAgICAgIGRlZmF1bHRWZXJ0aWNhbE9yaWdpblkgPSBjbGFtcFRv PGludDE2X3Q+KG1fbWlzc2luZ0dseXBoRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1l czo6dmVydF9vcmlnaW5feUF0dHIpLnRvSW50KCkpOwogICAgIHdyaXRlMTYocmVzdWx0LCBkZWZh dWx0VmVydGljYWxPcmlnaW5ZKTsKIAotICAgIFZlY3RvcjxzdGQ6OnBhaXI8dWludDE2X3QsIGlu dDE2X3Q+PiBvcmlnaW5zOwotICAgIGZvciAodWludDE2X3QgaSA9IDA7IGkgPCBtX2dseXBocy5z aXplKCk7ICsraSkgewotICAgICAgICBpZiAobV9nbHlwaHNbaV0uZ2x5cGhFbGVtZW50KSB7Ci0g ICAgICAgICAgICBhdXRvJiBhdHRyaWJ1dGUgPSBtX2dseXBoc1tpXS5nbHlwaEVsZW1lbnQtPmZh c3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnZlcnRfb3JpZ2luX3lBdHRyKTsKLSAgICAgICAgICAg IGlmIChhdHRyaWJ1dGUgIT0gbnVsbEF0b20gJiYgYXR0cmlidXRlLmlzOEJpdCgpKSB7Ci0gICAg ICAgICAgICAgICAgYm9vbCBvazsKLSAgICAgICAgICAgICAgICBpbnQxNl90IHZlcnRpY2FsT3Jp Z2luWSA9IGF0dHJpYnV0ZS50b0ludCgmb2spOwotICAgICAgICAgICAgICAgIGlmIChvayAmJiB2 ZXJ0aWNhbE9yaWdpblkpCi0gICAgICAgICAgICAgICAgICAgIG9yaWdpbnMuYXBwZW5kKHN0ZDo6 bWFrZV9wYWlyKGksIHZlcnRpY2FsT3JpZ2luWSkpOworICAgIGF1dG8gdGFibGVTaXplT2Zmc2V0 ID0gcmVzdWx0LnNpemUoKTsKKyAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFBsYWNlIHRvIHdy aXRlIHRhYmxlIHNpemUuCisgICAgZm9yIChHbHlwaCBpID0gMDsgaSA8IG1fZ2x5cGhzLnNpemUo KTsgKytpKSB7CisgICAgICAgIGlmIChhdXRvKiBnbHlwaCA9IG1fZ2x5cGhzW2ldLmdseXBoRWxl bWVudCkgeworICAgICAgICAgICAgaWYgKGludDE2X3QgdmVydGljYWxPcmlnaW5ZID0gY2xhbXBU bzxpbnQxNl90PihnbHlwaC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6dmVydF9vcmlnaW5f eUF0dHIpLnRvSW50KCkpKSB7CisgICAgICAgICAgICAgICAgd3JpdGUxNihyZXN1bHQsIGkpOwor ICAgICAgICAgICAgICAgIHdyaXRlMTYocmVzdWx0LCB2ZXJ0aWNhbE9yaWdpblkpOwogICAgICAg ICAgICAgfQogICAgICAgICB9CiAgICAgfQotICAgIHdyaXRlMTYocmVzdWx0LCBvcmlnaW5zLnNp emUoKSk7Ci0KLSAgICBmb3IgKGF1dG8mIHAgOiBvcmlnaW5zKSB7Ci0gICAgICAgIHdyaXRlMTYo cmVzdWx0LCBwLmZpcnN0KTsKLSAgICAgICAgd3JpdGUxNihyZXN1bHQsIHAuc2Vjb25kKTsKLSAg ICB9CisgICAgQVNTRVJUKCEoKHJlc3VsdC5zaXplKCkgLSB0YWJsZVNpemVPZmZzZXQgLSAyKSAl IDQpKTsKKyAgICBvdmVyd3JpdGUxNihyZXN1bHQsIHRhYmxlU2l6ZU9mZnNldCwgKHJlc3VsdC5z aXplKCkgLSB0YWJsZVNpemVPZmZzZXQgLSAyKSAvIDQpOwogfQogCiB2b2lkIFNWR1RvT1RGRm9u dENvbnZlcnRlcjo6YXBwZW5kVkhFQVRhYmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdApA QCAtNTg1LDcgKzU2NSw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWSEVB VGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgd3JpdGUxNihyZXN1bHQsIGNs YW1wVG88aW50MTZfdD4obV91bml0c1BlckVtIC0gbV9ib3VuZGluZ0JveC5tYXhZKCkpKTsgLy8g TWluaW11bSB0b3Agc2lkZSBiZWFyaW5nCiAgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50 MTZfdD4obV9ib3VuZGluZ0JveC55KCkpKTsgLy8gTWluaW11bSBib3R0b20gc2lkZSBiZWFyaW5n CiAgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdD4obV91bml0c1BlckVtIC0gbV9i b3VuZGluZ0JveC55KCkpKTsgLy8gWSBtYXhpbXVtIGV4dGVudAotICAgIC8vIFdlYktpdCBkcmF3 cyB0aGUgY2FyZXQKKyAgICAvLyBTaW5jZSBXZWJLaXQgZHJhd3MgdGhlIGNhcmV0IGFuZCBpZ25v cmVzIHRoZSBmb2xsb3dpbmcgdmFsdWVzLCBpdCBkb2Vzbid0IG1hdHRlciB3aGF0IHdlIHNldCB0 aGVtIHRvLgogICAgIHdyaXRlMTYocmVzdWx0LCAxKTsgLy8gVmVydGljYWwgY2FyZXQKICAgICB3 cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnRpY2FsIGNhcmV0CiAgICAgd3JpdGUxNihyZXN1bHQs IDApOyAvLyAiU2V0IHZhbHVlIHRvIDAgZm9yIG5vbi1zbGFudGVkIGZvbnRzIgpAQCAtNjA3LDEx ICs1ODcsMTAgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFkZENvZGVwb2ludFJhbmdl cyhjb25zdCBVbmljb2RlUmFuZ2VzJiB1bmljb2RlUmFuZ2UKIHsKICAgICBmb3IgKGF1dG8mIHVu aWNvZGVSYW5nZSA6IHVuaWNvZGVSYW5nZXMpIHsKICAgICAgICAgZm9yIChhdXRvIGNvZGVwb2lu dCA9IHVuaWNvZGVSYW5nZS5maXJzdDsgY29kZXBvaW50IDw9IHVuaWNvZGVSYW5nZS5zZWNvbmQ7 ICsrY29kZXBvaW50KSB7Ci0gICAgICAgICAgICBpZiAoIWNvZGVwb2ludCB8fCBjb2RlcG9pbnQg Pj0gc3RkOjpudW1lcmljX2xpbWl0czxDb2RlcG9pbnQ+OjptYXgoKSkKKyAgICAgICAgICAgIGlm ICghbV9jb2RlcG9pbnRUb0luZGV4TWFwLmlzVmFsaWRLZXkoY29kZXBvaW50KSkKICAgICAgICAg ICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGF1dG8gaXRlcmF0b3IgPSBtX2NvZGVwb2lu dFRvSW5kZXhNYXAuZmluZChjb2RlcG9pbnQpOwotICAgICAgICAgICAgaWYgKGl0ZXJhdG9yICE9 IG1fY29kZXBvaW50VG9JbmRleE1hcC5lbmQoKSkKLSAgICAgICAgICAgICAgICBnbHlwaFNldC5h ZGQoaXRlcmF0b3ItPnZhbHVlKTsKKyAgICAgICAgICAgIGlmIChHbHlwaCBnbHlwaCA9IG1fY29k ZXBvaW50VG9JbmRleE1hcC5nZXQoY29kZXBvaW50KSkKKyAgICAgICAgICAgICAgICBnbHlwaFNl dC5hZGQoZ2x5cGgpOwogICAgICAgICB9CiAgICAgfQogfQpAQCAtNjI4LDEyICs2MDcsMTAgQEAg dm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFkZENvZGVwb2ludHMoY29uc3QgSGFzaFNldDxT dHJpbmc+JiBjb2RlcG9pbnRzLCBIYXMKICAgICAgICAgICAgICAgICBjb2RlcG9pbnQgPSBjb2Rl cG9pbnRTdHJpbmcuY2hhcmFjdGVyczgoKVtpKytdOwogICAgICAgICAgICAgZWxzZQogICAgICAg ICAgICAgICAgIFUxNl9ORVhUKGNvZGVwb2ludFN0cmluZy5jaGFyYWN0ZXJzMTYoKSwgaSwgY29k ZXBvaW50U3RyaW5nTGVuZ3RoLCBjb2RlcG9pbnQpOwotCi0gICAgICAgICAgICBpZiAoIWNvZGVw b2ludCB8fCBjb2RlcG9pbnQgPj0gc3RkOjpudW1lcmljX2xpbWl0czxDb2RlcG9pbnQ+OjptYXgo KSkKKyAgICAgICAgICAgIGlmICghbV9jb2RlcG9pbnRUb0luZGV4TWFwLmlzVmFsaWRLZXkoY29k ZXBvaW50KSkKICAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGF1dG8gaW5k ZXhJdGVyID0gbV9jb2RlcG9pbnRUb0luZGV4TWFwLmZpbmQoY29kZXBvaW50KTsKLSAgICAgICAg ICAgIGlmIChpbmRleEl0ZXIgIT0gbV9jb2RlcG9pbnRUb0luZGV4TWFwLmVuZCgpKQotICAgICAg ICAgICAgICAgIGdseXBoU2V0LmFkZChpbmRleEl0ZXItPnZhbHVlKTsKKyAgICAgICAgICAgIGlm IChHbHlwaCBnbHlwaCA9IG1fY29kZXBvaW50VG9JbmRleE1hcC5nZXQoY29kZXBvaW50KSkKKyAg ICAgICAgICAgICAgICBnbHlwaFNldC5hZGQoZ2x5cGgpOwogICAgICAgICB9CiAgICAgfQogfQpA QCAtNjQxLDQ2ICs2MTgsNDcgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFkZENvZGVw b2ludHMoY29uc3QgSGFzaFNldDxTdHJpbmc+JiBjb2RlcG9pbnRzLCBIYXMKIHZvaWQgU1ZHVG9P VEZGb250Q29udmVydGVyOjphZGRHbHlwaE5hbWVzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYgZ2x5 cGhOYW1lcywgSGFzaFNldDx1aW50MTZfdD4mIGdseXBoU2V0KSBjb25zdAogewogICAgIGZvciAo YXV0byYgZ2x5cGhOYW1lIDogZ2x5cGhOYW1lcykgewotICAgICAgICBhdXRvIGluZGV4SXRlciA9 IG1fZ2x5cGhOYW1lVG9JbmRleE1hcC5maW5kKGdseXBoTmFtZSk7Ci0gICAgICAgIGlmIChpbmRl eEl0ZXIgIT0gbV9nbHlwaE5hbWVUb0luZGV4TWFwLmVuZCgpKQotICAgICAgICAgICAgZ2x5cGhT ZXQuYWRkKGluZGV4SXRlci0+dmFsdWUpOworICAgICAgICBpZiAoR2x5cGggZ2x5cGggPSBtX2ds eXBoTmFtZVRvSW5kZXhNYXAuZ2V0KGdseXBoTmFtZSkpCisgICAgICAgICAgICBnbHlwaFNldC5h ZGQoZ2x5cGgpOwogICAgIH0KIH0KIAotdGVtcGxhdGUgPHR5cGVuYW1lIFQ+Ci1hdXRvIFNWR1Rv T1RGRm9udENvbnZlcnRlcjo6Y29tcHV0ZUtlcm5pbmdEYXRhKGJvb2wgKFQ6OipidWlsZEtlcm5p bmdQYWlyKShTVkdLZXJuaW5nUGFpciYpIGNvbnN0KSBjb25zdCAtPiBWZWN0b3I8S2VybmluZ0Rh dGE+Cit2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YWRkS2VybmluZ1BhaXIoVmVjdG9yPEtl cm5pbmdEYXRhPiYgZGF0YSwgY29uc3QgU1ZHS2VybmluZ1BhaXImIGtlcm5pbmdQYWlyKSBjb25z dAogewotICAgIFZlY3RvcjxLZXJuaW5nRGF0YT4gcmVzdWx0OworICAgIEhhc2hTZXQ8R2x5cGg+ IGdseXBoU2V0MTsKKyAgICBIYXNoU2V0PEdseXBoPiBnbHlwaFNldDI7CisKKyAgICBhZGRDb2Rl cG9pbnRSYW5nZXMoa2VybmluZ1BhaXIudW5pY29kZVJhbmdlMSwgZ2x5cGhTZXQxKTsKKyAgICBh ZGRDb2RlcG9pbnRSYW5nZXMoa2VybmluZ1BhaXIudW5pY29kZVJhbmdlMiwgZ2x5cGhTZXQyKTsK KyAgICBhZGRHbHlwaE5hbWVzKGtlcm5pbmdQYWlyLmdseXBoTmFtZTEsIGdseXBoU2V0MSk7Cisg ICAgYWRkR2x5cGhOYW1lcyhrZXJuaW5nUGFpci5nbHlwaE5hbWUyLCBnbHlwaFNldDIpOworICAg IGFkZENvZGVwb2ludHMoa2VybmluZ1BhaXIudW5pY29kZU5hbWUxLCBnbHlwaFNldDEpOworICAg IGFkZENvZGVwb2ludHMoa2VybmluZ1BhaXIudW5pY29kZU5hbWUyLCBnbHlwaFNldDIpOworCisg ICAgLy8gRklYTUU6IFVzZSB0YWJsZSBmb3JtYXQgMiBzbyB3ZSBkb24ndCBoYXZlIHRvIGFwcGVu ZCBlYWNoIG9mIHRoZXNlIG9uZSBieSBvbmUuCisgICAgZm9yIChhdXRvJiBnbHlwaDEgOiBnbHlw aFNldDEpIHsKKyAgICAgICAgZm9yIChhdXRvJiBnbHlwaDIgOiBnbHlwaFNldDIpCisgICAgICAg ICAgICBkYXRhLmFwcGVuZChLZXJuaW5nRGF0YShnbHlwaDEsIGdseXBoMiwgY2xhbXBUbzxpbnQx Nl90Pigta2VybmluZ1BhaXIua2VybmluZykpKTsKKyAgICB9Cit9CiAKLSAgICBmb3IgKGF1dG8m IGtlcm5FbGVtZW50IDogY2hpbGRyZW5PZlR5cGU8VD4obV9mb250RWxlbWVudCkpIHsKK3RlbXBs YXRlPHR5cGVuYW1lIFQ+IGlubGluZSBzaXplX3QgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBl bmRLRVJOU3VidGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQsIGJvb2wgKFQ6OipidWlsZEtlcm5p bmdQYWlyKShTVkdLZXJuaW5nUGFpciYpIGNvbnN0LCB1aW50MTZfdCBjb3ZlcmFnZSkgY29uc3QK K3sKKyAgICBWZWN0b3I8S2VybmluZ0RhdGE+IGtlcm5pbmdEYXRhOworICAgIGZvciAoYXV0byYg ZWxlbWVudCA6IGNoaWxkcmVuT2ZUeXBlPFQ+KG1fZm9udEVsZW1lbnQpKSB7CiAgICAgICAgIFNW R0tlcm5pbmdQYWlyIGtlcm5pbmdQYWlyOwotICAgICAgICBpZiAoKGtlcm5FbGVtZW50LipidWls ZEtlcm5pbmdQYWlyKShrZXJuaW5nUGFpcikpIHsKLSAgICAgICAgICAgIEhhc2hTZXQ8R2x5cGg+ IGdseXBoU2V0MTsKLSAgICAgICAgICAgIEhhc2hTZXQ8R2x5cGg+IGdseXBoU2V0MjsKLQotICAg ICAgICAgICAgYWRkQ29kZXBvaW50UmFuZ2VzKGtlcm5pbmdQYWlyLnVuaWNvZGVSYW5nZTEsIGds eXBoU2V0MSk7Ci0gICAgICAgICAgICBhZGRDb2RlcG9pbnRSYW5nZXMoa2VybmluZ1BhaXIudW5p Y29kZVJhbmdlMiwgZ2x5cGhTZXQyKTsKLSAgICAgICAgICAgIGFkZEdseXBoTmFtZXMoa2Vybmlu Z1BhaXIuZ2x5cGhOYW1lMSwgZ2x5cGhTZXQxKTsKLSAgICAgICAgICAgIGFkZEdseXBoTmFtZXMo a2VybmluZ1BhaXIuZ2x5cGhOYW1lMiwgZ2x5cGhTZXQyKTsKLSAgICAgICAgICAgIGFkZENvZGVw b2ludHMoa2VybmluZ1BhaXIudW5pY29kZU5hbWUxLCBnbHlwaFNldDEpOwotICAgICAgICAgICAg YWRkQ29kZXBvaW50cyhrZXJuaW5nUGFpci51bmljb2RlTmFtZTIsIGdseXBoU2V0Mik7Ci0KLSAg ICAgICAgICAgIC8vIEZJWE1FOiBVc2UgdGFibGUgZm9ybWF0IDIgc28gd2UgZG9uJ3QgaGF2ZSB0 byBhcHBlbmQgZWFjaCBvZiB0aGVzZSBvbmUgYnkgb25lCi0gICAgICAgICAgICBmb3IgKGF1dG8m IGdseXBoMSA6IGdseXBoU2V0MSkgewotICAgICAgICAgICAgICAgIGZvciAoYXV0byYgZ2x5cGgy IDogZ2x5cGhTZXQyKQotICAgICAgICAgICAgICAgICAgICByZXN1bHQuYXBwZW5kKEtlcm5pbmdE YXRhKGdseXBoMSwgZ2x5cGgyLCBjbGFtcFRvPGludDE2X3Q+KC1rZXJuaW5nUGFpci5rZXJuaW5n KSkpOwotICAgICAgICAgICAgfQotICAgICAgICB9CisgICAgICAgIGlmICgoZWxlbWVudC4qYnVp bGRLZXJuaW5nUGFpcikoa2VybmluZ1BhaXIpKQorICAgICAgICAgICAgYWRkS2VybmluZ1BhaXIo a2VybmluZ0RhdGEsIGtlcm5pbmdQYWlyKTsKICAgICB9Ci0KLSAgICByZXR1cm4gcmVzdWx0Owor ICAgIHJldHVybiBmaW5pc2hBcHBlbmRpbmdLRVJOU3VidGFibGUocmVzdWx0LCBXVEY6Om1vdmUo a2VybmluZ0RhdGEpLCBjb3ZlcmFnZSk7CiB9CiAKLXRlbXBsYXRlIDx0eXBlbmFtZSBUPgotc2l6 ZV90IFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kS0VSTlN1YnRhYmxlKFZlY3RvcjxjaGFy PiYgcmVzdWx0LCBib29sIChUOjoqYnVpbGRLZXJuaW5nUGFpcikoU1ZHS2VybmluZ1BhaXImKSBj b25zdCwgdWludDE2X3QgY292ZXJhZ2UpIGNvbnN0CitzaXplX3QgU1ZHVG9PVEZGb250Q29udmVy dGVyOjpmaW5pc2hBcHBlbmRpbmdLRVJOU3VidGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQsIFZl Y3RvcjxLZXJuaW5nRGF0YT4ga2VybmluZ0RhdGEsIHVpbnQxNl90IGNvdmVyYWdlKSBjb25zdAog ewotICAgIFZlY3RvcjxLZXJuaW5nRGF0YT4ga2VybmluZ0RhdGEgPSBjb21wdXRlS2VybmluZ0Rh dGE8VD4oYnVpbGRLZXJuaW5nUGFpcik7Ci0gICAgc3RkOjpzb3J0KGtlcm5pbmdEYXRhLmJlZ2lu KCksIGtlcm5pbmdEYXRhLmVuZCgpKTsKKyAgICBzdGQ6OnNvcnQoa2VybmluZ0RhdGEuYmVnaW4o KSwga2VybmluZ0RhdGEuZW5kKCksIFtdKGNvbnN0IEtlcm5pbmdEYXRhJiBhLCBjb25zdCBLZXJu aW5nRGF0YSYgYikgeworICAgICAgICByZXR1cm4gYS5nbHlwaDEgPCBiLmdseXBoMSB8fCAoYS5n bHlwaDEgPT0gYi5nbHlwaDEgJiYgYS5nbHlwaDIgPCBiLmdseXBoMik7CisgICAgfSk7CisKICAg ICBzaXplX3Qgc2l6ZU9mS2VybmluZ0RhdGFUYWJsZSA9IDE0ICsgNiAqIGtlcm5pbmdEYXRhLnNp emUoKTsKICAgICBpZiAoc2l6ZU9mS2VybmluZ0RhdGFUYWJsZSA+IHN0ZDo6bnVtZXJpY19saW1p dHM8dWludDE2X3Q+OjptYXgoKSkgewogICAgICAgICBrZXJuaW5nRGF0YS5jbGVhcigpOwpAQCAt NzI5LDkgKzcwNyw4IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRLRVJOVGFi bGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAKIHN0YXRpYyB2b2lkIHdyaXRlQ0ZGRW5j b2RlZE51bWJlcihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgZmxvYXQgbnVtYmVyKQogewotICAgIGlu dCByYXcgPSBudW1iZXIgKiBwb3dmKDIsIDE2KTsKLSAgICB2ZWN0b3IuYXBwZW5kKC0xKTsgLy8g MHhGRgotICAgIHdyaXRlMzIodmVjdG9yLCByYXcpOworICAgIHZlY3Rvci5hcHBlbmQoMHhGRik7 CisgICAgd3JpdGUzMih2ZWN0b3IsIG51bWJlciAqIDB4MTAwMDApOwogfQogCiBzdGF0aWMgY29u c3QgY2hhciByTGluZVRvID0gMHgwNTsKQEAgLTc0Myw3ICs3MjAsNyBAQCBjbGFzcyBDRkZCdWls ZGVyIDogcHVibGljIFNWR1BhdGhCdWlsZGVyIHsKIHB1YmxpYzoKICAgICBDRkZCdWlsZGVyKFZl Y3RvcjxjaGFyPiYgY2ZmRGF0YSwgZmxvYXQgd2lkdGgsIEZsb2F0UG9pbnQgb3JpZ2luKQogICAg ICAgICA6IG1fY2ZmRGF0YShjZmZEYXRhKQotICAgICAgICAsIG1fZmlyc3RQb2ludCh0cnVlKQor ICAgICAgICAsIG1faGFzQm91bmRpbmdCb3goZmFsc2UpCiAgICAgewogICAgICAgICB3cml0ZUNG RkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCB3aWR0aCk7CiAgICAgICAgIHdyaXRlQ0ZGRW5jb2Rl ZE51bWJlcihtX2NmZkRhdGEsIG9yaWdpbi54KCkpOwpAQCAtNzUxLDQ4ICs3MjgsNTYgQEAgcHVi bGljOgogICAgICAgICBtX2NmZkRhdGEuYXBwZW5kKHJNb3ZlVG8pOwogICAgIH0KIAotICAgIHZv aWQgdXBkYXRlRm9yQ29uc3RpdHVlbnRQb2ludChGbG9hdFBvaW50IHgpCisgICAgRmxvYXRSZWN0 IGJvdW5kaW5nQm94KCkgY29uc3QKICAgICB7Ci0gICAgICAgIGlmIChtX2ZpcnN0UG9pbnQpCi0g ICAgICAgICAgICBtX2JvdW5kaW5nQm94ID0gRmxvYXRSZWN0KHgsIEZsb2F0U2l6ZSgpKTsKLSAg ICAgICAgZWxzZQotICAgICAgICAgICAgbV9ib3VuZGluZ0JveC5leHRlbmQoeCk7Ci0gICAgICAg IG1fZmlyc3RQb2ludCA9IGZhbHNlOworICAgICAgICByZXR1cm4gbV9ib3VuZGluZ0JveDsKICAg ICB9CiAKLSAgICB2b2lkIG1vdmVUbyhjb25zdCBGbG9hdFBvaW50JiB0YXJnZXRQb2ludCwgYm9v bCBjbG9zZWQsIFBhdGhDb29yZGluYXRlTW9kZSBtb2RlKSBvdmVycmlkZQorcHJpdmF0ZToKKyAg ICB2b2lkIHVwZGF0ZUJvdW5kaW5nQm94KEZsb2F0UG9pbnQgcG9pbnQpCiAgICAgewotICAgICAg ICBGbG9hdFBvaW50IGRlc3RpbmF0aW9uID0gbW9kZSA9PSBBYnNvbHV0ZUNvb3JkaW5hdGVzID8g dGFyZ2V0UG9pbnQgOiBtX2N1cnJlbnQgKyB0YXJnZXRQb2ludDsKLSAgICAgICAgdXBkYXRlRm9y Q29uc3RpdHVlbnRQb2ludChkZXN0aW5hdGlvbik7CisgICAgICAgIGlmICghbV9oYXNCb3VuZGlu Z0JveCkgeworICAgICAgICAgICAgbV9ib3VuZGluZ0JveCA9IEZsb2F0UmVjdChwb2ludCwgRmxv YXRTaXplKCkpOworICAgICAgICAgICAgbV9oYXNCb3VuZGluZ0JveCA9IHRydWU7CisgICAgICAg ICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgbV9ib3VuZGluZ0JveC5leHRlbmQocG9p bnQpOworICAgIH0KKworICAgIHZvaWQgd3JpdGVQb2ludChGbG9hdFBvaW50IGRlc3RpbmF0aW9u KQorICAgIHsKKyAgICAgICAgdXBkYXRlQm91bmRpbmdCb3goZGVzdGluYXRpb24pOworCiAgICAg ICAgIEZsb2F0U2l6ZSBkZWx0YSA9IGRlc3RpbmF0aW9uIC0gbV9jdXJyZW50OworICAgICAgICB3 cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBkZWx0YS53aWR0aCgpKTsKKyAgICAgICAg d3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgZGVsdGEuaGVpZ2h0KCkpOwogCisgICAg ICAgIG1fY3VycmVudCA9IGRlc3RpbmF0aW9uOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBt b3ZlVG8oY29uc3QgRmxvYXRQb2ludCYgdGFyZ2V0UG9pbnQsIGJvb2wgY2xvc2VkLCBQYXRoQ29v cmRpbmF0ZU1vZGUgbW9kZSkgb3ZlcnJpZGUKKyAgICB7CiAgICAgICAgIGlmIChjbG9zZWQgJiYg bV9jZmZEYXRhLnNpemUoKSkKICAgICAgICAgICAgIGNsb3NlUGF0aCgpOwogCi0gICAgICAgIHdy aXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIGRlbHRhLndpZHRoKCkpOwotICAgICAgICB3 cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBkZWx0YS5oZWlnaHQoKSk7CisgICAgICAg IEZsb2F0UG9pbnQgZGVzdGluYXRpb24gPSBtb2RlID09IEFic29sdXRlQ29vcmRpbmF0ZXMgPyB0 YXJnZXRQb2ludCA6IG1fY3VycmVudCArIHRhcmdldFBvaW50OworCisgICAgICAgIHdyaXRlUG9p bnQoZGVzdGluYXRpb24pOwogICAgICAgICBtX2NmZkRhdGEuYXBwZW5kKHJNb3ZlVG8pOwogCi0g ICAgICAgIG1fY3VycmVudCA9IGRlc3RpbmF0aW9uOwogICAgICAgICBtX3N0YXJ0aW5nUG9pbnQg PSBtX2N1cnJlbnQ7CiAgICAgfQogCi0gICAgdm9pZCBsaW5lVG8oY29uc3QgRmxvYXRQb2ludCYg dGFyZ2V0UG9pbnQsIFBhdGhDb29yZGluYXRlTW9kZSBtb2RlKSBvdmVycmlkZQorICAgIHZpcnR1 YWwgdm9pZCBsaW5lVG8oY29uc3QgRmxvYXRQb2ludCYgdGFyZ2V0UG9pbnQsIFBhdGhDb29yZGlu YXRlTW9kZSBtb2RlKSBvdmVycmlkZQogICAgIHsKICAgICAgICAgRmxvYXRQb2ludCBkZXN0aW5h dGlvbiA9IG1vZGUgPT0gQWJzb2x1dGVDb29yZGluYXRlcyA/IHRhcmdldFBvaW50IDogbV9jdXJy ZW50ICsgdGFyZ2V0UG9pbnQ7Ci0gICAgICAgIHVwZGF0ZUZvckNvbnN0aXR1ZW50UG9pbnQoZGVz dGluYXRpb24pOwotICAgICAgICBGbG9hdFNpemUgZGVsdGEgPSBkZXN0aW5hdGlvbiAtIG1fY3Vy cmVudDsKIAotICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBkZWx0YS53 aWR0aCgpKTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgZGVsdGEu aGVpZ2h0KCkpOworICAgICAgICB3cml0ZVBvaW50KGRlc3RpbmF0aW9uKTsKICAgICAgICAgbV9j ZmZEYXRhLmFwcGVuZChyTGluZVRvKTsKLQotICAgICAgICBtX2N1cnJlbnQgPSBkZXN0aW5hdGlv bjsKICAgICB9CiAKLSAgICB2b2lkIGN1cnZlVG9DdWJpYyhjb25zdCBGbG9hdFBvaW50JiBwb2lu dDEsIGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50MiwgY29uc3QgRmxvYXRQb2ludCYgdGFyZ2V0UG9p bnQsIFBhdGhDb29yZGluYXRlTW9kZSBtb2RlKSBvdmVycmlkZQorICAgIHZpcnR1YWwgdm9pZCBj dXJ2ZVRvQ3ViaWMoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQxLCBjb25zdCBGbG9hdFBvaW50JiBw b2ludDIsIGNvbnN0IEZsb2F0UG9pbnQmIHRhcmdldFBvaW50LCBQYXRoQ29vcmRpbmF0ZU1vZGUg bW9kZSkgb3ZlcnJpZGUKICAgICB7Ci0gICAgICAgIC8vIEZJWE1FOiBUaGlzIGNhbiBiZSBtYWRl IHdheSBmYXN0ZXIKICAgICAgICAgRmxvYXRQb2ludCBkZXN0aW5hdGlvbjEgPSBwb2ludDE7CiAg ICAgICAgIEZsb2F0UG9pbnQgZGVzdGluYXRpb24yID0gcG9pbnQyOwogICAgICAgICBGbG9hdFBv aW50IGRlc3RpbmF0aW9uMyA9IHRhcmdldFBvaW50OwpAQCAtODAxLDQ4ICs3ODYsMzEgQEAgcHVi bGljOgogICAgICAgICAgICAgZGVzdGluYXRpb24yICs9IG1fY3VycmVudDsKICAgICAgICAgICAg IGRlc3RpbmF0aW9uMyArPSBtX2N1cnJlbnQ7CiAgICAgICAgIH0KLSAgICAgICAgdXBkYXRlRm9y Q29uc3RpdHVlbnRQb2ludChkZXN0aW5hdGlvbjEpOwotICAgICAgICB1cGRhdGVGb3JDb25zdGl0 dWVudFBvaW50KGRlc3RpbmF0aW9uMik7Ci0gICAgICAgIHVwZGF0ZUZvckNvbnN0aXR1ZW50UG9p bnQoZGVzdGluYXRpb24zKTsKLSAgICAgICAgRmxvYXRTaXplIGRlbHRhMyA9IGRlc3RpbmF0aW9u MyAtIGRlc3RpbmF0aW9uMjsKLSAgICAgICAgRmxvYXRTaXplIGRlbHRhMiA9IGRlc3RpbmF0aW9u MiAtIGRlc3RpbmF0aW9uMTsKLSAgICAgICAgRmxvYXRTaXplIGRlbHRhMSA9IGRlc3RpbmF0aW9u MSAtIG1fY3VycmVudDsKLQotICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRh LCBkZWx0YTEud2lkdGgoKSk7Ci0gICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRh dGEsIGRlbHRhMS5oZWlnaHQoKSk7Ci0gICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2Nm ZkRhdGEsIGRlbHRhMi53aWR0aCgpKTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1f Y2ZmRGF0YSwgZGVsdGEyLmhlaWdodCgpKTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVy KG1fY2ZmRGF0YSwgZGVsdGEzLndpZHRoKCkpOwotICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1i ZXIobV9jZmZEYXRhLCBkZWx0YTMuaGVpZ2h0KCkpOwotICAgICAgICBtX2NmZkRhdGEuYXBwZW5k KHJyQ3VydmVUbyk7CiAKLSAgICAgICAgbV9jdXJyZW50ID0gZGVzdGluYXRpb24zOworICAgICAg ICB3cml0ZVBvaW50KGRlc3RpbmF0aW9uMSk7CisgICAgICAgIHdyaXRlUG9pbnQoZGVzdGluYXRp b24yKTsKKyAgICAgICAgd3JpdGVQb2ludChkZXN0aW5hdGlvbjMpOworICAgICAgICBtX2NmZkRh dGEuYXBwZW5kKHJyQ3VydmVUbyk7CiAgICAgfQogCi0gICAgdm9pZCBjbG9zZVBhdGgoKSBvdmVy cmlkZQorICAgIHZpcnR1YWwgdm9pZCBjbG9zZVBhdGgoKSBvdmVycmlkZQogICAgIHsKICAgICAg ICAgaWYgKG1fY3VycmVudCAhPSBtX3N0YXJ0aW5nUG9pbnQpCiAgICAgICAgICAgICBsaW5lVG8o bV9zdGFydGluZ1BvaW50LCBBYnNvbHV0ZUNvb3JkaW5hdGVzKTsKICAgICB9CiAKLSAgICBGbG9h dFJlY3QgYm91bmRpbmdCb3goKQotICAgIHsKLSAgICAgICAgcmV0dXJuIG1fYm91bmRpbmdCb3g7 Ci0gICAgfQotCi1wcml2YXRlOgogICAgIFZlY3RvcjxjaGFyPiYgbV9jZmZEYXRhOwogICAgIEZs b2F0UG9pbnQgbV9zdGFydGluZ1BvaW50OwogICAgIEZsb2F0UmVjdCBtX2JvdW5kaW5nQm94Owot ICAgIGJvb2wgbV9maXJzdFBvaW50OworICAgIGJvb2wgbV9oYXNCb3VuZGluZ0JveDsKIH07CiAK LXRlbXBsYXRlIDx0eXBlbmFtZSBUPgotVmVjdG9yPGNoYXI+IFNWR1RvT1RGRm9udENvbnZlcnRl cjo6dHJhbnNjb2RlR2x5cGhQYXRocyhmbG9hdCB3aWR0aCwgY29uc3QgVCYgZ2x5cGhFbGVtZW50 LCBGbG9hdFJlY3QmIGJvdW5kaW5nQm94KSBjb25zdAorVmVjdG9yPGNoYXI+IFNWR1RvT1RGRm9u dENvbnZlcnRlcjo6dHJhbnNjb2RlR2x5cGhQYXRocyhmbG9hdCB3aWR0aCwgY29uc3QgU1ZHRWxl bWVudCYgZ2x5cGhPck1pc3NpbmdHbHlwaEVsZW1lbnQsIEZsb2F0UmVjdCYgYm91bmRpbmdCb3gp IGNvbnN0CiB7CiAgICAgVmVjdG9yPGNoYXI+IHJlc3VsdDsKLSAgICBhdXRvJiBkQXR0cmlidXRl ID0gZ2x5cGhFbGVtZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OmRBdHRyKTsKLSAgICBp ZiAoZEF0dHJpYnV0ZS5pc0VtcHR5KCkpIHsKKworICAgIGF1dG8mIGRBdHRyaWJ1dGUgPSBnbHlw aE9yTWlzc2luZ0dseXBoRWxlbWVudC5mYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjpkQXR0cik7 CisgICAgaWYgKGRBdHRyaWJ1dGUuaXNOdWxsKCkpIHsKICAgICAgICAgd3JpdGVDRkZFbmNvZGVk TnVtYmVyKHJlc3VsdCwgd2lkdGgpOwogICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIocmVz dWx0LCAwKTsKICAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKHJlc3VsdCwgMCk7CkBAIC04 NTMsMTUgKzgyMSwxNiBAQCBWZWN0b3I8Y2hhcj4gU1ZHVG9PVEZGb250Q29udmVydGVyOjp0cmFu c2NvZGVHbHlwaFBhdGhzKGZsb2F0IHdpZHRoLCBjb25zdCBUJiBnbAogCiAgICAgLy8gRklYTUU6 IElmIHdlIGFyZSB2ZXJ0aWNhbCwgdXNlIHZlcnRfb3JpZ2luX3ggYW5kIHZlcnRfb3JpZ2luX3kK ICAgICBib29sIG9rOwotICAgIGZsb2F0IGhvcml6b250YWxPcmlnaW5YID0gZ2x5cGhFbGVtZW50 LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6Omhvcml6X29yaWdpbl94QXR0cikudG9GbG9hdCgm b2spOwotICAgIGlmICghb2sgJiYgbV9mb250RmFjZUVsZW1lbnQpCi0gICAgICAgIGhvcml6b250 YWxPcmlnaW5YID0gbV9mb250RmFjZUVsZW1lbnQtPmhvcml6b250YWxPcmlnaW5YKCk7Ci0gICAg ZmxvYXQgaG9yaXpvbnRhbE9yaWdpblkgPSBnbHlwaEVsZW1lbnQuZmFzdEdldEF0dHJpYnV0ZShT VkdOYW1lczo6aG9yaXpfb3JpZ2luX3lBdHRyKS50b0Zsb2F0KCZvayk7CisgICAgZmxvYXQgaG9y aXpvbnRhbE9yaWdpblggPSBnbHlwaE9yTWlzc2luZ0dseXBoRWxlbWVudC5mYXN0R2V0QXR0cmli dXRlKFNWR05hbWVzOjpob3Jpel9vcmlnaW5feEF0dHIpLnRvRmxvYXQoJm9rKTsKKyAgICBpZiAo IW9rKQorICAgICAgICBob3Jpem9udGFsT3JpZ2luWCA9IG1fZm9udEZhY2VFbGVtZW50ID8gbV9m b250RmFjZUVsZW1lbnQtPmhvcml6b250YWxPcmlnaW5YKCkgOiAwOworICAgIGZsb2F0IGhvcml6 b250YWxPcmlnaW5ZID0gZ2x5cGhPck1pc3NpbmdHbHlwaEVsZW1lbnQuZmFzdEdldEF0dHJpYnV0 ZShTVkdOYW1lczo6aG9yaXpfb3JpZ2luX3lBdHRyKS50b0Zsb2F0KCZvayk7CiAgICAgaWYgKCFv ayAmJiBtX2ZvbnRGYWNlRWxlbWVudCkKLSAgICAgICAgaG9yaXpvbnRhbE9yaWdpblkgPSBtX2Zv bnRGYWNlRWxlbWVudC0+aG9yaXpvbnRhbE9yaWdpblkoKTsKKyAgICAgICAgaG9yaXpvbnRhbE9y aWdpblkgPSBtX2ZvbnRGYWNlRWxlbWVudCA/IG1fZm9udEZhY2VFbGVtZW50LT5ob3Jpem9udGFs T3JpZ2luWSgpIDogMDsKIAogICAgIENGRkJ1aWxkZXIgYnVpbGRlcihyZXN1bHQsIHdpZHRoLCBG bG9hdFBvaW50KGhvcml6b250YWxPcmlnaW5YLCBob3Jpem9udGFsT3JpZ2luWSkpOwogICAgIFNW R1BhdGhTdHJpbmdTb3VyY2Ugc291cmNlKGRBdHRyaWJ1dGUpOworCiAgICAgU1ZHUGF0aFBhcnNl ciBwYXJzZXI7CiAgICAgcGFyc2VyLnNldEN1cnJlbnRTb3VyY2UoJnNvdXJjZSk7CiAgICAgcGFy c2VyLnNldEN1cnJlbnRDb25zdW1lcigmYnVpbGRlcik7CkBAIC04NzgsMzMgKzg0NywyMCBAQCBW ZWN0b3I8Y2hhcj4gU1ZHVG9PVEZGb250Q29udmVydGVyOjp0cmFuc2NvZGVHbHlwaFBhdGhzKGZs b2F0IHdpZHRoLCBjb25zdCBUJiBnbAogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKLXRlbXBsYXRl IDx0eXBlbmFtZSBUPgotdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEdseXBoRGF0 YShjb25zdCBWZWN0b3I8Y2hhcj4mIHBhdGgsIGNvbnN0IFQqLCBmbG9hdCBob3Jpem9udGFsQWR2 YW5jZSwgZmxvYXQgdmVydGljYWxBZHZhbmNlLCBjb25zdCBGbG9hdFJlY3QmIGJvdW5kaW5nQm94 LCBDb2RlcG9pbnQgY29kZXBvaW50KQotewotICAgIG1fZ2x5cGhzLmFwcGVuZChHbHlwaERhdGEo cGF0aCwgbnVsbHB0ciwgaG9yaXpvbnRhbEFkdmFuY2UsIHZlcnRpY2FsQWR2YW5jZSwgYm91bmRp bmdCb3gsIGNvZGVwb2ludCkpOwotfQotCi10ZW1wbGF0ZSA8Pgotdm9pZCBTVkdUb09URkZvbnRD b252ZXJ0ZXI6OmFwcGVuZEdseXBoRGF0YShjb25zdCBWZWN0b3I8Y2hhcj4mIHBhdGgsIGNvbnN0 IFNWR0dseXBoRWxlbWVudCogZWxlbWVudCwgZmxvYXQgaG9yaXpvbnRhbEFkdmFuY2UsIGZsb2F0 IHZlcnRpY2FsQWR2YW5jZSwgY29uc3QgRmxvYXRSZWN0JiBib3VuZGluZ0JveCwgQ29kZXBvaW50 IGNvZGVwb2ludCkKLXsKLSAgICBtX2dseXBocy5hcHBlbmQoR2x5cGhEYXRhKHBhdGgsIGVsZW1l bnQsIGhvcml6b250YWxBZHZhbmNlLCB2ZXJ0aWNhbEFkdmFuY2UsIGJvdW5kaW5nQm94LCBjb2Rl cG9pbnQpKTsKLX0KLQotdGVtcGxhdGUgPHR5cGVuYW1lIFQ+Ci12b2lkIFNWR1RvT1RGRm9udENv bnZlcnRlcjo6cHJvY2Vzc0dseXBoRWxlbWVudChjb25zdCBUJiBlbGVtZW50LCBmbG9hdCBkZWZh dWx0SG9yaXpvbnRhbEFkdmFuY2UsIGZsb2F0IGRlZmF1bHRWZXJ0aWNhbEFkdmFuY2UsIENvZGVw b2ludCBjb2RlcG9pbnQsIGJvb2wmIGluaXRpYWxHbHlwaCkKK3ZvaWQgU1ZHVG9PVEZGb250Q29u dmVydGVyOjpwcm9jZXNzR2x5cGhFbGVtZW50KGNvbnN0IFNWR0VsZW1lbnQmIGdseXBoT3JNaXNz aW5nR2x5cGhFbGVtZW50LCBjb25zdCBTVkdHbHlwaEVsZW1lbnQqIGdseXBoRWxlbWVudCwgZmxv YXQgZGVmYXVsdEhvcml6b250YWxBZHZhbmNlLCBmbG9hdCBkZWZhdWx0VmVydGljYWxBZHZhbmNl LCBDb2RlcG9pbnQgY29kZXBvaW50LCBib29sJiBpbml0aWFsR2x5cGgpCiB7CiAgICAgYm9vbCBv azsKLSAgICBmbG9hdCBob3Jpem9udGFsQWR2YW5jZSA9IGVsZW1lbnQuZmFzdEdldEF0dHJpYnV0 ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKS50b0Zsb2F0KCZvayk7CisgICAgZmxvYXQgaG9y aXpvbnRhbEFkdmFuY2UgPSBnbHlwaE9yTWlzc2luZ0dseXBoRWxlbWVudC5mYXN0R2V0QXR0cmli dXRlKFNWR05hbWVzOjpob3Jpel9hZHZfeEF0dHIpLnRvRmxvYXQoJm9rKTsKICAgICBpZiAoIW9r KQogICAgICAgICBob3Jpem9udGFsQWR2YW5jZSA9IGRlZmF1bHRIb3Jpem9udGFsQWR2YW5jZTsK ICAgICBtX2FkdmFuY2VXaWR0aE1heCA9IHN0ZDo6bWF4KG1fYWR2YW5jZVdpZHRoTWF4LCBob3Jp em9udGFsQWR2YW5jZSk7Ci0gICAgZmxvYXQgdmVydGljYWxBZHZhbmNlID0gZWxlbWVudC5mYXN0 R2V0QXR0cmlidXRlKFNWR05hbWVzOjp2ZXJ0X2Fkdl95QXR0cikudG9GbG9hdCgmb2spOworICAg IGZsb2F0IHZlcnRpY2FsQWR2YW5jZSA9IGdseXBoT3JNaXNzaW5nR2x5cGhFbGVtZW50LmZhc3RH ZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnZlcnRfYWR2X3lBdHRyKS50b0Zsb2F0KCZvayk7CiAgICAg aWYgKCFvaykKICAgICAgICAgdmVydGljYWxBZHZhbmNlID0gZGVmYXVsdFZlcnRpY2FsQWR2YW5j ZTsKICAgICBtX2FkdmFuY2VIZWlnaHRNYXggPSBzdGQ6Om1heChtX2FkdmFuY2VIZWlnaHRNYXgs IHZlcnRpY2FsQWR2YW5jZSk7CiAKICAgICBGbG9hdFJlY3QgZ2x5cGhCb3VuZGluZ0JveDsKLSAg ICBhdXRvIHBhdGggPSB0cmFuc2NvZGVHbHlwaFBhdGhzKGhvcml6b250YWxBZHZhbmNlLCBlbGVt ZW50LCBnbHlwaEJvdW5kaW5nQm94KTsKKyAgICBhdXRvIHBhdGggPSB0cmFuc2NvZGVHbHlwaFBh dGhzKGhvcml6b250YWxBZHZhbmNlLCBnbHlwaE9yTWlzc2luZ0dseXBoRWxlbWVudCwgZ2x5cGhC b3VuZGluZ0JveCk7CiAgICAgaWYgKGluaXRpYWxHbHlwaCkKICAgICAgICAgbV9ib3VuZGluZ0Jv eCA9IGdseXBoQm91bmRpbmdCb3g7CiAgICAgZWxzZQpAQCAtOTEyLDcgKzg2OCw3IEBAIHZvaWQg U1ZHVG9PVEZGb250Q29udmVydGVyOjpwcm9jZXNzR2x5cGhFbGVtZW50KGNvbnN0IFQmIGVsZW1l bnQsIGZsb2F0IGRlZmF1bHRICiAgICAgbV9taW5SaWdodFNpZGVCZWFyaW5nID0gc3RkOjptaW4o bV9taW5SaWdodFNpZGVCZWFyaW5nLCBob3Jpem9udGFsQWR2YW5jZSAtIGdseXBoQm91bmRpbmdC b3gubWF4WCgpKTsKICAgICBpbml0aWFsR2x5cGggPSBmYWxzZTsKIAotICAgIGFwcGVuZEdseXBo RGF0YShwYXRoLCAmZWxlbWVudCwgaG9yaXpvbnRhbEFkdmFuY2UsIHZlcnRpY2FsQWR2YW5jZSwg Z2x5cGhCb3VuZGluZ0JveCwgY29kZXBvaW50KTsKKyAgICBtX2dseXBocy5hcHBlbmQoR2x5cGhE YXRhKFdURjo6bW92ZShwYXRoKSwgZ2x5cGhFbGVtZW50LCBob3Jpem9udGFsQWR2YW5jZSwgdmVy dGljYWxBZHZhbmNlLCBtX2JvdW5kaW5nQm94LCBjb2RlcG9pbnQpKTsKIH0KIAogU1ZHVG9PVEZG b250Q29udmVydGVyOjpTVkdUb09URkZvbnRDb252ZXJ0ZXIoY29uc3QgU1ZHRm9udEVsZW1lbnQm IGZvbnRFbGVtZW50KQpAQCAtOTM1LDcgKzg5MSw3IEBAIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6 U1ZHVG9PVEZGb250Q29udmVydGVyKGNvbnN0IFNWR0ZvbnRFbGVtZW50JiBmb250RWxlbWVudCkK ICAgICAgICAgbV91bml0c1BlckVtID0gbV9mb250RmFjZUVsZW1lbnQtPnVuaXRzUGVyRW0oKTsK IAogICAgIGlmIChtX21pc3NpbmdHbHlwaEVsZW1lbnQpCi0gICAgICAgIHByb2Nlc3NHbHlwaEVs ZW1lbnQoKm1fbWlzc2luZ0dseXBoRWxlbWVudCwgZGVmYXVsdEhvcml6b250YWxBZHZhbmNlLCBk ZWZhdWx0VmVydGljYWxBZHZhbmNlLCAwLCBpbml0aWFsR2x5cGgpOworICAgICAgICBwcm9jZXNz R2x5cGhFbGVtZW50KCptX21pc3NpbmdHbHlwaEVsZW1lbnQsIG51bGxwdHIsIGRlZmF1bHRIb3Jp em9udGFsQWR2YW5jZSwgZGVmYXVsdFZlcnRpY2FsQWR2YW5jZSwgMCwgaW5pdGlhbEdseXBoKTsK ICAgICBlbHNlIHsKICAgICAgICAgVmVjdG9yPGNoYXI+IG5vdGRlZkNoYXJTdHJpbmc7CiAgICAg ICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihub3RkZWZDaGFyU3RyaW5nLCBtX3VuaXRzUGVyRW0p OwpAQCAtOTQzLDE4ICs4OTksMTggQEAgU1ZHVG9PVEZGb250Q29udmVydGVyOjpTVkdUb09URkZv bnRDb252ZXJ0ZXIoY29uc3QgU1ZHRm9udEVsZW1lbnQmIGZvbnRFbGVtZW50KQogICAgICAgICB3 cml0ZUNGRkVuY29kZWROdW1iZXIobm90ZGVmQ2hhclN0cmluZywgMCk7CiAgICAgICAgIG5vdGRl ZkNoYXJTdHJpbmcuYXBwZW5kKHJNb3ZlVG8pOwogICAgICAgICBub3RkZWZDaGFyU3RyaW5nLmFw cGVuZChlbmRDaGFyKTsKLSAgICAgICAgbV9nbHlwaHMuYXBwZW5kKEdseXBoRGF0YShub3RkZWZD aGFyU3RyaW5nLCBudWxscHRyLCBtX3VuaXRzUGVyRW0sIG1fdW5pdHNQZXJFbSwgRmxvYXRSZWN0 KCksIDApKTsKKyAgICAgICAgbV9nbHlwaHMuYXBwZW5kKEdseXBoRGF0YShXVEY6Om1vdmUobm90 ZGVmQ2hhclN0cmluZyksIG51bGxwdHIsIG1fdW5pdHNQZXJFbSwgbV91bml0c1BlckVtLCBGbG9h dFJlY3QoKSwgMCkpOwogICAgIH0KIAogICAgIGZvciAoYXV0byYgZ2x5cGhFbGVtZW50IDogY2hp bGRyZW5PZlR5cGU8U1ZHR2x5cGhFbGVtZW50PihtX2ZvbnRFbGVtZW50KSkgewogICAgICAgICBh dXRvJiB1bmljb2RlQXR0cmlidXRlID0gZ2x5cGhFbGVtZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZH TmFtZXM6OnVuaWNvZGVBdHRyKTsKICAgICAgICAgLy8gT25seSBzdXBwb3J0IEJhc2ljIE11bHRp bGluZ3VhbCBQbGFuZSB3L28gbGlnYXR1cmVzIGZvciBub3cKICAgICAgICAgaWYgKHVuaWNvZGVB dHRyaWJ1dGUubGVuZ3RoKCkgPT0gMSkKLSAgICAgICAgICAgIHByb2Nlc3NHbHlwaEVsZW1lbnQo Z2x5cGhFbGVtZW50LCBkZWZhdWx0SG9yaXpvbnRhbEFkdmFuY2UsIGRlZmF1bHRWZXJ0aWNhbEFk dmFuY2UsIHVuaWNvZGVBdHRyaWJ1dGVbMF0sIGluaXRpYWxHbHlwaCk7CisgICAgICAgICAgICBw cm9jZXNzR2x5cGhFbGVtZW50KGdseXBoRWxlbWVudCwgJmdseXBoRWxlbWVudCwgZGVmYXVsdEhv cml6b250YWxBZHZhbmNlLCBkZWZhdWx0VmVydGljYWxBZHZhbmNlLCB1bmljb2RlQXR0cmlidXRl WzBdLCBpbml0aWFsR2x5cGgpOwogICAgIH0KIAogICAgIGlmIChtX2dseXBocy5zaXplKCkgPiBz dGQ6Om51bWVyaWNfbGltaXRzPEdseXBoPjo6bWF4KCkpIHsKLSAgICAgICAgLy8gVGhpcyB3aWxs IGJyZWFrIGFsbCBzb3J0cyBvZiB0aGluZ3MuIEJhaWwgZWFybHkgaW5zdGVhZC4KKyAgICAgICAg Ly8gSW5kaWNhdGUgZXJyb3IgYnkgbGVhdmluZyB0aGUgZ2x5cGhzIHZlY3RvciBlbXB0eS4KICAg ICAgICAgbV9nbHlwaHMuY2xlYXIoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KQEAgLTk2Nyw1 NSArOTIzLDU2IEBAIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6U1ZHVG9PVEZGb250Q29udmVydGVy KGNvbnN0IFNWR0ZvbnRFbGVtZW50JiBmb250RWxlbWVudCkKICAgICAgICAgR2x5cGhEYXRhJiBn bHlwaCA9IG1fZ2x5cGhzW2ldOwogICAgICAgICBpZiAoZ2x5cGguZ2x5cGhFbGVtZW50KSB7CiAg ICAgICAgICAgICBhdXRvJiBnbHlwaE5hbWUgPSBnbHlwaC5nbHlwaEVsZW1lbnQtPmZhc3RHZXRB dHRyaWJ1dGUoU1ZHTmFtZXM6OmdseXBoX25hbWVBdHRyKTsKLSAgICAgICAgICAgIGlmICghZ2x5 cGhOYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGlmICghZ2x5cGhOYW1lLmlzTnVsbCgpKQog ICAgICAgICAgICAgICAgIG1fZ2x5cGhOYW1lVG9JbmRleE1hcC5hZGQoZ2x5cGhOYW1lLCBpKTsK ICAgICAgICAgfQotICAgICAgICBpZiAoZ2x5cGguY29kZXBvaW50KQorICAgICAgICBpZiAobV9j b2RlcG9pbnRUb0luZGV4TWFwLmlzVmFsaWRLZXkoZ2x5cGguY29kZXBvaW50KSkKICAgICAgICAg ICAgIG1fY29kZXBvaW50VG9JbmRleE1hcC5hZGQoZ2x5cGguY29kZXBvaW50LCBpKTsKICAgICB9 CiAKLSAgICAvLyBGSVhNRTogSGFuZGxlIGNvbW1hcworICAgIC8vIEZJWE1FOiBIYW5kbGUgY29t bWFzLgogICAgIGlmIChtX2ZvbnRGYWNlRWxlbWVudCkgewotICAgICAgICBhdXRvJiBmb250V2Vp Z2h0QXR0cmlidXRlID0gbV9mb250RmFjZUVsZW1lbnQtPmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFt ZXM6OmZvbnRfd2VpZ2h0QXR0cik7Ci0gICAgICAgIFZlY3RvcjxTdHJpbmc+IHNwbGl0OwotICAg ICAgICBmb250V2VpZ2h0QXR0cmlidXRlLnN0cmluZygpLnNwbGl0KCIgIiwgc3BsaXQpOwotICAg ICAgICBmb3IgKGF1dG8mIHNlZ21lbnQgOiBzcGxpdCkgewotICAgICAgICAgICAgaWYgKHNlZ21l bnQgPT0gImJvbGQiKQorICAgICAgICBWZWN0b3I8U3RyaW5nPiBzZWdtZW50czsKKyAgICAgICAg bV9mb250RmFjZUVsZW1lbnQtPmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OmZvbnRfd2VpZ2h0 QXR0cikuc3RyaW5nKCkuc3BsaXQoJyAnLCBzZWdtZW50cyk7CisgICAgICAgIGZvciAoYXV0byYg c2VnbWVudCA6IHNlZ21lbnRzKSB7CisgICAgICAgICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2Uo c2VnbWVudCwgImJvbGQiKSkgewogICAgICAgICAgICAgICAgIG1fd2VpZ2h0ID0gNzsKKyAgICAg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KICAgICAgICAgICAgIGJvb2wgb2s7CiAg ICAgICAgICAgICBpbnQgdmFsdWUgPSBzZWdtZW50LnRvSW50KCZvayk7Ci0gICAgICAgICAgICBp ZiAob2sgJiYgdmFsdWUgPj0gMCAmJiB2YWx1ZSA8IDEwMDApCi0gICAgICAgICAgICAgICAgbV93 ZWlnaHQgPSB2YWx1ZSAvIDEwMDsKKyAgICAgICAgICAgIGlmIChvayAmJiB2YWx1ZSA+PSAwICYm IHZhbHVlIDwgMTAwMCkgeworICAgICAgICAgICAgICAgIG1fd2VpZ2h0ID0gKHZhbHVlICsgNTAp IC8gMTAwOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQogICAgICAgICB9 Ci0gICAgICAgIGF1dG8mIGZvbnRTdHlsZUF0dHJpYnV0ZSA9IG1fZm9udEZhY2VFbGVtZW50LT5m YXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjpmb250X3dlaWdodEF0dHIpOwotICAgICAgICBzcGxp dC5jbGVhcigpOwotICAgICAgICBTdHJpbmcoZm9udFN0eWxlQXR0cmlidXRlKS5zcGxpdCgiICIs IHNwbGl0KTsKLSAgICAgICAgZm9yIChhdXRvJiBzIDogc3BsaXQpIHsKLSAgICAgICAgICAgIGlm IChzID09ICJpdGFsaWMiIHx8IHMgPT0gIm9ibGlxdWUiKQorICAgICAgICBtX2ZvbnRGYWNlRWxl bWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6Zm9udF9zdHlsZUF0dHIpLnN0cmluZygp LnNwbGl0KCcgJywgc2VnbWVudHMpOworICAgICAgICBmb3IgKGF1dG8mIHNlZ21lbnQgOiBzZWdt ZW50cykgeworICAgICAgICAgICAgaWYgKGVxdWFsSWdub3JpbmdDYXNlKHNlZ21lbnQsICJpdGFs aWMiKSB8fCBlcXVhbElnbm9yaW5nQ2FzZShzZWdtZW50LCAib2JsaXF1ZSIpKSB7CiAgICAgICAg ICAgICAgICAgbV9pdGFsaWMgPSB0cnVlOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAg ICAgICAgfQogICAgICAgICB9CiAgICAgfQogCi0gICAgLy8gTWlnaHQgbm90IGJlIHF1aXRlIHdo YXQgSSB3YW50CiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KQogICAgICAgICBtX2ZvbnRGYW1p bHkgPSBtX2ZvbnRGYWNlRWxlbWVudC0+Zm9udEZhbWlseSgpOwogfQogCiBzdGF0aWMgaW5saW5l IGJvb2wgaXNGb3VyQnl0ZUFsaWduZWQoc2l6ZV90IHgpCiB7Ci0gICAgcmV0dXJuICEoeCAmIHNp emVvZih1aW50MzJfdCktMSk7CisgICAgcmV0dXJuICEoeCAmIDMpOwogfQogCiBzdGF0aWMgdWlu dDMyX3QgY2FsY3VsYXRlQ2hlY2tzdW0oY29uc3QgVmVjdG9yPGNoYXI+JiB0YWJsZSwgc2l6ZV90 IHN0YXJ0aW5nT2Zmc2V0LCBzaXplX3QgZW5kaW5nT2Zmc2V0KQogewogICAgIEFTU0VSVChpc0Zv dXJCeXRlQWxpZ25lZChlbmRpbmdPZmZzZXQgLSBzdGFydGluZ09mZnNldCkpOwogICAgIHVpbnQz Ml90IHN1bSA9IDA7Ci0gICAgZm9yICg7IHN0YXJ0aW5nT2Zmc2V0IDwgZW5kaW5nT2Zmc2V0OyBz dGFydGluZ09mZnNldCArPSA0KSB7Ci0gICAgICAgIC8vIFRoZSBzcGVjIGlzIHVuY2xlYXIgd2hl dGhlciB0aGlzIGlzIGEgbGl0dGxlLWVuZGlhbiBzdW0gb3IgYSBiaWctZW5kaWFuIHN1bS4gQ2hv b3NlIGxpdHRsZSBlbmRpYW4uCi0gICAgICAgIHN1bSArPSAoc3RhdGljX2Nhc3Q8dW5zaWduZWQg Y2hhcj4odGFibGVbc3RhcnRpbmdPZmZzZXQgKyAzXSkgPDwgMjQpCi0gICAgICAgICAgICB8IChz dGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPih0YWJsZVtzdGFydGluZ09mZnNldCArIDJdKSA8PCAx NikKLSAgICAgICAgICAgIHwgKHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+KHRhYmxlW3N0YXJ0 aW5nT2Zmc2V0ICsgMV0pIDw8IDgpCi0gICAgICAgICAgICB8IHN0YXRpY19jYXN0PHVuc2lnbmVk IGNoYXI+KHRhYmxlW3N0YXJ0aW5nT2Zmc2V0XSk7CisgICAgZm9yIChzaXplX3Qgb2Zmc2V0ID0g c3RhcnRpbmdPZmZzZXQ7IG9mZnNldCA8IGVuZGluZ09mZnNldDsgb2Zmc2V0ICs9IDQpIHsKKyAg ICAgICAgc3VtICs9IChzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPih0YWJsZVtvZmZzZXQgKyAz XSkgPDwgMjQpCisgICAgICAgICAgICB8IChzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPih0YWJs ZVtvZmZzZXQgKyAyXSkgPDwgMTYpCisgICAgICAgICAgICB8IChzdGF0aWNfY2FzdDx1bnNpZ25l ZCBjaGFyPih0YWJsZVtvZmZzZXQgKyAxXSkgPDwgOCkKKyAgICAgICAgICAgIHwgc3RhdGljX2Nh c3Q8dW5zaWduZWQgY2hhcj4odGFibGVbb2Zmc2V0XSk7CiAgICAgfQogICAgIHJldHVybiBzdW07 CiB9CkBAIC0xMDI5LDcgKzk4Niw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBl bmRUYWJsZShjb25zdCBjaGFyIGlkZW50aWZpZXJbNF0sIFZlY3RvcjxjaGFyPiYKICAgICB3aGls ZSAoIWlzRm91ckJ5dGVBbGlnbmVkKG91dHB1dC5zaXplKCkpKQogICAgICAgICBvdXRwdXQuYXBw ZW5kKDApOwogICAgIEFTU0VSVChpc0ZvdXJCeXRlQWxpZ25lZChvdXRwdXQuc2l6ZSgpKSk7Ci0g ICAgc2l6ZV90IGRpcmVjdG9yeUVudHJ5T2Zmc2V0ID0ga1NORlRIZWFkZXJTaXplICsgbV90YWJs ZXNBcHBlbmRlZENvdW50ICoga0RpcmVjdG9yeUVudHJ5U2l6ZTsKKyAgICBzaXplX3QgZGlyZWN0 b3J5RW50cnlPZmZzZXQgPSBoZWFkZXJTaXplICsgbV90YWJsZXNBcHBlbmRlZENvdW50ICogZGly ZWN0b3J5RW50cnlTaXplOwogICAgIG91dHB1dFtkaXJlY3RvcnlFbnRyeU9mZnNldF0gPSBpZGVu dGlmaWVyWzBdOwogICAgIG91dHB1dFtkaXJlY3RvcnlFbnRyeU9mZnNldCArIDFdID0gaWRlbnRp ZmllclsxXTsKICAgICBvdXRwdXRbZGlyZWN0b3J5RW50cnlPZmZzZXQgKyAyXSA9IGlkZW50aWZp ZXJbMl07CkBAIC0xMDQzLDcgKzEwMDAsOCBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6 YXBwZW5kVGFibGUoY29uc3QgY2hhciBpZGVudGlmaWVyWzRdLCBWZWN0b3I8Y2hhcj4mCiBWZWN0 b3I8Y2hhcj4gU1ZHVG9PVEZGb250Q29udmVydGVyOjpjb252ZXJ0U1ZHVG9PVEZGb250KCkKIHsK ICAgICBWZWN0b3I8Y2hhcj4gcmVzdWx0OwotICAgIGlmICghbV9nbHlwaHMuc2l6ZSgpKQorCisg ICAgaWYgKG1fZ2x5cGhzLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIHJlc3VsdDsKIAogICAg IHVpbnQxNl90IG51bVRhYmxlcyA9IDEzOwpAQCAtMTA1OSwxMCArMTAxNywxMCBAQCBWZWN0b3I8 Y2hhcj4gU1ZHVG9PVEZGb250Q29udmVydGVyOjpjb252ZXJ0U1ZHVG9PVEZGb250KCkKICAgICB3 cml0ZTE2KHJlc3VsdCwgaW50ZWdyYWxMb2cyKHJvdW5kZWROdW1UYWJsZXMpKTsgLy8gZW50cnlT ZWxlY3RvcjogIkxvZzIobWF4aW11bSBwb3dlciBvZiAyIDw9IG51bVRhYmxlcykuIgogICAgIHdy aXRlMTYocmVzdWx0LCBudW1UYWJsZXMgKiAxNiAtIHNlYXJjaFJhbmdlKTsgLy8gcmFuZ2VTaGlm dDogIk51bVRhYmxlcyB4IDE2LXNlYXJjaFJhbmdlLiIKIAotICAgIEFTU0VSVChyZXN1bHQuc2l6 ZSgpID09IGtTTkZUSGVhZGVyU2l6ZSk7CisgICAgQVNTRVJUKHJlc3VsdC5zaXplKCkgPT0gaGVh ZGVyU2l6ZSk7CiAKLSAgICAvLyBMZWF2ZSBzcGFjZSBmb3IgdGhlIERpcmVjdG9yeSBFbnRyaWVz Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBrRGlyZWN0b3J5RW50cnlTaXplICogbnVtVGFi bGVzOyArK2kpCisgICAgLy8gTGVhdmUgc3BhY2UgZm9yIHRoZSBkaXJlY3RvcnkgZW50cmllcy4K KyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGRpcmVjdG9yeUVudHJ5U2l6ZSAqIG51bVRhYmxl czsgKytpKQogICAgICAgICByZXN1bHQuYXBwZW5kKDApOwogCiAgICAgYXBwZW5kVGFibGUoIkNG RiAiLCByZXN1bHQsICZTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZENGRlRhYmxlKTsKQEAg LTEwODIsMTAgKzEwNDAsOSBAQCBWZWN0b3I8Y2hhcj4gU1ZHVG9PVEZGb250Q29udmVydGVyOjpj b252ZXJ0U1ZHVG9PVEZGb250KCkKIAogICAgIEFTU0VSVChudW1UYWJsZXMgPT0gbV90YWJsZXNB cHBlbmRlZENvdW50KTsKIAotICAgIC8vIGNoZWNrU3VtQWRqdXN0bWVudDogIlRvIGNvbXB1dGU6 IHNldCBpdCB0byAwLCBjYWxjdWxhdGUgdGhlIGNoZWNrc3VtIGZvciB0aGUgJ2hlYWQnIHRhYmxl IGFuZCBwdXQgaXQgaW4gdGhlIHRhYmxlIGRpcmVjdG9yeSwKKyAgICAvLyBjaGVja3N1bUFkanVz dG1lbnQ6ICJUbyBjb21wdXRlOiBzZXQgaXQgdG8gMCwgY2FsY3VsYXRlIHRoZSBjaGVja3N1bSBm b3IgdGhlICdoZWFkJyB0YWJsZSBhbmQgcHV0IGl0IGluIHRoZSB0YWJsZSBkaXJlY3RvcnksCiAg ICAgLy8gc3VtIHRoZSBlbnRpcmUgZm9udCBhcyB1aW50MzIsIHRoZW4gc3RvcmUgQjFCMEFGQkEg LSBzdW0uIFRoZSBjaGVja3N1bSBmb3IgdGhlICdoZWFkJyB0YWJsZSB3aWxsIG5vdyBiZSB3cm9u Zy4gVGhhdCBpcyBPSy4iCi0gICAgdWludDMyX3QgY2hlY2tzdW1BZGp1c3RtZW50ID0gMHhCMUIw QUZCQVUgLSBjYWxjdWxhdGVDaGVja3N1bShyZXN1bHQsIDAsIHJlc3VsdC5zaXplKCkpOwotICAg IG92ZXJ3cml0ZTMyKHJlc3VsdCwgaGVhZFRhYmxlT2Zmc2V0ICsgOCwgY2hlY2tzdW1BZGp1c3Rt ZW50KTsKKyAgICBvdmVyd3JpdGUzMihyZXN1bHQsIGhlYWRUYWJsZU9mZnNldCArIDgsIDB4QjFC MEFGQkFVIC0gY2FsY3VsYXRlQ2hlY2tzdW0ocmVzdWx0LCAwLCByZXN1bHQuc2l6ZSgpKSk7CiAK ICAgICByZXR1cm4gcmVzdWx0OwogfQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9v bHMvQ2hhbmdlTG9nCmluZGV4IDNmMmU4OTlmNDlkMTNiODllMzg0ODFmOTgyOTc1ZTQwZWE0Yzk5 NjAuLjcxZmY1MTI0ZjhjYzU4ODJkY2YyN2Q1NmE3YzM0MjgyYjA3YTI5ZmUgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAor MjAxNC0wOS0yNiAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CisKKyAgICAgICAgVHdl YWsgYW5kIHRpZ2h0ZW4gU1ZHIGZvbnQgY29udmVydGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzY5NTYKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJIHdhcyBpbnZlc3RpZ2F0aW5nIGJlaGF2aW9yIG9m IFN0cmluZzo6dG9JbnQsIFN0cmluZzo6dG9Eb3VibGUsIGFuZAorICAgICAgICBTdHJpbmc6OnRv RmxvYXQgZm9yIHZhcmlvdXMgZmFpbHVyZSBjYXNlcywgYW5kIGRlY2lkZWQgdG8gc3RhcnQgc29t ZQorICAgICAgICB1bml0IHRlc3RzIGZvciB0aG9zZSBmdW5jdGlvbnMgaGVyZS4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dURlN0cmluZy5jcHA6CisgICAgICAgIChUZXN0 V2ViS2l0QVBJOjpURVNUKTogQWRkZGVkIGEgZmlyc3Qgc21hbGwgYml0IG9mIFN0cmluZ1RvSW50 IGFuZAorICAgICAgICBTdHJpbmdUb0RvdWJsZSB0ZXN0aW5nLgorCiAyMDE0LTA5LTI2ICBCZXRo IERha2luICA8YmRha2luQGFwcGxlLmNvbT4KIAogICAgICAgICBNYW55IHBsYXRmb3JtL21hYy13 azIvdGlsZWQtZHJhd2luZy8gdGVzdHMgZmFpbCB3aGVuIHJ1biBvbiBhIHJldGluYSBkZXZpY2UK ZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dURlN0cmluZy5jcHAg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XVEZTdHJpbmcuY3BwCmluZGV4IGEzOTVm Nzk3NDRmNjMwMjJkNmYzZjM1Y2IwNmJhZGQwZDJiMGY2NjIuLmY0MGU2YWY1MTAyYzY3YjBjYWM3 ZjhkMjM5NTdmMWIxYTRkNWZkNWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV1RGL1dURlN0cmluZy5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYv V1RGU3RyaW5nLmNwcApAQCAtMTYwLDQgKzE2MCwxMDQgQEAgVEVTVChXVEYsIFN0cmluZ0lzb2xh dGVkQ29weSkKICAgICBBU1NFUlRfRkFMU0Uob3JpZ2luYWwuaW1wbCgpID09IGNvcHkuaW1wbCgp KTsKIH0KIAorVEVTVChXVEYsIFN0cmluZ1RvSW50KQoreworICAgIGJvb2wgb2s7CisKKyAgICBF WFBFQ1RfRVEoMCwgU3RyaW5nKCkudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDAsIFN0cmluZygp LnRvSW50KCZvaykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgRVhQRUNUX0VR KDAsIGVtcHR5U3RyaW5nKCkudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDAsIGVtcHR5U3RyaW5n KCkudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBvayk7CisKKyAgICBFWFBFQ1Rf RVEoMCwgU3RyaW5nKCIwIikudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDAsIFN0cmluZygiMCIp LnRvSW50KCZvaykpOworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7CisKKyAgICBFWFBFQ1RfRVEo MSwgU3RyaW5nKCIxIikudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDEsIFN0cmluZygiMSIpLnRv SW50KCZvaykpOworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7CisKKyAgICBFWFBFQ1RfRVEoMjE0 NzQ4MzY0NywgU3RyaW5nKCIyMTQ3NDgzNjQ3IikudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDIx NDc0ODM2NDcsIFN0cmluZygiMjE0NzQ4MzY0NyIpLnRvSW50KCZvaykpOworICAgIEVYUEVDVF9F USh0cnVlLCBvayk7CisKKyAgICBFWFBFQ1RfRVEoMCwgU3RyaW5nKCIyMTQ3NDgzNjQ4IikudG9J bnQoKSk7CisgICAgRVhQRUNUX0VRKDAsIFN0cmluZygiMjE0NzQ4MzY0OCIpLnRvSW50KCZvaykp OworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgRVhQRUNUX0VRKC0yMTQ3NDgzNjQ4 LCBTdHJpbmcoIi0yMTQ3NDgzNjQ4IikudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKC0yMTQ3NDgz NjQ4LCBTdHJpbmcoIi0yMTQ3NDgzNjQ4IikudG9JbnQoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIG9rKTsKKworICAgIEVYUEVDVF9FUSgwLCBTdHJpbmcoIi0yMTQ3NDgzNjQ5IikudG9JbnQo KSk7CisgICAgRVhQRUNUX0VRKDAsIFN0cmluZygiLTIxNDc0ODM2NDkiKS50b0ludCgmb2spKTsK KyAgICBFWFBFQ1RfRVEoZmFsc2UsIG9rKTsKKworICAgIC8vIGZhaWwgaWYgd2Ugc2VlIGxlYWRp bmcganVuaworICAgIEVYUEVDVF9FUSgwLCBTdHJpbmcoIngxIikudG9JbnQoKSk7CisgICAgRVhQ RUNUX0VRKDAsIFN0cmluZygieDEiKS50b0ludCgmb2spKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2Us IG9rKTsKKworICAgIC8vIHN1Y2NlZWQgaWYgd2Ugc2VlIGxlYWRpbmcgc3BhY2VzCisgICAgRVhQ RUNUX0VRKDEsIFN0cmluZygiIDEiKS50b0ludCgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgU3RyaW5n KCIgMSIpLnRvSW50KCZvaykpOworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7CisKKyAgICAvLyBz aWxlbnRseSBpZ25vcmUgdHJhaWxpbmcganVuaworICAgIEVYUEVDVF9FUSgxLCBTdHJpbmcoIjF4 IikudG9JbnQoKSk7CisgICAgRVhQRUNUX0VRKDEsIFN0cmluZygiMXgiKS50b0ludCgmb2spKTsK KyAgICBFWFBFQ1RfRVEodHJ1ZSwgb2spOworfQorCitURVNUKFdURiwgU3RyaW5nVG9Eb3VibGUp Cit7CisgICAgYm9vbCBvazsKKworICAgIEVYUEVDVF9FUSgwLjAsIFN0cmluZygpLnRvRG91Ymxl KCkpOworICAgIEVYUEVDVF9FUSgwLjAsIFN0cmluZygpLnRvRG91YmxlKCZvaykpOworICAgIEVY UEVDVF9FUShmYWxzZSwgb2spOworCisgICAgRVhQRUNUX0VRKDAuMCwgZW1wdHlTdHJpbmcoKS50 b0RvdWJsZSgpKTsKKyAgICBFWFBFQ1RfRVEoMC4wLCBlbXB0eVN0cmluZygpLnRvRG91YmxlKCZv aykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgRVhQRUNUX0VRKDAuMCwgU3Ry aW5nKCIwIikudG9Eb3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDAuMCwgU3RyaW5nKCIwIikudG9E b3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIG9rKTsKKworICAgIEVYUEVDVF9FUSgx LjAsIFN0cmluZygiMSIpLnRvRG91YmxlKCkpOworICAgIEVYUEVDVF9FUSgxLjAsIFN0cmluZygi MSIpLnRvRG91YmxlKCZvaykpOworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7CisKKyAgICAvLyBm YWlsIGlmIHdlIHNlZSBsZWFkaW5nIGp1bmsKKyAgICBFWFBFQ1RfRVEoMC4wLCBTdHJpbmcoIngx IikudG9Eb3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDAuMCwgU3RyaW5nKCJ4MSIpLnRvRG91Ymxl KCZvaykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgLy8gc3VjY2VlZCBpZiB3 ZSBzZWUgbGVhZGluZyBzcGFjZXMKKyAgICBFWFBFQ1RfRVEoMS4wLCBTdHJpbmcoIiAxIikudG9E b3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDEuMCwgU3RyaW5nKCIgMSIpLnRvRG91YmxlKCZvaykp OworICAgIEVYUEVDVF9FUSh0cnVlLCBvayk7CisKKyAgICAvLyBpZ25vcmUgdHJhaWxpbmcganVu aywgYnV0IHJldHVybiBmYWxzZSBmb3IgIm9rIgorICAgIC8vIEZJWE1FOiBUaGlzIGlzIGFuIGlu Y29uc2lzdGVuY3kgd2l0aCB0b0ludCwgd2hpY2ggYWx3YXlzIGd1YXJhbnRlZXMKKyAgICAvLyBp dCB3aWxsIHJldHVybiAwIGlmIGl0J3MgYWxzbyBnb2luZyB0byByZXR1cm4gZmFsc2UgZm9yIG9r LgorICAgIEVYUEVDVF9FUSgxLjAsIFN0cmluZygiMXgiKS50b0RvdWJsZSgpKTsKKyAgICBFWFBF Q1RfRVEoMS4wLCBTdHJpbmcoIjF4IikudG9Eb3VibGUoJm9rKSk7CisgICAgRVhQRUNUX0VRKGZh bHNlLCBvayk7CisKKyAgICAvLyBwYXJzZSBvbmx5IG51bWJlcnMsIG5vdCBzcGVjaWFsIHZhbHVl cyBzdWNoIGFzICJpbmZpbml0eSIKKyAgICBFWFBFQ1RfRVEoMC4wLCBTdHJpbmcoImluZmluaXR5 IikudG9Eb3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDAuMCwgU3RyaW5nKCJpbmZpbml0eSIpLnRv RG91YmxlKCZvaykpOworICAgIEVYUEVDVF9FUShmYWxzZSwgb2spOworCisgICAgLy8gcGFyc2Ug b25seSBudW1iZXJzLCBub3Qgc3BlY2lhbCB2YWx1ZXMgc3VjaCBhcyAibmFuIgorICAgIEVYUEVD VF9FUSgwLjAsIFN0cmluZygibmFuIikudG9Eb3VibGUoKSk7CisgICAgRVhQRUNUX0VRKDAuMCwg U3RyaW5nKCJuYW4iKS50b0RvdWJsZSgmb2spKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIG9rKTsK K30KKwogfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQo=