45594 2010-09-11 10:35:43 -0700 Add AtomicString::fromUTF8 2010-12-02 14:51:43 -0800 1 1 1 Unclassified WebKit Web Template Framework 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 49581 43085 1 paroga paroga abarth ap barraclough buildbot commit-queue darin dglazkov eric gustavo webkit-ews webkit.review.bot xan.lopez oldest_to_newest 277736 0 paroga 2010-09-11 10:35:43 -0700 see patch 277738 1 67302 paroga 2010-09-11 10:40:29 -0700 Created attachment 67302 Patch I'll use this function for performance improvements of XMLParser (bug 43085). 277745 2 webkit-ews 2010-09-11 10:58:38 -0700 Attachment 67302 did not build on qt: Build output: http://queues.webkit.org/results/3897416 277760 3 webkit.review.bot 2010-09-11 11:37:24 -0700 Attachment 67302 did not build on chromium: Build output: http://queues.webkit.org/results/3914415 277770 4 webkit.review.bot 2010-09-11 13:04:16 -0700 Attachment 67302 did not build on gtk: Build output: http://queues.webkit.org/results/3946401 277856 5 67334 paroga 2010-09-12 05:06:43 -0700 Created attachment 67334 Patch 277885 6 67334 abarth 2010-09-12 12:17:55 -0700 Comment on attachment 67334 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67334&action=prettypatch I don't get it. Is this more efficient than making a string and then converting that to an atomic string? Maybe it saves you a memcpy in the case where you have multibyte characters? 277888 7 paroga 2010-09-12 12:30:37 -0700 (In reply to comment #6) > (From update of attachment 67334 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67334&action=prettypatch > > I don't get it. Is this more efficient than making a string and then converting that to an atomic string? Maybe it saves you a memcpy in the case where you have multibyte characters? XMLParser will uses the version witout a explicit length most of the time. Ther we can calcualte the hash, utf8length and utf16 length in one step: +AtomicString AtomicString::fromUTF8(const char* characters) +{ + if (!characters) + return AtomicString(); + + HashAndUTF8Characters buffer; + buffer.characters = characters; + buffer.string = 0; + + if (!calculateHashAndLength(characters, buffer.hash, buffer.lengthUTF8, buffer.lengthUTF16)) + return AtomicString(); // characters contains invalid UTF-8 characters. + + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable().add<HashAndUTF8Characters, HashAndUTF8CharactersTranslator>(buffer); + + // If the string is newly-translated, then we need to adopt it. + // The boolean in the pair tells us if that is so. + AtomicString atomicString; + atomicString.m_string = addResult.second ? adoptRef(*addResult.first) : *addResult.first; + return atomicString; +} This will avoid unnecessary operations, but requires additonal changes to the stringHash and UTF8 functions. I'd like to commit this in a first step to start using the "new API" in XMLParser. 277889 8 abarth 2010-09-12 12:36:00 -0700 > XMLParser will uses the version witout a explicit length most of the time. Ther we can calcualte the hash, utf8length and utf16 length in one step: The code you quote below isn't in the patch... If that's what we're aiming for, why not include that now? > This will avoid unnecessary operations, but requires additonal changes to the stringHash and UTF8 functions. > I'd like to commit this in a first step to start using the "new API" in XMLParser. I guess I still don't understand why any of this is specific to AtomicString. What we saving by putting these methods on AtomicString and not just on String? 277892 9 paroga 2010-09-12 12:43:54 -0700 (In reply to comment #8) > > XMLParser will uses the version witout a explicit length most of the time. Ther we can calcualte the hash, utf8length and utf16 length in one step: > > The code you quote below isn't in the patch... If that's what we're aiming for, why not include that now? It requires many other changes and I want to be able to create a patch for the XMLParser. > > This will avoid unnecessary operations, but requires additonal changes to the stringHash and UTF8 functions. > > I'd like to commit this in a first step to start using the "new API" in XMLParser. > > I guess I still don't understand why any of this is specific to AtomicString. What we saving by putting these methods on AtomicString and not just on String? HashAndUTF8CharactersTranslator is a new class which can operate directly with the utf8 characters. We don't need to convert it to utf16 for lookup in the HashTable (this will be the real performance win). 277894 10 abarth 2010-09-12 12:49:24 -0700 Ah, I see. That sounds cool. I don't see why we should take this partial patch. It doesn't seem to provide value on its own. Instead, we should do the full patch. Of course, you're encouraged to break it up into small pieces, but this patch seems to start in the middle of the dependency chain instead of at the bottom. 277895 11 67334 paroga 2010-09-12 12:56:50 -0700 Comment on attachment 67334 Patch (In reply to comment #10) > Ah, I see. That sounds cool. I don't see why we should take this partial patch. Ok, I'll start with an other patch. 277897 12 abarth 2010-09-12 12:59:38 -0700 > Ok, I'll start with an other patch. Thanks Patrick. 292149 13 70357 paroga 2010-10-09 11:36:32 -0700 Created attachment 70357 Patch 292150 14 webkit.review.bot 2010-10-09 11:42:28 -0700 Attachment 70357 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 JavaScriptCore/wtf/unicode/UTF8.cpp:326: A case label should not be indented, but line up with its switch statement. [whitespace/indent] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:326: More than one command on the same line [whitespace/newline] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:326: More than one command on the same line in if [whitespace/parens] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:327: More than one command on the same line [whitespace/newline] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:327: More than one command on the same line in if [whitespace/parens] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:328: More than one command on the same line [whitespace/newline] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:328: More than one command on the same line in if [whitespace/parens] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:329: More than one command on the same line [whitespace/newline] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:329: More than one command on the same line in if [whitespace/parens] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:330: More than one command on the same line [whitespace/newline] [4] JavaScriptCore/wtf/unicode/UTF8.cpp:330: More than one command on the same line in if [whitespace/parens] [4] Total errors found: 11 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 295116 15 webkit.review.bot 2010-10-16 03:18:01 -0700 Attachment 70357 did not build on win: Build output: http://queues.webkit.org/results/4456055 301282 16 paroga 2010-10-28 13:25:58 -0700 ping? 301317 17 70357 abarth 2010-10-28 13:59:57 -0700 Comment on attachment 70357 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=70357&action=review We'll need some unicode experts to look at this patch. > JavaScriptCore/wtf/text/AtomicString.cpp:232 > +static inline bool equal(StringImpl* string, const char* characters, unsigned length) > +{ > + if (string->length() != length) > + return false; > + > + const UChar* stringCharacters = string->characters(); > + for (unsigned i = 0; i != length; ++i) { > + if (*stringCharacters++ != *characters++) > + return false; > + } > + > + return true; > +} I don't understand how you're comparing UChars with chars. They're in different encodings... > JavaScriptCore/wtf/text/AtomicString.cpp:255 > + if (buffer.rawLength == buffer.utf16Length) // buffer contains only ASCII characters. > + return WTF::equal(string, buffer.characters, buffer.rawLength); I see what you're trying to do, but WTF::equal has way too general of a name. Also, this check isn't correct. Recall that some UTF16 characters are multibyte characters. > JavaScriptCore/wtf/text/AtomicString.cpp:391 > + // Try converting into the buffer. > + if (convertUTF8ToUTF16(&characters, characters + length, &buffer, bufferEnd) != conversionOK) > + return AtomicString(); > + > + // stringBuffer is full (the input must have been all ascii), use the string. > + if (buffer == bufferEnd) > + return AtomicString(stringBuffer.get()); This seems really sketchy. Why not just figure out what the correct length is? 301335 18 paroga 2010-10-28 14:27:55 -0700 (In reply to comment #17) > (From update of attachment 70357 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=70357&action=review > I don't understand how you're comparing UChars with chars. They're in different encodings... Is ok, if we give it a better name? (any good ideas?) > I see what you're trying to do, but WTF::equal has way too general of a name. Also, this check isn't correct. Recall that some UTF16 characters are multibyte characters. This check is only done if there are only ASCII characters. AFAIK the first byte of a UTF16 multibyte sequence will never match a ASCII character, so the true/false test should be ok IMHO. > > > JavaScriptCore/wtf/text/AtomicString.cpp:391 > > + // Try converting into the buffer. > > + if (convertUTF8ToUTF16(&characters, characters + length, &buffer, bufferEnd) != conversionOK) > > + return AtomicString(); > > + > > + // stringBuffer is full (the input must have been all ascii), use the string. > > + if (buffer == bufferEnd) > > + return AtomicString(stringBuffer.get()); > > This seems really sketchy. Why not just figure out what the correct length is? What do you mean exactly? Which length? This is the nearly the same alogrithm as for String::fromUtf8. 302340 19 70357 paroga 2010-10-30 13:27:15 -0700 Comment on attachment 70357 Patch Setting back to r? as discussed on IRC with abarth. @gbarra Can you have look at the this patch? svn blame shows you as author for most of the code in AtomicString. 302349 20 70357 darin 2010-10-30 15:23:28 -0700 Comment on attachment 70357 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=70357&action=review Basic idea here is quite good, but we should improve the execution at least a bit before landing. One thing we could do to cut down the size of the patch a bit is to add a non-optimized AtomicString::fromUTF8 first along with changes to adopt it, and then add the second patch which adds the optimized code path. > JavaScriptCore/wtf/text/AtomicString.cpp:217 > + mutable RefPtr<StringImpl> string; It’s pretty strange to have a mutable member in a struct with no member functions. It might be better to use a class. I think this idiom deserves at least a comment. Using a mutable structure so we can allocate the string during the lookup process and then reuse it when putting the string into the hash table is cleverness. Cleverness is a bad thing without comments to explain to those who follow. Quite a bit of additional complexity is here with the intention of speeding up cases that I don’t think are common enough to deserve it. Storing a StringImpl in the structure optimizes the case where we compare and discover the string is a new string, by removing one pass of UTF-8-to-16 conversion, but at the cost of extra string allocations where we compare and discover the string is not new, so I think it’s not a good tradeoff. With no comments about rationale, this all is a bit mysterious. > JavaScriptCore/wtf/text/AtomicString.cpp:220 > +static inline bool equal(StringImpl* string, const char* characters, unsigned length) Since this function is only legal for ASCII characters, then the name needs to express that limitation, and I’d like to see an assertion as well. I’m not sure a fast path for all-ASCII is needed, though. > JavaScriptCore/wtf/text/AtomicString.cpp:234 > +static inline void addStringImplIntoBuffer(const HashAndUTF8Characters& buffer) The function name here is pretty confusing. This seems like a perfect candidate for a member function. The more-typical idiom for this would be to use a private member for the string, and then have a public accessor function that does this work of creating the string. Then we avoid having this awkwardly-named function, and we also have an interface that's harder to use incorrectly. > JavaScriptCore/wtf/text/AtomicString.cpp:258 > + addStringImplIntoBuffer(buffer); > + return WTF::equal(string, buffer.string->characters(), buffer.string->length()); I think we easily can write code to compare a UTF-8 string with a UTF-16 string without allocating memory. This would come up in the relatively common case of looking for a non-ASCII string that is already in the table. It would be faster not to allocate memory in that case. > JavaScriptCore/wtf/text/AtomicString.cpp:377 > + return AtomicString(StringImpl::empty()); I believe it’s faster to return emptyAtom here. Other call sites in the same file should do the same if they don’t already. Unless it’s not faster! > JavaScriptCore/wtf/text/AtomicString.cpp:383 > + // We'll use a StringImpl as a buffer; if the source string only contains ascii this should be > + // the right length, if there are any multi-byte sequences this buffer will be too large. > + UChar* buffer; > + RefPtr<StringImpl> stringBuffer = StringImpl::createUninitialized(length, buffer); > + UChar* bufferEnd = buffer + length; This is not the right approach. We should write code that can look up the string in the hash table without allocating memory at all. There’s no reason we need a buffer to convert UTF-8 to UTF-16 until we have proven the string is not already in the table. I don’t think we need a special case for ASCII either; it will come out fast automatically. In this patch, we reserve the optimization of not allocating the string for null-terminated strings. That’s not the tradeoff we usually make in WebKit. > JavaScriptCore/wtf/text/AtomicString.cpp:399 > +AtomicString AtomicString::fromUTF8(const char* characters) This should call the other fromUTF8 function after first calling strlen rather than having separate logic. > JavaScriptCore/wtf/text/AtomicString.h:112 > + static AtomicString fromUTF8(const char*, size_t); > + static AtomicString fromUTF8(const char*); I think these functions and the ones already in the String class deserve a comment indicating what that the function returns a null string if the characters are not valid UTF-8. > JavaScriptCore/wtf/unicode/UTF8.h:73 > + bool calculateHashAndLength(const char* rawData, unsigned& hash, unsigned& rawLength, unsigned& utf16Length); This function is unclear. It has an argument name “rawData” and nothing in the function name or argument name make it clear that it’s expected to be UTF-8 data. I think you are using “raw” here to mean “UTF-8”, which is not a usual term of art. I also find the boolean result unclear. Without a comment I have no idea what its significance is. Maybe true if the function fails, or false if it fails? It’s not right to have this function work on null-terminated strings. Our normal approach is that all functions work on strings with an explicit separate length argument, except for a few convenience functions. Those can use strlen and then call through to the general case. Since this function works only on null-terminated strings, we can’t use it at all in functions that have strings with an explicit length: the function would run off the end of the buffer looking for a null character and also would misinterpret null characters as end-of-string indicators. A single function that computes a hash for a UTF-8 string and also returns the UTF-16 length as a side effect is OK. But we should add special cases only if we can prove with profiling they are beneficial. More branches mean the code is harder to test. Knowing the length in advance can be useful so we can allocate a perfectly-sized buffer without scanning the string again. It also serves the dual purpose of being an all-ASCII flag, but it’s not clear we need such a flag. The specifici motivation and value in having oblique functions with multiple purposes like this one means we need at least a brief mention in a comment of the benefit of doing these two things at once. The location of the function in this header isn’t perfect either, and creates a bit of a modularity problem within WTF. The function computes a hash, but the UTF8.h file is a lower level Unicode building block and this level knows nothing about the hashing algorithm. The code that knows about both UTF-8 and the hash functions probably belongs in StringHashFunctions.h rather than UTF8.h. I’d like us to add a function that compares a UTF-16 string to a UTF-8 one so we can find non-ASCII strings that are already present in the AtomicString table without allocating memory. 302351 21 70357 paroga 2010-10-30 16:29:20 -0700 Comment on attachment 70357 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=70357&action=review Many thanks for so much comments! >> JavaScriptCore/wtf/text/AtomicString.cpp:217 >> + mutable RefPtr<StringImpl> string; > > It’s pretty strange to have a mutable member in a struct with no member functions. It might be better to use a class. I think this idiom deserves at least a comment. Using a mutable structure so we can allocate the string during the lookup process and then reuse it when putting the string into the hash table is cleverness. Cleverness is a bad thing without comments to explain to those who follow. > > Quite a bit of additional complexity is here with the intention of speeding up cases that I don’t think are common enough to deserve it. Storing a StringImpl in the structure optimizes the case where we compare and discover the string is a new string, by removing one pass of UTF-8-to-16 conversion, but at the cost of extra string allocations where we compare and discover the string is not new, so I think it’s not a good tradeoff. > > With no comments about rationale, this all is a bit mysterious. If we add a UTF16/UTF8 equal function we won't need it anymore. :-) >> JavaScriptCore/wtf/text/AtomicString.cpp:220 >> +static inline bool equal(StringImpl* string, const char* characters, unsigned length) > > Since this function is only legal for ASCII characters, then the name needs to express that limitation, and I’d like to see an assertion as well. I’m not sure a fast path for all-ASCII is needed, though. It has the same name as http://trac.webkit.org/browser/trunk/JavaScriptCore/wtf/text/StringImpl.cpp?rev=69414#L915. Maybe we should change the name of other function too and add a ASSERT(containsOnlyASCII()). >> JavaScriptCore/wtf/text/AtomicString.cpp:234 >> +static inline void addStringImplIntoBuffer(const HashAndUTF8Characters& buffer) > > The function name here is pretty confusing. This seems like a perfect candidate for a member function. > > The more-typical idiom for this would be to use a private member for the string, and then have a public accessor function that does this work of creating the string. Then we avoid having this awkwardly-named function, and we also have an interface that's harder to use incorrectly. Will be removed too in favor of UTF16/UTF8 equal. >> JavaScriptCore/wtf/text/AtomicString.cpp:377 >> + return AtomicString(StringImpl::empty()); > > I believe it’s faster to return emptyAtom here. Other call sites in the same file should do the same if they don’t already. Unless it’s not faster! I wanted to use it, but didn't found it. I was looking for a member function like StringImpl::empty(). >> JavaScriptCore/wtf/text/AtomicString.cpp:383 >> + UChar* bufferEnd = buffer + length; > > This is not the right approach. We should write code that can look up the string in the hash table without allocating memory at all. There’s no reason we need a buffer to convert UTF-8 to UTF-16 until we have proven the string is not already in the table. I don’t think we need a special case for ASCII either; it will come out fast automatically. > > In this patch, we reserve the optimization of not allocating the string for null-terminated strings. That’s not the tradeoff we usually make in WebKit. If we add a equal function which compares UTF16 with UTF8 this won't make sense anymore. >> JavaScriptCore/wtf/text/AtomicString.cpp:399 >> +AtomicString AtomicString::fromUTF8(const char* characters) > > This should call the other fromUTF8 function after first calling strlen rather than having separate logic. I don't like the idea of calling strlen, when we iterate over the string too for calculating the hash afterwards. But it's ok to do it with strlen for now and get rid of it in a second patch. >> JavaScriptCore/wtf/text/AtomicString.h:112 >> + static AtomicString fromUTF8(const char*); > > I think these functions and the ones already in the String class deserve a comment indicating what that the function returns a null string if the characters are not valid UTF-8. I'll add comments in WTFString.h too. >> JavaScriptCore/wtf/unicode/UTF8.h:73 >> + bool calculateHashAndLength(const char* rawData, unsigned& hash, unsigned& rawLength, unsigned& utf16Length); > > This function is unclear. It has an argument name “rawData” and nothing in the function name or argument name make it clear that it’s expected to be UTF-8 data. I think you are using “raw” here to mean “UTF-8”, which is not a usual term of art. I also find the boolean result unclear. Without a comment I have no idea what its significance is. Maybe true if the function fails, or false if it fails? > > It’s not right to have this function work on null-terminated strings. Our normal approach is that all functions work on strings with an explicit separate length argument, except for a few convenience functions. Those can use strlen and then call through to the general case. Since this function works only on null-terminated strings, we can’t use it at all in functions that have strings with an explicit length: the function would run off the end of the buffer looking for a null character and also would misinterpret null characters as end-of-string indicators. > > A single function that computes a hash for a UTF-8 string and also returns the UTF-16 length as a side effect is OK. But we should add special cases only if we can prove with profiling they are beneficial. More branches mean the code is harder to test. Knowing the length in advance can be useful so we can allocate a perfectly-sized buffer without scanning the string again. It also serves the dual purpose of being an all-ASCII flag, but it’s not clear we need such a flag. The specifici motivation and value in having oblique functions with multiple purposes like this one means we need at least a brief mention in a comment of the benefit of doing these two things at once. > > The location of the function in this header isn’t perfect either, and creates a bit of a modularity problem within WTF. The function computes a hash, but the UTF8.h file is a lower level Unicode building block and this level knows nothing about the hashing algorithm. The code that knows about both UTF-8 and the hash functions probably belongs in StringHashFunctions.h rather than UTF8.h. > > I’d like us to add a function that compares a UTF-16 string to a UTF-8 one so we can find non-ASCII strings that are already present in the AtomicString table without allocating memory. In one of my first versions I had a utf8Length too, so a needed rawLength, but this doesn't apply any more. ;-) If we do the inital size check via strlen in a first patch, it makes no sense to work with null-terminated strings. IMHO the all-ASCII flag makes sense to avoid checking for UTF8-sequences later, but this might need some performance measurements to be sure. I'm not happy with the location too! I think that StringHash(Functions).h would be a better place, but the function uses to much (inline) stuff of the current UTF8.cpp (e.g. offsetsFromUTF8). We have the same problem for the UTF16/UTF8 equal function too. Our equal function all take a StringImpl*, but UTF8.cpp does not know anything about it, and StringImpl does not know anything about UTF8 sequences. I don't know what the best/clean solution might be. 308962 22 73819 paroga 2010-11-13 05:44:55 -0800 Created attachment 73819 Patch 309388 23 73819 darin 2010-11-15 12:11:33 -0800 Comment on attachment 73819 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=73819&action=review Looks good. Please consider some of my suggestions for improvement. For now, I set commit-queue- so you could think over if you want to make these changes before you land. > JavaScriptCore/wtf/text/AtomicString.cpp:233 > + UChar *target; The * is positioned incorrectly here. It should be next to the UChar. > JavaScriptCore/wtf/text/AtomicString.cpp:234 > + location = StringImpl::createUninitialized(buffer.utf16Length, target).releaseRef(); Please use the new name, leakRef, not the old name, releaseRef, in new code. > JavaScriptCore/wtf/text/AtomicString.h:112 > + // the input data contains invalid UTF-8 characters. Comment should say “invalid UTF-8 sequences” not “invalid UTF-8 characters”. > JavaScriptCore/wtf/text/WTFString.h:313 > + // the input data contains invalid UTF-8 characters. Same comment. > JavaScriptCore/wtf/unicode/UTF8.cpp:238 > + UChar32 ch = 0; I’d much prefer “character” for this local. > JavaScriptCore/wtf/unicode/UTF8.cpp:243 > + case 6: ch += static_cast<unsigned char>(*sequence++); ch <<= 6; // remember, illegal UTF-8 > + case 5: ch += static_cast<unsigned char>(*sequence++); ch <<= 6; // remember, illegal UTF-8 Who are we saying “remember” to in these comments? I know you just moved them, but I think these comments are unhelpful and unclear. We should remove the comments. > JavaScriptCore/wtf/unicode/UTF8.cpp:262 > + if (source + utf8SequenceLength > sourceEnd) { This should be written like this: if (sourceEnd - source < utf8SequenceLength) It’s not great to compute an address past the end of the buffer, and doing it this way guarantees we don’t try to do that. > JavaScriptCore/wtf/unicode/UTF8.cpp:313 > +unsigned calculateHashFromUTF8(const char* data, const char* dataEnd, unsigned& utf16Length) This function needs a policy for handling lengths that do not fit in unsigned. Even if that policy is simply to call CRASH when encountering a giant length. Not doing so can lead to security vulnerabilities. Alternatively, the type of the out argument could be changed to a size_t, but then the callers would need to check if they narrowed it to an unsigned. > JavaScriptCore/wtf/unicode/UTF8.cpp:322 > + if (!(*data & 0x80)) { It would be better to use isASCII from ASCIICType.h for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:337 > + ASSERT(ch >= 0x80); It would be better to use isASCII from ASCIICType.h for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:339 > + if (ch <= 0xFFFF) { It would be better to use U_IS_BMP for this. This is a macro from ICU that we may already implement for non-ICU platforms, but if not we can do so. > JavaScriptCore/wtf/unicode/UTF8.cpp:341 > + if (ch >= 0xD800 && ch <= 0xDFFF) It would be better to use U_IS_SURROGATE for this. Another ICU macro. > JavaScriptCore/wtf/unicode/UTF8.cpp:348 > + } else if (ch <= 0x10FFFF) { > + ch -= 0x0010000UL; > + stringHasher.addCharacters(static_cast<UChar>((ch >> 10) + 0xD800), > + static_cast<UChar>((ch & 0x03FF) + 0xDC00)); It would be better to use U_IS_SUPPLEMENTARY, U16_LEAD, and U16_TRAIL for this. More ICU macros. > JavaScriptCore/wtf/unicode/UTF8.cpp:360 > + if (!(*b & 0x80)) { It would be better to use isASCII from ASCIICType.h for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:361 > + if (*a++ != static_cast<UChar>(*b++)) The static_cast is unfortunate. Can we use a local variable to avoid the typecast? > JavaScriptCore/wtf/unicode/UTF8.cpp:375 > + ASSERT(ch >= 0x80); It would be better to use isASCII from ASCIICType.h for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:377 > + if (ch <= 0xFFFF) { It would be better to use U_IS_BMP for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:379 > + if (ch >= 0xD800 && ch <= 0xDFFF) It would be better to use U_IS_SURROGATE for this. > JavaScriptCore/wtf/unicode/UTF8.cpp:381 > + if (*a++ != static_cast<UChar>(ch)) I don’t think we need the static_cast here. Please remove it. > JavaScriptCore/wtf/unicode/UTF8.cpp:389 > + } else if (ch <= 0x10FFFF) { > + ch -= 0x0010000UL; > + > + if (*a++ != static_cast<UChar>((ch >> 10) + 0xD800)) > + return false; > + if (*a++ != static_cast<UChar>((ch & 0x03FF) + 0xDC00)) > + return false; It would be better to use U_IS_SUPPLEMENTARY, U16_LEAD, and U16_TRAIL for this. > JavaScriptCore/wtf/unicode/UTF8.h:73 > + unsigned calculateHashFromUTF8(const char* data, const char* dataEnd, unsigned& utf16Length); Still unfortunate to have this here in this file. At the very least this needs a comment to explain what kind of hash we are talking about. > JavaScriptCore/wtf/unicode/UTF8.h:75 > + bool equalUTF8(const UChar* a, const UChar* aEnd, const char* b, const char* bEnd); This name should mention UTF-16, not just UTF-8, since the function compares UTF-16 to UTF-8. 309585 24 buildbot 2010-11-15 22:04:36 -0800 Attachment 73819 did not build on win: Build output: http://queues.webkit.org/results/5989100 309614 25 paroga 2010-11-15 23:59:07 -0800 I created bug 45981 for some cleanup in UTF8.cpp. IMHO the UTF8 changes are independent and should go in before this one. 309615 26 paroga 2010-11-16 00:02:34 -0800 (In reply to comment #25) > I created bug 45981 for some cleanup in UTF8.cpp. bug 49581 instead of bug 45981 315616 27 75269 paroga 2010-12-01 06:35:27 -0800 Created attachment 75269 Patch 315617 28 webkit.review.bot 2010-12-01 06:38:00 -0800 Attachment 75269 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--diff-files', u'JavaScriptCore/ChangeLog', u'JavaScriptCore/JavaScriptCore.exp', u'JavaScriptCore/wtf/text/AtomicString.cpp', u'JavaScriptCore/wtf/text/AtomicString.h', u'JavaScriptCore/wtf/text/StringImpl.h', u'JavaScriptCore/wtf/text/WTFString.h', u'JavaScriptCore/wtf/unicode/UTF8.cpp', u'JavaScriptCore/wtf/unicode/UTF8.h', u'WebCore/ChangeLog', u'WebCore/dom/XMLDocumentParserLibxml2.cpp']" exit_code: 1 JavaScriptCore/wtf/text/AtomicString.cpp:233: Declaration has space between type name and * in UChar *target [whitespace/declaration] [3] Total errors found: 1 in 10 files If any of these errors are false positives, please file a bug against check-webkit-style. 315632 29 75271 paroga 2010-12-01 07:22:02 -0800 Created attachment 75271 Patch 315643 30 buildbot 2010-12-01 07:51:08 -0800 Attachment 75269 did not build on win: Build output: http://queues.webkit.org/results/6646008 315648 31 75274 paroga 2010-12-01 08:07:01 -0800 Created attachment 75274 Patch Try to make Win-EWS happy... 315678 32 buildbot 2010-12-01 09:04:19 -0800 Attachment 75271 did not build on win: Build output: http://queues.webkit.org/results/6617008 315851 33 75312 paroga 2010-12-01 13:15:20 -0800 Created attachment 75312 Patch Fixed style issue 316386 34 paroga 2010-12-02 13:15:23 -0800 @darin: ping 316390 35 75312 commit-queue 2010-12-02 13:21:41 -0800 Comment on attachment 75312 Patch Rejecting patch 75312 from commit-queue. Failed to run "['./WebKitTools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '--bot-id=eseidel-sf', 'apply-attachment', '--force-clean', '--non-interactive', 75312]" exit_code: 2 Last 500 characters of output: ing file JavaScriptCore/wtf/text/AtomicString.h patching file JavaScriptCore/wtf/text/StringImpl.h patching file JavaScriptCore/wtf/text/WTFString.h patching file JavaScriptCore/wtf/unicode/UTF8.cpp patching file JavaScriptCore/wtf/unicode/UTF8.h patching file WebCore/ChangeLog Hunk #1 succeeded at 1 with fuzz 3. patching file WebCore/dom/XMLDocumentParserLibxml2.cpp Failed to run "[u'/Projects/CommitQueue/WebKitTools/Scripts/svn-apply', u'--reviewer', u'Darin Adler', u'--force']" exit_code: 1 Full output: http://queues.webkit.org/results/6807015 316409 36 75414 paroga 2010-12-02 13:56:16 -0800 Created attachment 75414 Patch 316426 37 75414 commit-queue 2010-12-02 14:45:54 -0800 Comment on attachment 75414 Patch Clearing flags on attachment: 75414 Committed r73201: <http://trac.webkit.org/changeset/73201> 316427 38 commit-queue 2010-12-02 14:46:04 -0800 All reviewed patches have been landed. Closing bug. 316429 39 webkit.review.bot 2010-12-02 14:51:43 -0800 http://trac.webkit.org/changeset/73201 might have broken Qt Windows 32-bit Debug 67302 2010-09-11 10:40:29 -0700 2010-09-12 05:06:43 -0700 Patch 0001-AtomicString.patch text/plain 3001 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCBiZTcyNDhiLi5iMzIxZmVjIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTAtMDktMTEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHBhcm9nYS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVXNlIG5lYXJseSB0aGUgc2FtZSBpbXBsZW1lbnRh dGlvbiBhcyBpbiBTdHJpbmc6OmZyb21VVEY4LgorCisgICAgICAgICogd3RmL3RleHQvQXRvbWlj U3RyaW5nLmNwcDoKKyAgICAgICAgKFdURjo6QXRvbWljU3RyaW5nOjpmcm9tVVRGOCk6CisgICAg ICAgICogd3RmL3RleHQvQXRvbWljU3RyaW5nLmg6CisKIDIwMTAtMDktMTEgIFBhdHJpY2sgR2Fu c3RlcmVyICA8cGFyb2dhQHBhcm9nYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJp bmcuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcAppbmRleCAx OTgxMTcwLi5mZDUwYWY4IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9t aWNTdHJpbmcuY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5j cHAKQEAgLTI2LDkgKzI2LDEyIEBACiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRl IDx3dGYvVGhyZWFkaW5nLmg+CiAjaW5jbHVkZSA8d3RmL1dURlRocmVhZERhdGEuaD4KKyNpbmNs dWRlIDx3dGYvdW5pY29kZS9VVEY4Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCit1c2luZyBuYW1l c3BhY2UgVW5pY29kZTsKKwogQ09NUElMRV9BU1NFUlQoc2l6ZW9mKEF0b21pY1N0cmluZykgPT0g c2l6ZW9mKFN0cmluZyksIGF0b21pY19zdHJpbmdfYW5kX3N0cmluZ19tdXN0X2JlX3NhbWVfc2l6 ZSk7CiAKIGNsYXNzIEF0b21pY1N0cmluZ1RhYmxlIHsKQEAgLTI5Niw0ICsyOTksMzggQEAgQXRv bWljU3RyaW5nIEF0b21pY1N0cmluZzo6bG93ZXIoKSBjb25zdAogICAgIHJldHVybiBBdG9taWNT dHJpbmcobmV3SW1wbCk7CiB9CiAKK0F0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6OmZyb21VVEY4 KGNvbnN0IGNoYXIqIHN0cmluZ1N0YXJ0LCBzaXplX3QgbGVuZ3RoKQoreworICAgIGlmICghc3Ry aW5nU3RhcnQpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIC8vIFdlJ2xs IHVzZSBhIFN0cmluZ0ltcGwgYXMgYSBidWZmZXI7IGlmIHRoZSBzb3VyY2Ugc3RyaW5nIG9ubHkg Y29udGFpbnMgYXNjaWkgdGhpcyBzaG91bGQgYmUKKyAgICAvLyB0aGUgcmlnaHQgbGVuZ3RoLCBp ZiB0aGVyZSBhcmUgYW55IG11bHRpLWJ5dGUgc2VxdWVuY2VzIHRoaXMgYnVmZmVyIHdpbGwgYmUg dG9vIGxhcmdlLgorICAgIFVDaGFyKiBidWZmZXI7CisgICAgUmVmUHRyPFN0cmluZ0ltcGw+IHN0 cmluZ0J1ZmZlciA9IFN0cmluZ0ltcGw6OmNyZWF0ZVVuaW5pdGlhbGl6ZWQobGVuZ3RoLCBidWZm ZXIpOworICAgIFVDaGFyKiBidWZmZXJFbmQgPSBidWZmZXIgKyBsZW5ndGg7CisKKyAgICAvLyBU cnkgY29udmVydGluZyBpbnRvIHRoZSBidWZmZXIuCisgICAgY29uc3QgY2hhciogc3RyaW5nQ3Vy cmVudCA9IHN0cmluZ1N0YXJ0OworICAgIGlmIChjb252ZXJ0VVRGOFRvVVRGMTYoJnN0cmluZ0N1 cnJlbnQsIHN0cmluZ1N0YXJ0ICsgbGVuZ3RoLCAmYnVmZmVyLCBidWZmZXJFbmQpICE9IGNvbnZl cnNpb25PSykKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworCisgICAgLy8gc3RyaW5n QnVmZmVyIGlzIGZ1bGwgKHRoZSBpbnB1dCBtdXN0IGhhdmUgYmVlbiBhbGwgYXNjaWkpIHNvIGp1 c3QgcmV0dXJuIGl0IQorICAgIGlmIChidWZmZXIgPT0gYnVmZmVyRW5kKQorICAgICAgICByZXR1 cm4gc3RyaW5nQnVmZmVyOworCisgICAgLy8gc3RyaW5nQnVmZmVyIHNlcnZlZCBpdHMgcHVycG9z ZSBhcyBhIGJ1ZmZlciwgdHJ5IHRvIGZpbmQgYSBBdG9taWNTdHJpbmcuCisgICAgdW5zaWduZWQg dXRmMTZMZW5ndGggPSBidWZmZXIgLSBzdHJpbmdCdWZmZXItPmNoYXJhY3RlcnMoKTsKKyAgICBB U1NFUlQodXRmMTZMZW5ndGggPCBsZW5ndGgpOworICAgIHJldHVybiBhZGQoc3RyaW5nQnVmZmVy LT5jaGFyYWN0ZXJzKCksIHV0ZjE2TGVuZ3RoKTsKIH0KKworQXRvbWljU3RyaW5nIEF0b21pY1N0 cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhciogc3RyaW5nKQoreworICAgIGlmICghc3RyaW5nKQor ICAgICAgICByZXR1cm4gQXRvbWljU3RyaW5nKCk7CisKKyAgICByZXR1cm4gZnJvbVVURjgoc3Ry aW5nLCBzdHJsZW4oc3RyaW5nKSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0 IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29y ZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAppbmRleCBjZmFiZGU3Li5mMjgwNmY5IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAorKysgYi9KYXZhU2Ny aXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaApAQCAtMTA4LDYgKzEwOCw5IEBAIHB1Ymxp YzoKICAgICBvcGVyYXRvciBRU3RyaW5nKCkgY29uc3QgeyByZXR1cm4gbV9zdHJpbmc7IH0KICNl bmRpZgogCisgICAgc3RhdGljIEF0b21pY1N0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6 ZV90KTsKKyAgICBzdGF0aWMgQXRvbWljU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKKwog cHJpdmF0ZToKICAgICBTdHJpbmcgbV9zdHJpbmc7CiAgICAgCg== 67334 2010-09-12 05:06:43 -0700 2010-09-12 12:56:50 -0700 Patch 0001-AtomicString.patch text/plain 3030 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCBiZTcyNDhiLi5iMzIxZmVjIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTAtMDktMTEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHBhcm9nYS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVXNlIG5lYXJseSB0aGUgc2FtZSBpbXBsZW1lbnRh dGlvbiBhcyBpbiBTdHJpbmc6OmZyb21VVEY4LgorCisgICAgICAgICogd3RmL3RleHQvQXRvbWlj U3RyaW5nLmNwcDoKKyAgICAgICAgKFdURjo6QXRvbWljU3RyaW5nOjpmcm9tVVRGOCk6CisgICAg ICAgICogd3RmL3RleHQvQXRvbWljU3RyaW5nLmg6CisKIDIwMTAtMDktMTEgIFBhdHJpY2sgR2Fu c3RlcmVyICA8cGFyb2dhQHBhcm9nYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJp bmcuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcAppbmRleCAx OTgxMTcwLi5mZDUwYWY4IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9t aWNTdHJpbmcuY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5j cHAKQEAgLTI2LDkgKzI2LDEyIEBACiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRl IDx3dGYvVGhyZWFkaW5nLmg+CiAjaW5jbHVkZSA8d3RmL1dURlRocmVhZERhdGEuaD4KKyNpbmNs dWRlIDx3dGYvdW5pY29kZS9VVEY4Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCit1c2luZyBuYW1l c3BhY2UgVW5pY29kZTsKKwogQ09NUElMRV9BU1NFUlQoc2l6ZW9mKEF0b21pY1N0cmluZykgPT0g c2l6ZW9mKFN0cmluZyksIGF0b21pY19zdHJpbmdfYW5kX3N0cmluZ19tdXN0X2JlX3NhbWVfc2l6 ZSk7CiAKIGNsYXNzIEF0b21pY1N0cmluZ1RhYmxlIHsKQEAgLTI5Niw0ICsyOTksMzggQEAgQXRv bWljU3RyaW5nIEF0b21pY1N0cmluZzo6bG93ZXIoKSBjb25zdAogICAgIHJldHVybiBBdG9taWNT dHJpbmcobmV3SW1wbCk7CiB9CiAKK0F0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6OmZyb21VVEY4 KGNvbnN0IGNoYXIqIHN0cmluZ1N0YXJ0LCBzaXplX3QgbGVuZ3RoKQoreworICAgIGlmICghc3Ry aW5nU3RhcnQpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIC8vIFdlJ2xs IHVzZSBhIFN0cmluZ0ltcGwgYXMgYSBidWZmZXI7IGlmIHRoZSBzb3VyY2Ugc3RyaW5nIG9ubHkg Y29udGFpbnMgYXNjaWkgdGhpcyBzaG91bGQgYmUKKyAgICAvLyB0aGUgcmlnaHQgbGVuZ3RoLCBp ZiB0aGVyZSBhcmUgYW55IG11bHRpLWJ5dGUgc2VxdWVuY2VzIHRoaXMgYnVmZmVyIHdpbGwgYmUg dG9vIGxhcmdlLgorICAgIFVDaGFyKiBidWZmZXI7CisgICAgUmVmUHRyPFN0cmluZ0ltcGw+IHN0 cmluZ0J1ZmZlciA9IFN0cmluZ0ltcGw6OmNyZWF0ZVVuaW5pdGlhbGl6ZWQobGVuZ3RoLCBidWZm ZXIpOworICAgIFVDaGFyKiBidWZmZXJFbmQgPSBidWZmZXIgKyBsZW5ndGg7CisKKyAgICAvLyBU cnkgY29udmVydGluZyBpbnRvIHRoZSBidWZmZXIuCisgICAgY29uc3QgY2hhciogc3RyaW5nQ3Vy cmVudCA9IHN0cmluZ1N0YXJ0OworICAgIGlmIChjb252ZXJ0VVRGOFRvVVRGMTYoJnN0cmluZ0N1 cnJlbnQsIHN0cmluZ1N0YXJ0ICsgbGVuZ3RoLCAmYnVmZmVyLCBidWZmZXJFbmQpICE9IGNvbnZl cnNpb25PSykKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworCisgICAgLy8gc3RyaW5n QnVmZmVyIGlzIGZ1bGwgKHRoZSBpbnB1dCBtdXN0IGhhdmUgYmVlbiBhbGwgYXNjaWkpIHNvIGp1 c3QgcmV0dXJuIGl0IQorICAgIGlmIChidWZmZXIgPT0gYnVmZmVyRW5kKQorICAgICAgICByZXR1 cm4gQXRvbWljU3RyaW5nKHN0cmluZ0J1ZmZlci5nZXQoKSk7CisKKyAgICAvLyBzdHJpbmdCdWZm ZXIgc2VydmVkIGl0cyBwdXJwb3NlIGFzIGEgYnVmZmVyLCB0cnkgdG8gZmluZCBhIEF0b21pY1N0 cmluZy4KKyAgICB1bnNpZ25lZCB1dGYxNkxlbmd0aCA9IGJ1ZmZlciAtIHN0cmluZ0J1ZmZlci0+ Y2hhcmFjdGVycygpOworICAgIEFTU0VSVCh1dGYxNkxlbmd0aCA8IGxlbmd0aCk7CisgICAgcmV0 dXJuIEF0b21pY1N0cmluZyhzdHJpbmdCdWZmZXItPmNoYXJhY3RlcnMoKSwgdXRmMTZMZW5ndGgp OwogfQorCitBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpmcm9tVVRGOChjb25zdCBjaGFyKiBz dHJpbmcpCit7CisgICAgaWYgKCFzdHJpbmcpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmco KTsKKworICAgIHJldHVybiBmcm9tVVRGOChzdHJpbmcsIHN0cmxlbihzdHJpbmcpKTsKK30KKwor fSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9B dG9taWNTdHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oCmlu ZGV4IGNmYWJkZTcuLmYyODA2ZjkgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0 L0F0b21pY1N0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmlu Zy5oCkBAIC0xMDgsNiArMTA4LDkgQEAgcHVibGljOgogICAgIG9wZXJhdG9yIFFTdHJpbmcoKSBj b25zdCB7IHJldHVybiBtX3N0cmluZzsgfQogI2VuZGlmCiAKKyAgICBzdGF0aWMgQXRvbWljU3Ry aW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqLCBzaXplX3QpOworICAgIHN0YXRpYyBBdG9taWNTdHJp bmcgZnJvbVVURjgoY29uc3QgY2hhciopOworCiBwcml2YXRlOgogICAgIFN0cmluZyBtX3N0cmlu ZzsKICAgICAK 70357 2010-10-09 11:36:32 -0700 2010-11-13 05:44:55 -0800 Patch bug-45594.patch text/plain 14442 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3YWExZWEyLi5lZGZlZWYwIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjgg QEAKKzIwMTAtMTAtMDkgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlSGFzaEFuZExlbmd0 aCBjcmVhdGVzIGEgU3RyaW5nSGFzaCBvdXQgb2YgVVRGOCBpbnB1dCBkYXRhLCBjYWxjdWxhdGVz CisgICAgICAgIHRoZSBpbnB1dCBsZW5ndGggYW5kIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVU RjE2IGNvbnZlcnNhdGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQg aW4gYSBzcGVjaWFsaXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21p Y1N0cmluZy4KKworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiB3dGYv dGV4dC9BdG9taWNTdHJpbmcuY3BwOgorICAgICAgICAoV1RGOjplcXVhbCk6CisgICAgICAgIChX VEY6OmFkZFN0cmluZ0ltcGxJbnRvQnVmZmVyKToKKyAgICAgICAgKFdURjo6SGFzaEFuZFVURjhD aGFyYWN0ZXJzVHJhbnNsYXRvcjo6aGFzaCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hh cmFjdGVyc1RyYW5zbGF0b3I6OmVxdWFsKToKKyAgICAgICAgKFdURjo6SGFzaEFuZFVURjhDaGFy YWN0ZXJzVHJhbnNsYXRvcjo6dHJhbnNsYXRlKToKKyAgICAgICAgKFdURjo6QXRvbWljU3RyaW5n Ojpmcm9tVVRGOCk6CisgICAgICAgICogd3RmL3RleHQvQXRvbWljU3RyaW5nLmg6CisgICAgICAg ICogd3RmL3RleHQvU3RyaW5nSW1wbC5oOgorICAgICAgICAqIHd0Zi91bmljb2RlL1VURjguY3Bw OgorICAgICAgICAoV1RGOjpVbmljb2RlOjpjYWxjdWxhdGVIYXNoQW5kTGVuZ3RoKToKKyAgICAg ICAgKiB3dGYvdW5pY29kZS9VVEY4Lmg6CisKIDIwMTAtMTAtMDggIE1pY2hhZWwgU2Fib2ZmICA8 bXNhYm9mZkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRp ZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAgYi9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKaW5kZXggZjc3M2YwYi4uZGQ3YmU1YiAxMDA2NDQKLS0t IGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZXhwCisrKyBiL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLmV4cApAQCAtMzY3LDYgKzM2Nyw4IEBAIF9fWk4zV1RGMTJBdG9taWNT dHJpbmczYWRkRVBLdGoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmczYWRkRVBLdGpqCiBfX1pOM1dU RjEyQXRvbWljU3RyaW5nNGZpbmRFUEt0amoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmc0aW5pdEV2 CitfX1pOM1dURjEyQXRvbWljU3RyaW5nOGZyb21VVEY4RVBLYworX19aTjNXVEYxMkF0b21pY1N0 cmluZzhmcm9tVVRGOEVQS2NtCiBfX1pOM1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9FUzBfCiBf X1pOM1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9FUzBfUEtjCiBfX1pOM1dURjEyZGV0YWNoVGhy ZWFkRWoKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5j cHAgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwCmluZGV4IGM4MTQw ZDYuLmRkMjFiZWQgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0 cmluZy5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcApA QCAtMjYsOSArMjYsMTIgQEAKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0 Zi9UaHJlYWRpbmcuaD4KICNpbmNsdWRlIDx3dGYvV1RGVGhyZWFkRGF0YS5oPgorI2luY2x1ZGUg PHd0Zi91bmljb2RlL1VURjguaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKK3VzaW5nIG5hbWVzcGFj ZSBVbmljb2RlOworCiBDT01QSUxFX0FTU0VSVChzaXplb2YoQXRvbWljU3RyaW5nKSA9PSBzaXpl b2YoU3RyaW5nKSwgYXRvbWljX3N0cmluZ19hbmRfc3RyaW5nX211c3RfYmVfc2FtZV9zaXplKTsK IAogY2xhc3MgQXRvbWljU3RyaW5nVGFibGUgewpAQCAtODUsNyArODgsNyBAQCBzdHJ1Y3QgQ1N0 cmluZ1RyYW5zbGF0b3IgewogICAgICAgICAgICAgaWYgKGRbaV0gIT0gYykKICAgICAgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIHNbbGVuZ3RoXSA9 PSAwOworICAgICAgICByZXR1cm4gIXNbbGVuZ3RoXTsKICAgICB9CiAKICAgICBzdGF0aWMgdm9p ZCB0cmFuc2xhdGUoU3RyaW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBjaGFyKiBjb25zdCYgYywg dW5zaWduZWQgaGFzaCkKQEAgLTIwNiwxMiArMjA5LDc2IEBAIHN0cnVjdCBIYXNoQW5kQ2hhcmFj dGVyc1RyYW5zbGF0b3IgewogICAgIH0KIH07CiAKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3Rl cnMgeworICAgIHVuc2lnbmVkIGhhc2g7CisgICAgY29uc3QgY2hhciogY2hhcmFjdGVyczsKKyAg ICB1bnNpZ25lZCByYXdMZW5ndGg7CisgICAgdW5zaWduZWQgdXRmMTZMZW5ndGg7CisgICAgbXV0 YWJsZSBSZWZQdHI8U3RyaW5nSW1wbD4gc3RyaW5nOworfTsKKworc3RhdGljIGlubGluZSBib29s IGVxdWFsKFN0cmluZ0ltcGwqIHN0cmluZywgY29uc3QgY2hhciogY2hhcmFjdGVycywgdW5zaWdu ZWQgbGVuZ3RoKQoreworICAgIGlmIChzdHJpbmctPmxlbmd0aCgpICE9IGxlbmd0aCkKKyAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgY29uc3QgVUNoYXIqIHN0cmluZ0NoYXJhY3RlcnMgPSBz dHJpbmctPmNoYXJhY3RlcnMoKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpICE9IGxlbmd0 aDsgKytpKSB7CisgICAgICAgIGlmICgqc3RyaW5nQ2hhcmFjdGVycysrICE9ICpjaGFyYWN0ZXJz KyspCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgcmV0dXJuIHRydWU7 Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBhZGRTdHJpbmdJbXBsSW50b0J1ZmZlcihjb25zdCBI YXNoQW5kVVRGOENoYXJhY3RlcnMmIGJ1ZmZlcikKK3sKKyAgICBBU1NFUlQoIWJ1ZmZlci5zdHJp bmcpOworCisgICAgVUNoYXIqIGRhdGE7CisgICAgYnVmZmVyLnN0cmluZyA9IFN0cmluZ0ltcGw6 OmNyZWF0ZVVuaW5pdGlhbGl6ZWQoYnVmZmVyLnV0ZjE2TGVuZ3RoLCBkYXRhKTsKKworICAgIGNv bnN0IGNoYXIqIHNvdXJjZVN0YXJ0ID0gYnVmZmVyLmNoYXJhY3RlcnM7CisgICAgQ29udmVyc2lv blJlc3VsdCBjb252ZXJzaW9uUmVzdWx0ID0gY29udmVydFVURjhUb1VURjE2KCZzb3VyY2VTdGFy dCwgc291cmNlU3RhcnQgKyBidWZmZXIucmF3TGVuZ3RoLCAmZGF0YSwgZGF0YSArIGJ1ZmZlci51 dGYxNkxlbmd0aCk7CisgICAgQVNTRVJUX1VOVVNFRChjb252ZXJzaW9uUmVzdWx0LCBjb252ZXJz aW9uUmVzdWx0ID09IGNvbnZlcnNpb25PSyk7Cit9CisKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJh Y3RlcnNUcmFuc2xhdG9yIHsKKyAgICBzdGF0aWMgdW5zaWduZWQgaGFzaChjb25zdCBIYXNoQW5k VVRGOENoYXJhY3RlcnMmIGJ1ZmZlcikKKyAgICB7CisgICAgICAgIHJldHVybiBidWZmZXIuaGFz aDsKKyAgICB9CisKKyAgICBzdGF0aWMgYm9vbCBlcXVhbChTdHJpbmdJbXBsKiBjb25zdCYgc3Ry aW5nLCBjb25zdCBIYXNoQW5kVVRGOENoYXJhY3RlcnMmIGJ1ZmZlcikKKyAgICB7CisgICAgICAg IGlmIChidWZmZXIucmF3TGVuZ3RoID09IGJ1ZmZlci51dGYxNkxlbmd0aCkgLy8gYnVmZmVyIGNv bnRhaW5zIG9ubHkgQVNDSUkgY2hhcmFjdGVycy4KKyAgICAgICAgICAgIHJldHVybiBXVEY6OmVx dWFsKHN0cmluZywgYnVmZmVyLmNoYXJhY3RlcnMsIGJ1ZmZlci5yYXdMZW5ndGgpOworCisgICAg ICAgIGFkZFN0cmluZ0ltcGxJbnRvQnVmZmVyKGJ1ZmZlcik7CisgICAgICAgIHJldHVybiBXVEY6 OmVxdWFsKHN0cmluZywgYnVmZmVyLnN0cmluZy0+Y2hhcmFjdGVycygpLCBidWZmZXIuc3RyaW5n LT5sZW5ndGgoKSk7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgdHJhbnNsYXRlKFN0cmluZ0lt cGwqJiBsb2NhdGlvbiwgY29uc3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIsIHVuc2ln bmVkIGhhc2gpCisgICAgeworICAgICAgICBpZiAoYnVmZmVyLnJhd0xlbmd0aCA9PSBidWZmZXIu dXRmMTZMZW5ndGgpIC8vIGJ1ZmZlciBjb250YWlucyBvbmx5IEFTQ0lJIGNoYXJhY3RlcnMuCisg ICAgICAgICAgICBsb2NhdGlvbiA9IFN0cmluZ0ltcGw6OmNyZWF0ZShidWZmZXIuY2hhcmFjdGVy cywgYnVmZmVyLnJhd0xlbmd0aCkucmVsZWFzZVJlZigpOworICAgICAgICBlbHNlIHsKKyAgICAg ICAgICAgIGlmICghYnVmZmVyLnN0cmluZykKKyAgICAgICAgICAgICAgICBhZGRTdHJpbmdJbXBs SW50b0J1ZmZlcihidWZmZXIpOworICAgICAgICAgICAgbG9jYXRpb24gPSBidWZmZXIuc3RyaW5n LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCk7CisgICAgICAgIH0KKworICAgICAgICBsb2NhdGlvbi0+ c2V0SGFzaChoYXNoKTsKKyAgICAgICAgbG9jYXRpb24tPnNldElzQXRvbWljKHRydWUpOworICAg IH0KK307CisKIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3RyaW5nOjphZGQoY29uc3Qg VUNoYXIqIHMsIHVuc2lnbmVkIGxlbmd0aCkKIHsKICAgICBpZiAoIXMpCiAgICAgICAgIHJldHVy biAwOwogCi0gICAgaWYgKGxlbmd0aCA9PSAwKQorICAgIGlmICghbGVuZ3RoKQogICAgICAgICBy ZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHkoKTsKICAgICAKICAgICBVQ2hhckJ1ZmZlciBidWYgPSB7 IHMsIGxlbmd0aCB9OyAKQEAgLTIyNyw3ICsyOTQsNyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+ IEF0b21pY1N0cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2ln bgogICAgIEFTU0VSVChzKTsKICAgICBBU1NFUlQoZXhpc3RpbmdIYXNoKTsKIAotICAgIGlmIChs ZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6 OmVtcHR5KCk7CiAgICAgCiAgICAgSGFzaEFuZENoYXJhY3RlcnMgYnVmZmVyID0geyBleGlzdGlu Z0hhc2gsIHMsIGxlbmd0aCB9OyAKQEAgLTI0Niw3ICszMTMsNyBAQCBQYXNzUmVmUHRyPFN0cmlu Z0ltcGw+IEF0b21pY1N0cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzKQogICAgIHdoaWxlIChzW2xl bmd0aF0gIT0gVUNoYXIoMCkpCiAgICAgICAgIGxlbmd0aCsrOwogCi0gICAgaWYgKGxlbmd0aCA9 PSAwKQorICAgIGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHko KTsKIAogICAgIFVDaGFyQnVmZmVyIGJ1ZiA9IHtzLCBsZW5ndGh9OyAKQEAgLTI2Miw3ICszMjks NyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6YWRkU2xvd0Nhc2UoU3Ry aW5nSW1wbCogcikKICAgICBpZiAoIXIgfHwgci0+aXNBdG9taWMoKSkKICAgICAgICAgcmV0dXJu IHI7CiAKLSAgICBpZiAoci0+bGVuZ3RoKCkgPT0gMCkKKyAgICBpZiAoIXItPmxlbmd0aCgpKQog ICAgICAgICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIAogICAgIFN0cmluZ0ltcGwqIHJl c3VsdCA9ICpzdHJpbmdUYWJsZSgpLmFkZChyKS5maXJzdDsKQEAgLTI3Niw3ICszNDMsNyBAQCBB dG9taWNTdHJpbmdJbXBsKiBBdG9taWNTdHJpbmc6OmZpbmQoY29uc3QgVUNoYXIqIHMsIHVuc2ln bmVkIGxlbmd0aCwgdW5zaWduZWQgZQogICAgIEFTU0VSVChzKTsKICAgICBBU1NFUlQoZXhpc3Rp bmdIYXNoKTsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAg ICAgcmV0dXJuIHN0YXRpY19jYXN0PEF0b21pY1N0cmluZ0ltcGwqPihTdHJpbmdJbXBsOjplbXB0 eSgpKTsKIAogICAgIEhhc2hBbmRDaGFyYWN0ZXJzIGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBz LCBsZW5ndGggfTsgCkBAIC0yOTAsNyArMzU3LDcgQEAgdm9pZCBBdG9taWNTdHJpbmc6OnJlbW92 ZShTdHJpbmdJbXBsKiByKQogewogICAgIHN0cmluZ1RhYmxlKCkucmVtb3ZlKHIpOwogfQotICAg IAorCiBBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpsb3dlcigpIGNvbnN0CiB7CiAgICAgLy8g Tm90ZTogVGhpcyBpcyBhIGhvdCBmdW5jdGlvbiBpbiB0aGUgRHJvbWFlbyBiZW5jaG1hcmsuCkBA IC0zMDEsNCArMzY4LDU1IEBAIEF0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6Omxvd2VyKCkgY29u c3QKICAgICByZXR1cm4gQXRvbWljU3RyaW5nKG5ld0ltcGwpOwogfQogCitBdG9taWNTdHJpbmcg QXRvbWljU3RyaW5nOjpmcm9tVVRGOChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzLCBzaXplX3QgbGVu Z3RoKQoreworICAgIGlmICghY2hhcmFjdGVycykKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmlu ZygpOworCisgICAgaWYgKCFsZW5ndGgpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoU3Ry aW5nSW1wbDo6ZW1wdHkoKSk7CisKKyAgICAvLyBXZSdsbCB1c2UgYSBTdHJpbmdJbXBsIGFzIGEg YnVmZmVyOyBpZiB0aGUgc291cmNlIHN0cmluZyBvbmx5IGNvbnRhaW5zIGFzY2lpIHRoaXMgc2hv dWxkIGJlCisgICAgLy8gdGhlIHJpZ2h0IGxlbmd0aCwgaWYgdGhlcmUgYXJlIGFueSBtdWx0aS1i eXRlIHNlcXVlbmNlcyB0aGlzIGJ1ZmZlciB3aWxsIGJlIHRvbyBsYXJnZS4KKyAgICBVQ2hhciog YnVmZmVyOworICAgIFJlZlB0cjxTdHJpbmdJbXBsPiBzdHJpbmdCdWZmZXIgPSBTdHJpbmdJbXBs OjpjcmVhdGVVbmluaXRpYWxpemVkKGxlbmd0aCwgYnVmZmVyKTsKKyAgICBVQ2hhciogYnVmZmVy RW5kID0gYnVmZmVyICsgbGVuZ3RoOworCisgICAgLy8gVHJ5IGNvbnZlcnRpbmcgaW50byB0aGUg YnVmZmVyLgorICAgIGlmIChjb252ZXJ0VVRGOFRvVVRGMTYoJmNoYXJhY3RlcnMsIGNoYXJhY3Rl cnMgKyBsZW5ndGgsICZidWZmZXIsIGJ1ZmZlckVuZCkgIT0gY29udmVyc2lvbk9LKQorICAgICAg ICByZXR1cm4gQXRvbWljU3RyaW5nKCk7CisKKyAgICAvLyBzdHJpbmdCdWZmZXIgaXMgZnVsbCAo dGhlIGlucHV0IG11c3QgaGF2ZSBiZWVuIGFsbCBhc2NpaSksIHVzZSB0aGUgc3RyaW5nLgorICAg IGlmIChidWZmZXIgPT0gYnVmZmVyRW5kKQorICAgICAgICByZXR1cm4gQXRvbWljU3RyaW5nKHN0 cmluZ0J1ZmZlci5nZXQoKSk7CisKKyAgICAvLyBzdHJpbmdCdWZmZXIgc2VydmVkIGl0cyBwdXJw b3NlIGFzIGEgYnVmZmVyLCBhZGQgd2l0aCBjaGFyYWN0ZXJzIGFuZCBsZW5ndGguCisgICAgdW5z aWduZWQgdXRmMTZMZW5ndGggPSBidWZmZXIgLSBzdHJpbmdCdWZmZXItPmNoYXJhY3RlcnMoKTsK KyAgICBBU1NFUlQodXRmMTZMZW5ndGggPCBsZW5ndGgpOworICAgIHJldHVybiBBdG9taWNTdHJp bmcoc3RyaW5nQnVmZmVyLT5jaGFyYWN0ZXJzKCksIHV0ZjE2TGVuZ3RoKTsKIH0KKworQXRvbWlj U3RyaW5nIEF0b21pY1N0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhciogY2hhcmFjdGVycykKK3sK KyAgICBpZiAoIWNoYXJhY3RlcnMpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKwor ICAgIEhhc2hBbmRVVEY4Q2hhcmFjdGVycyBidWZmZXI7CisgICAgYnVmZmVyLmNoYXJhY3RlcnMg PSBjaGFyYWN0ZXJzOworCisgICAgaWYgKCFjYWxjdWxhdGVIYXNoQW5kTGVuZ3RoKGNoYXJhY3Rl cnMsIGJ1ZmZlci5oYXNoLCBidWZmZXIucmF3TGVuZ3RoLCBidWZmZXIudXRmMTZMZW5ndGgpKQor ICAgICAgICByZXR1cm4gQXRvbWljU3RyaW5nKCk7IC8vIGNoYXJhY3RlcnMgY29udGFpbnMgaW52 YWxpZCBVVEYtOCBjaGFyYWN0ZXJzLgorCisgICAgaWYgKCFidWZmZXIucmF3TGVuZ3RoKQorICAg ICAgICByZXR1cm4gQXRvbWljU3RyaW5nKFN0cmluZ0ltcGw6OmVtcHR5KCkpOworCisgICAgcGFp cjxIYXNoU2V0PFN0cmluZ0ltcGwqPjo6aXRlcmF0b3IsIGJvb2w+IGFkZFJlc3VsdCA9IHN0cmlu Z1RhYmxlKCkuYWRkPEhhc2hBbmRVVEY4Q2hhcmFjdGVycywgSGFzaEFuZFVURjhDaGFyYWN0ZXJz VHJhbnNsYXRvcj4oYnVmZmVyKTsKKworICAgIC8vIElmIHRoZSBzdHJpbmcgaXMgbmV3bHktdHJh bnNsYXRlZCwgdGhlbiB3ZSBuZWVkIHRvIGFkb3B0IGl0LgorICAgIC8vIFRoZSBib29sZWFuIGlu IHRoZSBwYWlyIHRlbGxzIHVzIGlmIHRoYXQgaXMgc28uCisgICAgQXRvbWljU3RyaW5nIGF0b21p Y1N0cmluZzsKKyAgICBhdG9taWNTdHJpbmcubV9zdHJpbmcgPSBhZGRSZXN1bHQuc2Vjb25kID8g YWRvcHRSZWYoKmFkZFJlc3VsdC5maXJzdCkgOiAqYWRkUmVzdWx0LmZpcnN0OworICAgIHJldHVy biBhdG9taWNTdHJpbmc7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2 YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYv dGV4dC9BdG9taWNTdHJpbmcuaAppbmRleCAwNmU2M2Y0Li4yMjE5MDcxIDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29y ZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaApAQCAtMTA4LDYgKzEwOCw5IEBAIHB1YmxpYzoKICAg ICBvcGVyYXRvciBRU3RyaW5nKCkgY29uc3QgeyByZXR1cm4gbV9zdHJpbmc7IH0KICNlbmRpZgog CisgICAgc3RhdGljIEF0b21pY1N0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6ZV90KTsK KyAgICBzdGF0aWMgQXRvbWljU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKKwogcHJpdmF0 ZToKICAgICBTdHJpbmcgbV9zdHJpbmc7CiAgICAgCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29y ZS93dGYvdGV4dC9TdHJpbmdJbXBsLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJ bXBsLmgKaW5kZXggNGRjZTU2Zi4uMDQ2NjNmMSAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUv d3RmL3RleHQvU3RyaW5nSW1wbC5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmlu Z0ltcGwuaApAQCAtNTMsNiArNTMsNyBAQCBuYW1lc3BhY2UgV1RGIHsKIAogc3RydWN0IENTdHJp bmdUcmFuc2xhdG9yOwogc3RydWN0IEhhc2hBbmRDaGFyYWN0ZXJzVHJhbnNsYXRvcjsKK3N0cnVj dCBIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOwogc3RydWN0IFVDaGFyQnVmZmVyVHJh bnNsYXRvcjsKIAogZW51bSBUZXh0Q2FzZVNlbnNpdGl2aXR5IHsgVGV4dENhc2VTZW5zaXRpdmUs IFRleHRDYXNlSW5zZW5zaXRpdmUgfTsKQEAgLTY2LDYgKzY3LDcgQEAgY2xhc3MgU3RyaW5nSW1w bCA6IHB1YmxpYyBTdHJpbmdJbXBsQmFzZSB7CiAgICAgZnJpZW5kIHN0cnVjdCBKU0M6OklkZW50 aWZpZXJVQ2hhckJ1ZmZlclRyYW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6OkNTdHJp bmdUcmFuc2xhdG9yOwogICAgIGZyaWVuZCBzdHJ1Y3QgV1RGOjpIYXNoQW5kQ2hhcmFjdGVyc1Ry YW5zbGF0b3I7CisgICAgZnJpZW5kIHN0cnVjdCBXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1Ry YW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6OlVDaGFyQnVmZmVyVHJhbnNsYXRvcjsK ICAgICBmcmllbmQgY2xhc3MgQXRvbWljU3RyaW5nSW1wbDsKIHByaXZhdGU6CmRpZmYgLS1naXQg YS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0 Zi91bmljb2RlL1VURjguY3BwCmluZGV4IDQwYzU2MDkuLjczMzE3ZGUgMTAwNjQ0Ci0tLSBhL0ph dmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0 Zi91bmljb2RlL1VURjguY3BwCkBAIC0yNSw2ICsyNSw3IEBACiAKICNpbmNsdWRlICJjb25maWcu aCIKICNpbmNsdWRlICJVVEY4LmgiCisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAK IG5hbWVzcGFjZSBXVEYgewogbmFtZXNwYWNlIFVuaWNvZGUgewpAQCAtMzAwLDUgKzMwMSw2MyBA QCBDb252ZXJzaW9uUmVzdWx0IGNvbnZlcnRVVEY4VG9VVEYxNigKICAgICByZXR1cm4gcmVzdWx0 OwogfQogCitib29sIGNhbGN1bGF0ZUhhc2hBbmRMZW5ndGgoY29uc3QgY2hhciogc291cmNlLCB1 bnNpZ25lZCYgaGFzaCwgdW5zaWduZWQmIHJhd0xlbmd0aCwgdW5zaWduZWQmIHV0ZjE2TGVuZ3Ro KQoreworICAgIGlmICghc291cmNlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBXVEY6 OlN0cmluZ0hhc2hlciBzdHJpbmdIYXNoZXI7CisgICAgcmF3TGVuZ3RoID0gMDsKKyAgICB1dGYx Nkxlbmd0aCA9IDA7CisKKyAgICB3aGlsZSAoKnNvdXJjZSkgeworICAgICAgICBpZiAoISgqc291 cmNlICYgMHg4MCkpIHsKKyAgICAgICAgICAgIHN0cmluZ0hhc2hlci5hZGRDaGFyYWN0ZXIoKnNv dXJjZSsrKTsKKyAgICAgICAgICAgIHJhd0xlbmd0aCsrOworICAgICAgICAgICAgdXRmMTZMZW5n dGgrKzsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgVUNoYXIz MiBjaCA9IDA7CisgICAgICAgIGludCB1dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2Vx dWVuY2VMZW5ndGgoKnNvdXJjZSk7CisKKyAgICAgICAgLy8gVGhlIGNhc2VzIGFsbCBmYWxsIHRo cm91Z2guCisgICAgICAgIHN3aXRjaCAodXRmOFNlcXVlbmNlTGVuZ3RoKSB7CisgICAgICAgICAg ICBjYXNlIDY6IGNoICs9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+KCpzb3VyY2UrKyk7IGNo IDw8PSA2OyBpZiAoISpzb3VyY2UpIHJldHVybiBmYWxzZTsgLy8gcmVtZW1iZXIsIGlsbGVnYWwg VVRGLTgKKyAgICAgICAgICAgIGNhc2UgNTogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hh cj4oKnNvdXJjZSsrKTsgY2ggPDw9IDY7IGlmICghKnNvdXJjZSkgcmV0dXJuIGZhbHNlOyAvLyBy ZW1lbWJlciwgaWxsZWdhbCBVVEYtOAorICAgICAgICAgICAgY2FzZSA0OiBjaCArPSBzdGF0aWNf Y2FzdDx1bnNpZ25lZCBjaGFyPigqc291cmNlKyspOyBjaCA8PD0gNjsgaWYgKCEqc291cmNlKSBy ZXR1cm4gZmFsc2U7CisgICAgICAgICAgICBjYXNlIDM6IGNoICs9IHN0YXRpY19jYXN0PHVuc2ln bmVkIGNoYXI+KCpzb3VyY2UrKyk7IGNoIDw8PSA2OyBpZiAoISpzb3VyY2UpIHJldHVybiBmYWxz ZTsKKyAgICAgICAgICAgIGNhc2UgMjogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4o KnNvdXJjZSsrKTsgY2ggPDw9IDY7IGlmICghKnNvdXJjZSkgcmV0dXJuIGZhbHNlOworICAgICAg ICAgICAgY2FzZSAxOiBjaCArPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPigqc291cmNlKysp OworICAgICAgICB9CisKKyAgICAgICAgLy8gRG8gdGhpcyBjaGVjayB3aGV0aGVyIGxlbmllbnQg b3Igc3RyaWN0CisgICAgICAgIGlmICghaXNMZWdhbFVURjgocmVpbnRlcnByZXRfY2FzdDxjb25z dCB1bnNpZ25lZCBjaGFyKj4oc291cmNlIC0gdXRmOFNlcXVlbmNlTGVuZ3RoKSwgdXRmOFNlcXVl bmNlTGVuZ3RoKSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICBjaCAtPSBv ZmZzZXRzRnJvbVVURjhbdXRmOFNlcXVlbmNlTGVuZ3RoIC0gMV07CisgICAgICAgIHJhd0xlbmd0 aCArPSB1dGY4U2VxdWVuY2VMZW5ndGg7CisKKyAgICAgICAgQVNTRVJUKGNoID49IDB4ODApOwor CisgICAgICAgIGlmIChjaCA8PSAweEZGRkYpIHsKKyAgICAgICAgICAgIC8vIFVURi0xNiBzdXJy b2dhdGUgdmFsdWVzIGFyZSBpbGxlZ2FsIGluIFVURi0zMgorICAgICAgICAgICAgaWYgKGNoID49 IDB4RDgwMCAmJiBjaCA8PSAweERGRkYpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFkZENoYXJhY3RlcihzdGF0aWNfY2FzdDxVQ2hhcj4o Y2gpKTsgLy8gbm9ybWFsIGNhc2UKKyAgICAgICAgICAgIHV0ZjE2TGVuZ3RoKys7CisgICAgICAg IH0gZWxzZSBpZiAoY2ggPD0gMHgxMEZGRkYpIHsKKyAgICAgICAgICAgIGNoIC09IDB4MDAxMDAw MFVMOworICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFkZENoYXJhY3RlcnMoc3RhdGljX2Nhc3Q8 VUNoYXI+KChjaCA+PiAxMCkgKyAweEQ4MDApLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgc3RhdGljX2Nhc3Q8VUNoYXI+KChjaCAmIDB4MDNGRikgKyAweERDMDApKTsK KyAgICAgICAgICAgIHV0ZjE2TGVuZ3RoICs9IDI7CisgICAgICAgIH0gZWxzZQorICAgICAgICAg ICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIGhhc2ggPSBzdHJpbmdIYXNoZXIuaGFzaCgp OworICAgIHJldHVybiB0cnVlOwogfQotfQorCit9IC8vIG5hbWVzcGFjZSBVbmljb2RlCit9IC8v IG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VU RjguaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguaAppbmRleCBhNWVkOTNlLi42 MzRlMDhiIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgKKysr IGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCkBAIC02OSw2ICs2OSw4IEBAIG5h bWVzcGFjZSBXVEYgewogICAgIENvbnZlcnNpb25SZXN1bHQgY29udmVydFVURjE2VG9VVEY4KAog ICAgICAgICAgICAgICAgICAgICBjb25zdCBVQ2hhcioqIHNvdXJjZVN0YXJ0LCBjb25zdCBVQ2hh ciogc291cmNlRW5kLCAKICAgICAgICAgICAgICAgICAgICAgY2hhcioqIHRhcmdldFN0YXJ0LCBj aGFyKiB0YXJnZXRFbmQsIGJvb2wgc3RyaWN0ID0gdHJ1ZSk7CisKKyAgICBib29sIGNhbGN1bGF0 ZUhhc2hBbmRMZW5ndGgoY29uc3QgY2hhciogcmF3RGF0YSwgdW5zaWduZWQmIGhhc2gsIHVuc2ln bmVkJiByYXdMZW5ndGgsIHVuc2lnbmVkJiB1dGYxNkxlbmd0aCk7CiAgIH0KIH0KIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjYzRkYTYz Li5kZDFhZGVkIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTEwLTA5ICBQYXRyaWNrIEdhbnN0ZXJlciAg PHBhcm9nYUB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEFkZCBBdG9taWNTdHJpbmc6OmZyb21VVEY4CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTU5NAorCisgICAgICAgIFVzZSBBdG9t aWNTdHJpbmc6OmZyb21VVEY4IGRpcmVjdGx5IGluIHRoZSBsaWJ4bWwyIHBhcnNlci4KKworICAg ICAgICAqIGRvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6dG9BdG9taWNTdHJpbmcpOgorCiAyMDEwLTEwLTA5ICBQcmF0aWsgU29sYW5raSAgPHBzb2xh bmtpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4gQmVybnN0ZWluLgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCBiL1dlYkNv cmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKaW5kZXggYzAxYTU3ZS4uZmI3MTlh OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAor KysgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCkBAIC02ODYsMTQg KzY4NiwxMiBAQCBzdGF0aWMgaW5saW5lIFN0cmluZyB0b1N0cmluZyhjb25zdCB4bWxDaGFyKiBz dHJpbmcpCiAKIHN0YXRpYyBpbmxpbmUgQXRvbWljU3RyaW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0 IHhtbENoYXIqIHN0cmluZywgc2l6ZV90IHNpemUpCiB7Ci0gICAgLy8gRklYTUU6IFVzZSBBdG9t aWNTdHJpbmc6OmZyb21VVEY4LgotICAgIHJldHVybiBBdG9taWNTdHJpbmcodG9TdHJpbmcoc3Ry aW5nLCBzaXplKSk7CisgICAgcmV0dXJuIEF0b21pY1N0cmluZzo6ZnJvbVVURjgocmVpbnRlcnBy ZXRfY2FzdDxjb25zdCBjaGFyKj4oc3RyaW5nKSwgc2l6ZSk7CiB9CiAKIHN0YXRpYyBpbmxpbmUg QXRvbWljU3RyaW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0cmluZykKIHsKLSAg ICAvLyBGSVhNRTogVXNlIEF0b21pY1N0cmluZzo6ZnJvbVVURjguCi0gICAgcmV0dXJuIEF0b21p Y1N0cmluZyh0b1N0cmluZyhzdHJpbmcpKTsKKyAgICByZXR1cm4gQXRvbWljU3RyaW5nOjpmcm9t VVRGOChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIqPihzdHJpbmcpKTsKIH0KIAogc3RydWN0 IF94bWxTQVgyTmFtZXNwYWNlIHsK 73819 2010-11-13 05:44:55 -0800 2010-12-01 06:35:27 -0800 Patch bug45594d.patch text/plain 19184 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCAxMjBhMmZkLi5mMTYyMGIyIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQg QEAKKzIwMTAtMTEtMTMgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlSGFzaEZyb21VVEY4 IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisgICAgICAg IGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZlcnNhdGlv biBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVjaWFsaXpl ZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4KKworICAg ICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiB3dGYvdGV4dC9BdG9taWNTdHJp bmcuY3BwOgorICAgICAgICAoV1RGOjpDU3RyaW5nVHJhbnNsYXRvcjo6ZXF1YWwpOgorICAgICAg ICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjpoYXNoKToKKyAgICAgICAg KFdURjo6SGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNsYXRvcjo6ZXF1YWwpOgorICAgICAgICAo V1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjp0cmFuc2xhdGUpOgorICAgICAg ICAoV1RGOjpBdG9taWNTdHJpbmc6OmFkZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6 YWRkU2xvd0Nhc2UpOgorICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmZpbmQpOgorICAgICAg ICAoV1RGOjpBdG9taWNTdHJpbmc6OmZyb21VVEY4KToKKyAgICAgICAgKiB3dGYvdGV4dC9BdG9t aWNTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdJbXBsLmg6CisgICAgICAgICog d3RmL3RleHQvV1RGU3RyaW5nLmg6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRGOC5jcHA6Cisg ICAgICAgIChXVEY6OlVuaWNvZGU6OnJlYWRVVEY4U2VxdWVuY2UpOgorICAgICAgICAoV1RGOjpV bmljb2RlOjpjb252ZXJ0VVRGOFRvVVRGMTYpOgorICAgICAgICAoV1RGOjpVbmljb2RlOjpjYWxj dWxhdGVIYXNoRnJvbVVURjgpOgorICAgICAgICAoV1RGOjpVbmljb2RlOjplcXVhbFVURjgpOgor ICAgICAgICAqIHd0Zi91bmljb2RlL1VURjguaDoKKwogMjAxMC0xMS0xMiAgQW5kZXJzIENhcmxz c29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gUm9i ZW4uCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAgYi9KYXZh U2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKaW5kZXggMzcxNWE0My4uNGE2NGI1YiAxMDA2 NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZXhwCisrKyBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cApAQCAtMzcxLDYgKzM3MSw4IEBAIF9fWk4zV1RGMTJB dG9taWNTdHJpbmczYWRkRVBLdGoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmczYWRkRVBLdGpqCiBf X1pOM1dURjEyQXRvbWljU3RyaW5nNGZpbmRFUEt0amoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmc0 aW5pdEV2CitfX1pOM1dURjEyQXRvbWljU3RyaW5nOGZyb21VVEY4RVBLYworX19aTjNXVEYxMkF0 b21pY1N0cmluZzhmcm9tVVRGOEVQS2NtCiBfX1pOM1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9F UzBfCiBfX1pOM1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9FUzBfUEtjCiBfX1pOM1dURjEyZGV0 YWNoVGhyZWFkRWoKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGExZTFjNWMuLmI0MGQ3NGUgMTAwNjQ0Ci0t LSBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagpAQCAtMjQ0Niw2ICsyNDQ2LDcgQEAKIAkJCWlzYSA9IFBCWFByb2plY3Q7CiAJCQli dWlsZENvbmZpZ3VyYXRpb25MaXN0ID0gMTQ5QzI3NzEwODkwMkFGRTAwOEE5RUZDIC8qIEJ1aWxk IGNvbmZpZ3VyYXRpb24gbGlzdCBmb3IgUEJYUHJvamVjdCAiSmF2YVNjcmlwdENvcmUiICovOwog CQkJY29tcGF0aWJpbGl0eVZlcnNpb24gPSAiWGNvZGUgMi40IjsKKwkJCWRldmVsb3BtZW50UmVn aW9uID0gRW5nbGlzaDsKIAkJCWhhc1NjYW5uZWRGb3JFbmNvZGluZ3MgPSAxOwogCQkJa25vd25S ZWdpb25zID0gKAogCQkJCUVuZ2xpc2gsCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYv dGV4dC9BdG9taWNTdHJpbmcuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3Ry aW5nLmNwcAppbmRleCBjNDlhODM3Li41ZWJmNjkzIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0 L0F0b21pY1N0cmluZy5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAy MDA0LCAyMDA1LCAyMDA2LCAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRyaWNrIEdhbnN0ZXJlciA8cGFyb2dhQHBhcm9n YS5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTI2LDkgKzI3LDEyIEBACiAjaW5jbHVkZSA8 d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAjaW5jbHVkZSA8d3Rm L1dURlRocmVhZERhdGEuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9VVEY4Lmg+CiAKIG5hbWVz cGFjZSBXVEYgewogCit1c2luZyBuYW1lc3BhY2UgVW5pY29kZTsKKwogQ09NUElMRV9BU1NFUlQo c2l6ZW9mKEF0b21pY1N0cmluZykgPT0gc2l6ZW9mKFN0cmluZyksIGF0b21pY19zdHJpbmdfYW5k X3N0cmluZ19tdXN0X2JlX3NhbWVfc2l6ZSk7CiAKIGNsYXNzIEF0b21pY1N0cmluZ1RhYmxlIHsK QEAgLTg1LDcgKzg5LDcgQEAgc3RydWN0IENTdHJpbmdUcmFuc2xhdG9yIHsKICAgICAgICAgICAg IGlmIChkW2ldICE9IGMpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICB9 Ci0gICAgICAgIHJldHVybiBzW2xlbmd0aF0gPT0gMDsKKyAgICAgICAgcmV0dXJuICFzW2xlbmd0 aF07CiAgICAgfQogCiAgICAgc3RhdGljIHZvaWQgdHJhbnNsYXRlKFN0cmluZ0ltcGwqJiBsb2Nh dGlvbiwgY29uc3QgY2hhciogY29uc3QmIGMsIHVuc2lnbmVkIGhhc2gpCkBAIC0yMDYsMTIgKzIx MCw0NCBAQCBzdHJ1Y3QgSGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yIHsKICAgICB9CiB9Owog CitzdHJ1Y3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzIHsKKyAgICB1bnNpZ25lZCBoYXNoOworICAg IGNvbnN0IGNoYXIqIGNoYXJhY3RlcnM7CisgICAgdW5zaWduZWQgbGVuZ3RoOworICAgIHVuc2ln bmVkIHV0ZjE2TGVuZ3RoOworfTsKKworc3RydWN0IEhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5z bGF0b3IgeworICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEhhc2hBbmRVVEY4Q2hhcmFj dGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGJ1ZmZlci5oYXNoOworICAgIH0K KworICAgIHN0YXRpYyBib29sIGVxdWFsKFN0cmluZ0ltcGwqIGNvbnN0JiBzdHJpbmcsIGNvbnN0 IEhhc2hBbmRVVEY4Q2hhcmFjdGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGVx dWFsVVRGOChzdHJpbmctPmNoYXJhY3RlcnMoKSwgc3RyaW5nLT5jaGFyYWN0ZXJzKCkgKyBzdHJp bmctPmxlbmd0aCgpLCBidWZmZXIuY2hhcmFjdGVycywgYnVmZmVyLmNoYXJhY3RlcnMgKyBidWZm ZXIubGVuZ3RoKTsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9pZCB0cmFuc2xhdGUoU3RyaW5nSW1w bComIGxvY2F0aW9uLCBjb25zdCBIYXNoQW5kVVRGOENoYXJhY3RlcnMmIGJ1ZmZlciwgdW5zaWdu ZWQgaGFzaCkKKyAgICB7CisgICAgICAgIFVDaGFyICp0YXJnZXQ7CisgICAgICAgIGxvY2F0aW9u ID0gU3RyaW5nSW1wbDo6Y3JlYXRlVW5pbml0aWFsaXplZChidWZmZXIudXRmMTZMZW5ndGgsIHRh cmdldCkucmVsZWFzZVJlZigpOworCisgICAgICAgIGNvbnN0IGNoYXIqIHNvdXJjZSA9IGJ1ZmZl ci5jaGFyYWN0ZXJzOworICAgICAgICBpZiAoY29udmVydFVURjhUb1VURjE2KCZzb3VyY2UsIHNv dXJjZSArIGJ1ZmZlci5sZW5ndGgsICZ0YXJnZXQsIHRhcmdldCArIGJ1ZmZlci51dGYxNkxlbmd0 aCkgIT0gY29udmVyc2lvbk9LKQorICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisK KyAgICAgICAgbG9jYXRpb24tPnNldEhhc2goaGFzaCk7CisgICAgICAgIGxvY2F0aW9uLT5zZXRJ c0F0b21pYyh0cnVlKTsKKyAgICB9Cit9OworCiBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21p Y1N0cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgpCiB7CiAgICAgaWYg KCFzKQogICAgICAgICByZXR1cm4gMDsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAo IWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAgICAgCiAgICAg VUNoYXJCdWZmZXIgYnVmID0geyBzLCBsZW5ndGggfTsgCkBAIC0yMjcsNyArMjYzLDcgQEAgUGFz c1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFkZChjb25zdCBVQ2hhciogcywgdW5z aWduZWQgbGVuZ3RoLCB1bnNpZ24KICAgICBBU1NFUlQocyk7CiAgICAgQVNTRVJUKGV4aXN0aW5n SGFzaCk7CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAgaWYgKCFsZW5ndGgpCiAgICAgICAg IHJldHVybiBTdHJpbmdJbXBsOjplbXB0eSgpOwogICAgIAogICAgIEhhc2hBbmRDaGFyYWN0ZXJz IGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBzLCBsZW5ndGggfTsgCkBAIC0yNDYsNyArMjgyLDcg QEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFkZChjb25zdCBVQ2hhciog cykKICAgICB3aGlsZSAoc1tsZW5ndGhdICE9IFVDaGFyKDApKQogICAgICAgICBsZW5ndGgrKzsK IAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJu IFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAKICAgICBVQ2hhckJ1ZmZlciBidWYgPSB7cywgbGVuZ3Ro fTsgCkBAIC0yNjIsNyArMjk4LDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJp bmc6OmFkZFNsb3dDYXNlKFN0cmluZ0ltcGwqIHIpCiAgICAgaWYgKCFyIHx8IHItPmlzQXRvbWlj KCkpCiAgICAgICAgIHJldHVybiByOwogCi0gICAgaWYgKHItPmxlbmd0aCgpID09IDApCisgICAg aWYgKCFyLT5sZW5ndGgoKSkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAK ICAgICBTdHJpbmdJbXBsKiByZXN1bHQgPSAqc3RyaW5nVGFibGUoKS5hZGQocikuZmlyc3Q7CkBA IC0yNzYsNyArMzEyLDcgQEAgQXRvbWljU3RyaW5nSW1wbCogQXRvbWljU3RyaW5nOjpmaW5kKGNv bnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIGUKICAgICBBU1NFUlQocyk7 CiAgICAgQVNTRVJUKGV4aXN0aW5nSGFzaCk7CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAg aWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxBdG9taWNTdHJpbmdJbXBs Kj4oU3RyaW5nSW1wbDo6ZW1wdHkoKSk7CiAKICAgICBIYXNoQW5kQ2hhcmFjdGVycyBidWZmZXIg PSB7IGV4aXN0aW5nSGFzaCwgcywgbGVuZ3RoIH07IApAQCAtMjkwLDcgKzMyNiw3IEBAIHZvaWQg QXRvbWljU3RyaW5nOjpyZW1vdmUoU3RyaW5nSW1wbCogcikKIHsKICAgICBzdHJpbmdUYWJsZSgp LnJlbW92ZShyKTsKIH0KLSAgICAKKwogQXRvbWljU3RyaW5nIEF0b21pY1N0cmluZzo6bG93ZXIo KSBjb25zdAogewogICAgIC8vIE5vdGU6IFRoaXMgaXMgYSBob3QgZnVuY3Rpb24gaW4gdGhlIERy b21hZW8gYmVuY2htYXJrLgpAQCAtMzAzLDQgKzMzOSwzNiBAQCBBdG9taWNTdHJpbmcgQXRvbWlj U3RyaW5nOjpsb3dlcigpIGNvbnN0CiAgICAgcmV0dXJuIEF0b21pY1N0cmluZyhuZXdJbXBsKTsK IH0KIAorQXRvbWljU3RyaW5nIEF0b21pY1N0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhciogY2hh cmFjdGVycywgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBpZiAoIWNoYXJhY3RlcnMpCisgICAgICAg IHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIGlmICghbGVuZ3RoKQorICAgICAgICByZXR1 cm4gZW1wdHlBdG9tOworCisgICAgSGFzaEFuZFVURjhDaGFyYWN0ZXJzIGJ1ZmZlcjsKKyAgICBi dWZmZXIuY2hhcmFjdGVycyA9IGNoYXJhY3RlcnM7CisgICAgYnVmZmVyLmxlbmd0aCA9IGxlbmd0 aDsKKyAgICBidWZmZXIuaGFzaCA9IGNhbGN1bGF0ZUhhc2hGcm9tVVRGOChjaGFyYWN0ZXJzLCBj aGFyYWN0ZXJzICsgbGVuZ3RoLCBidWZmZXIudXRmMTZMZW5ndGgpOworCisgICAgaWYgKCFidWZm ZXIuaGFzaCkKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworCisgICAgcGFpcjxIYXNo U2V0PFN0cmluZ0ltcGwqPjo6aXRlcmF0b3IsIGJvb2w+IGFkZFJlc3VsdCA9IHN0cmluZ1RhYmxl KCkuYWRkPEhhc2hBbmRVVEY4Q2hhcmFjdGVycywgSGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNs YXRvcj4oYnVmZmVyKTsKKworICAgIC8vIElmIHRoZSBzdHJpbmcgaXMgbmV3bHktdHJhbnNsYXRl ZCwgdGhlbiB3ZSBuZWVkIHRvIGFkb3B0IGl0LgorICAgIC8vIFRoZSBib29sZWFuIGluIHRoZSBw YWlyIHRlbGxzIHVzIGlmIHRoYXQgaXMgc28uCisgICAgQXRvbWljU3RyaW5nIGF0b21pY1N0cmlu ZzsKKyAgICBhdG9taWNTdHJpbmcubV9zdHJpbmcgPSBhZGRSZXN1bHQuc2Vjb25kID8gYWRvcHRS ZWYoKmFkZFJlc3VsdC5maXJzdCkgOiAqYWRkUmVzdWx0LmZpcnN0OworICAgIHJldHVybiBhdG9t aWNTdHJpbmc7CiB9CisKK0F0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6OmZyb21VVEY4KGNvbnN0 IGNoYXIqIGNoYXJhY3RlcnMpCit7CisgICAgaWYgKCFjaGFyYWN0ZXJzKQorICAgICAgICByZXR1 cm4gQXRvbWljU3RyaW5nKCk7CisgICAgcmV0dXJuIGZyb21VVEY4KGNoYXJhY3RlcnMsIHN0cmxl bihjaGFyYWN0ZXJzKSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2 YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYv dGV4dC9BdG9taWNTdHJpbmcuaAppbmRleCAwNmU2M2Y0Li40YzcwZTU0IDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29y ZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaApAQCAtMTA4LDYgKzEwOCwxMSBAQCBwdWJsaWM6CiAg ICAgb3BlcmF0b3IgUVN0cmluZygpIGNvbnN0IHsgcmV0dXJuIG1fc3RyaW5nOyB9CiAjZW5kaWYK IAorICAgIC8vIEF0b21pY1N0cmluZzo6ZnJvbVVURjggd2lsbCByZXR1cm4gYSBudWxsIHN0cmlu ZyBpZgorICAgIC8vIHRoZSBpbnB1dCBkYXRhIGNvbnRhaW5zIGludmFsaWQgVVRGLTggY2hhcmFj dGVycy4KKyAgICBzdGF0aWMgQXRvbWljU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqLCBzaXpl X3QpOworICAgIHN0YXRpYyBBdG9taWNTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hhciopOworCiBw cml2YXRlOgogICAgIFN0cmluZyBtX3N0cmluZzsKICAgICAKZGlmZiAtLWdpdCBhL0phdmFTY3Jp cHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0 cmluZ0ltcGwuaAppbmRleCA4ZjBhZjUyLi5kNmMxYWQ1IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0 Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQv U3RyaW5nSW1wbC5oCkBAIC01Myw2ICs1Myw3IEBAIG5hbWVzcGFjZSBXVEYgewogCiBzdHJ1Y3Qg Q1N0cmluZ1RyYW5zbGF0b3I7CiBzdHJ1Y3QgSGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yOwor c3RydWN0IEhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I7CiBzdHJ1Y3QgVUNoYXJCdWZm ZXJUcmFuc2xhdG9yOwogCiBlbnVtIFRleHRDYXNlU2Vuc2l0aXZpdHkgeyBUZXh0Q2FzZVNlbnNp dGl2ZSwgVGV4dENhc2VJbnNlbnNpdGl2ZSB9OwpAQCAtNjYsNiArNjcsNyBAQCBjbGFzcyBTdHJp bmdJbXBsIDogcHVibGljIFN0cmluZ0ltcGxCYXNlIHsKICAgICBmcmllbmQgc3RydWN0IEpTQzo6 SWRlbnRpZmllclVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKICAgICBmcmllbmQgc3RydWN0IFdURjo6 Q1N0cmluZ1RyYW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6Okhhc2hBbmRDaGFyYWN0 ZXJzVHJhbnNsYXRvcjsKKyAgICBmcmllbmQgc3RydWN0IFdURjo6SGFzaEFuZFVURjhDaGFyYWN0 ZXJzVHJhbnNsYXRvcjsKICAgICBmcmllbmQgc3RydWN0IFdURjo6VUNoYXJCdWZmZXJUcmFuc2xh dG9yOwogICAgIGZyaWVuZCBjbGFzcyBBdG9taWNTdHJpbmdJbXBsOwogcHJpdmF0ZToKZGlmZiAt LWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oIGIvSmF2YVNjcmlwdENv cmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKaW5kZXggZTlkNmFlNC4uNDY2MzNmMiAxMDA2NDQKLS0t IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKKysrIGIvSmF2YVNjcmlwdENv cmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKQEAgLTMwOSw2ICszMDksOCBAQCBwdWJsaWM6CiAgICAg U3RyaW5nKGNvbnN0IEFFQ0hBUiopOwogI2VuZGlmCiAKKyAgICAvLyBTdHJpbmc6OmZyb21VVEY4 IHdpbGwgcmV0dXJuIGEgbnVsbCBzdHJpbmcgaWYKKyAgICAvLyB0aGUgaW5wdXQgZGF0YSBjb250 YWlucyBpbnZhbGlkIFVURi04IGNoYXJhY3RlcnMuCiAgICAgc3RhdGljIFN0cmluZyBmcm9tVVRG OChjb25zdCBjaGFyKiwgc2l6ZV90KTsKICAgICBzdGF0aWMgU3RyaW5nIGZyb21VVEY4KGNvbnN0 IGNoYXIqKTsKIApkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5j cHAgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcAppbmRleCA0MGM1NjA5Li4z ZDRkMDFmIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcAor KysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcApAQCAtMSw1ICsxLDYgQEAK IC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcgQXBwbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRyaWNrIEdhbnN0ZXJlciA8cGFyb2dhQHBhcm9n YS5jb20+CiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI1LDYgKzI2LDcgQEAK IAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIlVURjguaCIKKyNpbmNsdWRlIDx3dGYv U3RyaW5nSGFzaGVyLmg+CiAKIG5hbWVzcGFjZSBXVEYgewogbmFtZXNwYWNlIFVuaWNvZGUgewpA QCAtMjMxLDYgKzIzMywyMyBAQCBzdGF0aWMgYm9vbCBpc0xlZ2FsVVRGOChjb25zdCB1bnNpZ25l ZCBjaGFyKiBzb3VyY2UsIGludCBsZW5ndGgpCiBzdGF0aWMgY29uc3QgVUNoYXIzMiBvZmZzZXRz RnJvbVVURjhbNl0gPSB7IDB4MDAwMDAwMDBVTCwgMHgwMDAwMzA4MFVMLCAweDAwMEUyMDgwVUws IAogICAgICAgICAgICAgMHgwM0M4MjA4MFVMLCAweEZBMDgyMDgwVUwsIDB4ODIwODIwODBVTCB9 OwogCitzdGF0aWMgaW5saW5lIFVDaGFyMzIgcmVhZFVURjhTZXF1ZW5jZShjb25zdCBjaGFyKiYg c2VxdWVuY2UsIHVuc2lnbmVkIGxlbmd0aCkKK3sKKyAgICBVQ2hhcjMyIGNoID0gMDsKKworICAg IC8vIFRoZSBjYXNlcyBhbGwgZmFsbCB0aHJvdWdoLgorICAgIHN3aXRjaCAobGVuZ3RoKSB7Cisg ICAgICAgIGNhc2UgNjogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4oKnNlcXVlbmNl KyspOyBjaCA8PD0gNjsgLy8gcmVtZW1iZXIsIGlsbGVnYWwgVVRGLTgKKyAgICAgICAgY2FzZSA1 OiBjaCArPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPigqc2VxdWVuY2UrKyk7IGNoIDw8PSA2 OyAvLyByZW1lbWJlciwgaWxsZWdhbCBVVEYtOAorICAgICAgICBjYXNlIDQ6IGNoICs9IHN0YXRp Y19jYXN0PHVuc2lnbmVkIGNoYXI+KCpzZXF1ZW5jZSsrKTsgY2ggPDw9IDY7CisgICAgICAgIGNh c2UgMzogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4oKnNlcXVlbmNlKyspOyBjaCA8 PD0gNjsKKyAgICAgICAgY2FzZSAyOiBjaCArPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPigq c2VxdWVuY2UrKyk7IGNoIDw8PSA2OworICAgICAgICBjYXNlIDE6IGNoICs9IHN0YXRpY19jYXN0 PHVuc2lnbmVkIGNoYXI+KCpzZXF1ZW5jZSsrKTsKKyAgICB9CisKKyAgICByZXR1cm4gY2ggLSBv ZmZzZXRzRnJvbVVURjhbbGVuZ3RoIC0gMV07Cit9CisKIENvbnZlcnNpb25SZXN1bHQgY29udmVy dFVURjhUb1VURjE2KAogICAgIGNvbnN0IGNoYXIqKiBzb3VyY2VTdGFydCwgY29uc3QgY2hhciog c291cmNlRW5kLCAKICAgICBVQ2hhcioqIHRhcmdldFN0YXJ0LCBVQ2hhciogdGFyZ2V0RW5kLCBi b29sIHN0cmljdCkKQEAgLTIzOSwzNyArMjU4LDI4IEBAIENvbnZlcnNpb25SZXN1bHQgY29udmVy dFVURjhUb1VURjE2KAogICAgIGNvbnN0IGNoYXIqIHNvdXJjZSA9ICpzb3VyY2VTdGFydDsKICAg ICBVQ2hhciogdGFyZ2V0ID0gKnRhcmdldFN0YXJ0OwogICAgIHdoaWxlIChzb3VyY2UgPCBzb3Vy Y2VFbmQpIHsKLSAgICAgICAgVUNoYXIzMiBjaCA9IDA7Ci0gICAgICAgIGludCBleHRyYUJ5dGVz VG9SZWFkID0gaW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoKCpzb3VyY2UpIC0gMTsKLSAgICAgICAg aWYgKHNvdXJjZSArIGV4dHJhQnl0ZXNUb1JlYWQgPj0gc291cmNlRW5kKSB7CisgICAgICAgIGlu dCB1dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGgoKnNvdXJjZSk7 CisgICAgICAgIGlmIChzb3VyY2UgKyB1dGY4U2VxdWVuY2VMZW5ndGggPiBzb3VyY2VFbmQpIHsK ICAgICAgICAgICAgIHJlc3VsdCA9IHNvdXJjZUV4aGF1c3RlZDsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICB9CiAgICAgICAgIC8vIERvIHRoaXMgY2hlY2sgd2hldGhlciBsZW5pZW50IG9y IHN0cmljdAotICAgICAgICBpZiAoIWlzTGVnYWxVVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3Qg dW5zaWduZWQgY2hhcio+KHNvdXJjZSksIGV4dHJhQnl0ZXNUb1JlYWQgKyAxKSkgeworICAgICAg ICBpZiAoIWlzTGVnYWxVVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgdW5zaWduZWQgY2hhcio+ KHNvdXJjZSksIHV0ZjhTZXF1ZW5jZUxlbmd0aCkpIHsKICAgICAgICAgICAgIHJlc3VsdCA9IHNv dXJjZUlsbGVnYWw7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQotICAgICAgICAvLyBU aGUgY2FzZXMgYWxsIGZhbGwgdGhyb3VnaC4KLSAgICAgICAgc3dpdGNoIChleHRyYUJ5dGVzVG9S ZWFkKSB7Ci0gICAgICAgICAgICBjYXNlIDU6IGNoICs9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNo YXI+KCpzb3VyY2UrKyk7IGNoIDw8PSA2OyAvLyByZW1lbWJlciwgaWxsZWdhbCBVVEYtOAotICAg ICAgICAgICAgY2FzZSA0OiBjaCArPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyPigqc291cmNl KyspOyBjaCA8PD0gNjsgLy8gcmVtZW1iZXIsIGlsbGVnYWwgVVRGLTgKLSAgICAgICAgICAgIGNh c2UgMzogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4oKnNvdXJjZSsrKTsgY2ggPDw9 IDY7Ci0gICAgICAgICAgICBjYXNlIDI6IGNoICs9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXI+ KCpzb3VyY2UrKyk7IGNoIDw8PSA2OwotICAgICAgICAgICAgY2FzZSAxOiBjaCArPSBzdGF0aWNf Y2FzdDx1bnNpZ25lZCBjaGFyPigqc291cmNlKyspOyBjaCA8PD0gNjsKLSAgICAgICAgICAgIGNh c2UgMDogY2ggKz0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcj4oKnNvdXJjZSsrKTsKLSAgICAg ICAgfQotICAgICAgICBjaCAtPSBvZmZzZXRzRnJvbVVURjhbZXh0cmFCeXRlc1RvUmVhZF07CisK KyAgICAgICAgVUNoYXIzMiBjaCA9IHJlYWRVVEY4U2VxdWVuY2Uoc291cmNlLCB1dGY4U2VxdWVu Y2VMZW5ndGgpOwogCiAgICAgICAgIGlmICh0YXJnZXQgPj0gdGFyZ2V0RW5kKSB7Ci0gICAgICAg ICAgICBzb3VyY2UgLT0gKGV4dHJhQnl0ZXNUb1JlYWQgKyAxKTsgLy8gQmFjayB1cCBzb3VyY2Ug cG9pbnRlciEKKyAgICAgICAgICAgIHNvdXJjZSAtPSB1dGY4U2VxdWVuY2VMZW5ndGg7IC8vIEJh Y2sgdXAgc291cmNlIHBvaW50ZXIhCiAgICAgICAgICAgICByZXN1bHQgPSB0YXJnZXRFeGhhdXN0 ZWQ7IGJyZWFrOwogICAgICAgICB9CiAgICAgICAgIGlmIChjaCA8PSAweEZGRkYpIHsKICAgICAg ICAgICAgIC8vIFVURi0xNiBzdXJyb2dhdGUgdmFsdWVzIGFyZSBpbGxlZ2FsIGluIFVURi0zMgog ICAgICAgICAgICAgaWYgKGNoID49IDB4RDgwMCAmJiBjaCA8PSAweERGRkYpIHsKICAgICAgICAg ICAgICAgICBpZiAoc3RyaWN0KSB7Ci0gICAgICAgICAgICAgICAgICAgIHNvdXJjZSAtPSAoZXh0 cmFCeXRlc1RvUmVhZCArIDEpOyAvLyByZXR1cm4gdG8gdGhlIGlsbGVnYWwgdmFsdWUgaXRzZWxm CisgICAgICAgICAgICAgICAgICAgIHNvdXJjZSAtPSB1dGY4U2VxdWVuY2VMZW5ndGg7IC8vIHJl dHVybiB0byB0aGUgaWxsZWdhbCB2YWx1ZSBpdHNlbGYKICAgICAgICAgICAgICAgICAgICAgcmVz dWx0ID0gc291cmNlSWxsZWdhbDsKICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg ICAgICAgICAgfSBlbHNlCkBAIC0yNzksMTQgKzI4OSwxNCBAQCBDb252ZXJzaW9uUmVzdWx0IGNv bnZlcnRVVEY4VG9VVEYxNigKICAgICAgICAgfSBlbHNlIGlmIChjaCA+IDB4MTBGRkZGKSB7CiAg ICAgICAgICAgICBpZiAoc3RyaWN0KSB7CiAgICAgICAgICAgICAgICAgcmVzdWx0ID0gc291cmNl SWxsZWdhbDsKLSAgICAgICAgICAgICAgICBzb3VyY2UgLT0gKGV4dHJhQnl0ZXNUb1JlYWQgKyAx KTsgLy8gcmV0dXJuIHRvIHRoZSBzdGFydAorICAgICAgICAgICAgICAgIHNvdXJjZSAtPSB1dGY4 U2VxdWVuY2VMZW5ndGg7IC8vIHJldHVybiB0byB0aGUgc3RhcnQKICAgICAgICAgICAgICAgICBi cmVhazsgLy8gQmFpbCBvdXQ7IHNob3VsZG4ndCBjb250aW51ZQogICAgICAgICAgICAgfSBlbHNl CiAgICAgICAgICAgICAgICAgKnRhcmdldCsrID0gMHhGRkZEOwogICAgICAgICB9IGVsc2Ugewog ICAgICAgICAgICAgLy8gdGFyZ2V0IGlzIGEgY2hhcmFjdGVyIGluIHJhbmdlIDB4RkZGRiAtIDB4 MTBGRkZGCiAgICAgICAgICAgICBpZiAodGFyZ2V0ICsgMSA+PSB0YXJnZXRFbmQpIHsKLSAgICAg ICAgICAgICAgICBzb3VyY2UgLT0gKGV4dHJhQnl0ZXNUb1JlYWQgKyAxKTsgLy8gQmFjayB1cCBz b3VyY2UgcG9pbnRlciEKKyAgICAgICAgICAgICAgICBzb3VyY2UgLT0gdXRmOFNlcXVlbmNlTGVu Z3RoOyAvLyBCYWNrIHVwIHNvdXJjZSBwb2ludGVyIQogICAgICAgICAgICAgICAgIHJlc3VsdCA9 IHRhcmdldEV4aGF1c3RlZDsKICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIH0K QEAgLTMwMCw1ICszMTAsODkgQEAgQ29udmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGOFRvVVRGMTYo CiAgICAgcmV0dXJuIHJlc3VsdDsKIH0KIAordW5zaWduZWQgY2FsY3VsYXRlSGFzaEZyb21VVEY4 KGNvbnN0IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVkJiB1dGYxNkxl bmd0aCkKK3sKKyAgICBpZiAoIWRhdGEpCisgICAgICAgIHJldHVybiAwOworCisgICAgV1RGOjpT dHJpbmdIYXNoZXIgc3RyaW5nSGFzaGVyOworICAgIHV0ZjE2TGVuZ3RoID0gMDsKKworICAgIHdo aWxlIChkYXRhIDwgZGF0YUVuZCkgeworICAgICAgICBpZiAoISgqZGF0YSAmIDB4ODApKSB7Cisg ICAgICAgICAgICBzdHJpbmdIYXNoZXIuYWRkQ2hhcmFjdGVyKCpkYXRhKyspOworICAgICAgICAg ICAgdXRmMTZMZW5ndGgrKzsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAg ICAgICAgaW50IHV0ZjhTZXF1ZW5jZUxlbmd0aCA9IGlubGluZVVURjhTZXF1ZW5jZUxlbmd0aE5v bkFTQ0lJKCpkYXRhKTsKKworICAgICAgICBpZiAoZGF0YSArIHV0ZjhTZXF1ZW5jZUxlbmd0aCA+ IGRhdGFFbmQpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgaWYgKCFpc0xl Z2FsVVRGOChyZWludGVycHJldF9jYXN0PGNvbnN0IHVuc2lnbmVkIGNoYXIqPihkYXRhKSwgdXRm OFNlcXVlbmNlTGVuZ3RoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgIFVDaGFy MzIgY2ggPSByZWFkVVRGOFNlcXVlbmNlKGRhdGEsIHV0ZjhTZXF1ZW5jZUxlbmd0aCk7CisgICAg ICAgIEFTU0VSVChjaCA+PSAweDgwKTsKKworICAgICAgICBpZiAoY2ggPD0gMHhGRkZGKSB7Cisg ICAgICAgICAgICAvLyBVVEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBhcmUgaWxsZWdhbCBpbiBVVEYt MzIKKyAgICAgICAgICAgIGlmIChjaCA+PSAweEQ4MDAgJiYgY2ggPD0gMHhERkZGKQorICAgICAg ICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFkZENoYXJhY3Rl cihzdGF0aWNfY2FzdDxVQ2hhcj4oY2gpKTsgLy8gbm9ybWFsIGNhc2UKKyAgICAgICAgICAgIHV0 ZjE2TGVuZ3RoKys7CisgICAgICAgIH0gZWxzZSBpZiAoY2ggPD0gMHgxMEZGRkYpIHsKKyAgICAg ICAgICAgIGNoIC09IDB4MDAxMDAwMFVMOworICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFkZENo YXJhY3RlcnMoc3RhdGljX2Nhc3Q8VUNoYXI+KChjaCA+PiAxMCkgKyAweEQ4MDApLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RhdGljX2Nhc3Q8VUNoYXI+KChjaCAm IDB4MDNGRikgKyAweERDMDApKTsKKyAgICAgICAgICAgIHV0ZjE2TGVuZ3RoICs9IDI7CisgICAg ICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgICAgcmV0dXJuIHN0 cmluZ0hhc2hlci5oYXNoKCk7CiB9CisKK2Jvb2wgZXF1YWxVVEY4KGNvbnN0IFVDaGFyKiBhLCBj b25zdCBVQ2hhciogYUVuZCwgY29uc3QgY2hhciogYiwgY29uc3QgY2hhciogYkVuZCkKK3sKKyAg ICB3aGlsZSAoYiA8IGJFbmQpIHsKKyAgICAgICAgaWYgKCEoKmIgJiAweDgwKSkgeworICAgICAg ICAgICAgaWYgKCphKysgIT0gc3RhdGljX2Nhc3Q8VUNoYXI+KCpiKyspKQorICAgICAgICAgICAg ICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAg ICAgICAgaW50IHV0ZjhTZXF1ZW5jZUxlbmd0aCA9IGlubGluZVVURjhTZXF1ZW5jZUxlbmd0aE5v bkFTQ0lJKCpiKTsKKworICAgICAgICBpZiAoYiArIHV0ZjhTZXF1ZW5jZUxlbmd0aCA+IGJFbmQp CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgaWYgKCFpc0xlZ2FsVVRGOChy ZWludGVycHJldF9jYXN0PGNvbnN0IHVuc2lnbmVkIGNoYXIqPihiKSwgdXRmOFNlcXVlbmNlTGVu Z3RoKSkKKyAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgIFVDaGFyMzIgY2ggPSByZWFk VVRGOFNlcXVlbmNlKGIsIHV0ZjhTZXF1ZW5jZUxlbmd0aCk7CisgICAgICAgIEFTU0VSVChjaCA+ PSAweDgwKTsKKworICAgICAgICBpZiAoY2ggPD0gMHhGRkZGKSB7CisgICAgICAgICAgICAvLyBV VEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBhcmUgaWxsZWdhbCBpbiBVVEYtMzIKKyAgICAgICAgICAg IGlmIChjaCA+PSAweEQ4MDAgJiYgY2ggPD0gMHhERkZGKQorICAgICAgICAgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IHN0YXRpY19jYXN0PFVDaGFyPihjaCkp CisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9IGVsc2UgaWYgKGNoIDw9 IDB4MTBGRkZGKSB7CisgICAgICAgICAgICBjaCAtPSAweDAwMTAwMDBVTDsKKworICAgICAgICAg ICAgaWYgKCphKysgIT0gc3RhdGljX2Nhc3Q8VUNoYXI+KChjaCA+PiAxMCkgKyAweEQ4MDApKQor ICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IHN0 YXRpY19jYXN0PFVDaGFyPigoY2ggJiAweDAzRkYpICsgMHhEQzAwKSkKKyAgICAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIH0KKworICAgIHJldHVybiBhID09IGFFbmQ7CiB9CisKK30gLy8gbmFtZXNwYWNlIFVu aWNvZGUKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3Rm L3VuaWNvZGUvVVRGOC5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCmluZGV4 IGE1ZWQ5M2UuLmJhMjU3ZGEgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2Rl L1VURjguaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgKQEAgLTI5LDcg KzI5LDcgQEAKICNpbmNsdWRlICJVbmljb2RlLmgiCiAKIG5hbWVzcGFjZSBXVEYgewotICBuYW1l c3BhY2UgVW5pY29kZSB7CituYW1lc3BhY2UgVW5pY29kZSB7CiAKICAgICAvLyBHaXZlbiBhIGZp cnN0IGJ5dGUsIGdpdmVzIHRoZSBsZW5ndGggb2YgdGhlIFVURi04IHNlcXVlbmNlIGl0IGJlZ2lu cy4KICAgICAvLyBSZXR1cm5zIDAgZm9yIGJ5dGVzIHRoYXQgYXJlIG5vdCBsZWdhbCBzdGFydHMg b2YgVVRGLTggc2VxdWVuY2VzLgpAQCAtNjksNyArNjksMTIgQEAgbmFtZXNwYWNlIFdURiB7CiAg ICAgQ29udmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGMTZUb1VURjgoCiAgICAgICAgICAgICAgICAg ICAgIGNvbnN0IFVDaGFyKiogc291cmNlU3RhcnQsIGNvbnN0IFVDaGFyKiBzb3VyY2VFbmQsIAog ICAgICAgICAgICAgICAgICAgICBjaGFyKiogdGFyZ2V0U3RhcnQsIGNoYXIqIHRhcmdldEVuZCwg Ym9vbCBzdHJpY3QgPSB0cnVlKTsKLSAgfQotfQorCisgICAgdW5zaWduZWQgY2FsY3VsYXRlSGFz aEZyb21VVEY4KGNvbnN0IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVk JiB1dGYxNkxlbmd0aCk7CisKKyAgICBib29sIGVxdWFsVVRGOChjb25zdCBVQ2hhciogYSwgY29u c3QgVUNoYXIqIGFFbmQsIGNvbnN0IGNoYXIqIGIsIGNvbnN0IGNoYXIqIGJFbmQpOworCit9IC8v IG5hbWVzcGFjZSBVbmljb2RlCit9IC8vIG5hbWVzcGFjZSBXVEYKIAogI2VuZGlmIC8vIFdURl9V VEY4X2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cK aW5kZXggMzdkMGMyNS4uYmViYTQzMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysr IGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMC0xMS0xMyAgUGF0cmlj ayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgQXRvbWljU3RyaW5nOjpmcm9tVVRGOAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU1OTQKKworICAg ICAgICBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOCBkaXJlY3RseSBpbiB0aGUgbGlieG1sMiBw YXJzZXIuCisKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OnRvQXRvbWljU3RyaW5nKToKKwogMjAxMC0xMS0xMiAgQWxleGV5IFBy b3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBG cmFzZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIu Y3BwIGIvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAppbmRleCA3YTMy ODVmLi4yM2Y5ODgzIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxp YnhtbDIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAK QEAgLTY4NiwxNCArNjg2LDEyIEBAIHN0YXRpYyBpbmxpbmUgU3RyaW5nIHRvU3RyaW5nKGNvbnN0 IHhtbENoYXIqIHN0cmluZykKIAogc3RhdGljIGlubGluZSBBdG9taWNTdHJpbmcgdG9BdG9taWNT dHJpbmcoY29uc3QgeG1sQ2hhciogc3RyaW5nLCBzaXplX3Qgc2l6ZSkKIHsKLSAgICAvLyBGSVhN RTogVXNlIEF0b21pY1N0cmluZzo6ZnJvbVVURjguCi0gICAgcmV0dXJuIEF0b21pY1N0cmluZyh0 b1N0cmluZyhzdHJpbmcsIHNpemUpKTsKKyAgICByZXR1cm4gQXRvbWljU3RyaW5nOjpmcm9tVVRG OChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIqPihzdHJpbmcpLCBzaXplKTsKIH0KIAogc3Rh dGljIGlubGluZSBBdG9taWNTdHJpbmcgdG9BdG9taWNTdHJpbmcoY29uc3QgeG1sQ2hhciogc3Ry aW5nKQogewotICAgIC8vIEZJWE1FOiBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOC4KLSAgICBy ZXR1cm4gQXRvbWljU3RyaW5nKHRvU3RyaW5nKHN0cmluZykpOworICAgIHJldHVybiBBdG9taWNT dHJpbmc6OmZyb21VVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KHN0cmluZykpOwog fQogCiBzdHJ1Y3QgX3htbFNBWDJOYW1lc3BhY2Ugewo= 75269 2010-12-01 06:35:27 -0800 2010-12-01 07:22:02 -0800 Patch bug-45594e.patch text/plain 14751 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3ZGY5NzEyLi4yOGJjYzhlIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQg QEAKKzIwMTAtMTItMDEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlU3RyaW5nSGFzaEZy b21VVEY4IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisg ICAgICAgIGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZl cnNhdGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVj aWFsaXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4K KworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiB3dGYvdGV4dC9BdG9t aWNTdHJpbmcuY3BwOgorICAgICAgICAoV1RGOjpDU3RyaW5nVHJhbnNsYXRvcjo6ZXF1YWwpOgor ICAgICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjpoYXNoKToKKyAg ICAgICAgKFdURjo6SGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNsYXRvcjo6ZXF1YWwpOgorICAg ICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjp0cmFuc2xhdGUpOgor ICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmFkZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0 cmluZzo6YWRkU2xvd0Nhc2UpOgorICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmZpbmQpOgor ICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmZyb21VVEY4KToKKyAgICAgICAgKiB3dGYvdGV4 dC9BdG9taWNTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdJbXBsLmg6CisgICAg ICAgICogd3RmL3RleHQvV1RGU3RyaW5nLmg6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRGOC5j cHA6CisgICAgICAgIChXVEY6OlVuaWNvZGU6OnJlYWRVVEY4U2VxdWVuY2UpOgorICAgICAgICAo V1RGOjpVbmljb2RlOjpjb252ZXJ0VVRGOFRvVVRGMTYpOgorICAgICAgICAoV1RGOjpVbmljb2Rl OjpjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgpOgorICAgICAgICAoV1RGOjpVbmljb2RlOjpl cXVhbFVURjE2V2l0aFVURjgpOgorICAgICAgICAqIHd0Zi91bmljb2RlL1VURjguaDoKKwogMjAx MC0xMS0zMCAgR2F2aW4gQmFycmFjbG91Z2ggIDxiYXJyYWNsb3VnaEBhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS5leHAgYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAK aW5kZXggY2RiM2NlNy4uNzMwM2IyYiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUuZXhwCisrKyBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cApAQCAt MzcxLDYgKzM3MSw4IEBAIF9fWk4zV1RGMTJBdG9taWNTdHJpbmczYWRkRVBLdGoKIF9fWk4zV1RG MTJBdG9taWNTdHJpbmczYWRkRVBLdGpqCiBfX1pOM1dURjEyQXRvbWljU3RyaW5nNGZpbmRFUEt0 amoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmc0aW5pdEV2CitfX1pOM1dURjEyQXRvbWljU3RyaW5n OGZyb21VVEY4RVBLYworX19aTjNXVEYxMkF0b21pY1N0cmluZzhmcm9tVVRGOEVQS2NtCiBfX1pO M1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9FUzBfCiBfX1pOM1dURjEyY3JlYXRlVGhyZWFkRVBG UHZTMF9FUzBfUEtjCiBfX1pOM1dURjEyZGV0YWNoVGhyZWFkRWoKZGlmZiAtLWdpdCBhL0phdmFT Y3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAgYi9KYXZhU2NyaXB0Q29yZS93dGYv dGV4dC9BdG9taWNTdHJpbmcuY3BwCmluZGV4IGM0OWE4MzcuLjhjOTBlOGEgMTAwNjQ0Ci0tLSBh L0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAKKysrIGIvSmF2YVNjcmlw dENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBD b3B5cmlnaHQgKEMpIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEwIFBhdHJpY2sgR2Fuc3RlcmVy IDxwYXJvZ2FAcGFyb2dhLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMjYsOSArMjcsMTIg QEAKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4K ICNpbmNsdWRlIDx3dGYvV1RGVGhyZWFkRGF0YS5oPgorI2luY2x1ZGUgPHd0Zi91bmljb2RlL1VU RjguaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKK3VzaW5nIG5hbWVzcGFjZSBVbmljb2RlOworCiBD T01QSUxFX0FTU0VSVChzaXplb2YoQXRvbWljU3RyaW5nKSA9PSBzaXplb2YoU3RyaW5nKSwgYXRv bWljX3N0cmluZ19hbmRfc3RyaW5nX211c3RfYmVfc2FtZV9zaXplKTsKIAogY2xhc3MgQXRvbWlj U3RyaW5nVGFibGUgewpAQCAtODUsNyArODksNyBAQCBzdHJ1Y3QgQ1N0cmluZ1RyYW5zbGF0b3Ig ewogICAgICAgICAgICAgaWYgKGRbaV0gIT0gYykKICAgICAgICAgICAgICAgICByZXR1cm4gZmFs c2U7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIHNbbGVuZ3RoXSA9PSAwOworICAgICAgICBy ZXR1cm4gIXNbbGVuZ3RoXTsKICAgICB9CiAKICAgICBzdGF0aWMgdm9pZCB0cmFuc2xhdGUoU3Ry aW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBjaGFyKiBjb25zdCYgYywgdW5zaWduZWQgaGFzaCkK QEAgLTIwNiwxMiArMjEwLDQ0IEBAIHN0cnVjdCBIYXNoQW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3Ig ewogICAgIH0KIH07CiAKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3RlcnMgeworICAgIHVuc2ln bmVkIGhhc2g7CisgICAgY29uc3QgY2hhciogY2hhcmFjdGVyczsKKyAgICB1bnNpZ25lZCBsZW5n dGg7CisgICAgdW5zaWduZWQgdXRmMTZMZW5ndGg7Cit9OworCitzdHJ1Y3QgSGFzaEFuZFVURjhD aGFyYWN0ZXJzVHJhbnNsYXRvciB7CisgICAgc3RhdGljIHVuc2lnbmVkIGhhc2goY29uc3QgSGFz aEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIpCisgICAgeworICAgICAgICByZXR1cm4gYnVmZmVy Lmhhc2g7CisgICAgfQorCisgICAgc3RhdGljIGJvb2wgZXF1YWwoU3RyaW5nSW1wbCogY29uc3Qm IHN0cmluZywgY29uc3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIpCisgICAgeworICAg ICAgICByZXR1cm4gZXF1YWxVVEYxNldpdGhVVEY4KHN0cmluZy0+Y2hhcmFjdGVycygpLCBzdHJp bmctPmNoYXJhY3RlcnMoKSArIHN0cmluZy0+bGVuZ3RoKCksIGJ1ZmZlci5jaGFyYWN0ZXJzLCBi dWZmZXIuY2hhcmFjdGVycyArIGJ1ZmZlci5sZW5ndGgpOworICAgIH0KKworICAgIHN0YXRpYyB2 b2lkIHRyYW5zbGF0ZShTdHJpbmdJbXBsKiYgbG9jYXRpb24sIGNvbnN0IEhhc2hBbmRVVEY4Q2hh cmFjdGVycyYgYnVmZmVyLCB1bnNpZ25lZCBoYXNoKQorICAgIHsKKyAgICAgICAgVUNoYXIgKnRh cmdldDsKKyAgICAgICAgbG9jYXRpb24gPSBTdHJpbmdJbXBsOjpjcmVhdGVVbmluaXRpYWxpemVk KGJ1ZmZlci51dGYxNkxlbmd0aCwgdGFyZ2V0KS5yZWxlYXNlUmVmKCk7CisKKyAgICAgICAgY29u c3QgY2hhciogc291cmNlID0gYnVmZmVyLmNoYXJhY3RlcnM7CisgICAgICAgIGlmIChjb252ZXJ0 VVRGOFRvVVRGMTYoJnNvdXJjZSwgc291cmNlICsgYnVmZmVyLmxlbmd0aCwgJnRhcmdldCwgdGFy Z2V0ICsgYnVmZmVyLnV0ZjE2TGVuZ3RoKSAhPSBjb252ZXJzaW9uT0spCisgICAgICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKworICAgICAgICBsb2NhdGlvbi0+c2V0SGFzaChoYXNoKTsK KyAgICAgICAgbG9jYXRpb24tPnNldElzQXRvbWljKHRydWUpOworICAgIH0KK307CisKIFBhc3NS ZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3RyaW5nOjphZGQoY29uc3QgVUNoYXIqIHMsIHVuc2ln bmVkIGxlbmd0aCkKIHsKICAgICBpZiAoIXMpCiAgICAgICAgIHJldHVybiAwOwogCi0gICAgaWYg KGxlbmd0aCA9PSAwKQorICAgIGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1w bDo6ZW1wdHkoKTsKICAgICAKICAgICBVQ2hhckJ1ZmZlciBidWYgPSB7IHMsIGxlbmd0aCB9OyAK QEAgLTIyNyw3ICsyNjMsNyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6 YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbgogICAgIEFTU0VSVChz KTsKICAgICBBU1NFUlQoZXhpc3RpbmdIYXNoKTsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAg ICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAgICAg CiAgICAgSGFzaEFuZENoYXJhY3RlcnMgYnVmZmVyID0geyBleGlzdGluZ0hhc2gsIHMsIGxlbmd0 aCB9OyAKQEAgLTI0Niw3ICsyODIsNyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0 cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzKQogICAgIHdoaWxlIChzW2xlbmd0aF0gIT0gVUNoYXIo MCkpCiAgICAgICAgIGxlbmd0aCsrOwogCi0gICAgaWYgKGxlbmd0aCA9PSAwKQorICAgIGlmICgh bGVuZ3RoKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIAogICAgIFVDaGFy QnVmZmVyIGJ1ZiA9IHtzLCBsZW5ndGh9OyAKQEAgLTI2Miw3ICsyOTgsNyBAQCBQYXNzUmVmUHRy PFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6YWRkU2xvd0Nhc2UoU3RyaW5nSW1wbCogcikKICAg ICBpZiAoIXIgfHwgci0+aXNBdG9taWMoKSkKICAgICAgICAgcmV0dXJuIHI7CiAKLSAgICBpZiAo ci0+bGVuZ3RoKCkgPT0gMCkKKyAgICBpZiAoIXItPmxlbmd0aCgpKQogICAgICAgICByZXR1cm4g U3RyaW5nSW1wbDo6ZW1wdHkoKTsKIAogICAgIFN0cmluZ0ltcGwqIHJlc3VsdCA9ICpzdHJpbmdU YWJsZSgpLmFkZChyKS5maXJzdDsKQEAgLTI3Niw3ICszMTIsNyBAQCBBdG9taWNTdHJpbmdJbXBs KiBBdG9taWNTdHJpbmc6OmZpbmQoY29uc3QgVUNoYXIqIHMsIHVuc2lnbmVkIGxlbmd0aCwgdW5z aWduZWQgZQogICAgIEFTU0VSVChzKTsKICAgICBBU1NFUlQoZXhpc3RpbmdIYXNoKTsKIAotICAg IGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIHN0YXRp Y19jYXN0PEF0b21pY1N0cmluZ0ltcGwqPihTdHJpbmdJbXBsOjplbXB0eSgpKTsKIAogICAgIEhh c2hBbmRDaGFyYWN0ZXJzIGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBzLCBsZW5ndGggfTsgCkBA IC0yOTAsNyArMzI2LDcgQEAgdm9pZCBBdG9taWNTdHJpbmc6OnJlbW92ZShTdHJpbmdJbXBsKiBy KQogewogICAgIHN0cmluZ1RhYmxlKCkucmVtb3ZlKHIpOwogfQotICAgIAorCiBBdG9taWNTdHJp bmcgQXRvbWljU3RyaW5nOjpsb3dlcigpIGNvbnN0CiB7CiAgICAgLy8gTm90ZTogVGhpcyBpcyBh IGhvdCBmdW5jdGlvbiBpbiB0aGUgRHJvbWFlbyBiZW5jaG1hcmsuCkBAIC0zMDMsNCArMzM5LDM2 IEBAIEF0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6Omxvd2VyKCkgY29uc3QKICAgICByZXR1cm4g QXRvbWljU3RyaW5nKG5ld0ltcGwpOwogfQogCitBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpm cm9tVVRGOChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzLCBzaXplX3QgbGVuZ3RoKQoreworICAgIGlm ICghY2hhcmFjdGVycykKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworCisgICAgaWYg KCFsZW5ndGgpCisgICAgICAgIHJldHVybiBlbXB0eUF0b207CisKKyAgICBIYXNoQW5kVVRGOENo YXJhY3RlcnMgYnVmZmVyOworICAgIGJ1ZmZlci5jaGFyYWN0ZXJzID0gY2hhcmFjdGVyczsKKyAg ICBidWZmZXIubGVuZ3RoID0gbGVuZ3RoOworICAgIGJ1ZmZlci5oYXNoID0gY2FsY3VsYXRlU3Ry aW5nSGFzaEZyb21VVEY4KGNoYXJhY3RlcnMsIGNoYXJhY3RlcnMgKyBsZW5ndGgsIGJ1ZmZlci51 dGYxNkxlbmd0aCk7CisKKyAgICBpZiAoIWJ1ZmZlci5oYXNoKQorICAgICAgICByZXR1cm4gQXRv bWljU3RyaW5nKCk7CisKKyAgICBwYWlyPEhhc2hTZXQ8U3RyaW5nSW1wbCo+OjppdGVyYXRvciwg Ym9vbD4gYWRkUmVzdWx0ID0gc3RyaW5nVGFibGUoKS5hZGQ8SGFzaEFuZFVURjhDaGFyYWN0ZXJz LCBIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yPihidWZmZXIpOworCisgICAgLy8gSWYg dGhlIHN0cmluZyBpcyBuZXdseS10cmFuc2xhdGVkLCB0aGVuIHdlIG5lZWQgdG8gYWRvcHQgaXQu CisgICAgLy8gVGhlIGJvb2xlYW4gaW4gdGhlIHBhaXIgdGVsbHMgdXMgaWYgdGhhdCBpcyBzby4K KyAgICBBdG9taWNTdHJpbmcgYXRvbWljU3RyaW5nOworICAgIGF0b21pY1N0cmluZy5tX3N0cmlu ZyA9IGFkZFJlc3VsdC5zZWNvbmQgPyBhZG9wdFJlZigqYWRkUmVzdWx0LmZpcnN0KSA6ICphZGRS ZXN1bHQuZmlyc3Q7CisgICAgcmV0dXJuIGF0b21pY1N0cmluZzsKIH0KKworQXRvbWljU3RyaW5n IEF0b21pY1N0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhciogY2hhcmFjdGVycykKK3sKKyAgICBp ZiAoIWNoYXJhY3RlcnMpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKyAgICByZXR1 cm4gZnJvbVVURjgoY2hhcmFjdGVycywgc3RybGVuKGNoYXJhY3RlcnMpKTsKK30KKworfSAvLyBu YW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNT dHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oCmluZGV4IDA2 ZTYzZjQuLmFiNWIzNjYgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21p Y1N0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oCkBA IC0xMDgsNiArMTA4LDExIEBAIHB1YmxpYzoKICAgICBvcGVyYXRvciBRU3RyaW5nKCkgY29uc3Qg eyByZXR1cm4gbV9zdHJpbmc7IH0KICNlbmRpZgogCisgICAgLy8gQXRvbWljU3RyaW5nOjpmcm9t VVRGOCB3aWxsIHJldHVybiBhIG51bGwgc3RyaW5nIGlmCisgICAgLy8gdGhlIGlucHV0IGRhdGEg Y29udGFpbnMgaW52YWxpZCBVVEYtOCBzZXF1ZW5jZXMuCisgICAgc3RhdGljIEF0b21pY1N0cmlu ZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6ZV90KTsKKyAgICBzdGF0aWMgQXRvbWljU3RyaW5n IGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKKwogcHJpdmF0ZToKICAgICBTdHJpbmcgbV9zdHJpbmc7 CiAgICAgCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgg Yi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKaW5kZXggOTlkMGU5ZC4uZGMx ZGJiMiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oCisr KyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaApAQCAtNTMsNiArNTMsNyBA QCBuYW1lc3BhY2UgV1RGIHsKIAogc3RydWN0IENTdHJpbmdUcmFuc2xhdG9yOwogc3RydWN0IEhh c2hBbmRDaGFyYWN0ZXJzVHJhbnNsYXRvcjsKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3RlcnNU cmFuc2xhdG9yOwogc3RydWN0IFVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKIAogZW51bSBUZXh0Q2Fz ZVNlbnNpdGl2aXR5IHsgVGV4dENhc2VTZW5zaXRpdmUsIFRleHRDYXNlSW5zZW5zaXRpdmUgfTsK QEAgLTY2LDYgKzY3LDcgQEAgY2xhc3MgU3RyaW5nSW1wbCA6IHB1YmxpYyBTdHJpbmdJbXBsQmFz ZSB7CiAgICAgZnJpZW5kIHN0cnVjdCBKU0M6OklkZW50aWZpZXJVQ2hhckJ1ZmZlclRyYW5zbGF0 b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6OkNTdHJpbmdUcmFuc2xhdG9yOwogICAgIGZyaWVu ZCBzdHJ1Y3QgV1RGOjpIYXNoQW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3I7CisgICAgZnJpZW5kIHN0 cnVjdCBXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0 cnVjdCBXVEY6OlVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKICAgICBmcmllbmQgY2xhc3MgQXRvbWlj U3RyaW5nSW1wbDsKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4 dC9XVEZTdHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oCmluZGV4 IGU5ZDZhZTQuLmViOTViNDEgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dU RlN0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oCkBAIC0z MDksNiArMzA5LDggQEAgcHVibGljOgogICAgIFN0cmluZyhjb25zdCBBRUNIQVIqKTsKICNlbmRp ZgogCisgICAgLy8gU3RyaW5nOjpmcm9tVVRGOCB3aWxsIHJldHVybiBhIG51bGwgc3RyaW5nIGlm CisgICAgLy8gdGhlIGlucHV0IGRhdGEgY29udGFpbnMgaW52YWxpZCBVVEYtOCBzZXF1ZW5jZXMu CiAgICAgc3RhdGljIFN0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6ZV90KTsKICAgICBz dGF0aWMgU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKIApkaWZmIC0tZ2l0IGEvSmF2YVNj cmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5jcHAgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29k ZS9VVEY4LmNwcAppbmRleCBjYTRmYzFjLi5kYzI0ZWQ1IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0 Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29k ZS9VVEY4LmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcgQXBw bGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRy aWNrIEdhbnN0ZXJlciA8cGFyb2dhQHBhcm9nYS5jb20+CiAgKgogICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKQEAgLTI1LDYgKzI2LDcgQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIlVURjguaCIKKyNpbmNsdWRlIDx3dGYvU3RyaW5nSGFzaGVyLmg+CiAKICNpbmNsdWRlICJB U0NJSUNUeXBlLmgiCiAKQEAgLTMyLDcgKzM0LDcgQEAgbmFtZXNwYWNlIFdURiB7CiBuYW1lc3Bh Y2UgVW5pY29kZSB7CiAKIC8vIEZJWE1FOiBVc2UgZGVmaW5pdGlvbiBmcm9tIENoYXJhY3Rlck5h bWVzLmguCi1jb25zdCBVQ2hhciByZXBsYWNlbWVudENoYXJhY3RlciA9IDB4RkZGRDsKK3N0YXRp YyBjb25zdCBVQ2hhciByZXBsYWNlbWVudENoYXJhY3RlciA9IDB4RkZGRDsKIAogaW5saW5lIGlu dCBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJSShjaGFyIGIwKQogewpAQCAtMzE0LDUg KzMxNiw4NiBAQCBDb252ZXJzaW9uUmVzdWx0IGNvbnZlcnRVVEY4VG9VVEYxNigKICAgICByZXR1 cm4gcmVzdWx0OwogfQogCit1bnNpZ25lZCBjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgoY29u c3QgY2hhciogZGF0YSwgY29uc3QgY2hhciogZGF0YUVuZCwgdW5zaWduZWQmIHV0ZjE2TGVuZ3Ro KQoreworICAgIGlmICghZGF0YSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBXVEY6OlN0cmlu Z0hhc2hlciBzdHJpbmdIYXNoZXI7CisgICAgdXRmMTZMZW5ndGggPSAwOworCisgICAgd2hpbGUg KGRhdGEgPCBkYXRhRW5kKSB7CisgICAgICAgIGlmIChpc0FTQ0lJKCpkYXRhKSkgeworICAgICAg ICAgICAgc3RyaW5nSGFzaGVyLmFkZENoYXJhY3RlcigqZGF0YSsrKTsKKyAgICAgICAgICAgIHV0 ZjE2TGVuZ3RoKys7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAg IGludCB1dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJ SSgqZGF0YSk7CisKKyAgICAgICAgaWYgKGRhdGFFbmQgLSBkYXRhIDwgdXRmOFNlcXVlbmNlTGVu Z3RoKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIGlmICghaXNMZWdhbFVU RjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCB1bnNpZ25lZCBjaGFyKj4oZGF0YSksIHV0ZjhTZXF1 ZW5jZUxlbmd0aCkpCisgICAgICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBVQ2hhcjMyIGNo YXJhY3RlciA9IHJlYWRVVEY4U2VxdWVuY2UoZGF0YSwgdXRmOFNlcXVlbmNlTGVuZ3RoKTsKKyAg ICAgICAgQVNTRVJUKCFpc0FTQ0lJKGNoYXJhY3RlcikpOworCisgICAgICAgIGlmIChVX0lTX0JN UChjaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICAvLyBVVEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBh cmUgaWxsZWdhbCBpbiBVVEYtMzIKKyAgICAgICAgICAgIGlmIChVX0lTX1NVUlJPR0FURShjaGFy YWN0ZXIpKQorICAgICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgc3RyaW5nSGFz aGVyLmFkZENoYXJhY3RlcihzdGF0aWNfY2FzdDxVQ2hhcj4oY2hhcmFjdGVyKSk7IC8vIG5vcm1h bCBjYXNlCisgICAgICAgICAgICB1dGYxNkxlbmd0aCsrOworICAgICAgICB9IGVsc2UgaWYgKFVf SVNfU1VQUExFTUVOVEFSWShjaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICBzdHJpbmdIYXNoZXIu YWRkQ2hhcmFjdGVycyhzdGF0aWNfY2FzdDxVQ2hhcj4oVTE2X0xFQUQoY2hhcmFjdGVyKSksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGF0aWNfY2FzdDxVQ2hhcj4o VTE2X1RSQUlMKGNoYXJhY3RlcikpKTsKKyAgICAgICAgICAgIHV0ZjE2TGVuZ3RoICs9IDI7Cisg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgICAgcmV0dXJu IHN0cmluZ0hhc2hlci5oYXNoKCk7Cit9CisKK2Jvb2wgZXF1YWxVVEYxNldpdGhVVEY4KGNvbnN0 IFVDaGFyKiBhLCBjb25zdCBVQ2hhciogYUVuZCwgY29uc3QgY2hhciogYiwgY29uc3QgY2hhciog YkVuZCkKK3sKKyAgICB3aGlsZSAoYiA8IGJFbmQpIHsKKyAgICAgICAgaWYgKGlzQVNDSUkoKmIp KSB7CisgICAgICAgICAgICBpZiAoKmErKyAhPSAqYisrKQorICAgICAgICAgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaW50 IHV0ZjhTZXF1ZW5jZUxlbmd0aCA9IGlubGluZVVURjhTZXF1ZW5jZUxlbmd0aE5vbkFTQ0lJKCpi KTsKKworICAgICAgICBpZiAoYkVuZCAtIGIgPCB1dGY4U2VxdWVuY2VMZW5ndGgpCisgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgaWYgKCFpc0xlZ2FsVVRGOChyZWludGVycHJl dF9jYXN0PGNvbnN0IHVuc2lnbmVkIGNoYXIqPihiKSwgdXRmOFNlcXVlbmNlTGVuZ3RoKSkKKyAg ICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgIFVDaGFyMzIgY2hhcmFjdGVyID0gcmVhZFVU RjhTZXF1ZW5jZShiLCB1dGY4U2VxdWVuY2VMZW5ndGgpOworICAgICAgICBBU1NFUlQoIWlzQVND SUkoY2hhcmFjdGVyKSk7CisKKyAgICAgICAgaWYgKFVfSVNfQk1QKGNoYXJhY3RlcikpIHsKKyAg ICAgICAgICAgIC8vIFVURi0xNiBzdXJyb2dhdGUgdmFsdWVzIGFyZSBpbGxlZ2FsIGluIFVURi0z MgorICAgICAgICAgICAgaWYgKFVfSVNfU1VSUk9HQVRFKGNoYXJhY3RlcikpCisgICAgICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgaWYgKCphKysgIT0gY2hhcmFjdGVyKQor ICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfSBlbHNlIGlmIChVX0lTX1NV UFBMRU1FTlRBUlkoY2hhcmFjdGVyKSkgeworICAgICAgICAgICAgaWYgKCphKysgIT0gVTE2X0xF QUQoY2hhcmFjdGVyKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAg ICBpZiAoKmErKyAhPSBVMTZfVFJBSUwoY2hhcmFjdGVyKSkKKyAgICAgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IH0KKworICAgIHJldHVybiBhID09IGFFbmQ7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFVuaWNvZGUK IH0gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNv ZGUvVVRGOC5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCmluZGV4IGE1ZWQ5 M2UuLjFmNGJhY2EgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjgu aAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgKQEAgLTI5LDcgKzI5LDcg QEAKICNpbmNsdWRlICJVbmljb2RlLmgiCiAKIG5hbWVzcGFjZSBXVEYgewotICBuYW1lc3BhY2Ug VW5pY29kZSB7CituYW1lc3BhY2UgVW5pY29kZSB7CiAKICAgICAvLyBHaXZlbiBhIGZpcnN0IGJ5 dGUsIGdpdmVzIHRoZSBsZW5ndGggb2YgdGhlIFVURi04IHNlcXVlbmNlIGl0IGJlZ2lucy4KICAg ICAvLyBSZXR1cm5zIDAgZm9yIGJ5dGVzIHRoYXQgYXJlIG5vdCBsZWdhbCBzdGFydHMgb2YgVVRG LTggc2VxdWVuY2VzLgpAQCAtNjksNyArNjksMTIgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgQ29u dmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGMTZUb1VURjgoCiAgICAgICAgICAgICAgICAgICAgIGNv bnN0IFVDaGFyKiogc291cmNlU3RhcnQsIGNvbnN0IFVDaGFyKiBzb3VyY2VFbmQsIAogICAgICAg ICAgICAgICAgICAgICBjaGFyKiogdGFyZ2V0U3RhcnQsIGNoYXIqIHRhcmdldEVuZCwgYm9vbCBz dHJpY3QgPSB0cnVlKTsKLSAgfQotfQorCisgICAgdW5zaWduZWQgY2FsY3VsYXRlU3RyaW5nSGFz aEZyb21VVEY4KGNvbnN0IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVk JiB1dGYxNkxlbmd0aCk7CisKKyAgICBib29sIGVxdWFsVVRGMTZXaXRoVVRGOChjb25zdCBVQ2hh ciogYSwgY29uc3QgVUNoYXIqIGFFbmQsIGNvbnN0IGNoYXIqIGIsIGNvbnN0IGNoYXIqIGJFbmQp OworCit9IC8vIG5hbWVzcGFjZSBVbmljb2RlCit9IC8vIG5hbWVzcGFjZSBXVEYKIAogI2VuZGlm IC8vIFdURl9VVEY4X2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9D aGFuZ2VMb2cKaW5kZXggZGNkNjFiMy4uYmQzODEzMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMC0xMi0w MSAgUGF0cmljayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgQXRvbWljU3RyaW5nOjpmcm9t VVRGOAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU1 OTQKKworICAgICAgICBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOCBkaXJlY3RseSBpbiB0aGUg bGlieG1sMiBwYXJzZXIuCisKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRvQXRvbWljU3RyaW5nKToKKwogMjAxMC0xMi0wMSAg UGF0cmljayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBBbmRyZWFzIEtsaW5nLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQ YXJzZXJMaWJ4bWwyLmNwcCBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHAKaW5kZXggN2EzMjg1Zi4uMjNmOTg4MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9j dW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAorKysgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNl ckxpYnhtbDIuY3BwCkBAIC02ODYsMTQgKzY4NiwxMiBAQCBzdGF0aWMgaW5saW5lIFN0cmluZyB0 b1N0cmluZyhjb25zdCB4bWxDaGFyKiBzdHJpbmcpCiAKIHN0YXRpYyBpbmxpbmUgQXRvbWljU3Ry aW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0cmluZywgc2l6ZV90IHNpemUpCiB7 Ci0gICAgLy8gRklYTUU6IFVzZSBBdG9taWNTdHJpbmc6OmZyb21VVEY4LgotICAgIHJldHVybiBB dG9taWNTdHJpbmcodG9TdHJpbmcoc3RyaW5nLCBzaXplKSk7CisgICAgcmV0dXJuIEF0b21pY1N0 cmluZzo6ZnJvbVVURjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oc3RyaW5nKSwgc2l6 ZSk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgQXRvbWljU3RyaW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0 IHhtbENoYXIqIHN0cmluZykKIHsKLSAgICAvLyBGSVhNRTogVXNlIEF0b21pY1N0cmluZzo6ZnJv bVVURjguCi0gICAgcmV0dXJuIEF0b21pY1N0cmluZyh0b1N0cmluZyhzdHJpbmcpKTsKKyAgICBy ZXR1cm4gQXRvbWljU3RyaW5nOjpmcm9tVVRGOChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIq PihzdHJpbmcpKTsKIH0KIAogc3RydWN0IF94bWxTQVgyTmFtZXNwYWNlIHsK 75271 2010-12-01 07:22:02 -0800 2010-12-01 08:07:01 -0800 Patch bug-45594f.patch text/plain 14751 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3ZGY5NzEyLi4yOGJjYzhlIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQg QEAKKzIwMTAtMTItMDEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlU3RyaW5nSGFzaEZy b21VVEY4IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisg ICAgICAgIGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZl cnNhdGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVj aWFsaXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4K KworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiB3dGYvdGV4dC9BdG9t aWNTdHJpbmcuY3BwOgorICAgICAgICAoV1RGOjpDU3RyaW5nVHJhbnNsYXRvcjo6ZXF1YWwpOgor ICAgICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjpoYXNoKToKKyAg ICAgICAgKFdURjo6SGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNsYXRvcjo6ZXF1YWwpOgorICAg ICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjp0cmFuc2xhdGUpOgor ICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmFkZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0 cmluZzo6YWRkU2xvd0Nhc2UpOgorICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmZpbmQpOgor ICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmZyb21VVEY4KToKKyAgICAgICAgKiB3dGYvdGV4 dC9BdG9taWNTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdJbXBsLmg6CisgICAg ICAgICogd3RmL3RleHQvV1RGU3RyaW5nLmg6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRGOC5j cHA6CisgICAgICAgIChXVEY6OlVuaWNvZGU6OnJlYWRVVEY4U2VxdWVuY2UpOgorICAgICAgICAo V1RGOjpVbmljb2RlOjpjb252ZXJ0VVRGOFRvVVRGMTYpOgorICAgICAgICAoV1RGOjpVbmljb2Rl OjpjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgpOgorICAgICAgICAoV1RGOjpVbmljb2RlOjpl cXVhbFVURjE2V2l0aFVURjgpOgorICAgICAgICAqIHd0Zi91bmljb2RlL1VURjguaDoKKwogMjAx MC0xMS0zMCAgR2F2aW4gQmFycmFjbG91Z2ggIDxiYXJyYWNsb3VnaEBhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS5leHAgYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAK aW5kZXggY2RiM2NlNy4uNzMwM2IyYiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUuZXhwCisrKyBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cApAQCAt MzcxLDYgKzM3MSw4IEBAIF9fWk4zV1RGMTJBdG9taWNTdHJpbmczYWRkRVBLdGoKIF9fWk4zV1RG MTJBdG9taWNTdHJpbmczYWRkRVBLdGpqCiBfX1pOM1dURjEyQXRvbWljU3RyaW5nNGZpbmRFUEt0 amoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmc0aW5pdEV2CitfX1pOM1dURjEyQXRvbWljU3RyaW5n OGZyb21VVEY4RVBLYworX19aTjNXVEYxMkF0b21pY1N0cmluZzhmcm9tVVRGOEVQS2NtCiBfX1pO M1dURjEyY3JlYXRlVGhyZWFkRVBGUHZTMF9FUzBfCiBfX1pOM1dURjEyY3JlYXRlVGhyZWFkRVBG UHZTMF9FUzBfUEtjCiBfX1pOM1dURjEyZGV0YWNoVGhyZWFkRWoKZGlmZiAtLWdpdCBhL0phdmFT Y3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAgYi9KYXZhU2NyaXB0Q29yZS93dGYv dGV4dC9BdG9taWNTdHJpbmcuY3BwCmluZGV4IGM0OWE4MzcuLjhjOTBlOGEgMTAwNjQ0Ci0tLSBh L0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAKKysrIGIvSmF2YVNjcmlw dENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBD b3B5cmlnaHQgKEMpIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEwIFBhdHJpY2sgR2Fuc3RlcmVy IDxwYXJvZ2FAcGFyb2dhLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMjYsOSArMjcsMTIg QEAKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4K ICNpbmNsdWRlIDx3dGYvV1RGVGhyZWFkRGF0YS5oPgorI2luY2x1ZGUgPHd0Zi91bmljb2RlL1VU RjguaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKK3VzaW5nIG5hbWVzcGFjZSBVbmljb2RlOworCiBD T01QSUxFX0FTU0VSVChzaXplb2YoQXRvbWljU3RyaW5nKSA9PSBzaXplb2YoU3RyaW5nKSwgYXRv bWljX3N0cmluZ19hbmRfc3RyaW5nX211c3RfYmVfc2FtZV9zaXplKTsKIAogY2xhc3MgQXRvbWlj U3RyaW5nVGFibGUgewpAQCAtODUsNyArODksNyBAQCBzdHJ1Y3QgQ1N0cmluZ1RyYW5zbGF0b3Ig ewogICAgICAgICAgICAgaWYgKGRbaV0gIT0gYykKICAgICAgICAgICAgICAgICByZXR1cm4gZmFs c2U7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIHNbbGVuZ3RoXSA9PSAwOworICAgICAgICBy ZXR1cm4gIXNbbGVuZ3RoXTsKICAgICB9CiAKICAgICBzdGF0aWMgdm9pZCB0cmFuc2xhdGUoU3Ry aW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBjaGFyKiBjb25zdCYgYywgdW5zaWduZWQgaGFzaCkK QEAgLTIwNiwxMiArMjEwLDQ0IEBAIHN0cnVjdCBIYXNoQW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3Ig ewogICAgIH0KIH07CiAKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3RlcnMgeworICAgIHVuc2ln bmVkIGhhc2g7CisgICAgY29uc3QgY2hhciogY2hhcmFjdGVyczsKKyAgICB1bnNpZ25lZCBsZW5n dGg7CisgICAgdW5zaWduZWQgdXRmMTZMZW5ndGg7Cit9OworCitzdHJ1Y3QgSGFzaEFuZFVURjhD aGFyYWN0ZXJzVHJhbnNsYXRvciB7CisgICAgc3RhdGljIHVuc2lnbmVkIGhhc2goY29uc3QgSGFz aEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIpCisgICAgeworICAgICAgICByZXR1cm4gYnVmZmVy Lmhhc2g7CisgICAgfQorCisgICAgc3RhdGljIGJvb2wgZXF1YWwoU3RyaW5nSW1wbCogY29uc3Qm IHN0cmluZywgY29uc3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIpCisgICAgeworICAg ICAgICByZXR1cm4gZXF1YWxVVEYxNldpdGhVVEY4KHN0cmluZy0+Y2hhcmFjdGVycygpLCBzdHJp bmctPmNoYXJhY3RlcnMoKSArIHN0cmluZy0+bGVuZ3RoKCksIGJ1ZmZlci5jaGFyYWN0ZXJzLCBi dWZmZXIuY2hhcmFjdGVycyArIGJ1ZmZlci5sZW5ndGgpOworICAgIH0KKworICAgIHN0YXRpYyB2 b2lkIHRyYW5zbGF0ZShTdHJpbmdJbXBsKiYgbG9jYXRpb24sIGNvbnN0IEhhc2hBbmRVVEY4Q2hh cmFjdGVycyYgYnVmZmVyLCB1bnNpZ25lZCBoYXNoKQorICAgIHsKKyAgICAgICAgVUNoYXIqIHRh cmdldDsKKyAgICAgICAgbG9jYXRpb24gPSBTdHJpbmdJbXBsOjpjcmVhdGVVbmluaXRpYWxpemVk KGJ1ZmZlci51dGYxNkxlbmd0aCwgdGFyZ2V0KS5yZWxlYXNlUmVmKCk7CisKKyAgICAgICAgY29u c3QgY2hhciogc291cmNlID0gYnVmZmVyLmNoYXJhY3RlcnM7CisgICAgICAgIGlmIChjb252ZXJ0 VVRGOFRvVVRGMTYoJnNvdXJjZSwgc291cmNlICsgYnVmZmVyLmxlbmd0aCwgJnRhcmdldCwgdGFy Z2V0ICsgYnVmZmVyLnV0ZjE2TGVuZ3RoKSAhPSBjb252ZXJzaW9uT0spCisgICAgICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKworICAgICAgICBsb2NhdGlvbi0+c2V0SGFzaChoYXNoKTsK KyAgICAgICAgbG9jYXRpb24tPnNldElzQXRvbWljKHRydWUpOworICAgIH0KK307CisKIFBhc3NS ZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3RyaW5nOjphZGQoY29uc3QgVUNoYXIqIHMsIHVuc2ln bmVkIGxlbmd0aCkKIHsKICAgICBpZiAoIXMpCiAgICAgICAgIHJldHVybiAwOwogCi0gICAgaWYg KGxlbmd0aCA9PSAwKQorICAgIGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1w bDo6ZW1wdHkoKTsKICAgICAKICAgICBVQ2hhckJ1ZmZlciBidWYgPSB7IHMsIGxlbmd0aCB9OyAK QEAgLTIyNyw3ICsyNjMsNyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6 YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbgogICAgIEFTU0VSVChz KTsKICAgICBBU1NFUlQoZXhpc3RpbmdIYXNoKTsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAg ICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAgICAg CiAgICAgSGFzaEFuZENoYXJhY3RlcnMgYnVmZmVyID0geyBleGlzdGluZ0hhc2gsIHMsIGxlbmd0 aCB9OyAKQEAgLTI0Niw3ICsyODIsNyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0 cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzKQogICAgIHdoaWxlIChzW2xlbmd0aF0gIT0gVUNoYXIo MCkpCiAgICAgICAgIGxlbmd0aCsrOwogCi0gICAgaWYgKGxlbmd0aCA9PSAwKQorICAgIGlmICgh bGVuZ3RoKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIAogICAgIFVDaGFy QnVmZmVyIGJ1ZiA9IHtzLCBsZW5ndGh9OyAKQEAgLTI2Miw3ICsyOTgsNyBAQCBQYXNzUmVmUHRy PFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6YWRkU2xvd0Nhc2UoU3RyaW5nSW1wbCogcikKICAg ICBpZiAoIXIgfHwgci0+aXNBdG9taWMoKSkKICAgICAgICAgcmV0dXJuIHI7CiAKLSAgICBpZiAo ci0+bGVuZ3RoKCkgPT0gMCkKKyAgICBpZiAoIXItPmxlbmd0aCgpKQogICAgICAgICByZXR1cm4g U3RyaW5nSW1wbDo6ZW1wdHkoKTsKIAogICAgIFN0cmluZ0ltcGwqIHJlc3VsdCA9ICpzdHJpbmdU YWJsZSgpLmFkZChyKS5maXJzdDsKQEAgLTI3Niw3ICszMTIsNyBAQCBBdG9taWNTdHJpbmdJbXBs KiBBdG9taWNTdHJpbmc6OmZpbmQoY29uc3QgVUNoYXIqIHMsIHVuc2lnbmVkIGxlbmd0aCwgdW5z aWduZWQgZQogICAgIEFTU0VSVChzKTsKICAgICBBU1NFUlQoZXhpc3RpbmdIYXNoKTsKIAotICAg IGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIHN0YXRp Y19jYXN0PEF0b21pY1N0cmluZ0ltcGwqPihTdHJpbmdJbXBsOjplbXB0eSgpKTsKIAogICAgIEhh c2hBbmRDaGFyYWN0ZXJzIGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBzLCBsZW5ndGggfTsgCkBA IC0yOTAsNyArMzI2LDcgQEAgdm9pZCBBdG9taWNTdHJpbmc6OnJlbW92ZShTdHJpbmdJbXBsKiBy KQogewogICAgIHN0cmluZ1RhYmxlKCkucmVtb3ZlKHIpOwogfQotICAgIAorCiBBdG9taWNTdHJp bmcgQXRvbWljU3RyaW5nOjpsb3dlcigpIGNvbnN0CiB7CiAgICAgLy8gTm90ZTogVGhpcyBpcyBh IGhvdCBmdW5jdGlvbiBpbiB0aGUgRHJvbWFlbyBiZW5jaG1hcmsuCkBAIC0zMDMsNCArMzM5LDM2 IEBAIEF0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6Omxvd2VyKCkgY29uc3QKICAgICByZXR1cm4g QXRvbWljU3RyaW5nKG5ld0ltcGwpOwogfQogCitBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpm cm9tVVRGOChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzLCBzaXplX3QgbGVuZ3RoKQoreworICAgIGlm ICghY2hhcmFjdGVycykKKyAgICAgICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworCisgICAgaWYg KCFsZW5ndGgpCisgICAgICAgIHJldHVybiBlbXB0eUF0b207CisKKyAgICBIYXNoQW5kVVRGOENo YXJhY3RlcnMgYnVmZmVyOworICAgIGJ1ZmZlci5jaGFyYWN0ZXJzID0gY2hhcmFjdGVyczsKKyAg ICBidWZmZXIubGVuZ3RoID0gbGVuZ3RoOworICAgIGJ1ZmZlci5oYXNoID0gY2FsY3VsYXRlU3Ry aW5nSGFzaEZyb21VVEY4KGNoYXJhY3RlcnMsIGNoYXJhY3RlcnMgKyBsZW5ndGgsIGJ1ZmZlci51 dGYxNkxlbmd0aCk7CisKKyAgICBpZiAoIWJ1ZmZlci5oYXNoKQorICAgICAgICByZXR1cm4gQXRv bWljU3RyaW5nKCk7CisKKyAgICBwYWlyPEhhc2hTZXQ8U3RyaW5nSW1wbCo+OjppdGVyYXRvciwg Ym9vbD4gYWRkUmVzdWx0ID0gc3RyaW5nVGFibGUoKS5hZGQ8SGFzaEFuZFVURjhDaGFyYWN0ZXJz LCBIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yPihidWZmZXIpOworCisgICAgLy8gSWYg dGhlIHN0cmluZyBpcyBuZXdseS10cmFuc2xhdGVkLCB0aGVuIHdlIG5lZWQgdG8gYWRvcHQgaXQu CisgICAgLy8gVGhlIGJvb2xlYW4gaW4gdGhlIHBhaXIgdGVsbHMgdXMgaWYgdGhhdCBpcyBzby4K KyAgICBBdG9taWNTdHJpbmcgYXRvbWljU3RyaW5nOworICAgIGF0b21pY1N0cmluZy5tX3N0cmlu ZyA9IGFkZFJlc3VsdC5zZWNvbmQgPyBhZG9wdFJlZigqYWRkUmVzdWx0LmZpcnN0KSA6ICphZGRS ZXN1bHQuZmlyc3Q7CisgICAgcmV0dXJuIGF0b21pY1N0cmluZzsKIH0KKworQXRvbWljU3RyaW5n IEF0b21pY1N0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhciogY2hhcmFjdGVycykKK3sKKyAgICBp ZiAoIWNoYXJhY3RlcnMpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKyAgICByZXR1 cm4gZnJvbVVURjgoY2hhcmFjdGVycywgc3RybGVuKGNoYXJhY3RlcnMpKTsKK30KKworfSAvLyBu YW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNT dHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oCmluZGV4IDA2 ZTYzZjQuLmFiNWIzNjYgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21p Y1N0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oCkBA IC0xMDgsNiArMTA4LDExIEBAIHB1YmxpYzoKICAgICBvcGVyYXRvciBRU3RyaW5nKCkgY29uc3Qg eyByZXR1cm4gbV9zdHJpbmc7IH0KICNlbmRpZgogCisgICAgLy8gQXRvbWljU3RyaW5nOjpmcm9t VVRGOCB3aWxsIHJldHVybiBhIG51bGwgc3RyaW5nIGlmCisgICAgLy8gdGhlIGlucHV0IGRhdGEg Y29udGFpbnMgaW52YWxpZCBVVEYtOCBzZXF1ZW5jZXMuCisgICAgc3RhdGljIEF0b21pY1N0cmlu ZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6ZV90KTsKKyAgICBzdGF0aWMgQXRvbWljU3RyaW5n IGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKKwogcHJpdmF0ZToKICAgICBTdHJpbmcgbV9zdHJpbmc7 CiAgICAgCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgg Yi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKaW5kZXggOTlkMGU5ZC4uZGMx ZGJiMiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oCisr KyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaApAQCAtNTMsNiArNTMsNyBA QCBuYW1lc3BhY2UgV1RGIHsKIAogc3RydWN0IENTdHJpbmdUcmFuc2xhdG9yOwogc3RydWN0IEhh c2hBbmRDaGFyYWN0ZXJzVHJhbnNsYXRvcjsKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3RlcnNU cmFuc2xhdG9yOwogc3RydWN0IFVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKIAogZW51bSBUZXh0Q2Fz ZVNlbnNpdGl2aXR5IHsgVGV4dENhc2VTZW5zaXRpdmUsIFRleHRDYXNlSW5zZW5zaXRpdmUgfTsK QEAgLTY2LDYgKzY3LDcgQEAgY2xhc3MgU3RyaW5nSW1wbCA6IHB1YmxpYyBTdHJpbmdJbXBsQmFz ZSB7CiAgICAgZnJpZW5kIHN0cnVjdCBKU0M6OklkZW50aWZpZXJVQ2hhckJ1ZmZlclRyYW5zbGF0 b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6OkNTdHJpbmdUcmFuc2xhdG9yOwogICAgIGZyaWVu ZCBzdHJ1Y3QgV1RGOjpIYXNoQW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3I7CisgICAgZnJpZW5kIHN0 cnVjdCBXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0 cnVjdCBXVEY6OlVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKICAgICBmcmllbmQgY2xhc3MgQXRvbWlj U3RyaW5nSW1wbDsKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4 dC9XVEZTdHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oCmluZGV4 IGU5ZDZhZTQuLmViOTViNDEgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dU RlN0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oCkBAIC0z MDksNiArMzA5LDggQEAgcHVibGljOgogICAgIFN0cmluZyhjb25zdCBBRUNIQVIqKTsKICNlbmRp ZgogCisgICAgLy8gU3RyaW5nOjpmcm9tVVRGOCB3aWxsIHJldHVybiBhIG51bGwgc3RyaW5nIGlm CisgICAgLy8gdGhlIGlucHV0IGRhdGEgY29udGFpbnMgaW52YWxpZCBVVEYtOCBzZXF1ZW5jZXMu CiAgICAgc3RhdGljIFN0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKiwgc2l6ZV90KTsKICAgICBz dGF0aWMgU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqKTsKIApkaWZmIC0tZ2l0IGEvSmF2YVNj cmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5jcHAgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29k ZS9VVEY4LmNwcAppbmRleCBjYTRmYzFjLi5kYzI0ZWQ1IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0 Q29yZS93dGYvdW5pY29kZS9VVEY4LmNwcAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29k ZS9VVEY4LmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcgQXBw bGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRy aWNrIEdhbnN0ZXJlciA8cGFyb2dhQHBhcm9nYS5jb20+CiAgKgogICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKQEAgLTI1LDYgKzI2LDcgQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIlVURjguaCIKKyNpbmNsdWRlIDx3dGYvU3RyaW5nSGFzaGVyLmg+CiAKICNpbmNsdWRlICJB U0NJSUNUeXBlLmgiCiAKQEAgLTMyLDcgKzM0LDcgQEAgbmFtZXNwYWNlIFdURiB7CiBuYW1lc3Bh Y2UgVW5pY29kZSB7CiAKIC8vIEZJWE1FOiBVc2UgZGVmaW5pdGlvbiBmcm9tIENoYXJhY3Rlck5h bWVzLmguCi1jb25zdCBVQ2hhciByZXBsYWNlbWVudENoYXJhY3RlciA9IDB4RkZGRDsKK3N0YXRp YyBjb25zdCBVQ2hhciByZXBsYWNlbWVudENoYXJhY3RlciA9IDB4RkZGRDsKIAogaW5saW5lIGlu dCBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJSShjaGFyIGIwKQogewpAQCAtMzE0LDUg KzMxNiw4NiBAQCBDb252ZXJzaW9uUmVzdWx0IGNvbnZlcnRVVEY4VG9VVEYxNigKICAgICByZXR1 cm4gcmVzdWx0OwogfQogCit1bnNpZ25lZCBjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgoY29u c3QgY2hhciogZGF0YSwgY29uc3QgY2hhciogZGF0YUVuZCwgdW5zaWduZWQmIHV0ZjE2TGVuZ3Ro KQoreworICAgIGlmICghZGF0YSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBXVEY6OlN0cmlu Z0hhc2hlciBzdHJpbmdIYXNoZXI7CisgICAgdXRmMTZMZW5ndGggPSAwOworCisgICAgd2hpbGUg KGRhdGEgPCBkYXRhRW5kKSB7CisgICAgICAgIGlmIChpc0FTQ0lJKCpkYXRhKSkgeworICAgICAg ICAgICAgc3RyaW5nSGFzaGVyLmFkZENoYXJhY3RlcigqZGF0YSsrKTsKKyAgICAgICAgICAgIHV0 ZjE2TGVuZ3RoKys7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAg IGludCB1dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJ SSgqZGF0YSk7CisKKyAgICAgICAgaWYgKGRhdGFFbmQgLSBkYXRhIDwgdXRmOFNlcXVlbmNlTGVu Z3RoKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIGlmICghaXNMZWdhbFVU RjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCB1bnNpZ25lZCBjaGFyKj4oZGF0YSksIHV0ZjhTZXF1 ZW5jZUxlbmd0aCkpCisgICAgICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBVQ2hhcjMyIGNo YXJhY3RlciA9IHJlYWRVVEY4U2VxdWVuY2UoZGF0YSwgdXRmOFNlcXVlbmNlTGVuZ3RoKTsKKyAg ICAgICAgQVNTRVJUKCFpc0FTQ0lJKGNoYXJhY3RlcikpOworCisgICAgICAgIGlmIChVX0lTX0JN UChjaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICAvLyBVVEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBh cmUgaWxsZWdhbCBpbiBVVEYtMzIKKyAgICAgICAgICAgIGlmIChVX0lTX1NVUlJPR0FURShjaGFy YWN0ZXIpKQorICAgICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgc3RyaW5nSGFz aGVyLmFkZENoYXJhY3RlcihzdGF0aWNfY2FzdDxVQ2hhcj4oY2hhcmFjdGVyKSk7IC8vIG5vcm1h bCBjYXNlCisgICAgICAgICAgICB1dGYxNkxlbmd0aCsrOworICAgICAgICB9IGVsc2UgaWYgKFVf SVNfU1VQUExFTUVOVEFSWShjaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICBzdHJpbmdIYXNoZXIu YWRkQ2hhcmFjdGVycyhzdGF0aWNfY2FzdDxVQ2hhcj4oVTE2X0xFQUQoY2hhcmFjdGVyKSksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGF0aWNfY2FzdDxVQ2hhcj4o VTE2X1RSQUlMKGNoYXJhY3RlcikpKTsKKyAgICAgICAgICAgIHV0ZjE2TGVuZ3RoICs9IDI7Cisg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgICAgcmV0dXJu IHN0cmluZ0hhc2hlci5oYXNoKCk7Cit9CisKK2Jvb2wgZXF1YWxVVEYxNldpdGhVVEY4KGNvbnN0 IFVDaGFyKiBhLCBjb25zdCBVQ2hhciogYUVuZCwgY29uc3QgY2hhciogYiwgY29uc3QgY2hhciog YkVuZCkKK3sKKyAgICB3aGlsZSAoYiA8IGJFbmQpIHsKKyAgICAgICAgaWYgKGlzQVNDSUkoKmIp KSB7CisgICAgICAgICAgICBpZiAoKmErKyAhPSAqYisrKQorICAgICAgICAgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaW50 IHV0ZjhTZXF1ZW5jZUxlbmd0aCA9IGlubGluZVVURjhTZXF1ZW5jZUxlbmd0aE5vbkFTQ0lJKCpi KTsKKworICAgICAgICBpZiAoYkVuZCAtIGIgPCB1dGY4U2VxdWVuY2VMZW5ndGgpCisgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgaWYgKCFpc0xlZ2FsVVRGOChyZWludGVycHJl dF9jYXN0PGNvbnN0IHVuc2lnbmVkIGNoYXIqPihiKSwgdXRmOFNlcXVlbmNlTGVuZ3RoKSkKKyAg ICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgIFVDaGFyMzIgY2hhcmFjdGVyID0gcmVhZFVU RjhTZXF1ZW5jZShiLCB1dGY4U2VxdWVuY2VMZW5ndGgpOworICAgICAgICBBU1NFUlQoIWlzQVND SUkoY2hhcmFjdGVyKSk7CisKKyAgICAgICAgaWYgKFVfSVNfQk1QKGNoYXJhY3RlcikpIHsKKyAg ICAgICAgICAgIC8vIFVURi0xNiBzdXJyb2dhdGUgdmFsdWVzIGFyZSBpbGxlZ2FsIGluIFVURi0z MgorICAgICAgICAgICAgaWYgKFVfSVNfU1VSUk9HQVRFKGNoYXJhY3RlcikpCisgICAgICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgaWYgKCphKysgIT0gY2hhcmFjdGVyKQor ICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfSBlbHNlIGlmIChVX0lTX1NV UFBMRU1FTlRBUlkoY2hhcmFjdGVyKSkgeworICAgICAgICAgICAgaWYgKCphKysgIT0gVTE2X0xF QUQoY2hhcmFjdGVyKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAg ICBpZiAoKmErKyAhPSBVMTZfVFJBSUwoY2hhcmFjdGVyKSkKKyAgICAgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IH0KKworICAgIHJldHVybiBhID09IGFFbmQ7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFVuaWNvZGUK IH0gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNv ZGUvVVRGOC5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCmluZGV4IGE1ZWQ5 M2UuLjFmNGJhY2EgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjgu aAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgKQEAgLTI5LDcgKzI5LDcg QEAKICNpbmNsdWRlICJVbmljb2RlLmgiCiAKIG5hbWVzcGFjZSBXVEYgewotICBuYW1lc3BhY2Ug VW5pY29kZSB7CituYW1lc3BhY2UgVW5pY29kZSB7CiAKICAgICAvLyBHaXZlbiBhIGZpcnN0IGJ5 dGUsIGdpdmVzIHRoZSBsZW5ndGggb2YgdGhlIFVURi04IHNlcXVlbmNlIGl0IGJlZ2lucy4KICAg ICAvLyBSZXR1cm5zIDAgZm9yIGJ5dGVzIHRoYXQgYXJlIG5vdCBsZWdhbCBzdGFydHMgb2YgVVRG LTggc2VxdWVuY2VzLgpAQCAtNjksNyArNjksMTIgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgQ29u dmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGMTZUb1VURjgoCiAgICAgICAgICAgICAgICAgICAgIGNv bnN0IFVDaGFyKiogc291cmNlU3RhcnQsIGNvbnN0IFVDaGFyKiBzb3VyY2VFbmQsIAogICAgICAg ICAgICAgICAgICAgICBjaGFyKiogdGFyZ2V0U3RhcnQsIGNoYXIqIHRhcmdldEVuZCwgYm9vbCBz dHJpY3QgPSB0cnVlKTsKLSAgfQotfQorCisgICAgdW5zaWduZWQgY2FsY3VsYXRlU3RyaW5nSGFz aEZyb21VVEY4KGNvbnN0IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVk JiB1dGYxNkxlbmd0aCk7CisKKyAgICBib29sIGVxdWFsVVRGMTZXaXRoVVRGOChjb25zdCBVQ2hh ciogYSwgY29uc3QgVUNoYXIqIGFFbmQsIGNvbnN0IGNoYXIqIGIsIGNvbnN0IGNoYXIqIGJFbmQp OworCit9IC8vIG5hbWVzcGFjZSBVbmljb2RlCit9IC8vIG5hbWVzcGFjZSBXVEYKIAogI2VuZGlm IC8vIFdURl9VVEY4X2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9D aGFuZ2VMb2cKaW5kZXggZGNkNjFiMy4uYmQzODEzMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMC0xMi0w MSAgUGF0cmljayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgQXRvbWljU3RyaW5nOjpmcm9t VVRGOAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU1 OTQKKworICAgICAgICBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOCBkaXJlY3RseSBpbiB0aGUg bGlieG1sMiBwYXJzZXIuCisKKyAgICAgICAgKiBkb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnRvQXRvbWljU3RyaW5nKToKKwogMjAxMC0xMi0wMSAg UGF0cmljayBHYW5zdGVyZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBBbmRyZWFzIEtsaW5nLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQ YXJzZXJMaWJ4bWwyLmNwcCBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHAKaW5kZXggN2EzMjg1Zi4uMjNmOTg4MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9j dW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAorKysgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNl ckxpYnhtbDIuY3BwCkBAIC02ODYsMTQgKzY4NiwxMiBAQCBzdGF0aWMgaW5saW5lIFN0cmluZyB0 b1N0cmluZyhjb25zdCB4bWxDaGFyKiBzdHJpbmcpCiAKIHN0YXRpYyBpbmxpbmUgQXRvbWljU3Ry aW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0cmluZywgc2l6ZV90IHNpemUpCiB7 Ci0gICAgLy8gRklYTUU6IFVzZSBBdG9taWNTdHJpbmc6OmZyb21VVEY4LgotICAgIHJldHVybiBB dG9taWNTdHJpbmcodG9TdHJpbmcoc3RyaW5nLCBzaXplKSk7CisgICAgcmV0dXJuIEF0b21pY1N0 cmluZzo6ZnJvbVVURjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oc3RyaW5nKSwgc2l6 ZSk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgQXRvbWljU3RyaW5nIHRvQXRvbWljU3RyaW5nKGNvbnN0 IHhtbENoYXIqIHN0cmluZykKIHsKLSAgICAvLyBGSVhNRTogVXNlIEF0b21pY1N0cmluZzo6ZnJv bVVURjguCi0gICAgcmV0dXJuIEF0b21pY1N0cmluZyh0b1N0cmluZyhzdHJpbmcpKTsKKyAgICBy ZXR1cm4gQXRvbWljU3RyaW5nOjpmcm9tVVRGOChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIq PihzdHJpbmcpKTsKIH0KIAogc3RydWN0IF94bWxTQVgyTmFtZXNwYWNlIHsK 75274 2010-12-01 08:07:01 -0800 2010-12-01 13:15:20 -0800 Patch bug-45594g.patch text/plain 16003 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3ZGY5NzEyLi4yYWZjMzMwIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUg QEAKKzIwMTAtMTItMDEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlU3RyaW5nSGFzaEZy b21VVEY4IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisg ICAgICAgIGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZl cnNhdGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVj aWFsaXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4K KworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29y ZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmOgorICAgICAgICAqIHd0 Zi90ZXh0L0F0b21pY1N0cmluZy5jcHA6CisgICAgICAgIChXVEY6OkNTdHJpbmdUcmFuc2xhdG9y OjplcXVhbCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6 Omhhc2gpOgorICAgICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjpl cXVhbCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6OnRy YW5zbGF0ZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6YWRkKToKKyAgICAgICAgKFdU Rjo6QXRvbWljU3RyaW5nOjphZGRTbG93Q2FzZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmlu Zzo6ZmluZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6ZnJvbVVURjgpOgorICAgICAg ICAqIHd0Zi90ZXh0L0F0b21pY1N0cmluZy5oOgorICAgICAgICAqIHd0Zi90ZXh0L1N0cmluZ0lt cGwuaDoKKyAgICAgICAgKiB3dGYvdGV4dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdW5p Y29kZS9VVEY4LmNwcDoKKyAgICAgICAgKFdURjo6VW5pY29kZTo6cmVhZFVURjhTZXF1ZW5jZSk6 CisgICAgICAgIChXVEY6OlVuaWNvZGU6OmNvbnZlcnRVVEY4VG9VVEYxNik6CisgICAgICAgIChX VEY6OlVuaWNvZGU6OmNhbGN1bGF0ZVN0cmluZ0hhc2hGcm9tVVRGOCk6CisgICAgICAgIChXVEY6 OlVuaWNvZGU6OmVxdWFsVVRGMTZXaXRoVVRGOCk6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRG OC5oOgorCiAyMDEwLTExLTMwICBHYXZpbiBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL0ph dmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3Jp cHRDb3JlLmV4cAppbmRleCBjZGIzY2U3Li43MzAzYjJiIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENv cmUuZXhwCkBAIC0zNzEsNiArMzcxLDggQEAgX19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0 agogX19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0amoKIF9fWk4zV1RGMTJBdG9taWNTdHJp bmc0ZmluZEVQS3RqagogX19aTjNXVEYxMkF0b21pY1N0cmluZzRpbml0RXYKK19fWk4zV1RGMTJB dG9taWNTdHJpbmc4ZnJvbVVURjhFUEtjCitfX1pOM1dURjEyQXRvbWljU3RyaW5nOGZyb21VVEY4 RVBLY20KIF9fWk4zV1RGMTJjcmVhdGVUaHJlYWRFUEZQdlMwX0VTMF8KIF9fWk4zV1RGMTJjcmVh dGVUaHJlYWRFUEZQdlMwX0VTMF9QS2MKIF9fWk4zV1RGMTJkZXRhY2hUaHJlYWRFagpkaWZmIC0t Z2l0IGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLmRlZiBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJv ai9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5kZWYKaW5kZXggNDJhYzdmMS4uOGI4NWU2 NiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFT Y3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmRlZgorKysgYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2Ny aXB0Q29yZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmCkBAIC01OCw2 ICs1OCw3IEBAIEVYUE9SVFMKICAgICA/YXR0YWNoQERlYnVnZ2VyQEpTQ0BAUUFFWFBBVkpTR2xv YmFsT2JqZWN0QDJAQFoKICAgICA/YnJvYWRjYXN0QFRocmVhZENvbmRpdGlvbkBXVEZAQFFBRVhY WgogICAgID9idWZmZXJMZW5ndGhGb3JTdHJpbmdEZWNpbWFsQERlY2ltYWxOdW1iZXJAV1RGQEBR QkVJWFoKKyAgICA/Y2FsY3VsYXRlU3RyaW5nSGFzaEZyb21VVEY4QFVuaWNvZGVAV1RGQEBZQUlQ QkQwQUFJQFoKICAgICA/Y2FsY3VsYXRlZEZ1bmN0aW9uTmFtZUBEZWJ1Z2dlckNhbGxGcmFtZUBK U0NAQFFCRT9BVlVTdHJpbmdAMkBYWgogICAgID9jYWxjdWxhdGVVVENPZmZzZXRAV1RGQEBZQUhY WgogICAgID9jYWxjdWxhdGVEU1RPZmZzZXRAV1RGQEBZQU5OTkBaCkBAIC0xMzksNiArMTQwLDcg QEAgRVhQT1JUUwogICAgID9lbXB0eUBTdHJpbmdJbXBsQFdURkBAU0FQQVYxMkBYWgogICAgID9l bnVtZXJhYmxlQFByb3BlcnR5RGVzY3JpcHRvckBKU0NAQFFCRV9OWFoKICAgICA/ZXF1YWxASWRl bnRpZmllckBKU0NAQFNBX05QQlZTdHJpbmdJbXBsQFdURkBAUEJEQFoKKyAgICA/ZXF1YWxVVEYx NldpdGhVVEY4QFVuaWNvZGVAV1RGQEBZQV9OUEJfVzBQQkQxQFoKICAgICA/ZXZhbHVhdGVARGVi dWdnZXJDYWxsRnJhbWVASlNDQEBRQkU/QVZKU1ZhbHVlQDJAQUJWVVN0cmluZ0AyQEFBVjMyQEBa CiAgICAgP2V2YWx1YXRlQEpTQ0BAWUE/QVZDb21wbGV0aW9uQDFAUEFWRXhlY1N0YXRlQDFAQUFW U2NvcGVDaGFpbkAxQEFCVlNvdXJjZUNvZGVAMUBWSlNWYWx1ZUAxQEBaCiAgICAgP2V4Y2x1ZGVA UHJvZmlsZUBKU0NAQFFBRVhQQlZQcm9maWxlTm9kZUAyQEBaCmRpZmYgLS1naXQgYS9KYXZhU2Ny aXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3Rl eHQvQXRvbWljU3RyaW5nLmNwcAppbmRleCBjNDlhODM3Li44YzkwZThhIDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwCisrKyBiL0phdmFTY3JpcHRD b3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRyaWNrIEdhbnN0ZXJlciA8 cGFyb2dhQHBhcm9nYS5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTI2LDkgKzI3LDEyIEBA CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAj aW5jbHVkZSA8d3RmL1dURlRocmVhZERhdGEuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9VVEY4 Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCit1c2luZyBuYW1lc3BhY2UgVW5pY29kZTsKKwogQ09N UElMRV9BU1NFUlQoc2l6ZW9mKEF0b21pY1N0cmluZykgPT0gc2l6ZW9mKFN0cmluZyksIGF0b21p Y19zdHJpbmdfYW5kX3N0cmluZ19tdXN0X2JlX3NhbWVfc2l6ZSk7CiAKIGNsYXNzIEF0b21pY1N0 cmluZ1RhYmxlIHsKQEAgLTg1LDcgKzg5LDcgQEAgc3RydWN0IENTdHJpbmdUcmFuc2xhdG9yIHsK ICAgICAgICAgICAgIGlmIChkW2ldICE9IGMpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiBzW2xlbmd0aF0gPT0gMDsKKyAgICAgICAgcmV0 dXJuICFzW2xlbmd0aF07CiAgICAgfQogCiAgICAgc3RhdGljIHZvaWQgdHJhbnNsYXRlKFN0cmlu Z0ltcGwqJiBsb2NhdGlvbiwgY29uc3QgY2hhciogY29uc3QmIGMsIHVuc2lnbmVkIGhhc2gpCkBA IC0yMDYsMTIgKzIxMCw0NCBAQCBzdHJ1Y3QgSGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yIHsK ICAgICB9CiB9OwogCitzdHJ1Y3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzIHsKKyAgICB1bnNpZ25l ZCBoYXNoOworICAgIGNvbnN0IGNoYXIqIGNoYXJhY3RlcnM7CisgICAgdW5zaWduZWQgbGVuZ3Ro OworICAgIHVuc2lnbmVkIHV0ZjE2TGVuZ3RoOworfTsKKworc3RydWN0IEhhc2hBbmRVVEY4Q2hh cmFjdGVyc1RyYW5zbGF0b3IgeworICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEhhc2hB bmRVVEY4Q2hhcmFjdGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGJ1ZmZlci5o YXNoOworICAgIH0KKworICAgIHN0YXRpYyBib29sIGVxdWFsKFN0cmluZ0ltcGwqIGNvbnN0JiBz dHJpbmcsIGNvbnN0IEhhc2hBbmRVVEY4Q2hhcmFjdGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAg ICAgcmV0dXJuIGVxdWFsVVRGMTZXaXRoVVRGOChzdHJpbmctPmNoYXJhY3RlcnMoKSwgc3RyaW5n LT5jaGFyYWN0ZXJzKCkgKyBzdHJpbmctPmxlbmd0aCgpLCBidWZmZXIuY2hhcmFjdGVycywgYnVm ZmVyLmNoYXJhY3RlcnMgKyBidWZmZXIubGVuZ3RoKTsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9p ZCB0cmFuc2xhdGUoU3RyaW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBIYXNoQW5kVVRGOENoYXJh Y3RlcnMmIGJ1ZmZlciwgdW5zaWduZWQgaGFzaCkKKyAgICB7CisgICAgICAgIFVDaGFyICp0YXJn ZXQ7CisgICAgICAgIGxvY2F0aW9uID0gU3RyaW5nSW1wbDo6Y3JlYXRlVW5pbml0aWFsaXplZChi dWZmZXIudXRmMTZMZW5ndGgsIHRhcmdldCkucmVsZWFzZVJlZigpOworCisgICAgICAgIGNvbnN0 IGNoYXIqIHNvdXJjZSA9IGJ1ZmZlci5jaGFyYWN0ZXJzOworICAgICAgICBpZiAoY29udmVydFVU RjhUb1VURjE2KCZzb3VyY2UsIHNvdXJjZSArIGJ1ZmZlci5sZW5ndGgsICZ0YXJnZXQsIHRhcmdl dCArIGJ1ZmZlci51dGYxNkxlbmd0aCkgIT0gY29udmVyc2lvbk9LKQorICAgICAgICAgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7CisKKyAgICAgICAgbG9jYXRpb24tPnNldEhhc2goaGFzaCk7Cisg ICAgICAgIGxvY2F0aW9uLT5zZXRJc0F0b21pYyh0cnVlKTsKKyAgICB9Cit9OworCiBQYXNzUmVm UHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25l ZCBsZW5ndGgpCiB7CiAgICAgaWYgKCFzKQogICAgICAgICByZXR1cm4gMDsKIAotICAgIGlmIChs ZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6 OmVtcHR5KCk7CiAgICAgCiAgICAgVUNoYXJCdWZmZXIgYnVmID0geyBzLCBsZW5ndGggfTsgCkBA IC0yMjcsNyArMjYzLDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFk ZChjb25zdCBVQ2hhciogcywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ24KICAgICBBU1NFUlQocyk7 CiAgICAgQVNTRVJUKGV4aXN0aW5nSGFzaCk7CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAg aWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBTdHJpbmdJbXBsOjplbXB0eSgpOwogICAgIAog ICAgIEhhc2hBbmRDaGFyYWN0ZXJzIGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBzLCBsZW5ndGgg fTsgCkBAIC0yNDYsNyArMjgyLDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJp bmc6OmFkZChjb25zdCBVQ2hhciogcykKICAgICB3aGlsZSAoc1tsZW5ndGhdICE9IFVDaGFyKDAp KQogICAgICAgICBsZW5ndGgrKzsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxl bmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAKICAgICBVQ2hhckJ1 ZmZlciBidWYgPSB7cywgbGVuZ3RofTsgCkBAIC0yNjIsNyArMjk4LDcgQEAgUGFzc1JlZlB0cjxT dHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFkZFNsb3dDYXNlKFN0cmluZ0ltcGwqIHIpCiAgICAg aWYgKCFyIHx8IHItPmlzQXRvbWljKCkpCiAgICAgICAgIHJldHVybiByOwogCi0gICAgaWYgKHIt Pmxlbmd0aCgpID09IDApCisgICAgaWYgKCFyLT5sZW5ndGgoKSkKICAgICAgICAgcmV0dXJuIFN0 cmluZ0ltcGw6OmVtcHR5KCk7CiAKICAgICBTdHJpbmdJbXBsKiByZXN1bHQgPSAqc3RyaW5nVGFi bGUoKS5hZGQocikuZmlyc3Q7CkBAIC0yNzYsNyArMzEyLDcgQEAgQXRvbWljU3RyaW5nSW1wbCog QXRvbWljU3RyaW5nOjpmaW5kKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2ln bmVkIGUKICAgICBBU1NFUlQocyk7CiAgICAgQVNTRVJUKGV4aXN0aW5nSGFzaCk7CiAKLSAgICBp ZiAobGVuZ3RoID09IDApCisgICAgaWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBzdGF0aWNf Y2FzdDxBdG9taWNTdHJpbmdJbXBsKj4oU3RyaW5nSW1wbDo6ZW1wdHkoKSk7CiAKICAgICBIYXNo QW5kQ2hhcmFjdGVycyBidWZmZXIgPSB7IGV4aXN0aW5nSGFzaCwgcywgbGVuZ3RoIH07IApAQCAt MjkwLDcgKzMyNiw3IEBAIHZvaWQgQXRvbWljU3RyaW5nOjpyZW1vdmUoU3RyaW5nSW1wbCogcikK IHsKICAgICBzdHJpbmdUYWJsZSgpLnJlbW92ZShyKTsKIH0KLSAgICAKKwogQXRvbWljU3RyaW5n IEF0b21pY1N0cmluZzo6bG93ZXIoKSBjb25zdAogewogICAgIC8vIE5vdGU6IFRoaXMgaXMgYSBo b3QgZnVuY3Rpb24gaW4gdGhlIERyb21hZW8gYmVuY2htYXJrLgpAQCAtMzAzLDQgKzMzOSwzNiBA QCBBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpsb3dlcigpIGNvbnN0CiAgICAgcmV0dXJuIEF0 b21pY1N0cmluZyhuZXdJbXBsKTsKIH0KIAorQXRvbWljU3RyaW5nIEF0b21pY1N0cmluZzo6ZnJv bVVURjgoY29uc3QgY2hhciogY2hhcmFjdGVycywgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBpZiAo IWNoYXJhY3RlcnMpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIGlmICgh bGVuZ3RoKQorICAgICAgICByZXR1cm4gZW1wdHlBdG9tOworCisgICAgSGFzaEFuZFVURjhDaGFy YWN0ZXJzIGJ1ZmZlcjsKKyAgICBidWZmZXIuY2hhcmFjdGVycyA9IGNoYXJhY3RlcnM7CisgICAg YnVmZmVyLmxlbmd0aCA9IGxlbmd0aDsKKyAgICBidWZmZXIuaGFzaCA9IGNhbGN1bGF0ZVN0cmlu Z0hhc2hGcm9tVVRGOChjaGFyYWN0ZXJzLCBjaGFyYWN0ZXJzICsgbGVuZ3RoLCBidWZmZXIudXRm MTZMZW5ndGgpOworCisgICAgaWYgKCFidWZmZXIuaGFzaCkKKyAgICAgICAgcmV0dXJuIEF0b21p Y1N0cmluZygpOworCisgICAgcGFpcjxIYXNoU2V0PFN0cmluZ0ltcGwqPjo6aXRlcmF0b3IsIGJv b2w+IGFkZFJlc3VsdCA9IHN0cmluZ1RhYmxlKCkuYWRkPEhhc2hBbmRVVEY4Q2hhcmFjdGVycywg SGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNsYXRvcj4oYnVmZmVyKTsKKworICAgIC8vIElmIHRo ZSBzdHJpbmcgaXMgbmV3bHktdHJhbnNsYXRlZCwgdGhlbiB3ZSBuZWVkIHRvIGFkb3B0IGl0Lgor ICAgIC8vIFRoZSBib29sZWFuIGluIHRoZSBwYWlyIHRlbGxzIHVzIGlmIHRoYXQgaXMgc28uCisg ICAgQXRvbWljU3RyaW5nIGF0b21pY1N0cmluZzsKKyAgICBhdG9taWNTdHJpbmcubV9zdHJpbmcg PSBhZGRSZXN1bHQuc2Vjb25kID8gYWRvcHRSZWYoKmFkZFJlc3VsdC5maXJzdCkgOiAqYWRkUmVz dWx0LmZpcnN0OworICAgIHJldHVybiBhdG9taWNTdHJpbmc7CiB9CisKK0F0b21pY1N0cmluZyBB dG9taWNTdHJpbmc6OmZyb21VVEY4KGNvbnN0IGNoYXIqIGNoYXJhY3RlcnMpCit7CisgICAgaWYg KCFjaGFyYWN0ZXJzKQorICAgICAgICByZXR1cm4gQXRvbWljU3RyaW5nKCk7CisgICAgcmV0dXJu IGZyb21VVEY4KGNoYXJhY3RlcnMsIHN0cmxlbihjaGFyYWN0ZXJzKSk7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3Ry aW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAppbmRleCAwNmU2 M2Y0Li5hYjViMzY2IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNT dHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaApAQCAt MTA4LDYgKzEwOCwxMSBAQCBwdWJsaWM6CiAgICAgb3BlcmF0b3IgUVN0cmluZygpIGNvbnN0IHsg cmV0dXJuIG1fc3RyaW5nOyB9CiAjZW5kaWYKIAorICAgIC8vIEF0b21pY1N0cmluZzo6ZnJvbVVU Rjggd2lsbCByZXR1cm4gYSBudWxsIHN0cmluZyBpZgorICAgIC8vIHRoZSBpbnB1dCBkYXRhIGNv bnRhaW5zIGludmFsaWQgVVRGLTggc2VxdWVuY2VzLgorICAgIHN0YXRpYyBBdG9taWNTdHJpbmcg ZnJvbVVURjgoY29uc3QgY2hhciosIHNpemVfdCk7CisgICAgc3RhdGljIEF0b21pY1N0cmluZyBm cm9tVVRGOChjb25zdCBjaGFyKik7CisKIHByaXZhdGU6CiAgICAgU3RyaW5nIG1fc3RyaW5nOwog ICAgIApkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oIGIv SmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oCmluZGV4IDk5ZDBlOWQuLmRjMWRi YjIgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaAorKysg Yi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKQEAgLTUzLDYgKzUzLDcgQEAg bmFtZXNwYWNlIFdURiB7CiAKIHN0cnVjdCBDU3RyaW5nVHJhbnNsYXRvcjsKIHN0cnVjdCBIYXNo QW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3I7CitzdHJ1Y3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJh bnNsYXRvcjsKIHN0cnVjdCBVQ2hhckJ1ZmZlclRyYW5zbGF0b3I7CiAKIGVudW0gVGV4dENhc2VT ZW5zaXRpdml0eSB7IFRleHRDYXNlU2Vuc2l0aXZlLCBUZXh0Q2FzZUluc2Vuc2l0aXZlIH07CkBA IC02Niw2ICs2Nyw3IEBAIGNsYXNzIFN0cmluZ0ltcGwgOiBwdWJsaWMgU3RyaW5nSW1wbEJhc2Ug ewogICAgIGZyaWVuZCBzdHJ1Y3QgSlNDOjpJZGVudGlmaWVyVUNoYXJCdWZmZXJUcmFuc2xhdG9y OwogICAgIGZyaWVuZCBzdHJ1Y3QgV1RGOjpDU3RyaW5nVHJhbnNsYXRvcjsKICAgICBmcmllbmQg c3RydWN0IFdURjo6SGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yOworICAgIGZyaWVuZCBzdHJ1 Y3QgV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOwogICAgIGZyaWVuZCBzdHJ1 Y3QgV1RGOjpVQ2hhckJ1ZmZlclRyYW5zbGF0b3I7CiAgICAgZnJpZW5kIGNsYXNzIEF0b21pY1N0 cmluZ0ltcGw7CiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQv V1RGU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuaAppbmRleCBl OWQ2YWU0Li5lYjk1YjQxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZT dHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuaApAQCAtMzA5 LDYgKzMwOSw4IEBAIHB1YmxpYzoKICAgICBTdHJpbmcoY29uc3QgQUVDSEFSKik7CiAjZW5kaWYK IAorICAgIC8vIFN0cmluZzo6ZnJvbVVURjggd2lsbCByZXR1cm4gYSBudWxsIHN0cmluZyBpZgor ICAgIC8vIHRoZSBpbnB1dCBkYXRhIGNvbnRhaW5zIGludmFsaWQgVVRGLTggc2VxdWVuY2VzLgog ICAgIHN0YXRpYyBTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hhciosIHNpemVfdCk7CiAgICAgc3Rh dGljIFN0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKik7CiAKZGlmZiAtLWdpdCBhL0phdmFTY3Jp cHRDb3JlL3d0Zi91bmljb2RlL1VURjguY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUv VVRGOC5jcHAKaW5kZXggY2E0ZmMxYy4uZGMyNGVkNSAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENv cmUvd3RmL3VuaWNvZGUvVVRGOC5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUv VVRGOC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3IEFwcGxl IEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgUGF0cmlj ayBHYW5zdGVyZXIgPHBhcm9nYUBwYXJvZ2EuY29tPgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCkBAIC0yNSw2ICsyNiw3IEBACiAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJVVEY4LmgiCisjaW5jbHVkZSA8d3RmL1N0cmluZ0hhc2hlci5oPgogCiAjaW5jbHVkZSAiQVND SUlDVHlwZS5oIgogCkBAIC0zMiw3ICszNCw3IEBAIG5hbWVzcGFjZSBXVEYgewogbmFtZXNwYWNl IFVuaWNvZGUgewogCiAvLyBGSVhNRTogVXNlIGRlZmluaXRpb24gZnJvbSBDaGFyYWN0ZXJOYW1l cy5oLgotY29uc3QgVUNoYXIgcmVwbGFjZW1lbnRDaGFyYWN0ZXIgPSAweEZGRkQ7CitzdGF0aWMg Y29uc3QgVUNoYXIgcmVwbGFjZW1lbnRDaGFyYWN0ZXIgPSAweEZGRkQ7CiAKIGlubGluZSBpbnQg aW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoTm9uQVNDSUkoY2hhciBiMCkKIHsKQEAgLTMxNCw1ICsz MTYsODYgQEAgQ29udmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGOFRvVVRGMTYoCiAgICAgcmV0dXJu IHJlc3VsdDsKIH0KIAordW5zaWduZWQgY2FsY3VsYXRlU3RyaW5nSGFzaEZyb21VVEY4KGNvbnN0 IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVkJiB1dGYxNkxlbmd0aCkK K3sKKyAgICBpZiAoIWRhdGEpCisgICAgICAgIHJldHVybiAwOworCisgICAgV1RGOjpTdHJpbmdI YXNoZXIgc3RyaW5nSGFzaGVyOworICAgIHV0ZjE2TGVuZ3RoID0gMDsKKworICAgIHdoaWxlIChk YXRhIDwgZGF0YUVuZCkgeworICAgICAgICBpZiAoaXNBU0NJSSgqZGF0YSkpIHsKKyAgICAgICAg ICAgIHN0cmluZ0hhc2hlci5hZGRDaGFyYWN0ZXIoKmRhdGErKyk7CisgICAgICAgICAgICB1dGYx Nkxlbmd0aCsrOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBp bnQgdXRmOFNlcXVlbmNlTGVuZ3RoID0gaW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoTm9uQVNDSUko KmRhdGEpOworCisgICAgICAgIGlmIChkYXRhRW5kIC0gZGF0YSA8IHV0ZjhTZXF1ZW5jZUxlbmd0 aCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICBpZiAoIWlzTGVnYWxVVEY4 KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgdW5zaWduZWQgY2hhcio+KGRhdGEpLCB1dGY4U2VxdWVu Y2VMZW5ndGgpKQorICAgICAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgICAgVUNoYXIzMiBjaGFy YWN0ZXIgPSByZWFkVVRGOFNlcXVlbmNlKGRhdGEsIHV0ZjhTZXF1ZW5jZUxlbmd0aCk7CisgICAg ICAgIEFTU0VSVCghaXNBU0NJSShjaGFyYWN0ZXIpKTsKKworICAgICAgICBpZiAoVV9JU19CTVAo Y2hhcmFjdGVyKSkgeworICAgICAgICAgICAgLy8gVVRGLTE2IHN1cnJvZ2F0ZSB2YWx1ZXMgYXJl IGlsbGVnYWwgaW4gVVRGLTMyCisgICAgICAgICAgICBpZiAoVV9JU19TVVJST0dBVEUoY2hhcmFj dGVyKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgICAgIHN0cmluZ0hhc2hl ci5hZGRDaGFyYWN0ZXIoc3RhdGljX2Nhc3Q8VUNoYXI+KGNoYXJhY3RlcikpOyAvLyBub3JtYWwg Y2FzZQorICAgICAgICAgICAgdXRmMTZMZW5ndGgrKzsKKyAgICAgICAgfSBlbHNlIGlmIChVX0lT X1NVUFBMRU1FTlRBUlkoY2hhcmFjdGVyKSkgeworICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFk ZENoYXJhY3RlcnMoc3RhdGljX2Nhc3Q8VUNoYXI+KFUxNl9MRUFEKGNoYXJhY3RlcikpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RhdGljX2Nhc3Q8VUNoYXI+KFUx Nl9UUkFJTChjaGFyYWN0ZXIpKSk7CisgICAgICAgICAgICB1dGYxNkxlbmd0aCArPSAyOworICAg ICAgICB9IGVsc2UKKyAgICAgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIHJldHVybiBz dHJpbmdIYXNoZXIuaGFzaCgpOworfQorCitib29sIGVxdWFsVVRGMTZXaXRoVVRGOChjb25zdCBV Q2hhciogYSwgY29uc3QgVUNoYXIqIGFFbmQsIGNvbnN0IGNoYXIqIGIsIGNvbnN0IGNoYXIqIGJF bmQpCit7CisgICAgd2hpbGUgKGIgPCBiRW5kKSB7CisgICAgICAgIGlmIChpc0FTQ0lJKCpiKSkg eworICAgICAgICAgICAgaWYgKCphKysgIT0gKmIrKykKKyAgICAgICAgICAgICAgICByZXR1cm4g ZmFsc2U7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGludCB1 dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJSSgqYik7 CisKKyAgICAgICAgaWYgKGJFbmQgLSBiIDwgdXRmOFNlcXVlbmNlTGVuZ3RoKQorICAgICAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIGlmICghaXNMZWdhbFVURjgocmVpbnRlcnByZXRf Y2FzdDxjb25zdCB1bnNpZ25lZCBjaGFyKj4oYiksIHV0ZjhTZXF1ZW5jZUxlbmd0aCkpCisgICAg ICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBVQ2hhcjMyIGNoYXJhY3RlciA9IHJlYWRVVEY4 U2VxdWVuY2UoYiwgdXRmOFNlcXVlbmNlTGVuZ3RoKTsKKyAgICAgICAgQVNTRVJUKCFpc0FTQ0lJ KGNoYXJhY3RlcikpOworCisgICAgICAgIGlmIChVX0lTX0JNUChjaGFyYWN0ZXIpKSB7CisgICAg ICAgICAgICAvLyBVVEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBhcmUgaWxsZWdhbCBpbiBVVEYtMzIK KyAgICAgICAgICAgIGlmIChVX0lTX1NVUlJPR0FURShjaGFyYWN0ZXIpKQorICAgICAgICAgICAg ICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IGNoYXJhY3RlcikKKyAg ICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZSBpZiAoVV9JU19TVVBQ TEVNRU5UQVJZKGNoYXJhY3RlcikpIHsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IFUxNl9MRUFE KGNoYXJhY3RlcikpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAg aWYgKCphKysgIT0gVTE2X1RSQUlMKGNoYXJhY3RlcikpCisgICAgICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9 CisKKyAgICByZXR1cm4gYSA9PSBhRW5kOworfQorCiB9IC8vIG5hbWVzcGFjZSBVbmljb2RlCiB9 IC8vIG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2Rl L1VURjguaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguaAppbmRleCBhNWVkOTNl Li4xZjRiYWNhIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgK KysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCkBAIC0yOSw3ICsyOSw3IEBA CiAjaW5jbHVkZSAiVW5pY29kZS5oIgogCiBuYW1lc3BhY2UgV1RGIHsKLSAgbmFtZXNwYWNlIFVu aWNvZGUgeworbmFtZXNwYWNlIFVuaWNvZGUgewogCiAgICAgLy8gR2l2ZW4gYSBmaXJzdCBieXRl LCBnaXZlcyB0aGUgbGVuZ3RoIG9mIHRoZSBVVEYtOCBzZXF1ZW5jZSBpdCBiZWdpbnMuCiAgICAg Ly8gUmV0dXJucyAwIGZvciBieXRlcyB0aGF0IGFyZSBub3QgbGVnYWwgc3RhcnRzIG9mIFVURi04 IHNlcXVlbmNlcy4KQEAgLTY5LDcgKzY5LDEyIEBAIG5hbWVzcGFjZSBXVEYgewogICAgIENvbnZl cnNpb25SZXN1bHQgY29udmVydFVURjE2VG9VVEY4KAogICAgICAgICAgICAgICAgICAgICBjb25z dCBVQ2hhcioqIHNvdXJjZVN0YXJ0LCBjb25zdCBVQ2hhciogc291cmNlRW5kLCAKICAgICAgICAg ICAgICAgICAgICAgY2hhcioqIHRhcmdldFN0YXJ0LCBjaGFyKiB0YXJnZXRFbmQsIGJvb2wgc3Ry aWN0ID0gdHJ1ZSk7Ci0gIH0KLX0KKworICAgIHVuc2lnbmVkIGNhbGN1bGF0ZVN0cmluZ0hhc2hG cm9tVVRGOChjb25zdCBjaGFyKiBkYXRhLCBjb25zdCBjaGFyKiBkYXRhRW5kLCB1bnNpZ25lZCYg dXRmMTZMZW5ndGgpOworCisgICAgYm9vbCBlcXVhbFVURjE2V2l0aFVURjgoY29uc3QgVUNoYXIq IGEsIGNvbnN0IFVDaGFyKiBhRW5kLCBjb25zdCBjaGFyKiBiLCBjb25zdCBjaGFyKiBiRW5kKTsK KworfSAvLyBuYW1lc3BhY2UgVW5pY29kZQorfSAvLyBuYW1lc3BhY2UgV1RGCiAKICNlbmRpZiAv LyBXVEZfVVRGOF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGRjZDYxYjMuLmJkMzgxMzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTAtMTItMDEg IFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21pY1N0cmluZzo6ZnJvbVVU RjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NTk0 CisKKyAgICAgICAgVXNlIEF0b21pY1N0cmluZzo6ZnJvbVVURjggZGlyZWN0bHkgaW4gdGhlIGxp YnhtbDIgcGFyc2VyLgorCisgICAgICAgICogZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHA6CisgICAgICAgIChXZWJDb3JlOjp0b0F0b21pY1N0cmluZyk6CisKIDIwMTAtMTItMDEgIFBh dHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgQW5kcmVhcyBLbGluZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFy c2VyTGlieG1sMi5jcHAgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3Bw CmluZGV4IDdhMzI4NWYuLjIzZjk4ODMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1hNTERvY3Vt ZW50UGFyc2VyTGlieG1sMi5jcHAKKysrIGIvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJM aWJ4bWwyLmNwcApAQCAtNjg2LDE0ICs2ODYsMTIgQEAgc3RhdGljIGlubGluZSBTdHJpbmcgdG9T dHJpbmcoY29uc3QgeG1sQ2hhciogc3RyaW5nKQogCiBzdGF0aWMgaW5saW5lIEF0b21pY1N0cmlu ZyB0b0F0b21pY1N0cmluZyhjb25zdCB4bWxDaGFyKiBzdHJpbmcsIHNpemVfdCBzaXplKQogewot ICAgIC8vIEZJWE1FOiBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOC4KLSAgICByZXR1cm4gQXRv bWljU3RyaW5nKHRvU3RyaW5nKHN0cmluZywgc2l6ZSkpOworICAgIHJldHVybiBBdG9taWNTdHJp bmc6OmZyb21VVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KHN0cmluZyksIHNpemUp OwogfQogCiBzdGF0aWMgaW5saW5lIEF0b21pY1N0cmluZyB0b0F0b21pY1N0cmluZyhjb25zdCB4 bWxDaGFyKiBzdHJpbmcpCiB7Ci0gICAgLy8gRklYTUU6IFVzZSBBdG9taWNTdHJpbmc6OmZyb21V VEY4LgotICAgIHJldHVybiBBdG9taWNTdHJpbmcodG9TdHJpbmcoc3RyaW5nKSk7CisgICAgcmV0 dXJuIEF0b21pY1N0cmluZzo6ZnJvbVVURjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4o c3RyaW5nKSk7CiB9CiAKIHN0cnVjdCBfeG1sU0FYMk5hbWVzcGFjZSB7Cg== 75312 2010-12-01 13:15:20 -0800 2010-12-02 13:56:16 -0800 Patch bug-45594h.patch text/plain 16003 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3ZGY5NzEyLi4yYWZjMzMwIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUg QEAKKzIwMTAtMTItMDEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21p Y1N0cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlU3RyaW5nSGFzaEZy b21VVEY4IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisg ICAgICAgIGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZl cnNhdGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVj aWFsaXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4K KworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29y ZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmOgorICAgICAgICAqIHd0 Zi90ZXh0L0F0b21pY1N0cmluZy5jcHA6CisgICAgICAgIChXVEY6OkNTdHJpbmdUcmFuc2xhdG9y OjplcXVhbCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6 Omhhc2gpOgorICAgICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjpl cXVhbCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6OnRy YW5zbGF0ZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6YWRkKToKKyAgICAgICAgKFdU Rjo6QXRvbWljU3RyaW5nOjphZGRTbG93Q2FzZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmlu Zzo6ZmluZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6ZnJvbVVURjgpOgorICAgICAg ICAqIHd0Zi90ZXh0L0F0b21pY1N0cmluZy5oOgorICAgICAgICAqIHd0Zi90ZXh0L1N0cmluZ0lt cGwuaDoKKyAgICAgICAgKiB3dGYvdGV4dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdW5p Y29kZS9VVEY4LmNwcDoKKyAgICAgICAgKFdURjo6VW5pY29kZTo6cmVhZFVURjhTZXF1ZW5jZSk6 CisgICAgICAgIChXVEY6OlVuaWNvZGU6OmNvbnZlcnRVVEY4VG9VVEYxNik6CisgICAgICAgIChX VEY6OlVuaWNvZGU6OmNhbGN1bGF0ZVN0cmluZ0hhc2hGcm9tVVRGOCk6CisgICAgICAgIChXVEY6 OlVuaWNvZGU6OmVxdWFsVVRGMTZXaXRoVVRGOCk6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRG OC5oOgorCiAyMDEwLTExLTMwICBHYXZpbiBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL0ph dmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3Jp cHRDb3JlLmV4cAppbmRleCBjZGIzY2U3Li43MzAzYjJiIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENv cmUuZXhwCkBAIC0zNzEsNiArMzcxLDggQEAgX19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0 agogX19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0amoKIF9fWk4zV1RGMTJBdG9taWNTdHJp bmc0ZmluZEVQS3RqagogX19aTjNXVEYxMkF0b21pY1N0cmluZzRpbml0RXYKK19fWk4zV1RGMTJB dG9taWNTdHJpbmc4ZnJvbVVURjhFUEtjCitfX1pOM1dURjEyQXRvbWljU3RyaW5nOGZyb21VVEY4 RVBLY20KIF9fWk4zV1RGMTJjcmVhdGVUaHJlYWRFUEZQdlMwX0VTMF8KIF9fWk4zV1RGMTJjcmVh dGVUaHJlYWRFUEZQdlMwX0VTMF9QS2MKIF9fWk4zV1RGMTJkZXRhY2hUaHJlYWRFagpkaWZmIC0t Z2l0IGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLmRlZiBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJv ai9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5kZWYKaW5kZXggNDJhYzdmMS4uOGI4NWU2 NiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFT Y3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmRlZgorKysgYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2Ny aXB0Q29yZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmCkBAIC01OCw2 ICs1OCw3IEBAIEVYUE9SVFMKICAgICA/YXR0YWNoQERlYnVnZ2VyQEpTQ0BAUUFFWFBBVkpTR2xv YmFsT2JqZWN0QDJAQFoKICAgICA/YnJvYWRjYXN0QFRocmVhZENvbmRpdGlvbkBXVEZAQFFBRVhY WgogICAgID9idWZmZXJMZW5ndGhGb3JTdHJpbmdEZWNpbWFsQERlY2ltYWxOdW1iZXJAV1RGQEBR QkVJWFoKKyAgICA/Y2FsY3VsYXRlU3RyaW5nSGFzaEZyb21VVEY4QFVuaWNvZGVAV1RGQEBZQUlQ QkQwQUFJQFoKICAgICA/Y2FsY3VsYXRlZEZ1bmN0aW9uTmFtZUBEZWJ1Z2dlckNhbGxGcmFtZUBK U0NAQFFCRT9BVlVTdHJpbmdAMkBYWgogICAgID9jYWxjdWxhdGVVVENPZmZzZXRAV1RGQEBZQUhY WgogICAgID9jYWxjdWxhdGVEU1RPZmZzZXRAV1RGQEBZQU5OTkBaCkBAIC0xMzksNiArMTQwLDcg QEAgRVhQT1JUUwogICAgID9lbXB0eUBTdHJpbmdJbXBsQFdURkBAU0FQQVYxMkBYWgogICAgID9l bnVtZXJhYmxlQFByb3BlcnR5RGVzY3JpcHRvckBKU0NAQFFCRV9OWFoKICAgICA/ZXF1YWxASWRl bnRpZmllckBKU0NAQFNBX05QQlZTdHJpbmdJbXBsQFdURkBAUEJEQFoKKyAgICA/ZXF1YWxVVEYx NldpdGhVVEY4QFVuaWNvZGVAV1RGQEBZQV9OUEJfVzBQQkQxQFoKICAgICA/ZXZhbHVhdGVARGVi dWdnZXJDYWxsRnJhbWVASlNDQEBRQkU/QVZKU1ZhbHVlQDJAQUJWVVN0cmluZ0AyQEFBVjMyQEBa CiAgICAgP2V2YWx1YXRlQEpTQ0BAWUE/QVZDb21wbGV0aW9uQDFAUEFWRXhlY1N0YXRlQDFAQUFW U2NvcGVDaGFpbkAxQEFCVlNvdXJjZUNvZGVAMUBWSlNWYWx1ZUAxQEBaCiAgICAgP2V4Y2x1ZGVA UHJvZmlsZUBKU0NAQFFBRVhQQlZQcm9maWxlTm9kZUAyQEBaCmRpZmYgLS1naXQgYS9KYXZhU2Ny aXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3Rl eHQvQXRvbWljU3RyaW5nLmNwcAppbmRleCBjNDlhODM3Li44YzkwZThhIDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwCisrKyBiL0phdmFTY3JpcHRD b3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMCBQYXRyaWNrIEdhbnN0ZXJlciA8 cGFyb2dhQHBhcm9nYS5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTI2LDkgKzI3LDEyIEBA CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAj aW5jbHVkZSA8d3RmL1dURlRocmVhZERhdGEuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9VVEY4 Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCit1c2luZyBuYW1lc3BhY2UgVW5pY29kZTsKKwogQ09N UElMRV9BU1NFUlQoc2l6ZW9mKEF0b21pY1N0cmluZykgPT0gc2l6ZW9mKFN0cmluZyksIGF0b21p Y19zdHJpbmdfYW5kX3N0cmluZ19tdXN0X2JlX3NhbWVfc2l6ZSk7CiAKIGNsYXNzIEF0b21pY1N0 cmluZ1RhYmxlIHsKQEAgLTg1LDcgKzg5LDcgQEAgc3RydWN0IENTdHJpbmdUcmFuc2xhdG9yIHsK ICAgICAgICAgICAgIGlmIChkW2ldICE9IGMpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiBzW2xlbmd0aF0gPT0gMDsKKyAgICAgICAgcmV0 dXJuICFzW2xlbmd0aF07CiAgICAgfQogCiAgICAgc3RhdGljIHZvaWQgdHJhbnNsYXRlKFN0cmlu Z0ltcGwqJiBsb2NhdGlvbiwgY29uc3QgY2hhciogY29uc3QmIGMsIHVuc2lnbmVkIGhhc2gpCkBA IC0yMDYsMTIgKzIxMCw0NCBAQCBzdHJ1Y3QgSGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yIHsK ICAgICB9CiB9OwogCitzdHJ1Y3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzIHsKKyAgICB1bnNpZ25l ZCBoYXNoOworICAgIGNvbnN0IGNoYXIqIGNoYXJhY3RlcnM7CisgICAgdW5zaWduZWQgbGVuZ3Ro OworICAgIHVuc2lnbmVkIHV0ZjE2TGVuZ3RoOworfTsKKworc3RydWN0IEhhc2hBbmRVVEY4Q2hh cmFjdGVyc1RyYW5zbGF0b3IgeworICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEhhc2hB bmRVVEY4Q2hhcmFjdGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGJ1ZmZlci5o YXNoOworICAgIH0KKworICAgIHN0YXRpYyBib29sIGVxdWFsKFN0cmluZ0ltcGwqIGNvbnN0JiBz dHJpbmcsIGNvbnN0IEhhc2hBbmRVVEY4Q2hhcmFjdGVycyYgYnVmZmVyKQorICAgIHsKKyAgICAg ICAgcmV0dXJuIGVxdWFsVVRGMTZXaXRoVVRGOChzdHJpbmctPmNoYXJhY3RlcnMoKSwgc3RyaW5n LT5jaGFyYWN0ZXJzKCkgKyBzdHJpbmctPmxlbmd0aCgpLCBidWZmZXIuY2hhcmFjdGVycywgYnVm ZmVyLmNoYXJhY3RlcnMgKyBidWZmZXIubGVuZ3RoKTsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9p ZCB0cmFuc2xhdGUoU3RyaW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBIYXNoQW5kVVRGOENoYXJh Y3RlcnMmIGJ1ZmZlciwgdW5zaWduZWQgaGFzaCkKKyAgICB7CisgICAgICAgIFVDaGFyKiB0YXJn ZXQ7CisgICAgICAgIGxvY2F0aW9uID0gU3RyaW5nSW1wbDo6Y3JlYXRlVW5pbml0aWFsaXplZChi dWZmZXIudXRmMTZMZW5ndGgsIHRhcmdldCkucmVsZWFzZVJlZigpOworCisgICAgICAgIGNvbnN0 IGNoYXIqIHNvdXJjZSA9IGJ1ZmZlci5jaGFyYWN0ZXJzOworICAgICAgICBpZiAoY29udmVydFVU RjhUb1VURjE2KCZzb3VyY2UsIHNvdXJjZSArIGJ1ZmZlci5sZW5ndGgsICZ0YXJnZXQsIHRhcmdl dCArIGJ1ZmZlci51dGYxNkxlbmd0aCkgIT0gY29udmVyc2lvbk9LKQorICAgICAgICAgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7CisKKyAgICAgICAgbG9jYXRpb24tPnNldEhhc2goaGFzaCk7Cisg ICAgICAgIGxvY2F0aW9uLT5zZXRJc0F0b21pYyh0cnVlKTsKKyAgICB9Cit9OworCiBQYXNzUmVm UHRyPFN0cmluZ0ltcGw+IEF0b21pY1N0cmluZzo6YWRkKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25l ZCBsZW5ndGgpCiB7CiAgICAgaWYgKCFzKQogICAgICAgICByZXR1cm4gMDsKIAotICAgIGlmIChs ZW5ndGggPT0gMCkKKyAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6 OmVtcHR5KCk7CiAgICAgCiAgICAgVUNoYXJCdWZmZXIgYnVmID0geyBzLCBsZW5ndGggfTsgCkBA IC0yMjcsNyArMjYzLDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFk ZChjb25zdCBVQ2hhciogcywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ24KICAgICBBU1NFUlQocyk7 CiAgICAgQVNTRVJUKGV4aXN0aW5nSGFzaCk7CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAg aWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBTdHJpbmdJbXBsOjplbXB0eSgpOwogICAgIAog ICAgIEhhc2hBbmRDaGFyYWN0ZXJzIGJ1ZmZlciA9IHsgZXhpc3RpbmdIYXNoLCBzLCBsZW5ndGgg fTsgCkBAIC0yNDYsNyArMjgyLDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJp bmc6OmFkZChjb25zdCBVQ2hhciogcykKICAgICB3aGlsZSAoc1tsZW5ndGhdICE9IFVDaGFyKDAp KQogICAgICAgICBsZW5ndGgrKzsKIAotICAgIGlmIChsZW5ndGggPT0gMCkKKyAgICBpZiAoIWxl bmd0aCkKICAgICAgICAgcmV0dXJuIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiAKICAgICBVQ2hhckJ1 ZmZlciBidWYgPSB7cywgbGVuZ3RofTsgCkBAIC0yNjIsNyArMjk4LDcgQEAgUGFzc1JlZlB0cjxT dHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFkZFNsb3dDYXNlKFN0cmluZ0ltcGwqIHIpCiAgICAg aWYgKCFyIHx8IHItPmlzQXRvbWljKCkpCiAgICAgICAgIHJldHVybiByOwogCi0gICAgaWYgKHIt Pmxlbmd0aCgpID09IDApCisgICAgaWYgKCFyLT5sZW5ndGgoKSkKICAgICAgICAgcmV0dXJuIFN0 cmluZ0ltcGw6OmVtcHR5KCk7CiAKICAgICBTdHJpbmdJbXBsKiByZXN1bHQgPSAqc3RyaW5nVGFi bGUoKS5hZGQocikuZmlyc3Q7CkBAIC0yNzYsNyArMzEyLDcgQEAgQXRvbWljU3RyaW5nSW1wbCog QXRvbWljU3RyaW5nOjpmaW5kKGNvbnN0IFVDaGFyKiBzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2ln bmVkIGUKICAgICBBU1NFUlQocyk7CiAgICAgQVNTRVJUKGV4aXN0aW5nSGFzaCk7CiAKLSAgICBp ZiAobGVuZ3RoID09IDApCisgICAgaWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBzdGF0aWNf Y2FzdDxBdG9taWNTdHJpbmdJbXBsKj4oU3RyaW5nSW1wbDo6ZW1wdHkoKSk7CiAKICAgICBIYXNo QW5kQ2hhcmFjdGVycyBidWZmZXIgPSB7IGV4aXN0aW5nSGFzaCwgcywgbGVuZ3RoIH07IApAQCAt MjkwLDcgKzMyNiw3IEBAIHZvaWQgQXRvbWljU3RyaW5nOjpyZW1vdmUoU3RyaW5nSW1wbCogcikK IHsKICAgICBzdHJpbmdUYWJsZSgpLnJlbW92ZShyKTsKIH0KLSAgICAKKwogQXRvbWljU3RyaW5n IEF0b21pY1N0cmluZzo6bG93ZXIoKSBjb25zdAogewogICAgIC8vIE5vdGU6IFRoaXMgaXMgYSBo b3QgZnVuY3Rpb24gaW4gdGhlIERyb21hZW8gYmVuY2htYXJrLgpAQCAtMzAzLDQgKzMzOSwzNiBA QCBBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpsb3dlcigpIGNvbnN0CiAgICAgcmV0dXJuIEF0 b21pY1N0cmluZyhuZXdJbXBsKTsKIH0KIAorQXRvbWljU3RyaW5nIEF0b21pY1N0cmluZzo6ZnJv bVVURjgoY29uc3QgY2hhciogY2hhcmFjdGVycywgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBpZiAo IWNoYXJhY3RlcnMpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIGlmICgh bGVuZ3RoKQorICAgICAgICByZXR1cm4gZW1wdHlBdG9tOworCisgICAgSGFzaEFuZFVURjhDaGFy YWN0ZXJzIGJ1ZmZlcjsKKyAgICBidWZmZXIuY2hhcmFjdGVycyA9IGNoYXJhY3RlcnM7CisgICAg YnVmZmVyLmxlbmd0aCA9IGxlbmd0aDsKKyAgICBidWZmZXIuaGFzaCA9IGNhbGN1bGF0ZVN0cmlu Z0hhc2hGcm9tVVRGOChjaGFyYWN0ZXJzLCBjaGFyYWN0ZXJzICsgbGVuZ3RoLCBidWZmZXIudXRm MTZMZW5ndGgpOworCisgICAgaWYgKCFidWZmZXIuaGFzaCkKKyAgICAgICAgcmV0dXJuIEF0b21p Y1N0cmluZygpOworCisgICAgcGFpcjxIYXNoU2V0PFN0cmluZ0ltcGwqPjo6aXRlcmF0b3IsIGJv b2w+IGFkZFJlc3VsdCA9IHN0cmluZ1RhYmxlKCkuYWRkPEhhc2hBbmRVVEY4Q2hhcmFjdGVycywg SGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJhbnNsYXRvcj4oYnVmZmVyKTsKKworICAgIC8vIElmIHRo ZSBzdHJpbmcgaXMgbmV3bHktdHJhbnNsYXRlZCwgdGhlbiB3ZSBuZWVkIHRvIGFkb3B0IGl0Lgor ICAgIC8vIFRoZSBib29sZWFuIGluIHRoZSBwYWlyIHRlbGxzIHVzIGlmIHRoYXQgaXMgc28uCisg ICAgQXRvbWljU3RyaW5nIGF0b21pY1N0cmluZzsKKyAgICBhdG9taWNTdHJpbmcubV9zdHJpbmcg PSBhZGRSZXN1bHQuc2Vjb25kID8gYWRvcHRSZWYoKmFkZFJlc3VsdC5maXJzdCkgOiAqYWRkUmVz dWx0LmZpcnN0OworICAgIHJldHVybiBhdG9taWNTdHJpbmc7CiB9CisKK0F0b21pY1N0cmluZyBB dG9taWNTdHJpbmc6OmZyb21VVEY4KGNvbnN0IGNoYXIqIGNoYXJhY3RlcnMpCit7CisgICAgaWYg KCFjaGFyYWN0ZXJzKQorICAgICAgICByZXR1cm4gQXRvbWljU3RyaW5nKCk7CisgICAgcmV0dXJu IGZyb21VVEY4KGNoYXJhY3RlcnMsIHN0cmxlbihjaGFyYWN0ZXJzKSk7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3Ry aW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaAppbmRleCAwNmU2 M2Y0Li5hYjViMzY2IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNT dHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNTdHJpbmcuaApAQCAt MTA4LDYgKzEwOCwxMSBAQCBwdWJsaWM6CiAgICAgb3BlcmF0b3IgUVN0cmluZygpIGNvbnN0IHsg cmV0dXJuIG1fc3RyaW5nOyB9CiAjZW5kaWYKIAorICAgIC8vIEF0b21pY1N0cmluZzo6ZnJvbVVU Rjggd2lsbCByZXR1cm4gYSBudWxsIHN0cmluZyBpZgorICAgIC8vIHRoZSBpbnB1dCBkYXRhIGNv bnRhaW5zIGludmFsaWQgVVRGLTggc2VxdWVuY2VzLgorICAgIHN0YXRpYyBBdG9taWNTdHJpbmcg ZnJvbVVURjgoY29uc3QgY2hhciosIHNpemVfdCk7CisgICAgc3RhdGljIEF0b21pY1N0cmluZyBm cm9tVVRGOChjb25zdCBjaGFyKik7CisKIHByaXZhdGU6CiAgICAgU3RyaW5nIG1fc3RyaW5nOwog ICAgIApkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oIGIv SmF2YVNjcmlwdENvcmUvd3RmL3RleHQvU3RyaW5nSW1wbC5oCmluZGV4IDk5ZDBlOWQuLmRjMWRi YjIgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaAorKysg Yi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKQEAgLTUzLDYgKzUzLDcgQEAg bmFtZXNwYWNlIFdURiB7CiAKIHN0cnVjdCBDU3RyaW5nVHJhbnNsYXRvcjsKIHN0cnVjdCBIYXNo QW5kQ2hhcmFjdGVyc1RyYW5zbGF0b3I7CitzdHJ1Y3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzVHJh bnNsYXRvcjsKIHN0cnVjdCBVQ2hhckJ1ZmZlclRyYW5zbGF0b3I7CiAKIGVudW0gVGV4dENhc2VT ZW5zaXRpdml0eSB7IFRleHRDYXNlU2Vuc2l0aXZlLCBUZXh0Q2FzZUluc2Vuc2l0aXZlIH07CkBA IC02Niw2ICs2Nyw3IEBAIGNsYXNzIFN0cmluZ0ltcGwgOiBwdWJsaWMgU3RyaW5nSW1wbEJhc2Ug ewogICAgIGZyaWVuZCBzdHJ1Y3QgSlNDOjpJZGVudGlmaWVyVUNoYXJCdWZmZXJUcmFuc2xhdG9y OwogICAgIGZyaWVuZCBzdHJ1Y3QgV1RGOjpDU3RyaW5nVHJhbnNsYXRvcjsKICAgICBmcmllbmQg c3RydWN0IFdURjo6SGFzaEFuZENoYXJhY3RlcnNUcmFuc2xhdG9yOworICAgIGZyaWVuZCBzdHJ1 Y3QgV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOwogICAgIGZyaWVuZCBzdHJ1 Y3QgV1RGOjpVQ2hhckJ1ZmZlclRyYW5zbGF0b3I7CiAgICAgZnJpZW5kIGNsYXNzIEF0b21pY1N0 cmluZ0ltcGw7CiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQv V1RGU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuaAppbmRleCBl OWQ2YWU0Li5lYjk1YjQxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZT dHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9XVEZTdHJpbmcuaApAQCAtMzA5 LDYgKzMwOSw4IEBAIHB1YmxpYzoKICAgICBTdHJpbmcoY29uc3QgQUVDSEFSKik7CiAjZW5kaWYK IAorICAgIC8vIFN0cmluZzo6ZnJvbVVURjggd2lsbCByZXR1cm4gYSBudWxsIHN0cmluZyBpZgor ICAgIC8vIHRoZSBpbnB1dCBkYXRhIGNvbnRhaW5zIGludmFsaWQgVVRGLTggc2VxdWVuY2VzLgog ICAgIHN0YXRpYyBTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hhciosIHNpemVfdCk7CiAgICAgc3Rh dGljIFN0cmluZyBmcm9tVVRGOChjb25zdCBjaGFyKik7CiAKZGlmZiAtLWdpdCBhL0phdmFTY3Jp cHRDb3JlL3d0Zi91bmljb2RlL1VURjguY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUv VVRGOC5jcHAKaW5kZXggY2E0ZmMxYy4uZGMyNGVkNSAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENv cmUvd3RmL3VuaWNvZGUvVVRGOC5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUv VVRGOC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3IEFwcGxl IEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgUGF0cmlj ayBHYW5zdGVyZXIgPHBhcm9nYUBwYXJvZ2EuY29tPgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCkBAIC0yNSw2ICsyNiw3IEBACiAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJVVEY4LmgiCisjaW5jbHVkZSA8d3RmL1N0cmluZ0hhc2hlci5oPgogCiAjaW5jbHVkZSAiQVND SUlDVHlwZS5oIgogCkBAIC0zMiw3ICszNCw3IEBAIG5hbWVzcGFjZSBXVEYgewogbmFtZXNwYWNl IFVuaWNvZGUgewogCiAvLyBGSVhNRTogVXNlIGRlZmluaXRpb24gZnJvbSBDaGFyYWN0ZXJOYW1l cy5oLgotY29uc3QgVUNoYXIgcmVwbGFjZW1lbnRDaGFyYWN0ZXIgPSAweEZGRkQ7CitzdGF0aWMg Y29uc3QgVUNoYXIgcmVwbGFjZW1lbnRDaGFyYWN0ZXIgPSAweEZGRkQ7CiAKIGlubGluZSBpbnQg aW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoTm9uQVNDSUkoY2hhciBiMCkKIHsKQEAgLTMxNCw1ICsz MTYsODYgQEAgQ29udmVyc2lvblJlc3VsdCBjb252ZXJ0VVRGOFRvVVRGMTYoCiAgICAgcmV0dXJu IHJlc3VsdDsKIH0KIAordW5zaWduZWQgY2FsY3VsYXRlU3RyaW5nSGFzaEZyb21VVEY4KGNvbnN0 IGNoYXIqIGRhdGEsIGNvbnN0IGNoYXIqIGRhdGFFbmQsIHVuc2lnbmVkJiB1dGYxNkxlbmd0aCkK K3sKKyAgICBpZiAoIWRhdGEpCisgICAgICAgIHJldHVybiAwOworCisgICAgV1RGOjpTdHJpbmdI YXNoZXIgc3RyaW5nSGFzaGVyOworICAgIHV0ZjE2TGVuZ3RoID0gMDsKKworICAgIHdoaWxlIChk YXRhIDwgZGF0YUVuZCkgeworICAgICAgICBpZiAoaXNBU0NJSSgqZGF0YSkpIHsKKyAgICAgICAg ICAgIHN0cmluZ0hhc2hlci5hZGRDaGFyYWN0ZXIoKmRhdGErKyk7CisgICAgICAgICAgICB1dGYx Nkxlbmd0aCsrOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBp bnQgdXRmOFNlcXVlbmNlTGVuZ3RoID0gaW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoTm9uQVNDSUko KmRhdGEpOworCisgICAgICAgIGlmIChkYXRhRW5kIC0gZGF0YSA8IHV0ZjhTZXF1ZW5jZUxlbmd0 aCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICBpZiAoIWlzTGVnYWxVVEY4 KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgdW5zaWduZWQgY2hhcio+KGRhdGEpLCB1dGY4U2VxdWVu Y2VMZW5ndGgpKQorICAgICAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgICAgVUNoYXIzMiBjaGFy YWN0ZXIgPSByZWFkVVRGOFNlcXVlbmNlKGRhdGEsIHV0ZjhTZXF1ZW5jZUxlbmd0aCk7CisgICAg ICAgIEFTU0VSVCghaXNBU0NJSShjaGFyYWN0ZXIpKTsKKworICAgICAgICBpZiAoVV9JU19CTVAo Y2hhcmFjdGVyKSkgeworICAgICAgICAgICAgLy8gVVRGLTE2IHN1cnJvZ2F0ZSB2YWx1ZXMgYXJl IGlsbGVnYWwgaW4gVVRGLTMyCisgICAgICAgICAgICBpZiAoVV9JU19TVVJST0dBVEUoY2hhcmFj dGVyKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgICAgIHN0cmluZ0hhc2hl ci5hZGRDaGFyYWN0ZXIoc3RhdGljX2Nhc3Q8VUNoYXI+KGNoYXJhY3RlcikpOyAvLyBub3JtYWwg Y2FzZQorICAgICAgICAgICAgdXRmMTZMZW5ndGgrKzsKKyAgICAgICAgfSBlbHNlIGlmIChVX0lT X1NVUFBMRU1FTlRBUlkoY2hhcmFjdGVyKSkgeworICAgICAgICAgICAgc3RyaW5nSGFzaGVyLmFk ZENoYXJhY3RlcnMoc3RhdGljX2Nhc3Q8VUNoYXI+KFUxNl9MRUFEKGNoYXJhY3RlcikpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RhdGljX2Nhc3Q8VUNoYXI+KFUx Nl9UUkFJTChjaGFyYWN0ZXIpKSk7CisgICAgICAgICAgICB1dGYxNkxlbmd0aCArPSAyOworICAg ICAgICB9IGVsc2UKKyAgICAgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIHJldHVybiBz dHJpbmdIYXNoZXIuaGFzaCgpOworfQorCitib29sIGVxdWFsVVRGMTZXaXRoVVRGOChjb25zdCBV Q2hhciogYSwgY29uc3QgVUNoYXIqIGFFbmQsIGNvbnN0IGNoYXIqIGIsIGNvbnN0IGNoYXIqIGJF bmQpCit7CisgICAgd2hpbGUgKGIgPCBiRW5kKSB7CisgICAgICAgIGlmIChpc0FTQ0lJKCpiKSkg eworICAgICAgICAgICAgaWYgKCphKysgIT0gKmIrKykKKyAgICAgICAgICAgICAgICByZXR1cm4g ZmFsc2U7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGludCB1 dGY4U2VxdWVuY2VMZW5ndGggPSBpbmxpbmVVVEY4U2VxdWVuY2VMZW5ndGhOb25BU0NJSSgqYik7 CisKKyAgICAgICAgaWYgKGJFbmQgLSBiIDwgdXRmOFNlcXVlbmNlTGVuZ3RoKQorICAgICAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIGlmICghaXNMZWdhbFVURjgocmVpbnRlcnByZXRf Y2FzdDxjb25zdCB1bnNpZ25lZCBjaGFyKj4oYiksIHV0ZjhTZXF1ZW5jZUxlbmd0aCkpCisgICAg ICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBVQ2hhcjMyIGNoYXJhY3RlciA9IHJlYWRVVEY4 U2VxdWVuY2UoYiwgdXRmOFNlcXVlbmNlTGVuZ3RoKTsKKyAgICAgICAgQVNTRVJUKCFpc0FTQ0lJ KGNoYXJhY3RlcikpOworCisgICAgICAgIGlmIChVX0lTX0JNUChjaGFyYWN0ZXIpKSB7CisgICAg ICAgICAgICAvLyBVVEYtMTYgc3Vycm9nYXRlIHZhbHVlcyBhcmUgaWxsZWdhbCBpbiBVVEYtMzIK KyAgICAgICAgICAgIGlmIChVX0lTX1NVUlJPR0FURShjaGFyYWN0ZXIpKQorICAgICAgICAgICAg ICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IGNoYXJhY3RlcikKKyAg ICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZSBpZiAoVV9JU19TVVBQ TEVNRU5UQVJZKGNoYXJhY3RlcikpIHsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IFUxNl9MRUFE KGNoYXJhY3RlcikpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAg aWYgKCphKysgIT0gVTE2X1RSQUlMKGNoYXJhY3RlcikpCisgICAgICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9 CisKKyAgICByZXR1cm4gYSA9PSBhRW5kOworfQorCiB9IC8vIG5hbWVzcGFjZSBVbmljb2RlCiB9 IC8vIG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2Rl L1VURjguaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguaAppbmRleCBhNWVkOTNl Li4xZjRiYWNhIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmgK KysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCkBAIC0yOSw3ICsyOSw3IEBA CiAjaW5jbHVkZSAiVW5pY29kZS5oIgogCiBuYW1lc3BhY2UgV1RGIHsKLSAgbmFtZXNwYWNlIFVu aWNvZGUgeworbmFtZXNwYWNlIFVuaWNvZGUgewogCiAgICAgLy8gR2l2ZW4gYSBmaXJzdCBieXRl LCBnaXZlcyB0aGUgbGVuZ3RoIG9mIHRoZSBVVEYtOCBzZXF1ZW5jZSBpdCBiZWdpbnMuCiAgICAg Ly8gUmV0dXJucyAwIGZvciBieXRlcyB0aGF0IGFyZSBub3QgbGVnYWwgc3RhcnRzIG9mIFVURi04 IHNlcXVlbmNlcy4KQEAgLTY5LDcgKzY5LDEyIEBAIG5hbWVzcGFjZSBXVEYgewogICAgIENvbnZl cnNpb25SZXN1bHQgY29udmVydFVURjE2VG9VVEY4KAogICAgICAgICAgICAgICAgICAgICBjb25z dCBVQ2hhcioqIHNvdXJjZVN0YXJ0LCBjb25zdCBVQ2hhciogc291cmNlRW5kLCAKICAgICAgICAg ICAgICAgICAgICAgY2hhcioqIHRhcmdldFN0YXJ0LCBjaGFyKiB0YXJnZXRFbmQsIGJvb2wgc3Ry aWN0ID0gdHJ1ZSk7Ci0gIH0KLX0KKworICAgIHVuc2lnbmVkIGNhbGN1bGF0ZVN0cmluZ0hhc2hG cm9tVVRGOChjb25zdCBjaGFyKiBkYXRhLCBjb25zdCBjaGFyKiBkYXRhRW5kLCB1bnNpZ25lZCYg dXRmMTZMZW5ndGgpOworCisgICAgYm9vbCBlcXVhbFVURjE2V2l0aFVURjgoY29uc3QgVUNoYXIq IGEsIGNvbnN0IFVDaGFyKiBhRW5kLCBjb25zdCBjaGFyKiBiLCBjb25zdCBjaGFyKiBiRW5kKTsK KworfSAvLyBuYW1lc3BhY2UgVW5pY29kZQorfSAvLyBuYW1lc3BhY2UgV1RGCiAKICNlbmRpZiAv LyBXVEZfVVRGOF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGRjZDYxYjMuLmJkMzgxMzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTAtMTItMDEg IFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEF0b21pY1N0cmluZzo6ZnJvbVVU RjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NTk0 CisKKyAgICAgICAgVXNlIEF0b21pY1N0cmluZzo6ZnJvbVVURjggZGlyZWN0bHkgaW4gdGhlIGxp YnhtbDIgcGFyc2VyLgorCisgICAgICAgICogZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHA6CisgICAgICAgIChXZWJDb3JlOjp0b0F0b21pY1N0cmluZyk6CisKIDIwMTAtMTItMDEgIFBh dHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgQW5kcmVhcyBLbGluZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFy c2VyTGlieG1sMi5jcHAgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3Bw CmluZGV4IDdhMzI4NWYuLjIzZjk4ODMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1hNTERvY3Vt ZW50UGFyc2VyTGlieG1sMi5jcHAKKysrIGIvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJM aWJ4bWwyLmNwcApAQCAtNjg2LDE0ICs2ODYsMTIgQEAgc3RhdGljIGlubGluZSBTdHJpbmcgdG9T dHJpbmcoY29uc3QgeG1sQ2hhciogc3RyaW5nKQogCiBzdGF0aWMgaW5saW5lIEF0b21pY1N0cmlu ZyB0b0F0b21pY1N0cmluZyhjb25zdCB4bWxDaGFyKiBzdHJpbmcsIHNpemVfdCBzaXplKQogewot ICAgIC8vIEZJWE1FOiBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOC4KLSAgICByZXR1cm4gQXRv bWljU3RyaW5nKHRvU3RyaW5nKHN0cmluZywgc2l6ZSkpOworICAgIHJldHVybiBBdG9taWNTdHJp bmc6OmZyb21VVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KHN0cmluZyksIHNpemUp OwogfQogCiBzdGF0aWMgaW5saW5lIEF0b21pY1N0cmluZyB0b0F0b21pY1N0cmluZyhjb25zdCB4 bWxDaGFyKiBzdHJpbmcpCiB7Ci0gICAgLy8gRklYTUU6IFVzZSBBdG9taWNTdHJpbmc6OmZyb21V VEY4LgotICAgIHJldHVybiBBdG9taWNTdHJpbmcodG9TdHJpbmcoc3RyaW5nKSk7CisgICAgcmV0 dXJuIEF0b21pY1N0cmluZzo6ZnJvbVVURjgocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4o c3RyaW5nKSk7CiB9CiAKIHN0cnVjdCBfeG1sU0FYMk5hbWVzcGFjZSB7Cg== 75414 2010-12-02 13:56:16 -0800 2010-12-02 14:45:54 -0800 Patch bug-45594i.patch text/plain 16037 paroga ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA3ZGY5NzEyLi4yYWZjMzMwIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUg QEAKKzIwMTAtMTItMDEgIFBhdHJpY2sgR2Fuc3RlcmVyICA8cGFyb2dhQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgQWRkIEF0b21pY1N0 cmluZzo6ZnJvbVVURjgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQ1NTk0CisKKyAgICAgICAgVW5pY29kZTo6Y2FsY3VsYXRlU3RyaW5nSGFzaEZyb21V VEY4IGNyZWF0ZXMgYSBTdHJpbmdIYXNoIG91dCBvZiBVVEY4IGlucHV0IGRhdGEgYW5kCisgICAg ICAgIGNhbGN1bGF0ZXMgdGhlIHJlcXVpcmVkIGxlbmd0aCBmb3IgdGhlIFVURjE2IGNvbnZlcnNh dGlvbiBpbiBvbmUgc3RlcC4KKyAgICAgICAgVGhpcyBpcyB0aGVuIHVzZWQgaW4gYSBzcGVjaWFs aXplZCB0cmFuc2xhdG9yIGZvciB0aGUgc3RyaW5nIHRhYmxlIG9mIEF0b21pY1N0cmluZy4KKwor ICAgICAgICAqIEphdmFTY3JpcHRDb3JlLmV4cDoKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS52 Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmOgorICAgICAgICAqIHd0Zi90 ZXh0L0F0b21pY1N0cmluZy5jcHA6CisgICAgICAgIChXVEY6OkNTdHJpbmdUcmFuc2xhdG9yOjpl cXVhbCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6Omhh c2gpOgorICAgICAgICAoV1RGOjpIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yOjplcXVh bCk6CisgICAgICAgIChXVEY6Okhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I6OnRyYW5z bGF0ZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6YWRkKToKKyAgICAgICAgKFdURjo6 QXRvbWljU3RyaW5nOjphZGRTbG93Q2FzZSk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6 ZmluZCk6CisgICAgICAgIChXVEY6OkF0b21pY1N0cmluZzo6ZnJvbVVURjgpOgorICAgICAgICAq IHd0Zi90ZXh0L0F0b21pY1N0cmluZy5oOgorICAgICAgICAqIHd0Zi90ZXh0L1N0cmluZ0ltcGwu aDoKKyAgICAgICAgKiB3dGYvdGV4dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKiB3dGYvdW5pY29k ZS9VVEY4LmNwcDoKKyAgICAgICAgKFdURjo6VW5pY29kZTo6cmVhZFVURjhTZXF1ZW5jZSk6Cisg ICAgICAgIChXVEY6OlVuaWNvZGU6OmNvbnZlcnRVVEY4VG9VVEYxNik6CisgICAgICAgIChXVEY6 OlVuaWNvZGU6OmNhbGN1bGF0ZVN0cmluZ0hhc2hGcm9tVVRGOCk6CisgICAgICAgIChXVEY6OlVu aWNvZGU6OmVxdWFsVVRGMTZXaXRoVVRGOCk6CisgICAgICAgICogd3RmL3VuaWNvZGUvVVRGOC5o OgorCiAyMDEwLTExLTMwICBHYXZpbiBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL0phdmFT Y3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmV4cCBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLmV4cAppbmRleCBjZGIzY2U3Li43MzAzYjJiIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS5leHAKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUu ZXhwCkBAIC0zNzEsNiArMzcxLDggQEAgX19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0agog X19aTjNXVEYxMkF0b21pY1N0cmluZzNhZGRFUEt0amoKIF9fWk4zV1RGMTJBdG9taWNTdHJpbmc0 ZmluZEVQS3RqagogX19aTjNXVEYxMkF0b21pY1N0cmluZzRpbml0RXYKK19fWk4zV1RGMTJBdG9t aWNTdHJpbmc4ZnJvbVVURjhFUEtjCitfX1pOM1dURjEyQXRvbWljU3RyaW5nOGZyb21VVEY4RVBL Y20KIF9fWk4zV1RGMTJjcmVhdGVUaHJlYWRFUEZQdlMwX0VTMF8KIF9fWk4zV1RGMTJjcmVhdGVU aHJlYWRFUEZQdlMwX0VTMF9QS2MKIF9fWk4zV1RGMTJkZXRhY2hUaHJlYWRFagpkaWZmIC0tZ2l0 IGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFTY3JpcHRDb3JlL0ph dmFTY3JpcHRDb3JlLmRlZiBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJvai9K YXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5kZWYKaW5kZXggNDJhYzdmMS4uOGI4NWU2NiAx MDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLmRlZgorKysgYi9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0 Q29yZS52Y3Byb2ovSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuZGVmCkBAIC01OCw2ICs1 OCw3IEBAIEVYUE9SVFMKICAgICA/YnJvYWRjYXN0QFRocmVhZENvbmRpdGlvbkBXVEZAQFFBRVhY WgogICAgID9idWZmZXJMZW5ndGhGb3JTdHJpbmdEZWNpbWFsQERlY2ltYWxOdW1iZXJAV1RGQEBR QkVJWFoKICAgICA/Y2FsY3VsYXRlRFNUT2Zmc2V0QFdURkBAWUFOTk5AWgorICAgID9jYWxjdWxh dGVTdHJpbmdIYXNoRnJvbVVURjhAVW5pY29kZUBXVEZAQFlBSVBCRDBBQUlAWgogICAgID9jYWxj dWxhdGVVVENPZmZzZXRAV1RGQEBZQUhYWgogICAgID9jYWxjdWxhdGVkRnVuY3Rpb25OYW1lQERl YnVnZ2VyQ2FsbEZyYW1lQEpTQ0BAUUJFP0FWVVN0cmluZ0AyQFhaCiAgICAgP2NhbGxASlNDQEBZ QT9BVkpTVmFsdWVAMUBQQVZFeGVjU3RhdGVAMUBWMjFAVzRDYWxsVHlwZUAxQEFCVENhbGxEYXRh QDFAMUFCVkFyZ0xpc3RAMUBAWgpAQCAtMTM5LDYgKzE0MCw3IEBAIEVYUE9SVFMKICAgICA/ZW1w dHlAU3RyaW5nSW1wbEBXVEZAQFNBUEFWMTJAWFoKICAgICA/ZW51bWVyYWJsZUBQcm9wZXJ0eURl c2NyaXB0b3JASlNDQEBRQkVfTlhaCiAgICAgP2VxdWFsQElkZW50aWZpZXJASlNDQEBTQV9OUEJW U3RyaW5nSW1wbEBXVEZAQFBCREBaCisgICAgP2VxdWFsVVRGMTZXaXRoVVRGOEBVbmljb2RlQFdU RkBAWUFfTlBCX1cwUEJEMUBaCiAgICAgP2V2YWx1YXRlQERlYnVnZ2VyQ2FsbEZyYW1lQEpTQ0BA UUJFP0FWSlNWYWx1ZUAyQEFCVlVTdHJpbmdAMkBBQVYzMkBAWgogICAgID9ldmFsdWF0ZUBKU0NA QFlBP0FWQ29tcGxldGlvbkAxQFBBVkV4ZWNTdGF0ZUAxQEFBVlNjb3BlQ2hhaW5AMUBBQlZTb3Vy Y2VDb2RlQDFAVkpTVmFsdWVAMUBAWgogICAgID9leGNsdWRlQFByb2ZpbGVASlNDQEBRQUVYUEJW UHJvZmlsZU5vZGVAMkBAWgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRv bWljU3RyaW5nLmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAK aW5kZXggYzQ5YTgzNy4uOGM5MGU4YSAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL3Rl eHQvQXRvbWljU3RyaW5nLmNwcAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvdGV4dC9BdG9taWNT dHJpbmcuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAw NSwgMjAwNiwgMjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBD b3B5cmlnaHQgKEMpIDIwMTAgUGF0cmljayBHYW5zdGVyZXIgPHBhcm9nYUBwYXJvZ2EuY29tPgog ICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljCkBAIC0yNiw5ICsyNywxMiBAQAogI2luY2x1ZGUgPHd0Zi9IYXNo U2V0Lmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgogI2luY2x1ZGUgPHd0Zi9XVEZUaHJl YWREYXRhLmg+CisjaW5jbHVkZSA8d3RmL3VuaWNvZGUvVVRGOC5oPgogCiBuYW1lc3BhY2UgV1RG IHsKIAordXNpbmcgbmFtZXNwYWNlIFVuaWNvZGU7CisKIENPTVBJTEVfQVNTRVJUKHNpemVvZihB dG9taWNTdHJpbmcpID09IHNpemVvZihTdHJpbmcpLCBhdG9taWNfc3RyaW5nX2FuZF9zdHJpbmdf bXVzdF9iZV9zYW1lX3NpemUpOwogCiBjbGFzcyBBdG9taWNTdHJpbmdUYWJsZSB7CkBAIC04NSw3 ICs4OSw3IEBAIHN0cnVjdCBDU3RyaW5nVHJhbnNsYXRvciB7CiAgICAgICAgICAgICBpZiAoZFtp XSAhPSBjKQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICAgICAgfQotICAgICAg ICByZXR1cm4gc1tsZW5ndGhdID09IDA7CisgICAgICAgIHJldHVybiAhc1tsZW5ndGhdOwogICAg IH0KIAogICAgIHN0YXRpYyB2b2lkIHRyYW5zbGF0ZShTdHJpbmdJbXBsKiYgbG9jYXRpb24sIGNv bnN0IGNoYXIqIGNvbnN0JiBjLCB1bnNpZ25lZCBoYXNoKQpAQCAtMjA2LDEyICsyMTAsNDQgQEAg c3RydWN0IEhhc2hBbmRDaGFyYWN0ZXJzVHJhbnNsYXRvciB7CiAgICAgfQogfTsKIAorc3RydWN0 IEhhc2hBbmRVVEY4Q2hhcmFjdGVycyB7CisgICAgdW5zaWduZWQgaGFzaDsKKyAgICBjb25zdCBj aGFyKiBjaGFyYWN0ZXJzOworICAgIHVuc2lnbmVkIGxlbmd0aDsKKyAgICB1bnNpZ25lZCB1dGYx Nkxlbmd0aDsKK307CisKK3N0cnVjdCBIYXNoQW5kVVRGOENoYXJhY3RlcnNUcmFuc2xhdG9yIHsK KyAgICBzdGF0aWMgdW5zaWduZWQgaGFzaChjb25zdCBIYXNoQW5kVVRGOENoYXJhY3RlcnMmIGJ1 ZmZlcikKKyAgICB7CisgICAgICAgIHJldHVybiBidWZmZXIuaGFzaDsKKyAgICB9CisKKyAgICBz dGF0aWMgYm9vbCBlcXVhbChTdHJpbmdJbXBsKiBjb25zdCYgc3RyaW5nLCBjb25zdCBIYXNoQW5k VVRGOENoYXJhY3RlcnMmIGJ1ZmZlcikKKyAgICB7CisgICAgICAgIHJldHVybiBlcXVhbFVURjE2 V2l0aFVURjgoc3RyaW5nLT5jaGFyYWN0ZXJzKCksIHN0cmluZy0+Y2hhcmFjdGVycygpICsgc3Ry aW5nLT5sZW5ndGgoKSwgYnVmZmVyLmNoYXJhY3RlcnMsIGJ1ZmZlci5jaGFyYWN0ZXJzICsgYnVm ZmVyLmxlbmd0aCk7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgdHJhbnNsYXRlKFN0cmluZ0lt cGwqJiBsb2NhdGlvbiwgY29uc3QgSGFzaEFuZFVURjhDaGFyYWN0ZXJzJiBidWZmZXIsIHVuc2ln bmVkIGhhc2gpCisgICAgeworICAgICAgICBVQ2hhciogdGFyZ2V0OworICAgICAgICBsb2NhdGlv biA9IFN0cmluZ0ltcGw6OmNyZWF0ZVVuaW5pdGlhbGl6ZWQoYnVmZmVyLnV0ZjE2TGVuZ3RoLCB0 YXJnZXQpLnJlbGVhc2VSZWYoKTsKKworICAgICAgICBjb25zdCBjaGFyKiBzb3VyY2UgPSBidWZm ZXIuY2hhcmFjdGVyczsKKyAgICAgICAgaWYgKGNvbnZlcnRVVEY4VG9VVEYxNigmc291cmNlLCBz b3VyY2UgKyBidWZmZXIubGVuZ3RoLCAmdGFyZ2V0LCB0YXJnZXQgKyBidWZmZXIudXRmMTZMZW5n dGgpICE9IGNvbnZlcnNpb25PSykKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwor CisgICAgICAgIGxvY2F0aW9uLT5zZXRIYXNoKGhhc2gpOworICAgICAgICBsb2NhdGlvbi0+c2V0 SXNBdG9taWModHJ1ZSk7CisgICAgfQorfTsKKwogUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9t aWNTdHJpbmc6OmFkZChjb25zdCBVQ2hhciogcywgdW5zaWduZWQgbGVuZ3RoKQogewogICAgIGlm ICghcykKICAgICAgICAgcmV0dXJuIDA7CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAgaWYg KCFsZW5ndGgpCiAgICAgICAgIHJldHVybiBTdHJpbmdJbXBsOjplbXB0eSgpOwogICAgIAogICAg IFVDaGFyQnVmZmVyIGJ1ZiA9IHsgcywgbGVuZ3RoIH07IApAQCAtMjI3LDcgKzI2Myw3IEBAIFBh c3NSZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3RyaW5nOjphZGQoY29uc3QgVUNoYXIqIHMsIHVu c2lnbmVkIGxlbmd0aCwgdW5zaWduCiAgICAgQVNTRVJUKHMpOwogICAgIEFTU0VSVChleGlzdGlu Z0hhc2gpOwogCi0gICAgaWYgKGxlbmd0aCA9PSAwKQorICAgIGlmICghbGVuZ3RoKQogICAgICAg ICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1wdHkoKTsKICAgICAKICAgICBIYXNoQW5kQ2hhcmFjdGVy cyBidWZmZXIgPSB7IGV4aXN0aW5nSGFzaCwgcywgbGVuZ3RoIH07IApAQCAtMjQ2LDcgKzI4Miw3 IEBAIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3RyaW5nOjphZGQoY29uc3QgVUNoYXIq IHMpCiAgICAgd2hpbGUgKHNbbGVuZ3RoXSAhPSBVQ2hhcigwKSkKICAgICAgICAgbGVuZ3RoKys7 CiAKLSAgICBpZiAobGVuZ3RoID09IDApCisgICAgaWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVy biBTdHJpbmdJbXBsOjplbXB0eSgpOwogCiAgICAgVUNoYXJCdWZmZXIgYnVmID0ge3MsIGxlbmd0 aH07IApAQCAtMjYyLDcgKzI5OCw3IEBAIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gQXRvbWljU3Ry aW5nOjphZGRTbG93Q2FzZShTdHJpbmdJbXBsKiByKQogICAgIGlmICghciB8fCByLT5pc0F0b21p YygpKQogICAgICAgICByZXR1cm4gcjsKIAotICAgIGlmIChyLT5sZW5ndGgoKSA9PSAwKQorICAg IGlmICghci0+bGVuZ3RoKCkpCiAgICAgICAgIHJldHVybiBTdHJpbmdJbXBsOjplbXB0eSgpOwog CiAgICAgU3RyaW5nSW1wbCogcmVzdWx0ID0gKnN0cmluZ1RhYmxlKCkuYWRkKHIpLmZpcnN0OwpA QCAtMjc2LDcgKzMxMiw3IEBAIEF0b21pY1N0cmluZ0ltcGwqIEF0b21pY1N0cmluZzo6ZmluZChj b25zdCBVQ2hhciogcywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBlCiAgICAgQVNTRVJUKHMp OwogICAgIEFTU0VSVChleGlzdGluZ0hhc2gpOwogCi0gICAgaWYgKGxlbmd0aCA9PSAwKQorICAg IGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QXRvbWljU3RyaW5nSW1w bCo+KFN0cmluZ0ltcGw6OmVtcHR5KCkpOwogCiAgICAgSGFzaEFuZENoYXJhY3RlcnMgYnVmZmVy ID0geyBleGlzdGluZ0hhc2gsIHMsIGxlbmd0aCB9OyAKQEAgLTI5MCw3ICszMjYsNyBAQCB2b2lk IEF0b21pY1N0cmluZzo6cmVtb3ZlKFN0cmluZ0ltcGwqIHIpCiB7CiAgICAgc3RyaW5nVGFibGUo KS5yZW1vdmUocik7CiB9Ci0gICAgCisKIEF0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6Omxvd2Vy KCkgY29uc3QKIHsKICAgICAvLyBOb3RlOiBUaGlzIGlzIGEgaG90IGZ1bmN0aW9uIGluIHRoZSBE cm9tYWVvIGJlbmNobWFyay4KQEAgLTMwMyw0ICszMzksMzYgQEAgQXRvbWljU3RyaW5nIEF0b21p Y1N0cmluZzo6bG93ZXIoKSBjb25zdAogICAgIHJldHVybiBBdG9taWNTdHJpbmcobmV3SW1wbCk7 CiB9CiAKK0F0b21pY1N0cmluZyBBdG9taWNTdHJpbmc6OmZyb21VVEY4KGNvbnN0IGNoYXIqIGNo YXJhY3RlcnMsIHNpemVfdCBsZW5ndGgpCit7CisgICAgaWYgKCFjaGFyYWN0ZXJzKQorICAgICAg ICByZXR1cm4gQXRvbWljU3RyaW5nKCk7CisKKyAgICBpZiAoIWxlbmd0aCkKKyAgICAgICAgcmV0 dXJuIGVtcHR5QXRvbTsKKworICAgIEhhc2hBbmRVVEY4Q2hhcmFjdGVycyBidWZmZXI7CisgICAg YnVmZmVyLmNoYXJhY3RlcnMgPSBjaGFyYWN0ZXJzOworICAgIGJ1ZmZlci5sZW5ndGggPSBsZW5n dGg7CisgICAgYnVmZmVyLmhhc2ggPSBjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgoY2hhcmFj dGVycywgY2hhcmFjdGVycyArIGxlbmd0aCwgYnVmZmVyLnV0ZjE2TGVuZ3RoKTsKKworICAgIGlm ICghYnVmZmVyLmhhc2gpCisgICAgICAgIHJldHVybiBBdG9taWNTdHJpbmcoKTsKKworICAgIHBh aXI8SGFzaFNldDxTdHJpbmdJbXBsKj46Oml0ZXJhdG9yLCBib29sPiBhZGRSZXN1bHQgPSBzdHJp bmdUYWJsZSgpLmFkZDxIYXNoQW5kVVRGOENoYXJhY3RlcnMsIEhhc2hBbmRVVEY4Q2hhcmFjdGVy c1RyYW5zbGF0b3I+KGJ1ZmZlcik7CisKKyAgICAvLyBJZiB0aGUgc3RyaW5nIGlzIG5ld2x5LXRy YW5zbGF0ZWQsIHRoZW4gd2UgbmVlZCB0byBhZG9wdCBpdC4KKyAgICAvLyBUaGUgYm9vbGVhbiBp biB0aGUgcGFpciB0ZWxscyB1cyBpZiB0aGF0IGlzIHNvLgorICAgIEF0b21pY1N0cmluZyBhdG9t aWNTdHJpbmc7CisgICAgYXRvbWljU3RyaW5nLm1fc3RyaW5nID0gYWRkUmVzdWx0LnNlY29uZCA/ IGFkb3B0UmVmKCphZGRSZXN1bHQuZmlyc3QpIDogKmFkZFJlc3VsdC5maXJzdDsKKyAgICByZXR1 cm4gYXRvbWljU3RyaW5nOwogfQorCitBdG9taWNTdHJpbmcgQXRvbWljU3RyaW5nOjpmcm9tVVRG OChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzKQoreworICAgIGlmICghY2hhcmFjdGVycykKKyAgICAg ICAgcmV0dXJuIEF0b21pY1N0cmluZygpOworICAgIHJldHVybiBmcm9tVVRGOChjaGFyYWN0ZXJz LCBzdHJsZW4oY2hhcmFjdGVycykpOworfQorCit9IC8vIG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdp dCBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5oIGIvSmF2YVNjcmlwdENv cmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmgKaW5kZXggMDZlNjNmNC4uYWI1YjM2NiAxMDA2NDQK LS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmgKKysrIGIvSmF2YVNj cmlwdENvcmUvd3RmL3RleHQvQXRvbWljU3RyaW5nLmgKQEAgLTEwOCw2ICsxMDgsMTEgQEAgcHVi bGljOgogICAgIG9wZXJhdG9yIFFTdHJpbmcoKSBjb25zdCB7IHJldHVybiBtX3N0cmluZzsgfQog I2VuZGlmCiAKKyAgICAvLyBBdG9taWNTdHJpbmc6OmZyb21VVEY4IHdpbGwgcmV0dXJuIGEgbnVs bCBzdHJpbmcgaWYKKyAgICAvLyB0aGUgaW5wdXQgZGF0YSBjb250YWlucyBpbnZhbGlkIFVURi04 IHNlcXVlbmNlcy4KKyAgICBzdGF0aWMgQXRvbWljU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIq LCBzaXplX3QpOworICAgIHN0YXRpYyBBdG9taWNTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hhciop OworCiBwcml2YXRlOgogICAgIFN0cmluZyBtX3N0cmluZzsKICAgICAKZGlmZiAtLWdpdCBhL0ph dmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1N0cmluZ0ltcGwuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi90 ZXh0L1N0cmluZ0ltcGwuaAppbmRleCA5OWQwZTlkLi5kYzFkYmIyIDEwMDY0NAotLS0gYS9KYXZh U2NyaXB0Q29yZS93dGYvdGV4dC9TdHJpbmdJbXBsLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3Rm L3RleHQvU3RyaW5nSW1wbC5oCkBAIC01Myw2ICs1Myw3IEBAIG5hbWVzcGFjZSBXVEYgewogCiBz dHJ1Y3QgQ1N0cmluZ1RyYW5zbGF0b3I7CiBzdHJ1Y3QgSGFzaEFuZENoYXJhY3RlcnNUcmFuc2xh dG9yOworc3RydWN0IEhhc2hBbmRVVEY4Q2hhcmFjdGVyc1RyYW5zbGF0b3I7CiBzdHJ1Y3QgVUNo YXJCdWZmZXJUcmFuc2xhdG9yOwogCiBlbnVtIFRleHRDYXNlU2Vuc2l0aXZpdHkgeyBUZXh0Q2Fz ZVNlbnNpdGl2ZSwgVGV4dENhc2VJbnNlbnNpdGl2ZSB9OwpAQCAtNjYsNiArNjcsNyBAQCBjbGFz cyBTdHJpbmdJbXBsIDogcHVibGljIFN0cmluZ0ltcGxCYXNlIHsKICAgICBmcmllbmQgc3RydWN0 IEpTQzo6SWRlbnRpZmllclVDaGFyQnVmZmVyVHJhbnNsYXRvcjsKICAgICBmcmllbmQgc3RydWN0 IFdURjo6Q1N0cmluZ1RyYW5zbGF0b3I7CiAgICAgZnJpZW5kIHN0cnVjdCBXVEY6Okhhc2hBbmRD aGFyYWN0ZXJzVHJhbnNsYXRvcjsKKyAgICBmcmllbmQgc3RydWN0IFdURjo6SGFzaEFuZFVURjhD aGFyYWN0ZXJzVHJhbnNsYXRvcjsKICAgICBmcmllbmQgc3RydWN0IFdURjo6VUNoYXJCdWZmZXJU cmFuc2xhdG9yOwogICAgIGZyaWVuZCBjbGFzcyBBdG9taWNTdHJpbmdJbXBsOwogcHJpdmF0ZToK ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi90ZXh0L1dURlN0cmluZy5oIGIvSmF2YVNj cmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKaW5kZXggZTlkNmFlNC4uZWI5NWI0MSAxMDA2 NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKKysrIGIvSmF2YVNj cmlwdENvcmUvd3RmL3RleHQvV1RGU3RyaW5nLmgKQEAgLTMwOSw2ICszMDksOCBAQCBwdWJsaWM6 CiAgICAgU3RyaW5nKGNvbnN0IEFFQ0hBUiopOwogI2VuZGlmCiAKKyAgICAvLyBTdHJpbmc6OmZy b21VVEY4IHdpbGwgcmV0dXJuIGEgbnVsbCBzdHJpbmcgaWYKKyAgICAvLyB0aGUgaW5wdXQgZGF0 YSBjb250YWlucyBpbnZhbGlkIFVURi04IHNlcXVlbmNlcy4KICAgICBzdGF0aWMgU3RyaW5nIGZy b21VVEY4KGNvbnN0IGNoYXIqLCBzaXplX3QpOwogICAgIHN0YXRpYyBTdHJpbmcgZnJvbVVURjgo Y29uc3QgY2hhciopOwogCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9V VEY4LmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguY3BwCmluZGV4IGNhNGZj MWMuLmRjMjRlZDUgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjgu Y3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi91bmljb2RlL1VURjguY3BwCkBAIC0xLDUgKzEs NiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNyBBcHBsZSBJbmMuICBBbGwgcmlnaHRzIHJl c2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEwIFBhdHJpY2sgR2Fuc3RlcmVyIDxwYXJvZ2FA cGFyb2dhLmNvbT4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjUsNiArMjYs NyBAQAogCiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiVVRGOC5oIgorI2luY2x1ZGUg PHd0Zi9TdHJpbmdIYXNoZXIuaD4KIAogI2luY2x1ZGUgIkFTQ0lJQ1R5cGUuaCIKIApAQCAtMzIs NyArMzQsNyBAQCBuYW1lc3BhY2UgV1RGIHsKIG5hbWVzcGFjZSBVbmljb2RlIHsKIAogLy8gRklY TUU6IFVzZSBkZWZpbml0aW9uIGZyb20gQ2hhcmFjdGVyTmFtZXMuaC4KLWNvbnN0IFVDaGFyIHJl cGxhY2VtZW50Q2hhcmFjdGVyID0gMHhGRkZEOworc3RhdGljIGNvbnN0IFVDaGFyIHJlcGxhY2Vt ZW50Q2hhcmFjdGVyID0gMHhGRkZEOwogCiBpbmxpbmUgaW50IGlubGluZVVURjhTZXF1ZW5jZUxl bmd0aE5vbkFTQ0lJKGNoYXIgYjApCiB7CkBAIC0zMTQsNSArMzE2LDg2IEBAIENvbnZlcnNpb25S ZXN1bHQgY29udmVydFVURjhUb1VURjE2KAogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK3Vuc2ln bmVkIGNhbGN1bGF0ZVN0cmluZ0hhc2hGcm9tVVRGOChjb25zdCBjaGFyKiBkYXRhLCBjb25zdCBj aGFyKiBkYXRhRW5kLCB1bnNpZ25lZCYgdXRmMTZMZW5ndGgpCit7CisgICAgaWYgKCFkYXRhKQor ICAgICAgICByZXR1cm4gMDsKKworICAgIFdURjo6U3RyaW5nSGFzaGVyIHN0cmluZ0hhc2hlcjsK KyAgICB1dGYxNkxlbmd0aCA9IDA7CisKKyAgICB3aGlsZSAoZGF0YSA8IGRhdGFFbmQpIHsKKyAg ICAgICAgaWYgKGlzQVNDSUkoKmRhdGEpKSB7CisgICAgICAgICAgICBzdHJpbmdIYXNoZXIuYWRk Q2hhcmFjdGVyKCpkYXRhKyspOworICAgICAgICAgICAgdXRmMTZMZW5ndGgrKzsKKyAgICAgICAg ICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaW50IHV0ZjhTZXF1ZW5jZUxlbmd0 aCA9IGlubGluZVVURjhTZXF1ZW5jZUxlbmd0aE5vbkFTQ0lJKCpkYXRhKTsKKworICAgICAgICBp ZiAoZGF0YUVuZCAtIGRhdGEgPCB1dGY4U2VxdWVuY2VMZW5ndGgpCisgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICAgICAgaWYgKCFpc0xlZ2FsVVRGOChyZWludGVycHJldF9jYXN0PGNv bnN0IHVuc2lnbmVkIGNoYXIqPihkYXRhKSwgdXRmOFNlcXVlbmNlTGVuZ3RoKSkKKyAgICAgICAg ICAgIHJldHVybiAwOworCisgICAgICAgIFVDaGFyMzIgY2hhcmFjdGVyID0gcmVhZFVURjhTZXF1 ZW5jZShkYXRhLCB1dGY4U2VxdWVuY2VMZW5ndGgpOworICAgICAgICBBU1NFUlQoIWlzQVNDSUko Y2hhcmFjdGVyKSk7CisKKyAgICAgICAgaWYgKFVfSVNfQk1QKGNoYXJhY3RlcikpIHsKKyAgICAg ICAgICAgIC8vIFVURi0xNiBzdXJyb2dhdGUgdmFsdWVzIGFyZSBpbGxlZ2FsIGluIFVURi0zMgor ICAgICAgICAgICAgaWYgKFVfSVNfU1VSUk9HQVRFKGNoYXJhY3RlcikpCisgICAgICAgICAgICAg ICAgcmV0dXJuIDA7CisgICAgICAgICAgICBzdHJpbmdIYXNoZXIuYWRkQ2hhcmFjdGVyKHN0YXRp Y19jYXN0PFVDaGFyPihjaGFyYWN0ZXIpKTsgLy8gbm9ybWFsIGNhc2UKKyAgICAgICAgICAgIHV0 ZjE2TGVuZ3RoKys7CisgICAgICAgIH0gZWxzZSBpZiAoVV9JU19TVVBQTEVNRU5UQVJZKGNoYXJh Y3RlcikpIHsKKyAgICAgICAgICAgIHN0cmluZ0hhc2hlci5hZGRDaGFyYWN0ZXJzKHN0YXRpY19j YXN0PFVDaGFyPihVMTZfTEVBRChjaGFyYWN0ZXIpKSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHN0YXRpY19jYXN0PFVDaGFyPihVMTZfVFJBSUwoY2hhcmFjdGVyKSkp OworICAgICAgICAgICAgdXRmMTZMZW5ndGggKz0gMjsKKyAgICAgICAgfSBlbHNlCisgICAgICAg ICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICByZXR1cm4gc3RyaW5nSGFzaGVyLmhhc2goKTsK K30KKworYm9vbCBlcXVhbFVURjE2V2l0aFVURjgoY29uc3QgVUNoYXIqIGEsIGNvbnN0IFVDaGFy KiBhRW5kLCBjb25zdCBjaGFyKiBiLCBjb25zdCBjaGFyKiBiRW5kKQoreworICAgIHdoaWxlIChi IDwgYkVuZCkgeworICAgICAgICBpZiAoaXNBU0NJSSgqYikpIHsKKyAgICAgICAgICAgIGlmICgq YSsrICE9ICpiKyspCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBpbnQgdXRmOFNlcXVlbmNlTGVuZ3RoID0g aW5saW5lVVRGOFNlcXVlbmNlTGVuZ3RoTm9uQVNDSUkoKmIpOworCisgICAgICAgIGlmIChiRW5k IC0gYiA8IHV0ZjhTZXF1ZW5jZUxlbmd0aCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgICAgICBpZiAoIWlzTGVnYWxVVEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgdW5zaWduZWQg Y2hhcio+KGIpLCB1dGY4U2VxdWVuY2VMZW5ndGgpKQorICAgICAgICAgICAgcmV0dXJuIDA7CisK KyAgICAgICAgVUNoYXIzMiBjaGFyYWN0ZXIgPSByZWFkVVRGOFNlcXVlbmNlKGIsIHV0ZjhTZXF1 ZW5jZUxlbmd0aCk7CisgICAgICAgIEFTU0VSVCghaXNBU0NJSShjaGFyYWN0ZXIpKTsKKworICAg ICAgICBpZiAoVV9JU19CTVAoY2hhcmFjdGVyKSkgeworICAgICAgICAgICAgLy8gVVRGLTE2IHN1 cnJvZ2F0ZSB2YWx1ZXMgYXJlIGlsbGVnYWwgaW4gVVRGLTMyCisgICAgICAgICAgICBpZiAoVV9J U19TVVJST0dBVEUoY2hhcmFjdGVyKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7Cisg ICAgICAgICAgICBpZiAoKmErKyAhPSBjaGFyYWN0ZXIpCisgICAgICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICB9IGVsc2UgaWYgKFVfSVNfU1VQUExFTUVOVEFSWShjaGFyYWN0ZXIp KSB7CisgICAgICAgICAgICBpZiAoKmErKyAhPSBVMTZfTEVBRChjaGFyYWN0ZXIpKQorICAgICAg ICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIGlmICgqYSsrICE9IFUxNl9UUkFJ TChjaGFyYWN0ZXIpKQorICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfSBl bHNlCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgcmV0dXJuIGEgPT0g YUVuZDsKK30KKwogfSAvLyBuYW1lc3BhY2UgVW5pY29kZQogfSAvLyBuYW1lc3BhY2UgV1RGCmRp ZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvdW5pY29kZS9VVEY4LmggYi9KYXZhU2NyaXB0 Q29yZS93dGYvdW5pY29kZS9VVEY4LmgKaW5kZXggYTVlZDkzZS4uMWY0YmFjYSAxMDA2NDQKLS0t IGEvSmF2YVNjcmlwdENvcmUvd3RmL3VuaWNvZGUvVVRGOC5oCisrKyBiL0phdmFTY3JpcHRDb3Jl L3d0Zi91bmljb2RlL1VURjguaApAQCAtMjksNyArMjksNyBAQAogI2luY2x1ZGUgIlVuaWNvZGUu aCIKIAogbmFtZXNwYWNlIFdURiB7Ci0gIG5hbWVzcGFjZSBVbmljb2RlIHsKK25hbWVzcGFjZSBV bmljb2RlIHsKIAogICAgIC8vIEdpdmVuIGEgZmlyc3QgYnl0ZSwgZ2l2ZXMgdGhlIGxlbmd0aCBv ZiB0aGUgVVRGLTggc2VxdWVuY2UgaXQgYmVnaW5zLgogICAgIC8vIFJldHVybnMgMCBmb3IgYnl0 ZXMgdGhhdCBhcmUgbm90IGxlZ2FsIHN0YXJ0cyBvZiBVVEYtOCBzZXF1ZW5jZXMuCkBAIC02OSw3 ICs2OSwxMiBAQCBuYW1lc3BhY2UgV1RGIHsKICAgICBDb252ZXJzaW9uUmVzdWx0IGNvbnZlcnRV VEYxNlRvVVRGOCgKICAgICAgICAgICAgICAgICAgICAgY29uc3QgVUNoYXIqKiBzb3VyY2VTdGFy dCwgY29uc3QgVUNoYXIqIHNvdXJjZUVuZCwgCiAgICAgICAgICAgICAgICAgICAgIGNoYXIqKiB0 YXJnZXRTdGFydCwgY2hhciogdGFyZ2V0RW5kLCBib29sIHN0cmljdCA9IHRydWUpOwotICB9Ci19 CisKKyAgICB1bnNpZ25lZCBjYWxjdWxhdGVTdHJpbmdIYXNoRnJvbVVURjgoY29uc3QgY2hhciog ZGF0YSwgY29uc3QgY2hhciogZGF0YUVuZCwgdW5zaWduZWQmIHV0ZjE2TGVuZ3RoKTsKKworICAg IGJvb2wgZXF1YWxVVEYxNldpdGhVVEY4KGNvbnN0IFVDaGFyKiBhLCBjb25zdCBVQ2hhciogYUVu ZCwgY29uc3QgY2hhciogYiwgY29uc3QgY2hhciogYkVuZCk7CisKK30gLy8gbmFtZXNwYWNlIFVu aWNvZGUKK30gLy8gbmFtZXNwYWNlIFdURgogCiAjZW5kaWYgLy8gV1RGX1VURjhfaApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBkY2Q2MWIz Li5iZDM4MTMyIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTEyLTAxICBQYXRyaWNrIEdhbnN0ZXJlciAg PHBhcm9nYUB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgor CisgICAgICAgIEFkZCBBdG9taWNTdHJpbmc6OmZyb21VVEY4CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTU5NAorCisgICAgICAgIFVzZSBBdG9taWNT dHJpbmc6OmZyb21VVEY4IGRpcmVjdGx5IGluIHRoZSBsaWJ4bWwyIHBhcnNlci4KKworICAgICAg ICAqIGRvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 dG9BdG9taWNTdHJpbmcpOgorCiAyMDEwLTEyLTAxICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9n YUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFuZHJlYXMgS2xpbmcuCmRpZmYg LS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwIGIvV2ViQ29y ZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAppbmRleCA3YTMyODVmLi4yM2Y5ODgz IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCisr KyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKQEAgLTY4NiwxNCAr Njg2LDEyIEBAIHN0YXRpYyBpbmxpbmUgU3RyaW5nIHRvU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0 cmluZykKIAogc3RhdGljIGlubGluZSBBdG9taWNTdHJpbmcgdG9BdG9taWNTdHJpbmcoY29uc3Qg eG1sQ2hhciogc3RyaW5nLCBzaXplX3Qgc2l6ZSkKIHsKLSAgICAvLyBGSVhNRTogVXNlIEF0b21p Y1N0cmluZzo6ZnJvbVVURjguCi0gICAgcmV0dXJuIEF0b21pY1N0cmluZyh0b1N0cmluZyhzdHJp bmcsIHNpemUpKTsKKyAgICByZXR1cm4gQXRvbWljU3RyaW5nOjpmcm9tVVRGOChyZWludGVycHJl dF9jYXN0PGNvbnN0IGNoYXIqPihzdHJpbmcpLCBzaXplKTsKIH0KIAogc3RhdGljIGlubGluZSBB dG9taWNTdHJpbmcgdG9BdG9taWNTdHJpbmcoY29uc3QgeG1sQ2hhciogc3RyaW5nKQogewotICAg IC8vIEZJWE1FOiBVc2UgQXRvbWljU3RyaW5nOjpmcm9tVVRGOC4KLSAgICByZXR1cm4gQXRvbWlj U3RyaW5nKHRvU3RyaW5nKHN0cmluZykpOworICAgIHJldHVybiBBdG9taWNTdHJpbmc6OmZyb21V VEY4KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KHN0cmluZykpOwogfQogCiBzdHJ1Y3Qg X3htbFNBWDJOYW1lc3BhY2Ugewo=