136971 2014-09-19 18:57:31 -0700 Implement 'vhea', 'vmtx', and 'kern' tables in SVG -> OTF converter 2014-09-22 15:08:44 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 mmaxfield mmaxfield darin dino jonlee mitz simon.fraser thorton oldest_to_newest 1036267 0 mmaxfield 2014-09-19 18:57:31 -0700 Implement 'vhea', 'vmtx', and 'kern' tables in SVG -> OTF converter 1036272 1 238404 mmaxfield 2014-09-19 19:29:49 -0700 Created attachment 238404 Patch 1036347 2 238404 darin 2014-09-21 10:49:16 -0700 Comment on attachment 238404 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238404&action=review I’m not sure that all this clamping is right. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:101 > + return (static_cast<uint32_t>(glyph1) << 16 | glyph2) < (static_cast<uint32_t>(other.glyph1) << 16 | other.glyph2); The static_cast here are not needed unless we are compiling for a platform where “int” and “unsigned” are 16-bit, and that won’t be happening. But also, there’s no need to combine these glyphs that way. Lets just write this: return glyph1 < other.glyph1 || (glyph1 == other.glyph1 && glyph2 < other.glyph2); Also, it would be cleaner to have this be a separate compareGlyphs function rather than having KerningData implement a < operator that doesn’t consider all of the data. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:142 > + HashMap<Codepoint, Glyph> m_codepointToIndexMap; // FIXME: There might be many glyphs that map to a single codepoint Missing period. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:338 > + auto& missingGlyphAdvanceAttribute = m_missingGlyphElement->fastGetAttribute(SVGNames::horiz_adv_xAttr); > + int value = missingGlyphAdvanceAttribute.toInt(&ok); No need for the local variable here. Just write this in one line. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:340 > + averageAdvance = clampTo<int16_t, int>(value); Should just be clampTo<int16_t>, it’s not helpful to specify the second time. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:547 > + int16_t defaultVerticalOriginY = clampTo<int16_t>(m_fontElement.fastGetAttribute(SVGNames::vert_origin_yAttr).toInt(&ok)); > + if (!ok && m_missingGlyphElement) Do we really need to check "ok"? Is zero a valid value? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:548 > + defaultVerticalOriginY = clampTo<int16_t>(m_missingGlyphElement->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt(&ok)); No reason to pass &ok here since we never look at it afterward. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:575 > + write16(result, clampTo<int16_t>(-static_cast<long>(m_unitsPerEm / 2))); // Vertical typographic descender The choice of the type "long" here is unusual. I could see using int or int32_t, but long doesn’t seem better than either of those two types. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:580 > + write16(result, clampTo<int16_t, float>(m_advanceHeightMax)); > + write16(result, clampTo<int16_t, float>(m_unitsPerEm - m_boundingBox.maxY())); // Minimum top side bearing > + write16(result, clampTo<int16_t, float>(m_boundingBox.y())); // Minimum bottom side bearing > + write16(result, clampTo<int16_t, float>(m_unitsPerEm - m_boundingBox.y())); // Y maximum extent No need to specify ", float" on all of these clampTo function calls. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:593 > + for (const auto& glyph : m_glyphs) { Just auto& is fine. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:595 > + write16(result, clampTo<uint16_t, float>(glyph.verticalAdvance)); > + write16(result, clampTo<int16_t, float>(m_unitsPerEm - glyph.boundingBox.maxY())); // top side bearing No need to specify ", float" on all of these clampTo function calls. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:601 > + uint16_t roundedNumKerningPairs = roundDownToPowerOfTwo(kerningData.size()); I really don’t understand why rounding *down* is OK. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:603 > + uint16_t searchRange = roundedNumKerningPairs * 6; > + uint16_t rangeShift = (kerningData.size() - roundedNumKerningPairs) * 6; No idea where this magic number 6 comes from. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:606 > + uint16_t entrySelector = 0; > + while (roundedNumKerningPairs >>= 1) > + ++entrySelector; I think it would be nicer to have a helper function for this rather than writing out the loop in this fashion. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:616 > + for (auto unicodeRange : unicodeRanges) { Should be auto&, not auto. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:619 > + if (codepoint > std::numeric_limits<Codepoint>::max()) > + continue; Why is this check needed? Is there some danger that the find call below will find something when passed in a huge number? It’s probably not a good idea to truncate a code point here, but I don’t understand how such bad values could get into UnicodeRanges in the first place. Also, 0x0000 and 0xFFFF will both cause trouble below in the has table code but this doesn’t disallow either of those. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:620 > + auto indexIter = m_codepointToIndexMap.find(codepoint); I think the word “iterator” would be better than word and a half “index iter”. What prevents us from passing 0 or the deleted value (usually -1) here? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:622 > + glyphSet.add(indexIter->value); This is a really inefficient data structure for this kind of thing. Representing every single value in a range as a separate entry in a HashSet is super-expensive for large ranges. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:630 > + // FIXME: Only support BMP for now Why? The code to handle any UTF-16 sequence is simple. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:631 > + if (codepoint.length() == 1 && codepoint.length() == 1 && codepoint.at(0) <= std::numeric_limits<Codepoint>::max()) { This says codepoint.length() twice. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:632 > + auto indexIter = m_codepointToIndexMap.find(codepoint.at(0)); What prevents us from trying to use 0x0000 or 0xFFFF here? > Source/WebCore/svg/SVGToOTFFontConversion.cpp:639 > +void SVGToOTFFontConverter::addGlyphNames(const HashSet<String>& glyphNames, HashSet<uint16_t>& glyphSet) const I’m not sure why we keep the glyph names in a set and then later put them into a map. It seems wasteful to use indexed data types for both. I suggest using just a Vector for the names in the kerningPair object. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:641 > + for (auto glyphName : glyphNames) { This should be auto&. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:668 > + for (auto glyph1 : glyphSet1) { > + for (auto glyph2 : glyphSet2) Should be auto& instead of auto. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:690 > + size_t sizeOfKerningDataTable = 14 + 6 * kerningData.size(); A little strange to put this into a size_t and then write it out as a 16-bit value without any range checking. I think the code overall is not consistent about things like clamping and range checking. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:693 > + sizeOfKerningDataTable = 0; Seems like this should be 14. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:714 > + // Table 2 This copy and paste code isn’t good. There should be a helper function rather than code that we just repeat twice. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:740 > + // There are two competing specs for the 'kern' table: one that only Apple supports and one that everyone supports. Apple's font > + // parser claims to support both; however, it requires some padding bytes at the end if you use the second format. <rdar://problem/18401901> I don’t think this should have all this commentary. Comment should say “Work around a bug in Apple's font parser by adding some padding bytes.” The commentary about two specs for 'kern' table doesn’t seem relevant here. > Source/WebCore/svg/SVGToOTFFontConversion.cpp:964 > + for (const auto& glyphElement : childrenOfType<SVGGlyphElement>(m_fontElement)) { Should just be auto&, not const auto&. 1036604 3 238404 mmaxfield 2014-09-22 14:52:37 -0700 Comment on attachment 238404 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238404&action=review >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:101 >> + return (static_cast<uint32_t>(glyph1) << 16 | glyph2) < (static_cast<uint32_t>(other.glyph1) << 16 | other.glyph2); > > The static_cast here are not needed unless we are compiling for a platform where “int” and “unsigned” are 16-bit, and that won’t be happening. But also, there’s no need to combine these glyphs that way. Lets just write this: > > return glyph1 < other.glyph1 || (glyph1 == other.glyph1 && glyph2 < other.glyph2); > > Also, it would be cleaner to have this be a separate compareGlyphs function rather than having KerningData implement a < operator that doesn’t consider all of the data. I had no idea that shifting performed integral promotions of the left argument! I had to read the C++ spec to figure out what you meant by that first statement. By the way, the original code was written like that because the spec says: "The left and right halves of the kerning pair make an unsigned 32-bit number, which is then used to order the kerning pairs numerically." Your way is more readable, though. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:142 >> + HashMap<Codepoint, Glyph> m_codepointToIndexMap; // FIXME: There might be many glyphs that map to a single codepoint > > Missing period. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:338 >> + int value = missingGlyphAdvanceAttribute.toInt(&ok); > > No need for the local variable here. Just write this in one line. Too bad you ended up mentioning a lot of these things twice. In my defense, I wrote this before I read your patch. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:340 >> + averageAdvance = clampTo<int16_t, int>(value); > > Should just be clampTo<int16_t>, it’s not helpful to specify the second time. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:547 >> + if (!ok && m_missingGlyphElement) > > Do we really need to check "ok"? Is zero a valid value? Yep. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:548 >> + defaultVerticalOriginY = clampTo<int16_t>(m_missingGlyphElement->fastGetAttribute(SVGNames::vert_origin_yAttr).toInt(&ok)); > > No reason to pass &ok here since we never look at it afterward. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:575 >> + write16(result, clampTo<int16_t>(-static_cast<long>(m_unitsPerEm / 2))); // Vertical typographic descender > > The choice of the type "long" here is unusual. I could see using int or int32_t, but long doesn’t seem better than either of those two types. I was using long for the case of std::numeric_limits<unsigned>::max() (which can't be negated properly) but the "/ 2" allows a int32_t work just fine, as you said. Now that I think about it, long wouldn't have worked on 32-bit machines... Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:580 >> + write16(result, clampTo<int16_t, float>(m_unitsPerEm - m_boundingBox.y())); // Y maximum extent > > No need to specify ", float" on all of these clampTo function calls. Done. I did this at all the call sites. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:593 >> + for (const auto& glyph : m_glyphs) { > > Just auto& is fine. Done. I believe I just fixed this throughout the whole file. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:595 >> + write16(result, clampTo<int16_t, float>(m_unitsPerEm - glyph.boundingBox.maxY())); // top side bearing > > No need to specify ", float" on all of these clampTo function calls. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:601 >> + uint16_t roundedNumKerningPairs = roundDownToPowerOfTwo(kerningData.size()); > > I really don’t understand why rounding *down* is OK. These formulas come directly from the spec. I'll add some comments quoting bits of the spec. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:603 >> + uint16_t rangeShift = (kerningData.size() - roundedNumKerningPairs) * 6; > > No idea where this magic number 6 comes from. Comments added. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:606 >> + ++entrySelector; > > I think it would be nicer to have a helper function for this rather than writing out the loop in this fashion. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:616 >> + for (auto unicodeRange : unicodeRanges) { > > Should be auto&, not auto. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:619 >> + continue; > > Why is this check needed? Is there some danger that the find call below will find something when passed in a huge number? It’s probably not a good idea to truncate a code point here, but I don’t understand how such bad values could get into UnicodeRanges in the first place. Also, 0x0000 and 0xFFFF will both cause trouble below in the has table code but this doesn’t disallow either of those. It's just that the key in m_codepointToIndexMap is a Codepoint, which is 16 bits, but UnicodeRange contains unsigned values. If the UnicodeRange contains 0x10001, I don't want the find() to look for 0x1. UnicodeRanges get created from the "unicode" property in the SVG file's <glyph> element, so it definitely can contain values > 0xFFFF. I'll guard against 0 and 0xFFFF as well. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:620 >> + auto indexIter = m_codepointToIndexMap.find(codepoint); > > I think the word “iterator” would be better than word and a half “index iter”. > > What prevents us from passing 0 or the deleted value (usually -1) here? Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:622 >> + glyphSet.add(indexIter->value); > > This is a really inefficient data structure for this kind of thing. Representing every single value in a range as a separate entry in a HashSet is super-expensive for large ranges. You're right, and I knew that going in. My thought was that it didn't matter because I had to output glyph-by-glyph anyway and that I haven't seen ranges used in any of the fonts I've looked at. I think this is something that I can fix up in a subsequent patch. https://bugs.webkit.org/show_bug.cgi?id=137010 >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:630 >> + // FIXME: Only support BMP for now > > Why? The code to handle any UTF-16 sequence is simple. Done. There are a few places in this file where non-BMP support needs to be added. This one is simple enough that I did it right now. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:631 >> + if (codepoint.length() == 1 && codepoint.length() == 1 && codepoint.at(0) <= std::numeric_limits<Codepoint>::max()) { > > This says codepoint.length() twice. Well, that's embarrassing. "codepoint.length() == 1 && codepoint.length() == 1" >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:632 >> + auto indexIter = m_codepointToIndexMap.find(codepoint.at(0)); > > What prevents us from trying to use 0x0000 or 0xFFFF here? Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:639 >> +void SVGToOTFFontConverter::addGlyphNames(const HashSet<String>& glyphNames, HashSet<uint16_t>& glyphSet) const > > I’m not sure why we keep the glyph names in a set and then later put them into a map. It seems wasteful to use indexed data types for both. I suggest using just a Vector for the names in the kerningPair object. Seems reasonable to me, though that class was not added by this patch. I've made a bug regarding cleaning this up: https://bugs.webkit.org/show_bug.cgi?id=137011 >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:641 >> + for (auto glyphName : glyphNames) { > > This should be auto&. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:668 >> + for (auto glyph2 : glyphSet2) > > Should be auto& instead of auto. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:690 >> + size_t sizeOfKerningDataTable = 14 + 6 * kerningData.size(); > > A little strange to put this into a size_t and then write it out as a 16-bit value without any range checking. I think the code overall is not consistent about things like clamping and range checking. Isn't that what line 691 is? >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:693 >> + sizeOfKerningDataTable = 0; > > Seems like this should be 14. Good catch. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:714 >> + // Table 2 > > This copy and paste code isn’t good. There should be a helper function rather than code that we just repeat twice. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:740 >> + // parser claims to support both; however, it requires some padding bytes at the end if you use the second format. <rdar://problem/18401901> > > I don’t think this should have all this commentary. Comment should say “Work around a bug in Apple's font parser by adding some padding bytes.” The commentary about two specs for 'kern' table doesn’t seem relevant here. Done. >> Source/WebCore/svg/SVGToOTFFontConversion.cpp:964 >> + for (const auto& glyphElement : childrenOfType<SVGGlyphElement>(m_fontElement)) { > > Should just be auto&, not const auto&. Done. 1036607 4 mmaxfield 2014-09-22 15:08:44 -0700 http://trac.webkit.org/changeset/173852 238404 2014-09-19 19:29:49 -0700 2014-09-22 14:52:37 -0700 Patch bug-136971-20140919192947.patch text/plain 38121 mmaxfield U3VidmVyc2lvbiBSZXZpc2lvbjogMTczNzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDE1MDhmOTNkNzI3YzA2 YzAyMzFkZGU4ZjA1YzU3M2VmYjEyMGI2Yi4uZjZkMWYzZDRkM2FiZDQyOWU5NmUwZTBmNWI4NzBi YWQ0OWNkN2YzNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDc4IEBACisyMDE0LTA5LTE5ICBNeWxl cyBDLiBNYXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50 ICd2aGVhJywgJ3ZtdHgnLCBhbmQgJ2tlcm4nIHRhYmxlcyBpbiBTVkcgLT4gT1RGIGNvbnZlcnRl cgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2OTcx CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBw YXRjaCBmaWxscyBpbiB0aGUgdGFibGVzIHJlbGF0ZWQgdG8gdmVydGljYWwgbWV0cmljcyBhbmQg a2VybmluZy4gVGhlIHZlcnRpY2FsIG1ldHJpY3MgdGFibGVzIGFyZQorICAgICAgICBmYWlybHkg c3RyYWlnaHRmb3J3YXJkLiBPbiB0aGUgb3RoZXIgaGFuZCwgdGhlICdrZXJuJyB0YWJsZSBoYXMg c3VidGFibGVzIHdoaWNoIGNhbiBiZSBpbiBhIHZhcmlldHkKKyAgICAgICAgb2YgZm9ybWF0czsg aG93ZXZlciwgYWNjb3JkaW5nIHRvIE1pY3Jvc29mdCwgV2luZG93cyBvbmx5IGFsbG93cyBvbmUg cGFydGljdWxhciBmb3JtYXQsIHdoaWNoIGRvZXNuJ3QKKyAgICAgICAgYWxsb3cgZm9yIHJhbmdl cyBvZiBnbHlwaHMgdG8gYmUgZGVzY3JpYmVkIGFuZCB0aGVyZWZvcmUgbWlnaHQgbGVhZCB0byBh IGxhcmdlICdrZXJuJyB0YWJsZSBzaXplLiBJbgorICAgICAgICB0aGUgaW50ZXJlc3Qgb2YgcGxh dGZvcm0gYWdub3N0aWNpc20gSSBoYXZlIGltcGxlbWVudGVkIHRoaXMgcGFydGljdWxhciBmb3Jt YXQsIGFuZCBoYXZlIG5vdCBhY3R1YWxseQorICAgICAgICB3aXRuZXNzZWQgYW55IGV4dHJlbWVs eSBsYXJnZSAna2VybicgdGFibGVzIGluIGFueSBvZiB0aGUgZm9udHMgdGhhdCBJIGhhdmUgbG9v a2VkIGF0LgorCisgICAgICAgIEkgYWxzbyBhZGRlZCBiYXNpYyBzdXBwb3J0IGZvciB0aGUgaG9y aXotb3JpZ2luLXggYW5kIGhvcml6LW9yaWdpbi15IFNWRyBwcm9wZXJ0aWVzLCB0aG91Z2ggc3Vw cG9ydAorICAgICAgICBtaWdodCBub3QgYmUgcGVyZmVjdCBiYXNlZCBvbiBteSB0ZXN0aW5nLgor CisgICAgICAgIFJlZ2FyZGluZyB0ZXN0aW5nLCBhZnRlciB0aGlzIHBhdGNoLCBhbG1vc3QgYWxs IG9mIG91ciBTVkcgZm9udHMgdGVzdHMgcGFzcyAoYmFycmluZyB0aW55IHJlYmFzZWxpbmluZzsK KyAgICAgICAgdGhlIHBsYXRmb3JtIGZvbnQgc3lzdGVtIGNhbGN1bGF0ZXMgc2xpZ2h0bHkgZGlm ZmVyZW50IGFkdmFuY2VzIHRoYW4gd2UgZGlkLiBUaGVzZSBkaWZmZXJlbmNlcyBhcmUgdGlueQor ICAgICAgICBhbmQgZXhwZWN0ZWQgZnJvbSBzdWNoIGEgZHJhbWF0aWMgc2hpZnQgaW4gdGV4dCBo YW5kbGluZyBlbmdpbmVzLikgVGhlcmUgYXJlIGFyb3VuZCB0d28gZG96ZW4gZmFpbGluZworICAg ICAgICB0ZXN0cyBsZWZ0IHRoYXQgbG9vayBsaWtlIHRoZXkgYXJlIGFjdHVhbGx5IGluZGljaWF0 aXZlIG9mIGNvZGUgcHJvYmxlbXMuCisKKyAgICAgICAgKiBzdmcvU1ZHRm9udEVsZW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6U1ZHRm9udEVsZW1lbnQ6OmVuc3VyZUdseXBoQ2FjaGUpOiBS ZWZhY3RvciB0byBhY2NlcHQgbmV3IHNpZ25hdHVyZSBvZgorICAgICAgICBTVkcqS2VybkVsZW1l bnQ6OmJ1aWxkKktlcm5pbmdQYWlyKCkuCisgICAgICAgICogc3ZnL1NWR0hLZXJuRWxlbWVudC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdIS2VybkVsZW1lbnQ6OmJ1aWxkSG9yaXpvbnRhbEtl cm5pbmdQYWlyKTogUmVmYWN0b3IgdG8gYWxsb3cgZm9yIGludGVybWVkaWF0ZSBkYXRhIHRvIGJl CisgICAgICAgIHJldHVybmVkLCB3aGljaCB0aGUgU1ZHIC0+IE9URiBmb250IGNvbnZlcnRlciBj YW4gdXNlLgorICAgICAgICAqIHN2Zy9TVkdIS2VybkVsZW1lbnQuaDogTmV3IHNpZ25hdHVyZSBm b3IgYnVpbGRIb3Jpem9udGFsS2VybmluZ1BhaXIoKS4KKyAgICAgICAgKiBzdmcvU1ZHVG9PVEZG b250Q29udmVyc2lvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0 ZXI6OkdseXBoRGF0YTo6R2x5cGhEYXRhKTogU2F2ZSB0aGUgZ2x5cGgncyB2ZXJ0aWNhbCBhZHZh bmNlIGFsb25nIHdpdGgKKyAgICAgICAgdGhlIGdseXBoJ3MgaG9yaXpvbnRhbCBhZHZhbmNlLgor ICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpLZXJuaW5nRGF0YTo6S2Vy bmluZ0RhdGEpOiBUaGlzIGRhdGEgcmVwcmVzZW50cyBhIHJlY29yZCBpbiBvbmUgb2YKKyAgICAg ICAgdGhlIHR3byAna2Vybicgc3VidGFibGVzLCBhbmQgYXMgc3VjaCBuZWVkcyB0byBiZSBzb3J0 ZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6Oktlcm5pbmdEYXRh OjpvcGVyYXRvcjwpOiBTb3J0IGNvbXBhcmF0b3IuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09U RkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEhFQURUYWJsZSk6IFNhdmUgdGhlIHVuaXRzUGVyRW0gbG9j YWxseSB0byBzYXZlIGEgY29uZGl0aW9uYWwuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZv bnRDb252ZXJ0ZXI6OmFwcGVuZEhIRUFUYWJsZSk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6 U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRITVRYVGFibGUpOiBEaXR0by4gQWxzbyB1c2Ug dGhlIGhvcml6b250YWwgYWR2YW5jZSBhcyBvcHBvc2VkIHRvCisgICAgICAgIHRoZSB2ZXJ0aWNh bCBhZHZhbmNlLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBl bmRPUzJUYWJsZSk6IFNhdmUgdGhlIHVuaXRzUGVyRW0gbG9jYWxseSB0byBzYXZlIGEgY29uZGl0 aW9uYWwuCisgICAgICAgIEFsc28gaWYgdGhlIGF2ZXJhZ2UgYWR2YW5jZSBpc24ndCBmb3VuZCBp biB0aGUgZm9udCwgdXNlIHRoZSBtaXNzaW5nIGdseXBoJ3MgYWR2YW5jZS4gSWYgdGhlcmUgaXMg bm8KKyAgICAgICAgbWlzc2luZyBnbHlwaCwgYmFpbCBhbmQgdXNlIHRoZSB1bml0c1BlckVtLgor ICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWT1JHVGFibGUp OiBJZiB0aGUgZGVmYXVsdCB2ZXJ0aWNhbCBvcmlnaW4gaXNuJ3QgZm91bmQgaW4gdGhlCisgICAg ICAgIGZvbnQsIHVzZSB0aGUgbWlzc2luZyBnbHlwaHMncyB2ZXJ0aWNhbCBvcmlnaW4uIElmIHRo ZXJlIGlzIG5vIG1pc3NpbmcgZ2x5cGgsIGJhaWwgYW5kIHVzZSAwLgorICAgICAgICAoV2ViQ29y ZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWSEVBVGFibGUpOiBQYXJhbGxlbCBvZiAn aGhlYScgdGFibGUsIGV4Y2VwdCBmb3IgdmVydGljYWwgaW5mby4KKyAgICAgICAgKFdlYkNvcmU6 OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kVk1UWFRhYmxlKTogUGFyYWxsZWwgb2YgJ2ht dHgnIHRhYmxlLCBleGNlcHQgZm9yIHZlcnRpY2FsIGluZm8uCisgICAgICAgIChXZWJDb3JlOjpT VkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEtlcm5pbmdIZWxwZXJGaWVsZHMpOiBDb21wdXRl cyBhbmQgYXBwZW5kcyA0IGZpZWxkcyB0aGF0IGZvbnQKKyAgICAgICAgcGFyc2VycyBuZWVkIGlu IG9yZGVyIHRvIGRvIGEgYmluYXJ5IHNlYXJjaCBvbiB0aGUga2VybiByZWNvcmRzLgorICAgICAg ICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjphZGRDb2RlcG9pbnRSYW5nZXMpOiBG b3IgZWFjaCBjb2RlcG9pbnQgaW4gdGhlIHJhbmdlcywgbG9vayB1cCBpdHMKKyAgICAgICAgcmVw cmVzZW50YXRpdmUgZ2x5cGggYW5kIGFwcGVuZCBpdCB0byBhIHNldC4KKyAgICAgICAgKFdlYkNv cmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YWRkQ29kZXBvaW50cyk6IEZvciBlYWNoIGNvZGVw b2ludCBpbiB0aGUgcmFuZ2UsIGxvb2sgdXAgaXRzCisgICAgICAgIHJlcHJlc2VudGF0aXZlIGds eXBoIGFuZCBhcHBlbmQgaXQgdG8gYSBzZXQuCisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZv bnRDb252ZXJ0ZXI6OmFkZEdseXBoTmFtZXMpOiBGb3IgZWFjaCBnbHlwaCBuYW1lLCBsb29rIHVw IGl0cyByZXByZXNlbnRhdGl2ZSBnbHlwaAorICAgICAgICBhbmQgYXBwZW5kIGl0IHRvIGEgc2V0 LgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpjb21wdXRlS2Vybmlu Z0RhdGEpOiBDYWxsIFNWRypLZXJuRWxlbWVudDo6YnVpbGQqS2VybmluZ1BhaXIoKSBhbmQKKyAg ICAgICAgaXRlcmF0ZSB0aHJvdWdoIGFsbCB0aGUgZGF0YSBpdCByZXR1cm5lZCwgYnVpbGRpbmcg dXAgcmVjb3JkcyBpbnRvIGEgVmVjdG9yLgorICAgICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250 Q29udmVydGVyOjphcHBlbmRLRVJOVGFibGUpOiBHbyB0aHJvdWdoIHRoZSB2ZWN0b3IgdGhhdCBj b21wdXRlS2VybmluZ0RhdGEoKQorICAgICAgICByZXR1cm5lZCBhbmQgYWN0dWFsbHkgd3JpdGUg b3V0IHRoZSB0d28gc3VidGFibGVzLiBPbmUgaXMgZm9yIGhvcml6b250YWwga2VybmluZyBhbmQg dGhlIG90aGVyIGlzIGZvcgorICAgICAgICB2ZXJ0aWNhbCBrZXJuaW5nLgorICAgICAgICAoV2Vi Q29yZTo6Q0ZGQnVpbGRlcjo6Q0ZGQnVpbGRlcik6IFVzZSB0aGUgcG9zaXRpb24gb2YgdGhlIGds eXBoIG9yaWdpbiB0byBwZXJmb3JtIHRoZSBpbml0aWFsIG1vdmV0bworICAgICAgICBjb21tYW5k LgorICAgICAgICAoV2ViQ29yZTo6dHJhbnNjb2RlR2x5cGhQYXRocyk6IEdldCB0aGUgZ2x5cGgn cyBvcmlnaW4gYW5kIHBhc3MgaXQgdG8gdGhlIENGRkJ1aWxkZXIuCisgICAgICAgIChXZWJDb3Jl OjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEdseXBoRGF0YSk6IFRlbXBsYXRlZCBvdmVy bG9hZGluZyBzbyB0aGF0IHRoZSBtaXNzaW5nIGdseXBoCisgICAgICAgIGdldHMgYSBudWxsIFNW R0dseXBoRWxlbWVudCBwb2ludGVyIGJ1dCB0aGUgcmVzdCBvZiB0aGUgZ2x5cGhzIGdldCBhIG5v bi1udWxsIG9uZS4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1RvT1RGRm9udENvbnZlcnRlcjo6cHJv Y2Vzc0dseXBoRWxlbWVudCk6IENhbGxlZCBvbiBib3RoIFNWR0dseXBoRWxlbWVudHMgYW5kCisg ICAgICAgIFNWR01pc3NpbmdHbHlwaEVsZW1lbnRzLCB0aGlzIHB1bGxzIG91dCBpbmZvcm1hdGlv biBmcm9tIHRoZSBlbGVtZW50IGFuZCBjb21wdXRzIGl0cyBwYXRoIGluZm9ybWF0aW9uLgorICAg ICAgICAoV2ViQ29yZTo6U1ZHVG9PVEZGb250Q29udmVydGVyOjpTVkdUb09URkZvbnRDb252ZXJ0 ZXIpOiBVc2UgdGhlIG5ldyB0ZW1wbGF0ZWQgdmVyc2lvbiBvZgorICAgICAgICBwcm9jZXNzR2x5 cGhFbGVtZW50IHNvIHdlIGNhbiBnZXQgdGhlIHNhbWUgZ2x5cGggcGFyc2luZyBiZWhhdmlvciBv biBTVkdNaXNzaW5nR2x5cGhFbGVtZW50cy4gSW4KKyAgICAgICAgYWRkaXRpb24sIHBvcHVsYXRl IHR3byBtYXBzIGZvciB0aGUga2VybmluZyB0YWJsZSBjcmVhdGlvbiBmdW5jdGlvbiB0byB1c2Uu CisgICAgICAgIChXZWJDb3JlOjpTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmNvbnZlcnRTVkdUb09U RkZvbnQpOiBBcHBlbmQgbmV3IHRhYmxlcy4KKyAgICAgICAgKiBzdmcvU1ZHVktlcm5FbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1ZLZXJuRWxlbWVudDo6YnVpbGRWZXJ0aWNhbEtl cm5pbmdQYWlyKTogUmVmYWN0b3IgdG8gYWxsb3cgZm9yIGludGVybWVkaWF0ZSBkYXRhIHRvIGJl CisgICAgICAgIHJldHVybmVkLCB3aGljaCB0aGUgU1ZHIC0+IE9URiBmb250IGNvbnZlcnRlciBj YW4gdXNlLgorICAgICAgICAqIHN2Zy9TVkdWS2VybkVsZW1lbnQuaDogTmV3IHNpZ25hdHVyZSBm b3IgYnVpbGRWZXJ0aWNhbEtlcm5pbmdQYWlyKCkuCisKIDIwMTQtMDktMTcgIE15bGVzIEMuIE1h eGZpZWxkICA8bW1heGZpZWxkQGFwcGxlLmNvbT4KIAogICAgICAgICBUZXh0IGxhaWQgb3V0IHdp dGggdGhlIFNWRyAtPiBPVEYgZm9udCBjb252ZXJ0ZXIgZG9lcyBub3QgaGF2ZSB0aGUgc2FtZSBt ZXRyaWNzIGFzIHdpdGggdGhlIFNWRyBmb250IGNvZGUgcGF0aApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvc3ZnL1NWR0ZvbnRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdG b250RWxlbWVudC5jcHAKaW5kZXggMTI4YTFiMWViN2FlODM3MGRmZDMxYWQ0MDQ4M2VhYTQzNjdm YTM0My4uOGUyMGQwMGNmNTQ0MDA5NTMyY2E1ZDUyODFmZDgxY2Q3OGMyYWIzYiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZvbnRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHRm9udEVsZW1lbnQuY3BwCkBAIC0xMzMsMTAgKzEzMywxNCBAQCB2b2lkIFNW R0ZvbnRFbGVtZW50OjplbnN1cmVHbHlwaENhY2hlKCkKICAgICAgICAgICAgICAgICBsaWdhdHVy ZXMuYXBwZW5kKHVuaWNvZGUuc3RyaW5nKCkpOwogICAgICAgICB9IGVsc2UgaWYgKGlzU1ZHSEtl cm5FbGVtZW50KGNoaWxkKSkgewogICAgICAgICAgICAgU1ZHSEtlcm5FbGVtZW50JiBoa2VybiA9 IHRvU1ZHSEtlcm5FbGVtZW50KGNoaWxkKTsKLSAgICAgICAgICAgIGhrZXJuLmJ1aWxkSG9yaXpv bnRhbEtlcm5pbmdQYWlyKG1faG9yaXpvbnRhbEtlcm5pbmdNYXApOworICAgICAgICAgICAgU1ZH S2VybmluZ1BhaXIga2VybmluZ1BhaXI7CisgICAgICAgICAgICBpZiAoaGtlcm4uYnVpbGRIb3Jp em9udGFsS2VybmluZ1BhaXIoa2VybmluZ1BhaXIpKQorICAgICAgICAgICAgICAgIG1faG9yaXpv bnRhbEtlcm5pbmdNYXAuaW5zZXJ0KGtlcm5pbmdQYWlyKTsKICAgICAgICAgfSBlbHNlIGlmIChp c1NWR1ZLZXJuRWxlbWVudChjaGlsZCkpIHsKICAgICAgICAgICAgIFNWR1ZLZXJuRWxlbWVudCYg dmtlcm4gPSB0b1NWR1ZLZXJuRWxlbWVudChjaGlsZCk7Ci0gICAgICAgICAgICB2a2Vybi5idWls ZFZlcnRpY2FsS2VybmluZ1BhaXIobV92ZXJ0aWNhbEtlcm5pbmdNYXApOworICAgICAgICAgICAg U1ZHS2VybmluZ1BhaXIga2VybmluZ1BhaXI7CisgICAgICAgICAgICBpZiAodmtlcm4uYnVpbGRW ZXJ0aWNhbEtlcm5pbmdQYWlyKGtlcm5pbmdQYWlyKSkKKyAgICAgICAgICAgICAgICBtX3ZlcnRp Y2FsS2VybmluZ01hcC5pbnNlcnQoa2VybmluZ1BhaXIpOwogICAgICAgICB9IGVsc2UgaWYgKGlz U1ZHTWlzc2luZ0dseXBoRWxlbWVudChjaGlsZCkgJiYgIWZpcnN0TWlzc2luZ0dseXBoRWxlbWVu dCkKICAgICAgICAgICAgIGZpcnN0TWlzc2luZ0dseXBoRWxlbWVudCA9ICZ0b1NWR01pc3NpbmdH bHlwaEVsZW1lbnQoY2hpbGQpOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdIS2VybkVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0hLZXJuRWxlbWVu dC5jcHAKaW5kZXggMTY4ODQ4N2E4MDNhMmQxYWRhMWM1M2EyMGRiZGZmYTM5NTQzNWNlNi4uMGMy MmE3N2I5YzI2YmI5ZmNiNDc0M2Q4YjFiMGQzZjE3YmM1YjFkYyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvc3ZnL1NWR0hLZXJuRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3Zn L1NWR0hLZXJuRWxlbWVudC5jcHAKQEAgLTU5LDIzICs1OSwyNCBAQCB2b2lkIFNWR0hLZXJuRWxl bWVudDo6cmVtb3ZlZEZyb20oQ29udGFpbmVyTm9kZSYgcm9vdFBhcmVudCkKICAgICBTVkdFbGVt ZW50OjpyZW1vdmVkRnJvbShyb290UGFyZW50KTsKIH0KIAotdm9pZCBTVkdIS2VybkVsZW1lbnQ6 OmJ1aWxkSG9yaXpvbnRhbEtlcm5pbmdQYWlyKFNWR0tlcm5pbmdNYXAmIGtlcm5pbmdNYXApCiti b29sIFNWR0hLZXJuRWxlbWVudDo6YnVpbGRIb3Jpem9udGFsS2VybmluZ1BhaXIoU1ZHS2Vybmlu Z1BhaXImIGtlcm5pbmdQYWlyKSBjb25zdAogewogICAgIFN0cmluZyB1MSA9IGZhc3RHZXRBdHRy aWJ1dGUoU1ZHTmFtZXM6OnUxQXR0cik7CiAgICAgU3RyaW5nIGcxID0gZmFzdEdldEF0dHJpYnV0 ZShTVkdOYW1lczo6ZzFBdHRyKTsKICAgICBTdHJpbmcgdTIgPSBmYXN0R2V0QXR0cmlidXRlKFNW R05hbWVzOjp1MkF0dHIpOwogICAgIFN0cmluZyBnMiA9IGZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFt ZXM6OmcyQXR0cik7CiAgICAgaWYgKCh1MS5pc0VtcHR5KCkgJiYgZzEuaXNFbXB0eSgpKSB8fCAo dTIuaXNFbXB0eSgpICYmIGcyLmlzRW1wdHkoKSkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAg cmV0dXJuIGZhbHNlOwogCi0gICAgU1ZHS2VybmluZ1BhaXIga2VybmluZ1BhaXI7CiAgICAgaWYg KHBhcnNlR2x5cGhOYW1lKGcxLCBrZXJuaW5nUGFpci5nbHlwaE5hbWUxKQogICAgICAgICAmJiBw YXJzZUdseXBoTmFtZShnMiwga2VybmluZ1BhaXIuZ2x5cGhOYW1lMikKICAgICAgICAgJiYgcGFy c2VLZXJuaW5nVW5pY29kZVN0cmluZyh1MSwga2VybmluZ1BhaXIudW5pY29kZVJhbmdlMSwga2Vy bmluZ1BhaXIudW5pY29kZU5hbWUxKQogICAgICAgICAmJiBwYXJzZUtlcm5pbmdVbmljb2RlU3Ry aW5nKHUyLCBrZXJuaW5nUGFpci51bmljb2RlUmFuZ2UyLCBrZXJuaW5nUGFpci51bmljb2RlTmFt ZTIpKSB7Ci0gICAgICAgIGtlcm5pbmdQYWlyLmtlcm5pbmcgPSBmYXN0R2V0QXR0cmlidXRlKFNW R05hbWVzOjprQXR0cikuc3RyaW5nKCkudG9GbG9hdCgpOwotICAgICAgICBrZXJuaW5nTWFwLmlu c2VydChrZXJuaW5nUGFpcik7CisgICAgICAgIGJvb2wgb2s7CisgICAgICAgIGtlcm5pbmdQYWly Lmtlcm5pbmcgPSBmYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjprQXR0cikuc3RyaW5nKCkudG9G bG9hdCgmb2spOworICAgICAgICByZXR1cm4gb2s7CiAgICAgfQorICAgIHJldHVybiBmYWxzZTsK IH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0hLZXJuRWxlbWVudC5o IGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0hLZXJuRWxlbWVudC5oCmluZGV4IGU1ZDhiNzhmZDM4 M2M4NDMzZWE2ZWQ0NDdkODgyNTViODMwMDc4N2EuLmYwNWNmNzcyYWI1MWZmNjVhNGJmYWI5Yzcy MGJhMjVjNTk1MTgxNGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdIS2VybkVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHSEtlcm5FbGVtZW50LmgKQEAgLTMx LDcgKzMxLDcgQEAgY2xhc3MgU1ZHSEtlcm5FbGVtZW50IGZpbmFsIDogcHVibGljIFNWR0VsZW1l bnQgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNWR0hLZXJuRWxlbWVudD4gY3Jl YXRlKGNvbnN0IFF1YWxpZmllZE5hbWUmLCBEb2N1bWVudCYpOwogCi0gICAgdm9pZCBidWlsZEhv cml6b250YWxLZXJuaW5nUGFpcihTVkdLZXJuaW5nTWFwJik7CisgICAgYm9vbCBidWlsZEhvcml6 b250YWxLZXJuaW5nUGFpcihTVkdLZXJuaW5nUGFpciYpIGNvbnN0OwogCiBwcml2YXRlOgogICAg IFNWR0hLZXJuRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiwgRG9jdW1lbnQmKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUb09URkZvbnRDb252ZXJzaW9uLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdUb09URkZvbnRDb252ZXJzaW9uLmNwcAppbmRleCA2OGIwYjRm MzQ0ZDhhMDcwZGIyOWMzYzUwMDUxZjMzYmFiMTc5M2RkLi44YjNmNmQ5MTQwYTlkMzYwZDgwMjQ5 ZjZiNjQ1YTkzODBmNmYwMjM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVG9P VEZGb250Q29udmVyc2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RvT1RGRm9u dENvbnZlcnNpb24uY3BwCkBAIC0zMSw5ICszMSwxMiBAQAogI2luY2x1ZGUgIlNWR0ZvbnRFbGVt ZW50LmgiCiAjaW5jbHVkZSAiU1ZHRm9udEZhY2VFbGVtZW50LmgiCiAjaW5jbHVkZSAiU1ZHR2x5 cGhFbGVtZW50LmgiCisjaW5jbHVkZSAiU1ZHSEtlcm5FbGVtZW50LmgiCisjaW5jbHVkZSAiU1ZH TWlzc2luZ0dseXBoRWxlbWVudC5oIgogI2luY2x1ZGUgIlNWR1BhdGhCdWlsZGVyLmgiCiAjaW5j bHVkZSAiU1ZHUGF0aFBhcnNlci5oIgogI2luY2x1ZGUgIlNWR1BhdGhTdHJpbmdTb3VyY2UuaCIK KyNpbmNsdWRlICJTVkdWS2VybkVsZW1lbnQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBA IC02NywzMSArNzAsNTkgQEAgcHVibGljOgogCiBwcml2YXRlOgogICAgIHR5cGVkZWYgdWludDE2 X3QgU0lEOyAvLyBTdHJpbmcgSUQKKyAgICB0eXBlZGVmIFVDaGFyIENvZGVwb2ludDsgLy8gRklY TUU6IE9ubHkgc3VwcG9ydCBCTVAgZm9yIG5vdwogICAgIHN0cnVjdCBHbHlwaERhdGEgewotICAg ICAgICBHbHlwaERhdGEoVmVjdG9yPGNoYXI+IGNoYXJTdHJpbmcsIGNvbnN0IFNWR0dseXBoRWxl bWVudCogZ2x5cGhFbGVtZW50LCBmbG9hdCBhZHZhbmNlLCBGbG9hdFJlY3QgYm91bmRpbmdCb3gs IHVpbnQxNl90IGNvZGVwb2ludCkKKyAgICAgICAgR2x5cGhEYXRhKFZlY3RvcjxjaGFyPiBjaGFy U3RyaW5nLCBjb25zdCBTVkdHbHlwaEVsZW1lbnQqIGdseXBoRWxlbWVudCwgZmxvYXQgaG9yaXpv bnRhbEFkdmFuY2UsIGZsb2F0IHZlcnRpY2FsQWR2YW5jZSwgRmxvYXRSZWN0IGJvdW5kaW5nQm94 LCBDb2RlcG9pbnQgY29kZXBvaW50KQogICAgICAgICAgICAgOiBib3VuZGluZ0JveChib3VuZGlu Z0JveCkKICAgICAgICAgICAgICwgY2hhclN0cmluZyhjaGFyU3RyaW5nKQogICAgICAgICAgICAg LCBnbHlwaEVsZW1lbnQoZ2x5cGhFbGVtZW50KQotICAgICAgICAgICAgLCBhZHZhbmNlKGFkdmFu Y2UpCisgICAgICAgICAgICAsIGhvcml6b250YWxBZHZhbmNlKGhvcml6b250YWxBZHZhbmNlKQor ICAgICAgICAgICAgLCB2ZXJ0aWNhbEFkdmFuY2UodmVydGljYWxBZHZhbmNlKQogICAgICAgICAg ICAgLCBjb2RlcG9pbnQoY29kZXBvaW50KQogICAgICAgICB7CiAgICAgICAgIH0KICAgICAgICAg RmxvYXRSZWN0IGJvdW5kaW5nQm94OwogICAgICAgICBWZWN0b3I8Y2hhcj4gY2hhclN0cmluZzsK ICAgICAgICAgY29uc3QgU1ZHR2x5cGhFbGVtZW50KiBnbHlwaEVsZW1lbnQ7Ci0gICAgICAgIGZs b2F0IGFkdmFuY2U7Ci0gICAgICAgIHVpbnQxNl90IGNvZGVwb2ludDsKKyAgICAgICAgZmxvYXQg aG9yaXpvbnRhbEFkdmFuY2U7CisgICAgICAgIGZsb2F0IHZlcnRpY2FsQWR2YW5jZTsKKyAgICAg ICAgQ29kZXBvaW50IGNvZGVwb2ludDsKKyAgICB9OworCisgICAgc3RydWN0IEtlcm5pbmdEYXRh IHsKKyAgICAgICAgS2VybmluZ0RhdGEodWludDE2X3QgZ2x5cGgxLCB1aW50MTZfdCBnbHlwaDIs IGludDE2X3QgYWRqdXN0bWVudCkKKyAgICAgICAgICAgIDogZ2x5cGgxKGdseXBoMSkKKyAgICAg ICAgICAgICwgZ2x5cGgyKGdseXBoMikKKyAgICAgICAgICAgICwgYWRqdXN0bWVudChhZGp1c3Rt ZW50KQorICAgICAgICB7CisgICAgICAgIH0KKyAgICAgICAgYm9vbCBvcGVyYXRvcjwoY29uc3Qg S2VybmluZ0RhdGEmIG90aGVyKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4g KHN0YXRpY19jYXN0PHVpbnQzMl90PihnbHlwaDEpIDw8IDE2IHwgZ2x5cGgyKSA8IChzdGF0aWNf Y2FzdDx1aW50MzJfdD4ob3RoZXIuZ2x5cGgxKSA8PCAxNiB8IG90aGVyLmdseXBoMik7CisgICAg ICAgIH0KKyAgICAgICAgdWludDE2X3QgZ2x5cGgxOworICAgICAgICB1aW50MTZfdCBnbHlwaDI7 CisgICAgICAgIGludDE2X3QgYWRqdXN0bWVudDsKICAgICB9OwogCiAgICAgc3RhdGljIGNvbnN0 IHNpemVfdCBrU05GVEhlYWRlclNpemUgPSAxMjsKICAgICBzdGF0aWMgY29uc3Qgc2l6ZV90IGtE aXJlY3RvcnlFbnRyeVNpemUgPSAxNjsKIAorCisgICAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+Cisg ICAgdm9pZCBhcHBlbmRHbHlwaERhdGEoY29uc3QgVmVjdG9yPGNoYXI+JiBwYXRoLCBjb25zdCBU KiBlbGVtZW50LCBmbG9hdCBob3Jpem9udGFsQWR2YW5jZSwgZmxvYXQgdmVydGljYWxBZHZhbmNl LCBjb25zdCBGbG9hdFJlY3QmIGJvdW5kaW5nQm94LCBDb2RlcG9pbnQpOworICAgIHRlbXBsYXRl IDx0eXBlbmFtZSBUPgorICAgIHZvaWQgcHJvY2Vzc0dseXBoRWxlbWVudChjb25zdCBUJiBlbGVt ZW50LCBmbG9hdCBkZWZhdWx0SG9yaXpvbnRhbEFkdmFuY2UsIGZsb2F0IGRlZmF1bHRWZXJ0aWNh bEFkdmFuY2UsIENvZGVwb2ludCwgYm9vbCYgaW5pdGlhbEdseXBoKTsKKwogICAgIHR5cGVkZWYg dm9pZCAoU1ZHVG9PVEZGb250Q29udmVydGVyOjoqRm9udEFwcGVuZGluZ0Z1bmN0aW9uKShWZWN0 b3I8Y2hhcj4gJikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmRUYWJsZShjb25zdCBjaGFyIGlkZW50 aWZpZXJbNF0sIFZlY3RvcjxjaGFyPiYsIEZvbnRBcHBlbmRpbmdGdW5jdGlvbik7CiAgICAgdm9p ZCBhcHBlbmRDTUFQVGFibGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmRI RUFEVGFibGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmRISEVBVGFibGUo VmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmRITVRYVGFibGUoVmVjdG9yPGNo YXI+JikgY29uc3Q7CisgICAgdm9pZCBhcHBlbmRWSEVBVGFibGUoVmVjdG9yPGNoYXI+JikgY29u c3Q7CisgICAgdm9pZCBhcHBlbmRWTVRYVGFibGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CisgICAg dm9pZCBhcHBlbmRLRVJOVGFibGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBl bmRNQVhQVGFibGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmROQU1FVGFi bGUoVmVjdG9yPGNoYXI+JikgY29uc3Q7CiAgICAgdm9pZCBhcHBlbmRPUzJUYWJsZShWZWN0b3I8 Y2hhcj4mKSBjb25zdDsKQEAgLTk5LDEzICsxMzAsMjUgQEAgcHJpdmF0ZToKICAgICB2b2lkIGFw cGVuZENGRlRhYmxlKFZlY3RvcjxjaGFyPiYpIGNvbnN0OwogICAgIHZvaWQgYXBwZW5kVk9SR1Rh YmxlKFZlY3RvcjxjaGFyPiYpIGNvbnN0OwogCisgICAgdm9pZCBhZGRDb2RlcG9pbnRSYW5nZXMo Y29uc3QgVW5pY29kZVJhbmdlcyYsIEhhc2hTZXQ8dWludDE2X3Q+JiBnbHlwaFNldCkgY29uc3Q7 CisgICAgdm9pZCBhZGRDb2RlcG9pbnRzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYgY29kZXBvaW50 cywgSGFzaFNldDx1aW50MTZfdD4mIGdseXBoU2V0KSBjb25zdDsKKyAgICB2b2lkIGFkZEdseXBo TmFtZXMoY29uc3QgSGFzaFNldDxTdHJpbmc+JiBnbHlwaE5hbWVzLCBIYXNoU2V0PHVpbnQxNl90 PiYgZ2x5cGhTZXQpIGNvbnN0OworICAgIHZvaWQgYXBwZW5kS2VybmluZ0hlbHBlckZpZWxkcyhW ZWN0b3I8Y2hhcj4mIHJlc3VsdCwgY29uc3QgVmVjdG9yPEtlcm5pbmdEYXRhPiYpIGNvbnN0Owor ICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBUPgorICAgIFZlY3RvcjxLZXJuaW5nRGF0YT4gY29tcHV0 ZUtlcm5pbmdEYXRhKGJvb2wgKFQ6OipidWlsZEtlcm5pbmdQYWlyKShTVkdLZXJuaW5nUGFpciYp IGNvbnN0KSBjb25zdDsKKwogICAgIFZlY3RvcjxHbHlwaERhdGE+IG1fZ2x5cGhzOworICAgIEhh c2hNYXA8U3RyaW5nLCBHbHlwaD4gbV9nbHlwaE5hbWVUb0luZGV4TWFwOyAvLyBTVkcgMS4xOiAi SXQgaXMgcmVjb21tZW5kZWQgdGhhdCBnbHlwaCBuYW1lcyBiZSB1bmlxdWUgd2l0aGluIGEgZm9u dC4iCisgICAgSGFzaE1hcDxDb2RlcG9pbnQsIEdseXBoPiBtX2NvZGVwb2ludFRvSW5kZXhNYXA7 IC8vIEZJWE1FOiBUaGVyZSBtaWdodCBiZSBtYW55IGdseXBocyB0aGF0IG1hcCB0byBhIHNpbmds ZSBjb2RlcG9pbnQKICAgICBGbG9hdFJlY3QgbV9ib3VuZGluZ0JveDsKICAgICBjb25zdCBTVkdG b250RWxlbWVudCYgbV9mb250RWxlbWVudDsKICAgICBjb25zdCBTVkdGb250RmFjZUVsZW1lbnQq IG1fZm9udEZhY2VFbGVtZW50OworICAgIGNvbnN0IFNWR01pc3NpbmdHbHlwaEVsZW1lbnQqIG1f bWlzc2luZ0dseXBoRWxlbWVudDsKICAgICBTdHJpbmcgbV9mb250RmFtaWx5OwogICAgIGZsb2F0 IG1fYWR2YW5jZVdpZHRoTWF4OworICAgIGZsb2F0IG1fYWR2YW5jZUhlaWdodE1heDsKICAgICBm bG9hdCBtX21pblJpZ2h0U2lkZUJlYXJpbmc7CisgICAgdW5zaWduZWQgbV91bml0c1BlckVtOwog ICAgIGludCBtX3RhYmxlc0FwcGVuZGVkQ291bnQ7CiAgICAgY2hhciBtX3dlaWdodDsKICAgICBi b29sIG1faXRhbGljOwpAQCAtMTc1LDkgKzIxOCw3IEBAIHZvaWQgU1ZHVG9PVEZGb250Q29udmVy dGVyOjphcHBlbmRIRUFEVGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0CiAgICAgcmVz dWx0LmFwcGVuZCgtMHgwQik7IC8vIFdyYXBhcm91bmQKICAgICB3cml0ZTE2KHJlc3VsdCwgKDEg PDwgOSkgfCAxKTsKIAotICAgIHVpbnQxNl90IHVuaXRzUGVyRW0gPSBtX2ZvbnRGYWNlRWxlbWVu dCA/IG1fZm9udEZhY2VFbGVtZW50LT51bml0c1BlckVtKCkgOiAwOwotCi0gICAgd3JpdGUxNihy ZXN1bHQsIHVuaXRzUGVyRW0pOworICAgIHdyaXRlMTYocmVzdWx0LCBtX3VuaXRzUGVyRW0pOwog ICAgIHdyaXRlMzIocmVzdWx0LCAwKTsgLy8gRmlyc3QgaGFsZiBvZiBjcmVhdGlvbiBkYXRlCiAg ICAgd3JpdGUzMihyZXN1bHQsIDApOyAvLyBMYXN0IGhhbGYgb2YgY3JlYXRpb24gZGF0ZQogICAg IHdyaXRlMzIocmVzdWx0LCAwKTsgLy8gRmlyc3QgaGFsZiBvZiBtb2RpZmljYXRpb24gZGF0ZQpA QCAtMjA0LDExICsyNDUsOSBAQCBzdGF0aWMgaW5saW5lIFQxIGNsYW1wVG8oVDIgeCkKIAogdm9p ZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEhIRUFUYWJsZShWZWN0b3I8Y2hhcj4mIHJl c3VsdCkgY29uc3QKIHsKLSAgICB1aW50MTZfdCB1bml0c1BlckVtID0gMDsKICAgICBpbnQxNl90 IGFzY2VudCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50MTZfdD46Om1heCgpOwogICAgIGludDE2 X3QgZGVzY2VudCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50MTZfdD46Om1heCgpOwogICAgIGlm IChtX2ZvbnRGYWNlRWxlbWVudCkgewotICAgICAgICB1bml0c1BlckVtID0gbV9mb250RmFjZUVs ZW1lbnQtPnVuaXRzUGVyRW0oKTsKICAgICAgICAgYXNjZW50ID0gbV9mb250RmFjZUVsZW1lbnQt PmFzY2VudCgpOwogICAgICAgICBkZXNjZW50ID0gbV9mb250RmFjZUVsZW1lbnQtPmRlc2NlbnQo KTsKICAgICB9CkBAIC0yMjcsNyArMjY2LDcgQEAgdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6 OmFwcGVuZEhIRUFUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAgICB3cml0ZTE2 KHJlc3VsdCwgZGVzY2VudCk7CiAgICAgLy8gV2ViS2l0J3MgU1ZHIGNvZGVwYXRoIGhhcmRjb2Rl cyB0aGUgbGluZSBnYXAgdG8gYmUgMS8xMHRoIG9mIHRoZSBmb250IHNpemUgKHNlZSByMjk3MTkp LiBNYXRjaGluZyB0aGF0CiAgICAgLy8gYWxsb3dzIHVzIHRvIGhhdmUgY29uc2lzdGVudCByZW5k ZXJpbmdzIGJldHdlZW4gdGhlIHR3byBwYXRocy4KLSAgICB3cml0ZTE2KHJlc3VsdCwgdW5pdHNQ ZXJFbSAvIDEwKTsgLy8gTGluZSBnYXAKKyAgICB3cml0ZTE2KHJlc3VsdCwgbV91bml0c1BlckVt IC8gMTApOyAvLyBMaW5lIGdhcAogICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPHVpbnQxNl90 LCBmbG9hdD4obV9hZHZhbmNlV2lkdGhNYXgpKTsKICAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBU bzxpbnQxNl90LCBmbG9hdD4obV9ib3VuZGluZ0JveC54KCkpKTsgLy8gTWluaW11bSBsZWZ0IHNp ZGUgYmVhcmluZwogICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPGludDE2X3QsIGZsb2F0Piht X21pblJpZ2h0U2lkZUJlYXJpbmcpKTsgLy8gTWluaW11bSByaWdodCBzaWRlIGJlYXJpbmcKQEAg LTI0NSw3ICsyODQsNyBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEhFQVRh YmxlKFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogdm9pZCBTVkdUb09URkZvbnRDb252ZXJ0 ZXI6OmFwcGVuZEhNVFhUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKIHsKICAgICBm b3IgKGNvbnN0IGF1dG8mIGdseXBoIDogbV9nbHlwaHMpIHsKLSAgICAgICAgd3JpdGUxNihyZXN1 bHQsIGNsYW1wVG88dWludDE2X3QsIGZsb2F0PihnbHlwaC5hZHZhbmNlKSk7CisgICAgICAgIHdy aXRlMTYocmVzdWx0LCBjbGFtcFRvPHVpbnQxNl90LCBmbG9hdD4oZ2x5cGguaG9yaXpvbnRhbEFk dmFuY2UpKTsKICAgICAgICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdCwgZmxvYXQ+ KGdseXBoLmJvdW5kaW5nQm94LngoKSkpOwogICAgIH0KIH0KQEAgLTI4OCwxNCArMzI3LDE4IEBA IHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmROQU1FVGFibGUoVmVjdG9yPGNoYXI+ JiByZXN1bHQpIGNvbnN0CiAKIHZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRPUzJU YWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKIHsKLSAgICAvLyBGSVhNRTogV2UgY2Fu IGxvb2sgYXQgdGhlIG1pc3NpbmcgZ2x5cGggaW5mbyBmb3IgdGhpcwotICAgIHVpbnQxNl90IHVu aXRzUGVyRW0gPSBtX2ZvbnRGYWNlRWxlbWVudCA/IG1fZm9udEZhY2VFbGVtZW50LT51bml0c1Bl ckVtKCkgOiAwOwotICAgIGludDE2X3QgYXZlcmFnZUFkdmFuY2UgPSB1bml0c1BlckVtIC8gMjsK KyAgICBpbnQxNl90IGF2ZXJhZ2VBZHZhbmNlID0gbV91bml0c1BlckVtOwogICAgIGF1dG8mIGF0 dHJpYnV0ZSA9IG1fZm9udEVsZW1lbnQuZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpf YWR2X3hBdHRyKTsKLSAgICBib29sIG9rID0gdHJ1ZTsKKyAgICBib29sIG9rOwogICAgIGludCB2 YWx1ZSA9IGF0dHJpYnV0ZS50b0ludCgmb2spOwogICAgIGlmIChvaykKICAgICAgICAgYXZlcmFn ZUFkdmFuY2UgPSBjbGFtcFRvPGludDE2X3QsIGludD4odmFsdWUpOworICAgIGVsc2UgaWYgKG1f bWlzc2luZ0dseXBoRWxlbWVudCkgeworICAgICAgICBhdXRvJiBtaXNzaW5nR2x5cGhBZHZhbmNl QXR0cmlidXRlID0gbV9taXNzaW5nR2x5cGhFbGVtZW50LT5mYXN0R2V0QXR0cmlidXRlKFNWR05h bWVzOjpob3Jpel9hZHZfeEF0dHIpOworICAgICAgICBpbnQgdmFsdWUgPSBtaXNzaW5nR2x5cGhB ZHZhbmNlQXR0cmlidXRlLnRvSW50KCZvayk7CisgICAgICAgIGlmIChvaykKKyAgICAgICAgICAg IGF2ZXJhZ2VBZHZhbmNlID0gY2xhbXBUbzxpbnQxNl90LCBpbnQ+KHZhbHVlKTsKKyAgICB9CiAK ICAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnNpb24KICAgICB3cml0ZTE2KHJlc3VsdCwg YXZlcmFnZUFkdmFuY2UpOwpAQCAtNDk5LDE1ICs1NDIsMTAgQEAgdm9pZCBTVkdUb09URkZvbnRD b252ZXJ0ZXI6OmFwcGVuZFZPUkdUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QKICAg ICB3cml0ZTE2KHJlc3VsdCwgMSk7IC8vIE1ham9yIHZlcnNpb24KICAgICB3cml0ZTE2KHJlc3Vs dCwgMCk7IC8vIE1pbm9yIHZlcnNpb24KIAotICAgIC8vIEZJWE1FOiBXZSBjYW4gdXNlIHRoZSBt aXNzaW5nIGdseXBoIGluZm8gZm9yIHRoaXMKLSAgICBpbnQxNl90IGRlZmF1bHRWZXJ0aWNhbE9y aWdpblkgPSAwOwotICAgIGF1dG8mIGF0dHJpYnV0ZSA9IG1fZm9udEVsZW1lbnQuZmFzdEdldEF0 dHJpYnV0ZShTVkdOYW1lczo6dmVydF9vcmlnaW5feUF0dHIpOwotICAgIGlmIChhdHRyaWJ1dGUg IT0gbnVsbEF0b20gJiYgYXR0cmlidXRlLmlzOEJpdCgpKSB7Ci0gICAgICAgIGJvb2wgb2s7Ci0g ICAgICAgIGludCB2ZXJ0aWNhbE9yaWdpblkgPSBhdHRyaWJ1dGUudG9JbnQoJm9rKTsKLSAgICAg ICAgaWYgKG9rICYmIHZlcnRpY2FsT3JpZ2luWSkKLSAgICAgICAgICAgIGRlZmF1bHRWZXJ0aWNh bE9yaWdpblkgPSB2ZXJ0aWNhbE9yaWdpblk7Ci0gICAgfQorICAgIGJvb2wgb2s7CisgICAgaW50 MTZfdCBkZWZhdWx0VmVydGljYWxPcmlnaW5ZID0gY2xhbXBUbzxpbnQxNl90PihtX2ZvbnRFbGVt ZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OnZlcnRfb3JpZ2luX3lBdHRyKS50b0ludCgm b2spKTsKKyAgICBpZiAoIW9rICYmIG1fbWlzc2luZ0dseXBoRWxlbWVudCkKKyAgICAgICAgZGVm YXVsdFZlcnRpY2FsT3JpZ2luWSA9IGNsYW1wVG88aW50MTZfdD4obV9taXNzaW5nR2x5cGhFbGVt ZW50LT5mYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjp2ZXJ0X29yaWdpbl95QXR0cikudG9JbnQo Jm9rKSk7CiAgICAgd3JpdGUxNihyZXN1bHQsIGRlZmF1bHRWZXJ0aWNhbE9yaWdpblkpOwogCiAg ICAgVmVjdG9yPHN0ZDo6cGFpcjx1aW50MTZfdCwgaW50MTZfdD4+IG9yaWdpbnM7CkBAIC01MzAs NiArNTY4LDE4MCBAQCB2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kVk9SR1RhYmxl KFZlY3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAogICAgIH0KIH0KIAordm9pZCBTVkdUb09URkZv bnRDb252ZXJ0ZXI6OmFwcGVuZFZIRUFUYWJsZShWZWN0b3I8Y2hhcj4mIHJlc3VsdCkgY29uc3QK K3sKKyAgICB3cml0ZTMyKHJlc3VsdCwgMHgwMDAxMTAwMCk7IC8vIFZlcnNpb24KKyAgICB3cml0 ZTE2KHJlc3VsdCwgbV91bml0c1BlckVtIC8gMik7IC8vIFZlcnRpY2FsIHR5cG9ncmFwaGljIGFz Y2VuZGVyICh2ZXJ0aWNhbCBiYXNlbGluZSB0byB0aGUgcmlnaHQpCisgICAgd3JpdGUxNihyZXN1 bHQsIGNsYW1wVG88aW50MTZfdD4oLXN0YXRpY19jYXN0PGxvbmc+KG1fdW5pdHNQZXJFbSAvIDIp KSk7IC8vIFZlcnRpY2FsIHR5cG9ncmFwaGljIGRlc2NlbmRlcgorICAgIHdyaXRlMTYocmVzdWx0 LCBtX3VuaXRzUGVyRW0gLyAxMCk7IC8vIFZlcnRpY2FsIHR5cG9ncmFwaGljIGxpbmUgZ2FwCisg ICAgd3JpdGUxNihyZXN1bHQsIGNsYW1wVG88aW50MTZfdCwgZmxvYXQ+KG1fYWR2YW5jZUhlaWdo dE1heCkpOworICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPGludDE2X3QsIGZsb2F0PihtX3Vu aXRzUGVyRW0gLSBtX2JvdW5kaW5nQm94Lm1heFkoKSkpOyAvLyBNaW5pbXVtIHRvcCBzaWRlIGJl YXJpbmcKKyAgICB3cml0ZTE2KHJlc3VsdCwgY2xhbXBUbzxpbnQxNl90LCBmbG9hdD4obV9ib3Vu ZGluZ0JveC55KCkpKTsgLy8gTWluaW11bSBib3R0b20gc2lkZSBiZWFyaW5nCisgICAgd3JpdGUx NihyZXN1bHQsIGNsYW1wVG88aW50MTZfdCwgZmxvYXQ+KG1fdW5pdHNQZXJFbSAtIG1fYm91bmRp bmdCb3gueSgpKSk7IC8vIFkgbWF4aW11bSBleHRlbnQKKyAgICAvLyBXZWJLaXQgZHJhd3MgdGhl IGNhcmV0CisgICAgd3JpdGUxNihyZXN1bHQsIDEpOyAvLyBWZXJ0aWNhbCBjYXJldAorICAgIHdy aXRlMTYocmVzdWx0LCAwKTsgLy8gVmVydGljYWwgY2FyZXQKKyAgICB3cml0ZTE2KHJlc3VsdCwg MCk7IC8vICJTZXQgdmFsdWUgdG8gMCBmb3Igbm9uLXNsYW50ZWQgZm9udHMiCisgICAgd3JpdGUz MihyZXN1bHQsIDApOyAvLyBSZXNlcnZlZAorICAgIHdyaXRlMzIocmVzdWx0LCAwKTsgLy8gUmVz ZXJ2ZWQKKyAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vICJTZXQgdG8gMCIKKyAgICB3cml0ZTE2 KHJlc3VsdCwgbV9nbHlwaHMuc2l6ZSgpKTsgLy8gTnVtYmVyIG9mIGFkdmFuY2UgaGVpZ2h0cyBp biBWTVRYIHRhYmxlCit9CisKK3ZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRWTVRY VGFibGUoVmVjdG9yPGNoYXI+JiByZXN1bHQpIGNvbnN0Cit7CisgICAgZm9yIChjb25zdCBhdXRv JiBnbHlwaCA6IG1fZ2x5cGhzKSB7CisgICAgICAgIHdyaXRlMTYocmVzdWx0LCBjbGFtcFRvPHVp bnQxNl90LCBmbG9hdD4oZ2x5cGgudmVydGljYWxBZHZhbmNlKSk7CisgICAgICAgIHdyaXRlMTYo cmVzdWx0LCBjbGFtcFRvPGludDE2X3QsIGZsb2F0PihtX3VuaXRzUGVyRW0gLSBnbHlwaC5ib3Vu ZGluZ0JveC5tYXhZKCkpKTsgLy8gdG9wIHNpZGUgYmVhcmluZworICAgIH0KK30KKwordm9pZCBT VkdUb09URkZvbnRDb252ZXJ0ZXI6OmFwcGVuZEtlcm5pbmdIZWxwZXJGaWVsZHMoVmVjdG9yPGNo YXI+JiByZXN1bHQsIGNvbnN0IFZlY3RvcjxLZXJuaW5nRGF0YT4mIGtlcm5pbmdEYXRhKSBjb25z dAoreworICAgIHVpbnQxNl90IHJvdW5kZWROdW1LZXJuaW5nUGFpcnMgPSByb3VuZERvd25Ub1Bv d2VyT2ZUd28oa2VybmluZ0RhdGEuc2l6ZSgpKTsKKyAgICB1aW50MTZfdCBzZWFyY2hSYW5nZSA9 IHJvdW5kZWROdW1LZXJuaW5nUGFpcnMgKiA2OworICAgIHVpbnQxNl90IHJhbmdlU2hpZnQgPSAo a2VybmluZ0RhdGEuc2l6ZSgpIC0gcm91bmRlZE51bUtlcm5pbmdQYWlycykgKiA2OworICAgIHVp bnQxNl90IGVudHJ5U2VsZWN0b3IgPSAwOworICAgIHdoaWxlIChyb3VuZGVkTnVtS2VybmluZ1Bh aXJzID4+PSAxKQorICAgICAgICArK2VudHJ5U2VsZWN0b3I7CisKKyAgICB3cml0ZTE2KHJlc3Vs dCwga2VybmluZ0RhdGEuc2l6ZSgpKTsKKyAgICB3cml0ZTE2KHJlc3VsdCwgc2VhcmNoUmFuZ2Up OworICAgIHdyaXRlMTYocmVzdWx0LCBlbnRyeVNlbGVjdG9yKTsKKyAgICB3cml0ZTE2KHJlc3Vs dCwgcmFuZ2VTaGlmdCk7Cit9CisKK3ZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphZGRDb2Rl cG9pbnRSYW5nZXMoY29uc3QgVW5pY29kZVJhbmdlcyYgdW5pY29kZVJhbmdlcywgSGFzaFNldDxH bHlwaD4mIGdseXBoU2V0KSBjb25zdAoreworICAgIGZvciAoYXV0byB1bmljb2RlUmFuZ2UgOiB1 bmljb2RlUmFuZ2VzKSB7CisgICAgICAgIGZvciAoYXV0byBjb2RlcG9pbnQgPSB1bmljb2RlUmFu Z2UuZmlyc3Q7IGNvZGVwb2ludCA8IHVuaWNvZGVSYW5nZS5zZWNvbmQ7ICsrY29kZXBvaW50KSB7 CisgICAgICAgICAgICBpZiAoY29kZXBvaW50ID4gc3RkOjpudW1lcmljX2xpbWl0czxDb2RlcG9p bnQ+OjptYXgoKSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGF1dG8g aW5kZXhJdGVyID0gbV9jb2RlcG9pbnRUb0luZGV4TWFwLmZpbmQoY29kZXBvaW50KTsKKyAgICAg ICAgICAgIGlmIChpbmRleEl0ZXIgIT0gbV9jb2RlcG9pbnRUb0luZGV4TWFwLmVuZCgpKQorICAg ICAgICAgICAgICAgIGdseXBoU2V0LmFkZChpbmRleEl0ZXItPnZhbHVlKTsKKyAgICAgICAgfQor ICAgIH0KK30KKwordm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OmFkZENvZGVwb2ludHMoY29u c3QgSGFzaFNldDxTdHJpbmc+JiBjb2RlcG9pbnRzLCBIYXNoU2V0PEdseXBoPiYgZ2x5cGhTZXQp IGNvbnN0Cit7CisgICAgZm9yIChhdXRvJiBjb2RlcG9pbnQgOiBjb2RlcG9pbnRzKSB7CisgICAg ICAgIC8vIEZJWE1FOiBPbmx5IHN1cHBvcnQgQk1QIGZvciBub3cKKyAgICAgICAgaWYgKGNvZGVw b2ludC5sZW5ndGgoKSA9PSAxICYmIGNvZGVwb2ludC5sZW5ndGgoKSA9PSAxICYmIGNvZGVwb2lu dC5hdCgwKSA8PSBzdGQ6Om51bWVyaWNfbGltaXRzPENvZGVwb2ludD46Om1heCgpKSB7CisgICAg ICAgICAgICBhdXRvIGluZGV4SXRlciA9IG1fY29kZXBvaW50VG9JbmRleE1hcC5maW5kKGNvZGVw b2ludC5hdCgwKSk7CisgICAgICAgICAgICBpZiAoaW5kZXhJdGVyICE9IG1fY29kZXBvaW50VG9J bmRleE1hcC5lbmQoKSkKKyAgICAgICAgICAgICAgICBnbHlwaFNldC5hZGQoaW5kZXhJdGVyLT52 YWx1ZSk7CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVy OjphZGRHbHlwaE5hbWVzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYgZ2x5cGhOYW1lcywgSGFzaFNl dDx1aW50MTZfdD4mIGdseXBoU2V0KSBjb25zdAoreworICAgIGZvciAoYXV0byBnbHlwaE5hbWUg OiBnbHlwaE5hbWVzKSB7CisgICAgICAgIGF1dG8gaW5kZXhJdGVyID0gbV9nbHlwaE5hbWVUb0lu ZGV4TWFwLmZpbmQoZ2x5cGhOYW1lKTsKKyAgICAgICAgaWYgKGluZGV4SXRlciAhPSBtX2dseXBo TmFtZVRvSW5kZXhNYXAuZW5kKCkpCisgICAgICAgICAgICBnbHlwaFNldC5hZGQoaW5kZXhJdGVy LT52YWx1ZSk7CisgICAgfQorfQorCit0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4KK2F1dG8gU1ZHVG9P VEZGb250Q29udmVydGVyOjpjb21wdXRlS2VybmluZ0RhdGEoYm9vbCAoVDo6KmJ1aWxkS2Vybmlu Z1BhaXIpKFNWR0tlcm5pbmdQYWlyJikgY29uc3QpIGNvbnN0IC0+IFZlY3RvcjxLZXJuaW5nRGF0 YT4KK3sKKyAgICBWZWN0b3I8S2VybmluZ0RhdGE+IHJlc3VsdDsKKworICAgIGZvciAoYXV0byYg a2VybkVsZW1lbnQgOiBjaGlsZHJlbk9mVHlwZTxUPihtX2ZvbnRFbGVtZW50KSkgeworICAgICAg ICBTVkdLZXJuaW5nUGFpciBrZXJuaW5nUGFpcjsKKyAgICAgICAgaWYgKChrZXJuRWxlbWVudC4q YnVpbGRLZXJuaW5nUGFpcikoa2VybmluZ1BhaXIpKSB7CisgICAgICAgICAgICBIYXNoU2V0PEds eXBoPiBnbHlwaFNldDE7CisgICAgICAgICAgICBIYXNoU2V0PEdseXBoPiBnbHlwaFNldDI7CisK KyAgICAgICAgICAgIGFkZENvZGVwb2ludFJhbmdlcyhrZXJuaW5nUGFpci51bmljb2RlUmFuZ2Ux LCBnbHlwaFNldDEpOworICAgICAgICAgICAgYWRkQ29kZXBvaW50UmFuZ2VzKGtlcm5pbmdQYWly LnVuaWNvZGVSYW5nZTIsIGdseXBoU2V0Mik7CisgICAgICAgICAgICBhZGRHbHlwaE5hbWVzKGtl cm5pbmdQYWlyLmdseXBoTmFtZTEsIGdseXBoU2V0MSk7CisgICAgICAgICAgICBhZGRHbHlwaE5h bWVzKGtlcm5pbmdQYWlyLmdseXBoTmFtZTIsIGdseXBoU2V0Mik7CisgICAgICAgICAgICBhZGRD b2RlcG9pbnRzKGtlcm5pbmdQYWlyLnVuaWNvZGVOYW1lMSwgZ2x5cGhTZXQxKTsKKyAgICAgICAg ICAgIGFkZENvZGVwb2ludHMoa2VybmluZ1BhaXIudW5pY29kZU5hbWUyLCBnbHlwaFNldDEpOwor CisgICAgICAgICAgICAvLyBGSVhNRTogVXNlIHRhYmxlIGZvcm1hdCAyIHNvIHdlIGRvbid0IGhh dmUgdG8gYXBwZW5kIGVhY2ggb2YgdGhlc2Ugb25lIGJ5IG9uZQorICAgICAgICAgICAgZm9yIChh dXRvIGdseXBoMSA6IGdseXBoU2V0MSkgeworICAgICAgICAgICAgICAgIGZvciAoYXV0byBnbHlw aDIgOiBnbHlwaFNldDIpCisgICAgICAgICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoS2Vybmlu Z0RhdGEoZ2x5cGgxLCBnbHlwaDIsIGNsYW1wVG88aW50MTZfdD4oLWtlcm5pbmdQYWlyLmtlcm5p bmcpKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gcmVz dWx0OworfQorCit2b2lkIFNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kS0VSTlRhYmxlKFZl Y3RvcjxjaGFyPiYgcmVzdWx0KSBjb25zdAoreworICAgIHdyaXRlMTYocmVzdWx0LCAwKTsgLy8g VmVyc2lvbgorICAgIHdyaXRlMTYocmVzdWx0LCAyKTsgLy8gTnVtYmVyIG9mIHN1YnRhYmxlcwor CisjaWYgIUFTU0VSVF9ESVNBQkxFRAorICAgIGF1dG8gc3VidGFibGVzT2Zmc2V0ID0gcmVzdWx0 LnNpemUoKTsKKyNlbmRpZgorCisgICAgLy8gVGFibGUgMQorICAgIHsKKyAgICAgICAgVmVjdG9y PEtlcm5pbmdEYXRhPiBrZXJuaW5nRGF0YSA9IGNvbXB1dGVLZXJuaW5nRGF0YTxTVkdIS2VybkVs ZW1lbnQ+KCZTVkdIS2VybkVsZW1lbnQ6OmJ1aWxkSG9yaXpvbnRhbEtlcm5pbmdQYWlyKTsKKyAg ICAgICAgc3RkOjpzb3J0KGtlcm5pbmdEYXRhLmJlZ2luKCksIGtlcm5pbmdEYXRhLmVuZCgpKTsK KyAgICAgICAgc2l6ZV90IHNpemVPZktlcm5pbmdEYXRhVGFibGUgPSAxNCArIDYgKiBrZXJuaW5n RGF0YS5zaXplKCk7CisgICAgICAgIGlmIChzaXplT2ZLZXJuaW5nRGF0YVRhYmxlID4gc3RkOjpu dW1lcmljX2xpbWl0czx1aW50MTZfdD46Om1heCgpKSB7CisgICAgICAgICAgICBrZXJuaW5nRGF0 YS5jbGVhcigpOworICAgICAgICAgICAgc2l6ZU9mS2VybmluZ0RhdGFUYWJsZSA9IDA7CisgICAg ICAgIH0KKworICAgICAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnNpb24gb2Ygc3VidGFi bGUKKyAgICAgICAgd3JpdGUxNihyZXN1bHQsIHNpemVPZktlcm5pbmdEYXRhVGFibGUpOyAvLyBM ZW5ndGggb2YgdGhpcyBzdWJ0YWJsZQorICAgICAgICB3cml0ZTE2KHJlc3VsdCwgMSk7IC8vIFRh YmxlIGNvdmVyYWdlIGJpdGZpZWxkCisKKyAgICAgICAgYXBwZW5kS2VybmluZ0hlbHBlckZpZWxk cyhyZXN1bHQsIGtlcm5pbmdEYXRhKTsKKworICAgICAgICBmb3IgKGF1dG8mIGtlcm5pbmdEYXRh IDoga2VybmluZ0RhdGEpIHsKKyAgICAgICAgICAgIHdyaXRlMTYocmVzdWx0LCBrZXJuaW5nRGF0 YS5nbHlwaDEpOworICAgICAgICAgICAgd3JpdGUxNihyZXN1bHQsIGtlcm5pbmdEYXRhLmdseXBo Mik7CisgICAgICAgICAgICB3cml0ZTE2KHJlc3VsdCwga2VybmluZ0RhdGEuYWRqdXN0bWVudCk7 CisgICAgICAgIH0KKworI2lmICFBU1NFUlRfRElTQUJMRUQKKyAgICAgICAgQVNTRVJUKHN1YnRh Ymxlc09mZnNldCArIHNpemVPZktlcm5pbmdEYXRhVGFibGUgPT0gcmVzdWx0LnNpemUoKSk7Cisg ICAgICAgIHN1YnRhYmxlc09mZnNldCA9IHJlc3VsdC5zaXplKCk7CisjZW5kaWYKKyAgICB9CisK KyAgICAvLyBUYWJsZSAyCisgICAgeworICAgICAgICBWZWN0b3I8S2VybmluZ0RhdGE+IGtlcm5p bmdEYXRhID0gY29tcHV0ZUtlcm5pbmdEYXRhPFNWR1ZLZXJuRWxlbWVudD4oJlNWR1ZLZXJuRWxl bWVudDo6YnVpbGRWZXJ0aWNhbEtlcm5pbmdQYWlyKTsKKyAgICAgICAgc3RkOjpzb3J0KGtlcm5p bmdEYXRhLmJlZ2luKCksIGtlcm5pbmdEYXRhLmVuZCgpKTsKKyAgICAgICAgc2l6ZV90IHNpemVP Zktlcm5pbmdEYXRhVGFibGUgPSAxNCArIDYgKiBrZXJuaW5nRGF0YS5zaXplKCk7CisgICAgICAg IGlmIChzaXplT2ZLZXJuaW5nRGF0YVRhYmxlID4gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MTZf dD46Om1heCgpKSB7CisgICAgICAgICAgICBrZXJuaW5nRGF0YS5jbGVhcigpOworICAgICAgICAg ICAgc2l6ZU9mS2VybmluZ0RhdGFUYWJsZSA9IDA7CisgICAgICAgIH0KKworICAgICAgICB3cml0 ZTE2KHJlc3VsdCwgMCk7IC8vIFZlcnNpb24gb2Ygc3VidGFibGUKKyAgICAgICAgd3JpdGUxNihy ZXN1bHQsIHNpemVPZktlcm5pbmdEYXRhVGFibGUpOyAvLyBMZW5ndGggb2YgdGhpcyBzdWJ0YWJs ZQorICAgICAgICB3cml0ZTE2KHJlc3VsdCwgMCk7IC8vIFRhYmxlIGNvdmVyYWdlIGJpdGZpZWxk CisKKyAgICAgICAgYXBwZW5kS2VybmluZ0hlbHBlckZpZWxkcyhyZXN1bHQsIGtlcm5pbmdEYXRh KTsKKworICAgICAgICBmb3IgKGF1dG8mIGtlcm5pbmdEYXRhIDoga2VybmluZ0RhdGEpIHsKKyAg ICAgICAgICAgIHdyaXRlMTYocmVzdWx0LCBrZXJuaW5nRGF0YS5nbHlwaDEpOworICAgICAgICAg ICAgd3JpdGUxNihyZXN1bHQsIGtlcm5pbmdEYXRhLmdseXBoMik7CisgICAgICAgICAgICB3cml0 ZTE2KHJlc3VsdCwga2VybmluZ0RhdGEuYWRqdXN0bWVudCk7CisgICAgICAgIH0KKworICAgICAg ICBBU1NFUlQoc3VidGFibGVzT2Zmc2V0ICsgc2l6ZU9mS2VybmluZ0RhdGFUYWJsZSA9PSByZXN1 bHQuc2l6ZSgpKTsKKyAgICB9CisKKyAgICAvLyBUaGVyZSBhcmUgdHdvIGNvbXBldGluZyBzcGVj cyBmb3IgdGhlICdrZXJuJyB0YWJsZTogb25lIHRoYXQgb25seSBBcHBsZSBzdXBwb3J0cyBhbmQg b25lIHRoYXQgZXZlcnlvbmUgc3VwcG9ydHMuIEFwcGxlJ3MgZm9udAorICAgIC8vIHBhcnNlciBj bGFpbXMgdG8gc3VwcG9ydCBib3RoOyBob3dldmVyLCBpdCByZXF1aXJlcyBzb21lIHBhZGRpbmcg Ynl0ZXMgYXQgdGhlIGVuZCBpZiB5b3UgdXNlIHRoZSBzZWNvbmQgZm9ybWF0LiA8cmRhcjovL3By b2JsZW0vMTg0MDE5MDE+CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCA2OyArK2kpCisgICAgICAg IHJlc3VsdC5hcHBlbmQoMCk7Cit9CisKIHN0YXRpYyB2b2lkIHdyaXRlQ0ZGRW5jb2RlZE51bWJl cihWZWN0b3I8Y2hhcj4mIHZlY3RvciwgZmxvYXQgbnVtYmVyKQogewogICAgIGludCByYXcgPSBu dW1iZXIgKiBwb3dmKDIsIDE2KTsKQEAgLTU0NCwxNCArNzU2LDEzIEBAIHN0YXRpYyBjb25zdCBj aGFyIHJNb3ZlVG8gPSAweDE1OwogCiBjbGFzcyBDRkZCdWlsZGVyIDogcHVibGljIFNWR1BhdGhC dWlsZGVyIHsKIHB1YmxpYzoKLSAgICBDRkZCdWlsZGVyKFZlY3RvcjxjaGFyPiYgY2ZmRGF0YSwg ZmxvYXQgd2lkdGgpCisgICAgQ0ZGQnVpbGRlcihWZWN0b3I8Y2hhcj4mIGNmZkRhdGEsIGZsb2F0 IHdpZHRoLCBGbG9hdFBvaW50IG9yaWdpbikKICAgICAgICAgOiBtX2NmZkRhdGEoY2ZmRGF0YSkK ICAgICAgICAgLCBtX2ZpcnN0UG9pbnQodHJ1ZSkKICAgICB7Ci0gICAgICAgIC8vIEZJWE1FOiBX ZSBwcm9iYWJseSB3YW50IHRoZSBpbml0aWFsIG1vdmV0byB0byB1c2UgaG9yaXotb3JpZ2luLXgg YW5kIGhvcml6LW9yaWdpbi15LCB1bmxlc3Mgd2UncmUgdmVydGljYWwKICAgICAgICAgd3JpdGVD RkZFbmNvZGVkTnVtYmVyKG1fY2ZmRGF0YSwgd2lkdGgpOwotICAgICAgICB3cml0ZUNGRkVuY29k ZWROdW1iZXIobV9jZmZEYXRhLCAwKTsKLSAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG1f Y2ZmRGF0YSwgMCk7CisgICAgICAgIHdyaXRlQ0ZGRW5jb2RlZE51bWJlcihtX2NmZkRhdGEsIG9y aWdpbi54KCkpOworICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobV9jZmZEYXRhLCBvcmln aW4ueSgpKTsKICAgICAgICAgbV9jZmZEYXRhLmFwcGVuZChyTW92ZVRvKTsKICAgICB9CiAKQEAg LTY0MSw3ICs4NTIsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9maXJzdFBvaW50OwogfTsKIAot c3RhdGljIFZlY3RvcjxjaGFyPiB0cmFuc2NvZGVHbHlwaFBhdGhzKGZsb2F0IHdpZHRoLCBjb25z dCBTVkdHbHlwaEVsZW1lbnQmIGdseXBoRWxlbWVudCwgRmxvYXRSZWN0JiBib3VuZGluZ0JveCkK K3RlbXBsYXRlIDx0eXBlbmFtZSBUPgorc3RhdGljIFZlY3RvcjxjaGFyPiB0cmFuc2NvZGVHbHlw aFBhdGhzKGZsb2F0IHdpZHRoLCBjb25zdCBUJiBnbHlwaEVsZW1lbnQsIEZsb2F0UmVjdCYgYm91 bmRpbmdCb3gpCiB7CiAgICAgVmVjdG9yPGNoYXI+IHJlc3VsdDsKICAgICBjb25zdCBhdXRvJiBk QXR0cmlidXRlID0gZ2x5cGhFbGVtZW50LmZhc3RHZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6OmRBdHRy KTsKQEAgLTY1NCwxMyArODY2LDIyIEBAIHN0YXRpYyBWZWN0b3I8Y2hhcj4gdHJhbnNjb2RlR2x5 cGhQYXRocyhmbG9hdCB3aWR0aCwgY29uc3QgU1ZHR2x5cGhFbGVtZW50JiBnbHlwCiAgICAgICAg IHJldHVybiByZXN1bHQ7CiAgICAgfQogCi0gICAgQ0ZGQnVpbGRlciBidWlsZGVyKHJlc3VsdCwg d2lkdGgpOworICAgIC8vIEZJWE1FOiBJZiB3ZSBhcmUgdmVydGljYWwsIHVzZSB2ZXJ0X29yaWdp bl94IGFuZCB2ZXJ0X29yaWdpbl95CisgICAgYm9vbCBvazsKKyAgICBmbG9hdCBob3Jpem9udGFs T3JpZ2luWCA9IGdseXBoRWxlbWVudC5mYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjpob3Jpel9v cmlnaW5feEF0dHIpLnRvRmxvYXQoJm9rKTsKKyAgICBpZiAoIW9rKQorICAgICAgICBob3Jpem9u dGFsT3JpZ2luWCA9IDA7CisgICAgZmxvYXQgaG9yaXpvbnRhbE9yaWdpblkgPSBnbHlwaEVsZW1l bnQuZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpfb3JpZ2luX3lBdHRyKS50b0Zsb2F0 KCZvayk7CisgICAgaWYgKCFvaykKKyAgICAgICAgaG9yaXpvbnRhbE9yaWdpblkgPSAwOworCisg ICAgQ0ZGQnVpbGRlciBidWlsZGVyKHJlc3VsdCwgd2lkdGgsIEZsb2F0UG9pbnQoaG9yaXpvbnRh bE9yaWdpblgsIGhvcml6b250YWxPcmlnaW5ZKSk7CiAgICAgU1ZHUGF0aFN0cmluZ1NvdXJjZSBz b3VyY2UoZEF0dHJpYnV0ZSk7CiAgICAgU1ZHUGF0aFBhcnNlciBwYXJzZXI7CiAgICAgcGFyc2Vy LnNldEN1cnJlbnRTb3VyY2UoJnNvdXJjZSk7CiAgICAgcGFyc2VyLnNldEN1cnJlbnRDb25zdW1l cigmYnVpbGRlcik7CiAKLSAgICBib29sIG9rID0gcGFyc2VyLnBhcnNlUGF0aERhdGFGcm9tU291 cmNlKE5vcm1hbGl6ZWRQYXJzaW5nKTsKKyAgICBvayA9IHBhcnNlci5wYXJzZVBhdGhEYXRhRnJv bVNvdXJjZShOb3JtYWxpemVkUGFyc2luZyk7CiAgICAgcGFyc2VyLmNsZWFudXAoKTsKIAogICAg IGlmICghb2spCkBAIC02NzIsNTIgKzg5MywxMDIgQEAgc3RhdGljIFZlY3RvcjxjaGFyPiB0cmFu c2NvZGVHbHlwaFBhdGhzKGZsb2F0IHdpZHRoLCBjb25zdCBTVkdHbHlwaEVsZW1lbnQmIGdseXAK ICAgICByZXR1cm4gcmVzdWx0OwogfQogCit0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4KK3ZvaWQgU1ZH VG9PVEZGb250Q29udmVydGVyOjphcHBlbmRHbHlwaERhdGEoY29uc3QgVmVjdG9yPGNoYXI+JiBw YXRoLCBjb25zdCBUKiwgZmxvYXQgaG9yaXpvbnRhbEFkdmFuY2UsIGZsb2F0IHZlcnRpY2FsQWR2 YW5jZSwgY29uc3QgRmxvYXRSZWN0JiBib3VuZGluZ0JveCwgQ29kZXBvaW50IGNvZGVwb2ludCkK K3sKKyAgICBtX2dseXBocy5hcHBlbmQoR2x5cGhEYXRhKHBhdGgsIG51bGxwdHIsIGhvcml6b250 YWxBZHZhbmNlLCB2ZXJ0aWNhbEFkdmFuY2UsIGJvdW5kaW5nQm94LCBjb2RlcG9pbnQpKTsKK30K KwordGVtcGxhdGUgPD4KK3ZvaWQgU1ZHVG9PVEZGb250Q29udmVydGVyOjphcHBlbmRHbHlwaERh dGEoY29uc3QgVmVjdG9yPGNoYXI+JiBwYXRoLCBjb25zdCBTVkdHbHlwaEVsZW1lbnQqIGVsZW1l bnQsIGZsb2F0IGhvcml6b250YWxBZHZhbmNlLCBmbG9hdCB2ZXJ0aWNhbEFkdmFuY2UsIGNvbnN0 IEZsb2F0UmVjdCYgYm91bmRpbmdCb3gsIENvZGVwb2ludCBjb2RlcG9pbnQpCit7CisgICAgbV9n bHlwaHMuYXBwZW5kKEdseXBoRGF0YShwYXRoLCBlbGVtZW50LCBob3Jpem9udGFsQWR2YW5jZSwg dmVydGljYWxBZHZhbmNlLCBib3VuZGluZ0JveCwgY29kZXBvaW50KSk7Cit9CisKK3RlbXBsYXRl IDx0eXBlbmFtZSBUPgordm9pZCBTVkdUb09URkZvbnRDb252ZXJ0ZXI6OnByb2Nlc3NHbHlwaEVs ZW1lbnQoY29uc3QgVCYgZWxlbWVudCwgZmxvYXQgZGVmYXVsdEhvcml6b250YWxBZHZhbmNlLCBm bG9hdCBkZWZhdWx0VmVydGljYWxBZHZhbmNlLCBDb2RlcG9pbnQgY29kZXBvaW50LCBib29sJiBp bml0aWFsR2x5cGgpCit7CisgICAgYm9vbCBvazsKKyAgICBmbG9hdCBob3Jpem9udGFsQWR2YW5j ZSA9IGVsZW1lbnQuZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6aG9yaXpfYWR2X3hBdHRyKS50 b0Zsb2F0KCZvayk7CisgICAgaWYgKCFvaykKKyAgICAgICAgaG9yaXpvbnRhbEFkdmFuY2UgPSBk ZWZhdWx0SG9yaXpvbnRhbEFkdmFuY2U7CisgICAgbV9hZHZhbmNlV2lkdGhNYXggPSBzdGQ6Om1h eChtX2FkdmFuY2VXaWR0aE1heCwgaG9yaXpvbnRhbEFkdmFuY2UpOworICAgIGZsb2F0IHZlcnRp Y2FsQWR2YW5jZSA9IGVsZW1lbnQuZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6dmVydF9hZHZf eUF0dHIpLnRvRmxvYXQoJm9rKTsKKyAgICBpZiAoIW9rKQorICAgICAgICB2ZXJ0aWNhbEFkdmFu Y2UgPSBkZWZhdWx0VmVydGljYWxBZHZhbmNlOworICAgIG1fYWR2YW5jZUhlaWdodE1heCA9IHN0 ZDo6bWF4KG1fYWR2YW5jZUhlaWdodE1heCwgdmVydGljYWxBZHZhbmNlKTsKKworICAgIEZsb2F0 UmVjdCBnbHlwaEJvdW5kaW5nQm94OworICAgIGNvbnN0IGF1dG8mIHBhdGggPSB0cmFuc2NvZGVH bHlwaFBhdGhzKGhvcml6b250YWxBZHZhbmNlLCBlbGVtZW50LCBnbHlwaEJvdW5kaW5nQm94KTsK KyAgICBpZiAoaW5pdGlhbEdseXBoKQorICAgICAgICBtX2JvdW5kaW5nQm94ID0gZ2x5cGhCb3Vu ZGluZ0JveDsKKyAgICBlbHNlCisgICAgICAgIG1fYm91bmRpbmdCb3gudW5pdGUoZ2x5cGhCb3Vu ZGluZ0JveCk7CisgICAgbV9taW5SaWdodFNpZGVCZWFyaW5nID0gc3RkOjptaW4obV9taW5SaWdo dFNpZGVCZWFyaW5nLCBob3Jpem9udGFsQWR2YW5jZSAtIGdseXBoQm91bmRpbmdCb3gubWF4WCgp KTsKKyAgICBpbml0aWFsR2x5cGggPSBmYWxzZTsKKworICAgIGFwcGVuZEdseXBoRGF0YShwYXRo LCAmZWxlbWVudCwgaG9yaXpvbnRhbEFkdmFuY2UsIHZlcnRpY2FsQWR2YW5jZSwgZ2x5cGhCb3Vu ZGluZ0JveCwgY29kZXBvaW50KTsKK30KKwogU1ZHVG9PVEZGb250Q29udmVydGVyOjpTVkdUb09U RkZvbnRDb252ZXJ0ZXIoY29uc3QgU1ZHRm9udEVsZW1lbnQmIGZvbnRFbGVtZW50KQogICAgIDog bV9mb250RWxlbWVudChmb250RWxlbWVudCkKICAgICAsIG1fZm9udEZhY2VFbGVtZW50KGNoaWxk cmVuT2ZUeXBlPFNWR0ZvbnRGYWNlRWxlbWVudD4obV9mb250RWxlbWVudCkuZmlyc3QoKSkKKyAg ICAsIG1fbWlzc2luZ0dseXBoRWxlbWVudChjaGlsZHJlbk9mVHlwZTxTVkdNaXNzaW5nR2x5cGhF bGVtZW50PihtX2ZvbnRFbGVtZW50KS5maXJzdCgpKQogICAgICwgbV9hZHZhbmNlV2lkdGhNYXgo MCkKKyAgICAsIG1fYWR2YW5jZUhlaWdodE1heCgwKQogICAgICwgbV9taW5SaWdodFNpZGVCZWFy aW5nKHN0ZDo6bnVtZXJpY19saW1pdHM8ZmxvYXQ+OjptYXgoKSkKKyAgICAsIG1fdW5pdHNQZXJF bSgwKQogICAgICwgbV90YWJsZXNBcHBlbmRlZENvdW50KDApCiAgICAgLCBtX3dlaWdodCg1KQog ICAgICwgbV9pdGFsaWMoZmFsc2UpCiB7Ci0gICAgYm9vbCBvayA9IHRydWU7Ci0gICAgZmxvYXQg ZGVmYXVsdEFkdmFuY2UgPSBmb250RWxlbWVudC5mYXN0R2V0QXR0cmlidXRlKFNWR05hbWVzOjpo b3Jpel9hZHZfeEF0dHIpLnRvRmxvYXQoJm9rKTsKLSAgICBpZiAoIW9rKQotICAgICAgICBkZWZh dWx0QWR2YW5jZSA9IDA7Ci0gICAgbV9hZHZhbmNlV2lkdGhNYXggPSBzdGQ6Om1heChtX2FkdmFu Y2VXaWR0aE1heCwgZGVmYXVsdEFkdmFuY2UpOwotCi0gICAgLy8gRklYTUU6IFVzZSB0aGUgbWlz c2luZ0dseXBoIGluZm8KLSAgICBWZWN0b3I8Y2hhciwgMT4gbm90ZGVmQ2hhclN0cmluZzsKLSAg ICBub3RkZWZDaGFyU3RyaW5nLmFwcGVuZChlbmRDaGFyKTsKLSAgICBtX2dseXBocy5hcHBlbmQo R2x5cGhEYXRhKG5vdGRlZkNoYXJTdHJpbmcsIG51bGxwdHIsIG1fZm9udEZhY2VFbGVtZW50ID8g bV9mb250RmFjZUVsZW1lbnQtPnVuaXRzUGVyRW0oKSA6IDAsIEZsb2F0UmVjdCgpLCAwKSk7Cisg ICAgZmxvYXQgZGVmYXVsdEhvcml6b250YWxBZHZhbmNlID0gbV9mb250RmFjZUVsZW1lbnQgPyBt X2ZvbnRGYWNlRWxlbWVudC0+aG9yaXpvbnRhbEFkdmFuY2VYKCkgOiAwOworICAgIGZsb2F0IGRl ZmF1bHRWZXJ0aWNhbEFkdmFuY2UgPSBtX2ZvbnRGYWNlRWxlbWVudCA/IG1fZm9udEZhY2VFbGVt ZW50LT52ZXJ0aWNhbEFkdmFuY2VZKCkgOiAwOwogICAgIGJvb2wgaW5pdGlhbEdseXBoID0gdHJ1 ZTsKLSAgICBmb3IgKGF1dG8mIGdseXBoIDogY2hpbGRyZW5PZlR5cGU8U1ZHR2x5cGhFbGVtZW50 PihtX2ZvbnRFbGVtZW50KSkgewotICAgICAgICBhdXRvJiB1bmljb2RlQXR0cmlidXRlID0gZ2x5 cGguZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6dW5pY29kZUF0dHIpOworCisgICAgaWYgKG1f Zm9udEZhY2VFbGVtZW50KQorICAgICAgICBtX3VuaXRzUGVyRW0gPSBtX2ZvbnRGYWNlRWxlbWVu dC0+dW5pdHNQZXJFbSgpOworCisgICAgaWYgKG1fbWlzc2luZ0dseXBoRWxlbWVudCkKKyAgICAg ICAgcHJvY2Vzc0dseXBoRWxlbWVudCgqbV9taXNzaW5nR2x5cGhFbGVtZW50LCBkZWZhdWx0SG9y aXpvbnRhbEFkdmFuY2UsIGRlZmF1bHRWZXJ0aWNhbEFkdmFuY2UsIDAsIGluaXRpYWxHbHlwaCk7 CisgICAgZWxzZSB7CisgICAgICAgIFZlY3RvcjxjaGFyPiBub3RkZWZDaGFyU3RyaW5nOworICAg ICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobm90ZGVmQ2hhclN0cmluZywgbV91bml0c1BlckVt KTsKKyAgICAgICAgd3JpdGVDRkZFbmNvZGVkTnVtYmVyKG5vdGRlZkNoYXJTdHJpbmcsIDApOwor ICAgICAgICB3cml0ZUNGRkVuY29kZWROdW1iZXIobm90ZGVmQ2hhclN0cmluZywgMCk7CisgICAg ICAgIG5vdGRlZkNoYXJTdHJpbmcuYXBwZW5kKHJNb3ZlVG8pOworICAgICAgICBub3RkZWZDaGFy U3RyaW5nLmFwcGVuZChlbmRDaGFyKTsKKyAgICAgICAgbV9nbHlwaHMuYXBwZW5kKEdseXBoRGF0 YShub3RkZWZDaGFyU3RyaW5nLCBudWxscHRyLCBtX3VuaXRzUGVyRW0sIG1fdW5pdHNQZXJFbSwg RmxvYXRSZWN0KCksIDApKTsKKyAgICB9CisKKyAgICBmb3IgKGNvbnN0IGF1dG8mIGdseXBoRWxl bWVudCA6IGNoaWxkcmVuT2ZUeXBlPFNWR0dseXBoRWxlbWVudD4obV9mb250RWxlbWVudCkpIHsK KyAgICAgICAgYXV0byYgdW5pY29kZUF0dHJpYnV0ZSA9IGdseXBoRWxlbWVudC5mYXN0R2V0QXR0 cmlidXRlKFNWR05hbWVzOjp1bmljb2RlQXR0cik7CiAgICAgICAgIC8vIE9ubHkgc3VwcG9ydCBC YXNpYyBNdWx0aWxpbmd1YWwgUGxhbmUgdy9vIGxpZ2F0dXJlcyBmb3Igbm93Ci0gICAgICAgIGlm ICh1bmljb2RlQXR0cmlidXRlLmxlbmd0aCgpID09IDEpIHsKLSAgICAgICAgICAgIGJvb2wgb2sg PSB0cnVlOwotICAgICAgICAgICAgZmxvYXQgZWZmZWN0aXZlQWR2YW5jZSA9IGdseXBoLmZhc3RH ZXRBdHRyaWJ1dGUoU1ZHTmFtZXM6Omhvcml6X2Fkdl94QXR0cikudG9GbG9hdCgmb2spOwotICAg ICAgICAgICAgaWYgKCFvaykKLSAgICAgICAgICAgICAgICBlZmZlY3RpdmVBZHZhbmNlID0gZGVm YXVsdEFkdmFuY2U7Ci0gICAgICAgICAgICBtX2FkdmFuY2VXaWR0aE1heCA9IHN0ZDo6bWF4KG1f YWR2YW5jZVdpZHRoTWF4LCBlZmZlY3RpdmVBZHZhbmNlKTsKLQotICAgICAgICAgICAgRmxvYXRS ZWN0IGdseXBoQm91bmRpbmdCb3g7Ci0gICAgICAgICAgICBjb25zdCBhdXRvJiBwYXRoID0gdHJh bnNjb2RlR2x5cGhQYXRocyhlZmZlY3RpdmVBZHZhbmNlLCBnbHlwaCwgZ2x5cGhCb3VuZGluZ0Jv eCk7Ci0gICAgICAgICAgICBpZiAoaW5pdGlhbEdseXBoKQotICAgICAgICAgICAgICAgIG1fYm91 bmRpbmdCb3ggPSBnbHlwaEJvdW5kaW5nQm94OwotICAgICAgICAgICAgZWxzZQotICAgICAgICAg ICAgICAgIG1fYm91bmRpbmdCb3gudW5pdGUoZ2x5cGhCb3VuZGluZ0JveCk7Ci0gICAgICAgICAg ICBtX21pblJpZ2h0U2lkZUJlYXJpbmcgPSBzdGQ6Om1pbihtX21pblJpZ2h0U2lkZUJlYXJpbmcs IGVmZmVjdGl2ZUFkdmFuY2UgLSBnbHlwaEJvdW5kaW5nQm94Lm1heFgoKSk7Ci0gICAgICAgICAg ICBpbml0aWFsR2x5cGggPSBmYWxzZTsKLQotICAgICAgICAgICAgbV9nbHlwaHMuYXBwZW5kKEds eXBoRGF0YShwYXRoLCAmZ2x5cGgsIGVmZmVjdGl2ZUFkdmFuY2UsIGdseXBoQm91bmRpbmdCb3gs IHVuaWNvZGVBdHRyaWJ1dGVbMF0pKTsKLSAgICAgICAgfQorICAgICAgICBpZiAodW5pY29kZUF0 dHJpYnV0ZS5sZW5ndGgoKSA9PSAxKQorICAgICAgICAgICAgcHJvY2Vzc0dseXBoRWxlbWVudChn bHlwaEVsZW1lbnQsIGRlZmF1bHRIb3Jpem9udGFsQWR2YW5jZSwgZGVmYXVsdFZlcnRpY2FsQWR2 YW5jZSwgdW5pY29kZUF0dHJpYnV0ZVswXSwgaW5pdGlhbEdseXBoKTsKKyAgICB9CisKKyAgICBp ZiAobV9nbHlwaHMuc2l6ZSgpID4gc3RkOjpudW1lcmljX2xpbWl0czxHbHlwaD46Om1heCgpKSB7 CisgICAgICAgIC8vIFRoaXMgd2lsbCBicmVhayBhbGwgc29ydHMgb2YgdGhpbmdzLiBCYWlsIGVh cmx5IGluc3RlYWQuCisgICAgICAgIG1fZ2x5cGhzLmNsZWFyKCk7CisgICAgICAgIHJldHVybjsK ICAgICB9CisKICAgICBzdGQ6OnNvcnQobV9nbHlwaHMuYmVnaW4oKSwgbV9nbHlwaHMuZW5kKCks IFtdKGNvbnN0IEdseXBoRGF0YSYgZGF0YTEsIGNvbnN0IEdseXBoRGF0YSYgZGF0YTIpIHsKICAg ICAgICAgcmV0dXJuIGRhdGExLmNvZGVwb2ludCA8IGRhdGEyLmNvZGVwb2ludDsKICAgICB9KTsK IAorICAgIGZvciAoR2x5cGggaSA9IDA7IGkgPCBtX2dseXBocy5zaXplKCk7ICsraSkgeworICAg ICAgICBHbHlwaERhdGEmIGdseXBoID0gbV9nbHlwaHNbaV07CisgICAgICAgIGlmIChnbHlwaC5n bHlwaEVsZW1lbnQpIHsKKyAgICAgICAgICAgIGF1dG8mIGdseXBoTmFtZSA9IGdseXBoLmdseXBo RWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6Z2x5cGhfbmFtZUF0dHIpOworICAg ICAgICAgICAgaWYgKCFnbHlwaE5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgIG1fZ2x5 cGhOYW1lVG9JbmRleE1hcC5hZGQoZ2x5cGhOYW1lLCBpKTsKKyAgICAgICAgfQorICAgICAgICBp ZiAoZ2x5cGguY29kZXBvaW50KQorICAgICAgICAgICAgbV9jb2RlcG9pbnRUb0luZGV4TWFwLmFk ZChnbHlwaC5jb2RlcG9pbnQsIGkpOworICAgIH0KKwogICAgIC8vIEZJWE1FOiBIYW5kbGUgY29t bWFzCiAgICAgaWYgKG1fZm9udEZhY2VFbGVtZW50KSB7CiAgICAgICAgIGF1dG8mIGZvbnRXZWln aHRBdHRyaWJ1dGUgPSBtX2ZvbnRGYWNlRWxlbWVudC0+ZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1l czo6Zm9udF93ZWlnaHRBdHRyKTsKQEAgLTcyNiw3ICs5OTcsNyBAQCBTVkdUb09URkZvbnRDb252 ZXJ0ZXI6OlNWR1RvT1RGRm9udENvbnZlcnRlcihjb25zdCBTVkdGb250RWxlbWVudCYgZm9udEVs ZW1lbnQpCiAgICAgICAgIGZvciAoY29uc3QgYXV0byYgc2VnbWVudCA6IHNwbGl0KSB7CiAgICAg ICAgICAgICBpZiAoc2VnbWVudCA9PSAiYm9sZCIpCiAgICAgICAgICAgICAgICAgbV93ZWlnaHQg PSA3OwotICAgICAgICAgICAgYm9vbCBvayA9IHRydWU7CisgICAgICAgICAgICBib29sIG9rOwog ICAgICAgICAgICAgaW50IHZhbHVlID0gc2VnbWVudC50b0ludCgmb2spOwogICAgICAgICAgICAg aWYgKG9rICYmIHZhbHVlID49IDAgJiYgdmFsdWUgPCAxMDAwKQogICAgICAgICAgICAgICAgIG1f d2VpZ2h0ID0gdmFsdWUgLyAxMDA7CkBAIC03ODcsMTAgKzEwNTgsMTAgQEAgdm9pZCBTVkdUb09U RkZvbnRDb252ZXJ0ZXI6OmFwcGVuZFRhYmxlKGNvbnN0IGNoYXIgaWRlbnRpZmllcls0XSwgVmVj dG9yPGNoYXI+JgogVmVjdG9yPGNoYXI+IFNWR1RvT1RGRm9udENvbnZlcnRlcjo6Y29udmVydFNW R1RvT1RGRm9udCgpCiB7CiAgICAgVmVjdG9yPGNoYXI+IHJlc3VsdDsKLSAgICBpZiAobV9nbHlw aHMuc2l6ZSgpID4gMHhGRkZGIHx8ICFtX2dseXBocy5zaXplKCkpCisgICAgaWYgKCFtX2dseXBo cy5zaXplKCkpCiAgICAgICAgIHJldHVybiByZXN1bHQ7CiAKLSAgICB1aW50MTZfdCBudW1UYWJs ZXMgPSAxMDsKKyAgICB1aW50MTZfdCBudW1UYWJsZXMgPSAxMzsKICAgICB1aW50MTZfdCByb3Vu ZGVkTnVtVGFibGVzID0gcm91bmREb3duVG9Qb3dlck9mVHdvKG51bVRhYmxlcyk7CiAgICAgdWlu dDE2X3Qgc2VhcmNoUmFuZ2UgPSByb3VuZGVkTnVtVGFibGVzICogMTY7CiAgICAgdWludDE2X3Qg ZW50cnlTZWxlY3RvciA9IDA7CkBAIC04MjEsOSArMTA5MiwxMiBAQCBWZWN0b3I8Y2hhcj4gU1ZH VG9PVEZGb250Q29udmVydGVyOjpjb252ZXJ0U1ZHVG9PVEZGb250KCkKICAgICBhcHBlbmRUYWJs ZSgiaGVhZCIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSEVBRFRhYmxl KTsKICAgICBhcHBlbmRUYWJsZSgiaGhlYSIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRl cjo6YXBwZW5kSEhFQVRhYmxlKTsKICAgICBhcHBlbmRUYWJsZSgiaG10eCIsIHJlc3VsdCwgJlNW R1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kSE1UWFRhYmxlKTsKKyAgICBhcHBlbmRUYWJsZSgi a2VybiIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kS0VSTlRhYmxlKTsK ICAgICBhcHBlbmRUYWJsZSgibWF4cCIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRlcjo6 YXBwZW5kTUFYUFRhYmxlKTsKICAgICBhcHBlbmRUYWJsZSgibmFtZSIsIHJlc3VsdCwgJlNWR1Rv T1RGRm9udENvbnZlcnRlcjo6YXBwZW5kTkFNRVRhYmxlKTsKICAgICBhcHBlbmRUYWJsZSgicG9z dCIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBwZW5kUE9TVFRhYmxlKTsKKyAg ICBhcHBlbmRUYWJsZSgidmhlYSIsIHJlc3VsdCwgJlNWR1RvT1RGRm9udENvbnZlcnRlcjo6YXBw ZW5kVkhFQVRhYmxlKTsKKyAgICBhcHBlbmRUYWJsZSgidm10eCIsIHJlc3VsdCwgJlNWR1RvT1RG Rm9udENvbnZlcnRlcjo6YXBwZW5kVk1UWFRhYmxlKTsKIAogICAgIEFTU0VSVChudW1UYWJsZXMg PT0gbV90YWJsZXNBcHBlbmRlZENvdW50KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv c3ZnL1NWR1ZLZXJuRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVktlcm5FbGVt ZW50LmNwcAppbmRleCA0NGUwOWZkNzliNDRjOWUzYzQxNThjZWE4MjEyZWVjZDkxNDlmYmRiLi44 MzhjMTA4NjRlNmY2NWQ3Yzg1ODljYjc5ODcwOGFkZmZkN2RmMWU3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHVktlcm5FbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9z dmcvU1ZHVktlcm5FbGVtZW50LmNwcApAQCAtNjAsMjMgKzYwLDI0IEBAIHZvaWQgU1ZHVktlcm5F bGVtZW50OjpyZW1vdmVkRnJvbShDb250YWluZXJOb2RlJiByb290UGFyZW50KQogICAgIFNWR0Vs ZW1lbnQ6OnJlbW92ZWRGcm9tKHJvb3RQYXJlbnQpOwogfQogCi12b2lkIFNWR1ZLZXJuRWxlbWVu dDo6YnVpbGRWZXJ0aWNhbEtlcm5pbmdQYWlyKFNWR0tlcm5pbmdNYXAmIGtlcm5pbmdNYXApCiti b29sIFNWR1ZLZXJuRWxlbWVudDo6YnVpbGRWZXJ0aWNhbEtlcm5pbmdQYWlyKFNWR0tlcm5pbmdQ YWlyJiBrZXJuaW5nUGFpcikgY29uc3QKIHsKICAgICBTdHJpbmcgdTEgPSBmYXN0R2V0QXR0cmli dXRlKFNWR05hbWVzOjp1MUF0dHIpOwogICAgIFN0cmluZyBnMSA9IGZhc3RHZXRBdHRyaWJ1dGUo U1ZHTmFtZXM6OmcxQXR0cik7CiAgICAgU3RyaW5nIHUyID0gZmFzdEdldEF0dHJpYnV0ZShTVkdO YW1lczo6dTJBdHRyKTsKICAgICBTdHJpbmcgZzIgPSBmYXN0R2V0QXR0cmlidXRlKFNWR05hbWVz OjpnMkF0dHIpOwogICAgIGlmICgodTEuaXNFbXB0eSgpICYmIGcxLmlzRW1wdHkoKSkgfHwgKHUy LmlzRW1wdHkoKSAmJiBnMi5pc0VtcHR5KCkpKQotICAgICAgICByZXR1cm47CisgICAgICAgIHJl dHVybiBmYWxzZTsKIAotICAgIFNWR0tlcm5pbmdQYWlyIGtlcm5pbmdQYWlyOwogICAgIGlmIChw YXJzZUdseXBoTmFtZShnMSwga2VybmluZ1BhaXIuZ2x5cGhOYW1lMSkKICAgICAgICAgJiYgcGFy c2VHbHlwaE5hbWUoZzIsIGtlcm5pbmdQYWlyLmdseXBoTmFtZTIpCiAgICAgICAgICYmIHBhcnNl S2VybmluZ1VuaWNvZGVTdHJpbmcodTEsIGtlcm5pbmdQYWlyLnVuaWNvZGVSYW5nZTEsIGtlcm5p bmdQYWlyLnVuaWNvZGVOYW1lMSkKICAgICAgICAgJiYgcGFyc2VLZXJuaW5nVW5pY29kZVN0cmlu Zyh1Miwga2VybmluZ1BhaXIudW5pY29kZVJhbmdlMiwga2VybmluZ1BhaXIudW5pY29kZU5hbWUy KSkgewotICAgICAgICBrZXJuaW5nUGFpci5rZXJuaW5nID0gZmFzdEdldEF0dHJpYnV0ZShTVkdO YW1lczo6a0F0dHIpLnN0cmluZygpLnRvRmxvYXQoKTsKLSAgICAgICAga2VybmluZ01hcC5pbnNl cnQoa2VybmluZ1BhaXIpOworICAgICAgICBib29sIG9rOworICAgICAgICBrZXJuaW5nUGFpci5r ZXJuaW5nID0gZmFzdEdldEF0dHJpYnV0ZShTVkdOYW1lczo6a0F0dHIpLnN0cmluZygpLnRvRmxv YXQoJm9rKTsKKyAgICAgICAgcmV0dXJuIG9rOwogICAgIH0KKyAgICByZXR1cm4gZmFsc2U7CiB9 CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdWS2VybkVsZW1lbnQuaCBi L1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdWS2VybkVsZW1lbnQuaAppbmRleCBjZTg4ZGU1YjQwZjcx Yjc0YmI4NDZjOWFkNTA5ZjhlNWZiNzc0ZTEzLi43ZWYyZTdjMzBlOWIxYWU1ZDk2MWNiY2EzZWIz ZjFhN2NhZGI4OGQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVktlcm5FbGVt ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1ZLZXJuRWxlbWVudC5oCkBAIC0zMCw3 ICszMCw3IEBAIGNsYXNzIFNWR1ZLZXJuRWxlbWVudCBmaW5hbCA6IHB1YmxpYyBTVkdFbGVtZW50 IHsKIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc1JlZlB0cjxTVkdWS2VybkVsZW1lbnQ+IGNyZWF0 ZShjb25zdCBRdWFsaWZpZWROYW1lJiwgRG9jdW1lbnQmKTsKIAotICAgIHZvaWQgYnVpbGRWZXJ0 aWNhbEtlcm5pbmdQYWlyKFNWR0tlcm5pbmdNYXAmKTsKKyAgICBib29sIGJ1aWxkVmVydGljYWxL ZXJuaW5nUGFpcihTVkdLZXJuaW5nUGFpciYpIGNvbnN0OwogCiBwcml2YXRlOgogICAgIFNWR1ZL ZXJuRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiwgRG9jdW1lbnQmKTsK