65803 2011-08-05 18:10:59 -0700 Initial pass at a new XML tree builder 2011-08-09 14:32:24 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 64396 1 jeffrey+webkit jeffrey+webkit abarth webkit.review.bot oldest_to_newest 447521 0 jeffrey+webkit 2011-08-05 18:10:59 -0700 Initial pass at a new XML tree builder 447526 1 103137 jeffrey+webkit 2011-08-05 18:36:17 -0700 Created attachment 103137 Patch 447549 2 103137 abarth 2011-08-05 19:25:30 -0700 Comment on attachment 103137 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=103137&action=review Overall, I would split most of this code out into a new object. NewXMLDocumentParser is going to be a large complex class. The more we can move off into smaller classes, the better off our lives will be. For HTML, we split this code into two pieces (the TreeBuilder and the ConstructionSite), but that's probably not necessary for XML because this part of the algorithm is simpler. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:124 > void NewXMLDocumentParser::finish() > { > + m_finishWasCalled = true; Should we assert that !m_finishWasCalled ? I think finish can only be called once. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:171 > +void NewXMLDocumentParser::pushCurrentNode(ContainerNode* n) n => node ? > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:213 > + ExceptionCode ec = 0; > + > + document()->setXMLVersion(String::adopt(token.xmlVersion()), ec); > + document()->setXMLStandalone(token.xmlStandalone(), ec); Does this ec just vanish? > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:221 > + String extId(token.publicIdentifier().data(), token.publicIdentifier().size()); > + String sysId(token.systemIdentifier().data(), token.systemIdentifier().size()); We should use complete words in variable names. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:232 > + if ((extId == "-//W3C//DTD XHTML 1.0 Transitional//EN") > + || (extId == "-//W3C//DTD XHTML 1.1//EN") > + || (extId == "-//W3C//DTD XHTML 1.0 Strict//EN") > + || (extId == "-//W3C//DTD XHTML 1.0 Frameset//EN") > + || (extId == "-//W3C//DTD XHTML Basic 1.0//EN") > + || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN") > + || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN") > + || (extId == "-//WAPFORUM//DTD XHTML Mobile 1.0//EN") These string constants should be AtomicStrings (as should extId) so we can do this comparison much faster. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:237 > +void NewXMLDocumentParser::processStartTag(const AtomicXMLToken& token) This function is too long and should be broken up into it's component pieces. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:247 > + if (attribute->name().prefix() == "xmlns") This should also be an atomic string comparison. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:274 > + if (token.attributes()) { > + for (unsigned i = 0; i < token.attributes()->length(); ++i) { > + Attribute* attribute = token.attributes()->attributeItem(i); > + ExceptionCode ec = 0; > + if (attribute->name().prefix() == "xmlns") > + newElement->setAttributeNS(XMLNSNames::xmlnsNamespaceURI, "xmlns:" + attribute->name().localName(), attribute->value(), ec); > + else if (attribute->name() == "xmlns") > + newElement->setAttributeNS(XMLNSNames::xmlnsNamespaceURI, xmlnsAtom, attribute->value(), ec); > + else { > + QualifiedName qName(attribute->prefix(), attribute->localName(), namespaceForPrefix(attribute->prefix(), nullAtom)); > + newElement->setAttribute(qName, attribute->value()); > + } > + } > + } For example, this is a self-contained, logical unity. Maybe this should be a method on the token to give its attributes to the element? > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:290 > + if (isFirstElement && document()->frame()) > + document()->frame()->loader()->dispatchDocumentElementAvailable(); > + > + m_currentNodeItem = m_currentNodeStack.last(); dispatchDocumentElementAvailable is likely to do a lot of work. Do we want to make sure this object is in a consistent state before calling out into a bunch of complex code that my re-enter us or assume that we're in a consistent state? > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:298 > + ContainerNode* n = m_currentNode; > + n->finishParsingChildren(); finishParsingChildren can run arbitrary code and re-enter this function. There's no guantee that n will still be alive after calling this. At the very least, we should grab a RefPtr to n before calling out to arbitrary code, but we should also ensure that we're in a consistent state. (Also, we should rename n to something like node.) > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:358 > + HTMLEntitySearch search; > + const AtomicString& name = token.name(); > + for (unsigned i = 0; i < name.length(); ++i) { > + search.advance(name[i]); > + if (!search.isEntityPrefix()) > + stopParsing(); > + return; > + } > + search.advance(';'); > + ExceptionCode ec = 0; > + UChar32 entityValue = search.currentValue(); > + if (entityValue <= 0xFFFF) > + m_leafTextNode->appendData(String(reinterpret_cast<UChar*>(&entityValue), 1), ec); > + else { > + UChar utf16Pair[2] = { U16_LEAD(entityValue), U16_TRAIL(entityValue) }; > + m_leafTextNode->appendData(String(utf16Pair, 2), ec); > + } This also looks like a self-contained block of code that should be factored out. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:380 > + AtomicString amp("amp"); > + AtomicString apos("apos"); > + AtomicString gt("gt"); > + AtomicString lt("lt"); > + AtomicString quot("quot"); > + ExceptionCode ec = 0; > + > + if (token.name() == amp) > + m_leafTextNode->appendData("&", ec); > + else if (token.name() == apos) > + m_leafTextNode->appendData("'", ec); > + else if (token.name() == gt) > + m_leafTextNode->appendData(">", ec); > + else if (token.name() == lt) > + m_leafTextNode->appendData("<", ec); > + else if (token.name() == quot) > + m_leafTextNode->appendData("\"", ec); > + else { > + stopParsing(); > + return; > + } I'd also factor this out into a static free function. The constants should be DEFINE_STATIC_LOCAL so we only need to allocate / hash them once. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:395 > +void NewXMLDocumentParser::enterText() > +{ > + if (!m_sawFirstElement) { > + // FIXME: ensure it's just whitespace > + return; > + } > + > + if (!m_leafTextNode) { > + m_leafTextNode = Text::create(document(), ""); > + m_currentNode->parserAddChild(m_leafTextNode.get()); > + } > +} Can we optimize this to allocate the text node with the first text token directly? I'm not sure if it's expensive to allocate text node with an empty string and then fill it, but it could well cost an extra malloc. This operation happens many, many times while parsing. > Source/WebCore/xml/parser/NewXMLDocumentParser.h:67 > + ContainerNode* m_node; > + AtomicString m_namespace; Data members should be private. You can expose getter/setting functions if you like. 448263 3 103292 jeffrey+webkit 2011-08-08 14:23:36 -0700 Created attachment 103292 Patch 448325 4 103292 abarth 2011-08-08 15:52:12 -0700 Comment on attachment 103292 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=103292&action=review Lots of detailed comments. Mostly r- for manual refcounting. > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:87 > + m_finishWasCalled = true; I thought you were going to ASSERT(!m_finishWasCalled) here? > Source/WebCore/xml/parser/NewXMLDocumentParser.cpp:118 > void NewXMLDocumentParser::prepareToStopParsing() > { > + ScriptableDocumentParser::prepareToStopParsing(); > } > > void NewXMLDocumentParser::stopParsing() > { > + ScriptableDocumentParser::stopParsing(); > } Why do these exist if we're just going to call through to the base class? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:82 > + default: > + break; Bad indent. Usually we skip the default case to have the compiler yell at us if we forget any cases. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:91 > + if (node != m_document) > + node->ref(); Why do we need to use manual ref counting? Can't we use RefPtr to do this work automatically? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:95 > + m_currentNode = node; How does a currentNode differ from a currentNodeItem? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:102 > + if (!m_currentNode) > + return; When would we ever pop the current node when m_currentNode is null? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:106 > + if (m_currentNode != m_document) > + m_currentNode->deref(); Frown. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:127 > + m_document->setXMLVersion(String::adopt(token.xmlVersion()), ec); We should use the copying string constructor rather than adopt here. The copying constructor is faster for small strings because adopt incurs an extra malloc. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:133 > + if (ec) > + m_parser->stopParsing(); Do we need to check for ec after each call? What if the second call clobbers the ec from the first? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:148 > + AtomicString publicIdentifier(token.publicIdentifier().data(), token.publicIdentifier().size()); > + AtomicString systemIdentifier(token.systemIdentifier().data(), token.systemIdentifier().size()); The design for the other fields is to have the AtomicXMLToken create these atomic strings on construction. We'll need to do the work either way, but doing it that way lets us save work if we need to look at these values in multiple places. That's probably not much of a win here, but it's useful to be consistent. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:160 > + || (publicIdentifier == xhtmlMobile) > + ) These lines should be merged. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:166 > + exitText(); Why don't the processing instruction or the xml declaration cause use to exitText? Do we need to assert that there's not text to exit? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:214 > + Extra blank line. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:215 > + enterText(String(token.characters().data(), token.characters().size())); So, you've got an extra memcpy here. You're memcpying data into this string, and then you'll end up memcpying into an existing text node, if there is one. That turned out to be costly in the HTML parser, which is why we came up with the notion of an external character buffer. You want to avoid memcpying the data into the String until as late as possible. Doing the memcpy here is probably too early. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:220 > + RefPtr<CDATASection> cdata = CDATASection::create(m_document, token.data()); No exitText? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:231 > + m_currentNode->parserAddChild(comment.get()); > + if (!comment->attached()) > + comment->attach(); This stanza is repeated all over the place. Maybe it should be factored out? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:236 > + // FIXME: support internal subset Comments should be complete sentences. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:246 > + if (token.attributes()) { Prefer early exit. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:247 > + for (unsigned i = 0; i < token.attributes()->length(); ++i) { unsigned => size_t > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:260 > + if (token.attributes()) { Prefer early exit. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:261 > + for (unsigned i = 0; i < token.attributes()->length(); ++i) { unsigned => size_t > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:262 > + Attribute* attribute = token.attributes()->attributeItem(i); It seems wasteful to iterate over the attributes twice. Can we do the work in a single pass over the attributes? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:265 > + newElement->setAttributeNS(XMLNSNames::xmlnsNamespaceURI, "xmlns:" + attribute->name().localName(), attribute->value(), ec); Why is there an ec parameter here? Do we need to handle exceptions? Can this run JavaScript synchronously (e.g., in a DOM mutation event)? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:295 > + m_leafTextNode->appendData("\"", ec); Can these trigger synchronous execution of JavaScript? In what cases could an ec be generated? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:309 > + for (unsigned i = 0; i < name.length(); ++i) { unsigned => size_t > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:318 > + enterText(String(reinterpret_cast<UChar*>(&entityValue), 1)); Yuck. That's an extra malloc. That's going to kill performance if there's a long string of entities. This is related to enterText requiring us to copy into a String too early. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:321 > + UChar utf16Pair[2] = { U16_LEAD(entityValue), U16_TRAIL(entityValue) }; > + enterText(String(utf16Pair, 2)); Same problem here. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:337 > + m_leafTextNode->appendData(text, ec); Is this going to involve copying the whole string over and over again? We might want to use something like StringBuilder to receive all these string fragments and the actually create the text node during exitText. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:356 > + if (!prefix.isNull()) { > + if (m_currentNodeItem.hasNamespaceURI(prefix)) These can be merged onto one line. Why isNull versus isEmpty? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:366 > + if (parent) { Prefer early exit. 448369 5 jeffrey+webkit 2011-08-08 16:57:42 -0700 (In reply to comment #4) > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:91 > > + if (node != m_document) > > + node->ref(); > > Why do we need to use manual ref counting? Can't we use RefPtr to do this work automatically? I don't really know why that was here. It was in the libxml2 version, and I figured it was there for a reason. Either that, or "it was in the HTML version", go for a lot of the things mentioned here. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:102 > > + if (!m_currentNode) > > + return; > > When would we ever pop the current node when m_currentNode is null? This is one instance of "it was in the libxml2 version". > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:148 > > + AtomicString publicIdentifier(token.publicIdentifier().data(), token.publicIdentifier().size()); > > + AtomicString systemIdentifier(token.systemIdentifier().data(), token.systemIdentifier().size()); > > The design for the other fields is to have the AtomicXMLToken create these atomic strings on construction. We'll need to do the work either way, but doing it that way lets us save work if we need to look at these values in multiple places. That's probably not much of a win here, but it's useful to be consistent. The Atomic[Markup]Tokens use the DTD class from the [Markup]Token so they can A) only have the object if it's needed and B) can take the pointer from the non-atomic token. This is what the HTML tokens did when I took a look at them. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:215 > > + enterText(String(token.characters().data(), token.characters().size())); > > So, you've got an extra memcpy here. You're memcpying data into this string, and then you'll end up memcpying into an existing text node, if there is one. That turned out to be costly in the HTML parser, which is why we came up with the notion of an external character buffer. You want to avoid memcpying the data into the String until as late as possible. Doing the memcpy here is probably too early. I'm not really sure how to reconcile the problems of "create the token with the string passed in" with "don't copy the string", given that I need to get the string to enterText somehow. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:247 > > + for (unsigned i = 0; i < token.attributes()->length(); ++i) { > > unsigned => size_t Also in the libxml2 version > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:262 > > + Attribute* attribute = token.attributes()->attributeItem(i); > > It seems wasteful to iterate over the attributes twice. Can we do the work in a single pass over the attributes? I agree, and this was originally one loop, but we need the namespace before we can create the attribute (to ensure that it's of the right subclass) and, unless we loop through twice to get the namespaces first for the attributes anyway, we can't create a NamedNodeMap with the right namespaces. Theoretically, a map of prefixes to a list of attributes with that prefix could fix this problem, but that seems like it might not be optimal. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:265 > > + newElement->setAttributeNS(XMLNSNames::xmlnsNamespaceURI, "xmlns:" + attribute->name().localName(), attribute->value(), ec); > > Why is there an ec parameter here? Do we need to handle exceptions? Can this run JavaScript synchronously (e.g., in a DOM mutation event)? It seems to be a formality. setAttributeNS only sets ec if the URI is null and the prefix is non-empty. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:295 > > + m_leafTextNode->appendData("\"", ec); > > Can these trigger synchronous execution of JavaScript? In what cases could an ec be generated? Likewise, this ec is actually unused within appendData. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:337 > > + m_leafTextNode->appendData(text, ec); > > Is this going to involve copying the whole string over and over again? We might want to use something like StringBuilder to receive all these string fragments and the actually create the text node during exitText. This sounds reasonable. I'll try that. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:356 > > + if (!prefix.isNull()) { > > + if (m_currentNodeItem.hasNamespaceURI(prefix)) > > These can be merged onto one line. Why isNull versus isEmpty? The prefix won't come out of the tokenizer and be empty and non-null. I can ASSERT that. 448400 6 103324 jeffrey+webkit 2011-08-08 18:16:01 -0700 Created attachment 103324 Patch 448443 7 103324 abarth 2011-08-08 22:49:33 -0700 Comment on attachment 103324 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=103324&action=review I'm slightly worried about re-entrancy problems. That was the hardest part about getting the HTML parser correct. I don't want to hold you up, because ironing out all those issues can be tricky, but it's something to keep in mind that we might need to return to at a later date. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:93 > + m_currentNodeStack.append(m_currentStackItem); For a later patch, you might want to experiment with using a Vector and using a linked list. We found that a linked list was faster for the HTML parser, but the HTML parser doesn't have as strong a stack discipline. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:101 > + m_currentNodeStack.removeLast(); Is there a reason to keep m_currentNodeStack separate? It seems like you can always just use m_currentNodeStack.last(). > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:102 > + m_currentStackItem = m_currentNodeStack.last(); Does this actually mutate m_currentStackItem? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:111 > + RefPtr<ProcessingInstruction> pi = ProcessingInstruction::create(m_document, token.target(), token.data()); > + add(pi); I would just combine these lines. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:171 > + RefPtr<Element> newElement = m_document->createElement(qName, true); > + if (!newElement) { How can this fail? > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:186 > + if (token.selfClosing()) > + newElement->finishParsingChildren(); > + else > + pushCurrentNode(newElement.get()); > + > + m_currentStackItem = m_currentNodeStack.last(); I'm still worried about getting re-entered via finishParsingChildren(). We need to make sure we're in a consistent state before calling out to arbitrary JavaScript. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:218 > + RefPtr<CDATASection> cdata = CDATASection::create(m_document, token.data()); > + add(cdata); I'd combine these lines. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:226 > + RefPtr<Comment> comment = Comment::create(m_document, token.comment()); > + add(comment); These too. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:314 > + appendToText(reinterpret_cast<UChar*>(&entityValue), 1); Bad indent. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:343 > + if (!m_sawFirstElement) { > + // FIXME: ensure it's just whitespace > + return; > + } Is this a parse error? I guess that's what the FIXME comment is about. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:354 > + RefPtr<Text> text = Text::create(m_document, m_leafText->toString()); > + add(text); I'd combine these lines. > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:375 > + m_namespace = parent->m_namespace; > + m_scopedNamespaces = parent->m_scopedNamespaces; Bad indent. > Source/WebCore/xml/parser/XMLTreeBuilder.h:107 > + NodeStackItem m_currentStackItem; > + Vector<NodeStackItem> m_currentNodeStack; I'm not sure whether m_currentStackItem is really adding any value given that m_currentNodeStack knows what the current item is anyway. 448446 8 abarth 2011-08-08 22:53:03 -0700 Yeah, the general thing to take away from this discussion is that the libxml2 version is not very high quality. The unsigned vs. size_t thing has to do with 64 bit machines. I believe unsigned is 32bits and size_t is 32 bits on 32 bit machines and 64 bits on 64 bit machines. If you're dealing with something like the difference between two memory addresses, you need something like size_t that scales with the architecture, otherwise you get integer overflow vulnerabilities. Long story short: always use size_t when dealing with sizes or offsets in memory. 448451 9 jeffrey+webkit 2011-08-08 23:17:08 -0700 (In reply to comment #7) > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:101 > > + m_currentNodeStack.removeLast(); > > Is there a reason to keep m_currentNodeStack separate? It seems like you can always just use m_currentNodeStack.last(). It is necessary to keep the top stack item separate from the working stack item because processStartTag can mutate the namespaces in m_currentStackItem (which are then used in the element and attribute creation). If the tag is not self-closing, these changes are pushed onto the stack. Otherwise, the changes are reset at the end of the function. It's probably better to only set m_currentStackItem inside of processStartTag and have it be either undefined outside of processStartTag or just passed to the functions that need to mutate it or use it (processNamespaces and processAttributes respectively). > > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:102 > > + m_currentStackItem = m_currentNodeStack.last(); > > Does this actually mutate m_currentStackItem? See above > > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:111 > > + RefPtr<ProcessingInstruction> pi = ProcessingInstruction::create(m_document, token.target(), token.data()); > > + add(pi); > > I would just combine these lines. Probably a good idea. I'll do that before I land it. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:171 > > + RefPtr<Element> newElement = m_document->createElement(qName, true); > > + if (!newElement) { > > How can this fail? I'm not sure, but I can take a closer look before I land it, and remove it if it can't. > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:343 > > + if (!m_sawFirstElement) { > > + // FIXME: ensure it's just whitespace > > + return; > > + } > > Is this a parse error? I guess that's what the FIXME comment is about. The XML spec stipulates that only comments, processing instructions and whitespace can appear outside of the root element, save for the declarations, which can only appear before everything else. However, the tokenizer spits out whitespace the same as regular text nodes, so we have to ignore whitespace tokens before the first element. Technically, this whitespace is "markup" and not "character data", but the tokenizer doesn't know that. > > Source/WebCore/xml/parser/XMLTreeBuilder.h:107 > > + NodeStackItem m_currentStackItem; > > + Vector<NodeStackItem> m_currentNodeStack; > > I'm not sure whether m_currentStackItem is really adding any value given that m_currentNodeStack knows what the current item is anyway. Again, see above comments 448456 10 abarth 2011-08-08 23:53:41 -0700 (In reply to comment #9) > (In reply to comment #7) > > > Source/WebCore/xml/parser/XMLTreeBuilder.cpp:101 > > > + m_currentNodeStack.removeLast(); > > > > Is there a reason to keep m_currentNodeStack separate? It seems like you can always just use m_currentNodeStack.last(). > > It is necessary to keep the top stack item separate from the working stack item because processStartTag can mutate the namespaces in m_currentStackItem (which are then used in the element and attribute creation). If the tag is not self-closing, these changes are pushed onto the stack. Otherwise, the changes are reset at the end of the function. It's probably better to only set m_currentStackItem inside of processStartTag and have it be either undefined outside of processStartTag or just passed to the functions that need to mutate it or use it (processNamespaces and processAttributes respectively). I would pass it around as an argument rather than storing it as a member, but that's a judgment call. Keeping it as a member makes me think that's it's always something interesting (e.g., the top of the stack). 448782 11 103392 jeffrey+webkit 2011-08-09 14:01:07 -0700 Created attachment 103392 Patch for landing 448813 12 103392 webkit.review.bot 2011-08-09 14:32:19 -0700 Comment on attachment 103392 Patch for landing Clearing flags on attachment: 103392 Committed r92709: <http://trac.webkit.org/changeset/92709> 448814 13 webkit.review.bot 2011-08-09 14:32:24 -0700 All reviewed patches have been landed. Closing bug. 103137 2011-08-05 18:36:17 -0700 2011-08-08 14:23:33 -0700 Patch bug-65803-20110805183615.patch text/plain 17206 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogOTIzMjkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA3ZTg1MzIzNGFkYzY3NGFl ZTA1Zjc3YmZmMzA0MDgyZjU1YjY4ZDA2Li5lNGNjZmUxNTk2NGQxMmIyYWEyNTZmNjlmYjIyNTk3 OWIyNzA4ZjY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzggQEAKKzIwMTEtMDgtMDUgIEplZmZy ZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBJbml0aWFsIHBhc3MgYXQgYSBu ZXcgWE1MIHRyZWUgYnVpbGRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NjU4MDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIHhtbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5ld1hNTERvY3VtZW50UGFyc2VyKToK KyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQpOgorICAgICAg ICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCk6CisgICAgICAgIChXZWJD b3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoV2FzQ2FsbGVkKToKKyAgICAgICAgKFdl YkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjpwcmVwYXJlVG9TdG9wUGFyc2luZyk6CisgICAg ICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6c3RvcFBhcnNpbmcpOgorICAgICAg ICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OnB1c2hDdXJyZW50Tm9kZSk6CisgICAg ICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6cG9wQ3VycmVudE5vZGUpOgorICAg ICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NQcm9jZXNzaW5nSW5z dHJ1Y3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nl c3NYTUxEZWNsYXJhdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNl cjo6cHJvY2Vzc0RPQ1RZUEUpOgorICAgICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJz ZXI6OnByb2Nlc3NTdGFydFRhZyk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBh cnNlcjo6cHJvY2Vzc0VuZFRhZyk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBh cnNlcjo6cHJvY2Vzc0NoYXJhY3Rlcik6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVu dFBhcnNlcjo6cHJvY2Vzc0NEQVRBKToKKyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50 UGFyc2VyOjpwcm9jZXNzQ29tbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVu dFBhcnNlcjo6cHJvY2Vzc0VudGl0eSk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVu dFBhcnNlcjo6ZW50ZXJUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFy c2VyOjpleGl0VGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6 bmFtZXNwYWNlRm9yUHJlZml4KToKKyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFy c2VyOjpOb2RlU3RhY2tJdGVtOjpOb2RlU3RhY2tJdGVtKToKKyAgICAgICAgKFdlYkNvcmU6Ok5l d1hNTERvY3VtZW50UGFyc2VyOjpOb2RlU3RhY2tJdGVtOjpoYXNOYW1lc3BhY2VVUkkpOgorICAg ICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5vZGVTdGFja0l0ZW06Om5hbWVz cGFjZVVSSSk6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6Tm9kZVN0 YWNrSXRlbTo6c2V0TmFtZXNwYWNlVVJJKToKKyAgICAgICAgKiB4bWwvcGFyc2VyL05ld1hNTERv Y3VtZW50UGFyc2VyLmg6CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6 fk5ld1hNTERvY3VtZW50UGFyc2VyKToKKwogMjAxMS0wOC0wMyAgTWFyayBQaWxncmltICA8cGls Z3JpbUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmVtb3ZlIExlZ2FjeURlZmF1bHRPcHRpb25h bEFyZ3VtZW50cyBmbGFnIGZyb20gQ29uc29sZS5pZGwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIvU291cmNlL1dlYkNvcmUv eG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggMmZhYzI3MTk0YWU5MGZk ZTcxNzc1ZmI5Zjk2YzU3M2M5ZGYyMGVhYy4uN2NlNDVkYTk4MjljY2JjMTM1OWJlMDk5OWNhNzI5 MTQ2ZGQ1ZGU0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxE b2N1bWVudFBhcnNlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxE b2N1bWVudFBhcnNlci5jcHAKQEAgLTI2LDE0ICsyNiwyOCBAQAogI2luY2x1ZGUgImNvbmZpZy5o IgogI2luY2x1ZGUgIk5ld1hNTERvY3VtZW50UGFyc2VyLmgiCiAKKyNpbmNsdWRlICJDREFUQVNl Y3Rpb24uaCIKKyNpbmNsdWRlICJDb21tZW50LmgiCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNp bmNsdWRlICJEb2N1bWVudFR5cGUuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkhU TUxFbnRpdHlTZWFyY2guaCIKKyNpbmNsdWRlICJQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaCIKICNp bmNsdWRlICJTZWdtZW50ZWRTdHJpbmcuaCIKKyNpbmNsdWRlICJUZXh0LmgiCisjaW5jbHVkZSAi WE1MTlNOYW1lcy5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIE5ld1hNTERvY3VtZW50UGFy c2VyOjpOZXdYTUxEb2N1bWVudFBhcnNlcihEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgOiBTY3Jp cHRhYmxlRG9jdW1lbnRQYXJzZXIoZG9jdW1lbnQpCisgICAgLCBtX2lzWEhUTUwoZmFsc2UpCisg ICAgLCBtX2ZpbmlzaFdhc0NhbGxlZChmYWxzZSkKICAgICAsIG1fdG9rZW5pemVyKFhNTFRva2Vu aXplcjo6Y3JlYXRlKCkpCisgICAgLCBtX2N1cnJlbnROb2RlKGRvY3VtZW50KQorICAgICwgbV9j dXJyZW50Tm9kZUl0ZW0oZG9jdW1lbnQpCiB7CisgICAgbV9jdXJyZW50Tm9kZVN0YWNrLmFwcGVu ZChOb2RlU3RhY2tJdGVtKGRvY3VtZW50KSk7CiB9CiAKIFRleHRQb3NpdGlvbjAgTmV3WE1MRG9j dW1lbnRQYXJzZXI6OnRleHRQb3NpdGlvbigpIGNvbnN0CkBAIC02Myw3ICs3Nyw0MSBAQCB2b2lk IE5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBzdHJp bmcpCiAgICAgICAgIG1fdG9rZW4ucHJpbnQoKTsKICNlbmRpZgogCi0gICAgICAgIGlmIChtX3Rv a2VuLnR5cGUoKSA9PSBYTUxUb2tlblR5cGVzOjpFbmRPZkZpbGUpCisgICAgICAgIEF0b21pY1hN TFRva2VuIHRva2VuKG1fdG9rZW4pOworCisgICAgICAgIHN3aXRjaCAodG9rZW4udHlwZSgpKSB7 CisgICAgICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6UHJvY2Vzc2luZ0luc3RydWN0aW9uOgorICAg ICAgICAgICAgcHJvY2Vzc1Byb2Nlc3NpbmdJbnN0cnVjdGlvbih0b2tlbik7CisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpYTUxEZWNsYXJhdGlvbjoKKyAg ICAgICAgICAgIHByb2Nlc3NYTUxEZWNsYXJhdGlvbih0b2tlbik7CisgICAgICAgICAgICBicmVh azsKKyAgICAgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpET0NUWVBFOgorICAgICAgICAgICAgcHJv Y2Vzc0RPQ1RZUEUodG9rZW4pOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgWE1M VG9rZW5UeXBlczo6U3RhcnRUYWc6CisgICAgICAgICAgICBwcm9jZXNzU3RhcnRUYWcodG9rZW4p OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6RW5kVGFn OgorICAgICAgICAgICAgcHJvY2Vzc0VuZFRhZyh0b2tlbik7CisgICAgICAgICAgICBicmVhazsK KyAgICAgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpDREFUQToKKyAgICAgICAgICAgIHByb2Nlc3ND REFUQSh0b2tlbik7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBYTUxUb2tlblR5 cGVzOjpDaGFyYWN0ZXI6CisgICAgICAgICAgICBwcm9jZXNzQ2hhcmFjdGVyKHRva2VuKTsKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFhNTFRva2VuVHlwZXM6OkNvbW1lbnQ6Cisg ICAgICAgICAgICBwcm9jZXNzQ29tbWVudCh0b2tlbik7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpFbnRpdHk6CisgICAgICAgICAgICBwcm9jZXNzRW50 aXR5KHRva2VuKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBkZWZhdWx0OgorICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgIH0KKworICAgICAgICBpZiAobV90b2tlbi50eXBlKCkgPT0g WE1MVG9rZW5UeXBlczo6RW5kT2ZGaWxlIHx8ICFpc1BhcnNpbmcoKSkKICAgICAgICAgICAgIGJy ZWFrOwogCiAgICAgICAgIG1fdG9rZW4uY2xlYXIoKTsKQEAgLTczLDYgKzEyMSwxMiBAQCB2b2lk IE5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBzdHJp bmcpCiAKIHZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCgpCiB7CisgICAgbV9maW5p c2hXYXNDYWxsZWQgPSB0cnVlOworCisgICAgaWYgKGlzUGFyc2luZygpKQorICAgICAgICBwcmVw YXJlVG9TdG9wUGFyc2luZygpOworICAgIGRvY3VtZW50KCktPnNldFJlYWR5U3RhdGUoRG9jdW1l bnQ6OkludGVyYWN0aXZlKTsKKyAgICBkb2N1bWVudCgpLT5maW5pc2hlZFBhcnNpbmcoKTsKIH0K IAogdm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZGV0YWNoKCkKQEAgLTg3LDIwICsxNDEsMTcg QEAgYm9vbCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6aGFzSW5zZXJ0aW9uUG9pbnQoKQogCiBib29s IE5ld1hNTERvY3VtZW50UGFyc2VyOjpmaW5pc2hXYXNDYWxsZWQoKQogewotICAgIHJldHVybiBm YWxzZTsKLX0KLQotYm9vbCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc2luZ0RhdGEoKSBj b25zdAotewotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gbV9maW5pc2hXYXNDYWxsZWQ7 CiB9CiAKIHZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCkK IHsKKyAgICBTY3JpcHRhYmxlRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCk7 CiB9CiAKIHZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnN0b3BQYXJzaW5nKCkKIHsKKyAgICBT Y3JpcHRhYmxlRG9jdW1lbnRQYXJzZXI6OnN0b3BQYXJzaW5nKCk7CiB9CiAKIGJvb2wgTmV3WE1M RG9jdW1lbnRQYXJzZXI6OmlzV2FpdGluZ0ZvclNjcmlwdHMoKSBjb25zdApAQCAtMTE3LDQgKzE2 OCwyNzUgQEAgdm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5n Rm9yU3R5bGVzaGVldHMoKQogewogfQogCit2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpwdXNo Q3VycmVudE5vZGUoQ29udGFpbmVyTm9kZSogbikKK3sKKyAgICBBU1NFUlQobik7CisgICAgQVNT RVJUKG1fY3VycmVudE5vZGUpOworICAgIGlmIChuICE9IGRvY3VtZW50KCkpCisgICAgICAgIG4t PnJlZigpOworCisgICAgbV9jdXJyZW50Tm9kZUl0ZW0ubV9ub2RlID0gbjsKKyAgICBtX2N1cnJl bnROb2RlU3RhY2suYXBwZW5kKG1fY3VycmVudE5vZGVJdGVtKTsKKyAgICBtX2N1cnJlbnROb2Rl ID0gbjsKKyAgICAvLyBGSVhNRTogaXMgdGhlcmUgYSBtYXhpbXVtIERPTSBkZXB0aAorfQorCit2 b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpwb3BDdXJyZW50Tm9kZSgpCit7CisgICAgaWYgKCFt X2N1cnJlbnROb2RlKQorICAgICAgICByZXR1cm47CisgICAgQVNTRVJUKG1fY3VycmVudE5vZGVT dGFjay5zaXplKCkpOworCisgICAgaWYgKG1fY3VycmVudE5vZGUgIT0gZG9jdW1lbnQoKSkKKyAg ICAgICAgbV9jdXJyZW50Tm9kZS0+ZGVyZWYoKTsKKworICAgIG1fY3VycmVudE5vZGVTdGFjay5y ZW1vdmVMYXN0KCk7CisgICAgbV9jdXJyZW50Tm9kZUl0ZW0gPSBtX2N1cnJlbnROb2RlU3RhY2su bGFzdCgpOworICAgIG1fY3VycmVudE5vZGUgPSBtX2N1cnJlbnROb2RlSXRlbS5tX25vZGU7Cit9 CisKK3ZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NQcm9jZXNzaW5nSW5zdHJ1Y3Rp b24oY29uc3QgV2ViQ29yZTo6QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIC8vIEZJWE1F OiBmYWxsIGJhY2sgaWYgd2UgY2FuJ3QgaGFuZGxlIHRoZSBQSSBvdXJzZWxmCisKKyAgICBSZWZQ dHI8UHJvY2Vzc2luZ0luc3RydWN0aW9uPiBwaSA9IFByb2Nlc3NpbmdJbnN0cnVjdGlvbjo6Y3Jl YXRlKGRvY3VtZW50KCksIHRva2VuLnRhcmdldCgpLCB0b2tlbi5kYXRhKCkpOworICAgIG1fY3Vy cmVudE5vZGUtPnBhcnNlckFkZENoaWxkKHBpLmdldCgpKTsKKyAgICBpZiAoIXBpLT5hdHRhY2hl ZCgpKQorICAgICAgICBwaS0+YXR0YWNoKCk7Cit9CisKK3ZvaWQgTmV3WE1MRG9jdW1lbnRQYXJz ZXI6OnByb2Nlc3NYTUxEZWNsYXJhdGlvbihjb25zdCBXZWJDb3JlOjpBdG9taWNYTUxUb2tlbiYg dG9rZW4pCit7CisgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CisKKyAgICBkb2N1bWVudCgpLT5z ZXRYTUxWZXJzaW9uKFN0cmluZzo6YWRvcHQodG9rZW4ueG1sVmVyc2lvbigpKSwgZWMpOworICAg IGRvY3VtZW50KCktPnNldFhNTFN0YW5kYWxvbmUodG9rZW4ueG1sU3RhbmRhbG9uZSgpLCBlYyk7 CisgICAgLy8gRklYTUU6IGhvdyBzaG91bGQgdGhpcyBiZWhhdmUgaWYgc3RhbmRhbG9uZSBpcyBu b3Qgc3BlY2lmaWVkPworICAgIC8vIEZJWE1FOiBzZXQgZW5jb2RpbmcKK30KKwordm9pZCBOZXdY TUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc0RPQ1RZUEUoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRv a2VuKQoreworICAgIFN0cmluZyBleHRJZCh0b2tlbi5wdWJsaWNJZGVudGlmaWVyKCkuZGF0YSgp LCB0b2tlbi5wdWJsaWNJZGVudGlmaWVyKCkuc2l6ZSgpKTsKKyAgICBTdHJpbmcgc3lzSWQodG9r ZW4uc3lzdGVtSWRlbnRpZmllcigpLmRhdGEoKSwgdG9rZW4uc3lzdGVtSWRlbnRpZmllcigpLnNp emUoKSk7CisgICAgUmVmUHRyPERvY3VtZW50VHlwZT4gZG9jdHlwZSA9IERvY3VtZW50VHlwZTo6 Y3JlYXRlKGRvY3VtZW50KCksIHRva2VuLm5hbWUoKSwgZXh0SWQsIHN5c0lkKTsKKyAgICBkb2N1 bWVudCgpLT5zZXREb2NUeXBlKGRvY3R5cGUpOworCisgICAgaWYgKChleHRJZCA9PSAiLS8vVzND Ly9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iKQorICAgICAgICB8fCAoZXh0SWQgPT0g Ii0vL1czQy8vRFREIFhIVE1MIDEuMS8vRU4iKQorICAgICAgICB8fCAoZXh0SWQgPT0gIi0vL1cz Qy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIikKKyAgICAgICAgfHwgKGV4dElkID09ICItLy9X M0MvL0RURCBYSFRNTCAxLjAgRnJhbWVzZXQvL0VOIikKKyAgICAgICAgfHwgKGV4dElkID09ICIt Ly9XM0MvL0RURCBYSFRNTCBCYXNpYyAxLjAvL0VOIikKKyAgICAgICAgfHwgKGV4dElkID09ICIt Ly9XM0MvL0RURCBYSFRNTCAxLjEgcGx1cyBNYXRoTUwgMi4wLy9FTiIpCisgICAgICAgIHx8IChl eHRJZCA9PSAiLS8vVzNDLy9EVEQgWEhUTUwgMS4xIHBsdXMgTWF0aE1MIDIuMCBwbHVzIFNWRyAx LjEvL0VOIikKKyAgICAgICAgfHwgKGV4dElkID09ICItLy9XQVBGT1JVTS8vRFREIFhIVE1MIE1v YmlsZSAxLjAvL0VOIikKKyAgICAgICApCisgICAgICAgIG1faXNYSFRNTCA9IHRydWU7Cit9CisK K3ZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NTdGFydFRhZyhjb25zdCBBdG9taWNY TUxUb2tlbiYgdG9rZW4pCit7CisgICAgZXhpdFRleHQoKTsKKworICAgIGJvb2wgaXNGaXJzdEVs ZW1lbnQgPSAhbV9zYXdGaXJzdEVsZW1lbnQ7CisgICAgbV9zYXdGaXJzdEVsZW1lbnQgPSB0cnVl OworCisgICAgaWYgKHRva2VuLmF0dHJpYnV0ZXMoKSkgeworICAgICAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgdG9rZW4uYXR0cmlidXRlcygpLT5sZW5ndGgoKTsgKytpKSB7CisgICAgICAg ICAgICBBdHRyaWJ1dGUqIGF0dHJpYnV0ZSA9IHRva2VuLmF0dHJpYnV0ZXMoKS0+YXR0cmlidXRl SXRlbShpKTsKKyAgICAgICAgICAgIGlmIChhdHRyaWJ1dGUtPm5hbWUoKS5wcmVmaXgoKSA9PSAi eG1sbnMiKQorICAgICAgICAgICAgICAgIG1fY3VycmVudE5vZGVJdGVtLnNldE5hbWVzcGFjZVVS SShhdHRyaWJ1dGUtPm5hbWUoKS5sb2NhbE5hbWUoKSwgYXR0cmlidXRlLT52YWx1ZSgpKTsKKyAg ICAgICAgICAgIGVsc2UgaWYgKGF0dHJpYnV0ZS0+bmFtZSgpID09ICJ4bWxucyIpCisgICAgICAg ICAgICAgICAgbV9jdXJyZW50Tm9kZUl0ZW0ubV9uYW1lc3BhY2UgPSBhdHRyaWJ1dGUtPnZhbHVl KCk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBRdWFsaWZpZWROYW1lIHFOYW1lKHRva2VuLnBy ZWZpeCgpLCB0b2tlbi5uYW1lKCksIG5hbWVzcGFjZUZvclByZWZpeCh0b2tlbi5wcmVmaXgoKSwg bV9jdXJyZW50Tm9kZUl0ZW0ubV9uYW1lc3BhY2UpKTsKKyAgICBSZWZQdHI8RWxlbWVudD4gbmV3 RWxlbWVudCA9IGRvY3VtZW50KCktPmNyZWF0ZUVsZW1lbnQocU5hbWUsIHRydWUpOworICAgIGlm ICghbmV3RWxlbWVudCkgeworICAgICAgICBzdG9wUGFyc2luZygpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgaWYgKHRva2VuLmF0dHJpYnV0ZXMoKSkgeworICAgICAgICBmb3IgKHVu c2lnbmVkIGkgPSAwOyBpIDwgdG9rZW4uYXR0cmlidXRlcygpLT5sZW5ndGgoKTsgKytpKSB7Cisg ICAgICAgICAgICBBdHRyaWJ1dGUqIGF0dHJpYnV0ZSA9IHRva2VuLmF0dHJpYnV0ZXMoKS0+YXR0 cmlidXRlSXRlbShpKTsKKyAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAg ICAgICAgaWYgKGF0dHJpYnV0ZS0+bmFtZSgpLnByZWZpeCgpID09ICJ4bWxucyIpCisgICAgICAg ICAgICAgICAgbmV3RWxlbWVudC0+c2V0QXR0cmlidXRlTlMoWE1MTlNOYW1lczo6eG1sbnNOYW1l c3BhY2VVUkksICJ4bWxuczoiICsgYXR0cmlidXRlLT5uYW1lKCkubG9jYWxOYW1lKCksIGF0dHJp YnV0ZS0+dmFsdWUoKSwgZWMpOworICAgICAgICAgICAgZWxzZSBpZiAoYXR0cmlidXRlLT5uYW1l KCkgPT0gInhtbG5zIikKKyAgICAgICAgICAgICAgICBuZXdFbGVtZW50LT5zZXRBdHRyaWJ1dGVO UyhYTUxOU05hbWVzOjp4bWxuc05hbWVzcGFjZVVSSSwgeG1sbnNBdG9tLCBhdHRyaWJ1dGUtPnZh bHVlKCksIGVjKTsKKyAgICAgICAgICAgIGVsc2UgeworICAgICAgICAgICAgICAgIFF1YWxpZmll ZE5hbWUgcU5hbWUoYXR0cmlidXRlLT5wcmVmaXgoKSwgYXR0cmlidXRlLT5sb2NhbE5hbWUoKSwg bmFtZXNwYWNlRm9yUHJlZml4KGF0dHJpYnV0ZS0+cHJlZml4KCksIG51bGxBdG9tKSk7CisgICAg ICAgICAgICAgICAgbmV3RWxlbWVudC0+c2V0QXR0cmlidXRlKHFOYW1lLCBhdHRyaWJ1dGUtPnZh bHVlKCkpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgbmV3RWxlbWVu dC0+YmVnaW5QYXJzaW5nQ2hpbGRyZW4oKTsKKyAgICBtX2N1cnJlbnROb2RlLT5wYXJzZXJBZGRD aGlsZChuZXdFbGVtZW50LmdldCgpKTsKKworICAgIGlmICh0b2tlbi5zZWxmQ2xvc2luZygpKQor ICAgICAgICBuZXdFbGVtZW50LT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsKKyAgICBlbHNlCisg ICAgICAgIHB1c2hDdXJyZW50Tm9kZShuZXdFbGVtZW50LmdldCgpKTsKKworICAgIGlmICghbmV3 RWxlbWVudC0+YXR0YWNoZWQoKSkKKyAgICAgICAgbmV3RWxlbWVudC0+YXR0YWNoKCk7CisKKyAg ICBpZiAoaXNGaXJzdEVsZW1lbnQgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKSkKKyAgICAgICAgZG9j dW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCktPmRpc3BhdGNoRG9jdW1lbnRFbGVtZW50QXZhaWxh YmxlKCk7CisKKyAgICBtX2N1cnJlbnROb2RlSXRlbSA9IG1fY3VycmVudE5vZGVTdGFjay5sYXN0 KCk7Cit9CisKK3ZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NFbmRUYWcoY29uc3Qg QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBDb250YWlu ZXJOb2RlKiBuID0gbV9jdXJyZW50Tm9kZTsKKyAgICBuLT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4o KTsKKworICAgIGlmICghbi0+aGFzVGFnTmFtZShRdWFsaWZpZWROYW1lKHRva2VuLnByZWZpeCgp LCB0b2tlbi5uYW1lKCksIG5hbWVzcGFjZUZvclByZWZpeCh0b2tlbi5wcmVmaXgoKSwgbV9jdXJy ZW50Tm9kZUl0ZW0ubV9uYW1lc3BhY2UpKSkpIHsKKyAgICAgICAgc3RvcFBhcnNpbmcoKTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHBvcEN1cnJlbnROb2RlKCk7Cit9CisKK3ZvaWQg TmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NDaGFyYWN0ZXIoY29uc3QgQXRvbWljWE1MVG9r ZW4mIHRva2VuKQoreworICAgIGVudGVyVGV4dCgpOworCisgICAgRXhjZXB0aW9uQ29kZSBlYyA9 IDA7CisgICAgaWYgKG1fbGVhZlRleHROb2RlKQorICAgICAgICBtX2xlYWZUZXh0Tm9kZS0+YXBw ZW5kRGF0YShTdHJpbmcodG9rZW4uY2hhcmFjdGVycygpLmRhdGEoKSwgdG9rZW4uY2hhcmFjdGVy cygpLnNpemUoKSksIGVjKTsKK30KKwordm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vz c0NEQVRBKGNvbnN0IFdlYkNvcmU6OkF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICBSZWZQ dHI8Q0RBVEFTZWN0aW9uPiBjZGF0YSA9IENEQVRBU2VjdGlvbjo6Y3JlYXRlKGRvY3VtZW50KCks IHRva2VuLmRhdGEoKSk7CisgICAgbV9jdXJyZW50Tm9kZS0+cGFyc2VyQWRkQ2hpbGQoY2RhdGEu Z2V0KCkpOworICAgIGlmICghY2RhdGEtPmF0dGFjaGVkKCkpCisgICAgICAgIGNkYXRhLT5hdHRh Y2goKTsKK30KKwordm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc0NvbW1lbnQoY29u c3QgV2ViQ29yZTo6QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIFJlZlB0cjxDb21tZW50 PiBjb21tZW50ID0gQ29tbWVudDo6Y3JlYXRlKGRvY3VtZW50KCksIHRva2VuLmNvbW1lbnQoKSk7 CisgICAgbV9jdXJyZW50Tm9kZS0+cGFyc2VyQWRkQ2hpbGQoY29tbWVudC5nZXQoKSk7CisgICAg aWYgKCFjb21tZW50LT5hdHRhY2hlZCgpKQorICAgICAgICBjb21tZW50LT5hdHRhY2goKTsKK30K Kwordm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc0VudGl0eShjb25zdCBXZWJDb3Jl OjpBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgZW50ZXJUZXh0KCk7CisKKyAgICBpZiAo IW1fbGVhZlRleHROb2RlKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBGSVhNRTogc3VwcG9y dCBpbnRlcm5hbCBzdWJzZXQKKyAgICBpZiAobV9pc1hIVE1MKSB7CisgICAgICAgIEhUTUxFbnRp dHlTZWFyY2ggc2VhcmNoOworICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUgPSB0b2tl bi5uYW1lKCk7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBuYW1lLmxlbmd0aCgp OyArK2kpIHsKKyAgICAgICAgICAgIHNlYXJjaC5hZHZhbmNlKG5hbWVbaV0pOworICAgICAgICAg ICAgaWYgKCFzZWFyY2guaXNFbnRpdHlQcmVmaXgoKSkKKyAgICAgICAgICAgICAgICBzdG9wUGFy c2luZygpOworICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICBzZWFy Y2guYWR2YW5jZSgnOycpOworICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICAgICAg VUNoYXIzMiBlbnRpdHlWYWx1ZSA9IHNlYXJjaC5jdXJyZW50VmFsdWUoKTsKKyAgICAgICAgaWYg KGVudGl0eVZhbHVlIDw9IDB4RkZGRikKKyAgICAgICAgICAgIG1fbGVhZlRleHROb2RlLT5hcHBl bmREYXRhKFN0cmluZyhyZWludGVycHJldF9jYXN0PFVDaGFyKj4oJmVudGl0eVZhbHVlKSwgMSks IGVjKTsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBVQ2hhciB1dGYxNlBhaXJbMl0gPSB7 IFUxNl9MRUFEKGVudGl0eVZhbHVlKSwgVTE2X1RSQUlMKGVudGl0eVZhbHVlKSB9OworICAgICAg ICAgICAgbV9sZWFmVGV4dE5vZGUtPmFwcGVuZERhdGEoU3RyaW5nKHV0ZjE2UGFpciwgMiksIGVj KTsKKyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIEF0b21pY1N0cmluZyBhbXAoImFt cCIpOworICAgICAgICBBdG9taWNTdHJpbmcgYXBvcygiYXBvcyIpOworICAgICAgICBBdG9taWNT dHJpbmcgZ3QoImd0Iik7CisgICAgICAgIEF0b21pY1N0cmluZyBsdCgibHQiKTsKKyAgICAgICAg QXRvbWljU3RyaW5nIHF1b3QoInF1b3QiKTsKKyAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7 CisKKyAgICAgICAgaWYgKHRva2VuLm5hbWUoKSA9PSBhbXApCisgICAgICAgICAgICBtX2xlYWZU ZXh0Tm9kZS0+YXBwZW5kRGF0YSgiJiIsIGVjKTsKKyAgICAgICAgZWxzZSBpZiAodG9rZW4ubmFt ZSgpID09IGFwb3MpCisgICAgICAgICAgICBtX2xlYWZUZXh0Tm9kZS0+YXBwZW5kRGF0YSgiJyIs IGVjKTsKKyAgICAgICAgZWxzZSBpZiAodG9rZW4ubmFtZSgpID09IGd0KQorICAgICAgICAgICAg bV9sZWFmVGV4dE5vZGUtPmFwcGVuZERhdGEoIj4iLCBlYyk7CisgICAgICAgIGVsc2UgaWYgKHRv a2VuLm5hbWUoKSA9PSBsdCkKKyAgICAgICAgICAgIG1fbGVhZlRleHROb2RlLT5hcHBlbmREYXRh KCI8IiwgZWMpOworICAgICAgICBlbHNlIGlmICh0b2tlbi5uYW1lKCkgPT0gcXVvdCkKKyAgICAg ICAgICAgIG1fbGVhZlRleHROb2RlLT5hcHBlbmREYXRhKCJcIiIsIGVjKTsKKyAgICAgICAgZWxz ZSB7CisgICAgICAgICAgICBzdG9wUGFyc2luZygpOworICAgICAgICAgICAgcmV0dXJuOworICAg ICAgICB9CisgICAgfQorfQorCit2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjplbnRlclRleHQo KQoreworICAgIGlmICghbV9zYXdGaXJzdEVsZW1lbnQpIHsKKyAgICAgICAgLy8gRklYTUU6IGVu c3VyZSBpdCdzIGp1c3Qgd2hpdGVzcGFjZQorICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg aWYgKCFtX2xlYWZUZXh0Tm9kZSkgeworICAgICAgICBtX2xlYWZUZXh0Tm9kZSA9IFRleHQ6OmNy ZWF0ZShkb2N1bWVudCgpLCAiIik7CisgICAgICAgIG1fY3VycmVudE5vZGUtPnBhcnNlckFkZENo aWxkKG1fbGVhZlRleHROb2RlLmdldCgpKTsKKyAgICB9Cit9CisKK3ZvaWQgTmV3WE1MRG9jdW1l bnRQYXJzZXI6OmV4aXRUZXh0KCkKK3sKKyAgICBpZiAobV9sZWFmVGV4dE5vZGUgJiYgIW1fbGVh ZlRleHROb2RlLT5hdHRhY2hlZCgpKQorICAgICAgICBtX2xlYWZUZXh0Tm9kZS0+YXR0YWNoKCk7 CisKKyAgICBtX2xlYWZUZXh0Tm9kZSA9IDA7Cit9CisKK0F0b21pY1N0cmluZyBOZXdYTUxEb2N1 bWVudFBhcnNlcjo6bmFtZXNwYWNlRm9yUHJlZml4KEF0b21pY1N0cmluZyBwcmVmaXgsIEF0b21p Y1N0cmluZyBmYWxsYmFjaykKK3sKKyAgICBBdG9taWNTdHJpbmcgdXJpID0gZmFsbGJhY2s7Cisg ICAgaWYgKCFwcmVmaXguaXNOdWxsKCkpIHsKKyAgICAgICAgaWYgKG1fY3VycmVudE5vZGVJdGVt Lmhhc05hbWVzcGFjZVVSSShwcmVmaXgpKQorICAgICAgICAgICAgdXJpID0gbV9jdXJyZW50Tm9k ZUl0ZW0ubmFtZXNwYWNlVVJJKHByZWZpeCk7CisgICAgfQorCisgICAgcmV0dXJuIHVyaTsKK30K KworTmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5vZGVTdGFja0l0ZW06Ok5vZGVTdGFja0l0ZW0oQ29u dGFpbmVyTm9kZSogbiwgTm9kZVN0YWNrSXRlbSogcGFyZW50KQorICAgIDogbV9ub2RlKG4pCit7 CisgICAgaWYgKHBhcmVudCkgeworICAgICAgICBtX25hbWVzcGFjZSA9IHBhcmVudC0+bV9uYW1l c3BhY2U7CisgICAgICAgIG1fc2NvcGVkTmFtZXNwYWNlcyA9IHBhcmVudC0+bV9zY29wZWROYW1l c3BhY2VzOworICAgIH0KK30KKworYm9vbCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6Tm9kZVN0YWNr SXRlbTo6aGFzTmFtZXNwYWNlVVJJKEF0b21pY1N0cmluZyBwcmVmaXgpCit7CisgICAgcmV0dXJu IG1fc2NvcGVkTmFtZXNwYWNlcy5jb250YWlucyhwcmVmaXgpOworfQorCitBdG9taWNTdHJpbmcg TmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5vZGVTdGFja0l0ZW06Om5hbWVzcGFjZVVSSShBdG9taWNT dHJpbmcgcHJlZml4KQoreworICAgIGlmIChtX3Njb3BlZE5hbWVzcGFjZXMuY29udGFpbnMocHJl Zml4KSkKKyAgICAgICAgcmV0dXJuIG1fc2NvcGVkTmFtZXNwYWNlcy5nZXQocHJlZml4KTsKKyAg ICByZXR1cm4gbnVsbEF0b207Cit9CisKK3ZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5vZGVT dGFja0l0ZW06OnNldE5hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgcHJlZml4LCBBdG9taWNTdHJp bmcgdXJpKQoreworICAgIG1fc2NvcGVkTmFtZXNwYWNlcy5zZXQocHJlZml4LCB1cmkpOworfQor CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50 UGFyc2VyLmggYi9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2Vy LmgKaW5kZXggMzU3NTc1NGRkYTNmOWE0YjUxMjhmZjQ4Y2I0MDY4MDc5MTMzZjEwZC4uOGYyM2Jh ZDgyN2ZlM2E2YjA2ZjFmYzcwYTg3YmU5NjJhNWNhZTk2YyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMzYsNiArMzYsNyBAQAog bmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBEb2N1bWVudDsKK2NsYXNzIENvbnRhaW5lck5v ZGU7CiAKIGNsYXNzIE5ld1hNTERvY3VtZW50UGFyc2VyIDogcHVibGljIFNjcmlwdGFibGVEb2N1 bWVudFBhcnNlciB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CkBAIC00NCw3ICs0NSw3 IEBAIHB1YmxpYzoKICAgICB7CiAgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgTmV3WE1MRG9j dW1lbnRQYXJzZXIoZG9jdW1lbnQpKTsKICAgICB9Ci0gICAgCisKICAgICB2aXJ0dWFsIFRleHRQ b3NpdGlvbjAgdGV4dFBvc2l0aW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBpbnQgbGluZU51bWJl cigpIGNvbnN0OwogCkBAIC01MywyMyArNTQsNjYgQEAgcHJvdGVjdGVkOgogICAgIHZpcnR1YWwg dm9pZCBhcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJik7CiAgICAgdmlydHVhbCB2b2lkIGZp bmlzaCgpOwogCi0KIHByaXZhdGU6CisgICAgY2xhc3MgTm9kZVN0YWNrSXRlbSB7CisgICAgcHVi bGljOgorICAgICAgICBOb2RlU3RhY2tJdGVtKENvbnRhaW5lck5vZGUqIGl0ZW0sIE5vZGVTdGFj a0l0ZW0qIHBhcmVudCA9IDApOworCisgICAgICAgIGJvb2wgaGFzTmFtZXNwYWNlVVJJKEF0b21p Y1N0cmluZyBwcmVmaXgpOworICAgICAgICBBdG9taWNTdHJpbmcgbmFtZXNwYWNlVVJJKEF0b21p Y1N0cmluZyBwcmVmaXgpOworICAgICAgICB2b2lkIHNldE5hbWVzcGFjZVVSSShBdG9taWNTdHJp bmcgcHJlZml4LCBBdG9taWNTdHJpbmcgdXJpKTsKKworICAgICAgICBDb250YWluZXJOb2RlKiBt X25vZGU7CisgICAgICAgIEF0b21pY1N0cmluZyBtX25hbWVzcGFjZTsKKworICAgIHByaXZhdGU6 CisgICAgICAgIEhhc2hNYXA8QXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmc+IG1fc2NvcGVkTmFt ZXNwYWNlczsKKyAgICB9OworCiAgICAgTmV3WE1MRG9jdW1lbnRQYXJzZXIoRG9jdW1lbnQqKTsK KyAgICB2aXJ0dWFsIH5OZXdYTUxEb2N1bWVudFBhcnNlcigpIHsgfQogCiAgICAgLy8gRG9jdW1l bnRQYXJzZXIKICAgICB2aXJ0dWFsIHZvaWQgZGV0YWNoKCk7CiAgICAgdmlydHVhbCBib29sIGhh c0luc2VydGlvblBvaW50KCk7CiAgICAgdmlydHVhbCBib29sIGZpbmlzaFdhc0NhbGxlZCgpOwot ICAgIHZpcnR1YWwgYm9vbCBwcm9jZXNzaW5nRGF0YSgpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9p ZCBwcmVwYXJlVG9TdG9wUGFyc2luZygpOwogICAgIHZpcnR1YWwgdm9pZCBzdG9wUGFyc2luZygp OwogICAgIHZpcnR1YWwgYm9vbCBpc1dhaXRpbmdGb3JTY3JpcHRzKCkgY29uc3Q7CiAgICAgdmly dHVhbCBib29sIGlzRXhlY3V0aW5nU2NyaXB0KCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIGV4 ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCk7CiAKKyAgICB2b2lkIHB1c2hDdXJy ZW50Tm9kZShDb250YWluZXJOb2RlKik7CisgICAgdm9pZCBwb3BDdXJyZW50Tm9kZSgpOworCisg ICAgdm9pZCBwcm9jZXNzUHJvY2Vzc2luZ0luc3RydWN0aW9uKGNvbnN0IEF0b21pY1hNTFRva2Vu Jik7CisgICAgdm9pZCBwcm9jZXNzWE1MRGVjbGFyYXRpb24oY29uc3QgQXRvbWljWE1MVG9rZW4m KTsKKyAgICB2b2lkIHByb2Nlc3NET0NUWVBFKGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisgICAg dm9pZCBwcm9jZXNzU3RhcnRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHBy b2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NDREFU QShjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0NoYXJhY3Rlcihjb25z dCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0NvbW1lbnQoY29uc3QgQXRvbWlj WE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NFbnRpdHkoY29uc3QgQXRvbWljWE1MVG9rZW4m KTsKKworICAgIHZvaWQgZW50ZXJUZXh0KCk7CisgICAgdm9pZCBleGl0VGV4dCgpOworCisgICAg QXRvbWljU3RyaW5nIG5hbWVzcGFjZUZvclByZWZpeChBdG9taWNTdHJpbmcgcHJlZml4LCBBdG9t aWNTdHJpbmcgZmFsbGJhY2spOworCisgICAgYm9vbCBtX2lzWEhUTUw7CisKKyAgICBib29sIG1f ZmluaXNoV2FzQ2FsbGVkOworCiAgICAgT3duUHRyPFhNTFRva2VuaXplcj4gbV90b2tlbml6ZXI7 CiAgICAgWE1MVG9rZW4gbV90b2tlbjsKKworICAgIGJvb2wgbV9zYXdGaXJzdEVsZW1lbnQ7Cisg ICAgQ29udGFpbmVyTm9kZSogbV9jdXJyZW50Tm9kZTsKKyAgICBOb2RlU3RhY2tJdGVtIG1fY3Vy cmVudE5vZGVJdGVtOworICAgIFZlY3RvcjxOb2RlU3RhY2tJdGVtPiBtX2N1cnJlbnROb2RlU3Rh Y2s7CisKKyAgICBSZWZQdHI8VGV4dD4gbV9sZWFmVGV4dE5vZGU7CiB9OwogCiB9Cg== 103292 2011-08-08 14:23:36 -0700 2011-08-08 18:15:58 -0700 Patch bug-65803-20110808142334.patch text/plain 31690 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogOTI2MDMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2MGQwZjljMGRjNjMyMmY3 NTgwY2E0ZDEwNjQ4YTdlZWZiY2E4YTM4Li5hNmNkYzZmYTc4NTQxNWZjNTAyZTQ2NTYwYjg5YmVk MTc0MzA0ZDNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTEtMDgtMDggIEplZmZy ZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBJbml0aWFsIHBhc3MgYXQgYSBu ZXcgWE1MIHRyZWUgYnVpbGRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NjU4MDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogV2ViQ29yZS5neXBp OgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoK KyAgICAgICAgKiB4bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjpOZXdYTUxEb2N1bWVudFBhcnNlcik6Cisg ICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6fk5ld1hNTERvY3VtZW50UGFy c2VyKToKKyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQpOgor ICAgICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCk6CisgICAgICAg IChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoV2FzQ2FsbGVkKToKKyAgICAg ICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjpwcmVwYXJlVG9TdG9wUGFyc2luZyk6 CisgICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6c3RvcFBhcnNpbmcpOgor ICAgICAgICAqIHhtbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiB4 bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpY TUxUcmVlQnVpbGRlcjo6WE1MVHJlZUJ1aWxkZXIpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJl ZUJ1aWxkZXI6OnByb2Nlc3NUb2tlbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRl cjo6cHVzaEN1cnJlbnROb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpw b3BDdXJyZW50Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vz c1Byb2Nlc3NpbmdJbnN0cnVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRl cjo6cHJvY2Vzc1hNTERlY2xhcmF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWls ZGVyOjpwcm9jZXNzRE9DVFlQRSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6 cHJvY2Vzc1N0YXJ0VGFnKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9j ZXNzRW5kVGFnKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ2hh cmFjdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ0RBVEEp OgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NDb21tZW50KToKKyAg ICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzRW50aXR5KToKKyAgICAgICAg KFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzTmFtZXNwYWNlcyk6CisgICAgICAgIChX ZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0F0dHJpYnV0ZXMpOgorICAgICAgICAoV2Vi Q29yZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NYTUxFbnRpdHkpOgorICAgICAgICAoV2ViQ29y ZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NIVE1MRW50aXR5KToKKyAgICAgICAgKFdlYkNvcmU6 OlhNTFRyZWVCdWlsZGVyOjplbnRlclRleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1 aWxkZXI6OmV4aXRUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpuYW1l c3BhY2VGb3JQcmVmaXgpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVT dGFja0l0ZW06Ok5vZGVTdGFja0l0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxk ZXI6Ok5vZGVTdGFja0l0ZW06Omhhc05hbWVzcGFjZVVSSSk6CisgICAgICAgIChXZWJDb3JlOjpY TUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6bmFtZXNwYWNlVVJJKToKKyAgICAgICAgKFdl YkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpzZXROYW1lc3BhY2VVUkkpOgor ICAgICAgICAqIHhtbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaDogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRy ZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpuYW1lc3BhY2VVUkkpOgorICAgICAgICAoV2ViQ29y ZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06OnNldE5hbWVzcGFjZVVSSSk6CisgICAg ICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6bm9kZUl0ZW0pOgor ICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06OnNldE5vZGVJ dGVtKToKKwogMjAxMS0wOC0wOCAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAg ICAgICAgIEJ1aWxkIGZpeC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxl Lmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IGEwNjhj MDI0NDhhNzYwNTM3N2Q3ZTA4NDY0MzA3OGVlNjQ5OGJkNGQuLmMwYmI5NWE2ZmY3NDRjYTQwMTZj MjA0YjcxNDkyYTliYTYzNTgwMjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2Vm aWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAt MzgzNyw2ICszODM3LDggQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS94 bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIv WE1MVG9rZW5pemVyLmggXAogCVNvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVG9rZW4uaCBc CisJU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9YTUxUcmVlQnVpbGRlci5jcHAgXAorCVNvdXJj ZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaCBcCiAJU291cmNlL1dlYkNvcmUv eG1sL0RPTVBhcnNlci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3htbC9ET01QYXJzZXIuaCBcCiAJ U291cmNlL1dlYkNvcmUveG1sL05hdGl2ZVhQYXRoTlNSZXNvbHZlci5jcHAgXApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5n eXBpCmluZGV4IDhkMGRmZjVjYjFmNTcxYjcyMzI4MTJkNzQ2ZmM4YTk5NWY1YjhmMzcuLjViMjcy N2M5YzFhZjYzMmQwN2Y2ZDMwZDFkMDgzODgwMzRlMjAxYjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAg LTUxNDIsNiArNTE0Miw4IEBACiAgICAgICAgICAgICAneG1sL3BhcnNlci9YTUxUb2tlbml6ZXIu Y3BwJywKICAgICAgICAgICAgICd4bWwvcGFyc2VyL1hNTFRva2VuaXplci5oJywKICAgICAgICAg ICAgICd4bWwvcGFyc2VyL1hNTFRva2VuLmgnLAorICAgICAgICAgICAgJ3htbC9wYXJzZXIvWE1M VHJlZUJ1aWxkZXIuY3BwJywKKyAgICAgICAgICAgICd4bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVy LmgnLAogICAgICAgICAgICAgJ3htbC9ET01QYXJzZXIuY3BwJywKICAgICAgICAgICAgICd4bWwv RE9NUGFyc2VyLmgnLAogICAgICAgICAgICAgJ3htbC9OYXRpdmVYUGF0aE5TUmVzb2x2ZXIuY3Bw JywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvU291cmNlL1dlYkNv cmUvV2ViQ29yZS5wcm8KaW5kZXggYTZmODlhNGI2MmZhYmUwZWM3YzcxZTA4YzA5OTUyZjBlZTRk MDE4Zi4uZmM1Njk2MjNhYjJlMzgyZDgxOWExMWFhMjllYWEzMzg1ZDdkOTEwMSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5wcm8KQEAgLTEyMDcsNyArMTIwNyw4IEBAIFNPVVJDRVMgKz0gXAogICAgIHhtbC9wYXJzZXIv TmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwIFwKICAgICB4bWwvcGFyc2VyL1hNTENoYXJhY3RlclJl ZmVyZW5jZVBhcnNlci5jcHAgXAogICAgIHhtbC9wYXJzZXIvWE1MRG9jdW1lbnRQYXJzZXIuY3Bw IFwKLSAgICB4bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAKKyAgICB4bWwvcGFyc2VyL1hNTFRv a2VuaXplci5jcHAgXAorICAgIHhtbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuY3BwCiAKIEhFQURF UlMgKz0gXAogICAgIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eUFSSUFHcmlkQ2VsbC5oIFwK QEAgLTI1MTksNiArMjUyMCw3IEBAIEhFQURFUlMgKz0gXAogICAgIHhtbC9wYXJzZXIvWE1MRG9j dW1lbnRQYXJzZXIuaCBcCiAgICAgeG1sL3BhcnNlci9YTUxUb2tlbml6ZXIuaCBcCiAgICAgeG1s L3BhcnNlci9YTUxUb2tlbi5oIFwKKyAgICB4bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmggXAog ICAgIHhtbC9ET01QYXJzZXIuaCBcCiAgICAgeG1sL05hdGl2ZVhQYXRoTlNSZXNvbHZlci5oIFwK ICAgICB4bWwvWE1MSHR0cFJlcXVlc3QuaCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNw cm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGIyZTY5ZTBlZWE1ZjYxZmY0NThjZTczN2FjOWQ1ZTlm MzZhYTVhYjAuLmEwNjZmNjk1ZDYwZmMxOWY1ZDM1NGFlYjFiOWE4OThiY2IzZTMzYTYgMTAwNzU1 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC00Mjc0NSw2 ICs0Mjc0NSwxNCBAQAogCQkJCQk+CiAJCQkJPC9GaWxlPgogCQkJCTxGaWxlCisJCQkJCVJlbGF0 aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxOZXdYTUxEb2N1bWVudFBhcnNlci5oIgorCQkJCQk+CisJ CQkJPC9GaWxlPgorCQkJCTxGaWxlCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxO ZXdYTUxEb2N1bWVudFBhcnNlci5jcHAiCisJCQkJCT4KKwkJCQk8L0ZpbGU+CisJCQkJPEZpbGUK IAkJCQkJUmVsYXRpdmVQYXRoPSIuLlx4bWxccGFyc2VyXFhNTERvY3VtZW50UGFyc2VyLmNwcCIK IAkJCQkJPgogCQkJCQk8RmlsZUNvbmZpZ3VyYXRpb24KQEAgLTQyODY4LDYgKzQyODc2LDE0IEBA CiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxYTUxUb2tlbml6ZXIuaCIKIAkJCQkJ PgogCQkJCTwvRmlsZT4KKwkJCQk8RmlsZQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHhtbFxwYXJz ZXJcWE1MVHJlZUJ1aWxkZXIuaCIKKwkJCQkJPgorCQkJCTwvRmlsZT4KKwkJCQk8RmlsZQorCQkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHhtbFxwYXJzZXJcWE1MVHJlZUJ1aWxkZXIuY3BwIgorCQkJCQk+ CisJCQkJPC9GaWxlPgogCQkJPC9GaWx0ZXI+CiAJCTwvRmlsdGVyPgogCQk8RmlsdGVyCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2og Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg N2Q2ZjdhZTM5ODY5NzE1M2Y0Y2ZkZjU1OGQ2NTgzZTEwYTQzODViOC4uYmUzN2NjMWVjNmEyNDli ODQzYjBlOTc4MjQwMDhhMGZkNGI1NWZmOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNTEsNiArNTEsOCBAQAogCQkwMDAyRUM1 QTEzQzNGNjdEMDAwNDBENDcgLyogWE1MVG9rZW5pemVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDAyRUM1NzEzQzNGNjdEMDAwNDBENDcgLyogWE1M VG9rZW5pemVyLmggKi87IH07CiAJCTAwMTQ2MjhBMTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5B Y2Nlc3NFbnRyeS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSAwMDE0NjI4ODEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwICov OyB9OwogCQkwMDE0NjI4QjEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMTQ2Mjg5MTAz Q0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovOyB9OworCQkwMDM1RUJCQjEz RjA2RkYyMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMzVFQkJBMTNGMDZGRjIwMEE1NjA4OSAvKiBYTUxU cmVlQnVpbGRlci5oICovOyB9OworCQkwMDM1RUJCRTEzRjA3MTNDMDBBNTYwODkgLyogWE1MVHJl ZUJ1aWxkZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMDAzNUVCQkQxM0YwNzEzQzAwQTU2MDg5IC8qIFhNTFRyZWVCdWlsZGVyLmNwcCAqLzsgfTsK IAkJMDAzRjFGRUExMUU2QUI0MzAwODI1OEQ5IC8qIFVzZXJDb250ZW50VHlwZXMuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwM0YxRkU5MTFFNkFCNDMw MDgyNThEOSAvKiBVc2VyQ29udGVudFR5cGVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJMDBBNjI5QzExM0QwQkVDNzAwNTBBQzUyIC8qIE1hcmt1 cFRva2VuQmFzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMDBBNjI5QzAxM0QwQkVDNzAwNTBBQzUyIC8qIE1hcmt1cFRva2VuQmFzZS5oICovOyB9Owog CQkwMEI5MzE4NzEzQkE4REIzMDAzNUE5NDggLyogWE1MRG9jdW1lbnRQYXJzZXIuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDBCOTMxODExM0JBODY3 RjAwMzVBOTQ4IC8qIFhNTERvY3VtZW50UGFyc2VyLmNwcCAqLzsgfTsKQEAgLTY0ODUsNiArNjQ4 Nyw4IEBACiAJCTAwMDJFQzU3MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWE1MVG9rZW5pemVyLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTAwMTQ2Mjg4MTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nl c3NFbnRyeS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBPcmlnaW5B Y2Nlc3NFbnRyeS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTAwMTQ2Mjg5MTAz Q0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQkwMDM1RUJCQTEzRjA2RkYyMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWE1MVHJlZUJ1aWxkZXIuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKKwkJMDAzNUVCQkQxM0YwNzEzQzAwQTU2MDg5IC8qIFhNTFRyZWVC dWlsZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFhNTFRyZWVC dWlsZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDAzRjFGRTkxMUU2QUI0 MzAwODI1OEQ5IC8qIFVzZXJDb250ZW50VHlwZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gVXNlckNvbnRlbnRUeXBlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQkwMEE2MjlDMDEzRDBCRUM3MDA1MEFDNTIgLyogTWFya3VwVG9rZW5CYXNlLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE1hcmt1cFRva2VuQmFzZS5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQkwMEI5MzE4MTEzQkE4NjdGMDAzNUE5NDggLyogWE1MRG9jdW1lbnRQ YXJzZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gWE1MRG9jdW1l bnRQYXJzZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTI4NjIsNiArMTI4 NjYsOCBAQAogCQkJCTAwMDJFQzU1MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbi5oICovLAog CQkJCTAwMDJFQzU2MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIuY3BwICovLAogCQkJ CTAwMDJFQzU3MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIuaCAqLywKKwkJCQkwMDM1 RUJCRDEzRjA3MTNDMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuY3BwICovLAorCQkJCTAwMzVF QkJBMTNGMDZGRjIwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5oICovLAogCQkJKTsKIAkJCXBh dGggPSBwYXJzZXI7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpAQCAtMjMzMzAsNiArMjMz MzYsNyBAQAogCQkJCTFBQ0U1M0VCMEE4RDE4RTcwMDIyOTQ3RCAvKiBYTUxTZXJpYWxpemVyLmgg aW4gSGVhZGVycyAqLywKIAkJCQkwMDAyRUM1ODEzQzNGNjdEMDAwNDBENDcgLyogWE1MVG9rZW4u aCBpbiBIZWFkZXJzICovLAogCQkJCTAwMDJFQzVBMTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tl bml6ZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTAwMzVFQkJCMTNGMDZGRjIwMEE1NjA4OSAvKiBY TUxUcmVlQnVpbGRlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNTkwNUFEQzAxMzAyRjNDRTAwRjEx NkRGIC8qIFhNTFRyZWVWaWV3ZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTFBQjdGQzY5MEE4Qjky RUMwMEQ5RDM3QiAvKiBYUGF0aEV2YWx1YXRvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQkM2MERB NUIwRDJBMzFGNzAwQjk5MThGIC8qIFhQYXRoRXhjZXB0aW9uLmggaW4gSGVhZGVycyAqLywKQEAg LTI2MTM3LDYgKzI2MTQ0LDcgQEAKIAkJCQlFMTVBMzZEOTExMDQ1NzI3MDBCN0I2MzkgLyogWE1M TlNOYW1lcy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQUNFNTNFQTBBOEQxOEU3MDAyMjk0N0Qg LyogWE1MU2VyaWFsaXplci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkwMDAyRUM1OTEzQzNGNjdE MDAwNDBENDcgLyogWE1MVG9rZW5pemVyLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTAwMzVFQkJF MTNGMDcxM0MwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQk1OTA1QURCRjEzMDJGM0NFMDBGMTE2REYgLyogWE1MVHJlZVZpZXdlci5jcHAgaW4gU291cmNl cyAqLywKIAkJCQkxQUI3RkM2ODBBOEI5MkVDMDBEOUQzN0IgLyogWFBhdGhFdmFsdWF0b3IuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJMUFCN0ZDNkIwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoRXhw cmVzc2lvbi5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3ht bC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIvU291cmNlL1dlYkNvcmUveG1sL3Bh cnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggMmZhYzI3MTk0YWU5MGZkZTcxNzc1 ZmI5Zjk2YzU3M2M5ZGYyMGVhYy4uZDgzM2Q5Yjc5NjlmOGFmODViODI3MjY2NTBmNDBiOTQ4MmNk Mjk1NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVu dFBhcnNlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVu dFBhcnNlci5jcHAKQEAgLTI3LDEyICsyNywxOSBAQAogI2luY2x1ZGUgIk5ld1hNTERvY3VtZW50 UGFyc2VyLmgiCiAKICNpbmNsdWRlICJTZWdtZW50ZWRTdHJpbmcuaCIKKyNpbmNsdWRlICJYTUxU cmVlQnVpbGRlci5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIE5ld1hNTERvY3VtZW50UGFy c2VyOjpOZXdYTUxEb2N1bWVudFBhcnNlcihEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgOiBTY3Jp cHRhYmxlRG9jdW1lbnRQYXJzZXIoZG9jdW1lbnQpCiAgICAgLCBtX3Rva2VuaXplcihYTUxUb2tl bml6ZXI6OmNyZWF0ZSgpKQorICAgICwgbV9maW5pc2hXYXNDYWxsZWQoZmFsc2UpCisgICAgLCBt X3RyZWVCdWlsZGVyKFhNTFRyZWVCdWlsZGVyOjpjcmVhdGUodGhpcywgZG9jdW1lbnQpKQorewor fQorCitOZXdYTUxEb2N1bWVudFBhcnNlcjo6fk5ld1hNTERvY3VtZW50UGFyc2VyKCkKIHsKIH0K IApAQCAtNjMsNyArNzAsMTEgQEAgdm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKGNv bnN0IFNlZ21lbnRlZFN0cmluZyYgc3RyaW5nKQogICAgICAgICBtX3Rva2VuLnByaW50KCk7CiAj ZW5kaWYKIAotICAgICAgICBpZiAobV90b2tlbi50eXBlKCkgPT0gWE1MVG9rZW5UeXBlczo6RW5k T2ZGaWxlKQorCisgICAgICAgIEF0b21pY1hNTFRva2VuIHRva2VuKG1fdG9rZW4pOworICAgICAg ICBtX3RyZWVCdWlsZGVyLT5wcm9jZXNzVG9rZW4odG9rZW4pOworCisgICAgICAgIGlmIChtX3Rv a2VuLnR5cGUoKSA9PSBYTUxUb2tlblR5cGVzOjpFbmRPZkZpbGUgfHwgIWlzUGFyc2luZygpKQog ICAgICAgICAgICAgYnJlYWs7CiAKICAgICAgICAgbV90b2tlbi5jbGVhcigpOwpAQCAtNzMsNiAr ODQsMTIgQEAgdm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKGNvbnN0IFNlZ21lbnRl ZFN0cmluZyYgc3RyaW5nKQogCiB2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpmaW5pc2goKQog eworICAgIG1fZmluaXNoV2FzQ2FsbGVkID0gdHJ1ZTsKKworICAgIGlmIChpc1BhcnNpbmcoKSkK KyAgICAgICAgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKKyAgICBkb2N1bWVudCgpLT5zZXRSZWFk eVN0YXRlKERvY3VtZW50OjpJbnRlcmFjdGl2ZSk7CisgICAgZG9jdW1lbnQoKS0+ZmluaXNoZWRQ YXJzaW5nKCk7CiB9CiAKIHZvaWQgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OmRldGFjaCgpCkBAIC04 NywyMCArMTA0LDE3IEBAIGJvb2wgTmV3WE1MRG9jdW1lbnRQYXJzZXI6Omhhc0luc2VydGlvblBv aW50KCkKIAogYm9vbCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoV2FzQ2FsbGVkKCkKIHsK LSAgICByZXR1cm4gZmFsc2U7Ci19Ci0KLWJvb2wgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nl c3NpbmdEYXRhKCkgY29uc3QKLXsKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIG1fZmlu aXNoV2FzQ2FsbGVkOwogfQogCiB2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpwcmVwYXJlVG9T dG9wUGFyc2luZygpCiB7CisgICAgU2NyaXB0YWJsZURvY3VtZW50UGFyc2VyOjpwcmVwYXJlVG9T dG9wUGFyc2luZygpOwogfQogCiB2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2lu ZygpCiB7CisgICAgU2NyaXB0YWJsZURvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2luZygpOwogfQog CiBib29sIE5ld1hNTERvY3VtZW50UGFyc2VyOjppc1dhaXRpbmdGb3JTY3JpcHRzKCkgY29uc3QK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJz ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaApp bmRleCAzNTc1NzU0ZGRhM2Y5YTRiNTEyOGZmNDhjYjQwNjgwNzkxMzNmMTBkLi4zYzVjZWIwYzNm YzNiOGY5ZmVhNzBjNTI4ZjdmZDQwYzNmYmI5ZTYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmgKKysrIGIvU291cmNlL1dlYkNvcmUv eG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5oCkBAIC0zNiw2ICszNiw4IEBACiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIERvY3VtZW50OworY2xhc3MgQ29udGFpbmVyTm9kZTsK K2NsYXNzIFhNTFRyZWVCdWlsZGVyOwogCiBjbGFzcyBOZXdYTUxEb2N1bWVudFBhcnNlciA6IHB1 YmxpYyBTY3JpcHRhYmxlRG9jdW1lbnRQYXJzZXIgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NB VEVEOwpAQCAtNDQsMzIgKzQ2LDM1IEBAIHB1YmxpYzoKICAgICB7CiAgICAgICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTmV3WE1MRG9jdW1lbnRQYXJzZXIoZG9jdW1lbnQpKTsKICAgICB9Ci0gICAg CisKICAgICB2aXJ0dWFsIFRleHRQb3NpdGlvbjAgdGV4dFBvc2l0aW9uKCkgY29uc3Q7CiAgICAg dmlydHVhbCBpbnQgbGluZU51bWJlcigpIGNvbnN0OwotCi1wcm90ZWN0ZWQ6Ci0gICAgdmlydHVh bCB2b2lkIGluc2VydChjb25zdCBTZWdtZW50ZWRTdHJpbmcmKTsKLSAgICB2aXJ0dWFsIHZvaWQg YXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYpOwotICAgIHZpcnR1YWwgdm9pZCBmaW5pc2go KTsKLQotCi1wcml2YXRlOgotICAgIE5ld1hNTERvY3VtZW50UGFyc2VyKERvY3VtZW50Kik7Ci0K KyAgICAKICAgICAvLyBEb2N1bWVudFBhcnNlcgogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsK ICAgICB2aXJ0dWFsIGJvb2wgaGFzSW5zZXJ0aW9uUG9pbnQoKTsKICAgICB2aXJ0dWFsIGJvb2wg ZmluaXNoV2FzQ2FsbGVkKCk7Ci0gICAgdmlydHVhbCBib29sIHByb2Nlc3NpbmdEYXRhKCkgY29u c3Q7CiAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1N0b3BQYXJzaW5nKCk7CiAgICAgdmlydHVh bCB2b2lkIHN0b3BQYXJzaW5nKCk7CiAgICAgdmlydHVhbCBib29sIGlzV2FpdGluZ0ZvclNjcmlw dHMoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNFeGVjdXRpbmdTY3JpcHQoKSBjb25zdDsK ICAgICB2aXJ0dWFsIHZvaWQgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKTsK IAorcHJvdGVjdGVkOgorICAgIHZpcnR1YWwgdm9pZCBpbnNlcnQoY29uc3QgU2VnbWVudGVkU3Ry aW5nJik7CisgICAgdmlydHVhbCB2b2lkIGFwcGVuZChjb25zdCBTZWdtZW50ZWRTdHJpbmcmKTsK KyAgICB2aXJ0dWFsIHZvaWQgZmluaXNoKCk7CisKK3ByaXZhdGU6CisgICAgTmV3WE1MRG9jdW1l bnRQYXJzZXIoRG9jdW1lbnQqKTsKKyAgICB2aXJ0dWFsIH5OZXdYTUxEb2N1bWVudFBhcnNlcigp OworICAgIAogICAgIE93blB0cjxYTUxUb2tlbml6ZXI+IG1fdG9rZW5pemVyOwogICAgIFhNTFRv a2VuIG1fdG9rZW47CisgICAgCisgICAgYm9vbCBtX2ZpbmlzaFdhc0NhbGxlZDsKKyAgICAKKyAg ICBPd25QdHI8WE1MVHJlZUJ1aWxkZXI+IG1fdHJlZUJ1aWxkZXI7CiB9OwogCiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjAyNDk2 NTM5NmM0M2Q1MDY4MDEyNzdjMTFhMDU5ZWU1ZTdjOGNjMzAKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcApAQCAtMCwwICsxLDM4 OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgor ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJYTUxUcmVlQnVpbGRlci5oIgorCisjaW5jbHVkZSAi Q0RBVEFTZWN0aW9uLmgiCisjaW5jbHVkZSAiQ29tbWVudC5oIgorI2luY2x1ZGUgIkRvY3VtZW50 LmgiCisjaW5jbHVkZSAiRG9jdW1lbnRUeXBlLmgiCisjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNs dWRlICJIVE1MRW50aXR5U2VhcmNoLmgiCisjaW5jbHVkZSAiTmV3WE1MRG9jdW1lbnRQYXJzZXIu aCIKKyNpbmNsdWRlICJQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaCIKKyNpbmNsdWRlICJYTUxOU05h bWVzLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworWE1MVHJlZUJ1aWxkZXI6OlhNTFRyZWVC dWlsZGVyKE5ld1hNTERvY3VtZW50UGFyc2VyKiBwYXJzZXIsIERvY3VtZW50KiBkb2N1bWVudCkK KyAgICA6IG1fZG9jdW1lbnQoZG9jdW1lbnQpCisgICAgLCBtX3BhcnNlcihwYXJzZXIpCisgICAg LCBtX2lzWEhUTUwoZmFsc2UpCisgICAgLCBtX2N1cnJlbnROb2RlKGRvY3VtZW50KQorICAgICwg bV9jdXJyZW50Tm9kZUl0ZW0oZG9jdW1lbnQpCit7CisgICAgbV9jdXJyZW50Tm9kZVN0YWNrLmFw cGVuZChOb2RlU3RhY2tJdGVtKGRvY3VtZW50KSk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6 OnByb2Nlc3NUb2tlbihjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgc3dpdGNo ICh0b2tlbi50eXBlKCkpIHsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OlByb2Nlc3NpbmdJbnN0 cnVjdGlvbjoKKyAgICAgICAgcHJvY2Vzc1Byb2Nlc3NpbmdJbnN0cnVjdGlvbih0b2tlbik7Cisg ICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6WE1MRGVjbGFyYXRpb246Cisg ICAgICAgIHByb2Nlc3NYTUxEZWNsYXJhdGlvbih0b2tlbik7CisgICAgICAgIGJyZWFrOworICAg IGNhc2UgWE1MVG9rZW5UeXBlczo6RE9DVFlQRToKKyAgICAgICAgcHJvY2Vzc0RPQ1RZUEUodG9r ZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OlN0YXJ0VGFnOgor ICAgICAgICBwcm9jZXNzU3RhcnRUYWcodG9rZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNl IFhNTFRva2VuVHlwZXM6OkVuZFRhZzoKKyAgICAgICAgcHJvY2Vzc0VuZFRhZyh0b2tlbik7Cisg ICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6Q0RBVEE6CisgICAgICAgIHBy b2Nlc3NDREFUQSh0b2tlbik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBl czo6Q2hhcmFjdGVyOgorICAgICAgICBwcm9jZXNzQ2hhcmFjdGVyKHRva2VuKTsKKyAgICAgICAg YnJlYWs7CisgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpDb21tZW50OgorICAgICAgICBwcm9jZXNz Q29tbWVudCh0b2tlbik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6 RW50aXR5OgorICAgICAgICBwcm9jZXNzRW50aXR5KHRva2VuKTsKKyAgICAgICAgYnJlYWs7Cisg ICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGJyZWFrOworICAgIH0KK30KKwordm9pZCBYTUxUcmVl QnVpbGRlcjo6cHVzaEN1cnJlbnROb2RlKENvbnRhaW5lck5vZGUqIG5vZGUpCit7CisgICAgQVNT RVJUKG5vZGUpOworICAgIEFTU0VSVChtX2N1cnJlbnROb2RlKTsKKyAgICBpZiAobm9kZSAhPSBt X2RvY3VtZW50KQorICAgICAgICBub2RlLT5yZWYoKTsKKworICAgIG1fY3VycmVudE5vZGVJdGVt LnNldE5vZGVJdGVtKG5vZGUpOworICAgIG1fY3VycmVudE5vZGVTdGFjay5hcHBlbmQobV9jdXJy ZW50Tm9kZUl0ZW0pOworICAgIG1fY3VycmVudE5vZGUgPSBub2RlOworICAgIC8vIEZJWE1FOiBp cyB0aGVyZSBhIG1heGltdW0gRE9NIGRlcHRoPworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpw b3BDdXJyZW50Tm9kZSgpCit7CisgICAgaWYgKCFtX2N1cnJlbnROb2RlKQorICAgICAgICByZXR1 cm47CisgICAgQVNTRVJUKG1fY3VycmVudE5vZGVTdGFjay5zaXplKCkpOworCisgICAgaWYgKG1f Y3VycmVudE5vZGUgIT0gbV9kb2N1bWVudCkKKyAgICAgICAgbV9jdXJyZW50Tm9kZS0+ZGVyZWYo KTsKKworICAgIG1fY3VycmVudE5vZGVTdGFjay5yZW1vdmVMYXN0KCk7CisgICAgbV9jdXJyZW50 Tm9kZUl0ZW0gPSBtX2N1cnJlbnROb2RlU3RhY2subGFzdCgpOworICAgIG1fY3VycmVudE5vZGUg PSBtX2N1cnJlbnROb2RlSXRlbS5ub2RlSXRlbSgpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVy Ojpwcm9jZXNzUHJvY2Vzc2luZ0luc3RydWN0aW9uKGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tl bikKK3sKKyAgICAvLyBGSVhNRTogZmFsbCBiYWNrIGlmIHdlIGNhbid0IGhhbmRsZSB0aGUgUEkg b3Vyc2VsZi4KKworICAgIFJlZlB0cjxQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24+IHBpID0gUHJvY2Vz c2luZ0luc3RydWN0aW9uOjpjcmVhdGUobV9kb2N1bWVudCwgdG9rZW4udGFyZ2V0KCksIHRva2Vu LmRhdGEoKSk7CisgICAgbV9jdXJyZW50Tm9kZS0+cGFyc2VyQWRkQ2hpbGQocGkuZ2V0KCkpOwor ICAgIGlmICghcGktPmF0dGFjaGVkKCkpCisgICAgICAgIHBpLT5hdHRhY2goKTsKK30KKwordm9p ZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1hNTERlY2xhcmF0aW9uKGNvbnN0IEF0b21pY1hNTFRv a2VuJiB0b2tlbikKK3sKKyAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKworICAgIG1fZG9jdW1l bnQtPnNldFhNTFZlcnNpb24oU3RyaW5nOjphZG9wdCh0b2tlbi54bWxWZXJzaW9uKCkpLCBlYyk7 CisgICAgbV9kb2N1bWVudC0+c2V0WE1MU3RhbmRhbG9uZSh0b2tlbi54bWxTdGFuZGFsb25lKCks IGVjKTsKKyAgICAvLyBGSVhNRTogaG93IHNob3VsZCB0aGlzIGJlaGF2ZSBpZiBzdGFuZGFsb25l IGlzIG5vdCBzcGVjaWZpZWQ/CisgICAgLy8gRklYTUU6IHNldCBlbmNvZGluZy4KKworICAgIGlm IChlYykKKyAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7Cit9CisKK3ZvaWQgWE1MVHJl ZUJ1aWxkZXI6OnByb2Nlc3NET0NUWVBFKGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sK KyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxUcmFuc2l0aW9uYWws ICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iKSk7CisgICAgREVGSU5F X1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIHhodG1sMTEsICgiLS8vVzNDLy9EVEQgWEhUTUwg MS4xLy9FTiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxT dHJpY3QsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iKSk7CisgICAgREVGSU5F X1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIHhodG1sRnJhbWVzZXQsICgiLS8vVzNDLy9EVEQg WEhUTUwgMS4wIEZyYW1lc2V0Ly9FTiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21p Y1N0cmluZywgeGh0bWxCYXNpYywgKCItLy9XM0MvL0RURCBYSFRNTCBCYXNpYyAxLjAvL0VOIikp OworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCB4aHRtbE1hdGhNTCwgKCIt Ly9XM0MvL0RURCBYSFRNTCAxLjEgcGx1cyBNYXRoTUwgMi4wLy9FTiIpKTsKKyAgICBERUZJTkVf U1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxNYXRoTUxTVkcsICgiLS8vVzNDLy9EVEQg WEhUTUwgMS4xIHBsdXMgTWF0aE1MIDIuMCBwbHVzIFNWRyAxLjEvL0VOIikpOworICAgIERFRklO RV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCB4aHRtbE1vYmlsZSwgKCItLy9XQVBGT1JVTS8v RFREIFhIVE1MIE1vYmlsZSAxLjAvL0VOIikpOworCisgICAgQXRvbWljU3RyaW5nIHB1YmxpY0lk ZW50aWZpZXIodG9rZW4ucHVibGljSWRlbnRpZmllcigpLmRhdGEoKSwgdG9rZW4ucHVibGljSWRl bnRpZmllcigpLnNpemUoKSk7CisgICAgQXRvbWljU3RyaW5nIHN5c3RlbUlkZW50aWZpZXIodG9r ZW4uc3lzdGVtSWRlbnRpZmllcigpLmRhdGEoKSwgdG9rZW4uc3lzdGVtSWRlbnRpZmllcigpLnNp emUoKSk7CisgICAgUmVmUHRyPERvY3VtZW50VHlwZT4gZG9jdHlwZSA9IERvY3VtZW50VHlwZTo6 Y3JlYXRlKG1fZG9jdW1lbnQsIHRva2VuLm5hbWUoKSwgcHVibGljSWRlbnRpZmllciwgc3lzdGVt SWRlbnRpZmllcik7CisgICAgbV9kb2N1bWVudC0+c2V0RG9jVHlwZShkb2N0eXBlKTsKKworICAg IGlmICgocHVibGljSWRlbnRpZmllciA9PSB4aHRtbFRyYW5zaXRpb25hbCkKKyAgICAgICAgfHwg KHB1YmxpY0lkZW50aWZpZXIgPT0geGh0bWwxMSkKKyAgICAgICAgfHwgKHB1YmxpY0lkZW50aWZp ZXIgPT0geGh0bWxTdHJpY3QpCisgICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1s RnJhbWVzZXQpCisgICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1sQmFzaWMpCisg ICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1sTWF0aE1MKQorICAgICAgICB8fCAo cHVibGljSWRlbnRpZmllciA9PSB4aHRtbE1hdGhNTFNWRykKKyAgICAgICAgfHwgKHB1YmxpY0lk ZW50aWZpZXIgPT0geGh0bWxNb2JpbGUpCisgICAgICAgKQorICAgICAgICBtX2lzWEhUTUwgPSB0 cnVlOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzU3RhcnRUYWcoY29uc3QgQXRv bWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBib29sIGlzRmly c3RFbGVtZW50ID0gIW1fc2F3Rmlyc3RFbGVtZW50OworICAgIG1fc2F3Rmlyc3RFbGVtZW50ID0g dHJ1ZTsKKworICAgIHByb2Nlc3NOYW1lc3BhY2VzKHRva2VuKTsKKworICAgIFF1YWxpZmllZE5h bWUgcU5hbWUodG9rZW4ucHJlZml4KCksIHRva2VuLm5hbWUoKSwgbmFtZXNwYWNlRm9yUHJlZml4 KHRva2VuLnByZWZpeCgpLCBtX2N1cnJlbnROb2RlSXRlbS5uYW1lc3BhY2VVUkkoKSkpOworICAg IFJlZlB0cjxFbGVtZW50PiBuZXdFbGVtZW50ID0gbV9kb2N1bWVudC0+Y3JlYXRlRWxlbWVudChx TmFtZSwgdHJ1ZSk7CisgICAgaWYgKCFuZXdFbGVtZW50KSB7CisgICAgICAgIG1fcGFyc2VyLT5z dG9wUGFyc2luZygpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgcHJvY2Vzc0F0dHJp YnV0ZXModG9rZW4sIG5ld0VsZW1lbnQpOworCisgICAgbmV3RWxlbWVudC0+YmVnaW5QYXJzaW5n Q2hpbGRyZW4oKTsKKyAgICBtX2N1cnJlbnROb2RlLT5wYXJzZXJBZGRDaGlsZChuZXdFbGVtZW50 LmdldCgpKTsKKworICAgIGlmICh0b2tlbi5zZWxmQ2xvc2luZygpKQorICAgICAgICBuZXdFbGVt ZW50LT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsKKyAgICBlbHNlCisgICAgICAgIHB1c2hDdXJy ZW50Tm9kZShuZXdFbGVtZW50LmdldCgpKTsKKworICAgIG1fY3VycmVudE5vZGVJdGVtID0gbV9j dXJyZW50Tm9kZVN0YWNrLmxhc3QoKTsKKworICAgIGlmICghbmV3RWxlbWVudC0+YXR0YWNoZWQo KSkKKyAgICAgICAgbmV3RWxlbWVudC0+YXR0YWNoKCk7CisKKyAgICBpZiAoaXNGaXJzdEVsZW1l bnQgJiYgbV9kb2N1bWVudC0+ZnJhbWUoKSkKKyAgICAgICAgbV9kb2N1bWVudC0+ZnJhbWUoKS0+ bG9hZGVyKCktPmRpc3BhdGNoRG9jdW1lbnRFbGVtZW50QXZhaWxhYmxlKCk7Cit9CisKK3ZvaWQg WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRva2Vu KQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBSZWZQdHI8Q29udGFpbmVyTm9kZT4gbm9kZSA9 IG1fY3VycmVudE5vZGU7CisKKyAgICBpZiAoIW5vZGUtPmhhc1RhZ05hbWUoUXVhbGlmaWVkTmFt ZSh0b2tlbi5wcmVmaXgoKSwgdG9rZW4ubmFtZSgpLCBuYW1lc3BhY2VGb3JQcmVmaXgodG9rZW4u cHJlZml4KCksIG1fY3VycmVudE5vZGVJdGVtLm5hbWVzcGFjZVVSSSgpKSkpKQorICAgICAgICBt X3BhcnNlci0+c3RvcFBhcnNpbmcoKTsKKyAgICAKKyAgICBwb3BDdXJyZW50Tm9kZSgpOworICAg IG5vZGUtPmZpbmlzaFBhcnNpbmdDaGlsZHJlbigpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVy Ojpwcm9jZXNzQ2hhcmFjdGVyKGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKworICAg IGVudGVyVGV4dChTdHJpbmcodG9rZW4uY2hhcmFjdGVycygpLmRhdGEoKSwgdG9rZW4uY2hhcmFj dGVycygpLnNpemUoKSkpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ0RBVEEo Y29uc3QgQXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIFJlZlB0cjxDREFUQVNlY3Rpb24+ IGNkYXRhID0gQ0RBVEFTZWN0aW9uOjpjcmVhdGUobV9kb2N1bWVudCwgdG9rZW4uZGF0YSgpKTsK KyAgICBtX2N1cnJlbnROb2RlLT5wYXJzZXJBZGRDaGlsZChjZGF0YS5nZXQoKSk7CisgICAgaWYg KCFjZGF0YS0+YXR0YWNoZWQoKSkKKyAgICAgICAgY2RhdGEtPmF0dGFjaCgpOworfQorCit2b2lk IFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ29tbWVudChjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9r ZW4pCit7CisgICAgUmVmUHRyPENvbW1lbnQ+IGNvbW1lbnQgPSBDb21tZW50OjpjcmVhdGUobV9k b2N1bWVudCwgdG9rZW4uY29tbWVudCgpKTsKKyAgICBtX2N1cnJlbnROb2RlLT5wYXJzZXJBZGRD aGlsZChjb21tZW50LmdldCgpKTsKKyAgICBpZiAoIWNvbW1lbnQtPmF0dGFjaGVkKCkpCisgICAg ICAgIGNvbW1lbnQtPmF0dGFjaCgpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNz RW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICAvLyBGSVhNRTogc3Vw cG9ydCBpbnRlcm5hbCBzdWJzZXQKKyAgICBpZiAobV9pc1hIVE1MKQorICAgICAgICBwcm9jZXNz SFRNTEVudGl0eSh0b2tlbik7CisgICAgZWxzZQorICAgICAgICBwcm9jZXNzWE1MRW50aXR5KHRv a2VuKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc05hbWVzcGFjZXMoY29uc3Qg QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWlj U3RyaW5nLCB4bWxuc1ByZWZpeCwgKCJ4bWxucyIpKTsKKyAgICBpZiAodG9rZW4uYXR0cmlidXRl cygpKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCB0b2tlbi5hdHRyaWJ1dGVz KCktPmxlbmd0aCgpOyArK2kpIHsKKyAgICAgICAgICAgIEF0dHJpYnV0ZSogYXR0cmlidXRlID0g dG9rZW4uYXR0cmlidXRlcygpLT5hdHRyaWJ1dGVJdGVtKGkpOworICAgICAgICAgICAgaWYgKGF0 dHJpYnV0ZS0+bmFtZSgpLnByZWZpeCgpID09IHhtbG5zUHJlZml4KQorICAgICAgICAgICAgICAg IG1fY3VycmVudE5vZGVJdGVtLnNldE5hbWVzcGFjZVVSSShhdHRyaWJ1dGUtPm5hbWUoKS5sb2Nh bE5hbWUoKSwgYXR0cmlidXRlLT52YWx1ZSgpKTsKKyAgICAgICAgICAgIGVsc2UgaWYgKGF0dHJp YnV0ZS0+bmFtZSgpID09IHhtbG5zUHJlZml4KQorICAgICAgICAgICAgICAgIG1fY3VycmVudE5v ZGVJdGVtLnNldE5hbWVzcGFjZVVSSShhdHRyaWJ1dGUtPnZhbHVlKCkpOworICAgICAgICB9Cisg ICAgfQorfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQXR0cmlidXRlcyhjb25zdCBB dG9taWNYTUxUb2tlbiYgdG9rZW4sIFBhc3NSZWZQdHI8RWxlbWVudD4gbmV3RWxlbWVudCkKK3sK KyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeG1sbnNQcmVmaXgsICgieG1s bnMiKSk7CisgICAgaWYgKHRva2VuLmF0dHJpYnV0ZXMoKSkgeworICAgICAgICBmb3IgKHVuc2ln bmVkIGkgPSAwOyBpIDwgdG9rZW4uYXR0cmlidXRlcygpLT5sZW5ndGgoKTsgKytpKSB7CisgICAg ICAgICAgICBBdHRyaWJ1dGUqIGF0dHJpYnV0ZSA9IHRva2VuLmF0dHJpYnV0ZXMoKS0+YXR0cmli dXRlSXRlbShpKTsKKyAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICAg ICAgaWYgKGF0dHJpYnV0ZS0+bmFtZSgpLnByZWZpeCgpID09IHhtbG5zUHJlZml4KQorICAgICAg ICAgICAgICAgIG5ld0VsZW1lbnQtPnNldEF0dHJpYnV0ZU5TKFhNTE5TTmFtZXM6OnhtbG5zTmFt ZXNwYWNlVVJJLCAieG1sbnM6IiArIGF0dHJpYnV0ZS0+bmFtZSgpLmxvY2FsTmFtZSgpLCBhdHRy aWJ1dGUtPnZhbHVlKCksIGVjKTsKKyAgICAgICAgICAgIGVsc2UgaWYgKGF0dHJpYnV0ZS0+bmFt ZSgpID09IHhtbG5zUHJlZml4KQorICAgICAgICAgICAgICAgIG5ld0VsZW1lbnQtPnNldEF0dHJp YnV0ZU5TKFhNTE5TTmFtZXM6OnhtbG5zTmFtZXNwYWNlVVJJLCB4bWxuc0F0b20sIGF0dHJpYnV0 ZS0+dmFsdWUoKSwgZWMpOworICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgUXVh bGlmaWVkTmFtZSBxTmFtZShhdHRyaWJ1dGUtPnByZWZpeCgpLCBhdHRyaWJ1dGUtPmxvY2FsTmFt ZSgpLCBuYW1lc3BhY2VGb3JQcmVmaXgoYXR0cmlidXRlLT5wcmVmaXgoKSwgbnVsbEF0b20pKTsK KyAgICAgICAgICAgICAgICBuZXdFbGVtZW50LT5zZXRBdHRyaWJ1dGUocU5hbWUsIGF0dHJpYnV0 ZS0+dmFsdWUoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQg WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NYTUxFbnRpdHkoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRv a2VuKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCBhbXAsICgiYW1w IikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCBhcG9zLCAoImFwb3Mi KSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIGd0LCAoImd0IikpOwor ICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCBsdCwgKCJsdCIpKTsKKyAgICBE RUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgcXVvdCwgKCJxdW90IikpOworCisgICAg RXhjZXB0aW9uQ29kZSBlYyA9IDA7CisKKyAgICBpZiAodG9rZW4ubmFtZSgpID09IGFtcCkKKyAg ICAgICAgbV9sZWFmVGV4dE5vZGUtPmFwcGVuZERhdGEoIiYiLCBlYyk7CisgICAgZWxzZSBpZiAo dG9rZW4ubmFtZSgpID09IGFwb3MpCisgICAgICAgIG1fbGVhZlRleHROb2RlLT5hcHBlbmREYXRh KCInIiwgZWMpOworICAgIGVsc2UgaWYgKHRva2VuLm5hbWUoKSA9PSBndCkKKyAgICAgICAgbV9s ZWFmVGV4dE5vZGUtPmFwcGVuZERhdGEoIj4iLCBlYyk7CisgICAgZWxzZSBpZiAodG9rZW4ubmFt ZSgpID09IGx0KQorICAgICAgICBtX2xlYWZUZXh0Tm9kZS0+YXBwZW5kRGF0YSgiPCIsIGVjKTsK KyAgICBlbHNlIGlmICh0b2tlbi5uYW1lKCkgPT0gcXVvdCkKKyAgICAgICAgbV9sZWFmVGV4dE5v ZGUtPmFwcGVuZERhdGEoIlwiIiwgZWMpOworICAgIGVsc2UgeworICAgICAgICBtX3BhcnNlci0+ c3RvcFBhcnNpbmcoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChlYykKKyAg ICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6 OnByb2Nlc3NIVE1MRW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICBI VE1MRW50aXR5U2VhcmNoIHNlYXJjaDsKKyAgICBjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUgPSB0 b2tlbi5uYW1lKCk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG5hbWUubGVuZ3RoKCk7 ICsraSkgeworICAgICAgICBzZWFyY2guYWR2YW5jZShuYW1lW2ldKTsKKyAgICAgICAgaWYgKCFz ZWFyY2guaXNFbnRpdHlQcmVmaXgoKSkKKyAgICAgICAgICAgIG1fcGFyc2VyLT5zdG9wUGFyc2lu ZygpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIHNlYXJjaC5hZHZhbmNlKCc7Jyk7Cisg ICAgVUNoYXIzMiBlbnRpdHlWYWx1ZSA9IHNlYXJjaC5jdXJyZW50VmFsdWUoKTsKKyAgICBpZiAo ZW50aXR5VmFsdWUgPD0gMHhGRkZGKQorICAgICAgIGVudGVyVGV4dChTdHJpbmcocmVpbnRlcnBy ZXRfY2FzdDxVQ2hhcio+KCZlbnRpdHlWYWx1ZSksIDEpKTsKKyAgICBlbHNlIHsKKyAgICAgICAg VUNoYXIgdXRmMTZQYWlyWzJdID0geyBVMTZfTEVBRChlbnRpdHlWYWx1ZSksIFUxNl9UUkFJTChl bnRpdHlWYWx1ZSkgfTsKKyAgICAgICAgZW50ZXJUZXh0KFN0cmluZyh1dGYxNlBhaXIsIDIpKTsK KyAgICB9Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OmVudGVyVGV4dChjb25zdCBTdHJpbmcm IHRleHQpCit7CisgICAgaWYgKCFtX3Nhd0ZpcnN0RWxlbWVudCkgeworICAgICAgICAvLyBGSVhN RTogZW5zdXJlIGl0J3MganVzdCB3aGl0ZXNwYWNlCisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBpZiAoIW1fbGVhZlRleHROb2RlKSB7CisgICAgICAgIG1fbGVhZlRleHROb2RlID0gVGV4 dDo6Y3JlYXRlKG1fZG9jdW1lbnQsIHRleHQpOworICAgICAgICBtX2N1cnJlbnROb2RlLT5wYXJz ZXJBZGRDaGlsZChtX2xlYWZUZXh0Tm9kZS5nZXQoKSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg RXhjZXB0aW9uQ29kZSBlYyA9IDA7CisgICAgICAgIG1fbGVhZlRleHROb2RlLT5hcHBlbmREYXRh KHRleHQsIGVjKTsKKworICAgICAgICBpZiAoZWMpCisgICAgICAgICAgICBtX3BhcnNlci0+c3Rv cFBhcnNpbmcoKTsKKyAgICB9Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OmV4aXRUZXh0KCkK K3sKKyAgICBpZiAobV9sZWFmVGV4dE5vZGUgJiYgIW1fbGVhZlRleHROb2RlLT5hdHRhY2hlZCgp KQorICAgICAgICBtX2xlYWZUZXh0Tm9kZS0+YXR0YWNoKCk7CisKKyAgICBtX2xlYWZUZXh0Tm9k ZSA9IDA7Cit9CisKK0F0b21pY1N0cmluZyBYTUxUcmVlQnVpbGRlcjo6bmFtZXNwYWNlRm9yUHJl Zml4KEF0b21pY1N0cmluZyBwcmVmaXgsIEF0b21pY1N0cmluZyBmYWxsYmFjaykKK3sKKyAgICBB dG9taWNTdHJpbmcgdXJpID0gZmFsbGJhY2s7CisgICAgaWYgKCFwcmVmaXguaXNOdWxsKCkpIHsK KyAgICAgICAgaWYgKG1fY3VycmVudE5vZGVJdGVtLmhhc05hbWVzcGFjZVVSSShwcmVmaXgpKQor ICAgICAgICAgICAgdXJpID0gbV9jdXJyZW50Tm9kZUl0ZW0ubmFtZXNwYWNlVVJJKHByZWZpeCk7 CisgICAgfQorCisgICAgcmV0dXJuIHVyaTsKK30KKworWE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFj a0l0ZW06Ok5vZGVTdGFja0l0ZW0oQ29udGFpbmVyTm9kZSogbiwgTm9kZVN0YWNrSXRlbSogcGFy ZW50KQorICAgIDogbV9ub2RlKG4pCit7CisgICAgaWYgKHBhcmVudCkgeworICAgICAgICBtX25h bWVzcGFjZSA9IHBhcmVudC0+bV9uYW1lc3BhY2U7CisgICAgICAgIG1fc2NvcGVkTmFtZXNwYWNl cyA9IHBhcmVudC0+bV9zY29wZWROYW1lc3BhY2VzOworICAgIH0KK30KKworYm9vbCBYTUxUcmVl QnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6aGFzTmFtZXNwYWNlVVJJKEF0b21pY1N0cmluZyBwcmVm aXgpCit7CisgICAgcmV0dXJuIG1fc2NvcGVkTmFtZXNwYWNlcy5jb250YWlucyhwcmVmaXgpOwor fQorCitBdG9taWNTdHJpbmcgWE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06Om5hbWVzcGFj ZVVSSShBdG9taWNTdHJpbmcgcHJlZml4KQoreworICAgIGlmIChtX3Njb3BlZE5hbWVzcGFjZXMu Y29udGFpbnMocHJlZml4KSkKKyAgICAgICAgcmV0dXJuIG1fc2NvcGVkTmFtZXNwYWNlcy5nZXQo cHJlZml4KTsKKyAgICByZXR1cm4gbnVsbEF0b207Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6 Ok5vZGVTdGFja0l0ZW06OnNldE5hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgcHJlZml4LCBBdG9t aWNTdHJpbmcgdXJpKQoreworICAgIG1fc2NvcGVkTmFtZXNwYWNlcy5zZXQocHJlZml4LCB1cmkp OworfQorCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRyZWVC dWlsZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uMmI5ZWVhYTRiYmI2NGY0MTM5MzYxOTU4MTAyZDZlY2U5NDljMDI0ZAotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaApA QCAtMCwwICsxLDExMSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBHT09HTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEdP T0dMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu IAorICovCisKKyNpZm5kZWYgWE1MVHJlZUJ1aWxkZXJfaAorI2RlZmluZSBYTUxUcmVlQnVpbGRl cl9oCisKKyNpbmNsdWRlICJUZXh0LmgiCisjaW5jbHVkZSAiWE1MVG9rZW4uaCIKKyNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitjbGFzcyBDb250YWluZXJOb2RlOworY2xhc3MgRG9jdW1lbnQ7CitjbGFz cyBOZXdYTUxEb2N1bWVudFBhcnNlcjsKKworY2xhc3MgWE1MVHJlZUJ1aWxkZXIgeworICAgIFdU Rl9NQUtFX05PTkNPUFlBQkxFKFhNTFRyZWVCdWlsZGVyKTsKKyAgICBXVEZfTUFLRV9GQVNUX0FM TE9DQVRFRDsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxYTUxUcmVlQnVpbGRlcj4g Y3JlYXRlKE5ld1hNTERvY3VtZW50UGFyc2VyKiBwYXJzZXIsIERvY3VtZW50KiBkb2N1bWVudCkK KyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgWE1MVHJlZUJ1aWxkZXIocGFyc2Vy LCBkb2N1bWVudCkpOworICAgIH0KKworICAgIHZvaWQgcHJvY2Vzc1Rva2VuKGNvbnN0IEF0b21p Y1hNTFRva2VuJik7CisKK3ByaXZhdGU6CisgICAgWE1MVHJlZUJ1aWxkZXIoTmV3WE1MRG9jdW1l bnRQYXJzZXIqLCBEb2N1bWVudCopOworCisgICAgY2xhc3MgTm9kZVN0YWNrSXRlbSB7CisgICAg cHVibGljOgorICAgICAgICBOb2RlU3RhY2tJdGVtKENvbnRhaW5lck5vZGUqIGl0ZW0sIE5vZGVT dGFja0l0ZW0qIHBhcmVudCA9IDApOworICAgICAgICAKKyAgICAgICAgYm9vbCBoYXNOYW1lc3Bh Y2VVUkkoQXRvbWljU3RyaW5nIHByZWZpeCk7CisgICAgICAgIEF0b21pY1N0cmluZyBuYW1lc3Bh Y2VVUkkoQXRvbWljU3RyaW5nIHByZWZpeCk7CisgICAgICAgIEF0b21pY1N0cmluZyBuYW1lc3Bh Y2VVUkkoKSB7IHJldHVybiBtX25hbWVzcGFjZTsgfQorICAgICAgICB2b2lkIHNldE5hbWVzcGFj ZVVSSShBdG9taWNTdHJpbmcgcHJlZml4LCBBdG9taWNTdHJpbmcgdXJpKTsKKyAgICAgICAgdm9p ZCBzZXROYW1lc3BhY2VVUkkoQXRvbWljU3RyaW5nIHVyaSkgeyBtX25hbWVzcGFjZSA9IHVyaTsg fQorICAgICAgICAKKyAgICAgICAgQ29udGFpbmVyTm9kZSogbm9kZUl0ZW0oKSB7IHJldHVybiBt X25vZGU7IH0KKyAgICAgICAgdm9pZCBzZXROb2RlSXRlbShDb250YWluZXJOb2RlKiBub2RlKSB7 IG1fbm9kZSA9IG5vZGU7IH0KKyAgICAgICAgCisgICAgcHJpdmF0ZToKKyAgICAgICAgSGFzaE1h cDxBdG9taWNTdHJpbmcsIEF0b21pY1N0cmluZz4gbV9zY29wZWROYW1lc3BhY2VzOworICAgICAg ICBDb250YWluZXJOb2RlKiBtX25vZGU7CisgICAgICAgIEF0b21pY1N0cmluZyBtX25hbWVzcGFj ZTsKKyAgICB9OworCisgICAgdm9pZCBwdXNoQ3VycmVudE5vZGUoQ29udGFpbmVyTm9kZSopOwor ICAgIHZvaWQgcG9wQ3VycmVudE5vZGUoKTsKKworICAgIHZvaWQgcHJvY2Vzc1Byb2Nlc3NpbmdJ bnN0cnVjdGlvbihjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc1hNTERl Y2xhcmF0aW9uKGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzRE9DVFlQ RShjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc1N0YXJ0VGFnKGNvbnN0 IEF0b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzRW5kVGFnKGNvbnN0IEF0b21pY1hN TFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzQ0RBVEEoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsK KyAgICB2b2lkIHByb2Nlc3NDaGFyYWN0ZXIoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2 b2lkIHByb2Nlc3NDb21tZW50KGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9j ZXNzRW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisKKyAgICB2b2lkIHByb2Nlc3NOYW1l c3BhY2VzKGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzQXR0cmlidXRl cyhjb25zdCBBdG9taWNYTUxUb2tlbiYsIFBhc3NSZWZQdHI8RWxlbWVudD4gbmV3RWxlbWVudCk7 CisgICAgdm9pZCBwcm9jZXNzWE1MRW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisgICAg dm9pZCBwcm9jZXNzSFRNTEVudGl0eShjb25zdCBBdG9taWNYTUxUb2tlbiYpOworCisgICAgdm9p ZCBlbnRlclRleHQoY29uc3QgU3RyaW5nJiB0ZXh0KTsKKyAgICB2b2lkIGV4aXRUZXh0KCk7CisK KyAgICBBdG9taWNTdHJpbmcgbmFtZXNwYWNlRm9yUHJlZml4KEF0b21pY1N0cmluZyBwcmVmaXgs IEF0b21pY1N0cmluZyBmYWxsYmFjayk7CisKKyAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKKyAg ICBOZXdYTUxEb2N1bWVudFBhcnNlciogbV9wYXJzZXI7CisKKyAgICBib29sIG1faXNYSFRNTDsK KworICAgIGJvb2wgbV9zYXdGaXJzdEVsZW1lbnQ7CisgICAgQ29udGFpbmVyTm9kZSogbV9jdXJy ZW50Tm9kZTsKKyAgICBOb2RlU3RhY2tJdGVtIG1fY3VycmVudE5vZGVJdGVtOworICAgIFZlY3Rv cjxOb2RlU3RhY2tJdGVtPiBtX2N1cnJlbnROb2RlU3RhY2s7CisKKyAgICBSZWZQdHI8VGV4dD4g bV9sZWFmVGV4dE5vZGU7Cit9OworCit9CisKKyNlbmRpZiAvLyBYTUxUcmVlQnVpbGRlcl9oCg== 103324 2011-08-08 18:16:01 -0700 2011-08-09 14:01:02 -0700 Patch bug-65803-20110808181600.patch text/plain 31793 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogOTI2MDMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2MGQwZjljMGRjNjMyMmY3 NTgwY2E0ZDEwNjQ4YTdlZWZiY2E4YTM4Li41ZWZhOTM5NWIwM2MxNmQxZDU2OTVjMjIxNzY2M2U3 NjEzYzZlOTZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTEtMDgtMDggIEplZmZy ZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBJbml0aWFsIHBhc3MgYXQgYSBu ZXcgWE1MIHRyZWUgYnVpbGRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NjU4MDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogV2ViQ29yZS5neXBp OgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoK KyAgICAgICAgKiB4bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjpOZXdYTUxEb2N1bWVudFBhcnNlcik6Cisg ICAgICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6fk5ld1hNTERvY3VtZW50UGFy c2VyKToKKyAgICAgICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQpOgor ICAgICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCk6CisgICAgICAg IChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoV2FzQ2FsbGVkKToKKyAgICAg ICAgKiB4bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmg6CisgICAgICAgICogeG1sL3Bh cnNlci9YTUxUcmVlQnVpbGRlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJl ZUJ1aWxkZXI6OlhNTFRyZWVCdWlsZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWls ZGVyOjpwcm9jZXNzVG9rZW4pOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnB1 c2hDdXJyZW50Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cG9wQ3Vy cmVudE5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NQcm9j ZXNzaW5nSW5zdHJ1Y3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnBy b2Nlc3NYTUxEZWNsYXJhdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6 cHJvY2Vzc0RPQ1RZUEUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nl c3NTdGFydFRhZyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0Vu ZFRhZyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0NoYXJhY3Rl cik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0NEQVRBKToKKyAg ICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ29tbWVudCk6CisgICAgICAg IChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0VudGl0eSk6CisgICAgICAgIChXZWJD b3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc05hbWVzcGFjZXMpOgorICAgICAgICAoV2ViQ29y ZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NBdHRyaWJ1dGVzKToKKyAgICAgICAgKFdlYkNvcmU6 OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzWE1MRW50aXR5KToKKyAgICAgICAgKFdlYkNvcmU6OlhN TFRyZWVCdWlsZGVyOjpwcm9jZXNzSFRNTEVudGl0eSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxU cmVlQnVpbGRlcjo6YWRkKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjphcHBl bmRUb1RleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OmVudGVyVGV4dCk6 CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6ZXhpdFRleHQpOgorICAgICAgICAo V2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Om5hbWVzcGFjZUZvclByZWZpeCk6CisgICAgICAgIChX ZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6Tm9kZVN0YWNrSXRlbSk6Cisg ICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6aGFzTmFtZXNw YWNlVVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVt OjpuYW1lc3BhY2VVUkkpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVT dGFja0l0ZW06OnNldE5hbWVzcGFjZVVSSSk6CisgICAgICAgICogeG1sL3BhcnNlci9YTUxUcmVl QnVpbGRlci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpjcmVh dGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06Om5h bWVzcGFjZVVSSSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNr SXRlbTo6c2V0TmFtZXNwYWNlVVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVy OjpOb2RlU3RhY2tJdGVtOjpub2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVy OjpOb2RlU3RhY2tJdGVtOjpzZXROb2RlKToKKwogMjAxMS0wOC0wOCAgRGFuIEJlcm5zdGVpbiAg PG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIEJ1aWxkIGZpeC4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmls ZS5saXN0LmFtCmluZGV4IGEwNjhjMDI0NDhhNzYwNTM3N2Q3ZTA4NDY0MzA3OGVlNjQ5OGJkNGQu LmMwYmI5NWE2ZmY3NDRjYTQwMTZjMjA0YjcxNDkyYTliYTYzNTgwMjEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05V bWFrZWZpbGUubGlzdC5hbQpAQCAtMzgzNyw2ICszODM3LDggQEAgd2ViY29yZV9zb3VyY2VzICs9 IFwKIAlTb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAgXAogCVNvdXJj ZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVG9rZW5pemVyLmggXAogCVNvdXJjZS9XZWJDb3JlL3ht bC9wYXJzZXIvWE1MVG9rZW4uaCBcCisJU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9YTUxUcmVl QnVpbGRlci5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIu aCBcCiAJU291cmNlL1dlYkNvcmUveG1sL0RPTVBhcnNlci5jcHAgXAogCVNvdXJjZS9XZWJDb3Jl L3htbC9ET01QYXJzZXIuaCBcCiAJU291cmNlL1dlYkNvcmUveG1sL05hdGl2ZVhQYXRoTlNSZXNv bHZlci5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDhkMGRmZjVjYjFmNTcxYjcyMzI4MTJkNzQ2 ZmM4YTk5NWY1YjhmMzcuLjViMjcyN2M5YzFhZjYzMmQwN2Y2ZDMwZDFkMDgzODgwMzRlMjAxYjMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLmd5cGkKQEAgLTUxNDIsNiArNTE0Miw4IEBACiAgICAgICAgICAgICAneG1s L3BhcnNlci9YTUxUb2tlbml6ZXIuY3BwJywKICAgICAgICAgICAgICd4bWwvcGFyc2VyL1hNTFRv a2VuaXplci5oJywKICAgICAgICAgICAgICd4bWwvcGFyc2VyL1hNTFRva2VuLmgnLAorICAgICAg ICAgICAgJ3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuY3BwJywKKyAgICAgICAgICAgICd4bWwv cGFyc2VyL1hNTFRyZWVCdWlsZGVyLmgnLAogICAgICAgICAgICAgJ3htbC9ET01QYXJzZXIuY3Bw JywKICAgICAgICAgICAgICd4bWwvRE9NUGFyc2VyLmgnLAogICAgICAgICAgICAgJ3htbC9OYXRp dmVYUGF0aE5TUmVzb2x2ZXIuY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUucHJvIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggYTZmODlhNGI2MmZhYmUw ZWM3YzcxZTA4YzA5OTUyZjBlZTRkMDE4Zi4uZmM1Njk2MjNhYjJlMzgyZDgxOWExMWFhMjllYWEz Mzg1ZDdkOTEwMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIv U291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTEyMDcsNyArMTIwNyw4IEBAIFNPVVJDRVMg Kz0gXAogICAgIHhtbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwIFwKICAgICB4bWwv cGFyc2VyL1hNTENoYXJhY3RlclJlZmVyZW5jZVBhcnNlci5jcHAgXAogICAgIHhtbC9wYXJzZXIv WE1MRG9jdW1lbnRQYXJzZXIuY3BwIFwKLSAgICB4bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAK KyAgICB4bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAgXAorICAgIHhtbC9wYXJzZXIvWE1MVHJl ZUJ1aWxkZXIuY3BwCiAKIEhFQURFUlMgKz0gXAogICAgIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eUFSSUFHcmlkQ2VsbC5oIFwKQEAgLTI1MTksNiArMjUyMCw3IEBAIEhFQURFUlMgKz0gXAog ICAgIHhtbC9wYXJzZXIvWE1MRG9jdW1lbnRQYXJzZXIuaCBcCiAgICAgeG1sL3BhcnNlci9YTUxU b2tlbml6ZXIuaCBcCiAgICAgeG1sL3BhcnNlci9YTUxUb2tlbi5oIFwKKyAgICB4bWwvcGFyc2Vy L1hNTFRyZWVCdWlsZGVyLmggXAogICAgIHhtbC9ET01QYXJzZXIuaCBcCiAgICAgeG1sL05hdGl2 ZVhQYXRoTlNSZXNvbHZlci5oIFwKICAgICB4bWwvWE1MSHR0cFJlcXVlc3QuaCBcCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGIyZTY5ZTBlZWE1 ZjYxZmY0NThjZTczN2FjOWQ1ZTlmMzZhYTVhYjAuLmEwNjZmNjk1ZDYwZmMxOWY1ZDM1NGFlYjFi OWE4OThiY2IzZTMzYTYgMTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9q L1dlYkNvcmUudmNwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qCkBAIC00Mjc0NSw2ICs0Mjc0NSwxNCBAQAogCQkJCQk+CiAJCQkJPC9GaWxlPgog CQkJCTxGaWxlCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxOZXdYTUxEb2N1bWVu dFBhcnNlci5oIgorCQkJCQk+CisJCQkJPC9GaWxlPgorCQkJCTxGaWxlCisJCQkJCVJlbGF0aXZl UGF0aD0iLi5ceG1sXHBhcnNlclxOZXdYTUxEb2N1bWVudFBhcnNlci5jcHAiCisJCQkJCT4KKwkJ CQk8L0ZpbGU+CisJCQkJPEZpbGUKIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlx4bWxccGFyc2VyXFhN TERvY3VtZW50UGFyc2VyLmNwcCIKIAkJCQkJPgogCQkJCQk8RmlsZUNvbmZpZ3VyYXRpb24KQEAg LTQyODY4LDYgKzQyODc2LDE0IEBACiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxY TUxUb2tlbml6ZXIuaCIKIAkJCQkJPgogCQkJCTwvRmlsZT4KKwkJCQk8RmlsZQorCQkJCQlSZWxh dGl2ZVBhdGg9Ii4uXHhtbFxwYXJzZXJcWE1MVHJlZUJ1aWxkZXIuaCIKKwkJCQkJPgorCQkJCTwv RmlsZT4KKwkJCQk8RmlsZQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHhtbFxwYXJzZXJcWE1MVHJl ZUJ1aWxkZXIuY3BwIgorCQkJCQk+CisJCQkJPC9GaWxlPgogCQkJPC9GaWx0ZXI+CiAJCTwvRmls dGVyPgogCQk8RmlsdGVyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKaW5kZXggN2Q2ZjdhZTM5ODY5NzE1M2Y0Y2ZkZjU1OGQ2NTgzZTEwYTQz ODViOC4uYmUzN2NjMWVjNmEyNDliODQzYjBlOTc4MjQwMDhhMGZkNGI1NWZmOSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNTEs NiArNTEsOCBAQAogCQkwMDAyRUM1QTEzQzNGNjdEMDAwNDBENDcgLyogWE1MVG9rZW5pemVyLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDAyRUM1NzEz QzNGNjdEMDAwNDBENDcgLyogWE1MVG9rZW5pemVyLmggKi87IH07CiAJCTAwMTQ2MjhBMTAzQ0Qx REUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDE0NjI4ODEwM0NEMURFMDAwQjIwREIgLyogT3Jp Z2luQWNjZXNzRW50cnkuY3BwICovOyB9OwogCQkwMDE0NjI4QjEwM0NEMURFMDAwQjIwREIgLyog T3JpZ2luQWNjZXNzRW50cnkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDAwMTQ2Mjg5MTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5o ICovOyB9OworCQkwMDM1RUJCQjEzRjA2RkYyMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMzVFQkJBMTNG MDZGRjIwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5oICovOyB9OworCQkwMDM1RUJCRTEzRjA3 MTNDMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDAzNUVCQkQxM0YwNzEzQzAwQTU2MDg5IC8qIFhNTFRy ZWVCdWlsZGVyLmNwcCAqLzsgfTsKIAkJMDAzRjFGRUExMUU2QUI0MzAwODI1OEQ5IC8qIFVzZXJD b250ZW50VHlwZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDAwM0YxRkU5MTFFNkFCNDMwMDgyNThEOSAvKiBVc2VyQ29udGVudFR5cGVzLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJMDBBNjI5QzExM0Qw QkVDNzAwNTBBQzUyIC8qIE1hcmt1cFRva2VuQmFzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDBBNjI5QzAxM0QwQkVDNzAwNTBBQzUyIC8qIE1hcmt1 cFRva2VuQmFzZS5oICovOyB9OwogCQkwMEI5MzE4NzEzQkE4REIzMDAzNUE5NDggLyogWE1MRG9j dW1lbnRQYXJzZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gMDBCOTMxODExM0JBODY3RjAwMzVBOTQ4IC8qIFhNTERvY3VtZW50UGFyc2VyLmNwcCAq LzsgfTsKQEAgLTY0ODUsNiArNjQ4Nyw4IEBACiAJCTAwMDJFQzU3MTNDM0Y2N0QwMDA0MEQ0NyAv KiBYTUxUb2tlbml6ZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWE1MVG9r ZW5pemVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTAwMTQ2Mjg4MTAzQ0QxREUw MDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTAwMTQ2Mjg5MTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQkwMDM1RUJCQTEzRjA2RkYyMDBBNTYwODkgLyog WE1MVHJlZUJ1aWxkZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWE1MVHJl ZUJ1aWxkZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJMDAzNUVCQkQxM0YwNzEz QzAwQTU2MDg5IC8qIFhNTFRyZWVCdWlsZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IFhNTFRyZWVCdWlsZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJMDAzRjFGRTkxMUU2QUI0MzAwODI1OEQ5IC8qIFVzZXJDb250ZW50VHlwZXMuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVXNlckNvbnRlbnRUeXBlcy5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQkwMEE2MjlDMDEzRDBCRUM3MDA1MEFDNTIgLyogTWFya3Vw VG9rZW5CYXNlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE1hcmt1cFRva2Vu QmFzZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwMEI5MzE4MTEzQkE4NjdGMDAz NUE5NDggLyogWE1MRG9jdW1lbnRQYXJzZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAu Y3BwOyBwYXRoID0gWE1MRG9jdW1lbnRQYXJzZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwpAQCAtMTI4NjIsNiArMTI4NjYsOCBAQAogCQkJCTAwMDJFQzU1MTNDM0Y2N0QwMDA0MEQ0 NyAvKiBYTUxUb2tlbi5oICovLAogCQkJCTAwMDJFQzU2MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxU b2tlbml6ZXIuY3BwICovLAogCQkJCTAwMDJFQzU3MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tl bml6ZXIuaCAqLywKKwkJCQkwMDM1RUJCRDEzRjA3MTNDMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxk ZXIuY3BwICovLAorCQkJCTAwMzVFQkJBMTNGMDZGRjIwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRl ci5oICovLAogCQkJKTsKIAkJCXBhdGggPSBwYXJzZXI7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91 cD4iOwpAQCAtMjMzMzAsNiArMjMzMzYsNyBAQAogCQkJCTFBQ0U1M0VCMEE4RDE4RTcwMDIyOTQ3 RCAvKiBYTUxTZXJpYWxpemVyLmggaW4gSGVhZGVycyAqLywKIAkJCQkwMDAyRUM1ODEzQzNGNjdE MDAwNDBENDcgLyogWE1MVG9rZW4uaCBpbiBIZWFkZXJzICovLAogCQkJCTAwMDJFQzVBMTNDM0Y2 N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTAwMzVFQkJC MTNGMDZGRjIwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJ NTkwNUFEQzAxMzAyRjNDRTAwRjExNkRGIC8qIFhNTFRyZWVWaWV3ZXIuaCBpbiBIZWFkZXJzICov LAogCQkJCTFBQjdGQzY5MEE4QjkyRUMwMEQ5RDM3QiAvKiBYUGF0aEV2YWx1YXRvci5oIGluIEhl YWRlcnMgKi8sCiAJCQkJQkM2MERBNUIwRDJBMzFGNzAwQjk5MThGIC8qIFhQYXRoRXhjZXB0aW9u LmggaW4gSGVhZGVycyAqLywKQEAgLTI2MTM3LDYgKzI2MTQ0LDcgQEAKIAkJCQlFMTVBMzZEOTEx MDQ1NzI3MDBCN0I2MzkgLyogWE1MTlNOYW1lcy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQUNF NTNFQTBBOEQxOEU3MDAyMjk0N0QgLyogWE1MU2VyaWFsaXplci5jcHAgaW4gU291cmNlcyAqLywK IAkJCQkwMDAyRUM1OTEzQzNGNjdEMDAwNDBENDcgLyogWE1MVG9rZW5pemVyLmNwcCBpbiBTb3Vy Y2VzICovLAorCQkJCTAwMzVFQkJFMTNGMDcxM0MwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5j cHAgaW4gU291cmNlcyAqLywKIAkJCQk1OTA1QURCRjEzMDJGM0NFMDBGMTE2REYgLyogWE1MVHJl ZVZpZXdlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQUI3RkM2ODBBOEI5MkVDMDBEOUQzN0Ig LyogWFBhdGhFdmFsdWF0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMUFCN0ZDNkIwQThCOTJF QzAwRDlEMzdCIC8qIFhQYXRoRXhwcmVzc2lvbi5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIv U291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXgg MmZhYzI3MTk0YWU5MGZkZTcxNzc1ZmI5Zjk2YzU3M2M5ZGYyMGVhYy4uMTExMmRiMjA2N2E0YmNm M2Q3MmM4M2QwNDU1MjQxOTU1MDNjZThjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUveG1s L3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUveG1s L3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAKQEAgLTI3LDEyICsyNywxOSBAQAogI2lu Y2x1ZGUgIk5ld1hNTERvY3VtZW50UGFyc2VyLmgiCiAKICNpbmNsdWRlICJTZWdtZW50ZWRTdHJp bmcuaCIKKyNpbmNsdWRlICJYTUxUcmVlQnVpbGRlci5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKIE5ld1hNTERvY3VtZW50UGFyc2VyOjpOZXdYTUxEb2N1bWVudFBhcnNlcihEb2N1bWVudCog ZG9jdW1lbnQpCiAgICAgOiBTY3JpcHRhYmxlRG9jdW1lbnRQYXJzZXIoZG9jdW1lbnQpCiAgICAg LCBtX3Rva2VuaXplcihYTUxUb2tlbml6ZXI6OmNyZWF0ZSgpKQorICAgICwgbV9maW5pc2hXYXND YWxsZWQoZmFsc2UpCisgICAgLCBtX3RyZWVCdWlsZGVyKFhNTFRyZWVCdWlsZGVyOjpjcmVhdGUo dGhpcywgZG9jdW1lbnQpKQoreworfQorCitOZXdYTUxEb2N1bWVudFBhcnNlcjo6fk5ld1hNTERv Y3VtZW50UGFyc2VyKCkKIHsKIH0KIApAQCAtNjMsNyArNzAsMTAgQEAgdm9pZCBOZXdYTUxEb2N1 bWVudFBhcnNlcjo6YXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYgc3RyaW5nKQogICAgICAg ICBtX3Rva2VuLnByaW50KCk7CiAjZW5kaWYKIAotICAgICAgICBpZiAobV90b2tlbi50eXBlKCkg PT0gWE1MVG9rZW5UeXBlczo6RW5kT2ZGaWxlKQorICAgICAgICBBdG9taWNYTUxUb2tlbiB0b2tl bihtX3Rva2VuKTsKKyAgICAgICAgbV90cmVlQnVpbGRlci0+cHJvY2Vzc1Rva2VuKHRva2VuKTsK KworICAgICAgICBpZiAobV90b2tlbi50eXBlKCkgPT0gWE1MVG9rZW5UeXBlczo6RW5kT2ZGaWxl IHx8ICFpc1BhcnNpbmcoKSkKICAgICAgICAgICAgIGJyZWFrOwogCiAgICAgICAgIG1fdG9rZW4u Y2xlYXIoKTsKQEAgLTczLDExICs4MywxMyBAQCB2b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjph cHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBzdHJpbmcpCiAKIHZvaWQgTmV3WE1MRG9jdW1l bnRQYXJzZXI6OmZpbmlzaCgpCiB7Ci19CisgICAgQVNTRVJUKCFtX2ZpbmlzaFdhc0NhbGxlZCk7 CisgICAgbV9maW5pc2hXYXNDYWxsZWQgPSB0cnVlOwogCi12b2lkIE5ld1hNTERvY3VtZW50UGFy c2VyOjpkZXRhY2goKQotewotICAgIFNjcmlwdGFibGVEb2N1bWVudFBhcnNlcjo6ZGV0YWNoKCk7 CisgICAgaWYgKGlzUGFyc2luZygpKQorICAgICAgICBwcmVwYXJlVG9TdG9wUGFyc2luZygpOwor ICAgIGRvY3VtZW50KCktPnNldFJlYWR5U3RhdGUoRG9jdW1lbnQ6OkludGVyYWN0aXZlKTsKKyAg ICBkb2N1bWVudCgpLT5maW5pc2hlZFBhcnNpbmcoKTsKIH0KIAogYm9vbCBOZXdYTUxEb2N1bWVu dFBhcnNlcjo6aGFzSW5zZXJ0aW9uUG9pbnQoKQpAQCAtODcsMjAgKzk5LDcgQEAgYm9vbCBOZXdY TUxEb2N1bWVudFBhcnNlcjo6aGFzSW5zZXJ0aW9uUG9pbnQoKQogCiBib29sIE5ld1hNTERvY3Vt ZW50UGFyc2VyOjpmaW5pc2hXYXNDYWxsZWQoKQogewotICAgIHJldHVybiBmYWxzZTsKLX0KLQot Ym9vbCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc2luZ0RhdGEoKSBjb25zdAotewotICAg IHJldHVybiBmYWxzZTsKLX0KLQotdm9pZCBOZXdYTUxEb2N1bWVudFBhcnNlcjo6cHJlcGFyZVRv U3RvcFBhcnNpbmcoKQotewotfQotCi12b2lkIE5ld1hNTERvY3VtZW50UGFyc2VyOjpzdG9wUGFy c2luZygpCi17CisgICAgcmV0dXJuIG1fZmluaXNoV2FzQ2FsbGVkOwogfQogCiBib29sIE5ld1hN TERvY3VtZW50UGFyc2VyOjppc1dhaXRpbmdGb3JTY3JpcHRzKCkgY29uc3QKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaCBiL1NvdXJj ZS9XZWJDb3JlL3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCAzNTc1NzU0 ZGRhM2Y5YTRiNTEyOGZmNDhjYjQwNjgwNzkxMzNmMTBkLi43OTk3Njg1YzI1NTM4ZjI5NTNhNWJj M2NiMGU0ODg1NGU4NWMyMzI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2Vy L05ld1hNTERvY3VtZW50UGFyc2VyLmgKKysrIGIvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9O ZXdYTUxEb2N1bWVudFBhcnNlci5oCkBAIC0zNiw2ICszNiw4IEBACiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKIGNsYXNzIERvY3VtZW50OworY2xhc3MgQ29udGFpbmVyTm9kZTsKK2NsYXNzIFhNTFRy ZWVCdWlsZGVyOwogCiBjbGFzcyBOZXdYTUxEb2N1bWVudFBhcnNlciA6IHB1YmxpYyBTY3JpcHRh YmxlRG9jdW1lbnRQYXJzZXIgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwpAQCAtNDQs MzIgKzQ2LDMyIEBAIHB1YmxpYzoKICAgICB7CiAgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg TmV3WE1MRG9jdW1lbnRQYXJzZXIoZG9jdW1lbnQpKTsKICAgICB9Ci0gICAgCisKICAgICB2aXJ0 dWFsIFRleHRQb3NpdGlvbjAgdGV4dFBvc2l0aW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBpbnQg bGluZU51bWJlcigpIGNvbnN0OworICAgIAorICAgIC8vIERvY3VtZW50UGFyc2VyCisgICAgdmly dHVhbCBib29sIGhhc0luc2VydGlvblBvaW50KCk7CisgICAgdmlydHVhbCBib29sIGZpbmlzaFdh c0NhbGxlZCgpOworICAgIHZpcnR1YWwgYm9vbCBpc1dhaXRpbmdGb3JTY3JpcHRzKCkgY29uc3Q7 CisgICAgdmlydHVhbCBib29sIGlzRXhlY3V0aW5nU2NyaXB0KCkgY29uc3Q7CisgICAgdmlydHVh bCB2b2lkIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCk7CiAKIHByb3RlY3Rl ZDoKICAgICB2aXJ0dWFsIHZvaWQgaW5zZXJ0KGNvbnN0IFNlZ21lbnRlZFN0cmluZyYpOwogICAg IHZpcnR1YWwgdm9pZCBhcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJik7CiAgICAgdmlydHVh bCB2b2lkIGZpbmlzaCgpOwogCi0KIHByaXZhdGU6CiAgICAgTmV3WE1MRG9jdW1lbnRQYXJzZXIo RG9jdW1lbnQqKTsKLQotICAgIC8vIERvY3VtZW50UGFyc2VyCi0gICAgdmlydHVhbCB2b2lkIGRl dGFjaCgpOwotICAgIHZpcnR1YWwgYm9vbCBoYXNJbnNlcnRpb25Qb2ludCgpOwotICAgIHZpcnR1 YWwgYm9vbCBmaW5pc2hXYXNDYWxsZWQoKTsKLSAgICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0Rh dGEoKSBjb25zdDsKLSAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKLSAg ICB2aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKTsKLSAgICB2aXJ0dWFsIGJvb2wgaXNXYWl0aW5n Rm9yU2NyaXB0cygpIGNvbnN0OwotICAgIHZpcnR1YWwgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgp IGNvbnN0OwotICAgIHZpcnR1YWwgdm9pZCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNo ZWV0cygpOwotCisgICAgdmlydHVhbCB+TmV3WE1MRG9jdW1lbnRQYXJzZXIoKTsKKyAgICAKICAg ICBPd25QdHI8WE1MVG9rZW5pemVyPiBtX3Rva2VuaXplcjsKICAgICBYTUxUb2tlbiBtX3Rva2Vu OworICAgIAorICAgIGJvb2wgbV9maW5pc2hXYXNDYWxsZWQ7CisgICAgCisgICAgT3duUHRyPFhN TFRyZWVCdWlsZGVyPiBtX3RyZWVCdWlsZGVyOwogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUveG1sL3BhcnNlci9YTUxUcmVlQnVpbGRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS94 bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NmQ5MDdjMTA1Njc3OGI5 NWEzNzZiZTFlODg2MjM2ZmQzZjE3MjEwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUveG1sL3BhcnNlci9YTUxUcmVlQnVpbGRlci5jcHAKQEAgLTAsMCArMSwzOTUgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFT IElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisjaW5jbHVkZSAiWE1MVHJlZUJ1aWxkZXIuaCIKKworI2luY2x1ZGUgIkNEQVRBU2VjdGlv bi5oIgorI2luY2x1ZGUgIkNvbW1lbnQuaCIKKyNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1 ZGUgIkRvY3VtZW50VHlwZS5oIgorI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiSFRNTEVu dGl0eVNlYXJjaC5oIgorI2luY2x1ZGUgIk5ld1hNTERvY3VtZW50UGFyc2VyLmgiCisjaW5jbHVk ZSAiUHJvY2Vzc2luZ0luc3RydWN0aW9uLmgiCisjaW5jbHVkZSAiWE1MTlNOYW1lcy5oIgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK1hNTFRyZWVCdWlsZGVyOjpYTUxUcmVlQnVpbGRlcihOZXdY TUxEb2N1bWVudFBhcnNlciogcGFyc2VyLCBEb2N1bWVudCogZG9jdW1lbnQpCisgICAgOiBtX2Rv Y3VtZW50KGRvY3VtZW50KQorICAgICwgbV9wYXJzZXIocGFyc2VyKQorICAgICwgbV9pc1hIVE1M KGZhbHNlKQorICAgICwgbV9jdXJyZW50U3RhY2tJdGVtKGRvY3VtZW50KQoreworICAgIG1fY3Vy cmVudE5vZGVTdGFjay5hcHBlbmQoTm9kZVN0YWNrSXRlbShkb2N1bWVudCkpOworfQorCit2b2lk IFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzVG9rZW4oY29uc3QgQXRvbWljWE1MVG9rZW4mIHRva2Vu KQoreworICAgIHN3aXRjaCAodG9rZW4udHlwZSgpKSB7CisgICAgY2FzZSBYTUxUb2tlblR5cGVz OjpVbmluaXRpYWxpemVkOgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAg YnJlYWs7CisgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpQcm9jZXNzaW5nSW5zdHJ1Y3Rpb246Cisg ICAgICAgIHByb2Nlc3NQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24odG9rZW4pOworICAgICAgICBicmVh azsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OlhNTERlY2xhcmF0aW9uOgorICAgICAgICBwcm9j ZXNzWE1MRGVjbGFyYXRpb24odG9rZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRv a2VuVHlwZXM6OkRPQ1RZUEU6CisgICAgICAgIHByb2Nlc3NET0NUWVBFKHRva2VuKTsKKyAgICAg ICAgYnJlYWs7CisgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpTdGFydFRhZzoKKyAgICAgICAgcHJv Y2Vzc1N0YXJ0VGFnKHRva2VuKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBYTUxUb2tlblR5 cGVzOjpFbmRUYWc6CisgICAgICAgIHByb2Nlc3NFbmRUYWcodG9rZW4pOworICAgICAgICBicmVh azsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OkNEQVRBOgorICAgICAgICBwcm9jZXNzQ0RBVEEo dG9rZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OkNoYXJhY3Rl cjoKKyAgICAgICAgcHJvY2Vzc0NoYXJhY3Rlcih0b2tlbik7CisgICAgICAgIGJyZWFrOworICAg IGNhc2UgWE1MVG9rZW5UeXBlczo6Q29tbWVudDoKKyAgICAgICAgcHJvY2Vzc0NvbW1lbnQodG9r ZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OkVudGl0eToKKyAg ICAgICAgcHJvY2Vzc0VudGl0eSh0b2tlbik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1M VG9rZW5UeXBlczo6RW5kT2ZGaWxlOgorICAgICAgICByZXR1cm47CisgICAgfQorfQorCit2b2lk IFhNTFRyZWVCdWlsZGVyOjpwdXNoQ3VycmVudE5vZGUoQ29udGFpbmVyTm9kZSogbm9kZSkKK3sK KyAgICBBU1NFUlQobm9kZSk7CisKKyAgICBtX2N1cnJlbnRTdGFja0l0ZW0uc2V0Tm9kZShub2Rl KTsKKyAgICBtX2N1cnJlbnROb2RlU3RhY2suYXBwZW5kKG1fY3VycmVudFN0YWNrSXRlbSk7Cisg ICAgLy8gRklYTUU6IGlzIHRoZXJlIGEgbWF4aW11bSBET00gZGVwdGg/Cit9CisKK3ZvaWQgWE1M VHJlZUJ1aWxkZXI6OnBvcEN1cnJlbnROb2RlKCkKK3sKKyAgICBBU1NFUlQobV9jdXJyZW50Tm9k ZVN0YWNrLnNpemUoKSk7CisKKyAgICBtX2N1cnJlbnROb2RlU3RhY2sucmVtb3ZlTGFzdCgpOwor ICAgIG1fY3VycmVudFN0YWNrSXRlbSA9IG1fY3VycmVudE5vZGVTdGFjay5sYXN0KCk7Cit9CisK K3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24oY29uc3Qg QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIEFTU0VSVCghbV9sZWFmVGV4dCk7CisgICAg Ly8gRklYTUU6IGZhbGwgYmFjayBpZiB3ZSBjYW4ndCBoYW5kbGUgdGhlIFBJIG91cnNlbGYuCisK KyAgICBSZWZQdHI8UHJvY2Vzc2luZ0luc3RydWN0aW9uPiBwaSA9IFByb2Nlc3NpbmdJbnN0cnVj dGlvbjo6Y3JlYXRlKG1fZG9jdW1lbnQsIHRva2VuLnRhcmdldCgpLCB0b2tlbi5kYXRhKCkpOwor ICAgIGFkZChwaSk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NYTUxEZWNsYXJh dGlvbihjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgQVNTRVJUKCFtX2xlYWZU ZXh0KTsKKworICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworCisgICAgbV9kb2N1bWVudC0+c2V0 WE1MVmVyc2lvbihTdHJpbmcodG9rZW4ueG1sVmVyc2lvbigpKSwgZWMpOworICAgIGlmIChlYykK KyAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7CisKKyAgICBtX2RvY3VtZW50LT5zZXRY TUxTdGFuZGFsb25lKHRva2VuLnhtbFN0YW5kYWxvbmUoKSwgZWMpOworICAgIGlmIChlYykKKyAg ICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7CisgICAgLy8gRklYTUU6IGhvdyBzaG91bGQg dGhpcyBiZWhhdmUgaWYgc3RhbmRhbG9uZSBpcyBub3Qgc3BlY2lmaWVkPworICAgIC8vIEZJWE1F OiBzZXQgZW5jb2RpbmcuCit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NET0NUWVBF KGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FM KEF0b21pY1N0cmluZywgeGh0bWxUcmFuc2l0aW9uYWwsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4w IFRyYW5zaXRpb25hbC8vRU4iKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJp bmcsIHhodG1sMTEsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4xLy9FTiIpKTsKKyAgICBERUZJTkVf U1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxTdHJpY3QsICgiLS8vVzNDLy9EVEQgWEhU TUwgMS4wIFN0cmljdC8vRU4iKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJp bmcsIHhodG1sRnJhbWVzZXQsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIEZyYW1lc2V0Ly9FTiIp KTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxCYXNpYywgKCIt Ly9XM0MvL0RURCBYSFRNTCBCYXNpYyAxLjAvL0VOIikpOworICAgIERFRklORV9TVEFUSUNfTE9D QUwoQXRvbWljU3RyaW5nLCB4aHRtbE1hdGhNTCwgKCItLy9XM0MvL0RURCBYSFRNTCAxLjEgcGx1 cyBNYXRoTUwgMi4wLy9FTiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmlu ZywgeGh0bWxNYXRoTUxTVkcsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4xIHBsdXMgTWF0aE1MIDIu MCBwbHVzIFNWRyAxLjEvL0VOIikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3Ry aW5nLCB4aHRtbE1vYmlsZSwgKCItLy9XQVBGT1JVTS8vRFREIFhIVE1MIE1vYmlsZSAxLjAvL0VO IikpOworCisgICAgQVNTRVJUKCFtX2xlYWZUZXh0KTsKKworICAgIEF0b21pY1N0cmluZyBwdWJs aWNJZGVudGlmaWVyKHRva2VuLnB1YmxpY0lkZW50aWZpZXIoKS5kYXRhKCksIHRva2VuLnB1Ymxp Y0lkZW50aWZpZXIoKS5zaXplKCkpOworICAgIEF0b21pY1N0cmluZyBzeXN0ZW1JZGVudGlmaWVy KHRva2VuLnN5c3RlbUlkZW50aWZpZXIoKS5kYXRhKCksIHRva2VuLnN5c3RlbUlkZW50aWZpZXIo KS5zaXplKCkpOworICAgIFJlZlB0cjxEb2N1bWVudFR5cGU+IGRvY3R5cGUgPSBEb2N1bWVudFR5 cGU6OmNyZWF0ZShtX2RvY3VtZW50LCB0b2tlbi5uYW1lKCksIHB1YmxpY0lkZW50aWZpZXIsIHN5 c3RlbUlkZW50aWZpZXIpOworICAgIG1fZG9jdW1lbnQtPnNldERvY1R5cGUoZG9jdHlwZSk7CisK KyAgICBpZiAoKHB1YmxpY0lkZW50aWZpZXIgPT0geGh0bWxUcmFuc2l0aW9uYWwpCisgICAgICAg IHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1sMTEpCisgICAgICAgIHx8IChwdWJsaWNJZGVu dGlmaWVyID09IHhodG1sU3RyaWN0KQorICAgICAgICB8fCAocHVibGljSWRlbnRpZmllciA9PSB4 aHRtbEZyYW1lc2V0KQorICAgICAgICB8fCAocHVibGljSWRlbnRpZmllciA9PSB4aHRtbEJhc2lj KQorICAgICAgICB8fCAocHVibGljSWRlbnRpZmllciA9PSB4aHRtbE1hdGhNTCkKKyAgICAgICAg fHwgKHB1YmxpY0lkZW50aWZpZXIgPT0geGh0bWxNYXRoTUxTVkcpCisgICAgICAgIHx8IChwdWJs aWNJZGVudGlmaWVyID09IHhodG1sTW9iaWxlKSkKKyAgICAgICAgbV9pc1hIVE1MID0gdHJ1ZTsK K30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1N0YXJ0VGFnKGNvbnN0IEF0b21pY1hN TFRva2VuJiB0b2tlbikKK3sKKyAgICBleGl0VGV4dCgpOworCisgICAgYm9vbCBpc0ZpcnN0RWxl bWVudCA9ICFtX3Nhd0ZpcnN0RWxlbWVudDsKKyAgICBtX3Nhd0ZpcnN0RWxlbWVudCA9IHRydWU7 CisKKyAgICBwcm9jZXNzTmFtZXNwYWNlcyh0b2tlbik7CisKKyAgICBRdWFsaWZpZWROYW1lIHFO YW1lKHRva2VuLnByZWZpeCgpLCB0b2tlbi5uYW1lKCksIG5hbWVzcGFjZUZvclByZWZpeCh0b2tl bi5wcmVmaXgoKSwgbV9jdXJyZW50U3RhY2tJdGVtLm5hbWVzcGFjZVVSSSgpKSk7CisgICAgUmVm UHRyPEVsZW1lbnQ+IG5ld0VsZW1lbnQgPSBtX2RvY3VtZW50LT5jcmVhdGVFbGVtZW50KHFOYW1l LCB0cnVlKTsKKyAgICBpZiAoIW5ld0VsZW1lbnQpIHsKKyAgICAgICAgbV9wYXJzZXItPnN0b3BQ YXJzaW5nKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBwcm9jZXNzQXR0cmlidXRl cyh0b2tlbiwgbmV3RWxlbWVudCk7CisKKyAgICBuZXdFbGVtZW50LT5iZWdpblBhcnNpbmdDaGls ZHJlbigpOworICAgIG1fY3VycmVudFN0YWNrSXRlbS5ub2RlKCktPnBhcnNlckFkZENoaWxkKG5l d0VsZW1lbnQuZ2V0KCkpOworCisgICAgaWYgKHRva2VuLnNlbGZDbG9zaW5nKCkpCisgICAgICAg IG5ld0VsZW1lbnQtPmZpbmlzaFBhcnNpbmdDaGlsZHJlbigpOworICAgIGVsc2UKKyAgICAgICAg cHVzaEN1cnJlbnROb2RlKG5ld0VsZW1lbnQuZ2V0KCkpOworCisgICAgbV9jdXJyZW50U3RhY2tJ dGVtID0gbV9jdXJyZW50Tm9kZVN0YWNrLmxhc3QoKTsKKworICAgIGlmICghbmV3RWxlbWVudC0+ YXR0YWNoZWQoKSkKKyAgICAgICAgbmV3RWxlbWVudC0+YXR0YWNoKCk7CisKKyAgICBpZiAoaXNG aXJzdEVsZW1lbnQgJiYgbV9kb2N1bWVudC0+ZnJhbWUoKSkKKyAgICAgICAgbV9kb2N1bWVudC0+ ZnJhbWUoKS0+bG9hZGVyKCktPmRpc3BhdGNoRG9jdW1lbnRFbGVtZW50QXZhaWxhYmxlKCk7Cit9 CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9r ZW4mIHRva2VuKQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBSZWZQdHI8Q29udGFpbmVyTm9k ZT4gbm9kZSA9IG1fY3VycmVudFN0YWNrSXRlbS5ub2RlKCk7CisKKyAgICBpZiAoIW5vZGUtPmhh c1RhZ05hbWUoUXVhbGlmaWVkTmFtZSh0b2tlbi5wcmVmaXgoKSwgdG9rZW4ubmFtZSgpLCBuYW1l c3BhY2VGb3JQcmVmaXgodG9rZW4ucHJlZml4KCksIG1fY3VycmVudFN0YWNrSXRlbS5uYW1lc3Bh Y2VVUkkoKSkpKSkKKyAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7CisgICAgCisgICAg cG9wQ3VycmVudE5vZGUoKTsKKyAgICBub2RlLT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsKK30K Kwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0NoYXJhY3Rlcihjb25zdCBBdG9taWNYTUxU b2tlbiYgdG9rZW4pCit7CisgICAgYXBwZW5kVG9UZXh0KHRva2VuLmNoYXJhY3RlcnMoKS5kYXRh KCksIHRva2VuLmNoYXJhY3RlcnMoKS5zaXplKCkpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVy Ojpwcm9jZXNzQ0RBVEEoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIGV4aXRU ZXh0KCk7CisKKyAgICBSZWZQdHI8Q0RBVEFTZWN0aW9uPiBjZGF0YSA9IENEQVRBU2VjdGlvbjo6 Y3JlYXRlKG1fZG9jdW1lbnQsIHRva2VuLmRhdGEoKSk7CisgICAgYWRkKGNkYXRhKTsKK30KKwor dm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0NvbW1lbnQoY29uc3QgQXRvbWljWE1MVG9rZW4m IHRva2VuKQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBSZWZQdHI8Q29tbWVudD4gY29tbWVu dCA9IENvbW1lbnQ6OmNyZWF0ZShtX2RvY3VtZW50LCB0b2tlbi5jb21tZW50KCkpOworICAgIGFk ZChjb21tZW50KTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0VudGl0eShjb25z dCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgLy8gRklYTUU6IHdlIHNob3VsZCBzdXBw b3J0IGludGVybmFsIHN1YnNldC4KKyAgICBpZiAobV9pc1hIVE1MKQorICAgICAgICBwcm9jZXNz SFRNTEVudGl0eSh0b2tlbik7CisgICAgZWxzZQorICAgICAgICBwcm9jZXNzWE1MRW50aXR5KHRv a2VuKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc05hbWVzcGFjZXMoY29uc3Qg QXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWlj U3RyaW5nLCB4bWxuc1ByZWZpeCwgKCJ4bWxucyIpKTsKKyAgICBpZiAoIXRva2VuLmF0dHJpYnV0 ZXMoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCB0b2tl bi5hdHRyaWJ1dGVzKCktPmxlbmd0aCgpOyArK2kpIHsKKyAgICAgICAgQXR0cmlidXRlKiBhdHRy aWJ1dGUgPSB0b2tlbi5hdHRyaWJ1dGVzKCktPmF0dHJpYnV0ZUl0ZW0oaSk7CisgICAgICAgIGlm IChhdHRyaWJ1dGUtPm5hbWUoKS5wcmVmaXgoKSA9PSB4bWxuc1ByZWZpeCkKKyAgICAgICAgICAg IG1fY3VycmVudFN0YWNrSXRlbS5zZXROYW1lc3BhY2VVUkkoYXR0cmlidXRlLT5uYW1lKCkubG9j YWxOYW1lKCksIGF0dHJpYnV0ZS0+dmFsdWUoKSk7CisgICAgICAgIGVsc2UgaWYgKGF0dHJpYnV0 ZS0+bmFtZSgpID09IHhtbG5zUHJlZml4KQorICAgICAgICAgICAgbV9jdXJyZW50U3RhY2tJdGVt LnNldE5hbWVzcGFjZVVSSShhdHRyaWJ1dGUtPnZhbHVlKCkpOworICAgIH0KK30KKwordm9pZCBY TUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0F0dHJpYnV0ZXMoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRv a2VuLCBQYXNzUmVmUHRyPEVsZW1lbnQ+IG5ld0VsZW1lbnQpCit7CisgICAgREVGSU5FX1NUQVRJ Q19MT0NBTChBdG9taWNTdHJpbmcsIHhtbG5zUHJlZml4LCAoInhtbG5zIikpOworICAgIGlmICgh dG9rZW4uYXR0cmlidXRlcygpKQorICAgICAgICByZXR1cm47CisKKyAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IHRva2VuLmF0dHJpYnV0ZXMoKS0+bGVuZ3RoKCk7ICsraSkgeworICAgICAgICBB dHRyaWJ1dGUqIGF0dHJpYnV0ZSA9IHRva2VuLmF0dHJpYnV0ZXMoKS0+YXR0cmlidXRlSXRlbShp KTsKKyAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CisgICAgICAgIGlmIChhdHRyaWJ1dGUt Pm5hbWUoKS5wcmVmaXgoKSA9PSB4bWxuc1ByZWZpeCkKKyAgICAgICAgICAgIG5ld0VsZW1lbnQt PnNldEF0dHJpYnV0ZU5TKFhNTE5TTmFtZXM6OnhtbG5zTmFtZXNwYWNlVVJJLCAieG1sbnM6IiAr IGF0dHJpYnV0ZS0+bmFtZSgpLmxvY2FsTmFtZSgpLCBhdHRyaWJ1dGUtPnZhbHVlKCksIGVjKTsK KyAgICAgICAgZWxzZSBpZiAoYXR0cmlidXRlLT5uYW1lKCkgPT0geG1sbnNQcmVmaXgpCisgICAg ICAgICAgICBuZXdFbGVtZW50LT5zZXRBdHRyaWJ1dGVOUyhYTUxOU05hbWVzOjp4bWxuc05hbWVz cGFjZVVSSSwgeG1sbnNBdG9tLCBhdHRyaWJ1dGUtPnZhbHVlKCksIGVjKTsKKyAgICAgICAgZWxz ZSB7CisgICAgICAgICAgICBRdWFsaWZpZWROYW1lIHFOYW1lKGF0dHJpYnV0ZS0+cHJlZml4KCks IGF0dHJpYnV0ZS0+bG9jYWxOYW1lKCksIG5hbWVzcGFjZUZvclByZWZpeChhdHRyaWJ1dGUtPnBy ZWZpeCgpLCBudWxsQXRvbSkpOworICAgICAgICAgICAgbmV3RWxlbWVudC0+c2V0QXR0cmlidXRl KHFOYW1lLCBhdHRyaWJ1dGUtPnZhbHVlKCkpOworICAgICAgICB9CisgICAgfQorfQorCit2b2lk IFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzWE1MRW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJiB0 b2tlbikKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgYW1wLCAoImFt cCIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgYXBvcywgKCJhcG9z IikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCBndCwgKCJndCIpKTsK KyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgbHQsICgibHQiKSk7CisgICAg REVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIHF1b3QsICgicXVvdCIpKTsKKyAgICBE RUZJTkVfU1RBVElDX0xPQ0FMKFN0cmluZywgYW1wUywgKCImIikpOworICAgIERFRklORV9TVEFU SUNfTE9DQUwoU3RyaW5nLCBhcG9zUywgKCInIikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwo U3RyaW5nLCBndFMsICgiPiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFN0cmluZywgbHRT LCAoIjwiKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIHF1b3RTLCAoIlwiIikp OworCisgICAgaWYgKHRva2VuLm5hbWUoKSA9PSBhbXApCisgICAgICAgIGFwcGVuZFRvVGV4dChh bXBTLmNoYXJhY3RlcnMoKSwgMSk7CisgICAgZWxzZSBpZiAodG9rZW4ubmFtZSgpID09IGFwb3Mp CisgICAgICAgIGFwcGVuZFRvVGV4dChhcG9zUy5jaGFyYWN0ZXJzKCksIDEpOworICAgIGVsc2Ug aWYgKHRva2VuLm5hbWUoKSA9PSBndCkKKyAgICAgICAgYXBwZW5kVG9UZXh0KGd0Uy5jaGFyYWN0 ZXJzKCksIDEpOworICAgIGVsc2UgaWYgKHRva2VuLm5hbWUoKSA9PSBsdCkKKyAgICAgICAgYXBw ZW5kVG9UZXh0KGx0Uy5jaGFyYWN0ZXJzKCksIDEpOworICAgIGVsc2UgaWYgKHRva2VuLm5hbWUo KSA9PSBxdW90KQorICAgICAgICBhcHBlbmRUb1RleHQocXVvdFMuY2hhcmFjdGVycygpLCAxKTsK KyAgICBlbHNlCisgICAgICAgIG1fcGFyc2VyLT5zdG9wUGFyc2luZygpOworfQorCit2b2lkIFhN TFRyZWVCdWlsZGVyOjpwcm9jZXNzSFRNTEVudGl0eShjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9r ZW4pCit7CisgICAgSFRNTEVudGl0eVNlYXJjaCBzZWFyY2g7CisgICAgY29uc3QgQXRvbWljU3Ry aW5nJiBuYW1lID0gdG9rZW4ubmFtZSgpOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbmFt ZS5sZW5ndGgoKTsgKytpKSB7CisgICAgICAgIHNlYXJjaC5hZHZhbmNlKG5hbWVbaV0pOworICAg ICAgICBpZiAoIXNlYXJjaC5pc0VudGl0eVByZWZpeCgpKSB7CisgICAgICAgICAgICBtX3BhcnNl ci0+c3RvcFBhcnNpbmcoKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0K KyAgICBzZWFyY2guYWR2YW5jZSgnOycpOworICAgIFVDaGFyMzIgZW50aXR5VmFsdWUgPSBzZWFy Y2guY3VycmVudFZhbHVlKCk7CisgICAgaWYgKGVudGl0eVZhbHVlIDw9IDB4RkZGRikKKyAgICAg ICBhcHBlbmRUb1RleHQocmVpbnRlcnByZXRfY2FzdDxVQ2hhcio+KCZlbnRpdHlWYWx1ZSksIDEp OworICAgIGVsc2UgeworICAgICAgICBVQ2hhciB1dGYxNlBhaXJbMl0gPSB7IFUxNl9MRUFEKGVu dGl0eVZhbHVlKSwgVTE2X1RSQUlMKGVudGl0eVZhbHVlKSB9OworICAgICAgICBhcHBlbmRUb1Rl eHQodXRmMTZQYWlyLCAyKTsKKyAgICB9Cit9CisKK2lubGluZSB2b2lkIFhNTFRyZWVCdWlsZGVy OjphZGQoUGFzc1JlZlB0cjxOb2RlPiBub2RlKQoreworICAgIG1fY3VycmVudFN0YWNrSXRlbS5u b2RlKCktPnBhcnNlckFkZENoaWxkKG5vZGUuZ2V0KCkpOworICAgIGlmICghbm9kZS0+YXR0YWNo ZWQoKSkKKyAgICAgICAgbm9kZS0+YXR0YWNoKCk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6 OmFwcGVuZFRvVGV4dChjb25zdCBVQ2hhciogdGV4dCwgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBl bnRlclRleHQoKTsKKworICAgIGlmICghbV9sZWFmVGV4dCkKKyAgICAgICAgcmV0dXJuOworCisg ICAgbV9sZWFmVGV4dC0+YXBwZW5kKHRleHQsIGxlbmd0aCk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1 aWxkZXI6OmVudGVyVGV4dCgpCit7CisgICAgaWYgKCFtX3Nhd0ZpcnN0RWxlbWVudCkgeworICAg ICAgICAvLyBGSVhNRTogZW5zdXJlIGl0J3MganVzdCB3aGl0ZXNwYWNlCisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBtX2xlYWZUZXh0ID0gYWRvcHRQdHIobmV3IFN0cmluZ0J1aWxkZXIo KSk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OmV4aXRUZXh0KCkKK3sKKyAgICBpZiAoIW1f bGVhZlRleHQuZ2V0KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxUZXh0PiB0ZXh0 ID0gVGV4dDo6Y3JlYXRlKG1fZG9jdW1lbnQsIG1fbGVhZlRleHQtPnRvU3RyaW5nKCkpOworICAg IGFkZCh0ZXh0KTsKKworICAgIG1fbGVhZlRleHQuY2xlYXIoKTsKK30KKworQXRvbWljU3RyaW5n IFhNTFRyZWVCdWlsZGVyOjpuYW1lc3BhY2VGb3JQcmVmaXgoQXRvbWljU3RyaW5nIHByZWZpeCwg QXRvbWljU3RyaW5nIGZhbGxiYWNrKQoreworICAgIEF0b21pY1N0cmluZyB1cmkgPSBmYWxsYmFj azsKKyAgICBpZiAoIXByZWZpeC5pc051bGwoKSAmJiBtX2N1cnJlbnRTdGFja0l0ZW0uaGFzTmFt ZXNwYWNlVVJJKHByZWZpeCkpCisgICAgICAgIHVyaSA9IG1fY3VycmVudFN0YWNrSXRlbS5uYW1l c3BhY2VVUkkocHJlZml4KTsKKworICAgIHJldHVybiB1cmk7Cit9CisKK1hNTFRyZWVCdWlsZGVy OjpOb2RlU3RhY2tJdGVtOjpOb2RlU3RhY2tJdGVtKFBhc3NSZWZQdHI8Q29udGFpbmVyTm9kZT4g biwgTm9kZVN0YWNrSXRlbSogcGFyZW50KQorICAgIDogbV9ub2RlKG4pCit7CisgICAgaWYgKCFw YXJlbnQpCisgICAgICAgIHJldHVybjsKKworICAgICAgICBtX25hbWVzcGFjZSA9IHBhcmVudC0+ bV9uYW1lc3BhY2U7CisgICAgICAgIG1fc2NvcGVkTmFtZXNwYWNlcyA9IHBhcmVudC0+bV9zY29w ZWROYW1lc3BhY2VzOworfQorCitib29sIFhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpo YXNOYW1lc3BhY2VVUkkoQXRvbWljU3RyaW5nIHByZWZpeCkKK3sKKyAgICByZXR1cm4gbV9zY29w ZWROYW1lc3BhY2VzLmNvbnRhaW5zKHByZWZpeCk7Cit9CisKK0F0b21pY1N0cmluZyBYTUxUcmVl QnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6bmFtZXNwYWNlVVJJKEF0b21pY1N0cmluZyBwcmVmaXgp Cit7CisgICAgaWYgKG1fc2NvcGVkTmFtZXNwYWNlcy5jb250YWlucyhwcmVmaXgpKQorICAgICAg ICByZXR1cm4gbV9zY29wZWROYW1lc3BhY2VzLmdldChwcmVmaXgpOworICAgIHJldHVybiBudWxs QXRvbTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6c2V0TmFtZXNw YWNlVVJJKEF0b21pY1N0cmluZyBwcmVmaXgsIEF0b21pY1N0cmluZyB1cmkpCit7CisgICAgbV9z Y29wZWROYW1lc3BhY2VzLnNldChwcmVmaXgsIHVyaSk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kNmQ3OWM5ZGQ4NjVkMmEy MzdhZTNlMWY2YzNiMjFiZTM1ZjY1ZmVhCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUveG1sL3BhcnNlci9YTUxUcmVlQnVpbGRlci5oCkBAIC0wLDAgKzEsMTE0IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDExIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEdPT0dMRSBJTkMuIGBgQVMg SVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgR09PR0xFIElOQy4gT1IKKyAqIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2lmbmRlZiBYTUxUcmVl QnVpbGRlcl9oCisjZGVmaW5lIFhNTFRyZWVCdWlsZGVyX2gKKworI2luY2x1ZGUgIlRleHQuaCIK KyNpbmNsdWRlICJYTUxUb2tlbi5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5j bHVkZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4K KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBDb250YWluZXJOb2RlOworY2xhc3MgRG9j dW1lbnQ7CitjbGFzcyBOZXdYTUxEb2N1bWVudFBhcnNlcjsKKworY2xhc3MgWE1MVHJlZUJ1aWxk ZXIgeworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFhNTFRyZWVCdWlsZGVyKTsKKyAgICBXVEZf TUFLRV9GQVNUX0FMTE9DQVRFRDsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxYTUxU cmVlQnVpbGRlcj4gY3JlYXRlKE5ld1hNTERvY3VtZW50UGFyc2VyKiBwYXJzZXIsIERvY3VtZW50 KiBkb2N1bWVudCkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgWE1MVHJlZUJ1 aWxkZXIocGFyc2VyLCBkb2N1bWVudCkpOworICAgIH0KKworICAgIHZvaWQgcHJvY2Vzc1Rva2Vu KGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisKK3ByaXZhdGU6CisgICAgWE1MVHJlZUJ1aWxkZXIo TmV3WE1MRG9jdW1lbnRQYXJzZXIqLCBEb2N1bWVudCopOworCisgICAgY2xhc3MgTm9kZVN0YWNr SXRlbSB7CisgICAgcHVibGljOgorICAgICAgICBOb2RlU3RhY2tJdGVtKFBhc3NSZWZQdHI8Q29u dGFpbmVyTm9kZT4gaXRlbSwgTm9kZVN0YWNrSXRlbSogcGFyZW50ID0gMCk7CisgICAgICAgIAor ICAgICAgICBib29sIGhhc05hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgcHJlZml4KTsKKyAgICAg ICAgQXRvbWljU3RyaW5nIG5hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgcHJlZml4KTsKKyAgICAg ICAgQXRvbWljU3RyaW5nIG5hbWVzcGFjZVVSSSgpIHsgcmV0dXJuIG1fbmFtZXNwYWNlOyB9Cisg ICAgICAgIHZvaWQgc2V0TmFtZXNwYWNlVVJJKEF0b21pY1N0cmluZyBwcmVmaXgsIEF0b21pY1N0 cmluZyB1cmkpOworICAgICAgICB2b2lkIHNldE5hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgdXJp KSB7IG1fbmFtZXNwYWNlID0gdXJpOyB9CisgICAgICAgIAorICAgICAgICBQYXNzUmVmUHRyPENv bnRhaW5lck5vZGU+IG5vZGUoKSB7IHJldHVybiBtX25vZGU7IH0KKyAgICAgICAgdm9pZCBzZXRO b2RlKFBhc3NSZWZQdHI8Q29udGFpbmVyTm9kZT4gbm9kZSkgeyBtX25vZGUgPSBub2RlOyB9Cisg ICAgICAgIAorICAgIHByaXZhdGU6CisgICAgICAgIEhhc2hNYXA8QXRvbWljU3RyaW5nLCBBdG9t aWNTdHJpbmc+IG1fc2NvcGVkTmFtZXNwYWNlczsKKyAgICAgICAgUmVmUHRyPENvbnRhaW5lck5v ZGU+IG1fbm9kZTsKKyAgICAgICAgQXRvbWljU3RyaW5nIG1fbmFtZXNwYWNlOworICAgIH07CisK KyAgICB2b2lkIHB1c2hDdXJyZW50Tm9kZShDb250YWluZXJOb2RlKik7CisgICAgdm9pZCBwb3BD dXJyZW50Tm9kZSgpOworCisgICAgdm9pZCBwcm9jZXNzUHJvY2Vzc2luZ0luc3RydWN0aW9uKGNv bnN0IEF0b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzWE1MRGVjbGFyYXRpb24oY29u c3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NET0NUWVBFKGNvbnN0IEF0b21p Y1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzU3RhcnRUYWcoY29uc3QgQXRvbWljWE1MVG9r ZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAg ICB2b2lkIHByb2Nlc3NDREFUQShjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJv Y2Vzc0NoYXJhY3Rlcihjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0Nv bW1lbnQoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NFbnRpdHkoY29u c3QgQXRvbWljWE1MVG9rZW4mKTsKKworICAgIHZvaWQgcHJvY2Vzc05hbWVzcGFjZXMoY29uc3Qg QXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NBdHRyaWJ1dGVzKGNvbnN0IEF0b21p Y1hNTFRva2VuJiwgUGFzc1JlZlB0cjxFbGVtZW50PiBuZXdFbGVtZW50KTsKKyAgICB2b2lkIHBy b2Nlc3NYTUxFbnRpdHkoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NI VE1MRW50aXR5KGNvbnN0IEF0b21pY1hNTFRva2VuJik7CisKKyAgICBpbmxpbmUgdm9pZCBhZGQo UGFzc1JlZlB0cjxOb2RlPik7CisKKyAgICB2b2lkIGFwcGVuZFRvVGV4dChjb25zdCBVQ2hhciog Y2hhcmFjdGVycywgc2l6ZV90IGxlbmd0aCk7CisgICAgdm9pZCBlbnRlclRleHQoKTsKKyAgICB2 b2lkIGV4aXRUZXh0KCk7CisKKyAgICBBdG9taWNTdHJpbmcgbmFtZXNwYWNlRm9yUHJlZml4KEF0 b21pY1N0cmluZyBwcmVmaXgsIEF0b21pY1N0cmluZyBmYWxsYmFjayk7CisKKyAgICBEb2N1bWVu dCogbV9kb2N1bWVudDsKKyAgICBOZXdYTUxEb2N1bWVudFBhcnNlciogbV9wYXJzZXI7CisKKyAg ICBib29sIG1faXNYSFRNTDsKKworICAgIGJvb2wgbV9zYXdGaXJzdEVsZW1lbnQ7CisgICAgTm9k ZVN0YWNrSXRlbSBtX2N1cnJlbnRTdGFja0l0ZW07CisgICAgVmVjdG9yPE5vZGVTdGFja0l0ZW0+ IG1fY3VycmVudE5vZGVTdGFjazsKKworICAgIE93blB0cjxTdHJpbmdCdWlsZGVyPiBtX2xlYWZU ZXh0OworfTsKKworfQorCisjZW5kaWYgLy8gWE1MVHJlZUJ1aWxkZXJfaAo= 103392 2011-08-09 14:01:07 -0700 2011-08-09 14:32:19 -0700 Patch for landing bug-65803-20110809140106.patch text/plain 31723 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogOTI2MDMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2MGQwZjljMGRjNjMyMmY3 NTgwY2E0ZDEwNjQ4YTdlZWZiY2E4YTM4Li43N2IyZjE5MDhkYWY0ODdjM2JiYzIyMTA5MWVjZjU1 ZTVmMTY5ZWE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTEtMDgtMDkgIEplZmZy ZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBJbml0aWFsIHBhc3MgYXQgYSBu ZXcgWE1MIHRyZWUgYnVpbGRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NjU4MDMKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisg ICAgICAgICogR05VbWFrZWZpbGUubGlzdC5hbToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6Cisg ICAgICAgICogV2ViQ29yZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52 Y3Byb2o6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICAqIHhtbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5ld1hNTERvY3VtZW50UGFyc2VyKToKKyAgICAg ICAgKFdlYkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjp+TmV3WE1MRG9jdW1lbnRQYXJzZXIp OgorICAgICAgICAoV2ViQ29yZTo6TmV3WE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZCk6CisgICAg ICAgIChXZWJDb3JlOjpOZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoKToKKyAgICAgICAgKFdl YkNvcmU6Ok5ld1hNTERvY3VtZW50UGFyc2VyOjpmaW5pc2hXYXNDYWxsZWQpOgorICAgICAgICAq IHhtbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiB4bWwvcGFyc2Vy L1hNTFRyZWVCdWlsZGVyLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVp bGRlcjo6WE1MVHJlZUJ1aWxkZXIpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6 OnByb2Nlc3NUb2tlbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHVzaEN1 cnJlbnROb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwb3BDdXJyZW50 Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1Byb2Nlc3Np bmdJbnN0cnVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vz c1hNTERlY2xhcmF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9j ZXNzRE9DVFlQRSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1N0 YXJ0VGFnKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzRW5kVGFn KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ2hhcmFjdGVyKToK KyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ0RBVEEpOgorICAgICAg ICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NDb21tZW50KToKKyAgICAgICAgKFdl YkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzRW50aXR5KToKKyAgICAgICAgKFdlYkNvcmU6 OlhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzTmFtZXNwYWNlcyk6CisgICAgICAgIChXZWJDb3JlOjpY TUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0F0dHJpYnV0ZXMpOgorICAgICAgICAoV2ViQ29yZTo6WE1M VHJlZUJ1aWxkZXI6OnByb2Nlc3NYTUxFbnRpdHkpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJl ZUJ1aWxkZXI6OnByb2Nlc3NIVE1MRW50aXR5KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVC dWlsZGVyOjphZGQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6OmFwcGVuZFRv VGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6ZW50ZXJUZXh0KToKKyAg ICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpleGl0VGV4dCk6CisgICAgICAgIChXZWJD b3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6Tm9kZVN0YWNrSXRlbSk6CisgICAg ICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0YWNrSXRlbTo6aGFzTmFtZXNwYWNl VVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpu YW1lc3BhY2VVUkkpOgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFj a0l0ZW06OnNldE5hbWVzcGFjZVVSSSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRl cjo6Tm9kZVN0YWNrSXRlbTo6bmFtZXNwYWNlRm9yUHJlZml4KToKKyAgICAgICAgKiB4bWwvcGFy c2VyL1hNTFRyZWVCdWlsZGVyLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6WE1MVHJlZUJ1 aWxkZXI6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxUcmVlQnVpbGRlcjo6Tm9kZVN0 YWNrSXRlbTo6bmFtZXNwYWNlVVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTFRyZWVCdWlsZGVy OjpOb2RlU3RhY2tJdGVtOjpzZXROYW1lc3BhY2VVUkkpOgorICAgICAgICAoV2ViQ29yZTo6WE1M VHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06Om5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1M VHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06OnNldE5vZGUpOgorCiAyMDExLTA4LTA4ICBEYW4g QmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgQnVpbGQgZml4LgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggYTA2OGMwMjQ0OGE3NjA1Mzc3ZDdlMDg0NjQzMDc4 ZWU2NDk4YmQ0ZC4uYzBiYjk1YTZmZjc0NGNhNDAxNmMyMDRiNzE0OTJhOWJhNjM1ODAyMSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2Uv V2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0zODM3LDYgKzM4MzcsOCBAQCB3ZWJjb3Jl X3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1MVG9rZW5pemVyLmNw cCBcCiAJU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9YTUxUb2tlbml6ZXIuaCBcCiAJU291cmNl L1dlYkNvcmUveG1sL3BhcnNlci9YTUxUb2tlbi5oIFwKKwlTb3VyY2UvV2ViQ29yZS94bWwvcGFy c2VyL1hNTFRyZWVCdWlsZGVyLmNwcCBcCisJU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9YTUxU cmVlQnVpbGRlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS94bWwvRE9NUGFyc2VyLmNwcCBcCiAJU291 cmNlL1dlYkNvcmUveG1sL0RPTVBhcnNlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS94bWwvTmF0aXZl WFBhdGhOU1Jlc29sdmVyLmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggOGQwZGZmNWNiMWY1NzFi NzIzMjgxMmQ3NDZmYzhhOTk1ZjViOGYzNy4uNWIyNzI3YzljMWFmNjMyZDA3ZjZkMzBkMWQwODM4 ODAzNGUyMDFiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtNTE0Miw2ICs1MTQyLDggQEAKICAgICAg ICAgICAgICd4bWwvcGFyc2VyL1hNTFRva2VuaXplci5jcHAnLAogICAgICAgICAgICAgJ3htbC9w YXJzZXIvWE1MVG9rZW5pemVyLmgnLAogICAgICAgICAgICAgJ3htbC9wYXJzZXIvWE1MVG9rZW4u aCcsCisgICAgICAgICAgICAneG1sL3BhcnNlci9YTUxUcmVlQnVpbGRlci5jcHAnLAorICAgICAg ICAgICAgJ3htbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaCcsCiAgICAgICAgICAgICAneG1sL0RP TVBhcnNlci5jcHAnLAogICAgICAgICAgICAgJ3htbC9ET01QYXJzZXIuaCcsCiAgICAgICAgICAg ICAneG1sL05hdGl2ZVhQYXRoTlNSZXNvbHZlci5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvV2ViQ29yZS5wcm8gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCBhNmY4 OWE0YjYyZmFiZTBlYzdjNzFlMDhjMDk5NTJmMGVlNGQwMThmLi5mYzU2OTYyM2FiMmUzODJkODE5 YTExYWEyOWVhYTMzODVkN2Q5MTAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl LnBybworKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMTIwNyw3ICsxMjA3LDgg QEAgU09VUkNFUyArPSBcCiAgICAgeG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5jcHAg XAogICAgIHhtbC9wYXJzZXIvWE1MQ2hhcmFjdGVyUmVmZXJlbmNlUGFyc2VyLmNwcCBcCiAgICAg eG1sL3BhcnNlci9YTUxEb2N1bWVudFBhcnNlci5jcHAgXAotICAgIHhtbC9wYXJzZXIvWE1MVG9r ZW5pemVyLmNwcAorICAgIHhtbC9wYXJzZXIvWE1MVG9rZW5pemVyLmNwcCBcCisgICAgeG1sL3Bh cnNlci9YTUxUcmVlQnVpbGRlci5jcHAKIAogSEVBREVSUyArPSBcCiAgICAgYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5QVJJQUdyaWRDZWxsLmggXApAQCAtMjUxOSw2ICsyNTIwLDcgQEAgSEVB REVSUyArPSBcCiAgICAgeG1sL3BhcnNlci9YTUxEb2N1bWVudFBhcnNlci5oIFwKICAgICB4bWwv cGFyc2VyL1hNTFRva2VuaXplci5oIFwKICAgICB4bWwvcGFyc2VyL1hNTFRva2VuLmggXAorICAg IHhtbC9wYXJzZXIvWE1MVHJlZUJ1aWxkZXIuaCBcCiAgICAgeG1sL0RPTVBhcnNlci5oIFwKICAg ICB4bWwvTmF0aXZlWFBhdGhOU1Jlc29sdmVyLmggXAogICAgIHhtbC9YTUxIdHRwUmVxdWVzdC5o IFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXgg YjJlNjllMGVlYTVmNjFmZjQ1OGNlNzM3YWM5ZDVlOWYzNmFhNWFiMC4uYTA2NmY2OTVkNjBmYzE5 ZjVkMzU0YWViMWI5YTg5OGJjYjNlMzNhNiAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTQyNzQ1LDYgKzQyNzQ1LDE0IEBACiAJCQkJCT4KIAkJ CQk8L0ZpbGU+CiAJCQkJPEZpbGUKKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlx4bWxccGFyc2VyXE5l d1hNTERvY3VtZW50UGFyc2VyLmgiCisJCQkJCT4KKwkJCQk8L0ZpbGU+CisJCQkJPEZpbGUKKwkJ CQkJUmVsYXRpdmVQYXRoPSIuLlx4bWxccGFyc2VyXE5ld1hNTERvY3VtZW50UGFyc2VyLmNwcCIK KwkJCQkJPgorCQkJCTwvRmlsZT4KKwkJCQk8RmlsZQogCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHht bFxwYXJzZXJcWE1MRG9jdW1lbnRQYXJzZXIuY3BwIgogCQkJCQk+CiAJCQkJCTxGaWxlQ29uZmln dXJhdGlvbgpAQCAtNDI4NjgsNiArNDI4NzYsMTQgQEAKIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlx4 bWxccGFyc2VyXFhNTFRva2VuaXplci5oIgogCQkJCQk+CiAJCQkJPC9GaWxlPgorCQkJCTxGaWxl CisJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBhcnNlclxYTUxUcmVlQnVpbGRlci5oIgorCQkJ CQk+CisJCQkJPC9GaWxlPgorCQkJCTxGaWxlCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5ceG1sXHBh cnNlclxYTUxUcmVlQnVpbGRlci5jcHAiCisJCQkJCT4KKwkJCQk8L0ZpbGU+CiAJCQk8L0ZpbHRl cj4KIAkJPC9GaWx0ZXI+CiAJCTxGaWx0ZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3ZDZmN2FlMzk4Njk3MTUzZjRjZmRmNTU4 ZDY1ODNlMTBhNDM4NWI4Li5iZTM3Y2MxZWM2YTI0OWI4NDNiMGU5NzgyNDAwOGEwZmQ0YjU1ZmY5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCkBAIC01MSw2ICs1MSw4IEBACiAJCTAwMDJFQzVBMTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxU b2tlbml6ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDAwMDJFQzU3MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIuaCAqLzsgfTsKIAkJMDAx NDYyOEExMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMTQ2Mjg4MTAzQ0QxREUwMDBC MjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi87IH07CiAJCTAwMTQ2MjhCMTAzQ0QxREUw MDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gMDAxNDYyODkxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFj Y2Vzc0VudHJ5LmggKi87IH07CisJCTAwMzVFQkJCMTNGMDZGRjIwMEE1NjA4OSAvKiBYTUxUcmVl QnVpbGRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g MDAzNUVCQkExM0YwNkZGMjAwQTU2MDg5IC8qIFhNTFRyZWVCdWlsZGVyLmggKi87IH07CisJCTAw MzVFQkJFMTNGMDcxM0MwMEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDM1RUJCRDEzRjA3MTNDMDBBNTYw ODkgLyogWE1MVHJlZUJ1aWxkZXIuY3BwICovOyB9OwogCQkwMDNGMUZFQTExRTZBQjQzMDA4MjU4 RDkgLyogVXNlckNvbnRlbnRUeXBlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gMDAzRjFGRTkxMUU2QUI0MzAwODI1OEQ5IC8qIFVzZXJDb250ZW50VHlw ZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQkw MEE2MjlDMTEzRDBCRUM3MDA1MEFDNTIgLyogTWFya3VwVG9rZW5CYXNlLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMEE2MjlDMDEzRDBCRUM3MDA1MEFD NTIgLyogTWFya3VwVG9rZW5CYXNlLmggKi87IH07CiAJCTAwQjkzMTg3MTNCQThEQjMwMDM1QTk0 OCAvKiBYTUxEb2N1bWVudFBhcnNlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSAwMEI5MzE4MTEzQkE4NjdGMDAzNUE5NDggLyogWE1MRG9jdW1lbnRQ YXJzZXIuY3BwICovOyB9OwpAQCAtNjQ4NSw2ICs2NDg3LDggQEAKIAkJMDAwMkVDNTcxM0MzRjY3 RDAwMDQwRDQ3IC8qIFhNTFRva2VuaXplci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBYTUxUb2tlbml6ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDAxNDYy ODgxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IE9yaWdpbkFjY2Vzc0VudHJ5LmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDAxNDYyODkxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFj Y2Vzc0VudHJ5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9yaWdpbkFjY2Vz c0VudHJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTAwMzVFQkJBMTNGMDZGRjIw MEE1NjA4OSAvKiBYTUxUcmVlQnVpbGRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBYTUxUcmVlQnVpbGRlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQkwMDM1 RUJCRDEzRjA3MTNDMDBBNTYwODkgLyogWE1MVHJlZUJ1aWxkZXIuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gWE1MVHJlZUJ1aWxkZXIuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQkwMDNGMUZFOTExRTZBQjQzMDA4MjU4RDkgLyogVXNlckNvbnRlbnRU eXBlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBVc2VyQ29udGVudFR5cGVz Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTAwQTYyOUMwMTNEMEJFQzcwMDUwQUM1 MiAvKiBNYXJrdXBUb2tlbkJhc2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g TWFya3VwVG9rZW5CYXNlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTAwQjkzMTgx MTNCQTg2N0YwMDM1QTk0OCAvKiBYTUxEb2N1bWVudFBhcnNlci5jcHAgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBYTUxEb2N1bWVudFBhcnNlci5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CkBAIC0xMjg2Miw2ICsxMjg2Niw4IEBACiAJCQkJMDAwMkVDNTUxM0Mz RjY3RDAwMDQwRDQ3IC8qIFhNTFRva2VuLmggKi8sCiAJCQkJMDAwMkVDNTYxM0MzRjY3RDAwMDQw RDQ3IC8qIFhNTFRva2VuaXplci5jcHAgKi8sCiAJCQkJMDAwMkVDNTcxM0MzRjY3RDAwMDQwRDQ3 IC8qIFhNTFRva2VuaXplci5oICovLAorCQkJCTAwMzVFQkJEMTNGMDcxM0MwMEE1NjA4OSAvKiBY TUxUcmVlQnVpbGRlci5jcHAgKi8sCisJCQkJMDAzNUVCQkExM0YwNkZGMjAwQTU2MDg5IC8qIFhN TFRyZWVCdWlsZGVyLmggKi8sCiAJCQkpOwogCQkJcGF0aCA9IHBhcnNlcjsKIAkJCXNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7CkBAIC0yMzMzMCw2ICsyMzMzNiw3IEBACiAJCQkJMUFDRTUzRUIwQThE MThFNzAwMjI5NDdEIC8qIFhNTFNlcmlhbGl6ZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTAwMDJF QzU4MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMDAw MkVDNUExM0MzRjY3RDAwMDQwRDQ3IC8qIFhNTFRva2VuaXplci5oIGluIEhlYWRlcnMgKi8sCisJ CQkJMDAzNUVCQkIxM0YwNkZGMjAwQTU2MDg5IC8qIFhNTFRyZWVCdWlsZGVyLmggaW4gSGVhZGVy cyAqLywKIAkJCQk1OTA1QURDMDEzMDJGM0NFMDBGMTE2REYgLyogWE1MVHJlZVZpZXdlci5oIGlu IEhlYWRlcnMgKi8sCiAJCQkJMUFCN0ZDNjkwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoRXZhbHVh dG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzYwREE1QjBEMkEzMUY3MDBCOTkxOEYgLyogWFBh dGhFeGNlcHRpb24uaCBpbiBIZWFkZXJzICovLApAQCAtMjYxMzcsNiArMjYxNDQsNyBAQAogCQkJ CUUxNUEzNkQ5MTEwNDU3MjcwMEI3QjYzOSAvKiBYTUxOU05hbWVzLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTFBQ0U1M0VBMEE4RDE4RTcwMDIyOTQ3RCAvKiBYTUxTZXJpYWxpemVyLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTAwMDJFQzU5MTNDM0Y2N0QwMDA0MEQ0NyAvKiBYTUxUb2tlbml6ZXIu Y3BwIGluIFNvdXJjZXMgKi8sCisJCQkJMDAzNUVCQkUxM0YwNzEzQzAwQTU2MDg5IC8qIFhNTFRy ZWVCdWlsZGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTU5MDVBREJGMTMwMkYzQ0UwMEYxMTZE RiAvKiBYTUxUcmVlVmlld2VyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTFBQjdGQzY4MEE4Qjky RUMwMEQ5RDM3QiAvKiBYUGF0aEV2YWx1YXRvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQUI3 RkM2QjBBOEI5MkVDMDBEOUQzN0IgLyogWFBhdGhFeHByZXNzaW9uLmNwcCBpbiBTb3VyY2VzICov LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBh cnNlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2Vy LmNwcAppbmRleCAyZmFjMjcxOTRhZTkwZmRlNzE3NzVmYjlmOTZjNTczYzlkZjIwZWFjLi4xMTEy ZGIyMDY3YTRiY2YzZDcyYzgzZDA0NTUyNDE5NTUwM2NlOGNiIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS94bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtMjcsMTIgKzI3 LDE5IEBACiAjaW5jbHVkZSAiTmV3WE1MRG9jdW1lbnRQYXJzZXIuaCIKIAogI2luY2x1ZGUgIlNl Z21lbnRlZFN0cmluZy5oIgorI2luY2x1ZGUgIlhNTFRyZWVCdWlsZGVyLmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogTmV3WE1MRG9jdW1lbnRQYXJzZXI6Ok5ld1hNTERvY3VtZW50UGFyc2Vy KERvY3VtZW50KiBkb2N1bWVudCkKICAgICA6IFNjcmlwdGFibGVEb2N1bWVudFBhcnNlcihkb2N1 bWVudCkKICAgICAsIG1fdG9rZW5pemVyKFhNTFRva2VuaXplcjo6Y3JlYXRlKCkpCisgICAgLCBt X2ZpbmlzaFdhc0NhbGxlZChmYWxzZSkKKyAgICAsIG1fdHJlZUJ1aWxkZXIoWE1MVHJlZUJ1aWxk ZXI6OmNyZWF0ZSh0aGlzLCBkb2N1bWVudCkpCit7Cit9CisKK05ld1hNTERvY3VtZW50UGFyc2Vy Ojp+TmV3WE1MRG9jdW1lbnRQYXJzZXIoKQogewogfQogCkBAIC02Myw3ICs3MCwxMCBAQCB2b2lk IE5ld1hNTERvY3VtZW50UGFyc2VyOjphcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBzdHJp bmcpCiAgICAgICAgIG1fdG9rZW4ucHJpbnQoKTsKICNlbmRpZgogCi0gICAgICAgIGlmIChtX3Rv a2VuLnR5cGUoKSA9PSBYTUxUb2tlblR5cGVzOjpFbmRPZkZpbGUpCisgICAgICAgIEF0b21pY1hN TFRva2VuIHRva2VuKG1fdG9rZW4pOworICAgICAgICBtX3RyZWVCdWlsZGVyLT5wcm9jZXNzVG9r ZW4odG9rZW4pOworCisgICAgICAgIGlmIChtX3Rva2VuLnR5cGUoKSA9PSBYTUxUb2tlblR5cGVz OjpFbmRPZkZpbGUgfHwgIWlzUGFyc2luZygpKQogICAgICAgICAgICAgYnJlYWs7CiAKICAgICAg ICAgbV90b2tlbi5jbGVhcigpOwpAQCAtNzMsMTEgKzgzLDEzIEBAIHZvaWQgTmV3WE1MRG9jdW1l bnRQYXJzZXI6OmFwcGVuZChjb25zdCBTZWdtZW50ZWRTdHJpbmcmIHN0cmluZykKIAogdm9pZCBO ZXdYTUxEb2N1bWVudFBhcnNlcjo6ZmluaXNoKCkKIHsKLX0KKyAgICBBU1NFUlQoIW1fZmluaXNo V2FzQ2FsbGVkKTsKKyAgICBtX2ZpbmlzaFdhc0NhbGxlZCA9IHRydWU7CiAKLXZvaWQgTmV3WE1M RG9jdW1lbnRQYXJzZXI6OmRldGFjaCgpCi17Ci0gICAgU2NyaXB0YWJsZURvY3VtZW50UGFyc2Vy OjpkZXRhY2goKTsKKyAgICBpZiAoaXNQYXJzaW5nKCkpCisgICAgICAgIHByZXBhcmVUb1N0b3BQ YXJzaW5nKCk7CisgICAgZG9jdW1lbnQoKS0+c2V0UmVhZHlTdGF0ZShEb2N1bWVudDo6SW50ZXJh Y3RpdmUpOworICAgIGRvY3VtZW50KCktPmZpbmlzaGVkUGFyc2luZygpOwogfQogCiBib29sIE5l d1hNTERvY3VtZW50UGFyc2VyOjpoYXNJbnNlcnRpb25Qb2ludCgpCkBAIC04NywyMCArOTksNyBA QCBib29sIE5ld1hNTERvY3VtZW50UGFyc2VyOjpoYXNJbnNlcnRpb25Qb2ludCgpCiAKIGJvb2wg TmV3WE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaFdhc0NhbGxlZCgpCiB7Ci0gICAgcmV0dXJuIGZh bHNlOwotfQotCi1ib29sIE5ld1hNTERvY3VtZW50UGFyc2VyOjpwcm9jZXNzaW5nRGF0YSgpIGNv bnN0Ci17Ci0gICAgcmV0dXJuIGZhbHNlOwotfQotCi12b2lkIE5ld1hNTERvY3VtZW50UGFyc2Vy OjpwcmVwYXJlVG9TdG9wUGFyc2luZygpCi17Ci19Ci0KLXZvaWQgTmV3WE1MRG9jdW1lbnRQYXJz ZXI6OnN0b3BQYXJzaW5nKCkKLXsKKyAgICByZXR1cm4gbV9maW5pc2hXYXNDYWxsZWQ7CiB9CiAK IGJvb2wgTmV3WE1MRG9jdW1lbnRQYXJzZXI6OmlzV2FpdGluZ0ZvclNjcmlwdHMoKSBjb25zdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNl ci5oIGIvU291cmNlL1dlYkNvcmUveG1sL3BhcnNlci9OZXdYTUxEb2N1bWVudFBhcnNlci5oCmlu ZGV4IDM1NzU3NTRkZGEzZjlhNGI1MTI4ZmY0OGNiNDA2ODA3OTEzM2YxMGQuLjczOTQwNTA1YzIw NmNmMjg1NjkwNTdmMWY3ZTVmNTU5Y2M1NTdmYzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3htbC9wYXJzZXIvTmV3WE1MRG9jdW1lbnRQYXJzZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS94 bWwvcGFyc2VyL05ld1hNTERvY3VtZW50UGFyc2VyLmgKQEAgLTM2LDYgKzM2LDggQEAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBDb250YWluZXJOb2RlOwor Y2xhc3MgWE1MVHJlZUJ1aWxkZXI7CiAKIGNsYXNzIE5ld1hNTERvY3VtZW50UGFyc2VyIDogcHVi bGljIFNjcmlwdGFibGVEb2N1bWVudFBhcnNlciB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FU RUQ7CkBAIC00NCwzMiArNDYsMzIgQEAgcHVibGljOgogICAgIHsKICAgICAgICAgcmV0dXJuIGFk b3B0UmVmKG5ldyBOZXdYTUxEb2N1bWVudFBhcnNlcihkb2N1bWVudCkpOwogICAgIH0KLSAgICAK KwogICAgIHZpcnR1YWwgVGV4dFBvc2l0aW9uMCB0ZXh0UG9zaXRpb24oKSBjb25zdDsKICAgICB2 aXJ0dWFsIGludCBsaW5lTnVtYmVyKCkgY29uc3Q7CiAKKyAgICAvLyBEb2N1bWVudFBhcnNlcgor ICAgIHZpcnR1YWwgYm9vbCBoYXNJbnNlcnRpb25Qb2ludCgpOworICAgIHZpcnR1YWwgYm9vbCBm aW5pc2hXYXNDYWxsZWQoKTsKKyAgICB2aXJ0dWFsIGJvb2wgaXNXYWl0aW5nRm9yU2NyaXB0cygp IGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNvbnN0OworICAg IHZpcnR1YWwgdm9pZCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworCiBw cm90ZWN0ZWQ6CiAgICAgdmlydHVhbCB2b2lkIGluc2VydChjb25zdCBTZWdtZW50ZWRTdHJpbmcm KTsKICAgICB2aXJ0dWFsIHZvaWQgYXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYpOwogICAg IHZpcnR1YWwgdm9pZCBmaW5pc2goKTsKIAotCiBwcml2YXRlOgogICAgIE5ld1hNTERvY3VtZW50 UGFyc2VyKERvY3VtZW50Kik7Ci0KLSAgICAvLyBEb2N1bWVudFBhcnNlcgotICAgIHZpcnR1YWwg dm9pZCBkZXRhY2goKTsKLSAgICB2aXJ0dWFsIGJvb2wgaGFzSW5zZXJ0aW9uUG9pbnQoKTsKLSAg ICB2aXJ0dWFsIGJvb2wgZmluaXNoV2FzQ2FsbGVkKCk7Ci0gICAgdmlydHVhbCBib29sIHByb2Nl c3NpbmdEYXRhKCkgY29uc3Q7Ci0gICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1N0b3BQYXJzaW5n KCk7Ci0gICAgdmlydHVhbCB2b2lkIHN0b3BQYXJzaW5nKCk7Ci0gICAgdmlydHVhbCBib29sIGlz V2FpdGluZ0ZvclNjcmlwdHMoKSBjb25zdDsKLSAgICB2aXJ0dWFsIGJvb2wgaXNFeGVjdXRpbmdT Y3JpcHQoKSBjb25zdDsKLSAgICB2aXJ0dWFsIHZvaWQgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9y U3R5bGVzaGVldHMoKTsKKyAgICB2aXJ0dWFsIH5OZXdYTUxEb2N1bWVudFBhcnNlcigpOwogCiAg ICAgT3duUHRyPFhNTFRva2VuaXplcj4gbV90b2tlbml6ZXI7CiAgICAgWE1MVG9rZW4gbV90b2tl bjsKKworICAgIGJvb2wgbV9maW5pc2hXYXNDYWxsZWQ7CisKKyAgICBPd25QdHI8WE1MVHJlZUJ1 aWxkZXI+IG1fdHJlZUJ1aWxkZXI7CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS94bWwvcGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJz ZXIvWE1MVHJlZUJ1aWxkZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjEwMjU4NmM5ZDA2YzJlOGQ3ODMzMGVj NzhhN2JiZjdiNTBhOGUzNTYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS94bWwv cGFyc2VyL1hNTFRyZWVCdWlsZGVyLmNwcApAQCAtMCwwICsxLDM4OSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBB TkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisg KiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNp bmNsdWRlICJYTUxUcmVlQnVpbGRlci5oIgorCisjaW5jbHVkZSAiQ0RBVEFTZWN0aW9uLmgiCisj aW5jbHVkZSAiQ29tbWVudC5oIgorI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRG9j dW1lbnRUeXBlLmgiCisjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJIVE1MRW50aXR5U2Vh cmNoLmgiCisjaW5jbHVkZSAiTmV3WE1MRG9jdW1lbnRQYXJzZXIuaCIKKyNpbmNsdWRlICJQcm9j ZXNzaW5nSW5zdHJ1Y3Rpb24uaCIKKyNpbmNsdWRlICJYTUxOU05hbWVzLmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworWE1MVHJlZUJ1aWxkZXI6OlhNTFRyZWVCdWlsZGVyKE5ld1hNTERvY3Vt ZW50UGFyc2VyKiBwYXJzZXIsIERvY3VtZW50KiBkb2N1bWVudCkKKyAgICA6IG1fZG9jdW1lbnQo ZG9jdW1lbnQpCisgICAgLCBtX3BhcnNlcihwYXJzZXIpCisgICAgLCBtX2lzWEhUTUwoZmFsc2Up Cit7CisgICAgbV9jdXJyZW50Tm9kZVN0YWNrLmFwcGVuZChOb2RlU3RhY2tJdGVtKGRvY3VtZW50 KSk7Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NUb2tlbihjb25zdCBBdG9taWNY TUxUb2tlbiYgdG9rZW4pCit7CisgICAgc3dpdGNoICh0b2tlbi50eXBlKCkpIHsKKyAgICBjYXNl IFhNTFRva2VuVHlwZXM6OlVuaW5pdGlhbGl6ZWQ6CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hF RCgpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OlByb2Nlc3NpbmdJ bnN0cnVjdGlvbjoKKyAgICAgICAgcHJvY2Vzc1Byb2Nlc3NpbmdJbnN0cnVjdGlvbih0b2tlbik7 CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6WE1MRGVjbGFyYXRpb246 CisgICAgICAgIHByb2Nlc3NYTUxEZWNsYXJhdGlvbih0b2tlbik7CisgICAgICAgIGJyZWFrOwor ICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6RE9DVFlQRToKKyAgICAgICAgcHJvY2Vzc0RPQ1RZUEUo dG9rZW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFhNTFRva2VuVHlwZXM6OlN0YXJ0VGFn OgorICAgICAgICBwcm9jZXNzU3RhcnRUYWcodG9rZW4pOworICAgICAgICBicmVhazsKKyAgICBj YXNlIFhNTFRva2VuVHlwZXM6OkVuZFRhZzoKKyAgICAgICAgcHJvY2Vzc0VuZFRhZyh0b2tlbik7 CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBlczo6Q0RBVEE6CisgICAgICAg IHByb2Nlc3NDREFUQSh0b2tlbik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5U eXBlczo6Q2hhcmFjdGVyOgorICAgICAgICBwcm9jZXNzQ2hhcmFjdGVyKHRva2VuKTsKKyAgICAg ICAgYnJlYWs7CisgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpDb21tZW50OgorICAgICAgICBwcm9j ZXNzQ29tbWVudCh0b2tlbik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgWE1MVG9rZW5UeXBl czo6RW50aXR5OgorICAgICAgICBwcm9jZXNzRW50aXR5KHRva2VuKTsKKyAgICAgICAgYnJlYWs7 CisgICAgY2FzZSBYTUxUb2tlblR5cGVzOjpFbmRPZkZpbGU6CisgICAgICAgIHJldHVybjsKKyAg ICB9Cit9CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnB1c2hDdXJyZW50Tm9kZShjb25zdCBOb2Rl U3RhY2tJdGVtJiBzdGFja0l0ZW0pCit7CisgICAgbV9jdXJyZW50Tm9kZVN0YWNrLmFwcGVuZChz dGFja0l0ZW0pOworICAgIC8vIEZJWE1FOiBpcyB0aGVyZSBhIG1heGltdW0gRE9NIGRlcHRoPwor fQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwb3BDdXJyZW50Tm9kZSgpCit7CisgICAgQVNTRVJU KG1fY3VycmVudE5vZGVTdGFjay5zaXplKCkpOworCisgICAgbV9jdXJyZW50Tm9kZVN0YWNrLnJl bW92ZUxhc3QoKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1Byb2Nlc3NpbmdJ bnN0cnVjdGlvbihjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgQVNTRVJUKCFt X2xlYWZUZXh0KTsKKyAgICAvLyBGSVhNRTogZmFsbCBiYWNrIGlmIHdlIGNhbid0IGhhbmRsZSB0 aGUgUEkgb3Vyc2VsZi4KKworICAgIGFkZChQcm9jZXNzaW5nSW5zdHJ1Y3Rpb246OmNyZWF0ZSht X2RvY3VtZW50LCB0b2tlbi50YXJnZXQoKSwgdG9rZW4uZGF0YSgpKSk7Cit9CisKK3ZvaWQgWE1M VHJlZUJ1aWxkZXI6OnByb2Nlc3NYTUxEZWNsYXJhdGlvbihjb25zdCBBdG9taWNYTUxUb2tlbiYg dG9rZW4pCit7CisgICAgQVNTRVJUKCFtX2xlYWZUZXh0KTsKKworICAgIEV4Y2VwdGlvbkNvZGUg ZWMgPSAwOworCisgICAgbV9kb2N1bWVudC0+c2V0WE1MVmVyc2lvbihTdHJpbmcodG9rZW4ueG1s VmVyc2lvbigpKSwgZWMpOworICAgIGlmIChlYykKKyAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJz aW5nKCk7CisKKyAgICBtX2RvY3VtZW50LT5zZXRYTUxTdGFuZGFsb25lKHRva2VuLnhtbFN0YW5k YWxvbmUoKSwgZWMpOworICAgIGlmIChlYykKKyAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5n KCk7CisgICAgLy8gRklYTUU6IGhvdyBzaG91bGQgdGhpcyBiZWhhdmUgaWYgc3RhbmRhbG9uZSBp cyBub3Qgc3BlY2lmaWVkPworICAgIC8vIEZJWE1FOiBzZXQgZW5jb2RpbmcuCit9CisKK3ZvaWQg WE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NET0NUWVBFKGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tl bikKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxUcmFuc2l0 aW9uYWwsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iKSk7CisgICAg REVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIHhodG1sMTEsICgiLS8vVzNDLy9EVEQg WEhUTUwgMS4xLy9FTiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywg eGh0bWxTdHJpY3QsICgiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iKSk7CisgICAg REVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcsIHhodG1sRnJhbWVzZXQsICgiLS8vVzND Ly9EVEQgWEhUTUwgMS4wIEZyYW1lc2V0Ly9FTiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FM KEF0b21pY1N0cmluZywgeGh0bWxCYXNpYywgKCItLy9XM0MvL0RURCBYSFRNTCBCYXNpYyAxLjAv L0VOIikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCB4aHRtbE1hdGhN TCwgKCItLy9XM0MvL0RURCBYSFRNTCAxLjEgcGx1cyBNYXRoTUwgMi4wLy9FTiIpKTsKKyAgICBE RUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeGh0bWxNYXRoTUxTVkcsICgiLS8vVzND Ly9EVEQgWEhUTUwgMS4xIHBsdXMgTWF0aE1MIDIuMCBwbHVzIFNWRyAxLjEvL0VOIikpOworICAg IERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCB4aHRtbE1vYmlsZSwgKCItLy9XQVBG T1JVTS8vRFREIFhIVE1MIE1vYmlsZSAxLjAvL0VOIikpOworCisgICAgQVNTRVJUKCFtX2xlYWZU ZXh0KTsKKworICAgIEF0b21pY1N0cmluZyBwdWJsaWNJZGVudGlmaWVyKHRva2VuLnB1YmxpY0lk ZW50aWZpZXIoKS5kYXRhKCksIHRva2VuLnB1YmxpY0lkZW50aWZpZXIoKS5zaXplKCkpOworICAg IEF0b21pY1N0cmluZyBzeXN0ZW1JZGVudGlmaWVyKHRva2VuLnN5c3RlbUlkZW50aWZpZXIoKS5k YXRhKCksIHRva2VuLnN5c3RlbUlkZW50aWZpZXIoKS5zaXplKCkpOworICAgIFJlZlB0cjxEb2N1 bWVudFR5cGU+IGRvY3R5cGUgPSBEb2N1bWVudFR5cGU6OmNyZWF0ZShtX2RvY3VtZW50LCB0b2tl bi5uYW1lKCksIHB1YmxpY0lkZW50aWZpZXIsIHN5c3RlbUlkZW50aWZpZXIpOworICAgIG1fZG9j dW1lbnQtPnNldERvY1R5cGUoZG9jdHlwZSk7CisKKyAgICBpZiAoKHB1YmxpY0lkZW50aWZpZXIg PT0geGh0bWxUcmFuc2l0aW9uYWwpCisgICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHho dG1sMTEpCisgICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1sU3RyaWN0KQorICAg ICAgICB8fCAocHVibGljSWRlbnRpZmllciA9PSB4aHRtbEZyYW1lc2V0KQorICAgICAgICB8fCAo cHVibGljSWRlbnRpZmllciA9PSB4aHRtbEJhc2ljKQorICAgICAgICB8fCAocHVibGljSWRlbnRp ZmllciA9PSB4aHRtbE1hdGhNTCkKKyAgICAgICAgfHwgKHB1YmxpY0lkZW50aWZpZXIgPT0geGh0 bWxNYXRoTUxTVkcpCisgICAgICAgIHx8IChwdWJsaWNJZGVudGlmaWVyID09IHhodG1sTW9iaWxl KSkKKyAgICAgICAgbV9pc1hIVE1MID0gdHJ1ZTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6 cHJvY2Vzc1N0YXJ0VGFnKGNvbnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICBleGl0 VGV4dCgpOworCisgICAgYm9vbCBpc0ZpcnN0RWxlbWVudCA9ICFtX3Nhd0ZpcnN0RWxlbWVudDsK KyAgICBtX3Nhd0ZpcnN0RWxlbWVudCA9IHRydWU7CisKKyAgICBOb2RlU3RhY2tJdGVtIHRvcCA9 IG1fY3VycmVudE5vZGVTdGFjay5sYXN0KCk7CisKKyAgICBwcm9jZXNzTmFtZXNwYWNlcyh0b2tl biwgdG9wKTsKKworICAgIFF1YWxpZmllZE5hbWUgcU5hbWUodG9rZW4ucHJlZml4KCksIHRva2Vu Lm5hbWUoKSwgdG9wLm5hbWVzcGFjZUZvclByZWZpeCh0b2tlbi5wcmVmaXgoKSwgdG9wLm5hbWVz cGFjZVVSSSgpKSk7CisgICAgUmVmUHRyPEVsZW1lbnQ+IG5ld0VsZW1lbnQgPSBtX2RvY3VtZW50 LT5jcmVhdGVFbGVtZW50KHFOYW1lLCB0cnVlKTsKKworICAgIHByb2Nlc3NBdHRyaWJ1dGVzKHRv a2VuLCB0b3AsIG5ld0VsZW1lbnQpOworCisgICAgbmV3RWxlbWVudC0+YmVnaW5QYXJzaW5nQ2hp bGRyZW4oKTsKKyAgICBtX2N1cnJlbnROb2RlU3RhY2subGFzdCgpLm5vZGUoKS0+cGFyc2VyQWRk Q2hpbGQobmV3RWxlbWVudC5nZXQoKSk7CisKKyAgICB0b3Auc2V0Tm9kZShuZXdFbGVtZW50KTsK KyAgICBwdXNoQ3VycmVudE5vZGUodG9wKTsKKworICAgIGlmICghbmV3RWxlbWVudC0+YXR0YWNo ZWQoKSkKKyAgICAgICAgbmV3RWxlbWVudC0+YXR0YWNoKCk7CisKKyAgICBpZiAoaXNGaXJzdEVs ZW1lbnQgJiYgbV9kb2N1bWVudC0+ZnJhbWUoKSkKKyAgICAgICAgbV9kb2N1bWVudC0+ZnJhbWUo KS0+bG9hZGVyKCktPmRpc3BhdGNoRG9jdW1lbnRFbGVtZW50QXZhaWxhYmxlKCk7CisKKyAgICBp ZiAodG9rZW4uc2VsZkNsb3NpbmcoKSkgeworICAgICAgICBwb3BDdXJyZW50Tm9kZSgpOworICAg ICAgICBuZXdFbGVtZW50LT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsKKyAgICB9Cit9CisKK3Zv aWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mIHRv a2VuKQoreworICAgIGV4aXRUZXh0KCk7CisKKyAgICBSZWZQdHI8Q29udGFpbmVyTm9kZT4gbm9k ZSA9IG1fY3VycmVudE5vZGVTdGFjay5sYXN0KCkubm9kZSgpOworCisgICAgaWYgKCFub2RlLT5o YXNUYWdOYW1lKFF1YWxpZmllZE5hbWUodG9rZW4ucHJlZml4KCksIHRva2VuLm5hbWUoKSwgbV9j dXJyZW50Tm9kZVN0YWNrLmxhc3QoKS5uYW1lc3BhY2VGb3JQcmVmaXgodG9rZW4ucHJlZml4KCks IG1fY3VycmVudE5vZGVTdGFjay5sYXN0KCkubmFtZXNwYWNlVVJJKCkpKSkpCisgICAgICAgIG1f cGFyc2VyLT5zdG9wUGFyc2luZygpOworCisgICAgcG9wQ3VycmVudE5vZGUoKTsKKyAgICBub2Rl LT5maW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJv Y2Vzc0NoYXJhY3Rlcihjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgYXBwZW5k VG9UZXh0KHRva2VuLmNoYXJhY3RlcnMoKS5kYXRhKCksIHRva2VuLmNoYXJhY3RlcnMoKS5zaXpl KCkpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzQ0RBVEEoY29uc3QgQXRvbWlj WE1MVG9rZW4mIHRva2VuKQoreworICAgIGV4aXRUZXh0KCk7CisgICAgYWRkKENEQVRBU2VjdGlv bjo6Y3JlYXRlKG1fZG9jdW1lbnQsIHRva2VuLmRhdGEoKSkpOworfQorCit2b2lkIFhNTFRyZWVC dWlsZGVyOjpwcm9jZXNzQ29tbWVudChjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7Cisg ICAgZXhpdFRleHQoKTsKKyAgICBhZGQoQ29tbWVudDo6Y3JlYXRlKG1fZG9jdW1lbnQsIHRva2Vu LmNvbW1lbnQoKSkpOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzRW50aXR5KGNv bnN0IEF0b21pY1hNTFRva2VuJiB0b2tlbikKK3sKKyAgICAvLyBGSVhNRTogd2Ugc2hvdWxkIHN1 cHBvcnQgaW50ZXJuYWwgc3Vic2V0LgorICAgIGlmIChtX2lzWEhUTUwpCisgICAgICAgIHByb2Nl c3NIVE1MRW50aXR5KHRva2VuKTsKKyAgICBlbHNlCisgICAgICAgIHByb2Nlc3NYTUxFbnRpdHko dG9rZW4pOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpwcm9jZXNzTmFtZXNwYWNlcyhjb25z dCBBdG9taWNYTUxUb2tlbiYgdG9rZW4sIE5vZGVTdGFja0l0ZW0mIHN0YWNrSXRlbSkKK3sKKyAg ICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0b21pY1N0cmluZywgeG1sbnNQcmVmaXgsICgieG1sbnMi KSk7CisgICAgaWYgKCF0b2tlbi5hdHRyaWJ1dGVzKCkpCisgICAgICAgIHJldHVybjsKKworICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgdG9rZW4uYXR0cmlidXRlcygpLT5sZW5ndGgoKTsgKytp KSB7CisgICAgICAgIEF0dHJpYnV0ZSogYXR0cmlidXRlID0gdG9rZW4uYXR0cmlidXRlcygpLT5h dHRyaWJ1dGVJdGVtKGkpOworICAgICAgICBpZiAoYXR0cmlidXRlLT5uYW1lKCkucHJlZml4KCkg PT0geG1sbnNQcmVmaXgpCisgICAgICAgICAgICBzdGFja0l0ZW0uc2V0TmFtZXNwYWNlVVJJKGF0 dHJpYnV0ZS0+bmFtZSgpLmxvY2FsTmFtZSgpLCBhdHRyaWJ1dGUtPnZhbHVlKCkpOworICAgICAg ICBlbHNlIGlmIChhdHRyaWJ1dGUtPm5hbWUoKSA9PSB4bWxuc1ByZWZpeCkKKyAgICAgICAgICAg IHN0YWNrSXRlbS5zZXROYW1lc3BhY2VVUkkoYXR0cmlidXRlLT52YWx1ZSgpKTsKKyAgICB9Cit9 CisKK3ZvaWQgWE1MVHJlZUJ1aWxkZXI6OnByb2Nlc3NBdHRyaWJ1dGVzKGNvbnN0IEF0b21pY1hN TFRva2VuJiB0b2tlbiwgTm9kZVN0YWNrSXRlbSYgc3RhY2tJdGVtLCBQYXNzUmVmUHRyPEVsZW1l bnQ+IG5ld0VsZW1lbnQpCit7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNTdHJpbmcs IHhtbG5zUHJlZml4LCAoInhtbG5zIikpOworICAgIGlmICghdG9rZW4uYXR0cmlidXRlcygpKQor ICAgICAgICByZXR1cm47CisKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHRva2VuLmF0dHJp YnV0ZXMoKS0+bGVuZ3RoKCk7ICsraSkgeworICAgICAgICBBdHRyaWJ1dGUqIGF0dHJpYnV0ZSA9 IHRva2VuLmF0dHJpYnV0ZXMoKS0+YXR0cmlidXRlSXRlbShpKTsKKyAgICAgICAgRXhjZXB0aW9u Q29kZSBlYyA9IDA7CisgICAgICAgIGlmIChhdHRyaWJ1dGUtPm5hbWUoKS5wcmVmaXgoKSA9PSB4 bWxuc1ByZWZpeCkKKyAgICAgICAgICAgIG5ld0VsZW1lbnQtPnNldEF0dHJpYnV0ZU5TKFhNTE5T TmFtZXM6OnhtbG5zTmFtZXNwYWNlVVJJLCAieG1sbnM6IiArIGF0dHJpYnV0ZS0+bmFtZSgpLmxv Y2FsTmFtZSgpLCBhdHRyaWJ1dGUtPnZhbHVlKCksIGVjKTsKKyAgICAgICAgZWxzZSBpZiAoYXR0 cmlidXRlLT5uYW1lKCkgPT0geG1sbnNQcmVmaXgpCisgICAgICAgICAgICBuZXdFbGVtZW50LT5z ZXRBdHRyaWJ1dGVOUyhYTUxOU05hbWVzOjp4bWxuc05hbWVzcGFjZVVSSSwgeG1sbnNBdG9tLCBh dHRyaWJ1dGUtPnZhbHVlKCksIGVjKTsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBRdWFs aWZpZWROYW1lIHFOYW1lKGF0dHJpYnV0ZS0+cHJlZml4KCksIGF0dHJpYnV0ZS0+bG9jYWxOYW1l KCksIHN0YWNrSXRlbS5uYW1lc3BhY2VGb3JQcmVmaXgoYXR0cmlidXRlLT5wcmVmaXgoKSwgbnVs bEF0b20pKTsKKyAgICAgICAgICAgIG5ld0VsZW1lbnQtPnNldEF0dHJpYnV0ZShxTmFtZSwgYXR0 cmlidXRlLT52YWx1ZSgpLCBlYyk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGVjKSB7CisgICAg ICAgICAgICBtX3BhcnNlci0+c3RvcFBhcnNpbmcoKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAg ICAgICAgfQorICAgIH0KK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc1hNTEVudGl0 eShjb25zdCBBdG9taWNYTUxUb2tlbiYgdG9rZW4pCit7CisgICAgREVGSU5FX1NUQVRJQ19MT0NB TChBdG9taWNTdHJpbmcsIGFtcCwgKCJhbXAiKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChB dG9taWNTdHJpbmcsIGFwb3MsICgiYXBvcyIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKEF0 b21pY1N0cmluZywgZ3QsICgiZ3QiKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChBdG9taWNT dHJpbmcsIGx0LCAoImx0IikpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5n LCBxdW90LCAoInF1b3QiKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIGFtcFMs ICgiJiIpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFN0cmluZywgYXBvc1MsICgiJyIpKTsK KyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFN0cmluZywgZ3RTLCAoIj4iKSk7CisgICAgREVGSU5F X1NUQVRJQ19MT0NBTChTdHJpbmcsIGx0UywgKCI8IikpOworICAgIERFRklORV9TVEFUSUNfTE9D QUwoU3RyaW5nLCBxdW90UywgKCJcIiIpKTsKKworICAgIGlmICh0b2tlbi5uYW1lKCkgPT0gYW1w KQorICAgICAgICBhcHBlbmRUb1RleHQoYW1wUy5jaGFyYWN0ZXJzKCksIDEpOworICAgIGVsc2Ug aWYgKHRva2VuLm5hbWUoKSA9PSBhcG9zKQorICAgICAgICBhcHBlbmRUb1RleHQoYXBvc1MuY2hh cmFjdGVycygpLCAxKTsKKyAgICBlbHNlIGlmICh0b2tlbi5uYW1lKCkgPT0gZ3QpCisgICAgICAg IGFwcGVuZFRvVGV4dChndFMuY2hhcmFjdGVycygpLCAxKTsKKyAgICBlbHNlIGlmICh0b2tlbi5u YW1lKCkgPT0gbHQpCisgICAgICAgIGFwcGVuZFRvVGV4dChsdFMuY2hhcmFjdGVycygpLCAxKTsK KyAgICBlbHNlIGlmICh0b2tlbi5uYW1lKCkgPT0gcXVvdCkKKyAgICAgICAgYXBwZW5kVG9UZXh0 KHF1b3RTLmNoYXJhY3RlcnMoKSwgMSk7CisgICAgZWxzZQorICAgICAgICBtX3BhcnNlci0+c3Rv cFBhcnNpbmcoKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6cHJvY2Vzc0hUTUxFbnRpdHko Y29uc3QgQXRvbWljWE1MVG9rZW4mIHRva2VuKQoreworICAgIEhUTUxFbnRpdHlTZWFyY2ggc2Vh cmNoOworICAgIGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSA9IHRva2VuLm5hbWUoKTsKKyAgICBm b3IgKHNpemVfdCBpID0gMDsgaSA8IG5hbWUubGVuZ3RoKCk7ICsraSkgeworICAgICAgICBzZWFy Y2guYWR2YW5jZShuYW1lW2ldKTsKKyAgICAgICAgaWYgKCFzZWFyY2guaXNFbnRpdHlQcmVmaXgo KSkgeworICAgICAgICAgICAgbV9wYXJzZXItPnN0b3BQYXJzaW5nKCk7CisgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgIH0KKyAgICB9CisgICAgc2VhcmNoLmFkdmFuY2UoJzsnKTsKKyAgICBV Q2hhcjMyIGVudGl0eVZhbHVlID0gc2VhcmNoLmN1cnJlbnRWYWx1ZSgpOworICAgIGlmIChlbnRp dHlWYWx1ZSA8PSAweEZGRkYpCisgICAgICAgYXBwZW5kVG9UZXh0KHJlaW50ZXJwcmV0X2Nhc3Q8 VUNoYXIqPigmZW50aXR5VmFsdWUpLCAxKTsKKyAgICBlbHNlIHsKKyAgICAgICAgVUNoYXIgdXRm MTZQYWlyWzJdID0geyBVMTZfTEVBRChlbnRpdHlWYWx1ZSksIFUxNl9UUkFJTChlbnRpdHlWYWx1 ZSkgfTsKKyAgICAgICAgYXBwZW5kVG9UZXh0KHV0ZjE2UGFpciwgMik7CisgICAgfQorfQorCitp bmxpbmUgdm9pZCBYTUxUcmVlQnVpbGRlcjo6YWRkKFBhc3NSZWZQdHI8Tm9kZT4gbm9kZSkKK3sK KyAgICBtX2N1cnJlbnROb2RlU3RhY2subGFzdCgpLm5vZGUoKS0+cGFyc2VyQWRkQ2hpbGQobm9k ZS5nZXQoKSk7CisgICAgaWYgKCFub2RlLT5hdHRhY2hlZCgpKQorICAgICAgICBub2RlLT5hdHRh Y2goKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6YXBwZW5kVG9UZXh0KGNvbnN0IFVDaGFy KiB0ZXh0LCBzaXplX3QgbGVuZ3RoKQoreworICAgIGVudGVyVGV4dCgpOworCisgICAgaWYgKCFt X2xlYWZUZXh0KQorICAgICAgICByZXR1cm47CisKKyAgICBtX2xlYWZUZXh0LT5hcHBlbmQodGV4 dCwgbGVuZ3RoKTsKK30KKwordm9pZCBYTUxUcmVlQnVpbGRlcjo6ZW50ZXJUZXh0KCkKK3sKKyAg ICBpZiAoIW1fc2F3Rmlyc3RFbGVtZW50KSB7CisgICAgICAgIC8vIEZJWE1FOiBlbnN1cmUgaXQn cyBqdXN0IHdoaXRlc3BhY2UKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIG1fbGVhZlRl eHQgPSBhZG9wdFB0cihuZXcgU3RyaW5nQnVpbGRlcigpKTsKK30KKwordm9pZCBYTUxUcmVlQnVp bGRlcjo6ZXhpdFRleHQoKQoreworICAgIGlmICghbV9sZWFmVGV4dC5nZXQoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgYWRkKFRleHQ6OmNyZWF0ZShtX2RvY3VtZW50LCBtX2xlYWZUZXh0LT50 b1N0cmluZygpKSk7CisKKyAgICBtX2xlYWZUZXh0LmNsZWFyKCk7Cit9CisKK1hNTFRyZWVCdWls ZGVyOjpOb2RlU3RhY2tJdGVtOjpOb2RlU3RhY2tJdGVtKFBhc3NSZWZQdHI8Q29udGFpbmVyTm9k ZT4gbiwgTm9kZVN0YWNrSXRlbSogcGFyZW50KQorICAgIDogbV9ub2RlKG4pCit7CisgICAgaWYg KCFwYXJlbnQpCisgICAgICAgIHJldHVybjsKKworICAgICAgICBtX25hbWVzcGFjZSA9IHBhcmVu dC0+bV9uYW1lc3BhY2U7CisgICAgICAgIG1fc2NvcGVkTmFtZXNwYWNlcyA9IHBhcmVudC0+bV9z Y29wZWROYW1lc3BhY2VzOworfQorCitib29sIFhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVt OjpoYXNOYW1lc3BhY2VVUkkoQXRvbWljU3RyaW5nIHByZWZpeCkKK3sKKyAgICBBU1NFUlQoIXBy ZWZpeC5pc051bGwoKSk7CisgICAgcmV0dXJuIG1fc2NvcGVkTmFtZXNwYWNlcy5jb250YWlucyhw cmVmaXgpOworfQorCitBdG9taWNTdHJpbmcgWE1MVHJlZUJ1aWxkZXI6Ok5vZGVTdGFja0l0ZW06 Om5hbWVzcGFjZVVSSShBdG9taWNTdHJpbmcgcHJlZml4KQoreworICAgIEFTU0VSVCghcHJlZml4 LmlzTnVsbCgpKTsKKyAgICBpZiAobV9zY29wZWROYW1lc3BhY2VzLmNvbnRhaW5zKHByZWZpeCkp CisgICAgICAgIHJldHVybiBtX3Njb3BlZE5hbWVzcGFjZXMuZ2V0KHByZWZpeCk7CisgICAgcmV0 dXJuIG51bGxBdG9tOworfQorCit2b2lkIFhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpz ZXROYW1lc3BhY2VVUkkoQXRvbWljU3RyaW5nIHByZWZpeCwgQXRvbWljU3RyaW5nIHVyaSkKK3sK KyAgICBtX3Njb3BlZE5hbWVzcGFjZXMuc2V0KHByZWZpeCwgdXJpKTsKK30KKworQXRvbWljU3Ry aW5nIFhNTFRyZWVCdWlsZGVyOjpOb2RlU3RhY2tJdGVtOjpuYW1lc3BhY2VGb3JQcmVmaXgoQXRv bWljU3RyaW5nIHByZWZpeCwgQXRvbWljU3RyaW5nIGZhbGxiYWNrKQoreworICAgIEF0b21pY1N0 cmluZyB1cmkgPSBmYWxsYmFjazsKKyAgICBpZiAoIXByZWZpeC5pc051bGwoKSAmJiBoYXNOYW1l c3BhY2VVUkkocHJlZml4KSkKKyAgICAgICAgdXJpID0gbmFtZXNwYWNlVVJJKHByZWZpeCk7CisK KyAgICByZXR1cm4gdXJpOworfQorCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS94bWwv cGFyc2VyL1hNTFRyZWVCdWlsZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS94bWwvcGFyc2VyL1hNTFRy ZWVCdWlsZGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTA2ZjU1ZmI5MjgxYjUzZGUwZGU2ZTc1NDIwZDljYjkw OTEzZDE0MgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3htbC9wYXJzZXIvWE1M VHJlZUJ1aWxkZXIuaApAQCAtMCwwICsxLDExNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBHT09HTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5P IEVWRU5UIFNIQUxMIEdPT0dMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpZm5kZWYgWE1MVHJlZUJ1aWxkZXJfaAorI2RlZmlu ZSBYTUxUcmVlQnVpbGRlcl9oCisKKyNpbmNsdWRlICJUZXh0LmgiCisjaW5jbHVkZSAiWE1MVG9r ZW4uaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3Iu aD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworY2xhc3MgQ29udGFpbmVyTm9kZTsKK2NsYXNzIERvY3VtZW50OworY2xhc3MgTmV3 WE1MRG9jdW1lbnRQYXJzZXI7CisKK2NsYXNzIFhNTFRyZWVCdWlsZGVyIHsKKyAgICBXVEZfTUFL RV9OT05DT1BZQUJMRShYTUxUcmVlQnVpbGRlcik7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FU RUQ7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8WE1MVHJlZUJ1aWxkZXI+IGNyZWF0 ZShOZXdYTUxEb2N1bWVudFBhcnNlciogcGFyc2VyLCBEb2N1bWVudCogZG9jdW1lbnQpCisgICAg eworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IFhNTFRyZWVCdWlsZGVyKHBhcnNlciwgZG9j dW1lbnQpKTsKKyAgICB9CisKKyAgICB2b2lkIHByb2Nlc3NUb2tlbihjb25zdCBBdG9taWNYTUxU b2tlbiYpOworCitwcml2YXRlOgorICAgIFhNTFRyZWVCdWlsZGVyKE5ld1hNTERvY3VtZW50UGFy c2VyKiwgRG9jdW1lbnQqKTsKKworICAgIGNsYXNzIE5vZGVTdGFja0l0ZW0geworICAgIHB1Ymxp YzoKKyAgICAgICAgTm9kZVN0YWNrSXRlbShQYXNzUmVmUHRyPENvbnRhaW5lck5vZGU+IGl0ZW0s IE5vZGVTdGFja0l0ZW0qIHBhcmVudCA9IDApOworCisgICAgICAgIGJvb2wgaGFzTmFtZXNwYWNl VVJJKEF0b21pY1N0cmluZyBwcmVmaXgpOworICAgICAgICBBdG9taWNTdHJpbmcgbmFtZXNwYWNl VVJJKEF0b21pY1N0cmluZyBwcmVmaXgpOworICAgICAgICBBdG9taWNTdHJpbmcgbmFtZXNwYWNl VVJJKCkgeyByZXR1cm4gbV9uYW1lc3BhY2U7IH0KKyAgICAgICAgdm9pZCBzZXROYW1lc3BhY2VV UkkoQXRvbWljU3RyaW5nIHByZWZpeCwgQXRvbWljU3RyaW5nIHVyaSk7CisgICAgICAgIHZvaWQg c2V0TmFtZXNwYWNlVVJJKEF0b21pY1N0cmluZyB1cmkpIHsgbV9uYW1lc3BhY2UgPSB1cmk7IH0K KyAgICAgICAgQXRvbWljU3RyaW5nIG5hbWVzcGFjZUZvclByZWZpeChBdG9taWNTdHJpbmcgcHJl Zml4LCBBdG9taWNTdHJpbmcgZmFsbGJhY2spOworCisgICAgICAgIFBhc3NSZWZQdHI8Q29udGFp bmVyTm9kZT4gbm9kZSgpIHsgcmV0dXJuIG1fbm9kZTsgfQorICAgICAgICB2b2lkIHNldE5vZGUo UGFzc1JlZlB0cjxDb250YWluZXJOb2RlPiBub2RlKSB7IG1fbm9kZSA9IG5vZGU7IH0KKworICAg IHByaXZhdGU6CisgICAgICAgIEhhc2hNYXA8QXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmc+IG1f c2NvcGVkTmFtZXNwYWNlczsKKyAgICAgICAgUmVmUHRyPENvbnRhaW5lck5vZGU+IG1fbm9kZTsK KyAgICAgICAgQXRvbWljU3RyaW5nIG1fbmFtZXNwYWNlOworICAgIH07CisKKyAgICB2b2lkIHB1 c2hDdXJyZW50Tm9kZShjb25zdCBOb2RlU3RhY2tJdGVtJik7CisgICAgdm9pZCBwb3BDdXJyZW50 Tm9kZSgpOworCisgICAgdm9pZCBwcm9jZXNzUHJvY2Vzc2luZ0luc3RydWN0aW9uKGNvbnN0IEF0 b21pY1hNTFRva2VuJik7CisgICAgdm9pZCBwcm9jZXNzWE1MRGVjbGFyYXRpb24oY29uc3QgQXRv bWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NET0NUWVBFKGNvbnN0IEF0b21pY1hNTFRv a2VuJik7CisgICAgdm9pZCBwcm9jZXNzU3RhcnRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsK KyAgICB2b2lkIHByb2Nlc3NFbmRUYWcoY29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lk IHByb2Nlc3NDREFUQShjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0No YXJhY3Rlcihjb25zdCBBdG9taWNYTUxUb2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0NvbW1lbnQo Y29uc3QgQXRvbWljWE1MVG9rZW4mKTsKKyAgICB2b2lkIHByb2Nlc3NFbnRpdHkoY29uc3QgQXRv bWljWE1MVG9rZW4mKTsKKworICAgIHZvaWQgcHJvY2Vzc05hbWVzcGFjZXMoY29uc3QgQXRvbWlj WE1MVG9rZW4mLCBOb2RlU3RhY2tJdGVtJik7CisgICAgdm9pZCBwcm9jZXNzQXR0cmlidXRlcyhj b25zdCBBdG9taWNYTUxUb2tlbiYsIE5vZGVTdGFja0l0ZW0mLCBQYXNzUmVmUHRyPEVsZW1lbnQ+ IG5ld0VsZW1lbnQpOworICAgIHZvaWQgcHJvY2Vzc1hNTEVudGl0eShjb25zdCBBdG9taWNYTUxU b2tlbiYpOworICAgIHZvaWQgcHJvY2Vzc0hUTUxFbnRpdHkoY29uc3QgQXRvbWljWE1MVG9rZW4m KTsKKworICAgIGlubGluZSB2b2lkIGFkZChQYXNzUmVmUHRyPE5vZGU+KTsKKworICAgIHZvaWQg YXBwZW5kVG9UZXh0KGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCBzaXplX3QgbGVuZ3RoKTsKKyAg ICB2b2lkIGVudGVyVGV4dCgpOworICAgIHZvaWQgZXhpdFRleHQoKTsKKworICAgIEF0b21pY1N0 cmluZyBuYW1lc3BhY2VGb3JQcmVmaXgoQXRvbWljU3RyaW5nIHByZWZpeCwgQXRvbWljU3RyaW5n IGZhbGxiYWNrKTsKKworICAgIERvY3VtZW50KiBtX2RvY3VtZW50OworICAgIE5ld1hNTERvY3Vt ZW50UGFyc2VyKiBtX3BhcnNlcjsKKworICAgIGJvb2wgbV9pc1hIVE1MOworCisgICAgYm9vbCBt X3Nhd0ZpcnN0RWxlbWVudDsKKyAgICBWZWN0b3I8Tm9kZVN0YWNrSXRlbT4gbV9jdXJyZW50Tm9k ZVN0YWNrOworCisgICAgT3duUHRyPFN0cmluZ0J1aWxkZXI+IG1fbGVhZlRleHQ7Cit9OworCit9 CisKKyNlbmRpZiAvLyBYTUxUcmVlQnVpbGRlcl9oCg==