193016 2018-12-23 15:11:26 -0800 Leak of CMSampleBuffer (752 bytes) in com.apple.WebKit.WebContent running WebKit layout tests 2019-01-02 22:43:12 -0800 1 1 1 Unclassified WebKit Media WebKit Local Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 ddkilzer ddkilzer andersca darin dbates eric.carlson ews-watchlist jer.noble mitz simon.fraser webkit-bug-importer oldest_to_newest 1490669 0 ddkilzer 2018-12-23 15:11:26 -0800 Leak of CMSampleBuffer (752 bytes) in com.apple.WebKit.WebContent running WebKit layout tests. $ ./Tools/Scripts/run-webkit-tests --no-build --debug --batch-size=1000 --child-processes=1 --verbose --leaks --no-retry --no-show-results imported/w3c/web-platform-tests/mediacapture-record/MediaRecorder-destroy-script-execution.html NOTE: Requires changes to run-webkit-tests to support --leaks with WebKit2. STACK OF 1 INSTANCE OF 'ROOT LEAK: <CMSampleBuffer>': [thread 0x1096575c0]: 23 libdyld.dylib 0x7fff6611008d start + 1 22 com.apple.WebKit.WebContent 0x100de77bb invocation function for block in WebKit::XPCServiceEventHandler(NSObject<OS_xpc_object>*) + 0 XPCServiceMain.mm:46 21 com.apple.WebKit.WebContent 0x100de7636 WebKit::XPCServiceMain(int, char const**) + 547 XPCServiceMain.mm:0 20 libxpc.dylib 0x7fff663469e5 _xpc_copy_xpcservice_dictionary + 0 19 libxpc.dylib 0x7fff66346ee6 _xpc_objc_main + 555 18 com.apple.Foundation 0x7fff3b21b28f -[NSRunLoop(NSRunLoop) run] + 76 17 com.apple.Foundation 0x7fff3b21b3ba -[NSRunLoop(NSRunLoop) runMode:beforeDate:] + 280 16 com.apple.CoreFoundation 0x7fff38e96be6 CFRunLoopRunSpecific + 467 15 com.apple.CoreFoundation 0x7fff38e976c4 __CFRunLoopRun + 2187 14 com.apple.CoreFoundation 0x7fff38eb611d __CFRunLoopDoTimers + 333 13 com.apple.CoreFoundation 0x7fff38eb65e8 __CFRunLoopDoTimer + 871 12 com.apple.CoreFoundation 0x7fff38eb6a35 __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__ + 20 11 com.apple.JavaScriptCore 0x10651ffcf WTF::timerFired(__CFRunLoopTimer*, void*) + 31 MainThreadCocoa.mm:110 10 com.apple.JavaScriptCore 0x10651f239 WTF::dispatchFunctionsFromMainThread() + 249 memory:2597 9 com.apple.WebCore 0x102bf6c38 WTF::Function<void ()>::CallableWrapper<WebCore::CanvasCaptureMediaStreamTrack::Source::create(WebCore::HTMLCanvasElement&, std::optional<double>&&)::$_4>::call() + 88 utility:896 8 com.apple.WebCore 0x10354819b WebCore::RealtimeMediaSource::videoSampleAvailable(WebCore::MediaSample&) + 59 memory:2285 7 com.apple.WebCore 0x103547fc7 WebCore::RealtimeMediaSource::forEachObserver(WTF::Function<void (WebCore::RealtimeMediaSource::Observer&)> const&) const + 663 Atomics.h:247 6 com.apple.WebCore 0x103544a66 WebCore::MediaStreamTrackPrivate::videoSampleAvailable(WebCore::MediaSample&) + 182 memory:2285 5 com.apple.WebCore 0x1035443a7 WebCore::MediaStreamTrackPrivate::forEachObserver(WTF::Function<void (WebCore::MediaStreamTrackPrivate::Observer&)> const&) const + 663 Atomics.h:247 4 com.apple.WebCore 0x1026813eb WebCore::MediaRecorderPrivateWriter::appendVideoSampleBuffer(opaqueCMSampleBuffer*) + 603 MediaRecorderPrivateWriterCocoa.mm:215 3 com.apple.CoreMedia 0x7fff3a01fb35 CMSampleBufferCreateCopyWithNewTiming + 296 2 com.apple.CoreMedia 0x7fff39fefb59 sBufCreate + 140 1 com.apple.CoreFoundation 0x7fff38e5fc70 _CFRuntimeCreateInstance + 271 0 libsystem_malloc.dylib 0x7fff662bd82b malloc_zone_malloc + 139 ==== 9 (752 bytes) ROOT LEAK: <CMSampleBuffer 0x7ffa39529f50> [432] 4 (176 bytes) <CMFormatDescription 0x7ffa39522a90> [48] 3 (128 bytes) <CFDictionary 0x7ffa39529820> [64] 1 (32 bytes) <CFDictionary (Key Storage) 0x7ffa39525b90> [32] 1 (32 bytes) <CFDictionary (Value Storage) 0x7ffa395250f0> [32] 4 (144 bytes) <NSArray 0x7ffa3951efc0> [16] 3 (128 bytes) __strong _object --> <CFDictionary 0x7ffa39520f30> [64] 1 (32 bytes) <CFDictionary (Key Storage) 0x7ffa39520000> [32] 1 (32 bytes) <CFDictionary (Value Storage) 0x7ffa3951cb40> [32] 1490670 1 ddkilzer 2018-12-23 15:11:36 -0800 <rdar://problem/46925703> 1490671 2 358031 ddkilzer 2018-12-23 15:15:38 -0800 Created attachment 358031 Patch v1 1490672 3 ews-watchlist 2018-12-23 15:18:10 -0800 Attachment 358031 did not pass style-queue: ERROR: Source/WTF/wtf/RetainPtr.h:153: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] ERROR: Source/WTF/wtf/RetainPtr.h:159: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] Total errors found: 2 in 8 files If any of these errors are false positives, please file a bug against check-webkit-style. 1490674 4 358031 ddkilzer 2018-12-23 15:23:56 -0800 Comment on attachment 358031 Patch v1 View in context: https://bugs.webkit.org/attachment.cgi?id=358031&action=review > Source/WTF/wtf/RetainPtr.h:96 > + PtrHandleType handle() { return fromStorageHandleType<PtrHandleType>(&m_ptr); } I'm most interested in feedback on this approach of exposing RetainPtr<>::m_ptr so that it can be set by out parameters directly to avoid all the extra stack variable normally required to put an out parameter into a RetainPtr<>: CMSampleBufferRef rawNewBuffer; OSStatus error = CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, originalBuffer, count, timeInfo.data(), &rawNewBuffer); if (error) return; RetainPtr<CMSampleBufferRef> newBuffer = adoptCF(rawNewBuffer); Versus: RetainPtr<CMSampleBufferRef> newBuffer; OSStatus error = CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, originalBuffer, count, timeInfo.data(), newBuffer.handle()); if (error) return nullptr; 1490678 5 358032 ddkilzer 2018-12-23 16:50:13 -0800 Created attachment 358032 Patch v2 Fix style warnings. 1490694 6 358032 ddkilzer 2018-12-24 04:18:58 -0800 Comment on attachment 358032 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=358032&action=review > Source/WTF/wtf/RetainPtr.h:162 > + template<typename U, typename std::enable_if<!std::is_const<typename std::remove_pointer<typename std::remove_pointer<U>::type>::type>::value, int>::type = 0> > + U fromStorageHandleType(StorageType* handle) > + { > + return reinterpret_cast<U>(const_cast<void**>(handle)); Casting through `void**` is not allowed in ARC: In file included from Tools/TestWebKitAPI/Tests/WTF/ns/RetainPtr.mm:31: $BUILD_DIR/Release/usr/local/include/wtf/RetainPtr.h:162:16: error: cast of a non-Objective-C pointer type 'void **' to 'NSString *__strong *' is disallowed with ARC return reinterpret_cast<U>(const_cast<void**>(handle)); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Also, while there are warnings with ARC for passing an `NSObject * __strong *` as a parameter with type `NSObject * __autoreleasing *`, there are no warnings in MRR. However, that mistake is easy to make without RetainPtr<>::handle(), so making handle() available for NSObjects still seems beneficial in the long run (assuming ARC is enabled for all of WebKit). 1490697 7 358032 ddkilzer 2018-12-24 04:44:18 -0800 Comment on attachment 358032 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=358032&action=review > Source/WTF/wtf/RetainPtr.h:70 > typedef CFTypeRef StorageType; Continuing from my comment about `const_cast<void**>` below: The fundamental problem may be that we're defining StorageType for NS object types as `CFTypeRef` (which is `const void*`) rather than `id`. That could be fixed by doing something like this, then fixing the fallout of the now-unnecessary casts when compiling with MRR and ARC: #ifdef __OBJC__ typedef typename std::conditional<std::is_convertible<U, id>::value, id, CFTypeRef>::type StorageType; #else typedef CFTypeRef StorageType; #endif 1490706 8 358032 ddkilzer 2018-12-24 07:54:22 -0800 Comment on attachment 358032 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=358032&action=review >> Source/WTF/wtf/RetainPtr.h:70 >> typedef CFTypeRef StorageType; > > Continuing from my comment about `const_cast<void**>` below: > > The fundamental problem may be that we're defining StorageType for NS object types as `CFTypeRef` (which is `const void*`) rather than `id`. > > That could be fixed by doing something like this, then fixing the fallout of the now-unnecessary casts when compiling with MRR and ARC: > > #ifdef __OBJC__ > typedef typename std::conditional<std::is_convertible<U, id>::value, id, CFTypeRef>::type StorageType; > #else > typedef CFTypeRef StorageType; > #endif Of course, RetainPtr<> really isn't needed with ARC, so the use of CFTypeRef now is really just a way to control the retain/release calls without ARC doing its automatic thing. I think it would be best to expose handle() as handleCF() and not provide the same feature for NS objects unless there is a compelling use case. 1490716 9 dbates 2018-12-24 12:09:39 -0800 (In reply to David Kilzer (:ddkilzer) from comment #8) > I think it would be best to expose handle() as handleCF() and not provide > the same feature for NS objects unless there is a compelling use case. Happy Holidays, Dave! I understand your motivation for this patch. I have an alternative strategy (at the end). I am not in favor of exposing a handle()/handleCF() because I feel it makes using RetainPtr more error prone. Here is my contrived (for simplicity) counter example: class A { public: ... void update() { // Code that sets up originalBuffer, count and timeInfo, but does not touch m_buffer. CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, originalBuffer, count, timeInfo.data(), m_buffer.handle()); } ... private RetainPtr<...> m_buffer; }; Suppose there is driver code as follows: A anA; anA.update(); ... anA.someOtherOperation(); ... anA.update(); Do you see the bug? In A::update() we need to have a line analogous to "m_buffer = nullptr;" or we will leak m_buffer on the second call to A::update(). Whenever dealing with C API I tend to find the strategy of extracting the C code into its own function or object that works nicely with the C++ runtime a good approach. This is what you were doing when you changed the return type for copySampleBufferWithCurrentTimeStamp(). The side effect is that the implementation of copySampleBufferWithCurrentTimeStamp() will be ugly, but that seems acceptable so that call sites of copySampleBufferWithCurrentTimeStamp() are easier to read and less error prone. If you desire you can simply repeat this approach until copySampleBufferWithCurrentTimeStamp() is to your liking...extract the code for CMSampleBufferCreateCopyWithNewTiming() into a new helper function h that returns a RetainPtr<CMSampleBufferRef> and have copySampleBufferWithCurrentTimeStamp() call h. 1490717 10 dbates 2018-12-24 12:26:01 -0800 If you were still interested in pursuing a handleCF() then I would consider naming it something scary (in the same vein as leakRef()). 1490941 11 ddkilzer 2018-12-28 10:15:29 -0800 (In reply to Daniel Bates from comment #9) > (In reply to David Kilzer (:ddkilzer) from comment #8) > > I think it would be best to expose handle() as handleCF() and not provide > > the same feature for NS objects unless there is a compelling use case. > > Happy Holidays, Dave! Thanks Dan! Hope you're able to disconnect. (I've failed so badly at disconnecting that I am writing C++ template code!) > I understand your motivation for this patch. I have an alternative strategy > (at the end). I am not in favor of exposing a handle()/handleCF() because I > feel it makes using RetainPtr more error prone. Here is my contrived (for > simplicity) counter example: > > class A { > public: > ... > void update() > { > // Code that sets up originalBuffer, count and timeInfo, but does > not touch m_buffer. > CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, > originalBuffer, count, timeInfo.data(), m_buffer.handle()); > } > ... > private > RetainPtr<...> m_buffer; > }; > > Suppose there is driver code as follows: > > A anA; > anA.update(); > ... > anA.someOtherOperation(); > ... > anA.update(); > > Do you see the bug? In A::update() we need to have a line analogous to > "m_buffer = nullptr;" or we will leak m_buffer on the second call to > A::update(). Very good point that I didn't consider when originally writing handleCF(). In thinking about this problem the last couple of days, I realized that I could check if m_ptr is not nullptr, then release it each time handleCF() is called, and maybe add a Debug assertion. However, my "simple" idea now has side-effects, so I'm not really sold on it anymore. > Whenever dealing with C API I tend to find the strategy of extracting the C > code into its own function or object that works nicely with the C++ runtime > a good approach. This is what you were doing when you changed the return > type for copySampleBufferWithCurrentTimeStamp(). The side effect is that the > implementation of copySampleBufferWithCurrentTimeStamp() will be ugly, but > that seems acceptable so that call sites of > copySampleBufferWithCurrentTimeStamp() are easier to read and less error > prone. If you desire you can simply repeat this approach until > copySampleBufferWithCurrentTimeStamp() is to your liking...extract the code > for CMSampleBufferCreateCopyWithNewTiming() into a new helper function h > that returns a RetainPtr<CMSampleBufferRef> and have > copySampleBufferWithCurrentTimeStamp() call h. I agree. (I really need that "extract a method" refactoring tool now! :) (In reply to Daniel Bates from comment #10) > If you were still interested in pursuing a handleCF() then I would consider > naming it something scary (in the same vein as leakRef()). Agreed. I should have mentioned that handleCF() was more of a working name. I also experimented with retainedOutParamCF(), but probably should put something to denote a raw pointer. Also wanted to keep it shorter, though! 1491020 12 358146 ddkilzer 2018-12-29 21:07:35 -0800 Created attachment 358146 Patch v3 - Removed RetainPtr<>::handleCF() changes and went with static helper methods per Dan's suggestion. - Adding RetainPtr.cpp to TestWTFLibrary is now in patch for Bug 193056. 1491172 13 358146 simon.fraser 2019-01-02 11:00:57 -0800 Comment on attachment 358146 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=358146&action=review > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:199 > +static inline RetainPtr<CMSampleBufferRef> copySampleBufferWithCurrentTimeStamp(CMSampleBufferRef originalBuffer) Maybe this shouldn't have 'copy' in the name now that it returns a RetainPtr<> > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:259 > + m_videoBufferPool.append(bufferWithCurrentTime); WTFMove()? > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:264 > + auto& basicDescription = *WTF::get<const AudioStreamBasicDescription*>(description.platformDescription().description); Why get basicDescription as a reference and then turn it back into a pointer two lines later? > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:328 > + m_audioBufferPool.append(sampleBuffer); WTFMove()? 1491298 14 358146 eric.carlson 2019-01-02 15:44:33 -0800 Comment on attachment 358146 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=358146&action=review > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:214 > + OSStatus error = CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, originalBuffer, count, timeInfo.data(), &newBuffer); Nit: s/OSStatus/auto/ > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:266 > + OSStatus error = CMAudioFormatDescriptionCreate(kCFAllocatorDefault, &basicDescription, 0, NULL, 0, NULL, NULL, &format); Ditto. > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:276 > + OSStatus error = CMAudioSampleBufferCreateWithPacketDescriptions(kCFAllocatorDefault, NULL, false, NULL, NULL, format, sampleCount, startTime, NULL, &sampleBuffer); Ditto. > Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:323 > + OSStatus error = CMSampleBufferSetDataBufferFromAudioBufferList(sampleBuffer.get(), kCFAllocatorDefault, kCFAllocatorDefault, 0, downcast<WebAudioBufferList>(data).list()); Ditto. 1491378 15 358146 ddkilzer 2019-01-02 22:06:59 -0800 Comment on attachment 358146 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=358146&action=review >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:199 >> +static inline RetainPtr<CMSampleBufferRef> copySampleBufferWithCurrentTimeStamp(CMSampleBufferRef originalBuffer) > > Maybe this shouldn't have 'copy' in the name now that it returns a RetainPtr<> It's still copying it and returning a +1 retained CMSampleBufferRef--it's just in a leak-proof container now. :) >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:214 >> + OSStatus error = CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, originalBuffer, count, timeInfo.data(), &newBuffer); > > Nit: s/OSStatus/auto/ Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:259 >> + m_videoBufferPool.append(bufferWithCurrentTime); > > WTFMove()? Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:264 >> + auto& basicDescription = *WTF::get<const AudioStreamBasicDescription*>(description.platformDescription().description); > > Why get basicDescription as a reference and then turn it back into a pointer two lines later? I was focused on preserving the original code when moving it around; didn't notice the inefficiency here. Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:266 >> + OSStatus error = CMAudioFormatDescriptionCreate(kCFAllocatorDefault, &basicDescription, 0, NULL, 0, NULL, NULL, &format); > > Ditto. Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:276 >> + OSStatus error = CMAudioSampleBufferCreateWithPacketDescriptions(kCFAllocatorDefault, NULL, false, NULL, NULL, format, sampleCount, startTime, NULL, &sampleBuffer); > > Ditto. Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:323 >> + OSStatus error = CMSampleBufferSetDataBufferFromAudioBufferList(sampleBuffer.get(), kCFAllocatorDefault, kCFAllocatorDefault, 0, downcast<WebAudioBufferList>(data).list()); > > Ditto. Will fix. >> Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:328 >> + m_audioBufferPool.append(sampleBuffer); > > WTFMove()? Will fix. 1491379 16 ddkilzer 2019-01-02 22:43:12 -0800 Committed r239587: <https://trac.webkit.org/changeset/239587> 358031 2018-12-23 15:15:38 -0800 2018-12-23 16:50:12 -0800 Patch v1 bug-193016-20181223151538.patch text/plain 14987 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjM5MzY3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGJmNDE2NmY2YjFlNWYzMGMwOGU5MmJi NDRiMGY5NDBiMDJmNGM4NmEuLmMxYzZjYTgzMGRiM2Q0NGE0MWRhMDU0MGNmY2I5MjQ3ZGViM2U5 YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMTgtMTItMjMgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBMZWFrIG9mIENNU2FtcGxlQnVmZmVyICg3NTIgYnl0 ZXMpIGluIGNvbS5hcHBsZS5XZWJLaXQuV2ViQ29udGVudCBydW5uaW5nIFdlYktpdCBsYXlvdXQg dGVzdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzE5MzAxNj4KKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzQ2OTI1NzAzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogd3RmL1JldGFpblB0ci5oOgorICAgICAgICAoV1RGOjpSZXRhaW5Q dHI6OmhhbmRsZSk6CisgICAgICAgIC0gQWRkIG1ldGhvZCB0aGF0IGxldHMgdXMgcGFzcyBSZXRh aW5QdHI8Pjo6bV9wdHIgZGlyZWN0bHkgdG8KKyAgICAgICAgICBmdW5jdGlvbnMgdGhhdCBlbXBs b3kgKzEgcmV0YWluZWQgb3V0IHBhcmFtZXRlcnMuCisgICAgICAgIChXVEY6OlJldGFpblB0cjo6 ZnJvbVN0b3JhZ2VIYW5kbGVUeXBlKToKKyAgICAgICAgLSBVc2UgY29uY2VwdCBvZiBTRklOQUUg dG8gZGVjaWRlIHdoZXRoZXIgd2UgbmVlZCBhCisgICAgICAgICAgY29uc3RfY2FzdDx2b2lkKio+ KCkgb3Igbm90IHdoZW4gY2FzdGluZyBTdG9yYWdlVHlwZSogdG8KKyAgICAgICAgICBQdHJIYW5k bGVUeXBlLgorCiAyMDE4LTEyLTEwICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+ CiAKICAgICAgICAgSGFjayB0byBtYWtlIFdlYktpdCBjb21waWxlIHdpdGggVVNFX1NZU1RFTV9N QUxMT0M9MSBvbiBtYWNPUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGZmOTA3NjA1YjY2ZTFlZDBjZWE3NGQ5ODgx YmVjYjc3NGIwYTZiNGIuLjFiYTQyZWEyNGFlMWJhMTYwZGUwZDNlYTk4YjliNDJiZDFmOWQxNjgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAxOC0xMi0yMyAgRGF2aWQgS2lsemVyICA8 ZGRraWx6ZXJAYXBwbGUuY29tPgorCisgICAgICAgIExlYWsgb2YgQ01TYW1wbGVCdWZmZXIgKDc1 MiBieXRlcykgaW4gY29tLmFwcGxlLldlYktpdC5XZWJDb250ZW50IHJ1bm5pbmcgV2ViS2l0IGxh eW91dCB0ZXN0cworICAgICAgICA8aHR0cHM6Ly93ZWJraXQub3JnL2IvMTkzMDE2PgorICAgICAg ICA8cmRhcjovL3Byb2JsZW0vNDY5MjU3MDM+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGVzdDogaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0 cy9tZWRpYWNhcHR1cmUtcmVjb3JkL01lZGlhUmVjb3JkZXItZGVzdHJveS1zY3JpcHQtZXhlY3V0 aW9uLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL21lZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFS ZWNvcmRlclByaXZhdGVXcml0ZXJDb2NvYS5tbToKKyAgICAgICAgKFdlYkNvcmU6OmNvcHlTYW1w bGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcCk6CisgICAgICAgIC0gQ2hhbmdlIHRvIHJldHVy biBSZXRhaW5QdHI8Pi4KKyAgICAgICAgLSBVc2UgUmV0YWluUHRyPD46OmhhbmRsZSgpIHRvIGNh cHR1cmUgKzEgcmV0YWluZWQKKyAgICAgICAgICBDTVNhbXBsZUJ1ZmZlciBvYmplY3QuCisgICAg ICAgIC0gQ2hlY2sgcmV0dXJuIHZhbHVlIG9mIENNU2FtcGxlQnVmZmVyQ3JlYXRlQ29weVdpdGhO ZXdUaW1pbmcoKS4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVy OjphcHBlbmRWaWRlb1NhbXBsZUJ1ZmZlcik6CisgICAgICAgIC0gQ2hlY2sgcmV0dXJuIHZhbHVl IG9mIGNvcHlTYW1wbGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcCgpLgorICAgICAgICAtIEZp eCBsZWFrIGJ5IHVzaW5nIFJldGFpblB0cjw+IHJldHVybmVkIGZyb20KKyAgICAgICAgICBjb3B5 U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoKSBpbnN0ZWFkIG9mIGxlYWtpbmcgcmF3 CisgICAgICAgICAgYnVmZmVyV2l0aEN1cnJlbnRUaW1lIGJ5IGNhbGxpbmcgcmV0YWluUHRyKCkg dnMuIGFkb3B0Q0YoKS4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUmVjb3JkZXJQcml2YXRlV3Jp dGVyOjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZlcik6CisgICAgICAgIC0gQ2hlY2sgcmV0dXJuIHZh bHVlIG9mIENNQXVkaW9Gb3JtYXREZXNjcmlwdGlvbkNyZWF0ZSgpLgorICAgICAgICAtIEZpeCBs ZWFrcyBvZiBib3RoIENNRm9ybWF0RGVzY3JpcHRpb25SZWYgYW5kIENNU2FtcGxlQnVmZmVyUmVm CisgICAgICAgICAgYnkgdXNpbmcgUmV0YWluUHRyPD46OmhhbmRsZSgpIHRvIGNhcHR1cmUgKzEg cmV0YWluZWQgb2JqZWN0cy4KKwogMjAxOC0xMi0xOCAgSnVzdGluIE1pY2hhdWQgIDxqdXN0aW5f bWljaGF1ZEBhcHBsZS5jb20+CiAKICAgICAgICAgVXBkYXRlIENTUyBQcm9wZXJ0aWVzIGFuZCBW YWx1ZXMgQVBJIHRvIHVzZSBuZXcgY3ljbGUgZmFsbGJhY2sgYmVoYXZpb3VyCmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9SZXRhaW5QdHIuaCBiL1NvdXJjZS9XVEYvd3RmL1JldGFpblB0ci5o CmluZGV4IGFhOTZkZWExYWM5NjcwMzFjODA4NGEyYmUxMWE3NmJkNzE3YTk2NzUuLmE1YzBiZjBk ZDllMmFjYTU2M2QzNDYxYTU4Y2ZkN2JlYmY4MmEyOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv d3RmL1JldGFpblB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1JldGFpblB0ci5oCkBAIC02Miw2 ICs2MiwxMSBAQCB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBSZXRhaW5QdHIgewogcHVibGlj OgogICAgIHR5cGVkZWYgdHlwZW5hbWUgc3RkOjpyZW1vdmVfcG9pbnRlcjxUPjo6dHlwZSBWYWx1 ZVR5cGU7CiAgICAgdHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisjaWZkZWYgX19PQkpDX18K KyAgICB0eXBlZGVmIFZhbHVlVHlwZSogX19zdHJvbmcgKiBQdHJIYW5kbGVUeXBlOworI2Vsc2UK KyAgICB0eXBlZGVmIFZhbHVlVHlwZSoqIFB0ckhhbmRsZVR5cGU7CisjZW5kaWYKICAgICB0eXBl ZGVmIENGVHlwZVJlZiBTdG9yYWdlVHlwZTsKIAogICAgIFJldGFpblB0cigpIDogbV9wdHIobnVs bHB0cikgeyB9CkBAIC04OCw2ICs5Myw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAgICAgUHRyVHlw ZSBnZXQoKSBjb25zdCB7IHJldHVybiBmcm9tU3RvcmFnZVR5cGUobV9wdHIpOyB9CisgICAgUHRy SGFuZGxlVHlwZSBoYW5kbGUoKSB7IHJldHVybiBmcm9tU3RvcmFnZUhhbmRsZVR5cGU8UHRySGFu ZGxlVHlwZT4oJm1fcHRyKTsgfQogICAgIFB0clR5cGUgb3BlcmF0b3ItPigpIGNvbnN0IHsgcmV0 dXJuIGZyb21TdG9yYWdlVHlwZShtX3B0cik7IH0KICAgICBleHBsaWNpdCBvcGVyYXRvciBQdHJU eXBlKCkgY29uc3QgeyByZXR1cm4gZnJvbVN0b3JhZ2VUeXBlKG1fcHRyKTsgfQogICAgIGV4cGxp Y2l0IG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiBtX3B0cjsgfQpAQCAtOTcsNyArMTAz LDcgQEAgcHVibGljOgogICAgIC8vIFRoaXMgY29udmVyc2lvbiBvcGVyYXRvciBhbGxvd3MgaW1w bGljaXQgY29udmVyc2lvbiB0byBib29sIGJ1dCBub3QgdG8gb3RoZXIgaW50ZWdlciB0eXBlcy4K ICAgICB0eXBlZGVmIFN0b3JhZ2VUeXBlIFJldGFpblB0cjo6KlVuc3BlY2lmaWVkQm9vbFR5cGU7 CiAgICAgb3BlcmF0b3IgVW5zcGVjaWZpZWRCb29sVHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fcHRy ID8gJlJldGFpblB0cjo6bV9wdHIgOiBudWxscHRyOyB9Ci0gICAgCisKICAgICBSZXRhaW5QdHIm IG9wZXJhdG9yPShjb25zdCBSZXRhaW5QdHImKTsKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBS ZXRhaW5QdHImIG9wZXJhdG9yPShjb25zdCBSZXRhaW5QdHI8VT4mKTsKICAgICBSZXRhaW5QdHIm IG9wZXJhdG9yPShQdHJUeXBlKTsKQEAgLTE0MCw5ICsxNDYsMjIgQEAgcHJpdmF0ZToKICAgICB7 CiAgICAgICAgIHJldHVybiAoUHRyVHlwZSljb25zdF9jYXN0PENGX0JSSURHRURfVFlQRShpZCkg dm9pZCo+KHB0cik7CiAgICAgfQorCiAgICAgU3RvcmFnZVR5cGUgdG9TdG9yYWdlVHlwZShQdHJU eXBlIHB0cikgY29uc3QgeyByZXR1cm4gKFN0b3JhZ2VUeXBlKXB0cjsgfQogI2VuZGlmCiAKKyAg ICB0ZW1wbGF0ZTx0eXBlbmFtZSBVLCB0eXBlbmFtZSBzdGQ6OmVuYWJsZV9pZjxzdGQ6OmlzX2Nv bnN0PHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX3BvaW50ZXI8dHlwZW5hbWUgc3RkOjpyZW1vdmVfcG9p bnRlcjxVPjo6dHlwZT46OnR5cGU+Ojp2YWx1ZSA9PSB0cnVlLCBpbnQ+Ojp0eXBlID0gMD4KKyAg ICBVIGZyb21TdG9yYWdlSGFuZGxlVHlwZShTdG9yYWdlVHlwZSogaGFuZGxlKQorICAgIHsKKyAg ICAgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8VT4oaGFuZGxlKTsKKyAgICB9CisKKyAgICB0 ZW1wbGF0ZTx0eXBlbmFtZSBVLCB0eXBlbmFtZSBzdGQ6OmVuYWJsZV9pZjxzdGQ6OmlzX2NvbnN0 PHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX3BvaW50ZXI8dHlwZW5hbWUgc3RkOjpyZW1vdmVfcG9pbnRl cjxVPjo6dHlwZT46OnR5cGU+Ojp2YWx1ZSA9PSBmYWxzZSwgaW50Pjo6dHlwZSA9IDA+CisgICAg VSBmcm9tU3RvcmFnZUhhbmRsZVR5cGUoU3RvcmFnZVR5cGUqIGhhbmRsZSkKKyAgICB7CisgICAg ICAgIHJldHVybiByZWludGVycHJldF9jYXN0PFU+KGNvbnN0X2Nhc3Q8dm9pZCoqPihoYW5kbGUp KTsKKyAgICB9CisKICNpZmRlZiBfX09CSkNfXwogICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IHN0 ZDo6ZW5hYmxlX2lmX3Q8c3RkOjppc19jb252ZXJ0aWJsZTxVLCBpZD46OnZhbHVlLCBQdHJUeXBl PiBhdXRvcmVsZWFzZUhlbHBlcigpOwogICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IHN0ZDo6ZW5h YmxlX2lmX3Q8IXN0ZDo6aXNfY29udmVydGlibGU8VSwgaWQ+Ojp2YWx1ZSwgUHRyVHlwZT4gYXV0 b3JlbGVhc2VIZWxwZXIoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21l ZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFSZWNvcmRlclByaXZhdGVXcml0ZXJDb2NvYS5tbSBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFSZWNvcmRlclBy aXZhdGVXcml0ZXJDb2NvYS5tbQppbmRleCA1N2FlZWMzMmQ0ZWQyNzUxZTY5YTc2MzUyOWNjZjFh YWVjZjBkOGIwLi40ZjE5ZWQ3OTZmOGRhNzc3NDc2ZDZjZjJkNzA3Y2RlYzkwMGM2NmU1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXJlY29yZGVyL2NvY29hL01lZGlh UmVjb3JkZXJQcml2YXRlV3JpdGVyQ29jb2EubW0KKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vbWVkaWFyZWNvcmRlci9jb2NvYS9NZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlckNvY29hLm1t CkBAIC0xOTYsNyArMTk2LDcgQEAgYm9vbCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6c2V0 QXVkaW9JbnB1dCgpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLXN0YXRpYyBpbmxpbmUgQ01TYW1w bGVCdWZmZXJSZWYgY29weVNhbXBsZUJ1ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKENNU2FtcGxl QnVmZmVyUmVmIG9yaWdpbmFsQnVmZmVyKQorc3RhdGljIGlubGluZSBSZXRhaW5QdHI8Q01TYW1w bGVCdWZmZXJSZWY+IGNvcHlTYW1wbGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcChDTVNhbXBs ZUJ1ZmZlclJlZiBvcmlnaW5hbEJ1ZmZlcikKIHsKICAgICBDTVRpbWUgc3RhcnRUaW1lID0gQ01D bG9ja0dldFRpbWUoQ01DbG9ja0dldEhvc3RUaW1lQ2xvY2soKSk7CiAgICAgQ01JdGVtQ291bnQg Y291bnQgPSAwOwpAQCAtMjEwLDggKzIxMCwxMCBAQCBzdGF0aWMgaW5saW5lIENNU2FtcGxlQnVm ZmVyUmVmIGNvcHlTYW1wbGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcChDTVNhbXBsZUJ1Zgog ICAgICAgICB0aW1lSW5mb1tpXS5wcmVzZW50YXRpb25UaW1lU3RhbXAgPSBzdGFydFRpbWU7CiAg ICAgfQogICAgIAotICAgIENNU2FtcGxlQnVmZmVyUmVmIG5ld0J1ZmZlcjsKLSAgICBDTVNhbXBs ZUJ1ZmZlckNyZWF0ZUNvcHlXaXRoTmV3VGltaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIG9yaWdp bmFsQnVmZmVyLCBjb3VudCwgdGltZUluZm8uZGF0YSgpLCAmbmV3QnVmZmVyKTsKKyAgICBSZXRh aW5QdHI8Q01TYW1wbGVCdWZmZXJSZWY+IG5ld0J1ZmZlcjsKKyAgICBPU1N0YXR1cyBlcnJvciA9 IENNU2FtcGxlQnVmZmVyQ3JlYXRlQ29weVdpdGhOZXdUaW1pbmcoa0NGQWxsb2NhdG9yRGVmYXVs dCwgb3JpZ2luYWxCdWZmZXIsIGNvdW50LCB0aW1lSW5mby5kYXRhKCksIG5ld0J1ZmZlci5oYW5k bGUoKSk7CisgICAgaWYgKGVycm9yKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICByZXR1 cm4gbmV3QnVmZmVyOwogfQogCkBAIC0yNDksOSArMjUxLDExIEBAIHZvaWQgTWVkaWFSZWNvcmRl clByaXZhdGVXcml0ZXI6OmFwcGVuZFZpZGVvU2FtcGxlQnVmZmVyKENNU2FtcGxlQnVmZmVyUmVm IHNhbXBsCiAgICAgICAgIH1dOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIENNU2FtcGxl QnVmZmVyUmVmIGJ1ZmZlcldpdGhDdXJyZW50VGltZSA9IGNvcHlTYW1wbGVCdWZmZXJXaXRoQ3Vy cmVudFRpbWVTdGFtcChzYW1wbGVCdWZmZXIpOworICAgIGF1dG8gYnVmZmVyV2l0aEN1cnJlbnRU aW1lID0gY29weVNhbXBsZUJ1ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKHNhbXBsZUJ1ZmZlcik7 CisgICAgaWYgKCFidWZmZXJXaXRoQ3VycmVudFRpbWUpCisgICAgICAgIHJldHVybjsKICAgICBh dXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fdmlkZW9Mb2NrKTsKLSAgICBtX3ZpZGVvQnVmZmVyUG9v bC5hcHBlbmQocmV0YWluUHRyKGJ1ZmZlcldpdGhDdXJyZW50VGltZSkpOworICAgIG1fdmlkZW9C dWZmZXJQb29sLmFwcGVuZChidWZmZXJXaXRoQ3VycmVudFRpbWUpOwogfQogCiB2b2lkIE1lZGlh UmVjb3JkZXJQcml2YXRlV3JpdGVyOjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZlcihjb25zdCBQbGF0 Zm9ybUF1ZGlvRGF0YSYgZGF0YSwgY29uc3QgQXVkaW9TdHJlYW1EZXNjcmlwdGlvbiYgZGVzY3Jp cHRpb24sIGNvbnN0IFdURjo6TWVkaWFUaW1lJiwgc2l6ZV90IHNhbXBsZUNvdW50KQpAQCAtMjU5 LDExICsyNjMsMTIgQEAgdm9pZCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6YXBwZW5kQXVk aW9TYW1wbGVCdWZmZXIoY29uc3QgUGxhdGZvcm1BdWRpb0RhdGEKICAgICBBU1NFUlQobV9hdWRp b0lucHV0KTsKICAgICBpZiAoKCFtX2hhc1N0YXJ0ZWRXcml0aW5nICYmIG1fdmlkZW9JbnB1dCkg fHwgbV9pc1N0b3BwZWQpCiAgICAgICAgIHJldHVybjsKLSAgICBDTVNhbXBsZUJ1ZmZlclJlZiBz YW1wbGVCdWZmZXI7Ci0gICAgQ01Gb3JtYXREZXNjcmlwdGlvblJlZiBmb3JtYXQ7CisgICAgUmV0 YWluUHRyPENNRm9ybWF0RGVzY3JpcHRpb25SZWY+IGZvcm1hdDsKICAgICBPU1N0YXR1cyBlcnJv cjsKICAgICBhdXRvJiBiYXNpY0Rlc2NyaXB0aW9uID0gKldURjo6Z2V0PGNvbnN0IEF1ZGlvU3Ry ZWFtQmFzaWNEZXNjcmlwdGlvbio+KGRlc2NyaXB0aW9uLnBsYXRmb3JtRGVzY3JpcHRpb24oKS5k ZXNjcmlwdGlvbik7Ci0gICAgZXJyb3IgPSBDTUF1ZGlvRm9ybWF0RGVzY3JpcHRpb25DcmVhdGUo a0NGQWxsb2NhdG9yRGVmYXVsdCwgJmJhc2ljRGVzY3JpcHRpb24sIDAsIE5VTEwsIDAsIE5VTEws IE5VTEwsICZmb3JtYXQpOworICAgIGVycm9yID0gQ01BdWRpb0Zvcm1hdERlc2NyaXB0aW9uQ3Jl YXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsICZiYXNpY0Rlc2NyaXB0aW9uLCAwLCBOVUxMLCAwLCBO VUxMLCBOVUxMLCBmb3JtYXQuaGFuZGxlKCkpOworICAgIGlmIChlcnJvcikKKyAgICAgICAgcmV0 dXJuOwogICAgIGlmIChtX2lzRmlyc3RBdWRpb1NhbXBsZSkgewogICAgICAgICBpZiAoIW1fdmlk ZW9JbnB1dCkgewogICAgICAgICAgICAgLy8gYXVkaW8tb25seSByZWNvcmRpbmcuCkBAIC0yOTUs MTUgKzMwMCwxNiBAQCB2b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjphcHBlbmRBdWRp b1NhbXBsZUJ1ZmZlcihjb25zdCBQbGF0Zm9ybUF1ZGlvRGF0YQogICAgIH0KICAgICBDTVRpbWUg c3RhcnRUaW1lID0gQ01DbG9ja0dldFRpbWUoQ01DbG9ja0dldEhvc3RUaW1lQ2xvY2soKSk7CiAK LSAgICBlcnJvciA9IENNQXVkaW9TYW1wbGVCdWZmZXJDcmVhdGVXaXRoUGFja2V0RGVzY3JpcHRp b25zKGtDRkFsbG9jYXRvckRlZmF1bHQsIE5VTEwsIGZhbHNlLCBOVUxMLCBOVUxMLCBmb3JtYXQs IHNhbXBsZUNvdW50LCBzdGFydFRpbWUsIE5VTEwsICZzYW1wbGVCdWZmZXIpOworICAgIFJldGFp blB0cjxDTVNhbXBsZUJ1ZmZlclJlZj4gc2FtcGxlQnVmZmVyOworICAgIGVycm9yID0gQ01BdWRp b1NhbXBsZUJ1ZmZlckNyZWF0ZVdpdGhQYWNrZXREZXNjcmlwdGlvbnMoa0NGQWxsb2NhdG9yRGVm YXVsdCwgTlVMTCwgZmFsc2UsIE5VTEwsIE5VTEwsIGZvcm1hdC5nZXQoKSwgc2FtcGxlQ291bnQs IHN0YXJ0VGltZSwgTlVMTCwgc2FtcGxlQnVmZmVyLmhhbmRsZSgpKTsKICAgICBpZiAoZXJyb3Ip CiAgICAgICAgIHJldHVybjsKLSAgICBlcnJvciA9IENNU2FtcGxlQnVmZmVyU2V0RGF0YUJ1ZmZl ckZyb21BdWRpb0J1ZmZlckxpc3Qoc2FtcGxlQnVmZmVyLCBrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBr Q0ZBbGxvY2F0b3JEZWZhdWx0LCAwLCBkb3duY2FzdDxXZWJBdWRpb0J1ZmZlckxpc3Q+KGRhdGEp Lmxpc3QoKSk7CisgICAgZXJyb3IgPSBDTVNhbXBsZUJ1ZmZlclNldERhdGFCdWZmZXJGcm9tQXVk aW9CdWZmZXJMaXN0KHNhbXBsZUJ1ZmZlci5nZXQoKSwga0NGQWxsb2NhdG9yRGVmYXVsdCwga0NG QWxsb2NhdG9yRGVmYXVsdCwgMCwgZG93bmNhc3Q8V2ViQXVkaW9CdWZmZXJMaXN0PihkYXRhKS5s aXN0KCkpOwogICAgIGlmIChlcnJvcikKICAgICAgICAgcmV0dXJuOwogCiAgICAgYXV0byBsb2Nr ZXIgPSBob2xkTG9jayhtX2F1ZGlvTG9jayk7Ci0gICAgbV9hdWRpb0J1ZmZlclBvb2wuYXBwZW5k KHJldGFpblB0cihzYW1wbGVCdWZmZXIpKTsKKyAgICBtX2F1ZGlvQnVmZmVyUG9vbC5hcHBlbmQo c2FtcGxlQnVmZmVyKTsKIH0KIAogdm9pZCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6c3Rv cFJlY29yZGluZygpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VM b2cKaW5kZXggN2VhZmNlYzFmMWU0YWVjN2IwYjU2OTVmYmY4ZGYzODI1ZWM0MmIwYi4uOGQ2MmNm YjNjMGFhMmI2ZjEyZmU3NjVkODRiYzVkYTExNDg4MTUzOCAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hh bmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDE4LTEyLTIz ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CisKKyAgICAgICAgTGVhayBvZiBD TVNhbXBsZUJ1ZmZlciAoNzUyIGJ5dGVzKSBpbiBjb20uYXBwbGUuV2ViS2l0LldlYkNvbnRlbnQg cnVubmluZyBXZWJLaXQgbGF5b3V0IHRlc3RzCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcv Yi8xOTMwMTY+CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS80NjkyNTcwMz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAtIEFkZCBtaXNz aW5nIFJldGFpblB0ci5jcHAgdG8gVGVzdFdURiB0YXJnZXQuCisgICAgICAgICogVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvY2YvUmV0YWluUHRyLmNwcDoKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OkNyZWF0ZUNGU3RyaW5nV2l0aE91dFBhcmFtZXRlcik6CisgICAgICAgIC0gQWRkIGhlbHBlciBm dW5jdGlvbi4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAtIEFkZCB0 ZXN0IGZvciBDRlR5cGVSZWYqIG91dCBwYXJhbWV0ZXJzLgorICAgICAgICAqIFRlc3RXZWJLaXRB UEkvVGVzdHMvV1RGL25zL1JldGFpblB0ci5tbToKKyAgICAgICAgKCtbTXlDbGFzcyBuZXdOU1N0 cmluZ1dpdGhPdXRQYXJhbWV0ZXI6XSk6CisgICAgICAgIC0gQWRkIGhlbHBlciBjbGFzcyBtZXRo b2QuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKyAgICAgICAgLSBBZGQgdGVzdCBm b3IgTlNPYmplY3QgKiogb3V0IHBhcmFtZXRlcnMuCisKIDIwMTgtMTItMDcgIERhdmlkIEtpbHpl ciAgPGRka2lsemVyQGFwcGxlLmNvbT4KIAogICAgICAgICBJZ25vcmUgZmFsc2UtcG9zaXRpdmUg bGVha3MgdW5kZXIgYm1hbGxvYzo6SGVhcDo6SGVhcApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRl eCA3ZThlZDNiZTUxNDg0MzA4ZTBkOGExYTliNzhiYTM1OGVmZjU1NGE1Li4wOWZiNzdhYmJiOTg2 YWVhYjM0MDU4YzczNzE3OTQyZWNmMGY4OWQxIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAt MTcwLDYgKzE3MCw3IEBACiAJCTQ0MzNBMzk2MjA4MDQ0MTQwMDkxRUQ1NyAvKiBTeW5jaHJvbm91 c1RpbWVvdXRUZXN0cy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ0MzNBMzk1MjA4MDQ0MTMwMDkxRUQ1NyAvKiBTeW5jaHJvbm91c1RpbWVvdXRUZXN0 cy5tbSAqLzsgfTsKIAkJNDQ4MTdBMkYxRjA0ODZCRjAwMDAzODEwIC8qIFdLUmVxdWVzdEFjdGl2 YXRlZEVsZW1lbnRJbmZvLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNDQ4MTdBMkUxRjA0ODZCRjAwMDAzODEwIC8qIFdLUmVxdWVzdEFjdGl2YXRlZEVs ZW1lbnRJbmZvLm1tICovOyB9OwogCQk0NDhEN0U0NzFFQTZDNTU1MDBFQ0M3NTYgLyogRW52aXJv bm1lbnRVdGlsaXRpZXNUZXN0LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDQ0OEQ3RTQ1MUVBNkM1NTUwMEVDQzc1NiAvKiBFbnZpcm9ubWVudFV0aWxp dGllc1Rlc3QuY3BwICovOyB9OworCQk0NEFDOEJDNjIxRDAyNDVBMDBDQUZCMzQgLyogUmV0YWlu UHRyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEJD MDI5QjE2MTQ4NkFENjQwMDgxN0RBOSAvKiBSZXRhaW5QdHIuY3BwICovOyB9OwogCQk0NjEyQzJC OTIxMEE2QUNFMDBCNzg4QTYgLyogTG9hZEZpbGVUaGVuUmVsb2FkLm1tIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDYxMkMyQjgyMTBBNkFCRjAwQjc4OEE2 IC8qIExvYWRGaWxlVGhlblJlbG9hZC5tbSAqLzsgfTsKIAkJNDYzOTdCOTUxREMyQzg1MDAwOUE3 OEFFIC8qIERPTU5vZGUubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA0NjM5N0I5NDFEQzJDODUwMDA5QTc4QUUgLyogRE9NTm9kZS5tbSAqLzsgfTsKIAkJ NDY0N0IxMjYxRUJBM0I4NTAwNDFEN0VGIC8qIFByb2Nlc3NEaWRUZXJtaW5hdGUuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDY0N0IxMjUxRUJBM0I3 MzAwNDFEN0VGIC8qIFByb2Nlc3NEaWRUZXJtaW5hdGUuY3BwICovOyB9OwpAQCAtMzc3NSw2ICsz Nzc2LDcgQEAKIAkJCQk3QzgzREYxNTFEMEE1OTBDMDBGRUJDRjMgLyogUmVmQ291bnRlci5jcHAg aW4gU291cmNlcyAqLywKIAkJCQk3QzgzREVENzFEMEE1OTBDMDBGRUJDRjMgLyogUmVmTG9nZ2Vy LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjE2MUQwQTU5MEMwMEZFQkNGMyAvKiBSZWZQ dHIuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNDRBQzhCQzYyMUQwMjQ1QTAwQ0FGQjM0IC8qIFJl dGFpblB0ci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3QzgzREYyNDFEMEE1OTBDMDBGRUJDRjMg LyogUmV0YWluUHRyLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0M4M0RGMDUxRDBBNTkwQzAwRkVC Q0YzIC8qIFJ1bkxvb3AuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0M4M0RGMjYxRDBBNTkwQzAw RkVCQ0YzIC8qIFNhdHVyYXRlZEFyaXRobWV0aWNPcGVyYXRpb25zLmNwcCBpbiBTb3VyY2VzICov LApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvY2YvUmV0YWluUHRy LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL2NmL1JldGFpblB0ci5jcHAKaW5k ZXggMDAzM2YzYjhiYzY4OWIyNzFlZDA2NGQ0NzhiOGI2YjY3NTI0NzA4NS4uMjcwODkxYTVhYTEy YTg5ODJhMWUxZDU3OGUzZDE0NjAwYWFhN2ZjMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvY2YvUmV0YWluUHRyLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dURi9jZi9SZXRhaW5QdHIuY3BwCkBAIC0zMiw2ICszMiwxOSBAQAogCiBuYW1lc3Bh Y2UgVGVzdFdlYktpdEFQSSB7CiAKK2Jvb2wgQ3JlYXRlQ0ZTdHJpbmdXaXRoT3V0UGFyYW1ldGVy KENGU3RyaW5nUmVmKiBjZlN0cmluZ0hhbmRsZSkKK3sKKyAgICBpZiAoIWNmU3RyaW5nSGFuZGxl KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBDRlN0cmluZ1JlZiBjZlN0cmluZyA9IENG U3RyaW5nQ3JlYXRlV2l0aENTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgX19QUkVUVFlfRlVO Q1RJT05fXywga0NGU3RyaW5nRW5jb2RpbmdJU09MYXRpbjEpOworICAgIGlmICghY2ZTdHJpbmcp CisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICpjZlN0cmluZ0hhbmRsZSA9IGNmU3RyaW5n OworICAgIHJldHVybiB0cnVlOworfQorCiBURVNUKFJldGFpblB0ciwgQWRvcHRDRikKIHsKICAg ICBSZXRhaW5QdHI8Q0ZBcnJheVJlZj4gZm9vID0gYWRvcHRDRihDRkFycmF5Q3JlYXRlKGtDRkFs bG9jYXRvckRlZmF1bHQsIG51bGxwdHIsIDAsIG51bGxwdHIpKTsKQEAgLTM5LDQgKzUyLDE0IEBA IFRFU1QoUmV0YWluUHRyLCBBZG9wdENGKQogICAgIEVYUEVDVF9FUSgxLCBDRkdldFJldGFpbkNv dW50KGZvby5nZXQoKSkpOwogfQogCitURVNUKFJldGFpblB0ciwgT3V0UGFyYW1ldGVyQ0YpCit7 CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBzdHJpbmc7CisgICAgYm9vbCByZXN1bHQgPSBD cmVhdGVDRlN0cmluZ1dpdGhPdXRQYXJhbWV0ZXIoc3RyaW5nLmhhbmRsZSgpKTsKKworICAgIEVY UEVDVF9UUlVFKHJlc3VsdCk7CisgICAgRVhQRUNUX1RSVUUoc3RyaW5nLmdldCgpKTsKKyAgICBF WFBFQ1RfRVEoMSwgQ0ZHZXRSZXRhaW5Db3VudChzdHJpbmcuZ2V0KCkpKTsKK30KKwogfSAvLyBu YW1lc3BhY2UgVGVzdFdlYktpdEFQSQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XVEYvbnMvUmV0YWluUHRyLm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYv bnMvUmV0YWluUHRyLm1tCmluZGV4IGY5MjVjZTdjZjk1OTM1MDE2ZDUzZWE2MzAxODJhMWQxODIw NTk3ZmMuLjhiYzAzODE0OTNmZmRkNjVhNzcyYjNmMWJiZjM3OTY1YWYwY2U3M2UgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL25zL1JldGFpblB0ci5tbQorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9ucy9SZXRhaW5QdHIubW0KQEAgLTMwLDYgKzMw LDI1IEBACiAKICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CiAKK0BpbnRlcmZhY2UgTXlDbGFz cyA6IE5TT2JqZWN0CisrIChCT09MKW5ld05TU3RyaW5nV2l0aE91dFBhcmFtZXRlcjooTlNTdHJp bmcgKiBfX3N0cm9uZyAqKW5zU3RyaW5nSGFuZGxlOworQGVuZAorCitAaW1wbGVtZW50YXRpb24g TXlDbGFzcworKyAoQk9PTCluZXdOU1N0cmluZ1dpdGhPdXRQYXJhbWV0ZXI6KE5TU3RyaW5nICog X19zdHJvbmcgKiluc1N0cmluZ0hhbmRsZQoreworICAgIGlmICghbnNTdHJpbmdIYW5kbGUpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIE5TU3RyaW5nICpuc1N0cmluZyA9IFtbTlNTdHJp bmcgYWxsb2NdIGluaXRXaXRoVVRGOFN0cmluZzpfX1BSRVRUWV9GVU5DVElPTl9fXTsKKyAgICBp ZiAoIW5zU3RyaW5nKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAqbnNTdHJpbmdIYW5k bGUgPSBuc1N0cmluZzsKKyAgICByZXR1cm4gdHJ1ZTsKK30KK0BlbmQKKwogbmFtZXNwYWNlIFRl c3RXZWJLaXRBUEkgewogCiBURVNUKFJldGFpblB0ciwgQWRvcHROUykKQEAgLTEyMyw0ICsxNDIs MTQgQEAgVEVTVChSZXRhaW5QdHIsIENvbnN0cnVjdGlvbkZyb21TaW1pbGFyVHlwZSkKICAgICBF WFBFQ1RfRVEoKE5TU3RyaW5nICopMCwgdGVtcCk7CiB9CiAKK1RFU1QoUmV0YWluUHRyLCBPdXRQ YXJhbWV0ZXJOUykKK3sKKyAgICBSZXRhaW5QdHI8TlNTdHJpbmc+IHN0cmluZzsKKyAgICBib29s IHJlc3VsdCA9IFtNeUNsYXNzIG5ld05TU3RyaW5nV2l0aE91dFBhcmFtZXRlcjpzdHJpbmcuaGFu ZGxlKCldOworCisgICAgRVhQRUNUX1RSVUUocmVzdWx0KTsKKyAgICBFWFBFQ1RfVFJVRShzdHJp bmcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBDRkdldFJldGFpbkNvdW50KChDRlN0cmluZ1Jl ZilzdHJpbmcuZ2V0KCkpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQo= 358032 2018-12-23 16:50:13 -0800 2018-12-29 21:07:34 -0800 Patch v2 bug-193016-20181223165012.patch text/plain 14971 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjM5MzY3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGJmNDE2NmY2YjFlNWYzMGMwOGU5MmJi NDRiMGY5NDBiMDJmNGM4NmEuLmMxYzZjYTgzMGRiM2Q0NGE0MWRhMDU0MGNmY2I5MjQ3ZGViM2U5 YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMTgtMTItMjMgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBMZWFrIG9mIENNU2FtcGxlQnVmZmVyICg3NTIgYnl0 ZXMpIGluIGNvbS5hcHBsZS5XZWJLaXQuV2ViQ29udGVudCBydW5uaW5nIFdlYktpdCBsYXlvdXQg dGVzdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzE5MzAxNj4KKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzQ2OTI1NzAzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogd3RmL1JldGFpblB0ci5oOgorICAgICAgICAoV1RGOjpSZXRhaW5Q dHI6OmhhbmRsZSk6CisgICAgICAgIC0gQWRkIG1ldGhvZCB0aGF0IGxldHMgdXMgcGFzcyBSZXRh aW5QdHI8Pjo6bV9wdHIgZGlyZWN0bHkgdG8KKyAgICAgICAgICBmdW5jdGlvbnMgdGhhdCBlbXBs b3kgKzEgcmV0YWluZWQgb3V0IHBhcmFtZXRlcnMuCisgICAgICAgIChXVEY6OlJldGFpblB0cjo6 ZnJvbVN0b3JhZ2VIYW5kbGVUeXBlKToKKyAgICAgICAgLSBVc2UgY29uY2VwdCBvZiBTRklOQUUg dG8gZGVjaWRlIHdoZXRoZXIgd2UgbmVlZCBhCisgICAgICAgICAgY29uc3RfY2FzdDx2b2lkKio+ KCkgb3Igbm90IHdoZW4gY2FzdGluZyBTdG9yYWdlVHlwZSogdG8KKyAgICAgICAgICBQdHJIYW5k bGVUeXBlLgorCiAyMDE4LTEyLTEwICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+ CiAKICAgICAgICAgSGFjayB0byBtYWtlIFdlYktpdCBjb21waWxlIHdpdGggVVNFX1NZU1RFTV9N QUxMT0M9MSBvbiBtYWNPUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGZmOTA3NjA1YjY2ZTFlZDBjZWE3NGQ5ODgx YmVjYjc3NGIwYTZiNGIuLjFiYTQyZWEyNGFlMWJhMTYwZGUwZDNlYTk4YjliNDJiZDFmOWQxNjgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAxOC0xMi0yMyAgRGF2aWQgS2lsemVyICA8 ZGRraWx6ZXJAYXBwbGUuY29tPgorCisgICAgICAgIExlYWsgb2YgQ01TYW1wbGVCdWZmZXIgKDc1 MiBieXRlcykgaW4gY29tLmFwcGxlLldlYktpdC5XZWJDb250ZW50IHJ1bm5pbmcgV2ViS2l0IGxh eW91dCB0ZXN0cworICAgICAgICA8aHR0cHM6Ly93ZWJraXQub3JnL2IvMTkzMDE2PgorICAgICAg ICA8cmRhcjovL3Byb2JsZW0vNDY5MjU3MDM+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGVzdDogaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0 cy9tZWRpYWNhcHR1cmUtcmVjb3JkL01lZGlhUmVjb3JkZXItZGVzdHJveS1zY3JpcHQtZXhlY3V0 aW9uLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL21lZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFS ZWNvcmRlclByaXZhdGVXcml0ZXJDb2NvYS5tbToKKyAgICAgICAgKFdlYkNvcmU6OmNvcHlTYW1w bGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcCk6CisgICAgICAgIC0gQ2hhbmdlIHRvIHJldHVy biBSZXRhaW5QdHI8Pi4KKyAgICAgICAgLSBVc2UgUmV0YWluUHRyPD46OmhhbmRsZSgpIHRvIGNh cHR1cmUgKzEgcmV0YWluZWQKKyAgICAgICAgICBDTVNhbXBsZUJ1ZmZlciBvYmplY3QuCisgICAg ICAgIC0gQ2hlY2sgcmV0dXJuIHZhbHVlIG9mIENNU2FtcGxlQnVmZmVyQ3JlYXRlQ29weVdpdGhO ZXdUaW1pbmcoKS4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVy OjphcHBlbmRWaWRlb1NhbXBsZUJ1ZmZlcik6CisgICAgICAgIC0gQ2hlY2sgcmV0dXJuIHZhbHVl IG9mIGNvcHlTYW1wbGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcCgpLgorICAgICAgICAtIEZp eCBsZWFrIGJ5IHVzaW5nIFJldGFpblB0cjw+IHJldHVybmVkIGZyb20KKyAgICAgICAgICBjb3B5 U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoKSBpbnN0ZWFkIG9mIGxlYWtpbmcgcmF3 CisgICAgICAgICAgYnVmZmVyV2l0aEN1cnJlbnRUaW1lIGJ5IGNhbGxpbmcgcmV0YWluUHRyKCkg dnMuIGFkb3B0Q0YoKS4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUmVjb3JkZXJQcml2YXRlV3Jp dGVyOjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZlcik6CisgICAgICAgIC0gQ2hlY2sgcmV0dXJuIHZh bHVlIG9mIENNQXVkaW9Gb3JtYXREZXNjcmlwdGlvbkNyZWF0ZSgpLgorICAgICAgICAtIEZpeCBs ZWFrcyBvZiBib3RoIENNRm9ybWF0RGVzY3JpcHRpb25SZWYgYW5kIENNU2FtcGxlQnVmZmVyUmVm CisgICAgICAgICAgYnkgdXNpbmcgUmV0YWluUHRyPD46OmhhbmRsZSgpIHRvIGNhcHR1cmUgKzEg cmV0YWluZWQgb2JqZWN0cy4KKwogMjAxOC0xMi0xOCAgSnVzdGluIE1pY2hhdWQgIDxqdXN0aW5f bWljaGF1ZEBhcHBsZS5jb20+CiAKICAgICAgICAgVXBkYXRlIENTUyBQcm9wZXJ0aWVzIGFuZCBW YWx1ZXMgQVBJIHRvIHVzZSBuZXcgY3ljbGUgZmFsbGJhY2sgYmVoYXZpb3VyCmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9SZXRhaW5QdHIuaCBiL1NvdXJjZS9XVEYvd3RmL1JldGFpblB0ci5o CmluZGV4IGFhOTZkZWExYWM5NjcwMzFjODA4NGEyYmUxMWE3NmJkNzE3YTk2NzUuLjYwNDFhNGMx NGNhNDI4NGQyMDgwNmRhNTYxODRjMThkOTYyYTNkYzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv d3RmL1JldGFpblB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1JldGFpblB0ci5oCkBAIC02Miw2 ICs2MiwxMSBAQCB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBSZXRhaW5QdHIgewogcHVibGlj OgogICAgIHR5cGVkZWYgdHlwZW5hbWUgc3RkOjpyZW1vdmVfcG9pbnRlcjxUPjo6dHlwZSBWYWx1 ZVR5cGU7CiAgICAgdHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisjaWZkZWYgX19PQkpDX18K KyAgICB0eXBlZGVmIFZhbHVlVHlwZSogX19zdHJvbmcgKiBQdHJIYW5kbGVUeXBlOworI2Vsc2UK KyAgICB0eXBlZGVmIFZhbHVlVHlwZSoqIFB0ckhhbmRsZVR5cGU7CisjZW5kaWYKICAgICB0eXBl ZGVmIENGVHlwZVJlZiBTdG9yYWdlVHlwZTsKIAogICAgIFJldGFpblB0cigpIDogbV9wdHIobnVs bHB0cikgeyB9CkBAIC04OCw2ICs5Myw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAgICAgUHRyVHlw ZSBnZXQoKSBjb25zdCB7IHJldHVybiBmcm9tU3RvcmFnZVR5cGUobV9wdHIpOyB9CisgICAgUHRy SGFuZGxlVHlwZSBoYW5kbGUoKSB7IHJldHVybiBmcm9tU3RvcmFnZUhhbmRsZVR5cGU8UHRySGFu ZGxlVHlwZT4oJm1fcHRyKTsgfQogICAgIFB0clR5cGUgb3BlcmF0b3ItPigpIGNvbnN0IHsgcmV0 dXJuIGZyb21TdG9yYWdlVHlwZShtX3B0cik7IH0KICAgICBleHBsaWNpdCBvcGVyYXRvciBQdHJU eXBlKCkgY29uc3QgeyByZXR1cm4gZnJvbVN0b3JhZ2VUeXBlKG1fcHRyKTsgfQogICAgIGV4cGxp Y2l0IG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiBtX3B0cjsgfQpAQCAtOTcsNyArMTAz LDcgQEAgcHVibGljOgogICAgIC8vIFRoaXMgY29udmVyc2lvbiBvcGVyYXRvciBhbGxvd3MgaW1w bGljaXQgY29udmVyc2lvbiB0byBib29sIGJ1dCBub3QgdG8gb3RoZXIgaW50ZWdlciB0eXBlcy4K ICAgICB0eXBlZGVmIFN0b3JhZ2VUeXBlIFJldGFpblB0cjo6KlVuc3BlY2lmaWVkQm9vbFR5cGU7 CiAgICAgb3BlcmF0b3IgVW5zcGVjaWZpZWRCb29sVHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fcHRy ID8gJlJldGFpblB0cjo6bV9wdHIgOiBudWxscHRyOyB9Ci0gICAgCisKICAgICBSZXRhaW5QdHIm IG9wZXJhdG9yPShjb25zdCBSZXRhaW5QdHImKTsKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBS ZXRhaW5QdHImIG9wZXJhdG9yPShjb25zdCBSZXRhaW5QdHI8VT4mKTsKICAgICBSZXRhaW5QdHIm IG9wZXJhdG9yPShQdHJUeXBlKTsKQEAgLTE0MCw5ICsxNDYsMjIgQEAgcHJpdmF0ZToKICAgICB7 CiAgICAgICAgIHJldHVybiAoUHRyVHlwZSljb25zdF9jYXN0PENGX0JSSURHRURfVFlQRShpZCkg dm9pZCo+KHB0cik7CiAgICAgfQorCiAgICAgU3RvcmFnZVR5cGUgdG9TdG9yYWdlVHlwZShQdHJU eXBlIHB0cikgY29uc3QgeyByZXR1cm4gKFN0b3JhZ2VUeXBlKXB0cjsgfQogI2VuZGlmCiAKKyAg ICB0ZW1wbGF0ZTx0eXBlbmFtZSBVLCB0eXBlbmFtZSBzdGQ6OmVuYWJsZV9pZjxzdGQ6OmlzX2Nv bnN0PHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX3BvaW50ZXI8dHlwZW5hbWUgc3RkOjpyZW1vdmVfcG9p bnRlcjxVPjo6dHlwZT46OnR5cGU+Ojp2YWx1ZSwgaW50Pjo6dHlwZSA9IDA+CisgICAgVSBmcm9t U3RvcmFnZUhhbmRsZVR5cGUoU3RvcmFnZVR5cGUqIGhhbmRsZSkKKyAgICB7CisgICAgICAgIHJl dHVybiByZWludGVycHJldF9jYXN0PFU+KGhhbmRsZSk7CisgICAgfQorCisgICAgdGVtcGxhdGU8 dHlwZW5hbWUgVSwgdHlwZW5hbWUgc3RkOjplbmFibGVfaWY8IXN0ZDo6aXNfY29uc3Q8dHlwZW5h bWUgc3RkOjpyZW1vdmVfcG9pbnRlcjx0eXBlbmFtZSBzdGQ6OnJlbW92ZV9wb2ludGVyPFU+Ojp0 eXBlPjo6dHlwZT46OnZhbHVlLCBpbnQ+Ojp0eXBlID0gMD4KKyAgICBVIGZyb21TdG9yYWdlSGFu ZGxlVHlwZShTdG9yYWdlVHlwZSogaGFuZGxlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHJlaW50 ZXJwcmV0X2Nhc3Q8VT4oY29uc3RfY2FzdDx2b2lkKio+KGhhbmRsZSkpOworICAgIH0KKwogI2lm ZGVmIF9fT0JKQ19fCiAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gc3RkOjplbmFibGVfaWZfdDxz dGQ6OmlzX2NvbnZlcnRpYmxlPFUsIGlkPjo6dmFsdWUsIFB0clR5cGU+IGF1dG9yZWxlYXNlSGVs cGVyKCk7CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gc3RkOjplbmFibGVfaWZfdDwhc3RkOjpp c19jb252ZXJ0aWJsZTxVLCBpZD46OnZhbHVlLCBQdHJUeXBlPiBhdXRvcmVsZWFzZUhlbHBlcigp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFyZWNvcmRlci9jb2Nv YS9NZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlckNvY29hLm1tIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbWVkaWFyZWNvcmRlci9jb2NvYS9NZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlckNvY29h Lm1tCmluZGV4IDU3YWVlYzMyZDRlZDI3NTFlNjlhNzYzNTI5Y2NmMWFhZWNmMGQ4YjAuLjRmMTll ZDc5NmY4ZGE3Nzc0NzZkNmNmMmQ3MDdjZGVjOTAwYzY2ZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL21lZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFSZWNvcmRlclByaXZhdGVX cml0ZXJDb2NvYS5tbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXJlY29yZGVy L2NvY29hL01lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyQ29jb2EubW0KQEAgLTE5Niw3ICsxOTYs NyBAQCBib29sIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjpzZXRBdWRpb0lucHV0KCkKICAg ICByZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIGlubGluZSBDTVNhbXBsZUJ1ZmZlclJlZiBjb3B5 U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoQ01TYW1wbGVCdWZmZXJSZWYgb3JpZ2lu YWxCdWZmZXIpCitzdGF0aWMgaW5saW5lIFJldGFpblB0cjxDTVNhbXBsZUJ1ZmZlclJlZj4gY29w eVNhbXBsZUJ1ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKENNU2FtcGxlQnVmZmVyUmVmIG9yaWdp bmFsQnVmZmVyKQogewogICAgIENNVGltZSBzdGFydFRpbWUgPSBDTUNsb2NrR2V0VGltZShDTUNs b2NrR2V0SG9zdFRpbWVDbG9jaygpKTsKICAgICBDTUl0ZW1Db3VudCBjb3VudCA9IDA7CkBAIC0y MTAsOCArMjEwLDEwIEBAIHN0YXRpYyBpbmxpbmUgQ01TYW1wbGVCdWZmZXJSZWYgY29weVNhbXBs ZUJ1ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKENNU2FtcGxlQnVmCiAgICAgICAgIHRpbWVJbmZv W2ldLnByZXNlbnRhdGlvblRpbWVTdGFtcCA9IHN0YXJ0VGltZTsKICAgICB9CiAgICAgCi0gICAg Q01TYW1wbGVCdWZmZXJSZWYgbmV3QnVmZmVyOwotICAgIENNU2FtcGxlQnVmZmVyQ3JlYXRlQ29w eVdpdGhOZXdUaW1pbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgb3JpZ2luYWxCdWZmZXIsIGNvdW50 LCB0aW1lSW5mby5kYXRhKCksICZuZXdCdWZmZXIpOworICAgIFJldGFpblB0cjxDTVNhbXBsZUJ1 ZmZlclJlZj4gbmV3QnVmZmVyOworICAgIE9TU3RhdHVzIGVycm9yID0gQ01TYW1wbGVCdWZmZXJD cmVhdGVDb3B5V2l0aE5ld1RpbWluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBvcmlnaW5hbEJ1ZmZl ciwgY291bnQsIHRpbWVJbmZvLmRhdGEoKSwgbmV3QnVmZmVyLmhhbmRsZSgpKTsKKyAgICBpZiAo ZXJyb3IpCisgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIHJldHVybiBuZXdCdWZmZXI7CiB9 CiAKQEAgLTI0OSw5ICsyNTEsMTEgQEAgdm9pZCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6 YXBwZW5kVmlkZW9TYW1wbGVCdWZmZXIoQ01TYW1wbGVCdWZmZXJSZWYgc2FtcGwKICAgICAgICAg fV07CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgQ01TYW1wbGVCdWZmZXJSZWYgYnVmZmVy V2l0aEN1cnJlbnRUaW1lID0gY29weVNhbXBsZUJ1ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKHNh bXBsZUJ1ZmZlcik7CisgICAgYXV0byBidWZmZXJXaXRoQ3VycmVudFRpbWUgPSBjb3B5U2FtcGxl QnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoc2FtcGxlQnVmZmVyKTsKKyAgICBpZiAoIWJ1ZmZl cldpdGhDdXJyZW50VGltZSkKKyAgICAgICAgcmV0dXJuOwogICAgIGF1dG8gbG9ja2VyID0gaG9s ZExvY2sobV92aWRlb0xvY2spOwotICAgIG1fdmlkZW9CdWZmZXJQb29sLmFwcGVuZChyZXRhaW5Q dHIoYnVmZmVyV2l0aEN1cnJlbnRUaW1lKSk7CisgICAgbV92aWRlb0J1ZmZlclBvb2wuYXBwZW5k KGJ1ZmZlcldpdGhDdXJyZW50VGltZSk7CiB9CiAKIHZvaWQgTWVkaWFSZWNvcmRlclByaXZhdGVX cml0ZXI6OmFwcGVuZEF1ZGlvU2FtcGxlQnVmZmVyKGNvbnN0IFBsYXRmb3JtQXVkaW9EYXRhJiBk YXRhLCBjb25zdCBBdWRpb1N0cmVhbURlc2NyaXB0aW9uJiBkZXNjcmlwdGlvbiwgY29uc3QgV1RG OjpNZWRpYVRpbWUmLCBzaXplX3Qgc2FtcGxlQ291bnQpCkBAIC0yNTksMTEgKzI2MywxMiBAQCB2 b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZlcihj b25zdCBQbGF0Zm9ybUF1ZGlvRGF0YQogICAgIEFTU0VSVChtX2F1ZGlvSW5wdXQpOwogICAgIGlm ICgoIW1faGFzU3RhcnRlZFdyaXRpbmcgJiYgbV92aWRlb0lucHV0KSB8fCBtX2lzU3RvcHBlZCkK ICAgICAgICAgcmV0dXJuOwotICAgIENNU2FtcGxlQnVmZmVyUmVmIHNhbXBsZUJ1ZmZlcjsKLSAg ICBDTUZvcm1hdERlc2NyaXB0aW9uUmVmIGZvcm1hdDsKKyAgICBSZXRhaW5QdHI8Q01Gb3JtYXRE ZXNjcmlwdGlvblJlZj4gZm9ybWF0OwogICAgIE9TU3RhdHVzIGVycm9yOwogICAgIGF1dG8mIGJh c2ljRGVzY3JpcHRpb24gPSAqV1RGOjpnZXQ8Y29uc3QgQXVkaW9TdHJlYW1CYXNpY0Rlc2NyaXB0 aW9uKj4oZGVzY3JpcHRpb24ucGxhdGZvcm1EZXNjcmlwdGlvbigpLmRlc2NyaXB0aW9uKTsKLSAg ICBlcnJvciA9IENNQXVkaW9Gb3JtYXREZXNjcmlwdGlvbkNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZh dWx0LCAmYmFzaWNEZXNjcmlwdGlvbiwgMCwgTlVMTCwgMCwgTlVMTCwgTlVMTCwgJmZvcm1hdCk7 CisgICAgZXJyb3IgPSBDTUF1ZGlvRm9ybWF0RGVzY3JpcHRpb25DcmVhdGUoa0NGQWxsb2NhdG9y RGVmYXVsdCwgJmJhc2ljRGVzY3JpcHRpb24sIDAsIE5VTEwsIDAsIE5VTEwsIE5VTEwsIGZvcm1h dC5oYW5kbGUoKSk7CisgICAgaWYgKGVycm9yKQorICAgICAgICByZXR1cm47CiAgICAgaWYgKG1f aXNGaXJzdEF1ZGlvU2FtcGxlKSB7CiAgICAgICAgIGlmICghbV92aWRlb0lucHV0KSB7CiAgICAg ICAgICAgICAvLyBhdWRpby1vbmx5IHJlY29yZGluZy4KQEAgLTI5NSwxNSArMzAwLDE2IEBAIHZv aWQgTWVkaWFSZWNvcmRlclByaXZhdGVXcml0ZXI6OmFwcGVuZEF1ZGlvU2FtcGxlQnVmZmVyKGNv bnN0IFBsYXRmb3JtQXVkaW9EYXRhCiAgICAgfQogICAgIENNVGltZSBzdGFydFRpbWUgPSBDTUNs b2NrR2V0VGltZShDTUNsb2NrR2V0SG9zdFRpbWVDbG9jaygpKTsKIAotICAgIGVycm9yID0gQ01B dWRpb1NhbXBsZUJ1ZmZlckNyZWF0ZVdpdGhQYWNrZXREZXNjcmlwdGlvbnMoa0NGQWxsb2NhdG9y RGVmYXVsdCwgTlVMTCwgZmFsc2UsIE5VTEwsIE5VTEwsIGZvcm1hdCwgc2FtcGxlQ291bnQsIHN0 YXJ0VGltZSwgTlVMTCwgJnNhbXBsZUJ1ZmZlcik7CisgICAgUmV0YWluUHRyPENNU2FtcGxlQnVm ZmVyUmVmPiBzYW1wbGVCdWZmZXI7CisgICAgZXJyb3IgPSBDTUF1ZGlvU2FtcGxlQnVmZmVyQ3Jl YXRlV2l0aFBhY2tldERlc2NyaXB0aW9ucyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBOVUxMLCBmYWxz ZSwgTlVMTCwgTlVMTCwgZm9ybWF0LmdldCgpLCBzYW1wbGVDb3VudCwgc3RhcnRUaW1lLCBOVUxM LCBzYW1wbGVCdWZmZXIuaGFuZGxlKCkpOwogICAgIGlmIChlcnJvcikKICAgICAgICAgcmV0dXJu OwotICAgIGVycm9yID0gQ01TYW1wbGVCdWZmZXJTZXREYXRhQnVmZmVyRnJvbUF1ZGlvQnVmZmVy TGlzdChzYW1wbGVCdWZmZXIsIGtDRkFsbG9jYXRvckRlZmF1bHQsIGtDRkFsbG9jYXRvckRlZmF1 bHQsIDAsIGRvd25jYXN0PFdlYkF1ZGlvQnVmZmVyTGlzdD4oZGF0YSkubGlzdCgpKTsKKyAgICBl cnJvciA9IENNU2FtcGxlQnVmZmVyU2V0RGF0YUJ1ZmZlckZyb21BdWRpb0J1ZmZlckxpc3Qoc2Ft cGxlQnVmZmVyLmdldCgpLCBrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBrQ0ZBbGxvY2F0b3JEZWZhdWx0 LCAwLCBkb3duY2FzdDxXZWJBdWRpb0J1ZmZlckxpc3Q+KGRhdGEpLmxpc3QoKSk7CiAgICAgaWYg KGVycm9yKQogICAgICAgICByZXR1cm47CiAKICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1f YXVkaW9Mb2NrKTsKLSAgICBtX2F1ZGlvQnVmZmVyUG9vbC5hcHBlbmQocmV0YWluUHRyKHNhbXBs ZUJ1ZmZlcikpOworICAgIG1fYXVkaW9CdWZmZXJQb29sLmFwcGVuZChzYW1wbGVCdWZmZXIpOwog fQogCiB2b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjpzdG9wUmVjb3JkaW5nKCkKZGlm ZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCA3ZWFmY2Vj MWYxZTRhZWM3YjBiNTY5NWZiZjhkZjM4MjVlYzQyYjBiLi44ZDYyY2ZiM2MwYWEyYjZmMTJmZTc2 NWQ4NGJjNWRhMTE0ODgxNTM4IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTgtMTItMjMgIERhdmlkIEtpbHplciAg PGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBMZWFrIG9mIENNU2FtcGxlQnVmZmVyICg3 NTIgYnl0ZXMpIGluIGNvbS5hcHBsZS5XZWJLaXQuV2ViQ29udGVudCBydW5uaW5nIFdlYktpdCBs YXlvdXQgdGVzdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzE5MzAxNj4KKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzQ2OTI1NzAzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgIC0gQWRkIG1pc3NpbmcgUmV0YWluUHRyLmNw cCB0byBUZXN0V1RGIHRhcmdldC4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9j Zi9SZXRhaW5QdHIuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6Q3JlYXRlQ0ZTdHJpbmdX aXRoT3V0UGFyYW1ldGVyKToKKyAgICAgICAgLSBBZGQgaGVscGVyIGZ1bmN0aW9uLgorICAgICAg ICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisgICAgICAgIC0gQWRkIHRlc3QgZm9yIENGVHlwZVJl Ziogb3V0IHBhcmFtZXRlcnMuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvbnMv UmV0YWluUHRyLm1tOgorICAgICAgICAoK1tNeUNsYXNzIG5ld05TU3RyaW5nV2l0aE91dFBhcmFt ZXRlcjpdKToKKyAgICAgICAgLSBBZGQgaGVscGVyIGNsYXNzIG1ldGhvZC4KKyAgICAgICAgKFRl c3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAtIEFkZCB0ZXN0IGZvciBOU09iamVjdCAqKiBv dXQgcGFyYW1ldGVycy4KKwogMjAxOC0xMi0wNyAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBw bGUuY29tPgogCiAgICAgICAgIElnbm9yZSBmYWxzZS1wb3NpdGl2ZSBsZWFrcyB1bmRlciBibWFs bG9jOjpIZWFwOjpIZWFwCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJL aXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDdlOGVkM2JlNTE0ODQz MDhlMGQ4YTFhOWI3OGJhMzU4ZWZmNTU0YTUuLjA5ZmI3N2FiYmI5ODZhZWFiMzQwNThjNzM3MTc5 NDJlY2YwZjg5ZDEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQ SS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xNzAsNiArMTcwLDcgQEAK IAkJNDQzM0EzOTYyMDgwNDQxNDAwOTFFRDU3IC8qIFN5bmNocm9ub3VzVGltZW91dFRlc3RzLm1t IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDQzM0EzOTUy MDgwNDQxMzAwOTFFRDU3IC8qIFN5bmNocm9ub3VzVGltZW91dFRlc3RzLm1tICovOyB9OwogCQk0 NDgxN0EyRjFGMDQ4NkJGMDAwMDM4MTAgLyogV0tSZXF1ZXN0QWN0aXZhdGVkRWxlbWVudEluZm8u bW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NDgxN0Ey RTFGMDQ4NkJGMDAwMDM4MTAgLyogV0tSZXF1ZXN0QWN0aXZhdGVkRWxlbWVudEluZm8ubW0gKi87 IH07CiAJCTQ0OEQ3RTQ3MUVBNkM1NTUwMEVDQzc1NiAvKiBFbnZpcm9ubWVudFV0aWxpdGllc1Rl c3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDQ4 RDdFNDUxRUE2QzU1NTAwRUNDNzU2IC8qIEVudmlyb25tZW50VXRpbGl0aWVzVGVzdC5jcHAgKi87 IH07CisJCTQ0QUM4QkM2MjFEMDI0NUEwMENBRkIzNCAvKiBSZXRhaW5QdHIuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQkMwMjlCMTYxNDg2QUQ2NDAw ODE3REE5IC8qIFJldGFpblB0ci5jcHAgKi87IH07CiAJCTQ2MTJDMkI5MjEwQTZBQ0UwMEI3ODhB NiAvKiBMb2FkRmlsZVRoZW5SZWxvYWQubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA0NjEyQzJCODIxMEE2QUJGMDBCNzg4QTYgLyogTG9hZEZpbGVUaGVu UmVsb2FkLm1tICovOyB9OwogCQk0NjM5N0I5NTFEQzJDODUwMDA5QTc4QUUgLyogRE9NTm9kZS5t bSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ2Mzk3Qjk0 MURDMkM4NTAwMDlBNzhBRSAvKiBET01Ob2RlLm1tICovOyB9OwogCQk0NjQ3QjEyNjFFQkEzQjg1 MDA0MUQ3RUYgLyogUHJvY2Vzc0RpZFRlcm1pbmF0ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NjQ3QjEyNTFFQkEzQjczMDA0MUQ3RUYgLyogUHJv Y2Vzc0RpZFRlcm1pbmF0ZS5jcHAgKi87IH07CkBAIC0zNzc1LDYgKzM3NzYsNyBAQAogCQkJCTdD ODNERjE1MUQwQTU5MEMwMEZFQkNGMyAvKiBSZWZDb3VudGVyLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTdDODNERUQ3MUQwQTU5MEMwMEZFQkNGMyAvKiBSZWZMb2dnZXIuY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJN0M4M0RGMTYxRDBBNTkwQzAwRkVCQ0YzIC8qIFJlZlB0ci5jcHAgaW4gU291cmNl cyAqLywKKwkJCQk0NEFDOEJDNjIxRDAyNDVBMDBDQUZCMzQgLyogUmV0YWluUHRyLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTdDODNERjI0MUQwQTU5MEMwMEZFQkNGMyAvKiBSZXRhaW5QdHIubW0g aW4gU291cmNlcyAqLywKIAkJCQk3QzgzREYwNTFEMEE1OTBDMDBGRUJDRjMgLyogUnVuTG9vcC5j cHAgaW4gU291cmNlcyAqLywKIAkJCQk3QzgzREYyNjFEMEE1OTBDMDBGRUJDRjMgLyogU2F0dXJh dGVkQXJpdGhtZXRpY09wZXJhdGlvbnMuY3BwIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9jZi9SZXRhaW5QdHIuY3BwIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XVEYvY2YvUmV0YWluUHRyLmNwcAppbmRleCAwMDMzZjNiOGJjNjg5 YjI3MWVkMDY0ZDQ3OGI4YjZiNjc1MjQ3MDg1Li4yNzA4OTFhNWFhMTJhODk4MmExZTFkNTc4ZTNk MTQ2MDBhYWE3ZmMzIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9j Zi9SZXRhaW5QdHIuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL2NmL1Jl dGFpblB0ci5jcHAKQEAgLTMyLDYgKzMyLDE5IEBACiAKIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJ IHsKIAorYm9vbCBDcmVhdGVDRlN0cmluZ1dpdGhPdXRQYXJhbWV0ZXIoQ0ZTdHJpbmdSZWYqIGNm U3RyaW5nSGFuZGxlKQoreworICAgIGlmICghY2ZTdHJpbmdIYW5kbGUpCisgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgIENGU3RyaW5nUmVmIGNmU3RyaW5nID0gQ0ZTdHJpbmdDcmVhdGVXaXRo Q1N0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBfX1BSRVRUWV9GVU5DVElPTl9fLCBrQ0ZTdHJp bmdFbmNvZGluZ0lTT0xhdGluMSk7CisgICAgaWYgKCFjZlN0cmluZykKKyAgICAgICAgcmV0dXJu IGZhbHNlOworCisgICAgKmNmU3RyaW5nSGFuZGxlID0gY2ZTdHJpbmc7CisgICAgcmV0dXJuIHRy dWU7Cit9CisKIFRFU1QoUmV0YWluUHRyLCBBZG9wdENGKQogewogICAgIFJldGFpblB0cjxDRkFy cmF5UmVmPiBmb28gPSBhZG9wdENGKENGQXJyYXlDcmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwg bnVsbHB0ciwgMCwgbnVsbHB0cikpOwpAQCAtMzksNCArNTIsMTQgQEAgVEVTVChSZXRhaW5QdHIs IEFkb3B0Q0YpCiAgICAgRVhQRUNUX0VRKDEsIENGR2V0UmV0YWluQ291bnQoZm9vLmdldCgpKSk7 CiB9CiAKK1RFU1QoUmV0YWluUHRyLCBPdXRQYXJhbWV0ZXJDRikKK3sKKyAgICBSZXRhaW5QdHI8 Q0ZTdHJpbmdSZWY+IHN0cmluZzsKKyAgICBib29sIHJlc3VsdCA9IENyZWF0ZUNGU3RyaW5nV2l0 aE91dFBhcmFtZXRlcihzdHJpbmcuaGFuZGxlKCkpOworCisgICAgRVhQRUNUX1RSVUUocmVzdWx0 KTsKKyAgICBFWFBFQ1RfVFJVRShzdHJpbmcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBDRkdl dFJldGFpbkNvdW50KHN0cmluZy5nZXQoKSkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2Vi S2l0QVBJCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9ucy9SZXRh aW5QdHIubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9ucy9SZXRhaW5QdHIubW0K aW5kZXggZjkyNWNlN2NmOTU5MzUwMTZkNTNlYTYzMDE4MmExZDE4MjA1OTdmYy4uOGJjMDM4MTQ5 M2ZmZGQ2NWE3NzJiM2YxYmJmMzc5NjVhZjBjZTczZSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XVEYvbnMvUmV0YWluUHRyLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV1RGL25zL1JldGFpblB0ci5tbQpAQCAtMzAsNiArMzAsMjUgQEAKIAogI2luY2x1 ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KIAorQGludGVyZmFjZSBNeUNsYXNzIDogTlNPYmplY3QKKysg KEJPT0wpbmV3TlNTdHJpbmdXaXRoT3V0UGFyYW1ldGVyOihOU1N0cmluZyAqIF9fc3Ryb25nICop bnNTdHJpbmdIYW5kbGU7CitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBNeUNsYXNzCisrIChCT09M KW5ld05TU3RyaW5nV2l0aE91dFBhcmFtZXRlcjooTlNTdHJpbmcgKiBfX3N0cm9uZyAqKW5zU3Ry aW5nSGFuZGxlCit7CisgICAgaWYgKCFuc1N0cmluZ0hhbmRsZSkKKyAgICAgICAgcmV0dXJuIGZh bHNlOworCisgICAgTlNTdHJpbmcgKm5zU3RyaW5nID0gW1tOU1N0cmluZyBhbGxvY10gaW5pdFdp dGhVVEY4U3RyaW5nOl9fUFJFVFRZX0ZVTkNUSU9OX19dOworICAgIGlmICghbnNTdHJpbmcpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICpuc1N0cmluZ0hhbmRsZSA9IG5zU3RyaW5nOwor ICAgIHJldHVybiB0cnVlOworfQorQGVuZAorCiBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CiAK IFRFU1QoUmV0YWluUHRyLCBBZG9wdE5TKQpAQCAtMTIzLDQgKzE0MiwxNCBAQCBURVNUKFJldGFp blB0ciwgQ29uc3RydWN0aW9uRnJvbVNpbWlsYXJUeXBlKQogICAgIEVYUEVDVF9FUSgoTlNTdHJp bmcgKikwLCB0ZW1wKTsKIH0KIAorVEVTVChSZXRhaW5QdHIsIE91dFBhcmFtZXRlck5TKQorewor ICAgIFJldGFpblB0cjxOU1N0cmluZz4gc3RyaW5nOworICAgIGJvb2wgcmVzdWx0ID0gW015Q2xh c3MgbmV3TlNTdHJpbmdXaXRoT3V0UGFyYW1ldGVyOnN0cmluZy5oYW5kbGUoKV07CisKKyAgICBF WFBFQ1RfVFJVRShyZXN1bHQpOworICAgIEVYUEVDVF9UUlVFKHN0cmluZy5nZXQoKSk7CisgICAg RVhQRUNUX0VRKDEsIENGR2V0UmV0YWluQ291bnQoKENGU3RyaW5nUmVmKXN0cmluZy5nZXQoKSkp OworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 358146 2018-12-29 21:07:35 -0800 2019-01-02 11:00:57 -0800 Patch v3 bug-193016-20181229210735.patch text/plain 7319 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjM5NTU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTVmMGFiODY1MWQ5NDkw NDFmODM0ODFjNzQwODQ5YTg0MTdkMzlhOS4uNDNkMjFkMmExYzgwNTFjN2JmMjg4Njk0YWUyYzc5 MWRhNzk4YmRhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE4LTEyLTI5ICBEYXZp ZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CisKKyAgICAgICAgTGVhayBvZiBDTVNhbXBs ZUJ1ZmZlciAoNzUyIGJ5dGVzKSBpbiBjb20uYXBwbGUuV2ViS2l0LldlYkNvbnRlbnQgcnVubmlu ZyBXZWJLaXQgbGF5b3V0IHRlc3RzCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8xOTMw MTY+CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS80NjkyNTcwMz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL21lZGlhcmVjb3JkZXIv Y29jb2EvTWVkaWFSZWNvcmRlclByaXZhdGVXcml0ZXJDb2NvYS5tbToKKyAgICAgICAgKFdlYkNv cmU6OmNvcHlTYW1wbGVCdWZmZXJXaXRoQ3VycmVudFRpbWVTdGFtcCk6CisgICAgICAgIC0gQ2hh bmdlIHRvIHJldHVybiBSZXRhaW5QdHI8Q01TYW1wbGVCdWZmZXJSZWY+LgorICAgICAgICAtIENo ZWNrIHJldHVybiB2YWx1ZSBvZiBDTVNhbXBsZUJ1ZmZlckNyZWF0ZUNvcHlXaXRoTmV3VGltaW5n KCkuCisgICAgICAgIChXZWJDb3JlOjpNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6YXBwZW5k VmlkZW9TYW1wbGVCdWZmZXIpOgorICAgICAgICAtIENoZWNrIHJldHVybiB2YWx1ZSBvZiBjb3B5 U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoKS4KKyAgICAgICAgLSBGaXggbGVhayBi eSB1c2luZyBSZXRhaW5QdHI8Q01TYW1wbGVCdWZmZXJSZWY+IHJldHVybmVkIGZyb20KKyAgICAg ICAgICBjb3B5U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoKSBpbnN0ZWFkIG9mIGxl YWtpbmcKKyAgICAgICAgICBgYnVmZmVyV2l0aEN1cnJlbnRUaW1lYCBieSB1c2luZyByZXRhaW5Q dHIoKS4KKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZUF1ZGlvRm9ybWF0RGVzY3JpcHRpb24pOgor ICAgICAgICAtIEV4dHJhY3QgbWV0aG9kIGZyb20gYXBwZW5kQXVkaW9TYW1wbGVCdWZmZXIoKSB0 byByZXR1cm4KKyAgICAgICAgICBSZXRhaW5QdHI8Q01Gb3JtYXREZXNjcmlwdGlvblJlZj4gYWZ0 ZXIgY2FsbGluZworICAgICAgICAgIENNQXVkaW9Gb3JtYXREZXNjcmlwdGlvbkNyZWF0ZSgpLgor ICAgICAgICAtIENoZWNrIHJldHVybiB2YWx1ZSBvZiBDTUF1ZGlvRm9ybWF0RGVzY3JpcHRpb25D cmVhdGUoKS4KKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZUF1ZGlvU2FtcGxlQnVmZmVyV2l0aFBh Y2tldERlc2NyaXB0aW9ucyk6CisgICAgICAgIC0gRXh0cmFjdCBtZXRob2QgZnJvbSBhcHBlbmRB dWRpb1NhbXBsZUJ1ZmZlcigpIHRvIHJldHVybgorICAgICAgICAgIFJldGFpblB0cjxDTVNhbXBs ZUJ1ZmZlclJlZj4gYWZ0ZXIgY2FsbGluZworICAgICAgICAgIENNQXVkaW9TYW1wbGVCdWZmZXJD cmVhdGVXaXRoUGFja2V0RGVzY3JpcHRpb25zKCkuCisgICAgICAgIChXZWJDb3JlOjpNZWRpYVJl Y29yZGVyUHJpdmF0ZVdyaXRlcjo6YXBwZW5kQXVkaW9TYW1wbGVCdWZmZXIpOgorICAgICAgICAt IENoZWNrIHJldHVybiB2YWx1ZXMgb2YgY3JlYXRlQXVkaW9Gb3JtYXREZXNjcmlwdGlvbigpIGFu ZAorICAgICAgICAgIGNyZWF0ZUF1ZGlvU2FtcGxlQnVmZmVyV2l0aFBhY2tldERlc2NyaXB0aW9u cygpLgorICAgICAgICAtIEZpeCBsZWFrcyBieSBleHRyYWN0aW5nIGNvZGUgaW50byBoZWxwZXIg bWV0aG9kcyB0aGF0IHJldHVybgorICAgICAgICAgIFJldGFpblB0cjw+IG9iamVjdHMgaW5zdGVh ZCBvZiBsZWFraW5nIENNRm9ybWF0RGVzY3JpcHRpb25SZWYKKyAgICAgICAgICBkaXJlY3RseSBv ciBsZWFraW5nIGBzYW1wbGVCdWZmZXJgIGJ5IHVzaW5nIHJldGFpblB0cigpLgorCiAyMDE4LTEy LTI5ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CiAKICAgICAgICAgY2xhbmct dGlkeTogU2F2ZSA4IHBhZGRpbmcgYnl0ZXMgb24gV2ViQ29yZTo6Qm9yZGVyRWRnZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFyZWNvcmRlci9jb2NvYS9NZWRpYVJl Y29yZGVyUHJpdmF0ZVdyaXRlckNvY29hLm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVk aWFyZWNvcmRlci9jb2NvYS9NZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlckNvY29hLm1tCmluZGV4 IDU3YWVlYzMyZDRlZDI3NTFlNjlhNzYzNTI5Y2NmMWFhZWNmMGQ4YjAuLjFmNzAzYmMzMWU4NTNi ZjhlYjMzMWZlM2Y5OGU0OTE0YzE2MjI0ZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL21lZGlhcmVjb3JkZXIvY29jb2EvTWVkaWFSZWNvcmRlclByaXZhdGVXcml0ZXJDb2Nv YS5tbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXJlY29yZGVyL2NvY29hL01l ZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyQ29jb2EubW0KQEAgLTE5Niw3ICsxOTYsNyBAQCBib29s IE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjpzZXRBdWRpb0lucHV0KCkKICAgICByZXR1cm4g dHJ1ZTsKIH0KIAotc3RhdGljIGlubGluZSBDTVNhbXBsZUJ1ZmZlclJlZiBjb3B5U2FtcGxlQnVm ZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoQ01TYW1wbGVCdWZmZXJSZWYgb3JpZ2luYWxCdWZmZXIp CitzdGF0aWMgaW5saW5lIFJldGFpblB0cjxDTVNhbXBsZUJ1ZmZlclJlZj4gY29weVNhbXBsZUJ1 ZmZlcldpdGhDdXJyZW50VGltZVN0YW1wKENNU2FtcGxlQnVmZmVyUmVmIG9yaWdpbmFsQnVmZmVy KQogewogICAgIENNVGltZSBzdGFydFRpbWUgPSBDTUNsb2NrR2V0VGltZShDTUNsb2NrR2V0SG9z dFRpbWVDbG9jaygpKTsKICAgICBDTUl0ZW1Db3VudCBjb3VudCA9IDA7CkBAIC0yMTAsOSArMjEw LDExIEBAIHN0YXRpYyBpbmxpbmUgQ01TYW1wbGVCdWZmZXJSZWYgY29weVNhbXBsZUJ1ZmZlcldp dGhDdXJyZW50VGltZVN0YW1wKENNU2FtcGxlQnVmCiAgICAgICAgIHRpbWVJbmZvW2ldLnByZXNl bnRhdGlvblRpbWVTdGFtcCA9IHN0YXJ0VGltZTsKICAgICB9CiAgICAgCi0gICAgQ01TYW1wbGVC dWZmZXJSZWYgbmV3QnVmZmVyOwotICAgIENNU2FtcGxlQnVmZmVyQ3JlYXRlQ29weVdpdGhOZXdU aW1pbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgb3JpZ2luYWxCdWZmZXIsIGNvdW50LCB0aW1lSW5m by5kYXRhKCksICZuZXdCdWZmZXIpOwotICAgIHJldHVybiBuZXdCdWZmZXI7CisgICAgQ01TYW1w bGVCdWZmZXJSZWYgbmV3QnVmZmVyID0gbnVsbHB0cjsKKyAgICBPU1N0YXR1cyBlcnJvciA9IENN U2FtcGxlQnVmZmVyQ3JlYXRlQ29weVdpdGhOZXdUaW1pbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwg b3JpZ2luYWxCdWZmZXIsIGNvdW50LCB0aW1lSW5mby5kYXRhKCksICZuZXdCdWZmZXIpOworICAg IGlmIChlcnJvcikKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJuIGFkb3B0Q0Yo bmV3QnVmZmVyKTsKIH0KIAogdm9pZCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdyaXRlcjo6YXBwZW5k VmlkZW9TYW1wbGVCdWZmZXIoQ01TYW1wbGVCdWZmZXJSZWYgc2FtcGxlQnVmZmVyKQpAQCAtMjQ5 LDkgKzI1MSwzMiBAQCB2b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjphcHBlbmRWaWRl b1NhbXBsZUJ1ZmZlcihDTVNhbXBsZUJ1ZmZlclJlZiBzYW1wbAogICAgICAgICB9XTsKICAgICAg ICAgcmV0dXJuOwogICAgIH0KLSAgICBDTVNhbXBsZUJ1ZmZlclJlZiBidWZmZXJXaXRoQ3VycmVu dFRpbWUgPSBjb3B5U2FtcGxlQnVmZmVyV2l0aEN1cnJlbnRUaW1lU3RhbXAoc2FtcGxlQnVmZmVy KTsKKyAgICBhdXRvIGJ1ZmZlcldpdGhDdXJyZW50VGltZSA9IGNvcHlTYW1wbGVCdWZmZXJXaXRo Q3VycmVudFRpbWVTdGFtcChzYW1wbGVCdWZmZXIpOworICAgIGlmICghYnVmZmVyV2l0aEN1cnJl bnRUaW1lKQorICAgICAgICByZXR1cm47CisKICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1f dmlkZW9Mb2NrKTsKLSAgICBtX3ZpZGVvQnVmZmVyUG9vbC5hcHBlbmQocmV0YWluUHRyKGJ1ZmZl cldpdGhDdXJyZW50VGltZSkpOworICAgIG1fdmlkZW9CdWZmZXJQb29sLmFwcGVuZChidWZmZXJX aXRoQ3VycmVudFRpbWUpOworfQorCitzdGF0aWMgaW5saW5lIFJldGFpblB0cjxDTUZvcm1hdERl c2NyaXB0aW9uUmVmPiBjcmVhdGVBdWRpb0Zvcm1hdERlc2NyaXB0aW9uKGNvbnN0IEF1ZGlvU3Ry ZWFtRGVzY3JpcHRpb24mIGRlc2NyaXB0aW9uKQoreworICAgIGF1dG8mIGJhc2ljRGVzY3JpcHRp b24gPSAqV1RGOjpnZXQ8Y29uc3QgQXVkaW9TdHJlYW1CYXNpY0Rlc2NyaXB0aW9uKj4oZGVzY3Jp cHRpb24ucGxhdGZvcm1EZXNjcmlwdGlvbigpLmRlc2NyaXB0aW9uKTsKKyAgICBDTUZvcm1hdERl c2NyaXB0aW9uUmVmIGZvcm1hdCA9IG51bGxwdHI7CisgICAgT1NTdGF0dXMgZXJyb3IgPSBDTUF1 ZGlvRm9ybWF0RGVzY3JpcHRpb25DcmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwgJmJhc2ljRGVz Y3JpcHRpb24sIDAsIE5VTEwsIDAsIE5VTEwsIE5VTEwsICZmb3JtYXQpOworICAgIGlmIChlcnJv cikKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJuIGFkb3B0Q0YoZm9ybWF0KTsK K30KKworc3RhdGljIGlubGluZSBSZXRhaW5QdHI8Q01TYW1wbGVCdWZmZXJSZWY+IGNyZWF0ZUF1 ZGlvU2FtcGxlQnVmZmVyV2l0aFBhY2tldERlc2NyaXB0aW9ucyhDTUZvcm1hdERlc2NyaXB0aW9u UmVmIGZvcm1hdCwgc2l6ZV90IHNhbXBsZUNvdW50KQoreworICAgIENNVGltZSBzdGFydFRpbWUg PSBDTUNsb2NrR2V0VGltZShDTUNsb2NrR2V0SG9zdFRpbWVDbG9jaygpKTsKKyAgICBDTVNhbXBs ZUJ1ZmZlclJlZiBzYW1wbGVCdWZmZXIgPSBudWxscHRyOworICAgIE9TU3RhdHVzIGVycm9yID0g Q01BdWRpb1NhbXBsZUJ1ZmZlckNyZWF0ZVdpdGhQYWNrZXREZXNjcmlwdGlvbnMoa0NGQWxsb2Nh dG9yRGVmYXVsdCwgTlVMTCwgZmFsc2UsIE5VTEwsIE5VTEwsIGZvcm1hdCwgc2FtcGxlQ291bnQs IHN0YXJ0VGltZSwgTlVMTCwgJnNhbXBsZUJ1ZmZlcik7CisgICAgaWYgKGVycm9yKQorICAgICAg ICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1cm4gYWRvcHRDRihzYW1wbGVCdWZmZXIpOwogfQog CiB2b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVyOjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZl cihjb25zdCBQbGF0Zm9ybUF1ZGlvRGF0YSYgZGF0YSwgY29uc3QgQXVkaW9TdHJlYW1EZXNjcmlw dGlvbiYgZGVzY3JpcHRpb24sIGNvbnN0IFdURjo6TWVkaWFUaW1lJiwgc2l6ZV90IHNhbXBsZUNv dW50KQpAQCAtMjU5LDExICsyODQsOSBAQCB2b2lkIE1lZGlhUmVjb3JkZXJQcml2YXRlV3JpdGVy OjphcHBlbmRBdWRpb1NhbXBsZUJ1ZmZlcihjb25zdCBQbGF0Zm9ybUF1ZGlvRGF0YQogICAgIEFT U0VSVChtX2F1ZGlvSW5wdXQpOwogICAgIGlmICgoIW1faGFzU3RhcnRlZFdyaXRpbmcgJiYgbV92 aWRlb0lucHV0KSB8fCBtX2lzU3RvcHBlZCkKICAgICAgICAgcmV0dXJuOwotICAgIENNU2FtcGxl QnVmZmVyUmVmIHNhbXBsZUJ1ZmZlcjsKLSAgICBDTUZvcm1hdERlc2NyaXB0aW9uUmVmIGZvcm1h dDsKLSAgICBPU1N0YXR1cyBlcnJvcjsKLSAgICBhdXRvJiBiYXNpY0Rlc2NyaXB0aW9uID0gKldU Rjo6Z2V0PGNvbnN0IEF1ZGlvU3RyZWFtQmFzaWNEZXNjcmlwdGlvbio+KGRlc2NyaXB0aW9uLnBs YXRmb3JtRGVzY3JpcHRpb24oKS5kZXNjcmlwdGlvbik7Ci0gICAgZXJyb3IgPSBDTUF1ZGlvRm9y bWF0RGVzY3JpcHRpb25DcmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwgJmJhc2ljRGVzY3JpcHRp b24sIDAsIE5VTEwsIDAsIE5VTEwsIE5VTEwsICZmb3JtYXQpOworICAgIGF1dG8gZm9ybWF0ID0g Y3JlYXRlQXVkaW9Gb3JtYXREZXNjcmlwdGlvbihkZXNjcmlwdGlvbik7CisgICAgaWYgKCFmb3Jt YXQpCisgICAgICAgIHJldHVybjsKICAgICBpZiAobV9pc0ZpcnN0QXVkaW9TYW1wbGUpIHsKICAg ICAgICAgaWYgKCFtX3ZpZGVvSW5wdXQpIHsKICAgICAgICAgICAgIC8vIGF1ZGlvLW9ubHkgcmVj b3JkaW5nLgpAQCAtMjkzLDE3ICszMTYsMTYgQEAgdm9pZCBNZWRpYVJlY29yZGVyUHJpdmF0ZVdy aXRlcjo6YXBwZW5kQXVkaW9TYW1wbGVCdWZmZXIoY29uc3QgUGxhdGZvcm1BdWRpb0RhdGEKICAg ICAgICAgICAgIH0KICAgICAgICAgfV07CiAgICAgfQotICAgIENNVGltZSBzdGFydFRpbWUgPSBD TUNsb2NrR2V0VGltZShDTUNsb2NrR2V0SG9zdFRpbWVDbG9jaygpKTsKIAotICAgIGVycm9yID0g Q01BdWRpb1NhbXBsZUJ1ZmZlckNyZWF0ZVdpdGhQYWNrZXREZXNjcmlwdGlvbnMoa0NGQWxsb2Nh dG9yRGVmYXVsdCwgTlVMTCwgZmFsc2UsIE5VTEwsIE5VTEwsIGZvcm1hdCwgc2FtcGxlQ291bnQs IHN0YXJ0VGltZSwgTlVMTCwgJnNhbXBsZUJ1ZmZlcik7Ci0gICAgaWYgKGVycm9yKQorICAgIGF1 dG8gc2FtcGxlQnVmZmVyID0gY3JlYXRlQXVkaW9TYW1wbGVCdWZmZXJXaXRoUGFja2V0RGVzY3Jp cHRpb25zKGZvcm1hdC5nZXQoKSwgc2FtcGxlQ291bnQpOworICAgIGlmICghc2FtcGxlQnVmZmVy KQogICAgICAgICByZXR1cm47Ci0gICAgZXJyb3IgPSBDTVNhbXBsZUJ1ZmZlclNldERhdGFCdWZm ZXJGcm9tQXVkaW9CdWZmZXJMaXN0KHNhbXBsZUJ1ZmZlciwga0NGQWxsb2NhdG9yRGVmYXVsdCwg a0NGQWxsb2NhdG9yRGVmYXVsdCwgMCwgZG93bmNhc3Q8V2ViQXVkaW9CdWZmZXJMaXN0PihkYXRh KS5saXN0KCkpOworICAgIE9TU3RhdHVzIGVycm9yID0gQ01TYW1wbGVCdWZmZXJTZXREYXRhQnVm ZmVyRnJvbUF1ZGlvQnVmZmVyTGlzdChzYW1wbGVCdWZmZXIuZ2V0KCksIGtDRkFsbG9jYXRvckRl ZmF1bHQsIGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsIGRvd25jYXN0PFdlYkF1ZGlvQnVmZmVyTGlz dD4oZGF0YSkubGlzdCgpKTsKICAgICBpZiAoZXJyb3IpCiAgICAgICAgIHJldHVybjsKIAogICAg IGF1dG8gbG9ja2VyID0gaG9sZExvY2sobV9hdWRpb0xvY2spOwotICAgIG1fYXVkaW9CdWZmZXJQ b29sLmFwcGVuZChyZXRhaW5QdHIoc2FtcGxlQnVmZmVyKSk7CisgICAgbV9hdWRpb0J1ZmZlclBv b2wuYXBwZW5kKHNhbXBsZUJ1ZmZlcik7CiB9CiAKIHZvaWQgTWVkaWFSZWNvcmRlclByaXZhdGVX cml0ZXI6OnN0b3BSZWNvcmRpbmcoKQo=