214809 2020-07-26 12:05:36 -0700 DisallowVMEntry needs a copy assignment operator, detected by gcc's -Wdeprecated-copy warning 2020-07-27 12:16:24 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build PC Linux RESOLVED FIXED InRadar P2 Normal --- 1 mcatanzaro mark.lam annulen darin ews-watchlist gyuyoung.kim jh718.park keith_miller mark.lam mcatanzaro msaboff ryuan.choi saam sergio tzagallo webkit-bug-importer ysuzuki oldest_to_newest 1675118 0 mcatanzaro 2020-07-26 12:05:36 -0700 Introduced by r264736: [1651/4306] Building CXX object Source/WebCore/CMakeFiles...es/WebCore/unified-sources/UnifiedSource-68aea4ac-6.cpp.o In file included from DerivedSources/ForwardingHeaders/wtf/Seconds.h:29, from DerivedSources/ForwardingHeaders/wtf/WallTime.h:29, from DerivedSources/ForwardingHeaders/wtf/ThreadingPrimitives.h:37, from DerivedSources/ForwardingHeaders/wtf/MainThread.h:35, from DerivedSources/ForwardingHeaders/wtf/NeverDestroyed.h:31, from DerivedSources/ForwardingHeaders/wtf/text/AtomString.h:24, from DerivedSources/ForwardingHeaders/wtf/text/WTFString.h:690, from ../../Source/WebCore/dom/Exception.h:30, from ../../Source/WebCore/dom/ExceptionOr.h:29, from ../../Source/WebCore/bindings/js/JSDOMBinding.h:28, from ../../Source/WebCore/bindings/js/JSDOMMapLike.h:28, from ../../Source/WebCore/bindings/js/JSDOMMapLike.cpp:27, from DerivedSources/WebCore/unified-sources/UnifiedSource-68aea4ac-6.cpp:1: DerivedSources/ForwardingHeaders/wtf/Optional.h: In instantiation of ‘WTF::Optional< <template-parameter-1-1> >& WTF::Optional< <template-parameter-1-1> >::operator=(const WTF::Optional< <template-parameter-1-1> >&) [with T = JSC::DisallowVMEntryImpl<JSC::VM>]’: DerivedSources/ForwardingHeaders/JavaScriptCore/PropertySlot.h:87:7: required from here DerivedSources/ForwardingHeaders/wtf/Optional.h:465:84: warning: implicitly-declared ‘constexpr JSC::DisallowVMEntryImpl<JSC::VM>& JSC::DisallowVMEntryImpl<JSC::VM>::operator=(const JSC::DisallowVMEntryImpl<JSC::VM>&)’ is deprecated [-Wdeprecated-copy] 465 | else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs; | ~~~~~~~~~~~~~~~~^~~~~~ In file included from DerivedSources/ForwardingHeaders/JavaScriptCore/VM.h:38, from DerivedSources/ForwardingHeaders/JavaScriptCore/Identifier.h:24, from DerivedSources/WebCore/JSDOMBindingInternalsBuiltins.h:34, from DerivedSources/WebCore/WebCoreJSBuiltinInternals.h:39, from ../../Source/WebCore/bindings/js/JSDOMGlobalObject.h:29, from ../../Source/WebCore/bindings/js/DOMWrapperWorld.h:24, from ../../Source/WebCore/bindings/js/JSDOMWrapperCache.h:26, from ../../Source/WebCore/bindings/js/JSDOMBinding.h:29, from ../../Source/WebCore/bindings/js/JSDOMMapLike.h:28, from ../../Source/WebCore/bindings/js/JSDOMMapLike.cpp:27, from DerivedSources/WebCore/unified-sources/UnifiedSource-68aea4ac-6.cpp:1: DerivedSources/ForwardingHeaders/JavaScriptCore/DisallowVMEntry.h:46:5: note: because ‘JSC::DisallowVMEntryImpl<JSC::VM>’ has user-provided ‘JSC::DisallowVMEntryImpl<VMType>::DisallowVMEntryImpl(const JSC::DisallowVMEntryImpl<VMType>&) [with VMType = JSC::VM]’ 46 | DisallowVMEntryImpl(const DisallowVMEntryImpl& other) | ^~~~~~~~~~~~~~~~~~~ Problem is the code makes a copy of the DisallowVMEntryImpl, and this copy fails to increment the VM's disallowVMEntryCount. But disallowVMEntryCount will be decremented when the DisallowVMEntryImpl is destroyed. ***I think that results in underflow.*** Let's add a copy constructor. 1675125 1 mcatanzaro 2020-07-26 12:18:57 -0700 (In reply to Michael Catanzaro from comment #0) > Let's add a copy constructor. Maybe it should be noncopyable instead? Seems safer? But then we can't use Optional<DisallowVMEntry>. 1675129 2 mark.lam 2020-07-26 12:29:13 -0700 (In reply to Michael Catanzaro from comment #1) > (In reply to Michael Catanzaro from comment #0) > > Let's add a copy constructor. > > Maybe it should be noncopyable instead? Seems safer? But then we can't use > Optional<DisallowVMEntry>. Optional will work just fine with non-copyable. That’s not the issue. The issue is that one place in WebCore wants to copy PropertySlots, which may mean copying DisallowVMEntry as well. 1675130 3 mark.lam 2020-07-26 12:34:39 -0700 (In reply to Michael Catanzaro from comment #0) ... > DerivedSources/WebCore/unified-sources/UnifiedSource-68aea4ac-6.cpp:1: > DerivedSources/ForwardingHeaders/JavaScriptCore/DisallowVMEntry.h:46:5: > note: because ‘JSC::DisallowVMEntryImpl<JSC::VM>’ has user-provided > ‘JSC::DisallowVMEntryImpl<VMType>::DisallowVMEntryImpl(const > JSC::DisallowVMEntryImpl<VMType>&) [with VMType = JSC::VM]’ > 46 | DisallowVMEntryImpl(const DisallowVMEntryImpl& other) > | ^~~~~~~~~~~~~~~~~~~ > > Problem is the code makes a copy of the DisallowVMEntryImpl, and this copy > fails to increment the VM's disallowVMEntryCount. But disallowVMEntryCount > will be decremented when the DisallowVMEntryImpl is destroyed. ***I think > that results in underflow.*** > > Let's add a copy constructor. Looking at the original patch, my copy constructor does increment vm->disallowVMEntryCount. What am I missing? 1675131 4 405257 mcatanzaro 2020-07-26 12:34:51 -0700 Created attachment 405257 Patch 1675132 5 mcatanzaro 2020-07-26 12:35:36 -0700 (In reply to Mark Lam from comment #3) > Looking at the original patch, my copy constructor does increment > vm->disallowVMEntryCount. What am I missing? The copy assignment operator! 1675133 6 405257 darin 2020-07-26 12:41:27 -0700 Comment on attachment 405257 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=405257&action=review > Source/JavaScriptCore/runtime/DisallowVMEntry.h:52 > + DisallowVMEntryImpl& operator=(const DisallowVMEntryImpl& other) Could you instead do a "delete"? void operator=(const DisallowVMEntryImpl&) = delete; I ask because I think we do not want to assign these and would prefer a compiler error. Not even sure why we want to copy them. 1675134 7 405257 darin 2020-07-26 12:42:13 -0700 Comment on attachment 405257 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=405257&action=review >> Source/JavaScriptCore/runtime/DisallowVMEntry.h:52 >> + DisallowVMEntryImpl& operator=(const DisallowVMEntryImpl& other) > > Could you instead do a "delete"? > > void operator=(const DisallowVMEntryImpl&) = delete; > > I ask because I think we do not want to assign these and would prefer a compiler error. Not even sure why we want to copy them. Oh, I see you already discussed this with Mark, and I guess we do want to assign these. 1675136 8 405257 darin 2020-07-26 12:44:44 -0700 Comment on attachment 405257 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=405257&action=review > Source/JavaScriptCore/runtime/DisallowVMEntry.h:55 > + m_vm = other.m_vm; > + m_vm->disallowVMEntryCount++; This is wrong. Needs to decrement the disallowVMEntryCount of the m_vm we are already pointing at. I suggest writing it in this more or less foolproof way instead: auto copy = other; std::swap(m_vm, copy.m_vm); Or you could add lines to this function: RELEASE_ASSERT(m_vm->disallowVMEntryCount); m_vm->disallowVMEntryCount--; 1675138 9 mark.lam 2020-07-26 13:27:13 -0700 (In reply to Darin Adler from comment #8) > Comment on attachment 405257 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=405257&action=review > > > Source/JavaScriptCore/runtime/DisallowVMEntry.h:55 > > + m_vm = other.m_vm; > > + m_vm->disallowVMEntryCount++; > > This is wrong. Needs to decrement the disallowVMEntryCount of the m_vm we > are already pointing at. I suggest writing it in this more or less foolproof > way instead: > > auto copy = other; > std::swap(m_vm, copy.m_vm); > > Or you could add lines to this function: > > RELEASE_ASSERT(m_vm->disallowVMEntryCount); > m_vm->disallowVMEntryCount--; I’m not sure swapping is the correct solution. I made this copyable in the first place because one place in WebCore was copying the PropertySlot that embeds it. From my reading of the code then, copying and incrementing the ref count is the right thing to do. That said, I can take another close look at this and see if we can solve this a different way without copying. I agree that not copying is preferable. I’ll do that later: away from my computer right now. 1675145 10 mcatanzaro 2020-07-26 14:16:54 -0700 (In reply to Darin Adler from comment #8) > This is wrong. Needs to decrement the disallowVMEntryCount of the m_vm we > are already pointing at. I suggest writing it in this more or less foolproof > way instead: > > auto copy = other; > std::swap(m_vm, copy.m_vm); I agree with Mark... I don't think swapping is safe here. 1675146 11 mcatanzaro 2020-07-26 14:19:41 -0700 (In reply to Michael Catanzaro from comment #10) > (In reply to Darin Adler from comment #8) > > This is wrong. Needs to decrement the disallowVMEntryCount of the m_vm we > > are already pointing at. You're right about that, though: my implementation is not safe if m_vm is initially nonnull. 1675151 12 mark.lam 2020-07-26 18:14:45 -0700 The function that wants to do PropertySlot assignment / copying is JSDOMWindow::getOwnPropertySlot(). The reason it wants to do this is because it wants to do is because it wants to call its Base::getOwnPropertySlot(). If Base::getOwnPropertySlot() does not find the requested property, JSDOMWindow::getOwnPropertySlot() wants to try again with the original PropertySlot value (in case Base::getOwnPropertySlot() has modified it though it isn't able to find the property). After looking at this code again, I think there are certainly ways around having an assignment operator for DisallowVMEntry. However, the alternatives may be worse than the straightforward approach of just having an assignment operator. When I wrote the code originally, I also made the same mistake of assuming that copy assignment is the same thing as simply invoking the copy constructor, which is probably why this is deprecated. I'll make the patch to fix the issue. Thanks for filing this bug. 1675158 13 mark.lam 2020-07-26 21:23:17 -0700 *** Bug 214815 has been marked as a duplicate of this bug. *** 1675159 14 mark.lam 2020-07-26 21:24:47 -0700 I already have a patch in hand. Just want to write a few tests and make sure it is functioning as expected before posting. 1675178 15 mark.lam 2020-07-27 01:26:37 -0700 For the record, there is no reference count mismatch. The only issue here is that C++ does not allow auto-generation of the copy assignment operator when a user declared destructor or copy constructor is present. In DisallowVMEntry's case, it has both a user declared destructor and copy constructor. 1675184 16 mark.lam 2020-07-27 01:48:00 -0700 (In reply to Mark Lam from comment #15) > For the record, there is no reference count mismatch. The only issue here > is that C++ does not allow auto-generation of the copy assignment operator > when a user declared destructor or copy constructor is present. In > DisallowVMEntry's case, it has both a user declared destructor and copy > constructor. I take that back: I'm not sure how the compiler generates the default copy assignment operator. If it calls the copy constructor, then there can be a reference count issue. My tests shows that this issue does not manifest with Clang though, FWIW. 1675185 17 405263 mark.lam 2020-07-27 01:48:36 -0700 Created attachment 405263 proposed patch. 1675231 18 mcatanzaro 2020-07-27 06:55:55 -0700 (In reply to Mark Lam from comment #16) > I take that back: I'm not sure how the compiler generates the default copy > assignment operator. If it calls the copy constructor, then there can be a > reference count issue. My tests shows that this issue does not manifest > with Clang though, FWIW. It doesn't call the copy constructor, it will just do a default copy of all data members. Combined with your RELEASE_ASSERT to ensure both DisallowVMEntry objects already correspond to the same VM before assignment, that explains why there's not currently any reference count issue. 1675286 19 darin 2020-07-27 10:22:01 -0700 (In reply to Michael Catanzaro from comment #10) > (In reply to Darin Adler from comment #8) > > This is wrong. Needs to decrement the disallowVMEntryCount of the m_vm we > > are already pointing at. I suggest writing it in this more or less foolproof > > way instead: > > > > auto copy = other; > > std::swap(m_vm, copy.m_vm); > > I agree with Mark... I don't think swapping is safe here. The new patch is a better idea. But the assignment operator based on swap here is *definitely* safe and correct. We don’t need to go into it since we have a different, better proposal, but I am concerned about this misunderstanding. 1675312 20 mcatanzaro 2020-07-27 11:05:00 -0700 (In reply to Darin Adler from comment #19) > But the assignment operator based on swap here is *definitely* safe and > correct. We don’t need to go into it since we have a different, better > proposal, but I am concerned about this misunderstanding. Hm... squinting at it: auto copy = other; std::swap(m_vm, copy.m_vm); Isn't it actually recursive? DisallowVMEntryImpl& operator=(const DisallowVMEntryImpl& other) { auto copy = other; // <-- calls itself? std::swap(m_vm, copy.m_vm); return *this; } I haven't tested it, but I guess we'd never reach the swap as the first line would keep calling itself forever? Doesn't matter, since Mark's solution is good. And it has so many tests! 1675323 21 mark.lam 2020-07-27 11:21:35 -0700 (In reply to Michael Catanzaro from comment #20) > (In reply to Darin Adler from comment #19) > > But the assignment operator based on swap here is *definitely* safe and > > correct. We don’t need to go into it since we have a different, better > > proposal, but I am concerned about this misunderstanding. > > Hm... squinting at it: > > auto copy = other; > std::swap(m_vm, copy.m_vm); > > Isn't it actually recursive? > > DisallowVMEntryImpl& operator=(const DisallowVMEntryImpl& other) > { > auto copy = other; // <-- calls itself? I think Darin meant that we should use the copy constructor here: auto copy(other); > std::swap(m_vm, copy.m_vm); > return *this; > } > > I haven't tested it, but I guess we'd never reach the swap as the first line > would keep calling itself forever? > > Doesn't matter, since Mark's solution is good. And it has so many tests! 1675329 22 405263 ysuzuki 2020-07-27 11:30:15 -0700 Comment on attachment 405263 proposed patch. r=me 1675330 23 darin 2020-07-27 11:32:38 -0700 (In reply to Michael Catanzaro from comment #20) > Hm... squinting at it: > > auto copy = other; > std::swap(m_vm, copy.m_vm); > > Isn't it actually recursive? No. > DisallowVMEntryImpl& operator=(const DisallowVMEntryImpl& other) > { > auto copy = other; // <-- calls itself? No, I am pretty sure that this is not assignment, although it looks like assignment (C++ trivia, I can provide a reference if you can't easily find it); just copy construction that can use any non-explicit constructor. If it's clearer, we can also write this line one of these ways: auto copy { other }; auto copy(other); 1675334 24 405263 mark.lam 2020-07-27 11:35:01 -0700 Comment on attachment 405263 proposed patch. Thanks for the review. Landing now. 1675338 25 ews-feeder 2020-07-27 11:50:48 -0700 Committed r264937: <https://trac.webkit.org/changeset/264937> All reviewed patches have been landed. Closing bug and clearing flags on attachment 405263. 1675339 26 webkit-bug-importer 2020-07-27 11:51:21 -0700 <rdar://problem/66174144> 1675345 27 mcatanzaro 2020-07-27 12:16:24 -0700 (In reply to Darin Adler from comment #23) > No, I am pretty sure that this is not assignment, although it looks like > assignment (C++ trivia, I can provide a reference if you can't easily find > it); just copy construction that can use any non-explicit constructor. If > it's clearer, we can also write this line one of these ways: > > auto copy { other }; > auto copy(other); You're right! Learning is good.... 405257 2020-07-26 12:34:51 -0700 2020-07-27 01:48:36 -0700 Patch bug-214809-20200726143451.patch text/plain 1435 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjY0ODk4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBi MjQwNjNiOTYzZjk3NjQxNWI0ZTRjMjkxNjcwMWJkZmUzNzFjOThjLi40MDM3NTU2YmE4ZWFhOWI1 ZjBlMjY4N2QyODUxMWE4ZDIxNGJiZjFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wNy0yNiAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICAtV2RlcHJlY2F0ZWQtY29weSBjYXVzZWQgYnkgRGlzYWxsb3dW TUVudHJ5IGNvcHkgY29uc3RydWN0b3IKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIxNDgwOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBhIGNvcHkgYXNzaWdubWVudCBvcGVyYXRvci4KKworICAgICAg ICAqIHJ1bnRpbWUvRGlzYWxsb3dWTUVudHJ5Lmg6CisgICAgICAgIChKU0M6OkRpc2FsbG93Vk1F bnRyeUltcGw6Om9wZXJhdG9yPSk6CisKIDIwMjAtMDctMjQgIE1hcmsgTGFtICA8bWFyay5sYW1A YXBwbGUuY29tPgogCiAgICAgICAgIHBsdWdpbkVsZW1lbnRDdXN0b21HZXRPd25Qcm9wZXJ0eVNs b3QoKSBzaG91bGQgc3VwcG9ydCBWTUlucXVpcnkgcmVxdWVzdHMuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9EaXNhbGxvd1ZNRW50cnkuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0Rpc2FsbG93Vk1FbnRyeS5oCmluZGV4IDBkYjhlN2Q2Y2QwYmEw NGRiZWUyZDM4NDA3ODhlOWE0N2Y1YmMyODIuLjYwZTc4YWNhNmZjZThlMzdlZTJiZTU3MjE1ZDk2 NGRlY2NlY2ZjNWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Rp c2FsbG93Vk1FbnRyeS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Rpc2Fs bG93Vk1FbnRyeS5oCkBAIC00OSw2ICs0OSwxMyBAQCBwdWJsaWM6CiAgICAgICAgIG1fdm0tPmRp c2FsbG93Vk1FbnRyeUNvdW50Kys7CiAgICAgfQogCisgICAgRGlzYWxsb3dWTUVudHJ5SW1wbCYg b3BlcmF0b3I9KGNvbnN0IERpc2FsbG93Vk1FbnRyeUltcGwmIG90aGVyKQorICAgIHsKKyAgICAg ICAgbV92bSA9IG90aGVyLm1fdm07CisgICAgICAgIG1fdm0tPmRpc2FsbG93Vk1FbnRyeUNvdW50 Kys7CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisKICAgICB+RGlzYWxsb3dWTUVudHJ5 SW1wbCgpCiAgICAgewogICAgICAgICBSRUxFQVNFX0FTU0VSVChtX3ZtLT5kaXNhbGxvd1ZNRW50 cnlDb3VudCk7Cg== 405263 2020-07-27 01:48:36 -0700 2020-07-27 11:50:49 -0700 proposed patch. bug-214809.patch text/plain 20793 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjY0OTAxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDI0IEBA CisyMDIwLTA3LTI3ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBE aXNhbGxvd1ZNRW50cnkgbmVlZHMgYSBjb3B5IGFzc2lnbm1lbnQgb3BlcmF0b3IsIGRldGVjdGVk IGJ5IGdjYydzIC1XZGVwcmVjYXRlZC1jb3B5IHdhcm5pbmcKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNDgwOQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFjY29yZGluZyB0byBodHRwczovL2VuLmNwcHJl ZmVyZW5jZS5jb20vdy9jcHAvbGFuZ3VhZ2UvY29weV9hc3NpZ25tZW50LAorICAgICAgICAiVGhl IGdlbmVyYXRpb24gb2YgdGhlIGltcGxpY2l0bHktZGVmaW5lZCBjb3B5IGFzc2lnbm1lbnQgb3Bl cmF0b3IgaXMgZGVwcmVjYXRlZAorICAgICAgICAoc2luY2UgQysrMTEpIGlmIFQgaGFzIGEgdXNl ci1kZWNsYXJlZCBkZXN0cnVjdG9yIG9yIHVzZXItZGVjbGFyZWQgY29weSBjb25zdHJ1Y3Rvci4i CisgICAgICAgIERpc2FsbG93Vk1FbnRyeSBoYXMgYm90aCBhIHVzZXItZGVjbGFyZWQgZGVzdHJ1 Y3RvciBhbmQgYSB1c2VyLWRlY2xhcmVkIGNvcHkKKyAgICAgICAgY29uc3RydWN0b3IuICBIZW5j ZSwgaXQgbmVlZHMgdG8gZGVmaW5lIGl0cyBvd24gY29weSBhc3NpZ25tZW50IG9wZXJhdG9yIHRv IHBsYWNhdGUKKyAgICAgICAgdGhlIGNvbXBpbGVyLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWxz byBhZGRzIGJhY2sgV1RGX0ZPUkJJRF9IRUFQX0FMTE9DQVRJT04gdG8gRGlzYWxsb3dWTUVudHJ5 LgorICAgICAgICBEaXNhbGxvd1ZNRW50cnkgc2hvdWxkIGFsd2F5cyBoYXZlIGZvcmJpZCBoZWFw IGFsbG9jYXRpb24uICBJdCB3YXMgYWNjaWRlbnRhbGx5CisgICAgICAgIHJlbW92ZWQgaW4gYSBw cmlvciBwYXRjaC4KKworICAgICAgICAqIHJ1bnRpbWUvRGlzYWxsb3dWTUVudHJ5Lmg6CisgICAg ICAgIChKU0M6OkRpc2FsbG93Vk1FbnRyeUltcGw6Om9wZXJhdG9yPSk6CisKIDIwMjAtMDctMjQg IE1hcmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAgICAgIHBsdWdpbkVsZW1lbnRD dXN0b21HZXRPd25Qcm9wZXJ0eVNsb3QoKSBzaG91bGQgc3VwcG9ydCBWTUlucXVpcnkgcmVxdWVz dHMuCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9EaXNhbGxvd1ZNRW50cnku aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9EaXNhbGxvd1ZN RW50cnkuaAkocmV2aXNpb24gMjY0OTAxKQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRGlzYWxsb3dWTUVudHJ5LmgJKHdvcmtpbmcgY29weSkKQEAgLTI1LDYgKzI1LDggQEAKIAog I3ByYWdtYSBvbmNlCiAKKyNpbmNsdWRlIDx3dGYvRm9yYmlkSGVhcEFsbG9jYXRpb24uaD4KKwog bmFtZXNwYWNlIEpTQyB7CiAKIGNsYXNzIFZNOwpAQCAtMzYsNiArMzgsNyBAQCBjbGFzcyBWTTsK IAogdGVtcGxhdGU8dHlwZW5hbWUgVk1UeXBlID0gVk0+CiBjbGFzcyBEaXNhbGxvd1ZNRW50cnlJ bXBsIHsKKyAgICBXVEZfRk9SQklEX0hFQVBfQUxMT0NBVElPTjsKIHB1YmxpYzoKICAgICBEaXNh bGxvd1ZNRW50cnlJbXBsKFZNVHlwZSYgdm0pCiAgICAgICAgIDogbV92bSgmdm0pCkBAIC01Niw2 ICs1OSwxOCBAQCBwdWJsaWM6CiAgICAgICAgIG1fdm0gPSBudWxscHRyOwogICAgIH0KIAorICAg IERpc2FsbG93Vk1FbnRyeUltcGwmIG9wZXJhdG9yPShjb25zdCBEaXNhbGxvd1ZNRW50cnlJbXBs JiBvdGhlcikKKyAgICB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKG1fdm0gJiYgbV92bSA9PSBv dGhlci5tX3ZtKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQobV92bS0+ZGlzYWxsb3dWTUVudHJ5 Q291bnQpOworICAgICAgICAvLyBDb25jZXB0dWFsbHksIHdlIG5lZWQgdG8gZGVjcmVtZW50IHRo ZSBkaXNhbGxvd1ZNRW50cnlDb3VudCBvZiB0aGUKKyAgICAgICAgLy8gb2xkIG1fdm0sIGFuZCBp bmNyZW1lbnQgdGhlIGRpc2FsbG93Vk1FbnRyeUNvdW50IG9mIHRoZSBuZXcgbV92bS4KKyAgICAg ICAgLy8gQnV0IHNpbmNlIHRoZSBvbGQgYW5kIHRoZSBuZXcgbV92bSBzaG91bGQgYWx3YXlzIGJl IHRoZSBzYW1lLCB0aGUKKyAgICAgICAgLy8gZGVjcmVtZW50aW5nIGFuZCBpbmNyZW1lbnRpbmcg Y2FuY2VscyBvdXQsIGFuZCB0aGVyZSdzIG5vdGhpbmcgbW9yZQorICAgICAgICAvLyB0byBkbyBo ZXJlLgorICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCiBwcml2YXRlOgogICAgIFZNVHlw ZSogbV92bTsKIH07CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCShyZXZpc2lvbiAyNjQ5MDEpCisrKyBTb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyMiBAQAorMjAyMC0w Ny0yNyAgTWFyayBMYW0gIDxtYXJrLmxhbUBhcHBsZS5jb20+CisKKyAgICAgICAgRGlzYWxsb3dW TUVudHJ5IG5lZWRzIGEgY29weSBhc3NpZ25tZW50IG9wZXJhdG9yLCBkZXRlY3RlZCBieSBnY2Mn cyAtV2RlcHJlY2F0ZWQtY29weSB3YXJuaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTQ4MDkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCBoYW5kbGluZyBvZiBhIHBvc3NpYmxlIFZNSW5xdWly eSBmYWlsdXJlIGluIEpTRE9NV2luZG93OjpnZXRPd25Qcm9wZXJ0eVNsb3QoKQorICAgICAgICBh ZnRlciByZXR1cm5pbmcgZnJvbSBCYXNlOjpnZXRPd25Qcm9wZXJ0eVNsb3QoKS4gIElmIGEgVk1J bnF1aXJ5IGlzIHJlcXVlc3RlZCBhbmQKKyAgICAgICAgQmFzZTo6Z2V0T3duUHJvcGVydHlTbG90 KCkgcmV0dXJucyBmYWxzZSB3aXRoIHNsb3QuaXNUYWludGVkQnlPcGFxdWVPYmplY3QoKSBzZXQs CisgICAgICAgIHRoZW4gaXQgbWVhbnMgdGhhdCBCYXNlOjpnZXRPd25Qcm9wZXJ0eVNsb3QoKSBm YWlsZWQgdG8gZXhlY3V0ZSB0aGUgVk1JbnF1aXJ5LAorICAgICAgICBub3QgdGhhdCBpdCBzdWNj ZXNzZnVsbHkgZGV0ZXJtaW5lZCB0aGF0IHRoZSBwcm9wZXJ0eSBkb2Vzbid0IGV4aXN0LgorCisg ICAgICAgIFRoaXMgaXNzdWUgd2FzIG5vdGljZWQgd2hpbGUgc3R1ZHlpbmcgaG93IEpTRE9NV2lu ZG93OjpnZXRPd25Qcm9wZXJ0eVNsb3QoKSB1c2VzCisgICAgICAgIGNvcHkgYXNzaWdubWVudCBv ZiBKU0M6OlByb3BlcnR5U2xvdHMuCisKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU0RPTVdpbmRv d0N1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpKU0RPTVdpbmRvdzo6Z2V0T3duUHJvcGVy dHlTbG90KToKKwogMjAyMC0wNy0yNiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+ CiAKICAgICAgICAgVXBkYXRlIGNhcHR1cmUgTWVkaWFTdHJlYW1UcmFjayBmcmFtZVJhdGUgYW5k IGFzcGVjdFJhdGlvIGNhcGFiaWxpdGllcwpJbmRleDogU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNET01XaW5kb3dDdXN0b20uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTRE9NV2luZG93Q3VzdG9tLmNwcAkocmV2aXNpb24gMjY0OTAxKQorKysgU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dDdXN0b20uY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0yMDksNyArMjA5LDkgQEAgYm9vbCBKU0RPTVdpbmRvdzo6Z2V0T3duUHJvcGVydHlT bG90KEpTTwogICAgICAgICBpZiAoIWlzU2hvd01vZGFsRGlhbG9nQW5kU2hvdWxkSGlkZSkKICAg ICAgICAgICAgIHJldHVybiB0cnVlOwogICAgICAgICBzbG90ID0gc2xvdENvcHk7Ci0gICAgfQor CisgICAgfSBlbHNlIGlmIChVTkxJS0VMWShzbG90LmlzVk1JbnF1aXJ5KCkgJiYgc2xvdC5pc1Rh aW50ZWRCeU9wYXF1ZU9iamVjdCgpKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAjaWYgRU5B QkxFKFVTRVJfTUVTU0FHRV9IQU5ETEVSUykKICAgICBpZiAocHJvcGVydHlOYW1lID09IHN0YXRp Y19jYXN0PEpTVk1DbGllbnREYXRhKj4obGV4aWNhbEdsb2JhbE9iamVjdC0+dm0oKS5jbGllbnRE YXRhKS0+YnVpbHRpbk5hbWVzKCkud2Via2l0UHVibGljTmFtZSgpICYmIHRoaXNPYmplY3QtPndy YXBwZWQoKS5zaG91bGRIYXZlV2ViS2l0TmFtZXNwYWNlRm9yV29ybGQodGhpc09iamVjdC0+d29y bGQoKSkpIHsKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFu Z2VMb2cJKHJldmlzaW9uIDI2NDkwOSkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDIxIEBACisyMDIwLTA3LTI3ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxl LmNvbT4KKworICAgICAgICBEaXNhbGxvd1ZNRW50cnkgbmVlZHMgYSBjb3B5IGFzc2lnbm1lbnQg b3BlcmF0b3IsIGRldGVjdGVkIGJ5IGdjYydzIC1XZGVwcmVjYXRlZC1jb3B5IHdhcm5pbmcKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNDgwOQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHRlc3Qg Y2FzZSBmb3IgSlNDJ3MgRGlzYWxsb3dWTUVudHJ5IGFuZCBQcm9wZXJ0eVNsb3QgbWFpbmx5IGZv ciB0aGUgY29weQorICAgICAgICBhc3NpZ25tZW50IG9wZXJhdGlvbiB1c2VkIGluIEpTRE9NV2lu ZG93OjpnZXRPd25Qcm9wZXJ0eVNsb3QoKS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvQ01h a2VMaXN0cy50eHQ6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9KYXZh U2NyaXB0Q29yZS9EaXNhbGxvd1ZNRW50cnkuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJL aXRBUEk6OmVudGVyU2NvcGUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisgICAg ICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9KYXZhU2NyaXB0Q29yZS9Qcm9wZXJ0eVNsb3QuY3Bw OiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDIwLTA3LTI2ICBX ZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJ T04gKHIyNjQ2OTApOiBbIGlPUyB3azIgXSBlZGl0aW5nL3NlbGVjdGlvbi9zaGlmdC1jbGljay1p bmNsdWRlcy1leGlzdGluZy1zZWxlY3Rpb24uaHRtbCBpcyBhIGZsYWt5IGZhaWx1cmUKSW5kZXg6 IFRvb2xzL1Rlc3RXZWJLaXRBUEkvQ01ha2VMaXN0cy50eHQKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv VGVzdFdlYktpdEFQSS9DTWFrZUxpc3RzLnR4dAkocmV2aXNpb24gMjY0OTAxKQorKysgVG9vbHMv VGVzdFdlYktpdEFQSS9DTWFrZUxpc3RzLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMTIyLDYgKzEy MiwzMSBAQCBzZXQoVGVzdFdURl9MSUJSQVJJRVMKIAogV0VCS0lUX0VYRUNVVEFCTEVfREVDTEFS RShUZXN0V1RGKQogCisjIFRlc3RKYXZhU2NyaXB0Q29yZSBkZWZpbml0aW9ucworaWYgKEVOQUJM RV9KQVZBU0NSSVBUQ09SRSkKKyAgICBzZXQoVGVzdEphdmFTY3JpcHRDb3JlX1NPVVJDRVMKKyAg ICAgICAgVGVzdHNDb250cm9sbGVyLmNwcAorICAgICAgICBXVEZTdHJpbmdVdGlsaXRpZXMuY3Bw CisKKyAgICAgICAgVGVzdHMvSmF2YVNjcmlwdENvcmUvRGlzYWxsb3dWTUVudHJ5LmNwcAorICAg ICAgICBUZXN0cy9KYXZhU2NyaXB0Q29yZS9Qcm9wZXJ0eVNsb3QuY3BwCisgICAgKQorCisgICAg c2V0KFRlc3RKYXZhU2NyaXB0Q29yZV9MSUJSQVJJRVMKKyAgICAgICAgV2ViS2l0OjpKYXZhU2Ny aXB0Q29yZQorICAgICAgICBndGVzdAorICAgICkKKworICAgIHNldChUZXN0SmF2YVNjcmlwdENv cmVfUFJJVkFURV9JTkNMVURFX0RJUkVDVE9SSUVTCisgICAgICAgICR7Q01BS0VfQklOQVJZX0RJ Un0KKyAgICAgICAgJHtURVNUV0VCS0lUQVBJX0RJUn0KKyAgICAgICAgJHtUSElSRFBBUlRZX0RJ Un0vZ3Rlc3QvaW5jbHVkZQorICAgICAgICAke0phdmFTY3JpcHRDb3JlQ29yZV9QUklWQVRFX0ZS QU1FV09SS19IRUFERVJTX0RJUn0KKyAgICApCisKKyAgICBXRUJLSVRfRVhFQ1VUQUJMRV9ERUNM QVJFKFRlc3RKYXZhU2NyaXB0Q29yZSkKK2VuZGlmICgpCisKICMgVGVzdFdlYkNvcmUgZGVmaW5p dGlvbnMKIGlmIChFTkFCTEVfV0VCQ09SRSkKICAgICBzZXQoVGVzdFdlYkNvcmVfU09VUkNFUwpA QCAtMzU2LDYgKzM4MSwxMSBAQCBXRUJLSVRfSU5DTFVERV9DT05GSUdfRklMRVNfSUZfRVhJU1RT KCkKICMgVGVzdFdURiB0YXJnZXQKIFdFQktJVF9URVNUKFRlc3RXVEYpCiAKKyMgVGVzdEphdmFT Y3JpcHRDb3JlIHRhcmdldAoraWYgKEVOQUJMRV9KQVZBU0NSSVBUQ09SRSkKKyAgICBXRUJLSVRf VEVTVChUZXN0SmF2YVNjcmlwdENvcmUpCitlbmRpZiAoKQorCiAjIFRlc3RXZWJDb3JlIHRhcmdl dAogaWYgKEVOQUJMRV9XRUJDT1JFKQogICAgIFdFQktJVF9URVNUKFRlc3RXZWJDb3JlKQpJbmRl eDogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDI2NDkwMSkKKysrIFRvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5n IGNvcHkpCkBAIC0xMTc3LDYgKzExNzcsOCBAQAogCQlGNkZERERENjE0MjQxQzZGMDA0RjE3Mjkg LyogcHVzaC1zdGF0ZS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY2RkREREQ1MTQyNDFDNDgwMDRGMTcyOSAvKiBwdXNoLXN0YXRlLmh0 bWwgKi87IH07CiAJCUZFMkJDREM3MjQ3MEZEQTMwMERFQzMzQiAvKiBTdGRMaWJFeHRyYXMuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkUyQkNEQzYy NDcwRkM3MDAwREVDMzNCIC8qIFN0ZExpYkV4dHJhcy5jcHAgKi87IH07CiAJCUZFMkQ5NDc0MjQ1 RUIyRjQwMEU0ODEzNSAvKiBCaXRtYXAuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRkUyRDk0NzMyNDVFQjJERjAwRTQ4MTM1IC8qIEJpdG1hcC5jcHAg Ki87IH07CisJCUZFQzJBODU0MjRDRTk3NUYwMEFEQkMzNSAvKiBEaXNhbGxvd1ZNRW50cnkuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkVDMkE4NTMy NENFOTc0RTAwQURCQzM1IC8qIERpc2FsbG93Vk1FbnRyeS5jcHAgKi87IH07CisJCUZFQzJBODU2 MjRDRUI2NUYwMEFEQkMzNSAvKiBQcm9wZXJ0eVNsb3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkVDMkE4NTUyNENFQjY1RjAwQURCQzM1IC8qIFBy b3BlcnR5U2xvdC5jcHAgKi87IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KIAog LyogQmVnaW4gUEJYQ29udGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTI4OTQsNiArMjg5 Niw4IEBACiAJCUZFMkJDREM2MjQ3MEZDNzAwMERFQzMzQiAvKiBTdGRMaWJFeHRyYXMuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU3RkTGliRXh0cmFzLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkUyRDk0NzMyNDVFQjJERjAwRTQ4MTM1IC8qIEJp dG1hcC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBCaXRtYXAuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRUI2Rjc0RTFCMkJBNDRFMDA5RTQ5MjIg LyogTmFrZWRQdHIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmFr ZWRQdHIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGRUMyQTg1MzI0Q0U5NzRF MDBBREJDMzUgLyogRGlzYWxsb3dWTUVudHJ5LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IERpc2FsbG93Vk1FbnRyeS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCUZFQzJBODU1MjRDRUI2NUYwMEFEQkMzNSAvKiBQcm9wZXJ0eVNsb3QuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUHJvcGVydHlTbG90LmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIC8qIEVuZCBQQlhGaWxlUmVmZXJlbmNlIHNlY3Rpb24gKi8K IAogLyogQmVnaW4gUEJYRnJhbWV3b3Jrc0J1aWxkUGhhc2Ugc2VjdGlvbiAqLwpAQCAtMzA3Niw3 ICszMDgwLDkgQEAKIAkJMTRDQzQyRTAyNEI4RDdFNzAwRTY0RjQ4IC8qIEphdmFTY3JpcHRDb3Jl ICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQlGRUMyQTg1 MzI0Q0U5NzRFMDBBREJDMzUgLyogRGlzYWxsb3dWTUVudHJ5LmNwcCAqLywKIAkJCQkxNENDNDJF NTI0QjhEOEZBMDBFNjRGNDggLyogSlNSdW5Mb29wVGltZXIubW0gKi8sCisJCQkJRkVDMkE4NTUy NENFQjY1RjAwQURCQzM1IC8qIFByb3BlcnR5U2xvdC5jcHAgKi8sCiAJCQkpOwogCQkJcGF0aCA9 IEphdmFTY3JpcHRDb3JlOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTUyNDQsNiAr NTI1MCw3IEBACiAJCQkJN0M4M0UwQzExRDBBNjUyRjAwRkVCQ0YzIC8qIFByb3Zpc2lvbmFsVVJM Tm90Q2hhbmdlLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNUNGQUNGNjUyMjZGRDJEQzAwNTZDN0Qw IC8qIFByb3h5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJMDQxQTFFMzQyMTZGRkRCQzAwNzg5RTBB IC8qIFB1YmxpY1N1ZmZpeC5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlGRUMyQTg1NDI0Q0U5NzVG MDBBREJDMzUgLyogRGlzYWxsb3dWTUVudHJ5LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNF MEMyMUQwQTY1MzUwMEZFQkNGMyAvKiBRdWlja0xvb2subW0gaW4gU291cmNlcyAqLywKIAkJCQk2 QjRFODYxQzIyMjBBNTUyMDAyMkYzODkgLyogUmVnaXN0cmFibGVEb21haW4uY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJN0NDRTdGMEQxQTQxMUFFNjAwNDQ3QzRDIC8qIFJlbG9hZFBhZ2VBZnRlckNy YXNoLmNwcCBpbiBTb3VyY2VzICovLApAQCAtNTQyOCw2ICs1NDM1LDcgQEAKIAkJCQk3QzgzRTBC NTFEMEE2NDkzMDBGRUJDRjMgLyogV0tSZXRhaW5QdHIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ NUU0QjFEMkUxRDQwNEM2MTAwMDUzNjIxIC8qIFdLU2Nyb2xsVmlld0RlbGVnYXRlLm1tIGluIFNv dXJjZXMgKi8sCiAJCQkJRjQzRTNCQkYyMERBREExRTAwQTRFN0VEIC8qIFdLU2Nyb2xsVmlld1Rl c3RzLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJRkVDMkE4NTYyNENFQjY1RjAwQURCQzM1IC8qIFBy b3BlcnR5U2xvdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk0NjI4QzhFOTIzNjdBQkQxMDBCMDcz RjAgLyogV0tTZWN1cml0eU9yaWdpbi5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3Q0NFN0YyMjFB NDExQUU2MDA0NDdDNEMgLyogV0tTdHJpbmcuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0NDRTdG MUUxQTQxMUFFNjAwNDQ3QzRDIC8qIFdLU3RyaW5nSlNTdHJpbmcuY3BwIGluIFNvdXJjZXMgKi8s CkluZGV4OiBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL0phdmFTY3JpcHRDb3JlL0Rpc2FsbG93 Vk1FbnRyeS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9KYXZh U2NyaXB0Q29yZS9EaXNhbGxvd1ZNRW50cnkuY3BwCShub25leGlzdGVudCkKKysrIFRvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvSmF2YVNjcmlwdENvcmUvRGlzYWxsb3dWTUVudHJ5LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMCwwICsxLDExNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMg SVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRP UlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MK KyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgor ICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9EaXNhbGxvd1ZNRW50cnkuaD4KKyNpbmNs dWRlIDxKYXZhU2NyaXB0Q29yZS9Jbml0aWFsaXplVGhyZWFkaW5nLmg+CisjaW5jbHVkZSA8SmF2 YVNjcmlwdENvcmUvVk0uaD4KKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCit1c2luZyBK U0M6OkRpc2FsbG93Vk1FbnRyeTsKK3VzaW5nIEpTQzo6SlNMb2NrSG9sZGVyOwordXNpbmcgSlND OjpMYXJnZUhlYXA7Cit1c2luZyBKU0M6OlZNOworCitzdGF0aWMgdm9pZCBlbnRlclNjb3BlKFZN JiB2bSwgdW5zaWduZWQgZW50cnlDb3VudCwgdW5zaWduZWQgcmVtYWluaW5nRW50cmllcykKK3sK KyAgICBEaXNhbGxvd1ZNRW50cnkgZGlzYWxsb3dWTUVudHJ5KHZtKTsKKyAgICBFWFBFQ1RfRVEo dm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIGVudHJ5Q291bnQpOworCisgICAgaWYgKC0tcmVtYWlu aW5nRW50cmllcykKKyAgICAgICAgZW50ZXJTY29wZSh2bSwgZW50cnlDb3VudCArIDEsIHJlbWFp bmluZ0VudHJpZXMpOworCisgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCBl bnRyeUNvdW50KTsKK30KKworVEVTVChKYXZhU2NyaXB0Q29yZV9EaXNhbGxvd1ZNRW50cnksIE5l c3RlZFNjb3BlcykKK3sKKyAgICBXVEY6OmluaXRpYWxpemVNYWluVGhyZWFkKCk7CisgICAgSlND Ojppbml0aWFsaXplKCk7CisKKyAgICBWTSYgdm0gPSBWTTo6Y3JlYXRlKExhcmdlSGVhcCkubGVh a1JlZigpOworICAgIHsKKyAgICAgICAgSlNMb2NrSG9sZGVyIGxvY2tlcih2bSk7CisgICAgICAg IEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUpOworICAgICAgICBlbnRlclNj b3BlKHZtLCAxLCAxMCk7CisgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3Vu dCwgMHUpOworICAgIH0KK30KKworVEVTVChKYXZhU2NyaXB0Q29yZV9EaXNhbGxvd1ZNRW50cnks IENvcHlDb25zdHJ1Y3Rpb24pCit7CisgICAgV1RGOjppbml0aWFsaXplTWFpblRocmVhZCgpOwor ICAgIEpTQzo6aW5pdGlhbGl6ZSgpOworCisgICAgVk0mIHZtID0gVk06OmNyZWF0ZShMYXJnZUhl YXApLmxlYWtSZWYoKTsKKyAgICB7CisgICAgICAgIEpTTG9ja0hvbGRlciBsb2NrZXIodm0pOwor ICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDB1KTsKKworICAgICAg ICB7CisgICAgICAgICAgICBEaXNhbGxvd1ZNRW50cnkgZGlzYWxsb3dWTUVudHJ5KHZtKTsKKyAg ICAgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMXUpOworICAgICAg ICAgICAgeworICAgICAgICAgICAgICAgIERpc2FsbG93Vk1FbnRyeSBkaXNhbGxvd1ZNRW50cnky KGRpc2FsbG93Vk1FbnRyeSk7CisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93 Vk1FbnRyeUNvdW50LCAydSk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBFWFBFQ1RfRVEo dm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDF1KTsKKyAgICAgICAgfQorCisgICAgICAgIEVYUEVD VF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUpOworICAgIH0KK30KKworVEVTVChKYXZh U2NyaXB0Q29yZV9EaXNhbGxvd1ZNRW50cnksIENvcHlBc3NpZ25tZW50KQoreworICAgIFdURjo6 aW5pdGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICBKU0M6OmluaXRpYWxpemUoKTsKKworICAgIFZN JiB2bSA9IFZNOjpjcmVhdGUoTGFyZ2VIZWFwKS5sZWFrUmVmKCk7CisgICAgeworICAgICAgICBK U0xvY2tIb2xkZXIgbG9ja2VyKHZtKTsKKyAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1F bnRyeUNvdW50LCAwdSk7CisKKyAgICAgICAgeworICAgICAgICAgICAgRGlzYWxsb3dWTUVudHJ5 IGRpc2FsbG93Vk1FbnRyeSh2bSk7CisgICAgICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dW TUVudHJ5Q291bnQsIDF1KTsKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBEaXNhbGxv d1ZNRW50cnkgZGlzYWxsb3dWTUVudHJ5MiA9IGRpc2FsbG93Vk1FbnRyeTsKKyAgICAgICAgICAg ICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDJ1KTsKKworICAgICAgICAg ICAgICAgIGRpc2FsbG93Vk1FbnRyeSA9IGRpc2FsbG93Vk1FbnRyeTI7CisgICAgICAgICAgICAg ICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAydSk7CisgICAgICAgICAgICB9 CisgICAgICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDF1KTsKKyAg ICAgICAgfQorCisgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUp OworICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQpJbmRleDogVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9KYXZhU2NyaXB0Q29yZS9Qcm9wZXJ0eVNsb3QuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvSmF2YVNjcmlwdENvcmUvUHJvcGVy dHlTbG90LmNwcAkobm9uZXhpc3RlbnQpCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL0ph dmFTY3JpcHRDb3JlL1Byb3BlcnR5U2xvdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSwx NjIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAor ICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisg KiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICog Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvSW5pdGlhbGl6ZVRocmVhZGluZy5oPgorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0pTQ0pTVmFsdWVJbmxpbmVzLmg+CisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvUHJvcGVydHlT bG90Lmg+CisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvVk0uaD4KKworbmFtZXNwYWNlIFRlc3RX ZWJLaXRBUEkgeworCit1c2luZyBKU0M6OkpTTG9ja0hvbGRlcjsKK3VzaW5nIEpTQzo6TGFyZ2VI ZWFwOwordXNpbmcgSlNDOjpQcm9wZXJ0eVNsb3Q7Cit1c2luZyBKU0M6OlZNOwordXNpbmcgSlND Ojpqc1VuZGVmaW5lZDsKKworVEVTVChKYXZhU2NyaXB0Q29yZV9Qcm9wZXJ0eVNsb3QsIERpc2Fs bG93Vk1FbnRyeUNvdW50QmFzaWMpCit7CisgICAgV1RGOjppbml0aWFsaXplTWFpblRocmVhZCgp OworICAgIEpTQzo6aW5pdGlhbGl6ZSgpOworCisgICAgVk0mIHZtID0gVk06OmNyZWF0ZShMYXJn ZUhlYXApLmxlYWtSZWYoKTsKKyAgICB7CisgICAgICAgIEpTTG9ja0hvbGRlciBsb2NrZXIodm0p OworICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDB1KTsKKyAgICAg ICAgeworICAgICAgICAgICAgUHJvcGVydHlTbG90IHNsb3QoanNVbmRlZmluZWQoKSwgUHJvcGVy dHlTbG90OjpJbnRlcm5hbE1ldGhvZFR5cGU6OkdldCk7CisgICAgICAgICAgICBFWFBFQ1RfRkFM U0UoISFzbG90LmRpc2FsbG93Vk1FbnRyeSk7CisgICAgICAgICAgICBFWFBFQ1RfRVEodm0uZGlz YWxsb3dWTUVudHJ5Q291bnQsIDB1KTsKKyAgICAgICAgfQorICAgICAgICBFWFBFQ1RfRVEodm0u ZGlzYWxsb3dWTUVudHJ5Q291bnQsIDB1KTsKKyAgICAgICAgeworICAgICAgICAgICAgUHJvcGVy dHlTbG90IHNsb3QoanNVbmRlZmluZWQoKSwgUHJvcGVydHlTbG90OjpJbnRlcm5hbE1ldGhvZFR5 cGU6Okhhc1Byb3BlcnR5KTsKKyAgICAgICAgICAgIEVYUEVDVF9GQUxTRSghIXNsb3QuZGlzYWxs b3dWTUVudHJ5KTsKKyAgICAgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3Vu dCwgMHUpOworICAgICAgICB9CisgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlD b3VudCwgMHUpOworICAgICAgICB7CisgICAgICAgICAgICBQcm9wZXJ0eVNsb3Qgc2xvdChqc1Vu ZGVmaW5lZCgpLCBQcm9wZXJ0eVNsb3Q6OkludGVybmFsTWV0aG9kVHlwZTo6R2V0T3duUHJvcGVy dHkpOworICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKCEhc2xvdC5kaXNhbGxvd1ZNRW50cnkpOwor ICAgICAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAwdSk7CisgICAg ICAgIH0KKyAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAwdSk7Cisg ICAgICAgIHsKKyAgICAgICAgICAgIFByb3BlcnR5U2xvdCBzbG90KGpzVW5kZWZpbmVkKCksIFBy b3BlcnR5U2xvdDo6SW50ZXJuYWxNZXRob2RUeXBlOjpWTUlucXVpcnksICZ2bSk7CisgICAgICAg ICAgICBFWFBFQ1RfVFJVRSghIXNsb3QuZGlzYWxsb3dWTUVudHJ5KTsKKyAgICAgICAgICAgIEVY UEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMXUpOworICAgICAgICB9CisgICAgICAg IEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUpOworICAgIH0KK30KKworVEVT VChKYXZhU2NyaXB0Q29yZV9Qcm9wZXJ0eVNsb3QsIFZNSW5xdWlyeVJlc2V0KQoreworICAgIFdU Rjo6aW5pdGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICBKU0M6OmluaXRpYWxpemUoKTsKKworICAg IFZNJiB2bSA9IFZNOjpjcmVhdGUoTGFyZ2VIZWFwKS5sZWFrUmVmKCk7CisgICAgeworICAgICAg ICBKU0xvY2tIb2xkZXIgbG9ja2VyKHZtKTsKKyAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93 Vk1FbnRyeUNvdW50LCAwdSk7CisKKyAgICAgICAgeworICAgICAgICAgICAgUHJvcGVydHlTbG90 IHNsb3QoanNVbmRlZmluZWQoKSwgUHJvcGVydHlTbG90OjpJbnRlcm5hbE1ldGhvZFR5cGU6OlZN SW5xdWlyeSwgJnZtKTsKKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKCEhc2xvdC5kaXNhbGxvd1ZN RW50cnkpOworICAgICAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAx dSk7CisKKyAgICAgICAgICAgIHNsb3QuZGlzYWxsb3dWTUVudHJ5LnJlc2V0KCk7CisgICAgICAg ICAgICBFWFBFQ1RfRkFMU0UoISFzbG90LmRpc2FsbG93Vk1FbnRyeSk7CisgICAgICAgICAgICBF WFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDB1KTsKKyAgICAgICAgfQorCisgICAg ICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUpOworICAgIH0KK30KKwor VEVTVChKYXZhU2NyaXB0Q29yZV9Qcm9wZXJ0eVNsb3QsIENvcHlBc3NpZ25tZW50KQoreworICAg IFdURjo6aW5pdGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICBKU0M6OmluaXRpYWxpemUoKTsKKwor ICAgIFZNJiB2bSA9IFZNOjpjcmVhdGUoTGFyZ2VIZWFwKS5sZWFrUmVmKCk7CisgICAgeworICAg ICAgICBKU0xvY2tIb2xkZXIgbG9ja2VyKHZtKTsKKyAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2Fs bG93Vk1FbnRyeUNvdW50LCAwdSk7CisKKyAgICAgICAgeworICAgICAgICAgICAgUHJvcGVydHlT bG90IHNsb3QoanNVbmRlZmluZWQoKSwgUHJvcGVydHlTbG90OjpJbnRlcm5hbE1ldGhvZFR5cGU6 OkdldCk7CisgICAgICAgICAgICBFWFBFQ1RfRkFMU0Uoc2xvdC5pc1ZNSW5xdWlyeSgpKTsKKyAg ICAgICAgICAgIEVYUEVDVF9GQUxTRSghIXNsb3QuZGlzYWxsb3dWTUVudHJ5KTsKKyAgICAgICAg ICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMHUpOworCisgICAgICAgICAg ICB7CisgICAgICAgICAgICAgICAgUHJvcGVydHlTbG90IHNsb3QyID0gc2xvdDsKKyAgICAgICAg ICAgICAgICBFWFBFQ1RfRkFMU0Uoc2xvdC5pc1ZNSW5xdWlyeSgpKTsKKyAgICAgICAgICAgICAg ICBFWFBFQ1RfRkFMU0UoISFzbG90LmRpc2FsbG93Vk1FbnRyeSk7CisgICAgICAgICAgICAgICAg RVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAwdSk7CisKKyAgICAgICAgICAgICAg ICBzbG90ID0gc2xvdDI7CisgICAgICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKHNsb3QuaXNWTUlu cXVpcnkoKSk7CisgICAgICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKCEhc2xvdC5kaXNhbGxvd1ZN RW50cnkpOworICAgICAgICAgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3Vu dCwgMHUpOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICBFWFBFQ1RfRkFMU0Uoc2xvdC5p c1ZNSW5xdWlyeSgpKTsKKyAgICAgICAgICAgIEVYUEVDVF9GQUxTRSghIXNsb3QuZGlzYWxsb3dW TUVudHJ5KTsKKyAgICAgICAgICAgIEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwg MHUpOworICAgICAgICB9CisKKyAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNv dW50LCAwdSk7CisKKyAgICAgICAgeworICAgICAgICAgICAgUHJvcGVydHlTbG90IHNsb3QoanNV bmRlZmluZWQoKSwgUHJvcGVydHlTbG90OjpJbnRlcm5hbE1ldGhvZFR5cGU6OlZNSW5xdWlyeSwg JnZtKTsKKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKHNsb3QuaXNWTUlucXVpcnkoKSk7CisgICAg ICAgICAgICBFWFBFQ1RfVFJVRSghIXNsb3QuZGlzYWxsb3dWTUVudHJ5KTsKKyAgICAgICAgICAg IEVYUEVDVF9FUSh2bS5kaXNhbGxvd1ZNRW50cnlDb3VudCwgMXUpOworCisgICAgICAgICAgICB7 CisgICAgICAgICAgICAgICAgUHJvcGVydHlTbG90IHNsb3QyID0gc2xvdDsKKyAgICAgICAgICAg ICAgICBFWFBFQ1RfVFJVRShzbG90Mi5pc1ZNSW5xdWlyeSgpKTsKKyAgICAgICAgICAgICAgICBF WFBFQ1RfVFJVRSghIXNsb3QyLmRpc2FsbG93Vk1FbnRyeSk7CisgICAgICAgICAgICAgICAgRVhQ RUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAydSk7CisKKyAgICAgICAgICAgICAgICBz bG90ID0gc2xvdDI7CisgICAgICAgICAgICAgICAgRVhQRUNUX1RSVUUoc2xvdC5pc1ZNSW5xdWly eSgpKTsKKyAgICAgICAgICAgICAgICBFWFBFQ1RfVFJVRSghIXNsb3QuZGlzYWxsb3dWTUVudHJ5 KTsKKyAgICAgICAgICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDJ1 KTsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgRVhQRUNUX1RSVUUoc2xvdC5pc1ZNSW5x dWlyeSgpKTsKKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKCEhc2xvdC5kaXNhbGxvd1ZNRW50cnkp OworICAgICAgICAgICAgRVhQRUNUX0VRKHZtLmRpc2FsbG93Vk1FbnRyeUNvdW50LCAxdSk7Cisg ICAgICAgIH0KKworICAgICAgICBFWFBFQ1RfRVEodm0uZGlzYWxsb3dWTUVudHJ5Q291bnQsIDB1 KTsKKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkK