61053 2011-05-18 07:49:29 -0700 Using null bytes when setting innerHTML in XTHML results in assertion and a crash due to null-pointer dereference 2011-06-16 22:59:55 -0700 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) PC Windows Vista RESOLVED FIXED P1 Normal --- 1 skylined jeffrey+webkit abarth ap darin dbates eric jeffrey+webkit ossy rniwa webkit.review.bot oldest_to_newest 405714 0 93913 skylined 2011-05-18 07:49:29 -0700 Created attachment 93913 Repro ASSERT Two very similar repros trigger an ASSERT and a NULL ptr: Repro ASSERT: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <body onload="document.body.innerHTML = 'x\x00\x3C';"></body> </html> (Ascii codes hint: that is "x\0<") Source: webkit\source\webcore\dom\xmldocumentparserlibxml2.cpp @ 1440: bool XMLDocumentParser::appendFragmentSource(const String& chunk) { ASSERT(!m_context); ASSERT(m_parsingFragment); CString chunkAsUtf8 = chunk.utf8(); initializeParserContext(chunkAsUtf8.data()); xmlParseContent(context()); endDocument(); // Close any open text nodes. // FIXME: If this code is actually needed, it should probably move to finish() // XMLDocumentParserQt has a similar check (m_stream.error() == QXmlStreamReader::PrematureEndOfDocumentError) in doEnd(). // Check if all the chunk has been processed. long bytesProcessed = xmlByteConsumed(context()); if (bytesProcessed == -1 || ((unsigned long)bytesProcessed) != chunkAsUtf8.length()) { // FIXME: I don't believe we can hit this case without also having seen an error. // If we hit this ASSERT, we've found a test case which demonstrates the need for this code. ASSERT(m_sawError); return false; } // No error if the chunk is well formed or it is not but we have no error. return context()->wellFormed || !xmlCtxtGetLastError(context()); } @eric: You wrote that comment and added the ASSERT. I've found your test case; it seems NULL bytes terminate processing of the string, so you do not end up processing as many bytes as there are in the chunkAsUtf8 string :) ---- Repro NULL ptr: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <body onload="document.body.innerHTML = '\x00\x3Cx';"></body> </html> (Ascii codes hint: that is "\0<x") Source: Let's see what happens in appendFragmentSource if chunk == ' <x': initializeParserContext(chunkAsUtf8.data()); xmlParseContent(context()); ==> "initializeParserContext" sets m_context, "xmlParseContent(context())" parses it. There is no check for a NULL m_context; this causes the NULL pointer. webkit\source\webcore\dom\xmldocumentparserlibxml2.cpp @ 1279: void XMLDocumentParser::initializeParserContext(const char* chunk) { <<<snip>>> if (m_parsingFragment) m_context = XMLParserContext::createMemoryParser(&sax, this, chunk); <<<snip>>> } webkit\source\webcore\dom\xmldocumentparserlibxml2.cpp @ 504: PassRefPtr<XMLParserContext> XMLParserContext::createMemoryParser(xmlSAXHandlerPtr handlers, void* userData, const char* chunk) { <<<snip>>> xmlParserCtxtPtr parser = xmlCreateMemoryParserCtxt(chunk, xmlStrlen((const xmlChar*)chunk)); if (!parser) return 0; <snip> ==> "xmlStrlen" (libxml\src\xmlstring.c @ 421) looks for the first '\0' and returns 0. ==> "xmlCreateMemoryParserCtxt" will return NULL if size == 0. ==> "createMemoryParser" will return NULL so "m_context" will be 0. 405715 1 93914 skylined 2011-05-18 07:50:00 -0700 Created attachment 93914 Repro NULL ptr 405720 2 skylined 2011-05-18 07:58:32 -0700 Chromium: https://code.google.com/p/chromium/issues/detail?id=83053 406404 3 eric 2011-05-19 08:23:49 -0700 I suspect the fix would be to tell the TextDecoder to remove nulls (change them to ? or something). 406408 4 eric 2011-05-19 08:28:26 -0700 It's possible that convertUTF16ToUTF8 (in UTF8.h) should convert nulls to the replacement character in lenient mode (just like how it converts other illegal chars). 406413 5 darin 2011-05-19 08:32:46 -0700 (In reply to comment #4) > It's possible that convertUTF16ToUTF8 (in UTF8.h) should convert nulls to the replacement character in lenient mode (just like how it converts other illegal chars). I don’t think that’s right. For one thing, a null character is not an “illegal character”. We may have some call sites that can’t handle null characters because they are using null terminated strings, and they do need to be protected from unexpected null characters, but a null character is not intrinsically bad. For another, I believe other illegal things are illegal sequences, not characters at all. 406417 6 eric 2011-05-19 08:40:30 -0700 I believe you to be much more familiar with this all than I Darin. :) It does seem like: CString String::utf8(bool strict) const Should replace nulls, since it returns a null terminated string. For other utf8 conversions, I have no opinion. 406450 7 skylined 2011-05-19 09:31:32 -0700 Not that I'm an expert, but what about "Modified utf-8" which encodes the nulls? I believe it was developed to address such issues. http://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8 406459 8 darin 2011-05-19 09:51:17 -0700 (In reply to comment #6) > It does seem like: > CString String::utf8(bool strict) const > Should replace nulls, since it returns a null terminated string. That’s an interesting point. Although constructing a CString does add a null terminator, the class will work with strings that have embedded nulls. The CString length function will still return the correct length that includes all the nulls and not the null terminator, and as long as we don’t use the data pointer as a null-terminated string we can make code that works with it just fine. But since CString clients are highly likely to use it as a null-terminated string, this could lead to problems and maybe even security vulnerabilities so we may want to change the design of the CString class or the String::utf8 function. We’ll have to decide if we want different behavior, and if so, implement it. None of that is necessarily required to fix this bug. Once we decide what behavior we want we can almost certainly fix this problem in the XML parser code, without changing the current design and implementation of CString. 416592 9 jeffrey+webkit 2011-06-07 10:06:55 -0700 *** Bug 62070 has been marked as a duplicate of this bug. *** 416626 10 jeffrey+webkit 2011-06-07 10:44:26 -0700 In the XML spec, null characters are disallowed. (In the 1.0 spec it is not shown in the permissible character range, and in 1.1 it is explicitly stated that it is disallowed.) However, this doesn't mean we should strip out the null characters; they're still there in the string that's being parsed. But we also shouldn't ignore them or treat them as an artificial string terminator, and given that they're disallowed in XML, we shouldn't just replace them either. My proposed solution is to pass the length of the string along with the string that potentially has nulls in it. libxml2 keeps parsing until it hits the first NULL (even though you pass the length of the string in), at which point it returns that it processed however many characters there are until the null character. Since we know the expected number of bytes to be processed, we can tell if it stopped midway through the string and throw an error if so; we should always process the full string as it is, and there is already an ASSERT to that effect. 416645 11 96263 jeffrey+webkit 2011-06-07 11:12:41 -0700 Created attachment 96263 Patch 416654 12 96263 ap 2011-06-07 11:20:22 -0700 Comment on attachment 96263 Patch This looks almost like the patch from bug 62070, with review comments not having been addressed. 416670 13 96263 darin 2011-06-07 11:37:41 -0700 Comment on attachment 96263 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=96263&action=review > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1446 > - initializeParserContext(chunkAsUtf8.data()); > + initializeParserContext(chunkAsUtf8.data(), chunkAsUtf8.length()); It’s not safe to pass a value that’s a size_t to a function that takes an int. This is especially true on 64-bit systems where size_t is a 64-bit unsigned integer and int is a 32-bit signed integer. Large lengths can turn into negative numbers or even zeros and cause problems such as security vulnerabilities. The type size_t needs to be used throughout, or we need something here to explicitly check that the size fits into an int. 416714 14 jeffrey+webkit 2011-06-07 12:12:08 -0700 (In reply to comment #12) > (From update of attachment 96263 [details]) > This looks almost like the patch from bug 62070, with review comments not having been addressed. I can add the test cases from the other bug to this patch in the next revision. I verified that my test case passes in Firefox. I prefixed the variable names with "chunk", but I see now that you meant unabbreviating "len" to "length" as well. I was following precedent that is set elsewhere in that file when I named the variable in the first place. I fixed the out of bounds problem by short-circuiting the check for a null byte in the string if the length is negative. I don't know why m_sawError doesn't get set for a null byte, and why it just bails out with the number of bytes up to the null being processed, but this appears to be behavior in libxml2 and not in WebKit code. m_sawError is generally set in the SAX callbacks that get set in intializeParserContext and invoked by xmlParseContext. The JS exception itself is likely thrown when it realizes that it can't parse the XML, so it can't replace the outer/innerHTML of the element without corrupting the XML of the entire page--so it just throws an exception instead of killing the page. As for the size_t issue, libxml2 uses int as its buffer length, so it probably can't handle any XML document larger than 2GiB. I can add a check to make sure that the value is within 2GiB, but beyond that, this patch doesn't really change the behavior of handling XML documents that are larger than 2GiB. 419070 15 96828 jeffrey+webkit 2011-06-10 17:35:28 -0700 Created attachment 96828 Patch 419085 16 96828 eric 2011-06-10 17:52:32 -0700 Comment on attachment 96828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=96828&action=review > Source/WebCore/dom/XMLDocumentParser.h:59 > + static PassRefPtr<XMLParserContext> createMemoryParser(xmlSAXHandlerPtr, void*, const char*, int); This argument should be named as the name adds clarity. The void* too! :) > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1448 > + // libxml2 takes an int for a length, and therefore can't handle XML chunks larger than 2 GiB I would have put the comment outside the if block and thus removed the { }. Also all comments should be sentences, beginning with a capital and ending with a period. In this case only the latter applies. :) > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1452 > + initializeParserContext(chunkAsUtf8.data(), chunkAsUtf8.length()); Should we just be passing the CString to this call instead of a pointer/length pair? > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1463 > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); So we're just bailing when we hit a null byte? 419111 17 jeffrey+webkit 2011-06-10 18:32:16 -0700 (In reply to comment #16) > (From update of attachment 96828 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=96828&action=review > > > Source/WebCore/dom/XMLDocumentParser.h:59 > > + static PassRefPtr<XMLParserContext> createMemoryParser(xmlSAXHandlerPtr, void*, const char*, int); > > This argument should be named as the name adds clarity. The void* too! :) I didn't create this function signature, but I can add the argument names. > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1448 > > + // libxml2 takes an int for a length, and therefore can't handle XML chunks larger than 2 GiB > > I would have put the comment outside the if block and thus removed the { }. Also all comments should be sentences, beginning with a capital and ending with a period. In this case only the latter applies. :) I figured since it's the name of something, I should go with the capitalization of the library name, but I can change this, too. > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1452 > > + initializeParserContext(chunkAsUtf8.data(), chunkAsUtf8.length()); > > Should we just be passing the CString to this call instead of a pointer/length pair? This sounds like a good idea to me. > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1463 > > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); > > So we're just bailing when we hit a null byte? The XML specification does not list null byte (nor most ASCII control characters) as acceptable characters in XML, and the XML 1.1 spec explicitly disallows them. If we hit a null byte, then the XML is technically malformed. 419212 18 darin 2011-06-11 09:10:28 -0700 (In reply to comment #17) > > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1448 > > > + // libxml2 takes an int for a length, and therefore can't handle XML chunks larger than 2 GiB > > > > I would have put the comment outside the if block and thus removed the { }. Also all comments should be sentences, beginning with a capital and ending with a period. In this case only the latter applies. :) > > I figured since it's the name of something, I should go with the capitalization of the library name, but I can change this, too. Maciej said “only the latter”, which means you should end with a period, but not begin with a capital letter. > > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1463 > > > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); > > > > So we're just bailing when we hit a null byte? > > The XML specification does not list null byte (nor most ASCII control characters) as acceptable characters in XML, and the XML 1.1 spec explicitly disallows them. If we hit a null byte, then the XML is technically malformed. Sure, but the XML specification doesn’t tell us how innerHTML should work. Stopping at the first null byte is one possible behavior. Another is doing nothing at all if the string contains any null bytes. Yet another is to strip the null bytes (that’s a bad idea). Another possibility is to treat any string with null bytes in it as if you had set innerHTML to the empty string. It’s not immediately obvious to me which is the correct behavior. Since you’ve had more time to think about it and investigate you might have come to a good decision and rationale for why it’s right. I think that’s the drift of Maciej’s question. 420035 19 jeffrey+webkit 2011-06-13 16:25:47 -0700 (In reply to comment #18) > > > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1463 > > > > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); > > > > > > So we're just bailing when we hit a null byte? > > > > The XML specification does not list null byte (nor most ASCII control characters) as acceptable characters in XML, and the XML 1.1 spec explicitly disallows them. If we hit a null byte, then the XML is technically malformed. > > Sure, but the XML specification doesn’t tell us how innerHTML should work. Stopping at the first null byte is one possible behavior. Another is doing nothing at all if the string contains any null bytes. Yet another is to strip the null bytes (that’s a bad idea). Another possibility is to treat any string with null bytes in it as if you had set innerHTML to the empty string. It’s not immediately obvious to me which is the correct behavior. Since you’ve had more time to think about it and investigate you might have come to a good decision and rationale for why it’s right. I think that’s the drift of Maciej’s question. The Element.innerHTML method is defined in the HTML 5 spec (in this case, the XHTML portion thereof), and it explicitly says that, if a character that does not match the Char specification in the XML spec (e.g. a null byte) arises in the input stream, that the user-agent must throw an INVALID_STATE_ERR exception. The document does not specify an Element.outerHTML method, but by analog, a similar logic can be employed. Although I had not found this segment of the spec until after submitting the patch, it lines up with the behavior the patch gives. So yes, we're just bailing if we hit a null byte. 420424 20 darin 2011-06-14 08:18:42 -0700 (In reply to comment #19) > Although I had not found this segment of the spec until after submitting the patch, it lines up with the behavior the patch gives. Sounds good. 421487 21 96828 ap 2011-06-15 12:06:14 -0700 Comment on attachment 96828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=96828&action=review Looks good to me. Please address Eric's comments too. > LayoutTests/ChangeLog:8 > + Added test cases covering four cases of using innerHTML and outerHTML with null bytes in XHTML I don't really like that the tests check assigning strings that are not valid fragments even if nulls are ignored, so checking these is confusing at best. I would have tested strings such as "<p>Test fails</p>\x00" or "\x00<p>Test fails</p>". Please change the tests to fail if the null bytes are manually removed, so that they actually check what happens with these. Please double-check Firefox compatibility once you make this change. > LayoutTests/fast/parser/xhtml-innerhtml-null-byte-first.xhtml:14 > + // Base64 says: \0 Is there a reason to use Base64, not \x00 in a string literal? The latter would be more readable, and wouldn't require comments. > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1447 > + if (chunkAsUtf8.length() > 0x7FFFFFFFL) { Why not INT_MAX? Or you could even check for something like "chunkAsUtf8.length() == static_cast<int>(chunkAsUtf8.length())", although the latter is not a common WebKit style. 422192 22 97489 jeffrey+webkit 2011-06-16 13:58:26 -0700 Created attachment 97489 Patch 422197 23 97489 eric 2011-06-16 14:03:37 -0700 Comment on attachment 97489 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97489&action=review > Source/WebCore/dom/XMLDocumentParser.h:61 > + static PassRefPtr<XMLParserContext> createMemoryParser(xmlSAXHandlerPtr handlers, void* userData, const CString& chunk); > + static PassRefPtr<XMLParserContext> createStringParser(xmlSAXHandlerPtr handlers, void* userData); The handlers name doesn't add anything (it's already described well by the type), so I wouldn't add it. But I appreciate you adding the void*. > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:514 > + ASSERT(chunk.length() <= INT_MAX); What happens if we do pass a length over INT_MAX to xmlCreateMemoryParserCtxt? > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1464 > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); I'm not sure I understand why we're adjusting this assert. Should we instead be setting m_sawError? I'm not sure w/o looking what m_sawError does? 422214 24 jeffrey+webkit 2011-06-16 14:18:37 -0700 (In reply to comment #23) > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:514 > > + ASSERT(chunk.length() <= INT_MAX); > > What happens if we do pass a length over INT_MAX to xmlCreateMemoryParserCtxt? xmlCreateMemoryParserCtxt takes an int, so if we pass something larger than INT_MAX, it's an integer overflow. I can add a comment that states such before the assert. > > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:1464 > > + ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed])); > > I'm not sure I understand why we're adjusting this assert. Should we instead be setting m_sawError? I'm not sure w/o looking what m_sawError does? m_sawError is only set in the handlers. As far as I know, if a null byte is encountered, the (memory) processor treats it as an EOF, so m_sawError can't be set by a handler, as it never sees the null byte. This appears to be a bug in libxml2, as it looks like the stream processor handles null characters properly. 422247 25 97489 eric 2011-06-16 14:40:19 -0700 Comment on attachment 97489 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97489&action=review > Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:516 > + xmlParserCtxtPtr parser = xmlCreateMemoryParserCtxt(chunk.data(), chunk.length()); I'm surprised the compiler won't warn here then, if length() is unsigned and we're using it as signed. 422266 26 97489 ap 2011-06-16 14:59:34 -0700 Comment on attachment 97489 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97489&action=review > LayoutTests/ChangeLog:8 > + Added test cases covering four cases of using innerHTML with null bytes in XHTML. four cases? >> Source/WebCore/dom/XMLDocumentParser.h:61 >> + static PassRefPtr<XMLParserContext> createStringParser(xmlSAXHandlerPtr handlers, void* userData); > > The handlers name doesn't add anything (it's already described well by the type), so I wouldn't add it. But I appreciate you adding the void*. Yup, "handlers" needn't be here. >> Source/WebCore/dom/XMLDocumentParserLibxml2.cpp:514 >> + ASSERT(chunk.length() <= INT_MAX); > > What happens if we do pass a length over INT_MAX to xmlCreateMemoryParserCtxt? This assertion is not particularly useful. It won't help us uncover any problems earlier, because we will never have chunks that long in practice. Perhaps a comment explaining where the length check is made would be more appropriate. 422366 27 97531 jeffrey+webkit 2011-06-16 18:08:02 -0700 Created attachment 97531 Patch 422426 28 97531 webkit.review.bot 2011-06-16 22:54:26 -0700 Comment on attachment 97531 Patch Clearing flags on attachment: 97531 Committed r89118: <http://trac.webkit.org/changeset/89118> 422427 29 webkit.review.bot 2011-06-16 22:54:33 -0700 All reviewed patches have been landed. Closing bug. 422430 30 rniwa 2011-06-16 22:59:55 -0700 This caused Qt build failure: http://build.webkit.org/builders/Qt%20Linux%20Release%20minimal/builds/27187/steps/compile-webkit/logs/stdio 93913 2011-05-18 07:49:29 -0700 2011-05-18 07:49:29 -0700 Repro ASSERT innerHTML-0byte-ASSERT.xhtml application/xhtml+xml 268 skylined PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4NCjwhRE9DVFlQRSBodG1sIFBV QkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9y Zy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4NCjxodG1sIHhtbG5zPSJodHRwOi8v d3d3LnczLm9yZy8xOTk5L3hodG1sIj4NCiAgPGJvZHkgb25sb2FkPSJkb2N1bWVudC5ib2R5Lmlu bmVySFRNTCA9ICd4XHgwMFx4M0MnOyI+PC9ib2R5Pg0KPC9odG1sPg== 93914 2011-05-18 07:50:00 -0700 2011-05-18 07:50:00 -0700 Repro NULL ptr innerHTML-0byte-NULL ptr.xhtml application/xhtml+xml 268 skylined PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4NCjwhRE9DVFlQRSBodG1sIFBV QkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9y Zy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4NCjxodG1sIHhtbG5zPSJodHRwOi8v d3d3LnczLm9yZy8xOTk5L3hodG1sIj4NCiAgPGJvZHkgb25sb2FkPSJkb2N1bWVudC5ib2R5Lmlu bmVySFRNTCA9ICdceDAwXHgzQ3gnOyI+PC9ib2R5Pg0KPC9odG1sPg== 96263 2011-06-07 11:12:41 -0700 2011-06-10 17:35:24 -0700 Patch bug-61053-20110607111240.patch text/plain 7627 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogODc5NjIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiYjIzYWVmOGJmYjlkNDczNjUxZjdl MDU0MTFmNmNiYWEyMTc1MDI4Li4zMmRjZDcwYjhkN2Y2MjQ4MmQzZGNmNjM4MmYwODE3YzQyZjEx YjY4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTEtMDYtMDcgIEplZmZyZXkgUGZhdSAgPGpw ZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBVc2luZyBOVUxMIGJ5dGVzIHdoZW4gc2V0dGluZyBpbm5lckhUTUwgaW4geGh0bWwg QVNTRVJUIGFuZCBOVUxMIHB0cgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NjEwNTMKKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGZvciBoYW5kbGlu ZyBOVUxMIGJ5dGVzIGFzIGluc2VydGVkIHRocm91Z2ggdGhlIG91dGVySFRNTCBwcm9wZXJ0eS4K KworICAgICAgICAqIGZhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVs bC1ieXRlLnhodG1sOiBBZGRlZC4KKwogMjAxMS0wNi0wMiAgSmlhbiBMaSAgPGppYW5saUBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5 dGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZmZDViMWRjYjU5NjdiOWE3Nzc3OGZiZDkwZTc0 N2YyYjQ0NDA5MGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94 aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitUaGlz IHRlc3Qgc3VjY2VlZHMgaWYgdGhpcyB0ZXh0IHJlbWFpbnMKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUueGh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLnhodG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjMyMmNiMmUyNDYzMGE0MjM4ZjBhMTE1YmFjZTNmZmY5YmZmMDRhZmEKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRl LnhodG1sCkBAIC0wLDAgKzEsMjIgQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9E VEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFRE L1N0cmljdC5kdGQiPiANCis8aHRtbCB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIiB4bWxucz0iaHR0 cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+DQorICA8aGVhZD4NCisgICAgPHRpdGxlPlhIVE1M IEJhc2UtNjQvb3V0ZXJIVE1MIG51bGwgYnl0ZSB0ZXN0PC90aXRsZT4NCisgICAgPHNjcmlwdD48 IVtDREFUQVsNCisgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQ0KKyAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOw0KKyAgICBdXT48L3NjcmlwdD4N CisgIDwvaGVhZD4NCisgIDxib2R5Pg0KKyAgICA8cCBpZD0icDAiPlRoaXMgdGVzdCBzdWNjZWVk cyBpZiB0aGlzIHRleHQgcmVtYWluczwvcD4NCisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAg ICB0cnkgew0KKyAgICAgICAgLy8gQmFzZTY0IHNheXM6IDxwIGlkPSJwMCI+VGVzdCBmYWlsZWQ8 L3A+XDA8Pg0KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAwIikub3V0ZXJIVE1M PXdpbmRvdy5hdG9iKCJQSEFnYVdROUluQXdJajVVWlhOMElHWmhhV3hsWkR3dmNENEFQRDRLIik7 DQorICAgICAgfSBjYXRjaChlKSB7DQorICAgICAgICBpZiAoZS5uYW1lICE9ICJJTlZBTElEX1NU QVRFX0VSUiIpDQorICAgICAgICAgIGNvbnNvbGUubG9nKCJVbmV4cGVjdGVkIGVycm9yIHRocm93 bjogIiArIGUubmFtZSArICI6ICIgKyBlLm1lc3NhZ2UpOw0KKyAgICAgIH0NCisgICAgXV0+PC9z Y3JpcHQ+DQorICA8L2JvZHk+DQorPC9odG1sPg0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0ODAxMWRmNTE1MDkw NGIwOGQ0NTU0MTNlZmQ0NTQ5ZDgzNjQ0NjY1Li4wMzU0ZjcxMTlmZmIxZjE5MzllMThiZDc4NzI0 NjY4M2RlMDZmNzcxIDEwMDc1NQotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTEtMDYtMDcgIEpl ZmZyZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBVc2luZyBOVUxMIGJ5dGVzIHdoZW4gc2V0dGluZyBpbm5l ckhUTUwgaW4geGh0bWwgQVNTRVJUIGFuZCBOVUxMIHB0cgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjEwNTMKKworICAgICAgICBDaGFuZ2VkIFhNTFBh cnNlckNvbnRleHQncyBtZW1vcnkgcGFyc2VyIHRvIHBhc3MgYWxvbmcgdGhlIGxlbmd0aCBvZiB0 aGUKKyAgICAgICAgc3RyaW5nLiBUaGlzIGFsbG93cyB0aGUgc3RyaW5nIHRvIGNvbnRhaW4gTlVM TCBieXRlcyB0aGF0IGFyZSBzZWVuIGFzIHBhcnQKKyAgICAgICAgb2YgdGhlIHN0cmluZyBpbnN0 ZWFkIG9mIHRoZSBlbmQgb2YgdGhlIHN0cmluZy4KKworICAgICAgICBUZXN0OiBmYXN0L3BhcnNl ci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLnhodG1sCisKKyAgICAgICAgKiBkb20vWE1MRG9j dW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNl cik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW5pdGlhbGl6ZVBhcnNl ckNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZEZy YWdtZW50U291cmNlKToKKwogMjAxMS0wNi0wMiAgSmlhbiBMaSAgPGppYW5saUBjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Y TUxEb2N1bWVudFBhcnNlci5oCmluZGV4IDI5NDgzM2Y3OTZmOGQzZDE3NjE3MzczNTk3NmIwZDli YzU1NGZmZjYuLmM2NWNhNDY3NDczMzkyOThmYTNjYmRjMzA5MDYxNGQ3NWM1YzI4MDggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5oCkBAIC01Niw3ICs1Niw3IEBAIGNsYXNz IFRleHQ7CiAjaWYgIVVTRShRWE1MU1RSRUFNKQogICAgIGNsYXNzIFhNTFBhcnNlckNvbnRleHQg OiBwdWJsaWMgUmVmQ291bnRlZDxYTUxQYXJzZXJDb250ZXh0PiB7CiAgICAgcHVibGljOgotICAg ICAgICBzdGF0aWMgUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBjcmVhdGVNZW1vcnlQYXJz ZXIoeG1sU0FYSGFuZGxlclB0ciwgdm9pZCosIGNvbnN0IGNoYXIqKTsKKyAgICAgICAgc3RhdGlj IFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gY3JlYXRlTWVtb3J5UGFyc2VyKHhtbFNBWEhh bmRsZXJQdHIsIHZvaWQqLCBjb25zdCBjaGFyKiwgaW50KTsKICAgICAgICAgc3RhdGljIFBhc3NS ZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gY3JlYXRlU3RyaW5nUGFyc2VyKHhtbFNBWEhhbmRsZXJQ dHIsIHZvaWQqKTsKICAgICAgICAgflhNTFBhcnNlckNvbnRleHQoKTsKICAgICAgICAgeG1sUGFy c2VyQ3R4dFB0ciBjb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0OyB9CkBAIC0xNjAs NyArMTYwLDcgQEAgcHVibGljOgogICAgICAgICB2b2lkIGVuZERvY3VtZW50KCk7CiAjZW5kaWYK ICAgICBwcml2YXRlOgotICAgICAgICB2b2lkIGluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0 IGNoYXIqIGNodW5rID0gMCk7CisgICAgICAgIHZvaWQgaW5pdGlhbGl6ZVBhcnNlckNvbnRleHQo Y29uc3QgY2hhciogY2h1bmsgPSAwLCBpbnQgY2h1bmtMZW4gPSAwKTsKIAogICAgICAgICB2b2lk IHB1c2hDdXJyZW50Tm9kZShDb250YWluZXJOb2RlKik7CiAgICAgICAgIHZvaWQgcG9wQ3VycmVu dE5vZGUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNl ckxpYnhtbDIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1s Mi5jcHAKaW5kZXggNDIwNDVkYzI3NDMxYmNhZDM3NTg2ZmI5Y2I4N2VmOWVmOTFhN2NjYy4uYWIw OTFkZDVkY2JhZGVlOWRiYmUwODRkYmJjZWM1Yzk1MjFlNmFlNSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKQEAgLTUwMSw3ICs1MDEsNyBA QCBQYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZVN0 cmluZ1BhcnNlcih4bWxTQVhIYW5kbGVyUAogCiAKIC8vIENodW5rIHNob3VsZCBiZSBlbmNvZGVk IGluIFVURi04Ci1QYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IFhNTFBhcnNlckNvbnRleHQ6 OmNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhIYW5kbGVyUHRyIGhhbmRsZXJzLCB2b2lkKiB1c2Vy RGF0YSwgY29uc3QgY2hhciogY2h1bmspCitQYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IFhN TFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhIYW5kbGVyUHRyIGhhbmRs ZXJzLCB2b2lkKiB1c2VyRGF0YSwgY29uc3QgY2hhciogY2h1bmssIGludCBjaHVua0xlbikKIHsK ICAgICBpZiAoIWRpZEluaXQpIHsKICAgICAgICAgeG1sSW5pdFBhcnNlcigpOwpAQCAtNTExLDcg KzUxMSw3IEBAIFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gWE1MUGFyc2VyQ29udGV4dDo6 Y3JlYXRlTWVtb3J5UGFyc2VyKHhtbFNBWEhhbmRsZXJQCiAgICAgICAgIGRpZEluaXQgPSB0cnVl OwogICAgIH0KIAotICAgIHhtbFBhcnNlckN0eHRQdHIgcGFyc2VyID0geG1sQ3JlYXRlTWVtb3J5 UGFyc2VyQ3R4dChjaHVuaywgeG1sU3RybGVuKChjb25zdCB4bWxDaGFyKiljaHVuaykpOworICAg IHhtbFBhcnNlckN0eHRQdHIgcGFyc2VyID0geG1sQ3JlYXRlTWVtb3J5UGFyc2VyQ3R4dChjaHVu aywgY2h1bmtMZW4pOwogCiAgICAgaWYgKCFwYXJzZXIpCiAgICAgICAgIHJldHVybiAwOwpAQCAt MTI3Niw3ICsxMjc2LDcgQEAgc3RhdGljIHZvaWQgaWdub3JhYmxlV2hpdGVzcGFjZUhhbmRsZXIo dm9pZCosIGNvbnN0IHhtbENoYXIqLCBpbnQpCiAgICAgLy8gaHR0cDovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NTc5MgogfQogCi12b2lkIFhNTERvY3VtZW50UGFyc2VyOjppbml0 aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBjaGFyKiBjaHVuaykKK3ZvaWQgWE1MRG9jdW1lbnRQ YXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNodW5rLCBpbnQgY2h1 bmtMZW4pCiB7CiAgICAgeG1sU0FYSGFuZGxlciBzYXg7CiAgICAgbWVtc2V0KCZzYXgsIDAsIHNp emVvZihzYXgpKTsKQEAgLTEzMDYsNyArMTMwNiw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6 OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNodW5rKQogCiAgICAgWE1MRG9j dW1lbnRQYXJzZXJTY29wZSBzY29wZShkb2N1bWVudCgpLT5jYWNoZWRSZXNvdXJjZUxvYWRlcigp KTsKICAgICBpZiAobV9wYXJzaW5nRnJhZ21lbnQpCi0gICAgICAgIG1fY29udGV4dCA9IFhNTFBh cnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcigmc2F4LCB0aGlzLCBjaHVuayk7CisgICAg ICAgIG1fY29udGV4dCA9IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcigmc2F4 LCB0aGlzLCBjaHVuaywgY2h1bmtMZW4pOwogICAgIGVsc2UgewogICAgICAgICBBU1NFUlQoIWNo dW5rKTsKICAgICAgICAgbV9jb250ZXh0ID0gWE1MUGFyc2VyQ29udGV4dDo6Y3JlYXRlU3RyaW5n UGFyc2VyKCZzYXgsIHRoaXMpOwpAQCAtMTQ0Myw3ICsxNDQzLDcgQEAgYm9vbCBYTUxEb2N1bWVu dFBhcnNlcjo6YXBwZW5kRnJhZ21lbnRTb3VyY2UoY29uc3QgU3RyaW5nJiBjaHVuaykKICAgICBB U1NFUlQobV9wYXJzaW5nRnJhZ21lbnQpOwogCiAgICAgQ1N0cmluZyBjaHVua0FzVXRmOCA9IGNo dW5rLnV0ZjgoKTsKLSAgICBpbml0aWFsaXplUGFyc2VyQ29udGV4dChjaHVua0FzVXRmOC5kYXRh KCkpOworICAgIGluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNodW5rQXNVdGY4LmRhdGEoKSwgY2h1 bmtBc1V0ZjgubGVuZ3RoKCkpOwogICAgIHhtbFBhcnNlQ29udGVudChjb250ZXh0KCkpOwogICAg IGVuZERvY3VtZW50KCk7IC8vIENsb3NlIGFueSBvcGVuIHRleHQgbm9kZXMuCiAKQEAgLTE0NTIs OSArMTQ1Miw5IEBAIGJvb2wgWE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZEZyYWdtZW50U291cmNl KGNvbnN0IFN0cmluZyYgY2h1bmspCiAgICAgLy8gQ2hlY2sgaWYgYWxsIHRoZSBjaHVuayBoYXMg YmVlbiBwcm9jZXNzZWQuCiAgICAgbG9uZyBieXRlc1Byb2Nlc3NlZCA9IHhtbEJ5dGVDb25zdW1l ZChjb250ZXh0KCkpOwogICAgIGlmIChieXRlc1Byb2Nlc3NlZCA9PSAtMSB8fCAoKHVuc2lnbmVk IGxvbmcpYnl0ZXNQcm9jZXNzZWQpICE9IGNodW5rQXNVdGY4Lmxlbmd0aCgpKSB7Ci0gICAgICAg IC8vIEZJWE1FOiBJIGRvbid0IGJlbGlldmUgd2UgY2FuIGhpdCB0aGlzIGNhc2Ugd2l0aG91dCBh bHNvIGhhdmluZyBzZWVuIGFuIGVycm9yLgorICAgICAgICAvLyBGSVhNRTogSSBkb24ndCBiZWxp ZXZlIHdlIGNhbiBoaXQgdGhpcyBjYXNlIHdpdGhvdXQgYWxzbyBoYXZpbmcgc2VlbiBhbiBlcnJv ciBvciBhIG51bGwgYnl0ZS4KICAgICAgICAgLy8gSWYgd2UgaGl0IHRoaXMgQVNTRVJULCB3ZSd2 ZSBmb3VuZCBhIHRlc3QgY2FzZSB3aGljaCBkZW1vbnN0cmF0ZXMgdGhlIG5lZWQgZm9yIHRoaXMg Y29kZS4KLSAgICAgICAgQVNTRVJUKG1fc2F3RXJyb3IpOworICAgICAgICBBU1NFUlQobV9zYXdF cnJvciB8fCAoYnl0ZXNQcm9jZXNzZWQgPj0gMCAmJiAhY2h1bmtBc1V0ZjguZGF0YSgpW2J5dGVz UHJvY2Vzc2VkXSkpOwogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCg== 96828 2011-06-10 17:35:28 -0700 2011-06-16 13:58:22 -0700 Patch bug-61053-20110610173527.patch text/plain 13188 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogODc5NjIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiYjIzYWVmOGJmYjlkNDczNjUxZjdl MDU0MTFmNmNiYWEyMTc1MDI4Li45YWZjNDg3N2JkZjc1NDc3MGI1YzhlYjY0MWRmODFlMmUyOWZi ZmNmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDYtMTAgIEplZmZyZXkgUGZhdSAgPGpw ZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBVc2luZyBudWxsIGJ5dGVzIHdoZW4gc2V0dGluZyBpbm5lckhUTUwgaW4gWFRITUwg cmVzdWx0cyBpbiBhc3NlcnRpb24gYW5kIGEgY3Jhc2ggZHVlIHRvIG51bGwtcG9pbnRlciBkZXJl ZmVyZW5jZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjEwNTMKKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGNvdmVyaW5nIGZvdXIgY2FzZXMgb2Yg dXNpbmcgaW5uZXJIVE1MIGFuZCBvdXRlckhUTUwgd2l0aCBudWxsIGJ5dGVzIGluIFhIVE1MCisK KyAgICAgICAgKiBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwt Ynl0ZS1maXJzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvcGFyc2VyL3ho dG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZmlyc3QueGh0bWw6IEFkZGVkLgorICAgICAgICAqIGZh c3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUueGh0bWw6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLWZp cnN0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wYXJzZXIveGh0bWwtb3V0 ZXJodG1sLW51bGwtYnl0ZS1maXJzdC54aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9wYXJz ZXIveGh0bWwtb3V0ZXJodG1sLW51bGwtYnl0ZS54aHRtbDogQWRkZWQuCisKIDIwMTEtMDYtMDIg IEppYW4gTGkgIDxqaWFubGlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERh dmlkIExldmluLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5u ZXJodG1sLW51bGwtYnl0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94 aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZmQ1YjFk Y2I1OTY3YjlhNzc3NzhmYmQ5MGU3NDdmMmI0NDQwOTBjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSBAQAorVGhpcyB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgdGV4dCByZW1haW5z CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVs bC1ieXRlLWZpcnN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1s LWlubmVyaHRtbC1udWxsLWJ5dGUtZmlyc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZmZDVi MWRjYjU5NjdiOWE3Nzc3OGZiZDkwZTc0N2YyYjQ0NDA5MGMKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitUaGlzIHRlc3Qgc3VjY2VlZHMgaWYgdGhpcyB0ZXh0 IHJlbWFpbnMKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlubmVy aHRtbC1udWxsLWJ5dGUtZmlyc3QueGh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRt bC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmQxOWI5Zjc3M2Yz ZDk4N2Q3OGFjMGQwYjdhZmQyM2IzZDRhODlkYjEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCkBA IC0wLDAgKzEsMjIgQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwg MS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL1N0cmljdC5k dGQiPiANCis8aHRtbCB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIiB4bWxucz0iaHR0cDovL3d3dy53 My5vcmcvMTk5OS94aHRtbCI+DQorICA8aGVhZD4NCisgICAgPHRpdGxlPlhIVE1MIEJhc2UtNjQv aW5uZXJIVE1MIG51bGwgYnl0ZSB0ZXN0PC90aXRsZT4NCisgICAgPHNjcmlwdD48IVtDREFUQVsN CisgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQ0KKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOw0KKyAgICBdXT48L3NjcmlwdD4NCisgIDwvaGVh ZD4NCisgIDxib2R5Pg0KKyAgICA8cCBpZD0icDAiPlRoaXMgdGVzdCBzdWNjZWVkcyBpZiB0aGlz IHRleHQgcmVtYWluczwvcD4NCisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAgICB0cnkgew0K KyAgICAgICAgLy8gQmFzZTY0IHNheXM6IFwwDQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicDAiKS5pbm5lckhUTUw9d2luZG93LmF0b2IoIkFBIik7DQorICAgICAgfSBjYXRjaChl KSB7DQorICAgICAgICBpZiAoZS5uYW1lICE9ICJJTlZBTElEX1NUQVRFX0VSUiIpDQorICAgICAg ICAgIGNvbnNvbGUubG9nKCJVbmV4cGVjdGVkIGVycm9yIHRocm93bjogIiArIGUubmFtZSArICI6 ICIgKyBlLm1lc3NhZ2UpOw0KKyAgICAgIH0NCisgICAgXV0+PC9zY3JpcHQ+DQorICA8L2JvZHk+ DQorPC9odG1sPg0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlu bmVyaHRtbC1udWxsLWJ5dGUueGh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1p bm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjAyOTJkODgwOTk1OTc0YjY0ZGJh NzM3MmMyNDZlZDY0NWY5YTAxNjcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCkBAIC0wLDAgKzEsMjIgQEAK KzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4i ICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL1N0cmljdC5kdGQiPiANCis8aHRtbCB4 bWw6bGFuZz0iZW4iIGxhbmc9ImVuIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRt bCI+DQorICA8aGVhZD4NCisgICAgPHRpdGxlPlhIVE1MIEJhc2UtNjQvaW5uZXJIVE1MIG51bGwg Ynl0ZSB0ZXN0PC90aXRsZT4NCisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQ0KKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOw0KKyAgICBdXT48L3NjcmlwdD4NCisgIDwvaGVhZD4NCisgIDxib2R5Pg0K KyAgICA8cCBpZD0icDAiPlRoaXMgdGVzdCBzdWNjZWVkcyBpZiB0aGlzIHRleHQgcmVtYWluczwv cD4NCisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAgICB0cnkgew0KKyAgICAgICAgLy8gQmFz ZTY0IHNheXM6IFRlc3QgZmFpbGVkXDA8Pg0KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInAwIikuaW5uZXJIVE1MPXdpbmRvdy5hdG9iKCJWR1Z6ZENCbVlXbHNaV1FBUEQ0PSIpOw0K KyAgICAgIH0gY2F0Y2goZSkgew0KKyAgICAgICAgaWYgKGUubmFtZSAhPSAiSU5WQUxJRF9TVEFU RV9FUlIiKQ0KKyAgICAgICAgICBjb25zb2xlLmxvZygiVW5leHBlY3RlZCBlcnJvciB0aHJvd246 ICIgKyBlLm5hbWUgKyAiOiAiICsgZS5tZXNzYWdlKTsNCisgICAgICB9DQorICAgIF1dPjwvc2Ny aXB0Pg0KKyAgPC9ib2R5Pg0KKzwvaHRtbD4NCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjZmZDViMWRjYjU5NjdiOWE3Nzc3OGZiZDkwZTc0N2YyYjQ0NDA5MGMKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1vdXRlcmh0bWwtbnVs bC1ieXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitUaGlzIHRlc3Qgc3VjY2VlZHMgaWYg dGhpcyB0ZXh0IHJlbWFpbnMKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3ho dG1sLW91dGVyaHRtbC1udWxsLWJ5dGUtZmlyc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9wYXJzZXIveGh0bWwtb3V0ZXJodG1sLW51bGwtYnl0ZS1maXJzdC1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uNmZkNWIxZGNiNTk2N2I5YTc3Nzc4ZmJkOTBlNzQ3ZjJiNDQ0MDkwYwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1u dWxsLWJ5dGUtZmlyc3QtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1RoaXMgdGVzdCBzdWNj ZWVkcyBpZiB0aGlzIHRleHQgcmVtYWlucwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9w YXJzZXIveGh0bWwtb3V0ZXJodG1sLW51bGwtYnl0ZS1maXJzdC54aHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUtZmlyc3QueGh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uYmQxMjZiMjAxNGEzODZiZTI1MmNjZWEyMWZlYTM3ZmQwZTY5MTQzZQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5 dGUtZmlyc3QueGh0bWwKQEAgLTAsMCArMSwyMiBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICIt Ly9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3ho dG1sMS9EVEQvU3RyaWN0LmR0ZCI+IA0KKzxodG1sIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iIHht bG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4NCisgIDxoZWFkPg0KKyAgICA8dGl0 bGU+WEhUTUwgQmFzZS02NC9vdXRlckhUTUwgbnVsbCBieXRlIHRlc3Q8L3RpdGxlPg0KKyAgICA8 c2NyaXB0PjwhW0NEQVRBWw0KKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIp DQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQorICAgIF1dPjwv c2NyaXB0Pg0KKyAgPC9oZWFkPg0KKyAgPGJvZHk+DQorICAgIDxwIGlkPSJwMCI+VGhpcyB0ZXN0 IHN1Y2NlZWRzIGlmIHRoaXMgdGV4dCByZW1haW5zPC9wPg0KKyAgICA8c2NyaXB0PjwhW0NEQVRB Ww0KKyAgICAgIHRyeSB7DQorICAgICAgICAvLyBCYXNlNjQgc2F5czogXDANCisgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMCIpLm91dGVySFRNTD13aW5kb3cuYXRvYigiQUEiKTsN CisgICAgICB9IGNhdGNoKGUpIHsNCisgICAgICAgIGlmIChlLm5hbWUgIT0gIklOVkFMSURfU1RB VEVfRVJSIikNCisgICAgICAgICAgY29uc29sZS5sb2coIlVuZXhwZWN0ZWQgZXJyb3IgdGhyb3du OiAiICsgZS5uYW1lICsgIjogIiArIGUubWVzc2FnZSk7DQorICAgICAgfQ0KKyAgICBdXT48L3Nj cmlwdD4NCisgIDwvYm9keT4NCis8L2h0bWw+DQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9wYXJzZXIveGh0bWwtb3V0ZXJodG1sLW51bGwtYnl0ZS54aHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUueGh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzIy Y2IyZTI0NjMwYTQyMzhmMGExMTViYWNlM2ZmZjliZmYwNGFmYQotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLW91dGVyaHRtbC1udWxsLWJ5dGUueGh0bWwK QEAgLTAsMCArMSwyMiBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRN TCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQvU3RyaWN0 LmR0ZCI+IA0KKzxodG1sIHhtbDpsYW5nPSJlbiIgbGFuZz0iZW4iIHhtbG5zPSJodHRwOi8vd3d3 LnczLm9yZy8xOTk5L3hodG1sIj4NCisgIDxoZWFkPg0KKyAgICA8dGl0bGU+WEhUTUwgQmFzZS02 NC9vdXRlckhUTUwgbnVsbCBieXRlIHRlc3Q8L3RpdGxlPg0KKyAgICA8c2NyaXB0PjwhW0NEQVRB Ww0KKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQorICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQorICAgIF1dPjwvc2NyaXB0Pg0KKyAgPC9o ZWFkPg0KKyAgPGJvZHk+DQorICAgIDxwIGlkPSJwMCI+VGhpcyB0ZXN0IHN1Y2NlZWRzIGlmIHRo aXMgdGV4dCByZW1haW5zPC9wPg0KKyAgICA8c2NyaXB0PjwhW0NEQVRBWw0KKyAgICAgIHRyeSB7 DQorICAgICAgICAvLyBCYXNlNjQgc2F5czogPHAgaWQ9InAwIj5UZXN0IGZhaWxlZDwvcD5cMDw+ DQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDAiKS5vdXRlckhUTUw9d2luZG93 LmF0b2IoIlBIQWdhV1E5SW5Bd0lqNVVaWE4wSUdaaGFXeGxaRHd2Y0Q0QVBENEsiKTsNCisgICAg ICB9IGNhdGNoKGUpIHsNCisgICAgICAgIGlmIChlLm5hbWUgIT0gIklOVkFMSURfU1RBVEVfRVJS IikNCisgICAgICAgICAgY29uc29sZS5sb2coIlVuZXhwZWN0ZWQgZXJyb3IgdGhyb3duOiAiICsg ZS5uYW1lICsgIjogIiArIGUubWVzc2FnZSk7DQorICAgICAgfQ0KKyAgICBdXT48L3NjcmlwdD4N CisgIDwvYm9keT4NCis8L2h0bWw+DQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDQ4MDExZGY1MTUwOTA0YjA4ZDQ1 NTQxM2VmZDQ1NDlkODM2NDQ2NjUuLjhmMTA2NmEzYmFkZjJiYmQ2Nzk0NzExYjU2MzY1MzRlZGU4 MjhhMWUgMTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMS0wNi0xMCAgSmVmZnJleSBQ ZmF1ICA8anBmYXVAYXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFVzaW5nIG51bGwgYnl0ZXMgd2hlbiBzZXR0aW5nIGlubmVySFRNTCBp biBYVEhNTCByZXN1bHRzIGluIGFzc2VydGlvbiBhbmQgYSBjcmFzaCBkdWUgdG8gbnVsbC1wb2lu dGVyIGRlcmVmZXJlbmNlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD02MTA1MworCisgICAgICAgIENoYW5nZWQgbWVtb3J5IHBhcnNlciB0byBwYXNzIGFy b3VuZCB0aGUgbGVuZ3RoIG9mIHRoZSBYTUwgY2h1bmsgaW4KKyAgICAgICAgYWRkaXRpb24gdG8g dGhlIGNodW5rIGl0c2VsZi4gQWxzbyBhZGRlZCBhIGNoZWNrIHRvIG1ha2Ugc3VyZSB0aGUKKyAg ICAgICAgbGVuZ3RoIG9mIHRoZSBjaHVuayBpcyBub3QgdG9vIGxhcmdlIHRvIGJlIHBhc3NlZCB0 byBsaWJ4bWwyLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwt bnVsbC1ieXRlLWZpcnN0LnhodG1sCisgICAgICAgICAgICAgICBmYXN0L3BhcnNlci94aHRtbC1p bm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCisgICAgICAgICAgICAgICBmYXN0L3BhcnNlci94aHRt bC1vdXRlcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCisgICAgICAgICAgICAgICBmYXN0L3Bh cnNlci94aHRtbC1vdXRlcmh0bWwtbnVsbC1ieXRlLnhodG1sCisKKyAgICAgICAgKiBkb20vWE1M RG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBh cnNlcik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW5pdGlhbGl6ZVBh cnNlckNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVu ZEZyYWdtZW50U291cmNlKToKKwogMjAxMS0wNi0wMiAgSmlhbiBMaSAgPGppYW5saUBjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9YTUxEb2N1bWVudFBhcnNlci5oCmluZGV4IDI5NDgzM2Y3OTZmOGQzZDE3NjE3MzczNTk3NmIw ZDliYzU1NGZmZjYuLmMzN2ZjN2Y1NTUyNGEzMGMyZTQ1NzJkMDFhODBjZTdhNDY0ZDc2NGUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5oCkBAIC01Niw3ICs1Niw3IEBAIGNs YXNzIFRleHQ7CiAjaWYgIVVTRShRWE1MU1RSRUFNKQogICAgIGNsYXNzIFhNTFBhcnNlckNvbnRl eHQgOiBwdWJsaWMgUmVmQ291bnRlZDxYTUxQYXJzZXJDb250ZXh0PiB7CiAgICAgcHVibGljOgot ICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBjcmVhdGVNZW1vcnlQ YXJzZXIoeG1sU0FYSGFuZGxlclB0ciwgdm9pZCosIGNvbnN0IGNoYXIqKTsKKyAgICAgICAgc3Rh dGljIFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gY3JlYXRlTWVtb3J5UGFyc2VyKHhtbFNB WEhhbmRsZXJQdHIsIHZvaWQqLCBjb25zdCBjaGFyKiwgaW50KTsKICAgICAgICAgc3RhdGljIFBh c3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gY3JlYXRlU3RyaW5nUGFyc2VyKHhtbFNBWEhhbmRs ZXJQdHIsIHZvaWQqKTsKICAgICAgICAgflhNTFBhcnNlckNvbnRleHQoKTsKICAgICAgICAgeG1s UGFyc2VyQ3R4dFB0ciBjb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0OyB9CkBAIC0x NjAsNyArMTYwLDcgQEAgcHVibGljOgogICAgICAgICB2b2lkIGVuZERvY3VtZW50KCk7CiAjZW5k aWYKICAgICBwcml2YXRlOgotICAgICAgICB2b2lkIGluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNv bnN0IGNoYXIqIGNodW5rID0gMCk7CisgICAgICAgIHZvaWQgaW5pdGlhbGl6ZVBhcnNlckNvbnRl eHQoY29uc3QgY2hhciogY2h1bmsgPSAwLCBpbnQgY2h1bmtMZW5ndGggPSAwKTsKIAogICAgICAg ICB2b2lkIHB1c2hDdXJyZW50Tm9kZShDb250YWluZXJOb2RlKik7CiAgICAgICAgIHZvaWQgcG9w Q3VycmVudE5vZGUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVu dFBhcnNlckxpYnhtbDIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2Vy TGlieG1sMi5jcHAKaW5kZXggNDIwNDVkYzI3NDMxYmNhZDM3NTg2ZmI5Y2I4N2VmOWVmOTFhN2Nj Yy4uYTA1YmJkYmY1MDZhNTcwNDRhMmQzYTIzZDI1NTE1MzUwYjRlNGYyZSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKQEAgLTUwMSw3ICs1 MDEsNyBAQCBQYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IFhNTFBhcnNlckNvbnRleHQ6OmNy ZWF0ZVN0cmluZ1BhcnNlcih4bWxTQVhIYW5kbGVyUAogCiAKIC8vIENodW5rIHNob3VsZCBiZSBl bmNvZGVkIGluIFVURi04Ci1QYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IFhNTFBhcnNlckNv bnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhIYW5kbGVyUHRyIGhhbmRsZXJzLCB2b2lk KiB1c2VyRGF0YSwgY29uc3QgY2hhciogY2h1bmspCitQYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRl eHQ+IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhIYW5kbGVyUHRy IGhhbmRsZXJzLCB2b2lkKiB1c2VyRGF0YSwgY29uc3QgY2hhciogY2h1bmssIGludCBjaHVua0xl bmd0aCkKIHsKICAgICBpZiAoIWRpZEluaXQpIHsKICAgICAgICAgeG1sSW5pdFBhcnNlcigpOwpA QCAtNTExLDcgKzUxMSw3IEBAIFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4dD4gWE1MUGFyc2Vy Q29udGV4dDo6Y3JlYXRlTWVtb3J5UGFyc2VyKHhtbFNBWEhhbmRsZXJQCiAgICAgICAgIGRpZElu aXQgPSB0cnVlOwogICAgIH0KIAotICAgIHhtbFBhcnNlckN0eHRQdHIgcGFyc2VyID0geG1sQ3Jl YXRlTWVtb3J5UGFyc2VyQ3R4dChjaHVuaywgeG1sU3RybGVuKChjb25zdCB4bWxDaGFyKiljaHVu aykpOworICAgIHhtbFBhcnNlckN0eHRQdHIgcGFyc2VyID0geG1sQ3JlYXRlTWVtb3J5UGFyc2Vy Q3R4dChjaHVuaywgY2h1bmtMZW5ndGgpOwogCiAgICAgaWYgKCFwYXJzZXIpCiAgICAgICAgIHJl dHVybiAwOwpAQCAtMTI3Niw3ICsxMjc2LDcgQEAgc3RhdGljIHZvaWQgaWdub3JhYmxlV2hpdGVz cGFjZUhhbmRsZXIodm9pZCosIGNvbnN0IHhtbENoYXIqLCBpbnQpCiAgICAgLy8gaHR0cDovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTc5MgogfQogCi12b2lkIFhNTERvY3VtZW50 UGFyc2VyOjppbml0aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBjaGFyKiBjaHVuaykKK3ZvaWQg WE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNo dW5rLCBpbnQgY2h1bmtMZW5ndGgpCiB7CiAgICAgeG1sU0FYSGFuZGxlciBzYXg7CiAgICAgbWVt c2V0KCZzYXgsIDAsIHNpemVvZihzYXgpKTsKQEAgLTEzMDYsNyArMTMwNiw3IEBAIHZvaWQgWE1M RG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNodW5r KQogCiAgICAgWE1MRG9jdW1lbnRQYXJzZXJTY29wZSBzY29wZShkb2N1bWVudCgpLT5jYWNoZWRS ZXNvdXJjZUxvYWRlcigpKTsKICAgICBpZiAobV9wYXJzaW5nRnJhZ21lbnQpCi0gICAgICAgIG1f Y29udGV4dCA9IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcigmc2F4LCB0aGlz LCBjaHVuayk7CisgICAgICAgIG1fY29udGV4dCA9IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1l bW9yeVBhcnNlcigmc2F4LCB0aGlzLCBjaHVuaywgY2h1bmtMZW5ndGgpOwogICAgIGVsc2Ugewog ICAgICAgICBBU1NFUlQoIWNodW5rKTsKICAgICAgICAgbV9jb250ZXh0ID0gWE1MUGFyc2VyQ29u dGV4dDo6Y3JlYXRlU3RyaW5nUGFyc2VyKCZzYXgsIHRoaXMpOwpAQCAtMTQ0Myw3ICsxNDQzLDEz IEBAIGJvb2wgWE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZEZyYWdtZW50U291cmNlKGNvbnN0IFN0 cmluZyYgY2h1bmspCiAgICAgQVNTRVJUKG1fcGFyc2luZ0ZyYWdtZW50KTsKIAogICAgIENTdHJp bmcgY2h1bmtBc1V0ZjggPSBjaHVuay51dGY4KCk7Ci0gICAgaW5pdGlhbGl6ZVBhcnNlckNvbnRl eHQoY2h1bmtBc1V0ZjguZGF0YSgpKTsKKworICAgIGlmIChjaHVua0FzVXRmOC5sZW5ndGgoKSA+ IDB4N0ZGRkZGRkZMKSB7CisgICAgICAgIC8vIGxpYnhtbDIgdGFrZXMgYW4gaW50IGZvciBhIGxl bmd0aCwgYW5kIHRoZXJlZm9yZSBjYW4ndCBoYW5kbGUgWE1MIGNodW5rcyBsYXJnZXIgdGhhbiAy IEdpQgorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgaW5pdGlhbGl6ZVBhcnNl ckNvbnRleHQoY2h1bmtBc1V0ZjguZGF0YSgpLCBjaHVua0FzVXRmOC5sZW5ndGgoKSk7CiAgICAg eG1sUGFyc2VDb250ZW50KGNvbnRleHQoKSk7CiAgICAgZW5kRG9jdW1lbnQoKTsgLy8gQ2xvc2Ug YW55IG9wZW4gdGV4dCBub2Rlcy4KIApAQCAtMTQ1Miw5ICsxNDU4LDkgQEAgYm9vbCBYTUxEb2N1 bWVudFBhcnNlcjo6YXBwZW5kRnJhZ21lbnRTb3VyY2UoY29uc3QgU3RyaW5nJiBjaHVuaykKICAg ICAvLyBDaGVjayBpZiBhbGwgdGhlIGNodW5rIGhhcyBiZWVuIHByb2Nlc3NlZC4KICAgICBsb25n IGJ5dGVzUHJvY2Vzc2VkID0geG1sQnl0ZUNvbnN1bWVkKGNvbnRleHQoKSk7CiAgICAgaWYgKGJ5 dGVzUHJvY2Vzc2VkID09IC0xIHx8ICgodW5zaWduZWQgbG9uZylieXRlc1Byb2Nlc3NlZCkgIT0g Y2h1bmtBc1V0ZjgubGVuZ3RoKCkpIHsKLSAgICAgICAgLy8gRklYTUU6IEkgZG9uJ3QgYmVsaWV2 ZSB3ZSBjYW4gaGl0IHRoaXMgY2FzZSB3aXRob3V0IGFsc28gaGF2aW5nIHNlZW4gYW4gZXJyb3Iu CisgICAgICAgIC8vIEZJWE1FOiBJIGRvbid0IGJlbGlldmUgd2UgY2FuIGhpdCB0aGlzIGNhc2Ug d2l0aG91dCBhbHNvIGhhdmluZyBzZWVuIGFuIGVycm9yIG9yIGEgbnVsbCBieXRlLgogICAgICAg ICAvLyBJZiB3ZSBoaXQgdGhpcyBBU1NFUlQsIHdlJ3ZlIGZvdW5kIGEgdGVzdCBjYXNlIHdoaWNo IGRlbW9uc3RyYXRlcyB0aGUgbmVlZCBmb3IgdGhpcyBjb2RlLgotICAgICAgICBBU1NFUlQobV9z YXdFcnJvcik7CisgICAgICAgIEFTU0VSVChtX3Nhd0Vycm9yIHx8IChieXRlc1Byb2Nlc3NlZCA+ PSAwICYmICFjaHVua0FzVXRmOC5kYXRhKClbYnl0ZXNQcm9jZXNzZWRdKSk7CiAgICAgICAgIHJl dHVybiBmYWxzZTsKICAgICB9CiAK 97489 2011-06-16 13:58:26 -0700 2011-06-16 18:07:58 -0700 Patch bug-61053-20110616135825.patch text/plain 9843 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogODg5ODYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAyOTY1MTk1ZmVjMmVlZDgyNTc0ZjE4 ODBhNjNmMzE0NzJiNDM2NmI4Li42OWFkMjU3NzRiODhlN2YyODFiOTgwZmJkMjQyY2Y5ZjY1ZjNh YTU2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYtMTYgIEplZmZyZXkgUGZhdSAgPGpw ZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBVc2luZyBudWxsIGJ5dGVzIHdoZW4gc2V0dGluZyBpbm5lckhUTUwgaW4gWFRITUwg cmVzdWx0cyBpbiBhc3NlcnRpb24gYW5kIGEgY3Jhc2ggZHVlIHRvIG51bGwtcG9pbnRlciBkZXJl ZmVyZW5jZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjEwNTMKKworICAgICAgICBBZGRlZCB0ZXN0IGNhc2VzIGNvdmVyaW5nIGZvdXIgY2FzZXMgb2Yg dXNpbmcgaW5uZXJIVE1MIHdpdGggbnVsbCBieXRlcyBpbiBYSFRNTC4KKworICAgICAgICAqIGZh c3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1s LW51bGwtYnl0ZS1maXJzdC54aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9wYXJzZXIveGh0 bWwtaW5uZXJodG1sLW51bGwtYnl0ZS54aHRtbDogQWRkZWQuCisKIDIwMTEtMDYtMTUgIFN0ZXBo ZW4gV2hpdGUgIDxzZW5vcmJsYW5jb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdl ZDsgbW9yZSB0ZXN0IGV4cGVjdGF0aW9ucyBjbGVhbnVwLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVk LnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lNzdjMDAzODhiZGFjNWE2ZjUzMWFkNzgxODFkN2JlNWJhMmM4NzQ3 Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJo dG1sLW51bGwtYnl0ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFTUzogQW4gZXhjZXB0 aW9uIHdhcyByYWlzZWQsIG5vIGNyYXNoaW5nLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1maXJzdC1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNzdjMDAzODhiZGFjNWE2ZjUzMWFkNzgxODFkN2JlNWJh MmM4NzQ3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwt aW5uZXJodG1sLW51bGwtYnl0ZS1maXJzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFT UzogQW4gZXhjZXB0aW9uIHdhcyByYWlzZWQsIG5vIGNyYXNoaW5nLgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1maXJzdC54aHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZmly c3QueGh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uODU5MzZjOGJkMTQ0ZmFlZDI1ZWQxNjk5NGVkOGQzYzY2M2Uy ZGEwMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlu bmVyaHRtbC1udWxsLWJ5dGUtZmlyc3QueGh0bWwKQEAgLTAsMCArMSwyMiBAQAorPCFET0NUWVBF IGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93 d3cudzMub3JnL1RSL3hodG1sMS9EVEQvU3RyaWN0LmR0ZCI+IA0KKzxodG1sIHhtbDpsYW5nPSJl biIgbGFuZz0iZW4iIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4NCisgIDxo ZWFkPg0KKyAgICA8dGl0bGU+WEhUTUwgaW5uZXJIVE1MIG51bGwgYnl0ZSB0ZXN0PC90aXRsZT4N CisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKQ0KKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOw0KKyAg ICBdXT48L3NjcmlwdD4NCisgIDwvaGVhZD4NCisgIDxib2R5Pg0KKyAgICA8cCBpZD0icDAiPkZB SUw6IE5vIGV4Y2VwdGlvbiByYWlzZWQuPC9wPg0KKyAgICA8c2NyaXB0PjwhW0NEQVRBWw0KKyAg ICAgIHRyeSB7DQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDAiKS5pbm5lckhU TUwgPSAiXHgwMEZBSUw6IE51bGxzIG1pc2hhbmRsZWQuIjsNCisgICAgICB9IGNhdGNoKGUpIHsN CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMCIpLmlubmVySFRNTCA9ICJQQVNT OiBBbiBleGNlcHRpb24gd2FzIHJhaXNlZCwgbm8gY3Jhc2hpbmcuIjsNCisgICAgICAgIGlmIChl LmNvZGUgIT0gMTEpDQorICAgICAgICAgIGNvbnNvbGUubG9nKCJVbmV4cGVjdGVkIGVycm9yIHRo cm93bjogIiArIGUubmFtZSArICI6ICIgKyBlLm1lc3NhZ2UpOw0KKyAgICAgIH0NCisgICAgXV0+ PC9zY3JpcHQ+DQorICA8L2JvZHk+DQorPC9odG1sPg0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUueGh0bWwgYi9MYXlvdXRUZXN0 cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjRjZTc5NDAxMjdmZjM2NDUzNGViZmVmMTcyNzM5MjI4NzVlODk2ZDIKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnho dG1sCkBAIC0wLDAgKzEsMjIgQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQg WEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL1N0 cmljdC5kdGQiPiANCis8aHRtbCB4bWw6bGFuZz0iZW4iIGxhbmc9ImVuIiB4bWxucz0iaHR0cDov L3d3dy53My5vcmcvMTk5OS94aHRtbCI+DQorICA8aGVhZD4NCisgICAgPHRpdGxlPlhIVE1MIGlu bmVySFRNTCBudWxsIGJ5dGUgdGVzdDwvdGl0bGU+DQorICAgIDxzY3JpcHQ+PCFbQ0RBVEFbDQor ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikNCisgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsNCisgICAgXV0+PC9zY3JpcHQ+DQorICA8L2hlYWQ+ DQorICA8Ym9keT4NCisgICAgPHAgaWQ9InAwIj5GQUlMOiBObyBleGNlcHRpb24gcmFpc2VkLjwv cD4NCisgICAgPHNjcmlwdD48IVtDREFUQVsNCisgICAgICB0cnkgew0KKyAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInAwIikuaW5uZXJIVE1MID0gIkZBSUw6IE51bGxzIG1pc2hhbmRs ZWQuXHgwMCI7DQorICAgICAgfSBjYXRjaChlKSB7DQorICAgICAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgicDAiKS5pbm5lckhUTUwgPSAiUEFTUzogQW4gZXhjZXB0aW9uIHdhcyByYWlzZWQs IG5vIGNyYXNoaW5nLiI7DQorICAgICAgICBpZiAoZS5jb2RlICE9IDExKQ0KKyAgICAgICAgICBj b25zb2xlLmxvZygiVW5leHBlY3RlZCBlcnJvciB0aHJvd246ICIgKyBlLm5hbWUgKyAiOiAiICsg ZS5tZXNzYWdlKTsNCisgICAgICB9DQorICAgIF1dPjwvc2NyaXB0Pg0KKyAgPC9ib2R5Pg0KKzwv aHRtbD4NCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKaW5kZXggNzMyYjVkNTJlNzIzYTAyMTAxMWNjNzA2OGFhMGMyZWVkYjJi YzRlZC4uYzUzYTkzODUwYzM4NWUyNTJhZjBjMjE0NWM1MTRmMDRkNmFiMWM5YyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDIxIEBACisyMDExLTA2LTE2ICBKZWZmcmV5IFBmYXUgIDxqcGZhdUBhcHBs ZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg VXNpbmcgbnVsbCBieXRlcyB3aGVuIHNldHRpbmcgaW5uZXJIVE1MIGluIFhUSE1MIHJlc3VsdHMg aW4gYXNzZXJ0aW9uIGFuZCBhIGNyYXNoIGR1ZSB0byBudWxsLXBvaW50ZXIgZGVyZWZlcmVuY2UK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYxMDUzCisK KyAgICAgICAgWE1MIHBhcnNpbmcgaW4tbWVtb3J5IFhNTCBjaHVua3Mgbm93IHBhc3NlcyBhcm91 bmQgYSBzdHJpbmcgb2JqZWN0IGluc3RlYWQgb2YgYSBDIHN0cmluZywgZW5zdXJpbmcgbnVsbCBj aGFyYWN0ZXJzIGFyZSBwcm9wZXJseSBoYW5kbGVkLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3Bh cnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCisgICAgICAgICAgICAg ICBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCisKKyAgICAgICAg KiBkb20vWE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJz ZXJMaWJ4bWwyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTFBhcnNlckNvbnRleHQ6OmNyZWF0 ZU1lbW9yeVBhcnNlcik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW5p dGlhbGl6ZVBhcnNlckNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJz ZXI6OmFwcGVuZEZyYWdtZW50U291cmNlKToKKwogMjAxMS0wNi0xNSAgR3l1eW91bmcgS2ltICA8 Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbnQgVGFt dXJhLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyLmgg Yi9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCAyOTQ4MzNmNzk2 ZjhkM2QxNzYxNzM3MzU5NzZiMGQ5YmM1NTRmZmY2Li5lOTM2ODI0ZGUwZWI5NTA3OGQzMmFiNTc2 Y2M2YTNjMGQyOTNiNjlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1l bnRQYXJzZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuaApA QCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlNlZ21lbnRlZFN0cmluZy5oIgogI2luY2x1ZGUg PHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKICNpZiBV U0UoUVhNTFNUUkVBTSkKQEAgLTU2LDggKzU3LDggQEAgY2xhc3MgVGV4dDsKICNpZiAhVVNFKFFY TUxTVFJFQU0pCiAgICAgY2xhc3MgWE1MUGFyc2VyQ29udGV4dCA6IHB1YmxpYyBSZWZDb3VudGVk PFhNTFBhcnNlckNvbnRleHQ+IHsKICAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNzUmVm UHRyPFhNTFBhcnNlckNvbnRleHQ+IGNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhIYW5kbGVyUHRy LCB2b2lkKiwgY29uc3QgY2hhciopOwotICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxYTUxQYXJz ZXJDb250ZXh0PiBjcmVhdGVTdHJpbmdQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciwgdm9pZCopOwor ICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBjcmVhdGVNZW1vcnlQ YXJzZXIoeG1sU0FYSGFuZGxlclB0ciBoYW5kbGVycywgdm9pZCogdXNlckRhdGEsIGNvbnN0IENT dHJpbmcmIGNodW5rKTsKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4 dD4gY3JlYXRlU3RyaW5nUGFyc2VyKHhtbFNBWEhhbmRsZXJQdHIgaGFuZGxlcnMsIHZvaWQqIHVz ZXJEYXRhKTsKICAgICAgICAgflhNTFBhcnNlckNvbnRleHQoKTsKICAgICAgICAgeG1sUGFyc2Vy Q3R4dFB0ciBjb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0OyB9CiAKQEAgLTE2MCw3 ICsxNjEsNyBAQCBwdWJsaWM6CiAgICAgICAgIHZvaWQgZW5kRG9jdW1lbnQoKTsKICNlbmRpZgog ICAgIHByaXZhdGU6Ci0gICAgICAgIHZvaWQgaW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY29uc3Qg Y2hhciogY2h1bmsgPSAwKTsKKyAgICAgICAgdm9pZCBpbml0aWFsaXplUGFyc2VyQ29udGV4dChj b25zdCBDU3RyaW5nJiBjaHVuayA9IENTdHJpbmcoKSk7CiAKICAgICAgICAgdm9pZCBwdXNoQ3Vy cmVudE5vZGUoQ29udGFpbmVyTm9kZSopOwogICAgICAgICB2b2lkIHBvcEN1cnJlbnROb2RlKCk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwy LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCmlu ZGV4IDQyMDQ1ZGMyNzQzMWJjYWQzNzU4NmZiOWNiODdlZjllZjkxYTdjY2MuLjBkYzYzMzNlNmEy MTdhYTIwNzBjY2E1OGQ0MDM3YzE2NGZiOTY5YjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCkBAIC01MDEsNyArNTAxLDcgQEAgUGFzc1Jl ZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVTdHJpbmdQYXJz ZXIoeG1sU0FYSGFuZGxlclAKIAogCiAvLyBDaHVuayBzaG91bGQgYmUgZW5jb2RlZCBpbiBVVEYt OAotUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVN ZW1vcnlQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciBoYW5kbGVycywgdm9pZCogdXNlckRhdGEsIGNv bnN0IGNoYXIqIGNodW5rKQorUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJD b250ZXh0OjpjcmVhdGVNZW1vcnlQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciBoYW5kbGVycywgdm9p ZCogdXNlckRhdGEsIGNvbnN0IENTdHJpbmcmIGNodW5rKQogewogICAgIGlmICghZGlkSW5pdCkg ewogICAgICAgICB4bWxJbml0UGFyc2VyKCk7CkBAIC01MTEsNyArNTExLDkgQEAgUGFzc1JlZlB0 cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVNZW1vcnlQYXJzZXIo eG1sU0FYSGFuZGxlclAKICAgICAgICAgZGlkSW5pdCA9IHRydWU7CiAgICAgfQogCi0gICAgeG1s UGFyc2VyQ3R4dFB0ciBwYXJzZXIgPSB4bWxDcmVhdGVNZW1vcnlQYXJzZXJDdHh0KGNodW5rLCB4 bWxTdHJsZW4oKGNvbnN0IHhtbENoYXIqKWNodW5rKSk7CisgICAgQVNTRVJUKGNodW5rLmxlbmd0 aCgpIDw9IElOVF9NQVgpOworCisgICAgeG1sUGFyc2VyQ3R4dFB0ciBwYXJzZXIgPSB4bWxDcmVh dGVNZW1vcnlQYXJzZXJDdHh0KGNodW5rLmRhdGEoKSwgY2h1bmsubGVuZ3RoKCkpOwogCiAgICAg aWYgKCFwYXJzZXIpCiAgICAgICAgIHJldHVybiAwOwpAQCAtMTI3Niw3ICsxMjc4LDcgQEAgc3Rh dGljIHZvaWQgaWdub3JhYmxlV2hpdGVzcGFjZUhhbmRsZXIodm9pZCosIGNvbnN0IHhtbENoYXIq LCBpbnQpCiAgICAgLy8gaHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTc5 MgogfQogCi12b2lkIFhNTERvY3VtZW50UGFyc2VyOjppbml0aWFsaXplUGFyc2VyQ29udGV4dChj b25zdCBjaGFyKiBjaHVuaykKK3ZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJz ZXJDb250ZXh0KGNvbnN0IENTdHJpbmcmIGNodW5rKQogewogICAgIHhtbFNBWEhhbmRsZXIgc2F4 OwogICAgIG1lbXNldCgmc2F4LCAwLCBzaXplb2Yoc2F4KSk7CkBAIC0xMzA4LDcgKzEzMTAsNyBA QCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjppbml0aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBj aGFyKiBjaHVuaykKICAgICBpZiAobV9wYXJzaW5nRnJhZ21lbnQpCiAgICAgICAgIG1fY29udGV4 dCA9IFhNTFBhcnNlckNvbnRleHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcigmc2F4LCB0aGlzLCBjaHVu ayk7CiAgICAgZWxzZSB7Ci0gICAgICAgIEFTU0VSVCghY2h1bmspOworICAgICAgICBBU1NFUlQo IWNodW5rLmRhdGEoKSk7CiAgICAgICAgIG1fY29udGV4dCA9IFhNTFBhcnNlckNvbnRleHQ6OmNy ZWF0ZVN0cmluZ1BhcnNlcigmc2F4LCB0aGlzKTsKICAgICB9CiB9CkBAIC0xNDQzLDcgKzE0NDUs MTIgQEAgYm9vbCBYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kRnJhZ21lbnRTb3VyY2UoY29uc3Qg U3RyaW5nJiBjaHVuaykKICAgICBBU1NFUlQobV9wYXJzaW5nRnJhZ21lbnQpOwogCiAgICAgQ1N0 cmluZyBjaHVua0FzVXRmOCA9IGNodW5rLnV0ZjgoKTsKLSAgICBpbml0aWFsaXplUGFyc2VyQ29u dGV4dChjaHVua0FzVXRmOC5kYXRhKCkpOworICAgIAorICAgIC8vIGxpYnhtbDIgdGFrZXMgYW4g aW50IGZvciBhIGxlbmd0aCwgYW5kIHRoZXJlZm9yZSBjYW4ndCBoYW5kbGUgWE1MIGNodW5rcyBs YXJnZXIgdGhhbiAyIEdpQi4KKyAgICBpZiAoY2h1bmtBc1V0ZjgubGVuZ3RoKCkgPiBJTlRfTUFY KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpbml0aWFsaXplUGFyc2VyQ29udGV4dChj aHVua0FzVXRmOCk7CiAgICAgeG1sUGFyc2VDb250ZW50KGNvbnRleHQoKSk7CiAgICAgZW5kRG9j dW1lbnQoKTsgLy8gQ2xvc2UgYW55IG9wZW4gdGV4dCBub2Rlcy4KIApAQCAtMTQ1Miw5ICsxNDU5 LDkgQEAgYm9vbCBYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kRnJhZ21lbnRTb3VyY2UoY29uc3Qg U3RyaW5nJiBjaHVuaykKICAgICAvLyBDaGVjayBpZiBhbGwgdGhlIGNodW5rIGhhcyBiZWVuIHBy b2Nlc3NlZC4KICAgICBsb25nIGJ5dGVzUHJvY2Vzc2VkID0geG1sQnl0ZUNvbnN1bWVkKGNvbnRl eHQoKSk7CiAgICAgaWYgKGJ5dGVzUHJvY2Vzc2VkID09IC0xIHx8ICgodW5zaWduZWQgbG9uZyli eXRlc1Byb2Nlc3NlZCkgIT0gY2h1bmtBc1V0ZjgubGVuZ3RoKCkpIHsKLSAgICAgICAgLy8gRklY TUU6IEkgZG9uJ3QgYmVsaWV2ZSB3ZSBjYW4gaGl0IHRoaXMgY2FzZSB3aXRob3V0IGFsc28gaGF2 aW5nIHNlZW4gYW4gZXJyb3IuCisgICAgICAgIC8vIEZJWE1FOiBJIGRvbid0IGJlbGlldmUgd2Ug Y2FuIGhpdCB0aGlzIGNhc2Ugd2l0aG91dCBhbHNvIGhhdmluZyBzZWVuIGFuIGVycm9yIG9yIGEg bnVsbCBieXRlLgogICAgICAgICAvLyBJZiB3ZSBoaXQgdGhpcyBBU1NFUlQsIHdlJ3ZlIGZvdW5k IGEgdGVzdCBjYXNlIHdoaWNoIGRlbW9uc3RyYXRlcyB0aGUgbmVlZCBmb3IgdGhpcyBjb2RlLgot ICAgICAgICBBU1NFUlQobV9zYXdFcnJvcik7CisgICAgICAgIEFTU0VSVChtX3Nhd0Vycm9yIHx8 IChieXRlc1Byb2Nlc3NlZCA+PSAwICYmICFjaHVua0FzVXRmOC5kYXRhKClbYnl0ZXNQcm9jZXNz ZWRdKSk7CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAK 97531 2011-06-16 18:08:02 -0700 2011-06-16 22:54:26 -0700 Patch bug-61053-20110616180801.patch text/plain 9871 jeffrey+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogODg5ODYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAyOTY1MTk1ZmVjMmVlZDgyNTc0ZjE4 ODBhNjNmMzE0NzJiNDM2NmI4Li4wZmE5YTk5MTY5YzAxOGU0MThhNjA5NTBmZjFhNWIwNWY5ODU2 MTJjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYtMTYgIEplZmZyZXkgUGZhdSAgPGpw ZmF1QGFwcGxlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBBbGV4ZXkgUHJvc2t1cnlha292 LgorCisgICAgICAgIFVzaW5nIG51bGwgYnl0ZXMgd2hlbiBzZXR0aW5nIGlubmVySFRNTCBpbiBY VEhNTCByZXN1bHRzIGluIGFzc2VydGlvbiBhbmQgYSBjcmFzaCBkdWUgdG8gbnVsbC1wb2ludGVy IGRlcmVmZXJlbmNlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD02MTA1MworCisgICAgICAgIEFkZGVkIHRlc3QgY2FzZXMgY292ZXJpbmcgdHdvIGNhc2Vz IG9mIHVzaW5nIGlubmVySFRNTCB3aXRoIG51bGwgYnl0ZXMgaW4gWEhUTUwuCisKKyAgICAgICAg KiBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1maXJz dC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvcGFyc2VyL3hodG1sLWlubmVy aHRtbC1udWxsLWJ5dGUtZmlyc3QueGh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvcGFyc2Vy L3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUueGh0bWw6IEFkZGVkLgorCiAyMDExLTA2LTE1ICBT dGVwaGVuIFdoaXRlICA8c2Vub3JibGFuY29AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2 aWV3ZWQ7IG1vcmUgdGVzdCBleHBlY3RhdGlvbnMgY2xlYW51cC4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZTc3YzAwMzg4YmRhYzVhNmY1MzFhZDc4MTgxZDdiZTViYTJj ODc0NwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlu bmVyaHRtbC1udWxsLWJ5dGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1BBU1M6IEFuIGV4 Y2VwdGlvbiB3YXMgcmFpc2VkLCBubyBjcmFzaGluZy4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZmlyc3QtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS1maXJz dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZTc3YzAwMzg4YmRhYzVhNmY1MzFhZDc4MTgxZDdi ZTViYTJjODc0NwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3ho dG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZmlyc3QtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAK K1BBU1M6IEFuIGV4Y2VwdGlvbiB3YXMgcmFpc2VkLCBubyBjcmFzaGluZy4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvcGFyc2VyL3hodG1sLWlubmVyaHRtbC1udWxsLWJ5dGUtZmlyc3Qu eGh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRl LWZpcnN0LnhodG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg1OTM2YzhiZDE0NGZhZWQyNWVkMTY5OTRlZDhkM2M2 NjNlMmRhMDIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3BhcnNlci94aHRt bC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCkBAIC0wLDAgKzEsMjIgQEAKKzwhRE9D VFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRw Oi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL1N0cmljdC5kdGQiPiANCis8aHRtbCB4bWw6bGFu Zz0iZW4iIGxhbmc9ImVuIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+DQor ICA8aGVhZD4NCisgICAgPHRpdGxlPlhIVE1MIGlubmVySFRNTCBudWxsIGJ5dGUgdGVzdDwvdGl0 bGU+DQorICAgIDxzY3JpcHQ+PCFbQ0RBVEFbDQorICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikNCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsN CisgICAgXV0+PC9zY3JpcHQ+DQorICA8L2hlYWQ+DQorICA8Ym9keT4NCisgICAgPHAgaWQ9InAw Ij5GQUlMOiBObyBleGNlcHRpb24gcmFpc2VkLjwvcD4NCisgICAgPHNjcmlwdD48IVtDREFUQVsN CisgICAgICB0cnkgew0KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInAwIikuaW5u ZXJIVE1MID0gIlx4MDBGQUlMOiBOdWxscyBtaXNoYW5kbGVkLiI7DQorICAgICAgfSBjYXRjaChl KSB7DQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicDAiKS5pbm5lckhUTUwgPSAi UEFTUzogQW4gZXhjZXB0aW9uIHdhcyByYWlzZWQsIG5vIGNyYXNoaW5nLiI7DQorICAgICAgICBp ZiAoZS5jb2RlICE9IDExKQ0KKyAgICAgICAgICBjb25zb2xlLmxvZygiVW5leHBlY3RlZCBlcnJv ciB0aHJvd246ICIgKyBlLm5hbWUgKyAiOiAiICsgZS5tZXNzYWdlKTsNCisgICAgICB9DQorICAg IF1dPjwvc2NyaXB0Pg0KKyAgPC9ib2R5Pg0KKzwvaHRtbD4NCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0ZS54aHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi40Y2U3OTQwMTI3ZmYzNjQ1MzRlYmZlZjE3MjczOTIyODc1ZTg5NmQyCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9wYXJzZXIveGh0bWwtaW5uZXJodG1sLW51bGwtYnl0 ZS54aHRtbApAQCAtMCwwICsxLDIyIEBACis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8v RFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RU RC9TdHJpY3QuZHRkIj4gDQorPGh0bWwgeG1sOmxhbmc9ImVuIiBsYW5nPSJlbiIgeG1sbnM9Imh0 dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPg0KKyAgPGhlYWQ+DQorICAgIDx0aXRsZT5YSFRN TCBpbm5lckhUTUwgbnVsbCBieXRlIHRlc3Q8L3RpdGxlPg0KKyAgICA8c2NyaXB0PjwhW0NEQVRB Ww0KKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQorICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQorICAgIF1dPjwvc2NyaXB0Pg0KKyAgPC9o ZWFkPg0KKyAgPGJvZHk+DQorICAgIDxwIGlkPSJwMCI+RkFJTDogTm8gZXhjZXB0aW9uIHJhaXNl ZC48L3A+DQorICAgIDxzY3JpcHQ+PCFbQ0RBVEFbDQorICAgICAgdHJ5IHsNCisgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJwMCIpLmlubmVySFRNTCA9ICJGQUlMOiBOdWxscyBtaXNo YW5kbGVkLlx4MDAiOw0KKyAgICAgIH0gY2F0Y2goZSkgew0KKyAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInAwIikuaW5uZXJIVE1MID0gIlBBU1M6IEFuIGV4Y2VwdGlvbiB3YXMgcmFp c2VkLCBubyBjcmFzaGluZy4iOw0KKyAgICAgICAgaWYgKGUuY29kZSAhPSAxMSkNCisgICAgICAg ICAgY29uc29sZS5sb2coIlVuZXhwZWN0ZWQgZXJyb3IgdGhyb3duOiAiICsgZS5uYW1lICsgIjog IiArIGUubWVzc2FnZSk7DQorICAgICAgfQ0KKyAgICBdXT48L3NjcmlwdD4NCisgIDwvYm9keT4N Cis8L2h0bWw+DQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDczMmI1ZDUyZTcyM2EwMjEwMTFjYzcwNjhhYTBjMmVl ZGIyYmM0ZWQuLmVmMWU0MDExMTM3Mjc2ZGNmNDNmMjQ5MzQ3MjI3OWE3NzRjNjMzNWYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMS0wNi0xNiAgSmVmZnJleSBQZmF1ICA8anBmYXVA YXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IEFsZXhleSBQcm9za3VyeWFrb3YuCisK KyAgICAgICAgVXNpbmcgbnVsbCBieXRlcyB3aGVuIHNldHRpbmcgaW5uZXJIVE1MIGluIFhUSE1M IHJlc3VsdHMgaW4gYXNzZXJ0aW9uIGFuZCBhIGNyYXNoIGR1ZSB0byBudWxsLXBvaW50ZXIgZGVy ZWZlcmVuY2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTYxMDUzCisKKyAgICAgICAgWE1MIHBhcnNpbmcgaW4tbWVtb3J5IFhNTCBjaHVua3Mgbm93IHBh c3NlcyBhcm91bmQgYSBzdHJpbmcgb2JqZWN0IGluc3RlYWQgb2YgYSBDIHN0cmluZywgZW5zdXJp bmcgbnVsbCBjaGFyYWN0ZXJzIGFyZSBwcm9wZXJseSBoYW5kbGVkLgorCisgICAgICAgIFRlc3Rz OiBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLWZpcnN0LnhodG1sCisgICAg ICAgICAgICAgICBmYXN0L3BhcnNlci94aHRtbC1pbm5lcmh0bWwtbnVsbC1ieXRlLnhodG1sCisK KyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBkb20vWE1MRG9j dW1lbnRQYXJzZXJMaWJ4bWwyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTFBhcnNlckNvbnRl eHQ6OmNyZWF0ZU1lbW9yeVBhcnNlcik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBh cnNlcjo6aW5pdGlhbGl6ZVBhcnNlckNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9j dW1lbnRQYXJzZXI6OmFwcGVuZEZyYWdtZW50U291cmNlKToKKwogMjAxMS0wNi0xNSAgR3l1eW91 bmcgS2ltICA8Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEtlbnQgVGFtdXJhLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50 UGFyc2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCAy OTQ4MzNmNzk2ZjhkM2QxNzYxNzM3MzU5NzZiMGQ5YmM1NTRmZmY2Li4zYWNkZDI1YzU1ZGMwMzVi OGYzMmE3NDE3NWE0NmQ5ODllZWIyNzVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20v WE1MRG9jdW1lbnRQYXJzZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQ YXJzZXIuaApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlNlZ21lbnRlZFN0cmluZy5oIgog I2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1 ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+ CiAKICNpZiBVU0UoUVhNTFNUUkVBTSkKQEAgLTU2LDggKzU3LDggQEAgY2xhc3MgVGV4dDsKICNp ZiAhVVNFKFFYTUxTVFJFQU0pCiAgICAgY2xhc3MgWE1MUGFyc2VyQ29udGV4dCA6IHB1YmxpYyBS ZWZDb3VudGVkPFhNTFBhcnNlckNvbnRleHQ+IHsKICAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRp YyBQYXNzUmVmUHRyPFhNTFBhcnNlckNvbnRleHQ+IGNyZWF0ZU1lbW9yeVBhcnNlcih4bWxTQVhI YW5kbGVyUHRyLCB2b2lkKiwgY29uc3QgY2hhciopOwotICAgICAgICBzdGF0aWMgUGFzc1JlZlB0 cjxYTUxQYXJzZXJDb250ZXh0PiBjcmVhdGVTdHJpbmdQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciwg dm9pZCopOworICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBjcmVh dGVNZW1vcnlQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciwgdm9pZCogdXNlckRhdGEsIGNvbnN0IENT dHJpbmcmIGNodW5rKTsKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8WE1MUGFyc2VyQ29udGV4 dD4gY3JlYXRlU3RyaW5nUGFyc2VyKHhtbFNBWEhhbmRsZXJQdHIsIHZvaWQqIHVzZXJEYXRhKTsK ICAgICAgICAgflhNTFBhcnNlckNvbnRleHQoKTsKICAgICAgICAgeG1sUGFyc2VyQ3R4dFB0ciBj b250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0OyB9CiAKQEAgLTE2MCw3ICsxNjEsNyBA QCBwdWJsaWM6CiAgICAgICAgIHZvaWQgZW5kRG9jdW1lbnQoKTsKICNlbmRpZgogICAgIHByaXZh dGU6Ci0gICAgICAgIHZvaWQgaW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY29uc3QgY2hhciogY2h1 bmsgPSAwKTsKKyAgICAgICAgdm9pZCBpbml0aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBDU3Ry aW5nJiBjaHVuayA9IENTdHJpbmcoKSk7CiAKICAgICAgICAgdm9pZCBwdXNoQ3VycmVudE5vZGUo Q29udGFpbmVyTm9kZSopOwogICAgICAgICB2b2lkIHBvcEN1cnJlbnROb2RlKCk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCmluZGV4IDQyMDQ1 ZGMyNzQzMWJjYWQzNzU4NmZiOWNiODdlZjllZjkxYTdjY2MuLmYyZjM5ZmI0ZWM3ZGVlMDcwYTgz NTE1YWUwYzRmNDEwZjZiNzI4NmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxE b2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9YTUxEb2N1 bWVudFBhcnNlckxpYnhtbDIuY3BwCkBAIC01MDEsNyArNTAxLDcgQEAgUGFzc1JlZlB0cjxYTUxQ YXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVTdHJpbmdQYXJzZXIoeG1sU0FY SGFuZGxlclAKIAogCiAvLyBDaHVuayBzaG91bGQgYmUgZW5jb2RlZCBpbiBVVEYtOAotUGFzc1Jl ZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVNZW1vcnlQYXJz ZXIoeG1sU0FYSGFuZGxlclB0ciBoYW5kbGVycywgdm9pZCogdXNlckRhdGEsIGNvbnN0IGNoYXIq IGNodW5rKQorUGFzc1JlZlB0cjxYTUxQYXJzZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0Ojpj cmVhdGVNZW1vcnlQYXJzZXIoeG1sU0FYSGFuZGxlclB0ciBoYW5kbGVycywgdm9pZCogdXNlckRh dGEsIGNvbnN0IENTdHJpbmcmIGNodW5rKQogewogICAgIGlmICghZGlkSW5pdCkgewogICAgICAg ICB4bWxJbml0UGFyc2VyKCk7CkBAIC01MTEsNyArNTExLDggQEAgUGFzc1JlZlB0cjxYTUxQYXJz ZXJDb250ZXh0PiBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVNZW1vcnlQYXJzZXIoeG1sU0FYSGFu ZGxlclAKICAgICAgICAgZGlkSW5pdCA9IHRydWU7CiAgICAgfQogCi0gICAgeG1sUGFyc2VyQ3R4 dFB0ciBwYXJzZXIgPSB4bWxDcmVhdGVNZW1vcnlQYXJzZXJDdHh0KGNodW5rLCB4bWxTdHJsZW4o KGNvbnN0IHhtbENoYXIqKWNodW5rKSk7CisgICAgLy8gYXBwZW5kRnJhZ21lbnRTb3VyY2UoKSBj aGVja3MgdGhhdCB0aGUgbGVuZ3RoIGRvZXNuJ3Qgb3ZlcmZsb3cgYW4gaW50LgorICAgIHhtbFBh cnNlckN0eHRQdHIgcGFyc2VyID0geG1sQ3JlYXRlTWVtb3J5UGFyc2VyQ3R4dChjaHVuay5kYXRh KCksIGNodW5rLmxlbmd0aCgpKTsKIAogICAgIGlmICghcGFyc2VyKQogICAgICAgICByZXR1cm4g MDsKQEAgLTEyNzYsNyArMTI3Nyw3IEBAIHN0YXRpYyB2b2lkIGlnbm9yYWJsZVdoaXRlc3BhY2VI YW5kbGVyKHZvaWQqLCBjb25zdCB4bWxDaGFyKiwgaW50KQogICAgIC8vIGh0dHA6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU3OTIKIH0KIAotdm9pZCBYTUxEb2N1bWVudFBhcnNl cjo6aW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY29uc3QgY2hhciogY2h1bmspCit2b2lkIFhNTERv Y3VtZW50UGFyc2VyOjppbml0aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBDU3RyaW5nJiBjaHVu aykKIHsKICAgICB4bWxTQVhIYW5kbGVyIHNheDsKICAgICBtZW1zZXQoJnNheCwgMCwgc2l6ZW9m KHNheCkpOwpAQCAtMTMwOCw3ICsxMzA5LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6aW5p dGlhbGl6ZVBhcnNlckNvbnRleHQoY29uc3QgY2hhciogY2h1bmspCiAgICAgaWYgKG1fcGFyc2lu Z0ZyYWdtZW50KQogICAgICAgICBtX2NvbnRleHQgPSBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVN ZW1vcnlQYXJzZXIoJnNheCwgdGhpcywgY2h1bmspOwogICAgIGVsc2UgewotICAgICAgICBBU1NF UlQoIWNodW5rKTsKKyAgICAgICAgQVNTRVJUKCFjaHVuay5kYXRhKCkpOwogICAgICAgICBtX2Nv bnRleHQgPSBYTUxQYXJzZXJDb250ZXh0OjpjcmVhdGVTdHJpbmdQYXJzZXIoJnNheCwgdGhpcyk7 CiAgICAgfQogfQpAQCAtMTQ0Myw3ICsxNDQ0LDEyIEBAIGJvb2wgWE1MRG9jdW1lbnRQYXJzZXI6 OmFwcGVuZEZyYWdtZW50U291cmNlKGNvbnN0IFN0cmluZyYgY2h1bmspCiAgICAgQVNTRVJUKG1f cGFyc2luZ0ZyYWdtZW50KTsKIAogICAgIENTdHJpbmcgY2h1bmtBc1V0ZjggPSBjaHVuay51dGY4 KCk7Ci0gICAgaW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY2h1bmtBc1V0ZjguZGF0YSgpKTsKKyAg ICAKKyAgICAvLyBsaWJ4bWwyIHRha2VzIGFuIGludCBmb3IgYSBsZW5ndGgsIGFuZCB0aGVyZWZv cmUgY2FuJ3QgaGFuZGxlIFhNTCBjaHVua3MgbGFyZ2VyIHRoYW4gMiBHaUIuCisgICAgaWYgKGNo dW5rQXNVdGY4Lmxlbmd0aCgpID4gSU5UX01BWCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgaW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY2h1bmtBc1V0ZjgpOwogICAgIHhtbFBhcnNlQ29u dGVudChjb250ZXh0KCkpOwogICAgIGVuZERvY3VtZW50KCk7IC8vIENsb3NlIGFueSBvcGVuIHRl eHQgbm9kZXMuCiAKQEAgLTE0NTIsOSArMTQ1OCw5IEBAIGJvb2wgWE1MRG9jdW1lbnRQYXJzZXI6 OmFwcGVuZEZyYWdtZW50U291cmNlKGNvbnN0IFN0cmluZyYgY2h1bmspCiAgICAgLy8gQ2hlY2sg aWYgYWxsIHRoZSBjaHVuayBoYXMgYmVlbiBwcm9jZXNzZWQuCiAgICAgbG9uZyBieXRlc1Byb2Nl c3NlZCA9IHhtbEJ5dGVDb25zdW1lZChjb250ZXh0KCkpOwogICAgIGlmIChieXRlc1Byb2Nlc3Nl ZCA9PSAtMSB8fCAoKHVuc2lnbmVkIGxvbmcpYnl0ZXNQcm9jZXNzZWQpICE9IGNodW5rQXNVdGY4 Lmxlbmd0aCgpKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBJIGRvbid0IGJlbGlldmUgd2UgY2FuIGhp dCB0aGlzIGNhc2Ugd2l0aG91dCBhbHNvIGhhdmluZyBzZWVuIGFuIGVycm9yLgorICAgICAgICAv LyBGSVhNRTogSSBkb24ndCBiZWxpZXZlIHdlIGNhbiBoaXQgdGhpcyBjYXNlIHdpdGhvdXQgYWxz byBoYXZpbmcgc2VlbiBhbiBlcnJvciBvciBhIG51bGwgYnl0ZS4KICAgICAgICAgLy8gSWYgd2Ug aGl0IHRoaXMgQVNTRVJULCB3ZSd2ZSBmb3VuZCBhIHRlc3QgY2FzZSB3aGljaCBkZW1vbnN0cmF0 ZXMgdGhlIG5lZWQgZm9yIHRoaXMgY29kZS4KLSAgICAgICAgQVNTRVJUKG1fc2F3RXJyb3IpOwor ICAgICAgICBBU1NFUlQobV9zYXdFcnJvciB8fCAoYnl0ZXNQcm9jZXNzZWQgPj0gMCAmJiAhY2h1 bmtBc1V0ZjguZGF0YSgpW2J5dGVzUHJvY2Vzc2VkXSkpOwogICAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgfQogCg==