202874 2019-10-11 19:10:30 -0700 Use a Version 1 CFRunLoopSource for faster task dispatch 2021-01-21 15:27:31 -0800 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified REOPENED https://bugs.webkit.org/show_bug.cgi?id=203176 https://bugs.webkit.org/show_bug.cgi?id=203157 https://bugs.webkit.org/show_bug.cgi?id=203173 https://bugs.webkit.org/show_bug.cgi?id=203118 https://bugs.webkit.org/show_bug.cgi?id=219401 InRadar P2 Normal --- 213043 219656 219717 219785 1 sihui_liu ggaren andersca benjamin cdumez cmarcelo commit-queue dbates ews-watchlist ggaren koivisto nham pvollan rniwa sam sihui_liu simon.fraser thorton tsavell webkit-bug-importer wenson_hsieh youennf oldest_to_newest 1579348 0 sihui_liu 2019-10-11 19:10:30 -0700 ... 1579352 1 380807 sihui_liu 2019-10-11 19:22:52 -0700 Created attachment 380807 Patch 1579438 2 380807 ggaren 2019-10-12 11:36:10 -0700 Comment on attachment 380807 Patch It looks like some tests are timing out. My best guess is that some calls to RunLoop::dispatch() implicitly rely on ordering, and when we don’t use the explicit function queue, we break that ordering. I think it’s worth testing dispatch_async as the implementation of wakeUp. (We tested that once, but only with a broken patch that called isMain(), which is incorrect). That way, we preserve ordering. I’d change wakeUp to take an argument indicating whether this == s_mainRunLoop. Then, if true, the CF implementation should use dispatch_async to call the function that executes all tasks, rather than CFRunLoopWakeup. If that’s not fast enough, or it breaks things, then we should just add an inline function that calls dispatch_async or RunLoop::dispatch, depending on platform. And then call that just from IDB code. 1579489 3 380845 ggaren 2019-10-13 08:48:05 -0700 Created attachment 380845 patch - mach message Out of curiosity, I disassembled libdispatch to see what method it uses to signal the RunLoop. It looks like libdispatch uses a "version 1" RunLoop source <https://developer.apple.com/documentation/corefoundation/cfrunloopsource?language=objc>, which triggers by mach message, rather than CFRunLoopWakeup(). I've duplicated that behavior here. Can you test the performance of this approach? 1579490 4 ggaren 2019-10-13 08:48:55 -0700 (In reply to Geoffrey Garen from comment #3) (I verified that this patch passes the css3 layout tests.) 1579491 5 380846 ggaren 2019-10-13 08:52:03 -0700 Created attachment 380846 patch - mach message 1579518 6 380851 ggaren 2019-10-13 14:20:42 -0700 Created attachment 380851 patch - getUserMedia.html It looks like the iOS API test failure for TestWebKitAPI.WebKit2.CaptureMute is real. The test is racy, and its timing has changed slightly. Here's a patch that should make the test more deterministic. 1579557 7 sihui_liu 2019-10-13 23:35:16 -0700 (In reply to Geoffrey Garen from comment #3) > Created attachment 380845 [details] > patch - mach message > > Out of curiosity, I disassembled libdispatch to see what method it uses to > signal the RunLoop. It looks like libdispatch uses a "version 1" RunLoop > source > <https://developer.apple.com/documentation/corefoundation/ > cfrunloopsource?language=objc>, which triggers by mach message, rather than > CFRunLoopWakeup(). I've duplicated that behavior here. > > Can you test the performance of this approach? It's about 15% speed up on the test PerformanceTests/IndexedDB/basic/objectstore-get.html. 1579657 8 ggaren 2019-10-14 09:42:25 -0700 > > Can you test the performance of this approach? > > It's about 15% speed up on the test > PerformanceTests/IndexedDB/basic/objectstore-get.html. So, still slower than dispatch_async? 1579961 9 ggaren 2019-10-14 20:24:49 -0700 Oh, actually, it's expected that the patch above doesn't achieve all 20%, because it doesn't include the fix for callOnMainThread. I'll upload a patch that includes callOnMainThread and the regression test change all in one. 1579964 10 380952 ggaren 2019-10-14 20:26:46 -0700 Created attachment 380952 patch - mach message 1580017 11 sihui_liu 2019-10-15 00:49:17 -0700 (In reply to Geoffrey Garen from comment #9) > Oh, actually, it's expected that the patch above doesn't achieve all 20%, > because it doesn't include the fix for callOnMainThread. I'll upload a patch > that includes callOnMainThread and the regression test change all in one. I previously made the change of the callOnMainThread locally and tested. I tried with the latest patch and it seemed it's still not as fast as using dispatch_async directly. It's close though. Also I debugged the layout test failure of the dispatch_async patch. The cause is that we try to block main thread when waiting for reply of sync messages. Our implementation is: 1. Start a task on main thread 2. While not receiving reply, ask RunLoop to run. RunLoop can listen for input sources and processes data from sources(receiving and handling reply) at this time. (Thread is blocked.) 3. Continue to finish the task It looks like when we do dispatch_async, the RunLoop doesn't think it is a source and thus time out at step2. 1580162 12 ggaren 2019-10-15 10:37:57 -0700 (In reply to Sihui Liu from comment #11) > (In reply to Geoffrey Garen from comment #9) > > Oh, actually, it's expected that the patch above doesn't achieve all 20%, > > because it doesn't include the fix for callOnMainThread. I'll upload a patch > > that includes callOnMainThread and the regression test change all in one. > > I previously made the change of the callOnMainThread locally and tested. I > tried with the latest patch and it seemed it's still not as fast as using > dispatch_async directly. It's close though. > > Also I debugged the layout test failure of the dispatch_async patch. The > cause is that we try to block main thread when waiting for reply of sync > messages. Our implementation is: > 1. Start a task on main thread > 2. While not receiving reply, ask RunLoop to run. RunLoop can listen for > input sources and processes data from sources(receiving and handling reply) > at this time. (Thread is blocked.) > 3. Continue to finish the task > It looks like when we do dispatch_async, the RunLoop doesn't think it is a > source and thus time out at step2. Is this in Connection::waitForSyncReply? Or something else? I suspect that dispatch_async is not willing to execute inside a nested RunLoop. I believe that's a fundamental difference between libdispatch and CFRunLoop. (libdispatch requires all tasks to dispatch in order, and that means prohibiting re-entrant dispatch. Relatedly, libdispatch explicitly documents that dispatch_sync(dispatch_get_current_queue(), ...) is always a deadlock.) So, I guess we can't use dispatch_async. Let's try to finish up the mach_message / version 1 RunLoopSource solution, since it delivers most of the speedup. Can you do that? Outstanding issues: 1. inspector/css/pseudo-creation.html fails. It used to fail sometimes (e.g. https://build.webkit.org/builders/Apple%20High%20Sierra%20Debug%20WK1%20(Tests)/builds/11323), and now it fails all the time. So, the code has gotten better (more deterministic), but we broke a test. It looks like something about InspectorProtocol.eventHandler is racy relative to promise resolution. We need to fix this, or perhaps disable the test. 2. TestWebKitAPI.WebKitLegacy.ScrollingDoesNotPauseMedia times out. It must either time out in its call to Util::run, or its call to callOnMainThreadAndWait. I think it's probably callOnMainThreadAndWait. If so, this test has a simple bug. It calls "callOnMainThreadAndWait" *from the main thread*. I'm not sure exactly why this ever worked, but I think you can fix it by just switching to callOnMainThread. 1580650 13 381101 sihui_liu 2019-10-16 13:12:41 -0700 Created attachment 381101 Patch 1580652 14 381103 sihui_liu 2019-10-16 13:27:40 -0700 Created attachment 381103 Patch 1580657 15 381103 sam 2019-10-16 13:35:05 -0700 Comment on attachment 381103 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=381103&action=review > Source/WTF/ChangeLog:9 > + We used CFRunLoopWakeUp to wake up runloop to process source, which seems to be slow according to profiling. To > + avoid calling CFRunLoopWakeUp, use CFRunloopSource1 instead of CFRunloopSource0. What is CFRunloopSource1? Why is this faster? If it's not the current default, what is the reason it's not and what potential downsides are there? 1580658 16 381103 ggaren 2019-10-16 13:36:11 -0700 Comment on attachment 381103 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=381103&action=review Looks great, and thanks for fixing those tests. One comment on callOonMainThread. > Source/WTF/wtf/cocoa/MainThreadCocoa.mm:136 > - [staticMainThreadCaller performSelectorOnMainThread:@selector(call) withObject:nil waitUntilDone:NO]; > + dispatch_async(dispatch_get_main_queue(), ^{ > + [staticMainThreadCaller call]; > + }); You can remove some indirection here by deleting staticMainThreadCaller and JSWTFMainThreadCaller and just calling WTF::dispatchFunctionsFromMainThread() directly. staticMainThreadCaller and JSWTFMainThreadCaller only existed for the sake of doing the async dispatch, which you're doing a different way now. Side note: Is dispatch_async better than RunLoop::main().dispatch() in this case? Also, is it OK that callOnMainThread will not run in nested run loops? 1580668 17 381106 sihui_liu 2019-10-16 14:11:56 -0700 Created attachment 381106 Patch 1580700 18 sihui_liu 2019-10-16 14:51:29 -0700 (In reply to Sam Weinig from comment #15) > Comment on attachment 381103 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=381103&action=review > > > Source/WTF/ChangeLog:9 > > + We used CFRunLoopWakeUp to wake up runloop to process source, which seems to be slow according to profiling. To > > + avoid calling CFRunLoopWakeUp, use CFRunloopSource1 instead of CFRunloopSource0. > > What is CFRunloopSource1? Why is this faster? If it's not the current > default, what is the reason it's not and what potential downsides are there? It's version 1 source in CFRunloop: https://developer.apple.com/documentation/corefoundation/cfrunloopsource-rhr According to our profiling on test like OpenSource/PerformanceTests/IndexedDB/basic/objectstore-get.html, we spent a lot of time on waking up the runloop when receiving IPC message. And we tried libdispatch, which uses version 1 source for dispatching to runloop, and is much faster. So we think we could probably adopt this for better performance. I don't know why version 0 source is our default.. 1580714 19 sihui_liu 2019-10-16 15:06:02 -0700 (In reply to Geoffrey Garen from comment #16) > Comment on attachment 381103 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=381103&action=review > > Looks great, and thanks for fixing those tests. One comment on > callOonMainThread. > > > Source/WTF/wtf/cocoa/MainThreadCocoa.mm:136 > > - [staticMainThreadCaller performSelectorOnMainThread:@selector(call) withObject:nil waitUntilDone:NO]; > > + dispatch_async(dispatch_get_main_queue(), ^{ > > + [staticMainThreadCaller call]; > > + }); > > You can remove some indirection here by deleting staticMainThreadCaller and > JSWTFMainThreadCaller and just calling > WTF::dispatchFunctionsFromMainThread() directly. staticMainThreadCaller and > JSWTFMainThreadCaller only existed for the sake of doing the async dispatch, > which you're doing a different way now. > staticMainThreadCaller is used in the #if USE(WEB_THREAD) case, which is a few lines above. I would change this to WTF::dispatchFunctionsFromMainThread(). > Side note: Is dispatch_async better than RunLoop::main().dispatch() in this > case? Also, is it OK that callOnMainThread will not run in nested run loops? The reason why I didn't use RunLoop::main().dispatch() because RunLoop::main() needs to run after RunLoop::initializeMainRunLoop() and callOnMainThread does not seem to care about whether we have initialized mainRunLoop or not. Why can't callOnMainThread run in nested run loops? 1580729 20 381124 sihui_liu 2019-10-16 15:31:50 -0700 Created attachment 381124 Patch 1580771 21 sam 2019-10-16 16:46:16 -0700 (In reply to Sihui Liu from comment #18) > (In reply to Sam Weinig from comment #15) > > Comment on attachment 381103 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=381103&action=review > > > > > Source/WTF/ChangeLog:9 > > > + We used CFRunLoopWakeUp to wake up runloop to process source, which seems to be slow according to profiling. To > > > + avoid calling CFRunLoopWakeUp, use CFRunloopSource1 instead of CFRunloopSource0. > > > > What is CFRunloopSource1? Why is this faster? If it's not the current > > default, what is the reason it's not and what potential downsides are there? > > It's version 1 source in CFRunloop: > https://developer.apple.com/documentation/corefoundation/cfrunloopsource-rhr > > According to our profiling on test like > OpenSource/PerformanceTests/IndexedDB/basic/objectstore-get.html, we spent a > lot of time on waking up the runloop when receiving IPC message. And we > tried libdispatch, which uses version 1 source for dispatching to runloop, > and is much faster. So we think we could probably adopt this for better > performance. Does that mean this is not a speedup on it's own? 1580783 22 sihui_liu 2019-10-16 17:22:19 -0700 (In reply to Sam Weinig from comment #21) > (In reply to Sihui Liu from comment #18) > > (In reply to Sam Weinig from comment #15) > > > Comment on attachment 381103 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=381103&action=review > > > > > > > Source/WTF/ChangeLog:9 > > > > + We used CFRunLoopWakeUp to wake up runloop to process source, which seems to be slow according to profiling. To > > > > + avoid calling CFRunLoopWakeUp, use CFRunloopSource1 instead of CFRunloopSource0. > > > > > > What is CFRunloopSource1? Why is this faster? If it's not the current > > > default, what is the reason it's not and what potential downsides are there? > > > > It's version 1 source in CFRunloop: > > https://developer.apple.com/documentation/corefoundation/cfrunloopsource-rhr > > > > According to our profiling on test like > > OpenSource/PerformanceTests/IndexedDB/basic/objectstore-get.html, we spent a > > lot of time on waking up the runloop when receiving IPC message. And we > > tried libdispatch, which uses version 1 source for dispatching to runloop, > > and is much faster. So we think we could probably adopt this for better > > performance. > > Does that mean this is not a speedup on it's own? It's a speedup on it's own. The patch gives us about 15% speedup on the test we profiled (PerformanceTests/IndexedDB/basic/objectstore-get.html). It saves time by eliminating CFRunLoopWakeUps from the trace. 1580850 23 ggaren 2019-10-16 21:16:51 -0700 > staticMainThreadCaller is used in the #if USE(WEB_THREAD) case, which is a > few lines above. You can change that case to stop using staticMainThreadCaller too. > > Side note: Is dispatch_async better than RunLoop::main().dispatch() in this > > case? Also, is it OK that callOnMainThread will not run in nested run loops? > > The reason why I didn't use RunLoop::main().dispatch() because > RunLoop::main() needs to run after RunLoop::initializeMainRunLoop() and > callOnMainThread does not seem to care about whether we have initialized > mainRunLoop or not. callOnMainThread depends on initializeMainThread() to initialize staticMainThreadCaller. > Why can't callOnMainThread run in nested run loops? Because dispatch_async doesn't run in nested run loops. (I confirmed this theory at https://www.thecave.com/2015/08/10/dispatch-async-to-main-queue-doesnt-work-with-modal-window-on-mac-os-x/.) If there isn't a specific advantage to dispatch_async here, maybe RunLoop::main() is better, to avoid this minor change in behavior. 1580912 24 381180 sihui_liu 2019-10-17 01:30:06 -0700 Created attachment 381180 Patch 1580952 25 sam 2019-10-17 07:59:00 -0700 (In reply to Sihui Liu from comment #22) > (In reply to Sam Weinig from comment #21) > > (In reply to Sihui Liu from comment #18) > > > (In reply to Sam Weinig from comment #15) > > > > Comment on attachment 381103 [details] > > > > Patch > > > > > > > > View in context: > > > > https://bugs.webkit.org/attachment.cgi?id=381103&action=review > > > > > > > > > Source/WTF/ChangeLog:9 > > > > > + We used CFRunLoopWakeUp to wake up runloop to process source, which seems to be slow according to profiling. To > > > > > + avoid calling CFRunLoopWakeUp, use CFRunloopSource1 instead of CFRunloopSource0. > > > > > > > > What is CFRunloopSource1? Why is this faster? If it's not the current > > > > default, what is the reason it's not and what potential downsides are there? > > > > > > It's version 1 source in CFRunloop: > > > https://developer.apple.com/documentation/corefoundation/cfrunloopsource-rhr > > > > > > According to our profiling on test like > > > OpenSource/PerformanceTests/IndexedDB/basic/objectstore-get.html, we spent a > > > lot of time on waking up the runloop when receiving IPC message. And we > > > tried libdispatch, which uses version 1 source for dispatching to runloop, > > > and is much faster. So we think we could probably adopt this for better > > > performance. > > > > Does that mean this is not a speedup on it's own? > > It's a speedup on it's own. The patch gives us about 15% speedup on the test > we profiled (PerformanceTests/IndexedDB/basic/objectstore-get.html). It > saves time by eliminating CFRunLoopWakeUps from the trace. Very nice! 1581043 26 381180 ggaren 2019-10-17 10:40:20 -0700 Comment on attachment 381180 Patch r=me 1581106 27 381217 sihui_liu 2019-10-17 12:58:29 -0700 Created attachment 381217 Patch for landing 1581140 28 commit-queue 2019-10-17 14:09:57 -0700 The commit-queue encountered the following flaky tests while processing attachment 381217: inspector/console/webcore-logging.html bug 203118 (authors: drousso@apple.com and eric.carlson@apple.com) The commit-queue is continuing to process your patch. 1581143 29 commit-queue 2019-10-17 14:10:03 -0700 The commit-queue encountered the following flaky tests while processing attachment 381217: imported/w3c/web-platform-tests/websockets/bufferedAmount-unchanged-by-sync-xhr.any.worker.html bug 202003 (author: youennf@gmail.com) The commit-queue is continuing to process your patch. 1581173 30 381217 commit-queue 2019-10-17 15:05:30 -0700 Comment on attachment 381217 Patch for landing Clearing flags on attachment: 381217 Committed r251261: <https://trac.webkit.org/changeset/251261> 1581174 31 commit-queue 2019-10-17 15:05:33 -0700 All reviewed patches have been landed. Closing bug. 1581177 32 webkit-bug-importer 2019-10-17 15:06:29 -0700 <rdar://problem/56387205> 1581433 33 tsavell 2019-10-18 09:34:03 -0700 It looks like the changes in https://trac.webkit.org/changeset/251261/webkit broke inspector/console/webcore-logging.html History: https://results.webkit.org/?suite=layout-tests&test=inspector%2Fconsole%2Fwebcore-logging.html Diff: --- /Volumes/Data/slave/mojave-release-tests-wk1/build/layout-test-results/inspector/console/webcore-logging-expected.txt +++ /Volumes/Data/slave/mojave-release-tests-wk1/build/layout-test-results/inspector/console/webcore-logging-actual.txt @@ -27,7 +27,9 @@ -- Running test case: Console.Logging.MediaLogging PASS: Media logging disabled. PASS: Media logging has been enabled. -PASS: Media log message should have source 'media'. +FAIL: Media log message should have source 'media'. + Expected: truthy + Actual: false -- Running test case: Console.Logging.LogAsJSONWithoutRepeat PASS: Media logging disabled. This reproduces easily by running the test in iterations. It fails on 251261 but not 251260. 1581435 34 tsavell 2019-10-18 09:39:55 -0700 This also broke inspector/runtime/getProperties.html History https://results.webkit.org/?suite=layout-tests&test=inspector%2Fruntime%2FgetProperties.html 1583159 35 tsavell 2019-10-23 17:06:03 -0700 Reverted r251261 for reason: This broke multiple tests Committed r251514: <https://trac.webkit.org/changeset/251514> 1583171 36 sihui_liu 2019-10-23 17:45:12 -0700 (In reply to Truitt Savell from comment #35) > Reverted r251261 for reason: > > This broke multiple tests > > Committed r251514: <https://trac.webkit.org/changeset/251514> inspector/console/webcore-logging.html was fixed by r251482 (and got reverted too), which fixed the test and made another meaningful bug fix. inspector/runtime/getProperties.html is caused by that the test file doesn't handle error case correctly. (The diff is one error console message.) scrollingcoordinator/ios/non-stable-viewport-scroll.html is flaky by its nature, as I commented in rdar://problem/56410921 and I replied in Slack. Are there any other failure caused by this patch? If yes, what are they? If no, what led this to be reverted? 1583348 37 tsavell 2019-10-24 08:06:24 -0700 (In reply to Sihui Liu from comment #36) > (In reply to Truitt Savell from comment #35) > > Reverted r251261 for reason: > > > > This broke multiple tests > > > > Committed r251514: <https://trac.webkit.org/changeset/251514> > > inspector/console/webcore-logging.html was fixed by r251482 (and got > reverted too), which fixed the test and made another meaningful bug fix. > > inspector/runtime/getProperties.html is caused by that the test file doesn't > handle error case correctly. (The diff is one error console message.) > > scrollingcoordinator/ios/non-stable-viewport-scroll.html is flaky by its > nature, as I commented in rdar://problem/56410921 and I replied in Slack. > > Are there any other failure caused by this patch? If yes, what are they? > If no, what led this to be reverted? Those are the tests that lead us to roll this patch out 1583469 38 ggaren 2019-10-24 12:47:36 -0700 > inspector/console/webcore-logging.html was fixed by r251482 (and got > reverted too), which fixed the test and made another meaningful bug fix. Sounds great! > inspector/runtime/getProperties.html is caused by that the test file doesn't > handle error case correctly. (The diff is one error console message.) Does this mean that inspector/runtime/getProperties.html does fail when this patch is applied? If so, I'd suggest updating the test to handle error or updating the expected result to include the console message when re-landing. > scrollingcoordinator/ios/non-stable-viewport-scroll.html is flaky by its > nature, as I commented in rdar://problem/56410921 and I replied in Slack. Was this test failing sometimes before this patch landed? If so, seems OK to ignore. If not, we probably need to skip this test until it gets fixed. 1583488 39 ggaren 2019-10-24 13:25:49 -0700 > inspector/runtime/getProperties.html is caused by that the test file doesn't handle error case correctly. (The diff is one error console message.) For this case, let's use if (window.internals) window.internals.settings.setUnhandledPromiseRejectionToConsoleEnabled(false); and then update the test result not to expect a console message. 1583507 40 ggaren 2019-10-24 13:46:06 -0700 > scrollingcoordinator/ios/non-stable-viewport-scroll.html is flaky by its > nature, as I commented in rdar://problem/56410921 and I replied in Slack. For this case, the test is marked as flaky, so I think it's OK to land without fixing it, since doing so won't make the bots red. (We analyzed this test a bit, and fixing it will be non-trivial. More information from <rdar://problem/56410921>: "Talked to Simon, the test is flaky without my patch. We found some graphics work is done after callback of uiController.doAfterPresentationUpdate and RenderLayerCompositor::layerTreeAsText, but layerTreeAsText should show us the final result. With my patch, some of those work (result is not reflected in the -expected.txt file) has bigger chance to finish sooner than layerTreeAsText, so the test has become more flaky." ) 1583727 41 koivisto 2019-10-25 01:53:33 -0700 Seems like this patch was a significant (~11%) StyleBench perf regression: https://perf.webkit.org/v3/#/charts?since=1571129192465&paneList=((20-1649-36468600-null-(5-2.5-500))) Rollout brought the perf back where it was. This should be looked into before relanding. 1583785 42 sihui_liu 2019-10-25 06:22:34 -0700 (In reply to Antti Koivisto from comment #41) > Seems like this patch was a significant (~11%) StyleBench perf regression: > > https://perf.webkit.org/v3/#/charts?since=1571129192465&paneList=((20-1649- > 36468600-null-(5-2.5-500))) > > Rollout brought the perf back where it was. This should be looked into > before relanding. That's surprising! How can I run this test? 1583819 43 ggaren 2019-10-25 08:14:19 -0700 (In reply to Sihui Liu from comment #42) > (In reply to Antti Koivisto from comment #41) > > Seems like this patch was a significant (~11%) StyleBench perf regression: > > > > https://perf.webkit.org/v3/#/charts?since=1571129192465&paneList=((20-1649- > > 36468600-null-(5-2.5-500))) > > > > Rollout brought the perf back where it was. This should be looked into > > before relanding. > > That's surprising! How can I run this test? OpenSource/PerformanceTests/StyleBench/index.html 1583847 44 koivisto 2019-10-25 09:07:53 -0700 cd PerformanceTests/StyleBench python -m SimpleHTTPServer 8000 navigate to localhost:8000 Alternatively individual subtests can be run with web server by opening PerformanceTests/StyleBench/InteractiveRunner.html 1583849 45 koivisto 2019-10-25 09:08:32 -0700 > Alternatively individual subtests can be run with web server by opening *without web server 1583928 46 rniwa 2019-10-25 11:26:46 -0700 There is also Tools/Scripts/run-perf-tests <path> 1618692 47 koivisto 2020-02-13 13:43:54 -0800 Are there any show stoppers for landing this? It might help with first paint performance (type 1 sources don't prevent runloop observers from firing and so don't delay layer flushes). I don't think StyleBench regression is a show stopper, it is not a zero regression test. It sounded like it was a bug in how measurements are made we understood what was wrong. 1618701 48 sihui_liu 2020-02-13 14:05:31 -0800 (In reply to Antti Koivisto from comment #47) > Are there any show stoppers for landing this? It might help with first paint > performance (type 1 sources don't prevent runloop observers from firing and > so don't delay layer flushes). > > I don't think StyleBench regression is a show stopper, it is not a zero > regression test. It sounded like it was a bug in how measurements are made > we understood what was wrong. No,the we could try landing this again. 1619111 49 nham 2020-02-14 11:42:32 -0800 I still think we should try to commit this but I'm not sure if this will help first paint perf due to excessive batching before an observer fires (namely the one that causes layer flush to occur). As far as I can tell, it looks like servicing a type 0 source will still turn the entire run loop and fire observers. After a type 0 source is handled: 1. The GCD main queue port is polled with 0 timeout; if this succeeds, go to (5) skipping before/after waiting observers 2. Before waiting observers fired 3. wakeup/timer/source1 port set polled with a 0 timeout 4. after waiting observers fired 5. GCD main queue / wakeup / timer / source1 callback runs This patch mainly seems to optimize things by using a source1 mach port to wake up the run loop instead of CFRunLoopWakeUp. This is more efficient because this patch just sends a mach message, while CFRunLoopWakeUp both takes a lock and sends a mach message. But both before and after this patch, we can end up handling a bunch of IPC messages in a row before a run loop observer fires because of the way WTF::RunLoop::performWork batches up work. 1619115 50 simon.fraser 2020-02-14 11:47:22 -0800 (In reply to Ben Nham from comment #49) > I still think we should try to commit this but I'm not sure if this will > help first paint perf due to excessive batching before an observer fires > (namely the one that causes layer flush to occur). As far as I can tell, it > looks like servicing a type 0 source will still turn the entire run loop and > fire observers. It does not fire "before waiting" observers, which the CoreAnimation commit observer is: https://github.com/opensource-apple/CF/blob/master/CFRunLoop.c#L2403 https://github.com/opensource-apple/CF/blob/master/CFRunLoop.c#L2425 After a type 0 source is handled: > > 1. The GCD main queue port is polled with 0 timeout; if this succeeds, go to > (5) skipping before/after waiting observers > 2. Before waiting observers fired No, because of "if (!poll". > 3. wakeup/timer/source1 port set polled with a 0 timeout > 4. after waiting observers fired > 5. GCD main queue / wakeup / timer / source1 callback runs > > This patch mainly seems to optimize things by using a source1 mach port to > wake up the run loop instead of CFRunLoopWakeUp. This is more efficient > because this patch just sends a mach message, while CFRunLoopWakeUp both > takes a lock and sends a mach message. But both before and after this patch, > we can end up handling a bunch of IPC messages in a row before a run loop > observer fires because of the way WTF::RunLoop::performWork batches up work. 1619123 51 nham 2020-02-14 11:57:19 -0800 I see, I missed that. So the hypothesis is basically that an IPC that causes a layout to occur in a source 0 callback, which then calls flushLayers, and then CA's auto-commit observer doesn't run as soon as it should because of this source 0 behavior? 1619156 52 simon.fraser 2020-02-14 13:19:49 -0800 (In reply to Ben Nham from comment #51) > I see, I missed that. So the hypothesis is basically that an IPC that causes > a layout to occur in a source 0 callback, which then calls flushLayers, and > then CA's auto-commit observer doesn't run as soon as it should because of > this source 0 behavior? More simply put, a flood of IPC messages can postpone rendering for many event loop cycles. 1619693 53 390927 sihui_liu 2020-02-17 09:59:53 -0800 Created attachment 390927 Patch 1622319 54 391575 sihui_liu 2020-02-24 14:19:34 -0800 Created attachment 391575 Patch 1622845 55 391705 sihui_liu 2020-02-25 17:10:17 -0800 Created attachment 391705 Patch 1660880 56 401478 ggaren 2020-06-09 14:57:17 -0700 Created attachment 401478 Patch - just the RunLoop parts Let's see if we can land the refactoring part of this patch without the behavior change, to shrink the diff and help move to just one function queue. 1661081 57 401478 sihui_liu 2020-06-09 21:53:56 -0700 Comment on attachment 401478 Patch - just the RunLoop parts Looks green. Do we need a new bug for this change? 1661088 58 401478 koivisto 2020-06-09 23:32:39 -0700 Comment on attachment 401478 Patch - just the RunLoop parts View in context: https://bugs.webkit.org/attachment.cgi?id=401478&action=review > Source/WTF/ChangeLog:3 > + Use CFRunLoopSource1 for faster task dispatch The tittle does not describe this patch. 1661302 59 401478 ggaren 2020-06-10 12:50:25 -0700 Comment on attachment 401478 Patch - just the RunLoop parts Yeah, I'll obsolete this patch and post in a separate bug. 1661306 60 ggaren 2020-06-10 12:55:09 -0700 Refactoring patch is now posted @ https://bugs.webkit.org/show_bug.cgi?id=213043. 1707336 61 414072 ggaren 2020-11-13 11:54:53 -0800 Created attachment 414072 Patch 1707337 62 414072 ggaren 2020-11-13 11:56:19 -0800 Comment on attachment 414072 Patch Re-based patch. 1707339 63 414073 ggaren 2020-11-13 12:00:26 -0800 Created attachment 414073 Patch 1707422 64 sihui_liu 2020-11-13 16:05:59 -0800 Note using version 1 source may cause issue in our test runner, details in <rdar://problem/59637925>. 1707941 65 414266 ggaren 2020-11-16 12:17:58 -0800 Created attachment 414266 Patch 1708110 66 414303 ggaren 2020-11-16 20:40:28 -0800 Created attachment 414303 Patch 1709622 67 414710 ggaren 2020-11-20 13:28:14 -0800 Created attachment 414710 microbenchmark Uploading a microbenchmark for posterity. Interestingly, the fastest case for V0 and V1 is about equal. But on average V0 is 2X slower; and in the worst case, it's 5X slower, causing a full 2ms of latency! 1709623 68 414303 ggaren 2020-11-20 13:29:37 -0800 Comment on attachment 414303 Patch Tests pass and microbenchmark confirms a speedup. So, I think this is ready for review. 1709643 69 ews-feeder 2020-11-20 14:04:47 -0800 Committed r270132: <https://trac.webkit.org/changeset/270132> All reviewed patches have been landed. Closing bug and clearing flags on attachment 414303. 1711076 70 ryanhaddad 2020-12-01 10:00:55 -0800 Reverted r270132 for reason: Caused at least one regression test failure (webkit.org/b/219401) Committed r270311: <https://trac.webkit.org/changeset/270311> 1711149 71 ryanhaddad 2020-12-01 13:47:01 -0800 (In reply to Ryan Haddad from comment #70) > Caused at least one regression test failure (webkit.org/b/219401) It appears that these WPT worklet tests that had become flaky on iOS are OK again after the revert, so these were also affected: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&suite=layout-tests&test=imported%2Fw3c%2Fweb-platform-tests%2Fworklets%2Fanimation-worklet-csp.https.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fworklets%2Fanimation-worklet-referrer.https.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fworklets%2Flayout-worklet-referrer.https.html https://build.webkit.org/results/Apple-iOS-14-Simulator-Release-WK2-Tests/r270300%20(1074)/results.html 1713747 72 415939 ggaren 2020-12-10 15:35:37 -0800 Created attachment 415939 Patch 1713748 73 ggaren 2020-12-10 15:36:28 -0800 Previous test failures should be resolved by: https://bugs.webkit.org/show_bug.cgi?id=219717 https://bugs.webkit.org/show_bug.cgi?id=219656 1713755 74 ews-feeder 2020-12-10 16:17:48 -0800 Committed r270661: <https://trac.webkit.org/changeset/270661> All reviewed patches have been landed. Closing bug and clearing flags on attachment 415939. 1714295 75 ryanhaddad 2020-12-12 21:22:36 -0800 Looks like there are still more failures/timeouts because of this change. The failures are a bit difficult to enumerate because some are flaky, but here are the ones that clearly start with this change: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&test=fast%2Ftext%2Fcanvas-color-fonts%2FCOLR.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-001.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-003.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-001.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-002.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-003.html 1714296 76 ryanhaddad 2020-12-12 21:27:20 -0800 Two more that appear to be iOS specific: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&test=imported%2Fw3c%2Fweb-platform-tests%2Fworkers%2Fmodules%2Fshared-worker-import-csp.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fworklets%2Flayout-worklet-csp.https.html 1714297 77 ryanhaddad 2020-12-12 21:40:57 -0800 Another: https://results.webkit.org/?suite=layout-tests&test=inspector%2Fformatting%2Fsource-map-javascript-2.html 1714298 78 ryanhaddad 2020-12-12 21:44:20 -0800 Reverted r270661 for reason: Caused layout test failures and timeouts Committed r270746: <https://trac.webkit.org/changeset/270746> 1714299 79 ryanhaddad 2020-12-12 21:46:35 -0800 (In reply to Ryan Haddad from comment #78) > Reverted r270661 for reason: > > Caused layout test failures and timeouts Here is one link that shows all the ones I've found so far: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&suite=layout-tests&test=fast%2Ftext%2Fcanvas-color-fonts%2FCOLR.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-001.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-003.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-001.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-002.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fcss%2Fcss-transitions%2Fproperties-value-inherit-003.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fworkers%2Fmodules%2Fshared-worker-import-csp.html&test=imported%2Fw3c%2Fweb-platform-tests%2Fworklets%2Flayout-worklet-csp.https.html&test=inspector%2Fformatting%2Fsource-map-javascript-2.html&test=inspector%2Fruntime%2Fparse.html 1715362 80 415939 pvollan 2020-12-17 03:30:51 -0800 Comment on attachment 415939 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=415939&action=review > Source/WTF/wtf/cf/RunLoopCF.cpp:76 > + mach_msg_header_t header; > + header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); > + header.msgh_size = sizeof(mach_msg_header_t); > + header.msgh_remote_port = CFMachPortGetPort(m_port.get()); > + header.msgh_local_port = MACH_PORT_NULL; > + header.msgh_id = 0; > + mach_msg_return_t result = mach_msg(&header, MACH_SEND_MSG | MACH_SEND_TIMEOUT, header.msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL); > + RELEASE_ASSERT(result == MACH_MSG_SUCCESS || result == MACH_SEND_TIMED_OUT); > + if (result == MACH_SEND_TIMED_OUT) > + mach_msg_destroy(&header); Could this be simplified by using CFMessagePort instead of CFMachPort? 1715392 81 ggaren 2020-12-17 08:42:25 -0800 > Could this be simplified by using CFMessagePort instead of CFMachPort? Unfortunately, CFMessagePortSendRequest still locks a pthread_mutex_t before sending, and pthread_mutex_t is most of the overhead we are trying to avoid. 1720998 82 pvollan 2021-01-20 14:14:12 -0800 (In reply to Geoffrey Garen from comment #81) > > Could this be simplified by using CFMessagePort instead of CFMachPort? > > Unfortunately, CFMessagePortSendRequest still locks a pthread_mutex_t before > sending, and pthread_mutex_t is most of the overhead we are trying to avoid. Ah, got it, thanks! If there is a little bit of flakiness associated with this patch, could this possibly be addressed by dispatching off a run loop observer for the main thread run loop, in order to make the ordering deterministic? 1721374 83 ggaren 2021-01-21 15:27:31 -0800 > If there is a little bit of flakiness associated with this patch, could this > possibly be addressed by dispatching off a run loop observer for the main > thread run loop, in order to make the ordering deterministic? I had the same thought! :P I do think that approach *could* work. I spent a few days trying to make that work, but I ended up with too many test failures. It's possible that I did not succeed in making behavior more deterministic; or maybe I succeeded in making behavior more deterministic, but deterministically failing. One gotcha is that run loop observers don't run at *exactly* the same point as run loop sources. Another gotcha is that the relative order of run loop observers is different in the case where you first call CFRunLoopRun() vs the case where you were already sleeping inside CFRunLoopRun(). My next move is to A/B test to see if the change is worth it. If it is, I think I can make things more deterministic by standardizing how we schedule tasks. (I started this in https://trac.webkit.org/changeset/271493/webkit.) 380807 2019-10-11 19:22:52 -0700 2019-10-16 13:12:39 -0700 Patch bug-202874-20191011192236.patch text/plain 4746 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMDA5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc3NmQ0Y2QxMzRlZDYyNjc0MjJlOGQw MTk5N2EzYTRkMmQ1ODZhNjMuLmNiMmU4YjM5OWJlYzFkZDUyZWM1MWIzZTE1MTdkNDNiY2U2OTMx Y2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTktMTAtMTEgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgZGlzcGF0Y2hfYXN5bmMgZm9yIGZhc3RlciB0 YXNrIGRpc3BhdGNoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMDI4NzQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBSdW5Mb29wOjp3YWtlVXAoKSBvbiBtYWluIHRocmVhZCBhbmQgcGVyZm9ybVNlbGVjdG9y T25NYWluVGhyZWFkIHdvdWxkIGludm9rZSBDRlJ1bmxvb3BXYWtlVXAsIHdoaWNoIGlzIAorICAg ICAgICBleHBlbnNpdmUgYWNjb3JkaW5nIHRvIHRyYWNlLCB3aGlsZSBkaXNwYXRjaF9hc3luYyBk b2VzIG5vdC4KKworICAgICAgICBBZnRlciB0aGlzIGNoYW5nZSwgcnVubmluZyBQZXJmb3JtYW5j ZVRlc3RzL0luZGV4ZWREQi9iYXNpYy9vYmplY3RzdG9yZS1nZXQuaHRtbCBvbiBhIHJlbGVhc2Ug YnVpbGQgbWluaWJyb3dzZXIKKyAgICAgICAgaXMgYWJvdXQgMjAlIGZhc3Rlci4KKworICAgICAg ICAqIHd0Zi9SdW5Mb29wLmNwcDoKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6ZGlzcGF0Y2gpOgor ICAgICAgICAqIHd0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW06CisgICAgICAgIChXVEY6Omlu aXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0pOgorICAgICAgICAoV1RGOjppbml0aWFsaXplTWFp blRocmVhZFRvUHJvY2Vzc01haW5UaHJlYWRQbGF0Zm9ybSk6CisgICAgICAgIChXVEY6OnNjaGVk dWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQpOgorICAgICAgICAoLVtKU1dURk1haW5U aHJlYWRDYWxsZXIgY2FsbF0pOiBEZWxldGVkLgorCiAyMDE5LTEwLTExICBKb25hdGhhbiBCZWRh cmQgIDxqYmVkYXJkQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91 dCByMjUwOTQ1LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAgYi9Tb3Vy Y2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAppbmRleCAxYmUyMmQ4MDlmM2RlNjk1NTk5NjY1ZDIxMzBj OWRkY2YxYjAwZTcwLi5jNzBmZTU4OGI2NTUxMWJkYzQ5ZWFiNjljOTdmNTcyYWNkN2U1N2Y3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2lu Y2x1ZGUgPHd0Zi9SdW5Mb29wLmg+CiAKKyNpbmNsdWRlIDx3dGYvQmxvY2tQdHIuaD4KICNpbmNs dWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+ CiAjaW5jbHVkZSA8d3RmL1RocmVhZFNwZWNpZmljLmg+CkBAIC0xMjcsNiArMTI4LDE2IEBAIHZv aWQgUnVuTG9vcDo6cGVyZm9ybVdvcmsoKQogCiB2b2lkIFJ1bkxvb3A6OmRpc3BhdGNoKEZ1bmN0 aW9uPHZvaWQgKCk+JiYgZnVuY3Rpb24pCiB7CisjaWYgUExBVEZPUk0oQ09DT0EpCisgICAgLy8g RmFzdCBwYXRoIHRvIGF2b2lkIENGUnVubG9vcFdha2V1cC4KKyAgICBpZiAodGhpcyA9PSBzX21h aW5SdW5Mb29wKSB7CisgICAgICAgIGRpc3BhdGNoX2FzeW5jKGRpc3BhdGNoX2dldF9tYWluX3F1 ZXVlKCksIG1ha2VCbG9ja1B0cihbZnVuY3Rpb24gPSBXVEZNb3ZlKGZ1bmN0aW9uKV0oKSB7Cisg ICAgICAgICAgICBmdW5jdGlvbigpOworICAgICAgICB9KS5nZXQoKSk7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisjZW5kaWYKKwogICAgIHsKICAgICAgICAgYXV0byBsb2NrZXIgPSBob2xkTG9j ayhtX2Z1bmN0aW9uUXVldWVMb2NrKTsKICAgICAgICAgbV9mdW5jdGlvblF1ZXVlLmFwcGVuZChX VEZNb3ZlKGZ1bmN0aW9uKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWlu VGhyZWFkQ29jb2EubW0gYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW0K aW5kZXggNThiNmY5MWExNmEyZjYyNWVlNTU4OWRhMjUxZDhjYmQ3MGQ4NzMyYy4uZTA5Mjg0OWQx NTc4YzE1NTA0OTUyODVlM2U2NzZmNjRlMGVkOTY1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93 dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tCisrKyBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL01h aW5UaHJlYWRDb2NvYS5tbQpAQCAtMzYsNiArMzYsNyBAQAogI2ltcG9ydCA8d3RmL0Fzc2VydGlv bnMuaD4KICNpbXBvcnQgPHd0Zi9IYXNoU2V0Lmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+ CisjaW1wb3J0IDx3dGYvUnVuTG9vcC5oPgogI2ltcG9ydCA8d3RmL1NjaGVkdWxlUGFpci5oPgog I2ltcG9ydCA8d3RmL1RocmVhZGluZy5oPgogCkBAIC00MywyMiArNDQsOCBAQAogI2luY2x1ZGUg PHd0Zi9pb3MvV2ViQ29yZVRocmVhZC5oPgogI2VuZGlmCiAKLUBpbnRlcmZhY2UgSlNXVEZNYWlu VGhyZWFkQ2FsbGVyIDogTlNPYmplY3QKLS0gKHZvaWQpY2FsbDsKLUBlbmQKLQotQGltcGxlbWVu dGF0aW9uIEpTV1RGTWFpblRocmVhZENhbGxlcgotCi0tICh2b2lkKWNhbGwKLXsKLSAgICBXVEY6 OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKLX0KLQotQGVuZAotCiBuYW1lc3Bh Y2UgV1RGIHsKIAotc3RhdGljIEpTV1RGTWFpblRocmVhZENhbGxlciogc3RhdGljTWFpblRocmVh ZENhbGxlcjsKIHN0YXRpYyBib29sIGlzVGltZXJQb3N0ZWQ7IC8vIFRoaXMgaXMgb25seSBhY2Nl c3NlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCiBzdGF0aWMgYm9vbCBtYWluVGhyZWFkRXN0YWJsaXNo ZWRBc1B0aHJlYWRNYWluIHsgZmFsc2UgfTsKIHN0YXRpYyBwdGhyZWFkX3QgbWFpblRocmVhZFB0 aHJlYWQgeyBudWxscHRyIH07CkBAIC03MSw5ICs1OCw2IEBAIHN0YXRpYyBUaHJlYWQqIHNXZWJU aHJlYWQ7CiAKIHZvaWQgaW5pdGlhbGl6ZU1haW5UaHJlYWRQbGF0Zm9ybSgpCiB7Ci0gICAgQVNT RVJUKCFzdGF0aWNNYWluVGhyZWFkQ2FsbGVyKTsKLSAgICBzdGF0aWNNYWluVGhyZWFkQ2FsbGVy ID0gW1tKU1dURk1haW5UaHJlYWRDYWxsZXIgYWxsb2NdIGluaXRdOwotCiAjaWYgIVVTRShXRUJf VEhSRUFEKQogICAgIG1haW5UaHJlYWRFc3RhYmxpc2hlZEFzUHRocmVhZE1haW4gPSBmYWxzZTsK ICAgICBtYWluVGhyZWFkUHRocmVhZCA9IHB0aHJlYWRfc2VsZigpOwpAQCAtOTEsOSArNzUsNiBA QCB2b2lkIGluaXRpYWxpemVNYWluVGhyZWFkVG9Qcm9jZXNzTWFpblRocmVhZFBsYXRmb3JtKCkK ICAgICBpZiAoIXB0aHJlYWRfbWFpbl9ucCgpKQogICAgICAgICBOU0xvZyhAIldlYktpdCBUaHJl YWRpbmcgVmlvbGF0aW9uIC0gaW5pdGlhbCB1c2Ugb2YgV2ViS2l0IGZyb20gYSBzZWNvbmRhcnkg dGhyZWFkLiIpOwogCi0gICAgQVNTRVJUKCFzdGF0aWNNYWluVGhyZWFkQ2FsbGVyKTsKLSAgICBz dGF0aWNNYWluVGhyZWFkQ2FsbGVyID0gW1tKU1dURk1haW5UaHJlYWRDYWxsZXIgYWxsb2NdIGlu aXRdOwotCiAgICAgbWFpblRocmVhZEVzdGFibGlzaGVkQXNQdGhyZWFkTWFpbiA9IHRydWU7CiAg ICAgbWFpblRocmVhZFB0aHJlYWQgPSAwOwogICAgIG1haW5UaHJlYWROU1RocmVhZCA9IG5pbDsK QEAgLTEyMyw4ICsxMDQsNiBAQCBzdGF0aWMgdm9pZCBwb3N0VGltZXIoKQogCiB2b2lkIHNjaGVk dWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQoKQogewotICAgIEFTU0VSVChzdGF0aWNN YWluVGhyZWFkQ2FsbGVyKTsKLQogICAgIGlmIChpc1dlYlRocmVhZCgpKSB7CiAgICAgICAgIHBv c3RUaW1lcigpOwogICAgICAgICByZXR1cm47CkBAIC0xMzIsMTIgKzExMSwxNiBAQCB2b2lkIHNj aGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQoKQogICAgIAogICAgIGlmIChtYWlu VGhyZWFkRXN0YWJsaXNoZWRBc1B0aHJlYWRNYWluKSB7CiAgICAgICAgIEFTU0VSVCghbWFpblRo cmVhZE5TVGhyZWFkKTsKLSAgICAgICAgW3N0YXRpY01haW5UaHJlYWRDYWxsZXIgcGVyZm9ybVNl bGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3aXRoT2JqZWN0Om5pbCB3YWl0VW50 aWxEb25lOk5PXTsKKyAgICAgICAgUnVuTG9vcDo6bWFpbigpLmRpc3BhdGNoKFtdIHsKKyAgICAg ICAgICAgIFdURjo6ZGlzcGF0Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOworICAgICAgICB9 KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAogICAgIEFTU0VSVChtYWluVGhyZWFkTlNUaHJl YWQpOwotICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVyIHBlcmZvcm1TZWxlY3RvcjpAc2VsZWN0 b3IoY2FsbCkgb25UaHJlYWQ6bWFpblRocmVhZE5TVGhyZWFkIHdpdGhPYmplY3Q6bmlsIHdhaXRV bnRpbERvbmU6Tk9dOworICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbXSB7CisgICAgICAg IFdURjo6ZGlzcGF0Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOworICAgIH0pOwogfQogCiB2 b2lkIGRpc3BhdGNoQXN5bmNPbk1haW5UaHJlYWRXaXRoV2ViVGhyZWFkTG9ja0lmTmVlZGVkKHZv aWQgKF5ibG9jaykoKSkK 380845 2019-10-13 08:48:05 -0700 2019-10-13 08:52:25 -0700 patch - mach message ro.txt text/plain 2688 ggaren SW5kZXg6IFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RG L3d0Zi9SdW5Mb29wLmgJKHJldmlzaW9uIDI1MTA1MCkKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxv b3AuaAkod29ya2luZyBjb3B5KQpAQCAtMTc4LDkgKzE3OCwxMCBAQCBwcml2YXRlOgogCiAgICAg TG9jayBtX2xvb3BMb2NrOwogI2VsaWYgVVNFKENPQ09BX0VWRU5UX0xPT1ApCi0gICAgc3RhdGlj IHZvaWQgcGVyZm9ybVdvcmsodm9pZCopOworICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKENG TWFjaFBvcnRSZWYsIHZvaWQqIG1zZywgQ0ZJbmRleCBzaXplLCB2b2lkKiBpbmZvKTsKICAgICBS ZXRhaW5QdHI8Q0ZSdW5Mb29wUmVmPiBtX3J1bkxvb3A7CiAgICAgUmV0YWluUHRyPENGUnVuTG9v cFNvdXJjZVJlZj4gbV9ydW5Mb29wU291cmNlOworICAgIFJldGFpblB0cjxDRk1hY2hQb3J0UmVm PiBtX3BvcnQ7CiAjZWxpZiBVU0UoR0xJQl9FVkVOVF9MT09QKQogICAgIEdSZWZQdHI8R01haW5D b250ZXh0PiBtX21haW5Db250ZXh0OwogICAgIFZlY3RvcjxHUmVmUHRyPEdNYWluTG9vcD4+IG1f bWFpbkxvb3BzOwpJbmRleDogU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCShyZXZpc2lvbiAyNTEwNTAp CisrKyBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0z MiwyMiArMzIsMjQgQEAKIAogbmFtZXNwYWNlIFdURiB7CiAKLXZvaWQgUnVuTG9vcDo6cGVyZm9y bVdvcmsodm9pZCogY29udGV4dCkKK3ZvaWQgUnVuTG9vcDo6cGVyZm9ybVdvcmsoQ0ZNYWNoUG9y dFJlZiwgdm9pZCosIENGSW5kZXgsIHZvaWQqIGluZm8pCiB7CiAgICAgQXV0b2RyYWluZWRQb29s IHBvb2w7Ci0gICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGNvbnRleHQpLT5wZXJmb3JtV29yaygp OworICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihpbmZvKS0+cGVyZm9ybVdvcmsoKTsKIH0KIAog UnVuTG9vcDo6UnVuTG9vcCgpCiAgICAgOiBtX3J1bkxvb3AoQ0ZSdW5Mb29wR2V0Q3VycmVudCgp KQogewotICAgIENGUnVuTG9vcFNvdXJjZUNvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgMCwg MCwgMCwgMCwgMCwgMCwgMCwgcGVyZm9ybVdvcmsgfTsKLSAgICBtX3J1bkxvb3BTb3VyY2UgPSBh ZG9wdENGKENGUnVuTG9vcFNvdXJjZUNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCAwLCAmY29u dGV4dCkpOworICAgIENGTWFjaFBvcnRDb250ZXh0IGNvbnRleHQgPSB7IDAsIHRoaXMsIG51bGxw dHIsIG51bGxwdHIsIG51bGxwdHIgfTsKKyAgICBtX3BvcnQgPSBhZG9wdENGKENGTWFjaFBvcnRD cmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwgcGVyZm9ybVdvcmssICZjb250ZXh0LCBudWxscHRy KSk7CisgICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlUnVuTG9v cFNvdXJjZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBtX3BvcnQuZ2V0KCksIDApKTsKICAgICBDRlJ1 bkxvb3BBZGRTb3VyY2UobV9ydW5Mb29wLmdldCgpLCBtX3J1bkxvb3BTb3VyY2UuZ2V0KCksIGtD RlJ1bkxvb3BDb21tb25Nb2Rlcyk7CiB9CiAKIFJ1bkxvb3A6On5SdW5Mb29wKCkKIHsKKyAgICBD Rk1hY2hQb3J0SW52YWxpZGF0ZShtX3BvcnQuZ2V0KCkpOwogICAgIENGUnVuTG9vcFNvdXJjZUlu dmFsaWRhdGUobV9ydW5Mb29wU291cmNlLmdldCgpKTsKIH0KIApAQCAtNTgsOCArNjAsMTYgQEAg dm9pZCBSdW5Mb29wOjpydW5Gb3JEdXJhdGlvbihTZWNvbmRzIGR1cgogCiB2b2lkIFJ1bkxvb3A6 Ondha2VVcCgpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlU2lnbmFsKG1fcnVuTG9vcFNvdXJjZS5n ZXQoKSk7Ci0gICAgQ0ZSdW5Mb29wV2FrZVVwKG1fcnVuTG9vcC5nZXQoKSk7CisgICAgbWFjaF9t c2dfaGVhZGVyX3QgaGVhZGVyOworICAgIGhlYWRlci5tc2doX2JpdHMgPSBNQUNIX01TR0hfQklU UyhNQUNIX01TR19UWVBFX0NPUFlfU0VORCwgMCk7CisgICAgaGVhZGVyLm1zZ2hfc2l6ZSA9IHNp emVvZihtYWNoX21zZ19oZWFkZXJfdCk7CisgICAgaGVhZGVyLm1zZ2hfcmVtb3RlX3BvcnQgPSBD Rk1hY2hQb3J0R2V0UG9ydChtX3BvcnQuZ2V0KCkpOworICAgIGhlYWRlci5tc2doX2xvY2FsX3Bv cnQgPSBNQUNIX1BPUlRfTlVMTDsKKyAgICBoZWFkZXIubXNnaF9pZCA9IDA7CisgICAgbWFjaF9t c2dfcmV0dXJuX3QgcmVzdWx0ID0gbWFjaF9tc2coJmhlYWRlciwgTUFDSF9TRU5EX01TRyB8IE1B Q0hfU0VORF9USU1FT1VULCBoZWFkZXIubXNnaF9zaXplLCAwLCBNQUNIX1BPUlRfTlVMTCwgMCwg TUFDSF9QT1JUX05VTEwpOworICAgIFJFTEVBU0VfQVNTRVJUKHJlc3VsdCA9PSBNQUNIX01TR19T VUNDRVNTIHx8IHJlc3VsdCA9PSBNQUNIX1NFTkRfVElNRURfT1VUKTsKKyAgICBpZiAocmVzdWx0 ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpCisgICAgICAgIG1hY2hfbXNnX2Rlc3Ryb3koJmhlYWRl cik7CiB9CiAKIFJ1bkxvb3A6OkN5Y2xlUmVzdWx0IFJ1bkxvb3A6OmN5Y2xlKGNvbnN0IFN0cmlu ZyYgbW9kZSkK 380846 2019-10-13 08:52:03 -0700 2019-10-14 20:26:46 -0700 patch - mach message ro.txt text/plain 2824 ggaren SW5kZXg6IFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RG L3d0Zi9SdW5Mb29wLmgJKHJldmlzaW9uIDI1MTA1MCkKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxv b3AuaAkod29ya2luZyBjb3B5KQpAQCAtMTc4LDkgKzE3OCwxMCBAQCBwcml2YXRlOgogCiAgICAg TG9jayBtX2xvb3BMb2NrOwogI2VsaWYgVVNFKENPQ09BX0VWRU5UX0xPT1ApCi0gICAgc3RhdGlj IHZvaWQgcGVyZm9ybVdvcmsodm9pZCopOworICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKENG TWFjaFBvcnRSZWYsIHZvaWQqIG1zZywgQ0ZJbmRleCBzaXplLCB2b2lkKiBpbmZvKTsKICAgICBS ZXRhaW5QdHI8Q0ZSdW5Mb29wUmVmPiBtX3J1bkxvb3A7CiAgICAgUmV0YWluUHRyPENGUnVuTG9v cFNvdXJjZVJlZj4gbV9ydW5Mb29wU291cmNlOworICAgIFJldGFpblB0cjxDRk1hY2hQb3J0UmVm PiBtX3BvcnQ7CiAjZWxpZiBVU0UoR0xJQl9FVkVOVF9MT09QKQogICAgIEdSZWZQdHI8R01haW5D b250ZXh0PiBtX21haW5Db250ZXh0OwogICAgIFZlY3RvcjxHUmVmUHRyPEdNYWluTG9vcD4+IG1f bWFpbkxvb3BzOwpJbmRleDogU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCShyZXZpc2lvbiAyNTEwNTAp CisrKyBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0y OCwyNiArMjgsMjkgQEAKIAogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9u Lmg+CiAjaW5jbHVkZSA8ZGlzcGF0Y2gvZGlzcGF0Y2guaD4KKyNpbmNsdWRlIDxtYWNoL21hY2gu aD4KICNpbmNsdWRlIDx3dGYvQXV0b2RyYWluZWRQb29sLmg+CiAKIG5hbWVzcGFjZSBXVEYgewog Ci12b2lkIFJ1bkxvb3A6OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6 OnBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQog ewogICAgIEF1dG9kcmFpbmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihj b250ZXh0KS0+cGVyZm9ybVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbykt PnBlcmZvcm1Xb3JrKCk7CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29w KENGUnVuTG9vcEdldEN1cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNv bnRleHQgPSB7IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0g ICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxs b2NhdG9yRGVmYXVsdCwgMCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250 ZXh0ID0geyAwLCB0aGlzLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0 ID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1X b3JrLCAmY29udGV4dCwgbnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0Yo Q0ZNYWNoUG9ydENyZWF0ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0 LmdldCgpLCAwKSk7CiAgICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9y dW5Mb29wU291cmNlLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29w Ojp+UnVuTG9vcCgpCiB7CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsK ICAgICBDRlJ1bkxvb3BTb3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9 CiAKQEAgLTU4LDggKzYxLDE2IEBAIHZvaWQgUnVuTG9vcDo6cnVuRm9yRHVyYXRpb24oU2Vjb25k cyBkdXIKIAogdm9pZCBSdW5Mb29wOjp3YWtlVXAoKQogewotICAgIENGUnVuTG9vcFNvdXJjZVNp Z25hbChtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwotICAgIENGUnVuTG9vcFdha2VVcChtX3J1bkxv b3AuZ2V0KCkpOworICAgIG1hY2hfbXNnX2hlYWRlcl90IGhlYWRlcjsKKyAgICBoZWFkZXIubXNn aF9iaXRzID0gTUFDSF9NU0dIX0JJVFMoTUFDSF9NU0dfVFlQRV9DT1BZX1NFTkQsIDApOworICAg IGhlYWRlci5tc2doX3NpemUgPSBzaXplb2YobWFjaF9tc2dfaGVhZGVyX3QpOworICAgIGhlYWRl ci5tc2doX3JlbW90ZV9wb3J0ID0gQ0ZNYWNoUG9ydEdldFBvcnQobV9wb3J0LmdldCgpKTsKKyAg ICBoZWFkZXIubXNnaF9sb2NhbF9wb3J0ID0gTUFDSF9QT1JUX05VTEw7CisgICAgaGVhZGVyLm1z Z2hfaWQgPSAwOworICAgIG1hY2hfbXNnX3JldHVybl90IHJlc3VsdCA9IG1hY2hfbXNnKCZoZWFk ZXIsIE1BQ0hfU0VORF9NU0cgfCBNQUNIX1NFTkRfVElNRU9VVCwgaGVhZGVyLm1zZ2hfc2l6ZSwg MCwgTUFDSF9QT1JUX05VTEwsIDAsIE1BQ0hfUE9SVF9OVUxMKTsKKyAgICBSRUxFQVNFX0FTU0VS VChyZXN1bHQgPT0gTUFDSF9NU0dfU1VDQ0VTUyB8fCByZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVE X09VVCk7CisgICAgaWYgKHJlc3VsdCA9PSBNQUNIX1NFTkRfVElNRURfT1VUKQorICAgICAgICBt YWNoX21zZ19kZXN0cm95KCZoZWFkZXIpOwogfQogCiBSdW5Mb29wOjpDeWNsZVJlc3VsdCBSdW5M b29wOjpjeWNsZShjb25zdCBTdHJpbmcmIG1vZGUpCg== 380851 2019-10-13 14:20:42 -0700 2019-10-14 20:26:46 -0700 patch - getUserMedia.html ro.txt text/plain 3115 ggaren SW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1s Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJN ZWRpYS5odG1sCShyZXZpc2lvbiAyNTEwNTApCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMiwxNSArMiwxNSBA QAogPGh0bWw+CiAgICAgPGhlYWQ+CiAgICAgICAgIDxzY3JpcHQ+Ci0KLSAgICAgICAgICAgIGxl dCBzdHJlYW0gPSBudWxsOworICAgICAgICAgICAgbGV0IHN0cmVhbVByb21pc2UgPSBQcm9taXNl LnJlc29sdmUoKTsKIAogICAgICAgICAgICAgZnVuY3Rpb24gcHJvbXB0Rm9yQ2FwdHVyZSgpCiAg ICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5lbnVt ZXJhdGVEZXZpY2VzKCkudGhlbigoKSA9PiB7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlz ZSA9IG5hdmlnYXRvci5tZWRpYURldmljZXMuZW51bWVyYXRlRGV2aWNlcygpLnRoZW4oKCkgPT4g ewogICAgICAgICAgICAgICAgICAgICByZXR1cm4gbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRV c2VyTWVkaWEoeyBhdWRpbzogZmFsc2UsIHZpZGVvOiB0cnVlIH0pCi0gICAgICAgICAgICAgICAg fSkudGhlbigocykgPT4gewotICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBzOworICAgICAg ICAgICAgICAgIH0pOworCisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChzdHJl YW0pID0+IHsKICAgICAgICAgICAgICAgICAgICAgdmlkZW8uc3JjT2JqZWN0ID0gc3RyZWFtOwog ICAgICAgICAgICAgICAgICAgICBjb25zb2xlLmxvZygiR290IHVzZXIgbWVkaWEiKTsKICAgICAg ICAgICAgICAgICB9KS5jYXRjaCgoZXJyb3IpID0+IGNvbnNvbGUubG9nKGBGYWlsZWQgd2l0aCBl cnJvcjogJHtlcnJvcn1gKSk7CkBAIC0xOCwyMyArMTgsMjkgQEAKIAogICAgICAgICAgICAgZnVu Y3Rpb24gc3RvcChraW5kKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIGxldCBhY3Rp dmVUcmFja3MgPSBbXTsKLSAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJhY2tzKCkuZm9yRWFj aCh0cmFjayA9PiB7Ci0gICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5raW5k ID09IGtpbmQpCi0gICAgICAgICAgICAgICAgICAgICAgICB0cmFjay5zdG9wKCk7Ci0gICAgICAg ICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNrcy5w dXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVhbSkg PT4geworICAgICAgICAgICAgICAgICAgICBsZXQgYWN0aXZlVHJhY2tzID0gW107CisgICAgICAg ICAgICAgICAgICAgIHN0cmVhbS5nZXRUcmFja3MoKS5mb3JFYWNoKHRyYWNrID0+IHsKKyAgICAg ICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5raW5kID09IGtpbmQpCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOworICAgICAgICAgICAgICAgICAg ICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNrcy5wdXNo KHRyYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CisKKyAgICAgICAgICAgICAgICAgICAg aWYgKCFhY3RpdmVUcmFja3MubGVuZ3RoKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBzdHJl YW1Qcm9taXNlRGlkUmVzb2x2ZSA9IGZhbHNlOworICAgICAgICAgICAgICAgICAgICAgICAgdmlk ZW8uc3JjT2JqZWN0ID0gbnVsbDsKKyAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg ICAgIH0pOwotCi0gICAgICAgICAgICAgICAgaWYgKCFhY3RpdmVUcmFja3MubGVuZ3RoKSB7Ci0g ICAgICAgICAgICAgICAgICAgIHN0cmVhbSA9IG51bGw7Ci0gICAgICAgICAgICAgICAgICAgIHZp ZGVvLnNyY09iamVjdCA9IG51bGw7Ci0gICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQog CisgICAgICAgICAgICBsZXQgc3RyZWFtUHJvbWlzZURpZFJlc29sdmUgPSBmYWxzZTsKKwogICAg ICAgICAgICAgZnVuY3Rpb24gaGF2ZVN0cmVhbSgpCiAgICAgICAgICAgICB7Ci0gICAgICAgICAg ICAgICAgcmV0dXJuIHN0cmVhbSAhPT0gbnVsbDsKKyAgICAgICAgICAgICAgICAvLyBPdXIgY2Fs bGVyIHBvbGxzIHJlcGVhdGVkbHkgdW50aWwgb3VyIHByb21pc2UgcmVzb2x2ZXMuCisgICAgICAg ICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChzdHJlYW0pID0+IHN0cmVhbVByb21pc2VEaWRS ZXNvbHZlID0gISFzdHJlYW0pOworICAgICAgICAgICAgICAgIHJldHVybiBzdHJlYW1Qcm9taXNl RGlkUmVzb2x2ZTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgZnVuY3Rpb24gZG9NdWx0 aXBsZUdldFVzZXJNZWRpYVN5bmNocm9ub3VzbHkoKQpAQCAtNTMsMTIgKzU5LDEyIEBACiAKICAg ICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVBdWRpbygpCiAgICAgICAgICAgICB7Ci0gICAgICAg ICAgICAgICAgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVl fSkudGhlbihzID0+IHN0cmVhbSA9IHMpOworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2Ug PSBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWV9KTsKICAg ICAgICAgICAgIH0KIAogICAgICAgICAgICAgZnVuY3Rpb24gY2FwdHVyZUF1ZGlvQW5kVmlkZW8o KQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMu Z2V0VXNlck1lZGlhKHthdWRpbzogdHJ1ZSwgdmlkZW86IHRydWV9KS50aGVuKHMgPT4gc3RyZWFt ID0gcyk7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZSA9IG5hdmlnYXRvci5tZWRpYURl dmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzogdHJ1ZSwgdmlkZW86IHRydWV9KTsKICAgICAgICAg ICAgIH0KICAgICAgICAgPC9zY3JpcHQ+CiAgICAgPGhlYWQ+Cg== 380952 2019-10-14 20:26:46 -0700 2019-10-16 13:12:40 -0700 patch - mach message ro.txt text/plain 8456 ggaren SW5kZXg6IFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RG L3d0Zi9SdW5Mb29wLmgJKHJldmlzaW9uIDI1MTA1MCkKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxv b3AuaAkod29ya2luZyBjb3B5KQpAQCAtMTc4LDkgKzE3OCwxMCBAQCBwcml2YXRlOgogCiAgICAg TG9jayBtX2xvb3BMb2NrOwogI2VsaWYgVVNFKENPQ09BX0VWRU5UX0xPT1ApCi0gICAgc3RhdGlj IHZvaWQgcGVyZm9ybVdvcmsodm9pZCopOworICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKENG TWFjaFBvcnRSZWYsIHZvaWQqIG1zZywgQ0ZJbmRleCBzaXplLCB2b2lkKiBpbmZvKTsKICAgICBS ZXRhaW5QdHI8Q0ZSdW5Mb29wUmVmPiBtX3J1bkxvb3A7CiAgICAgUmV0YWluUHRyPENGUnVuTG9v cFNvdXJjZVJlZj4gbV9ydW5Mb29wU291cmNlOworICAgIFJldGFpblB0cjxDRk1hY2hQb3J0UmVm PiBtX3BvcnQ7CiAjZWxpZiBVU0UoR0xJQl9FVkVOVF9MT09QKQogICAgIEdSZWZQdHI8R01haW5D b250ZXh0PiBtX21haW5Db250ZXh0OwogICAgIFZlY3RvcjxHUmVmUHRyPEdNYWluTG9vcD4+IG1f bWFpbkxvb3BzOwpJbmRleDogU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCShyZXZpc2lvbiAyNTEwNTAp CisrKyBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0y OCwyNiArMjgsMjkgQEAKIAogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9u Lmg+CiAjaW5jbHVkZSA8ZGlzcGF0Y2gvZGlzcGF0Y2guaD4KKyNpbmNsdWRlIDxtYWNoL21hY2gu aD4KICNpbmNsdWRlIDx3dGYvQXV0b2RyYWluZWRQb29sLmg+CiAKIG5hbWVzcGFjZSBXVEYgewog Ci12b2lkIFJ1bkxvb3A6OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6 OnBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQog ewogICAgIEF1dG9kcmFpbmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihj b250ZXh0KS0+cGVyZm9ybVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbykt PnBlcmZvcm1Xb3JrKCk7CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29w KENGUnVuTG9vcEdldEN1cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNv bnRleHQgPSB7IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0g ICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxs b2NhdG9yRGVmYXVsdCwgMCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250 ZXh0ID0geyAwLCB0aGlzLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0 ID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1X b3JrLCAmY29udGV4dCwgbnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0Yo Q0ZNYWNoUG9ydENyZWF0ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0 LmdldCgpLCAwKSk7CiAgICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9y dW5Mb29wU291cmNlLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29w Ojp+UnVuTG9vcCgpCiB7CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsK ICAgICBDRlJ1bkxvb3BTb3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9 CiAKQEAgLTU4LDggKzYxLDE2IEBAIHZvaWQgUnVuTG9vcDo6cnVuRm9yRHVyYXRpb24oU2Vjb25k cyBkdXIKIAogdm9pZCBSdW5Mb29wOjp3YWtlVXAoKQogewotICAgIENGUnVuTG9vcFNvdXJjZVNp Z25hbChtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwotICAgIENGUnVuTG9vcFdha2VVcChtX3J1bkxv b3AuZ2V0KCkpOworICAgIG1hY2hfbXNnX2hlYWRlcl90IGhlYWRlcjsKKyAgICBoZWFkZXIubXNn aF9iaXRzID0gTUFDSF9NU0dIX0JJVFMoTUFDSF9NU0dfVFlQRV9DT1BZX1NFTkQsIDApOworICAg IGhlYWRlci5tc2doX3NpemUgPSBzaXplb2YobWFjaF9tc2dfaGVhZGVyX3QpOworICAgIGhlYWRl ci5tc2doX3JlbW90ZV9wb3J0ID0gQ0ZNYWNoUG9ydEdldFBvcnQobV9wb3J0LmdldCgpKTsKKyAg ICBoZWFkZXIubXNnaF9sb2NhbF9wb3J0ID0gTUFDSF9QT1JUX05VTEw7CisgICAgaGVhZGVyLm1z Z2hfaWQgPSAwOworICAgIG1hY2hfbXNnX3JldHVybl90IHJlc3VsdCA9IG1hY2hfbXNnKCZoZWFk ZXIsIE1BQ0hfU0VORF9NU0cgfCBNQUNIX1NFTkRfVElNRU9VVCwgaGVhZGVyLm1zZ2hfc2l6ZSwg MCwgTUFDSF9QT1JUX05VTEwsIDAsIE1BQ0hfUE9SVF9OVUxMKTsKKyAgICBSRUxFQVNFX0FTU0VS VChyZXN1bHQgPT0gTUFDSF9NU0dfU1VDQ0VTUyB8fCByZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVE X09VVCk7CisgICAgaWYgKHJlc3VsdCA9PSBNQUNIX1NFTkRfVElNRURfT1VUKQorICAgICAgICBt YWNoX21zZ19kZXN0cm95KCZoZWFkZXIpOwogfQogCiBSdW5Mb29wOjpDeWNsZVJlc3VsdCBSdW5M b29wOjpjeWNsZShjb25zdCBTdHJpbmcmIG1vZGUpCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9jb2Nv YS9NYWluVGhyZWFkQ29jb2EubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvY29jb2Ev TWFpblRocmVhZENvY29hLm1tCShyZXZpc2lvbiAyNTEwNTApCisrKyBTb3VyY2UvV1RGL3d0Zi9j b2NvYS9NYWluVGhyZWFkQ29jb2EubW0JKHdvcmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAK ICNpbXBvcnQgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW1wb3J0IDx3dGYvSGFzaFNldC5oPgogI2lt cG9ydCA8d3RmL1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL1J1bkxvb3AuaD4KICNpbXBvcnQg PHd0Zi9TY2hlZHVsZVBhaXIuaD4KICNpbXBvcnQgPHd0Zi9UaHJlYWRpbmcuaD4KIApAQCAtNDMs MjIgKzQ0LDggQEAKICNpbmNsdWRlIDx3dGYvaW9zL1dlYkNvcmVUaHJlYWQuaD4KICNlbmRpZgog Ci1AaW50ZXJmYWNlIEpTV1RGTWFpblRocmVhZENhbGxlciA6IE5TT2JqZWN0Ci0tICh2b2lkKWNh bGw7Ci1AZW5kCi0KLUBpbXBsZW1lbnRhdGlvbiBKU1dURk1haW5UaHJlYWRDYWxsZXIKLQotLSAo dm9pZCljYWxsCi17Ci0gICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7 Ci19Ci0KLUBlbmQKLQogbmFtZXNwYWNlIFdURiB7CiAKLXN0YXRpYyBKU1dURk1haW5UaHJlYWRD YWxsZXIqIHN0YXRpY01haW5UaHJlYWRDYWxsZXI7CiBzdGF0aWMgYm9vbCBpc1RpbWVyUG9zdGVk OyAvLyBUaGlzIGlzIG9ubHkgYWNjZXNzZWQgb24gdGhlIG1haW4gdGhyZWFkLgogc3RhdGljIGJv b2wgbWFpblRocmVhZEVzdGFibGlzaGVkQXNQdGhyZWFkTWFpbiB7IGZhbHNlIH07CiBzdGF0aWMg cHRocmVhZF90IG1haW5UaHJlYWRQdGhyZWFkIHsgbnVsbHB0ciB9OwpAQCAtNzEsOSArNTgsNiBA QCBzdGF0aWMgVGhyZWFkKiBzV2ViVGhyZWFkOwogCiB2b2lkIGluaXRpYWxpemVNYWluVGhyZWFk UGxhdGZvcm0oKQogewotICAgIEFTU0VSVCghc3RhdGljTWFpblRocmVhZENhbGxlcik7Ci0gICAg c3RhdGljTWFpblRocmVhZENhbGxlciA9IFtbSlNXVEZNYWluVGhyZWFkQ2FsbGVyIGFsbG9jXSBp bml0XTsKLQogI2lmICFVU0UoV0VCX1RIUkVBRCkKICAgICBtYWluVGhyZWFkRXN0YWJsaXNoZWRB c1B0aHJlYWRNYWluID0gZmFsc2U7CiAgICAgbWFpblRocmVhZFB0aHJlYWQgPSBwdGhyZWFkX3Nl bGYoKTsKQEAgLTkxLDkgKzc1LDYgQEAgdm9pZCBpbml0aWFsaXplTWFpblRocmVhZFRvUHJvY2Vz c01haW5UaAogICAgIGlmICghcHRocmVhZF9tYWluX25wKCkpCiAgICAgICAgIE5TTG9nKEAiV2Vi S2l0IFRocmVhZGluZyBWaW9sYXRpb24gLSBpbml0aWFsIHVzZSBvZiBXZWJLaXQgZnJvbSBhIHNl Y29uZGFyeSB0aHJlYWQuIik7CiAKLSAgICBBU1NFUlQoIXN0YXRpY01haW5UaHJlYWRDYWxsZXIp OwotICAgIHN0YXRpY01haW5UaHJlYWRDYWxsZXIgPSBbW0pTV1RGTWFpblRocmVhZENhbGxlciBh bGxvY10gaW5pdF07Ci0KICAgICBtYWluVGhyZWFkRXN0YWJsaXNoZWRBc1B0aHJlYWRNYWluID0g dHJ1ZTsKICAgICBtYWluVGhyZWFkUHRocmVhZCA9IDA7CiAgICAgbWFpblRocmVhZE5TVGhyZWFk ID0gbmlsOwpAQCAtMTIzLDggKzEwNCw2IEBAIHN0YXRpYyB2b2lkIHBvc3RUaW1lcigpCiAKIHZv aWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiB7Ci0gICAgQVNTRVJU KHN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwotCiAgICAgaWYgKGlzV2ViVGhyZWFkKCkpIHsKICAg ICAgICAgcG9zdFRpbWVyKCk7CiAgICAgICAgIHJldHVybjsKQEAgLTEzMiwxMiArMTExLDEyIEBA IHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmUKICAgICAKICAgICBpZiAo bWFpblRocmVhZEVzdGFibGlzaGVkQXNQdGhyZWFkTWFpbikgewogICAgICAgICBBU1NFUlQoIW1h aW5UaHJlYWROU1RocmVhZCk7Ci0gICAgICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVyIHBlcmZv cm1TZWxlY3Rvck9uTWFpblRocmVhZDpAc2VsZWN0b3IoY2FsbCkgd2l0aE9iamVjdDpuaWwgd2Fp dFVudGlsRG9uZTpOT107CisgICAgICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbXSB7IFdU Rjo6ZGlzcGF0Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOyB9KTsKICAgICAgICAgcmV0dXJu OwogICAgIH0KIAogICAgIEFTU0VSVChtYWluVGhyZWFkTlNUaHJlYWQpOwotICAgIFtzdGF0aWNN YWluVGhyZWFkQ2FsbGVyIHBlcmZvcm1TZWxlY3RvcjpAc2VsZWN0b3IoY2FsbCkgb25UaHJlYWQ6 bWFpblRocmVhZE5TVGhyZWFkIHdpdGhPYmplY3Q6bmlsIHdhaXRVbnRpbERvbmU6Tk9dOworICAg IFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbXSB7IFdURjo6ZGlzcGF0Y2hGdW5jdGlvbnNGcm9t TWFpblRocmVhZCgpOyB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFzeW5jT25NYWluVGhyZWFkV2l0 aFdlYlRocmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkpCkluZGV4OiBUb29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBU b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbAkocmV2aXNp b24gMjUxMDUwKQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNlck1l ZGlhLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTIsMTUgKzIsMTUgQEAKIDxodG1sPgogICAgIDxo ZWFkPgogICAgICAgICA8c2NyaXB0PgotCi0gICAgICAgICAgICBsZXQgc3RyZWFtID0gbnVsbDsK KyAgICAgICAgICAgIGxldCBzdHJlYW1Qcm9taXNlID0gUHJvbWlzZS5yZXNvbHZlKCk7CiAKICAg ICAgICAgICAgIGZ1bmN0aW9uIHByb21wdEZvckNhcHR1cmUoKQogICAgICAgICAgICAgewotICAg ICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZW51bWVyYXRlRGV2aWNlcygpLnRo ZW4oKCkgPT4geworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVk aWFEZXZpY2VzLmVudW1lcmF0ZURldmljZXMoKS50aGVuKCgpID0+IHsKICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHsgYXVkaW86 IGZhbHNlLCB2aWRlbzogdHJ1ZSB9KQotICAgICAgICAgICAgICAgIH0pLnRoZW4oKHMpID0+IHsK LSAgICAgICAgICAgICAgICAgICAgc3RyZWFtID0gczsKKyAgICAgICAgICAgICAgICB9KTsKKwor ICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9PiB7CiAgICAgICAg ICAgICAgICAgICAgIHZpZGVvLnNyY09iamVjdCA9IHN0cmVhbTsKICAgICAgICAgICAgICAgICAg ICAgY29uc29sZS5sb2coIkdvdCB1c2VyIG1lZGlhIik7CiAgICAgICAgICAgICAgICAgfSkuY2F0 Y2goKGVycm9yKSA9PiBjb25zb2xlLmxvZyhgRmFpbGVkIHdpdGggZXJyb3I6ICR7ZXJyb3J9YCkp OwpAQCAtMTgsMjMgKzE4LDI5IEBACiAKICAgICAgICAgICAgIGZ1bmN0aW9uIHN0b3Aoa2luZCkK ICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBsZXQgYWN0aXZlVHJhY2tzID0gW107Ci0g ICAgICAgICAgICAgICAgc3RyZWFtLmdldFRyYWNrcygpLmZvckVhY2godHJhY2sgPT4gewotICAg ICAgICAgICAgICAgICAgICBpZiAoIWtpbmQgfHwgdHJhY2sua2luZCA9PSBraW5kKQotICAgICAg ICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOwotICAgICAgICAgICAgICAgICAgICBlbHNl Ci0gICAgICAgICAgICAgICAgICAgICAgICBhY3RpdmVUcmFja3MucHVzaCh0cmFjayk7CisgICAg ICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChzdHJlYW0pID0+IHsKKyAgICAgICAgICAg ICAgICAgICAgbGV0IGFjdGl2ZVRyYWNrcyA9IFtdOworICAgICAgICAgICAgICAgICAgICBzdHJl YW0uZ2V0VHJhY2tzKCkuZm9yRWFjaCh0cmFjayA9PiB7CisgICAgICAgICAgICAgICAgICAgICAg ICBpZiAoIWtpbmQgfHwgdHJhY2sua2luZCA9PSBraW5kKQorICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHRyYWNrLnN0b3AoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICBhY3RpdmVUcmFja3MucHVzaCh0cmFjayk7CisgICAgICAg ICAgICAgICAgICAgIH0pOworCisgICAgICAgICAgICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tz Lmxlbmd0aCkgeworICAgICAgICAgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZURpZFJlc29s dmUgPSBmYWxzZTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHZpZGVvLnNyY09iamVjdCA9IG51 bGw7CisgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICB9KTsKLQotICAgICAg ICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkgewotICAgICAgICAgICAgICAgICAg ICBzdHJlYW0gPSBudWxsOwotICAgICAgICAgICAgICAgICAgICB2aWRlby5zcmNPYmplY3QgPSBu dWxsOwotICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH0KIAorICAgICAgICAgICAgbGV0 IHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0gZmFsc2U7CisKICAgICAgICAgICAgIGZ1bmN0aW9u IGhhdmVTdHJlYW0oKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIHJldHVybiBzdHJl YW0gIT09IG51bGw7CisgICAgICAgICAgICAgICAgLy8gT3VyIGNhbGxlciBwb2xscyByZXBlYXRl ZGx5IHVudGlsIG91ciBwcm9taXNlIHJlc29sdmVzLgorICAgICAgICAgICAgICAgIHN0cmVhbVBy b21pc2UudGhlbigoc3RyZWFtKSA9PiBzdHJlYW1Qcm9taXNlRGlkUmVzb2x2ZSA9ICEhc3RyZWFt KTsKKyAgICAgICAgICAgICAgICByZXR1cm4gc3RyZWFtUHJvbWlzZURpZFJlc29sdmU7CiAgICAg ICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRvTXVsdGlwbGVHZXRVc2VyTWVkaWFT eW5jaHJvbm91c2x5KCkKQEAgLTUzLDEyICs1OSwxMiBAQAogCiAgICAgICAgICAgICBmdW5jdGlv biBjYXB0dXJlQXVkaW8oKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIG5hdmlnYXRv ci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzogdHJ1ZX0pLnRoZW4ocyA9PiBzdHJl YW0gPSBzKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlID0gbmF2aWdhdG9yLm1lZGlh RGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlfSk7CiAgICAgICAgICAgICB9CiAKICAg ICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVBdWRpb0FuZFZpZGVvKCkKICAgICAgICAgICAgIHsK LSAgICAgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVk aW86IHRydWUsIHZpZGVvOiB0cnVlfSkudGhlbihzID0+IHN0cmVhbSA9IHMpOworICAgICAgICAg ICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRp YSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIDwv c2NyaXB0PgogICAgIDxoZWFkPgo= 381101 2019-10-16 13:12:41 -0700 2019-10-16 13:27:39 -0700 Patch bug-202874-20191016131240.patch text/plain 14392 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMTU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDdmMmFiMzFiNjgyMGY4YWJhNjBkMzlk Y2YxM2U0NzI5MDY2YzMxMGYuLjBiZmI4Y2M4ZDJlZTg0ZjY3OTllZWU4MzU1MTc2NTA0YThiNDNh ZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTktMTAtMTYgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9vcCB0byBwcm9j ZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8gcHJvZmlsaW5n LiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHVzZSBDRlJ1bmxv b3BTb3VyY2UxIGluc3RlYWQgb2YgQ0ZSdW5sb29wU291cmNlMC4KKworICAgICAgICAqIHd0Zi9S dW5Mb29wLmg6CisgICAgICAgICogd3RmL2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6UnVuTG9vcCk6 CisgICAgICAgIChXVEY6OlJ1bkxvb3A6On5SdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9v cDo6d2FrZVVwKToKKyAgICAgICAgKiB3dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tOgorICAg ICAgICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKwogMjAx OS0xMC0xNCAgVGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAg ICBVbmlmeSBzb3VyY2VzIGZvciBiaW5kaW5ncyBtb3JlIGRlbnNlbHkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL1J1bkxvb3AuaCBiL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAppbmRleCA5 ZGU4ODU5YmEyNjdlMmM0YTNlNzU0ZmNjOGQyOGExOWE4ZDBhOGY2Li5iMGU0MTg2NmQxNThmYjY0 NDQzMTNmYWU3MGEzYTZkZDRlMWM5ZWIyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5M b29wLmgKKysrIGIvU291cmNlL1dURi93dGYvUnVuTG9vcC5oCkBAIC0xNzgsOSArMTc4LDEwIEBA IHByaXZhdGU6CiAKICAgICBMb2NrIG1fbG9vcExvY2s7CiAjZWxpZiBVU0UoQ09DT0FfRVZFTlRf TE9PUCkKLSAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayh2b2lkKik7CisgICAgc3RhdGljIHZv aWQgcGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJlZiwgdm9pZCogbXNnLCBDRkluZGV4IHNpemUsIHZv aWQqIGluZm8pOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BSZWY+IG1fcnVuTG9vcDsKICAgICBS ZXRhaW5QdHI8Q0ZSdW5Mb29wU291cmNlUmVmPiBtX3J1bkxvb3BTb3VyY2U7CisgICAgUmV0YWlu UHRyPENGTWFjaFBvcnRSZWY+IG1fcG9ydDsKICNlbGlmIFVTRShHTElCX0VWRU5UX0xPT1ApCiAg ICAgR1JlZlB0cjxHTWFpbkNvbnRleHQ+IG1fbWFpbkNvbnRleHQ7CiAgICAgVmVjdG9yPEdSZWZQ dHI8R01haW5Mb29wPj4gbV9tYWluTG9vcHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9j Zi9SdW5Mb29wQ0YuY3BwIGIvU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAppbmRleCAy N2QzZmUyYzljYjQyODdiYTc4NTM1ODRmNDgzOWViMzdlZjkwN2EyLi5iMmUyZTViNzQxNzc0ZDkw YzNmZWJmYjc5N2ZhMDUwOWEzZTcxZjllIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9jZi9S dW5Mb29wQ0YuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKQEAgLTI4 LDI2ICsyOCwyOSBAQAogCiAjaW5jbHVkZSA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24u aD4KICNpbmNsdWRlIDxkaXNwYXRjaC9kaXNwYXRjaC5oPgorI2luY2x1ZGUgPG1hY2gvbWFjaC5o PgogI2luY2x1ZGUgPHd0Zi9BdXRvZHJhaW5lZFBvb2wuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAK LXZvaWQgUnVuTG9vcDo6cGVyZm9ybVdvcmsodm9pZCogY29udGV4dCkKK3ZvaWQgUnVuTG9vcDo6 cGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJlZiwgdm9pZCosIENGSW5kZXgsIHZvaWQqIGluZm8pCiB7 CiAgICAgQXV0b2RyYWluZWRQb29sIHBvb2w7Ci0gICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGNv bnRleHQpLT5wZXJmb3JtV29yaygpOworICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihpbmZvKS0+ cGVyZm9ybVdvcmsoKTsKIH0KIAogUnVuTG9vcDo6UnVuTG9vcCgpCiAgICAgOiBtX3J1bkxvb3Ao Q0ZSdW5Mb29wR2V0Q3VycmVudCgpKQogewotICAgIENGUnVuTG9vcFNvdXJjZUNvbnRleHQgY29u dGV4dCA9IHsgMCwgdGhpcywgMCwgMCwgMCwgMCwgMCwgMCwgMCwgcGVyZm9ybVdvcmsgfTsKLSAg ICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGUnVuTG9vcFNvdXJjZUNyZWF0ZShrQ0ZBbGxv Y2F0b3JEZWZhdWx0LCAwLCAmY29udGV4dCkpOworICAgIENGTWFjaFBvcnRDb250ZXh0IGNvbnRl eHQgPSB7IDAsIHRoaXMsIG51bGxwdHIsIG51bGxwdHIsIG51bGxwdHIgfTsKKyAgICBtX3BvcnQg PSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwgcGVyZm9ybVdv cmssICZjb250ZXh0LCBudWxscHRyKSk7CisgICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihD Rk1hY2hQb3J0Q3JlYXRlUnVuTG9vcFNvdXJjZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBtX3BvcnQu Z2V0KCksIDApKTsKICAgICBDRlJ1bkxvb3BBZGRTb3VyY2UobV9ydW5Mb29wLmdldCgpLCBtX3J1 bkxvb3BTb3VyY2UuZ2V0KCksIGtDRlJ1bkxvb3BDb21tb25Nb2Rlcyk7CiB9CiAKIFJ1bkxvb3A6 On5SdW5Mb29wKCkKIHsKKyAgICBDRk1hY2hQb3J0SW52YWxpZGF0ZShtX3BvcnQuZ2V0KCkpOwog ICAgIENGUnVuTG9vcFNvdXJjZUludmFsaWRhdGUobV9ydW5Mb29wU291cmNlLmdldCgpKTsKIH0K IApAQCAtNTgsOCArNjEsMTYgQEAgdm9pZCBSdW5Mb29wOjpydW5Gb3JEdXJhdGlvbihTZWNvbmRz IGR1cmF0aW9uKQogCiB2b2lkIFJ1bkxvb3A6Ondha2VVcCgpCiB7Ci0gICAgQ0ZSdW5Mb29wU291 cmNlU2lnbmFsKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7Ci0gICAgQ0ZSdW5Mb29wV2FrZVVwKG1f cnVuTG9vcC5nZXQoKSk7CisgICAgbWFjaF9tc2dfaGVhZGVyX3QgaGVhZGVyOworICAgIGhlYWRl ci5tc2doX2JpdHMgPSBNQUNIX01TR0hfQklUUyhNQUNIX01TR19UWVBFX0NPUFlfU0VORCwgMCk7 CisgICAgaGVhZGVyLm1zZ2hfc2l6ZSA9IHNpemVvZihtYWNoX21zZ19oZWFkZXJfdCk7CisgICAg aGVhZGVyLm1zZ2hfcmVtb3RlX3BvcnQgPSBDRk1hY2hQb3J0R2V0UG9ydChtX3BvcnQuZ2V0KCkp OworICAgIGhlYWRlci5tc2doX2xvY2FsX3BvcnQgPSBNQUNIX1BPUlRfTlVMTDsKKyAgICBoZWFk ZXIubXNnaF9pZCA9IDA7CisgICAgbWFjaF9tc2dfcmV0dXJuX3QgcmVzdWx0ID0gbWFjaF9tc2co JmhlYWRlciwgTUFDSF9TRU5EX01TRyB8IE1BQ0hfU0VORF9USU1FT1VULCBoZWFkZXIubXNnaF9z aXplLCAwLCBNQUNIX1BPUlRfTlVMTCwgMCwgTUFDSF9QT1JUX05VTEwpOworICAgIFJFTEVBU0Vf QVNTRVJUKHJlc3VsdCA9PSBNQUNIX01TR19TVUNDRVNTIHx8IHJlc3VsdCA9PSBNQUNIX1NFTkRf VElNRURfT1VUKTsKKyAgICBpZiAocmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpCisgICAg ICAgIG1hY2hfbXNnX2Rlc3Ryb3koJmhlYWRlcik7CiB9CiAKIFJ1bkxvb3A6OkN5Y2xlUmVzdWx0 IFJ1bkxvb3A6OmN5Y2xlKGNvbnN0IFN0cmluZyYgbW9kZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X VEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbSBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL01h aW5UaHJlYWRDb2NvYS5tbQppbmRleCA1OGI2ZjkxYTE2YTJmNjI1ZWU1NTg5ZGEyNTFkOGNiZDcw ZDg3MzJjLi44NGNjNzNmYzE2OWZjY2RlOGI2YjVmMzhmNjRiY2RhODc0NjFiMzg4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW0KKysrIGIvU291cmNl L1dURi93dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tCkBAIC0xMzAsOSArMTMwLDEwIEBAIHZv aWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiAgICAgICAgIHJldHVy bjsKICAgICB9CiAgICAgCi0gICAgaWYgKG1haW5UaHJlYWRFc3RhYmxpc2hlZEFzUHRocmVhZE1h aW4pIHsKLSAgICAgICAgQVNTRVJUKCFtYWluVGhyZWFkTlNUaHJlYWQpOwotICAgICAgICBbc3Rh dGljTWFpblRocmVhZENhbGxlciBwZXJmb3JtU2VsZWN0b3JPbk1haW5UaHJlYWQ6QHNlbGVjdG9y KGNhbGwpIHdpdGhPYmplY3Q6bmlsIHdhaXRVbnRpbERvbmU6Tk9dOworICAgIGlmIChtYWluVGhy ZWFkRXN0YWJsaXNoZWRBc1B0aHJlYWRNYWluIHx8IG1haW5UaHJlYWROU1RocmVhZCA9PSBbTlNU aHJlYWQgbWFpblRocmVhZF0pIHsKKyAgICAgICAgZGlzcGF0Y2hfYXN5bmMoZGlzcGF0Y2hfZ2V0 X21haW5fcXVldWUoKSwgXnsKKyAgICAgICAgICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVyIGNh bGxdOworICAgICAgICB9KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApkaWZmIC0tZ2l0IGEv VG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGRlYTRkYmIyNzg2YzE1MmZj OWY1YWE4NjFjN2Y4MjIyODBlMTgwODcuLjc0OGJhZWRjMjkxOGM2MzYzZmZkYWZiMWJjNzljYjZh NGI5M2U0MDEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNCBAQAorMjAxOS0xMC0xNiAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFw cGxlLmNvbT4KKworICAgICAgICBVc2luZyBDRlJ1bkxvb3BTb3VyY2UxIGZvciBmYXN0ZXIgdGFz ayBkaXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgTW9kaWZ5IGEgdGVzdCB0byBtYWtlIGl0IG1vcmUgZGV0ZXJtaW5pc3RpYy4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sOgorCiAyMDE5 LTEwLTE1ICBKaWV3ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW1dl YkF1dGhuXSBSZW5hbWUgLVtXS1VJRGVsZWdhdGVQcml2YXRlIHdlYlZpZXc6cnVuV2ViQXV0aGVu dGljYXRpb25QYW5lbDppbml0aWF0ZWRCeUZyYW1lOmNvbXBsZXRpb25IYW5kbGVyOl0gdG8gLVtX S1VJRGVsZWdhdGVQcml2YXRlIF93ZWJWaWV3OnJ1bldlYkF1dGhlbnRpY2F0aW9uUGFuZWw6aW5p dGlhdGVkQnlGcmFtZTpjb21wbGV0aW9uSGFuZGxlcjpdCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sCmluZGV4IGNiMzJkODBlYjY4N2Vi MzNhMWNiZmQyNzU1NmU0ZTczMGYxNmZmOTkuLjdlNDYxN2JmZTg5NjhiN2U5NzM4MWIyMjIzYjdh NjQwNTk1ODQwMTQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 L2dldFVzZXJNZWRpYS5odG1sCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 L2dldFVzZXJNZWRpYS5odG1sCkBAIC0yLDE0ICsyLDE1IEBACiA8aHRtbD4KICAgICA8aGVhZD4K ICAgICAgICAgPHNjcmlwdD4KLQotICAgICAgICAgICAgbGV0IHN0cmVhbSA9IG51bGw7CisgICAg ICAgICAgICBsZXQgc3RyZWFtUHJvbWlzZSA9IFByb21pc2UucmVzb2x2ZSgpOwogCiAgICAgICAg ICAgICBmdW5jdGlvbiBwcm9tcHRGb3JDYXB0dXJlKCkKICAgICAgICAgICAgIHsKLSAgICAgICAg ICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmVudW1lcmF0ZURldmljZXMoKS50aGVuKCgp ID0+IHsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlID0gbmF2aWdhdG9yLm1lZGlhRGV2 aWNlcy5lbnVtZXJhdGVEZXZpY2VzKCkudGhlbigoKSA9PiB7CiAgICAgICAgICAgICAgICAgICAg IHJldHVybiBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7IGF1ZGlvOiBmYWxz ZSwgdmlkZW86IHRydWUgfSkKLSAgICAgICAgICAgICAgICB9KS50aGVuKChzKSA9PiB7CisgICAg ICAgICAgICAgICAgfSk7CisKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0 cmVhbSkgPT4gewogICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBzOwogICAgICAgICAgICAg ICAgICAgICB2aWRlby5zcmNPYmplY3QgPSBzdHJlYW07CiAgICAgICAgICAgICAgICAgICAgIGNv bnNvbGUubG9nKCJHb3QgdXNlciBtZWRpYSIpOwpAQCAtMTgsMjMgKzE5LDI5IEBACiAKICAgICAg ICAgICAgIGZ1bmN0aW9uIHN0b3Aoa2luZCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAg ICBsZXQgYWN0aXZlVHJhY2tzID0gW107Ci0gICAgICAgICAgICAgICAgc3RyZWFtLmdldFRyYWNr cygpLmZvckVhY2godHJhY2sgPT4gewotICAgICAgICAgICAgICAgICAgICBpZiAoIWtpbmQgfHwg dHJhY2sua2luZCA9PSBraW5kKQotICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgp OwotICAgICAgICAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgICAgICAgICBhY3Rp dmVUcmFja3MucHVzaCh0cmFjayk7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVu KChzdHJlYW0pID0+IHsKKyAgICAgICAgICAgICAgICAgICAgbGV0IGFjdGl2ZVRyYWNrcyA9IFtd OworICAgICAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJhY2tzKCkuZm9yRWFjaCh0cmFjayA9 PiB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWtpbmQgfHwgdHJhY2sua2luZCA9PSBr aW5kKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNrLnN0b3AoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3RpdmVU cmFja3MucHVzaCh0cmFjayk7CisgICAgICAgICAgICAgICAgICAgIH0pOworIAorICAgICAgICAg ICAgICAgICAgICBpZiAoIWFjdGl2ZVRyYWNrcy5sZW5ndGgpIHsKKyAgICAgICAgICAgICAgICAg ICAgICAgIHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0gZmFsc2U7CisgICAgICAgICAgICAgICAg ICAgICAgICB2aWRlby5zcmNPYmplY3QgPSBudWxsOworICAgICAgICAgICAgICAgICAgICB9CiAg ICAgICAgICAgICAgICAgfSk7Ci0KLSAgICAgICAgICAgICAgICBpZiAoIWFjdGl2ZVRyYWNrcy5s ZW5ndGgpIHsKLSAgICAgICAgICAgICAgICAgICAgc3RyZWFtID0gbnVsbDsKLSAgICAgICAgICAg ICAgICAgICAgdmlkZW8uc3JjT2JqZWN0ID0gbnVsbDsKLSAgICAgICAgICAgICAgICB9CiAgICAg ICAgICAgICB9CiAKKyAgICAgICAgICAgIGxldCBzdHJlYW1Qcm9taXNlRGlkUmVzb2x2ZSA9IGZh bHNlOworCiAgICAgICAgICAgICBmdW5jdGlvbiBoYXZlU3RyZWFtKCkKICAgICAgICAgICAgIHsK LSAgICAgICAgICAgICAgICByZXR1cm4gc3RyZWFtICE9PSBudWxsOworICAgICAgICAgICAgICAg IC8vIE91ciBjYWxsZXIgcG9sbHMgcmVwZWF0ZWRseSB1bnRpbCBvdXIgcHJvbWlzZSByZXNvbHZl cy4KKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVhbSkgPT4gc3RyZWFt UHJvbWlzZURpZFJlc29sdmUgPSAhIXN0cmVhbSk7CisgICAgICAgICAgICAgICAgcmV0dXJuIHN0 cmVhbVByb21pc2VEaWRSZXNvbHZlOwogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBmdW5j dGlvbiBkb011bHRpcGxlR2V0VXNlck1lZGlhU3luY2hyb25vdXNseSgpCkBAIC01MywxMiArNjAs MTIgQEAKIAogICAgICAgICAgICAgZnVuY3Rpb24gY2FwdHVyZUF1ZGlvKCkKICAgICAgICAgICAg IHsKLSAgICAgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7 YXVkaW86IHRydWV9KS50aGVuKHMgPT4gc3RyZWFtID0gcyk7CisgICAgICAgICAgICAgICAgc3Ry ZWFtUHJvbWlzZSA9IG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzog dHJ1ZX0pOwogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBmdW5jdGlvbiBjYXB0dXJlQXVk aW9BbmRWaWRlbygpCiAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgbmF2aWdhdG9yLm1l ZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlLCB2aWRlbzogdHJ1ZX0pLnRoZW4o cyA9PiBzdHJlYW0gPSBzKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlID0gbmF2aWdh dG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlLCB2aWRlbzogdHJ1ZX0p OwogICAgICAgICAgICAgfQogICAgICAgICA8L3NjcmlwdD4KICAgICA8aGVhZD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAw ZWI5MjRmNTNkMzA5M2UyY2U0ZDkyNjNiYWYxNzhmYThkZjczNDhiLi43YTVjMzFiMTUxYmU5Y2Ni YzBiMTY0ODMwMjFkODRkMDNhZjUyYTA3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTktMTAt MTYgIFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZS dW5Mb29wU291cmNlMSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1vZGlmeSBhIHRlc3QgdG8gbWFrZSBpdCBt b3JlIGRldGVybWluaXN0aWMuCisKKyAgICAgICAgKiBpbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVh dGlvbi1leHBlY3RlZC50eHQ6CisgICAgICAgICogaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRp b24uaHRtbDoKKwogMjAxOS0xMC0xNSAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxl LmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OOiBlZGl0aW5nL2FzeW5jLWNsaXBib2FyZC9jbGlw Ym9hcmQtaW50ZXJmYWNlcy5odG1sIGlzIGZhaWxpbmcgaW4gV2ViS2l0MQpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24tZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24tZXhwZWN0ZWQudHh0Cmlu ZGV4IDViODMyMzM0OWExMjhiYTY2M2JkYzg3OGI0YTYyZWQ2NDIzZDgxNzIuLjQ5YjdmZmE3NGZk MDIxZGViZThjNzBlNzcxZjZiZWZiOGJkZTJkZDkgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2lu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0 cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi1leHBlY3RlZC50eHQKQEAgLTEyLDExICsx MiwxMSBAQCBQQVNTOiBUaGVyZSBzaG91bGQgYmUgMCBub2RlIHdpdGggdGhlIGNsYXNzICIudGVz dC1wc2V1ZG8td2l0aG91dC1jb250ZW50Ii4KIAogQ2FsbGluZyAiY3JlYXRlRWxlbWVudFdpdGhD bGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250ZW50IikiLi4uCiBDaGVja2luZyBmb3Igbm9kZXMg d2l0aCBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGgtY29udGVudCIuLi4KLVBBU1M6IENyZWF0ZWQg OjpiZWZvcmUgcHNldWRvIGVsZW1lbnQKIFBBU1M6IFRoZXJlIHNob3VsZCBiZSAxIG5vZGUgd2l0 aCB0aGUgY2xhc3MgIi50ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLgorUEFTUzogQ3JlYXRlZCA6 OmJlZm9yZSBwc2V1ZG8gZWxlbWVudAogCiBDYWxsaW5nICJyZW1vdmVFbGVtZW50V2l0aENsYXNz KCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSIuLi4KIENoZWNraW5nIGZvciBub2RlcyB3aXRo IGNsYXNzICIudGVzdC1wc2V1ZG8td2l0aC1jb250ZW50Ii4uLgotUEFTUzogUmVtb3ZlZCA6OmJl Zm9yZSBwc2V1ZG8gZWxlbWVudAogUEFTUzogVGhlcmUgc2hvdWxkIGJlIDAgbm9kZSB3aXRoIHRo ZSBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGgtY29udGVudCIuCitQQVNTOiBSZW1vdmVkIDo6YmVm b3JlIHBzZXVkbyBlbGVtZW50CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLmh0bWwgYi9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVk by1jcmVhdGlvbi5odG1sCmluZGV4IGEwMWNlMGQzNjQ1ZDM4ZjQ3ZTUyNjdlYWM5ZDhlMGY0ODZk MWE2NDYuLjA5ZGZhYTRjYTgyYTdlM2U4M2IyNDllNzE4Njg5ZjA5MjhlOWFjMDUgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2luc3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbApAQCAtMjYsNyAr MjYsOCBAQCBmdW5jdGlvbiByZW1vdmVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSkgewogCiBm dW5jdGlvbiB0ZXN0KCkgewogICAgIGxldCBkb2N1bWVudE5vZGUgPSBudWxsOwotICAgIGxldCBw c2V1ZG9FbGVtZW50ID0gbnVsbDsKKyAgICBsZXQgcHNldWRvRWxlbWVudEFkZGVkID0gbnVsbDsK KyAgICBsZXQgcHNldWRvRWxlbWVudFJlbW92ZWQgPSBudWxsOwogCiAgICAgZnVuY3Rpb24gaGFu ZGxlUHJvbWlzZVJlamVjdChlcnJvcikgewogICAgICAgICBjb25zb2xlLmxvZyhlcnJvcik7CkBA IC01NiwyNyArNTcsMzcgQEAgZnVuY3Rpb24gdGVzdCgpIHsKICAgICAgICAgLmNhdGNoKGhhbmRs ZVByb21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIGNyZWF0ZUVsZW1lbnRXaXRo Q2xhc3MoY2xhc3NOYW1lKSB7CisgICAgZnVuY3Rpb24gY3JlYXRlRWxlbWVudFdpdGhDbGFzcyhj bGFzc05hbWUsIHNob3VsZENoZWNrRWxlbWVudCkgewogICAgICAgICByZXR1cm4gZXZhbHVhdGVX aXRoTG9nKGBjcmVhdGVFbGVtZW50V2l0aENsYXNzKCIke2NsYXNzTmFtZX0iKWApCiAgICAgICAg IC50aGVuKCgpID0+IGNoZWNrRWxlbWVudHNXaXRoQ2xhc3MoY2xhc3NOYW1lLCAxKSkKKyAgICAg ICAgLnRoZW4oKCkgPT4geworICAgICAgICAgICAgaWYgKHNob3VsZENoZWNrRWxlbWVudCkgewor ICAgICAgICAgICAgICAgIGlmIChwc2V1ZG9FbGVtZW50QWRkZWQpCisgICAgICAgICAgICAgICAg ICAgIFByb3RvY29sVGVzdC5wYXNzKGBDcmVhdGVkIDo6JHtwc2V1ZG9FbGVtZW50QWRkZWQucHNl dWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsKKyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBwc2V1ZG9FbGVtZW50QWRkZWRQcm9taXNlLnRoZW4oKCkgPT4g eyBQcm90b2NvbFRlc3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudEFkZGVkLnBzZXVk b1R5cGV9IHBzZXVkbyBlbGVtZW50YCk7IH0pOworICAgICAgICAgICAgfQorICAgICAgICB9KQog ICAgICAgICAuY2F0Y2goaGFuZGxlUHJvbWlzZVJlamVjdCk7CiAgICAgfQogCi0gICAgZnVuY3Rp b24gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcyhjbGFzc05hbWUpIHsKKyAgICBmdW5jdGlvbiByZW1v dmVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSwgc2hvdWxkQ2hlY2tFbGVtZW50KSB7CiAgICAg ICAgIHJldHVybiBldmFsdWF0ZVdpdGhMb2coYHJlbW92ZUVsZW1lbnRXaXRoQ2xhc3MoIiR7Y2xh c3NOYW1lfSIpYCkKICAgICAgICAgLnRoZW4oKCkgPT4gY2hlY2tFbGVtZW50c1dpdGhDbGFzcyhj bGFzc05hbWUsIDApKQorICAgICAgICAudGhlbigoKSA9PiB7CisgICAgICAgICAgICBpZiAoc2hv dWxkQ2hlY2tFbGVtZW50KSB7CisgICAgICAgICAgICAgICAgaWYgKHBzZXVkb0VsZW1lbnRSZW1v dmVkKQorICAgICAgICAgICAgICAgICAgICBQcm90b2NvbFRlc3QuZXhwZWN0RXF1YWwocHNldWRv RWxlbWVudFJlbW92ZWQucHNldWRvRWxlbWVudElkLCBwc2V1ZG9FbGVtZW50Lm5vZGVJZCwgYFJl bW92ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGAp OworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBzZXVk b0VsZW1lbnRSZW1vdmVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LmV4cGVjdEVx dWFsKHBzZXVkb0VsZW1lbnRSZW1vdmVkLnBzZXVkb0VsZW1lbnRJZCwgcHNldWRvRWxlbWVudEFk ZGVkLm5vZGVJZCwgYFJlbW92ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBw c2V1ZG8gZWxlbWVudGApOyB9KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAg LmNhdGNoKGhhbmRsZVByb21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIEluc3BlY3RvclByb3Rv Y29sLmV2ZW50SGFuZGxlclsiRE9NLnBzZXVkb0VsZW1lbnRBZGRlZCJdID0gKHJlc3BvbnNlKSA9 PiB7Ci0gICAgICAgIHBzZXVkb0VsZW1lbnQgPSByZXNwb25zZS5wYXJhbXMucHNldWRvRWxlbWVu dDsKLQotICAgICAgICBQcm90b2NvbFRlc3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVu dC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOwotICAgIH07CisgICAgbGV0IHBzZXVkb0Vs ZW1lbnRBZGRlZFByb21pc2UgPSBJbnNwZWN0b3JQcm90b2NvbC5hd2FpdEV2ZW50KHtldmVudDog IkRPTS5wc2V1ZG9FbGVtZW50QWRkZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVu dEFkZGVkID0gZXZlbnQucGFyYW1zLnBzZXVkb0VsZW1lbnR9KTsKKyAgICBsZXQgcHNldWRvRWxl bWVudFJlbW92ZWRQcm9taXNlID0gSW5zcGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6 ICJET00ucHNldWRvRWxlbWVudFJlbW92ZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxl bWVudFJlbW92ZWQgPSBldmVudC5wYXJhbXN9KTsKIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2 ZW50SGFuZGxlclsiRE9NLnBzZXVkb0VsZW1lbnRSZW1vdmVkIl0gPSAocmVzcG9uc2UpID0+IHsK LSAgICAgICAgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHJlc3BvbnNlLnBhcmFtcy5wc2V1ZG9F bGVtZW50SWQsIHBzZXVkb0VsZW1lbnQubm9kZUlkLCBgUmVtb3ZlZCA6OiR7cHNldWRvRWxlbWVu dC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOwotICAgIH07CiAKICAgICBQcm90b2NvbFRl c3QubG9nKCJSZXF1ZXN0aW5nIGRvY3VtZW50Li4uIik7CiAgICAgSW5zcGVjdG9yUHJvdG9jb2wu c2VuZENvbW1hbmQoIkRPTS5nZXREb2N1bWVudCIsIHt9LCAocmVzcG9uc2UpID0+IHsKQEAgLTg1 LDEwICs5NiwxMCBAQCBmdW5jdGlvbiB0ZXN0KCkgewogICAgICAgICBkb2N1bWVudE5vZGUgPSBy ZXNwb25zZS5yZXN1bHQucm9vdDsKIAogICAgICAgICBQcm9taXNlLnJlc29sdmUoKQotICAgICAg ICAudGhlbigoKSA9PiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0 LWNvbnRlbnQiKSkKLSAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygi dGVzdC1wc2V1ZG8td2l0aG91dC1jb250ZW50IikpCi0gICAgICAgIC50aGVuKCgpID0+IGNyZWF0 ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29udGVudCIpKQotICAgICAgICAu dGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRl bnQiKSkKKyAgICAgICAgLnRoZW4oKCkgPT4gY3JlYXRlRWxlbWVudFdpdGhDbGFzcygidGVzdC1w c2V1ZG8td2l0aG91dC1jb250ZW50IiksIGZhbHNlKQorICAgICAgICAudGhlbigoKSA9PiByZW1v dmVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSwgZmFsc2Up CisgICAgICAgIC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRv LXdpdGgtY29udGVudCIsIHRydWUpKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50 V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLCB0cnVlKSkKICAgICAgICAgLnRo ZW4oKCkgPT4gUHJvdG9jb2xUZXN0LmNvbXBsZXRlVGVzdCgpKQogICAgICAgICAuY2F0Y2goaGFu ZGxlUHJvbWlzZVJlamVjdCk7CiAgICAgfSk7Cg== 381103 2019-10-16 13:27:40 -0700 2019-10-16 14:11:55 -0700 Patch bug-202874-20191016132740.patch text/plain 14084 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc1NTVkNGVhN2QxOGE4YTliNGEwOGM4 NDIzOWExZGM3NzFmYWQ2OTQuLjRkYzZhMGVmZWY1YjJhMmFjNTFjNjk4NTU0OTIyMGViOTE3ZGI4 YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTktMTAtMTYgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9vcCB0byBwcm9j ZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8gcHJvZmlsaW5n LiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHVzZSBDRlJ1bmxv b3BTb3VyY2UxIGluc3RlYWQgb2YgQ0ZSdW5sb29wU291cmNlMC4KKworICAgICAgICAqIHd0Zi9S dW5Mb29wLmg6CisgICAgICAgICogd3RmL2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6UnVuTG9vcCk6 CisgICAgICAgIChXVEY6OlJ1bkxvb3A6On5SdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9v cDo6d2FrZVVwKToKKyAgICAgICAgKiB3dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tOgorICAg ICAgICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKwogMjAx OS0xMC0xNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCBmaXggdGhlIGludGVybmFsIG1hY09TIDEwLjEzIGFuZCAxMC4xNCBidWls ZHMgYWZ0ZXIgcjI1MTE3MQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5oIGIv U291cmNlL1dURi93dGYvUnVuTG9vcC5oCmluZGV4IDlkZTg4NTliYTI2N2UyYzRhM2U3NTRmY2M4 ZDI4YTE5YThkMGE4ZjYuLmIwZTQxODY2ZDE1OGZiNjQ0NDMxM2ZhZTcwYTNhNmRkNGUxYzllYjIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmgKQEAgLTE3OCw5ICsxNzgsMTAgQEAgcHJpdmF0ZToKIAogICAgIExvY2sgbV9s b29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09QKQotICAgIHN0YXRpYyB2b2lkIHBl cmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayhDRk1hY2hQb3J0 UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCogaW5mbyk7CiAgICAgUmV0YWluUHRy PENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BTb3VyY2VS ZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0 OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBHUmVmUHRyPEdNYWluQ29udGV4dD4g bV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxHTWFpbkxvb3A+PiBtX21haW5Mb29w czsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAgYi9Tb3VyY2Uv V1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IDI3ZDNmZTJjOWNiNDI4N2JhNzg1MzU4NGY0 ODM5ZWIzN2VmOTA3YTIuLmIyZTJlNWI3NDE3NzRkOTBjM2ZlYmZiNzk3ZmEwNTA5YTNlNzFmOWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKKysrIGIvU291cmNl L1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYgKzI4LDI5IEBACiAKICNpbmNsdWRl IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNoL2Rp c3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9kcmFp bmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29y ayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVm LCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wgcG9v bDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7Cisg ICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBSdW5M b29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpCiB7 Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAwLCAw LCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0 Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250ZXh0 KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0ciwg bnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0 ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIpKTsK KyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29wU291 cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVuTG9v cEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NGUnVu TG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENGTWFj aFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52YWxp ZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBAIC01OCw4ICs2MSwxNiBAQCB2b2lk IFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVyYXRpb24pCiAKIHZvaWQgUnVuTG9v cDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291cmNl LmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBtYWNo X21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNHSF9C SVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXplID0g c2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9ydCA9 IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9jYWxf cG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBtYWNo X21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNHIHwg TUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxMLCAw LCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hfTVNH X1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChyZXN1 bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgmaGVh ZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoY29uc3QgU3Ry aW5nJiBtb2RlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENv Y29hLm1tIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tCmluZGV4IDI3 ZWIwMGRiYTEwOWJhMWZhNTAwZDU3Y2JiNWYzMTQ1YjdlMjEyNDkuLjZmZTg5ZTM0YWY2YTVhMjU4 MDg0NzZlZmRjYmY4MTM0OGYxNTcxOGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NvY29h L01haW5UaHJlYWRDb2NvYS5tbQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFk Q29jb2EubW0KQEAgLTEzMSw3ICsxMzEsOSBAQCB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlv bnNPbk1haW5UaHJlYWQoKQogICAgIH0KICNlbmRpZgogCi0gICAgW3N0YXRpY01haW5UaHJlYWRD YWxsZXIgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3aXRoT2Jq ZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKKyAgICBkaXNwYXRjaF9hc3luYyhkaXNwYXRjaF9n ZXRfbWFpbl9xdWV1ZSgpLCBeeworICAgICAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBjYWxs XTsKKyAgICB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFzeW5jT25NYWluVGhyZWFkV2l0aFdlYlRo cmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOWM5YzUwMGExMzI2OTJlZmY4YmE5NWFlYzA3 ZGU0NmFhYzkzOWQ0Yy4uMjgxM2M0ZTA3YmI3YjI4MjUwNzY1OGY5YTMzNWYwOGZjMWE2Njc1YSAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE0IEBACisyMDE5LTEwLTE2ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgor CisgICAgICAgIFVzaW5nIENGUnVuTG9vcFNvdXJjZTEgZm9yIGZhc3RlciB0YXNrIGRpc3BhdGNo CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBGaXggYSBm bGFreSB0ZXN0LgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWw6CisKIDIwMTktMTAtMTYgIEZ1amlpIEhpcm9ub3JpICA8SGlyb25vcmkuRnVq aWlAc29ueS5jb20+CiAKICAgICAgICAgRHVtcFJlbmRlclRyZWUgc2hvdWxkIGNsZWFyIFdURkxv Z0NoYW5uZWxTdGF0ZTo6T25XaXRoQWNjdW11bGF0aW9uIHN0YXRlIHNldCBieSB0ZXN0UnVubmVy LmFjY3VtbXVsYXRlTG9nc0ZvckNoYW5uZWwKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQvZ2V0VXNlck1lZGlhLmh0bWwKaW5kZXggY2IzMmQ4MGViNjg3ZWIzM2ExY2Jm ZDI3NTU2ZTRlNzMwZjE2ZmY5OS4uN2U0NjE3YmZlODk2OGI3ZTk3MzgxYjIyMjNiN2E2NDA1OTU4 NDAxNCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWwKQEAgLTIsMTQgKzIsMTUgQEAKIDxodG1sPgogICAgIDxoZWFkPgogICAgICAg ICA8c2NyaXB0PgotCi0gICAgICAgICAgICBsZXQgc3RyZWFtID0gbnVsbDsKKyAgICAgICAgICAg IGxldCBzdHJlYW1Qcm9taXNlID0gUHJvbWlzZS5yZXNvbHZlKCk7CiAKICAgICAgICAgICAgIGZ1 bmN0aW9uIHByb21wdEZvckNhcHR1cmUoKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAg IG5hdmlnYXRvci5tZWRpYURldmljZXMuZW51bWVyYXRlRGV2aWNlcygpLnRoZW4oKCkgPT4gewor ICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmVu dW1lcmF0ZURldmljZXMoKS50aGVuKCgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHsgYXVkaW86IGZhbHNlLCB2aWRl bzogdHJ1ZSB9KQotICAgICAgICAgICAgICAgIH0pLnRoZW4oKHMpID0+IHsKKyAgICAgICAgICAg ICAgICB9KTsKKworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9 PiB7CiAgICAgICAgICAgICAgICAgICAgIHN0cmVhbSA9IHM7CiAgICAgICAgICAgICAgICAgICAg IHZpZGVvLnNyY09iamVjdCA9IHN0cmVhbTsKICAgICAgICAgICAgICAgICAgICAgY29uc29sZS5s b2coIkdvdCB1c2VyIG1lZGlhIik7CkBAIC0xOCwyMyArMTksMjkgQEAKIAogICAgICAgICAgICAg ZnVuY3Rpb24gc3RvcChraW5kKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIGxldCBh Y3RpdmVUcmFja3MgPSBbXTsKLSAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJhY2tzKCkuZm9y RWFjaCh0cmFjayA9PiB7Ci0gICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5r aW5kID09IGtpbmQpCi0gICAgICAgICAgICAgICAgICAgICAgICB0cmFjay5zdG9wKCk7Ci0gICAg ICAgICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNr cy5wdXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVh bSkgPT4geworICAgICAgICAgICAgICAgICAgICBsZXQgYWN0aXZlVHJhY2tzID0gW107CisgICAg ICAgICAgICAgICAgICAgIHN0cmVhbS5nZXRUcmFja3MoKS5mb3JFYWNoKHRyYWNrID0+IHsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5raW5kID09IGtpbmQpCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOworICAgICAgICAgICAgICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNrcy5w dXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CisgCisgICAgICAgICAgICAgICAg ICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkgeworICAgICAgICAgICAgICAgICAgICAgICAg c3RyZWFtUHJvbWlzZURpZFJlc29sdmUgPSBmYWxzZTsKKyAgICAgICAgICAgICAgICAgICAgICAg IHZpZGVvLnNyY09iamVjdCA9IG51bGw7CisgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICB9KTsKLQotICAgICAgICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkg ewotICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBudWxsOwotICAgICAgICAgICAgICAgICAg ICB2aWRlby5zcmNPYmplY3QgPSBudWxsOwotICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg IH0KIAorICAgICAgICAgICAgbGV0IHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0gZmFsc2U7CisK ICAgICAgICAgICAgIGZ1bmN0aW9uIGhhdmVTdHJlYW0oKQogICAgICAgICAgICAgewotICAgICAg ICAgICAgICAgIHJldHVybiBzdHJlYW0gIT09IG51bGw7CisgICAgICAgICAgICAgICAgLy8gT3Vy IGNhbGxlciBwb2xscyByZXBlYXRlZGx5IHVudGlsIG91ciBwcm9taXNlIHJlc29sdmVzLgorICAg ICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9PiBzdHJlYW1Qcm9taXNl RGlkUmVzb2x2ZSA9ICEhc3RyZWFtKTsKKyAgICAgICAgICAgICAgICByZXR1cm4gc3RyZWFtUHJv bWlzZURpZFJlc29sdmU7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRv TXVsdGlwbGVHZXRVc2VyTWVkaWFTeW5jaHJvbm91c2x5KCkKQEAgLTUzLDEyICs2MCwxMiBAQAog CiAgICAgICAgICAgICBmdW5jdGlvbiBjYXB0dXJlQXVkaW8oKQogICAgICAgICAgICAgewotICAg ICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzog dHJ1ZX0pLnRoZW4ocyA9PiBzdHJlYW0gPSBzKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9t aXNlID0gbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlfSk7 CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVBdWRpb0FuZFZp ZGVvKCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZp Y2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSkudGhlbihzID0+IHN0 cmVhbSA9IHMpOworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVk aWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSk7CiAgICAg ICAgICAgICB9CiAgICAgICAgIDwvc2NyaXB0PgogICAgIDxoZWFkPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGNkOWUxYzhj YTUyODI5NGI4MjI5MzYyNzRjODc5Yzg4ZGNhNDkzMGUuLjMzZWY1NTVjNDY5ZTNjMDc5YzQ5NzEx YjdiN2I3ZTdlM2FhYjY3OWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysg Yi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxOS0xMC0xNiAgU2lo dWkgTGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBVc2luZyBDRlJ1bkxvb3BT b3VyY2UxIGZvciBmYXN0ZXIgdGFzayBkaXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAgICAgICAqIGlu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBpbnNw ZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sOgorCiAyMDE5LTEwLTE2ICBSdXNzZWxsIEVw c3RlaW4gIDxyZXBzdGVpbkBhcHBsZS5jb20+CiAKICAgICAgICAgQ29ycmVjdCBUZXN0RXhwZWN0 YXRpb25zIGZyb20gcjI1MTExOS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA1YjgzMjMzNDlhMTI4YmE2NjNi ZGM4NzhiNGE2MmVkNjQyM2Q4MTcyLi40OWI3ZmZhNzRmZDAyMWRlYmU4YzcwZTc3MWY2YmVmYjhi ZGUyZGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVh dGlvbi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8t Y3JlYXRpb24tZXhwZWN0ZWQudHh0CkBAIC0xMiwxMSArMTIsMTEgQEAgUEFTUzogVGhlcmUgc2hv dWxkIGJlIDAgbm9kZSB3aXRoIHRoZSBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGhvdXQtY29udGVu dCIuCiAKIENhbGxpbmcgImNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgt Y29udGVudCIpIi4uLgogQ2hlY2tpbmcgZm9yIG5vZGVzIHdpdGggY2xhc3MgIi50ZXN0LXBzZXVk by13aXRoLWNvbnRlbnQiLi4uCi1QQVNTOiBDcmVhdGVkIDo6YmVmb3JlIHBzZXVkbyBlbGVtZW50 CiBQQVNTOiBUaGVyZSBzaG91bGQgYmUgMSBub2RlIHdpdGggdGhlIGNsYXNzICIudGVzdC1wc2V1 ZG8td2l0aC1jb250ZW50Ii4KK1BBU1M6IENyZWF0ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQK IAogQ2FsbGluZyAicmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250 ZW50IikiLi4uCiBDaGVja2luZyBmb3Igbm9kZXMgd2l0aCBjbGFzcyAiLnRlc3QtcHNldWRvLXdp dGgtY29udGVudCIuLi4KLVBBU1M6IFJlbW92ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQKIFBB U1M6IFRoZXJlIHNob3VsZCBiZSAwIG5vZGUgd2l0aCB0aGUgY2xhc3MgIi50ZXN0LXBzZXVkby13 aXRoLWNvbnRlbnQiLgorUEFTUzogUmVtb3ZlZCA6OmJlZm9yZSBwc2V1ZG8gZWxlbWVudAogCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1s IGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbAppbmRleCBh MDFjZTBkMzY0NWQzOGY0N2U1MjY3ZWFjOWQ4ZTBmNDg2ZDFhNjQ2Li4wOWRmYWE0Y2E4MmE3ZTNl ODNiMjQ5ZTcxODY4OWYwOTI4ZTlhYzA1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0 b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sCisrKyBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLmh0bWwKQEAgLTI2LDcgKzI2LDggQEAgZnVuY3Rpb24gcmVtb3Zl RWxlbWVudFdpdGhDbGFzcyhjbGFzc05hbWUpIHsKIAogZnVuY3Rpb24gdGVzdCgpIHsKICAgICBs ZXQgZG9jdW1lbnROb2RlID0gbnVsbDsKLSAgICBsZXQgcHNldWRvRWxlbWVudCA9IG51bGw7Cisg ICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRlZCA9IG51bGw7CisgICAgbGV0IHBzZXVkb0VsZW1lbnRS ZW1vdmVkID0gbnVsbDsKIAogICAgIGZ1bmN0aW9uIGhhbmRsZVByb21pc2VSZWplY3QoZXJyb3Ip IHsKICAgICAgICAgY29uc29sZS5sb2coZXJyb3IpOwpAQCAtNTYsMjcgKzU3LDM3IEBAIGZ1bmN0 aW9uIHRlc3QoKSB7CiAgICAgICAgIC5jYXRjaChoYW5kbGVQcm9taXNlUmVqZWN0KTsKICAgICB9 CiAKLSAgICBmdW5jdGlvbiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSkgeworICAg IGZ1bmN0aW9uIGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoY2xhc3NOYW1lLCBzaG91bGRDaGVja0Vs ZW1lbnQpIHsKICAgICAgICAgcmV0dXJuIGV2YWx1YXRlV2l0aExvZyhgY3JlYXRlRWxlbWVudFdp dGhDbGFzcygiJHtjbGFzc05hbWV9IilgKQogICAgICAgICAudGhlbigoKSA9PiBjaGVja0VsZW1l bnRzV2l0aENsYXNzKGNsYXNzTmFtZSwgMSkpCisgICAgICAgIC50aGVuKCgpID0+IHsKKyAgICAg ICAgICAgIGlmIChzaG91bGRDaGVja0VsZW1lbnQpIHsKKyAgICAgICAgICAgICAgICBpZiAocHNl dWRvRWxlbWVudEFkZGVkKQorICAgICAgICAgICAgICAgICAgICBQcm90b2NvbFRlc3QucGFzcyhg Q3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudEFkZGVkLnBzZXVkb1R5cGV9IHBzZXVkbyBlbGVtZW50 YCk7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcHNl dWRvRWxlbWVudEFkZGVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LnBhc3MoYENy ZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGAp OyB9KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVBy b21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIHJlbW92ZUVsZW1lbnRXaXRoQ2xh c3MoY2xhc3NOYW1lKSB7CisgICAgZnVuY3Rpb24gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcyhjbGFz c05hbWUsIHNob3VsZENoZWNrRWxlbWVudCkgewogICAgICAgICByZXR1cm4gZXZhbHVhdGVXaXRo TG9nKGByZW1vdmVFbGVtZW50V2l0aENsYXNzKCIke2NsYXNzTmFtZX0iKWApCiAgICAgICAgIC50 aGVuKCgpID0+IGNoZWNrRWxlbWVudHNXaXRoQ2xhc3MoY2xhc3NOYW1lLCAwKSkKKyAgICAgICAg LnRoZW4oKCkgPT4geworICAgICAgICAgICAgaWYgKHNob3VsZENoZWNrRWxlbWVudCkgeworICAg ICAgICAgICAgICAgIGlmIChwc2V1ZG9FbGVtZW50UmVtb3ZlZCkKKyAgICAgICAgICAgICAgICAg ICAgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRSZW1vdmVkLnBzZXVkb0Vs ZW1lbnRJZCwgcHNldWRvRWxlbWVudC5ub2RlSWQsIGBSZW1vdmVkIDo6JHtwc2V1ZG9FbGVtZW50 QWRkZWQucHNldWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsKKyAgICAgICAgICAgICAgICBlbHNl CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwc2V1ZG9FbGVtZW50UmVtb3ZlZFByb21pc2Uu dGhlbigoKSA9PiB7IFByb3RvY29sVGVzdC5leHBlY3RFcXVhbChwc2V1ZG9FbGVtZW50UmVtb3Zl ZC5wc2V1ZG9FbGVtZW50SWQsIHBzZXVkb0VsZW1lbnRBZGRlZC5ub2RlSWQsIGBSZW1vdmVkIDo6 JHtwc2V1ZG9FbGVtZW50QWRkZWQucHNldWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsgfSk7Cisg ICAgICAgICAgICB9CisgICAgICAgIH0pCiAgICAgICAgIC5jYXRjaChoYW5kbGVQcm9taXNlUmVq ZWN0KTsKICAgICB9CiAKLSAgICBJbnNwZWN0b3JQcm90b2NvbC5ldmVudEhhbmRsZXJbIkRPTS5w c2V1ZG9FbGVtZW50QWRkZWQiXSA9IChyZXNwb25zZSkgPT4gewotICAgICAgICBwc2V1ZG9FbGVt ZW50ID0gcmVzcG9uc2UucGFyYW1zLnBzZXVkb0VsZW1lbnQ7Ci0KLSAgICAgICAgUHJvdG9jb2xU ZXN0LnBhc3MoYENyZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnQucHNldWRvVHlwZX0gcHNldWRvIGVs ZW1lbnRgKTsKLSAgICB9OworICAgIGxldCBwc2V1ZG9FbGVtZW50QWRkZWRQcm9taXNlID0gSW5z cGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6ICJET00ucHNldWRvRWxlbWVudEFkZGVk In0pLnRoZW4oKGV2ZW50KSA9PiB7IHBzZXVkb0VsZW1lbnRBZGRlZCA9IGV2ZW50LnBhcmFtcy5w c2V1ZG9FbGVtZW50fSk7CisgICAgbGV0IHBzZXVkb0VsZW1lbnRSZW1vdmVkUHJvbWlzZSA9IElu c3BlY3RvclByb3RvY29sLmF3YWl0RXZlbnQoe2V2ZW50OiAiRE9NLnBzZXVkb0VsZW1lbnRSZW1v dmVkIn0pLnRoZW4oKGV2ZW50KSA9PiB7IHBzZXVkb0VsZW1lbnRSZW1vdmVkID0gZXZlbnQucGFy YW1zfSk7CiAKLSAgICBJbnNwZWN0b3JQcm90b2NvbC5ldmVudEhhbmRsZXJbIkRPTS5wc2V1ZG9F bGVtZW50UmVtb3ZlZCJdID0gKHJlc3BvbnNlKSA9PiB7Ci0gICAgICAgIFByb3RvY29sVGVzdC5l eHBlY3RFcXVhbChyZXNwb25zZS5wYXJhbXMucHNldWRvRWxlbWVudElkLCBwc2V1ZG9FbGVtZW50 Lm5vZGVJZCwgYFJlbW92ZWQgOjoke3BzZXVkb0VsZW1lbnQucHNldWRvVHlwZX0gcHNldWRvIGVs ZW1lbnRgKTsKLSAgICB9OwogCiAgICAgUHJvdG9jb2xUZXN0LmxvZygiUmVxdWVzdGluZyBkb2N1 bWVudC4uLiIpOwogICAgIEluc3BlY3RvclByb3RvY29sLnNlbmRDb21tYW5kKCJET00uZ2V0RG9j dW1lbnQiLCB7fSwgKHJlc3BvbnNlKSA9PiB7CkBAIC04NSwxMCArOTYsMTAgQEAgZnVuY3Rpb24g dGVzdCgpIHsKICAgICAgICAgZG9jdW1lbnROb2RlID0gcmVzcG9uc2UucmVzdWx0LnJvb3Q7CiAK ICAgICAgICAgUHJvbWlzZS5yZXNvbHZlKCkKLSAgICAgICAgLnRoZW4oKCkgPT4gY3JlYXRlRWxl bWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1jb250ZW50IikpCi0gICAgICAgIC50 aGVuKCgpID0+IHJlbW92ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGhvdXQtY29u dGVudCIpKQotICAgICAgICAudGhlbigoKSA9PiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0 LXBzZXVkby13aXRoLWNvbnRlbnQiKSkKLSAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVu dFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250ZW50IikpCisgICAgICAgIC50aGVuKCgp ID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGhvdXQtY29udGVudCIp LCBmYWxzZSkKKyAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVz dC1wc2V1ZG8td2l0aG91dC1jb250ZW50IiksIGZhbHNlKQorICAgICAgICAudGhlbigoKSA9PiBj cmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLCB0cnVlKSkK KyAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8t d2l0aC1jb250ZW50IiwgdHJ1ZSkpCiAgICAgICAgIC50aGVuKCgpID0+IFByb3RvY29sVGVzdC5j b21wbGV0ZVRlc3QoKSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVByb21pc2VSZWplY3QpOwogICAg IH0pOwo= 381106 2019-10-16 14:11:56 -0700 2019-10-16 15:31:49 -0700 Patch bug-202874-20191016141156.patch text/plain 14089 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc1NTVkNGVhN2QxOGE4YTliNGEwOGM4 NDIzOWExZGM3NzFmYWQ2OTQuLjRkYzZhMGVmZWY1YjJhMmFjNTFjNjk4NTU0OTIyMGViOTE3ZGI4 YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTktMTAtMTYgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9vcCB0byBwcm9j ZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8gcHJvZmlsaW5n LiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHVzZSBDRlJ1bmxv b3BTb3VyY2UxIGluc3RlYWQgb2YgQ0ZSdW5sb29wU291cmNlMC4KKworICAgICAgICAqIHd0Zi9S dW5Mb29wLmg6CisgICAgICAgICogd3RmL2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6UnVuTG9vcCk6 CisgICAgICAgIChXVEY6OlJ1bkxvb3A6On5SdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9v cDo6d2FrZVVwKToKKyAgICAgICAgKiB3dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tOgorICAg ICAgICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKwogMjAx OS0xMC0xNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCBmaXggdGhlIGludGVybmFsIG1hY09TIDEwLjEzIGFuZCAxMC4xNCBidWls ZHMgYWZ0ZXIgcjI1MTE3MQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5oIGIv U291cmNlL1dURi93dGYvUnVuTG9vcC5oCmluZGV4IDlkZTg4NTliYTI2N2UyYzRhM2U3NTRmY2M4 ZDI4YTE5YThkMGE4ZjYuLmIwZTQxODY2ZDE1OGZiNjQ0NDMxM2ZhZTcwYTNhNmRkNGUxYzllYjIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmgKQEAgLTE3OCw5ICsxNzgsMTAgQEAgcHJpdmF0ZToKIAogICAgIExvY2sgbV9s b29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09QKQotICAgIHN0YXRpYyB2b2lkIHBl cmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayhDRk1hY2hQb3J0 UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCogaW5mbyk7CiAgICAgUmV0YWluUHRy PENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BTb3VyY2VS ZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0 OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBHUmVmUHRyPEdNYWluQ29udGV4dD4g bV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxHTWFpbkxvb3A+PiBtX21haW5Mb29w czsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAgYi9Tb3VyY2Uv V1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IDI3ZDNmZTJjOWNiNDI4N2JhNzg1MzU4NGY0 ODM5ZWIzN2VmOTA3YTIuLmIyZTJlNWI3NDE3NzRkOTBjM2ZlYmZiNzk3ZmEwNTA5YTNlNzFmOWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKKysrIGIvU291cmNl L1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYgKzI4LDI5IEBACiAKICNpbmNsdWRl IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNoL2Rp c3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9kcmFp bmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29y ayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVm LCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wgcG9v bDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7Cisg ICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBSdW5M b29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpCiB7 Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAwLCAw LCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0 Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250ZXh0 KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0ciwg bnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0 ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIpKTsK KyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29wU291 cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVuTG9v cEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NGUnVu TG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENGTWFj aFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52YWxp ZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBAIC01OCw4ICs2MSwxNiBAQCB2b2lk IFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVyYXRpb24pCiAKIHZvaWQgUnVuTG9v cDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291cmNl LmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBtYWNo X21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNHSF9C SVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXplID0g c2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9ydCA9 IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9jYWxf cG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBtYWNo X21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNHIHwg TUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxMLCAw LCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hfTVNH X1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChyZXN1 bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgmaGVh ZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoY29uc3QgU3Ry aW5nJiBtb2RlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENv Y29hLm1tIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tCmluZGV4IDI3 ZWIwMGRiYTEwOWJhMWZhNTAwZDU3Y2JiNWYzMTQ1YjdlMjEyNDkuLjZmZTg5ZTM0YWY2YTVhMjU4 MDg0NzZlZmRjYmY4MTM0OGYxNTcxOGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NvY29h L01haW5UaHJlYWRDb2NvYS5tbQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFk Q29jb2EubW0KQEAgLTEzMSw3ICsxMzEsOSBAQCB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlv bnNPbk1haW5UaHJlYWQoKQogICAgIH0KICNlbmRpZgogCi0gICAgW3N0YXRpY01haW5UaHJlYWRD YWxsZXIgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3aXRoT2Jq ZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKKyAgICBkaXNwYXRjaF9hc3luYyhkaXNwYXRjaF9n ZXRfbWFpbl9xdWV1ZSgpLCBeeworICAgICAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBjYWxs XTsKKyAgICB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFzeW5jT25NYWluVGhyZWFkV2l0aFdlYlRo cmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOWM5YzUwMGExMzI2OTJlZmY4YmE5NWFlYzA3 ZGU0NmFhYzkzOWQ0Yy4uMjgxM2M0ZTA3YmI3YjI4MjUwNzY1OGY5YTMzNWYwOGZjMWE2Njc1YSAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE0IEBACisyMDE5LTEwLTE2ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgor CisgICAgICAgIFVzaW5nIENGUnVuTG9vcFNvdXJjZTEgZm9yIGZhc3RlciB0YXNrIGRpc3BhdGNo CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBGaXggYSBm bGFreSB0ZXN0LgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWw6CisKIDIwMTktMTAtMTYgIEZ1amlpIEhpcm9ub3JpICA8SGlyb25vcmkuRnVq aWlAc29ueS5jb20+CiAKICAgICAgICAgRHVtcFJlbmRlclRyZWUgc2hvdWxkIGNsZWFyIFdURkxv Z0NoYW5uZWxTdGF0ZTo6T25XaXRoQWNjdW11bGF0aW9uIHN0YXRlIHNldCBieSB0ZXN0UnVubmVy LmFjY3VtbXVsYXRlTG9nc0ZvckNoYW5uZWwKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQvZ2V0VXNlck1lZGlhLmh0bWwKaW5kZXggY2IzMmQ4MGViNjg3ZWIzM2ExY2Jm ZDI3NTU2ZTRlNzMwZjE2ZmY5OS4uN2U0NjE3YmZlODk2OGI3ZTk3MzgxYjIyMjNiN2E2NDA1OTU4 NDAxNCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNl ck1lZGlhLmh0bWwKQEAgLTIsMTQgKzIsMTUgQEAKIDxodG1sPgogICAgIDxoZWFkPgogICAgICAg ICA8c2NyaXB0PgotCi0gICAgICAgICAgICBsZXQgc3RyZWFtID0gbnVsbDsKKyAgICAgICAgICAg IGxldCBzdHJlYW1Qcm9taXNlID0gUHJvbWlzZS5yZXNvbHZlKCk7CiAKICAgICAgICAgICAgIGZ1 bmN0aW9uIHByb21wdEZvckNhcHR1cmUoKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAg IG5hdmlnYXRvci5tZWRpYURldmljZXMuZW51bWVyYXRlRGV2aWNlcygpLnRoZW4oKCkgPT4gewor ICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmVu dW1lcmF0ZURldmljZXMoKS50aGVuKCgpID0+IHsKICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHsgYXVkaW86IGZhbHNlLCB2aWRl bzogdHJ1ZSB9KQotICAgICAgICAgICAgICAgIH0pLnRoZW4oKHMpID0+IHsKKyAgICAgICAgICAg ICAgICB9KTsKKworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9 PiB7CiAgICAgICAgICAgICAgICAgICAgIHN0cmVhbSA9IHM7CiAgICAgICAgICAgICAgICAgICAg IHZpZGVvLnNyY09iamVjdCA9IHN0cmVhbTsKICAgICAgICAgICAgICAgICAgICAgY29uc29sZS5s b2coIkdvdCB1c2VyIG1lZGlhIik7CkBAIC0xOCwyMyArMTksMjkgQEAKIAogICAgICAgICAgICAg ZnVuY3Rpb24gc3RvcChraW5kKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIGxldCBh Y3RpdmVUcmFja3MgPSBbXTsKLSAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJhY2tzKCkuZm9y RWFjaCh0cmFjayA9PiB7Ci0gICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5r aW5kID09IGtpbmQpCi0gICAgICAgICAgICAgICAgICAgICAgICB0cmFjay5zdG9wKCk7Ci0gICAg ICAgICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNr cy5wdXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVh bSkgPT4geworICAgICAgICAgICAgICAgICAgICBsZXQgYWN0aXZlVHJhY2tzID0gW107CisgICAg ICAgICAgICAgICAgICAgIHN0cmVhbS5nZXRUcmFja3MoKS5mb3JFYWNoKHRyYWNrID0+IHsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5raW5kID09IGtpbmQpCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOworICAgICAgICAgICAgICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2ZVRyYWNrcy5w dXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CisgCisgICAgICAgICAgICAgICAg ICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkgeworICAgICAgICAgICAgICAgICAgICAgICAg c3RyZWFtUHJvbWlzZURpZFJlc29sdmUgPSBmYWxzZTsKKyAgICAgICAgICAgICAgICAgICAgICAg IHZpZGVvLnNyY09iamVjdCA9IG51bGw7CisgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAg ICAgICAgICB9KTsKLQotICAgICAgICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkg ewotICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBudWxsOwotICAgICAgICAgICAgICAgICAg ICB2aWRlby5zcmNPYmplY3QgPSBudWxsOwotICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg IH0KIAorICAgICAgICAgICAgbGV0IHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0gZmFsc2U7CisK ICAgICAgICAgICAgIGZ1bmN0aW9uIGhhdmVTdHJlYW0oKQogICAgICAgICAgICAgewotICAgICAg ICAgICAgICAgIHJldHVybiBzdHJlYW0gIT09IG51bGw7CisgICAgICAgICAgICAgICAgLy8gT3Vy IGNhbGxlciBwb2xscyByZXBlYXRlZGx5IHVudGlsIG91ciBwcm9taXNlIHJlc29sdmVzLgorICAg ICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9PiBzdHJlYW1Qcm9taXNl RGlkUmVzb2x2ZSA9ICEhc3RyZWFtKTsKKyAgICAgICAgICAgICAgICByZXR1cm4gc3RyZWFtUHJv bWlzZURpZFJlc29sdmU7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRv TXVsdGlwbGVHZXRVc2VyTWVkaWFTeW5jaHJvbm91c2x5KCkKQEAgLTUzLDEyICs2MCwxMiBAQAog CiAgICAgICAgICAgICBmdW5jdGlvbiBjYXB0dXJlQXVkaW8oKQogICAgICAgICAgICAgewotICAg ICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzog dHJ1ZX0pLnRoZW4ocyA9PiBzdHJlYW0gPSBzKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9t aXNlID0gbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlfSk7 CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVBdWRpb0FuZFZp ZGVvKCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZp Y2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSkudGhlbihzID0+IHN0 cmVhbSA9IHMpOworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVk aWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSk7CiAgICAg ICAgICAgICB9CiAgICAgICAgIDwvc2NyaXB0PgogICAgIDxoZWFkPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGNkOWUxYzhj YTUyODI5NGI4MjI5MzYyNzRjODc5Yzg4ZGNhNDkzMGUuLjMzZWY1NTVjNDY5ZTNjMDc5YzQ5NzEx YjdiN2I3ZTdlM2FhYjY3OWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysg Yi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxOS0xMC0xNiAgU2lo dWkgTGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBVc2luZyBDRlJ1bkxvb3BT b3VyY2UxIGZvciBmYXN0ZXIgdGFzayBkaXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAgICAgICAqIGlu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBpbnNw ZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sOgorCiAyMDE5LTEwLTE2ICBSdXNzZWxsIEVw c3RlaW4gIDxyZXBzdGVpbkBhcHBsZS5jb20+CiAKICAgICAgICAgQ29ycmVjdCBUZXN0RXhwZWN0 YXRpb25zIGZyb20gcjI1MTExOS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA1YjgzMjMzNDlhMTI4YmE2NjNi ZGM4NzhiNGE2MmVkNjQyM2Q4MTcyLi40OWI3ZmZhNzRmZDAyMWRlYmU4YzcwZTc3MWY2YmVmYjhi ZGUyZGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVh dGlvbi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8t Y3JlYXRpb24tZXhwZWN0ZWQudHh0CkBAIC0xMiwxMSArMTIsMTEgQEAgUEFTUzogVGhlcmUgc2hv dWxkIGJlIDAgbm9kZSB3aXRoIHRoZSBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGhvdXQtY29udGVu dCIuCiAKIENhbGxpbmcgImNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgt Y29udGVudCIpIi4uLgogQ2hlY2tpbmcgZm9yIG5vZGVzIHdpdGggY2xhc3MgIi50ZXN0LXBzZXVk by13aXRoLWNvbnRlbnQiLi4uCi1QQVNTOiBDcmVhdGVkIDo6YmVmb3JlIHBzZXVkbyBlbGVtZW50 CiBQQVNTOiBUaGVyZSBzaG91bGQgYmUgMSBub2RlIHdpdGggdGhlIGNsYXNzICIudGVzdC1wc2V1 ZG8td2l0aC1jb250ZW50Ii4KK1BBU1M6IENyZWF0ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQK IAogQ2FsbGluZyAicmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250 ZW50IikiLi4uCiBDaGVja2luZyBmb3Igbm9kZXMgd2l0aCBjbGFzcyAiLnRlc3QtcHNldWRvLXdp dGgtY29udGVudCIuLi4KLVBBU1M6IFJlbW92ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQKIFBB U1M6IFRoZXJlIHNob3VsZCBiZSAwIG5vZGUgd2l0aCB0aGUgY2xhc3MgIi50ZXN0LXBzZXVkby13 aXRoLWNvbnRlbnQiLgorUEFTUzogUmVtb3ZlZCA6OmJlZm9yZSBwc2V1ZG8gZWxlbWVudAogCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1s IGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbAppbmRleCBh MDFjZTBkMzY0NWQzOGY0N2U1MjY3ZWFjOWQ4ZTBmNDg2ZDFhNjQ2Li44NGY1MDUwMGJkMzc0NmNh M2JkNjg4ZDkwMGE0NzQ3MTI4MmM0OGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0 b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sCisrKyBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9j c3MvcHNldWRvLWNyZWF0aW9uLmh0bWwKQEAgLTI2LDcgKzI2LDggQEAgZnVuY3Rpb24gcmVtb3Zl RWxlbWVudFdpdGhDbGFzcyhjbGFzc05hbWUpIHsKIAogZnVuY3Rpb24gdGVzdCgpIHsKICAgICBs ZXQgZG9jdW1lbnROb2RlID0gbnVsbDsKLSAgICBsZXQgcHNldWRvRWxlbWVudCA9IG51bGw7Cisg ICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRlZCA9IG51bGw7CisgICAgbGV0IHBzZXVkb0VsZW1lbnRS ZW1vdmVkID0gbnVsbDsKIAogICAgIGZ1bmN0aW9uIGhhbmRsZVByb21pc2VSZWplY3QoZXJyb3Ip IHsKICAgICAgICAgY29uc29sZS5sb2coZXJyb3IpOwpAQCAtNTYsMjcgKzU3LDM3IEBAIGZ1bmN0 aW9uIHRlc3QoKSB7CiAgICAgICAgIC5jYXRjaChoYW5kbGVQcm9taXNlUmVqZWN0KTsKICAgICB9 CiAKLSAgICBmdW5jdGlvbiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSkgeworICAg IGZ1bmN0aW9uIGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoY2xhc3NOYW1lLCBzaG91bGRDaGVja0Vs ZW1lbnQpIHsKICAgICAgICAgcmV0dXJuIGV2YWx1YXRlV2l0aExvZyhgY3JlYXRlRWxlbWVudFdp dGhDbGFzcygiJHtjbGFzc05hbWV9IilgKQogICAgICAgICAudGhlbigoKSA9PiBjaGVja0VsZW1l bnRzV2l0aENsYXNzKGNsYXNzTmFtZSwgMSkpCisgICAgICAgIC50aGVuKCgpID0+IHsKKyAgICAg ICAgICAgIGlmIChzaG91bGRDaGVja0VsZW1lbnQpIHsKKyAgICAgICAgICAgICAgICBpZiAocHNl dWRvRWxlbWVudEFkZGVkKQorICAgICAgICAgICAgICAgICAgICBQcm90b2NvbFRlc3QucGFzcyhg Q3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudEFkZGVkLnBzZXVkb1R5cGV9IHBzZXVkbyBlbGVtZW50 YCk7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcHNl dWRvRWxlbWVudEFkZGVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LnBhc3MoYENy ZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGAp OyB9KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVBy b21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIHJlbW92ZUVsZW1lbnRXaXRoQ2xh c3MoY2xhc3NOYW1lKSB7CisgICAgZnVuY3Rpb24gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcyhjbGFz c05hbWUsIHNob3VsZENoZWNrRWxlbWVudCkgewogICAgICAgICByZXR1cm4gZXZhbHVhdGVXaXRo TG9nKGByZW1vdmVFbGVtZW50V2l0aENsYXNzKCIke2NsYXNzTmFtZX0iKWApCiAgICAgICAgIC50 aGVuKCgpID0+IGNoZWNrRWxlbWVudHNXaXRoQ2xhc3MoY2xhc3NOYW1lLCAwKSkKKyAgICAgICAg LnRoZW4oKCkgPT4geworICAgICAgICAgICAgaWYgKHNob3VsZENoZWNrRWxlbWVudCkgeworICAg ICAgICAgICAgICAgIGlmIChwc2V1ZG9FbGVtZW50UmVtb3ZlZCkKKyAgICAgICAgICAgICAgICAg ICAgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRSZW1vdmVkLnBzZXVkb0Vs ZW1lbnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJZCwgYFJlbW92ZWQgOjoke3BzZXVkb0Vs ZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOworICAgICAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBzZXVkb0VsZW1lbnRSZW1vdmVkUHJv bWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRS ZW1vdmVkLnBzZXVkb0VsZW1lbnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJZCwgYFJlbW92 ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOyB9 KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVByb21p c2VSZWplY3QpOwogICAgIH0KIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50SGFuZGxlclsi RE9NLnBzZXVkb0VsZW1lbnRBZGRlZCJdID0gKHJlc3BvbnNlKSA9PiB7Ci0gICAgICAgIHBzZXVk b0VsZW1lbnQgPSByZXNwb25zZS5wYXJhbXMucHNldWRvRWxlbWVudDsKLQotICAgICAgICBQcm90 b2NvbFRlc3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9UeXBlfSBwc2V1 ZG8gZWxlbWVudGApOwotICAgIH07CisgICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRlZFByb21pc2Ug PSBJbnNwZWN0b3JQcm90b2NvbC5hd2FpdEV2ZW50KHtldmVudDogIkRPTS5wc2V1ZG9FbGVtZW50 QWRkZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudEFkZGVkID0gZXZlbnQucGFy YW1zLnBzZXVkb0VsZW1lbnR9KTsKKyAgICBsZXQgcHNldWRvRWxlbWVudFJlbW92ZWRQcm9taXNl ID0gSW5zcGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6ICJET00ucHNldWRvRWxlbWVu dFJlbW92ZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudFJlbW92ZWQgPSBldmVu dC5wYXJhbXN9KTsKIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50SGFuZGxlclsiRE9NLnBz ZXVkb0VsZW1lbnRSZW1vdmVkIl0gPSAocmVzcG9uc2UpID0+IHsKLSAgICAgICAgUHJvdG9jb2xU ZXN0LmV4cGVjdEVxdWFsKHJlc3BvbnNlLnBhcmFtcy5wc2V1ZG9FbGVtZW50SWQsIHBzZXVkb0Vs ZW1lbnQubm9kZUlkLCBgUmVtb3ZlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9UeXBlfSBwc2V1 ZG8gZWxlbWVudGApOwotICAgIH07CiAKICAgICBQcm90b2NvbFRlc3QubG9nKCJSZXF1ZXN0aW5n IGRvY3VtZW50Li4uIik7CiAgICAgSW5zcGVjdG9yUHJvdG9jb2wuc2VuZENvbW1hbmQoIkRPTS5n ZXREb2N1bWVudCIsIHt9LCAocmVzcG9uc2UpID0+IHsKQEAgLTg1LDEwICs5NiwxMCBAQCBmdW5j dGlvbiB0ZXN0KCkgewogICAgICAgICBkb2N1bWVudE5vZGUgPSByZXNwb25zZS5yZXN1bHQucm9v dDsKIAogICAgICAgICBQcm9taXNlLnJlc29sdmUoKQotICAgICAgICAudGhlbigoKSA9PiBjcmVh dGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSkKLSAgICAg ICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91 dC1jb250ZW50IikpCi0gICAgICAgIC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3Mo InRlc3QtcHNldWRvLXdpdGgtY29udGVudCIpKQotICAgICAgICAudGhlbigoKSA9PiByZW1vdmVF bGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSkKKyAgICAgICAgLnRo ZW4oKCkgPT4gY3JlYXRlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1jb250 ZW50IiksIGZhbHNlKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNz KCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSwgZmFsc2UpCisgICAgICAgIC50aGVuKCgp ID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29udGVudCIsIHRy dWUpKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBz ZXVkby13aXRoLWNvbnRlbnQiLCB0cnVlKSkKICAgICAgICAgLnRoZW4oKCkgPT4gUHJvdG9jb2xU ZXN0LmNvbXBsZXRlVGVzdCgpKQogICAgICAgICAuY2F0Y2goaGFuZGxlUHJvbWlzZVJlamVjdCk7 CiAgICAgfSk7Cg== 381124 2019-10-16 15:31:50 -0700 2019-10-17 01:30:04 -0700 Patch bug-202874-20191016153150.patch text/plain 14098 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc1NTVkNGVhN2QxOGE4YTliNGEwOGM4 NDIzOWExZGM3NzFmYWQ2OTQuLjRkYzZhMGVmZWY1YjJhMmFjNTFjNjk4NTU0OTIyMGViOTE3ZGI4 YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTktMTAtMTYgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9vcCB0byBwcm9j ZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8gcHJvZmlsaW5n LiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHVzZSBDRlJ1bmxv b3BTb3VyY2UxIGluc3RlYWQgb2YgQ0ZSdW5sb29wU291cmNlMC4KKworICAgICAgICAqIHd0Zi9S dW5Mb29wLmg6CisgICAgICAgICogd3RmL2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6UnVuTG9vcCk6 CisgICAgICAgIChXVEY6OlJ1bkxvb3A6On5SdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9v cDo6d2FrZVVwKToKKyAgICAgICAgKiB3dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tOgorICAg ICAgICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKwogMjAx OS0xMC0xNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCBmaXggdGhlIGludGVybmFsIG1hY09TIDEwLjEzIGFuZCAxMC4xNCBidWls ZHMgYWZ0ZXIgcjI1MTE3MQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5oIGIv U291cmNlL1dURi93dGYvUnVuTG9vcC5oCmluZGV4IDlkZTg4NTliYTI2N2UyYzRhM2U3NTRmY2M4 ZDI4YTE5YThkMGE4ZjYuLmIwZTQxODY2ZDE1OGZiNjQ0NDMxM2ZhZTcwYTNhNmRkNGUxYzllYjIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmgKQEAgLTE3OCw5ICsxNzgsMTAgQEAgcHJpdmF0ZToKIAogICAgIExvY2sgbV9s b29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09QKQotICAgIHN0YXRpYyB2b2lkIHBl cmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayhDRk1hY2hQb3J0 UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCogaW5mbyk7CiAgICAgUmV0YWluUHRy PENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BTb3VyY2VS ZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0 OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBHUmVmUHRyPEdNYWluQ29udGV4dD4g bV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxHTWFpbkxvb3A+PiBtX21haW5Mb29w czsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAgYi9Tb3VyY2Uv V1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IDI3ZDNmZTJjOWNiNDI4N2JhNzg1MzU4NGY0 ODM5ZWIzN2VmOTA3YTIuLmIyZTJlNWI3NDE3NzRkOTBjM2ZlYmZiNzk3ZmEwNTA5YTNlNzFmOWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKKysrIGIvU291cmNl L1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYgKzI4LDI5IEBACiAKICNpbmNsdWRl IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNoL2Rp c3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9kcmFp bmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29y ayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVm LCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wgcG9v bDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7Cisg ICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBSdW5M b29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpCiB7 Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAwLCAw LCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0 Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250ZXh0 KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0ciwg bnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0 ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIpKTsK KyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29wU291 cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVuTG9v cEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NGUnVu TG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENGTWFj aFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52YWxp ZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBAIC01OCw4ICs2MSwxNiBAQCB2b2lk IFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVyYXRpb24pCiAKIHZvaWQgUnVuTG9v cDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291cmNl LmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBtYWNo X21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNHSF9C SVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXplID0g c2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9ydCA9 IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9jYWxf cG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBtYWNo X21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNHIHwg TUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxMLCAw LCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hfTVNH X1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChyZXN1 bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgmaGVh ZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoY29uc3QgU3Ry aW5nJiBtb2RlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENv Y29hLm1tIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tCmluZGV4IDI3 ZWIwMGRiYTEwOWJhMWZhNTAwZDU3Y2JiNWYzMTQ1YjdlMjEyNDkuLmY2ZTI3ZmUwNDJhMDljOTZk MjRmM2JlNjE2NGM0MTk5NmRhOGJhOWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NvY29h L01haW5UaHJlYWRDb2NvYS5tbQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFk Q29jb2EubW0KQEAgLTEzMSw3ICsxMzEsOSBAQCB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlv bnNPbk1haW5UaHJlYWQoKQogICAgIH0KICNlbmRpZgogCi0gICAgW3N0YXRpY01haW5UaHJlYWRD YWxsZXIgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3aXRoT2Jq ZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKKyAgICBkaXNwYXRjaF9hc3luYyhkaXNwYXRjaF9n ZXRfbWFpbl9xdWV1ZSgpLCBeeworICAgICAgICBXVEY6OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1h aW5UaHJlYWQoKTsKKyAgICB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFzeW5jT25NYWluVGhyZWFk V2l0aFdlYlRocmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkpCmRpZmYgLS1naXQgYS9U b29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOWM5YzUwMGExMzI2OTJlZmY4 YmE5NWFlYzA3ZGU0NmFhYzkzOWQ0Yy4uMjgxM2M0ZTA3YmI3YjI4MjUwNzY1OGY5YTMzNWYwOGZj MWE2Njc1YSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE0IEBACisyMDE5LTEwLTE2ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBw bGUuY29tPgorCisgICAgICAgIFVzaW5nIENGUnVuTG9vcFNvdXJjZTEgZm9yIGZhc3RlciB0YXNr IGRpc3BhdGNoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMDI4NzQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBGaXggYSBmbGFreSB0ZXN0LgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQvZ2V0VXNlck1lZGlhLmh0bWw6CisKIDIwMTktMTAtMTYgIEZ1amlpIEhpcm9ub3JpICA8SGly b25vcmkuRnVqaWlAc29ueS5jb20+CiAKICAgICAgICAgRHVtcFJlbmRlclRyZWUgc2hvdWxkIGNs ZWFyIFdURkxvZ0NoYW5uZWxTdGF0ZTo6T25XaXRoQWNjdW11bGF0aW9uIHN0YXRlIHNldCBieSB0 ZXN0UnVubmVyLmFjY3VtbXVsYXRlTG9nc0ZvckNoYW5uZWwKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNlck1lZGlhLmh0bWwKaW5kZXggY2IzMmQ4MGViNjg3 ZWIzM2ExY2JmZDI3NTU2ZTRlNzMwZjE2ZmY5OS4uN2U0NjE3YmZlODk2OGI3ZTk3MzgxYjIyMjNi N2E2NDA1OTU4NDAxNCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQvZ2V0VXNlck1lZGlhLmh0bWwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQvZ2V0VXNlck1lZGlhLmh0bWwKQEAgLTIsMTQgKzIsMTUgQEAKIDxodG1sPgogICAgIDxoZWFk PgogICAgICAgICA8c2NyaXB0PgotCi0gICAgICAgICAgICBsZXQgc3RyZWFtID0gbnVsbDsKKyAg ICAgICAgICAgIGxldCBzdHJlYW1Qcm9taXNlID0gUHJvbWlzZS5yZXNvbHZlKCk7CiAKICAgICAg ICAgICAgIGZ1bmN0aW9uIHByb21wdEZvckNhcHR1cmUoKQogICAgICAgICAgICAgewotICAgICAg ICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZW51bWVyYXRlRGV2aWNlcygpLnRoZW4o KCkgPT4geworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZpZ2F0b3IubWVkaWFE ZXZpY2VzLmVudW1lcmF0ZURldmljZXMoKS50aGVuKCgpID0+IHsKICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHsgYXVkaW86IGZh bHNlLCB2aWRlbzogdHJ1ZSB9KQotICAgICAgICAgICAgICAgIH0pLnRoZW4oKHMpID0+IHsKKyAg ICAgICAgICAgICAgICB9KTsKKworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigo c3RyZWFtKSA9PiB7CiAgICAgICAgICAgICAgICAgICAgIHN0cmVhbSA9IHM7CiAgICAgICAgICAg ICAgICAgICAgIHZpZGVvLnNyY09iamVjdCA9IHN0cmVhbTsKICAgICAgICAgICAgICAgICAgICAg Y29uc29sZS5sb2coIkdvdCB1c2VyIG1lZGlhIik7CkBAIC0xOCwyMyArMTksMjkgQEAKIAogICAg ICAgICAgICAgZnVuY3Rpb24gc3RvcChraW5kKQogICAgICAgICAgICAgewotICAgICAgICAgICAg ICAgIGxldCBhY3RpdmVUcmFja3MgPSBbXTsKLSAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJh Y2tzKCkuZm9yRWFjaCh0cmFjayA9PiB7Ci0gICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8 fCB0cmFjay5raW5kID09IGtpbmQpCi0gICAgICAgICAgICAgICAgICAgICAgICB0cmFjay5zdG9w KCk7Ci0gICAgICAgICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICAgICAgICAgIGFj dGl2ZVRyYWNrcy5wdXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRo ZW4oKHN0cmVhbSkgPT4geworICAgICAgICAgICAgICAgICAgICBsZXQgYWN0aXZlVHJhY2tzID0g W107CisgICAgICAgICAgICAgICAgICAgIHN0cmVhbS5nZXRUcmFja3MoKS5mb3JFYWNoKHRyYWNr ID0+IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmICgha2luZCB8fCB0cmFjay5raW5kID09 IGtpbmQpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOworICAgICAg ICAgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGl2 ZVRyYWNrcy5wdXNoKHRyYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgfSk7CisgCisgICAgICAg ICAgICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tzLmxlbmd0aCkgeworICAgICAgICAgICAgICAg ICAgICAgICAgc3RyZWFtUHJvbWlzZURpZFJlc29sdmUgPSBmYWxzZTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIHZpZGVvLnNyY09iamVjdCA9IG51bGw7CisgICAgICAgICAgICAgICAgICAgIH0K ICAgICAgICAgICAgICAgICB9KTsKLQotICAgICAgICAgICAgICAgIGlmICghYWN0aXZlVHJhY2tz Lmxlbmd0aCkgewotICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBudWxsOwotICAgICAgICAg ICAgICAgICAgICB2aWRlby5zcmNPYmplY3QgPSBudWxsOwotICAgICAgICAgICAgICAgIH0KICAg ICAgICAgICAgIH0KIAorICAgICAgICAgICAgbGV0IHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0g ZmFsc2U7CisKICAgICAgICAgICAgIGZ1bmN0aW9uIGhhdmVTdHJlYW0oKQogICAgICAgICAgICAg ewotICAgICAgICAgICAgICAgIHJldHVybiBzdHJlYW0gIT09IG51bGw7CisgICAgICAgICAgICAg ICAgLy8gT3VyIGNhbGxlciBwb2xscyByZXBlYXRlZGx5IHVudGlsIG91ciBwcm9taXNlIHJlc29s dmVzLgorICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigoc3RyZWFtKSA9PiBzdHJl YW1Qcm9taXNlRGlkUmVzb2x2ZSA9ICEhc3RyZWFtKTsKKyAgICAgICAgICAgICAgICByZXR1cm4g c3RyZWFtUHJvbWlzZURpZFJlc29sdmU7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1 bmN0aW9uIGRvTXVsdGlwbGVHZXRVc2VyTWVkaWFTeW5jaHJvbm91c2x5KCkKQEAgLTUzLDEyICs2 MCwxMiBAQAogCiAgICAgICAgICAgICBmdW5jdGlvbiBjYXB0dXJlQXVkaW8oKQogICAgICAgICAg ICAgewotICAgICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlh KHthdWRpbzogdHJ1ZX0pLnRoZW4ocyA9PiBzdHJlYW0gPSBzKTsKKyAgICAgICAgICAgICAgICBz dHJlYW1Qcm9taXNlID0gbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlv OiB0cnVlfSk7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVB dWRpb0FuZFZpZGVvKCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBuYXZpZ2F0b3Iu bWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVlfSkudGhl bihzID0+IHN0cmVhbSA9IHMpOworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UgPSBuYXZp Z2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRydWUsIHZpZGVvOiB0cnVl fSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIDwvc2NyaXB0PgogICAgIDxoZWFkPgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4 IGNkOWUxYzhjYTUyODI5NGI4MjI5MzYyNzRjODc5Yzg4ZGNhNDkzMGUuLjMzZWY1NTVjNDY5ZTNj MDc5YzQ5NzExYjdiN2I3ZTdlM2FhYjY3OWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxOS0x MC0xNiAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBVc2luZyBD RlJ1bkxvb3BTb3VyY2UxIGZvciBmYXN0ZXIgdGFzayBkaXNwYXRjaAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAg ICAgICAqIGluc3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAg ICAgKiBpbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sOgorCiAyMDE5LTEwLTE2ICBS dXNzZWxsIEVwc3RlaW4gIDxyZXBzdGVpbkBhcHBsZS5jb20+CiAKICAgICAgICAgQ29ycmVjdCBU ZXN0RXhwZWN0YXRpb25zIGZyb20gcjI1MTExOS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2lu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2lu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA1YjgzMjMzNDlh MTI4YmE2NjNiZGM4NzhiNGE2MmVkNjQyM2Q4MTcyLi40OWI3ZmZhNzRmZDAyMWRlYmU4YzcwZTc3 MWY2YmVmYjhiZGUyZGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3Bz ZXVkby1jcmVhdGlvbi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nz cy9wc2V1ZG8tY3JlYXRpb24tZXhwZWN0ZWQudHh0CkBAIC0xMiwxMSArMTIsMTEgQEAgUEFTUzog VGhlcmUgc2hvdWxkIGJlIDAgbm9kZSB3aXRoIHRoZSBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGhv dXQtY29udGVudCIuCiAKIENhbGxpbmcgImNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNl dWRvLXdpdGgtY29udGVudCIpIi4uLgogQ2hlY2tpbmcgZm9yIG5vZGVzIHdpdGggY2xhc3MgIi50 ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLi4uCi1QQVNTOiBDcmVhdGVkIDo6YmVmb3JlIHBzZXVk byBlbGVtZW50CiBQQVNTOiBUaGVyZSBzaG91bGQgYmUgMSBub2RlIHdpdGggdGhlIGNsYXNzICIu dGVzdC1wc2V1ZG8td2l0aC1jb250ZW50Ii4KK1BBU1M6IENyZWF0ZWQgOjpiZWZvcmUgcHNldWRv IGVsZW1lbnQKIAogQ2FsbGluZyAicmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8t d2l0aC1jb250ZW50IikiLi4uCiBDaGVja2luZyBmb3Igbm9kZXMgd2l0aCBjbGFzcyAiLnRlc3Qt cHNldWRvLXdpdGgtY29udGVudCIuLi4KLVBBU1M6IFJlbW92ZWQgOjpiZWZvcmUgcHNldWRvIGVs ZW1lbnQKIFBBU1M6IFRoZXJlIHNob3VsZCBiZSAwIG5vZGUgd2l0aCB0aGUgY2xhc3MgIi50ZXN0 LXBzZXVkby13aXRoLWNvbnRlbnQiLgorUEFTUzogUmVtb3ZlZCA6OmJlZm9yZSBwc2V1ZG8gZWxl bWVudAogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVh dGlvbi5odG1sIGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRt bAppbmRleCBhMDFjZTBkMzY0NWQzOGY0N2U1MjY3ZWFjOWQ4ZTBmNDg2ZDFhNjQ2Li44NGY1MDUw MGJkMzc0NmNhM2JkNjg4ZDkwMGE0NzQ3MTI4MmM0OGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sCisrKyBiL0xheW91dFRlc3RzL2lu c3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLmh0bWwKQEAgLTI2LDcgKzI2LDggQEAgZnVuY3Rp b24gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcyhjbGFzc05hbWUpIHsKIAogZnVuY3Rpb24gdGVzdCgp IHsKICAgICBsZXQgZG9jdW1lbnROb2RlID0gbnVsbDsKLSAgICBsZXQgcHNldWRvRWxlbWVudCA9 IG51bGw7CisgICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRlZCA9IG51bGw7CisgICAgbGV0IHBzZXVk b0VsZW1lbnRSZW1vdmVkID0gbnVsbDsKIAogICAgIGZ1bmN0aW9uIGhhbmRsZVByb21pc2VSZWpl Y3QoZXJyb3IpIHsKICAgICAgICAgY29uc29sZS5sb2coZXJyb3IpOwpAQCAtNTYsMjcgKzU3LDM3 IEBAIGZ1bmN0aW9uIHRlc3QoKSB7CiAgICAgICAgIC5jYXRjaChoYW5kbGVQcm9taXNlUmVqZWN0 KTsKICAgICB9CiAKLSAgICBmdW5jdGlvbiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFt ZSkgeworICAgIGZ1bmN0aW9uIGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoY2xhc3NOYW1lLCBzaG91 bGRDaGVja0VsZW1lbnQpIHsKICAgICAgICAgcmV0dXJuIGV2YWx1YXRlV2l0aExvZyhgY3JlYXRl RWxlbWVudFdpdGhDbGFzcygiJHtjbGFzc05hbWV9IilgKQogICAgICAgICAudGhlbigoKSA9PiBj aGVja0VsZW1lbnRzV2l0aENsYXNzKGNsYXNzTmFtZSwgMSkpCisgICAgICAgIC50aGVuKCgpID0+ IHsKKyAgICAgICAgICAgIGlmIChzaG91bGRDaGVja0VsZW1lbnQpIHsKKyAgICAgICAgICAgICAg ICBpZiAocHNldWRvRWxlbWVudEFkZGVkKQorICAgICAgICAgICAgICAgICAgICBQcm90b2NvbFRl c3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudEFkZGVkLnBzZXVkb1R5cGV9IHBzZXVk byBlbGVtZW50YCk7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gcHNldWRvRWxlbWVudEFkZGVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0 LnBhc3MoYENyZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8g ZWxlbWVudGApOyB9KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNo KGhhbmRsZVByb21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIHJlbW92ZUVsZW1l bnRXaXRoQ2xhc3MoY2xhc3NOYW1lKSB7CisgICAgZnVuY3Rpb24gcmVtb3ZlRWxlbWVudFdpdGhD bGFzcyhjbGFzc05hbWUsIHNob3VsZENoZWNrRWxlbWVudCkgewogICAgICAgICByZXR1cm4gZXZh bHVhdGVXaXRoTG9nKGByZW1vdmVFbGVtZW50V2l0aENsYXNzKCIke2NsYXNzTmFtZX0iKWApCiAg ICAgICAgIC50aGVuKCgpID0+IGNoZWNrRWxlbWVudHNXaXRoQ2xhc3MoY2xhc3NOYW1lLCAwKSkK KyAgICAgICAgLnRoZW4oKCkgPT4geworICAgICAgICAgICAgaWYgKHNob3VsZENoZWNrRWxlbWVu dCkgeworICAgICAgICAgICAgICAgIGlmIChwc2V1ZG9FbGVtZW50UmVtb3ZlZCkKKyAgICAgICAg ICAgICAgICAgICAgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRSZW1vdmVk LnBzZXVkb0VsZW1lbnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJZCwgYFJlbW92ZWQgOjok e3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOworICAgICAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBzZXVkb0VsZW1lbnRS ZW1vdmVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVk b0VsZW1lbnRSZW1vdmVkLnBzZXVkb0VsZW1lbnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJ ZCwgYFJlbW92ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxl bWVudGApOyB9KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhh bmRsZVByb21pc2VSZWplY3QpOwogICAgIH0KIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50 SGFuZGxlclsiRE9NLnBzZXVkb0VsZW1lbnRBZGRlZCJdID0gKHJlc3BvbnNlKSA9PiB7Ci0gICAg ICAgIHBzZXVkb0VsZW1lbnQgPSByZXNwb25zZS5wYXJhbXMucHNldWRvRWxlbWVudDsKLQotICAg ICAgICBQcm90b2NvbFRlc3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9U eXBlfSBwc2V1ZG8gZWxlbWVudGApOwotICAgIH07CisgICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRl ZFByb21pc2UgPSBJbnNwZWN0b3JQcm90b2NvbC5hd2FpdEV2ZW50KHtldmVudDogIkRPTS5wc2V1 ZG9FbGVtZW50QWRkZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudEFkZGVkID0g ZXZlbnQucGFyYW1zLnBzZXVkb0VsZW1lbnR9KTsKKyAgICBsZXQgcHNldWRvRWxlbWVudFJlbW92 ZWRQcm9taXNlID0gSW5zcGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6ICJET00ucHNl dWRvRWxlbWVudFJlbW92ZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudFJlbW92 ZWQgPSBldmVudC5wYXJhbXN9KTsKIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50SGFuZGxl clsiRE9NLnBzZXVkb0VsZW1lbnRSZW1vdmVkIl0gPSAocmVzcG9uc2UpID0+IHsKLSAgICAgICAg UHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHJlc3BvbnNlLnBhcmFtcy5wc2V1ZG9FbGVtZW50SWQs IHBzZXVkb0VsZW1lbnQubm9kZUlkLCBgUmVtb3ZlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9U eXBlfSBwc2V1ZG8gZWxlbWVudGApOwotICAgIH07CiAKICAgICBQcm90b2NvbFRlc3QubG9nKCJS ZXF1ZXN0aW5nIGRvY3VtZW50Li4uIik7CiAgICAgSW5zcGVjdG9yUHJvdG9jb2wuc2VuZENvbW1h bmQoIkRPTS5nZXREb2N1bWVudCIsIHt9LCAocmVzcG9uc2UpID0+IHsKQEAgLTg1LDEwICs5Niwx MCBAQCBmdW5jdGlvbiB0ZXN0KCkgewogICAgICAgICBkb2N1bWVudE5vZGUgPSByZXNwb25zZS5y ZXN1bHQucm9vdDsKIAogICAgICAgICBQcm9taXNlLnJlc29sdmUoKQotICAgICAgICAudGhlbigo KSA9PiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQi KSkKLSAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1 ZG8td2l0aG91dC1jb250ZW50IikpCi0gICAgICAgIC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRX aXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29udGVudCIpKQotICAgICAgICAudGhlbigoKSA9 PiByZW1vdmVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSkKKyAg ICAgICAgLnRoZW4oKCkgPT4gY3JlYXRlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0 aG91dC1jb250ZW50IiksIGZhbHNlKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50 V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSwgZmFsc2UpCisgICAgICAg IC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29u dGVudCIsIHRydWUpKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNz KCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLCB0cnVlKSkKICAgICAgICAgLnRoZW4oKCkgPT4g UHJvdG9jb2xUZXN0LmNvbXBsZXRlVGVzdCgpKQogICAgICAgICAuY2F0Y2goaGFuZGxlUHJvbWlz ZVJlamVjdCk7CiAgICAgfSk7Cg== 381180 2019-10-17 01:30:06 -0700 2019-10-17 12:58:27 -0700 Patch bug-202874-20191017013001.patch text/plain 18133 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc1NTVkNGVhN2QxOGE4YTliNGEwOGM4 NDIzOWExZGM3NzFmYWQ2OTQuLjk1ZjYyN2M2YTk0YjU4YTc0YWFjYzY2NjY4MTZhMzVjZDQ1MGZk NDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTktMTAtMTcgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgdmVyc2lvbiAxIENGUnVubG9vcFNvdXJjZSBm b3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9v cCB0byBwcm9jZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8g cHJvZmlsaW5nLiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHdl IHNob3VsZCB1c2UgdmVyc2lvbiAxIENGUnVubG9vcFNvdXJjZSBpbnN0ZWFkIG9mIHZlcnNpb24g MC4gVGhpcyBwYXRjaCBicmluZ3MKKyAgICAgICAgYWJvdXQgMTUlIHNwZWVkdXAgZm9yIHRlc3Qg UGVyZm9ybWFuY2VUZXN0cy9JbmRleGVkREIvYmFzaWMvb2JqZWN0c3RvcmUtZ2V0Lmh0bWwuCisK KyAgICAgICAgKiB3dGYvUnVuTG9vcC5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OmluaXRp YWxpemVXZWJSdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6d2ViKToKKyAgICAgICAg KiB3dGYvUnVuTG9vcC5oOgorICAgICAgICAqIHd0Zi9jZi9SdW5Mb29wQ0YuY3BwOgorICAgICAg ICAoV1RGOjpSdW5Mb29wOjpwZXJmb3JtV29yayk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1 bkxvb3ApOgorICAgICAgICAoV1RGOjpSdW5Mb29wOjp+UnVuTG9vcCk6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6Ondha2VVcCk6CisgICAgICAgICogd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5t bToKKyAgICAgICAgKFdURjo6aW5pdGlhbGl6ZU1haW5UaHJlYWRQbGF0Zm9ybSk6CisgICAgICAg IChXVEY6OnNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQpOgorICAgICAgICAo V1RGOjppbml0aWFsaXplV2ViVGhyZWFkKToKKyAgICAgICAgKC1bSlNXVEZNYWluVGhyZWFkQ2Fs bGVyIGNhbGxdKTogRGVsZXRlZC4KKwogMjAxOS0xMC0xNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29u X2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBmaXggdGhlIGludGVybmFs IG1hY09TIDEwLjEzIGFuZCAxMC4xNCBidWlsZHMgYWZ0ZXIgcjI1MTE3MQpkaWZmIC0tZ2l0IGEv U291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApp bmRleCAxYmUyMmQ4MDlmM2RlNjk1NTk5NjY1ZDIxMzBjOWRkY2YxYjAwZTcwLi45MzhiOWU5OWQ1 ZTQxNDg4MmNjOWUwMzEwN2JmNGY2NjNmYzIyNGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApAQCAtMzMsNiAr MzMsOSBAQAogbmFtZXNwYWNlIFdURiB7CiAKIHN0YXRpYyBSdW5Mb29wKiBzX21haW5SdW5Mb29w OworI2lmIFVTRShXRUJfVEhSRUFEKQorc3RhdGljIFJ1bkxvb3AqIHNfd2ViUnVuTG9vcDsKKyNl bmRpZgogCiAvLyBIZWxwZXIgY2xhc3MgZm9yIFRocmVhZFNwZWNpZmljRGF0YS4KIGNsYXNzIFJ1 bkxvb3A6OkhvbGRlciB7CkBAIC02OSw2ICs3MiwxOSBAQCBSdW5Mb29wJiBSdW5Mb29wOjptYWlu KCkKICAgICByZXR1cm4gKnNfbWFpblJ1bkxvb3A7CiB9CiAKKyNpZiBVU0UoV0VCX1RIUkVBRCkK K3ZvaWQgUnVuTG9vcDo6aW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKQoreworICAgIHNfd2ViUnVuTG9v cCA9ICZSdW5Mb29wOjpjdXJyZW50KCk7Cit9CisKK1J1bkxvb3AmIFJ1bkxvb3A6OndlYigpCit7 CisgICAgQVNTRVJUKHNfd2ViUnVuTG9vcCk7CisgICAgcmV0dXJuICpzX3dlYlJ1bkxvb3A7Cit9 CisjZW5kaWYKKwogYm9vbCBSdW5Mb29wOjppc01haW4oKQogewogICAgIEFTU0VSVChzX21haW5S dW5Mb29wKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaCBiL1NvdXJjZS9X VEYvd3RmL1J1bkxvb3AuaAppbmRleCA5ZGU4ODU5YmEyNjdlMmM0YTNlNzU0ZmNjOGQyOGExOWE4 ZDBhOGY2Li5hODUxMThkN2MzNTc1ZDNjMDgxZGQxZmZmOTVhYzU3Y2I0ZjAwNDU4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgKKysrIGIvU291cmNlL1dURi93dGYvUnVuTG9v cC5oCkBAIC00OSw5ICs0OSwxNSBAQCBwdWJsaWM6CiAgICAgLy8gTXVzdCBiZSBjYWxsZWQgZnJv bSB0aGUgbWFpbiB0aHJlYWQgKGV4Y2VwdCBmb3IgdGhlIE1hYyBwbGF0Zm9ybSwgd2hlcmUgaXQK ICAgICAvLyBjYW4gYmUgY2FsbGVkIGZyb20gYW55IHRocmVhZCkuCiAgICAgV1RGX0VYUE9SVF9Q UklWQVRFIHN0YXRpYyB2b2lkIGluaXRpYWxpemVNYWluUnVuTG9vcCgpOworI2lmIFVTRShXRUJf VEhSRUFEKQorICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBpbml0aWFsaXplV2Vi UnVuTG9vcCgpOworI2VuZGlmCiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxv b3AmIGN1cnJlbnQoKTsKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIG1h aW4oKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGlj IFJ1bkxvb3AmIHdlYigpOworI2VuZGlmCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBi b29sIGlzTWFpbigpOwogICAgIH5SdW5Mb29wKCk7CiAKQEAgLTE3OCw5ICsxODQsMTAgQEAgcHJp dmF0ZToKIAogICAgIExvY2sgbV9sb29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09Q KQotICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBw ZXJmb3JtV29yayhDRk1hY2hQb3J0UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCog aW5mbyk7CiAgICAgUmV0YWluUHRyPENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFp blB0cjxDRlJ1bkxvb3BTb3VyY2VSZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8 Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBH UmVmUHRyPEdNYWluQ29udGV4dD4gbV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxH TWFpbkxvb3A+PiBtX21haW5Mb29wczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1 bkxvb3BDRi5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IDI3ZDNm ZTJjOWNiNDI4N2JhNzg1MzU4NGY0ODM5ZWIzN2VmOTA3YTIuLmIyZTJlNWI3NDE3NzRkOTBjM2Zl YmZiNzk3ZmEwNTA5YTNlNzFmOWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxv b3BDRi5jcHAKKysrIGIvU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYg KzI4LDI5IEBACiAKICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgog I2luY2x1ZGUgPGRpc3BhdGNoL2Rpc3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAj aW5jbHVkZSA8d3RmL0F1dG9kcmFpbmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9p ZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJm b3JtV29yayhDRk1hY2hQb3J0UmVmLCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAg ICBBdXRvZHJhaW5lZFBvb2wgcG9vbDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4 dCktPnBlcmZvcm1Xb3JrKCk7CisgICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJm b3JtV29yaygpOwogfQogCiBSdW5Mb29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1 bkxvb3BHZXRDdXJyZW50KCkpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0 ID0geyAwLCB0aGlzLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1f cnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRv ckRlZmF1bHQsIDAsICZjb250ZXh0KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9 IHsgMCwgdGhpcywgbnVsbHB0ciwgbnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFk b3B0Q0YoQ0ZNYWNoUG9ydENyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywg JmNvbnRleHQsIG51bGxwdHIpKTsKKyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFj aFBvcnRDcmVhdGVSdW5Mb29wU291cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQo KSwgMCkpOwogICAgIENGUnVuTG9vcEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9v cFNvdXJjZS5nZXQoKSwga0NGUnVuTG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1 bkxvb3AoKQogeworICAgIENGTWFjaFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAg Q0ZSdW5Mb29wU291cmNlSW52YWxpZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBA IC01OCw4ICs2MSwxNiBAQCB2b2lkIFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVy YXRpb24pCiAKIHZvaWQgUnVuTG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VT aWduYWwobV9ydW5Mb29wU291cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5M b29wLmdldCgpKTsKKyAgICBtYWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1z Z2hfYml0cyA9IE1BQ0hfTVNHSF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAg ICBoZWFkZXIubXNnaF9zaXplID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFk ZXIubXNnaF9yZW1vdGVfcG9ydCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7Cisg ICAgaGVhZGVyLm1zZ2hfbG9jYWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5t c2doX2lkID0gMDsKKyAgICBtYWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVh ZGVyLCBNQUNIX1NFTkRfTVNHIHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUs IDAsIE1BQ0hfUE9SVF9OVUxMLCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NF UlQocmVzdWx0ID09IE1BQ0hfTVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1F RF9PVVQpOworICAgIGlmIChyZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAg bWFjaF9tc2dfZGVzdHJveSgmaGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVu TG9vcDo6Y3ljbGUoY29uc3QgU3RyaW5nJiBtb2RlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93 dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRo cmVhZENvY29hLm1tCmluZGV4IDI3ZWIwMGRiYTEwOWJhMWZhNTAwZDU3Y2JiNWYzMTQ1YjdlMjEy NDkuLjI3MGI3YjA5Yjk2NjBhNGZkZjEwNDRmZWJjOTQwOTI3NmIwNGM4N2QgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbQorKysgYi9Tb3VyY2UvV1RG L3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW0KQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBvcnQg PHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW1wb3J0IDx3dGYvSGFzaFNldC5oPgogI2ltcG9ydCA8d3Rm L1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL1J1bkxvb3AuaD4KICNpbXBvcnQgPHd0Zi9TY2hl ZHVsZVBhaXIuaD4KICNpbXBvcnQgPHd0Zi9UaHJlYWRpbmcuaD4KIApAQCAtNDMsMTkgKzQ0LDYg QEAKICNpbmNsdWRlIDx3dGYvaW9zL1dlYkNvcmVUaHJlYWQuaD4KICNlbmRpZgogCi1AaW50ZXJm YWNlIEpTV1RGTWFpblRocmVhZENhbGxlciA6IE5TT2JqZWN0Ci0tICh2b2lkKWNhbGw7Ci1AZW5k Ci0KLUBpbXBsZW1lbnRhdGlvbiBKU1dURk1haW5UaHJlYWRDYWxsZXIKLQotLSAodm9pZCljYWxs Ci17Ci0gICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7Ci19Ci0KLUBl bmQKLQogI2RlZmluZSBMT0dfQ0hBTk5FTF9QUkVGSVggTG9nCiAKIG5hbWVzcGFjZSBXVEYgewpA QCAtNjYsOCArNTQsNiBAQCBXVEZMb2dDaGFubmVsIExvZ1RocmVhZGluZyA9IHsgV1RGTG9nQ2hh bm5lbFN0YXRlOjpPbiwgIlRocmVhZGluZyIsIFdURkxvZ0xldmVsOgogV1RGTG9nQ2hhbm5lbCBM b2dUaHJlYWRpbmcgPSB7IFdURkxvZ0NoYW5uZWxTdGF0ZTo6T24sICJUaHJlYWRpbmciLCBXVEZM b2dMZXZlbDo6RXJyb3IsIExPR19DSEFOTkVMX1dFQktJVF9TVUJTWVNURU0sIE9TX0xPR19ERUZB VUxUIH07CiAjZW5kaWYKIAotCi1zdGF0aWMgSlNXVEZNYWluVGhyZWFkQ2FsbGVyKiBzdGF0aWNN YWluVGhyZWFkQ2FsbGVyOwogc3RhdGljIGJvb2wgaXNUaW1lclBvc3RlZDsgLy8gVGhpcyBpcyBv bmx5IGFjY2Vzc2VkIG9uIHRoZSBtYWluIHRocmVhZC4KIAogI2lmIFVTRShXRUJfVEhSRUFEKQpA QCAtODQsOSArNzAsNiBAQCB2b2lkIGluaXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0oKQogICAg IGlmICghcHRocmVhZF9tYWluX25wKCkpCiAgICAgICAgIFJFTEVBU0VfTE9HX0ZBVUxUKFRocmVh ZGluZywgIldlYktpdCBUaHJlYWRpbmcgVmlvbGF0aW9uIC0gaW5pdGlhbCB1c2Ugb2YgV2ViS2l0 IGZyb20gYSBzZWNvbmRhcnkgdGhyZWFkLiIpOwogICAgIEFTU0VSVChwdGhyZWFkX21haW5fbnAo KSk7Ci0KLSAgICBBU1NFUlQoIXN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwotICAgIHN0YXRpY01h aW5UaHJlYWRDYWxsZXIgPSBbW0pTV1RGTWFpblRocmVhZENhbGxlciBhbGxvY10gaW5pdF07CiB9 CiAKIHN0YXRpYyB2b2lkIHRpbWVyRmlyZWQoQ0ZSdW5Mb29wVGltZXJSZWYgdGltZXIsIHZvaWQq KQpAQCAtMTEyLDggKzk1LDYgQEAgc3RhdGljIHZvaWQgcG9zdFRpbWVyKCkKIAogdm9pZCBzY2hl ZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKCkKIHsKLSAgICBBU1NFUlQoc3RhdGlj TWFpblRocmVhZENhbGxlcik7Ci0gICAgCiAjaWYgVVNFKFdFQl9USFJFQUQpCiAgICAgaWYgKGlz V2ViVGhyZWFkKCkpIHsKICAgICAgICAgcG9zdFRpbWVyKCk7CkBAIC0xMjEsNyArMTAyLDkgQEAg dm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKCkKICAgICB9CiAKICAg ICBpZiAobWFpblRocmVhZFB0aHJlYWQpIHsKLSAgICAgICAgW3N0YXRpY01haW5UaHJlYWRDYWxs ZXIgcGVyZm9ybVNlbGVjdG9yOkBzZWxlY3RvcihjYWxsKSBvblRocmVhZDptYWluVGhyZWFkTlNU aHJlYWQgd2l0aE9iamVjdDpuaWwgd2FpdFVudGlsRG9uZTpOT107CisgICAgICAgIFJ1bkxvb3A6 OndlYigpLmRpc3BhdGNoKFtdIHsKKyAgICAgICAgICAgIFdURjo6ZGlzcGF0Y2hGdW5jdGlvbnNG cm9tTWFpblRocmVhZCgpOworICAgICAgICB9KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KICNl bHNlCkBAIC0xMzEsNyArMTE0LDkgQEAgdm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25N YWluVGhyZWFkKCkKICAgICB9CiAjZW5kaWYKIAotICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVy IHBlcmZvcm1TZWxlY3Rvck9uTWFpblRocmVhZDpAc2VsZWN0b3IoY2FsbCkgd2l0aE9iamVjdDpu aWwgd2FpdFVudGlsRG9uZTpOT107CisgICAgUnVuTG9vcDo6bWFpbigpLmRpc3BhdGNoKFtdIHsK KyAgICAgICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7CisgICAgfSk7 CiB9CiAKIHZvaWQgZGlzcGF0Y2hBc3luY09uTWFpblRocmVhZFdpdGhXZWJUaHJlYWRMb2NrSWZO ZWVkZWQodm9pZCAoXmJsb2NrKSgpKQpAQCAtMTk2LDYgKzE4MSw3IEBAIHZvaWQgaW5pdGlhbGl6 ZVdlYlRocmVhZCgpCiAgICAgICAgIG1haW5UaHJlYWRQdGhyZWFkID0gcHRocmVhZF9zZWxmKCk7 CiAgICAgICAgIG1haW5UaHJlYWROU1RocmVhZCA9IFtOU1RocmVhZCBjdXJyZW50VGhyZWFkXTsK ICAgICAgICAgc1dlYlRocmVhZCA9ICZUaHJlYWQ6OmN1cnJlbnQoKTsKKyAgICAgICAgUnVuTG9v cDo6aW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKTsKICAgICB9KTsKIH0KIApkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGY0MDI1OTRlZDMzOWMxYmMzZWQ2 YzNhZDYzOTc3NDgwMDhkOWI1YTcuLjNiMmZmZTNhNWYzZTAwNDliOTdiNzFjOGEyOTgyMDU2ZjNk MDM0NTggMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxMiBAQAorMjAxOS0xMC0xNyAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGxl LmNvbT4KKworICAgICAgICBVc2luZyBDRlJ1bkxvb3BTb3VyY2UxIGZvciBmYXN0ZXIgdGFzayBk aXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjAyODc0CisKKyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAgICAgICAqIFRlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sOgorCiAyMDE5LTEwLTE2ICBLYXRl IENoZW5leSAgPGthdGhlcmluZV9jaGVuZXlAYXBwbGUuY29tPgogCiAgICAgICAgIFdLV2Vic2l0 ZURhdGFTdG9yZVN0YXRpc3RpY3NSZXNldFRvQ29uc2lzdGVudFN0YXRlKCkgc2hvdWxkIGNhbGwg c3RvcmUuc2V0VXNlSVRQRGF0YWJhc2UoZmFsc2UpCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sCmluZGV4IGNiMzJkODBlYjY4N2ViMzNh MWNiZmQyNzU1NmU0ZTczMGYxNmZmOTkuLjdlNDYxN2JmZTg5NjhiN2U5NzM4MWIyMjIzYjdhNjQw NTk1ODQwMTQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dl dFVzZXJNZWRpYS5odG1sCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L2dl dFVzZXJNZWRpYS5odG1sCkBAIC0yLDE0ICsyLDE1IEBACiA8aHRtbD4KICAgICA8aGVhZD4KICAg ICAgICAgPHNjcmlwdD4KLQotICAgICAgICAgICAgbGV0IHN0cmVhbSA9IG51bGw7CisgICAgICAg ICAgICBsZXQgc3RyZWFtUHJvbWlzZSA9IFByb21pc2UucmVzb2x2ZSgpOwogCiAgICAgICAgICAg ICBmdW5jdGlvbiBwcm9tcHRGb3JDYXB0dXJlKCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAg ICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmVudW1lcmF0ZURldmljZXMoKS50aGVuKCgpID0+ IHsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlID0gbmF2aWdhdG9yLm1lZGlhRGV2aWNl cy5lbnVtZXJhdGVEZXZpY2VzKCkudGhlbigoKSA9PiB7CiAgICAgICAgICAgICAgICAgICAgIHJl dHVybiBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7IGF1ZGlvOiBmYWxzZSwg dmlkZW86IHRydWUgfSkKLSAgICAgICAgICAgICAgICB9KS50aGVuKChzKSA9PiB7CisgICAgICAg ICAgICAgICAgfSk7CisKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVh bSkgPT4gewogICAgICAgICAgICAgICAgICAgICBzdHJlYW0gPSBzOwogICAgICAgICAgICAgICAg ICAgICB2aWRlby5zcmNPYmplY3QgPSBzdHJlYW07CiAgICAgICAgICAgICAgICAgICAgIGNvbnNv bGUubG9nKCJHb3QgdXNlciBtZWRpYSIpOwpAQCAtMTgsMjMgKzE5LDI5IEBACiAKICAgICAgICAg ICAgIGZ1bmN0aW9uIHN0b3Aoa2luZCkKICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBs ZXQgYWN0aXZlVHJhY2tzID0gW107Ci0gICAgICAgICAgICAgICAgc3RyZWFtLmdldFRyYWNrcygp LmZvckVhY2godHJhY2sgPT4gewotICAgICAgICAgICAgICAgICAgICBpZiAoIWtpbmQgfHwgdHJh Y2sua2luZCA9PSBraW5kKQotICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2suc3RvcCgpOwot ICAgICAgICAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgICAgICAgICBhY3RpdmVU cmFja3MucHVzaCh0cmFjayk7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChz dHJlYW0pID0+IHsKKyAgICAgICAgICAgICAgICAgICAgbGV0IGFjdGl2ZVRyYWNrcyA9IFtdOwor ICAgICAgICAgICAgICAgICAgICBzdHJlYW0uZ2V0VHJhY2tzKCkuZm9yRWFjaCh0cmFjayA9PiB7 CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWtpbmQgfHwgdHJhY2sua2luZCA9PSBraW5k KQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNrLnN0b3AoKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3RpdmVUcmFj a3MucHVzaCh0cmFjayk7CisgICAgICAgICAgICAgICAgICAgIH0pOworIAorICAgICAgICAgICAg ICAgICAgICBpZiAoIWFjdGl2ZVRyYWNrcy5sZW5ndGgpIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgIHN0cmVhbVByb21pc2VEaWRSZXNvbHZlID0gZmFsc2U7CisgICAgICAgICAgICAgICAgICAg ICAgICB2aWRlby5zcmNPYmplY3QgPSBudWxsOworICAgICAgICAgICAgICAgICAgICB9CiAgICAg ICAgICAgICAgICAgfSk7Ci0KLSAgICAgICAgICAgICAgICBpZiAoIWFjdGl2ZVRyYWNrcy5sZW5n dGgpIHsKLSAgICAgICAgICAgICAgICAgICAgc3RyZWFtID0gbnVsbDsKLSAgICAgICAgICAgICAg ICAgICAgdmlkZW8uc3JjT2JqZWN0ID0gbnVsbDsKLSAgICAgICAgICAgICAgICB9CiAgICAgICAg ICAgICB9CiAKKyAgICAgICAgICAgIGxldCBzdHJlYW1Qcm9taXNlRGlkUmVzb2x2ZSA9IGZhbHNl OworCiAgICAgICAgICAgICBmdW5jdGlvbiBoYXZlU3RyZWFtKCkKICAgICAgICAgICAgIHsKLSAg ICAgICAgICAgICAgICByZXR1cm4gc3RyZWFtICE9PSBudWxsOworICAgICAgICAgICAgICAgIC8v IE91ciBjYWxsZXIgcG9sbHMgcmVwZWF0ZWRseSB1bnRpbCBvdXIgcHJvbWlzZSByZXNvbHZlcy4K KyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlLnRoZW4oKHN0cmVhbSkgPT4gc3RyZWFtUHJv bWlzZURpZFJlc29sdmUgPSAhIXN0cmVhbSk7CisgICAgICAgICAgICAgICAgcmV0dXJuIHN0cmVh bVByb21pc2VEaWRSZXNvbHZlOwogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBmdW5jdGlv biBkb011bHRpcGxlR2V0VXNlck1lZGlhU3luY2hyb25vdXNseSgpCkBAIC01MywxMiArNjAsMTIg QEAKIAogICAgICAgICAgICAgZnVuY3Rpb24gY2FwdHVyZUF1ZGlvKCkKICAgICAgICAgICAgIHsK LSAgICAgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVk aW86IHRydWV9KS50aGVuKHMgPT4gc3RyZWFtID0gcyk7CisgICAgICAgICAgICAgICAgc3RyZWFt UHJvbWlzZSA9IG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzogdHJ1 ZX0pOwogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBmdW5jdGlvbiBjYXB0dXJlQXVkaW9B bmRWaWRlbygpCiAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgbmF2aWdhdG9yLm1lZGlh RGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlLCB2aWRlbzogdHJ1ZX0pLnRoZW4ocyA9 PiBzdHJlYW0gPSBzKTsKKyAgICAgICAgICAgICAgICBzdHJlYW1Qcm9taXNlID0gbmF2aWdhdG9y Lm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOiB0cnVlLCB2aWRlbzogdHJ1ZX0pOwog ICAgICAgICAgICAgfQogICAgICAgICA8L3NjcmlwdD4KICAgICA8aGVhZD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjZDll MWM4Y2E1MjgyOTRiODIyOTM2Mjc0Yzg3OWM4OGRjYTQ5MzBlLi42OWQyYmE1NDE3Zjc5YTBlZGFi M2Q3MTg2NTAzNmIzZGY3YTQzZTU3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cK KysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMTktMTAtMTcg IFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5M b29wU291cmNlMSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeCBhIGZsYWt5IHRlc3QuCisKKyAgICAgICAg KiBpbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi1leHBlY3RlZC50eHQ6CisgICAgICAgICog aW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbDoKKworMjAxOS0xMC0xNiAgU2lodWkg TGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBVc2luZyBDRlJ1bkxvb3BTb3Vy Y2UxIGZvciBmYXN0ZXIgdGFzayBkaXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAgICAgICAqIGluc3Bl Y3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBpbnNwZWN0 b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sOgorCiAyMDE5LTEwLTE2ICBSdXNzZWxsIEVwc3Rl aW4gIDxyZXBzdGVpbkBhcHBsZS5jb20+CiAKICAgICAgICAgQ29ycmVjdCBUZXN0RXhwZWN0YXRp b25zIGZyb20gcjI1MTExOS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2luc3BlY3Rvci9jc3Mv cHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9jc3Mv cHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCA1YjgzMjMzNDlhMTI4YmE2NjNiZGM4 NzhiNGE2MmVkNjQyM2Q4MTcyLi40OWI3ZmZhNzRmZDAyMWRlYmU4YzcwZTc3MWY2YmVmYjhiZGUy ZGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlv bi1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3Jl YXRpb24tZXhwZWN0ZWQudHh0CkBAIC0xMiwxMSArMTIsMTEgQEAgUEFTUzogVGhlcmUgc2hvdWxk IGJlIDAgbm9kZSB3aXRoIHRoZSBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGhvdXQtY29udGVudCIu CiAKIENhbGxpbmcgImNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29u dGVudCIpIi4uLgogQ2hlY2tpbmcgZm9yIG5vZGVzIHdpdGggY2xhc3MgIi50ZXN0LXBzZXVkby13 aXRoLWNvbnRlbnQiLi4uCi1QQVNTOiBDcmVhdGVkIDo6YmVmb3JlIHBzZXVkbyBlbGVtZW50CiBQ QVNTOiBUaGVyZSBzaG91bGQgYmUgMSBub2RlIHdpdGggdGhlIGNsYXNzICIudGVzdC1wc2V1ZG8t d2l0aC1jb250ZW50Ii4KK1BBU1M6IENyZWF0ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQKIAog Q2FsbGluZyAicmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250ZW50 IikiLi4uCiBDaGVja2luZyBmb3Igbm9kZXMgd2l0aCBjbGFzcyAiLnRlc3QtcHNldWRvLXdpdGgt Y29udGVudCIuLi4KLVBBU1M6IFJlbW92ZWQgOjpiZWZvcmUgcHNldWRvIGVsZW1lbnQKIFBBU1M6 IFRoZXJlIHNob3VsZCBiZSAwIG5vZGUgd2l0aCB0aGUgY2xhc3MgIi50ZXN0LXBzZXVkby13aXRo LWNvbnRlbnQiLgorUEFTUzogUmVtb3ZlZCA6OmJlZm9yZSBwc2V1ZG8gZWxlbWVudAogCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sIGIv TGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbAppbmRleCBhMDFj ZTBkMzY0NWQzOGY0N2U1MjY3ZWFjOWQ4ZTBmNDg2ZDFhNjQ2Li44NGY1MDUwMGJkMzc0NmNhM2Jk Njg4ZDkwMGE0NzQ3MTI4MmM0OGQ5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbnNwZWN0b3Iv Y3NzL3BzZXVkby1jcmVhdGlvbi5odG1sCisrKyBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9jc3Mv cHNldWRvLWNyZWF0aW9uLmh0bWwKQEAgLTI2LDcgKzI2LDggQEAgZnVuY3Rpb24gcmVtb3ZlRWxl bWVudFdpdGhDbGFzcyhjbGFzc05hbWUpIHsKIAogZnVuY3Rpb24gdGVzdCgpIHsKICAgICBsZXQg ZG9jdW1lbnROb2RlID0gbnVsbDsKLSAgICBsZXQgcHNldWRvRWxlbWVudCA9IG51bGw7CisgICAg bGV0IHBzZXVkb0VsZW1lbnRBZGRlZCA9IG51bGw7CisgICAgbGV0IHBzZXVkb0VsZW1lbnRSZW1v dmVkID0gbnVsbDsKIAogICAgIGZ1bmN0aW9uIGhhbmRsZVByb21pc2VSZWplY3QoZXJyb3IpIHsK ICAgICAgICAgY29uc29sZS5sb2coZXJyb3IpOwpAQCAtNTYsMjcgKzU3LDM3IEBAIGZ1bmN0aW9u IHRlc3QoKSB7CiAgICAgICAgIC5jYXRjaChoYW5kbGVQcm9taXNlUmVqZWN0KTsKICAgICB9CiAK LSAgICBmdW5jdGlvbiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSkgeworICAgIGZ1 bmN0aW9uIGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoY2xhc3NOYW1lLCBzaG91bGRDaGVja0VsZW1l bnQpIHsKICAgICAgICAgcmV0dXJuIGV2YWx1YXRlV2l0aExvZyhgY3JlYXRlRWxlbWVudFdpdGhD bGFzcygiJHtjbGFzc05hbWV9IilgKQogICAgICAgICAudGhlbigoKSA9PiBjaGVja0VsZW1lbnRz V2l0aENsYXNzKGNsYXNzTmFtZSwgMSkpCisgICAgICAgIC50aGVuKCgpID0+IHsKKyAgICAgICAg ICAgIGlmIChzaG91bGRDaGVja0VsZW1lbnQpIHsKKyAgICAgICAgICAgICAgICBpZiAocHNldWRv RWxlbWVudEFkZGVkKQorICAgICAgICAgICAgICAgICAgICBQcm90b2NvbFRlc3QucGFzcyhgQ3Jl YXRlZCA6OiR7cHNldWRvRWxlbWVudEFkZGVkLnBzZXVkb1R5cGV9IHBzZXVkbyBlbGVtZW50YCk7 CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcHNldWRv RWxlbWVudEFkZGVkUHJvbWlzZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LnBhc3MoYENyZWF0 ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOyB9 KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVByb21p c2VSZWplY3QpOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIHJlbW92ZUVsZW1lbnRXaXRoQ2xhc3Mo Y2xhc3NOYW1lKSB7CisgICAgZnVuY3Rpb24gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcyhjbGFzc05h bWUsIHNob3VsZENoZWNrRWxlbWVudCkgewogICAgICAgICByZXR1cm4gZXZhbHVhdGVXaXRoTG9n KGByZW1vdmVFbGVtZW50V2l0aENsYXNzKCIke2NsYXNzTmFtZX0iKWApCiAgICAgICAgIC50aGVu KCgpID0+IGNoZWNrRWxlbWVudHNXaXRoQ2xhc3MoY2xhc3NOYW1lLCAwKSkKKyAgICAgICAgLnRo ZW4oKCkgPT4geworICAgICAgICAgICAgaWYgKHNob3VsZENoZWNrRWxlbWVudCkgeworICAgICAg ICAgICAgICAgIGlmIChwc2V1ZG9FbGVtZW50UmVtb3ZlZCkKKyAgICAgICAgICAgICAgICAgICAg UHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRSZW1vdmVkLnBzZXVkb0VsZW1l bnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJZCwgYFJlbW92ZWQgOjoke3BzZXVkb0VsZW1l bnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOworICAgICAgICAgICAgICAgIGVs c2UKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBzZXVkb0VsZW1lbnRSZW1vdmVkUHJvbWlz ZS50aGVuKCgpID0+IHsgUHJvdG9jb2xUZXN0LmV4cGVjdEVxdWFsKHBzZXVkb0VsZW1lbnRSZW1v dmVkLnBzZXVkb0VsZW1lbnRJZCwgcHNldWRvRWxlbWVudEFkZGVkLm5vZGVJZCwgYFJlbW92ZWQg Ojoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBlfSBwc2V1ZG8gZWxlbWVudGApOyB9KTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfSkKICAgICAgICAgLmNhdGNoKGhhbmRsZVByb21pc2VS ZWplY3QpOwogICAgIH0KIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50SGFuZGxlclsiRE9N LnBzZXVkb0VsZW1lbnRBZGRlZCJdID0gKHJlc3BvbnNlKSA9PiB7Ci0gICAgICAgIHBzZXVkb0Vs ZW1lbnQgPSByZXNwb25zZS5wYXJhbXMucHNldWRvRWxlbWVudDsKLQotICAgICAgICBQcm90b2Nv bFRlc3QucGFzcyhgQ3JlYXRlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9UeXBlfSBwc2V1ZG8g ZWxlbWVudGApOwotICAgIH07CisgICAgbGV0IHBzZXVkb0VsZW1lbnRBZGRlZFByb21pc2UgPSBJ bnNwZWN0b3JQcm90b2NvbC5hd2FpdEV2ZW50KHtldmVudDogIkRPTS5wc2V1ZG9FbGVtZW50QWRk ZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudEFkZGVkID0gZXZlbnQucGFyYW1z LnBzZXVkb0VsZW1lbnR9KTsKKyAgICBsZXQgcHNldWRvRWxlbWVudFJlbW92ZWRQcm9taXNlID0g SW5zcGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6ICJET00ucHNldWRvRWxlbWVudFJl bW92ZWQifSkudGhlbigoZXZlbnQpID0+IHsgcHNldWRvRWxlbWVudFJlbW92ZWQgPSBldmVudC5w YXJhbXN9KTsKIAotICAgIEluc3BlY3RvclByb3RvY29sLmV2ZW50SGFuZGxlclsiRE9NLnBzZXVk b0VsZW1lbnRSZW1vdmVkIl0gPSAocmVzcG9uc2UpID0+IHsKLSAgICAgICAgUHJvdG9jb2xUZXN0 LmV4cGVjdEVxdWFsKHJlc3BvbnNlLnBhcmFtcy5wc2V1ZG9FbGVtZW50SWQsIHBzZXVkb0VsZW1l bnQubm9kZUlkLCBgUmVtb3ZlZCA6OiR7cHNldWRvRWxlbWVudC5wc2V1ZG9UeXBlfSBwc2V1ZG8g ZWxlbWVudGApOwotICAgIH07CiAKICAgICBQcm90b2NvbFRlc3QubG9nKCJSZXF1ZXN0aW5nIGRv Y3VtZW50Li4uIik7CiAgICAgSW5zcGVjdG9yUHJvdG9jb2wuc2VuZENvbW1hbmQoIkRPTS5nZXRE b2N1bWVudCIsIHt9LCAocmVzcG9uc2UpID0+IHsKQEAgLTg1LDEwICs5NiwxMCBAQCBmdW5jdGlv biB0ZXN0KCkgewogICAgICAgICBkb2N1bWVudE5vZGUgPSByZXNwb25zZS5yZXN1bHQucm9vdDsK IAogICAgICAgICBQcm9taXNlLnJlc29sdmUoKQotICAgICAgICAudGhlbigoKSA9PiBjcmVhdGVF bGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSkKLSAgICAgICAg LnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1j b250ZW50IikpCi0gICAgICAgIC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRl c3QtcHNldWRvLXdpdGgtY29udGVudCIpKQotICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVt ZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSkKKyAgICAgICAgLnRoZW4o KCkgPT4gY3JlYXRlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1jb250ZW50 IiksIGZhbHNlKQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNzKCJ0 ZXN0LXBzZXVkby13aXRob3V0LWNvbnRlbnQiKSwgZmFsc2UpCisgICAgICAgIC50aGVuKCgpID0+ IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNldWRvLXdpdGgtY29udGVudCIsIHRydWUp KQorICAgICAgICAudGhlbigoKSA9PiByZW1vdmVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVk by13aXRoLWNvbnRlbnQiLCB0cnVlKSkKICAgICAgICAgLnRoZW4oKCkgPT4gUHJvdG9jb2xUZXN0 LmNvbXBsZXRlVGVzdCgpKQogICAgICAgICAuY2F0Y2goaGFuZGxlUHJvbWlzZVJlamVjdCk7CiAg ICAgfSk7Cg== 381217 2019-10-17 12:58:29 -0700 2020-02-17 09:59:51 -0800 Patch for landing bug-202874-20191017125828.patch text/plain 17810 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxMjUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDc1NTVkNGVhN2QxOGE4YTliNGEwOGM4 NDIzOWExZGM3NzFmYWQ2OTQuLjBlNDQ1MjJlMDc4OTk1MjU1MmFiOTJkZDg4Nzg1NjVlNzQzYWFk ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTktMTAtMTcgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgdmVyc2lvbiAxIENGUnVubG9vcFNvdXJjZSBm b3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IEdlb2ZmcmV5IEdh cmVuLgorCisgICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9v cCB0byBwcm9jZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBhY2NvcmRpbmcgdG8g cHJvZmlsaW5nLiBUbyAKKyAgICAgICAgYXZvaWQgY2FsbGluZyBDRlJ1bkxvb3BXYWtlVXAsIHdl IHNob3VsZCB1c2UgdmVyc2lvbiAxIENGUnVubG9vcFNvdXJjZSBpbnN0ZWFkIG9mIHZlcnNpb24g MC4gVGhpcyBwYXRjaCBicmluZ3MKKyAgICAgICAgYWJvdXQgMTUlIHNwZWVkdXAgZm9yIHRlc3Qg UGVyZm9ybWFuY2VUZXN0cy9JbmRleGVkREIvYmFzaWMvb2JqZWN0c3RvcmUtZ2V0Lmh0bWwuCisK KyAgICAgICAgKiB3dGYvUnVuTG9vcC5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OmluaXRp YWxpemVXZWJSdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6d2ViKToKKyAgICAgICAg KiB3dGYvUnVuTG9vcC5oOgorICAgICAgICAqIHd0Zi9jZi9SdW5Mb29wQ0YuY3BwOgorICAgICAg ICAoV1RGOjpSdW5Mb29wOjpwZXJmb3JtV29yayk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1 bkxvb3ApOgorICAgICAgICAoV1RGOjpSdW5Mb29wOjp+UnVuTG9vcCk6CisgICAgICAgIChXVEY6 OlJ1bkxvb3A6Ondha2VVcCk6CisgICAgICAgICogd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5t bToKKyAgICAgICAgKFdURjo6aW5pdGlhbGl6ZU1haW5UaHJlYWRQbGF0Zm9ybSk6CisgICAgICAg IChXVEY6OnNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQpOgorICAgICAgICAo V1RGOjppbml0aWFsaXplV2ViVGhyZWFkKToKKyAgICAgICAgKC1bSlNXVEZNYWluVGhyZWFkQ2Fs bGVyIGNhbGxdKTogRGVsZXRlZC4KKwogMjAxOS0xMC0xNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29u X2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBmaXggdGhlIGludGVybmFs IG1hY09TIDEwLjEzIGFuZCAxMC4xNCBidWlsZHMgYWZ0ZXIgcjI1MTE3MQpkaWZmIC0tZ2l0IGEv U291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApp bmRleCAxYmUyMmQ4MDlmM2RlNjk1NTk5NjY1ZDIxMzBjOWRkY2YxYjAwZTcwLi45MzhiOWU5OWQ1 ZTQxNDg4MmNjOWUwMzEwN2JmNGY2NjNmYzIyNGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApAQCAtMzMsNiAr MzMsOSBAQAogbmFtZXNwYWNlIFdURiB7CiAKIHN0YXRpYyBSdW5Mb29wKiBzX21haW5SdW5Mb29w OworI2lmIFVTRShXRUJfVEhSRUFEKQorc3RhdGljIFJ1bkxvb3AqIHNfd2ViUnVuTG9vcDsKKyNl bmRpZgogCiAvLyBIZWxwZXIgY2xhc3MgZm9yIFRocmVhZFNwZWNpZmljRGF0YS4KIGNsYXNzIFJ1 bkxvb3A6OkhvbGRlciB7CkBAIC02OSw2ICs3MiwxOSBAQCBSdW5Mb29wJiBSdW5Mb29wOjptYWlu KCkKICAgICByZXR1cm4gKnNfbWFpblJ1bkxvb3A7CiB9CiAKKyNpZiBVU0UoV0VCX1RIUkVBRCkK K3ZvaWQgUnVuTG9vcDo6aW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKQoreworICAgIHNfd2ViUnVuTG9v cCA9ICZSdW5Mb29wOjpjdXJyZW50KCk7Cit9CisKK1J1bkxvb3AmIFJ1bkxvb3A6OndlYigpCit7 CisgICAgQVNTRVJUKHNfd2ViUnVuTG9vcCk7CisgICAgcmV0dXJuICpzX3dlYlJ1bkxvb3A7Cit9 CisjZW5kaWYKKwogYm9vbCBSdW5Mb29wOjppc01haW4oKQogewogICAgIEFTU0VSVChzX21haW5S dW5Mb29wKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaCBiL1NvdXJjZS9X VEYvd3RmL1J1bkxvb3AuaAppbmRleCA5ZGU4ODU5YmEyNjdlMmM0YTNlNzU0ZmNjOGQyOGExOWE4 ZDBhOGY2Li5hODUxMThkN2MzNTc1ZDNjMDgxZGQxZmZmOTVhYzU3Y2I0ZjAwNDU4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgKKysrIGIvU291cmNlL1dURi93dGYvUnVuTG9v cC5oCkBAIC00OSw5ICs0OSwxNSBAQCBwdWJsaWM6CiAgICAgLy8gTXVzdCBiZSBjYWxsZWQgZnJv bSB0aGUgbWFpbiB0aHJlYWQgKGV4Y2VwdCBmb3IgdGhlIE1hYyBwbGF0Zm9ybSwgd2hlcmUgaXQK ICAgICAvLyBjYW4gYmUgY2FsbGVkIGZyb20gYW55IHRocmVhZCkuCiAgICAgV1RGX0VYUE9SVF9Q UklWQVRFIHN0YXRpYyB2b2lkIGluaXRpYWxpemVNYWluUnVuTG9vcCgpOworI2lmIFVTRShXRUJf VEhSRUFEKQorICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBpbml0aWFsaXplV2Vi UnVuTG9vcCgpOworI2VuZGlmCiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxv b3AmIGN1cnJlbnQoKTsKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIG1h aW4oKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGlj IFJ1bkxvb3AmIHdlYigpOworI2VuZGlmCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBi b29sIGlzTWFpbigpOwogICAgIH5SdW5Mb29wKCk7CiAKQEAgLTE3OCw5ICsxODQsMTAgQEAgcHJp dmF0ZToKIAogICAgIExvY2sgbV9sb29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09Q KQotICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBw ZXJmb3JtV29yayhDRk1hY2hQb3J0UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCog aW5mbyk7CiAgICAgUmV0YWluUHRyPENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFp blB0cjxDRlJ1bkxvb3BTb3VyY2VSZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8 Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBH UmVmUHRyPEdNYWluQ29udGV4dD4gbV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxH TWFpbkxvb3A+PiBtX21haW5Mb29wczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1 bkxvb3BDRi5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IDI3ZDNm ZTJjOWNiNDI4N2JhNzg1MzU4NGY0ODM5ZWIzN2VmOTA3YTIuLmIyZTJlNWI3NDE3NzRkOTBjM2Zl YmZiNzk3ZmEwNTA5YTNlNzFmOWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxv b3BDRi5jcHAKKysrIGIvU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYg KzI4LDI5IEBACiAKICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgog I2luY2x1ZGUgPGRpc3BhdGNoL2Rpc3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAj aW5jbHVkZSA8d3RmL0F1dG9kcmFpbmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9p ZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJm b3JtV29yayhDRk1hY2hQb3J0UmVmLCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAg ICBBdXRvZHJhaW5lZFBvb2wgcG9vbDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4 dCktPnBlcmZvcm1Xb3JrKCk7CisgICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJm b3JtV29yaygpOwogfQogCiBSdW5Mb29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1 bkxvb3BHZXRDdXJyZW50KCkpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0 ID0geyAwLCB0aGlzLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1f cnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRv ckRlZmF1bHQsIDAsICZjb250ZXh0KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9 IHsgMCwgdGhpcywgbnVsbHB0ciwgbnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFk b3B0Q0YoQ0ZNYWNoUG9ydENyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywg JmNvbnRleHQsIG51bGxwdHIpKTsKKyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFj aFBvcnRDcmVhdGVSdW5Mb29wU291cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQo KSwgMCkpOwogICAgIENGUnVuTG9vcEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9v cFNvdXJjZS5nZXQoKSwga0NGUnVuTG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1 bkxvb3AoKQogeworICAgIENGTWFjaFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAg Q0ZSdW5Mb29wU291cmNlSW52YWxpZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBA IC01OCw4ICs2MSwxNiBAQCB2b2lkIFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVy YXRpb24pCiAKIHZvaWQgUnVuTG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VT aWduYWwobV9ydW5Mb29wU291cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5M b29wLmdldCgpKTsKKyAgICBtYWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1z Z2hfYml0cyA9IE1BQ0hfTVNHSF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAg ICBoZWFkZXIubXNnaF9zaXplID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFk ZXIubXNnaF9yZW1vdGVfcG9ydCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7Cisg ICAgaGVhZGVyLm1zZ2hfbG9jYWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5t c2doX2lkID0gMDsKKyAgICBtYWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVh ZGVyLCBNQUNIX1NFTkRfTVNHIHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUs IDAsIE1BQ0hfUE9SVF9OVUxMLCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NF UlQocmVzdWx0ID09IE1BQ0hfTVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1F RF9PVVQpOworICAgIGlmIChyZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAg bWFjaF9tc2dfZGVzdHJveSgmaGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVu TG9vcDo6Y3ljbGUoY29uc3QgU3RyaW5nJiBtb2RlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93 dGYvY29jb2EvTWFpblRocmVhZENvY29hLm1tIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRo cmVhZENvY29hLm1tCmluZGV4IDI3ZWIwMGRiYTEwOWJhMWZhNTAwZDU3Y2JiNWYzMTQ1YjdlMjEy NDkuLjI3MGI3YjA5Yjk2NjBhNGZkZjEwNDRmZWJjOTQwOTI3NmIwNGM4N2QgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbQorKysgYi9Tb3VyY2UvV1RG L3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW0KQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBvcnQg PHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW1wb3J0IDx3dGYvSGFzaFNldC5oPgogI2ltcG9ydCA8d3Rm L1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL1J1bkxvb3AuaD4KICNpbXBvcnQgPHd0Zi9TY2hl ZHVsZVBhaXIuaD4KICNpbXBvcnQgPHd0Zi9UaHJlYWRpbmcuaD4KIApAQCAtNDMsMTkgKzQ0LDYg QEAKICNpbmNsdWRlIDx3dGYvaW9zL1dlYkNvcmVUaHJlYWQuaD4KICNlbmRpZgogCi1AaW50ZXJm YWNlIEpTV1RGTWFpblRocmVhZENhbGxlciA6IE5TT2JqZWN0Ci0tICh2b2lkKWNhbGw7Ci1AZW5k Ci0KLUBpbXBsZW1lbnRhdGlvbiBKU1dURk1haW5UaHJlYWRDYWxsZXIKLQotLSAodm9pZCljYWxs Ci17Ci0gICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7Ci19Ci0KLUBl bmQKLQogI2RlZmluZSBMT0dfQ0hBTk5FTF9QUkVGSVggTG9nCiAKIG5hbWVzcGFjZSBXVEYgewpA QCAtNjYsOCArNTQsNiBAQCBXVEZMb2dDaGFubmVsIExvZ1RocmVhZGluZyA9IHsgV1RGTG9nQ2hh bm5lbFN0YXRlOjpPbiwgIlRocmVhZGluZyIsIFdURkxvZ0xldmVsOgogV1RGTG9nQ2hhbm5lbCBM b2dUaHJlYWRpbmcgPSB7IFdURkxvZ0NoYW5uZWxTdGF0ZTo6T24sICJUaHJlYWRpbmciLCBXVEZM b2dMZXZlbDo6RXJyb3IsIExPR19DSEFOTkVMX1dFQktJVF9TVUJTWVNURU0sIE9TX0xPR19ERUZB VUxUIH07CiAjZW5kaWYKIAotCi1zdGF0aWMgSlNXVEZNYWluVGhyZWFkQ2FsbGVyKiBzdGF0aWNN YWluVGhyZWFkQ2FsbGVyOwogc3RhdGljIGJvb2wgaXNUaW1lclBvc3RlZDsgLy8gVGhpcyBpcyBv bmx5IGFjY2Vzc2VkIG9uIHRoZSBtYWluIHRocmVhZC4KIAogI2lmIFVTRShXRUJfVEhSRUFEKQpA QCAtODQsOSArNzAsNiBAQCB2b2lkIGluaXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0oKQogICAg IGlmICghcHRocmVhZF9tYWluX25wKCkpCiAgICAgICAgIFJFTEVBU0VfTE9HX0ZBVUxUKFRocmVh ZGluZywgIldlYktpdCBUaHJlYWRpbmcgVmlvbGF0aW9uIC0gaW5pdGlhbCB1c2Ugb2YgV2ViS2l0 IGZyb20gYSBzZWNvbmRhcnkgdGhyZWFkLiIpOwogICAgIEFTU0VSVChwdGhyZWFkX21haW5fbnAo KSk7Ci0KLSAgICBBU1NFUlQoIXN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwotICAgIHN0YXRpY01h aW5UaHJlYWRDYWxsZXIgPSBbW0pTV1RGTWFpblRocmVhZENhbGxlciBhbGxvY10gaW5pdF07CiB9 CiAKIHN0YXRpYyB2b2lkIHRpbWVyRmlyZWQoQ0ZSdW5Mb29wVGltZXJSZWYgdGltZXIsIHZvaWQq KQpAQCAtMTEyLDggKzk1LDYgQEAgc3RhdGljIHZvaWQgcG9zdFRpbWVyKCkKIAogdm9pZCBzY2hl ZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKCkKIHsKLSAgICBBU1NFUlQoc3RhdGlj TWFpblRocmVhZENhbGxlcik7Ci0gICAgCiAjaWYgVVNFKFdFQl9USFJFQUQpCiAgICAgaWYgKGlz V2ViVGhyZWFkKCkpIHsKICAgICAgICAgcG9zdFRpbWVyKCk7CkBAIC0xMjEsNyArMTAyLDkgQEAg dm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKCkKICAgICB9CiAKICAg ICBpZiAobWFpblRocmVhZFB0aHJlYWQpIHsKLSAgICAgICAgW3N0YXRpY01haW5UaHJlYWRDYWxs ZXIgcGVyZm9ybVNlbGVjdG9yOkBzZWxlY3RvcihjYWxsKSBvblRocmVhZDptYWluVGhyZWFkTlNU aHJlYWQgd2l0aE9iamVjdDpuaWwgd2FpdFVudGlsRG9uZTpOT107CisgICAgICAgIFJ1bkxvb3A6 OndlYigpLmRpc3BhdGNoKFtdIHsKKyAgICAgICAgICAgIFdURjo6ZGlzcGF0Y2hGdW5jdGlvbnNG cm9tTWFpblRocmVhZCgpOworICAgICAgICB9KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KICNl bHNlCkBAIC0xMzEsNyArMTE0LDkgQEAgdm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25N YWluVGhyZWFkKCkKICAgICB9CiAjZW5kaWYKIAotICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVy IHBlcmZvcm1TZWxlY3Rvck9uTWFpblRocmVhZDpAc2VsZWN0b3IoY2FsbCkgd2l0aE9iamVjdDpu aWwgd2FpdFVudGlsRG9uZTpOT107CisgICAgUnVuTG9vcDo6bWFpbigpLmRpc3BhdGNoKFtdIHsK KyAgICAgICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7CisgICAgfSk7 CiB9CiAKIHZvaWQgZGlzcGF0Y2hBc3luY09uTWFpblRocmVhZFdpdGhXZWJUaHJlYWRMb2NrSWZO ZWVkZWQodm9pZCAoXmJsb2NrKSgpKQpAQCAtMTk2LDYgKzE4MSw3IEBAIHZvaWQgaW5pdGlhbGl6 ZVdlYlRocmVhZCgpCiAgICAgICAgIG1haW5UaHJlYWRQdGhyZWFkID0gcHRocmVhZF9zZWxmKCk7 CiAgICAgICAgIG1haW5UaHJlYWROU1RocmVhZCA9IFtOU1RocmVhZCBjdXJyZW50VGhyZWFkXTsK ICAgICAgICAgc1dlYlRocmVhZCA9ICZUaHJlYWQ6OmN1cnJlbnQoKTsKKyAgICAgICAgUnVuTG9v cDo6aW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKTsKICAgICB9KTsKIH0KIApkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDYwMmViZmNmOGQyNDI3NDI1ZGVl ZTYxNjFiNDdmMTQ2MDMzMTRhOTEuLmQ2M2Y0NmJlZDliYWY0YzBkYTBlYmM1OTJlOWI3ZjRlY2Uw MTY3OGYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNCBAQAorMjAxOS0xMC0xNyAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGxl LmNvbT4KKworICAgICAgICBVc2luZyB2ZXJzaW9uIDEgQ0ZSdW5sb29wU291cmNlIGZvciBmYXN0 ZXIgdGFzayBkaXNwYXRjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjAyODc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgR2VvZmZyZXkgR2FyZW4uCisK KyAgICAgICAgRml4IGEgZmxha3kgdGVzdC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0L2dldFVzZXJNZWRpYS5odG1sOgorCiAyMDE5LTEwLTE3ICBFbWlsaW8gQ29ib3Mg w4FsdmFyZXogIDxlbWlsaW9AY3Jpc2FsLmlvPgogCiAgICAgICAgIFtHVEtdIEV4cGxpY2l0bHkg dXNlIFB5dGhvbiAyIGluIGpoYnVpbGQtd3JhcHBlcgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQvZ2V0VXNlck1lZGlhLmh0bWwgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdC9nZXRVc2VyTWVkaWEuaHRtbAppbmRleCBjYjMyZDgwZWI2ODdlYjMz YTFjYmZkMjc1NTZlNGU3MzBmMTZmZjk5Li43ZTQ2MTdiZmU4OTY4YjdlOTczODFiMjIyM2I3YTY0 MDU5NTg0MDE0IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdC9n ZXRVc2VyTWVkaWEuaHRtbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdC9n ZXRVc2VyTWVkaWEuaHRtbApAQCAtMiwxNCArMiwxNSBAQAogPGh0bWw+CiAgICAgPGhlYWQ+CiAg ICAgICAgIDxzY3JpcHQ+Ci0KLSAgICAgICAgICAgIGxldCBzdHJlYW0gPSBudWxsOworICAgICAg ICAgICAgbGV0IHN0cmVhbVByb21pc2UgPSBQcm9taXNlLnJlc29sdmUoKTsKIAogICAgICAgICAg ICAgZnVuY3Rpb24gcHJvbXB0Rm9yQ2FwdHVyZSgpCiAgICAgICAgICAgICB7Ci0gICAgICAgICAg ICAgICAgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5lbnVtZXJhdGVEZXZpY2VzKCkudGhlbigoKSA9 PiB7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZSA9IG5hdmlnYXRvci5tZWRpYURldmlj ZXMuZW51bWVyYXRlRGV2aWNlcygpLnRoZW4oKCkgPT4gewogICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoeyBhdWRpbzogZmFsc2Us IHZpZGVvOiB0cnVlIH0pCi0gICAgICAgICAgICAgICAgfSkudGhlbigocykgPT4geworICAgICAg ICAgICAgICAgIH0pOworCisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChzdHJl YW0pID0+IHsKICAgICAgICAgICAgICAgICAgICAgc3RyZWFtID0gczsKICAgICAgICAgICAgICAg ICAgICAgdmlkZW8uc3JjT2JqZWN0ID0gc3RyZWFtOwogICAgICAgICAgICAgICAgICAgICBjb25z b2xlLmxvZygiR290IHVzZXIgbWVkaWEiKTsKQEAgLTE4LDIzICsxOSwyOSBAQAogCiAgICAgICAg ICAgICBmdW5jdGlvbiBzdG9wKGtpbmQpCiAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAg bGV0IGFjdGl2ZVRyYWNrcyA9IFtdOwotICAgICAgICAgICAgICAgIHN0cmVhbS5nZXRUcmFja3Mo KS5mb3JFYWNoKHRyYWNrID0+IHsKLSAgICAgICAgICAgICAgICAgICAgaWYgKCFraW5kIHx8IHRy YWNrLmtpbmQgPT0ga2luZCkKLSAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNrLnN0b3AoKTsK LSAgICAgICAgICAgICAgICAgICAgZWxzZQotICAgICAgICAgICAgICAgICAgICAgICAgYWN0aXZl VHJhY2tzLnB1c2godHJhY2spOworICAgICAgICAgICAgICAgIHN0cmVhbVByb21pc2UudGhlbigo c3RyZWFtKSA9PiB7CisgICAgICAgICAgICAgICAgICAgIGxldCBhY3RpdmVUcmFja3MgPSBbXTsK KyAgICAgICAgICAgICAgICAgICAgc3RyZWFtLmdldFRyYWNrcygpLmZvckVhY2godHJhY2sgPT4g eworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKCFraW5kIHx8IHRyYWNrLmtpbmQgPT0ga2lu ZCkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB0cmFjay5zdG9wKCk7CisgICAgICAgICAg ICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0aXZlVHJh Y2tzLnB1c2godHJhY2spOworICAgICAgICAgICAgICAgICAgICB9KTsKKyAKKyAgICAgICAgICAg ICAgICAgICAgaWYgKCFhY3RpdmVUcmFja3MubGVuZ3RoKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICBzdHJlYW1Qcm9taXNlRGlkUmVzb2x2ZSA9IGZhbHNlOworICAgICAgICAgICAgICAgICAg ICAgICAgdmlkZW8uc3JjT2JqZWN0ID0gbnVsbDsKKyAgICAgICAgICAgICAgICAgICAgfQogICAg ICAgICAgICAgICAgIH0pOwotCi0gICAgICAgICAgICAgICAgaWYgKCFhY3RpdmVUcmFja3MubGVu Z3RoKSB7Ci0gICAgICAgICAgICAgICAgICAgIHN0cmVhbSA9IG51bGw7Ci0gICAgICAgICAgICAg ICAgICAgIHZpZGVvLnNyY09iamVjdCA9IG51bGw7Ci0gICAgICAgICAgICAgICAgfQogICAgICAg ICAgICAgfQogCisgICAgICAgICAgICBsZXQgc3RyZWFtUHJvbWlzZURpZFJlc29sdmUgPSBmYWxz ZTsKKwogICAgICAgICAgICAgZnVuY3Rpb24gaGF2ZVN0cmVhbSgpCiAgICAgICAgICAgICB7Ci0g ICAgICAgICAgICAgICAgcmV0dXJuIHN0cmVhbSAhPT0gbnVsbDsKKyAgICAgICAgICAgICAgICAv LyBPdXIgY2FsbGVyIHBvbGxzIHJlcGVhdGVkbHkgdW50aWwgb3VyIHByb21pc2UgcmVzb2x2ZXMu CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZS50aGVuKChzdHJlYW0pID0+IHN0cmVhbVBy b21pc2VEaWRSZXNvbHZlID0gISFzdHJlYW0pOworICAgICAgICAgICAgICAgIHJldHVybiBzdHJl YW1Qcm9taXNlRGlkUmVzb2x2ZTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgZnVuY3Rp b24gZG9NdWx0aXBsZUdldFVzZXJNZWRpYVN5bmNocm9ub3VzbHkoKQpAQCAtNTMsMTIgKzYwLDEy IEBACiAKICAgICAgICAgICAgIGZ1bmN0aW9uIGNhcHR1cmVBdWRpbygpCiAgICAgICAgICAgICB7 Ci0gICAgICAgICAgICAgICAgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1 ZGlvOiB0cnVlfSkudGhlbihzID0+IHN0cmVhbSA9IHMpOworICAgICAgICAgICAgICAgIHN0cmVh bVByb21pc2UgPSBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86IHRy dWV9KTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgZnVuY3Rpb24gY2FwdHVyZUF1ZGlv QW5kVmlkZW8oKQogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIG5hdmlnYXRvci5tZWRp YURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzogdHJ1ZSwgdmlkZW86IHRydWV9KS50aGVuKHMg PT4gc3RyZWFtID0gcyk7CisgICAgICAgICAgICAgICAgc3RyZWFtUHJvbWlzZSA9IG5hdmlnYXRv ci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzogdHJ1ZSwgdmlkZW86IHRydWV9KTsK ICAgICAgICAgICAgIH0KICAgICAgICAgPC9zY3JpcHQ+CiAgICAgPGhlYWQ+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggMzI0 MTI3NjA2OTJlNWFlMWFkYzI0Y2I0YzJlYmY0ZGYzMTkyZGU0ZS4uNDYwOTk0MDc1ZGM0YzkwNWI4 YzhlZmQ5MzZkNmI4MzFhNGNiNzgyNiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE5LTEwLTE3 ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIFVzaW5nIHZlcnNp b24gMSBDRlJ1bmxvb3BTb3VyY2UgZm9yIGZhc3RlciB0YXNrIGRpc3BhdGNoCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQKKworICAgICAgICBS ZXZpZXdlZCBieSBHZW9mZnJleSBHYXJlbi4KKworICAgICAgICBGaXggYSBmbGFreSB0ZXN0Lgor CisgICAgICAgICogaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24tZXhwZWN0ZWQudHh0Ogor ICAgICAgICAqIGluc3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLmh0bWw6CisKIDIwMTktMTAt MTcgIERpcmsgU2NodWx6ZSAgPGtyaXRAd2Via2l0Lm9yZz4KIAogICAgICAgICB0cmFuc2Zvcm0t Ym94OiBjb250ZW50LWJveCwgc3Ryb2tlLWJveCBtaXNzaW5nCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi1leHBlY3RlZC50eHQKaW5kZXggNWI4 MzIzMzQ5YTEyOGJhNjYzYmRjODc4YjRhNjJlZDY0MjNkODE3Mi4uNDliN2ZmYTc0ZmQwMjFkZWJl OGM3MGU3NzFmNmJlZmI4YmRlMmRkOSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaW5zcGVjdG9y L2Nzcy9wc2V1ZG8tY3JlYXRpb24tZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2luc3Bl Y3Rvci9jc3MvcHNldWRvLWNyZWF0aW9uLWV4cGVjdGVkLnR4dApAQCAtMTIsMTEgKzEyLDExIEBA IFBBU1M6IFRoZXJlIHNob3VsZCBiZSAwIG5vZGUgd2l0aCB0aGUgY2xhc3MgIi50ZXN0LXBzZXVk by13aXRob3V0LWNvbnRlbnQiLgogCiBDYWxsaW5nICJjcmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0 ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSIuLi4KIENoZWNraW5nIGZvciBub2RlcyB3aXRoIGNs YXNzICIudGVzdC1wc2V1ZG8td2l0aC1jb250ZW50Ii4uLgotUEFTUzogQ3JlYXRlZCA6OmJlZm9y ZSBwc2V1ZG8gZWxlbWVudAogUEFTUzogVGhlcmUgc2hvdWxkIGJlIDEgbm9kZSB3aXRoIHRoZSBj bGFzcyAiLnRlc3QtcHNldWRvLXdpdGgtY29udGVudCIuCitQQVNTOiBDcmVhdGVkIDo6YmVmb3Jl IHBzZXVkbyBlbGVtZW50CiAKIENhbGxpbmcgInJlbW92ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3Qt cHNldWRvLXdpdGgtY29udGVudCIpIi4uLgogQ2hlY2tpbmcgZm9yIG5vZGVzIHdpdGggY2xhc3Mg Ii50ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiLi4uCi1QQVNTOiBSZW1vdmVkIDo6YmVmb3JlIHBz ZXVkbyBlbGVtZW50CiBQQVNTOiBUaGVyZSBzaG91bGQgYmUgMCBub2RlIHdpdGggdGhlIGNsYXNz ICIudGVzdC1wc2V1ZG8td2l0aC1jb250ZW50Ii4KK1BBU1M6IFJlbW92ZWQgOjpiZWZvcmUgcHNl dWRvIGVsZW1lbnQKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1 ZG8tY3JlYXRpb24uaHRtbCBiL0xheW91dFRlc3RzL2luc3BlY3Rvci9jc3MvcHNldWRvLWNyZWF0 aW9uLmh0bWwKaW5kZXggYTAxY2UwZDM2NDVkMzhmNDdlNTI2N2VhYzlkOGUwZjQ4NmQxYTY0Ni4u ODRmNTA1MDBiZDM3NDZjYTNiZDY4OGQ5MDBhNDc0NzEyODJjNDhkOSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaW5zcGVjdG9yL2Nzcy9wc2V1ZG8tY3JlYXRpb24uaHRtbAorKysgYi9MYXlvdXRU ZXN0cy9pbnNwZWN0b3IvY3NzL3BzZXVkby1jcmVhdGlvbi5odG1sCkBAIC0yNiw3ICsyNiw4IEBA IGZ1bmN0aW9uIHJlbW92ZUVsZW1lbnRXaXRoQ2xhc3MoY2xhc3NOYW1lKSB7CiAKIGZ1bmN0aW9u IHRlc3QoKSB7CiAgICAgbGV0IGRvY3VtZW50Tm9kZSA9IG51bGw7Ci0gICAgbGV0IHBzZXVkb0Vs ZW1lbnQgPSBudWxsOworICAgIGxldCBwc2V1ZG9FbGVtZW50QWRkZWQgPSBudWxsOworICAgIGxl dCBwc2V1ZG9FbGVtZW50UmVtb3ZlZCA9IG51bGw7CiAKICAgICBmdW5jdGlvbiBoYW5kbGVQcm9t aXNlUmVqZWN0KGVycm9yKSB7CiAgICAgICAgIGNvbnNvbGUubG9nKGVycm9yKTsKQEAgLTU2LDI3 ICs1NywzNyBAQCBmdW5jdGlvbiB0ZXN0KCkgewogICAgICAgICAuY2F0Y2goaGFuZGxlUHJvbWlz ZVJlamVjdCk7CiAgICAgfQogCi0gICAgZnVuY3Rpb24gY3JlYXRlRWxlbWVudFdpdGhDbGFzcyhj bGFzc05hbWUpIHsKKyAgICBmdW5jdGlvbiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFt ZSwgc2hvdWxkQ2hlY2tFbGVtZW50KSB7CiAgICAgICAgIHJldHVybiBldmFsdWF0ZVdpdGhMb2co YGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoIiR7Y2xhc3NOYW1lfSIpYCkKICAgICAgICAgLnRoZW4o KCkgPT4gY2hlY2tFbGVtZW50c1dpdGhDbGFzcyhjbGFzc05hbWUsIDEpKQorICAgICAgICAudGhl bigoKSA9PiB7CisgICAgICAgICAgICBpZiAoc2hvdWxkQ2hlY2tFbGVtZW50KSB7CisgICAgICAg ICAgICAgICAgaWYgKHBzZXVkb0VsZW1lbnRBZGRlZCkKKyAgICAgICAgICAgICAgICAgICAgUHJv dG9jb2xUZXN0LnBhc3MoYENyZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnRBZGRlZC5wc2V1ZG9UeXBl fSBwc2V1ZG8gZWxlbWVudGApOworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIHBzZXVkb0VsZW1lbnRBZGRlZFByb21pc2UudGhlbigoKSA9PiB7IFByb3Rv Y29sVGVzdC5wYXNzKGBDcmVhdGVkIDo6JHtwc2V1ZG9FbGVtZW50QWRkZWQucHNldWRvVHlwZX0g cHNldWRvIGVsZW1lbnRgKTsgfSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0pCiAgICAgICAg IC5jYXRjaChoYW5kbGVQcm9taXNlUmVqZWN0KTsKICAgICB9CiAKLSAgICBmdW5jdGlvbiByZW1v dmVFbGVtZW50V2l0aENsYXNzKGNsYXNzTmFtZSkgeworICAgIGZ1bmN0aW9uIHJlbW92ZUVsZW1l bnRXaXRoQ2xhc3MoY2xhc3NOYW1lLCBzaG91bGRDaGVja0VsZW1lbnQpIHsKICAgICAgICAgcmV0 dXJuIGV2YWx1YXRlV2l0aExvZyhgcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygiJHtjbGFzc05hbWV9 IilgKQogICAgICAgICAudGhlbigoKSA9PiBjaGVja0VsZW1lbnRzV2l0aENsYXNzKGNsYXNzTmFt ZSwgMCkpCisgICAgICAgIC50aGVuKCgpID0+IHsKKyAgICAgICAgICAgIGlmIChzaG91bGRDaGVj a0VsZW1lbnQpIHsKKyAgICAgICAgICAgICAgICBpZiAocHNldWRvRWxlbWVudFJlbW92ZWQpCisg ICAgICAgICAgICAgICAgICAgIFByb3RvY29sVGVzdC5leHBlY3RFcXVhbChwc2V1ZG9FbGVtZW50 UmVtb3ZlZC5wc2V1ZG9FbGVtZW50SWQsIHBzZXVkb0VsZW1lbnRBZGRlZC5ub2RlSWQsIGBSZW1v dmVkIDo6JHtwc2V1ZG9FbGVtZW50QWRkZWQucHNldWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsK KyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwc2V1ZG9F bGVtZW50UmVtb3ZlZFByb21pc2UudGhlbigoKSA9PiB7IFByb3RvY29sVGVzdC5leHBlY3RFcXVh bChwc2V1ZG9FbGVtZW50UmVtb3ZlZC5wc2V1ZG9FbGVtZW50SWQsIHBzZXVkb0VsZW1lbnRBZGRl ZC5ub2RlSWQsIGBSZW1vdmVkIDo6JHtwc2V1ZG9FbGVtZW50QWRkZWQucHNldWRvVHlwZX0gcHNl dWRvIGVsZW1lbnRgKTsgfSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0pCiAgICAgICAgIC5j YXRjaChoYW5kbGVQcm9taXNlUmVqZWN0KTsKICAgICB9CiAKLSAgICBJbnNwZWN0b3JQcm90b2Nv bC5ldmVudEhhbmRsZXJbIkRPTS5wc2V1ZG9FbGVtZW50QWRkZWQiXSA9IChyZXNwb25zZSkgPT4g ewotICAgICAgICBwc2V1ZG9FbGVtZW50ID0gcmVzcG9uc2UucGFyYW1zLnBzZXVkb0VsZW1lbnQ7 Ci0KLSAgICAgICAgUHJvdG9jb2xUZXN0LnBhc3MoYENyZWF0ZWQgOjoke3BzZXVkb0VsZW1lbnQu cHNldWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsKLSAgICB9OworICAgIGxldCBwc2V1ZG9FbGVt ZW50QWRkZWRQcm9taXNlID0gSW5zcGVjdG9yUHJvdG9jb2wuYXdhaXRFdmVudCh7ZXZlbnQ6ICJE T00ucHNldWRvRWxlbWVudEFkZGVkIn0pLnRoZW4oKGV2ZW50KSA9PiB7IHBzZXVkb0VsZW1lbnRB ZGRlZCA9IGV2ZW50LnBhcmFtcy5wc2V1ZG9FbGVtZW50fSk7CisgICAgbGV0IHBzZXVkb0VsZW1l bnRSZW1vdmVkUHJvbWlzZSA9IEluc3BlY3RvclByb3RvY29sLmF3YWl0RXZlbnQoe2V2ZW50OiAi RE9NLnBzZXVkb0VsZW1lbnRSZW1vdmVkIn0pLnRoZW4oKGV2ZW50KSA9PiB7IHBzZXVkb0VsZW1l bnRSZW1vdmVkID0gZXZlbnQucGFyYW1zfSk7CiAKLSAgICBJbnNwZWN0b3JQcm90b2NvbC5ldmVu dEhhbmRsZXJbIkRPTS5wc2V1ZG9FbGVtZW50UmVtb3ZlZCJdID0gKHJlc3BvbnNlKSA9PiB7Ci0g ICAgICAgIFByb3RvY29sVGVzdC5leHBlY3RFcXVhbChyZXNwb25zZS5wYXJhbXMucHNldWRvRWxl bWVudElkLCBwc2V1ZG9FbGVtZW50Lm5vZGVJZCwgYFJlbW92ZWQgOjoke3BzZXVkb0VsZW1lbnQu cHNldWRvVHlwZX0gcHNldWRvIGVsZW1lbnRgKTsKLSAgICB9OwogCiAgICAgUHJvdG9jb2xUZXN0 LmxvZygiUmVxdWVzdGluZyBkb2N1bWVudC4uLiIpOwogICAgIEluc3BlY3RvclByb3RvY29sLnNl bmRDb21tYW5kKCJET00uZ2V0RG9jdW1lbnQiLCB7fSwgKHJlc3BvbnNlKSA9PiB7CkBAIC04NSwx MCArOTYsMTAgQEAgZnVuY3Rpb24gdGVzdCgpIHsKICAgICAgICAgZG9jdW1lbnROb2RlID0gcmVz cG9uc2UucmVzdWx0LnJvb3Q7CiAKICAgICAgICAgUHJvbWlzZS5yZXNvbHZlKCkKLSAgICAgICAg LnRoZW4oKCkgPT4gY3JlYXRlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1j b250ZW50IikpCi0gICAgICAgIC50aGVuKCgpID0+IHJlbW92ZUVsZW1lbnRXaXRoQ2xhc3MoInRl c3QtcHNldWRvLXdpdGhvdXQtY29udGVudCIpKQotICAgICAgICAudGhlbigoKSA9PiBjcmVhdGVF bGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13aXRoLWNvbnRlbnQiKSkKLSAgICAgICAgLnRo ZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250ZW50 IikpCisgICAgICAgIC50aGVuKCgpID0+IGNyZWF0ZUVsZW1lbnRXaXRoQ2xhc3MoInRlc3QtcHNl dWRvLXdpdGhvdXQtY29udGVudCIpLCBmYWxzZSkKKyAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3Zl RWxlbWVudFdpdGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aG91dC1jb250ZW50IiksIGZhbHNlKQor ICAgICAgICAudGhlbigoKSA9PiBjcmVhdGVFbGVtZW50V2l0aENsYXNzKCJ0ZXN0LXBzZXVkby13 aXRoLWNvbnRlbnQiLCB0cnVlKSkKKyAgICAgICAgLnRoZW4oKCkgPT4gcmVtb3ZlRWxlbWVudFdp dGhDbGFzcygidGVzdC1wc2V1ZG8td2l0aC1jb250ZW50IiwgdHJ1ZSkpCiAgICAgICAgIC50aGVu KCgpID0+IFByb3RvY29sVGVzdC5jb21wbGV0ZVRlc3QoKSkKICAgICAgICAgLmNhdGNoKGhhbmRs ZVByb21pc2VSZWplY3QpOwogICAgIH0pOwo= 390927 2020-02-17 09:59:53 -0800 2020-02-24 14:19:32 -0800 Patch bug-202874-20200217095953.patch text/plain 8286 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjU2NzM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDVkYjQ3MDI5MzM0YjUxY2QxMjEyODgx YmIwZWQxOTI3ODE0ZmVmNzMuLmMyMTJmNzBkYTY1OTM1Nzc4ZWI2OTM5YzRiN2M5M2I5NDQ3ZjQy MzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMjAtMDItMTcgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgdmVyc2lvbiAxIENGUnVubG9vcFNvdXJjZSBm b3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IEdlb2ZmcmV5IEdh cmVuLgorCisgICAgICAgIFdlIHVzZWQgQ0ZSdW5Mb29wV2FrZVVwIHRvIHdha2UgdXAgcnVubG9v cCB0byBwcm9jZXNzIHNvdXJjZSwgd2hpY2ggc2VlbXMgdG8gYmUgc2xvdyBiZWNhdXNlIG9mIGxv Y2tpbmcuIFRvIAorICAgICAgICBhdm9pZCBjYWxsaW5nIENGUnVuTG9vcFdha2VVcCwgd2Ugc2hv dWxkIHVzZSB2ZXJzaW9uIDEgQ0ZSdW5sb29wU291cmNlIGluc3RlYWQgb2YgdmVyc2lvbiAwLgor CisgICAgICAgICogd3RmL1J1bkxvb3AuY3BwOgorICAgICAgICAoV1RGOjpSdW5Mb29wOjppbml0 aWFsaXplV2ViUnVuTG9vcCk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OndlYik6CisgICAgICAg ICogd3RmL1J1bkxvb3AuaDoKKyAgICAgICAgKiB3dGYvY2YvUnVuTG9vcENGLmNwcDoKKyAgICAg ICAgKFdURjo6UnVuTG9vcDo6cGVyZm9ybVdvcmspOgorICAgICAgICAoV1RGOjpSdW5Mb29wOjpS dW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6flJ1bkxvb3ApOgorICAgICAgICAoV1RG OjpSdW5Mb29wOjp3YWtlVXApOgorICAgICAgICAqIHd0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2Eu bW06CisgICAgICAgIChXVEY6OmluaXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0pOgorICAgICAg ICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKyAgICAgICAg KFdURjo6aW5pdGlhbGl6ZVdlYlRocmVhZCk6CisgICAgICAgICgtW0pTV1RGTWFpblRocmVhZENh bGxlciBjYWxsXSk6IERlbGV0ZWQuCisKIDIwMjAtMDItMTcgIEFudHRpIEtvaXZpc3RvICA8YW50 dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFttYWNPU10gQWRkIHRyYWNlIHBvaW50cyBmb3IgbGF5 ZXIgZmx1c2ggcnVubG9vcCBvYnNlcnZlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVu TG9vcC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAppbmRleCAxYmUyMmQ4MDlmM2Rl Njk1NTk5NjY1ZDIxMzBjOWRkY2YxYjAwZTcwLi45MzhiOWU5OWQ1ZTQxNDg4MmNjOWUwMzEwN2Jm NGY2NjNmYzIyNGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAorKysg Yi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApAQCAtMzMsNiArMzMsOSBAQAogbmFtZXNwYWNl IFdURiB7CiAKIHN0YXRpYyBSdW5Mb29wKiBzX21haW5SdW5Mb29wOworI2lmIFVTRShXRUJfVEhS RUFEKQorc3RhdGljIFJ1bkxvb3AqIHNfd2ViUnVuTG9vcDsKKyNlbmRpZgogCiAvLyBIZWxwZXIg Y2xhc3MgZm9yIFRocmVhZFNwZWNpZmljRGF0YS4KIGNsYXNzIFJ1bkxvb3A6OkhvbGRlciB7CkBA IC02OSw2ICs3MiwxOSBAQCBSdW5Mb29wJiBSdW5Mb29wOjptYWluKCkKICAgICByZXR1cm4gKnNf bWFpblJ1bkxvb3A7CiB9CiAKKyNpZiBVU0UoV0VCX1RIUkVBRCkKK3ZvaWQgUnVuTG9vcDo6aW5p dGlhbGl6ZVdlYlJ1bkxvb3AoKQoreworICAgIHNfd2ViUnVuTG9vcCA9ICZSdW5Mb29wOjpjdXJy ZW50KCk7Cit9CisKK1J1bkxvb3AmIFJ1bkxvb3A6OndlYigpCit7CisgICAgQVNTRVJUKHNfd2Vi UnVuTG9vcCk7CisgICAgcmV0dXJuICpzX3dlYlJ1bkxvb3A7Cit9CisjZW5kaWYKKwogYm9vbCBS dW5Mb29wOjppc01haW4oKQogewogICAgIEFTU0VSVChzX21haW5SdW5Mb29wKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaCBiL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaApp bmRleCBlMjQyNDc2ZTk3ZGU1NDc5Yjc2ZDc1OGYyZjQxNTQxZGM2ZWNkMDAzLi42MmU0OTIyMGE2 ZmQyYTFkODI5YWQwMjc5YmNhY2UxNGY0ODUyZWMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0 Zi9SdW5Mb29wLmgKKysrIGIvU291cmNlL1dURi93dGYvUnVuTG9vcC5oCkBAIC02MSw5ICs2MSwx NSBAQCBwdWJsaWM6CiAgICAgLy8gTXVzdCBiZSBjYWxsZWQgZnJvbSB0aGUgbWFpbiB0aHJlYWQg KGV4Y2VwdCBmb3IgdGhlIE1hYyBwbGF0Zm9ybSwgd2hlcmUgaXQKICAgICAvLyBjYW4gYmUgY2Fs bGVkIGZyb20gYW55IHRocmVhZCkuCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyB2b2lk IGluaXRpYWxpemVNYWluUnVuTG9vcCgpOworI2lmIFVTRShXRUJfVEhSRUFEKQorICAgIFdURl9F WFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBpbml0aWFsaXplV2ViUnVuTG9vcCgpOworI2VuZGlm CiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIGN1cnJlbnQoKTsKICAg ICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIG1haW4oKTsKKyNpZiBVU0UoV0VC X1RIUkVBRCkKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIHdlYigpOwor I2VuZGlmCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBib29sIGlzTWFpbigpOwogICAg IH5SdW5Mb29wKCk7CiAKQEAgLTE5MCw5ICsxOTYsMTAgQEAgcHJpdmF0ZToKIAogICAgIExvY2sg bV9sb29wTG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09QKQotICAgIHN0YXRpYyB2b2lk IHBlcmZvcm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayhDRk1hY2hQ b3J0UmVmLCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCogaW5mbyk7CiAgICAgUmV0YWlu UHRyPENGUnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BTb3Vy Y2VSZWY+IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZNYWNoUG9ydFJlZj4gbV9w b3J0OwogI2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBHUmVmUHRyPEdNYWluQ29udGV4 dD4gbV9tYWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxHTWFpbkxvb3A+PiBtX21haW5M b29wczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAgYi9Tb3Vy Y2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IGE1N2Y3YTJlZDE1ZTQyODc1YzMzZTVh MWM2ZmM3NTUwOThiYTg5Y2EuLjRkYWU4NTA5MWUxNWE2NTM2YWE3OGZhMmZmNmI2ZWRjNWU5ZGE1 ZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKKysrIGIvU291 cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYgKzI4LDI5IEBACiAKICNpbmNs dWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNo L2Rpc3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9k cmFpbmVkUG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9pZCBSdW5Mb29wOjpwZXJmb3Jt V29yayh2b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0 UmVmLCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wg cG9vbDsKLSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7 CisgICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBS dW5Mb29wOjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkp CiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAw LCAwLCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFk b3B0Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250 ZXh0KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0 ciwgbnVsbHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENy ZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIp KTsKKyAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29w U291cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVu TG9vcEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NG UnVuTG9vcENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENG TWFjaFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52 YWxpZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBAIC01OCw4ICs2MSwxNiBAQCB2 b2lkIFJ1bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVyYXRpb24pCiAKIHZvaWQgUnVu TG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291 cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBt YWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNH SF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXpl ID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9y dCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9j YWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBt YWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNH IHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxM LCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hf TVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChy ZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgm aGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoUnVuTG9v cE1vZGUgbW9kZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRD b2NvYS5tbSBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbQppbmRleCA3 NDY0NjhkNTc1OTI1MzM0OTJmNTc4M2FiYzkxYjYxMmI0NTJjZWJkLi5jZTI5YTJjNjk1YWRhNzEw YmMxOTVjMDdmNjIzZDQxZGJiNDA3ZTAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9jb2Nv YS9NYWluVGhyZWFkQ29jb2EubW0KKysrIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVh ZENvY29hLm1tCkBAIC0zNiw2ICszNiw3IEBACiAjaW1wb3J0IDx3dGYvQXNzZXJ0aW9ucy5oPgog I2ltcG9ydCA8d3RmL0hhc2hTZXQuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBv cnQgPHd0Zi9SdW5Mb29wLmg+CiAjaW1wb3J0IDx3dGYvU2NoZWR1bGVQYWlyLmg+CiAjaW1wb3J0 IDx3dGYvVGhyZWFkaW5nLmg+CiAKQEAgLTQzLDE5ICs0NCw2IEBACiAjaW5jbHVkZSA8d3RmL2lv cy9XZWJDb3JlVGhyZWFkLmg+CiAjZW5kaWYKIAotQGludGVyZmFjZSBKU1dURk1haW5UaHJlYWRD YWxsZXIgOiBOU09iamVjdAotLSAodm9pZCljYWxsOwotQGVuZAotCi1AaW1wbGVtZW50YXRpb24g SlNXVEZNYWluVGhyZWFkQ2FsbGVyCi0KLS0gKHZvaWQpY2FsbAotewotICAgIFdURjo6ZGlzcGF0 Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOwotfQotCi1AZW5kCi0KICNkZWZpbmUgTE9HX0NI QU5ORUxfUFJFRklYIExvZwogCiBuYW1lc3BhY2UgV1RGIHsKQEAgLTY2LDggKzU0LDYgQEAgV1RG TG9nQ2hhbm5lbCBMb2dUaHJlYWRpbmcgPSB7IFdURkxvZ0NoYW5uZWxTdGF0ZTo6T24sICJUaHJl YWRpbmciLCBXVEZMb2dMZXZlbDoKIFdURkxvZ0NoYW5uZWwgTG9nVGhyZWFkaW5nID0geyBXVEZM b2dDaGFubmVsU3RhdGU6Ok9uLCAiVGhyZWFkaW5nIiwgV1RGTG9nTGV2ZWw6OkVycm9yLCBMT0df Q0hBTk5FTF9XRUJLSVRfU1VCU1lTVEVNLCBPU19MT0dfREVGQVVMVCB9OwogI2VuZGlmCiAKLQot c3RhdGljIEpTV1RGTWFpblRocmVhZENhbGxlciogc3RhdGljTWFpblRocmVhZENhbGxlcjsKIHN0 YXRpYyBib29sIGlzVGltZXJQb3N0ZWQ7IC8vIFRoaXMgaXMgb25seSBhY2Nlc3NlZCBvbiB0aGUg bWFpbiB0aHJlYWQuCiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKQEAgLTg0LDkgKzcwLDYgQEAgdm9p ZCBpbml0aWFsaXplTWFpblRocmVhZFBsYXRmb3JtKCkKICAgICBpZiAoIXB0aHJlYWRfbWFpbl9u cCgpKQogICAgICAgICBSRUxFQVNFX0xPR19GQVVMVChUaHJlYWRpbmcsICJXZWJLaXQgVGhyZWFk aW5nIFZpb2xhdGlvbiAtIGluaXRpYWwgdXNlIG9mIFdlYktpdCBmcm9tIGEgc2Vjb25kYXJ5IHRo cmVhZC4iKTsKICAgICBBU1NFUlQocHRocmVhZF9tYWluX25wKCkpOwotCi0gICAgQVNTRVJUKCFz dGF0aWNNYWluVGhyZWFkQ2FsbGVyKTsKLSAgICBzdGF0aWNNYWluVGhyZWFkQ2FsbGVyID0gW1tK U1dURk1haW5UaHJlYWRDYWxsZXIgYWxsb2NdIGluaXRdOwogfQogCiBzdGF0aWMgdm9pZCB0aW1l ckZpcmVkKENGUnVuTG9vcFRpbWVyUmVmIHRpbWVyLCB2b2lkKikKQEAgLTExMiw4ICs5NSw2IEBA IHN0YXRpYyB2b2lkIHBvc3RUaW1lcigpCiAKIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9u c09uTWFpblRocmVhZCgpCiB7Ci0gICAgQVNTRVJUKHN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwot ICAgIAogI2lmIFVTRShXRUJfVEhSRUFEKQogICAgIGlmIChpc1dlYlRocmVhZCgpKSB7CiAgICAg ICAgIHBvc3RUaW1lcigpOwpAQCAtMTIxLDcgKzEwMiw5IEBAIHZvaWQgc2NoZWR1bGVEaXNwYXRj aEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiAgICAgfQogCiAgICAgaWYgKG1haW5UaHJlYWRQdGhy ZWFkKSB7Ci0gICAgICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVyIHBlcmZvcm1TZWxlY3RvcjpA c2VsZWN0b3IoY2FsbCkgb25UaHJlYWQ6bWFpblRocmVhZE5TVGhyZWFkIHdpdGhPYmplY3Q6bmls IHdhaXRVbnRpbERvbmU6Tk9dOworICAgICAgICBSdW5Mb29wOjp3ZWIoKS5kaXNwYXRjaChbXSB7 CisgICAgICAgICAgICBXVEY6OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKKyAg ICAgICAgfSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAjZWxzZQpAQCAtMTMxLDcgKzExNCw5 IEBAIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiAgICAgfQog I2VuZGlmCiAKLSAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBwZXJmb3JtU2VsZWN0b3JPbk1h aW5UaHJlYWQ6QHNlbGVjdG9yKGNhbGwpIHdpdGhPYmplY3Q6bmlsIHdhaXRVbnRpbERvbmU6Tk9d OworICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbXSB7CisgICAgICAgIFdURjo6ZGlzcGF0 Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOworICAgIH0pOwogfQogCiB2b2lkIGRpc3BhdGNo QXN5bmNPbk1haW5UaHJlYWRXaXRoV2ViVGhyZWFkTG9ja0lmTmVlZGVkKHZvaWQgKF5ibG9jayko KSkKQEAgLTE5Niw2ICsxODEsNyBAQCB2b2lkIGluaXRpYWxpemVXZWJUaHJlYWQoKQogICAgICAg ICBtYWluVGhyZWFkUHRocmVhZCA9IHB0aHJlYWRfc2VsZigpOwogICAgICAgICBtYWluVGhyZWFk TlNUaHJlYWQgPSBbTlNUaHJlYWQgY3VycmVudFRocmVhZF07CiAgICAgICAgIHNXZWJUaHJlYWQg PSAmVGhyZWFkOjpjdXJyZW50KCk7CisgICAgICAgIFJ1bkxvb3A6OmluaXRpYWxpemVXZWJSdW5M b29wKCk7CiAgICAgfSk7CiB9CiAK 391575 2020-02-24 14:19:34 -0800 2020-02-25 17:10:14 -0800 Patch bug-202874-20200224141933.patch text/plain 11079 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3MjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDQwN2EzOGFiMDA3YTUzNmRlYTA5NGE0 NTNiZjgwMzY0MDZlMTRmOWYuLjZmNDFhOGVmODg3Y2U3ZDAxYTg4MzFlMjIyNjJiYTg5ODI4NDQy OTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMjAtMDItMjQgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTYzODcyMDU+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiB3dGYvUnVuTG9vcC5j cHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OmluaXRpYWxpemVXZWJSdW5Mb29wKToKKyAgICAg ICAgKFdURjo6UnVuTG9vcDo6d2ViKToKKyAgICAgICAgKiB3dGYvUnVuTG9vcC5oOgorICAgICAg ICAqIHd0Zi9jZi9SdW5Mb29wQ0YuY3BwOgorICAgICAgICAoV1RGOjpSdW5Mb29wOjpwZXJmb3Jt V29yayk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1bkxvb3ApOgorICAgICAgICAoV1RGOjpS dW5Mb29wOjp+UnVuTG9vcCk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6Ondha2VVcCk6CisgICAg ICAgICogd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbToKKyAgICAgICAgKFdURjo6aW5pdGlh bGl6ZU1haW5UaHJlYWRQbGF0Zm9ybSk6CisgICAgICAgIChXVEY6OnNjaGVkdWxlRGlzcGF0Y2hG dW5jdGlvbnNPbk1haW5UaHJlYWQpOgorICAgICAgICAoV1RGOjppbml0aWFsaXplV2ViVGhyZWFk KToKKyAgICAgICAgKC1bSlNXVEZNYWluVGhyZWFkQ2FsbGVyIGNhbGxdKTogRGVsZXRlZC4KKwog MjAyMC0wMi0yMyAgWXVzdWtlIFN1enVraSAgPHlzdXp1a2lAYXBwbGUuY29tPgogCiAgICAgICAg IFtKU0NdIFNocmluayBTdHJ1Y3R1cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1J1bkxv b3AuY3BwIGIvU291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAKaW5kZXggYTBhMjhlODIyYzRhOWMz MjRhMmY1YWNmNTEyZjIyYmM2YjNhNTk1Zi4uOWYxYTEzYTgwMjlmOTdmNWUzYjczYTA2ZWVjMzlm YTZjZmFkMGFkNSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAKKysrIGIv U291cmNlL1dURi93dGYvUnVuTG9vcC5jcHAKQEAgLTMzLDYgKzMzLDkgQEAKIG5hbWVzcGFjZSBX VEYgewogCiBzdGF0aWMgUnVuTG9vcCogc19tYWluUnVuTG9vcDsKKyNpZiBVU0UoV0VCX1RIUkVB RCkKK3N0YXRpYyBSdW5Mb29wKiBzX3dlYlJ1bkxvb3A7CisjZW5kaWYKIAogLy8gSGVscGVyIGNs YXNzIGZvciBUaHJlYWRTcGVjaWZpY0RhdGEuCiBjbGFzcyBSdW5Mb29wOjpIb2xkZXIgewpAQCAt NjksNiArNzIsMTkgQEAgUnVuTG9vcCYgUnVuTG9vcDo6bWFpbigpCiAgICAgcmV0dXJuICpzX21h aW5SdW5Mb29wOwogfQogCisjaWYgVVNFKFdFQl9USFJFQUQpCit2b2lkIFJ1bkxvb3A6OmluaXRp YWxpemVXZWJSdW5Mb29wKCkKK3sKKyAgICBzX3dlYlJ1bkxvb3AgPSAmUnVuTG9vcDo6Y3VycmVu dCgpOworfQorCitSdW5Mb29wJiBSdW5Mb29wOjp3ZWIoKQoreworICAgIEFTU0VSVChzX3dlYlJ1 bkxvb3ApOworICAgIHJldHVybiAqc193ZWJSdW5Mb29wOworfQorI2VuZGlmCisKIGJvb2wgUnVu TG9vcDo6aXNNYWluKCkKIHsKICAgICBBU1NFUlQoc19tYWluUnVuTG9vcCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmggYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgKaW5k ZXggYTM5NWIzNmU5NTYwZGVhYjI1MjU5OTkzMWYwYzZmNDY0YTZlYzQxOC4uNWYzYTNmZGM0Y2Ji YjA0NTliNzRhZGI4YzcwZjYyNWFjZjFmMjU5NyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYv UnVuTG9vcC5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaApAQCAtNjEsOSArNjEsMTUg QEAgcHVibGljOgogICAgIC8vIE11c3QgYmUgY2FsbGVkIGZyb20gdGhlIG1haW4gdGhyZWFkIChl eGNlcHQgZm9yIHRoZSBNYWMgcGxhdGZvcm0sIHdoZXJlIGl0CiAgICAgLy8gY2FuIGJlIGNhbGxl ZCBmcm9tIGFueSB0aHJlYWQpLgogICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBp bml0aWFsaXplTWFpblJ1bkxvb3AoKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBXVEZfRVhQ T1JUX1BSSVZBVEUgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKTsKKyNlbmRpZgog CiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiBjdXJyZW50KCk7CiAgICAg V1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiBtYWluKCk7CisjaWYgVVNFKFdFQl9U SFJFQUQpCisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiB3ZWIoKTsKKyNl bmRpZgogICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgYm9vbCBpc01haW4oKTsKICAgICB+ UnVuTG9vcCgpOwogCkBAIC0xOTQsOSArMjAwLDEwIEBAIHByaXZhdGU6CiAKICAgICBMb2NrIG1f bG9vcExvY2s7CiAjZWxpZiBVU0UoQ09DT0FfRVZFTlRfTE9PUCkKLSAgICBzdGF0aWMgdm9pZCBw ZXJmb3JtV29yayh2b2lkKik7CisgICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmsoQ0ZNYWNoUG9y dFJlZiwgdm9pZCogbXNnLCBDRkluZGV4IHNpemUsIHZvaWQqIGluZm8pOwogICAgIFJldGFpblB0 cjxDRlJ1bkxvb3BSZWY+IG1fcnVuTG9vcDsKICAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29wU291cmNl UmVmPiBtX3J1bkxvb3BTb3VyY2U7CisgICAgUmV0YWluUHRyPENGTWFjaFBvcnRSZWY+IG1fcG9y dDsKICNlbGlmIFVTRShHTElCX0VWRU5UX0xPT1ApCiAgICAgR1JlZlB0cjxHTWFpbkNvbnRleHQ+ IG1fbWFpbkNvbnRleHQ7CiAgICAgVmVjdG9yPEdSZWZQdHI8R01haW5Mb29wPj4gbV9tYWluTG9v cHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwIGIvU291cmNl L1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAppbmRleCBhNTdmN2EyZWQxNWU0Mjg3NWMzM2U1YTFj NmZjNzU1MDk4YmE4OWNhLi40ZGFlODUwOTFlMTVhNjUzNmFhNzhmYTJmZjZiNmVkYzVlOWRhNWQy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCisrKyBiL1NvdXJj ZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKQEAgLTI4LDI2ICsyOCwyOSBAQAogCiAjaW5jbHVk ZSA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KICNpbmNsdWRlIDxkaXNwYXRjaC9k aXNwYXRjaC5oPgorI2luY2x1ZGUgPG1hY2gvbWFjaC5oPgogI2luY2x1ZGUgPHd0Zi9BdXRvZHJh aW5lZFBvb2wuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKLXZvaWQgUnVuTG9vcDo6cGVyZm9ybVdv cmsodm9pZCogY29udGV4dCkKK3ZvaWQgUnVuTG9vcDo6cGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJl Ziwgdm9pZCosIENGSW5kZXgsIHZvaWQqIGluZm8pCiB7CiAgICAgQXV0b2RyYWluZWRQb29sIHBv b2w7Ci0gICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGNvbnRleHQpLT5wZXJmb3JtV29yaygpOwor ICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihpbmZvKS0+cGVyZm9ybVdvcmsoKTsKIH0KIAogUnVu TG9vcDo6UnVuTG9vcCgpCiAgICAgOiBtX3J1bkxvb3AoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpKQog ewotICAgIENGUnVuTG9vcFNvdXJjZUNvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgMCwgMCwg MCwgMCwgMCwgMCwgMCwgcGVyZm9ybVdvcmsgfTsKLSAgICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9w dENGKENGUnVuTG9vcFNvdXJjZUNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCAwLCAmY29udGV4 dCkpOworICAgIENGTWFjaFBvcnRDb250ZXh0IGNvbnRleHQgPSB7IDAsIHRoaXMsIG51bGxwdHIs IG51bGxwdHIsIG51bGxwdHIgfTsKKyAgICBtX3BvcnQgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVh dGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwgcGVyZm9ybVdvcmssICZjb250ZXh0LCBudWxscHRyKSk7 CisgICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlUnVuTG9vcFNv dXJjZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBtX3BvcnQuZ2V0KCksIDApKTsKICAgICBDRlJ1bkxv b3BBZGRTb3VyY2UobV9ydW5Mb29wLmdldCgpLCBtX3J1bkxvb3BTb3VyY2UuZ2V0KCksIGtDRlJ1 bkxvb3BDb21tb25Nb2Rlcyk7CiB9CiAKIFJ1bkxvb3A6On5SdW5Mb29wKCkKIHsKKyAgICBDRk1h Y2hQb3J0SW52YWxpZGF0ZShtX3BvcnQuZ2V0KCkpOwogICAgIENGUnVuTG9vcFNvdXJjZUludmFs aWRhdGUobV9ydW5Mb29wU291cmNlLmdldCgpKTsKIH0KIApAQCAtNTgsOCArNjEsMTYgQEAgdm9p ZCBSdW5Mb29wOjpydW5Gb3JEdXJhdGlvbihTZWNvbmRzIGR1cmF0aW9uKQogCiB2b2lkIFJ1bkxv b3A6Ondha2VVcCgpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlU2lnbmFsKG1fcnVuTG9vcFNvdXJj ZS5nZXQoKSk7Ci0gICAgQ0ZSdW5Mb29wV2FrZVVwKG1fcnVuTG9vcC5nZXQoKSk7CisgICAgbWFj aF9tc2dfaGVhZGVyX3QgaGVhZGVyOworICAgIGhlYWRlci5tc2doX2JpdHMgPSBNQUNIX01TR0hf QklUUyhNQUNIX01TR19UWVBFX0NPUFlfU0VORCwgMCk7CisgICAgaGVhZGVyLm1zZ2hfc2l6ZSA9 IHNpemVvZihtYWNoX21zZ19oZWFkZXJfdCk7CisgICAgaGVhZGVyLm1zZ2hfcmVtb3RlX3BvcnQg PSBDRk1hY2hQb3J0R2V0UG9ydChtX3BvcnQuZ2V0KCkpOworICAgIGhlYWRlci5tc2doX2xvY2Fs X3BvcnQgPSBNQUNIX1BPUlRfTlVMTDsKKyAgICBoZWFkZXIubXNnaF9pZCA9IDA7CisgICAgbWFj aF9tc2dfcmV0dXJuX3QgcmVzdWx0ID0gbWFjaF9tc2coJmhlYWRlciwgTUFDSF9TRU5EX01TRyB8 IE1BQ0hfU0VORF9USU1FT1VULCBoZWFkZXIubXNnaF9zaXplLCAwLCBNQUNIX1BPUlRfTlVMTCwg MCwgTUFDSF9QT1JUX05VTEwpOworICAgIFJFTEVBU0VfQVNTRVJUKHJlc3VsdCA9PSBNQUNIX01T R19TVUNDRVNTIHx8IHJlc3VsdCA9PSBNQUNIX1NFTkRfVElNRURfT1VUKTsKKyAgICBpZiAocmVz dWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpCisgICAgICAgIG1hY2hfbXNnX2Rlc3Ryb3koJmhl YWRlcik7CiB9CiAKIFJ1bkxvb3A6OkN5Y2xlUmVzdWx0IFJ1bkxvb3A6OmN5Y2xlKFJ1bkxvb3BN b2RlIG1vZGUpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29j b2EubW0gYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW0KaW5kZXggNzQ2 NDY4ZDU3NTkyNTMzNDkyZjU3ODNhYmM5MWI2MTJiNDUyY2ViZC4uY2UyOWEyYzY5NWFkYTcxMGJj MTk1YzA3ZjYyM2Q0MWRiYjQwN2UwMSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvY29jb2Ev TWFpblRocmVhZENvY29hLm1tCisrKyBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRD b2NvYS5tbQpAQCAtMzYsNiArMzYsNyBAQAogI2ltcG9ydCA8d3RmL0Fzc2VydGlvbnMuaD4KICNp bXBvcnQgPHd0Zi9IYXNoU2V0Lmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisjaW1wb3J0 IDx3dGYvUnVuTG9vcC5oPgogI2ltcG9ydCA8d3RmL1NjaGVkdWxlUGFpci5oPgogI2ltcG9ydCA8 d3RmL1RocmVhZGluZy5oPgogCkBAIC00MywxOSArNDQsNiBAQAogI2luY2x1ZGUgPHd0Zi9pb3Mv V2ViQ29yZVRocmVhZC5oPgogI2VuZGlmCiAKLUBpbnRlcmZhY2UgSlNXVEZNYWluVGhyZWFkQ2Fs bGVyIDogTlNPYmplY3QKLS0gKHZvaWQpY2FsbDsKLUBlbmQKLQotQGltcGxlbWVudGF0aW9uIEpT V1RGTWFpblRocmVhZENhbGxlcgotCi0tICh2b2lkKWNhbGwKLXsKLSAgICBXVEY6OmRpc3BhdGNo RnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKLX0KLQotQGVuZAotCiAjZGVmaW5lIExPR19DSEFO TkVMX1BSRUZJWCBMb2cKIAogbmFtZXNwYWNlIFdURiB7CkBAIC02Niw4ICs1NCw2IEBAIFdURkxv Z0NoYW5uZWwgTG9nVGhyZWFkaW5nID0geyBXVEZMb2dDaGFubmVsU3RhdGU6Ok9uLCAiVGhyZWFk aW5nIiwgV1RGTG9nTGV2ZWw6CiBXVEZMb2dDaGFubmVsIExvZ1RocmVhZGluZyA9IHsgV1RGTG9n Q2hhbm5lbFN0YXRlOjpPbiwgIlRocmVhZGluZyIsIFdURkxvZ0xldmVsOjpFcnJvciwgTE9HX0NI QU5ORUxfV0VCS0lUX1NVQlNZU1RFTSwgT1NfTE9HX0RFRkFVTFQgfTsKICNlbmRpZgogCi0KLXN0 YXRpYyBKU1dURk1haW5UaHJlYWRDYWxsZXIqIHN0YXRpY01haW5UaHJlYWRDYWxsZXI7CiBzdGF0 aWMgYm9vbCBpc1RpbWVyUG9zdGVkOyAvLyBUaGlzIGlzIG9ubHkgYWNjZXNzZWQgb24gdGhlIG1h aW4gdGhyZWFkLgogCiAjaWYgVVNFKFdFQl9USFJFQUQpCkBAIC04NCw5ICs3MCw2IEBAIHZvaWQg aW5pdGlhbGl6ZU1haW5UaHJlYWRQbGF0Zm9ybSgpCiAgICAgaWYgKCFwdGhyZWFkX21haW5fbnAo KSkKICAgICAgICAgUkVMRUFTRV9MT0dfRkFVTFQoVGhyZWFkaW5nLCAiV2ViS2l0IFRocmVhZGlu ZyBWaW9sYXRpb24gLSBpbml0aWFsIHVzZSBvZiBXZWJLaXQgZnJvbSBhIHNlY29uZGFyeSB0aHJl YWQuIik7CiAgICAgQVNTRVJUKHB0aHJlYWRfbWFpbl9ucCgpKTsKLQotICAgIEFTU0VSVCghc3Rh dGljTWFpblRocmVhZENhbGxlcik7Ci0gICAgc3RhdGljTWFpblRocmVhZENhbGxlciA9IFtbSlNX VEZNYWluVGhyZWFkQ2FsbGVyIGFsbG9jXSBpbml0XTsKIH0KIAogc3RhdGljIHZvaWQgdGltZXJG aXJlZChDRlJ1bkxvb3BUaW1lclJlZiB0aW1lciwgdm9pZCopCkBAIC0xMTIsOCArOTUsNiBAQCBz dGF0aWMgdm9pZCBwb3N0VGltZXIoKQogCiB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNP bk1haW5UaHJlYWQoKQogewotICAgIEFTU0VSVChzdGF0aWNNYWluVGhyZWFkQ2FsbGVyKTsKLSAg ICAKICNpZiBVU0UoV0VCX1RIUkVBRCkKICAgICBpZiAoaXNXZWJUaHJlYWQoKSkgewogICAgICAg ICBwb3N0VGltZXIoKTsKQEAgLTEyMSw3ICsxMDIsOSBAQCB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hG dW5jdGlvbnNPbk1haW5UaHJlYWQoKQogICAgIH0KIAogICAgIGlmIChtYWluVGhyZWFkUHRocmVh ZCkgewotICAgICAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBwZXJmb3JtU2VsZWN0b3I6QHNl bGVjdG9yKGNhbGwpIG9uVGhyZWFkOm1haW5UaHJlYWROU1RocmVhZCB3aXRoT2JqZWN0Om5pbCB3 YWl0VW50aWxEb25lOk5PXTsKKyAgICAgICAgUnVuTG9vcDo6d2ViKCkuZGlzcGF0Y2goW10gewor ICAgICAgICAgICAgV1RGOjpkaXNwYXRjaEZ1bmN0aW9uc0Zyb21NYWluVGhyZWFkKCk7CisgICAg ICAgIH0pOwogICAgICAgICByZXR1cm47CiAgICAgfQogI2Vsc2UKQEAgLTEzMSw3ICsxMTQsOSBA QCB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1haW5UaHJlYWQoKQogICAgIH0KICNl bmRpZgogCi0gICAgW3N0YXRpY01haW5UaHJlYWRDYWxsZXIgcGVyZm9ybVNlbGVjdG9yT25NYWlu VGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3aXRoT2JqZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsK KyAgICBSdW5Mb29wOjptYWluKCkuZGlzcGF0Y2goW10geworICAgICAgICBXVEY6OmRpc3BhdGNo RnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKKyAgICB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFz eW5jT25NYWluVGhyZWFkV2l0aFdlYlRocmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkp CkBAIC0xOTYsNiArMTgxLDcgQEAgdm9pZCBpbml0aWFsaXplV2ViVGhyZWFkKCkKICAgICAgICAg bWFpblRocmVhZFB0aHJlYWQgPSBwdGhyZWFkX3NlbGYoKTsKICAgICAgICAgbWFpblRocmVhZE5T VGhyZWFkID0gW05TVGhyZWFkIGN1cnJlbnRUaHJlYWRdOwogICAgICAgICBzV2ViVGhyZWFkID0g JlRocmVhZDo6Y3VycmVudCgpOworICAgICAgICBSdW5Mb29wOjppbml0aWFsaXplV2ViUnVuTG9v cCgpOwogICAgIH0pOwogfQogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9D aGFuZ2VMb2cKaW5kZXggNTgyOGMwZmZjM2E0ZDRhYzk3YjYzYTI3MGM4NDczY2ZhZTQzMDZkMi4u YmExMjk5MTEwYzM4YzQwNjY5MTdlNzJkOGNjZjQyMzBiNDIwNzVjNSAxMDA2NDQKLS0tIGEvVG9v bHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIw LTAyLTI0ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIFVzaW5n IENGUnVuTG9vcFNvdXJjZTEgZm9yIGZhc3RlciB0YXNrIGRpc3BhdGNoCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQKKyAgICAgICAgPHJkYXI6 Ly9wcm9ibGVtLzU2Mzg3MjA1PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFVzZSBvYnNlcnZlciBpbiB0ZXN0IHJ1bm5lciB0byBhdm9pZCBzdGFydmF0 aW9uIHByb2JsZW0gaW4gPHJkYXI6Ly9wcm9ibGVtLzU5NjM3OTI1Pi4KKworICAgICAgICAqIFRl c3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW06CisgICAgICAgIChUZXN0V2ViS2l0 QVBJOjpVdGlsOjpydW5DYWxsYmFjayk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpVdGlsOjpy dW4pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VXRpbDo6c3BpblJ1bkxvb3BDYWxsYmFjayk6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpVdGlsOjpzcGluUnVuTG9vcCk6CisKIDIwMjAtMDIt MjQgIEVsbGllIEVwc2thbXAtSHVudCAgPGVlcHNrYW1waHVudEBhcHBsZS5jb20+CiAKICAgICAg ICAgUHJvdmlkZSBhbHRlcm5hdGUgd2F5IHRvIG5hbWUgV2ViIENvbnRlbnQgcHJvY2VzcwpkaWZm IC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9jb2NvYS9VdGlsaXRpZXNDb2NvYS5tbSBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0KaW5kZXggMmM4Zjk1MmNl NWEzODE3NzdmNDZhMDEwYTU2ZmU5NjA0MjEzNDUwYS4uNDk5MjUzYmU3ZGQyMTMyNDY0YjgwOGYw MzRjMTViYTVhZjBhMzlhOCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9jb2NvYS9V dGlsaXRpZXNDb2NvYS5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGll c0NvY29hLm1tCkBAIC0yOSwxNiArMjksNDUgQEAKIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsK IG5hbWVzcGFjZSBVdGlsIHsKIAorc3RhdGljIHZvaWQgcnVuQ2FsbGJhY2soQ0ZSdW5Mb29wT2Jz ZXJ2ZXJSZWYgb2JzZXJ2ZXIsIENGUnVuTG9vcEFjdGl2aXR5IGFjdGl2aXR5LCB2b2lkKiBpbmZv KQoreworICAgIGJvb2wmIGRvbmUgPSAqKHN0YXRpY19jYXN0PGJvb2wqPihpbmZvKSk7CisgICAg aWYgKGRvbmUpCisgICAgICAgIENGUnVuTG9vcFN0b3AoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpKTsK K30KKwogdm9pZCBydW4oYm9vbCogZG9uZSkKIHsKLSAgICB3aGlsZSAoISpkb25lKQotICAgICAg ICBbW05TUnVuTG9vcCBjdXJyZW50UnVuTG9vcF0gcnVuTW9kZTpOU0RlZmF1bHRSdW5Mb29wTW9k ZSBiZWZvcmVEYXRlOltOU0RhdGUgZGlzdGFudFBhc3RdXTsKKyAgICBDRlJ1bkxvb3BPYnNlcnZl ckNvbnRleHQgY29udGV4dCA9IHsgMCwgZG9uZSwgMCwgMCwgMCB9OworICAgIENGUnVuTG9vcE9i c2VydmVyUmVmIG9ic2VydmVyID0gQ0ZSdW5Mb29wT2JzZXJ2ZXJDcmVhdGUoMCwga0NGUnVuTG9v cEJlZm9yZVRpbWVycywgdHJ1ZSwgMCwgcnVuQ2FsbGJhY2ssICZjb250ZXh0KTsKKyAgICBDRlJ1 bkxvb3BBZGRPYnNlcnZlcihDRlJ1bkxvb3BHZXRDdXJyZW50KCksIG9ic2VydmVyLCBrQ0ZSdW5M b29wRGVmYXVsdE1vZGUpOworICAgIENGUnVuTG9vcFJ1bigpOworICAgIENGUnVuTG9vcFJlbW92 ZU9ic2VydmVyKENGUnVuTG9vcEdldEN1cnJlbnQoKSwgb2JzZXJ2ZXIsIGtDRlJ1bkxvb3BEZWZh dWx0TW9kZSk7CisgICAgQ0ZSZWxlYXNlKG9ic2VydmVyKTsKK30KKworc3RhdGljIHZvaWQgc3Bp blJ1bkxvb3BDYWxsYmFjayhDRlJ1bkxvb3BPYnNlcnZlclJlZiBvYnNlcnZlciwgQ0ZSdW5Mb29w QWN0aXZpdHkgYWN0aXZpdHksIHZvaWQqIGluZm8pCit7CisgICAgdWludDY0X3QmIGNvdW50ID0g KihzdGF0aWNfY2FzdDx1aW50NjRfdCo+KGluZm8pKTsKKyAgICBpZiAoY291bnQpCisgICAgICAg IC0tY291bnQ7CisKKyAgICBpZiAoIWNvdW50KQorICAgICAgICBDRlJ1bkxvb3BTdG9wKENGUnVu TG9vcEdldEN1cnJlbnQoKSk7CiB9CiAKIHZvaWQgc3BpblJ1bkxvb3AodWludDY0X3QgY291bnQp CiB7Ci0gICAgZm9yICh1aW50NjRfdCBpID0gMDsgaSA8IGNvdW50OyArK2kpCi0gICAgICAgIFtb TlNSdW5Mb29wIGN1cnJlbnRSdW5Mb29wXSBydW5Nb2RlOk5TRGVmYXVsdFJ1bkxvb3BNb2RlIGJl Zm9yZURhdGU6W05TRGF0ZSBkaXN0YW50UGFzdF1dOworICAgIC8vIE1ha2Ugc3VyZSBHQ0QgcG9y dCB3aWxsIGJlIGhhbmRsZWQuIFNlZSA8cmRhcjovL3Byb2JsZW0vNTk2Mzc5MjU+LgorICAgIGlm IChjb3VudCA8IDIpCisgICAgICAgIGNvdW50ID0gMjsKKworICAgIENGUnVuTG9vcE9ic2VydmVy Q29udGV4dCBjb250ZXh0ID0geyAwLCAmY291bnQsIDAsIDAsIDAgfTsKKyAgICBDRlJ1bkxvb3BP YnNlcnZlclJlZiBvYnNlcnZlciA9IENGUnVuTG9vcE9ic2VydmVyQ3JlYXRlKDAsIGtDRlJ1bkxv b3BCZWZvcmVUaW1lcnMsIHRydWUsIDAsIHNwaW5SdW5Mb29wQ2FsbGJhY2ssICZjb250ZXh0KTsK KyAgICBDRlJ1bkxvb3BBZGRPYnNlcnZlcihDRlJ1bkxvb3BHZXRDdXJyZW50KCksIG9ic2VydmVy LCBrQ0ZSdW5Mb29wRGVmYXVsdE1vZGUpOworICAgIENGUnVuTG9vcFJ1bigpOworICAgIENGUnVu TG9vcFJlbW92ZU9ic2VydmVyKENGUnVuTG9vcEdldEN1cnJlbnQoKSwgb2JzZXJ2ZXIsIGtDRlJ1 bkxvb3BEZWZhdWx0TW9kZSk7CisgICAgQ0ZSZWxlYXNlKG9ic2VydmVyKTsKIH0KIAogdm9pZCBz bGVlcChkb3VibGUgc2Vjb25kcykK 391705 2020-02-25 17:10:17 -0800 2020-11-13 11:54:51 -0800 Patch bug-202874-20200225171017.patch text/plain 11052 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3Mzk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDY5MWE1YjcwOWVlZWQyOWEwMDNlMDAx OThhZjMwMTEwZGU4MDljOTAuLjI0OGY0NmJmNzllMzM1OGJlZjhjOTFmYjQ5OGE4M2FkYzgxYjE5 YjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMjAtMDItMjUgIFNpaHVpIExpdSAgPHNpaHVpX2xp dUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZSdW5Mb29wU291cmNlMSBmb3IgZmFzdGVy IHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjg3NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTYzODcyMDU+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVXNlIG9ic2VydmVyIGlu IHRlc3QgcnVubmVyIHRvIGF2b2lkIHN0YXJ2YXRpb24gcHJvYmxlbSBpbiA8cmRhcjovL3Byb2Js ZW0vNTk2Mzc5MjU+LgorCisgICAgICAgICogd3RmL1J1bkxvb3AuY3BwOgorICAgICAgICAoV1RG OjpSdW5Mb29wOjppbml0aWFsaXplV2ViUnVuTG9vcCk6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6 OndlYik6CisgICAgICAgICogd3RmL1J1bkxvb3AuaDoKKyAgICAgICAgKiB3dGYvY2YvUnVuTG9v cENGLmNwcDoKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6cGVyZm9ybVdvcmspOgorICAgICAgICAo V1RGOjpSdW5Mb29wOjpSdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6flJ1bkxvb3Ap OgorICAgICAgICAoV1RGOjpSdW5Mb29wOjp3YWtlVXApOgorICAgICAgICAqIHd0Zi9jb2NvYS9N YWluVGhyZWFkQ29jb2EubW06CisgICAgICAgIChXVEY6OmluaXRpYWxpemVNYWluVGhyZWFkUGxh dGZvcm0pOgorICAgICAgICAoV1RGOjpzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhy ZWFkKToKKyAgICAgICAgKFdURjo6aW5pdGlhbGl6ZVdlYlRocmVhZCk6CisgICAgICAgICgtW0pT V1RGTWFpblRocmVhZENhbGxlciBjYWxsXSk6IERlbGV0ZWQuCisKIDIwMjAtMDItMjUgIFBoaWxp cHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtXUEVdIEVuYWJs ZSBCQUNLVFJBQ0VfU1lNQk9MUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUnVuTG9vcC5j cHAgYi9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAppbmRleCBhMGEyOGU4MjJjNGE5YzMyNGEy ZjVhY2Y1MTJmMjJiYzZiM2E1OTVmLi45ZjFhMTNhODAyOWY5N2Y1ZTNiNzNhMDZlZWMzOWZhNmNm YWQwYWQ1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAorKysgYi9Tb3Vy Y2UvV1RGL3d0Zi9SdW5Mb29wLmNwcApAQCAtMzMsNiArMzMsOSBAQAogbmFtZXNwYWNlIFdURiB7 CiAKIHN0YXRpYyBSdW5Mb29wKiBzX21haW5SdW5Mb29wOworI2lmIFVTRShXRUJfVEhSRUFEKQor c3RhdGljIFJ1bkxvb3AqIHNfd2ViUnVuTG9vcDsKKyNlbmRpZgogCiAvLyBIZWxwZXIgY2xhc3Mg Zm9yIFRocmVhZFNwZWNpZmljRGF0YS4KIGNsYXNzIFJ1bkxvb3A6OkhvbGRlciB7CkBAIC02OSw2 ICs3MiwxOSBAQCBSdW5Mb29wJiBSdW5Mb29wOjptYWluKCkKICAgICByZXR1cm4gKnNfbWFpblJ1 bkxvb3A7CiB9CiAKKyNpZiBVU0UoV0VCX1RIUkVBRCkKK3ZvaWQgUnVuTG9vcDo6aW5pdGlhbGl6 ZVdlYlJ1bkxvb3AoKQoreworICAgIHNfd2ViUnVuTG9vcCA9ICZSdW5Mb29wOjpjdXJyZW50KCk7 Cit9CisKK1J1bkxvb3AmIFJ1bkxvb3A6OndlYigpCit7CisgICAgQVNTRVJUKHNfd2ViUnVuTG9v cCk7CisgICAgcmV0dXJuICpzX3dlYlJ1bkxvb3A7Cit9CisjZW5kaWYKKwogYm9vbCBSdW5Mb29w Ojppc01haW4oKQogewogICAgIEFTU0VSVChzX21haW5SdW5Mb29wKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL1J1bkxvb3AuaCBiL1NvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAppbmRleCBh Mzk1YjM2ZTk1NjBkZWFiMjUyNTk5OTMxZjBjNmY0NjRhNmVjNDE4Li41ZjNhM2ZkYzRjYmJiMDQ1 OWI3NGFkYjhjNzBmNjI1YWNmMWYyNTk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SdW5M b29wLmgKKysrIGIvU291cmNlL1dURi93dGYvUnVuTG9vcC5oCkBAIC02MSw5ICs2MSwxNSBAQCBw dWJsaWM6CiAgICAgLy8gTXVzdCBiZSBjYWxsZWQgZnJvbSB0aGUgbWFpbiB0aHJlYWQgKGV4Y2Vw dCBmb3IgdGhlIE1hYyBwbGF0Zm9ybSwgd2hlcmUgaXQKICAgICAvLyBjYW4gYmUgY2FsbGVkIGZy b20gYW55IHRocmVhZCkuCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyB2b2lkIGluaXRp YWxpemVNYWluUnVuTG9vcCgpOworI2lmIFVTRShXRUJfVEhSRUFEKQorICAgIFdURl9FWFBPUlRf UFJJVkFURSBzdGF0aWMgdm9pZCBpbml0aWFsaXplV2ViUnVuTG9vcCgpOworI2VuZGlmCiAKICAg ICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIGN1cnJlbnQoKTsKICAgICBXVEZf RVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIG1haW4oKTsKKyNpZiBVU0UoV0VCX1RIUkVB RCkKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIFJ1bkxvb3AmIHdlYigpOworI2VuZGlm CiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBib29sIGlzTWFpbigpOwogICAgIH5SdW5M b29wKCk7CiAKQEAgLTE5NCw5ICsyMDAsMTAgQEAgcHJpdmF0ZToKIAogICAgIExvY2sgbV9sb29w TG9jazsKICNlbGlmIFVTRShDT0NPQV9FVkVOVF9MT09QKQotICAgIHN0YXRpYyB2b2lkIHBlcmZv cm1Xb3JrKHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVm LCB2b2lkKiBtc2csIENGSW5kZXggc2l6ZSwgdm9pZCogaW5mbyk7CiAgICAgUmV0YWluUHRyPENG UnVuTG9vcFJlZj4gbV9ydW5Mb29wOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BTb3VyY2VSZWY+ IG1fcnVuTG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZNYWNoUG9ydFJlZj4gbV9wb3J0Owog I2VsaWYgVVNFKEdMSUJfRVZFTlRfTE9PUCkKICAgICBHUmVmUHRyPEdNYWluQ29udGV4dD4gbV9t YWluQ29udGV4dDsKICAgICBWZWN0b3I8R1JlZlB0cjxHTWFpbkxvb3A+PiBtX21haW5Mb29wczsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAgYi9Tb3VyY2UvV1RG L3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCmluZGV4IGE1N2Y3YTJlZDE1ZTQyODc1YzMzZTVhMWM2ZmM3 NTUwOThiYTg5Y2EuLjRkYWU4NTA5MWUxNWE2NTM2YWE3OGZhMmZmNmI2ZWRjNWU5ZGE1ZDIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKKysrIGIvU291cmNlL1dU Ri93dGYvY2YvUnVuTG9vcENGLmNwcApAQCAtMjgsMjYgKzI4LDI5IEBACiAKICNpbmNsdWRlIDxD b3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNoL2Rpc3Bh dGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9kcmFpbmVk UG9vbC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAotdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2 b2lkKiBjb250ZXh0KQordm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVmLCB2 b2lkKiwgQ0ZJbmRleCwgdm9pZCogaW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wgcG9vbDsK LSAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7CisgICAg c3RhdGljX2Nhc3Q8UnVuTG9vcCo+KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBSdW5Mb29w OjpSdW5Mb29wKCkKICAgICA6IG1fcnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpCiB7Ci0g ICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAwLCAwLCAw LCAwLCAwLCAwLCBwZXJmb3JtV29yayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0Yo Q0ZSdW5Mb29wU291cmNlQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250ZXh0KSk7 CisgICAgQ0ZNYWNoUG9ydENvbnRleHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0ciwgbnVs bHB0ciwgbnVsbHB0ciB9OworICAgIG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0ZShr Q0ZBbGxvY2F0b3JEZWZhdWx0LCBwZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIpKTsKKyAg ICBtX3J1bkxvb3BTb3VyY2UgPSBhZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29wU291cmNl KGtDRkFsbG9jYXRvckRlZmF1bHQsIG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVuTG9vcEFk ZFNvdXJjZShtX3J1bkxvb3AuZ2V0KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NGUnVuTG9v cENvbW1vbk1vZGVzKTsKIH0KIAogUnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENGTWFjaFBv cnRJbnZhbGlkYXRlKG1fcG9ydC5nZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52YWxpZGF0 ZShtX3J1bkxvb3BTb3VyY2UuZ2V0KCkpOwogfQogCkBAIC01OCw4ICs2MSwxNiBAQCB2b2lkIFJ1 bkxvb3A6OnJ1bkZvckR1cmF0aW9uKFNlY29uZHMgZHVyYXRpb24pCiAKIHZvaWQgUnVuTG9vcDo6 d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291cmNlLmdl dCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBtYWNoX21z Z19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNHSF9CSVRT KE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXplID0gc2l6 ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9ydCA9IENG TWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9jYWxfcG9y dCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBtYWNoX21z Z19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNHIHwgTUFD SF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxMLCAwLCBN QUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hfTVNHX1NV Q0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChyZXN1bHQg PT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgmaGVhZGVy KTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoUnVuTG9vcE1vZGUg bW9kZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5t bSBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL01haW5UaHJlYWRDb2NvYS5tbQppbmRleCA3NDY0Njhk NTc1OTI1MzM0OTJmNTc4M2FiYzkxYjYxMmI0NTJjZWJkLi5jZTI5YTJjNjk1YWRhNzEwYmMxOTVj MDdmNjIzZDQxZGJiNDA3ZTAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWlu VGhyZWFkQ29jb2EubW0KKysrIGIvU291cmNlL1dURi93dGYvY29jb2EvTWFpblRocmVhZENvY29h Lm1tCkBAIC0zNiw2ICszNiw3IEBACiAjaW1wb3J0IDx3dGYvQXNzZXJ0aW9ucy5oPgogI2ltcG9y dCA8d3RmL0hhc2hTZXQuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0 Zi9SdW5Mb29wLmg+CiAjaW1wb3J0IDx3dGYvU2NoZWR1bGVQYWlyLmg+CiAjaW1wb3J0IDx3dGYv VGhyZWFkaW5nLmg+CiAKQEAgLTQzLDE5ICs0NCw2IEBACiAjaW5jbHVkZSA8d3RmL2lvcy9XZWJD b3JlVGhyZWFkLmg+CiAjZW5kaWYKIAotQGludGVyZmFjZSBKU1dURk1haW5UaHJlYWRDYWxsZXIg OiBOU09iamVjdAotLSAodm9pZCljYWxsOwotQGVuZAotCi1AaW1wbGVtZW50YXRpb24gSlNXVEZN YWluVGhyZWFkQ2FsbGVyCi0KLS0gKHZvaWQpY2FsbAotewotICAgIFdURjo6ZGlzcGF0Y2hGdW5j dGlvbnNGcm9tTWFpblRocmVhZCgpOwotfQotCi1AZW5kCi0KICNkZWZpbmUgTE9HX0NIQU5ORUxf UFJFRklYIExvZwogCiBuYW1lc3BhY2UgV1RGIHsKQEAgLTY2LDggKzU0LDYgQEAgV1RGTG9nQ2hh bm5lbCBMb2dUaHJlYWRpbmcgPSB7IFdURkxvZ0NoYW5uZWxTdGF0ZTo6T24sICJUaHJlYWRpbmci LCBXVEZMb2dMZXZlbDoKIFdURkxvZ0NoYW5uZWwgTG9nVGhyZWFkaW5nID0geyBXVEZMb2dDaGFu bmVsU3RhdGU6Ok9uLCAiVGhyZWFkaW5nIiwgV1RGTG9nTGV2ZWw6OkVycm9yLCBMT0dfQ0hBTk5F TF9XRUJLSVRfU1VCU1lTVEVNLCBPU19MT0dfREVGQVVMVCB9OwogI2VuZGlmCiAKLQotc3RhdGlj IEpTV1RGTWFpblRocmVhZENhbGxlciogc3RhdGljTWFpblRocmVhZENhbGxlcjsKIHN0YXRpYyBi b29sIGlzVGltZXJQb3N0ZWQ7IC8vIFRoaXMgaXMgb25seSBhY2Nlc3NlZCBvbiB0aGUgbWFpbiB0 aHJlYWQuCiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKQEAgLTg0LDkgKzcwLDYgQEAgdm9pZCBpbml0 aWFsaXplTWFpblRocmVhZFBsYXRmb3JtKCkKICAgICBpZiAoIXB0aHJlYWRfbWFpbl9ucCgpKQog ICAgICAgICBSRUxFQVNFX0xPR19GQVVMVChUaHJlYWRpbmcsICJXZWJLaXQgVGhyZWFkaW5nIFZp b2xhdGlvbiAtIGluaXRpYWwgdXNlIG9mIFdlYktpdCBmcm9tIGEgc2Vjb25kYXJ5IHRocmVhZC4i KTsKICAgICBBU1NFUlQocHRocmVhZF9tYWluX25wKCkpOwotCi0gICAgQVNTRVJUKCFzdGF0aWNN YWluVGhyZWFkQ2FsbGVyKTsKLSAgICBzdGF0aWNNYWluVGhyZWFkQ2FsbGVyID0gW1tKU1dURk1h aW5UaHJlYWRDYWxsZXIgYWxsb2NdIGluaXRdOwogfQogCiBzdGF0aWMgdm9pZCB0aW1lckZpcmVk KENGUnVuTG9vcFRpbWVyUmVmIHRpbWVyLCB2b2lkKikKQEAgLTExMiw4ICs5NSw2IEBAIHN0YXRp YyB2b2lkIHBvc3RUaW1lcigpCiAKIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFp blRocmVhZCgpCiB7Ci0gICAgQVNTRVJUKHN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwotICAgIAog I2lmIFVTRShXRUJfVEhSRUFEKQogICAgIGlmIChpc1dlYlRocmVhZCgpKSB7CiAgICAgICAgIHBv c3RUaW1lcigpOwpAQCAtMTIxLDcgKzEwMiw5IEBAIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0 aW9uc09uTWFpblRocmVhZCgpCiAgICAgfQogCiAgICAgaWYgKG1haW5UaHJlYWRQdGhyZWFkKSB7 Ci0gICAgICAgIFtzdGF0aWNNYWluVGhyZWFkQ2FsbGVyIHBlcmZvcm1TZWxlY3RvcjpAc2VsZWN0 b3IoY2FsbCkgb25UaHJlYWQ6bWFpblRocmVhZE5TVGhyZWFkIHdpdGhPYmplY3Q6bmlsIHdhaXRV bnRpbERvbmU6Tk9dOworICAgICAgICBSdW5Mb29wOjp3ZWIoKS5kaXNwYXRjaChbXSB7CisgICAg ICAgICAgICBXVEY6OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKKyAgICAgICAg fSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAjZWxzZQpAQCAtMTMxLDcgKzExNCw5IEBAIHZv aWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiAgICAgfQogI2VuZGlm CiAKLSAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBwZXJmb3JtU2VsZWN0b3JPbk1haW5UaHJl YWQ6QHNlbGVjdG9yKGNhbGwpIHdpdGhPYmplY3Q6bmlsIHdhaXRVbnRpbERvbmU6Tk9dOworICAg IFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbXSB7CisgICAgICAgIFdURjo6ZGlzcGF0Y2hGdW5j dGlvbnNGcm9tTWFpblRocmVhZCgpOworICAgIH0pOwogfQogCiB2b2lkIGRpc3BhdGNoQXN5bmNP bk1haW5UaHJlYWRXaXRoV2ViVGhyZWFkTG9ja0lmTmVlZGVkKHZvaWQgKF5ibG9jaykoKSkKQEAg LTE5Niw2ICsxODEsNyBAQCB2b2lkIGluaXRpYWxpemVXZWJUaHJlYWQoKQogICAgICAgICBtYWlu VGhyZWFkUHRocmVhZCA9IHB0aHJlYWRfc2VsZigpOwogICAgICAgICBtYWluVGhyZWFkTlNUaHJl YWQgPSBbTlNUaHJlYWQgY3VycmVudFRocmVhZF07CiAgICAgICAgIHNXZWJUaHJlYWQgPSAmVGhy ZWFkOjpjdXJyZW50KCk7CisgICAgICAgIFJ1bkxvb3A6OmluaXRpYWxpemVXZWJSdW5Mb29wKCk7 CiAgICAgfSk7CiB9CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZwppbmRleCA3M2E0NzZhNjhlMmU0OWMwZmU2NGYyMDk0OTllZmU4ZGIwYjRlZmYxLi41M2U3 ZDE2NWYzZWUyNTI0YjEwNzg2OWJkMzljNGYzNzIwMzM1Zjk4IDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDIt MjUgIFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5jb20+CisKKyAgICAgICAgVXNpbmcgQ0ZS dW5Mb29wU291cmNlMSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorICAgICAgICA8cmRhcjovL3By b2JsZW0vNTYzODcyMDU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1V0aWxpdGllcy5oOgorICAgICAgICAqIFRlc3RXZWJL aXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW06CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpV dGlsOjpydW4pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VXRpbDo6c3BpblJ1bkxvb3BDYWxs YmFjayk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpVdGlsOjpzcGluUnVuTG9vcCk6CisKIDIw MjAtMDItMjUgIE1hdHQgTGV3aXMgIDxqbGV3aXMzQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQg Y2hlY2tvdXRfcm9vdCB0byBzdHVicmVwb3NpdG9yeS5weQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9VdGlsaXRpZXMuaCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVXRpbGl0aWVzLmgK aW5kZXggMWRmMWUxNDQxYzEwYzJmM2I4ZjA4YjE4N2RkNmE2MDBlYjc2NDdmYi4uMTNkMzAxNjJi MTI1ZGFlMTIzZjQzZjVmM2M0YTMxNGY5ZjZlOTdhZSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdl YktpdEFQSS9VdGlsaXRpZXMuaAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1V0aWxpdGllcy5o CkBAIC0zMiw3ICszMiw3IEBAIG5hbWVzcGFjZSBVdGlsIHsKIHZvaWQgcnVuKGJvb2wqIGRvbmUp OwogCiAvLyBSdW5zIGEgcGxhdGZvcm0gcnVubG9vcCBgY291bnRgIG51bWJlciBvZiBzcGlucy4K LXZvaWQgc3BpblJ1bkxvb3AodWludDY0X3QgY291bnQgPSAxKTsKK3ZvaWQgc3BpblJ1bkxvb3Ao dWludDY0X3QgY291bnQgPSAyKTsKIAogLy8gUnVucyBhIHBsYXRmb3JtIHJ1bmxvb3AgdW50aWwg dGhlIGFtb3VudCBvZiBzZWNvbmRzIGhhcyBwYXNzZWQuCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNv bmRzKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29j b2EubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29hLm1tCmluZGV4 IDJjOGY5NTJjZTVhMzgxNzc3ZjQ2YTAxMGE1NmZlOTYwNDIxMzQ1MGEuLjgzNWM1MTY1MDM4OWMx Y2JmNzBiOGNlNmQ4ODc0NDE2ZjFmN2YzZGMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0KKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9jb2Nv YS9VdGlsaXRpZXNDb2NvYS5tbQpAQCAtMzIsMTMgKzMyLDMzIEBAIG5hbWVzcGFjZSBVdGlsIHsK IHZvaWQgcnVuKGJvb2wqIGRvbmUpCiB7CiAgICAgd2hpbGUgKCEqZG9uZSkKLSAgICAgICAgW1tO U1J1bkxvb3AgY3VycmVudFJ1bkxvb3BdIHJ1bk1vZGU6TlNEZWZhdWx0UnVuTG9vcE1vZGUgYmVm b3JlRGF0ZTpbTlNEYXRlIGRpc3RhbnRQYXN0XV07CisgICAgICAgIHNwaW5SdW5Mb29wKCk7Cit9 CisKK3N0YXRpYyB2b2lkIHNwaW5SdW5Mb29wQ2FsbGJhY2soQ0ZSdW5Mb29wT2JzZXJ2ZXJSZWYg b2JzZXJ2ZXIsIENGUnVuTG9vcEFjdGl2aXR5IGFjdGl2aXR5LCB2b2lkKiBpbmZvKQoreworICAg IHVpbnQ2NF90JiBjb3VudCA9ICooc3RhdGljX2Nhc3Q8dWludDY0X3QqPihpbmZvKSk7CisgICAg aWYgKGNvdW50KQorICAgICAgICAtLWNvdW50OworCisgICAgaWYgKCFjb3VudCkKKyAgICAgICAg Q0ZSdW5Mb29wU3RvcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpOworCisgICAgQ0ZSdW5Mb29wV2Fr ZVVwKENGUnVuTG9vcEdldEN1cnJlbnQoKSk7CiB9CiAKIHZvaWQgc3BpblJ1bkxvb3AodWludDY0 X3QgY291bnQpCiB7Ci0gICAgZm9yICh1aW50NjRfdCBpID0gMDsgaSA8IGNvdW50OyArK2kpCi0g ICAgICAgIFtbTlNSdW5Mb29wIGN1cnJlbnRSdW5Mb29wXSBydW5Nb2RlOk5TRGVmYXVsdFJ1bkxv b3BNb2RlIGJlZm9yZURhdGU6W05TRGF0ZSBkaXN0YW50UGFzdF1dOworICAgIC8vIE1ha2Ugc3Vy ZSBHQ0QgcG9ydCB3aWxsIGJlIGhhbmRsZWQgd2l0aCBhdCBsZWFzdCAyIHBhc3MuIFNlZSA8cmRh cjovL3Byb2JsZW0vNTk2Mzc5MjU+LgorICAgIGlmIChjb3VudCA8IDIpCisgICAgICAgIGNvdW50 ID0gMjsKKworICAgIENGUnVuTG9vcE9ic2VydmVyQ29udGV4dCBjb250ZXh0ID0geyAwLCAmY291 bnQsIDAsIDAsIDAgfTsKKyAgICBDRlJ1bkxvb3BPYnNlcnZlclJlZiBvYnNlcnZlciA9IENGUnVu TG9vcE9ic2VydmVyQ3JlYXRlKDAsIGtDRlJ1bkxvb3BCZWZvcmVUaW1lcnMsIHRydWUsIDAsIHNw aW5SdW5Mb29wQ2FsbGJhY2ssICZjb250ZXh0KTsKKyAgICBDRlJ1bkxvb3BBZGRPYnNlcnZlcihD RlJ1bkxvb3BHZXRDdXJyZW50KCksIG9ic2VydmVyLCBrQ0ZSdW5Mb29wRGVmYXVsdE1vZGUpOwor ICAgIENGUnVuTG9vcFJ1bigpOworICAgIENGUnVuTG9vcFJlbW92ZU9ic2VydmVyKENGUnVuTG9v cEdldEN1cnJlbnQoKSwgb2JzZXJ2ZXIsIGtDRlJ1bkxvb3BEZWZhdWx0TW9kZSk7CisgICAgQ0ZS ZWxlYXNlKG9ic2VydmVyKTsKIH0KIAogdm9pZCBzbGVlcChkb3VibGUgc2Vjb25kcykK 401478 2020-06-09 14:57:17 -0700 2020-06-10 12:50:25 -0700 Patch - just the RunLoop parts ro.txt text/plain 5353 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjI4MTMpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDI5IEBACisyMDIwLTA2LTA5ICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIENGUnVuTG9vcFNvdXJjZTEgZm9yIGZhc3Rl ciB0YXNrIGRpc3BhdGNoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMDI4NzQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU2Mzg3MjA1PgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBhdGNoIGJ5IFNpaHVp IExpdS4KKworICAgICAgICBUaGlzIGlzIGp1c3QgdGhlIHBhcnQgb2YgU2lodWkncyBwYXRjaCB0 aGF0IHVuaWZpZXMgc29tZSBvZiBSdW5Mb29wIGFuZAorICAgICAgICBjYWxsT25NYWluVGhyZWFk LCB3aXRob3V0IHN3aXRjaGluZyB0byBDRlJ1bkxvb3BTb3VyY2UxIHlldC4KKworICAgICAgICBN eSBnb2FsIGlzIHRvIHNpbXBsaWZ5IHRoZSBjb2RlLCBhbmQgc2hyaW5rIHRoZSBkaWZmIHdoZW4g dGVzdGluZworICAgICAgICBDRlJ1bkxvb3BTb3VyY2UxIGluIHRoZSBmdXR1cmUuCisKKyAgICAg ICAgKiB3dGYvUnVuTG9vcC5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OmluaXRpYWxpemVX ZWJSdW5Mb29wKToKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6d2ViKToKKyAgICAgICAgKiB3dGYv UnVuTG9vcC5oOgorICAgICAgICAqIHd0Zi9jb2NvYS9NYWluVGhyZWFkQ29jb2EubW06CisgICAg ICAgIChXVEY6OmluaXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0pOgorICAgICAgICAoV1RGOjpz Y2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFkKToKKyAgICAgICAgKFdURjo6aW5p dGlhbGl6ZVdlYlRocmVhZCk6CisgICAgICAgICgtW0pTV1RGTWFpblRocmVhZENhbGxlciBjYWxs XSk6IERlbGV0ZWQuCisKIDIwMjAtMDYtMDkgIFBlciBBcm5lIFZvbGxhbiAgPHB2b2xsYW5AYXBw bGUuY29tPgogCiAgICAgICAgIEFsbCBwbGF0Zm9ybXMgc2hvdWxkIGVuYWJsZSBDRlByZWZzIHJl YWQgb25seSBtb2RlIGluIHRoZSBXZWJDb250ZW50IHByb2Nlc3MKSW5kZXg6IFNvdXJjZS9XVEYv d3RmL1J1bkxvb3AuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuY3Bw CShyZXZpc2lvbiAyNjI4MTEpCisrKyBTb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMzMsNiArMzMsOSBAQAogbmFtZXNwYWNlIFdURiB7CiAKIHN0YXRpYyBSdW5M b29wKiBzX21haW5SdW5Mb29wOworI2lmIFVTRShXRUJfVEhSRUFEKQorc3RhdGljIFJ1bkxvb3Aq IHNfd2ViUnVuTG9vcDsKKyNlbmRpZgogCiAvLyBIZWxwZXIgY2xhc3MgZm9yIFRocmVhZFNwZWNp ZmljRGF0YS4KIGNsYXNzIFJ1bkxvb3A6OkhvbGRlciB7CkBAIC02OSw2ICs3MiwxOSBAQCBSdW5M b29wJiBSdW5Mb29wOjptYWluKCkKICAgICByZXR1cm4gKnNfbWFpblJ1bkxvb3A7CiB9CiAKKyNp ZiBVU0UoV0VCX1RIUkVBRCkKK3ZvaWQgUnVuTG9vcDo6aW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKQor eworICAgIHNfd2ViUnVuTG9vcCA9ICZSdW5Mb29wOjpjdXJyZW50KCk7Cit9CisKK1J1bkxvb3Am IFJ1bkxvb3A6OndlYigpCit7CisgICAgQVNTRVJUKHNfd2ViUnVuTG9vcCk7CisgICAgcmV0dXJu ICpzX3dlYlJ1bkxvb3A7Cit9CisjZW5kaWYKKwogYm9vbCBSdW5Mb29wOjppc01haW4oKQogewog ICAgIEFTU0VSVChzX21haW5SdW5Mb29wKTsKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL1J1bkxvb3Au aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgJKHJldmlzaW9uIDI2Mjgx MSkKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkod29ya2luZyBjb3B5KQpAQCAtNjEsOSAr NjEsMTUgQEAgcHVibGljOgogICAgIC8vIE11c3QgYmUgY2FsbGVkIGZyb20gdGhlIG1haW4gdGhy ZWFkIChleGNlcHQgZm9yIHRoZSBNYWMgcGxhdGZvcm0sIHdoZXJlIGl0CiAgICAgLy8gY2FuIGJl IGNhbGxlZCBmcm9tIGFueSB0aHJlYWQpLgogICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMg dm9pZCBpbml0aWFsaXplTWFpblJ1bkxvb3AoKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBX VEZfRVhQT1JUX1BSSVZBVEUgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZVdlYlJ1bkxvb3AoKTsKKyNl bmRpZgogCiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiBjdXJyZW50KCk7 CiAgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiBtYWluKCk7CisjaWYgVVNF KFdFQl9USFJFQUQpCisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyBSdW5Mb29wJiB3ZWIo KTsKKyNlbmRpZgogICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgYm9vbCBpc01haW4oKTsK ICAgICB+UnVuTG9vcCgpIGZpbmFsOwogCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9jb2NvYS9NYWlu VGhyZWFkQ29jb2EubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvY29jb2EvTWFpblRo cmVhZENvY29hLm1tCShyZXZpc2lvbiAyNjI4MTEpCisrKyBTb3VyY2UvV1RGL3d0Zi9jb2NvYS9N YWluVGhyZWFkQ29jb2EubW0JKHdvcmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBv cnQgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW1wb3J0IDx3dGYvSGFzaFNldC5oPgogI2ltcG9ydCA8 d3RmL1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL1J1bkxvb3AuaD4KICNpbXBvcnQgPHd0Zi9T Y2hlZHVsZVBhaXIuaD4KICNpbXBvcnQgPHd0Zi9UaHJlYWRpbmcuaD4KIApAQCAtNDMsMTkgKzQ0 LDYgQEAKICNpbXBvcnQgPHd0Zi9pb3MvV2ViQ29yZVRocmVhZC5oPgogI2VuZGlmCiAKLUBpbnRl cmZhY2UgSlNXVEZNYWluVGhyZWFkQ2FsbGVyIDogTlNPYmplY3QKLS0gKHZvaWQpY2FsbDsKLUBl bmQKLQotQGltcGxlbWVudGF0aW9uIEpTV1RGTWFpblRocmVhZENhbGxlcgotCi0tICh2b2lkKWNh bGwKLXsKLSAgICBXVEY6OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1haW5UaHJlYWQoKTsKLX0KLQot QGVuZAotCiAjZGVmaW5lIExPR19DSEFOTkVMX1BSRUZJWCBMb2cKIAogbmFtZXNwYWNlIFdURiB7 CkBAIC02Niw4ICs1NCw2IEBAIFdURkxvZ0NoYW5uZWwgTG9nVGhyZWFkaW5nID0geyBXVEZMb2dD aGEKIFdURkxvZ0NoYW5uZWwgTG9nVGhyZWFkaW5nID0geyBXVEZMb2dDaGFubmVsU3RhdGU6Ok9u LCAiVGhyZWFkaW5nIiwgV1RGTG9nTGV2ZWw6OkVycm9yLCBMT0dfQ0hBTk5FTF9XRUJLSVRfU1VC U1lTVEVNLCBPU19MT0dfREVGQVVMVCB9OwogI2VuZGlmCiAKLQotc3RhdGljIEpTV1RGTWFpblRo cmVhZENhbGxlciogc3RhdGljTWFpblRocmVhZENhbGxlcjsKIHN0YXRpYyBib29sIGlzVGltZXJQ b3N0ZWQ7IC8vIFRoaXMgaXMgb25seSBhY2Nlc3NlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCiAKICNp ZiBVU0UoV0VCX1RIUkVBRCkKQEAgLTg0LDkgKzcwLDYgQEAgdm9pZCBpbml0aWFsaXplTWFpblRo cmVhZFBsYXRmb3JtKCkKICAgICBpZiAoIXB0aHJlYWRfbWFpbl9ucCgpKQogICAgICAgICBSRUxF QVNFX0xPR19GQVVMVChUaHJlYWRpbmcsICJXZWJLaXQgVGhyZWFkaW5nIFZpb2xhdGlvbiAtIGlu aXRpYWwgdXNlIG9mIFdlYktpdCBmcm9tIGEgc2Vjb25kYXJ5IHRocmVhZC4iKTsKICAgICBBU1NF UlQocHRocmVhZF9tYWluX25wKCkpOwotCi0gICAgQVNTRVJUKCFzdGF0aWNNYWluVGhyZWFkQ2Fs bGVyKTsKLSAgICBzdGF0aWNNYWluVGhyZWFkQ2FsbGVyID0gW1tKU1dURk1haW5UaHJlYWRDYWxs ZXIgYWxsb2NdIGluaXRdOwogfQogCiBzdGF0aWMgdm9pZCB0aW1lckZpcmVkKENGUnVuTG9vcFRp bWVyUmVmIHRpbWVyLCB2b2lkKikKQEAgLTExMiw4ICs5NSw2IEBAIHN0YXRpYyB2b2lkIHBvc3RU aW1lcigpCiAKIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCiB7 Ci0gICAgQVNTRVJUKHN0YXRpY01haW5UaHJlYWRDYWxsZXIpOwotICAgIAogI2lmIFVTRShXRUJf VEhSRUFEKQogICAgIGlmIChpc1dlYlRocmVhZCgpKSB7CiAgICAgICAgIHBvc3RUaW1lcigpOwpA QCAtMTIxLDcgKzEwMiw5IEBAIHZvaWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRo cmUKICAgICB9CiAKICAgICBpZiAobWFpblRocmVhZFB0aHJlYWQpIHsKLSAgICAgICAgW3N0YXRp Y01haW5UaHJlYWRDYWxsZXIgcGVyZm9ybVNlbGVjdG9yOkBzZWxlY3RvcihjYWxsKSBvblRocmVh ZDptYWluVGhyZWFkTlNUaHJlYWQgd2l0aE9iamVjdDpuaWwgd2FpdFVudGlsRG9uZTpOT107Cisg ICAgICAgIFJ1bkxvb3A6OndlYigpLmRpc3BhdGNoKFtdIHsKKyAgICAgICAgICAgIFdURjo6ZGlz cGF0Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOworICAgICAgICB9KTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KICNlbHNlCkBAIC0xMzEsNyArMTE0LDkgQEAgdm9pZCBzY2hlZHVsZURpc3Bh dGNoRnVuY3Rpb25zT25NYWluVGhyZQogICAgIH0KICNlbmRpZgogCi0gICAgW3N0YXRpY01haW5U aHJlYWRDYWxsZXIgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihjYWxsKSB3 aXRoT2JqZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKKyAgICBSdW5Mb29wOjptYWluKCkuZGlz cGF0Y2goW10geworICAgICAgICBXVEY6OmRpc3BhdGNoRnVuY3Rpb25zRnJvbU1haW5UaHJlYWQo KTsKKyAgICB9KTsKIH0KIAogdm9pZCBkaXNwYXRjaEFzeW5jT25NYWluVGhyZWFkV2l0aFdlYlRo cmVhZExvY2tJZk5lZWRlZCh2b2lkICheYmxvY2spKCkpCkBAIC0xOTYsNiArMTgxLDcgQEAgdm9p ZCBpbml0aWFsaXplV2ViVGhyZWFkKCkKICAgICAgICAgbWFpblRocmVhZFB0aHJlYWQgPSBwdGhy ZWFkX3NlbGYoKTsKICAgICAgICAgbWFpblRocmVhZE5TVGhyZWFkID0gW05TVGhyZWFkIGN1cnJl bnRUaHJlYWRdOwogICAgICAgICBzV2ViVGhyZWFkID0gJlRocmVhZDo6Y3VycmVudCgpOworICAg ICAgICBSdW5Mb29wOjppbml0aWFsaXplV2ViUnVuTG9vcCgpOwogICAgIH0pOwogfQogCg== 414072 2020-11-13 11:54:53 -0800 2020-11-13 12:09:33 -0800 Patch bug-202874-20201113115452.patch text/plain 4290 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjk3ODYpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBACisyMDIwLTExLTEzICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVuTG9vcFNvdXJj ZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFRoaXMgcGVyZm9ybWFuY2UgYm90dGxlbmVjayBzaG93ZWQgdXAg aW4gSW5kZXhlZERCLiBXZSB3b3JrZWQgYXJvdW5kIGl0CisgICAgICAgIGJ5IHN3aXRjaGluZyB0 byBXb3JrUXVldWVNZXNzYWdlUmVjZWl2ZXIuIE5vdyBpdCdzIHNob3dpbmcgdXAgYWdhaW4KKyAg ICAgICAgaW4gdGhlIEdQVSBQcm9jZXNzLgorCisgICAgICAgICogd3RmL1J1bkxvb3AuaDogQWRk ZWQgYSBtYWNoIHBvcnQuIFdlIHVzZSB0aGlzIGZvciB3YWtlLXVwLgorCisgICAgICAgICogd3Rm L2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKTog VXNlIHRoZSBzdGFuZGFyZCBkZWNsYXJhdGlvbiBmb3IgYQorICAgICAgICBWZXJzaW9uIDEgcnVu IGxvb3Agc291cmNlIGNhbGxiYWNrLgorCisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1bkxvb3Ap OiBVc2UgYSBkdW1teSBtYWNoIHBvcnQgZm9yIHdha2UtdXBzLiBUaGUgZGVmYXVsdAorICAgICAg ICB3YWtlLXVwIG1lY2hhbmlzbSB1c2VzIHB0aHJlYWQgQVBJcywgd2hpY2ggY29zdCBodW5kcmVk cyBvZiBtaWNyb3NlY29uZHMKKyAgICAgICAgcGVyIGludm9jYXRpb24sIGV2ZW4gb24gdGhlIG1v c3QgbW9kZXJuIGhhcmR3YXJlLiBJbiBjb250cmFzdCwgYSBtYWNoCisgICAgICAgIG1lc3NhZ2Ug dGFrZXMgYWJvdXQgbmluZSBtaWNyb3NlY29uZHMuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 flJ1bkxvb3ApOiBGcmVlIHRoZSBtYWNoIHBvcnQuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 d2FrZVVwKTogQ29weS1wYXN0ZWQgY29kZSB0byBzaWduYWwgYSBtYWNoIHBvcnQuIFRoZQorICAg ICAgICBtZXNzYWdlIHBheWxvYWQgZG9lc24ndCBtYXR0ZXIgYmVjYXVzZSB3ZSdyZSBqdXN0IHRy eWluZyB0byBhY2hpZXZlCisgICAgICAgIGEgd2FrZXVwLCBraW5kIG9mIGxpa2UgY2FsbGluZyBh IHZvaWQoKSBmdW5jdGlvbi4KKwogMjAyMC0xMS0xMiAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIHVudXNlZCBhZHZhbmNlZCBwbHVnLWluIGZlYXR1cmVz OiBzbmFwc2hvdHRpbmcgYW5kIHBsdWctaW4gbG9hZCBwb2xpY3kKSW5kZXg6IFNvdXJjZS9XVEYv d3RmL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgJKHJl dmlzaW9uIDI2OTc0NykKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkod29ya2luZyBjb3B5 KQpAQCAtMjI1LDkgKzIyNSwxMCBAQCBwcml2YXRlOgogCiAgICAgTG9jayBtX2xvb3BMb2NrOwog I2VsaWYgVVNFKENPQ09BX0VWRU5UX0xPT1ApCi0gICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmso dm9pZCopOworICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQq IG1zZywgQ0ZJbmRleCBzaXplLCB2b2lkKiBpbmZvKTsKICAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29w UmVmPiBtX3J1bkxvb3A7CiAgICAgUmV0YWluUHRyPENGUnVuTG9vcFNvdXJjZVJlZj4gbV9ydW5M b29wU291cmNlOworICAgIFJldGFpblB0cjxDRk1hY2hQb3J0UmVmPiBtX3BvcnQ7CiAjZWxpZiBV U0UoR0xJQl9FVkVOVF9MT09QKQogICAgIHZvaWQgbm90aWZ5KEV2ZW50LCBjb25zdCBjaGFyKik7 CiAKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAkocmV2aXNpb24gMjY5NzQ3KQorKysgU291 cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDAsMjkgKzQw LDM5IEBAIHN0YXRpYyBSZXRhaW5QdHI8Q0ZSdW5Mb29wVGltZXJSZWY+IGNyZWEKICAgICByZXR1 cm4gYWRvcHRDRihDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBDRkFi c29sdXRlVGltZUdldEN1cnJlbnQoKSArIGludGVydmFsLnNlY29uZHMoKSwgcmVwZWF0SW50ZXJ2 YWwuc2Vjb25kcygpLCAwLCAwLCB0aW1lckZpcmVkLCAmY29udGV4dCkpOwogfQogCi12b2lkIFJ1 bkxvb3A6OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6OnBlcmZvcm1X b3JrKENGTWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQogewogICAgIEF1 dG9kcmFpbmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihjb250ZXh0KS0+ cGVyZm9ybVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbyktPnBlcmZvcm1X b3JrKCk7CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29wKENGUnVuTG9v cEdldEN1cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNvbnRleHQgPSB7 IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0gICAgbV9ydW5M b29wU291cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxsb2NhdG9yRGVm YXVsdCwgMCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250ZXh0ID0geyAw LCB0aGlzLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0ID0gYWRvcHRD RihDRk1hY2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1Xb3JrLCAmY29u dGV4dCwgbnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0YoQ0ZNYWNoUG9y dENyZWF0ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0LmdldCgpLCAw KSk7CiAgICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9ydW5Mb29wU291 cmNlLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29wOjp+UnVuTG9v cCgpCiB7CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsKICAgICBDRlJ1 bkxvb3BTb3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9CiAKIHZvaWQg UnVuTG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29w U291cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAg ICBtYWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hf TVNHSF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9z aXplID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVf cG9ydCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hf bG9jYWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAg ICBtYWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRf TVNHIHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9O VUxMLCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1B Q0hfTVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlm IChyZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJv eSgmaGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoUnVu TG9vcE1vZGUgbW9kZSkK 414073 2020-11-13 12:00:26 -0800 2020-11-16 12:17:56 -0800 Patch bug-202874-20201113120025.patch text/plain 4477 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjk3ODYpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBACisyMDIwLTExLTEzICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVuTG9vcFNvdXJj ZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFRoaXMgcGVyZm9ybWFuY2UgYm90dGxlbmVjayBzaG93ZWQgdXAg aW4gSW5kZXhlZERCLiBXZSB3b3JrZWQgYXJvdW5kIGl0CisgICAgICAgIGJ5IHN3aXRjaGluZyB0 byBXb3JrUXVldWVNZXNzYWdlUmVjZWl2ZXIuIE5vdyBpdCdzIHNob3dpbmcgdXAgYWdhaW4KKyAg ICAgICAgaW4gdGhlIEdQVSBQcm9jZXNzLgorCisgICAgICAgICogd3RmL1J1bkxvb3AuaDogQWRk ZWQgYSBtYWNoIHBvcnQuIFdlIHVzZSB0aGlzIGZvciB3YWtlLXVwLgorCisgICAgICAgICogd3Rm L2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKTog VXNlIHRoZSBzdGFuZGFyZCBkZWNsYXJhdGlvbiBmb3IgYQorICAgICAgICBWZXJzaW9uIDEgcnVu IGxvb3Agc291cmNlIGNhbGxiYWNrLgorCisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1bkxvb3Ap OiBVc2UgYSBkdW1teSBtYWNoIHBvcnQgZm9yIHdha2UtdXBzLiBUaGUgZGVmYXVsdAorICAgICAg ICB3YWtlLXVwIG1lY2hhbmlzbSB1c2VzIHB0aHJlYWQgQVBJcywgd2hpY2ggY29zdCBodW5kcmVk cyBvZiBtaWNyb3NlY29uZHMKKyAgICAgICAgcGVyIGludm9jYXRpb24sIGV2ZW4gb24gdGhlIG1v c3QgbW9kZXJuIGhhcmR3YXJlLiBJbiBjb250cmFzdCwgYSBtYWNoCisgICAgICAgIG1lc3NhZ2Ug dGFrZXMgYWJvdXQgbmluZSBtaWNyb3NlY29uZHMuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 flJ1bkxvb3ApOiBGcmVlIHRoZSBtYWNoIHBvcnQuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 d2FrZVVwKTogQ29weS1wYXN0ZWQgY29kZSB0byBzaWduYWwgYSBtYWNoIHBvcnQuIFRoZQorICAg ICAgICBtZXNzYWdlIHBheWxvYWQgZG9lc24ndCBtYXR0ZXIgYmVjYXVzZSB3ZSdyZSBqdXN0IHRy eWluZyB0byBhY2hpZXZlCisgICAgICAgIGEgd2FrZXVwLCBraW5kIG9mIGxpa2UgY2FsbGluZyBh IHZvaWQoKSBmdW5jdGlvbi4KKwogMjAyMC0xMS0xMiAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIHVudXNlZCBhZHZhbmNlZCBwbHVnLWluIGZlYXR1cmVz OiBzbmFwc2hvdHRpbmcgYW5kIHBsdWctaW4gbG9hZCBwb2xpY3kKSW5kZXg6IFNvdXJjZS9XVEYv d3RmL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9SdW5Mb29wLmgJKHJl dmlzaW9uIDI2OTc0NykKKysrIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkod29ya2luZyBjb3B5 KQpAQCAtMjI1LDkgKzIyNSwxMCBAQCBwcml2YXRlOgogCiAgICAgTG9jayBtX2xvb3BMb2NrOwog I2VsaWYgVVNFKENPQ09BX0VWRU5UX0xPT1ApCi0gICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmso dm9pZCopOworICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQq IG1zZywgQ0ZJbmRleCBzaXplLCB2b2lkKiBpbmZvKTsKICAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29w UmVmPiBtX3J1bkxvb3A7CiAgICAgUmV0YWluUHRyPENGUnVuTG9vcFNvdXJjZVJlZj4gbV9ydW5M b29wU291cmNlOworICAgIFJldGFpblB0cjxDRk1hY2hQb3J0UmVmPiBtX3BvcnQ7CiAjZWxpZiBV U0UoR0xJQl9FVkVOVF9MT09QKQogICAgIHZvaWQgbm90aWZ5KEV2ZW50LCBjb25zdCBjaGFyKik7 CiAKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL2NmL1J1bkxvb3BDRi5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAkocmV2aXNpb24gMjY5NzQ3KQorKysgU291 cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgsNiArMjgs NyBAQAogCiAjaW5jbHVkZSA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KICNpbmNs dWRlIDxkaXNwYXRjaC9kaXNwYXRjaC5oPgorI2luY2x1ZGUgPG1hY2gvbWFjaC5oPgogI2luY2x1 ZGUgPHd0Zi9BdXRvZHJhaW5lZFBvb2wuaD4KICNpbmNsdWRlIDx3dGYvU2NoZWR1bGVQYWlyLmg+ CiAKQEAgLTQwLDI5ICs0MSwzOSBAQCBzdGF0aWMgUmV0YWluUHRyPENGUnVuTG9vcFRpbWVyUmVm PiBjcmVhCiAgICAgcmV0dXJuIGFkb3B0Q0YoQ0ZSdW5Mb29wVGltZXJDcmVhdGUoa0NGQWxsb2Nh dG9yRGVmYXVsdCwgQ0ZBYnNvbHV0ZVRpbWVHZXRDdXJyZW50KCkgKyBpbnRlcnZhbC5zZWNvbmRz KCksIHJlcGVhdEludGVydmFsLnNlY29uZHMoKSwgMCwgMCwgdGltZXJGaXJlZCwgJmNvbnRleHQp KTsKIH0KIAotdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lkKiBjb250ZXh0KQordm9pZCBS dW5Mb29wOjpwZXJmb3JtV29yayhDRk1hY2hQb3J0UmVmLCB2b2lkKiwgQ0ZJbmRleCwgdm9pZCog aW5mbykKIHsKICAgICBBdXRvZHJhaW5lZFBvb2wgcG9vbDsKLSAgICBzdGF0aWNfY2FzdDxSdW5M b29wKj4oY29udGV4dCktPnBlcmZvcm1Xb3JrKCk7CisgICAgc3RhdGljX2Nhc3Q8UnVuTG9vcCo+ KGluZm8pLT5wZXJmb3JtV29yaygpOwogfQogCiBSdW5Mb29wOjpSdW5Mb29wKCkKICAgICA6IG1f cnVuTG9vcChDRlJ1bkxvb3BHZXRDdXJyZW50KCkpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNlQ29u dGV4dCBjb250ZXh0ID0geyAwLCB0aGlzLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBwZXJmb3JtV29y ayB9OwotICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0YoQ0ZSdW5Mb29wU291cmNlQ3JlYXRl KGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZjb250ZXh0KSk7CisgICAgQ0ZNYWNoUG9ydENvbnRl eHQgY29udGV4dCA9IHsgMCwgdGhpcywgbnVsbHB0ciwgbnVsbHB0ciwgbnVsbHB0ciB9OworICAg IG1fcG9ydCA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBw ZXJmb3JtV29yaywgJmNvbnRleHQsIG51bGxwdHIpKTsKKyAgICBtX3J1bkxvb3BTb3VyY2UgPSBh ZG9wdENGKENGTWFjaFBvcnRDcmVhdGVSdW5Mb29wU291cmNlKGtDRkFsbG9jYXRvckRlZmF1bHQs IG1fcG9ydC5nZXQoKSwgMCkpOwogICAgIENGUnVuTG9vcEFkZFNvdXJjZShtX3J1bkxvb3AuZ2V0 KCksIG1fcnVuTG9vcFNvdXJjZS5nZXQoKSwga0NGUnVuTG9vcENvbW1vbk1vZGVzKTsKIH0KIAog UnVuTG9vcDo6flJ1bkxvb3AoKQogeworICAgIENGTWFjaFBvcnRJbnZhbGlkYXRlKG1fcG9ydC5n ZXQoKSk7CiAgICAgQ0ZSdW5Mb29wU291cmNlSW52YWxpZGF0ZShtX3J1bkxvb3BTb3VyY2UuZ2V0 KCkpOwogfQogCiB2b2lkIFJ1bkxvb3A6Ondha2VVcCgpCiB7Ci0gICAgQ0ZSdW5Mb29wU291cmNl U2lnbmFsKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7Ci0gICAgQ0ZSdW5Mb29wV2FrZVVwKG1fcnVu TG9vcC5nZXQoKSk7CisgICAgbWFjaF9tc2dfaGVhZGVyX3QgaGVhZGVyOworICAgIGhlYWRlci5t c2doX2JpdHMgPSBNQUNIX01TR0hfQklUUyhNQUNIX01TR19UWVBFX0NPUFlfU0VORCwgMCk7Cisg ICAgaGVhZGVyLm1zZ2hfc2l6ZSA9IHNpemVvZihtYWNoX21zZ19oZWFkZXJfdCk7CisgICAgaGVh ZGVyLm1zZ2hfcmVtb3RlX3BvcnQgPSBDRk1hY2hQb3J0R2V0UG9ydChtX3BvcnQuZ2V0KCkpOwor ICAgIGhlYWRlci5tc2doX2xvY2FsX3BvcnQgPSBNQUNIX1BPUlRfTlVMTDsKKyAgICBoZWFkZXIu bXNnaF9pZCA9IDA7CisgICAgbWFjaF9tc2dfcmV0dXJuX3QgcmVzdWx0ID0gbWFjaF9tc2coJmhl YWRlciwgTUFDSF9TRU5EX01TRyB8IE1BQ0hfU0VORF9USU1FT1VULCBoZWFkZXIubXNnaF9zaXpl LCAwLCBNQUNIX1BPUlRfTlVMTCwgMCwgTUFDSF9QT1JUX05VTEwpOworICAgIFJFTEVBU0VfQVNT RVJUKHJlc3VsdCA9PSBNQUNIX01TR19TVUNDRVNTIHx8IHJlc3VsdCA9PSBNQUNIX1NFTkRfVElN RURfT1VUKTsKKyAgICBpZiAocmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpCisgICAgICAg IG1hY2hfbXNnX2Rlc3Ryb3koJmhlYWRlcik7CiB9CiAKIFJ1bkxvb3A6OkN5Y2xlUmVzdWx0IFJ1 bkxvb3A6OmN5Y2xlKFJ1bkxvb3BNb2RlIG1vZGUpCg== 414266 2020-11-16 12:17:58 -0800 2020-11-16 20:40:25 -0800 Patch bug-202874-20201116121758.patch text/plain 8004 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjk4MDMpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBACisyMDIwLTExLTEzICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVuTG9vcFNvdXJj ZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFRoaXMgcGVyZm9ybWFuY2UgYm90dGxlbmVjayBzaG93ZWQgdXAg aW4gSW5kZXhlZERCLiBXZSB3b3JrZWQgYXJvdW5kIGl0CisgICAgICAgIGJ5IHN3aXRjaGluZyB0 byBXb3JrUXVldWVNZXNzYWdlUmVjZWl2ZXIuIE5vdyBpdCdzIHNob3dpbmcgdXAgYWdhaW4KKyAg ICAgICAgaW4gdGhlIEdQVSBQcm9jZXNzLgorCisgICAgICAgICogd3RmL1J1bkxvb3AuaDogQWRk ZWQgYSBtYWNoIHBvcnQuIFdlIHVzZSB0aGlzIGZvciB3YWtlLXVwLgorCisgICAgICAgICogd3Rm L2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKTog VXNlIHRoZSBzdGFuZGFyZCBkZWNsYXJhdGlvbiBmb3IgYQorICAgICAgICBWZXJzaW9uIDEgcnVu IGxvb3Agc291cmNlIGNhbGxiYWNrLgorCisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1bkxvb3Ap OiBVc2UgYSBkdW1teSBtYWNoIHBvcnQgZm9yIHdha2UtdXBzLiBUaGUgZGVmYXVsdAorICAgICAg ICB3YWtlLXVwIG1lY2hhbmlzbSB1c2VzIHB0aHJlYWQgQVBJcywgd2hpY2ggY29zdCBodW5kcmVk cyBvZiBtaWNyb3NlY29uZHMKKyAgICAgICAgcGVyIGludm9jYXRpb24sIGV2ZW4gb24gdGhlIG1v c3QgbW9kZXJuIGhhcmR3YXJlLiBJbiBjb250cmFzdCwgYSBtYWNoCisgICAgICAgIG1lc3NhZ2Ug dGFrZXMgYWJvdXQgbmluZSBtaWNyb3NlY29uZHMuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 flJ1bkxvb3ApOiBGcmVlIHRoZSBtYWNoIHBvcnQuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 d2FrZVVwKTogQ29weS1wYXN0ZWQgY29kZSB0byBzaWduYWwgYSBtYWNoIHBvcnQuIFRoZQorICAg ICAgICBtZXNzYWdlIHBheWxvYWQgZG9lc24ndCBtYXR0ZXIgYmVjYXVzZSB3ZSdyZSBqdXN0IHRy eWluZyB0byBhY2hpZXZlCisgICAgICAgIGEgd2FrZXVwLCBraW5kIG9mIGxpa2UgY2FsbGluZyBh IHZvaWQoKSBmdW5jdGlvbi4KKwogMjAyMC0xMS0xMyAgWGFuIEzDs3BleiAgPHhhbkBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtKU0NdIFVzZSBzeW1ib2xzIGFzIGlkZW50aWZpZXJzIGZvciBjbGFz cyBmaWVsZHMgY29tcHV0ZWQgbmFtZXMgc3RvcmFnZQpJbmRleDogU291cmNlL1dURi93dGYvUnVu TG9vcC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkocmV2aXNpb24g MjY5ODAzKQorKysgU291cmNlL1dURi93dGYvUnVuTG9vcC5oCSh3b3JraW5nIGNvcHkpCkBAIC0y MjUsOSArMjI1LDEwIEBAIHByaXZhdGU6CiAKICAgICBMb2NrIG1fbG9vcExvY2s7CiAjZWxpZiBV U0UoQ09DT0FfRVZFTlRfTE9PUCkKLSAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayh2b2lkKik7 CisgICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJlZiwgdm9pZCogbXNnLCBD RkluZGV4IHNpemUsIHZvaWQqIGluZm8pOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BSZWY+IG1f cnVuTG9vcDsKICAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29wU291cmNlUmVmPiBtX3J1bkxvb3BTb3Vy Y2U7CisgICAgUmV0YWluUHRyPENGTWFjaFBvcnRSZWY+IG1fcG9ydDsKICNlbGlmIFVTRShHTElC X0VWRU5UX0xPT1ApCiAgICAgdm9pZCBub3RpZnkoRXZlbnQsIGNvbnN0IGNoYXIqKTsKIApJbmRl eDogU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCShyZXZpc2lvbiAyNjk4MDMpCisrKyBTb3VyY2UvV1RG L3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw2ICsyOCw3IEBACiAK ICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRp c3BhdGNoL2Rpc3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3Rm L0F1dG9kcmFpbmVkUG9vbC5oPgogI2luY2x1ZGUgPHd0Zi9TY2hlZHVsZVBhaXIuaD4KIApAQCAt NDAsMjkgKzQxLDM5IEBAIHN0YXRpYyBSZXRhaW5QdHI8Q0ZSdW5Mb29wVGltZXJSZWY+IGNyZWEK ICAgICByZXR1cm4gYWRvcHRDRihDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBDRkFic29sdXRlVGltZUdldEN1cnJlbnQoKSArIGludGVydmFsLnNlY29uZHMoKSwgcmVw ZWF0SW50ZXJ2YWwuc2Vjb25kcygpLCAwLCAwLCB0aW1lckZpcmVkLCAmY29udGV4dCkpOwogfQog Ci12b2lkIFJ1bkxvb3A6OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6 OnBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQog ewogICAgIEF1dG9kcmFpbmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihj b250ZXh0KS0+cGVyZm9ybVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbykt PnBlcmZvcm1Xb3JrKCk7CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29w KENGUnVuTG9vcEdldEN1cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNv bnRleHQgPSB7IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0g ICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxs b2NhdG9yRGVmYXVsdCwgMCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250 ZXh0ID0geyAwLCB0aGlzLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0 ID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1X b3JrLCAmY29udGV4dCwgbnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0Yo Q0ZNYWNoUG9ydENyZWF0ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0 LmdldCgpLCAwKSk7CiAgICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9y dW5Mb29wU291cmNlLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29w Ojp+UnVuTG9vcCgpCiB7CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsK ICAgICBDRlJ1bkxvb3BTb3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9 CiAKIHZvaWQgUnVuTG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwo bV9ydW5Mb29wU291cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdl dCgpKTsKKyAgICBtYWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0 cyA9IE1BQ0hfTVNHSF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFk ZXIubXNnaF9zaXplID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNn aF9yZW1vdGVfcG9ydCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVh ZGVyLm1zZ2hfbG9jYWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lk ID0gMDsKKyAgICBtYWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBN QUNIX1NFTkRfTVNHIHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1B Q0hfUE9SVF9OVUxMLCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVz dWx0ID09IE1BQ0hfTVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQp OworICAgIGlmIChyZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9t c2dfZGVzdHJveSgmaGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6 Y3ljbGUoUnVuTG9vcE1vZGUgbW9kZSkKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2OTg2NykKKysrIFRvb2xzL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMwIEBACisyMDIwLTExLTE2ICBHZW9mZnJleSBH YXJlbiAgPGdnYXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVu TG9vcFNvdXJjZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeGVkIGEgdGVzdCBpbmNvbXBhdGliaWlsdHku CisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NlcnZpY2VXb3Jr ZXJCYXNpYy5tbTogT25seSBzZXQgb3VyCisgICAgICAgIGFzc2VydGlvbiBzdGF0dXMgYmVmb3Jl IGVudGVyaW5nIHRoZSBsb29wLiBUaGF0IHNob3VsZCBiZSBzdWZmaWNpZW50CisgICAgICAgIGZv ciB0ZXN0aW5nLgorCisgICAgICAgIFNldHRpbmcgb3VyIGFzc2VydGlvbiBzdGF0dXMgc2NoZWR1 bGVzIGEgdGFzayBpbiB0aGUgcnVubG9vcC4gU28sIHNldHRpbmcKKyAgICAgICAgdGhlIHN0YXR1 cyBhbmQgdGhlbiBydW5uaW5nIHRoZSBydW4gbG9vcCBleGFjdGx5IG9uY2Ugb25seSBwcm9ncmVz c2VkCisgICAgICAgIHRoZSBydW4gbG9vcCBmYXIgZW5vdWdoIHRvIHNldCB0aGUgc3RhdHVzLCBi dXQgbm90IGZhciBlbm91Z2ggdG8KKyAgICAgICAgcGVyZm9ybSBhbnkgb3RoZXIgd29yayAobGlr ZSByZWZsZWN0aW5nIHRoZSBzdGF0dXMgY2hhbmdlKS4KKworICAgICAgICBJdCdzIGFuIG9kZGl0 eSBvZiBGb3VuZGF0aW9uJ3MgcnVubG9vcCBBUElzIHRoYXQgKGEpIHJ1bm5pbmcgdGhlIHJ1bmxv b3AKKyAgICAgICAgb25seSBydW5zIHVudGlsIGFuIHVuc3BlY2lmaWVkIHN1YnNldCBvZiBzb3Vy Y2VzIGhhdmUgYmVlbiBoYW5kbGVkIGFuZAorICAgICAgICAoYikgc3RhdGljIGltcGxpY3Qgb3Jk ZXJpbmcgYmV0d2VlbiBzb3VyY2VzIGFsbG93cyBvbmUgc291cmNlIHRvIHN0YXJ2ZQorICAgICAg ICBhbm90aGVyLiAoTW9yZSBpbmZvIGluIHJkYXI6Ly9wcm9ibGVtLzU5NjM3OTI1LikgSSBjb25z aWRlcmVkIGNoYW5naW5nCisgICAgICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnNwaW5SdW5Mb29w KCkgb3IgV1RGOjpSdW5Mb29wOjpjeWNsZSgpIHRvIHdvcmsKKyAgICAgICAgYXJvdW5kIHRoaXMs IGJ1dCBzaW5jZSB0aGlzIHRlc3Qgc2VlbWVkIHRvIHRyaWdnZXIgdGhpcyBvZGRpdHkgYnkKKyAg ICAgICAgYWNjaWRlbnQgYW5kIG5vdCBmb3IgYW55IGludGVuZGVkIHB1cnBvc2UsIEkgZGVjaWRl ZCB0byBmaXggdGhlIHRlc3QKKyAgICAgICAgaW5zdGVhZC4KKwogMjAyMC0xMS0xNiAgQ2hyaXMg RHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgogCiAgICAgICAgIEZpeCBzZXZlcmFsIGxlYWtzIG9m IENHQ29udGV4dCBpbiBBUEkgdGVzdHMKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Q29jb2EvU2VydmljZVdvcmtlckJhc2ljLm1tCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvU2VydmljZVdvcmtlckJhc2ljLm1tCShyZXZp c2lvbiAyNjk4MDMpCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1Nl cnZpY2VXb3JrZXJCYXNpYy5tbQkod29ya2luZyBjb3B5KQpAQCAtMTcxNiwyMSArMTcxNiwxNyBA QCB2b2lkIHRlc3RTdXNwZW5kU2VydmljZVdvcmtlclByb2Nlc3NCYXNlCiAgICAgd2ViVmlldyA9 IG51bGxwdHI7CiAKICAgICAvLyBUaGUgc2VydmljZSB3b3JrZXIgcHJvY2VzcyBzaG91bGQgdGFr ZSBhY3Rpdml0eSBiYXNlZCBvbiB3ZWJWaWV3MiBwcm9jZXNzLgotICAgIFt3ZWJWaWV3MiBfc2V0 QXNzZXJ0aW9uVHlwZUZvclRlc3Rpbmc6IDFdOwotICAgIHdoaWxlICh3ZWJWaWV3Mi5nZXQoKS5f aGFzU2VydmljZVdvcmtlckZvcmVncm91bmRBY3Rpdml0eUZvclRlc3RpbmcgfHwgIXdlYlZpZXcy LmdldCgpLl9oYXNTZXJ2aWNlV29ya2VyQmFja2dyb3VuZEFjdGl2aXR5Rm9yVGVzdGluZykgewot ICAgICAgICBbd2ViVmlldzIgX3NldEFzc2VydGlvblR5cGVGb3JUZXN0aW5nOiAxXTsKKyAgICBb d2ViVmlldzIgX3NldEFzc2VydGlvblR5cGVGb3JUZXN0aW5nOiAxXTsgLy8gYmFja2dyb3VuZAor ICAgIHdoaWxlICh3ZWJWaWV3Mi5nZXQoKS5faGFzU2VydmljZVdvcmtlckZvcmVncm91bmRBY3Rp dml0eUZvclRlc3RpbmcgfHwgIXdlYlZpZXcyLmdldCgpLl9oYXNTZXJ2aWNlV29ya2VyQmFja2dy b3VuZEFjdGl2aXR5Rm9yVGVzdGluZykKICAgICAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6c3Bp blJ1bkxvb3AoMSk7Ci0gICAgfQogCi0gICAgd2hpbGUgKCF3ZWJWaWV3Mi5nZXQoKS5faGFzU2Vy dmljZVdvcmtlckZvcmVncm91bmRBY3Rpdml0eUZvclRlc3RpbmcgfHwgd2ViVmlldzIuZ2V0KCku X2hhc1NlcnZpY2VXb3JrZXJCYWNrZ3JvdW5kQWN0aXZpdHlGb3JUZXN0aW5nKSB7Ci0gICAgICAg IFt3ZWJWaWV3MiBfc2V0QXNzZXJ0aW9uVHlwZUZvclRlc3Rpbmc6IDNdOworICAgIFt3ZWJWaWV3 MiBfc2V0QXNzZXJ0aW9uVHlwZUZvclRlc3Rpbmc6IDNdOyAvLyBmb3JlZ3JvdW5kCisgICAgd2hp bGUgKCF3ZWJWaWV3Mi5nZXQoKS5faGFzU2VydmljZVdvcmtlckZvcmVncm91bmRBY3Rpdml0eUZv clRlc3RpbmcgfHwgd2ViVmlldzIuZ2V0KCkuX2hhc1NlcnZpY2VXb3JrZXJCYWNrZ3JvdW5kQWN0 aXZpdHlGb3JUZXN0aW5nKQogICAgICAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpzcGluUnVuTG9v cCgxKTsKLSAgICB9CiAKLSAgICB3aGlsZSAod2ViVmlldzIuZ2V0KCkuX2hhc1NlcnZpY2VXb3Jr ZXJGb3JlZ3JvdW5kQWN0aXZpdHlGb3JUZXN0aW5nIHx8IHdlYlZpZXcyLmdldCgpLl9oYXNTZXJ2 aWNlV29ya2VyQmFja2dyb3VuZEFjdGl2aXR5Rm9yVGVzdGluZykgewotICAgICAgICBbd2ViVmll dzIgX3NldEFzc2VydGlvblR5cGVGb3JUZXN0aW5nOiAwXTsKKyAgICBbd2ViVmlldzIgX3NldEFz c2VydGlvblR5cGVGb3JUZXN0aW5nOiAwXTsgLy8gc3VzcGVuZGVkCisgICAgd2hpbGUgKHdlYlZp ZXcyLmdldCgpLl9oYXNTZXJ2aWNlV29ya2VyRm9yZWdyb3VuZEFjdGl2aXR5Rm9yVGVzdGluZyB8 fCB3ZWJWaWV3Mi5nZXQoKS5faGFzU2VydmljZVdvcmtlckJhY2tncm91bmRBY3Rpdml0eUZvclRl c3RpbmcpCiAgICAgICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnNwaW5SdW5Mb29wKDEpOwotICAg IH0KIH0KIAogVEVTVChTZXJ2aWNlV29ya2VycywgU3VzcGVuZFNlcnZpY2VXb3JrZXJQcm9jZXNz QmFzZWRPbkNsaWVudFByb2Nlc3NlcykK 414303 2020-11-16 20:40:28 -0800 2020-11-20 14:04:48 -0800 Patch bug-202874-20201116204027.patch text/plain 6074 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjk4MDMpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBACisyMDIwLTExLTEzICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVuTG9vcFNvdXJj ZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFRoaXMgcGVyZm9ybWFuY2UgYm90dGxlbmVjayBzaG93ZWQgdXAg aW4gSW5kZXhlZERCLiBXZSB3b3JrZWQgYXJvdW5kIGl0CisgICAgICAgIGJ5IHN3aXRjaGluZyB0 byBXb3JrUXVldWVNZXNzYWdlUmVjZWl2ZXIuIE5vdyBpdCdzIHNob3dpbmcgdXAgYWdhaW4KKyAg ICAgICAgaW4gdGhlIEdQVSBQcm9jZXNzLgorCisgICAgICAgICogd3RmL1J1bkxvb3AuaDogQWRk ZWQgYSBtYWNoIHBvcnQuIFdlIHVzZSB0aGlzIGZvciB3YWtlLXVwLgorCisgICAgICAgICogd3Rm L2NmL1J1bkxvb3BDRi5jcHA6CisgICAgICAgIChXVEY6OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKTog VXNlIHRoZSBzdGFuZGFyZCBkZWNsYXJhdGlvbiBmb3IgYQorICAgICAgICBWZXJzaW9uIDEgcnVu IGxvb3Agc291cmNlIGNhbGxiYWNrLgorCisgICAgICAgIChXVEY6OlJ1bkxvb3A6OlJ1bkxvb3Ap OiBVc2UgYSBkdW1teSBtYWNoIHBvcnQgZm9yIHdha2UtdXBzLiBUaGUgZGVmYXVsdAorICAgICAg ICB3YWtlLXVwIG1lY2hhbmlzbSB1c2VzIHB0aHJlYWQgQVBJcywgd2hpY2ggY29zdCBodW5kcmVk cyBvZiBtaWNyb3NlY29uZHMKKyAgICAgICAgcGVyIGludm9jYXRpb24sIGV2ZW4gb24gdGhlIG1v c3QgbW9kZXJuIGhhcmR3YXJlLiBJbiBjb250cmFzdCwgYSBtYWNoCisgICAgICAgIG1lc3NhZ2Ug dGFrZXMgYWJvdXQgbmluZSBtaWNyb3NlY29uZHMuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 flJ1bkxvb3ApOiBGcmVlIHRoZSBtYWNoIHBvcnQuCisKKyAgICAgICAgKFdURjo6UnVuTG9vcDo6 d2FrZVVwKTogQ29weS1wYXN0ZWQgY29kZSB0byBzaWduYWwgYSBtYWNoIHBvcnQuIFRoZQorICAg ICAgICBtZXNzYWdlIHBheWxvYWQgZG9lc24ndCBtYXR0ZXIgYmVjYXVzZSB3ZSdyZSBqdXN0IHRy eWluZyB0byBhY2hpZXZlCisgICAgICAgIGEgd2FrZXVwLCBraW5kIG9mIGxpa2UgY2FsbGluZyBh IHZvaWQoKSBmdW5jdGlvbi4KKwogMjAyMC0xMS0xMyAgWGFuIEzDs3BleiAgPHhhbkBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtKU0NdIFVzZSBzeW1ib2xzIGFzIGlkZW50aWZpZXJzIGZvciBjbGFz cyBmaWVsZHMgY29tcHV0ZWQgbmFtZXMgc3RvcmFnZQpJbmRleDogU291cmNlL1dURi93dGYvUnVu TG9vcC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkocmV2aXNpb24g MjY5ODAzKQorKysgU291cmNlL1dURi93dGYvUnVuTG9vcC5oCSh3b3JraW5nIGNvcHkpCkBAIC0y MjUsOSArMjI1LDEwIEBAIHByaXZhdGU6CiAKICAgICBMb2NrIG1fbG9vcExvY2s7CiAjZWxpZiBV U0UoQ09DT0FfRVZFTlRfTE9PUCkKLSAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayh2b2lkKik7 CisgICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJlZiwgdm9pZCogbXNnLCBD RkluZGV4IHNpemUsIHZvaWQqIGluZm8pOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BSZWY+IG1f cnVuTG9vcDsKICAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29wU291cmNlUmVmPiBtX3J1bkxvb3BTb3Vy Y2U7CisgICAgUmV0YWluUHRyPENGTWFjaFBvcnRSZWY+IG1fcG9ydDsKICNlbGlmIFVTRShHTElC X0VWRU5UX0xPT1ApCiAgICAgdm9pZCBub3RpZnkoRXZlbnQsIGNvbnN0IGNoYXIqKTsKIApJbmRl eDogU291cmNlL1dURi93dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCShyZXZpc2lvbiAyNjk4MDMpCisrKyBTb3VyY2UvV1RG L3d0Zi9jZi9SdW5Mb29wQ0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw2ICsyOCw3IEBACiAK ICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRp c3BhdGNoL2Rpc3BhdGNoLmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3Rm L0F1dG9kcmFpbmVkUG9vbC5oPgogI2luY2x1ZGUgPHd0Zi9TY2hlZHVsZVBhaXIuaD4KIApAQCAt NDAsMjkgKzQxLDM5IEBAIHN0YXRpYyBSZXRhaW5QdHI8Q0ZSdW5Mb29wVGltZXJSZWY+IGNyZWEK ICAgICByZXR1cm4gYWRvcHRDRihDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBDRkFic29sdXRlVGltZUdldEN1cnJlbnQoKSArIGludGVydmFsLnNlY29uZHMoKSwgcmVw ZWF0SW50ZXJ2YWwuc2Vjb25kcygpLCAwLCAwLCB0aW1lckZpcmVkLCAmY29udGV4dCkpOwogfQog Ci12b2lkIFJ1bkxvb3A6OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6 OnBlcmZvcm1Xb3JrKENGTWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQog ewogICAgIEF1dG9kcmFpbmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihj b250ZXh0KS0+cGVyZm9ybVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbykt PnBlcmZvcm1Xb3JrKCk7CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29w KENGUnVuTG9vcEdldEN1cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNv bnRleHQgPSB7IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0g ICAgbV9ydW5Mb29wU291cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxs b2NhdG9yRGVmYXVsdCwgMCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250 ZXh0ID0geyAwLCB0aGlzLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0 ID0gYWRvcHRDRihDRk1hY2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1X b3JrLCAmY29udGV4dCwgbnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0Yo Q0ZNYWNoUG9ydENyZWF0ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0 LmdldCgpLCAwKSk7CiAgICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9y dW5Mb29wU291cmNlLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29w Ojp+UnVuTG9vcCgpCiB7CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsK ICAgICBDRlJ1bkxvb3BTb3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9 CiAKIHZvaWQgUnVuTG9vcDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwo bV9ydW5Mb29wU291cmNlLmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdl dCgpKTsKKyAgICBtYWNoX21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0 cyA9IE1BQ0hfTVNHSF9CSVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFk ZXIubXNnaF9zaXplID0gc2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNn aF9yZW1vdGVfcG9ydCA9IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVh ZGVyLm1zZ2hfbG9jYWxfcG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lk ID0gMDsKKyAgICBtYWNoX21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBN QUNIX1NFTkRfTVNHIHwgTUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1B Q0hfUE9SVF9OVUxMLCAwLCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVz dWx0ID09IE1BQ0hfTVNHX1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQp OworICAgIGlmIChyZXN1bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9t c2dfZGVzdHJveSgmaGVhZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6 Y3ljbGUoUnVuTG9vcE1vZGUgbW9kZSkKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2OTg5MikKKysrIFRvb2xzL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIxIEBACisyMDIwLTExLTE2ICBHZW9mZnJleSBH YXJlbiAgPGdnYXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVXNlIGEgVmVyc2lvbiAxIENGUnVu TG9vcFNvdXJjZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjg3NAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeGVkIGEgdGVzdCBpbmNvbXBhdGliaWlsdHku CisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29hLm1tOgorICAg ICAgICAoVGVzdFdlYktpdEFQSTo6VXRpbDo6c3BpblJ1bkxvb3ApOiBCZSBzdXJlIHRvIHJ1biB0 aGUgcnVubG9vcCB1bnRpbAorICAgICAgICBpdCBydW5zIG91dCBvZiBzb3VyY2VzIHRvIGhhbmRs ZS4KKworICAgICAgICBUaGUgU3VzcGVuZFNlcnZpY2VXb3JrZXJQcm9jZXNzQmFzZWRPbkNsaWVu dFByb2Nlc3NlcyB0ZXN0IGludm9rZXMKKyAgICAgICAgc3BpblJ1bkxvb3Agd2hpbGUgYWRkaW5n IGl0ZW1zIHRvIHRoZSBydW5sb29wLiBVbmRlciB0aG9zZSBjb25kaXRpb25zLAorICAgICAgICB3 aGV0aGVyIGEgZ2l2ZW4gc291cmNlIHdpbGwgZmlyZSBvciBub3QgaW4gYSBzaW5nbGUgaW52b2Nh dGlvbiBvZgorICAgICAgICBDRlJ1bkxvb3BSdW5Jbk1vZGUgaXMgdW5kZWZpbmVkIGJlaGF2aW9y LgorCiAyMDIwLTExLTE2ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNvbT4KIAog ICAgICAgICBbd2Via2l0c2NtcHldIEdlbmVyYWxpemUgcGFydHMgb2YgbG9jYWwuU2NtIGNsYXNz CkluZGV4OiBUb29scy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29hLm1tCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0JKHJl dmlzaW9uIDI2OTgwMykKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29j b2EubW0JKHdvcmtpbmcgY29weSkKQEAgLTM4LDcgKzM4LDcgQEAgdm9pZCBydW4oYm9vbCogZG9u ZSkKIHZvaWQgc3BpblJ1bkxvb3AodWludDY0X3QgY291bnQpCiB7CiAgICAgZm9yICh1aW50NjRf dCBpID0gMDsgaSA8IGNvdW50OyArK2kpCi0gICAgICAgIFtbTlNSdW5Mb29wIGN1cnJlbnRSdW5M b29wXSBydW5Nb2RlOk5TRGVmYXVsdFJ1bkxvb3BNb2RlIGJlZm9yZURhdGU6W05TRGF0ZSBkaXN0 YW50UGFzdF1dOworICAgICAgICB3aGlsZSAoQ0ZSdW5Mb29wUnVuSW5Nb2RlKGtDRlJ1bkxvb3BE ZWZhdWx0TW9kZSwgMCwgdHJ1ZSkgPT0ga0NGUnVuTG9vcFJ1bkhhbmRsZWRTb3VyY2UpIHsgfQog fQogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKQo= 414710 2020-11-20 13:28:14 -0800 2020-11-20 13:28:14 -0800 microbenchmark Scratch.zip application/zip 41230 ggaren UEsDBBQAAAAAABprdFEAAAAAAAAAAAAAAAAIACAAU2NyYXRjaC9VVA0AByU0uF8nNLhfJzS4X3V4 CwABBPUBAAAEFAAAAFBLAwQUAAgACAAaa3RRAAAAAAAAAADSAAAAEgAgAF9fTUFDT1NYLy5fU2Ny YXRjaFVUDQAHJTS4Xyc0uF8+NLhfdXgLAAEE9QEAAAQUAAAAY2AVY2dgYmDwTUxW8A9WiFCAApAY AycQGwHxAiAG8S8xEAUcQ0KCoEyQjhVArIWmhBEhrpKcn6uXWFCQk6qXm1qSmJJYkmgVn+3r4lmS mhtanFoUkphezMCQVJCTWVxiYLCAA2oAI5JJyIATAFBLBwiW3gKobQAAANIAAABQSwMEFAAAAAAA 2pFzUQAAAAAAAAAAAAAAABoAIABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL1VUDQAHnCa3X5wm t19pKLdfdXgLAAEE9QEAAAQUAAAAUEsDBBQACAAIANqRc1EAAAAAAAAAALAAAAAkACAAX19NQUNP U1gvU2NyYXRjaC8uX1NjcmF0Y2gueGNvZGVwcm9qVVQNAAecJrdfnCa3Xz40uF91eAsAAQT1AQAA BBQAAABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAXEdEIP4GxiQgAIDLuAYEhIEZYJ0LABiATQl jAhxqeT8XL3EgoKcVL2cxOKS0uLUlJTEklTlgGCQwkyN7fEgWqi8RwdEAwBQSwcIZzN3uWAAAACw AAAAUEsDBBQAAAAAABlrdFEAAAAAAAAAAAAAAAAQACAAU2NyYXRjaC9TY3JhdGNoL1VUDQAHIzS4 XyQ0uF8kNLhfdXgLAAEE9QEAAAQUAAAAUEsDBBQACAAIABlrdFEAAAAAAAAAANIAAAAaACAAX19N QUNPU1gvU2NyYXRjaC8uX1NjcmF0Y2hVVA0AByM0uF8kNLhfPjS4X3V4CwABBPUBAAAEFAAAAGNg FWNnYGJg8E1MVvAPVohQgAKQGAMnEBsB8QIgBvEvMRAFHENCgqBMkI4VQKyFpoQRIa6SnJ+rl1hQ kJOql5takpiSWJJoFZ/t6+JZkpobWpxaFJKYXszAkFSQk1lcYmCwgANqACOSSciAEwBQSwcIlt4C qG0AAADSAAAAUEsDBBQACAAIAPFpcVEAAAAAAAAAAIsuAAApACAAU2NyYXRjaC9TY3JhdGNoLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2pVVA0AB3Y9tF92PbRfdj20X3V4CwABBPUBAAAEFAAAAO1a XXObShJ9ln+FrioPN04iW7bjOOW9WzuCkcwaMSwfjpUXCqOxzQ0CFaDYrq389+0ZQIAAgZ3kZct5 iCTo7unpPn26GXxw0P/jzb5pTM723/yx99+9nh069+53ekXDyA38/l/90flez/HsKKIR/AKJH3Ah uPmbOnEu9PFwczGR2jvY74/pnev31fH1eO16i4nr0X4EAkxj/2Cv1xudCJOj0Wd09PH05NPJZHR4 eIJOThHugy5arUTq0Ts7psNlH8zowTp0wIX9A2bfjWz4KJo+79/C/xq9ZS4nhj+3G94/OO+z/WS+ CKnKaUkF9h5Hw0fH5l+YNxqNnu/PuIvxbY8mdUoz2/Vn1F8PH92bF7sjtlre8gUd1WksQeOlKUKj HRbT1eEC9heNMCoBbZLYpyH1nXqwfazDhO6EduzcD+3Vatv5ksXzPn1cea7jxuyy8bSiIPQQghoN mTLcstmK5xANx1svqORL/oI+gtTheX9lx/fwrbDYeT9JmxFSZmlsSrJhqRoRTcHQLVHSylA4a8Pz fYv3UMXxpR88+AX3Ew+cYEGHzvB+42XJ7Jafg3/chcF69c9B2b1O5fZT7gHBOLUeLrt52LEAn+vj beAtGACYPgDA9oK73Muy9W5+4jo/x3ZEX+IcfGXFfN737SVHGdjZuMd+DL1VGPx9UKz8Tm6iwzo3 Jf82GEIlRPELnI3pY5woDx+X3sbL3GY3x3azyq+DYGKym0/HdT5lXED92I09uoTPlwCwELaipQrl lG/u8Drn3EZGLfNuCNh6CMJvEedo9Z5htY5+j+o4ItdO9w7yvXz/NbZZXHs37Cfia8zs6BtIH43A 9tkxrMAFGPTZNPIn+/GWXwrXPvG9p0kQinTlBU8sFGoQxVAB0Lki17/jXA2i5Si07K8UjCkLZN3u z7Lp4nCz++3Ncl3uKUxh3gKinvmfRfDTjgYGi70vyp7WyaphsFg7HGfv88A0gCEJRGeDL9hPh4Zc cDPlsGzJZ7jeErcXeN6pHZfy0alDljQ6dqySTpe5rqjQgcdL4rvZtST6HNIrZLlMW+1Jzgu1Unul ylRgOvtODTu8o3EtPZ08EyRFgzknCYF/696tQz4LyiyCm3n3tLazM6W+U9Tq88DfBmHF7UHqzoDN x5slOSNF2wgd1W5nM6WXUNPOzCXx4zrx4mNIIZ3cQ21dIeMFXVEYj33H3b6TlnkRAKuk5JXGO3mX 2jzhdOCWooW0mw6cYMmneTpMb3yI4U5xwK8CrwlaJfwBbbEn5NreIFZ6Q0KtXCF5sq5DYCrBt2HH cejerOPsQR3+yTAtmKu70F5Q4Z46rEmOjg55g+v1Em9RVau5HDYSPSGkwFgL4htB4EWF44KjYWo+ od/s40eX+vh8WBeFtvrIolQpDUgkUIl743pu/JS7OLhmw1z/8/B4kOLwO/WCFSMiDVLFZajPb0FZ 6Y7t+3QBIwP2QQ9GhCibEXrf2CCW6OTFR/2kUthsXagCxpAJPWW7rc4DW3gui7d230ybBUN0QzVh 0cGgeF0Lgji/GHMEVHijhQbzTZVKoAbdJfRv2KFlRmyllkoR1Fh+wYT4M2dAJW589pFNASUvHFBb YlvKg94pCy29o5KDitWXZ6D7OVMp7M89R/z5qO+MZCnmV3bo2n7c+GjQaWirxLxodeeouutAoTpd l04CnjF8NW0yj8S1MK40gLpwoJM6h0V6s76rxKHOZo49ncZxStlJ50LyFzTXLR0jTbiwTB1rloqM Cx0EFJI0LEFGytRCCpLnX+G2QhTFlGUQmGO9XsKcjeGDjP+NBcMSiHKFNV0iSqJioelUw7ouXeGi tnB9bbEvJppiSzeQIiJNZPG989fv3o1OBhVhaawhbc5EPPfGefeuJIEVNJaxNSOiKWO96mx6H3wU LNj6boEvGF1WJb4gTbHGMhEuLQGphqlhC5kG0bCMkS4p0yYNQuRKUCpSApnNUOM9hQWoGtqKpIhV DQvIwGKyEWmmyniGFQMZoFQTlkRL0ljiEg0dASogJ2nysKYRrapBBHNjlvsOP5rM45lqzCEM4rxJ AADUvjdJmUiKZGALnDV3C3aIFKAaEGVgDckWg3e7xiagkiAZ4ISBJAXqSJ7sks+W6GZdIwRcl5Gu 74z+f0zCMiwpgmyKGD6tiYZm+AvRLq0LjESsNSyiwTdsyYSoSfHqUlPOdEOTBH4YbxBjrtZVVCJn 6irEg5g6lN4VbpAyWZlrIviMrpAko7EEcZnvpIdUT8NIuOCFKRCxybwlmiwrAHtrho0LIlozZAgX JWmizi31AumYb00t0J2Ix+aUoYtoswTPyTcQWTzY4W0ildJDGheerZk+1bEiFpdJpQwM9VrcZHJ3 KgiWUEt6wHmjUS4kzhU0kwQAqQXRLfjKbsJFVnAk5SJ9ewWiGtJM+ppsRcZXWN7M6/w+MASkVYCQ Ew0IgxdVSg5J0+wNeEj+Gg3ep7/f/On69zR04YHnbXrxbW6Q5+D0xDKIdXxkjaWm6tvIojExeQWZ 8IOhq4r2jaypiBhSrQF2oNaApohWa9NU+D6QLH1lMANe1hvwVVCB9idaE1MRjCZXU5krpEkss0WZ GRKIfs0oVyZzxn+WgbQpZrgZjbKHwJkhZ50lxxk70k9rVyemJuBcdoJ0g6G3BF6iyHMLgZNXmPWu 0j1dvGSswU/jnSB6LDxspuMMHxu2jgPRx7oBQ4NJMX/L8jpivI4YryPG64jxOmL8zhFjwGeMDw9u fP9hET0tB6VBQgHfdSDQrLQyg92mkc7zRttI8drhn9/hs1Q1dvX2zp324+3e/en3HQ4A1gwAOZLJ lCFClWRoukiF+gNswEzKwoNWK8lJzTRoTGUyBkZCgoA5UcowaWbajkP9WAi8IMzKho1B0pRxtCEZ SS9hmU0PXA9q395vqerGnKcOreNgCbt0MoHZWFKwdSGJqgTEClVQwjZLFZQ1JGcicf1szcJfXHBB WbQ0U2FTTDbWZBNNNjLXjMi9wb/oI3XWsX3jUYu91DsYDg/yd0rlSTr9uydrDPUAWJJEFo6JxImW vZGhj/aSvZMpvvrZKKXBBS8ShPILbwcdh8Gz3zkMvkLq/xxSZZZKj0PbTjqLZ6LV92F1J8S/7NXY Npwry+doLt2qHNPvPKQt/R1Ay9NW4Qh6QW/ttReXFpaiKzdyIeGb5/g6KWVnz/i1L95/WQh3trJS CFs46veFcAPo3TBlwQ6DICbJq+rNO85u77XP937s/Q9QSwcIUf+SjXwJAACLLgAAUEsDBBQAAAAA APJpcVEAAAAAAAAAAAAAAAAlACAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai94Y3VzZXJkYXRh L1VUDQAHeD20X/t0tV94PbRfdXgLAAEE9QEAAAQUAAAAUEsDBBQAAAAAAPJpcVEAAAAAAAAAAAAA AAAuACAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL1VUDQAH eD20X/t0tV+j+rZfdXgLAAEE9QEAAAQUAAAAUEsDBBQACAAIAPJpcVEAAAAAAAAAALAAAAA4ACAA X19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai8uX3Byb2plY3QueGN3b3Jrc3BhY2VV VA0AB3g9tF/7dLVfPjS4X3V4CwABBPUBAAAEFAAAAGNgFWNnYGJg8E1MVvAPVohQgAKQGAMnEBsB cR0Qg/gbGIgCjiEhQVAmSMcCIBZAU8KIEJdKzs/VSywoyEnVy0ksLiktTk1JSSxJVQ4IBilc/Gtb PIh+fuizEIgGAFBLBwiUiBETXQAAALAAAABQSwMEFAAAAAAA2pFzUQAAAAAAAAAAAAAAACcAIABT Y3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL3hjc2hhcmVkZGF0YS9VVA0AB5wmt1+cJrdfnCa3X3V4 CwABBPUBAAAEFAAAAFBLAwQUAAgACADuaXFRAAAAAAAAAACuAAAAHQAgAFNjcmF0Y2gvU2NyYXRj aC9BcHBEZWxlZ2F0ZS5oVVQNAAdxPbRfcj20X3E9tF91eAsAAQT1AQAABBQAAABNTUsKwjAQ3c8p BtxnjBtBRCoV3NVFTjBNJzZSkzBk4+1NC4Kbx/vyiIAI8VrKTRZ5chUzb47zytWvfJO9SssmHD94 lxyCSiOskjAntJbskQ57s7ZhF98la8Vzn31m2tDMF4Aupioa2Mv/H55wcI/xJb5NBteSJXquMadf o02hkzQBfAFQSwcIJ/rXmoQAAACuAAAAUEsDBBQACAAIAO5pcVEAAAAAAAAAAKsAAAAoACAAX19N QUNPU1gvU2NyYXRjaC9TY3JhdGNoLy5fQXBwRGVsZWdhdGUuaFVUDQAHcT20X3I9tF8+NLhfdXgL AAEE9QEAAAQUAAAAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwFxJRCD+KsZiAKOISFBUCZIxxwg 5kdTwogQF0/Oz9VLLCjISdULSa0occ1Lzk/JzEsHSpaWpOlaWBsamxgZmltamAAAUEsHCHAajcBd AAAAqwAAAFBLAwQUAAAAAADzaXFRAAAAAAAAAAAAAAAAIAAgAFNjcmF0Y2gvU2NyYXRjaC9Bc3Nl dHMueGNhc3NldHMvVVQNAAd7PbRfez20X3s9tF91eAsAAQT1AQAABBQAAABQSwMEFAAIAAgA82lx UQAAAAAAAAAA0gAAACoAIABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvLl9Bc3NldHMueGNhc3Nl dHNVVA0AB3s9tF97PbRfPjS4X3V4CwABBPUBAAAEFAAAAGNgFWNnYGJg8E1MVvAPVohQgAKQGAMn EBsB8QIgBvEvMRAFHENCgqBMkI4VQKyFpoQRIa6SnJ+rl1hQkJOql5takpiSWJJoFZ/t6+JZkpob WpxaFJKYXszAkFSQk1lcYmCwgANqACOSSciAEwBQSwcIlt4CqG0AAADSAAAAUEsDBBQAAAAAAPNp cVEAAAAAAAAAAAAAAAAbACAAU2NyYXRjaC9TY3JhdGNoL0Jhc2UubHByb2ovVVQNAAd7PbRfez20 X3s9tF91eAsAAQT1AQAABBQAAABQSwMEFAAIAAgA82lxUQAAAAAAAAAA0gAAACUAIABfX01BQ09T WC9TY3JhdGNoL1NjcmF0Y2gvLl9CYXNlLmxwcm9qVVQNAAd7PbRfez20Xz40uF91eAsAAQT1AQAA BBQAAABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAfECIAbxLzEQBRxDQoKgTJCOFUCshaaEESGu kpyfq5dYUJCTqpebWpKYkliSaBWf7eviWZKaG1qcWhSSmF7MwJBUkJNZXGJgsIADagAjkknIgBMA UEsHCJbeAqhtAAAA0gAAAFBLAwQUAAgACADxaXFRAAAAAAAAAAAgAQAAFgAgAFNjcmF0Y2gvU2Ny YXRjaC9tYWluLm1VVA0AB3Y9tF93PbRfdj20X3V4CwABBPUBAAAEFAAAAE2OMW8CMQyF9/wKS11K VV24LgytEBUDE11urDqYnLkE3cWRzyBViP9OknbAw9OzZT9/1hprASYMsZmq7ZygOp99bbdCqNTD 4Rd2xMejUDYoFIEjtK1tV/Zt2ZRt8xSmxKLwsWXHaKs2fm1MiFo/PBeDMrhXcBxnBedR4KWMLt8/ C7gayLXBs7LQSDhTYh7/x6UyUEd6Tvm8J1CPOTcMPgdVSni47IEPJ3I6w8A0gyehpubcqkqOkQhf 3WdKY3CogeO+IP7hFaLFu7mZO1BLBwhrJlbyzAAAACABAABQSwMEFAAIAAgA8WlxUQAAAAAAAAAA qwAAACEAIABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvLl9tYWluLm1VVA0AB3Y9tF93PbRfPjS4 X3V4CwABBPUBAAAEFAAAAGNgFWNnYGJg8E1MVvAPVohQgAKQGAMnEBsBcSUQg/irGYgCjiEhQVAm SMccIOZHU8KIEBdPzs/VSywoyEnVC0mtKHHNS85PycxLB0qWlqTpWlgbGpsYGZpbWpgAAFBLBwhw Go3AXQAAAKsAAABQSwMEFAAIAAgAGGt0UQAAAAAAAAAANA4AAB0AIABTY3JhdGNoL1NjcmF0Y2gv QXBwRGVsZWdhdGUubVVUDQAHIDS4XyE0uF8gNLhfdXgLAAEE9QEAAAQUAAAAnVd7b9pIEP/fn2Iu p1aG42ETIASupxCStEgJ4QJpVVWttdgLWNhe1173cbl895td22Abg3K1ouxr5jfv2aXZVJpNgKHv X1GHrginDVfuzMyAcHONc7kcBRTPLFj8hLeULZcBxQkJqAfMA11v6mfNltYQ1MrvtuuzgMNJFnR9 oijNqgIKzIjrOxRYxP2IC+6Wpp+D3j2BO2JeMraBacD6ioL7La2u6/WWBvppv6X3Nb1x2m1r3bO6 1tO0VMNPndOedt7X2y29rbU+w+jmIfJuGfNnLApMOrNXHnH6MF8TDhzh+6A3uu1Op90JD8rQ9fNf kUG+rcDmFFls5vVBa2j46d0jctr6r8hxbW9fjqYdkdP5JXtc8qMoR++dnZfKaTdOW91ur3NUjkvM teGGq1w4tEav2+n1Wodhz05fClsaAe2Ixmed3guh/4/TY+iz44magd73s9bWTkMsgioW1IXt4eGS mDRbp6BW8MgPmE8D/hPUkAfMW1VgfHkfcYdymMw+2J7FvkP1uxwHygX1LEUJOcoxYcGYA5ZtTRGa Be4HFmwGivKN2Rb4u633miq2qmAyVOIHryhPCuCXZ4Q3wIOIDpTnEgRdHd1gaa+n2BQe6BJEc6iB JKui+TXMvrFn0R8Q2v/Q9MD2luyFshbUM9cuCTYq6hhyMNckqIJH3BRM/WISx1kQc1ORxlRSYCHQ 4DvXh4ity6gO5PnoZm67dCy8/404mK4c/7+B8lORHwfPMMDyLLEn9EVCGF8jGgkFvuJhYdOU/VaN rbgaz6bD+eid8ffj9eO1Mbt+GA9vKwna97WN7VTdGVGvVyC2r9R5S+KENOEVn2EsHGZuUOXhImRO xKlQHTBLAj7IwCTqkfCnZ6pfa/AlI0Q6UzAgfh7nLeWjKMB7gquVQY4+jUl2/7mSUSwx7Le8BZUc yLZx4TD27phF1c1274ouSeRwsVuDTk2mTVZAIUhWFDvwqA1QL3pmO7GXoG4x/hT5kNc1TpCUYlDO 95fIlQKfTJ59vu0kzss/ijTPypZqMrtlK/Xi5FWY67yvnGV4UktKRaIkscjSF1rqPg80k6JpaCXs hbaZYxcuKuHId8M8BzpHVv6FLV4RLsYk9lumMSpKHeI6J77v2KYkuLKtG9uzw/UtibBd2N6qr05m E8btZUIB1QrJrZ+UfIZh63KJ7SVLmSXJHBPkDk/UNLkK1+kobp1pC32vIe8TaLWDf7n+C8+DMlCh TihnEq8oMm4fWAtDB6ubcBYk1SAFvN6qUimADy0rRlCz1m3Tv7aVWYNdoY2Y6zJZfWHqgl1TPil9 XGBEvzxlKrGERE1FZRrElvAD2dBHX80EJKF6Tsa4wTuU+qq+i0t6DxVDou+HZOf34uUlqTNYR3yd uwczfsf5nuv34lomJkd7QKZUsUTAS2Orvzy26RsmH85011hTYtEAb7h4sotjvG4gzdpY2FxcvHdD vODuZm/fGZfj+UxNl8b84/TaGN1PP+K9N7namVWEEZc5woiBLdU9FQ5wBdRlnBryB0vW2+gYMaix Mw8wC887Ka9UeHr/MDcmj7e35Qz4GNk+EbKOUl/HVLUYRRgqbId/M+v5+O76/nFe2zNapmteeslW pjzk5NOnyWy4648Q4quJWpmdz4A9GDs0Jl3fs53PcdsVL8j/AFBLBwhw8JHD3gQAADQOAABQSwME FAAIAAgAGGt0UQAAAAAAAAAAsAAAACgAIABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvLl9BcHBE ZWxlZ2F0ZS5tVVQNAAcgNLhfITS4Xz40uF91eAsAAQT1AQAABBQAAABjYBVjZ2BiYPBNTFbwD1aI UIACkBgDJxAbAXEdEIP4GxiIAo4hIUFQJkjHAiAWQFPCiBCXSs7P1UssKMhJ1ctJLC4pLU5NSUks SVUOCAYp/GO8Ix5ZIwBQSwcIbOOGN1cAAACwAAAAUEsDBBQACAAIAPFpcVEAAAAAAAAAAEIBAAAk ACAAU2NyYXRjaC9TY3JhdGNoL1NjcmF0Y2guZW50aXRsZW1lbnRzVVQNAAd2PbRfdz20X3Y9tF91 eAsAAQT1AQAABBQAAAB9jsFKxDAQhu99iph7MnoTyXbR7QoLRQt2Dx5rMmowm4Rkardvb2q9COLc Zvj+b361PZ8c+8SUbfAbfiUvOUOvg7H+bcOP/b245tu6UhfN465/7vYsOpuJdce79rBjXADcxugQ oOkb1rWHp54VB8D+gTP+ThRvAKZpksNCSR1OC5ihSyFiorktMlEC0pDh5c1q/1WnXI3VVFesjPrA uS6WH19GPSZL87KKPHjzEs4KFmalKY0I/ydfrcMsx4xJZHSoCY1MOBgRvJv/cClY2yj47lpXX1BL BwjejftO1AAAAEIBAABQSwMEFAAIAAgA8WlxUQAAAAAAAAAAqwAAAC8AIABfX01BQ09TWC9TY3Jh dGNoL1NjcmF0Y2gvLl9TY3JhdGNoLmVudGl0bGVtZW50c1VUDQAHdj20X3c9tF8+NLhfdXgLAAEE 9QEAAAQUAAAAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwFxJRCD+KsZiAKOISFBUCZIxxwg5kdT wogQF0/Oz9VLLCjISdULSa0occ1Lzk/JzEsHSpaWpOlaWBsamxgZmltamAAAUEsHCHAajcBdAAAA qwAAAFBLAwQUAAgACADxaXFRAAAAAAAAAADKAwAAGgAgAFNjcmF0Y2gvU2NyYXRjaC9JbmZvLnBs aXN0VVQNAAd2PbRfdj20X3Y9tF91eAsAAQT1AQAABBQAAAB9U8FSgzAUPNuvQMaDHkrsxXEcxKEk 7TBCyJTg6ImJEGtGCAykVv7e0NaDIB7h7e7bfXnPfvgqC+OTN62o5L25sK5Ng8usyoXc3psJXc1v zQdnZp/DyKMvBBl1IVplkGQZ+J5hzgFw67rgAEAKDRL4MTW0BgAIm4b5rlR9B8B+v7dYj7KyquyB LSBNVfNGdYEWm2uClavc1G2O6r/s6L+5yJQzO7M/eOd4q+VO5gWH/JMXVV1yqTZ8q9E26Msa1apG m3cuLiF6QkFEQoRpGrh4nbhrdGWDU32gh754tlPsteBjIfSMvIS6ywCl2A2nNfyskisxVpjE59q9 eBO8GfckmwgmHk2XCYa6rw91Cn/lo810d/lWQT0pPQvWdE/HGQ6Fb6zrKT5m5R/Zf3z8G5yw7INt Oe3qfxROSYjrPeqHSPttmhSM36tGnSLEB8RQdzEdZCL6YogP4lBIUe7KuGsVLydoF5eh60XxcwoR CaKXwzZRd7NGdOQexyETEovXv5agL4Vc7sYkoj8zUbPCK1jbDnk47i9MZEwdzP2QbXC8ChscbsaZ fQNQSwcIzUVtaacBAADKAwAAUEsDBBQAAAAAAPJpcVEAAAAAAAAAAAAAAAA4ACAAU2NyYXRjaC9T Y3JhdGNoLnhjb2RlcHJvai94Y3VzZXJkYXRhL2dnYXJlbi54Y3VzZXJkYXRhZC9VVA0AB3g9tF/7 dLVfeD20X3V4CwABBPUBAAAEFAAAAFBLAwQUAAgACADxaXFRAAAAAAAAAACHAAAARgAgAFNjcmF0 Y2gvU2NyYXRjaC54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS9jb250ZW50cy54Y3dvcmtz cGFjZWRhdGFVVA0AB3c9tF96PbRfdz20X3V4CwABBPUBAAAEFAAAALOxr8jNUShLLSrOzM+zVTLU M1BSSM1Lzk/JzEu3VQoNcdO1ULK347IJzy/KLi5ITE7lUlCAKVewVQBrsAOJ2bhl5qQGpaaB2ECQ k5+cWAJVU5yak2YFVaUPVQY0Uh9uph0XAFBLBwhKmO8eYwAAAIcAAABQSwMEFAAAAAAA8WlxUQAA AAAAAAAAAAAAADkAIABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL3Byb2plY3QueGN3b3Jrc3Bh Y2UveGN1c2VyZGF0YS9VVA0AB3c9tF/7dLVfdz20X3V4CwABBPUBAAAEFAAAAFBLAwQUAAAAAADy aXFRAAAAAAAAAAAAAAAAOwAgAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2ovcHJvamVjdC54Y3dv cmtzcGFjZS94Y3NoYXJlZGRhdGEvVVQNAAd4PbRf+3S1X3g9tF91eAsAAQT1AQAABBQAAABQSwME FAAAAAAA2pFzUQAAAAAAAAAAAAAAADEAIABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL3hjc2hh cmVkZGF0YS94Y3NjaGVtZXMvVVQNAAecJrdfnCa3X5wmt191eAsAAQT1AQAABBQAAABQSwMEFAAA AAAA82lxUQAAAAAAAAAAAAAAADMAIABTY3JhdGNoL1NjcmF0Y2gvQXNzZXRzLnhjYXNzZXRzL0Fw cEljb24uYXBwaWNvbnNldC9VVA0AB3s9tF97PbRfez20X3V4CwABBPUBAAAEFAAAAFBLAwQUAAgA CADzaXFRAAAAAAAAAADSAAAAPQAgAF9fTUFDT1NYL1NjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNh c3NldHMvLl9BcHBJY29uLmFwcGljb25zZXRVVA0AB3s9tF97PbRfPjS4X3V4CwABBPUBAAAEFAAA AGNgFWNnYGJg8E1MVvAPVohQgAKQGAMnEBsB8QIgBvEvMRAFHENCgqBMkI4VQKyFpoQRIa6SnJ+r l1hQkJOql5takpiSWJJoFZ/t6+JZkpobWpxaFJKYXszAkFSQk1lcYmCwgANqACOSSciAEwBQSwcI lt4CqG0AAADSAAAAUEsDBBQAAAAAAPFpcVEAAAAAAAAAAAAAAAA1ACAAU2NyYXRjaC9TY3JhdGNo L0Fzc2V0cy54Y2Fzc2V0cy9BY2NlbnRDb2xvci5jb2xvcnNldC9VVA0AB3Y9tF92PbRfdj20X3V4 CwABBPUBAAAEFAAAAFBLAwQUAAgACADxaXFRAAAAAAAAAADSAAAAPwAgAF9fTUFDT1NYL1NjcmF0 Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3NldHMvLl9BY2NlbnRDb2xvci5jb2xvcnNldFVUDQAHdj20 X3Y9tF8+NLhfdXgLAAEE9QEAAAQUAAAAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwHxAiAG8S8x EAUcQ0KCoEyQjhVArIWmhBEhrpKcn6uXWFCQk6qXm1qSmJJYkmgVn+3r4lmSmhtanFoUkphezMCQ VJCTWVxiYLCAA2oAI5JJyIATAFBLBwiW3gKobQAAANIAAABQSwMEFAAIAAgA7mlxUQAAAAAAAAAA PwAAAC0AIABTY3JhdGNoL1NjcmF0Y2gvQXNzZXRzLnhjYXNzZXRzL0NvbnRlbnRzLmpzb25VVA0A B3E9tF9xPbRfcT20X3V4CwABBPUBAAAEFAAAAKvmUlBQysxLy1dSsFKoBnKA3MTSkoz8IpCAUkVy fkqqkg5EvCy1qDgzPw8kYQgUqeWq5QIAUEsHCHJPOUY1AAAAPwAAAFBLAwQUAAgACADuaXFRAAAA AAAAAACrAAAAOAAgAF9fTUFDT1NYL1NjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3NldHMvLl9D b250ZW50cy5qc29uVVQNAAdxPbRfcT20Xz40uF91eAsAAQT1AQAABBQAAABjYBVjZ2BiYPBNTFbw D1aIUIACkBgDJxAbAXElEIP4qxmIAo4hIUFQJkjHHCDmR1PCiBAXT87P1UssKMhJ1QtJrShxzUvO T8nMSwdKlpak6VpYGxqbGBmaW1qYAABQSwcIcBqNwF0AAACrAAAAUEsDBBQACAAIAPFpcVEAAAAA AAAAAHnFAAAnACAAU2NyYXRjaC9TY3JhdGNoL0Jhc2UubHByb2ovTWFpbk1lbnUueGliVVQNAAd2 PbRfdz20X3Y9tF91eAsAAQT1AQAABBQAAADtXdmW4kiSfZ76Cg4v/dBzM9kJejKrDmsE+77Fm5Ac IRCS0MLWM+f01/SH9ZeMNiJQIBEik2CJzDp1qgKBzMztmrmbu5ubf/trPecDSyIrnCh8D4a/hIIB ItAiwwns92C3U8BDMKColMBQvCiQ70FBDP715x/fGJHW5kRQA+pG0p/S4vwLJUk8+VIUVCKPKZpk NI5niBz9khVpkfoyKGaCr3yiBh9VFHml98I6HI7G9IeUzBK1pQkqN9cJVym63h5YNIIBSRYlIqub NE0TRcmKgiqLvCGTQIIBTSFpTRV5aiNq6vfgMN8OBmhNUcV5fTQltFoUjHaonEqpOsMqUSci8z3I cLL+XfDPPwL6P98YIhGB0RXAEcV6ZD6WeI0tCgFO/0blxhyRj7XYErahv8IJe0222vfVZvT1kNM3 0RRzn++++Dr370FEzHbKFWpE9IYXOJ78TQnUVwKRd43N8pSifA/W2mldOo42Gxt8pWnRFQVBJ6l/ ozi/seTQVJ6oL8rWdUR4wlKqrmOGKConmDS/B3siQWcNuZINmsI9brNgu4h1F7tmvpD86spRf7zX wKPtDr9pt6yogRZRJFHX4dumm9++fvn1KOGog/C+zo7p8yjNfb04aOgUci+qtL6piozGk4YsLnXj 0s3qJ5FacQIjrt7g1FxmUU1hk2QtnNiihCcRD7nU2XEaVjZIxBEebQ/UV9C9tUoJFPsGEr0X0QK6 V/Kmt3NCoKo/0PucjaKSufH39+CcMjzJoJ8ealDKWLQTbxXF6b92U5FBvqh/t2PRpmVKpScWufBA xdMQWmYVPHzVel3vCQ2Hr1LKLDAjuor1/+QXGrekeL0zqO59/VaZzhaa7yraaG627q0w+601exVL Pq25QS6HUk72kO9Y04+qIT3SbSfgUEZ81kNvhOa6fYTZORXjoHfU0F3foMxfBxTdo2hV1H1HlHUX Ksi6nbXNAUtmzFY2KIHw/9iNLFZfYrQ3v5aQfUaPzH0J6O4a7j/dadsvKJzSJhKlYyHKxmd78DL7 kvoCmxDa+af3hDyAuCGTMZH1EYYo//nXv4MBBz7fg/9tMcjUC6hVEab7/hl4i7sqZNGpo50tnSxu m8hLTpfVIlSrihDnEGbbaxjjEY99kXLfZRWH7JNtCpkYBpv4u0o4o6XEpgSlFrRE62TVP+ljz2tf 8MZO7N6hzq8gNDBq1vwAcgZvnuhCuXhtQ6ihS2OeeLi61+5rr65O9EDPS3k9RsZYwmBbP7c1B0TJ GuStcFecz/Wez/p0oV7XwMls/V58pLgA1+vEQA0xyHZuBbj2RFwF0jxvyVdmIphLkLr3OvxpggGF 3p53gMhNWFQI1uL66kB492az7Br1PJbsu9ZyAGtT41TP3mxhd5bKCDEFvQp3od5MnyLOjYDcrUvr kCQkAcNt4QqAfPt6JHy0CLhE1UcIH+BhTFKthjJVBXQR823zOuH2qyQjboTuFMutdu7AukZWB0Zn T176lIJSGuojfyGjE8gqZ6/TuJhdrM1hUAMdj129H7B1V5eI4BaqipbAxbSI9hBjJnUh/emzauGI Akc9wQidy7XnW1JgoEVoXV5LRHWgu5uM1Uq5rTDaIeh+JC2bz3ZKtwNqUXecOo0x9+yjFSZnH557 IOm+IrM8oWR7JcKQYFkbQt5iGov4lOCV8nl16qB9sok73j4wd9podMsJgFv8QFFIMchEuycL7N8F nK/5c4fX3/uE32t4+xHmfoKaeTyGogKukj85qMnyokIOOsaVjUhPBPUIiXu8UMcoEXksynNTKBcL eZrXUdHbmWzeSsfYppbEbWSxOxhpvUY8hcagdyEFKro8R0YWlTxjkMGiNLwlBQbSrgtJtnFnVkkU OuCi6SvoMO3WUc1zY2xlFEPZW9FiiyyJrAZUMWDokzlQpWxPRak+xioe4k8XUqVsyrVTZkc0pXPR KFeKorHEbHWww+OupqtMHanSBFwMIzI+fcmUYkmgTVRNcjP0hkV/UWyj/4A2Vz77Yo4y4cbqFddy ZE0wVFAxt1Ddhn5OMMIgNvvuyqZJ/wIe1ZA5QXUDS7KNocMjrKFU8LWqc46h0RDIRXUL6hmxFSix /ikn+XmGs6cc8WYBdQpSqHOdSf6rJP3YAxJjxHLH5ts/NMnvCox4YHFbe5GjVULMWM1hL2Rxmi6M i8FVEwS0BjbZuxVfbREXrT1b0iaYCbZt9Kj5xYY8V62JxTRaChL13NW15j3C9Vs91IrIr7enzyM0 9QCCtb3Z3OLBDaEJl5pF0K5jzLBEkHhAMaVcHYGdzkRpc6A02pJ2HV3i8RFcv3sppenCuGjtMTzG YwUlcXMrWmtQino4Y13aKSi9NLoxKEzlUsOyIY2L3rrLNh4Imgx7U3oL6JFfoGrsYATa6oY/1GPP 7glIB9EetqvZ59tYNCFLKw2e4oQOWbv1FXR+gvIAq9LNLDQY+V2qvckgUVE0i9AiZwfnQggwZmNc 9B6qzlDl0aCqt6L3tim0tZv7xlUoS+aWtkJijkzkUhGG9ZcukdtmeG2OKgeGq11dgd5hhrbhMXnA oB45OcwocAJj7zLla9ik9enAsZ22VzoX24F4lTA8SoIPQVivL7W7YPA256wqxer8Dyx2bAk22MYh xFAP9U/ddDjzxoC93GuIbSbTpc0fuPXHuSSaCjI1X1uKDqaX2Row33GDwxxwW0TiKZrsQRPxwmaY 36D0hM7YT36ak/vFBmEH22uZRD8XxSOLePrdjMADptc2iZoedNiGcGgHdi71IpTCuIP2htyLj9Zy IlrPWKbezRM8YHptQBoyWXKiptigRA9AebRzFVdVzCdoVv1s5zjYXguUp/oEyhBRytf0zcH0iqB0 FWO1nLeYB/SWBqxR1UQneYDOLvdGK0FjIZXVe0Gnm0xAWEKK+1oUcjC9IjolbS6ZW007hA4AmVrN a4ckiFnMK8yVATEyD4j8Im9R6HEKN+JJWiaUCyzF+iMSObDxzI3CcuVEhN3USCI8zwmsGeI8ypQe RNj7jLllGJyI4TJ5W7H5TmJLymixBqWLaMbPgrpJ+WfjczMx2F1tbzzoH3b3XRBBb7BdF6/sQYou +aNGFMXr0MuyMEVZwWQTvVGfMd85WIGdEHoW2O1PB2riYY7l/+zOXkSQ7SLb8mPSDp7n7ssMkXc2 5ALEeJtELwuZ+FpCcfC6BhDeqwSj2goig7nka0/4kLID4hen6084ngQ6G+mlG5BHObQmWBX9HEBx srqfFDxVZFmeGAebOUHTI11TH6Zq3K0ouUqguUVodqtDoPmOO9Z2nxroc+ok4Ozy5+UEIhJiJT9b UU5W94a1rYUjGM+1HJoCprHVXWEsysbB+lePNs7mzymVoyme39jW+zDEJI1EZPnpYX5p/U4ftn7c JxwRvoomh366caOQ30hkq40U/U/NbKyluRRHo1CBOPKzmHvJkPZQ1AKpIveAfu/Y4W4H+fPEtYeS bBMFFPqICh+6mHllP9w7Hb6vAa9AWZxpxskJru0r1dHB+rbiM7axRjYFresr8eyQ8s529EFKDRip EF/tnX3T3TYqYhkI7eonthyrBzcVUBQUI1HWa180WiyhTZB7vquFIgvapiaqLyfYmyNElhgPf6GB 2Wz/ftfggq+kLrBm0Kyn7w/fHKVMdvjKbBXjGDb028pA79O+W3yN9r8Dr5hVIdWRYk/fXrs6vBVO mNno0qsKGmFMuZPXc+8XXaP5Ob1T9oqoHzkJ+SgK4vKeoM1RKhWwmiXKNrpqS4bEINzwk9HupH63 6Bp6OIZuK1xEbYHyiL8ndI2ktl3OwfzlyO5ToQm2jFrBzzkqJ/27xdfQxJ4i3E6eLBsoEDQ2iRtF +DZmxB2ZEhRjU5Pam95FxCJaAp5L2duaE7sKSz9Q2CTQa/odvH56VlylZiTQlSQiB7KUYk9slvMe EgyS05N3dO7ICzWj0bTe5r4+OXZxOqUxQWcGwmg36nTmO654VsSVA08mVUU2B6r6mWMi3mj0ETy5 7jNGcUy4uxoms5TEqRTPbW0ou/lnZBTwi8+8OUC/NNoDy0jiCZ0KBGVyo1jexoDYlgjZFbhcy3lU nzEdhG5rHNyXMSq38ZxGTfRz9Nuk+9OLwqoxfdRloGYv+29DYYbxA+iK34Irr9Tvx8UUo+G7drt4 WCIeQ43FbHNXvWVbFaU3aNY3WzAb5B79nHxwEr8nNEXpCJjM4AEJCdPNQc3jd1l90u7yAoXfzNDe 0v903THycoSi16rFR5d+25PlMV9HcQW6fPaqykaN6916UxzhNlrNzG2NNZaE+xW3xi8yUwNKD5BR ohYX3ZA0RDqsnGrL1IwTPJRRy/mV6YXXh20fGvK+3TXcr3tunnp4kiEsEFnf1UZBRuQZzwMPI9uw MynUqyCRayfYUQxjINGRKU49gsRkMcNEhjL0VQbBwfKKSBSN2J/2PCDG2acIp2usOQjTazuHTyyK Tz3UM6BDd5V82jVukeA54fAQtrYrx/BorC2UwyevyJ97PWcnqUsAVBi2ERmhlPZVUszB57byGeJs B+Us+u2fy2fIcKxxE4XXSaK/29XGVQntBnp5P3UKHPzODK0ZIWwMJzviX106CYZDV6jcBcav+5c8 /wJF7AAK2ItXYQZ5GYu2V10hT4bXgOKJHqAyBqkxdwHFkULc6yhyM6yjJ2UYH4BcJrJdBXmaaUJO oFe+qVKq3hHzq+QqnzMqW4npU5OdTA4nxsoH0r09eJcjY0rjd9ONLgVSB70a/oBor2w+TsEOPj/l kA5Kh0OgQnaXvxjAeazsMDOkeGRnvoq+eDL/MUd1kjjdaR3vuxlGzbwNzTqOn0GxjMmo9YtbharJ Qn089raI7gMFdosqRX02i+hw7EQldg8WSzRAZ5AeTn91g7C04m0QEzmJ2hYPsvjZDKIiisrOHkSW hjyAmg3/4vbAm0rxNocHLoZxCoXyu5W7j/K9rjn4XmI+ZHjhKUGFYym9z96lq4oJAjmEav/kdY7r hIxvxF+F5lhu0M76ubfigM2Hxo0Uq6JbQYhEf/EOYC9ufEHP7byl1sKKQW59chqag/0NDgvOyLGU 3ICvYtE4tYKKk8f924UdOR6zCW4QAZtGkX+3GutR1jdqEy/3o62bOYTH6MdOLdviZHH/JmHcM83z xyyirMfYszQ6WvmOLeJ+ooUMpYPD7bquOtXEIIqeIt5HsOCUnpvOkM+AYambixWi9TnyG0R6fu49 8GbzCToAQaFlTnJLUw8tn5GKY7gS7tjzzfcPz1pLRLbabZ+5WNCIxkAXC7+4OSivmnE7ErroYSxi JZ18W5aD601axGjfHoqhNtgJYgk/txt6M/kM9jDytIZmoo9YH8XHTxcrtihul2sfmSSRbyEtnpqg 7WRw/5YgGzrZje9uN3AqM0TDSDZPTkp08L1BazCPX9jlldU1+iGsc6tf3BrM0xlHrKFeCGNEo9w/ uXiyg+/vWYP7Oz72umvMCosoxtRJNT/csxqzIi+6XAiftYumsQKyHdB5P1cDOJh9WFqjKbBXNZR5 e4DBFrnefWRueUPMVRVs0+gWTipH7XoljMfNHPbFMPHeEvwWGSX3axYIN+6peZMj83IWv1THOo1K 7D5K66j797K4Y27farMsZzGtojrze3jnldmnwNy8scUD9NI4h2wFPDkpbc/k80kPYJi/c6sJYCds UjyKMTSer3J7zJFT2y8SMikac4JK5GJn1dI8xwqBChkfXmL2T0um52oYiSY2m1N3tM+eEm2Iakjq 4gvb7hKtMLT0ydkmVz2Ha1bnPlD8/9q56MUh0iy29OgWFG/J6nakXRpgPsOMvqsSPyVNUbmxXTWz FO8ivgIbOXXP9p6O85koWs3mXK8i5qcVJLuY1u6q1JrVgbWM7KMDR/o/O1tgFMEyB34RuwVHMkV1 Ub8ce8DoEUNy78cJYkoEj0P0xift1R0A25c51ahym+Psqq52Gnh4hDYHMVW6JV/1Htw9mvEwl6HM MZyeWj3DZHfOXamGDiIrU9IkGCACNeKJMW2v22P/so7HGZrdU8NvJ8ePX2k633KbeVj/UcE0jnb6 p7J8FVU2gDcbbOo6+Od/2dt/375aX962Uk0+H7h8N6dm5lqu7SIvHlIz0gAot0WThdpDnKCbObmK s0OSW1reNZpVGU1QimDR83PlrSdJN3szwmXjxhpz0PltdceszlBVR/QanduhAVJtNNvjT2V508IC agaxst+bGl1JulmeqUjD9Ay9/ra8Y5Znqqojekxt4+MZFhmkFydf9+eQ5qYszzN2VFYSWBlUJPzD kcDB3sHrZV0H8Q29WGI8RXFyamVIJ8d7i29qogR6ilS0+Tu++WB/N9b2/Mc3fKNoVDt/fpI+j6/r zcqwVSwJ6NRP5cT/jm/cKPm2uuPxDU31kVlilbrnrXLzfYfltTIxtOd40vwUavUk+Tu+caPk2/KO xzf5QQ4JGc/dk0uiOqT5naTh/o6PoGtc3oBNIczOfz5Jo6XxuzSlZWWOaBHF7smVPu5oVd0qu222 2q1ETH2NpxLKq/tY091PxbCBdE/FqM56aMholOMfui2vq0CVRf4G9+WNXAwv0JNhDuM+ov3IPYFu JWO4o24nY1R6VczqGPc+tIL3DaNuZmN4wU63J8ZBxkX1VmH/hPUwexxZ2dtCDxMkR6jGvO5X+uBq mHuSbHoYT9Bi6+euhWkOsB1R5Ecu9ybbGSSK0Ef7AdmVn575gklSp7ui11hrK8BQhtvFJZnBECsa 21DWl1j+Xe+HE5CymqKKc25Ldtj951//thO5u2U8CGg2GtdISDoDIrIm2G3aNdK8eKKhC6S6Xucm NYtgo6h2+ldHxzsenmSiqBQwCb0btXncB8kxxM1F7eIFs2IDyzEmVP7sLvpzQ+f5fNTWgNvR7hUF lka87OuS7ku4Z97IawoUNJ4PtGmZGIVc3uA2tvMaSkkwDahrPwdJ7xM3QwuWEtwKfnd1x00j3PKV ZHxm6D4+luhzAiPaYzjVLYAJI+5Z5uuDo4mdLPtVpVd78nWYJKgc4vyxE9k/FGNUOYGbmxeDvHGC uX2kZphEvwBJ9FPG4hyGKRHZuNDIkMtYNtdFczHN3qqDfg7DBrmVXuVZFG2NtWIihAjyvrLPbnGQ txEwWuR2jViRB53V/1WurnrvEZ1oUSQ5bIrvjjqHpRDMpd+0PjqoYsA81mNPhvMRUC2EBn7y0G4R VkqWKYElRcFslBuyrRrGGtimr/tw7q6/fyK8ZOeHSjKiC1Rpr1y8D+7tLUn2+/rJi2yFSBvjLWq9 Y1u1PzabpHVPoScBi/ub3v4vm3s5b2yflDU/95ycwygVPX42BHIxx01ygEgTKcFX/cBbNscDYm8J fLPG+jdIBQMUz4srxZhxdThJ6U+IkJYknqPNSVdRKQqGPpfEym+gNF2jhKZ4WuMplShlsjEWKSqi KFk/kHWtUwphDDpZXlR2iRGUHgGYFDNkQi05AxZmv2pJc5lFNYVNkn1jFLbY5oGuV09Rdh9te2d2 Ua7O0kjHsD/OXwb4vYcyUfY/f3Xl1xAVzhD3laVOSuUofv+LYIAnY7Wtypq6o23sSu0/MK672fs4 ElV9Rrv35C13Y3fL4meE77rbtPQHwcD6ezAajQcD+vNoKhQMrDhGneizhwf97wkxmOpfJEJHyClm BP5CLfQlZFIz/29TCyf2yYVDkeQBvaUOtkO81yWqPNdBdYpw2+0yqj1BxjI1J54yvNcik5hlhTqK +ij6CtDbpwfCfzWk33cQC2rrybev4miqC6l70LevjEhruveof/7x/1BLBwjlh28XxBYAAHnFAABQ SwMEFAAIAAgA8WlxUQAAAAAAAAAAqwAAADIAIABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvQmFz ZS5scHJvai8uX01haW5NZW51LnhpYlVUDQAHdj20X3c9tF8+NLhfdXgLAAEE9QEAAAQUAAAAY2AV Y2dgYmDwTUxW8A9WiFCAApAYAycQGwFxJRCD+KsZiAKOISFBUCZIxxwg5kdTwogQF0/Oz9VLLCjI SdULSa0occ1Lzk/JzEsHSpaWpOlaWBsamxgZmltamAAAUEsHCHAajcBdAAAAqwAAAFBLAwQUAAAA AADZkXNRAAAAAAAAAAAAAAAAQgAgAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2oveGN1c2VyZGF0 YS9nZ2FyZW4ueGN1c2VyZGF0YWQveGNzY2hlbWVzL1VUDQAHmya3X5wmt1+bJrdfdXgLAAEE9QEA AAQUAAAAUEsDBBQAAAAAAChrdFEAAAAAAAAAAAAAAABMACAAU2NyYXRjaC9TY3JhdGNoLnhjb2Rl cHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL3hjdXNlcmRhdGEvZ2dhcmVuLnhjdXNlcmRhdGFkL1VU DQAHPDS4Xzw0uF88NLhfdXgLAAEE9QEAAAQUAAAAUEsDBBQACAAIAPJpcVEAAAAAAAAAAO4AAABT ACAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL3hjc2hhcmVk ZGF0YS9JREVXb3Jrc3BhY2VDaGVja3MucGxpc3RVVA0AB3g9tF96PbRfeD20X3V4CwABBPUBAAAE FAAAAFWOzQ6CMBAGz/IUtXdYfy7GVIxSTEhQSYQYj4Q22gi0Kavo21v05HUzM/ux9aupyVPaTul2 RafBhBLZVlqo9rqiRb7zF3QdemzMj1F+yWJiatUhyYptmkSE+gAbY2oJwHNOsjQ55cQ1AOIDJfSG aJYAfd8H5UAFlW4GsIPMaiMtvlMX850QCBTUvfnV/+a4q1AVht6I3eU7THjMlYh0Yx4o92U1n20V nkvbusEMBsKBaB8SnAg/k8G3G3ofUEsHCHcVcri8AAAA7gAAAFBLAwQUAAgACADakXNRAAAAAAAA AABmCwAAQQAgAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2oveGNzaGFyZWRkYXRhL3hjc2NoZW1l cy9TY3JhdGNoLnhjc2NoZW1lVVQNAAecJrdfnSa3X5wmt191eAsAAQT1AQAABBQAAADtVk1T2zAQ vfMrPL43JEwKbSeECSSZyUwKDIF+HIW8cdTKkkeWXcKvZ2VZiWWXJsClnalv3n3alZ7fPmtw9pDw oACVMSlOw16nGwYgqIyYiE/Du9vpuw/h2fBgsKArSOAgCII5yfRdGisSwRe7LDgNwt5RtxuadFGL dU7CoYkNznPGoxHVmDDv+KREEc6Bs0cok+SeQ2YWfZ8swgpzbxKzJOWMMj2GFESEW2Nb3LAC1utP hFYIcanfZNfblGsyleoWMo1nbmzBx9zkQuzCXCu5ZHwXaqToihU7UYLw9WMNNfRggw1zN7AEhdyA l8dng5ghdZotGShTK1UsIWodtuA8B8wJ7cN7/YvpUe9j/+j9cf+kP+11u/1R/3g0aa937S5JAmbl giqi6apD0vT5Zg1wC7g5XXQhhSZM2F1R9/LJdXlA3WJJ+aNJ1GGbqbpADpsK2QirmXHK8hI2YgTk Sbz8irjjJYtz3F81FGO4z2N3xAw4UA1RGYxB+bR/M8fpuNxU5iIqy2xCnfl8fN6sNSe5wGHdt5aD +7VWMufRXQY2a4d/pOJsIorW8JmDl+O7Zc0P2fc6V7bsHmzd4KFIBn87X9zSpNe8FHLXxfMMLvJM y+SrVD9xjsdMYU+p1gZ1eeVgLBZSQXZtrDPTuI2FJhquhO3lYyOzpbGkeYK4yoDbPlKiFqAKRmHy gCWdJ+O4gUJbcUA0YflrLml5uAVLcr7hvu2w5pOiv0U51cYKzet2ilQVsZzhlj4jg5aNlhk/71kv Maw3udX+VrWfT73NpP7kULVcg/xquurTZEP2JwSvGLA9Bt9BSQHRrZTcZ/+F0t8h5//6+wf056nN xuzNZR8B2v9hVclbVlUqb0qvkLKCAgivls/ElYqJwNum8qSFLev1bWwm8O/F+QtaVrW8hXhpPrTz Mzx4AlBLBwgGORmGtwIAAGYLAABQSwMEFAAIAAgA8WlxUQAAAAAAAAAAiAMAAEAAIABTY3JhdGNo L1NjcmF0Y2gvQXNzZXRzLnhjYXNzZXRzL0FwcEljb24uYXBwaWNvbnNldC9Db250ZW50cy5qc29u VVQNAAd2PbRfdj20X3Y9tF91eAsAAQT1AQAABBQAAACtk0ELAiEQhe/+imHOXnRZif5KdJBdKyFX WCuGlv3vqW1Q4CX08AZ8j/l4DLgwALROn01A2MMhPgGWPFMwWu+Sj04PyD92GPTVZFvQl2ufm6lI KMz2yv8EytbAYsNOUidbNqwBlm8odxTV9IpVyGJL2SuKatmyDlls2QtJUS1b/iLjPPL8kaaTT/mb jvp+u/g5L9DgR7OB8GHmYP2UAsHS/speUEsHCEfDq3qjAAAAiAMAAFBLAwQUAAgACADuaXFRAAAA AAAAAAB7AAAAQgAgAFNjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3NldHMvQWNjZW50Q29sb3Iu Y29sb3JzZXQvQ29udGVudHMuanNvblVUDQAHcT20X3E9tF9xPbRfdXgLAAEE9QEAAAQUAAAAJYsx CsAgEAR7X3FcbZM2XwkpRA05UA80hoD493jaLOzOTlMAaDlwLgg7HKMCtJkDkCOOsmNN9PpcTMDJ +shTi0vpYnksB019bs5T+Sw7j3rtIhMnAZsSv6sfUEsHCMfjjxJaAAAAewAAAFBLAwQUAAgACADu aXFRAAAAAAAAAACrAAAATQAgAF9fTUFDT1NYL1NjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3Nl dHMvQWNjZW50Q29sb3IuY29sb3JzZXQvLl9Db250ZW50cy5qc29uVVQNAAdxPbRfcT20Xz40uF91 eAsAAQT1AQAABBQAAABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAXElEIP4qxmIAo4hIUFQJkjH HCDmR1PCiBAXT87P1UssKMhJ1QtJrShxzUvOT8nMSwdKlpak6VpYGxqbGBmaW1qYAABQSwcIcBqN wF0AAACrAAAAUEsDBBQACAAIANmRc1EAAAAAAAAAAOsBAABaACAAU2NyYXRjaC9TY3JhdGNoLnhj b2RlcHJvai94Y3VzZXJkYXRhL2dnYXJlbi54Y3VzZXJkYXRhZC94Y3NjaGVtZXMveGNzY2hlbWVt YW5hZ2VtZW50LnBsaXN0VVQNAAebJrdfnSa3X5smt191eAsAAQT1AQAABBQAAAB1kF1vwiAUhq/1 VzC8trSmcx+pNfUrM2m2JtaL3WgYnFiyfhCgU//9qK5zJu4KODzvOQ8E40ORoy9QWlTlCHuOixGU rOKi3I3wOl30H/E47AZ3s7dp+p7MkcyFNihZT+LlFOE+IZGUORAyS2coiZerFNkehMxfMcKZMfKZ kP1+79CGclhVNKAmiaokKHOMbbO+DTjccGzHnLtf6dgqF8yE3U7wCcdwxTIoYK1BrQw1EJCmaO9+ mBZS1LDMOTB9wrebns6oAt7bbNvEJXLOVIqDehGl+QU6gT3BDlToBqTdNkHSCpErs1pKBVpPapFz +pFDVJuKKaDGvuW2p+dPFwPvyR/cD/0Hf+G5rh/5w2j+n6NUoqDq+MfQqBrITanLevrUsPsNUEsH CMYmUIkkAQAA6wEAAFBLAwQUAAgACAAoa3RRAAAAAAAAAAAQcwAAagAgAFNjcmF0Y2gvU2NyYXRj aC54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3VzZXJkYXRhL2dnYXJlbi54Y3VzZXJk YXRhZC9Vc2VySW50ZXJmYWNlU3RhdGUueGN1c2Vyc3RhdGVVVA0ABzw0uF8+NLhfPDS4X3V4CwAB BPUBAAAEFAAAAO28d1xT1/sHfs5dbEgYYQbCRmUjiJO9BMIIhE2IIUAUEkyCiqv32tbWUXetqyo4 UavW1lm1rqpd7llb66yzrda6rf7OzU0Yasenv79+31/hldxzz3nOOc95zvt5znNWBjXWq3T68PAT AAIM4IAAJKCAGbAs9hum1OpUGnWJn1yrqFOhtwI/vaax2E8zaLBSodfZAzh+sYxnJ5ZkKpuV1QlG oqPAHFgUSvRyvZKG6/iYM7AC1sAZuABXEAbCQQSIBFGgJ4gGMaAXiAW9QQJIBEmgCFSASlAN6oAK NAA10AIdGA5GgNFgDGDAODAevAM+BAvBIrAYtIBWsAQsBcvAcrAKfAw2gE/Ap2Az2AJ2gs/BAXAQ fAm+Ad+CI+AoOAa+A+fA9+BHcB88AA/BI/AYPAFPwTPwB3gOMWgBLaEVtIb20AG6Qw8ohCLoDX1g d9gDJsBEmASTYQpMhWkwHWbAgVAMC6EUFsEKWAlrYC2sg41wKHwHvgsnwIlwEpwM34NT4FQ4Dc6C 8+EC2AqXwNVwDfwIboSb4DfwW3gIHoZH4FF4DB6HJ+BJeBZegBfhJXgZ3oA34W/wHvwd3ocP4HP4 AnPCBJgz5oK5Ym6YO+aBCTFPzAfrhnXHemARWCTWB+uL9cP6YwOwVCwNq8AqMRlWhcmxQZgCq8aU WA02GBuKabERWDPGYOOwN7G3sMnYe9gSbCm2DFuOrcBWYm3YKmw1tgZbj23GtmBbsc+xXdhB7Evs K+xr7BvsBHYSO4f9iF3AbmK3sNvYz9hd7DH2BHuK4ziBkziFm+HWuA3Ox51xF9wVj8Aj8Si8Jx6N x+C98Fi8N94H74v3w/vjA/A4PB5PwBPxLDwbF+M5eBEuxwfhCrwaV+I1eC0+FNfiOlyPj8XfwGl8 Ij4Jn4xPw2fhS/Fl+HJ8Bb4Sb8M/wtfjH+Of4hvxrfjn+F58P34MP4Wfxs/h3+MX8Iv4Vfwh/gh/ jD/Bn+LP8D/w54Qj4UQICGfChXAl3Ah3woMQEt2I7kQPIpgIIXoTfYi+RD+iP5FAJBLpRAaRTYgJ CaEgqgklUUPUEnWEihhMDCOGEyOIZmIkMZYYR7xJjCfeIaYS04jpxAxiJjGXmEd8SCwklhLLiI+I tcQ64jBxhDhKHCOOEyeIk8Qp4jRxhjhLfEecI74nfiDOE1eIq8RN4nfiPvGAeEg8Ih6TOEmQJEmR lqQtaUc6kELSk/Qju5M9yDAyiuxFxpL9yHgymUwnC8hCUkoWkcXkIFJBVpNKcjA5kqTJ8eREcgo5 g5xJfkDOIdeS68j15MfkBvIT8lNyI7mJ3Ex+Ru4h95Jfkl+Rx8jj5Dnye/IH8iJ5k7xD3iUfkc/I P8jnFEbhFEGZUxaUDWVL2VEOlCPlRLlSQiqACqYiqRiqDzWAiqOSqBKqlCqjyqkKqpKSUVWUnBpE 1VANlI7SU6OpMdTb1HhqIjWJ+oCaQ82l5lHzqRXUSqqNWkWtpj6mNlCbqd3UHmov9S11iDpMnaRO UacL/dRN9fXHgQ2wBXaABxyAoEgsCR2ibNaVoqfR9kj9FPVyna4V8IE9jdF4K3AETjTBwF50PxnP MSM5pUijHaJrlCuUyRpFU4NSrZfx/CJTYhJSk5JSQhKTUyNCeqbGxIQkJPVMCIkJj46MjY6KjIiJ STXV7Ab8QGgbcAceQAg8gRcQAW/gA3xpkqZoM9qctqAtaSvamrZpA/4gAASCINANdAc9QDAIoW1p O/oe/YCB5gzswcBgBoYyMIxORLwlapXyIY0alVqvS1DoVcOQnayW8dySlTXypnp9SrVKr9EarKcu VaMtzM/SlRvIlBJFnbJBiQrgXvOb1MlKnV6lluuRjZbxwrPkOn2SpqGxXokKzGVNt06Pms1lS5Tr kIVmM6r0zfnKRo0WycPOJJoilbpaM1yHuOBCCVqtXF2rZJOSlYOaajPUNRpELlHWI9krq9vJXfKV CkTD8WwqjGXZwiTFPqA/CG0FfUE/mkfzW8EAEEfb0xdYQYQUKzTVylDUVZkqfWjXMkJzlbVyXZNO omnSKpRJiE7G68XRG76jcrUaFgeSpka2KS/n7kJjYiUZZIPQlSAFpII0kA4ywECQCbJoB1pAu9Bu tAftSYton5VADHJALsgD+UACCkAh7Ucn0eX0UPpt+kP6U/pLOvE4KEbFlYBSUAbKWWwOQsItQ0+t sl7Odg0NaCfaUcY7UKOqV/YJCwuTauoRY7owA18RkQmxEbG962QNEb0TYsKjwiPCZQ2R4QmRUbFR xkB0lEwVEZsQ1TtKlop6VaJqkCVqNDq9rGd4WiJXSqi8sTEsSaNmu1gXlqwcpqzXNCq1YbmIhRqN tkEXli1X5EiKQxuNEZ1oJMmZpuSIiNDwUF31kLAmnTZMpVbUN1Urw6pVSHH0irqwoU3KJmVo3TEg A1VADgaVclqnljcoi7mgUlcolqAeb0XJimKxJGcQJ/IOCdUapOEs4z34/5A0JM1IdxrCslSDtHJt c1iqFrV4OGtQwlI1Tepqg8qF1phiw6Sco6QLSwpLV8qr0VuYWFKgalBqQ+s6y6LeIAtXGe/x/wlZ JGm0yr+WR0K7PJJSk5FJ6yqOoQZxuMt4f/z/UByo2Lpc1nZ1Eckwg0iEMt6j/xMiSWhsZI3732gK oqpXKTipdZHGKIM0vGS8Z/8npPG/AQQN8FkaTWNXidAGiXjLeH1MEinUseS1tXKtUo040w1BU7Qw iUJrMOCmJ5JwMhq8a1kVbOhc3tuG8nz/r0j4n1tnNFAlIQnrkZFmJcy5CO+CGazPNwFMBJPAZPAe mAKmgmlgOu1PB9CBdBDdje5O96CD6ZA2MBPMMvx/AOaAueg5nw6lexr+o+n+9AD0jGO9HLcOF4Zz UkJ1Bi/K4LN5vJpYpxmerVKrGuSNMp73a5PZ1yQNmmjLa5FX5PVamgz1MJVONaheqXtdKfXyZk2T PmUE6g+DYGQ831dLUWg19fUGPzRUU1OjU+pfy08nqnqVWvlnTUpo0tdptLrXJbMASdXUV6vUtccM nbACtLWAlXQYHcW9rwZtS8Ea8BH6rKPD6Qj0iaSj+Pg6nh+vN+eabASbkB/Geq3NrehFYW7q0K3g MyBoAdvomBawnTbMDZCjXa+Xc5VndRWEKdcusBcIWsFusIeOpXu3gn3gC7oP3ZfuV8a2MUNdrRyh 1FVWG73NLKW6Vl/H8foVaFuMePstjuPrEDhcLpYkqwzdjaDaimIUvvHdgeGPj88z1XgcnGJrPAFO 0vF0QqcaC2uQaF6tiy38B3BexnMQS7Kb9HLU0x21LEFJqB5T2RfATRbUF8ElcBlcAVfBT+AauA5u 0Ml0Cp1Kp9HpdAY9kM6ks9rALTSVYUH9K7gD7qLnPTobTWVYUOfTxXQJepb+B+p/A+oXCNQQ0GIj qCGOQA0JSKKPGZ1D56JPHh3F8+DZ8HoYOw7aQDsEXmhLS1ogjy74Z+CFjtAZQQk6gd10IR3bCl2g Ky2li+h+L4GI7/CQY8XTgFlfYPzjAVNJvjDAAEroj0BZ1gpdoQsqR/pKSSb6YBiDgAZDYCgMg+Ew AkbCKNgTRtMVdCUto6toOT2IVtDVtLIN9uKsJ+zLAQ3G0TVG6znYCDTNf0D7F0CDmSzQsuhaE9By WKDlgrswF0roOiTZOlqFgObMszV1WzEsZWFWQg9pgWV0/T+EmQwOMthIKEc2sgFZLFiNLJb6VZg5 /WrKooL1HJ6GIDw1/nkWE70WjmbxpIN62ASHweFwBGyGI+EoWkvraD3dRA+jh9Mj6GZ6ZBscwxku yBjx9DY9ymi4xhrx9OZ/ePo3eJrO4mkGPdqEp/dZPM1GeEIfegySLPuJ4glNnfYhXMSiaSH9Rgtc TNP/EE1L4QrWaC1DRothjdZKZLTGvc5omaeZsqyFH3NoWo/Q9BZrnVaiDOP+FE2b4W4WTVvgVrgN fga3wx1wJ/wc7qLH0+/Q79IT6In0JHoy/R49pQ3uMVqn/fAAPIieX9FTjdZpFj2Xnoee8/9D079B 0ykWTafpaSY0fcei6Rz8Hn3O09PpGegzE/lPsIwPU/lwoKnvrsCfWFBdpd9vgdfo2f8QVLfgLyyo biNQfcCC6lewj56DLM4roJq52Tfe0eiTwThT9ofwCQewxwhgC1hz9SvKPOfPAIYBzBIBDIMYhuEY gZEYhZlh5pgFvZBeRC+mW+hWegm9lF5GL2/DrDiAYXYYD+OjpwO9wgiw1fR6+mP03PAfwP4FwDAv BDBMRK80AgzzRQDD/OBszA8LpNuQsWqjVyFzlcILM3VbMBaKsIWF0GtasDD6o3+GLSwKizEMf1g0 Gv7WInBgsQgc617Flv/3vvE8o2dlghYWhyUaoIUlIGh98ue5TfTpWD4LrQxsIJaJZWHZmBjLwXKx PHojvYneTG+ht9Lb6M/o7fSONkxihFYRVsyOhFgZvdMIrd30fsNIeOA/aP0baNWy0KqjPzdBawgL rXpwl/3Qu5BkdxlGQtPcE9NhTSyw9PSeFmwYvfcfAmskNgZBAxuFjNY+ZLSwschoffE6o2Xb0/fz OxywTHnfxt7lYPUOgtVBFlZjUc4v/hRWU7A5LKymYtOw6dgMbCY2C3sfm419QH9Ff01/Q39LH6IP 00foo/SxNmyuEVYfYguxRejZQh83wuo0/T39A3qe/w9W/wZWH7GwWkufMMHqYxZWGxCsPkWwOokg dYqFFR8+5cNnpo7bhm1nofUZfaYF20Gf/YfQ2o3t42zWXmSzvmPhsR/B49yr0JJ94RvvZxoPfzZl /xY7wqHrMELXj3+e3UR/CjsDQluw0/TFFuwsfbnLvhl23rDueEnGi/lf1jFDR7Dia9RqBpsquYhd BaFLsEvYZewKfYW+Sv+0BPsJu4Zdp6/Rd+nfWEgGd9kNNO6vGncyTTuGWRpu+Vn3evJcrXKYStOk K5Bra5XGuCR2+0vGC3gNuYyL60zN9e0vbF//Sl+no05gv2H3sN9R3H3sAfYQe1TSricl7JqkTi9v aCyr7thSpW/RN+kb9J1/LTHfhD0b+owdFttuLZ5hL0BoK/YH9py+Tf/cigMc0r/Qv9KJUo5lKce/ jGf/anOKjMUbVqJwc9xCxhN2EcTLgl2CW+JWQPF3ZDKeQ7K04NXY17BgbAZui9uB0MWLWXhxEfa4 I1IO3IH+vQV3ou/T/SoyklPE8galRK9FWmdi3UTuhvsDwSrcHffAhbgn7oWLcG/cB/fF/eiH9CP6 Mf2Efko/o/+gn9MvGAhW4QF4IDvZxLvjPfBgPAQPBf4MhAzE2AknA3EGEgwkGUgx0AxF9SvRG7iW JGfKeI5cOBnBSaE0LX+XqnQp9apa1n7JeILOFBm6IpUW4YIFGq+9GKlcq5Kz5xm6lNZJWFy04TyW Hgm5Satsj+RoU+UNqvpmGc+pc2Q2knA9t9X+EhNJGrVCq9QrSxvkCo1uBLsOL+WChYaHjOdTPUxf baAOqUd81IcoNA2NTXqlto/htU6j00tHxMbIYnrmVmbLFYkazRCEgIiY4AhTNyThaUiR8WQ8BU9l oAUDLRlotQRPxzPwgQy0ZmB3Bjqz6hyOerPrQQbjoQfUdklTQ4Nc28x1tERZy4KIPabwSpacRqO2 C15JKlDp65UGdcVzcekyPA/PxyV4AV7IQBsGOjLQhYHuDBQxsJuJ92K8nOW9BC/Fyxhoy0A7BvKW 4BV4JS5jIJ+B9gx0YHkPeKW2LqzmalUaLUqS8Xr8NWGiXDFEomyUIyAja8Pr9tfU3ItUXt+k9I03 5+y6Aoj8MSB6WRnq8PrXtaQBV7O94MRAgaEXfOONi4V5osLEJlV9tSl/E978mvwYDx+Fj6bXM9CV gW50Yn6fVypm8LdfV/F4/B38XQZ6MFDIQE9UcdydLvwfw99DmafgU9ljGNVyvTyHL1AMMp1ohBhO kJTZvz/JaG5RoNVo9DRcx/OysnZw9PQSde8R1rtPX/9+8ekZAzOz8qVFZZV1mkb9cOOxJRtbOx7f vlgsMQqdOyVRLpYk6FHEIKQSOhqjPWm8RNKkUCiV1crq404CW2c34WsOObW6uNIETba6e9AU7Uo7 SsWSVI1ajyiTNPUa7UlvH18/W/+AwKBuKEWiGqlE9dak1str2QrRgKDQqhpZQy6WsObPNz7AOKa/ y6PNaTPaBcE/lN17VXIbaoUZbOmJyDk5ZhscEop8Cq6+jpI6NcKZtmAZD+8pXBIRGcUdhVoSHdOL tkE2T8CefnHgcrN8teeT8USI+QI2PlUpZy2TRKnXI0HpOpG4mEgKMwp1yOtrTzomsO0f1zKAtqOd 2LoTkoWtiUmGc0UpqbQ97cDW6o6ymkpmB1SNNqMa6YCqRqVEmuLcnlrQ3KjsSOEBHnUsW5yT+7oT Ll23cHLy2o+5oBySgsr2HRjD/tMSSWGeaS8KIYprCCtTQ1NQjuISZMtfFmxrad5rYhF1eYWx01vL 807KquSDbBXVyppaVEMRa9zLWSg0NGrUrKErN+JCwp56QxYfvTbp9JqGjsjEcJAULorg4bQbLTyh GjzEtr5hoLpALMlILkRfSUmoXMMwwLOg3WmPHD5/AYLLAjnCCIaA06DWa9PyE0qKS0pFZt8Dc+CM /LlQYCdX6BoTcnOzWHCpES/glb8HpwA0zFRC2LJeTf/LP7IaSQQ9d6FPc7VO0QAA7AeAuZuiUasH wKIYxfsO1zey4dEo7DikID8JhachGmtjXvbPK02pVmpVClEa6htRmhyNFaLI0EgRGolYl+p/5Oof /DXUN7XXjT7WuiGSTPQMRfy/VS1PZsN9UHiDQp4iQeFYFL49TCUVo3A8AJhfoz4xH4UHonB105DC BBQORuG1NdrUQhQegMLf1TWls+GeAOAuI+sKilDYDYWzhmgy2bw+KFyjHiTO4erC31XokkpROAiF 99QpM9g+Q64+flOryWdpugNA2FYrk1NQGPFBxKr0GQXG8HjdMEkKxydxYmRdkpiri7QeLB+Yi8LI vJAByvq0fK4cMqtRn8uWid7JYep6cRbXLvKgUmdoL3qnzPV1BekoHInCBXptQT7HDzW+RpWagcKp KLyqTpuez7WXutNYb8AZkolZqFybksbJxGyEtim/kGuj2VKlupAtH2HE7DyQQjlQAg0YhL4VQA0u AhHQARUYZgjVAjloQB8R4iAYfdIQlRp9tIhCB4YYKLTganu6KQebJwQ0ojQNqEG09SinKV4EqlEJ XE62FA36sG9sydcNcQpjjaHok+S5DDShtzpwG6XXoVA2uGCIGYE4bEDPJBTbhNJqUbhzLVz+XAO3 HA8iI/83jLVoDLzI2/N18JaE0tVgJIrRmdpGOBPhRBT69CWyiP5EuCGXFlE0gxBDfD9DnKnWjpaz bbvRXutQxGvn1neWmEmKu1EuPXqvRy1UG+WjQ9w8Q3mGGHO/1M5pbk1BjY2zp+RlVC7nYsZpZSrF 4al3Doze7gJEpybv+hKI1vC2HmznUXSS2FJ+3PrA6L/o1Vd569qrOZ1xY0BS9Su4QXWRx8gj5Hny BBCh5xXyJHkdhdjD1d+TZ9v56egDTjYmTHB8KSDezkMCqrnekNqAPioDja69P5pQWI++awy5Q17q i7RXWtQ5XdNeey36aF7mwYgYpaF++Wvl879oSCdJ1qinuTU2Vi4f/VTZyMmD7TvlO+IHYjAuOHx9 +O3wpeFrwu+Fn+/ov/DT4T+HnwxvQSm38Jn4RnwHvhXfhn8DROhtG74b32oIrcG3o/+P/0Qjal+j ESzCFEYNYFP1Rgx21pXObU7o1BssvUmGg/8E350xxMryn3HUuZyuFkTZoaW2vrYRtma23W2jbRNs oa03+o+0jUchX1sf2yxbZ5Sabhtom2zr3gl3XI/VGxGk6mIPOI5LUKoJaWqDNZIjSpZCbmzvy20U dWkl2zJVZ2xAG4QNVScb8jrbJeqia4UorwoMN+TXGayD2pCvsQu+dQarhWJgmaEPX8Mb1YcKpFKo wI56qGQqnUpFzwg2ngqjBqJwb5aK8CQiiAxk3XKAiEggool4Y5izeCabZ+hVIg6lDiCSiVjWRnbR BMXftrSzFiJfQ68coWcdgyRNY7NWVVunFxk8cVGGWhEaLIoMj0AjIutnce7DvTyD/wQF3yiatMO4 OIL9IoEl8sEcgSvwBL5oVA9BdfUCfdE4m4LGyBxQgHq2EnFXh7jRItmOBgwYDyaBaeB9MA8sAktB G1gLNoDNYDuyyvvB1+AIOAnOoRHoKrgF7oAH4CmE0AzaQAfoCr2gP+wBI2EsHABTYBbMhyWwCtZC NWyCo+GbcBKcAefBFtgGP4Zb4W74JTwKz8KL8Ab8DT7BcMwac8SEWAAWhsViCVgmVoBVYLXYUGwk 9ha7GI21YmuwTdhu7GvsJHYBu4XdxwFuhQtwbzwEj8WT8Bw0PazBtfhYfCI+G2/F1yIrcAA/jl/A b+OPCYpwIERECOqbdKKQUBBDibHEZGIesZLYROwjjhMXiTvEc9KG9CB7kH3IDLKYrCWHk+PJ2eRy ciP5BbLaV8kHFEUJEC56IbyUUIOpUdRk6kNqHbWLOkpdpu6bmZm5mvUw62+WYyY305uNN5trtsbs c7NjZlfNHplbmXuZR5qnmpeaq83Hmc82X2W+0/yY+TXzpxY8C3+LPhY5FtUWzRZTLZZabLM4bHHV 4qkl3zLQsr9lgeVgS8ZyjuVayy8sv7e8Z2Vl5WPV2yrPSmVFW82xWm910Oqi1WNre+vu1knW5dZN 1lOsV1jvsj5rfc/GxibAJt6m1EZvM8WmzWavzXmbR7YOtqG2GbbVtm/YzrfdZHvM9hc7Czt/uwS7 SruRdrPtPrE7bHebZ8EL4CXx5LyxvPm8rbzTvPt8B34EP4ffwJ/MX8X/kn/d3sw+wD7Fvtr+Lfsl 9nvtLzvgDr4OSQ4Khzcdljp84XDVkXIMdMxwHOw4yfEjx0OOd5zsnXo6SZ1GOM132uF0QYALAgQZ gnrBVMEGwSnBE2ehc4Kz0nmC81rnY84PXdxd4l2ULhNd1rmcdHniKnJNcR3iOt11s+sPboRbd7c8 t+FuC92+cLvt7uje113hPtF9g/t3HphHd498j1EeSzy+8bgv9BSmCRuFc4V7hbc9BZ7xnoM9Z3nu 9Lzh5eA1wEvlNcvrc6+bIidRgqheNEe0T3TH28M73bvJu8X7kPdTn0CfQp9xPut8fvC19I31rfGd 5bvH946fl1+232i/1X7f+Vv4x/rX+X/gf8D/YUBgQFHAOwGbA64HugRmBI4MXB34fZBNUFzQ0KDW oBPdqG6x3YZ0+7Dbke5Y9+judd3ndz/cA+sR00PV48MeR4PJ4N7B6uDW4NMh1iEJIcNCVodcDBWE ZoWOC90c+kuYX1hp2PSwA2HPw6PD69H4di7CPmJgxLiIbRG/RXaPVETOjzwRZROVGvVG1Jaouz17 9FT2XNjzTLRDdHb0O9F7ov+I6RWjjVkbc6OXX6+qXgt6nY51jM2NnRx7sDfZO7H3G723937cJ6aP vs+GPr/2Dek7pO+qvtf7BfZT9lva73J/n/7y/i39LwwQDagasHjAhTjvOHlca9yleN/46vjl8dcS uiUMTliT8EtieKI2cWPiw6Q+SWOSdiXjyWnJE5MPpdinFKbMSzmf6pNam7o69U5adNqotF3pZHpm +vT00xnCDEVGW8adgb0Gjhm4L9M6U5I5L/NSVvcsbda2bCx7YPbM7O/F/mK1eHMOyMnImZnzQ25g 7tDcz/KovNy8+Xk/5Ufkj84/IHGQyCSrJA8KEgumFpwrDCpsKtwjtZOWS9ukD4uSi2YUXSgOKx5T /HWJW4mqZEupWam0dHnp/bKUsvfLrpZHl48vP1URWDGi4stKt8r6yh0yO5lc9kkVWVVUtarqmTxH 3iq/Pyhj0IJBdxRJig8Ut6rjq2dV31D2V85QXqvpXzOj5npt/9qZtTfq4upm191WJanmqe4OTh+8 aPDDITlDVgx5UV9Uv67BvKGqYavaXj1EvU/jqRmhOdrYo3F844WhfYa+P/SONlO7XAd1Fbotekc0 Kf2mKajp7aaLwwYMmz/s0XDp8E9G8EeoR3zT3L15QvO1kakjl40iRilG7RntPZoZfXFMwpiWsXDs oLF73vB94603rtJp9ErGkhnCfDsufNyMcb+/WfTmtreEb9FvXX477e3V423Ha8effqfvO4veJd5V vXtoQtSEuROeT6ye+NWk8EmzJz2brJj81XsR781578WUmimHpsZMXTiNmqaedmp63PSVM/gzRs64 PDN75qZZolkTZ/3+vuz9L2f3nL3oA8sPmj64MCdrzpa5fnOnzX02r27eyfmJ89ct8FgwYcHDD6s/ PLYwfuHaRcJFkxY9WaxafKYlrWVTa0Dr7CXUkmFLfloqXXpgWeyytuVuyyct/2OFesWFlfkr97X1 amtb5bFq6mpsddPqG2vK1xz5KPmjLWtD1rasE6ybtB6sb1p/8+Oqj09tyNyw55PYT9Z+6v/pgo0O GydugpuaN93ZXLf5wpaSLUe3Dty6Z1vfbRs/C/1sxXbv7fN3OO2YutNy51s7X3w+8vP7uxp33d5d u/vyHtmec3uL957Yl7fv0BeZXxzcn7p/74GEA58f7H9w+5d9vtz6VexXm7+O+XrTN9HfbPw2+tuN h2IObTrc6/CWI72PbDva7+jOY3HHdh9PPr7/RMaJr0+KTx49VXjqzOny0xfOVJ+5frb+7N3vhn33 9ByNHPuJP/B+mH3e43zrj91+XHch5sKOi8kXv7kkuXTusuLyrSu6K8+uvvWTzU+zr3lda7seeX37 jdQbR26W3bx6q/HW09vjf+b/vOCXoF8+/TX+12/uFN+5eld798Vvk++53lvxe8/f99zPvX/+QcOD pw8nPnJ9tPJx7OMDT4qeXHs6/JnZszl/dPtj2/PM59+/aHjx4li2eKi2y6pPqy6vyzuiaBpmWi9s bcpD7yOaDUtD7Ytq1dxKZevIvNfGA3PAN9yF7GbwLDLQrD0PSNDsYxQYh/yIGciHaAFLwDKwDmwC Ow3Xrg8hH+I48iJOg7PIj7gO7oEnEIc86AxF0Bd5EIGwG0yEabAa1sA6qIE65D0Mh81wDHwDMsiL eBvOhzuR33AeXoCX4BX2HA+8gzyI+/AhfAyfYq5YFBaN9cL6YWlYLvIgqjAVpsbGYAw2AZuPLcY+ QT7El9gh5EOcwS4jL+IRTuJuuBB5Eb64Px6Ih+PReF/kTaTgaXiG4w3HXxyfOj53snLiObk4uTuJ nKKdYjkPC4PG1ZtRXdd1nLIZ6MVtfU3HZ1R0HMGW6+VLUNRMoJCKJeybaXn7fXwBCF2Ol+Af4HPw MnwePt+wyO3NQB8G8hjoy0C/5XgFvhBfhC9G3wsN2wb+DAxgYJAh4M/uH/j89UI/u6b5t0TsNSwZ L/DviST65vq/p2RvuRkoefAYvgo1dTW+hl3KZjcxfRP2fBp9ZLvddAYGcuJai6/jJKNEzhu7Hcgr 0FTLm0VyvSiiT2RPUW42R7cB/+TldVV8A3uyn3eT25rZhEtbgD2Nd9qF2YZvB6GGyBZ8BwND6ESO dFcHKRexD5cubn85ANra2Hug+FcI2ykgDT+EH8aPsDdBGRhOe9AOtAsDIxnYk4ExdFSnLWz8JLuF zcCI/yt3Z/7f307Cv+NEEvXfjb4OmfzIyST6vwuwoAx7aDj2ccOksj/hv4DQFfg1/Dp+A7+J30LT uJ8ZGMvA3gzsw8C+DOzHwP4MHLAC/xW/A2bhv+HX2L13BsYxmBPdk8EEiNxw0BtZxwGdb/0XyAex 4mDP6yi1st7RCVEJsVG9Q6J7pUSH9ExI7BWSGB6eEJIU2zsiJio8OiEltVclm91ws93QWm63lotA hSXKtUVynZQ7ZlSk0tdJkA2sZ6uR8YI6V8zlkIkl+UqdXqNlDZjhwBA7HMh4XiZrqvwTTnmuHbVq NPWD5NoMU63cRnZnjtqTTAJ9QViA0DYCEJDACJwgCBLNis0IcwbGMzCBgYkMTGJgMgNTGJjKwDQG prcBf8KKsCZsCFvCjuChN3saDU0ZDGxk4FAG6hnYxMDhbNxIVso8xIOkTjNcLB+mquX2n3mGAxbG 1wStErWTj6IK9ap6lV6l1BWpqvV1HFmGWtdo2JXrIGvPaSArl6qUww0/OlDLSsMhW9mg0TanaeWN dR2xJh7aa2CPeHDHQthyjdIgPAlfELqU8CJEhDeB7PlABmYyMIuB2UsJP8IfRQcyUMzAUkN8Pds6 UZcfJWhnLbS9t2Q8jz8hMbCHmmQ6W9RJQHZpWk1To8R0wkdnYjCUiGIZDCPCiQgCDTI5DMxlYB4D 85cSPYloIoZAw46EgQUMLEQBw89HpKrq9UruByISm9nNukwl8uj47K8/tNeYzZ3iKFTXvJbYhStD WV2Y0TXJxNcAIg4IFi9mz5W5dO4hlkyiQSJHNsFEm0SkAEELgTAlbSEQpor+MtcxlGMgkUlkyXhu SIysduSyu/XIs9Aqdch4GSwLA0sYWJzDh2913csXOAtLVMguGbhGMKhHjU5QKJQ6nbKadSoquQN6 uRqdii2mQmfsigyUR7eUsubZHzMzt7AqaJTr60pU7D2+dJVa32ppaTqOwAPHbGztrF5XtHJEo9xw nM5QeVTCnk/mOp0ZchgVyLdqsTzm4Oj0z7PJRGxgydMp/rxWF7dWV9f221et7h6+8UO5sG/8JO60 Q4snqsXLe4mlpaiiy01eHjS45+4gFPRHTkwuKERWthrUAg0YCoaBCWAOcs6Xg5XgI7ALHAZnwEVw BVwDd5BL/gyS0AxaI7fc8yVn16erswtFBpeMyCFykUlMGdFYzxm1nCY9ewSSVVfuvAQbaQTUEiKP yGfdu39IL+MNkhXo05KkETHJ0oKOPEjBImNeWwTr6up6mbJLJbKoiA46Q6QEwU9d22nz3wTYAqIM +eJEISEliohiooRA6l/GwHIGVjCwkoEyBlYtJ8qJCnAXGcMqdrSRM3AQXcKawCHcUMPiG9WiGMLu viPgsh1sOGAj4zmjJIMpKNCyHW84f8P+mAtKSU5Ma1cK41jNaaqL0Z7lqOubkWOlRown1msUQ3Ts mGQ08fkIyTKesBNlhppVYvYnYGqNpfEwUyOHEI2sZaknGgg1oWGggoHVDFQysGYpMZTQooYhu17L QBXbqMFsk5xMfKewiK02Ko2M54vik5q0WvY8nrxJraiTcM3NV9ag2tUKzqREIKp0+TBlhhppnry+ vtlUSlJuIWe3WS7rVPXVKI+xzz1NNXa1mKithqoN/jkxihjTgkP6VwZyhw2JNwi6vH1qIFHql6AY BigKxRL0Ut6rJjY2XB7ZKwo5UlwBb3HePrKco0aFB4vCxwSLRkX2igwWxfbuOWaMSV7vEpNAaCsx gZjIwAYGqluJyYSIgUhymaxw/F9v8w1mPRTNh5qMp+y8/4rOOED87RDjG98Yb1A9E3OziNloZkO8 z0BtC/EBA3UsS95NOiV7MBX1ArLkSUiitWigbD/0m5FsFOB8rv3tVsVU6CKihS0UpQ1rAf7Ih0Jl urPQ0rHYMoKOVTXurEv7mLWcaGMltYJYycARDGxuZY+FGw6CsyBqLyBLKR+irOZQjNye4vz2FCNW U7WahvYmmwpfT3wOQtcSHxMbiE+IT4mNxCZiM7GF2EpsIz4jthM7iJ0MHMXA0Qwcw8CxDHyDgTQD GQaOY+CbDHyLgW8zcDwD32Hgu2vBXWI3sYfYS+xDPqM/cQC9f0l8RXxNfIMYRgPMBAai3p7NwA9Q 65EazGUj5zEQzc1XMBjgWhSZqETusjJbPkLVoBqpZPVdrlXpNGqD5rJHcI2i4twPTp9Fxpemer2K PV6FBjH2cB97NpE7m40GbJM3Y0hk5VzapQSTTnR4NQZCw+XzXDR8VRgNgfHEMY/HvpjK5JwrOyO2 DIMPmqFXmhpRbVRAkfE3pzp+LKrrMMxqfyPHtokNw8G46q5kqNtf4tJk8RwMGm6ow8Aax1fQX4pU pWtnU8azN4orS1mjL9Dks/tkJqj8SFxk8XuBgZNaiEsMnMz2Fh8NH+0C7WRFfsKlrcQ14joD32Pg zI5FA+IW8SsQLCFuEz8TvzBwCgOnMnDaEuIOwstvDJzOwmIG3a8CFdsxkpSzbx1OOQ+9stVly2uR 8WuqVpa0O6O+8eN5XZTuCfH8ddW9AP4kZOAstrr3Wf/JzmQajZ3pG6/jtJcHjpNmpDly9VdCb9IC tVgsaccEd/7ecJCsPc4wKjFwjsF4klakdVmnxFbSBig6R5TmNCrVGWo0uzDpO8kj+dz56pOkI+mE IgSkM+lCupJupDu4yzb/pdPalR2SYos0UDTIVerO5/BcDTXm1JjydqQxcCkDP2TgcgYuoEtkvLB2 a9lldOCK7LCZ7TbY0N+kF2hbQopIbxJ5/QsZ2MLAVjrqOOlPBqDEQHwh2a20o8pCAzMMXGRYaFvc 1cXi5BZMhiDHn527tbsu3CqYUXIqbSsZyjo8f0ljZACH4C7Zjf6VNTeLTUz1ZOMYuMQQ2X461nBD 4B6gyT6glPZm4DIacAz1Jwe8/qx8KxnH8vG6JC5nApnIzVi7yLOD56663UomscX9Y3pO/Cm4tIVE c4GVHZpGZpBi5JGQA8lMMovMZmAbA1cxcDUD1ywlc8hcMg/cZeBHDESq/AL5Wqwyc0rETXWNJsuB i0tXsXPrZoMLpitjGcpE7jzyRDoZUVPFJWQFCF1ClpJlJPLx1jJwHQPXLyErwV12mfVjVuCGxVV7 FvUJOmPRRu+HZ7LDKNHQj+yv5jWr5Q0qhSmGa3INaGsla8k6Bm5g4BE66gw5hKwnG0g1StOQjeRQ MpDUkXqyiRxGBoJMEvlMrqbrHV0kKzasPXiza0XskgHr6IbqDDh62era6QzrCu1HU9H4re5c0sv0 fPXL9XS+YIJym946nIhOaom0YxsDP2PgJww8jF5p5B4d6mwTRpGjOZvAwK0M/NSkwpx4GFYhx5Fv kmiI3sjATQzc/JJCtuvfX2nJVE5LtvytliDpNjYNqlcpjGep0agVogjRGW5jmYAxl1wCQtvIeeR8 cgH5IbmQXEQuJlvIVgZuZ+AOBiJf43MG7mLgbgbuYeBeBu5rI5dy9+DIldz1SnINA7/gLsIx8CB3 wZKB3/x3Fe5fXIUjt4C2FhJhZ7/xLhy5HbQtJXcgdOxgVfWAAR/sNx3FszL14j5yPxC0kF8w8MsW EiV+9c9uw5Ffk4cMt+HIb+lYBn7dCl2xsXTRn9+WJE+Qpw3338hTdDwDv/3zDP/rT1tydvk8+SP3 w6VdLByrqa3kBdYGvzbtVTNzibwMSsmryMxcA1lkMwNPMvACDRh41KC3F9mNjS56e4u8jfT2F1Zv f2TgcYPeHmOH3tC/HHrbl4RTkaViB3quy35ju+we+Tt5n3zAwBMMPM3A7xj4fYe2XyKfsDqM2DqF lNhw66LLj3HxikyULyjAUp5h4FlEWdqx8szLM5JQJGcQzhkMQmnHMrUp3ZKyYtN/YOB5lqCBXeUW savcPDOT2XjbYDZ8jWbDzmg2FCF1hoVsFDMIzXLrkBM8JIi9FsDtG1ECNMRRzgy8zO4kUW4oxp3y QDN5BTdVfqWjGHiFgc9fOypQIsrbNCqY7OxtBl59vZ2lAqkgk529xcCfuthZKgTZWSqUCqPCGXiN gcjhvfEv7CzVlxPrzb+1s0bloJIpNLq3USlUKpVGpVMZ1EAqk8qi0Dj/MwORq4vm73cYiFhGXvU9 Bv7OwPttVA5nSykJZ0upIgY+MNnSRyZb+uw/W/ovbCmlQLaUqmbgQ6MtpWpfe13d1H9qqhFZUUrD wMct1FAGPvlnVpRqokYYrCg1nLWiT//WilJjKcZgRSmataJ//HkGg1Wk3qHe5ZamXvX7WqkJrFl8 fSI7hTJ6hbIu90WpydR05IdS71FTqKnUNAaDDIYxGM5gxFJqBjWTKKfeZzCSwSzZZT/MgU4sZief 7ASPq6t9etk+oy3lZMP6nCWGKSqbaqpuAdXCVvchtZBaRC1mMIrBzBjMnMEsWE/iLnQF/gjwJUgE 3AqM4XInCzm2EMOaSb58uGESx/48c9dUo2sqUWjYfX9Rl0QDgUbb6TYRe9vx1dJZ/9LE6xpqLZpS Ux8xmFULtY7BrP9iSk19gqbU1KfURgazYTBeh6NPbaG2v2aOS+1ACv45g7F3ZDE7ul+7VH3j6Tud 58jUPurg6/J/CfyprxmMj+bImD3dr0PSvvFvruxSwBHqGNuMowzm2IKwzs0lkpCGauqV3M4Ht8bi bFgQjI1mVwQjevWODBZFhEeEjxljuFRIncGn5vAJt5cvEwb828uEP/LszC0sray5G4IOjk4CZxdX N3cPd08vEXuRz79CLOm0/VjE7p/q2fUFvsyUwO0oKrWlKA1NitiVJ0SWoUP1SMWSwoyM5GL2NRsN z9xtMpWW3VnRNWrQPEWL5vmGO+vcBIPXXiqHXl0Ze2exuV6ZLdcNMVze41LbZ9gZyVy1adpGQz3s 9Kd6RKWJTtzUMEippSGN05S5BY1Z0IAmaDM+bUeTNJ8H+OZh63j2gUHduvcIDgnt1X9AXEpmVnau hLs3KeMJw1FPiNhuMPSCiP03vvWOFkkRt30iY7tOzdGU7dWN11zjSrbRlnTsrB4PC4+I7Bnz578l 3xJFm7dE09Y073hs74g+ffsZbiKisU+pVHMyKizMSOam9IajUp2T2FuO3C/Cy3h+UUkxSRHJEREh qck9I0LCUyJjQiJSU9BXeFRqZGLP8KSY3inlJshFRIaPORafkJj0uquHlV1raU1M7viN7dS0iPSM gWii07Uju2xhe3VN61yWgcJwW9Puz1UBmYyOVXNTQu/oMSzH4pzKrqW3ipNRdF5+1/uSecmV4SN6 1SirY+W9esXIFeGvnCgbDEYAGhnDRWAFWAs2g6/AKXAD3IdWUAC9YCgMh5HszwjCGBgLe8O+sD+M g4kwGabCdJgJq2ANHA/fg/Phevgx/BIegWfgZXgT3jaeGvsdPsUEWA8sBAvDIrBiTIkNxpqwsdh7 2DRsLrYY246dxy5gl7Ar2HPcGffAe+CheBQejye9tC1W0HVbDM9noBdqiivwAcEgAvQBcSAPSEE5 qCSmEbOJJcRqYhOxg9hD7CP2E18T3xJHiGPEDZJHCslwMpLsScaQsWQfsh85gIwnE8lCsogsIcvI CrKKVJA1pAr5iWrybbKVXEfuJx9TVlQQ1YcqpKSUgqqjBlP11FBKh4bf4dQK6iL1C/XCDJrhZqSZ mZmFmZWZjZmdmcjMx8zPLMAsyKy7WbBZqFm4WaRZnFmamcSs0KzIrMTc1zzYvJd5vHmqeaZ5gbnc XGGuNK+1qLJosNBYDLXQWWosR1uOtaQtx1mNs5pqNd1qptX71tOsP7ReZN1ivcSm1Wadzcc2n9hs tPnN5oUttMVtSTvCjm/nZxdgF2TX3S7YLtQu3C7SrqddjF2GXaZdtl2OXZ6dxK7QrsiuxK7MrsJu pN1cux12P/JwXjdeNq+eN4k3i/cBby5vPm8p7yPeOt7HvE94G3mbedt423k7eQd4h3kneCd5l3hX edd4N3m3eb/wrfgufCHfi+/ND+AH8bvzg/mx/DR+Lj+PL+FL+TJ+PX8ofyR/DH8ifyp/On8mfw5/ Hn8BfyF/Kf8T/nb+Mf5Z/k/8x/yn/D/4L+yhPW5P2pvZW9hb2Xvai+x97P3sA+yD7LvbB9uH2ofb R9rn2KvtZ9h/an/G/rmDj0OCQ5WDyqHeQe3Q6NDsMM7hLYfxDu86THSY7DDFYZrDDIdFDq0OSx1W OLQ5rHY46HDS4TuH7x3OO1x2uOpwzeGGwyOHp46EI+lo5shztHf0cvRzDHAMcgxxDHOMcIxyTHTM cRzkWO1Y41jnONix3lHt2OioddQ7vuM4wXGS43uOUx2nO850fN/xA8e5jvMdtziednzqJHRKcKp1 muS0yulLp2NOJ51OO511uuR0y+lnp1+d7jrdc7rv9NDpsYASWAisBLYCnsBeECboJ0gQJAlSBAMF WQKxIFcgEwwSaAR6wTDBCMEYwRsCRvCmYIZgkWCD4FPBJsEWwTbBdsFOwS7BHsE+wWnBWcE5wQ+C HwUXBZcFVwXXBDcEt5zNnQOdM50bnKc7b3Y+5/zExdXFx8XfJdClm0ukS1+X/i5xLgkuSS4pLmku BS5FLiUu5S6VLlUuY1wmukx1me4y02WOyzyXBS4LXT5yWe+yw2WPyz6X/S5fu3zrctjlqMsFl59d gSvmSrhSruaulq7WrrauPFd7V3/XQNdurj1cQ1zDXCNco1yjXXu59naVuja5znX9zPVHN9Ktm1u6 W61bo5vOrcltuBvtNsFtktt7blPdprvNdJvtNtdtgVub2xq3tW4fu33ittHtmNuPblfcfnK77vaz 269ud93uuWPupLutO9/d093X3d890D3YPdQ93D3SPcFd7C53V7gr3WvdVe5D3BvcNe5D3XXu493f dZ/oPtl9ivs09xnus9xnu89xn+e+2f2U+xMPD494jxqPiR5tHgc9jnqc8DjlccbjosdNj9sev3jc 8fjN43ePBx6PhKTQXGgptBHaCfnCUGFfYbwwUZgszBBmCrOFOcJKoVw4WFgvbBaOFdLCccJ3hBOE k4TvCRcI24TbhTuFu4R7hPuE+4UHhV8JvxEeEl4UXhZeFV4T3hDeEv4s/FV4V3hPeN/T3jPCs9Bz uOd8z92eV70IL1+vYK8wrwivKK9+XileaV4ZXple2V45XnlelV5yL4VXjVed12Cvd7xmec31mu/1 oVer11Kv5V4rvTZ7bfPa63XE66TXaa+zXue9Lnhd8rridU8ERA4iJ5GzyFXkLhKKkJMj8hX5i2JF fUT9RANE8aJEUbIoVZQuGijKEqlE74rWiA6JfvN28e7nXeY90vtN7/He73pP9J7pvcB7ofdi71bv pd7Lvdu813hv9d7uvdN7t/de7y+8L3n/6v279wPvR95/eL/wgT64j72Pk4+nj7dPqE+UT7RPL59+ PgN84n0SffJ8Kn3kPgqfGp86n8E+w32afUb5jPHZ5LPX5yufb3wO+RzxOe1z1ueczw8+P/ra+vb3 rfHV+Gp99b7DfN/xne4733eFb5vvat+PfNf5Xve96/vcD/cj/cz8rP1s/Xh+9n6ufiK/aL/+fql+ NX4Nfu/5LfHb4veF336/A35f+p3yO+t3zu+83wW/S353/B75k/5u/h7+nv4ifx9/P/8A/yD/7v7B /mH+yf5p/gP9s/zF/nn+Bf5F/qX+Ff4yf7n/EP9x/u/5L/ff6n/E/6r/kwD7gB4BMQH9A5IC6gI0 AY0BbwRMDpgZMDtgbsCCgCUBywPaAtYErA24GPAs0CnQM7BbYHBgWGBkYHRgbGDfwPTAnMD8wMLA 4kBZ4KBAZWBd4ODAmYG7A38OfBD4RxAZZB/kGuQR5BXkE9QtKDgoLCgyqGdQ/6C4oJSg/KCSoPIg WdCgIFXQkCB10NAgXdCwoLFBk4JmBL0fNCdoflBr0LKglUGrgz4K2hS0I2h/0KG46LjYuIS4nDhp XEXc4LjhcSPjxsTRcW/GjY+bEDc7bm7cgrhFca1xy+JWxq2KOxz3e7xnfHr8wHhJfFl8dXxtfGP8 8PjR8VPj58SviF8bvz5+a/z2+J3xu+MPxR+NPx5/Kv5s/Ln4K/HX4m/E346/H/8g/nECluCU4Jzg muCR4JkgSvBJ8E8ISuiREJLQJ6FfwoCEhMT4xOzEnMS8xIKkgiR5kiJJmVSXLE9WJzcma5P1yUzy tOSZybOT5yYvSF6U3Jq8LPnT5M3J25K3J3+evCd5X/L+5IMpFikuKQkp9SlTUlalfJFyLOVqyvWU Wym/pNxN+T3lYcqTlD9SQapDqlOqS6p7qmeqd6pfamBqt9Tg1NDUhNSC1LrUUalTUxekbkj9IvV4 6oXUG6m3U39N/S31furzNJhGpJmlWaZZp4WlidMGpenTmLSJae+lTUubmTY7bVFaa9qytJVpq9M+ StuXdibtbrp1umu6W7p7ujA9Nj0lPT09M12cnpcuSVenD0+flf5B+ryBPgN7DCwYWDbwrYE3Bj7I xDOpTItM60y7TPtMp0yfTP/MoMzumcGZYZkRmVGZ4sy6zHGZH2auyfwm81Dmucwrmdcyb2b+nHkn 83Hms8wXWTCLyKKyPLOSs0Zkzc1qzVqWtSJrVdYnWbuyDmR9m/Vd1uWsK1nXsp5nW2Xzsh2yBdnu 2Z7Z3tm+2ZnZmuwZ2fOzV2avzl6b/XH2p9mbsr/Lvpx9Jfta9p3sP8RAjIspsbnYUhwkjhb3EfcX x4tTxGniDHGmWCF+WzxDvE68QbxRvEX8mXineLd4n/iA+Cvxt+Ij4uPiU+Kz4gfiR+Kn4uc5MIfI oXLMc6xybHJ4OQ45ghzXHPccYU5+TlPOhJxZOZtzvsg5k3Mz53GuR25ibmluY+783PW5O3J35e7N 3Z/7Ze7XuT/mXs/9OfdO7r3cB3l4nmWeTR4vzyHPLU+Y55Xnk+eXF5kXl5efV56nzNPmNeeNznsj b1zehLzJeVPypufNzFuWtzZvfd6OvKN5V/Ku5d3Je5YP823yXfL98wPyA/O75Q/Iz8uvytflT82f kf9+/pz8+fkf5h/OP5P/Y/6l/Kv51/Nv5j+UYBJziZXEVsKXeEmCJGmSLMkQyQjJSMloyRuSyZKp kumSWZIFkjbJaslayXrJVslhyQnJTcm9As8C3wJxQVFBaUFFQVVBQ8GwguaC0QVvFIwrmFQwpWB6 wayC2QVzCtYU7Ck4VHC24KeCnwvuFNwreFDwRyEoxArJQrNCj8KwwoTCgYU5hfmFhYVFhSMKZxVu Kfyq8HrhM6m5NEDaTRosDZNGSqOlsdI+0v7SfGmhtFhaJq2UVklV0kapTjpM2iwdJX1XOkk6RTpd ulC6WNoqXSbdIN0o3SzdJt0jPSw9Kj0hPSX9TfqiyL7IqcilyL3Is8i7yK8osKh7UUhRfFFSUUpR WlFGUVaRuCi3KL+osKioSF80s2hz0dmiP4p9i9OKa4rfLp5SPL14VvHs4kXFK4tXF68t/rj40+JN xVuKvyg+WPx18aHio8XHi+8U/1GClRAlZiXWJbYlvBL7Eu+S0JKokuiS2JL+JXElCSVJJfkl40om lbSWrCjZWfJjyaWSqyXXSm6W/Fxyp+S3kvullqU2pbxSh1JBqUtpRml+aVlpZam8tLq0tlRVOqy0 uXR06Rul00tnli4uXVK6vLSt9NPSTaV7S/eXHiz9uvRU6eXSn0pvlN4ufVj6uIwqMy+zKrMp8yqL KOtT1r8sviypLKustmxwWUPZlLLpZbPKPiibV/Zh2eKy1rJlZdvKdpTtKttbtr/sYNnRsjNl58rO l10su1x2p+xe2YOyx+VUuXm5ZblNuVu5sNyr3Ke8e3mv8t7l/coHlGeWV5bLy6vLa8sHlzeUN5br yoeVN5dPLp9aPr18Zvn75XPK55UvKF9Y3lK+pHxX+Y8VeIV/RUaFpmJmxYaKoxXfVfxQcaHiUsWt it8rHlQ8qnhS8azieaVVpW0lv9Kx0rnStTKmMqkyvXJgZXZlfmVBpbSyuLK2Ul/ZXDmqcmzlm5Vv V75TOaFyTmVL5dbKnZWnKq9X3q98LoMyQmYms5Q5yAQyV5mHzEvmLesuS5Rly4pk1bIGWaNMJxsm a5aNk70lGy97VzZRNlm2SnZAdrMKr+JVOVQJqlyrPKo8qyKr+lbFVyVVpVZlVEmrKqqqqhRVNVUN VY1V2qqmquFVdNWEqtlVH1YtrlpStbzqo6r1VRuqNlZtrtpd9VXV6arvqn6oulB1qepK1SO5vdxd 2ds4rcO4J/Vd12mdst//A1BLBwjDGCAv7T8AABBzAABQSwECFAMUAAAAAAAaa3RRAAAAAAAAAAAA AAAACAAgAAAAAAAAAAAA7UEAAAAAU2NyYXRjaC9VVA0AByU0uF8nNLhfJzS4X3V4CwABBPUBAAAE FAAAAFBLAQIUAxQACAAIABprdFGW3gKobQAAANIAAAASACAAAAAAAAAAAADtgUYAAABfX01BQ09T WC8uX1NjcmF0Y2hVVA0AByU0uF8nNLhfPjS4X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQAAAAAANqR c1EAAAAAAAAAAAAAAAAaACAAAAAAAAAAAADtQRMBAABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9q L1VUDQAHnCa3X5wmt19pKLdfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA2pFzUWczd7lgAAAA sAAAACQAIAAAAAAAAAAAAO2BawEAAF9fTUFDT1NYL1NjcmF0Y2gvLl9TY3JhdGNoLnhjb2RlcHJv alVUDQAHnCa3X5wmt18+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAAAAAAGWt0UQAAAAAAAAAA AAAAABAAIAAAAAAAAAAAAO1BPQIAAFNjcmF0Y2gvU2NyYXRjaC9VVA0AByM0uF8kNLhfJDS4X3V4 CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIABlrdFGW3gKobQAAANIAAAAaACAAAAAAAAAAAADtgYsC AABfX01BQ09TWC9TY3JhdGNoLy5fU2NyYXRjaFVUDQAHIzS4XyQ0uF8+NLhfdXgLAAEE9QEAAAQU AAAAUEsBAhQDFAAIAAgA8WlxUVH/ko18CQAAiy4AACkAIAAAAAAAAAAAAKSBYAMAAFNjcmF0Y2gv U2NyYXRjaC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qVVQNAAd2PbRfdj20X3Y9tF91eAsAAQT1 AQAABBQAAABQSwECFAMUAAAAAADyaXFRAAAAAAAAAAAAAAAAJQAgAAAAAAAAAAAA7UFTDQAAU2Ny YXRjaC9TY3JhdGNoLnhjb2RlcHJvai94Y3VzZXJkYXRhL1VUDQAHeD20X/t0tV94PbRfdXgLAAEE 9QEAAAQUAAAAUEsBAhQDFAAAAAAA8mlxUQAAAAAAAAAAAAAAAC4AIAAAAAAAAAAAAO1Btg0AAFNj cmF0Y2gvU2NyYXRjaC54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS9VVA0AB3g9tF/7dLVf o/q2X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPJpcVGUiBETXQAAALAAAAA4ACAAAAAAAAAA AADtgSIOAABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qLy5fcHJvamVjdC54Y3dv cmtzcGFjZVVUDQAHeD20X/t0tV8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAAAAAA2pFzUQAA AAAAAAAAAAAAACcAIAAAAAAAAAAAAO1BBQ8AAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2oveGNz aGFyZWRkYXRhL1VUDQAHnCa3X5wmt1+cJrdfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA7mlx USf615qEAAAArgAAAB0AIAAAAAAAAAAAAKSBag8AAFNjcmF0Y2gvU2NyYXRjaC9BcHBEZWxlZ2F0 ZS5oVVQNAAdxPbRfcj20X3E9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADuaXFRcBqNwF0A AACrAAAAKAAgAAAAAAAAAAAApIFZEAAAX19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoLy5fQXBwRGVs ZWdhdGUuaFVUDQAHcT20X3I9tF8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAAAAAA82lxUQAA AAAAAAAAAAAAACAAIAAAAAAAAAAAAO1BLBEAAFNjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3Nl dHMvVVQNAAd7PbRfez20X3s9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADzaXFRlt4CqG0A AADSAAAAKgAgAAAAAAAAAAAA7YGKEQAAX19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoLy5fQXNzZXRz LnhjYXNzZXRzVVQNAAd7PbRfez20Xz40uF91eAsAAQT1AQAABBQAAABQSwECFAMUAAAAAADzaXFR AAAAAAAAAAAAAAAAGwAgAAAAAAAAAAAA7UFvEgAAU2NyYXRjaC9TY3JhdGNoL0Jhc2UubHByb2ov VVQNAAd7PbRfez20X3s9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADzaXFRlt4CqG0AAADS AAAAJQAgAAAAAAAAAAAA7YHIEgAAX19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoLy5fQmFzZS5scHJv alVUDQAHez20X3s9tF8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA8WlxUWsmVvLMAAAA IAEAABYAIAAAAAAAAAAAAKSBqBMAAFNjcmF0Y2gvU2NyYXRjaC9tYWluLm1VVA0AB3Y9tF93PbRf dj20X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVFwGo3AXQAAAKsAAAAhACAAAAAAAAAA AACkgdgUAABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvLl9tYWluLm1VVA0AB3Y9tF93PbRfPjS4 X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIABhrdFFw8JHD3gQAADQOAAAdACAAAAAAAAAAAACk gaQVAABTY3JhdGNoL1NjcmF0Y2gvQXBwRGVsZWdhdGUubVVUDQAHIDS4XyE0uF8gNLhfdXgLAAEE 9QEAAAQUAAAAUEsBAhQDFAAIAAgAGGt0UWzjhjdXAAAAsAAAACgAIAAAAAAAAAAAAKSB7RoAAF9f TUFDT1NYL1NjcmF0Y2gvU2NyYXRjaC8uX0FwcERlbGVnYXRlLm1VVA0AByA0uF8hNLhfPjS4X3V4 CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVHejftO1AAAAEIBAAAkACAAAAAAAAAAAACkgbob AABTY3JhdGNoL1NjcmF0Y2gvU2NyYXRjaC5lbnRpdGxlbWVudHNVVA0AB3Y9tF93PbRfdj20X3V4 CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVFwGo3AXQAAAKsAAAAvACAAAAAAAAAAAACkgQAd AABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvLl9TY3JhdGNoLmVudGl0bGVtZW50c1VUDQAHdj20 X3c9tF8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA8WlxUc1FbWmnAQAAygMAABoAIAAA AAAAAAAAAKSB2h0AAFNjcmF0Y2gvU2NyYXRjaC9JbmZvLnBsaXN0VVQNAAd2PbRfdj20X3Y9tF91 eAsAAQT1AQAABBQAAABQSwECFAMUAAAAAADyaXFRAAAAAAAAAAAAAAAAOAAgAAAAAAAAAAAA7UHp HwAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai94Y3VzZXJkYXRhL2dnYXJlbi54Y3VzZXJkYXRh ZC9VVA0AB3g9tF/7dLVfeD20X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVFKmO8eYwAA AIcAAABGACAAAAAAAAAAAACkgV8gAABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL3Byb2plY3Qu eGN3b3Jrc3BhY2UvY29udGVudHMueGN3b3Jrc3BhY2VkYXRhVVQNAAd3PbRfej20X3c9tF91eAsA AQT1AQAABBQAAABQSwECFAMUAAAAAADxaXFRAAAAAAAAAAAAAAAAOQAgAAAAAAAAAAAA7UFWIQAA U2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL3hjdXNlcmRhdGEv VVQNAAd3PbRf+3S1X3c9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAAAAADyaXFRAAAAAAAAAAAA AAAAOwAgAAAAAAAAAAAA7UHNIQAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai9wcm9qZWN0Lnhj d29ya3NwYWNlL3hjc2hhcmVkZGF0YS9VVA0AB3g9tF/7dLVfeD20X3V4CwABBPUBAAAEFAAAAFBL AQIUAxQAAAAAANqRc1EAAAAAAAAAAAAAAAAxACAAAAAAAAAAAADtQUYiAABTY3JhdGNoL1NjcmF0 Y2gueGNvZGVwcm9qL3hjc2hhcmVkZGF0YS94Y3NjaGVtZXMvVVQNAAecJrdfnCa3X5wmt191eAsA AQT1AQAABBQAAABQSwECFAMUAAAAAADzaXFRAAAAAAAAAAAAAAAAMwAgAAAAAAAAAAAA7UG1IgAA U2NyYXRjaC9TY3JhdGNoL0Fzc2V0cy54Y2Fzc2V0cy9BcHBJY29uLmFwcGljb25zZXQvVVQNAAd7 PbRfez20X3s9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADzaXFRlt4CqG0AAADSAAAAPQAg AAAAAAAAAAAA7YEmIwAAX19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoL0Fzc2V0cy54Y2Fzc2V0cy8u X0FwcEljb24uYXBwaWNvbnNldFVUDQAHez20X3s9tF8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQD FAAAAAAA8WlxUQAAAAAAAAAAAAAAADUAIAAAAAAAAAAAAO1BHiQAAFNjcmF0Y2gvU2NyYXRjaC9B c3NldHMueGNhc3NldHMvQWNjZW50Q29sb3IuY29sb3JzZXQvVVQNAAd2PbRfdj20X3Y9tF91eAsA AQT1AQAABBQAAABQSwECFAMUAAgACADxaXFRlt4CqG0AAADSAAAAPwAgAAAAAAAAAAAA7YGRJAAA X19NQUNPU1gvU2NyYXRjaC9TY3JhdGNoL0Fzc2V0cy54Y2Fzc2V0cy8uX0FjY2VudENvbG9yLmNv bG9yc2V0VVQNAAd2PbRfdj20Xz40uF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADuaXFRck85 RjUAAAA/AAAALQAgAAAAAAAAAAAApIGLJQAAU2NyYXRjaC9TY3JhdGNoL0Fzc2V0cy54Y2Fzc2V0 cy9Db250ZW50cy5qc29uVVQNAAdxPbRfcT20X3E9tF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgA CADuaXFRcBqNwF0AAACrAAAAOAAgAAAAAAAAAAAApIE7JgAAX19NQUNPU1gvU2NyYXRjaC9TY3Jh dGNoL0Fzc2V0cy54Y2Fzc2V0cy8uX0NvbnRlbnRzLmpzb25VVA0AB3E9tF9xPbRfPjS4X3V4CwAB BPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVHlh28XxBYAAHnFAAAnACAAAAAAAAAAAACkgR4nAABT Y3JhdGNoL1NjcmF0Y2gvQmFzZS5scHJvai9NYWluTWVudS54aWJVVA0AB3Y9tF93PbRfdj20X3V4 CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPFpcVFwGo3AXQAAAKsAAAAyACAAAAAAAAAAAACkgVc+ AABfX01BQ09TWC9TY3JhdGNoL1NjcmF0Y2gvQmFzZS5scHJvai8uX01haW5NZW51LnhpYlVUDQAH dj20X3c9tF8+NLhfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAAAAAA2ZFzUQAAAAAAAAAAAAAAAEIA IAAAAAAAAAAAAO1BND8AAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2oveGN1c2VyZGF0YS9nZ2Fy ZW4ueGN1c2VyZGF0YWQveGNzY2hlbWVzL1VUDQAHmya3X5wmt1+bJrdfdXgLAAEE9QEAAAQUAAAA UEsBAhQDFAAAAAAAKGt0UQAAAAAAAAAAAAAAAEwAIAAAAAAAAAAAAO1BtD8AAFNjcmF0Y2gvU2Ny YXRjaC54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3VzZXJkYXRhL2dnYXJlbi54Y3Vz ZXJkYXRhZC9VVA0ABzw0uF88NLhfPDS4X3V4CwABBPUBAAAEFAAAAFBLAQIUAxQACAAIAPJpcVF3 FXK4vAAAAO4AAABTACAAAAAAAAAAAACkgT5AAABTY3JhdGNoL1NjcmF0Y2gueGNvZGVwcm9qL3By b2plY3QueGN3b3Jrc3BhY2UveGNzaGFyZWRkYXRhL0lERVdvcmtzcGFjZUNoZWNrcy5wbGlzdFVU DQAHeD20X3o9tF94PbRfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA2pFzUQY5GYa3AgAAZgsA AEEAIAAAAAAAAAAAAKSBm0EAAFNjcmF0Y2gvU2NyYXRjaC54Y29kZXByb2oveGNzaGFyZWRkYXRh L3hjc2NoZW1lcy9TY3JhdGNoLnhjc2NoZW1lVVQNAAecJrdfnSa3X5wmt191eAsAAQT1AQAABBQA AABQSwECFAMUAAgACADxaXFRR8OreqMAAACIAwAAQAAgAAAAAAAAAAAApIHhRAAAU2NyYXRjaC9T Y3JhdGNoL0Fzc2V0cy54Y2Fzc2V0cy9BcHBJY29uLmFwcGljb25zZXQvQ29udGVudHMuanNvblVU DQAHdj20X3Y9tF92PbRfdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAgA7mlxUcfjjxJaAAAAewAA AEIAIAAAAAAAAAAAAKSBEkYAAFNjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3NldHMvQWNjZW50 Q29sb3IuY29sb3JzZXQvQ29udGVudHMuanNvblVUDQAHcT20X3E9tF9xPbRfdXgLAAEE9QEAAAQU AAAAUEsBAhQDFAAIAAgA7mlxUXAajcBdAAAAqwAAAE0AIAAAAAAAAAAAAKSB/EYAAF9fTUFDT1NY L1NjcmF0Y2gvU2NyYXRjaC9Bc3NldHMueGNhc3NldHMvQWNjZW50Q29sb3IuY29sb3JzZXQvLl9D b250ZW50cy5qc29uVVQNAAdxPbRfcT20Xz40uF91eAsAAQT1AQAABBQAAABQSwECFAMUAAgACADZ kXNRxiZQiSQBAADrAQAAWgAgAAAAAAAAAAAApIH0RwAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJv ai94Y3VzZXJkYXRhL2dnYXJlbi54Y3VzZXJkYXRhZC94Y3NjaGVtZXMveGNzY2hlbWVtYW5hZ2Vt ZW50LnBsaXN0VVQNAAebJrdfnSa3X5smt191eAsAAQT1AQAABBQAAABQSwECFAMUAAgACAAoa3RR wxggL+0/AAAQcwAAagAgAAAAAAAAAAAApIHASQAAU2NyYXRjaC9TY3JhdGNoLnhjb2RlcHJvai9w cm9qZWN0Lnhjd29ya3NwYWNlL3hjdXNlcmRhdGEvZ2dhcmVuLnhjdXNlcmRhdGFkL1VzZXJJbnRl cmZhY2VTdGF0ZS54Y3VzZXJzdGF0ZVVUDQAHPDS4Xz40uF88NLhfdXgLAAEE9QEAAAQUAAAAUEsF BgAAAAAuAC4AkxYAAGWKAAAAAA== 415939 2020-12-10 15:35:37 -0800 2020-12-10 16:17:49 -0800 Patch bug-202874-20201210153536.patch text/plain 4865 ggaren SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNzA2NjApCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDIwLTEyLTEwICBHZW9mZnJleSBHYXJlbiAgPGdn YXJlbkBhcHBsZS5jb20+CisKKyAgICAgICAgVW5yZXZpZXdlZCwgcmUtbGFuZGluZyByMjcwMTMy LgorCisgICAgICAgIFJlZ3Jlc3Npb24gdGVzdCBmYWlsdXJlcyBoYXZlIGJlZW4gcmVzb2x2ZWQu CisKKyAgICAgICAgUmUtbGFuZGVkIGNoYW5nZXNldDoKKworICAgICAgICAiVXNlIGEgVmVyc2lv biAxIENGUnVuTG9vcFNvdXJjZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2giCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQKKyAgICAgICAgaHR0 cHM6Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzI3MDEzMgorCiAyMDIwLTEyLTEwICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgcnVudGltZSBmbGFnIGZv ciBBTkdMRSBvbiBNZXRhbApJbmRleDogU291cmNlL1dURi93dGYvUnVuTG9vcC5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1J1bkxvb3AuaAkocmV2aXNpb24gMjcwNjYwKQorKysgU291 cmNlL1dURi93dGYvUnVuTG9vcC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMjcsOSArMjI3LDEwIEBA IHByaXZhdGU6CiAKICAgICBMb2NrIG1fbG9vcExvY2s7CiAjZWxpZiBVU0UoQ09DT0FfRVZFTlRf TE9PUCkKLSAgICBzdGF0aWMgdm9pZCBwZXJmb3JtV29yayh2b2lkKik7CisgICAgc3RhdGljIHZv aWQgcGVyZm9ybVdvcmsoQ0ZNYWNoUG9ydFJlZiwgdm9pZCogbXNnLCBDRkluZGV4IHNpemUsIHZv aWQqIGluZm8pOwogICAgIFJldGFpblB0cjxDRlJ1bkxvb3BSZWY+IG1fcnVuTG9vcDsKICAgICBS ZXRhaW5QdHI8Q0ZSdW5Mb29wU291cmNlUmVmPiBtX3J1bkxvb3BTb3VyY2U7CisgICAgUmV0YWlu UHRyPENGTWFjaFBvcnRSZWY+IG1fcG9ydDsKICNlbGlmIFVTRShHTElCX0VWRU5UX0xPT1ApCiAg ICAgdm9pZCBub3RpZnkoRXZlbnQsIGNvbnN0IGNoYXIqKTsKIApJbmRleDogU291cmNlL1dURi93 dGYvY2YvUnVuTG9vcENGLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5M b29wQ0YuY3BwCShyZXZpc2lvbiAyNzA2NjApCisrKyBTb3VyY2UvV1RGL3d0Zi9jZi9SdW5Mb29w Q0YuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlIDxDb3Jl Rm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2luY2x1ZGUgPGRpc3BhdGNoL2Rpc3BhdGNo Lmg+CisjaW5jbHVkZSA8bWFjaC9tYWNoLmg+CiAjaW5jbHVkZSA8d3RmL0F1dG9kcmFpbmVkUG9v bC5oPgogI2luY2x1ZGUgPHd0Zi9TY2hlZHVsZVBhaXIuaD4KIApAQCAtNDAsMjkgKzQxLDM5IEBA IHN0YXRpYyBSZXRhaW5QdHI8Q0ZSdW5Mb29wVGltZXJSZWY+IGNyZWEKICAgICByZXR1cm4gYWRv cHRDRihDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBDRkFic29sdXRl VGltZUdldEN1cnJlbnQoKSArIGludGVydmFsLnNlY29uZHMoKSwgcmVwZWF0SW50ZXJ2YWwuc2Vj b25kcygpLCAwLCAwLCB0aW1lckZpcmVkLCAmY29udGV4dCkpOwogfQogCi12b2lkIFJ1bkxvb3A6 OnBlcmZvcm1Xb3JrKHZvaWQqIGNvbnRleHQpCit2b2lkIFJ1bkxvb3A6OnBlcmZvcm1Xb3JrKENG TWFjaFBvcnRSZWYsIHZvaWQqLCBDRkluZGV4LCB2b2lkKiBpbmZvKQogewogICAgIEF1dG9kcmFp bmVkUG9vbCBwb29sOwotICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihjb250ZXh0KS0+cGVyZm9y bVdvcmsoKTsKKyAgICBzdGF0aWNfY2FzdDxSdW5Mb29wKj4oaW5mbyktPnBlcmZvcm1Xb3JrKCk7 CiB9CiAKIFJ1bkxvb3A6OlJ1bkxvb3AoKQogICAgIDogbV9ydW5Mb29wKENGUnVuTG9vcEdldEN1 cnJlbnQoKSkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNvbnRleHQgPSB7IDAsIHRo aXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07Ci0gICAgbV9ydW5Mb29wU291 cmNlID0gYWRvcHRDRihDRlJ1bkxvb3BTb3VyY2VDcmVhdGUoa0NGQWxsb2NhdG9yRGVmYXVsdCwg MCwgJmNvbnRleHQpKTsKKyAgICBDRk1hY2hQb3J0Q29udGV4dCBjb250ZXh0ID0geyAwLCB0aGlz LCBudWxscHRyLCBudWxscHRyLCBudWxscHRyIH07CisgICAgbV9wb3J0ID0gYWRvcHRDRihDRk1h Y2hQb3J0Q3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIHBlcmZvcm1Xb3JrLCAmY29udGV4dCwg bnVsbHB0cikpOworICAgIG1fcnVuTG9vcFNvdXJjZSA9IGFkb3B0Q0YoQ0ZNYWNoUG9ydENyZWF0 ZVJ1bkxvb3BTb3VyY2Uoa0NGQWxsb2NhdG9yRGVmYXVsdCwgbV9wb3J0LmdldCgpLCAwKSk7CiAg ICAgQ0ZSdW5Mb29wQWRkU291cmNlKG1fcnVuTG9vcC5nZXQoKSwgbV9ydW5Mb29wU291cmNlLmdl dCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCiBSdW5Mb29wOjp+UnVuTG9vcCgpCiB7 CisgICAgQ0ZNYWNoUG9ydEludmFsaWRhdGUobV9wb3J0LmdldCgpKTsKICAgICBDRlJ1bkxvb3BT b3VyY2VJbnZhbGlkYXRlKG1fcnVuTG9vcFNvdXJjZS5nZXQoKSk7CiB9CiAKIHZvaWQgUnVuTG9v cDo6d2FrZVVwKCkKIHsKLSAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwobV9ydW5Mb29wU291cmNl LmdldCgpKTsKLSAgICBDRlJ1bkxvb3BXYWtlVXAobV9ydW5Mb29wLmdldCgpKTsKKyAgICBtYWNo X21zZ19oZWFkZXJfdCBoZWFkZXI7CisgICAgaGVhZGVyLm1zZ2hfYml0cyA9IE1BQ0hfTVNHSF9C SVRTKE1BQ0hfTVNHX1RZUEVfQ09QWV9TRU5ELCAwKTsKKyAgICBoZWFkZXIubXNnaF9zaXplID0g c2l6ZW9mKG1hY2hfbXNnX2hlYWRlcl90KTsKKyAgICBoZWFkZXIubXNnaF9yZW1vdGVfcG9ydCA9 IENGTWFjaFBvcnRHZXRQb3J0KG1fcG9ydC5nZXQoKSk7CisgICAgaGVhZGVyLm1zZ2hfbG9jYWxf cG9ydCA9IE1BQ0hfUE9SVF9OVUxMOworICAgIGhlYWRlci5tc2doX2lkID0gMDsKKyAgICBtYWNo X21zZ19yZXR1cm5fdCByZXN1bHQgPSBtYWNoX21zZygmaGVhZGVyLCBNQUNIX1NFTkRfTVNHIHwg TUFDSF9TRU5EX1RJTUVPVVQsIGhlYWRlci5tc2doX3NpemUsIDAsIE1BQ0hfUE9SVF9OVUxMLCAw LCBNQUNIX1BPUlRfTlVMTCk7CisgICAgUkVMRUFTRV9BU1NFUlQocmVzdWx0ID09IE1BQ0hfTVNH X1NVQ0NFU1MgfHwgcmVzdWx0ID09IE1BQ0hfU0VORF9USU1FRF9PVVQpOworICAgIGlmIChyZXN1 bHQgPT0gTUFDSF9TRU5EX1RJTUVEX09VVCkKKyAgICAgICAgbWFjaF9tc2dfZGVzdHJveSgmaGVh ZGVyKTsKIH0KIAogUnVuTG9vcDo6Q3ljbGVSZXN1bHQgUnVuTG9vcDo6Y3ljbGUoUnVuTG9vcE1v ZGUgbW9kZSkKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFu Z2VMb2cJKHJldmlzaW9uIDI3MDY2MCkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDE1IEBACisyMDIwLTEyLTEwICBHZW9mZnJleSBHYXJlbiAgPGdnYXJlbkBh cHBsZS5jb20+CisKKyAgICAgICAgVW5yZXZpZXdlZCwgcmUtbGFuZGluZyByMjcwMTMyLgorCisg ICAgICAgIFJlZ3Jlc3Npb24gdGVzdCBmYWlsdXJlcyBoYXZlIGJlZW4gcmVzb2x2ZWQuCisKKyAg ICAgICAgUmUtbGFuZGVkIGNoYW5nZXNldDoKKworICAgICAgICAiVXNlIGEgVmVyc2lvbiAxIENG UnVuTG9vcFNvdXJjZSBmb3IgZmFzdGVyIHRhc2sgZGlzcGF0Y2giCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDI4NzQKKyAgICAgICAgaHR0cHM6Ly90 cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzI3MDEzMgorCiAyMDIwLTEyLTEwICBEb24gT2xtc3Rl YWQgIDxkb24ub2xtc3RlYWRAc29ueS5jb20+CiAKICAgICAgICAgW0NNYWtlXSBEZXRlcm1pbmUg d2hlbiB0byB1c2UgJDxUQVJHRVRfT0JKRUNUUz4gZm9yIGV4ZWN1dGFibGVzCkluZGV4OiBUb29s cy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29hLm1tCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRv b2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0JKHJldmlzaW9uIDI3MDY2 MCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0JKHdvcmtp bmcgY29weSkKQEAgLTM4LDcgKzM4LDcgQEAgdm9pZCBydW4oYm9vbCogZG9uZSkKIHZvaWQgc3Bp blJ1bkxvb3AodWludDY0X3QgY291bnQpCiB7CiAgICAgZm9yICh1aW50NjRfdCBpID0gMDsgaSA8 IGNvdW50OyArK2kpCi0gICAgICAgIFtbTlNSdW5Mb29wIGN1cnJlbnRSdW5Mb29wXSBydW5Nb2Rl Ok5TRGVmYXVsdFJ1bkxvb3BNb2RlIGJlZm9yZURhdGU6W05TRGF0ZSBkaXN0YW50UGFzdF1dOwor ICAgICAgICB3aGlsZSAoQ0ZSdW5Mb29wUnVuSW5Nb2RlKGtDRlJ1bkxvb3BEZWZhdWx0TW9kZSwg MCwgdHJ1ZSkgPT0ga0NGUnVuTG9vcFJ1bkhhbmRsZWRTb3VyY2UpIHsgfQogfQogCiB2b2lkIHNs ZWVwKGRvdWJsZSBzZWNvbmRzKQo=