211142 2020-04-28 12:48:17 -0700 U_STRING_NOT_TERMINATED_WARNING ICU must be handled when using the output buffer as a C string 2020-04-29 00:15:25 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 saam saam andy annulen benjamin cdumez cmarcelo darin ews-watchlist fpizlo ggaren gskachkov guijemont gyuyoung.kim keith_miller mark.lam mifenton msaboff rmorisset ross.kirsling ryuan.choi sergio ticaiolima tzagallo webkit-bug-importer ysuzuki oldest_to_newest 1646633 0 saam 2020-04-28 12:48:17 -0700 We have code that checks if we got the U_BUFFER_OVERFLOW_ERROR, and we grow the output buffer and try again when we see such a "warning". We also detect "failure" using U_FAILURE, which doesn't consdier U_STRING_NOT_TERMINATED_WARNING as failure, which seems crazy at first glance, and is leading to bugs in at least some parts of JSC. There are 118 uses of U_BUFFER_OVERFLOW_ERROR in WebKit There are 211 uses of U_FAILURE in WebKit I think we need to audit all of them 1646634 1 saam 2020-04-28 12:52:17 -0700 Some examples that appear troublesome: ``` String LocaleICU::decimalSymbol(UNumberFormatSymbol symbol) { UErrorCode status = U_ZERO_ERROR; int32_t bufferLength = unum_getSymbol(m_numberFormat, symbol, 0, 0, &status); ASSERT(U_SUCCESS(status) || status == U_BUFFER_OVERFLOW_ERROR); if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) return String(); Vector<UChar> buffer(bufferLength); status = U_ZERO_ERROR; unum_getSymbol(m_numberFormat, symbol, buffer.data(), bufferLength, &status); if (U_FAILURE(status)) return String(); return String::adopt(WTFMove(buffer)); } ``` ``` int32_t parsedLength; auto intermediateLength = uloc_forLanguageTag(input.data(), intermediate.data(), intermediate.size(), &parsedLength, &status); if (status == U_BUFFER_OVERFLOW_ERROR) { intermediate.resize(intermediateLength + 1); status = U_ZERO_ERROR; uloc_forLanguageTag(input.data(), intermediate.data(), intermediateLength + 1, &parsedLength, &status); } if (U_FAILURE(status) || parsedLength != static_cast<int32_t>(input.length())) return String(); ``` 1646635 2 darin 2020-04-28 12:53:26 -0700 I am puzzled by this. What specifically goes wrong in what case? 1646637 3 saam 2020-04-28 12:53:53 -0700 (In reply to Saam Barati from comment #1) > Some examples that appear troublesome: > ``` > String LocaleICU::decimalSymbol(UNumberFormatSymbol symbol) > { > UErrorCode status = U_ZERO_ERROR; > int32_t bufferLength = unum_getSymbol(m_numberFormat, symbol, 0, 0, > &status); > ASSERT(U_SUCCESS(status) || status == U_BUFFER_OVERFLOW_ERROR); > if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) > return String(); > Vector<UChar> buffer(bufferLength); > status = U_ZERO_ERROR; > unum_getSymbol(m_numberFormat, symbol, buffer.data(), bufferLength, > &status); > if (U_FAILURE(status)) > return String(); > return String::adopt(WTFMove(buffer)); > } > ``` Actually this one might be ok, since we don't rely on the buffer being a valid C string > > ``` > int32_t parsedLength; > auto intermediateLength = uloc_forLanguageTag(input.data(), > intermediate.data(), intermediate.size(), &parsedLength, &status); > if (status == U_BUFFER_OVERFLOW_ERROR) { > intermediate.resize(intermediateLength + 1); > status = U_ZERO_ERROR; > uloc_forLanguageTag(input.data(), intermediate.data(), > intermediateLength + 1, &parsedLength, &status); > } > if (U_FAILURE(status) || parsedLength != > static_cast<int32_t>(input.length())) > return String(); > ``` This isn't ok, since we do rely on it being a C string 1646638 4 darin 2020-04-28 12:54:01 -0700 U_STRING_NOT_TERMINATED_WARNING is only relevant if we rely on a 0 character terminator, and we do not rely on that in the code above. 1646639 5 darin 2020-04-28 12:54:16 -0700 I’m not sure there is any problem here at all. 1646641 6 saam 2020-04-28 12:54:59 -0700 (In reply to Darin Adler from comment #2) > I am puzzled by this. What specifically goes wrong in what case? We will take the output of an ICU call and trust that it's a C string. See: ``` UErrorCode status = U_ZERO_ERROR; Vector<char, 32> intermediate(31); int32_t parsedLength; auto intermediateLength = uloc_forLanguageTag(input.data(), intermediate.data(), intermediate.size(), &parsedLength, &status); if (status == U_BUFFER_OVERFLOW_ERROR) { intermediate.resize(intermediateLength + 1); status = U_ZERO_ERROR; uloc_forLanguageTag(input.data(), intermediate.data(), intermediateLength + 1, &parsedLength, &status); } if (U_FAILURE(status) || parsedLength != static_cast<int32_t>(input.length())) return String(); Vector<char, 32> result(32); auto resultLength = uloc_toLanguageTag(intermediate.data(), result.data(), result.size(), false, &status); if (status == U_BUFFER_OVERFLOW_ERROR) { result.grow(resultLength); status = U_ZERO_ERROR; uloc_toLanguageTag(intermediate.data(), result.data(), resultLength, false, &status); } if (U_FAILURE(status)) return String(); ``` 1646642 7 darin 2020-04-28 12:57:35 -0700 (In reply to Saam Barati from comment #3) > > if (U_FAILURE(status) || parsedLength != > > static_cast<int32_t>(input.length())) > > return String(); > > ``` > > This isn't ok, since we do rely on it being a C string I see now. That’s right! That case is wrong. I’d be surprised if there are a lot of other examples like this, but there may be a few in the new Intl code. 1646643 8 darin 2020-04-28 12:58:38 -0700 (In reply to Saam Barati from comment #6) > We will take the output of an ICU call and trust that it's a C string. I think it’s great to audit carefully. But I think it’s unlikely that we’ve made this mistake a lot in the past. 1646644 9 saam 2020-04-28 12:59:00 -0700 (In reply to Darin Adler from comment #7) > (In reply to Saam Barati from comment #3) > > > if (U_FAILURE(status) || parsedLength != > > > static_cast<int32_t>(input.length())) > > > return String(); > > > ``` > > > > This isn't ok, since we do rely on it being a C string > > I see now. That’s right! That case is wrong. I’d be surprised if there are a > lot of other examples like this, but there may be a few in the new Intl code. Yeah my initial reaction of this being terribly wrong was off-base. However, I've spotted a handful in JSC's Intl code already, so there exist a non-trivial amount. It's probably worth doing at least a basic audit of all uses of this. 1646645 10 saam 2020-04-28 12:59:29 -0700 (In reply to Darin Adler from comment #8) > (In reply to Saam Barati from comment #6) > > We will take the output of an ICU call and trust that it's a C string. > > I think it’s great to audit carefully. But I think it’s unlikely that we’ve > made this mistake a lot in the past. Yeah it seems like we do the right thing in most places, maybe except JSC's Intl code. 1646649 11 ross.kirsling 2020-04-28 13:14:38 -0700 I'll note that that uloc_forLanguageTag -> uloc_toLanguageTag case was particularly tricky to get working safely (hence the comment I added) so any ideas on how to make it less fragile would be great. The other case I'm aware of where we pass the C string from one ICU API directly into another is here: https://github.com/WebKit/webkit/blob/master/Source/JavaScriptCore/runtime/IntlDateTimeFormat.cpp#L115-L144 But this case is still less horrible because the second call takes an input length. 1646654 12 darin 2020-04-28 13:35:39 -0700 I want to quibble with the language here. Let’s stay logical: there’s no need for fuzziness here. If we need a null-terminated string, we *must* treat U_STRING_NOT_TERMINATED_WARNING as a “buffer too small” case; unless there is some other way we are adding a null terminator. If we do *not* need a null-terminated string, then we can and should ignore that warning. (In reply to Ross Kirsling from comment #11) > But this case is still less horrible because the second call takes an input > length. Here’s my quibble. That case is not just “less horrible”. It is *correct*. The other case is *incorrect*. 1646747 13 saam 2020-04-28 16:37:06 -0700 <rdar://problem/62530860> 1646753 14 397904 saam 2020-04-28 16:45:48 -0700 Created attachment 397904 patch 1646763 15 397904 darin 2020-04-28 17:04:00 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review Honestly I think needsToGrowToProduceBuffer doesn’t make things easier to read. It’s mainly valuable as a record of the fact that you audited a given call site. On the other hand, needsToGrowToProduceCString is definitely valuable. But only in exactly one place. I think adding the header is overkill, but I won’t stand in your way if you still like it. > Source/JavaScriptCore/runtime/IntlObject.cpp:334 > + if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING || parsedLength != static_cast<int32_t>(input.length())) How can U_STRING_NOT_TERMINATED_WARNING happen here? Seems like we can just leave this out or simply assert it doesn’t happen. We are using the length it returned, so there is no chance it will happen. > Source/JavaScriptCore/runtime/IntlObject.cpp:346 > +#if ASSERT_ENABLED > + bool sawNullTerminator = false; > + for (char c : intermediate) { > + if (c == '\0') { > + sawNullTerminator = true; > + break; > + } > + } > + ASSERT(sawNullTerminator); > +#endif Alternate implementation that does the same thing: ASSERT(intermediate.contains('\0')); > Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:78 > + if (needsToGrowToProduceCString(status)) { This doesn’t seem right. I don’t see code depending on scratchBuffer being null terminated. > Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:79 > scratchBuffer.grow(lengthNeeded + 1); Seems like this should just be lengthNeeded, not + 1. 1646800 16 397904 mark.lam 2020-04-28 19:52:40 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review > Source/JavaScriptCore/runtime/IntlObject.cpp:154 > - return String(StringImpl::createStaticStringImpl(buffer.data(), length)); > + return String(buffer.data(), length); This is wrong. convertICULocaleToBCP47LanguageTag() is only called from inside std::call_once guarded blocks i.e. it's meant to produce immortal singleton strings. Before I changed it to be StringImpl::createStaticStringImpl(), we had UAFs due to a user of this string freeing it. 1646809 17 397904 mark.lam 2020-04-28 20:02:53 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review >> Source/JavaScriptCore/runtime/IntlObject.cpp:154 >> + return String(buffer.data(), length); > > This is wrong. convertICULocaleToBCP47LanguageTag() is only called from inside std::call_once guarded blocks i.e. it's meant to produce immortal singleton strings. Before I changed it to be StringImpl::createStaticStringImpl(), we had UAFs due to a user of this string freeing it. I talked to Saam offline, but for the record, there's another important property of StaticStringImpls i.e. that they are safe to be ref'ed and deref'ed from different threads without locks. That's the most important reason this needs to be a StaticStringImpl because it is a singleton that can be used from different threads. 1646811 18 397904 mark.lam 2020-04-28 20:04:56 -0700 Comment on attachment 397904 patch Restoring Darin's r+ since Saam said he will undo the StringImpl::createStaticStringImpl() change. 1646813 19 397904 saam 2020-04-28 20:11:26 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review >> Source/JavaScriptCore/runtime/IntlObject.cpp:154 >> + return String(buffer.data(), length); > > This is wrong. convertICULocaleToBCP47LanguageTag() is only called from inside std::call_once guarded blocks i.e. it's meant to produce immortal singleton strings. Before I changed it to be StringImpl::createStaticStringImpl(), we had UAFs due to a user of this string freeing it. As Mark and I discussed on Slack, the actual issue here isn't being called from call_once, but the fact that the resulting string may ref/deref from more than one thread at once. >> Source/JavaScriptCore/runtime/IntlObject.cpp:334 >> + if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING || parsedLength != static_cast<int32_t>(input.length())) > > How can U_STRING_NOT_TERMINATED_WARNING happen here? Seems like we can just leave this out or simply assert it doesn’t happen. We are using the length it returned, so there is no chance it will happen. My thinking here was just ICU failing for some reason, but this would be a weird way for it to fail. >> Source/JavaScriptCore/runtime/IntlObject.cpp:346 >> +#endif > > Alternate implementation that does the same thing: > > ASSERT(intermediate.contains('\0')); That'd be too easy! >> Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:78 >> + if (needsToGrowToProduceCString(status)) { > > This doesn’t seem right. I don’t see code depending on scratchBuffer being null terminated. Yeah it's not needed. I got confused with the AtomString::fromUTF8 version that doesn't take "length" that ends up calling strlen. 1646817 20 397904 saam 2020-04-28 20:13:34 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review >>> Source/JavaScriptCore/runtime/IntlObject.cpp:334 >>> + if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING || parsedLength != static_cast<int32_t>(input.length())) >> >> How can U_STRING_NOT_TERMINATED_WARNING happen here? Seems like we can just leave this out or simply assert it doesn’t happen. We are using the length it returned, so there is no chance it will happen. > > My thinking here was just ICU failing for some reason, but this would be a weird way for it to fail. I guess part of my reasoning. is that if for some reason ICU again hit this warning, that "status == U_STRING_NOT_TERMINATED_WARNING" is just as bad as U_FAILURE 1646819 21 saam 2020-04-28 20:39:57 -0700 (In reply to Darin Adler from comment #15) > Comment on attachment 397904 [details] > patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=397904&action=review > > Honestly I think needsToGrowToProduceBuffer doesn’t make things easier to > read. It’s mainly valuable as a record of the fact that you audited a given > call site. On the other hand, needsToGrowToProduceCString is definitely > valuable. But only in exactly one place. I think adding the header is > overkill, but I won’t stand in your way if you still like it. I'm going to keep "needsToGrowToProduceBuffer". The reason I like it is that if you end writing code to use it, it's (hopefully) a forcing function to consider if you should instead be using needsToGrowToProduceCString. > > > Source/JavaScriptCore/runtime/IntlObject.cpp:334 > > + if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING || parsedLength != static_cast<int32_t>(input.length())) > > How can U_STRING_NOT_TERMINATED_WARNING happen here? Seems like we can just > leave this out or simply assert it doesn’t happen. We are using the length > it returned, so there is no chance it will happen. > > > Source/JavaScriptCore/runtime/IntlObject.cpp:346 > > +#if ASSERT_ENABLED > > + bool sawNullTerminator = false; > > + for (char c : intermediate) { > > + if (c == '\0') { > > + sawNullTerminator = true; > > + break; > > + } > > + } > > + ASSERT(sawNullTerminator); > > +#endif > > Alternate implementation that does the same thing: > > ASSERT(intermediate.contains('\0')); > > > Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:78 > > + if (needsToGrowToProduceCString(status)) { > > This doesn’t seem right. I don’t see code depending on scratchBuffer being > null terminated. > > > Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:79 > > scratchBuffer.grow(lengthNeeded + 1); > > Seems like this should just be lengthNeeded, not + 1. 1646820 22 397904 saam 2020-04-28 20:48:48 -0700 Comment on attachment 397904 patch View in context: https://bugs.webkit.org/attachment.cgi?id=397904&action=review >> Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:79 >> scratchBuffer.grow(lengthNeeded + 1); > > Seems like this should just be lengthNeeded, not + 1. I believe this is needed. But this is my first time reading ICU documentation, and it's not crystal clear exactly what the invariants are. My reading, and slight guessing, given the ambiguity, at what ICU means by "input buffer containing well-formed locale ID to be modified" is that it's null-terminated. There is also this warning: "NOTE: Unlike almost every other ICU function which takes a buffer, this function will NOT truncate the output text, and will not update the buffer with unterminated text setting a status of U_STRING_NOT_TERMINATED_WARNING.". So I think we need to give it the capacity to write the terminating byte otherwise it won't write any output I'm reading the documentation here: https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/uloc_8h.html#a4ba76d26bf66ef7629a649f6dfc3cc93 1646825 23 saam 2020-04-28 21:22:37 -0700 (In reply to Saam Barati from comment #22) > Comment on attachment 397904 [details] > patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=397904&action=review > > >> Source/WTF/wtf/text/LineBreakIteratorPoolICU.h:79 > >> scratchBuffer.grow(lengthNeeded + 1); > > > > Seems like this should just be lengthNeeded, not + 1. > > I believe this is needed. But this is my first time reading ICU > documentation, and it's not crystal clear exactly what the invariants are. > My reading, and slight guessing, given the ambiguity, at what ICU means by > "input buffer containing well-formed locale ID to be modified" is that it's > null-terminated. > There is also this warning: "NOTE: Unlike almost every other ICU function > which takes a buffer, this function will NOT truncate the output text, and > will not update the buffer with unterminated text setting a status of > U_STRING_NOT_TERMINATED_WARNING.". So I think we need to give it the > capacity to write the terminating byte otherwise it won't write any output > > I'm reading the documentation here: > https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/uloc_8h. > html#a4ba76d26bf66ef7629a649f6dfc3cc93 I misread their "NOTE". As Ross pointed out on Slack, ICU is calling out that they won't set such a warning. I read this as having a comma between "text" and "setting". 1646826 24 397921 saam 2020-04-28 21:26:07 -0700 Created attachment 397921 patch for landing 1646885 25 ews-feeder 2020-04-29 00:15:23 -0700 Committed r260882: <https://trac.webkit.org/changeset/260882> All reviewed patches have been landed. Closing bug and clearing flags on attachment 397921. 397904 2020-04-28 16:45:48 -0700 2020-04-28 21:26:07 -0700 patch c-backup.diff text/plain 29169 saam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYwODU1KQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMwIEBA CisyMDIwLTA0LTI4ICBTYWFtIEJhcmF0aSAgPHNiYXJhdGlAYXBwbGUuY29tPgorCisgICAgICAg IFVfU1RSSU5HX05PVF9URVJNSU5BVEVEX1dBUk5JTkcgSUNVIG11c3QgYmUgaGFuZGxlZCB3aGVu IHVzaW5nIHRoZSBvdXRwdXQgYnVmZmVyIGFzIGEgQyBzdHJpbmcKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMTE0MgorICAgICAgICA8cmRhcjovL3By b2JsZW0vNjI1MzA4NjA+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBydW50aW1lL0ludGxEYXRlVGltZUZvcm1hdC5jcHA6CisgICAgICAgIChKU0M6 OmRlZmF1bHRUaW1lWm9uZSk6CisgICAgICAgIChKU0M6OmNhbm9uaWNhbGl6ZVRpbWVab25lTmFt ZSk6CisgICAgICAgIChKU0M6OkludGxEYXRlVGltZUZvcm1hdDo6aW5pdGlhbGl6ZURhdGVUaW1l Rm9ybWF0KToKKyAgICAgICAgKEpTQzo6SW50bERhdGVUaW1lRm9ybWF0Ojpmb3JtYXQpOgorICAg ICAgICAoSlNDOjpJbnRsRGF0ZVRpbWVGb3JtYXQ6OmZvcm1hdFRvUGFydHMpOgorICAgICAgICAq IHJ1bnRpbWUvSW50bE51bWJlckZvcm1hdC5jcHA6CisgICAgICAgIChKU0M6OkludGxOdW1iZXJG b3JtYXQ6OmZvcm1hdCk6CisgICAgICAgIChKU0M6OkludGxOdW1iZXJGb3JtYXQ6OmZvcm1hdFRv UGFydHMpOgorICAgICAgICAqIHJ1bnRpbWUvSW50bE9iamVjdC5jcHA6CisgICAgICAgIChKU0M6 OmNvbnZlcnRJQ1VMb2NhbGVUb0JDUDQ3TGFuZ3VhZ2VUYWcpOgorICAgICAgICAoSlNDOjpjYW5v bmljYWxpemVMYW5ndWFnZVRhZyk6CisgICAgICAgICogcnVudGltZS9JbnRsUmVsYXRpdmVUaW1l Rm9ybWF0LmNwcDoKKyAgICAgICAgKEpTQzo6SW50bFJlbGF0aXZlVGltZUZvcm1hdDo6Zm9ybWF0 SW50ZXJuYWwpOgorICAgICAgICAoSlNDOjpJbnRsUmVsYXRpdmVUaW1lRm9ybWF0Ojpmb3JtYXRU b1BhcnRzKToKKyAgICAgICAgKiBydW50aW1lL1N0cmluZ1Byb3RvdHlwZS5jcHA6CisgICAgICAg IChKU0M6OnRvTG9jYWxlQ2FzZSk6CisgICAgICAgIChKU0M6Om5vcm1hbGl6ZSk6CisKIDIwMjAt MDQtMjggIFJvc3MgS2lyc2xpbmcgIDxyb3NzLmtpcnNsaW5nQHNvbnkuY29tPgogCiAgICAgICAg IFtKU0NdIEFsaWduIHVwb24gdGhlIG5hbWUgaXNDYWxsYWJsZSBpbnN0ZWFkIG9mIGlzRnVuY3Rp b24KSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ludGxEYXRlVGltZUZvcm1h dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSW50bERh dGVUaW1lRm9ybWF0LmNwcAkocmV2aXNpb24gMjYwODQyKQorKysgU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvSW50bERhdGVUaW1lRm9ybWF0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzks NiArMzksNyBAQAogI2luY2x1ZGUgPHVuaWNvZGUvdWVudW0uaD4KICNpbmNsdWRlIDx1bmljb2Rl L3VmaWVsZHBvc2l0ZXIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+Cisj aW5jbHVkZSA8d3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIEpTQyB7 CiAKQEAgLTExOSw3ICsxMjAsNyBAQCBzdGF0aWMgU3RyaW5nIGRlZmF1bHRUaW1lWm9uZSgpCiAK ICAgICBWZWN0b3I8VUNoYXIsIDMyPiBidWZmZXIoMzIpOwogICAgIGF1dG8gYnVmZmVyTGVuZ3Ro ID0gdWNhbF9nZXREZWZhdWx0VGltZVpvbmUoYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSwg JnN0YXR1cyk7Ci0gICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikgewor ICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKSB7CiAgICAgICAgIHN0 YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICAgICAgYnVmZmVyLmdyb3coYnVmZmVyTGVuZ3RoKTsK ICAgICAgICAgdWNhbF9nZXREZWZhdWx0VGltZVpvbmUoYnVmZmVyLmRhdGEoKSwgYnVmZmVyTGVu Z3RoLCAmc3RhdHVzKTsKQEAgLTEyOCw3ICsxMjksNyBAQCBzdGF0aWMgU3RyaW5nIGRlZmF1bHRU aW1lWm9uZSgpCiAgICAgICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICAgICAgVmVjdG9y PFVDaGFyLCAzMj4gY2Fub25pY2FsQnVmZmVyKDMyKTsKICAgICAgICAgYXV0byBjYW5vbmljYWxM ZW5ndGggPSB1Y2FsX2dldENhbm9uaWNhbFRpbWVab25lSUQoYnVmZmVyLmRhdGEoKSwgYnVmZmVy TGVuZ3RoLCBjYW5vbmljYWxCdWZmZXIuZGF0YSgpLCBjYW5vbmljYWxCdWZmZXIuc2l6ZSgpLCBu dWxscHRyLCAmc3RhdHVzKTsKLSAgICAgICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxP V19FUlJPUikgeworICAgICAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVz KSkgewogICAgICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICAgICAgY2Fu b25pY2FsQnVmZmVyLmdyb3coY2Fub25pY2FsTGVuZ3RoKTsKICAgICAgICAgICAgIHVjYWxfZ2V0 Q2Fub25pY2FsVGltZVpvbmVJRChidWZmZXIuZGF0YSgpLCBidWZmZXJMZW5ndGgsIGNhbm9uaWNh bEJ1ZmZlci5kYXRhKCksIGNhbm9uaWNhbExlbmd0aCwgbnVsbHB0ciwgJnN0YXR1cyk7CkBAIC0x NzUsNyArMTc2LDcgQEAgc3RhdGljIFN0cmluZyBjYW5vbmljYWxpemVUaW1lWm9uZU5hbWUoYwog ICAgICAgICBWZWN0b3I8VUNoYXIsIDMyPiBidWZmZXIoaWFuYVRpbWVab25lTGVuZ3RoKTsKICAg ICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICBhdXRvIGNhbm9uaWNhbExlbmd0 aCA9IHVjYWxfZ2V0Q2Fub25pY2FsVGltZVpvbmVJRChpYW5hVGltZVpvbmUsIGlhbmFUaW1lWm9u ZUxlbmd0aCwgYnVmZmVyLmRhdGEoKSwgaWFuYVRpbWVab25lTGVuZ3RoLCBudWxscHRyLCAmc3Rh dHVzKTsKLSAgICAgICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikgewor ICAgICAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkgewogICAgICAg ICAgICAgYnVmZmVyLmdyb3coY2Fub25pY2FsTGVuZ3RoKTsKICAgICAgICAgICAgIHN0YXR1cyA9 IFVfWkVST19FUlJPUjsKICAgICAgICAgICAgIHVjYWxfZ2V0Q2Fub25pY2FsVGltZVpvbmVJRChp YW5hVGltZVpvbmUsIGlhbmFUaW1lWm9uZUxlbmd0aCwgYnVmZmVyLmRhdGEoKSwgY2Fub25pY2Fs TGVuZ3RoLCBudWxscHRyLCAmc3RhdHVzKTsKQEAgLTY1MCw3ICs2NTEsNyBAQCB2b2lkIEludGxE YXRlVGltZUZvcm1hdDo6aW5pdGlhbGl6ZURhdGVUCiAgICAgVmVjdG9yPFVDaGFyLCAzMj4gcGF0 dGVybkJ1ZmZlcigzMik7CiAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIGF1dG8gcGF0 dGVybkxlbmd0aCA9IHVkYXRwZ19nZXRCZXN0UGF0dGVybldpdGhPcHRpb25zKGdlbmVyYXRvciwg c2tlbGV0b25WaWV3LnVwY29udmVydGVkQ2hhcmFjdGVycygpLCBza2VsZXRvblZpZXcubGVuZ3Ro KCksIFVEQVRQR19NQVRDSF9IT1VSX0ZJRUxEX0xFTkdUSCwgcGF0dGVybkJ1ZmZlci5kYXRhKCks IHBhdHRlcm5CdWZmZXIuc2l6ZSgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVG RkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVy KHN0YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICBwYXR0 ZXJuQnVmZmVyLmdyb3cocGF0dGVybkxlbmd0aCk7CiAgICAgICAgIHVkYXRwZ19nZXRCZXN0UGF0 dGVybihnZW5lcmF0b3IsIHNrZWxldG9uVmlldy51cGNvbnZlcnRlZENoYXJhY3RlcnMoKSwgc2tl bGV0b25WaWV3Lmxlbmd0aCgpLCBwYXR0ZXJuQnVmZmVyLmRhdGEoKSwgcGF0dGVybkxlbmd0aCwg JnN0YXR1cyk7CkBAIC05MDgsNyArOTA5LDcgQEAgSlNWYWx1ZSBJbnRsRGF0ZVRpbWVGb3JtYXQ6 OmZvcm1hdChKU0dsbwogICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAg IFZlY3RvcjxVQ2hhciwgMzI+IHJlc3VsdCgzMik7CiAgICAgYXV0byByZXN1bHRMZW5ndGggPSB1 ZGF0X2Zvcm1hdChtX2RhdGVGb3JtYXQuZ2V0KCksIHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1 bHQuc2l6ZSgpLCBudWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVS X09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0 YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQu Z3JvdyhyZXN1bHRMZW5ndGgpOwogICAgICAgICB1ZGF0X2Zvcm1hdChtX2RhdGVGb3JtYXQuZ2V0 KCksIHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsIG51bGxwdHIsICZzdGF0dXMp OwpAQCAtMTAwMCw3ICsxMDAxLDcgQEAgSlNWYWx1ZSBJbnRsRGF0ZVRpbWVGb3JtYXQ6OmZvcm1h dFRvUGFydAogICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0b3I8VUNoYXIsIDMy PiByZXN1bHQoMzIpOwogICAgIGF1dG8gcmVzdWx0TGVuZ3RoID0gdWRhdF9mb3JtYXRGb3JGaWVs ZHMobV9kYXRlRm9ybWF0LmdldCgpLCB2YWx1ZSwgcmVzdWx0LmRhdGEoKSwgcmVzdWx0LnNpemUo KSwgZmllbGRzLmdldCgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09W RVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1 cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQuZ3Jv dyhyZXN1bHRMZW5ndGgpOwogICAgICAgICB1ZGF0X2Zvcm1hdEZvckZpZWxkcyhtX2RhdGVGb3Jt YXQuZ2V0KCksIHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsIGZpZWxkcy5nZXQo KSwgJnN0YXR1cyk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JbnRsTnVt YmVyRm9ybWF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9JbnRsTnVtYmVyRm9ybWF0LmNwcAkocmV2aXNpb24gMjYwODQyKQorKysgU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSW50bE51bWJlckZvcm1hdC5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJKU0NJbmxpbmVzLmgiCiAjaW5jbHVkZSAiT2JqZWN0 Q29uc3RydWN0b3IuaCIKICNpbmNsdWRlIDx1bmljb2RlL3VmaWVsZHBvc2l0ZXIuaD4KKyNpbmNs dWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlNDIHsKIApA QCAtMzYxLDcgKzM2Miw3IEBAIEpTVmFsdWUgSW50bE51bWJlckZvcm1hdDo6Zm9ybWF0KEpTR2xv YmEKICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0b3I8VUNo YXIsIDMyPiBidWZmZXIoMzIpOwogICAgIGF1dG8gbGVuZ3RoID0gdW51bV9mb3JtYXREb3VibGUo bV9udW1iZXJGb3JtYXQuZ2V0KCksIHZhbHVlLCBidWZmZXIuZGF0YSgpLCBidWZmZXIuc2l6ZSgp LCBudWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9X X0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpIHsK ICAgICAgICAgYnVmZmVyLmdyb3cobGVuZ3RoKTsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VS Uk9SOwogICAgICAgICB1bnVtX2Zvcm1hdERvdWJsZShtX251bWJlckZvcm1hdC5nZXQoKSwgdmFs dWUsIGJ1ZmZlci5kYXRhKCksIGxlbmd0aCwgbnVsbHB0ciwgJnN0YXR1cyk7CkBAIC0zODksNyAr MzkwLDcgQEAgSlNWYWx1ZSBJbnRsTnVtYmVyRm9ybWF0Ojpmb3JtYXQoSlNHbG9iYQogICAgIFVF cnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIFZlY3RvcjxVQ2hhciwgMzI+IGJ1 ZmZlcigzMik7CiAgICAgYXV0byBsZW5ndGggPSB1bnVtX2Zvcm1hdERlY2ltYWwobV9udW1iZXJG b3JtYXQuZ2V0KCksIHJhd1N0cmluZywgc3RyaW5nLmxlbmd0aCgpLCBidWZmZXIuZGF0YSgpLCBi dWZmZXIuc2l6ZSgpLCBudWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVG RkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVy KHN0YXR1cykpIHsKICAgICAgICAgYnVmZmVyLmdyb3cobGVuZ3RoKTsKICAgICAgICAgc3RhdHVz ID0gVV9aRVJPX0VSUk9SOwogICAgICAgICB1bnVtX2Zvcm1hdERlY2ltYWwobV9udW1iZXJGb3Jt YXQuZ2V0KCksIHJhd1N0cmluZywgc3RyaW5nLmxlbmd0aCgpLCBidWZmZXIuZGF0YSgpLCBsZW5n dGgsIG51bGxwdHIsICZzdGF0dXMpOwpAQCAtNTUyLDcgKzU1Myw3IEBAIEpTVmFsdWUgSW50bE51 bWJlckZvcm1hdDo6Zm9ybWF0VG9QYXJ0cygKIAogICAgIFZlY3RvcjxVQ2hhciwgMzI+IHJlc3Vs dCgzMik7CiAgICAgYXV0byByZXN1bHRMZW5ndGggPSB1bnVtX2Zvcm1hdERvdWJsZUZvckZpZWxk cyhtX251bWJlckZvcm1hdC5nZXQoKSwgdmFsdWUsIHJlc3VsdC5kYXRhKCksIHJlc3VsdC5zaXpl KCksIGZpZWxkSXRyLmdldCgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVS X09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0 YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQu Z3JvdyhyZXN1bHRMZW5ndGgpOwogICAgICAgICB1bnVtX2Zvcm1hdERvdWJsZUZvckZpZWxkcyht X251bWJlckZvcm1hdC5nZXQoKSwgdmFsdWUsIHJlc3VsdC5kYXRhKCksIHJlc3VsdExlbmd0aCwg ZmllbGRJdHIuZ2V0KCksICZzdGF0dXMpOwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSW50bE9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvSW50bE9iamVjdC5jcHAJKHJldmlzaW9uIDI2MDg0MikKKysrIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0ludGxPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NCw2 ICs1NCw3IEBACiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8d3Rm L3RleHQvU3RyaW5nQnVpbGRlci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0ltcGwuaD4K KyNpbmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlND IHsKIApAQCAtMTQ0LDEzICsxNDUsMTMgQEAgc3RhdGljIFN0cmluZyBjb252ZXJ0SUNVTG9jYWxl VG9CQ1A0N0xhbgogICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIFZl Y3RvcjxjaGFyLCAzMj4gYnVmZmVyKDMyKTsKICAgICBhdXRvIGxlbmd0aCA9IHVsb2NfdG9MYW5n dWFnZVRhZyhsb2NhbGVJRCwgYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSwgZmFsc2UsICZz dGF0dXMpOwotICAgIGlmIChzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpIHsKKyAg ICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkgewogICAgICAgICBidWZm ZXIuZ3JvdyhsZW5ndGgpOwogICAgICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAg IHVsb2NfdG9MYW5ndWFnZVRhZyhsb2NhbGVJRCwgYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUo KSwgZmFsc2UsICZzdGF0dXMpOwogICAgIH0KICAgICBpZiAoIVVfRkFJTFVSRShzdGF0dXMpKQot ICAgICAgICByZXR1cm4gU3RyaW5nKFN0cmluZ0ltcGw6OmNyZWF0ZVN0YXRpY1N0cmluZ0ltcGwo YnVmZmVyLmRhdGEoKSwgbGVuZ3RoKSk7CisgICAgICAgIHJldHVybiBTdHJpbmcoYnVmZmVyLmRh dGEoKSwgbGVuZ3RoKTsKICAgICByZXR1cm4gU3RyaW5nKCk7CiB9CiAKQEAgLTMyMiwyMCArMzIz LDMyIEBAIHN0YXRpYyBTdHJpbmcgY2Fub25pY2FsaXplTGFuZ3VhZ2VUYWcoY28KICAgICAvLyAt IHVsb2NfdG9MYW5ndWFnZVRhZyBkb2Vzbid0IHRha2UgYW4gaW5wdXQgc2l6ZSBwYXJhbSBzbyB3 ZSBtdXN0IGVuc3VyZSB0aGUgc3RyaW5nIGlzIG51bGwtdGVybWluYXRlZCBvdXJzZWx2ZXMKICAg ICAvLyAtIGJlZm9yZSBJQ1UgNjQsIHRoZXJlJ3MgYSBjaGFuY2UgdGhhdCBpdCB3aWxsICJidWZm ZXIgb3ZlcmZsb3ciIHdoaWxlIHJlcXVlc3RpbmcgYSAqc21hbGxlciogc2l6ZQogICAgIFVFcnJv ckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwotICAgIFZlY3RvcjxjaGFyLCAzMj4gaW50ZXJt ZWRpYXRlKDMxKTsKKyAgICBWZWN0b3I8Y2hhciwgMzI+IGludGVybWVkaWF0ZSgzMik7CiAgICAg aW50MzJfdCBwYXJzZWRMZW5ndGg7CiAgICAgYXV0byBpbnRlcm1lZGlhdGVMZW5ndGggPSB1bG9j X2Zvckxhbmd1YWdlVGFnKGlucHV0LmRhdGEoKSwgaW50ZXJtZWRpYXRlLmRhdGEoKSwgaW50ZXJt ZWRpYXRlLnNpemUoKSwgJnBhcnNlZExlbmd0aCwgJnN0YXR1cyk7Ci0gICAgaWYgKHN0YXR1cyA9 PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikgeworICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVj ZUNTdHJpbmcoc3RhdHVzKSkgewogICAgICAgICBpbnRlcm1lZGlhdGUucmVzaXplKGludGVybWVk aWF0ZUxlbmd0aCArIDEpOwogICAgICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAg IHVsb2NfZm9yTGFuZ3VhZ2VUYWcoaW5wdXQuZGF0YSgpLCBpbnRlcm1lZGlhdGUuZGF0YSgpLCBp bnRlcm1lZGlhdGVMZW5ndGggKyAxLCAmcGFyc2VkTGVuZ3RoLCAmc3RhdHVzKTsKICAgICB9Ci0g ICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpIHx8IHBhcnNlZExlbmd0aCAhPSBzdGF0aWNfY2FzdDxp bnQzMl90PihpbnB1dC5sZW5ndGgoKSkpCisgICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpIHx8IHN0 YXR1cyA9PSBVX1NUUklOR19OT1RfVEVSTUlOQVRFRF9XQVJOSU5HIHx8IHBhcnNlZExlbmd0aCAh PSBzdGF0aWNfY2FzdDxpbnQzMl90PihpbnB1dC5sZW5ndGgoKSkpCiAgICAgICAgIHJldHVybiBT dHJpbmcoKTsKIAorI2lmIEFTU0VSVF9FTkFCTEVECisgICAgYm9vbCBzYXdOdWxsVGVybWluYXRv ciA9IGZhbHNlOworICAgIGZvciAoY2hhciBjIDogaW50ZXJtZWRpYXRlKSB7CisgICAgICAgIGlm IChjID09ICdcMCcpIHsKKyAgICAgICAgICAgIHNhd051bGxUZXJtaW5hdG9yID0gdHJ1ZTsKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorICAgIEFTU0VSVChzYXdOdWxsVGVy bWluYXRvcik7CisjZW5kaWYKKworICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0 b3I8Y2hhciwgMzI+IHJlc3VsdCgzMik7CiAgICAgYXV0byByZXN1bHRMZW5ndGggPSB1bG9jX3Rv TGFuZ3VhZ2VUYWcoaW50ZXJtZWRpYXRlLmRhdGEoKSwgcmVzdWx0LmRhdGEoKSwgcmVzdWx0LnNp emUoKSwgZmFsc2UsICZzdGF0dXMpOwotICAgIGlmIChzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZM T1dfRVJST1IpIHsKKyAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkg ewogICAgICAgICByZXN1bHQuZ3JvdyhyZXN1bHRMZW5ndGgpOwogICAgICAgICBzdGF0dXMgPSBV X1pFUk9fRVJST1I7CiAgICAgICAgIHVsb2NfdG9MYW5ndWFnZVRhZyhpbnRlcm1lZGlhdGUuZGF0 YSgpLCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsIGZhbHNlLCAmc3RhdHVzKTsKSW5kZXg6 IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ludGxSZWxhdGl2ZVRpbWVGb3JtYXQuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ludGxSZWxhdGl2 ZVRpbWVGb3JtYXQuY3BwCShyZXZpc2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9JbnRsUmVsYXRpdmVUaW1lRm9ybWF0LmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkludGxPYmplY3QuaCIKICNpbmNsdWRlICJKU0NJbmxp bmVzLmgiCiAjaW5jbHVkZSAiT2JqZWN0Q29uc3RydWN0b3IuaCIKKyNpbmNsdWRlIDx3dGYvdW5p Y29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlNDIHsKIApAQCAtMjUzLDcgKzI1 NCw3IEBAIFN0cmluZyBJbnRsUmVsYXRpdmVUaW1lRm9ybWF0Ojpmb3JtYXRJbnQKICAgICBVRXJy b3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0b3I8VUNoYXIsIDMyPiByZXN1 bHQoMzIpOwogICAgIGF1dG8gcmVzdWx0TGVuZ3RoID0gZm9ybWF0UmVsYXRpdmVUaW1lKG1fcmVs YXRpdmVEYXRlVGltZUZvcm1hdHRlci5nZXQoKSwgdmFsdWUsIHVuaXRUeXBlLnZhbHVlKCksIHJl c3VsdC5kYXRhKCksIHJlc3VsdC5zaXplKCksICZzdGF0dXMpOwotICAgIGlmIChzdGF0dXMgPT0g VV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpIHsKKyAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VC dWZmZXIoc3RhdHVzKSkgewogICAgICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAg IHJlc3VsdC5ncm93KHJlc3VsdExlbmd0aCk7CiAgICAgICAgIGZvcm1hdFJlbGF0aXZlVGltZSht X3JlbGF0aXZlRGF0ZVRpbWVGb3JtYXR0ZXIuZ2V0KCksIHZhbHVlLCB1bml0VHlwZS52YWx1ZSgp LCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsICZzdGF0dXMpOwpAQCAtMjk1LDcgKzI5Niw3 IEBAIEpTVmFsdWUgSW50bFJlbGF0aXZlVGltZUZvcm1hdDo6Zm9ybWF0VG8KIAogICAgIFZlY3Rv cjxVQ2hhciwgMzI+IGJ1ZmZlcigzMik7CiAgICAgYXV0byBudW1iZXJMZW5ndGggPSB1bnVtX2Zv cm1hdERvdWJsZUZvckZpZWxkcyhtX251bWJlckZvcm1hdC5nZXQoKSwgYWJzVmFsdWUsIGJ1ZmZl ci5kYXRhKCksIGJ1ZmZlci5zaXplKCksIGl0ZXJhdG9yLmdldCgpLCAmc3RhdHVzKTsKLSAgICBp ZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9H cm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VS Uk9SOwogICAgICAgICBidWZmZXIuZ3JvdyhudW1iZXJMZW5ndGgpOwogICAgICAgICB1bnVtX2Zv cm1hdERvdWJsZUZvckZpZWxkcyhtX251bWJlckZvcm1hdC5nZXQoKSwgYWJzVmFsdWUsIGJ1ZmZl ci5kYXRhKCksIG51bWJlckxlbmd0aCwgaXRlcmF0b3IuZ2V0KCksICZzdGF0dXMpOwpJbmRleDog U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvU3RyaW5nUHJvdG90eXBlLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9TdHJpbmdQcm90b3R5cGUuY3Bw CShyZXZpc2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9TdHJp bmdQcm90b3R5cGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01OCw2ICs1OCw3IEBACiAjaW5jbHVk ZSA8d3RmL01hdGhFeHRyYXMuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+ CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nVmlldy5oPgorI2luY2x1ZGUgPHd0Zi91bmljb2Rl L2ljdS9JQ1VIZWxwZXJzLmg+CiAKIG5hbWVzcGFjZSBKU0MgewogCkBAIC0xNjIwLDE1ICsxNjIx LDE1IEBAIHN0YXRpYyBFbmNvZGVkSlNWYWx1ZSB0b0xvY2FsZUNhc2UoSlNHbG8KICAgICAvLyAx Ny4gTGV0IEwgYmUgYSBTdHJpbmcgd2hvc2UgZWxlbWVudHMgYXJlLCBpbiBvcmRlciwgdGhlIGVs ZW1lbnRzIG9mIGN1TGlzdC4KIAogICAgIC8vIE1vc3Qgc3RyaW5ncyBsb3dlci91cHBlciBjYXNl IHdpbGwgYmUgdGhlIHNhbWUgc2l6ZSBhcyBvcmlnaW5hbCwgc28gdHJ5IHRoYXQgZmlyc3QuCi0g ICAgVUVycm9yQ29kZSBlcnJvcihVX1pFUk9fRVJST1IpOworICAgIFVFcnJvckNvZGUgZXJyb3Ig PSBVX1pFUk9fRVJST1I7CiAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIodmlld0xlbmd0aCk7CiAg ICAgU3RyaW5nIGxvd2VyOwogICAgIGNvbnN0IGludDMyX3QgcmVzdWx0TGVuZ3RoID0gY29udmVy dENhc2UoYnVmZmVyLmRhdGEoKSwgdmlld0xlbmd0aCwgdmlldy51cGNvbnZlcnRlZENoYXJhY3Rl cnMoKSwgdmlld0xlbmd0aCwgdXRmOExvY2FsZUJ1ZmZlci5kYXRhKCksICZlcnJvcik7CiAgICAg aWYgKFVfU1VDQ0VTUyhlcnJvcikpCiAgICAgICAgIGxvd2VyID0gU3RyaW5nKGJ1ZmZlci5kYXRh KCksIHJlc3VsdExlbmd0aCk7Ci0gICAgZWxzZSBpZiAoZXJyb3IgPT0gVV9CVUZGRVJfT1ZFUkZM T1dfRVJST1IpIHsKKyAgICBlbHNlIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihlcnJv cikpIHsKICAgICAgICAgLy8gQ29udmVydGVkIGNhc2UgbmVlZHMgbW9yZSBzcGFjZSB0aGFuIG9y aWdpbmFsLiBUcnkgYWdhaW4uCi0gICAgICAgIFVFcnJvckNvZGUgZXJyb3IoVV9aRVJPX0VSUk9S KTsKKyAgICAgICAgVUVycm9yQ29kZSBlcnJvciA9IFVfWkVST19FUlJPUjsKICAgICAgICAgVmVj dG9yPFVDaGFyPiBidWZmZXIocmVzdWx0TGVuZ3RoKTsKICAgICAgICAgY29udmVydENhc2UoYnVm ZmVyLmRhdGEoKSwgcmVzdWx0TGVuZ3RoLCB2aWV3LnVwY29udmVydGVkQ2hhcmFjdGVycygpLCB2 aWV3TGVuZ3RoLCB1dGY4TG9jYWxlQnVmZmVyLmRhdGEoKSwgJmVycm9yKTsKICAgICAgICAgaWYg KFVfRkFJTFVSRShlcnJvcikpCkBAIC0xOTI2LDcgKzE5MjcsNyBAQCBzdGF0aWMgSlNWYWx1ZSBu b3JtYWxpemUoSlNHbG9iYWxPYmplY3QqCiAgICAgICAgIFJFTEVBU0VfQU5EX1JFVFVSTihzY29w ZSwgc3RyaW5nKTsKIAogICAgIGludDMyX3Qgbm9ybWFsaXplZFN0cmluZ0xlbmd0aCA9IHVub3Jt Ml9ub3JtYWxpemUobm9ybWFsaXplciwgY2hhcmFjdGVycywgdmlldy5sZW5ndGgoKSwgbnVsbHB0 ciwgMCwgJnN0YXR1cyk7Ci0gICAgQVNTRVJUKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19F UlJPUik7CisgICAgQVNTRVJUKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpOwog CiAgICAgVUNoYXIqIGJ1ZmZlcjsKICAgICBhdXRvIHJlc3VsdCA9IFN0cmluZ0ltcGw6OnRyeUNy ZWF0ZVVuaW5pdGlhbGl6ZWQobm9ybWFsaXplZFN0cmluZ0xlbmd0aCwgYnVmZmVyKTsKSW5kZXg6 IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hhbmdlTG9n CShyZXZpc2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDQzIEBACisyMDIwLTA0LTI4ICBTYWFtIEJhcmF0aSAgPHNiYXJhdGlAYXBw bGUuY29tPgorCisgICAgICAgIFVfU1RSSU5HX05PVF9URVJNSU5BVEVEX1dBUk5JTkcgSUNVIG11 c3QgYmUgaGFuZGxlZCB3aGVuIHVzaW5nIHRoZSBvdXRwdXQgYnVmZmVyIGFzIGEgQyBzdHJpbmcK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMTE0Mgor ICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjI1MzA4NjA+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisJCisgICAgICAgIE1vc3Qgb2Ygb3VyIHVzZXMgb2YgSUNVIHJlcXVp cmUgdXMgdG8gcHJvZHVjZSBhIGJ1ZmZlciBvZiB0aGUgY29ycmVjdAorICAgICAgICBsZW5ndGgu IFdlIG9mdGVuIHRlc3QgaWYgdGhlIGZpcnN0IGNhbGwgdG8gSUNVIEFQSSBzdWNjZWVkcywgYW5k IGlmIGl0CisgICAgICAgIGRvZXNuJ3QsIHdlIGdyb3cgdG8gdGhlIHJlcXVpcmVkIGJ1ZmZlciBz aXplLCBhbmQgdHJ5IGFnYWluLiBIb3dldmVyLAorICAgICAgICB0aGVyZSBhcmUgYSBmZXcgQVBJ cyB0aGF0IHdlIHVzZSBsaWtlIHRoaXMsIGV4Y2VwdCB0aGF0IHRoZXkgd3JpdGUgdGhlaXIKKyAg ICAgICAgb3V0cHV0IHRvIGEgQyBzdHJpbmcgaW5zdGVhZCBvZiBhIGJ1ZmZlci4KKyAgICAgICAg CisgICAgICAgIEluIGEgY291cGxlIHNjZW5hcmlvcyB3aGVuIHdlIHdlcmUgcHJvZHVjaW5nIEMg c3RyaW5ncywgd2Ugd2VyZSBvbmx5IHRlc3RpbmcKKyAgICAgICAgZm9yIHRoZSBVX0JVRkZFUl9P VkVSRkxPV19FUlJPUiwgaW5zdGVhZCBvZiBib3RoIFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SIGFu ZAorICAgICAgICBVX1NUUklOR19OT1RfVEVSTUlOQVRFRF9XQVJOSU5HLiBUaGlzIHBhdGNoIGZp eGVzIHRob3NlIGJ1Z3MuIEl0IGFsc28KKyAgICAgICAgaW50cm9kdWNlcyB0d28gbmV3IGhlbHBl ciBtZXRob2RzIGZvciB0ZXN0aW5nIGVycm9yIGNvZGVzIHJldHVybmVkIGJ5IElDVS4KKyAgICAg ICAgCisgICAgICAgIC0gVGhlIGZpcnN0IGlzIG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyLCB3 aGljaCByZXR1cm5zIHRydWUgaWYgd2UgbmVlZCB0bworICAgICAgICBncm93IHRoZSBidWZmZXIg YW5kIHJlLWNhbGwgaW50byBJQ1UgdG8gZ2V0IHRoZSByZXN1bHQuCisgICAgICAgIC0gVGhlIHNl Y29uZCBpcyBuZWVkc1RvR3Jvd1RvUHJvZHVjZUNTdHJpbmcsIHdoaWNoIHJldHVybnMgdHJ1ZSBp ZiB3ZSBuZWVkIHRvCisgICAgICAgIGdyb3cgdGhlIGJ1ZmZlciBhbmQgcmUtY2FsbCBpbnRvIElD VSB0byBwcm9kdWNlIGEgdmFsaWQgQyBzdHJpbmcuCisgICAgICAgIAorICAgICAgICBJJ3ZlIGF1 ZGl0ZWQgYWxsIHVzZXMgb2YgVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IgYW5kIGNvbnZlcnRlZCB0 aGVtIHRvIHVzZSBvbmUKKyAgICAgICAgb2YgdGhlIGFib3ZlIGhlbHBlciBtZXRob2RzIGluc3Rl YWQuCisgICAgICAgIAorICAgICAgICBUaGUgaXNzdWVzIGluIG91ciBoYW5kbGluZyBvZiBVX1NU UklOR19OT1RfVEVSTUlOQVRFRF9XQVJOSU5HIHdlcmUgY2F1Z2h0IG9uIGlPUyBKU0MKKyAgICAg ICAgdGVzdHMgaW4gSlNUZXN0cy9zdHJlc3MvaW50bC1kYXRldGltZWZvcm1hdC5qcworCisgICAg ICAgICogV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogd3RmL0NNYWtl TGlzdHMudHh0OgorICAgICAgICAqIHd0Zi90ZXh0L0xpbmVCcmVha0l0ZXJhdG9yUG9vbElDVS5o OgorICAgICAgICAoV1RGOjpMaW5lQnJlYWtJdGVyYXRvclBvb2w6Om1ha2VMb2NhbGVXaXRoQnJl YWtLZXl3b3JkKToKKyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdWaWV3LmNwcDoKKyAgICAgICAg KFdURjo6bm9ybWFsaXplZE5GQyk6CisgICAgICAgICogd3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBl cnMuaDogQWRkZWQuCisgICAgICAgIChXVEY6Om5lZWRzVG9Hcm93VG9Qcm9kdWNlQ1N0cmluZyk6 CisgICAgICAgIChXVEY6Om5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKToKKwogMjAyMC0wNC0y NyAgUnlhbiBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBbQ29jb2Fd IHN0b3AgdXNpbmcgb3V0IGFyZ3VtZW50cyBmb3IgZG9jdW1lbnQgYXR0cmlidXRlcyB3aGVuIGNv bnZlcnRpbmcgdG8gYXR0cmlidXRlZCBzdHJpbmdzCkluZGV4OiBTb3VyY2UvV1RGL1dURi54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvV1RGLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDI2MDg0MikKKysrIFNvdXJjZS9XVEYvV1RG Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTM5Miw2ICszOTIs NyBAQAogCQk1MUYxNzUyOTFGM0Q0ODYwMDBDNzQ5NTAgLyogUGVyc2lzdGVudEVuY29kZXIuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGVyc2lzdGVudEVuY29kZXIu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUYxNzUyQTFGM0Q0ODYwMDBDNzQ5 NTAgLyogUGVyc2lzdGVudEVuY29kZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gUGVyc2lzdGVudEVuY29kZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTI2 QUVDOTExRjZCNEU1QzAwNjk1RjVEIC8qIE5vVGFpbENhbGxzLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IE5vVGFpbENhbGxzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTUyQjIyOEMxMjQ1OERDODIwMDc1M0Q5MSAvKiBJQ1VIZWxwZXJzLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IElDVUhlbHBlcnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTMwQTYzNDgx RkEzRTNBMDAwMjZBNTQ1IC8qIFNjcmlwdHMgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg bGFzdEtub3duRmlsZVR5cGUgPSBmb2xkZXI7IHBhdGggPSBTY3JpcHRzOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk1MzExQkQ1MTFFQTcxQ0FEMDA1MjUyODEgLyogU2lnbmFscy5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBTaWduYWxzLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTMxMUJENTUxRUE3RTE1QTAwNTI1MjgxIC8qIExvY2ts ZXNzQmFnLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IExvY2tsZXNzQmFnLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xNDM4LDYgKzE0MzksNyBAQAogCQlBOEE0 NzM0RjE1MUE4MjVCMDA0MTIzRkYgLyogaWN1ICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJ CQljaGlsZHJlbiA9ICgKKwkJCQk1MkIyMjhDMTI0NThEQzgyMDA3NTNEOTEgLyogSUNVSGVscGVy cy5oICovLAogCQkJCUE4QTQ3MzUwMTUxQTgyNUIwMDQxMjNGRiAvKiBDb2xsYXRvcklDVS5jcHAg Ki8sCiAJCQkpOwogCQkJcGF0aCA9IGljdTsKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL0NNYWtlTGlz dHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL0NNYWtlTGlzdHMudHh0CShyZXZp c2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAkod29ya2luZyBj b3B5KQpAQCAtMzU4LDYgKzM1OCw3IEBAIHNldChXVEZfUFVCTElDX0hFQURFUlMKICAgICB1bmlj b2RlL0NoYXJhY3Rlck5hbWVzLmgKICAgICB1bmljb2RlL0NvbGxhdG9yLmgKICAgICB1bmljb2Rl L1VURjhDb252ZXJzaW9uLmgKKyAgICB1bmljb2RlL2ljdS9JQ1VIZWxwZXJzLmgKICkKIAogc2V0 KFdURl9TT1VSQ0VTCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi90ZXh0L0xpbmVCcmVha0l0ZXJhdG9y UG9vbElDVS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL3RleHQvTGluZUJyZWFrSXRl cmF0b3JQb29sSUNVLmgJKHJldmlzaW9uIDI2MDg0MikKKysrIFNvdXJjZS9XVEYvd3RmL3RleHQv TGluZUJyZWFrSXRlcmF0b3JQb29sSUNVLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDYgKzMwLDcg QEAKICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFk U3BlY2lmaWMuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9BdG9tU3RyaW5nLmg+CisjaW5jbHVkZSA8 d3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKQEAgLTc0 LDcgKzc1LDcgQEAgcHVibGljOgogICAgICAgICBpbnQzMl90IGxlbmd0aE5lZWRlZCA9IHVsb2Nf c2V0S2V5d29yZFZhbHVlKCJsYiIsIGtleXdvcmRWYWx1ZSwgc2NyYXRjaEJ1ZmZlci5kYXRhKCks IHNjcmF0Y2hCdWZmZXIuc2l6ZSgpLCAmc3RhdHVzKTsKICAgICAgICAgaWYgKFVfU1VDQ0VTUyhz dGF0dXMpKQogICAgICAgICAgICAgcmV0dXJuIEF0b21TdHJpbmc6OmZyb21VVEY4KHNjcmF0Y2hC dWZmZXIuZGF0YSgpLCBsZW5ndGhOZWVkZWQpOwotICAgICAgICBpZiAoc3RhdHVzID09IFVfQlVG RkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUNT dHJpbmcoc3RhdHVzKSkgewogICAgICAgICAgICAgc2NyYXRjaEJ1ZmZlci5ncm93KGxlbmd0aE5l ZWRlZCArIDEpOwogICAgICAgICAgICAgbWVtc2V0KHNjcmF0Y2hCdWZmZXIuZGF0YSgpICsgdXRm OExvY2FsZS5sZW5ndGgoKSwgMCwgc2NyYXRjaEJ1ZmZlci5zaXplKCkgLSB1dGY4TG9jYWxlLmxl bmd0aCgpKTsKICAgICAgICAgICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKSW5kZXg6IFNvdXJj ZS9XVEYvd3RmL3RleHQvU3RyaW5nVmlldy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93 dGYvdGV4dC9TdHJpbmdWaWV3LmNwcAkocmV2aXNpb24gMjYwODQyKQorKysgU291cmNlL1dURi93 dGYvdGV4dC9TdHJpbmdWaWV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQCBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJCiAjaW5jbHVkZSA8d3RmL09w dGlvbmFsLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nVG9JbnRlZ2VyQ29udmVyc2lvbi5o PgogI2luY2x1ZGUgPHd0Zi90ZXh0L1RleHRCcmVha0l0ZXJhdG9yLmg+CisjaW5jbHVkZSA8d3Rm L3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKQEAgLTI5MSw3 ICsyOTIsNyBAQCBTdHJpbmdWaWV3V2l0aFVuZGVybHlpbmdTdHJpbmcgbm9ybWFsaXplCiAgICAg ICAgIHJldHVybiB7IHN0cmluZywgeyB9IH07CiAKICAgICB1bnNpZ25lZCBub3JtYWxpemVkTGVu Z3RoID0gdW5vcm0yX25vcm1hbGl6ZShub3JtYWxpemVyLCBzdHJpbmcuY2hhcmFjdGVyczE2KCks IHN0cmluZy5sZW5ndGgoKSwgbnVsbHB0ciwgMCwgJnN0YXR1cyk7Ci0gICAgQVNTRVJUKHN0YXR1 cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUik7CisgICAgQVNTRVJUKG5lZWRzVG9Hcm93VG9Q cm9kdWNlQnVmZmVyKHN0YXR1cykpOwogCiAgICAgVUNoYXIqIGNoYXJhY3RlcnM7CiAgICAgU3Ry aW5nIHJlc3VsdCA9IFN0cmluZzo6Y3JlYXRlVW5pbml0aWFsaXplZChub3JtYWxpemVkTGVuZ3Ro LCBjaGFyYWN0ZXJzKTsKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBl cnMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi91bmljb2RlL2ljdS9JQ1VIZWxwZXJz LmgJKG5vbmV4aXN0ZW50KQorKysgU291cmNlL1dURi93dGYvdW5pY29kZS9pY3UvSUNVSGVscGVy cy5oCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsNDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDx1bmlj b2RlL3V0eXBlcy5oPgorCituYW1lc3BhY2UgV1RGIHsKKworaW5saW5lIGJvb2wgbmVlZHNUb0dy b3dUb1Byb2R1Y2VDU3RyaW5nKFVFcnJvckNvZGUgZXJyb3JDb2RlKQoreworICAgIHJldHVybiBl cnJvckNvZGUgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IgfHwgZXJyb3JDb2RlID09IFVfU1RS SU5HX05PVF9URVJNSU5BVEVEX1dBUk5JTkc7Cit9CisKK2lubGluZSBib29sIG5lZWRzVG9Hcm93 VG9Qcm9kdWNlQnVmZmVyKFVFcnJvckNvZGUgZXJyb3JDb2RlKQoreworICAgIHJldHVybiBlcnJv ckNvZGUgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1I7Cit9CisKK30KKwordXNpbmcgV1RGOjpu ZWVkc1RvR3Jvd1RvUHJvZHVjZUNTdHJpbmc7Cit1c2luZyBXVEY6Om5lZWRzVG9Hcm93VG9Qcm9k dWNlQnVmZmVyOwpJbmRleDogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYwODQyKQorKysgU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjcgQEAKKzIwMjAtMDQt MjggIFNhYW0gQmFyYXRpICA8c2JhcmF0aUBhcHBsZS5jb20+CisKKyAgICAgICAgVV9TVFJJTkdf Tk9UX1RFUk1JTkFURURfV0FSTklORyBJQ1UgbXVzdCBiZSBoYW5kbGVkIHdoZW4gdXNpbmcgdGhl IG91dHB1dCBidWZmZXIgYXMgYSBDIHN0cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExMTQyCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS82MjUz MDg2MD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBO byBuZXcgdGVzdHMgKE9PUFMhKS4KKworICAgICAgICAqIGVkaXRpbmcvVGV4dEl0ZXJhdG9yLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6Om5vcm1hbGl6ZUNoYXJhY3RlcnMpOgorICAgICAgICAqIHBs YXRmb3JtL3RleHQvTG9jYWxlSUNVLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsZUlDVTo6 ZGVjaW1hbFN5bWJvbCk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbGVJQ1U6OmRlY2ltYWxUZXh0 QXR0cmlidXRlKToKKyAgICAgICAgKFdlYkNvcmU6OmdldERhdGVGb3JtYXRQYXR0ZXJuKToKKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsZUlDVTo6Y3JlYXRlTGFiZWxWZWN0b3IpOgorICAgICAgICAo V2ViQ29yZTo6Z2V0Rm9ybWF0Rm9yU2tlbGV0b24pOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQv TG9jYWxlVG9TY3JpcHRNYXBwaW5nSUNVLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmxvY2FsZVRv U2NyaXB0Q29kZUZvckZvbnRTZWxlY3Rpb24pOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvVGV4 dENvZGVjSUNVLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRleHRDb2RlY0lDVTo6ZGVjb2RlKToK KyAgICAgICAgKFdlYkNvcmU6OlRleHRDb2RlY0lDVTo6ZW5jb2RlKToKKwogMjAyMC0wNC0yOCAg SmFjayBMZWUgIDxzaGloY2hpZWhfbGVlQGFwcGxlLmNvbT4KIAogICAgICAgICBOdWxscHRyIGNy YXNoIGluIEVkaXRDb21tYW5kOjpFZGl0Q29tbWFuZCB2aWEgQ29tcG9zaXRlRWRpdENvbW1hbmQ6 OnJlbW92ZU5vZGUKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVGV4dEl0ZXJhdG9yLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1RleHRJdGVyYXRvci5jcHAJ KHJldmlzaW9uIDI2MDg0MikKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVGV4dEl0ZXJhdG9y LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjYsNiArNjYsNyBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0 L1N0cmluZ0J1aWxkZXIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9UZXh0QnJlYWtJdGVyYXRvci5o PgogI2luY2x1ZGUgPHd0Zi91bmljb2RlL0NoYXJhY3Rlck5hbWVzLmg+CisjaW5jbHVkZSA8d3Rm L3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogI2lmICFVQ09ORklHX05PX0NPTExBVElPTgog I2luY2x1ZGUgPHVuaWNvZGUvdXNlYXJjaC5oPgpAQCAtMTgzNiw3ICsxODM3LDcgQEAgc3RhdGlj IHZvaWQgbm9ybWFsaXplQ2hhcmFjdGVycyhjb25zdCBVQwogICAgIGJ1ZmZlci5yZXNpemUobGVu Z3RoKTsKIAogICAgIGF1dG8gbm9ybWFsaXplZExlbmd0aCA9IHVub3JtMl9ub3JtYWxpemUobm9y bWFsaXplciwgY2hhcmFjdGVycywgbGVuZ3RoLCBidWZmZXIuZGF0YSgpLCBsZW5ndGgsICZzdGF0 dXMpOwotICAgIEFTU0VSVChVX1NVQ0NFU1Moc3RhdHVzKSB8fCBzdGF0dXMgPT0gVV9CVUZGRVJf T1ZFUkZMT1dfRVJST1IpOworICAgIEFTU0VSVChVX1NVQ0NFU1Moc3RhdHVzKSB8fCBuZWVkc1Rv R3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKTsKIAogICAgIGJ1ZmZlci5yZXNpemUobm9ybWFs aXplZExlbmd0aCk7CiAKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvTG9jYWxl SUNVLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0xvY2Fs ZUlDVS5jcHAJKHJldmlzaW9uIDI2MDg0MikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Rl eHQvTG9jYWxlSUNVLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1 ZGUgPHVuaWNvZGUvdWxvYy5oPgogI2luY2x1ZGUgPHd0Zi9EYXRlTWF0aC5oPgogI2luY2x1ZGUg PHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNV SGVscGVycy5oPgogCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTY5LDggKzcwLDggQEAgU3Ry aW5nIExvY2FsZUlDVTo6ZGVjaW1hbFN5bWJvbChVTnVtYmVyRgogewogICAgIFVFcnJvckNvZGUg c3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIGludDMyX3QgYnVmZmVyTGVuZ3RoID0gdW51bV9n ZXRTeW1ib2wobV9udW1iZXJGb3JtYXQsIHN5bWJvbCwgMCwgMCwgJnN0YXR1cyk7Ci0gICAgQVNT RVJUKFVfU1VDQ0VTUyhzdGF0dXMpIHx8IHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJP Uik7Ci0gICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpICYmIHN0YXR1cyAhPSBVX0JVRkZFUl9PVkVS RkxPV19FUlJPUikKKyAgICBBU1NFUlQoVV9TVUNDRVNTKHN0YXR1cykgfHwgbmVlZHNUb0dyb3dU b1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSk7CisgICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpICYmICFu ZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKQogICAgICAgICByZXR1cm4gU3RyaW5n KCk7CiAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIoYnVmZmVyTGVuZ3RoKTsKICAgICBzdGF0dXMg PSBVX1pFUk9fRVJST1I7CkBAIC04NCw4ICs4NSw4IEBAIFN0cmluZyBMb2NhbGVJQ1U6OmRlY2lt YWxUZXh0QXR0cmlidXRlKFUKIHsKICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJP UjsKICAgICBpbnQzMl90IGJ1ZmZlckxlbmd0aCA9IHVudW1fZ2V0VGV4dEF0dHJpYnV0ZShtX251 bWJlckZvcm1hdCwgdGFnLCAwLCAwLCAmc3RhdHVzKTsKLSAgICBBU1NFUlQoVV9TVUNDRVNTKHN0 YXR1cykgfHwgc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKTsKLSAgICBpZiAoVV9G QUlMVVJFKHN0YXR1cykgJiYgc3RhdHVzICE9IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKQorICAg IEFTU0VSVChVX1NVQ0NFU1Moc3RhdHVzKSB8fCBuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihz dGF0dXMpKTsKKyAgICBpZiAoVV9GQUlMVVJFKHN0YXR1cykgJiYgIW5lZWRzVG9Hcm93VG9Qcm9k dWNlQnVmZmVyKHN0YXR1cykpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKICAgICBWZWN0b3I8 VUNoYXI+IGJ1ZmZlcihidWZmZXJMZW5ndGgpOwogICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsK QEAgLTE1MCw3ICsxNTEsNyBAQCBzdGF0aWMgU3RyaW5nIGdldERhdGVGb3JtYXRQYXR0ZXJuKGNv bnN0CiAKICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBpbnQzMl90 IGxlbmd0aCA9IHVkYXRfdG9QYXR0ZXJuKGRhdGVGb3JtYXQsIFRSVUUsIDAsIDAsICZzdGF0dXMp OwotICAgIGlmIChzdGF0dXMgIT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IgfHwgIWxlbmd0aCkK KyAgICBpZiAoIW5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykgfHwgIWxlbmd0aCkK ICAgICAgICAgcmV0dXJuIGVtcHR5U3RyaW5nKCk7CiAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIo bGVuZ3RoKTsKICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CkBAIC0xNzIsNyArMTczLDcgQEAg c3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxTdHJpbmc+PiBMb2NhbGVJQwogICAgIGZvciAoaW50MzJf dCBpID0gMDsgaSA8IHNpemU7ICsraSkgewogICAgICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVf WkVST19FUlJPUjsKICAgICAgICAgaW50MzJfdCBsZW5ndGggPSB1ZGF0X2dldFN5bWJvbHMoZGF0 ZUZvcm1hdCwgdHlwZSwgc3RhcnRJbmRleCArIGksIDAsIDAsICZzdGF0dXMpOwotICAgICAgICBp ZiAoc3RhdHVzICE9IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKQorICAgICAgICBpZiAoIW5lZWRz VG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpCiAgICAgICAgICAgICByZXR1cm4gbWFrZVVu aXF1ZTxWZWN0b3I8U3RyaW5nPj4oKTsKICAgICAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIobGVu Z3RoKTsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwpAQCAtMjY0LDcgKzI2NSw3IEBA IHN0YXRpYyBTdHJpbmcgZ2V0Rm9ybWF0Rm9yU2tlbGV0b24oY29uc3QKICAgICAgICAgcmV0dXJu IGZvcm1hdDsKICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgaW50MzJfdCBsZW5ndGgg PSB1ZGF0cGdfZ2V0QmVzdFBhdHRlcm4ocGF0dGVybkdlbmVyYXRvciwgc2tlbGV0b24sIHNrZWxl dG9uTGVuZ3RoLCAwLCAwLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09W RVJGTE9XX0VSUk9SICYmIGxlbmd0aCkgeworICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1 ZmZlcihzdGF0dXMpICYmIGxlbmd0aCkgewogICAgICAgICBWZWN0b3I8VUNoYXI+IGJ1ZmZlcihs ZW5ndGgpOwogICAgICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAgIHVkYXRwZ19n ZXRCZXN0UGF0dGVybihwYXR0ZXJuR2VuZXJhdG9yLCBza2VsZXRvbiwgc2tlbGV0b25MZW5ndGgs IGJ1ZmZlci5kYXRhKCksIGxlbmd0aCwgJnN0YXR1cyk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS90ZXh0L0xvY2FsZVRvU2NyaXB0TWFwcGluZ0lDVS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9Mb2NhbGVUb1NjcmlwdE1hcHBpbmdJQ1UuY3Bw CShyZXZpc2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0xvY2Fs ZVRvU2NyaXB0TWFwcGluZ0lDVS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDYgKzM0LDcgQEAK ICNpbmNsdWRlIDx1bmljb2RlL3Vsb2MuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisjaW5jbHVkZSA8d3RmL3VuaWNvZGUv aWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC03MSw3ICs3Miw3 IEBAIFVTY3JpcHRDb2RlIGxvY2FsZVRvU2NyaXB0Q29kZUZvckZvbnRTZWwKICAgICBVU2NyaXB0 Q29kZSBzY3JpcHRDb2RlID0gVVNDUklQVF9DT01NT047CiAgICAgdXNjcmlwdF9nZXRDb2RlKHNj cmlwdCwgJnNjcmlwdENvZGUsIDEsICZzdGF0dXMpOwogICAgIC8vIElnbm9yZSBlcnJvciB0aGF0 IG11bHRpcGxlIHNjcmlwdHMgY291bGQgYmUgcmV0dXJuZWQsIHNpbmNlIHdlIG9ubHkgd2FudCBv bmUgc2NyaXB0LgotICAgIGlmIChVX0ZBSUxVUkUoc3RhdHVzKSAmJiBzdGF0dXMgIT0gVV9CVUZG RVJfT1ZFUkZMT1dfRVJST1IpCisgICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpICYmICFuZWVkc1Rv R3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKQogICAgICAgICByZXR1cm4gVVNDUklQVF9DT01N T047CiAKICAgICByZXR1cm4gc2NyaXB0Q29kZUZvckZvbnRTZWxlY3Rpb24oc2NyaXB0Q29kZSk7 CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY0lDVS5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Q29kZWNJQ1UuY3Bw CShyZXZpc2lvbiAyNjA4NDIpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRD b2RlY0lDVS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlIDx3 dGYvdGV4dC9DU3RyaW5nLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgog I2luY2x1ZGUgPHd0Zi91bmljb2RlL0NoYXJhY3Rlck5hbWVzLmg+CisjaW5jbHVkZSA8d3RmL3Vu aWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0zMDgs NyArMzA5LDcgQEAgU3RyaW5nIFRleHRDb2RlY0lDVTo6ZGVjb2RlKGNvbnN0IGNoYXIqIAogICAg IGRvIHsKICAgICAgICAgaW50IHVjaGFyc0RlY29kZWQgPSBkZWNvZGVUb0J1ZmZlcihidWZmZXIs IGJ1ZmZlckxpbWl0LCBzb3VyY2UsIHNvdXJjZUxpbWl0LCBvZmZzZXRzLCBmbHVzaCwgZXJyKTsK ICAgICAgICAgcmVzdWx0LmFwcGVuZENoYXJhY3RlcnMoYnVmZmVyLCB1Y2hhcnNEZWNvZGVkKTsK LSAgICB9IHdoaWxlIChlcnIgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpOworICAgIH0gd2hp bGUgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKGVycikpOwogCiAgICAgaWYgKFVfRkFJTFVS RShlcnIpKSB7CiAgICAgICAgIC8vIGZsdXNoIHRoZSBjb252ZXJ0ZXIgc28gaXQgY2FuIGJlIHJl dXNlZCwgYW5kIG5vdCBiZSBib3RoZXJlZCBieSB0aGlzIGVycm9yLgpAQCAtNDYxLDcgKzQ2Miw3 IEBAIFZlY3Rvcjx1aW50OF90PiBUZXh0Q29kZWNJQ1U6OmVuY29kZShTdHIKICAgICAgICAgZXJy b3IgPSBVX1pFUk9fRVJST1I7CiAgICAgICAgIHVjbnZfZnJvbVVuaWNvZGUobV9jb252ZXJ0ZXIu Z2V0KCksICZ0YXJnZXQsIHRhcmdldExpbWl0LCAmc291cmNlLCBzb3VyY2VMaW1pdCwgMCwgdHJ1 ZSwgJmVycm9yKTsKICAgICAgICAgcmVzdWx0LmFwcGVuZChyZWludGVycHJldF9jYXN0PHVpbnQ4 X3QqPihidWZmZXIpLCB0YXJnZXQgLSBidWZmZXIpOwotICAgIH0gd2hpbGUgKGVycm9yID09IFVf QlVGRkVSX09WRVJGTE9XX0VSUk9SKTsKKyAgICB9IHdoaWxlIChuZWVkc1RvR3Jvd1RvUHJvZHVj ZUJ1ZmZlcihlcnJvcikpOwogICAgIHJldHVybiByZXN1bHQ7CiB9CiAK 397921 2020-04-28 21:26:07 -0700 2020-04-29 00:15:24 -0700 patch for landing b-backup.diff text/plain 28986 saam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYwODYyKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMwIEBA CisyMDIwLTA0LTI4ICBTYWFtIEJhcmF0aSAgPHNiYXJhdGlAYXBwbGUuY29tPgorCisgICAgICAg IFVfU1RSSU5HX05PVF9URVJNSU5BVEVEX1dBUk5JTkcgSUNVIG11c3QgYmUgaGFuZGxlZCB3aGVu IHVzaW5nIHRoZSBvdXRwdXQgYnVmZmVyIGFzIGEgQyBzdHJpbmcKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMTE0MgorICAgICAgICA8cmRhcjovL3By b2JsZW0vNjI1MzA4NjA+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAg ICAgICAgKiBydW50aW1lL0ludGxEYXRlVGltZUZvcm1hdC5jcHA6CisgICAgICAgIChKU0M6OmRl ZmF1bHRUaW1lWm9uZSk6CisgICAgICAgIChKU0M6OmNhbm9uaWNhbGl6ZVRpbWVab25lTmFtZSk6 CisgICAgICAgIChKU0M6OkludGxEYXRlVGltZUZvcm1hdDo6aW5pdGlhbGl6ZURhdGVUaW1lRm9y bWF0KToKKyAgICAgICAgKEpTQzo6SW50bERhdGVUaW1lRm9ybWF0Ojpmb3JtYXQpOgorICAgICAg ICAoSlNDOjpJbnRsRGF0ZVRpbWVGb3JtYXQ6OmZvcm1hdFRvUGFydHMpOgorICAgICAgICAqIHJ1 bnRpbWUvSW50bE51bWJlckZvcm1hdC5jcHA6CisgICAgICAgIChKU0M6OkludGxOdW1iZXJGb3Jt YXQ6OmZvcm1hdCk6CisgICAgICAgIChKU0M6OkludGxOdW1iZXJGb3JtYXQ6OmZvcm1hdFRvUGFy dHMpOgorICAgICAgICAqIHJ1bnRpbWUvSW50bE9iamVjdC5jcHA6CisgICAgICAgIChKU0M6OmNv bnZlcnRJQ1VMb2NhbGVUb0JDUDQ3TGFuZ3VhZ2VUYWcpOgorICAgICAgICAoSlNDOjpjYW5vbmlj YWxpemVMYW5ndWFnZVRhZyk6CisgICAgICAgICogcnVudGltZS9JbnRsUmVsYXRpdmVUaW1lRm9y bWF0LmNwcDoKKyAgICAgICAgKEpTQzo6SW50bFJlbGF0aXZlVGltZUZvcm1hdDo6Zm9ybWF0SW50 ZXJuYWwpOgorICAgICAgICAoSlNDOjpJbnRsUmVsYXRpdmVUaW1lRm9ybWF0Ojpmb3JtYXRUb1Bh cnRzKToKKyAgICAgICAgKiBydW50aW1lL1N0cmluZ1Byb3RvdHlwZS5jcHA6CisgICAgICAgIChK U0M6OnRvTG9jYWxlQ2FzZSk6CisgICAgICAgIChKU0M6Om5vcm1hbGl6ZSk6CisKIDIwMjAtMDQt MjggIFJvc3MgS2lyc2xpbmcgIDxyb3NzLmtpcnNsaW5nQHNvbnkuY29tPgogCiAgICAgICAgIFtK U0NdIEFsaWduIHVwb24gdGhlIG5hbWUgaXNDYWxsYWJsZSBpbnN0ZWFkIG9mIGlzRnVuY3Rpb24K SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ludGxEYXRlVGltZUZvcm1hdC5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSW50bERhdGVU aW1lRm9ybWF0LmNwcAkocmV2aXNpb24gMjYwODYyKQorKysgU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvSW50bERhdGVUaW1lRm9ybWF0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzksNiAr MzksNyBAQAogI2luY2x1ZGUgPHVuaWNvZGUvdWVudW0uaD4KICNpbmNsdWRlIDx1bmljb2RlL3Vm aWVsZHBvc2l0ZXIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisjaW5j bHVkZSA8d3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIEpTQyB7CiAK QEAgLTExOSw3ICsxMjAsNyBAQCBzdGF0aWMgU3RyaW5nIGRlZmF1bHRUaW1lWm9uZSgpCiAKICAg ICBWZWN0b3I8VUNoYXIsIDMyPiBidWZmZXIoMzIpOwogICAgIGF1dG8gYnVmZmVyTGVuZ3RoID0g dWNhbF9nZXREZWZhdWx0VGltZVpvbmUoYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSwgJnN0 YXR1cyk7Ci0gICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikgeworICAg IGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKSB7CiAgICAgICAgIHN0YXR1 cyA9IFVfWkVST19FUlJPUjsKICAgICAgICAgYnVmZmVyLmdyb3coYnVmZmVyTGVuZ3RoKTsKICAg ICAgICAgdWNhbF9nZXREZWZhdWx0VGltZVpvbmUoYnVmZmVyLmRhdGEoKSwgYnVmZmVyTGVuZ3Ro LCAmc3RhdHVzKTsKQEAgLTEyOCw3ICsxMjksNyBAQCBzdGF0aWMgU3RyaW5nIGRlZmF1bHRUaW1l Wm9uZSgpCiAgICAgICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICAgICAgVmVjdG9yPFVD aGFyLCAzMj4gY2Fub25pY2FsQnVmZmVyKDMyKTsKICAgICAgICAgYXV0byBjYW5vbmljYWxMZW5n dGggPSB1Y2FsX2dldENhbm9uaWNhbFRpbWVab25lSUQoYnVmZmVyLmRhdGEoKSwgYnVmZmVyTGVu Z3RoLCBjYW5vbmljYWxCdWZmZXIuZGF0YSgpLCBjYW5vbmljYWxCdWZmZXIuc2l6ZSgpLCBudWxs cHRyLCAmc3RhdHVzKTsKLSAgICAgICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19F UlJPUikgeworICAgICAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkg ewogICAgICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICAgICAgY2Fub25p Y2FsQnVmZmVyLmdyb3coY2Fub25pY2FsTGVuZ3RoKTsKICAgICAgICAgICAgIHVjYWxfZ2V0Q2Fu b25pY2FsVGltZVpvbmVJRChidWZmZXIuZGF0YSgpLCBidWZmZXJMZW5ndGgsIGNhbm9uaWNhbEJ1 ZmZlci5kYXRhKCksIGNhbm9uaWNhbExlbmd0aCwgbnVsbHB0ciwgJnN0YXR1cyk7CkBAIC0xNzUs NyArMTc2LDcgQEAgc3RhdGljIFN0cmluZyBjYW5vbmljYWxpemVUaW1lWm9uZU5hbWUoYwogICAg ICAgICBWZWN0b3I8VUNoYXIsIDMyPiBidWZmZXIoaWFuYVRpbWVab25lTGVuZ3RoKTsKICAgICAg ICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICBhdXRvIGNhbm9uaWNhbExlbmd0aCA9 IHVjYWxfZ2V0Q2Fub25pY2FsVGltZVpvbmVJRChpYW5hVGltZVpvbmUsIGlhbmFUaW1lWm9uZUxl bmd0aCwgYnVmZmVyLmRhdGEoKSwgaWFuYVRpbWVab25lTGVuZ3RoLCBudWxscHRyLCAmc3RhdHVz KTsKLSAgICAgICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikgeworICAg ICAgICBpZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkgewogICAgICAgICAg ICAgYnVmZmVyLmdyb3coY2Fub25pY2FsTGVuZ3RoKTsKICAgICAgICAgICAgIHN0YXR1cyA9IFVf WkVST19FUlJPUjsKICAgICAgICAgICAgIHVjYWxfZ2V0Q2Fub25pY2FsVGltZVpvbmVJRChpYW5h VGltZVpvbmUsIGlhbmFUaW1lWm9uZUxlbmd0aCwgYnVmZmVyLmRhdGEoKSwgY2Fub25pY2FsTGVu Z3RoLCBudWxscHRyLCAmc3RhdHVzKTsKQEAgLTY1MCw3ICs2NTEsNyBAQCB2b2lkIEludGxEYXRl VGltZUZvcm1hdDo6aW5pdGlhbGl6ZURhdGVUCiAgICAgVmVjdG9yPFVDaGFyLCAzMj4gcGF0dGVy bkJ1ZmZlcigzMik7CiAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIGF1dG8gcGF0dGVy bkxlbmd0aCA9IHVkYXRwZ19nZXRCZXN0UGF0dGVybldpdGhPcHRpb25zKGdlbmVyYXRvciwgc2tl bGV0b25WaWV3LnVwY29udmVydGVkQ2hhcmFjdGVycygpLCBza2VsZXRvblZpZXcubGVuZ3RoKCks IFVEQVRQR19NQVRDSF9IT1VSX0ZJRUxEX0xFTkdUSCwgcGF0dGVybkJ1ZmZlci5kYXRhKCksIHBh dHRlcm5CdWZmZXIuc2l6ZSgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVS X09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0 YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICBwYXR0ZXJu QnVmZmVyLmdyb3cocGF0dGVybkxlbmd0aCk7CiAgICAgICAgIHVkYXRwZ19nZXRCZXN0UGF0dGVy bihnZW5lcmF0b3IsIHNrZWxldG9uVmlldy51cGNvbnZlcnRlZENoYXJhY3RlcnMoKSwgc2tlbGV0 b25WaWV3Lmxlbmd0aCgpLCBwYXR0ZXJuQnVmZmVyLmRhdGEoKSwgcGF0dGVybkxlbmd0aCwgJnN0 YXR1cyk7CkBAIC05MDgsNyArOTA5LDcgQEAgSlNWYWx1ZSBJbnRsRGF0ZVRpbWVGb3JtYXQ6OmZv cm1hdChKU0dsbwogICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIFZl Y3RvcjxVQ2hhciwgMzI+IHJlc3VsdCgzMik7CiAgICAgYXV0byByZXN1bHRMZW5ndGggPSB1ZGF0 X2Zvcm1hdChtX2RhdGVGb3JtYXQuZ2V0KCksIHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1bHQu c2l6ZSgpLCBudWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09W RVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1 cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQuZ3Jv dyhyZXN1bHRMZW5ndGgpOwogICAgICAgICB1ZGF0X2Zvcm1hdChtX2RhdGVGb3JtYXQuZ2V0KCks IHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsIG51bGxwdHIsICZzdGF0dXMpOwpA QCAtMTAwMCw3ICsxMDAxLDcgQEAgSlNWYWx1ZSBJbnRsRGF0ZVRpbWVGb3JtYXQ6OmZvcm1hdFRv UGFydAogICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0b3I8VUNoYXIsIDMyPiBy ZXN1bHQoMzIpOwogICAgIGF1dG8gcmVzdWx0TGVuZ3RoID0gdWRhdF9mb3JtYXRGb3JGaWVsZHMo bV9kYXRlRm9ybWF0LmdldCgpLCB2YWx1ZSwgcmVzdWx0LmRhdGEoKSwgcmVzdWx0LnNpemUoKSwg ZmllbGRzLmdldCgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJG TE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykp IHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQuZ3Jvdyhy ZXN1bHRMZW5ndGgpOwogICAgICAgICB1ZGF0X2Zvcm1hdEZvckZpZWxkcyhtX2RhdGVGb3JtYXQu Z2V0KCksIHZhbHVlLCByZXN1bHQuZGF0YSgpLCByZXN1bHRMZW5ndGgsIGZpZWxkcy5nZXQoKSwg JnN0YXR1cyk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JbnRsTnVtYmVy Rm9ybWF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9J bnRsTnVtYmVyRm9ybWF0LmNwcAkocmV2aXNpb24gMjYwODYyKQorKysgU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvSW50bE51bWJlckZvcm1hdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM3 LDYgKzM3LDcgQEAKICNpbmNsdWRlICJKU0NJbmxpbmVzLmgiCiAjaW5jbHVkZSAiT2JqZWN0Q29u c3RydWN0b3IuaCIKICNpbmNsdWRlIDx1bmljb2RlL3VmaWVsZHBvc2l0ZXIuaD4KKyNpbmNsdWRl IDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlNDIHsKIApAQCAt MzYxLDcgKzM2Miw3IEBAIEpTVmFsdWUgSW50bE51bWJlckZvcm1hdDo6Zm9ybWF0KEpTR2xvYmEK ICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBWZWN0b3I8VUNoYXIs IDMyPiBidWZmZXIoMzIpOwogICAgIGF1dG8gbGVuZ3RoID0gdW51bV9mb3JtYXREb3VibGUobV9u dW1iZXJGb3JtYXQuZ2V0KCksIHZhbHVlLCBidWZmZXIuZGF0YSgpLCBidWZmZXIuc2l6ZSgpLCBu dWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VS Uk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpIHsKICAg ICAgICAgYnVmZmVyLmdyb3cobGVuZ3RoKTsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9S OwogICAgICAgICB1bnVtX2Zvcm1hdERvdWJsZShtX251bWJlckZvcm1hdC5nZXQoKSwgdmFsdWUs IGJ1ZmZlci5kYXRhKCksIGxlbmd0aCwgbnVsbHB0ciwgJnN0YXR1cyk7CkBAIC0zODksNyArMzkw LDcgQEAgSlNWYWx1ZSBJbnRsTnVtYmVyRm9ybWF0Ojpmb3JtYXQoSlNHbG9iYQogICAgIFVFcnJv ckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIFZlY3RvcjxVQ2hhciwgMzI+IGJ1ZmZl cigzMik7CiAgICAgYXV0byBsZW5ndGggPSB1bnVtX2Zvcm1hdERlY2ltYWwobV9udW1iZXJGb3Jt YXQuZ2V0KCksIHJhd1N0cmluZywgc3RyaW5nLmxlbmd0aCgpLCBidWZmZXIuZGF0YSgpLCBidWZm ZXIuc2l6ZSgpLCBudWxscHRyLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVS X09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0 YXR1cykpIHsKICAgICAgICAgYnVmZmVyLmdyb3cobGVuZ3RoKTsKICAgICAgICAgc3RhdHVzID0g VV9aRVJPX0VSUk9SOwogICAgICAgICB1bnVtX2Zvcm1hdERlY2ltYWwobV9udW1iZXJGb3JtYXQu Z2V0KCksIHJhd1N0cmluZywgc3RyaW5nLmxlbmd0aCgpLCBidWZmZXIuZGF0YSgpLCBsZW5ndGgs IG51bGxwdHIsICZzdGF0dXMpOwpAQCAtNTUyLDcgKzU1Myw3IEBAIEpTVmFsdWUgSW50bE51bWJl ckZvcm1hdDo6Zm9ybWF0VG9QYXJ0cygKIAogICAgIFZlY3RvcjxVQ2hhciwgMzI+IHJlc3VsdCgz Mik7CiAgICAgYXV0byByZXN1bHRMZW5ndGggPSB1bnVtX2Zvcm1hdERvdWJsZUZvckZpZWxkcyht X251bWJlckZvcm1hdC5nZXQoKSwgdmFsdWUsIHJlc3VsdC5kYXRhKCksIHJlc3VsdC5zaXplKCks IGZpZWxkSXRyLmdldCgpLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09W RVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1 cykpIHsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQuZ3Jv dyhyZXN1bHRMZW5ndGgpOwogICAgICAgICB1bnVtX2Zvcm1hdERvdWJsZUZvckZpZWxkcyhtX251 bWJlckZvcm1hdC5nZXQoKSwgdmFsdWUsIHJlc3VsdC5kYXRhKCksIHJlc3VsdExlbmd0aCwgZmll bGRJdHIuZ2V0KCksICZzdGF0dXMpOwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvSW50bE9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSW50bE9iamVjdC5jcHAJKHJldmlzaW9uIDI2MDg2MikKKysrIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0ludGxPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NCw2ICs1 NCw3IEBACiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8d3RmL3Rl eHQvU3RyaW5nQnVpbGRlci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0ltcGwuaD4KKyNp bmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlNDIHsK IApAQCAtMTQ0LDEzICsxNDUsMTcgQEAgc3RhdGljIFN0cmluZyBjb252ZXJ0SUNVTG9jYWxlVG9C Q1A0N0xhbgogICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgIFZlY3Rv cjxjaGFyLCAzMj4gYnVmZmVyKDMyKTsKICAgICBhdXRvIGxlbmd0aCA9IHVsb2NfdG9MYW5ndWFn ZVRhZyhsb2NhbGVJRCwgYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSwgZmFsc2UsICZzdGF0 dXMpOwotICAgIGlmIChzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpIHsKKyAgICBp ZiAobmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZmZXIoc3RhdHVzKSkgewogICAgICAgICBidWZmZXIu Z3JvdyhsZW5ndGgpOwogICAgICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAgIHVs b2NfdG9MYW5ndWFnZVRhZyhsb2NhbGVJRCwgYnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSwg ZmFsc2UsICZzdGF0dXMpOwogICAgIH0KLSAgICBpZiAoIVVfRkFJTFVSRShzdGF0dXMpKQorICAg IGlmICghVV9GQUlMVVJFKHN0YXR1cykpIHsKKyAgICAgICAgLy8gVGhpcyBpcyB1c2VkIHRvIHN0 b3JlIGludG8gc3RhdGljIHZhcmlhYmxlcyB0aGF0IG1heSBiZSBzaGFyZWQgYWNyb3NzIAorICAg ICAgICAvLyBKU0MgZXhlY3V0aW9uIHRocmVhZHMuIFRoaXMgbXVzdCBiZSBpbW1vcnRhbCB0byBt YWtlIGNvbmN1cnJlbnQgcmVmL2RlcmVmCisgICAgICAgIC8vIHNhZmUuCiAgICAgICAgIHJldHVy biBTdHJpbmcoU3RyaW5nSW1wbDo6Y3JlYXRlU3RhdGljU3RyaW5nSW1wbChidWZmZXIuZGF0YSgp LCBsZW5ndGgpKTsKKyAgICB9CiAgICAgcmV0dXJuIFN0cmluZygpOwogfQogCkBAIC0zMjIsMTAg KzMyNywxMCBAQCBzdGF0aWMgU3RyaW5nIGNhbm9uaWNhbGl6ZUxhbmd1YWdlVGFnKGNvCiAgICAg Ly8gLSB1bG9jX3RvTGFuZ3VhZ2VUYWcgZG9lc24ndCB0YWtlIGFuIGlucHV0IHNpemUgcGFyYW0g c28gd2UgbXVzdCBlbnN1cmUgdGhlIHN0cmluZyBpcyBudWxsLXRlcm1pbmF0ZWQgb3Vyc2VsdmVz CiAgICAgLy8gLSBiZWZvcmUgSUNVIDY0LCB0aGVyZSdzIGEgY2hhbmNlIHRoYXQgaXQgd2lsbCAi YnVmZmVyIG92ZXJmbG93IiB3aGlsZSByZXF1ZXN0aW5nIGEgKnNtYWxsZXIqIHNpemUKICAgICBV RXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKLSAgICBWZWN0b3I8Y2hhciwgMzI+IGlu dGVybWVkaWF0ZSgzMSk7CisgICAgVmVjdG9yPGNoYXIsIDMyPiBpbnRlcm1lZGlhdGUoMzIpOwog ICAgIGludDMyX3QgcGFyc2VkTGVuZ3RoOwogICAgIGF1dG8gaW50ZXJtZWRpYXRlTGVuZ3RoID0g dWxvY19mb3JMYW5ndWFnZVRhZyhpbnB1dC5kYXRhKCksIGludGVybWVkaWF0ZS5kYXRhKCksIGlu dGVybWVkaWF0ZS5zaXplKCksICZwYXJzZWRMZW5ndGgsICZzdGF0dXMpOwotICAgIGlmIChzdGF0 dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpIHsKKyAgICBpZiAobmVlZHNUb0dyb3dUb1By b2R1Y2VDU3RyaW5nKHN0YXR1cykpIHsKICAgICAgICAgaW50ZXJtZWRpYXRlLnJlc2l6ZShpbnRl cm1lZGlhdGVMZW5ndGggKyAxKTsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAg ICAgICB1bG9jX2Zvckxhbmd1YWdlVGFnKGlucHV0LmRhdGEoKSwgaW50ZXJtZWRpYXRlLmRhdGEo KSwgaW50ZXJtZWRpYXRlTGVuZ3RoICsgMSwgJnBhcnNlZExlbmd0aCwgJnN0YXR1cyk7CkBAIC0z MzMsOSArMzM4LDEyIEBAIHN0YXRpYyBTdHJpbmcgY2Fub25pY2FsaXplTGFuZ3VhZ2VUYWcoY28K ICAgICBpZiAoVV9GQUlMVVJFKHN0YXR1cykgfHwgcGFyc2VkTGVuZ3RoICE9IHN0YXRpY19jYXN0 PGludDMyX3Q+KGlucHV0Lmxlbmd0aCgpKSkKICAgICAgICAgcmV0dXJuIFN0cmluZygpOwogCisg ICAgQVNTRVJUKGludGVybWVkaWF0ZS5jb250YWlucygnXDAnKSk7CisKKyAgICBzdGF0dXMgPSBV X1pFUk9fRVJST1I7CiAgICAgVmVjdG9yPGNoYXIsIDMyPiByZXN1bHQoMzIpOwogICAgIGF1dG8g cmVzdWx0TGVuZ3RoID0gdWxvY190b0xhbmd1YWdlVGFnKGludGVybWVkaWF0ZS5kYXRhKCksIHJl c3VsdC5kYXRhKCksIHJlc3VsdC5zaXplKCksIGZhbHNlLCAmc3RhdHVzKTsKLSAgICBpZiAoc3Rh dHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYgKG5lZWRzVG9Hcm93VG9Q cm9kdWNlQnVmZmVyKHN0YXR1cykpIHsKICAgICAgICAgcmVzdWx0Lmdyb3cocmVzdWx0TGVuZ3Ro KTsKICAgICAgICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICAgICAgICB1bG9jX3RvTGFuZ3Vh Z2VUYWcoaW50ZXJtZWRpYXRlLmRhdGEoKSwgcmVzdWx0LmRhdGEoKSwgcmVzdWx0TGVuZ3RoLCBm YWxzZSwgJnN0YXR1cyk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JbnRs UmVsYXRpdmVUaW1lRm9ybWF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9JbnRsUmVsYXRpdmVUaW1lRm9ybWF0LmNwcAkocmV2aXNpb24gMjYwODYyKQor KysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSW50bFJlbGF0aXZlVGltZUZvcm1hdC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJJbnRsT2JqZWN0 LmgiCiAjaW5jbHVkZSAiSlNDSW5saW5lcy5oIgogI2luY2x1ZGUgIk9iamVjdENvbnN0cnVjdG9y LmgiCisjaW5jbHVkZSA8d3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBlcnMuaD4KIAogbmFtZXNwYWNl IEpTQyB7CiAKQEAgLTI1Myw3ICsyNTQsNyBAQCBTdHJpbmcgSW50bFJlbGF0aXZlVGltZUZvcm1h dDo6Zm9ybWF0SW50CiAgICAgVUVycm9yQ29kZSBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAg VmVjdG9yPFVDaGFyLCAzMj4gcmVzdWx0KDMyKTsKICAgICBhdXRvIHJlc3VsdExlbmd0aCA9IGZv cm1hdFJlbGF0aXZlVGltZShtX3JlbGF0aXZlRGF0ZVRpbWVGb3JtYXR0ZXIuZ2V0KCksIHZhbHVl LCB1bml0VHlwZS52YWx1ZSgpLCByZXN1bHQuZGF0YSgpLCByZXN1bHQuc2l6ZSgpLCAmc3RhdHVz KTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgaWYg KG5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpIHsKICAgICAgICAgc3RhdHVzID0g VV9aRVJPX0VSUk9SOwogICAgICAgICByZXN1bHQuZ3JvdyhyZXN1bHRMZW5ndGgpOwogICAgICAg ICBmb3JtYXRSZWxhdGl2ZVRpbWUobV9yZWxhdGl2ZURhdGVUaW1lRm9ybWF0dGVyLmdldCgpLCB2 YWx1ZSwgdW5pdFR5cGUudmFsdWUoKSwgcmVzdWx0LmRhdGEoKSwgcmVzdWx0TGVuZ3RoLCAmc3Rh dHVzKTsKQEAgLTI5NSw3ICsyOTYsNyBAQCBKU1ZhbHVlIEludGxSZWxhdGl2ZVRpbWVGb3JtYXQ6 OmZvcm1hdFRvCiAKICAgICBWZWN0b3I8VUNoYXIsIDMyPiBidWZmZXIoMzIpOwogICAgIGF1dG8g bnVtYmVyTGVuZ3RoID0gdW51bV9mb3JtYXREb3VibGVGb3JGaWVsZHMobV9udW1iZXJGb3JtYXQu Z2V0KCksIGFic1ZhbHVlLCBidWZmZXIuZGF0YSgpLCBidWZmZXIuc2l6ZSgpLCBpdGVyYXRvci5n ZXQoKSwgJnN0YXR1cyk7Ci0gICAgaWYgKHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJP UikgeworICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKSB7CiAgICAg ICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICAgICAgYnVmZmVyLmdyb3cobnVtYmVyTGVu Z3RoKTsKICAgICAgICAgdW51bV9mb3JtYXREb3VibGVGb3JGaWVsZHMobV9udW1iZXJGb3JtYXQu Z2V0KCksIGFic1ZhbHVlLCBidWZmZXIuZGF0YSgpLCBudW1iZXJMZW5ndGgsIGl0ZXJhdG9yLmdl dCgpLCAmc3RhdHVzKTsKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1N0cmlu Z1Byb3RvdHlwZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvU3RyaW5nUHJvdG90eXBlLmNwcAkocmV2aXNpb24gMjYwODYyKQorKysgU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvU3RyaW5nUHJvdG90eXBlLmNwcAkod29ya2luZyBjb3B5KQpAQCAt NTgsNiArNTgsNyBAQAogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAjaW5jbHVkZSA8d3Rm L3RleHQvU3RyaW5nQnVpbGRlci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ1ZpZXcuaD4K KyNpbmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1lc3BhY2UgSlND IHsKIApAQCAtMTYyMCwxNSArMTYyMSwxNSBAQCBzdGF0aWMgRW5jb2RlZEpTVmFsdWUgdG9Mb2Nh bGVDYXNlKEpTR2xvCiAgICAgLy8gMTcuIExldCBMIGJlIGEgU3RyaW5nIHdob3NlIGVsZW1lbnRz IGFyZSwgaW4gb3JkZXIsIHRoZSBlbGVtZW50cyBvZiBjdUxpc3QuCiAKICAgICAvLyBNb3N0IHN0 cmluZ3MgbG93ZXIvdXBwZXIgY2FzZSB3aWxsIGJlIHRoZSBzYW1lIHNpemUgYXMgb3JpZ2luYWws IHNvIHRyeSB0aGF0IGZpcnN0LgotICAgIFVFcnJvckNvZGUgZXJyb3IoVV9aRVJPX0VSUk9SKTsK KyAgICBVRXJyb3JDb2RlIGVycm9yID0gVV9aRVJPX0VSUk9SOwogICAgIFZlY3RvcjxVQ2hhcj4g YnVmZmVyKHZpZXdMZW5ndGgpOwogICAgIFN0cmluZyBsb3dlcjsKICAgICBjb25zdCBpbnQzMl90 IHJlc3VsdExlbmd0aCA9IGNvbnZlcnRDYXNlKGJ1ZmZlci5kYXRhKCksIHZpZXdMZW5ndGgsIHZp ZXcudXBjb252ZXJ0ZWRDaGFyYWN0ZXJzKCksIHZpZXdMZW5ndGgsIHV0ZjhMb2NhbGVCdWZmZXIu ZGF0YSgpLCAmZXJyb3IpOwogICAgIGlmIChVX1NVQ0NFU1MoZXJyb3IpKQogICAgICAgICBsb3dl ciA9IFN0cmluZyhidWZmZXIuZGF0YSgpLCByZXN1bHRMZW5ndGgpOwotICAgIGVsc2UgaWYgKGVy cm9yID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKSB7CisgICAgZWxzZSBpZiAobmVlZHNUb0dy b3dUb1Byb2R1Y2VCdWZmZXIoZXJyb3IpKSB7CiAgICAgICAgIC8vIENvbnZlcnRlZCBjYXNlIG5l ZWRzIG1vcmUgc3BhY2UgdGhhbiBvcmlnaW5hbC4gVHJ5IGFnYWluLgotICAgICAgICBVRXJyb3JD b2RlIGVycm9yKFVfWkVST19FUlJPUik7CisgICAgICAgIFVFcnJvckNvZGUgZXJyb3IgPSBVX1pF Uk9fRVJST1I7CiAgICAgICAgIFZlY3RvcjxVQ2hhcj4gYnVmZmVyKHJlc3VsdExlbmd0aCk7CiAg ICAgICAgIGNvbnZlcnRDYXNlKGJ1ZmZlci5kYXRhKCksIHJlc3VsdExlbmd0aCwgdmlldy51cGNv bnZlcnRlZENoYXJhY3RlcnMoKSwgdmlld0xlbmd0aCwgdXRmOExvY2FsZUJ1ZmZlci5kYXRhKCks ICZlcnJvcik7CiAgICAgICAgIGlmIChVX0ZBSUxVUkUoZXJyb3IpKQpAQCAtMTkyNiw3ICsxOTI3 LDcgQEAgc3RhdGljIEpTVmFsdWUgbm9ybWFsaXplKEpTR2xvYmFsT2JqZWN0KgogICAgICAgICBS RUxFQVNFX0FORF9SRVRVUk4oc2NvcGUsIHN0cmluZyk7CiAKICAgICBpbnQzMl90IG5vcm1hbGl6 ZWRTdHJpbmdMZW5ndGggPSB1bm9ybTJfbm9ybWFsaXplKG5vcm1hbGl6ZXIsIGNoYXJhY3RlcnMs IHZpZXcubGVuZ3RoKCksIG51bGxwdHIsIDAsICZzdGF0dXMpOwotICAgIEFTU0VSVChzdGF0dXMg PT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpOworICAgIEFTU0VSVChuZWVkc1RvR3Jvd1RvUHJv ZHVjZUJ1ZmZlcihzdGF0dXMpKTsKIAogICAgIFVDaGFyKiBidWZmZXI7CiAgICAgYXV0byByZXN1 bHQgPSBTdHJpbmdJbXBsOjp0cnlDcmVhdGVVbmluaXRpYWxpemVkKG5vcm1hbGl6ZWRTdHJpbmdM ZW5ndGgsIGJ1ZmZlcik7CkluZGV4OiBTb3VyY2UvV1RGL0NoYW5nZUxvZwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV1RGL0NoYW5nZUxvZwkocmV2aXNpb24gMjYwODYyKQorKysgU291cmNlL1dURi9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw0MyBAQAorMjAyMC0wNC0yOCAgU2Fh bSBCYXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KKworICAgICAgICBVX1NUUklOR19OT1RfVEVS TUlOQVRFRF9XQVJOSU5HIElDVSBtdXN0IGJlIGhhbmRsZWQgd2hlbiB1c2luZyB0aGUgb3V0cHV0 IGJ1ZmZlciBhcyBhIEMgc3RyaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMTExNDIKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYyNTMwODYwPgor CisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgorCisgICAgICAgIE1vc3Qgb2Ygb3Vy IHVzZXMgb2YgSUNVIHJlcXVpcmUgdXMgdG8gcHJvZHVjZSBhIGJ1ZmZlciBvZiB0aGUgY29ycmVj dAorICAgICAgICBsZW5ndGguIFdlIG9mdGVuIHRlc3QgaWYgdGhlIGZpcnN0IGNhbGwgdG8gSUNV IEFQSSBzdWNjZWVkcywgYW5kIGlmIGl0CisgICAgICAgIGRvZXNuJ3QsIHdlIGdyb3cgdG8gdGhl IHJlcXVpcmVkIGJ1ZmZlciBzaXplLCBhbmQgdHJ5IGFnYWluLiBIb3dldmVyLAorICAgICAgICB0 aGVyZSBhcmUgYSBmZXcgQVBJcyB0aGF0IHdlIHVzZSBsaWtlIHRoaXMsIGV4Y2VwdCB0aGF0IHRo ZXkgd3JpdGUgdGhlaXIKKyAgICAgICAgb3V0cHV0IHRvIGEgQyBzdHJpbmcgaW5zdGVhZCBvZiBh IGJ1ZmZlci4KKyAgICAgICAgCisgICAgICAgIEluIGEgY291cGxlIHNjZW5hcmlvcyB3aGVuIHdl IHdlcmUgcHJvZHVjaW5nIEMgc3RyaW5ncywgd2Ugd2VyZSBvbmx5IHRlc3RpbmcKKyAgICAgICAg Zm9yIHRoZSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUiwgaW5zdGVhZCBvZiBib3RoIFVfQlVGRkVS X09WRVJGTE9XX0VSUk9SIGFuZAorICAgICAgICBVX1NUUklOR19OT1RfVEVSTUlOQVRFRF9XQVJO SU5HLiBUaGlzIHBhdGNoIGZpeGVzIHRob3NlIGJ1Z3MuIEl0IGFsc28KKyAgICAgICAgaW50cm9k dWNlcyB0d28gbmV3IGhlbHBlciBtZXRob2RzIGZvciB0ZXN0aW5nIGVycm9yIGNvZGVzIHJldHVy bmVkIGJ5IElDVS4KKyAgICAgICAgCisgICAgICAgIC0gVGhlIGZpcnN0IGlzIG5lZWRzVG9Hcm93 VG9Qcm9kdWNlQnVmZmVyLCB3aGljaCByZXR1cm5zIHRydWUgaWYgd2UgbmVlZCB0bworICAgICAg ICBncm93IHRoZSBidWZmZXIgYW5kIHJlLWNhbGwgaW50byBJQ1UgdG8gZ2V0IHRoZSByZXN1bHQu CisgICAgICAgIC0gVGhlIHNlY29uZCBpcyBuZWVkc1RvR3Jvd1RvUHJvZHVjZUNTdHJpbmcsIHdo aWNoIHJldHVybnMgdHJ1ZSBpZiB3ZSBuZWVkIHRvCisgICAgICAgIGdyb3cgdGhlIGJ1ZmZlciBh bmQgcmUtY2FsbCBpbnRvIElDVSB0byBwcm9kdWNlIGEgdmFsaWQgQyBzdHJpbmcuCisgICAgICAg IAorICAgICAgICBJJ3ZlIGF1ZGl0ZWQgYWxsIHVzZXMgb2YgVV9CVUZGRVJfT1ZFUkZMT1dfRVJS T1IgYW5kIGNvbnZlcnRlZCB0aGVtIHRvIHVzZSBvbmUKKyAgICAgICAgb2YgdGhlIGFib3ZlIGhl bHBlciBtZXRob2RzIGluc3RlYWQuCisgICAgICAgIAorICAgICAgICBUaGUgaXNzdWVzIGluIG91 ciBoYW5kbGluZyBvZiBVX1NUUklOR19OT1RfVEVSTUlOQVRFRF9XQVJOSU5HIHdlcmUgY2F1Z2h0 IG9uIGlPUyBKU0MKKyAgICAgICAgdGVzdHMgaW4gSlNUZXN0cy9zdHJlc3MvaW50bC1kYXRldGlt ZWZvcm1hdC5qcworCisgICAgICAgICogV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6Cisg ICAgICAgICogd3RmL0NNYWtlTGlzdHMudHh0OgorICAgICAgICAqIHd0Zi90ZXh0L0xpbmVCcmVh a0l0ZXJhdG9yUG9vbElDVS5oOgorICAgICAgICAoV1RGOjpMaW5lQnJlYWtJdGVyYXRvclBvb2w6 Om1ha2VMb2NhbGVXaXRoQnJlYWtLZXl3b3JkKToKKyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdW aWV3LmNwcDoKKyAgICAgICAgKFdURjo6bm9ybWFsaXplZE5GQyk6CisgICAgICAgICogd3RmL3Vu aWNvZGUvaWN1L0lDVUhlbHBlcnMuaDogQWRkZWQuCisgICAgICAgIChXVEY6Om5lZWRzVG9Hcm93 VG9Qcm9kdWNlQ1N0cmluZyk6CisgICAgICAgIChXVEY6Om5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVm ZmVyKToKKwogMjAyMC0wNC0yNyAgUnlhbiBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4K IAogICAgICAgICBbQ29jb2FdIHN0b3AgdXNpbmcgb3V0IGFyZ3VtZW50cyBmb3IgZG9jdW1lbnQg YXR0cmlidXRlcyB3aGVuIGNvbnZlcnRpbmcgdG8gYXR0cmlidXRlZCBzdHJpbmdzCkluZGV4OiBT b3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDI2MDg2MikK KysrIFNvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29w eSkKQEAgLTM5Miw2ICszOTIsNyBAQAogCQk1MUYxNzUyOTFGM0Q0ODYwMDBDNzQ5NTAgLyogUGVy c2lzdGVudEVuY29kZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g UGVyc2lzdGVudEVuY29kZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUYx NzUyQTFGM0Q0ODYwMDBDNzQ5NTAgLyogUGVyc2lzdGVudEVuY29kZXIuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gUGVyc2lzdGVudEVuY29kZXIuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJNTI2QUVDOTExRjZCNEU1QzAwNjk1RjVEIC8qIE5vVGFpbENhbGxzLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5vVGFpbENhbGxzLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTUyQjIyOEMxMjQ1OERDODIwMDc1M0Q5MSAvKiBJQ1VIZWxw ZXJzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElDVUhlbHBlcnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJNTMwQTYzNDgxRkEzRTNBMDAwMjZBNTQ1IC8qIFNjcmlwdHMgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBmb2xkZXI7IHBhdGggPSBTY3Jp cHRzOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MzExQkQ1MTFFQTcxQ0FEMDA1MjUy ODEgLyogU2lnbmFscy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBT aWduYWxzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTMxMUJENTUxRUE3RTE1 QTAwNTI1MjgxIC8qIExvY2tsZXNzQmFnLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IExvY2tsZXNzQmFnLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xNDM4LDYg KzE0MzksNyBAQAogCQlBOEE0NzM0RjE1MUE4MjVCMDA0MTIzRkYgLyogaWN1ICovID0gewogCQkJ aXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQk1MkIyMjhDMTI0NThEQzgyMDA3 NTNEOTEgLyogSUNVSGVscGVycy5oICovLAogCQkJCUE4QTQ3MzUwMTUxQTgyNUIwMDQxMjNGRiAv KiBDb2xsYXRvcklDVS5jcHAgKi8sCiAJCQkpOwogCQkJcGF0aCA9IGljdTsKSW5kZXg6IFNvdXJj ZS9XVEYvd3RmL0NNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL0NN YWtlTGlzdHMudHh0CShyZXZpc2lvbiAyNjA4NjIpCisrKyBTb3VyY2UvV1RGL3d0Zi9DTWFrZUxp c3RzLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMzU4LDYgKzM1OCw4IEBAIHNldChXVEZfUFVCTElD X0hFQURFUlMKICAgICB1bmljb2RlL0NoYXJhY3Rlck5hbWVzLmgKICAgICB1bmljb2RlL0NvbGxh dG9yLmgKICAgICB1bmljb2RlL1VURjhDb252ZXJzaW9uLmgKKworICAgIHVuaWNvZGUvaWN1L0lD VUhlbHBlcnMuaAogKQogCiBzZXQoV1RGX1NPVVJDRVMKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3Rl eHQvTGluZUJyZWFrSXRlcmF0b3JQb29sSUNVLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93 dGYvdGV4dC9MaW5lQnJlYWtJdGVyYXRvclBvb2xJQ1UuaAkocmV2aXNpb24gMjYwODYyKQorKysg U291cmNlL1dURi93dGYvdGV4dC9MaW5lQnJlYWtJdGVyYXRvclBvb2xJQ1UuaAkod29ya2luZyBj b3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgog I2luY2x1ZGUgPHd0Zi9UaHJlYWRTcGVjaWZpYy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L0F0b21T dHJpbmcuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgogCiBuYW1l c3BhY2UgV1RGIHsKIApAQCAtNzQsNyArNzUsNyBAQCBwdWJsaWM6CiAgICAgICAgIGludDMyX3Qg bGVuZ3RoTmVlZGVkID0gdWxvY19zZXRLZXl3b3JkVmFsdWUoImxiIiwga2V5d29yZFZhbHVlLCBz Y3JhdGNoQnVmZmVyLmRhdGEoKSwgc2NyYXRjaEJ1ZmZlci5zaXplKCksICZzdGF0dXMpOwogICAg ICAgICBpZiAoVV9TVUNDRVNTKHN0YXR1cykpCiAgICAgICAgICAgICByZXR1cm4gQXRvbVN0cmlu Zzo6ZnJvbVVURjgoc2NyYXRjaEJ1ZmZlci5kYXRhKCksIGxlbmd0aE5lZWRlZCk7Ci0gICAgICAg IGlmIChzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpIHsKKyAgICAgICAgaWYgKG5l ZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykpIHsKICAgICAgICAgICAgIHNjcmF0Y2hC dWZmZXIuZ3JvdyhsZW5ndGhOZWVkZWQgKyAxKTsKICAgICAgICAgICAgIG1lbXNldChzY3JhdGNo QnVmZmVyLmRhdGEoKSArIHV0ZjhMb2NhbGUubGVuZ3RoKCksIDAsIHNjcmF0Y2hCdWZmZXIuc2l6 ZSgpIC0gdXRmOExvY2FsZS5sZW5ndGgoKSk7CiAgICAgICAgICAgICBzdGF0dXMgPSBVX1pFUk9f RVJST1I7CkluZGV4OiBTb3VyY2UvV1RGL3d0Zi90ZXh0L1N0cmluZ1ZpZXcuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XVEYvd3RmL3RleHQvU3RyaW5nVmlldy5jcHAJKHJldmlzaW9uIDI2MDg2 MikKKysrIFNvdXJjZS9XVEYvd3RmL3RleHQvU3RyaW5nVmlldy5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTM3LDYgKzM3LDcgQEAgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SQogI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ1Rv SW50ZWdlckNvbnZlcnNpb24uaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9UZXh0QnJlYWtJdGVyYXRv ci5oPgorI2luY2x1ZGUgPHd0Zi91bmljb2RlL2ljdS9JQ1VIZWxwZXJzLmg+CiAKIG5hbWVzcGFj ZSBXVEYgewogCkBAIC0yOTEsNyArMjkyLDcgQEAgU3RyaW5nVmlld1dpdGhVbmRlcmx5aW5nU3Ry aW5nIG5vcm1hbGl6ZQogICAgICAgICByZXR1cm4geyBzdHJpbmcsIHsgfSB9OwogCiAgICAgdW5z aWduZWQgbm9ybWFsaXplZExlbmd0aCA9IHVub3JtMl9ub3JtYWxpemUobm9ybWFsaXplciwgc3Ry aW5nLmNoYXJhY3RlcnMxNigpLCBzdHJpbmcubGVuZ3RoKCksIG51bGxwdHIsIDAsICZzdGF0dXMp OwotICAgIEFTU0VSVChzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpOworICAgIEFT U0VSVChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKTsKIAogICAgIFVDaGFyKiBj aGFyYWN0ZXJzOwogICAgIFN0cmluZyByZXN1bHQgPSBTdHJpbmc6OmNyZWF0ZVVuaW5pdGlhbGl6 ZWQobm9ybWFsaXplZExlbmd0aCwgY2hhcmFjdGVycyk7CkluZGV4OiBTb3VyY2UvV1RGL3d0Zi91 bmljb2RlL2ljdS9JQ1VIZWxwZXJzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvdW5p Y29kZS9pY3UvSUNVSGVscGVycy5oCShub25leGlzdGVudCkKKysrIFNvdXJjZS9XVEYvd3RmL3Vu aWNvZGUvaWN1L0lDVUhlbHBlcnMuaAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDQ1IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g YGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICog T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNwcmFnbWEgb25j ZQorCisjaW5jbHVkZSA8dW5pY29kZS91dHlwZXMuaD4KKworbmFtZXNwYWNlIFdURiB7CisKK2lu bGluZSBib29sIG5lZWRzVG9Hcm93VG9Qcm9kdWNlQ1N0cmluZyhVRXJyb3JDb2RlIGVycm9yQ29k ZSkKK3sKKyAgICByZXR1cm4gZXJyb3JDb2RlID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SIHx8 IGVycm9yQ29kZSA9PSBVX1NUUklOR19OT1RfVEVSTUlOQVRFRF9XQVJOSU5HOworfQorCitpbmxp bmUgYm9vbCBuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihVRXJyb3JDb2RlIGVycm9yQ29kZSkK K3sKKyAgICByZXR1cm4gZXJyb3JDb2RlID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SOworfQor Cit9CisKK3VzaW5nIFdURjo6bmVlZHNUb0dyb3dUb1Byb2R1Y2VDU3RyaW5nOwordXNpbmcgV1RG OjpuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcjsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2 MDg2MikKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDI1IEBACisyMDIwLTA0LTI4ICBTYWFtIEJhcmF0aSAgPHNiYXJhdGlAYXBwbGUuY29tPgor CisgICAgICAgIFVfU1RSSU5HX05PVF9URVJNSU5BVEVEX1dBUk5JTkcgSUNVIG11c3QgYmUgaGFu ZGxlZCB3aGVuIHVzaW5nIHRoZSBvdXRwdXQgYnVmZmVyIGFzIGEgQyBzdHJpbmcKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMTE0MgorICAgICAgICA8 cmRhcjovL3Byb2JsZW0vNjI1MzA4NjA+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRs ZXIuCisKKyAgICAgICAgKiBlZGl0aW5nL1RleHRJdGVyYXRvci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpub3JtYWxpemVDaGFyYWN0ZXJzKToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L0xvY2Fs ZUlDVS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbGVJQ1U6OmRlY2ltYWxTeW1ib2wpOgor ICAgICAgICAoV2ViQ29yZTo6TG9jYWxlSUNVOjpkZWNpbWFsVGV4dEF0dHJpYnV0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpnZXREYXRlRm9ybWF0UGF0dGVybik6CisgICAgICAgIChXZWJDb3JlOjpM b2NhbGVJQ1U6OmNyZWF0ZUxhYmVsVmVjdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OmdldEZvcm1h dEZvclNrZWxldG9uKToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L0xvY2FsZVRvU2NyaXB0TWFw cGluZ0lDVS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpsb2NhbGVUb1NjcmlwdENvZGVGb3JGb250 U2VsZWN0aW9uKToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1RleHRDb2RlY0lDVS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpUZXh0Q29kZWNJQ1U6OmRlY29kZSk6CisgICAgICAgIChXZWJDb3Jl OjpUZXh0Q29kZWNJQ1U6OmVuY29kZSk6CisKIDIwMjAtMDQtMjggIFNpbW9uIEZyYXNlciAgPHNp bW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgVXBkYXRlIHRoZSB4Y2ZpbGVsaXN0cy4K SW5kZXg6IFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVGV4dEl0ZXJhdG9yLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1RleHRJdGVyYXRvci5jcHAJKHJldmlzaW9uIDI2 MDg2MikKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVGV4dEl0ZXJhdG9yLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNiArNjYsNyBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxk ZXIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9UZXh0QnJlYWtJdGVyYXRvci5oPgogI2luY2x1ZGUg PHd0Zi91bmljb2RlL0NoYXJhY3Rlck5hbWVzLmg+CisjaW5jbHVkZSA8d3RmL3VuaWNvZGUvaWN1 L0lDVUhlbHBlcnMuaD4KIAogI2lmICFVQ09ORklHX05PX0NPTExBVElPTgogI2luY2x1ZGUgPHVu aWNvZGUvdXNlYXJjaC5oPgpAQCAtMTgzNiw3ICsxODM3LDcgQEAgc3RhdGljIHZvaWQgbm9ybWFs aXplQ2hhcmFjdGVycyhjb25zdCBVQwogICAgIGJ1ZmZlci5yZXNpemUobGVuZ3RoKTsKIAogICAg IGF1dG8gbm9ybWFsaXplZExlbmd0aCA9IHVub3JtMl9ub3JtYWxpemUobm9ybWFsaXplciwgY2hh cmFjdGVycywgbGVuZ3RoLCBidWZmZXIuZGF0YSgpLCBsZW5ndGgsICZzdGF0dXMpOwotICAgIEFT U0VSVChVX1NVQ0NFU1Moc3RhdHVzKSB8fCBzdGF0dXMgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJS T1IpOworICAgIEFTU0VSVChVX1NVQ0NFU1Moc3RhdHVzKSB8fCBuZWVkc1RvR3Jvd1RvUHJvZHVj ZUJ1ZmZlcihzdGF0dXMpKTsKIAogICAgIGJ1ZmZlci5yZXNpemUobm9ybWFsaXplZExlbmd0aCk7 CiAKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvTG9jYWxlSUNVLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0xvY2FsZUlDVS5jcHAJKHJl dmlzaW9uIDI2MDg2MikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvTG9jYWxlSUNV LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPHVuaWNvZGUv dWxvYy5oPgogI2luY2x1ZGUgPHd0Zi9EYXRlTWF0aC5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0 cmluZ0J1aWxkZXIuaD4KKyNpbmNsdWRlIDx3dGYvdW5pY29kZS9pY3UvSUNVSGVscGVycy5oPgog CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTY5LDggKzcwLDggQEAgU3RyaW5nIExvY2FsZUlD VTo6ZGVjaW1hbFN5bWJvbChVTnVtYmVyRgogewogICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9a RVJPX0VSUk9SOwogICAgIGludDMyX3QgYnVmZmVyTGVuZ3RoID0gdW51bV9nZXRTeW1ib2wobV9u dW1iZXJGb3JtYXQsIHN5bWJvbCwgMCwgMCwgJnN0YXR1cyk7Ci0gICAgQVNTRVJUKFVfU1VDQ0VT UyhzdGF0dXMpIHx8IHN0YXR1cyA9PSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUik7Ci0gICAgaWYg KFVfRkFJTFVSRShzdGF0dXMpICYmIHN0YXR1cyAhPSBVX0JVRkZFUl9PVkVSRkxPV19FUlJPUikK KyAgICBBU1NFUlQoVV9TVUNDRVNTKHN0YXR1cykgfHwgbmVlZHNUb0dyb3dUb1Byb2R1Y2VCdWZm ZXIoc3RhdHVzKSk7CisgICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpICYmICFuZWVkc1RvR3Jvd1Rv UHJvZHVjZUJ1ZmZlcihzdGF0dXMpKQogICAgICAgICByZXR1cm4gU3RyaW5nKCk7CiAgICAgVmVj dG9yPFVDaGFyPiBidWZmZXIoYnVmZmVyTGVuZ3RoKTsKICAgICBzdGF0dXMgPSBVX1pFUk9fRVJS T1I7CkBAIC04NCw4ICs4NSw4IEBAIFN0cmluZyBMb2NhbGVJQ1U6OmRlY2ltYWxUZXh0QXR0cmli dXRlKFUKIHsKICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBpbnQz Ml90IGJ1ZmZlckxlbmd0aCA9IHVudW1fZ2V0VGV4dEF0dHJpYnV0ZShtX251bWJlckZvcm1hdCwg dGFnLCAwLCAwLCAmc3RhdHVzKTsKLSAgICBBU1NFUlQoVV9TVUNDRVNTKHN0YXR1cykgfHwgc3Rh dHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKTsKLSAgICBpZiAoVV9GQUlMVVJFKHN0YXR1 cykgJiYgc3RhdHVzICE9IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKQorICAgIEFTU0VSVChVX1NV Q0NFU1Moc3RhdHVzKSB8fCBuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMpKTsKKyAg ICBpZiAoVV9GQUlMVVJFKHN0YXR1cykgJiYgIW5lZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0 YXR1cykpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKICAgICBWZWN0b3I8VUNoYXI+IGJ1ZmZl cihidWZmZXJMZW5ndGgpOwogICAgIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKQEAgLTE1MCw3ICsx NTEsNyBAQCBzdGF0aWMgU3RyaW5nIGdldERhdGVGb3JtYXRQYXR0ZXJuKGNvbnN0CiAKICAgICBV RXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsKICAgICBpbnQzMl90IGxlbmd0aCA9IHVk YXRfdG9QYXR0ZXJuKGRhdGVGb3JtYXQsIFRSVUUsIDAsIDAsICZzdGF0dXMpOwotICAgIGlmIChz dGF0dXMgIT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IgfHwgIWxlbmd0aCkKKyAgICBpZiAoIW5l ZWRzVG9Hcm93VG9Qcm9kdWNlQnVmZmVyKHN0YXR1cykgfHwgIWxlbmd0aCkKICAgICAgICAgcmV0 dXJuIGVtcHR5U3RyaW5nKCk7CiAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIobGVuZ3RoKTsKICAg ICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CkBAIC0xNzIsNyArMTczLDcgQEAgc3RkOjp1bmlxdWVf cHRyPFZlY3RvcjxTdHJpbmc+PiBMb2NhbGVJQwogICAgIGZvciAoaW50MzJfdCBpID0gMDsgaSA8 IHNpemU7ICsraSkgewogICAgICAgICBVRXJyb3JDb2RlIHN0YXR1cyA9IFVfWkVST19FUlJPUjsK ICAgICAgICAgaW50MzJfdCBsZW5ndGggPSB1ZGF0X2dldFN5bWJvbHMoZGF0ZUZvcm1hdCwgdHlw ZSwgc3RhcnRJbmRleCArIGksIDAsIDAsICZzdGF0dXMpOwotICAgICAgICBpZiAoc3RhdHVzICE9 IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9SKQorICAgICAgICBpZiAoIW5lZWRzVG9Hcm93VG9Qcm9k dWNlQnVmZmVyKHN0YXR1cykpCiAgICAgICAgICAgICByZXR1cm4gbWFrZVVuaXF1ZTxWZWN0b3I8 U3RyaW5nPj4oKTsKICAgICAgICAgVmVjdG9yPFVDaGFyPiBidWZmZXIobGVuZ3RoKTsKICAgICAg ICAgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwpAQCAtMjY0LDcgKzI2NSw3IEBAIHN0YXRpYyBTdHJp bmcgZ2V0Rm9ybWF0Rm9yU2tlbGV0b24oY29uc3QKICAgICAgICAgcmV0dXJuIGZvcm1hdDsKICAg ICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgaW50MzJfdCBsZW5ndGggPSB1ZGF0cGdfZ2V0 QmVzdFBhdHRlcm4ocGF0dGVybkdlbmVyYXRvciwgc2tlbGV0b24sIHNrZWxldG9uTGVuZ3RoLCAw LCAwLCAmc3RhdHVzKTsKLSAgICBpZiAoc3RhdHVzID09IFVfQlVGRkVSX09WRVJGTE9XX0VSUk9S ICYmIGxlbmd0aCkgeworICAgIGlmIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihzdGF0dXMp ICYmIGxlbmd0aCkgewogICAgICAgICBWZWN0b3I8VUNoYXI+IGJ1ZmZlcihsZW5ndGgpOwogICAg ICAgICBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAgICAgICAgIHVkYXRwZ19nZXRCZXN0UGF0dGVy bihwYXR0ZXJuR2VuZXJhdG9yLCBza2VsZXRvbiwgc2tlbGV0b25MZW5ndGgsIGJ1ZmZlci5kYXRh KCksIGxlbmd0aCwgJnN0YXR1cyk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0 L0xvY2FsZVRvU2NyaXB0TWFwcGluZ0lDVS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vdGV4dC9Mb2NhbGVUb1NjcmlwdE1hcHBpbmdJQ1UuY3BwCShyZXZpc2lvbiAy NjA4NjIpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0xvY2FsZVRvU2NyaXB0TWFw cGluZ0lDVS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlIDx1 bmljb2RlL3Vsb2MuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CisjaW5jbHVkZSA8d3RmL3VuaWNvZGUvaWN1L0lDVUhlbHBl cnMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC03MSw3ICs3Miw3IEBAIFVTY3JpcHRD b2RlIGxvY2FsZVRvU2NyaXB0Q29kZUZvckZvbnRTZWwKICAgICBVU2NyaXB0Q29kZSBzY3JpcHRD b2RlID0gVVNDUklQVF9DT01NT047CiAgICAgdXNjcmlwdF9nZXRDb2RlKHNjcmlwdCwgJnNjcmlw dENvZGUsIDEsICZzdGF0dXMpOwogICAgIC8vIElnbm9yZSBlcnJvciB0aGF0IG11bHRpcGxlIHNj cmlwdHMgY291bGQgYmUgcmV0dXJuZWQsIHNpbmNlIHdlIG9ubHkgd2FudCBvbmUgc2NyaXB0Lgot ICAgIGlmIChVX0ZBSUxVUkUoc3RhdHVzKSAmJiBzdGF0dXMgIT0gVV9CVUZGRVJfT1ZFUkZMT1df RVJST1IpCisgICAgaWYgKFVfRkFJTFVSRShzdGF0dXMpICYmICFuZWVkc1RvR3Jvd1RvUHJvZHVj ZUJ1ZmZlcihzdGF0dXMpKQogICAgICAgICByZXR1cm4gVVNDUklQVF9DT01NT047CiAKICAgICBy ZXR1cm4gc2NyaXB0Q29kZUZvckZvbnRTZWxlY3Rpb24oc2NyaXB0Q29kZSk7CkluZGV4OiBTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY0lDVS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Q29kZWNJQ1UuY3BwCShyZXZpc2lvbiAy NjA4NjIpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY0lDVS5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlIDx3dGYvdGV4dC9DU3Ry aW5nLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogI2luY2x1ZGUgPHd0 Zi91bmljb2RlL0NoYXJhY3Rlck5hbWVzLmg+CisjaW5jbHVkZSA8d3RmL3VuaWNvZGUvaWN1L0lD VUhlbHBlcnMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0zMDgsNyArMzA5LDcgQEAg U3RyaW5nIFRleHRDb2RlY0lDVTo6ZGVjb2RlKGNvbnN0IGNoYXIqIAogICAgIGRvIHsKICAgICAg ICAgaW50IHVjaGFyc0RlY29kZWQgPSBkZWNvZGVUb0J1ZmZlcihidWZmZXIsIGJ1ZmZlckxpbWl0 LCBzb3VyY2UsIHNvdXJjZUxpbWl0LCBvZmZzZXRzLCBmbHVzaCwgZXJyKTsKICAgICAgICAgcmVz dWx0LmFwcGVuZENoYXJhY3RlcnMoYnVmZmVyLCB1Y2hhcnNEZWNvZGVkKTsKLSAgICB9IHdoaWxl IChlcnIgPT0gVV9CVUZGRVJfT1ZFUkZMT1dfRVJST1IpOworICAgIH0gd2hpbGUgKG5lZWRzVG9H cm93VG9Qcm9kdWNlQnVmZmVyKGVycikpOwogCiAgICAgaWYgKFVfRkFJTFVSRShlcnIpKSB7CiAg ICAgICAgIC8vIGZsdXNoIHRoZSBjb252ZXJ0ZXIgc28gaXQgY2FuIGJlIHJldXNlZCwgYW5kIG5v dCBiZSBib3RoZXJlZCBieSB0aGlzIGVycm9yLgpAQCAtNDYxLDcgKzQ2Miw3IEBAIFZlY3Rvcjx1 aW50OF90PiBUZXh0Q29kZWNJQ1U6OmVuY29kZShTdHIKICAgICAgICAgZXJyb3IgPSBVX1pFUk9f RVJST1I7CiAgICAgICAgIHVjbnZfZnJvbVVuaWNvZGUobV9jb252ZXJ0ZXIuZ2V0KCksICZ0YXJn ZXQsIHRhcmdldExpbWl0LCAmc291cmNlLCBzb3VyY2VMaW1pdCwgMCwgdHJ1ZSwgJmVycm9yKTsK ICAgICAgICAgcmVzdWx0LmFwcGVuZChyZWludGVycHJldF9jYXN0PHVpbnQ4X3QqPihidWZmZXIp LCB0YXJnZXQgLSBidWZmZXIpOwotICAgIH0gd2hpbGUgKGVycm9yID09IFVfQlVGRkVSX09WRVJG TE9XX0VSUk9SKTsKKyAgICB9IHdoaWxlIChuZWVkc1RvR3Jvd1RvUHJvZHVjZUJ1ZmZlcihlcnJv cikpOwogICAgIHJldHVybiByZXN1bHQ7CiB9CiAK