231681 2021-10-13 09:39:29 -0700 REGRESSION (r284079): fast/canvas/gradient-with-clip.html and fast/canvas/gradient-text-with-shadow.html are flaky failures 2022-03-25 10:47:52 -0700 1 1 1 Unclassified WebKit Canvas WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=237674 InRadar P2 Normal --- 1 ayumi_kojima wenson_hsieh ap cdumez dino ews-watchlist hi kkinnunen mkwst thorton webkit-bot-watchers-bugzilla webkit-bug-importer wenson_hsieh oldest_to_newest 1803806 0 ayumi_kojima 2021-10-13 09:39:29 -0700 fast/canvas/gradient-text-with-shadow.html fast/canvas/gradient-with-clip.html Are flaky failing on iOS Release and macOS Release wk2. History: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&test=fast%2Fcanvas%2Fgradient-text-with-shadow.html&test=fast%2Fcanvas%2Fgradient-with-clip.html Result page: https://build.webkit.org/results/Apple-iOS-15-Simulator-Release-WK2-Tests/r284084%20(149)/results.html# Diff: --- /Volumes/Data/worker/ios-simulator-15-release-tests-wk2/build/layout-test-results/fast/canvas/gradient-text-with-shadow-expected.txt +++ /Volumes/Data/worker/ios-simulator-15-release-tests-wk2/build/layout-test-results/fast/canvas/gradient-text-with-shadow-actual.txt @@ -1 +1 @@ -PASSED +FAILED Diff: --- /Volumes/Data/worker/ios-simulator-15-release-tests-wk2/build/layout-test-results/fast/canvas/gradient-with-clip-expected.txt +++ /Volumes/Data/worker/ios-simulator-15-release-tests-wk2/build/layout-test-results/fast/canvas/gradient-with-clip-actual.txt @@ -1,10 +1,11 @@ +CONSOLE MESSAGE: Unable to get image data from canvas. Requested size was 1 x 1 +CONSOLE MESSAGE: InvalidStateError: The object is in an invalid state. Test for canvas regression where gradient clips were not cleared https://bugs.webkit.org/show_bug.cgi?id=21498 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE". -PASS pixel 20, 20 is [0, 128, 0, 255] -PASS successfullyParsed is true +FAIL successfullyParsed should be true (of type boolean). Was undefined (of type undefined). TEST COMPLETE 1803807 1 webkit-bug-importer 2021-10-13 09:40:44 -0700 <rdar://problem/84202478> 1803825 2 ayumi_kojima 2021-10-13 10:05:15 -0700 Marked test expectations https://trac.webkit.org/changeset/284100/webkit 1804604 3 ap 2021-10-14 16:54:55 -0700 Wenson, could this have been caused by r284079? The first failure is r284081, and these are pretty frequent. 1804606 4 wenson_hsieh 2021-10-14 16:56:10 -0700 (In reply to Alexey Proskuryakov from comment #3) > Wenson, could this have been caused by r284079? The first failure is > r284081, and these are pretty frequent. Potentially — let me take a look. 1804632 5 wenson_hsieh 2021-10-14 17:53:12 -0700 (In reply to Wenson Hsieh from comment #4) > (In reply to Alexey Proskuryakov from comment #3) > > Wenson, could this have been caused by r284079? The first failure is > > r284081, and these are pretty frequent. > > Potentially — let me take a look. I have been unable to reproduce either test failure locally by running both for 500 iterations each. That said, I am on macOS Monterey, and it seems like the bots are on older macOS releases. It's also possible that this is dependent on test order (although I wasn't able to reproduce by running all the tests in fast/canvas either). I'll try iOS simulator next; if I still can't reproduce, I'll try to repro in EWS by uploading patches. 1804811 6 wenson_hsieh 2021-10-15 08:18:08 -0700 Okay, I can occasionally reproduce in iOS simulator by running `fast/canvas` (at least, the `fast/canvas/gradient-with-clip.html` failure). Taking a look... 1804978 7 wenson_hsieh 2021-10-15 13:26:14 -0700 (In reply to Wenson Hsieh from comment #6) > Okay, I can occasionally reproduce in iOS simulator by running `fast/canvas` > (at least, the `fast/canvas/gradient-with-clip.html` failure). > > Taking a look... This seems to be relatively consistent method of reproducing the flaky failure: run-webkit-tests --ios-simulator --exit-after-n-failures 1 --iterations 100 fast/canvas/getPutImageDataPairTest.html fast/canvas/gradient-text-with-shadow.html fast/canvas/gradient-with-clip.html 1805050 8 wenson_hsieh 2021-10-15 15:13:56 -0700 Some logging in the application (WKTR), GPU, and web processes demonstrates that when this test fails, the smoking gun is the fact that we fail to receive the GetPixelBuffer stream message. Occasionally, the GPU Process seems to drop IPC stream messages in the middle of processing... ``` (UI) Running /Users/whsieh/work/OpenSource/LayoutTests/fast/canvas/gradient-with-clip.html ... (WEB) Sending: RemoteRenderingBackend_FinalizeRenderingUpdate (GPU) Received: RemoteRenderingBackend_FinalizeRenderingUpdate (WEB) Sending: RemoteRenderingBackend_CreateImageBuffer (WEB) Sending: RemoteDisplayListRecorder_Save (WEB) Sending: RemoteDisplayListRecorder_Save (WEB) Sending: RemoteDisplayListRecorder_SetState (WEB) Sending: RemoteDisplayListRecorder_FillRect (WEB) Sending: RemoteDisplayListRecorder_Restore (WEB) Sending: RemoteDisplayListRecorder_GetPixelBuffer (WEB) Sending: RemoteDisplayListRecorder_FlushContext (GPU) Received: RemoteRenderingBackend_CreateImageBuffer (GPU) Received: RemoteDisplayListRecorder_Save (GPU) Received: RemoteDisplayListRecorder_Save (GPU) Received: RemoteDisplayListRecorder_SetState (GPU) Received: RemoteDisplayListRecorder_FillRect (GPU) Received: RemoteDisplayListRecorder_Restore (GPU) Received: RemoteDisplayListRecorder_GetPixelBuffer (WEB) Sending: RemoteRenderingBackend_CreateImageBuffer (GPU) Received: RemoteDisplayListRecorder_FlushContext (WEB) Sending: RemoteDisplayListRecorder_Save (WEB) Sending: RemoteDisplayListRecorder_SetState (WEB) Sending: RemoteDisplayListRecorder_FillPath (WEB) Sending: RemoteDisplayListRecorder_SetInlineFillColor (WEB) Sending: RemoteDisplayListRecorder_FillRect (WEB) Sending: RemoteDisplayListRecorder_GetPixelBuffer (WEB) Sending: RemoteDisplayListRecorder_FlushContext (GPU) Received: RemoteRenderingBackend_CreateImageBuffer (GPU) Received: RemoteDisplayListRecorder_Save (WEB) FAILED TO WAIT FOR GetPixelBuffer! (WEB) DESTROYING GET PIXEL BUFFER SHARED MEMORY. ``` 1805137 9 wenson_hsieh 2021-10-15 17:06:56 -0700 I think I'm beginning to get some grasp of what's happening: ``` (UI) Running /Users/whsieh/work/OpenSource/LayoutTests/fast/canvas/gradient-with-clip.html (WEB) Waking up the GPU process. (WEB) Sent in stream: RemoteRenderingBackend_FinalizeRenderingUpdate @[2096960] (GPU) Received: RemoteRenderingBackend_FinalizeRenderingUpdate (GPU) Waiting for more messages... (WEB) Waking up the GPU process. (WEB) Sent in stream: RemoteRenderingBackend_CreateImageBuffer @[2096976] (WEB) Sent in stream: RemoteDisplayListRecorder_Save @[2097064] (WEB) Sent in stream: RemoteDisplayListRecorder_Save @[2097074] (WEB) Sent in stream: RemoteDisplayListRecorder_SetState @[2097084] (WEB) Resetting stream buffer capacity (size=22 bytes, capacity=14 bytes) (WEB) Sent out of stream: RemoteDisplayListRecorder_FillRect (WEB) Sent in stream: RemoteDisplayListRecorder_Restore @[0] (WEB) Sent in stream: RemoteDisplayListRecorder_GetPixelBuffer @[10] (WEB) Sent in stream: RemoteDisplayListRecorder_FlushContext @[66] (GPU) Received: RemoteRenderingBackend_CreateImageBuffer (GPU) Received: RemoteDisplayListRecorder_Save (GPU) Received: RemoteDisplayListRecorder_Save (GPU) Received: RemoteDisplayListRecorder_SetState (GPU) No out of stream messages to process? (GPU) Waiting for more messages... (GPU) No out of stream messages to process? (GPU) Waiting for more messages... (WEB) FAILED TO WAIT FOR GetPixelBuffer! ``` ...when we exhaust the available (2MB) capacity in the stream buffer, the last message that would've caused us to run off the end of the buffer is instead dispatched to the GPU Process as an out-of-stream message, and we just drop a `ProcessOutOfStreamMessage` at the end, instead. The write offset is then returned to the start, and subsequent IPC stream messages are sent in the stream, starting at offset 0. For some reason, we never wake up in the GPU Process to process the last stream message that was sent before exhausting capacity. Investigating further to discern why that is the case. 1805293 10 wenson_hsieh 2021-10-16 12:52:55 -0700 I understand what's happening now: ``` (UI) Running /Users/whsieh/work/OpenSource/LayoutTests/fast/canvas/gradient-with-clip.html (WEB) Sent in stream: RemoteRenderingBackend_FinalizeRenderingUpdate @[2096800] (GPU) Dispatching in stream: RemoteRenderingBackend_FinalizeRenderingUpdate (WEB) Sent in stream: RemoteRenderingBackend_CreateImageBuffer @[2096816] (GPU) Dispatching in stream: RemoteRenderingBackend_CreateImageBuffer (WEB) Sent in stream: RemoteDisplayListRecorder_Save @[2096904] (WEB) Sent in stream: RemoteDisplayListRecorder_Save @[2096914] (WEB) Sent in stream: RemoteDisplayListRecorder_SetState @[2096924] (WEB) Sent in stream: RemoteDisplayListRecorder_FillRect @[2096946] (WEB) Sent in stream: RemoteDisplayListRecorder_Restore @[2096968] (WEB) Sent in stream: RemoteDisplayListRecorder_GetPixelBuffer @[2096978] (WEB) Sent in stream: RemoteDisplayListRecorder_FlushContext @[2097034] (GPU) Start receiving messages for RemoteDisplayListRecorder(#20899) (GPU) Dispatching in stream: RemoteDisplayListRecorder_Save (GPU) Dispatching in stream: RemoteDisplayListRecorder_Save (GPU) Dispatching in stream: RemoteDisplayListRecorder_SetState (GPU) Dispatching in stream: RemoteDisplayListRecorder_FillRect (GPU) Dispatching in stream: RemoteDisplayListRecorder_Restore (GPU) Dispatching in stream: RemoteDisplayListRecorder_GetPixelBuffer (GPU) Dispatching in stream: RemoteDisplayListRecorder_FlushContext (WEB) Sent out of stream: RemoteRenderingBackend_CreateImageBuffer (WEB) Sent in stream: RemoteDisplayListRecorder_Save @[2097088] (GPU) Dispatching out-of-stream: RemoteRenderingBackend_CreateImageBuffer (WEB) Sent out of stream: RemoteDisplayListRecorder_SetState (GPU) Processing incoming message: RemoteDisplayListRecorder_SetState for RemoteDisplayListRecorder(#20901) 0x0 (WEB) Sent out of stream: RemoteDisplayListRecorder_FillPath (WEB) Sent in stream: RemoteDisplayListRecorder_SetInlineFillColor @[0] (GPU) Processing incoming message: RemoteDisplayListRecorder_FillPath for RemoteDisplayListRecorder(#20901) 0x0 (WEB) Sent in stream: RemoteDisplayListRecorder_FillRect @[10] (WEB) Sent in stream: RemoteDisplayListRecorder_GetPixelBuffer @[32] (WEB) Sent in stream: RemoteDisplayListRecorder_FlushContext @[90] (GPU) Start receiving messages for RemoteDisplayListRecorder(#20901) (GPU) Dispatching in stream: RemoteDisplayListRecorder_Save (WEB) FAILED TO WAIT FOR GetPixelBuffer! ``` When we are about to run off the end of the stream buffer and (as a result) send out-of-stream messages, it's possible for these OOS IPC messages to be received on the IPC::Connection via the IPC thread, right before we add the RemoteDisplayListRecorder as an IPC receive queue in `StreamServerConnection::startReceivingMessages` when creating a new remote image buffer: ``` void Connection::processIncomingMessage(std::unique_ptr<Decoder> message) { … Locker incomingMessagesLocker { m_incomingMessagesLock }; if (auto* receiveQueue = m_receiveQueues.get(*message)) { receiveQueue->enqueueMessage(*this, WTFMove(message)); return; } ``` ..as a result, `receiveQueue` above ends up being null, and there is no mechanism for queueing IPC messages for a receive queue that will be added in the future, so we end up missing the OOS message altogether, and stop processing stream messages. In order to address this, we need to somehow fix the race condition between: 1. Adding RemoteDisplayListRecorder as an IPC receive queue, and 2. Receiving out of stream messages on the IPC thread 1805434 11 441552 wenson_hsieh 2021-10-17 15:13:22 -0700 Created attachment 441552 Patch 1805435 12 441553 wenson_hsieh 2021-10-17 15:24:59 -0700 Created attachment 441553 Initial approach 1805482 13 441553 kkinnunen 2021-10-18 01:18:16 -0700 Comment on attachment 441553 Initial approach View in context: https://bugs.webkit.org/attachment.cgi?id=441553&action=review > Source/WebKit/ChangeLog:35 > + receiver on `m_incomingMessages` instead of falling through the early return. This allows us to enqueue the The message comes as the first message in m_incomingMessages. If it doesn't have a receiver, this puts the message back as the last message in m_incomingMessages. As far as I understand, this reorders messages, which is not a desirable characteristic of a IPC system. If you consider message scenario like Save() Restore() Suppose both get sent as OOS. Suppose following sequence: 1) Process Save. Notice no receive queue. Requeue Save as the last message. 2) RRB installs receive queue for the new RemoteImageBuffer. 3) Process Restore. Notice the receive queue. Send it for processing. 4) Process Save. Notice the receive queue. Send it for processing. So this makes Restore happen before Save. 1805491 14 kkinnunen 2021-10-18 02:00:25 -0700 Great debugging! The root cause of this issue is that the install trigger is on one stream, where as the payload messages are in other. So the design of the stream system is spelled out in one of the headers, namely - Messages in one stream for one destination are guaranteed to be processed in order. - There are no guarantees between messages across different streams or different destinations. This didn't explicitly change even though you changed it so that the underlying stream buffer can be used to deliver many different streams. The unwritten requirement is that the install trigger be normal, main-thread processed message. This I forgot completely when you mentioned both IPC receivers would be streams. This is an implementation flaw of the stream system that was inherited from the way the IPC system works. For this particular problem, one of the following could be a better solution a) Make RRB a normal IPC receiver in main thread (how does this relate to the threading model for the other messages? Maybe not feasible?) b) Make StreamConnectionWorkQueue thread safe, and register RDLR in the RRB+RDLR thread. Connection should already be thread safe for this use-case, as well as StreamServerConnection. c) Add concept which allows for StreamServerConnection to register "all RDLR messages go to this receive queue". There's already support for this in Connection. For the StreamServerConnection implementation it's a bit verbose and adds a mode, so it'd be elaborate. d) Make sure OOS messages are not sent until sender knows receiver is ready, e.g. sender semaphore is received (or some other signal). Since this in current system is message interface specific operation, this would need to be a virtual function that waits on the particular message response, this seems quite elaborate too. -- Long term, I think workable solution would be to define that: 1) message receivers should receive the messages in send order (currently only guaranteed for stream messages) 2) message order across receivers is not preserved 3) explicit messaging synchronisation primitives can be used to express cross-receiver order Then the implementation would be to have one explicit queue per receiver with hard-cap on the queued messages, where exceeding the cap would be cause for termination for untrusted connections. And queue should probably be pair (mach message port, vector) 1805492 15 kkinnunen 2021-10-18 02:11:42 -0700 > b) Make StreamConnectionWorkQueue thread safe, and register RDLR in the RRB+RDLR thread. Scratch this, this doesn't fix anything.. e) createImageBuffer could be synchronous (for the time being, to unblock?) Maybe e), c), undo e) sound the best for short-term fixing from my perspective. 1805573 16 wenson_hsieh 2021-10-18 08:04:02 -0700 (In reply to Kimmo Kinnunen from comment #13) > Comment on attachment 441553 [details] > Rebaseline unit test > > View in context: > https://bugs.webkit.org/attachment.cgi?id=441553&action=review > > > Source/WebKit/ChangeLog:35 > > + receiver on `m_incomingMessages` instead of falling through the early return. This allows us to enqueue the > > The message comes as the first message in m_incomingMessages. > If it doesn't have a receiver, this puts the message back as the last > message in m_incomingMessages. > As far as I understand, this reorders messages, which is not a desirable > characteristic of a IPC system. > > If you consider message scenario like > Save() > Restore() > > Suppose both get sent as OOS. > Suppose following sequence: > 1) Process Save. Notice no receive queue. Requeue Save as the last message. > 2) RRB installs receive queue for the new RemoteImageBuffer. > 3) Process Restore. Notice the receive queue. Send it for processing. > 4) Process Save. Notice the receive queue. Send it for processing. > > So this makes Restore happen before Save. So in this scenario, when (2) happens, `enqueueMatchingMessagesToMessageReceiveQueue` will move the queued Save in `m_incomingMessages` to the new receive queue, so that we end up processing the Save before the Restore and don't end up with out-of-order messages. 1805574 17 wenson_hsieh 2021-10-18 08:08:19 -0700 (In reply to Kimmo Kinnunen from comment #15) > > b) Make StreamConnectionWorkQueue thread safe, and register RDLR in the RRB+RDLR thread. > > Scratch this, this doesn't fix anything.. > > e) createImageBuffer could be synchronous (for the time being, to unblock?) > > > Maybe e), c), undo e) sound the best for short-term fixing from my > perspective. Thank you for your thoughts! I think (e) seems...maybe okay as a temporary workaround, but I'm concerned about potential performance impact on Canvas Images. I agree that (c) sounds like a good plan, so I'll work towards that! 1805592 18 441608 wenson_hsieh 2021-10-18 08:53:46 -0700 Created attachment 441608 Workaround to keep tests passing 1805626 19 441553 wenson_hsieh 2021-10-18 09:47:14 -0700 Comment on attachment 441553 Initial approach (Re-marking this patch for r?, since I don't _think_ this should result in out of order messages within the same IPC stream...) 1806098 20 441553 wenson_hsieh 2021-10-19 09:54:55 -0700 Comment on attachment 441553 Initial approach Kimmo pointed out that here is still the possibility of reordered messages here in the following scenario: 1. Receive stream IPC message (A) for an unknown receiver 2. Receive normal IPC message (B) 3. Receive stream IPC message (C) for an unknown receiver It's possible that (2) causes us to try and dispatch an incoming message, which (in this patch) will take (A) and append it to the end. Later, when the receive queue is actually added, we'll end up moving messages (C) and (A) into the new receive queue, in that order. I think we could adjust the patch to be robust against this possibility by adding receiver-less stream messages to a separate queue that is not `m_incomingMessages`, and taking messages from that separate queue underneath `enqueueMatchingMessagesToMessageReceiveQueue`. 1806142 21 441754 wenson_hsieh 2021-10-19 10:38:32 -0700 Created attachment 441754 Async approach, v2 1806149 22 441755 wenson_hsieh 2021-10-19 10:45:53 -0700 Created attachment 441755 Async approach, v2 1806167 23 441755 kkinnunen 2021-10-19 11:08:18 -0700 Comment on attachment 441755 Async approach, v2 View in context: https://bugs.webkit.org/attachment.cgi?id=441755&action=review > Source/WebKit/Platform/IPC/Connection.cpp:362 > + enqueueMatchingMessagesToMessageReceiveQueue(receiveQueue, m_incomingReceiveQueueMessages, receiverName, destinationID); Receive queue is not a stream-specific thing. Everything that receives messages off main thread is a receive queue. This now dispatches only the pending stream messages to the newly added receive queues. > Source/WebKit/Platform/IPC/Connection.cpp:772 > + if (isStreamMessageReceiver(message->messageReceiverName())) { I don't think generally this sort of special casing of "is it stream or is it not" is warranted. The root of the problem is that there are two different message receivers. These message receivers are not supposed to be sequential, nothing guarantees it. These are not guaranteed to be sequential, so we shouldn't try to find stop-gap measures to make them so. If we want two message receivers be sequential, we need to define the mechanism as an API guarantee which makes it happen. Then we need to implement that. 1806175 24 441755 wenson_hsieh 2021-10-19 11:18:42 -0700 Comment on attachment 441755 Async approach, v2 View in context: https://bugs.webkit.org/attachment.cgi?id=441755&action=review >> Source/WebKit/Platform/IPC/Connection.cpp:362 >> + enqueueMatchingMessagesToMessageReceiveQueue(receiveQueue, m_incomingReceiveQueueMessages, receiverName, destinationID); > > Receive queue is not a stream-specific thing. > Everything that receives messages off main thread is a receive queue. > This now dispatches only the pending stream messages to the newly added receive queues. I think it's true that stream messages should only ever be enqueued on receive queues, though? (In other words, I don't think there should ever be `m_incomingMessages` that are destined for a `MessageReceiveQueue`). >> Source/WebKit/Platform/IPC/Connection.cpp:772 >> + if (isStreamMessageReceiver(message->messageReceiverName())) { > > I don't think generally this sort of special casing of "is it stream or is it not" is warranted. > > The root of the problem is that there are two different message receivers. > These message receivers are not supposed to be sequential, nothing guarantees it. > These are not guaranteed to be sequential, so we shouldn't try to find stop-gap measures to make them so. > > If we want two message receivers be sequential, we need to define the mechanism as an API guarantee which makes it happen. Then we need to implement that. I agree that it's a bit fragile, but IIUC `isStreamMessageReceiver()` implies that the message should end up in a receive queue, currently. Instead of checking for `isStreamMessageReceiver`, we could instead either: 1. Add a mechanism for the owner of the Connection (e.g. `GPUConnectionToWebProcess`) to indicate that certain ReceiverNames are expected to always end up in receive queues, or 2. Bake this into the grammar of `*.messages.in` as a new receiver attribute In lieu of these alternatives, could we temporarily address the flaky test failures by landing the other mitigation (making CreateImageBuffer sync) first? 1806176 25 441608 kkinnunen 2021-10-19 11:23:04 -0700 Comment on attachment 441608 Workaround to keep tests passing Looks good as far as I understand RRB. I think the message could return the handle, but then it'd reply out of stream and I understand you want to preserve the didCreate.. message so that one day we can make the sync call async again 1806181 26 wenson_hsieh 2021-10-19 11:26:21 -0700 (In reply to Kimmo Kinnunen from comment #25) > Comment on attachment 441608 [details] > Workaround to keep tests passing > > Looks good as far as I understand RRB. > I think the message could return the handle, but then it'd reply out of > stream and I understand you want to preserve the didCreate.. message so that > one day we can make the sync call async again Indeed — it will make it easier to restore the async codepath in a followup. Filed https://bugs.webkit.org/show_bug.cgi?id=231970 to track this. Thanks! 1806191 27 kkinnunen 2021-10-19 11:36:16 -0700 (In reply to Wenson Hsieh from comment #24) > I think it's true that stream messages should only ever be enqueued on > receive queues, though? (In other words, I don't think there should ever be > `m_incomingMessages` that are destined for a `MessageReceiveQueue`). (How I read the statements, what is not in parenthesis talks about stream messages and what is in parenthesis talks about non-stream messages, but the statements claimed do not overlap, and as such binding "in other words" is not correct.) There are normal IPC messages that are sent to MessageReceiveQueues or Connection::Client (e.g. "to main thread message receiver"). So I think this counters the claim : > "I don't think there should ever be `m_incomingMessages` that are destined for a `MessageReceiveQueue`" There are stream IPC messages that are sent to MessageReceiveQueues. Conceivably there could be "main thread message receiver" that would process stream messages and as such could receive (OOS) stream messages through main thread dispatch mechanism, but there are none today and it wouldn't be too useful. So I think this discusses the practically true claim: >I think it's true that stream messages should only ever be enqueued on > receive queues, though? 1806208 28 wenson_hsieh 2021-10-19 12:00:21 -0700 (In reply to Kimmo Kinnunen from comment #27) > (In reply to Wenson Hsieh from comment #24) > > I think it's true that stream messages should only ever be enqueued on > > receive queues, though? (In other words, I don't think there should ever be > > `m_incomingMessages` that are destined for a `MessageReceiveQueue`). > > (How I read the statements, what is not in parenthesis talks about stream > messages and what is in parenthesis talks about non-stream messages, but the > statements claimed do not overlap, and as such binding "in other words" is > not correct.) > > There are normal IPC messages that are sent to MessageReceiveQueues or > Connection::Client (e.g. "to main thread message receiver"). > So I think this counters the claim : > > "I don't think there should ever be `m_incomingMessages` that are destined for a `MessageReceiveQueue`" Sorry, I should've been more explicit — what I mean is that `Connection::addMessageReceiveQueue` is only ever called in the context of streaming IPC, so in the previous patch, this line: ``` enqueueMatchingMessagesToMessageReceiveQueue(receiveQueue, m_incomingReceiveQueueMessages, receiverName, destinationID); ``` ..is not incorrect, since the `receiveQueue` passed into `addMessageReceiveQueue` is only ever going to receive stream messages. That said, I do agree that making this contract explicit (through some new mechanism on Connection) is a better approach, since it makes the code less fragile. > > > There are stream IPC messages that are sent to MessageReceiveQueues. > Conceivably there could be "main thread message receiver" that would process > stream messages and as such could receive (OOS) stream messages through main > thread dispatch mechanism, but there are none today and it wouldn't be too > useful. > So I think this discusses the practically true claim: > >I think it's true that stream messages should only ever be enqueued on > > receive queues, though? 1806215 29 ews-feeder 2021-10-19 12:09:49 -0700 Committed r284476 (243235@main): <https://commits.webkit.org/243235@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 441608. 441552 2021-10-17 15:13:22 -0700 2021-10-17 15:24:56 -0700 Patch bug-231681-20211017151321.patch text/plain 11436 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MzM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDNkOTg0NzhkYjNjNGM1NjU1 ZWNmOTU2OGQwNzExZjRlYmE4NTdlZDEuLjlmYjQzMDU0NmVmYTc4YzY2NzljMzYyMDQyYWIxYThm ZTc5YzU5ZTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTggQEAKKzIwMjEtMTAtMTcgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAocjI4 NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIGFuZCBmYXN0L2NhbnZh cy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5IGZhaWx1cmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2ODEKKyAgICAg ICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhlc2UgdGVzdHMgb2NjYXNpb25hbGx5IGZhaWwgd2hlbiB3ZSB0aW1lIG91 dCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgcGl4ZWwgYnVmZmVyIHRvIGJlIHBvcHVsYXRlZCB1bmRl cm5lYXRoCisgICAgICAgIGBSZW1vdGVJbWFnZUJ1ZmZlclByb3h5OjpnZXRQaXhlbEJ1ZmZlcmA7 IHRoaXMgaGFwcGVucyBiZWNhdXNlIHRoZSBHUFUgcHJvY2VzcyBzb21ldGltZXMgaGFsdHMgKGFu ZCBuZXZlcgorICAgICAgICByZXN1bWVzKSB3aGlsZSBwcm9jZXNzaW5nIHN0cmVhbSBtZXNzYWdl cywgYW5kIGNvbnNlcXVlbnRseSBuZXZlciBlbmRzIHVwIHByb2Nlc3NpbmcgdGhlIEdldFBpeGVs QnVmZmVyIElQQworICAgICAgICBzdHJlYW0gbWVzc2FnZSB0aGF0J3MgbmVjZXNzYXJ5IHRvIHBv cHVsYXRlIHRoZSBzaGFyZWQgbWVtb3J5IGJ1ZmZlciBmb3IgR2V0UGl4ZWxCdWZmZXIuCisKKyAg ICAgICAgVGhpcywgaW4gdHVybiwgaGFwcGVucyB3aGVuIHRoZSBJUEMgc3RyZWFtIGJ1ZmZlciBp cyBhYm91dCB0byBleGhhdXN0IGFsbCBhdmFpbGFibGUgY2FwYWNpdHkgKGkuZS4gdGhlIHdyaXRl CisgICAgICAgIGN1cnNvciBpcyBuZWFyaW5nIHRoZSBlbmQgb2YgdGhlIDJNQiBidWZmZXIpLCBh bmQgYXMgYSByZXN1bHQsIHdlIHNlbmQgbWVzc2FnZXMgdGhhdCB3b3VsZCBub3JtYWxseSBiZSBl bmNvZGVkCisgICAgICAgIGluIHRoZSBJUEMgc3RyZWFtIGFzIG91dC1vZi1saW5lIElQQyBtZXNz YWdlcyBpbnN0ZWFkLCB3aGljaCBhcmUgcmVjZWl2ZWQgaW4gdGhlIEdQVSBwcm9jZXNzIG9uIHRo ZSBJUEMgdGhyZWFkCisgICAgICAgIGFuZCBhcHBlbmRlZCB0byB0aGUgcmVjZWl2ZSBxdWV1ZSBj b3JyZXNwb25kaW5nIHRvIHRoZSBkZXN0aW5hdGlvbiBJRCBpbiBgQ29ubmVjdGlvbjo6cHJvY2Vz c0luY29taW5nTWVzc2FnZSgpYC4KKworICAgICAgICBJZiB3ZSBoYXBwZW4gdG8gaGF2ZSBzZW50 IGBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFnZUJ1ZmZlcihhKWAgcmlnaHQgYmVm b3JlIGV4aGF1c3RpbmcgY2FwYWNpdHkgYW5kCisgICAgICAgIHNlbmRpbmcgb3V0LW9mLWxpbmUg bWVzc2FnZXMgdGFyZ2V0aW5nIHRoZSBSZW1vdGVEaXNwbGF5TGlzdFJlY29yZGVyIGNvcnJlc3Bv bmRpbmcgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgaW1hZ2UKKyAgICAgICAgYnVmZmVyIGBhYCwgd2Un bGwgZW5kIHVwIHdpdGggYSByYWNlIGNvbmRpdGlvbiB3aGVyZSB0aGUgSVBDIHRocmVhZCBtYXkg cmVjZWl2ZSB0aGUgb3V0LW9mLWxpbmUgbWVzc2FnZXMgbWVhbnQKKyAgICAgICAgZm9yIHRoZSBu ZXcgcmVtb3RlIGRpc3BsYXkgbGlzdCBkZXN0aW5hdGlvbiAqYmVmb3JlKiB0aGUgbmV3IHJlbW90 ZSBkaXNwbGF5IGxpc3QgaGFzIGFkZGVkIGl0c2VsZiBhcyBhbiBJUEMKKyAgICAgICAgcmVjZWl2 ZSBxdWV1ZSBieSBjYWxsaW5nIGludG8gYFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OnN0YXJ0UmVj ZWl2aW5nTWVzc2FnZXMoKWAuCisKKyAgICAgICAgSW4gdGhpcyBwYXJ0aWN1bGFyIHNjZW5hcmlv ICh3aGVyZSB3ZSAibG9zZSIgdGhlIHJhY2UpLCBgQ29ubmVjdGlvbjo6cHJvY2Vzc0luY29taW5n TWVzc2FnZWAgd2lsbCBza2lwIHBhc3QgdGhlCisgICAgICAgIGVhcmx5IHJldHVybiB3aGVyZSBp dCB3b3VsZCBub3JtYWxseSBmaW5kIGl0cyBjb3JyZXNwb25kaW5nIHJlY2VpdmUgcXVldWUgdmlh IGBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKWAsCisgICAgICAgIGFuZCBpbnN0ZWFkIGZh bGxzIHRocm91Z2ggdG8gYENvbm5lY3Rpb246OlN5bmNNZXNzYWdlU3RhdGU6OnByb2Nlc3NJbmNv bWluZ01lc3NhZ2UoKWAsIHdoaWNoIHdpbGwgYXR0ZW1wdCB0bworICAgICAgICBkaXNwYXRjaCB0 aGUgaW5jb21pbmcgbWVzc2FnZSB0byB0aGUgQ29ubmVjdGlvbidzIGNsaWVudCAoR1BVQ29ubmVj dGlvblRvV2ViUHJvY2VzcykuIE9mIGNvdXJzZSwgdGhlCisgICAgICAgIEdQVUNvbm5lY3Rpb25U b1dlYlByb2Nlc3MgaXNuJ3QgYXdhcmUgb2YgaG93IHRvIHByb2Nlc3MgdGhpcyBpbmNvbWluZyBt ZXNzYWdlLCBzbyBpdCBzaW1wbHkgZ2V0cyBkcm9wcGVkLiBCeSB0aGUKKyAgICAgICAgdGltZSB0 aGUgcmVjZWl2ZSBxdWV1ZSBpcyBhZGRlZCBmb3IgdGhlIG5ldyBSZW1vdGVEaXNwbGF5TGlzdFJl Y29yZGVyLCB3ZSdsbCBvYnNlcnZlIGEgUHJvY2Vzc091dE9mU3RyZWFtTWVzc2FnZQorICAgICAg ICBhbmQgZW5kIHVwIHdhaXRpbmcgZm9yZXZlciBmb3IgdGhpcyBvdXQtb2YtbGluZSBtZXNzYWdl IHRvIGJlIGFkZGVkIHRvIHRoZSByZWNlaXZlIHF1ZXVlLCBidXQgdGhpcyBuZXZlciBlbmRzIHVw CisgICAgICAgIGhhcHBlbmluZyBiZWNhdXNlIGl0IGhhcyBhbHJlYWR5IGJlZW4gcmVjZWl2ZWQg YW5kIGRyb3BwZWQgYnkgR1BVQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy4KKworICAgICAgICBUbyBw cmV2ZW50IHRoaXMgcmFjZSBmcm9tIGhhcHBlbmluZywgd2UgY2FuIGVucXVldWUgYSBzdHJlYW0g bWVzc2FnZSB0aGF0IGRvZXMgbm90IHlldCBoYXZlIGEgY29ycmVzcG9uZGluZworICAgICAgICBy ZWNlaXZlciBvbiBgbV9pbmNvbWluZ01lc3NhZ2VzYCBpbnN0ZWFkIG9mIGZhbGxpbmcgdGhyb3Vn aCB0aGUgZWFybHkgcmV0dXJuLiBUaGlzIGFsbG93cyB1cyB0byBlbnF1ZXVlIHRoZQorICAgICAg ICBpbmNvbWluZyBtZXNzYWdlIGxhdGVyLCB1bmRlcm5lYXRoIGBDb25uZWN0aW9uOjplbnF1ZXVl TWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZWAuIFdlIGRvIHRoaXMKKyAgICAg ICAgc3BlY2lmaWNhbGx5IGZvciBvdXQtb2YtbGluZSBzdHJlYW0gbWVzc2FnZXMgKGFuZCBub3Qg YWxsIElQQyBtZXNzYWdlcyksIHNpbmNlIHdlIGtub3cgYS1wcmlvcmkgdGhhdCB0aGVzZQorICAg ICAgICBtZXNzYWdlcyByZXF1aXJlIGEgcmVjZWl2ZSBxdWV1ZSwgYW5kIHNob3VsZCBuZXZlciBi ZSBoYW5kbGVkIGFzIGEgcmVndWxhciBJUEMgbWVzc2FnZS4KKworICAgICAgICAqIFBsYXRmb3Jt L0lQQy9Db25uZWN0aW9uLmNwcDoKKyAgICAgICAgKElQQzo6Q29ubmVjdGlvbjo6cHJvY2Vzc0lu Y29taW5nTWVzc2FnZSk6CisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmFwcGVuZE1lc3NhZ2VU b1JlY2VpdmVRdWV1ZUlmUG9zc2libGUpOgorCisgICAgICAgIFB1bGwgb3V0IGxvZ2ljIGZvciBt YXBwaW5nIGEgZ2l2ZW4gbWVzc2FnZSBkZWNvZGVyIHRvIGEgcmVjZWl2ZSBxdWV1ZSBvdXQgaW50 byBhIG5ldyBoZWxwZXIgbWV0aG9kLCBhbmQgYWxzbworICAgICAgICBtYWtlIHRoZSBoZWxwZXIg bWV0aG9kIGVucXVldWUgc3RyZWFtIG1lc3NhZ2VzIHRvIHRoZSBpbmNvbWluZyBtZXNzYWdlcyBx dWV1ZSBpZiBpdCBjYW5ub3QgZmluZCBhbiBhcHByb3ByaWF0ZQorICAgICAgICByZWNlaXZlIHF1 ZXVlLgorCisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmRpc3BhdGNoTWVzc2FnZSk6CisgICAg ICAgICogUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uaDoKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dC9tZXNzYWdlcy5weToKKworICAgICAgICBBZGQgYSBoZWxwZXIgZnVuY3Rpb24gdG8gZGV0ZXJt aW5lIHdoZXRoZXIgYSBnaXZlbiBNZXNzYWdlUmVjZWl2ZXIgcmVjZWl2ZXMgc3RyZWFtIG1lc3Nh Z2VzLgorCisgICAgICAgIChnZW5lcmF0ZV9tZXNzYWdlX25hbWVzX2hlYWRlcik6CisKIDIwMjEt MTAtMTcgIEJKIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgW0NvY29hXSBXZWIg SW5zcGVjdG9yOiByZW1vdmUgX1dLSW5zcGVjdG9yRXh0ZW5zaW9uUHJpdmF0ZUZvclRlc3RpbmcK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uY3BwIGIv U291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5jcHAKaW5kZXggZmNhMmI1NGQw ZjNiZjkzMDk5N2FlMDk4OTczNGZkNWVhZmZkNTcyNy4uN2M0MWU2NDE3YTFmOThkNmVhOWQ1ZDUz Y2M0YzYzOTQ2ZmNjYzc5MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMv Q29ubmVjdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlv bi5jcHAKQEAgLTc2NCwxMCArNzY0LDggQEAgdm9pZCBDb25uZWN0aW9uOjpwcm9jZXNzSW5jb21p bmdNZXNzYWdlKHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPiBtZXNzYWdlKQogICAgIExvY2tlciB3 YWl0Rm9yTWVzc2FnZXNMb2NrZXIgeyBtX3dhaXRGb3JNZXNzYWdlTG9jayB9OwogCiAgICAgTG9j a2VyIGluY29taW5nTWVzc2FnZXNMb2NrZXIgeyBtX2luY29taW5nTWVzc2FnZXNMb2NrIH07Ci0g ICAgaWYgKGF1dG8qIHJlY2VpdmVRdWV1ZSA9IG1fcmVjZWl2ZVF1ZXVlcy5nZXQoKm1lc3NhZ2Up KSB7Ci0gICAgICAgIHJlY2VpdmVRdWV1ZS0+ZW5xdWV1ZU1lc3NhZ2UoKnRoaXMsIFdURk1vdmUo bWVzc2FnZSkpOworICAgIGlmIChhcHBlbmRNZXNzYWdlVG9SZWNlaXZlUXVldWVJZlBvc3NpYmxl KG1lc3NhZ2UpKQogICAgICAgICByZXR1cm47Ci0gICAgfQogCiAgICAgaWYgKG1lc3NhZ2UtPmlz U3luY01lc3NhZ2UoKSkgewogICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9pbmNvbWluZ1N5bmNN ZXNzYWdlQ2FsbGJhY2tMb2NrIH07CkBAIC04MDksNiArODA3LDI0IEBAIHZvaWQgQ29ubmVjdGlv bjo6cHJvY2Vzc0luY29taW5nTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4gbWVzc2Fn ZSkKICAgICBlbnF1ZXVlSW5jb21pbmdNZXNzYWdlKFdURk1vdmUobWVzc2FnZSkpOwogfQogCiti b29sIENvbm5lY3Rpb246OmFwcGVuZE1lc3NhZ2VUb1JlY2VpdmVRdWV1ZUlmUG9zc2libGUoc3Rk Ojp1bmlxdWVfcHRyPERlY29kZXI+JiBtZXNzYWdlKQoreworICAgIGlmIChhdXRvKiByZWNlaXZl UXVldWUgPSBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKSkgeworICAgICAgICByZWNlaXZl UXVldWUtPmVucXVldWVNZXNzYWdlKCp0aGlzLCBXVEZNb3ZlKG1lc3NhZ2UpKTsKKyAgICAgICAg cmV0dXJuIHRydWU7CisgICAgfQorCisgICAgaWYgKGlzU3RyZWFtTWVzc2FnZVJlY2VpdmVyKG1l c3NhZ2UtPm1lc3NhZ2VSZWNlaXZlck5hbWUoKSkpIHsKKyAgICAgICAgLy8gV2UgbWlnaHQgaGF2 ZSByZWNlaXZlZCB0aGlzIG1lc3NhZ2Ugb24gdGhlIElQQyB0aHJlYWQgYmVmb3JlIHRoZSBzdHJl YW0gZGVzdGluYXRpb24gaGFzIGFkZGVkIGl0c2VsZiBhcworICAgICAgICAvLyBhIHJlY2VpdmUg cXVldWUgb24gdGhlIGNvbm5lY3Rpb247IGluIHRoaXMgY2FzZSwgYXBwZW5kIHRoZSBtZXNzYWdl IHRvIHRoZSBpbmNvbWluZyBtZXNzYWdlIHF1ZXVlOyB3aGVuCisgICAgICAgIC8vIHRoZSByZWNl aXZlIHF1ZXVlIGlzIGFkZGVkLCB3ZSdsbCB0YWtlIHRoaXMgcXVldWVkIG1lc3NhZ2UgYW5kIGFw cGVuZCBpdCB0byB0aGUgcmVjZWl2ZSBxdWV1ZS4KKyAgICAgICAgbV9pbmNvbWluZ01lc3NhZ2Vz LmFwcGVuZChXVEZNb3ZlKG1lc3NhZ2UpKTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQor CisgICAgcmV0dXJuIGZhbHNlOworfQorCiB1aW50NjRfdCBDb25uZWN0aW9uOjppbnN0YWxsSW5j b21pbmdTeW5jTWVzc2FnZUNhbGxiYWNrKFdURjo6RnVuY3Rpb248dm9pZCAoKT4mJiBjYWxsYmFj aykKIHsKICAgICBMb2NrZXIgbG9ja2VyIHsgbV9pbmNvbWluZ1N5bmNNZXNzYWdlQ2FsbGJhY2tM b2NrIH07CkBAIC0xMDcyLDEwICsxMDg4LDggQEAgdm9pZCBDb25uZWN0aW9uOjpkaXNwYXRjaE1l c3NhZ2Uoc3RkOjp1bmlxdWVfcHRyPERlY29kZXI+IG1lc3NhZ2UpCiAgICAgICAgIC8vIGdvIHRv IENvbm5lY3Rpb246Om1faW5jb21pbmdNZXNzYWdlcy4gU2hvdWxkIGJlIGZpeGVkIGJ5IGFkZGlu ZyBhbGwKICAgICAgICAgLy8gbWVzc2FnZXMgdG8gb25lIGxpc3QuCiAgICAgICAgIExvY2tlciBp bmNvbWluZ01lc3NhZ2VzTG9ja2VyIHsgbV9pbmNvbWluZ01lc3NhZ2VzTG9jayB9OwotICAgICAg ICBpZiAoYXV0byogcmVjZWl2ZVF1ZXVlID0gbV9yZWNlaXZlUXVldWVzLmdldCgqbWVzc2FnZSkp IHsKLSAgICAgICAgICAgIHJlY2VpdmVRdWV1ZS0+ZW5xdWV1ZU1lc3NhZ2UoKnRoaXMsIFdURk1v dmUobWVzc2FnZSkpOworICAgICAgICBpZiAoYXBwZW5kTWVzc2FnZVRvUmVjZWl2ZVF1ZXVlSWZQ b3NzaWJsZShtZXNzYWdlKSkKICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQogICAgIH0K IAogICAgIGlmIChtZXNzYWdlLT5zaG91bGRVc2VGdWxseVN5bmNocm9ub3VzTW9kZUZvclRlc3Rp bmcoKSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlv bi5oIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oCmluZGV4IDIyMGU1 ZWFiY2M0MDk5NjhlZjdiZmYwMDllYzc2MjgyNWMzZTBjNTUuLmYwZWQ1ODMxMDJmMDY1ZGNkNTE4 NTk4MGRkOWNhMmYwMDY3NjUyYTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0v SVBDL0Nvbm5lY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0 aW9uLmgKQEAgLTM3Niw2ICszNzYsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgc2VuZE1lc3NhZ2Uo c3RkOjp1bmlxdWVfcHRyPE1hY2hNZXNzYWdlPik7CiAjZW5kaWYKIAorICAgIGJvb2wgYXBwZW5k TWVzc2FnZVRvUmVjZWl2ZVF1ZXVlSWZQb3NzaWJsZShzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4m KSBXVEZfUkVRVUlSRVNfTE9DSyhtX2luY29taW5nTWVzc2FnZXNMb2NrKTsKKwogICAgIGNsYXNz IE1lc3NhZ2VzVGhyb3R0bGVyIHsKICAgICAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiAg ICAgcHVibGljOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC9tZXNz YWdlcy5weSBiL1NvdXJjZS9XZWJLaXQvU2NyaXB0cy93ZWJraXQvbWVzc2FnZXMucHkKaW5kZXgg NjU4NGQxYWQ3ZTE1NGViMDkyMDIzMTBkZGZhNmI1ZTEyMWFkMmMzOS4uZjdjY2RjOGM2N2QyYmEy YzNkZWY4ZGEyZWMyZGU0YmY4YTUyNjBiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TY3Jp cHRzL3dlYmtpdC9tZXNzYWdlcy5weQorKysgYi9Tb3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Via2l0 L21lc3NhZ2VzLnB5CkBAIC0xMDkzLDYgKzEwOTMsMTggQEAgZGVmIGdlbmVyYXRlX21lc3NhZ2Vf bmFtZXNfaGVhZGVyKHJlY2VpdmVycyk6CiAgICAgICAgIHJlc3VsdC5hcHBlbmQoJyAgICByZXR1 cm4gZmFsc2U7XG4nKQogICAgIHJlc3VsdC5hcHBlbmQoJ31cbicpCiAgICAgcmVzdWx0LmFwcGVu ZCgnXG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJ2NvbnN0ZXhwciBib29sIGlzU3RyZWFtTWVzc2Fn ZVJlY2VpdmVyKFJlY2VpdmVyTmFtZSBuYW1lKVxuJykKKyAgICByZXN1bHQuYXBwZW5kKCd7XG4n KQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICBzd2l0Y2ggKG5hbWUpIHtcbicpCisgICAgZm9yIG5h bWUgaW4gW3JlY2VpdmVyLm5hbWUgZm9yIHJlY2VpdmVyIGluIHJlY2VpdmVycyBpZiByZWNlaXZl ci5oYXNfYXR0cmlidXRlKFNUUkVBTV9BVFRSSUJVVEUpXToKKyAgICAgICAgcmVzdWx0LmFwcGVu ZCgnICAgIGNhc2UgUmVjZWl2ZXJOYW1lOjolczpcbicgJSBuYW1lKQorICAgIHJlc3VsdC5hcHBl bmQoJyAgICAgICAgcmV0dXJuIHRydWU7XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICBkZWZh dWx0OlxuJykKKyAgICByZXN1bHQuYXBwZW5kKCcgICAgICAgIGJyZWFrO1xuJykKKyAgICByZXN1 bHQuYXBwZW5kKCcgICAgfVxuJykKKyAgICByZXN1bHQuYXBwZW5kKCcgICAgcmV0dXJuIGZhbHNl O1xuJykKKyAgICByZXN1bHQuYXBwZW5kKCd9XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJ1xuJykK ICAgICByZXN1bHQuYXBwZW5kKCd9IC8vIG5hbWVzcGFjZSBJUENcbicpCiAgICAgcmVzdWx0LmFw cGVuZCgnXG4nKQogICAgIHJlc3VsdC5hcHBlbmQoJ25hbWVzcGFjZSBXVEYge1xuJykKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCA1OWE5OGE2OTA2YzVjMDVjZDA3MGE5YzljMzlkOGI3Y2U1YTM3YzhiLi43MTI1OGExOTUyOWE0 M2VlOWExNDQwNjRkMmM0OTIyZGQwYzdiY2ZjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjEt MTAtMTcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg UkVHUkVTU0lPTiAocjI4NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1s IGFuZCBmYXN0L2NhbnZhcy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5 IGZhaWx1cmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMzE2ODEKKyAgICAgICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVtb3ZlIHRoZSBmbGFreSBmYWlsdXJlIGVudHJp ZXMgaW4gdGVzdCBleHBlY3RhdGlvbnMuIFNlZSBXZWJLaXQyIENoYW5nZUxvZyBmb3IgbW9yZSBk ZXRhaWxzLgorCisgICAgICAgICogcGxhdGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0YXRpb25zOgor ICAgICAgICAqIHBsYXRmb3JtL21hYy13azIvVGVzdEV4cGVjdGF0aW9uczoKKwogMjAyMS0xMC0x NyAgU2ltb24gRnJhc2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdS RVNTSU9OIChyMjcwODUwKTogUmVmZXJlbmNlIGNsaXAgcGF0aCBjbGlwcyBpbiB0aGUgd3Jvbmcg cGxhY2Ugd2hlbiBpbnNpZGUgbm9uLXZpc2libGUgb3ZlcmZsb3cKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2lvcy13azIvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2lvcy13azIvVGVzdEV4cGVjdGF0aW9ucwppbmRleCAxM2Y0ZWMwYzljMzViODUyNGFi ZDdlODlkZmQxNTM4YTgwYTliY2ZlLi42YzVjMmIyM2NkMDkzYzM2NmZhOWIyNDUzNmNkZjdjMTli N2RjNGEyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBl Y3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0YXRp b25zCkBAIC0yMDMyLDkgKzIwMzIsNiBAQCB3ZWJraXQub3JnL2IvMjE5NDM4IFsgUmVsZWFzZSBd IGZhc3QvY2FudmFzL2NhbnZhcy1vdmVyZmxvdy1oaWRkZW4tYW5pbWF0aW9uLmh0bQogCiB3ZWJr aXQub3JnL2IvMjMwNDEzIFsgRGVidWcgXSBmYXN0L2NhbnZhcy9jYW52YXMtZHJhd0ltYWdlLWRl dGFjaGVkLWxlYWsuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCiAKLXdlYmtpdC5vcmcvYi8yMzE2ODEg WyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvZ3JhZGllbnQtdGV4dC13aXRoLXNoYWRvdy5odG1sIFsg UGFzcyBGYWlsdXJlIF0KLXdlYmtpdC5vcmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0gZmFzdC9jYW52 YXMvZ3JhZGllbnQtd2l0aC1jbGlwLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQotCiB3ZWJhbmltYXRp b25zL211bHRpcGxlLXRyYW5zZm9ybS1wcm9wZXJ0aWVzLWFuZC1tdWx0aXBsZS10cmFuc2Zvcm0t cHJvcGVydGllcy1hbmltYXRpb24td2l0aC1kZWxheS1vbi1mb3JjZWQtbGF5ZXIuaHRtbCBbIFBh c3MgXQogd2ViYW5pbWF0aW9ucy9yb3RhdGUtcHJvcGVydHktYW5kLXJvdGF0ZS1hbmltYXRpb24t d2l0aC1kZWxheS1vbi1mb3JjZWQtbGF5ZXIuaHRtbCBbIFBhc3MgXQogd2ViYW5pbWF0aW9ucy9z Y2FsZS1wcm9wZXJ0eS1hbmQtc2NhbGUtYW5pbWF0aW9uLXdpdGgtZGVsYXktb24tZm9yY2VkLWxh eWVyLmh0bWwgWyBQYXNzIF0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy13 azIvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvVGVzdEV4 cGVjdGF0aW9ucwppbmRleCA4ODk1ZWMyZjNkYjA3ZmMwOTU0NDhhNTMyZmYxMTEzNWMxMjJhZWM1 Li45YTRmOTJhNTliMjFiZTQzZDY4ZGNkYzgwY2M4YTE0MDc4ZDgxMWI5IDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRpb25zCkBAIC0xNTEzLDkgKzE1MTMs NiBAQCB3ZWJraXQub3JnL2IvMjI3ODA1IFsgRGVidWcgXSBmYXN0L2NhbnZhcy9jYW52YXMtY29t cG9zaXRlLWltYWdlLmh0bWwgWyBQYXNzIENyYQogd2Via2l0Lm9yZy9iLzIzMDM2NiBbIFJlbGVh c2UgXSBmYXN0L2NhbnZhcy9jYW52YXMtYmxlbmRpbmctdGV4dC5odG1sIFsgUGFzcyBGYWlsdXJl IENyYXNoIF0KIHdlYmtpdC5vcmcvYi8yMzAzNjYgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvY2Fu dmFzLWNvbXBvc2l0ZS10ZXh0LWFscGhhLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQogCi13ZWJraXQu b3JnL2IvMjMxNjgxIFsgUmVsZWFzZSBdIGZhc3QvY2FudmFzL2dyYWRpZW50LXRleHQtd2l0aC1z aGFkb3cuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCi13ZWJraXQub3JnL2IvMjMxNjgxIFsgUmVsZWFz ZSBdIGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIFsgUGFzcyBGYWlsdXJlIF0K LQogd2Via2l0Lm9yZy9iLzIzMDQxMyBmYXN0L2NhbnZhcy9jYW52YXMtZHJhd0ltYWdlLWRldGFj aGVkLWxlYWsuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCiAKIHdlYmtpdC5vcmcvYi8yMjY4MjggWyBC aWdTdXIrIF0gbWVkaWEvbW9kZXJuLW1lZGlhLWNvbnRyb2xzL292ZXJmbG93LXN1cHBvcnQvY2hh cHRlcnMuaHRtbCBbIFBhc3MgRmFpbHVyZSBUaW1lb3V0IF0K 441553 2021-10-17 15:24:59 -0700 2021-10-19 09:54:55 -0700 Initial approach bug-231681-20211017152458.patch text/plain 12250 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MzM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDNkOTg0NzhkYjNjNGM1NjU1 ZWNmOTU2OGQwNzExZjRlYmE4NTdlZDEuLjZhYmJkNDAwNGQ4YmJiZjQ1ZTM2NTY0ZDUzY2E1N2U5 NThmNmIxZjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjAgQEAKKzIwMjEtMTAtMTcgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAocjI4 NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIGFuZCBmYXN0L2NhbnZh cy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5IGZhaWx1cmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2ODEKKyAgICAg ICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhlc2UgdGVzdHMgb2NjYXNpb25hbGx5IGZhaWwgd2hlbiB3ZSB0aW1lIG91 dCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgcGl4ZWwgYnVmZmVyIHRvIGJlIHBvcHVsYXRlZCB1bmRl cm5lYXRoCisgICAgICAgIGBSZW1vdGVJbWFnZUJ1ZmZlclByb3h5OjpnZXRQaXhlbEJ1ZmZlcmA7 IHRoaXMgaGFwcGVucyBiZWNhdXNlIHRoZSBHUFUgcHJvY2VzcyBzb21ldGltZXMgaGFsdHMgKGFu ZCBuZXZlcgorICAgICAgICByZXN1bWVzKSB3aGlsZSBwcm9jZXNzaW5nIHN0cmVhbSBtZXNzYWdl cywgYW5kIGNvbnNlcXVlbnRseSBuZXZlciBlbmRzIHVwIHByb2Nlc3NpbmcgdGhlIEdldFBpeGVs QnVmZmVyIElQQworICAgICAgICBzdHJlYW0gbWVzc2FnZSB0aGF0J3MgbmVjZXNzYXJ5IHRvIHBv cHVsYXRlIHRoZSBzaGFyZWQgbWVtb3J5IGJ1ZmZlciBmb3IgR2V0UGl4ZWxCdWZmZXIuCisKKyAg ICAgICAgVGhpcywgaW4gdHVybiwgaGFwcGVucyB3aGVuIHRoZSBJUEMgc3RyZWFtIGJ1ZmZlciBp cyBhYm91dCB0byBleGhhdXN0IGFsbCBhdmFpbGFibGUgY2FwYWNpdHkgKGkuZS4gdGhlIHdyaXRl CisgICAgICAgIGN1cnNvciBpcyBuZWFyaW5nIHRoZSBlbmQgb2YgdGhlIDJNQiBidWZmZXIpLCBh bmQgYXMgYSByZXN1bHQsIHdlIHNlbmQgbWVzc2FnZXMgdGhhdCB3b3VsZCBub3JtYWxseSBiZSBl bmNvZGVkCisgICAgICAgIGluIHRoZSBJUEMgc3RyZWFtIGFzIG91dC1vZi1saW5lIElQQyBtZXNz YWdlcyBpbnN0ZWFkLCB3aGljaCBhcmUgcmVjZWl2ZWQgaW4gdGhlIEdQVSBwcm9jZXNzIG9uIHRo ZSBJUEMgdGhyZWFkCisgICAgICAgIGFuZCBhcHBlbmRlZCB0byB0aGUgcmVjZWl2ZSBxdWV1ZSBj b3JyZXNwb25kaW5nIHRvIHRoZSBkZXN0aW5hdGlvbiBJRCBpbiBgQ29ubmVjdGlvbjo6cHJvY2Vz c0luY29taW5nTWVzc2FnZSgpYC4KKworICAgICAgICBJZiB3ZSBoYXBwZW4gdG8gaGF2ZSBzZW50 IGBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFnZUJ1ZmZlcihhKWAgcmlnaHQgYmVm b3JlIGV4aGF1c3RpbmcgY2FwYWNpdHkgYW5kCisgICAgICAgIHNlbmRpbmcgb3V0LW9mLWxpbmUg bWVzc2FnZXMgdGFyZ2V0aW5nIHRoZSBSZW1vdGVEaXNwbGF5TGlzdFJlY29yZGVyIGNvcnJlc3Bv bmRpbmcgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgaW1hZ2UKKyAgICAgICAgYnVmZmVyIGBhYCwgd2Un bGwgZW5kIHVwIHdpdGggYSByYWNlIGNvbmRpdGlvbiB3aGVyZSB0aGUgSVBDIHRocmVhZCBtYXkg cmVjZWl2ZSB0aGUgb3V0LW9mLWxpbmUgbWVzc2FnZXMgbWVhbnQKKyAgICAgICAgZm9yIHRoZSBu ZXcgcmVtb3RlIGRpc3BsYXkgbGlzdCBkZXN0aW5hdGlvbiAqYmVmb3JlKiB0aGUgbmV3IHJlbW90 ZSBkaXNwbGF5IGxpc3QgaGFzIGFkZGVkIGl0c2VsZiBhcyBhbiBJUEMKKyAgICAgICAgcmVjZWl2 ZSBxdWV1ZSBieSBjYWxsaW5nIGludG8gYFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OnN0YXJ0UmVj ZWl2aW5nTWVzc2FnZXMoKWAuCisKKyAgICAgICAgSW4gdGhpcyBwYXJ0aWN1bGFyIHNjZW5hcmlv ICh3aGVyZSB3ZSAibG9zZSIgdGhlIHJhY2UpLCBgQ29ubmVjdGlvbjo6cHJvY2Vzc0luY29taW5n TWVzc2FnZWAgd2lsbCBza2lwIHBhc3QgdGhlCisgICAgICAgIGVhcmx5IHJldHVybiB3aGVyZSBp dCB3b3VsZCBub3JtYWxseSBmaW5kIGl0cyBjb3JyZXNwb25kaW5nIHJlY2VpdmUgcXVldWUgdmlh IGBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKWAsCisgICAgICAgIGFuZCBpbnN0ZWFkIGZh bGxzIHRocm91Z2ggdG8gYENvbm5lY3Rpb246OlN5bmNNZXNzYWdlU3RhdGU6OnByb2Nlc3NJbmNv bWluZ01lc3NhZ2UoKWAsIHdoaWNoIHdpbGwgYXR0ZW1wdCB0bworICAgICAgICBkaXNwYXRjaCB0 aGUgaW5jb21pbmcgbWVzc2FnZSB0byB0aGUgQ29ubmVjdGlvbidzIGNsaWVudCAoR1BVQ29ubmVj dGlvblRvV2ViUHJvY2VzcykuIE9mIGNvdXJzZSwgdGhlCisgICAgICAgIEdQVUNvbm5lY3Rpb25U b1dlYlByb2Nlc3MgaXNuJ3QgYXdhcmUgb2YgaG93IHRvIHByb2Nlc3MgdGhpcyBpbmNvbWluZyBt ZXNzYWdlLCBzbyBpdCBzaW1wbHkgZ2V0cyBkcm9wcGVkLiBCeSB0aGUKKyAgICAgICAgdGltZSB0 aGUgcmVjZWl2ZSBxdWV1ZSBpcyBhZGRlZCBmb3IgdGhlIG5ldyBSZW1vdGVEaXNwbGF5TGlzdFJl Y29yZGVyLCB3ZSdsbCBvYnNlcnZlIGEgUHJvY2Vzc091dE9mU3RyZWFtTWVzc2FnZQorICAgICAg ICBhbmQgZW5kIHVwIHdhaXRpbmcgZm9yZXZlciBmb3IgdGhpcyBvdXQtb2YtbGluZSBtZXNzYWdl IHRvIGJlIGFkZGVkIHRvIHRoZSByZWNlaXZlIHF1ZXVlLCBidXQgdGhpcyBuZXZlciBlbmRzIHVw CisgICAgICAgIGhhcHBlbmluZyBiZWNhdXNlIGl0IGhhcyBhbHJlYWR5IGJlZW4gcmVjZWl2ZWQg YW5kIGRyb3BwZWQgYnkgR1BVQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy4KKworICAgICAgICBUbyBw cmV2ZW50IHRoaXMgcmFjZSBmcm9tIGhhcHBlbmluZywgd2UgY2FuIGVucXVldWUgYSBzdHJlYW0g bWVzc2FnZSB0aGF0IGRvZXMgbm90IHlldCBoYXZlIGEgY29ycmVzcG9uZGluZworICAgICAgICBy ZWNlaXZlciBvbiBgbV9pbmNvbWluZ01lc3NhZ2VzYCBpbnN0ZWFkIG9mIGZhbGxpbmcgdGhyb3Vn aCB0aGUgZWFybHkgcmV0dXJuLiBUaGlzIGFsbG93cyB1cyB0byBlbnF1ZXVlIHRoZQorICAgICAg ICBpbmNvbWluZyBtZXNzYWdlIGxhdGVyLCB1bmRlcm5lYXRoIGBDb25uZWN0aW9uOjplbnF1ZXVl TWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZWAuIFdlIGRvIHRoaXMKKyAgICAg ICAgc3BlY2lmaWNhbGx5IGZvciBvdXQtb2YtbGluZSBzdHJlYW0gbWVzc2FnZXMgKGFuZCBub3Qg YWxsIElQQyBtZXNzYWdlcyksIHNpbmNlIHdlIGtub3cgYS1wcmlvcmkgdGhhdCB0aGVzZQorICAg ICAgICBtZXNzYWdlcyByZXF1aXJlIGEgcmVjZWl2ZSBxdWV1ZSwgYW5kIHNob3VsZCBuZXZlciBi ZSBoYW5kbGVkIGFzIGEgcmVndWxhciBJUEMgbWVzc2FnZS4KKworICAgICAgICAqIFBsYXRmb3Jt L0lQQy9Db25uZWN0aW9uLmNwcDoKKyAgICAgICAgKElQQzo6Q29ubmVjdGlvbjo6cHJvY2Vzc0lu Y29taW5nTWVzc2FnZSk6CisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmFwcGVuZE1lc3NhZ2VU b1JlY2VpdmVRdWV1ZUlmUG9zc2libGUpOgorCisgICAgICAgIFB1bGwgb3V0IGxvZ2ljIGZvciBt YXBwaW5nIGEgZ2l2ZW4gbWVzc2FnZSBkZWNvZGVyIHRvIGEgcmVjZWl2ZSBxdWV1ZSBvdXQgaW50 byBhIG5ldyBoZWxwZXIgbWV0aG9kLCBhbmQgYWxzbworICAgICAgICBtYWtlIHRoZSBoZWxwZXIg bWV0aG9kIGVucXVldWUgc3RyZWFtIG1lc3NhZ2VzIHRvIHRoZSBpbmNvbWluZyBtZXNzYWdlcyBx dWV1ZSBpZiBpdCBjYW5ub3QgZmluZCBhbiBhcHByb3ByaWF0ZQorICAgICAgICByZWNlaXZlIHF1 ZXVlLgorCisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmRpc3BhdGNoTWVzc2FnZSk6CisgICAg ICAgICogUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uaDoKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dC9tZXNzYWdlcy5weToKKworICAgICAgICBBZGQgYSBoZWxwZXIgZnVuY3Rpb24gdG8gZGV0ZXJt aW5lIHdoZXRoZXIgYSBnaXZlbiBNZXNzYWdlUmVjZWl2ZXIgcmVjZWl2ZXMgc3RyZWFtIG1lc3Nh Z2VzLgorCisgICAgICAgIChnZW5lcmF0ZV9tZXNzYWdlX25hbWVzX2hlYWRlcik6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXQvdGVzdHMvTWVzc2FnZU5hbWVzLmg6CisgICAgICAgIChJUEM6Omlz U3RyZWFtTWVzc2FnZVJlY2VpdmVyKToKKwogMjAyMS0xMC0xNyAgQkogQnVyZyAgPGJidXJnQGFw cGxlLmNvbT4KIAogICAgICAgICBbQ29jb2FdIFdlYiBJbnNwZWN0b3I6IHJlbW92ZSBfV0tJbnNw ZWN0b3JFeHRlbnNpb25Qcml2YXRlRm9yVGVzdGluZwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5jcHAgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQ Qy9Db25uZWN0aW9uLmNwcAppbmRleCBmY2EyYjU0ZDBmM2JmOTMwOTk3YWUwOTg5NzM0ZmQ1ZWFm ZmQ1NzI3Li43YzQxZTY0MTdhMWY5OGQ2ZWE5ZDVkNTNjYzRjNjM5NDZmY2NjNzkwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmNwcApAQCAtNzY0LDEwICs3NjQsOCBA QCB2b2lkIENvbm5lY3Rpb246OnByb2Nlc3NJbmNvbWluZ01lc3NhZ2Uoc3RkOjp1bmlxdWVfcHRy PERlY29kZXI+IG1lc3NhZ2UpCiAgICAgTG9ja2VyIHdhaXRGb3JNZXNzYWdlc0xvY2tlciB7IG1f d2FpdEZvck1lc3NhZ2VMb2NrIH07CiAKICAgICBMb2NrZXIgaW5jb21pbmdNZXNzYWdlc0xvY2tl ciB7IG1faW5jb21pbmdNZXNzYWdlc0xvY2sgfTsKLSAgICBpZiAoYXV0byogcmVjZWl2ZVF1ZXVl ID0gbV9yZWNlaXZlUXVldWVzLmdldCgqbWVzc2FnZSkpIHsKLSAgICAgICAgcmVjZWl2ZVF1ZXVl LT5lbnF1ZXVlTWVzc2FnZSgqdGhpcywgV1RGTW92ZShtZXNzYWdlKSk7CisgICAgaWYgKGFwcGVu ZE1lc3NhZ2VUb1JlY2VpdmVRdWV1ZUlmUG9zc2libGUobWVzc2FnZSkpCiAgICAgICAgIHJldHVy bjsKLSAgICB9CiAKICAgICBpZiAobWVzc2FnZS0+aXNTeW5jTWVzc2FnZSgpKSB7CiAgICAgICAg IExvY2tlciBsb2NrZXIgeyBtX2luY29taW5nU3luY01lc3NhZ2VDYWxsYmFja0xvY2sgfTsKQEAg LTgwOSw2ICs4MDcsMjQgQEAgdm9pZCBDb25uZWN0aW9uOjpwcm9jZXNzSW5jb21pbmdNZXNzYWdl KHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPiBtZXNzYWdlKQogICAgIGVucXVldWVJbmNvbWluZ01l c3NhZ2UoV1RGTW92ZShtZXNzYWdlKSk7CiB9CiAKK2Jvb2wgQ29ubmVjdGlvbjo6YXBwZW5kTWVz c2FnZVRvUmVjZWl2ZVF1ZXVlSWZQb3NzaWJsZShzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4mIG1l c3NhZ2UpCit7CisgICAgaWYgKGF1dG8qIHJlY2VpdmVRdWV1ZSA9IG1fcmVjZWl2ZVF1ZXVlcy5n ZXQoKm1lc3NhZ2UpKSB7CisgICAgICAgIHJlY2VpdmVRdWV1ZS0+ZW5xdWV1ZU1lc3NhZ2UoKnRo aXMsIFdURk1vdmUobWVzc2FnZSkpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAg ICBpZiAoaXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIobWVzc2FnZS0+bWVzc2FnZVJlY2VpdmVyTmFt ZSgpKSkgeworICAgICAgICAvLyBXZSBtaWdodCBoYXZlIHJlY2VpdmVkIHRoaXMgbWVzc2FnZSBv biB0aGUgSVBDIHRocmVhZCBiZWZvcmUgdGhlIHN0cmVhbSBkZXN0aW5hdGlvbiBoYXMgYWRkZWQg aXRzZWxmIGFzCisgICAgICAgIC8vIGEgcmVjZWl2ZSBxdWV1ZSBvbiB0aGUgY29ubmVjdGlvbjsg aW4gdGhpcyBjYXNlLCBhcHBlbmQgdGhlIG1lc3NhZ2UgdG8gdGhlIGluY29taW5nIG1lc3NhZ2Ug cXVldWU7IHdoZW4KKyAgICAgICAgLy8gdGhlIHJlY2VpdmUgcXVldWUgaXMgYWRkZWQsIHdlJ2xs IHRha2UgdGhpcyBxdWV1ZWQgbWVzc2FnZSBhbmQgYXBwZW5kIGl0IHRvIHRoZSByZWNlaXZlIHF1 ZXVlLgorICAgICAgICBtX2luY29taW5nTWVzc2FnZXMuYXBwZW5kKFdURk1vdmUobWVzc2FnZSkp OworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK IHVpbnQ2NF90IENvbm5lY3Rpb246Omluc3RhbGxJbmNvbWluZ1N5bmNNZXNzYWdlQ2FsbGJhY2so V1RGOjpGdW5jdGlvbjx2b2lkICgpPiYmIGNhbGxiYWNrKQogewogICAgIExvY2tlciBsb2NrZXIg eyBtX2luY29taW5nU3luY01lc3NhZ2VDYWxsYmFja0xvY2sgfTsKQEAgLTEwNzIsMTAgKzEwODgs OCBAQCB2b2lkIENvbm5lY3Rpb246OmRpc3BhdGNoTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8RGVj b2Rlcj4gbWVzc2FnZSkKICAgICAgICAgLy8gZ28gdG8gQ29ubmVjdGlvbjo6bV9pbmNvbWluZ01l c3NhZ2VzLiBTaG91bGQgYmUgZml4ZWQgYnkgYWRkaW5nIGFsbAogICAgICAgICAvLyBtZXNzYWdl cyB0byBvbmUgbGlzdC4KICAgICAgICAgTG9ja2VyIGluY29taW5nTWVzc2FnZXNMb2NrZXIgeyBt X2luY29taW5nTWVzc2FnZXNMb2NrIH07Ci0gICAgICAgIGlmIChhdXRvKiByZWNlaXZlUXVldWUg PSBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKSkgewotICAgICAgICAgICAgcmVjZWl2ZVF1 ZXVlLT5lbnF1ZXVlTWVzc2FnZSgqdGhpcywgV1RGTW92ZShtZXNzYWdlKSk7CisgICAgICAgIGlm IChhcHBlbmRNZXNzYWdlVG9SZWNlaXZlUXVldWVJZlBvc3NpYmxlKG1lc3NhZ2UpKQogICAgICAg ICAgICAgcmV0dXJuOwotICAgICAgICB9CiAgICAgfQogCiAgICAgaWYgKG1lc3NhZ2UtPnNob3Vs ZFVzZUZ1bGx5U3luY2hyb25vdXNNb2RlRm9yVGVzdGluZygpKSB7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmggYi9Tb3VyY2UvV2ViS2l0L1BsYXRm b3JtL0lQQy9Db25uZWN0aW9uLmgKaW5kZXggMjIwZTVlYWJjYzQwOTk2OGVmN2JmZjAwOWVjNzYy ODI1YzNlMGM1NS4uZjBlZDU4MzEwMmYwNjVkY2Q1MTg1OTgwZGQ5Y2EyZjAwNjc2NTJhNCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uaApAQCAtMzc2LDYgKzM3Niw4IEBA IHByaXZhdGU6CiAgICAgYm9vbCBzZW5kTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8TWFjaE1lc3Nh Z2U+KTsKICNlbmRpZgogCisgICAgYm9vbCBhcHBlbmRNZXNzYWdlVG9SZWNlaXZlUXVldWVJZlBv c3NpYmxlKHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPiYpIFdURl9SRVFVSVJFU19MT0NLKG1faW5j b21pbmdNZXNzYWdlc0xvY2spOworCiAgICAgY2xhc3MgTWVzc2FnZXNUaHJvdHRsZXIgewogICAg ICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJsaWM6CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5IGIvU291cmNlL1dlYktpdC9T Y3JpcHRzL3dlYmtpdC9tZXNzYWdlcy5weQppbmRleCA2NTg0ZDFhZDdlMTU0ZWIwOTIwMjMxMGRk ZmE2YjVlMTIxYWQyYzM5Li5mN2NjZGM4YzY3ZDJiYTJjM2RlZjhkYTJlYzJkZTRiZjhhNTI2MGJi IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5Cisr KyBiL1NvdXJjZS9XZWJLaXQvU2NyaXB0cy93ZWJraXQvbWVzc2FnZXMucHkKQEAgLTEwOTMsNiAr MTA5MywxOCBAQCBkZWYgZ2VuZXJhdGVfbWVzc2FnZV9uYW1lc19oZWFkZXIocmVjZWl2ZXJzKToK ICAgICAgICAgcmVzdWx0LmFwcGVuZCgnICAgIHJldHVybiBmYWxzZTtcbicpCiAgICAgcmVzdWx0 LmFwcGVuZCgnfVxuJykKICAgICByZXN1bHQuYXBwZW5kKCdcbicpCisgICAgcmVzdWx0LmFwcGVu ZCgnY29uc3RleHByIGJvb2wgaXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIoUmVjZWl2ZXJOYW1lIG5h bWUpXG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJ3tcbicpCisgICAgcmVzdWx0LmFwcGVuZCgnICAg IHN3aXRjaCAobmFtZSkge1xuJykKKyAgICBmb3IgbmFtZSBpbiBbcmVjZWl2ZXIubmFtZSBmb3Ig cmVjZWl2ZXIgaW4gcmVjZWl2ZXJzIGlmIHJlY2VpdmVyLmhhc19hdHRyaWJ1dGUoU1RSRUFNX0FU VFJJQlVURSldOgorICAgICAgICByZXN1bHQuYXBwZW5kKCcgICAgY2FzZSBSZWNlaXZlck5hbWU6 OiVzOlxuJyAlIG5hbWUpCisgICAgcmVzdWx0LmFwcGVuZCgnICAgICAgICByZXR1cm4gdHJ1ZTtc bicpCisgICAgcmVzdWx0LmFwcGVuZCgnICAgIGRlZmF1bHQ6XG4nKQorICAgIHJlc3VsdC5hcHBl bmQoJyAgICAgICAgYnJlYWs7XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICB9XG4nKQorICAg IHJlc3VsdC5hcHBlbmQoJyAgICByZXR1cm4gZmFsc2U7XG4nKQorICAgIHJlc3VsdC5hcHBlbmQo J31cbicpCisgICAgcmVzdWx0LmFwcGVuZCgnXG4nKQogICAgIHJlc3VsdC5hcHBlbmQoJ30gLy8g bmFtZXNwYWNlIElQQ1xuJykKICAgICByZXN1bHQuYXBwZW5kKCdcbicpCiAgICAgcmVzdWx0LmFw cGVuZCgnbmFtZXNwYWNlIFdURiB7XG4nKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TY3Jp cHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdlTmFtZXMuaCBiL1NvdXJjZS9XZWJLaXQvU2NyaXB0cy93 ZWJraXQvdGVzdHMvTWVzc2FnZU5hbWVzLmgKaW5kZXggMmVmZDVlMDQ5MGYxMDZhYzA2YWYxZTlj MjRhZmU3NDYwMTUxNzkzNi4uZGI0MTc4MTAzODJjMzIyYmE2OThhZjJhMDg2N2YyNGUyZmY5NmFh ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdl TmFtZXMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Via2l0L3Rlc3RzL01lc3NhZ2VO YW1lcy5oCkBAIC0xMjksNiArMTI5LDE3IEBAIGNvbnN0ZXhwciBib29sIG1lc3NhZ2VJc1N5bmMo TWVzc2FnZU5hbWUgbmFtZSkKICAgICByZXR1cm4gbmFtZSA+PSBNZXNzYWdlTmFtZTo6VGVzdFdp dGhMZWdhY3lSZWNlaXZlcl9HZXRQbHVnaW5Qcm9jZXNzQ29ubmVjdGlvbjsKIH0KIAorY29uc3Rl eHByIGJvb2wgaXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIoUmVjZWl2ZXJOYW1lIG5hbWUpCit7Cisg ICAgc3dpdGNoIChuYW1lKSB7CisgICAgY2FzZSBSZWNlaXZlck5hbWU6OlRlc3RXaXRoU3RyZWFt OgorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBkZWZhdWx0OgorICAgICAgICBicmVhazsKKyAg ICB9CisgICAgcmV0dXJuIGZhbHNlOworfQorCiB9IC8vIG5hbWVzcGFjZSBJUEMKIAogbmFtZXNw YWNlIFdURiB7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKaW5kZXggNTlhOThhNjkwNmM1YzA1Y2QwNzBhOWM5YzM5ZDhiN2NlNWEzN2M4 Yi4uNzEyNThhMTk1MjlhNDNlZTlhMTQ0MDY0ZDJjNDkyMmRkMGM3YmNmYyAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE2IEBACisyMDIxLTEwLTE3ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUu Y29tPgorCisgICAgICAgIFJFR1JFU1NJT04gKHIyODQwNzkpOiBmYXN0L2NhbnZhcy9ncmFkaWVu dC13aXRoLWNsaXAuaHRtbCBhbmQgZmFzdC9jYW52YXMvZ3JhZGllbnQtdGV4dC13aXRoLXNoYWRv dy5odG1sIGFyZSBmbGFreSBmYWlsdXJlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjMxNjgxCisgICAgICAgIHJkYXI6Ly84NDIwMjQ3OAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlbW92ZSB0aGUgZmxh a3kgZmFpbHVyZSBlbnRyaWVzIGluIHRlc3QgZXhwZWN0YXRpb25zLiBTZWUgV2ViS2l0MiBDaGFu Z2VMb2cgZm9yIG1vcmUgZGV0YWlscy4KKworICAgICAgICAqIHBsYXRmb3JtL2lvcy13azIvVGVz dEV4cGVjdGF0aW9uczoKKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlv bnM6CisKIDIwMjEtMTAtMTcgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+ CiAKICAgICAgICAgUkVHUkVTU0lPTiAocjI3MDg1MCk6IFJlZmVyZW5jZSBjbGlwIHBhdGggY2xp cHMgaW4gdGhlIHdyb25nIHBsYWNlIHdoZW4gaW5zaWRlIG5vbi12aXNpYmxlIG92ZXJmbG93CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnMg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnMKaW5kZXggMTNm NGVjMGM5YzM1Yjg1MjRhYmQ3ZTg5ZGZkMTUzOGE4MGE5YmNmZS4uNmM1YzJiMjNjZDA5M2MzNjZm YTliMjQ1MzZjZGY3YzE5YjdkYzRhMiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v aW9zLXdrMi9UZXN0RXhwZWN0YXRpb25zCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy13 azIvVGVzdEV4cGVjdGF0aW9ucwpAQCAtMjAzMiw5ICsyMDMyLDYgQEAgd2Via2l0Lm9yZy9iLzIx OTQzOCBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9jYW52YXMtb3ZlcmZsb3ctaGlkZGVuLWFuaW1h dGlvbi5odG0KIAogd2Via2l0Lm9yZy9iLzIzMDQxMyBbIERlYnVnIF0gZmFzdC9jYW52YXMvY2Fu dmFzLWRyYXdJbWFnZS1kZXRhY2hlZC1sZWFrLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQogCi13ZWJr aXQub3JnL2IvMjMxNjgxIFsgUmVsZWFzZSBdIGZhc3QvY2FudmFzL2dyYWRpZW50LXRleHQtd2l0 aC1zaGFkb3cuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCi13ZWJraXQub3JnL2IvMjMxNjgxIFsgUmVs ZWFzZSBdIGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIFsgUGFzcyBGYWlsdXJl IF0KLQogd2ViYW5pbWF0aW9ucy9tdWx0aXBsZS10cmFuc2Zvcm0tcHJvcGVydGllcy1hbmQtbXVs dGlwbGUtdHJhbnNmb3JtLXByb3BlcnRpZXMtYW5pbWF0aW9uLXdpdGgtZGVsYXktb24tZm9yY2Vk LWxheWVyLmh0bWwgWyBQYXNzIF0KIHdlYmFuaW1hdGlvbnMvcm90YXRlLXByb3BlcnR5LWFuZC1y b3RhdGUtYW5pbWF0aW9uLXdpdGgtZGVsYXktb24tZm9yY2VkLWxheWVyLmh0bWwgWyBQYXNzIF0K IHdlYmFuaW1hdGlvbnMvc2NhbGUtcHJvcGVydHktYW5kLXNjYWxlLWFuaW1hdGlvbi13aXRoLWRl bGF5LW9uLWZvcmNlZC1sYXllci5odG1sIFsgUGFzcyBdCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlvbnMgYi9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlvbnMKaW5kZXggODg5NWVjMmYzZGIwN2ZjMDk1NDQ4YTUz MmZmMTExMzVjMTIyYWVjNS4uOWE0ZjkyYTU5YjIxYmU0M2Q2OGRjZGM4MGNjOGExNDA3OGQ4MTFi OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRp b25zCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvVGVzdEV4cGVjdGF0aW9ucwpA QCAtMTUxMyw5ICsxNTEzLDYgQEAgd2Via2l0Lm9yZy9iLzIyNzgwNSBbIERlYnVnIF0gZmFzdC9j YW52YXMvY2FudmFzLWNvbXBvc2l0ZS1pbWFnZS5odG1sIFsgUGFzcyBDcmEKIHdlYmtpdC5vcmcv Yi8yMzAzNjYgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvY2FudmFzLWJsZW5kaW5nLXRleHQuaHRt bCBbIFBhc3MgRmFpbHVyZSBDcmFzaCBdCiB3ZWJraXQub3JnL2IvMjMwMzY2IFsgUmVsZWFzZSBd IGZhc3QvY2FudmFzL2NhbnZhcy1jb21wb3NpdGUtdGV4dC1hbHBoYS5odG1sIFsgUGFzcyBGYWls dXJlIF0KIAotd2Via2l0Lm9yZy9iLzIzMTY4MSBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9ncmFk aWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgWyBQYXNzIEZhaWx1cmUgXQotd2Via2l0Lm9yZy9i LzIzMTY4MSBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9ncmFkaWVudC13aXRoLWNsaXAuaHRtbCBb IFBhc3MgRmFpbHVyZSBdCi0KIHdlYmtpdC5vcmcvYi8yMzA0MTMgZmFzdC9jYW52YXMvY2FudmFz LWRyYXdJbWFnZS1kZXRhY2hlZC1sZWFrLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQogCiB3ZWJraXQu b3JnL2IvMjI2ODI4IFsgQmlnU3VyKyBdIG1lZGlhL21vZGVybi1tZWRpYS1jb250cm9scy9vdmVy Zmxvdy1zdXBwb3J0L2NoYXB0ZXJzLmh0bWwgWyBQYXNzIEZhaWx1cmUgVGltZW91dCBdCg== 441608 2021-10-18 08:53:46 -0700 2021-10-19 12:09:51 -0700 Workaround to keep tests passing bug-231681-20211018085345.patch text/plain 13406 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0MzM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDNkOTg0NzhkYjNjNGM1NjU1 ZWNmOTU2OGQwNzExZjRlYmE4NTdlZDEuLmVlOGY3MWEyNWY2ZmY1MzEzNGFhYTM2MjE3ZjM2MTM5 NTNkZjZjOTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTEgQEAKKzIwMjEtMTAtMTggIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAocjI4 NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIGFuZCBmYXN0L2NhbnZh cy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5IGZhaWx1cmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2ODEKKyAgICAg ICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhlc2UgdGVzdHMgb2NjYXNpb25hbGx5IGZhaWwgd2hlbiB3ZSB0aW1lIG91 dCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgcGl4ZWwgYnVmZmVyIHRvIGJlIHBvcHVsYXRlZCB1bmRl cm5lYXRoCisgICAgICAgIGBSZW1vdGVJbWFnZUJ1ZmZlclByb3h5OjpnZXRQaXhlbEJ1ZmZlcmA7 IHRoaXMgaGFwcGVucyBiZWNhdXNlIHRoZSBHUFUgcHJvY2VzcyBzb21ldGltZXMgaGFsdHMgKGFu ZCBuZXZlcgorICAgICAgICByZXN1bWVzKSB3aGlsZSBwcm9jZXNzaW5nIHN0cmVhbSBtZXNzYWdl cywgYW5kIGNvbnNlcXVlbnRseSBuZXZlciBlbmRzIHVwIHByb2Nlc3NpbmcgdGhlIEdldFBpeGVs QnVmZmVyIElQQworICAgICAgICBzdHJlYW0gbWVzc2FnZSB0aGF0J3MgbmVjZXNzYXJ5IHRvIHBv cHVsYXRlIHRoZSBzaGFyZWQgbWVtb3J5IGJ1ZmZlciBmb3IgR2V0UGl4ZWxCdWZmZXIuCisKKyAg ICAgICAgVGhpcywgaW4gdHVybiwgaGFwcGVucyB3aGVuIHRoZSBJUEMgc3RyZWFtIGJ1ZmZlciBp cyBhYm91dCB0byBleGhhdXN0IGFsbCBhdmFpbGFibGUgY2FwYWNpdHkgKGkuZS4gdGhlIHdyaXRl CisgICAgICAgIGN1cnNvciBpcyBuZWFyaW5nIHRoZSBlbmQgb2YgdGhlIDJNQiBidWZmZXIpLCBh bmQgYXMgYSByZXN1bHQsIHdlIHNlbmQgbWVzc2FnZXMgdGhhdCB3b3VsZCBub3JtYWxseSBiZSBl bmNvZGVkCisgICAgICAgIGluIHRoZSBJUEMgc3RyZWFtIGFzIG91dC1vZi1saW5lIElQQyBtZXNz YWdlcyBpbnN0ZWFkLCB3aGljaCBhcmUgcmVjZWl2ZWQgaW4gdGhlIEdQVSBwcm9jZXNzIG9uIHRo ZSBJUEMgdGhyZWFkCisgICAgICAgIGFuZCBhcHBlbmRlZCB0byB0aGUgcmVjZWl2ZSBxdWV1ZSBj b3JyZXNwb25kaW5nIHRvIHRoZSBkZXN0aW5hdGlvbiBJRCBpbiBgQ29ubmVjdGlvbjo6cHJvY2Vz c0luY29taW5nTWVzc2FnZSgpYC4KKworICAgICAgICBJZiB3ZSBoYXBwZW4gdG8gaGF2ZSBzZW50 IGBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFnZUJ1ZmZlcihhKWAgcmlnaHQgYmVm b3JlIGV4aGF1c3RpbmcgY2FwYWNpdHkgYW5kCisgICAgICAgIHNlbmRpbmcgb3V0LW9mLWxpbmUg bWVzc2FnZXMgdGFyZ2V0aW5nIHRoZSBSZW1vdGVEaXNwbGF5TGlzdFJlY29yZGVyIGNvcnJlc3Bv bmRpbmcgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgaW1hZ2UKKyAgICAgICAgYnVmZmVyIGBhYCwgd2Un bGwgZW5kIHVwIHdpdGggYSByYWNlIGNvbmRpdGlvbiB3aGVyZSB0aGUgSVBDIHRocmVhZCBtYXkg cmVjZWl2ZSB0aGUgb3V0LW9mLWxpbmUgbWVzc2FnZXMgbWVhbnQKKyAgICAgICAgZm9yIHRoZSBu ZXcgcmVtb3RlIGRpc3BsYXkgbGlzdCBkZXN0aW5hdGlvbiAqYmVmb3JlKiB0aGUgbmV3IHJlbW90 ZSBkaXNwbGF5IGxpc3QgaGFzIGFkZGVkIGl0c2VsZiBhcyBhbiBJUEMKKyAgICAgICAgcmVjZWl2 ZSBxdWV1ZSBieSBjYWxsaW5nIGludG8gYFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OnN0YXJ0UmVj ZWl2aW5nTWVzc2FnZXMoKWAuCisKKyAgICAgICAgSW4gdGhpcyBwYXJ0aWN1bGFyIHNjZW5hcmlv ICh3aGVyZSB3ZSAibG9zZSIgdGhlIHJhY2UpLCBgQ29ubmVjdGlvbjo6cHJvY2Vzc0luY29taW5n TWVzc2FnZWAgd2lsbCBza2lwIHBhc3QgdGhlCisgICAgICAgIGVhcmx5IHJldHVybiB3aGVyZSBp dCB3b3VsZCBub3JtYWxseSBmaW5kIGl0cyBjb3JyZXNwb25kaW5nIHJlY2VpdmUgcXVldWUgdmlh IGBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKWAsCisgICAgICAgIGFuZCBpbnN0ZWFkIGZh bGxzIHRocm91Z2ggdG8gYENvbm5lY3Rpb246OlN5bmNNZXNzYWdlU3RhdGU6OnByb2Nlc3NJbmNv bWluZ01lc3NhZ2UoKWAsIHdoaWNoIHdpbGwgYXR0ZW1wdCB0bworICAgICAgICBkaXNwYXRjaCB0 aGUgaW5jb21pbmcgbWVzc2FnZSB0byB0aGUgQ29ubmVjdGlvbidzIGNsaWVudCAoR1BVQ29ubmVj dGlvblRvV2ViUHJvY2VzcykuIE9mIGNvdXJzZSwgdGhlCisgICAgICAgIEdQVUNvbm5lY3Rpb25U b1dlYlByb2Nlc3MgaXNuJ3QgYXdhcmUgb2YgaG93IHRvIHByb2Nlc3MgdGhpcyBpbmNvbWluZyBt ZXNzYWdlLCBzbyBpdCBzaW1wbHkgZ2V0cyBkcm9wcGVkLiBCeSB0aGUKKyAgICAgICAgdGltZSB0 aGUgcmVjZWl2ZSBxdWV1ZSBpcyBhZGRlZCBmb3IgdGhlIG5ldyBSZW1vdGVEaXNwbGF5TGlzdFJl Y29yZGVyLCB3ZSdsbCBvYnNlcnZlIGEgUHJvY2Vzc091dE9mU3RyZWFtTWVzc2FnZQorICAgICAg ICBhbmQgZW5kIHVwIHdhaXRpbmcgZm9yZXZlciBmb3IgdGhpcyBvdXQtb2YtbGluZSBtZXNzYWdl IHRvIGJlIGFkZGVkIHRvIHRoZSByZWNlaXZlIHF1ZXVlLCBidXQgdGhpcyBuZXZlciBlbmRzIHVw CisgICAgICAgIGhhcHBlbmluZyBiZWNhdXNlIGl0IGhhcyBhbHJlYWR5IGJlZW4gcmVjZWl2ZWQg YW5kIGRyb3BwZWQgYnkgR1BVQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy4KKworICAgICAgICBUbyBh ZGRyZXNzIHRoZSBmbGFreSB0ZXN0cyBpbiB0aGUgc2hvcnQgdGVybSwgd2Ugd29yayBhcm91bmQg dGhpcyBpc3N1ZSBieSBtYWtpbmcgYENyZWF0ZUltYWdlQnVmZmVyYCBhIHN5bmMKKyAgICAgICAg bWVzc2FnZSwgc28gd2UgZ3VhcmFudGVlIHRoYXQgYW55IHN1YnNlcXVlbnQgbWVzc2FnZXMgc2Vu dCB0byB0aGUgaW1hZ2UgYnVmZmVyJ3MgUmVtb3RlRGlzcGxheUxpc3RSZWNvcmRlciB3aWxsCisg ICAgICAgIG5vdCBiZSBkcm9wcGVkLiBJbiB0aGUgKHNsaWdodGx5KSBsb25nZXIgdGVybSwgd2Ug c2hvdWxkIHR1cm4gdGhpcyBiYWNrIGludG8gYW4gYXN5bmMgc3RyZWFtIG1lc3NhZ2UsIGFuZCBh ZGQgYQorICAgICAgICBtZWNoYW5pc20gdG8gcmVkaXJlY3QgYWxsIHJlY2VpdmVyLWxlc3MgUmVt b3RlRGlzcGxheUxpc3RSZWNvcmRlciBtZXNzYWdlcyB0byBhIHNlcGFyYXRlIHF1ZXVlLgorCisg ICAgICAgICogR1BVUHJvY2Vzcy9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kLmNwcDoK KyAgICAgICAgKFdlYktpdDo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZDo6Y3JlYXRlSW1hZ2VCdWZm ZXIpOgorICAgICAgICAqIEdQVVByb2Nlc3MvZ3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5nQmFja2Vu ZC5oOgorICAgICAgICAqIEdQVVByb2Nlc3MvZ3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5nQmFja2Vu ZC5tZXNzYWdlcy5pbjoKKworICAgICAgICBNYWtlIGBDcmVhdGVJbWFnZUJ1ZmZlcmAgYSBzeW5j aHJvbm91cyBzdHJlYW0gbWVzc2FnZSBmb3Igbm93LgorCisgICAgICAgICogV2ViUHJvY2Vzcy9H UFUvZ3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5LmNwcDoKKyAgICAgICAgKFdl YktpdDo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5OjpjcmVhdGVSZW1vdGVJbWFnZUJ1ZmZl cik6CisKIDIwMjEtMTAtMTcgIEJKIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAg W0NvY29hXSBXZWIgSW5zcGVjdG9yOiByZW1vdmUgX1dLSW5zcGVjdG9yRXh0ZW5zaW9uUHJpdmF0 ZUZvclRlc3RpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvR1BVUHJvY2Vzcy9ncmFwaGlj cy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kLmNwcCBiL1NvdXJjZS9XZWJLaXQvR1BVUHJvY2Vzcy9n cmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kLmNwcAppbmRleCA3ZDkxZjM4MzM5NWE1MGVj ZGM2ODE2MjFiMTI3MWZiM2Q5OGVhM2UxLi4yNzg1NGM3OTMzNWZhYTIyYjZjYWRhYzhmYzBkOTli YzM0MjJhNzg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0dQVVByb2Nlc3MvZ3JhcGhpY3Mv UmVtb3RlUmVuZGVyaW5nQmFja2VuZC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9HUFVQcm9jZXNz L2dyYXBoaWNzL1JlbW90ZVJlbmRlcmluZ0JhY2tlbmQuY3BwCkBAIC0xMzgsMTEgKzEzOCwxMiBA QCB2b2lkIFJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OmRpZEZsdXNoKEdyYXBoaWNzQ29udGV4dEZs dXNoSWRlbnRpZmllciBmbHVzaElkZW50aQogICAgIHNlbmQoTWVzc2FnZXM6OlJlbW90ZVJlbmRl cmluZ0JhY2tlbmRQcm94eTo6RGlkRmx1c2goZmx1c2hJZGVudGlmaWVyLCByZW5kZXJpbmdSZXNv dXJjZUlkZW50aWZpZXIub2JqZWN0KCkpLCBtX3JlbmRlcmluZ0JhY2tlbmRJZGVudGlmaWVyKTsK IH0KIAotdm9pZCBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpjcmVhdGVJbWFnZUJ1ZmZlcihjb25z dCBGbG9hdFNpemUmIGxvZ2ljYWxTaXplLCBSZW5kZXJpbmdNb2RlIHJlbmRlcmluZ01vZGUsIGZs b2F0IHJlc29sdXRpb25TY2FsZSwgY29uc3QgRGVzdGluYXRpb25Db2xvclNwYWNlJiBjb2xvclNw YWNlLCBQaXhlbEZvcm1hdCBwaXhlbEZvcm1hdCwgUmVuZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVy IGltYWdlQnVmZmVyUmVzb3VyY2VJZGVudGlmaWVyKQordm9pZCBSZW1vdGVSZW5kZXJpbmdCYWNr ZW5kOjpjcmVhdGVJbWFnZUJ1ZmZlcihjb25zdCBGbG9hdFNpemUmIGxvZ2ljYWxTaXplLCBSZW5k ZXJpbmdNb2RlIHJlbmRlcmluZ01vZGUsIGZsb2F0IHJlc29sdXRpb25TY2FsZSwgY29uc3QgRGVz dGluYXRpb25Db2xvclNwYWNlJiBjb2xvclNwYWNlLCBQaXhlbEZvcm1hdCBwaXhlbEZvcm1hdCwg UmVuZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyIGltYWdlQnVmZmVyUmVzb3VyY2VJZGVudGlmaWVy LCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCiB7CiAgICAg Ly8gSW1tZWRpYXRlbHkgdHVybiB0aGUgUmVuZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyICh3aGlj aCBpcyBlcnJvci1wcm9uZSkgdG8gYSBRdWFsaWZpZWRSZW5kZXJpbmdSZXNvdXJjZUlkZW50aWZp ZXIsCiAgICAgLy8gYW5kIHVzZSBhIGhlbHBlciBmdW5jdGlvbiB0byBtYWtlIHN1cmUgdGhhdCBk b24ndCBhY2NpZGVudGFsbHkgdXNlIHRoZSBSZW5kZXJpbmdSZXNvdXJjZUlkZW50aWZpZXIgKGJl Y2F1c2UgdGhlIGhlbHBlciBmdW5jdGlvbiBjYW4ndCBzZWUgaXQpLgogICAgIGNyZWF0ZUltYWdl QnVmZmVyV2l0aFF1YWxpZmllZElkZW50aWZpZXIobG9naWNhbFNpemUsIHJlbmRlcmluZ01vZGUs IHJlc29sdXRpb25TY2FsZSwgY29sb3JTcGFjZSwgcGl4ZWxGb3JtYXQsIHsgaW1hZ2VCdWZmZXJS ZXNvdXJjZUlkZW50aWZpZXIsIG1fZ3B1Q29ubmVjdGlvblRvV2ViUHJvY2Vzcy0+d2ViUHJvY2Vz c0lkZW50aWZpZXIoKSB9KTsKKyAgICBjb21wbGV0aW9uSGFuZGxlcigpOwogfQogCiB2b2lkIFJl bW90ZVJlbmRlcmluZ0JhY2tlbmQ6OmNyZWF0ZUltYWdlQnVmZmVyV2l0aFF1YWxpZmllZElkZW50 aWZpZXIoY29uc3QgRmxvYXRTaXplJiBsb2dpY2FsU2l6ZSwgUmVuZGVyaW5nTW9kZSByZW5kZXJp bmdNb2RlLCBmbG9hdCByZXNvbHV0aW9uU2NhbGUsIGNvbnN0IERlc3RpbmF0aW9uQ29sb3JTcGFj ZSYgY29sb3JTcGFjZSwgUGl4ZWxGb3JtYXQgcGl4ZWxGb3JtYXQsIFF1YWxpZmllZFJlbmRlcmlu Z1Jlc291cmNlSWRlbnRpZmllciBpbWFnZUJ1ZmZlclJlc291cmNlSWRlbnRpZmllcikKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvR1BVUHJvY2Vzcy9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdC YWNrZW5kLmggYi9Tb3VyY2UvV2ViS2l0L0dQVVByb2Nlc3MvZ3JhcGhpY3MvUmVtb3RlUmVuZGVy aW5nQmFja2VuZC5oCmluZGV4IDFkMDI3Zjg4MDYxZjE0OGEzM2RhMjk0YjcyMWUwNzBkMDFlNzdk MWQuLmU0NmJlYjk2YWU4MzlkMjUxNWFlZmQyMWNkN2EwNDQ5NWRkNWY5YTAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvR1BVUHJvY2Vzcy9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5k LmgKKysrIGIvU291cmNlL1dlYktpdC9HUFVQcm9jZXNzL2dyYXBoaWNzL1JlbW90ZVJlbmRlcmlu Z0JhY2tlbmQuaApAQCAtMTAxLDcgKzEwMSw3IEBAIHByaXZhdGU6CiAgICAgdWludDY0X3QgbWVz c2FnZVNlbmRlckRlc3RpbmF0aW9uSUQoKSBjb25zdCBvdmVycmlkZTsKIAogICAgIC8vIE1lc3Nh Z2VzIHRvIGJlIHJlY2VpdmVkLgotICAgIHZvaWQgY3JlYXRlSW1hZ2VCdWZmZXIoY29uc3QgV2Vi Q29yZTo6RmxvYXRTaXplJiBsb2dpY2FsU2l6ZSwgV2ViQ29yZTo6UmVuZGVyaW5nTW9kZSwgZmxv YXQgcmVzb2x1dGlvblNjYWxlLCBjb25zdCBXZWJDb3JlOjpEZXN0aW5hdGlvbkNvbG9yU3BhY2Um LCBXZWJDb3JlOjpQaXhlbEZvcm1hdCwgV2ViQ29yZTo6UmVuZGVyaW5nUmVzb3VyY2VJZGVudGlm aWVyKTsKKyAgICB2b2lkIGNyZWF0ZUltYWdlQnVmZmVyKGNvbnN0IFdlYkNvcmU6OkZsb2F0U2l6 ZSYgbG9naWNhbFNpemUsIFdlYkNvcmU6OlJlbmRlcmluZ01vZGUsIGZsb2F0IHJlc29sdXRpb25T Y2FsZSwgY29uc3QgV2ViQ29yZTo6RGVzdGluYXRpb25Db2xvclNwYWNlJiwgV2ViQ29yZTo6UGl4 ZWxGb3JtYXQsIFdlYkNvcmU6OlJlbmRlcmluZ1Jlc291cmNlSWRlbnRpZmllciwgQ29tcGxldGlv bkhhbmRsZXI8dm9pZCgpPiYmKTsKICAgICB2b2lkIHVwZGF0ZVNoYXJlZE1lbW9yeUZvckdldFBp eGVsQnVmZmVyKHVpbnQzMl90IGJ5dGVDb3VudCwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChjb25z dCBTaGFyZWRNZW1vcnk6OklQQ0hhbmRsZSYpPiYmKTsKICAgICB2b2lkIHNlbWFwaG9yZUZvckdl dFBpeGVsQnVmZmVyKENvbXBsZXRpb25IYW5kbGVyPHZvaWQoY29uc3QgSVBDOjpTZW1hcGhvcmUm KT4mJik7CiAgICAgdm9pZCB1cGRhdGVTaGFyZWRNZW1vcnlBbmRTZW1hcGhvcmVGb3JHZXRQaXhl bEJ1ZmZlcih1aW50MzJfdCBieXRlQ291bnQsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoY29uc3Qg U2hhcmVkTWVtb3J5OjpJUENIYW5kbGUmLCBjb25zdCBJUEM6OlNlbWFwaG9yZSYpPiYmKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvR1BVUHJvY2Vzcy9ncmFwaGljcy9SZW1vdGVSZW5kZXJp bmdCYWNrZW5kLm1lc3NhZ2VzLmluIGIvU291cmNlL1dlYktpdC9HUFVQcm9jZXNzL2dyYXBoaWNz L1JlbW90ZVJlbmRlcmluZ0JhY2tlbmQubWVzc2FnZXMuaW4KaW5kZXggYTE0MmY0ODk2NmY1YzQ5 NzU5NDU2NTQ3NzJjNzljMzE5NzZmNTNkYy4uOTQ5ODg2MzA4YTM1NDY1ZGNlNWZmYWNiY2M3YmMx YzZjNDU3YjQwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9HUFVQcm9jZXNzL2dyYXBoaWNz L1JlbW90ZVJlbmRlcmluZ0JhY2tlbmQubWVzc2FnZXMuaW4KKysrIGIvU291cmNlL1dlYktpdC9H UFVQcm9jZXNzL2dyYXBoaWNzL1JlbW90ZVJlbmRlcmluZ0JhY2tlbmQubWVzc2FnZXMuaW4KQEAg LTIzLDcgKzIzLDcgQEAKICNpZiBFTkFCTEUoR1BVX1BST0NFU1MpCiAKIG1lc3NhZ2VzIC0+IFJl bW90ZVJlbmRlcmluZ0JhY2tlbmQgTm90UmVmQ291bnRlZCBTdHJlYW0gewotICAgIENyZWF0ZUlt YWdlQnVmZmVyKFdlYkNvcmU6OkZsb2F0U2l6ZSBsb2dpY2FsU2l6ZSwgV2ViQ29yZTo6UmVuZGVy aW5nTW9kZSByZW5kZXJpbmdNb2RlLCBmbG9hdCByZXNvbHV0aW9uU2NhbGUsIFdlYkNvcmU6OkRl c3RpbmF0aW9uQ29sb3JTcGFjZSBjb2xvclNwYWNlLCBlbnVtOnVpbnQ4X3QgV2ViQ29yZTo6UGl4 ZWxGb3JtYXQgcGl4ZWxGb3JtYXQsIFdlYkNvcmU6OlJlbmRlcmluZ1Jlc291cmNlSWRlbnRpZmll ciByZW5kZXJpbmdSZXNvdXJjZUlkZW50aWZpZXIpCisgICAgQ3JlYXRlSW1hZ2VCdWZmZXIoV2Vi Q29yZTo6RmxvYXRTaXplIGxvZ2ljYWxTaXplLCBXZWJDb3JlOjpSZW5kZXJpbmdNb2RlIHJlbmRl cmluZ01vZGUsIGZsb2F0IHJlc29sdXRpb25TY2FsZSwgV2ViQ29yZTo6RGVzdGluYXRpb25Db2xv clNwYWNlIGNvbG9yU3BhY2UsIGVudW06dWludDhfdCBXZWJDb3JlOjpQaXhlbEZvcm1hdCBwaXhl bEZvcm1hdCwgV2ViQ29yZTo6UmVuZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyIHJlbmRlcmluZ1Jl c291cmNlSWRlbnRpZmllcikgLT4gKCkgU3luY2hyb25vdXMKICAgICBVcGRhdGVTaGFyZWRNZW1v cnlGb3JHZXRQaXhlbEJ1ZmZlcih1aW50MzJfdCBieXRlQ291bnQpIC0+IChXZWJLaXQ6OlNoYXJl ZE1lbW9yeTo6SVBDSGFuZGxlIGhhbmRsZSkgU3luY2hyb25vdXMgTm90U3RyZWFtRW5jb2RhYmxl UmVwbHkKICAgICBTZW1hcGhvcmVGb3JHZXRQaXhlbEJ1ZmZlcigpIC0+IChJUEM6OlNlbWFwaG9y ZSBzZW1hcGhvcmUpIFN5bmNocm9ub3VzIE5vdFN0cmVhbUVuY29kYWJsZVJlcGx5CiAgICAgVXBk YXRlU2hhcmVkTWVtb3J5QW5kU2VtYXBob3JlRm9yR2V0UGl4ZWxCdWZmZXIodWludDMyX3QgYnl0 ZUNvdW50KSAtPiAoV2ViS2l0OjpTaGFyZWRNZW1vcnk6OklQQ0hhbmRsZSBoYW5kbGUsIElQQzo6 U2VtYXBob3JlIHNlbWFwaG9yZSkgU3luY2hyb25vdXMgTm90U3RyZWFtRW5jb2RhYmxlUmVwbHkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3Rl UmVuZGVyaW5nQmFja2VuZFByb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUv Z3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5LmNwcAppbmRleCAyOGJiMjQ0ODE2 ODE5M2VlZTdkY2FjZWIzODFhOGYzZGUwOGRhMWFmLi40MTM1MTcyZmFiZmMxNjExZGQ1NjNkYjA5 MjY5MmZkZWEyMDc2ODIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvR1BV L2dyYXBoaWNzL1JlbW90ZVJlbmRlcmluZ0JhY2tlbmRQcm94eS5jcHAKKysrIGIvU291cmNlL1dl YktpdC9XZWJQcm9jZXNzL0dQVS9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHku Y3BwCkBAIC0xMjcsNyArMTI3LDkgQEAgYm9vbCBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6 OndhaXRGb3JEaWRGbHVzaCgpCiAKIHZvaWQgUmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5Ojpj cmVhdGVSZW1vdGVJbWFnZUJ1ZmZlcihJbWFnZUJ1ZmZlciYgaW1hZ2VCdWZmZXIpCiB7Ci0gICAg c2VuZFRvU3RyZWFtKE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFn ZUJ1ZmZlcihpbWFnZUJ1ZmZlci5sb2dpY2FsU2l6ZSgpLCBpbWFnZUJ1ZmZlci5yZW5kZXJpbmdN b2RlKCksIGltYWdlQnVmZmVyLnJlc29sdXRpb25TY2FsZSgpLCBpbWFnZUJ1ZmZlci5jb2xvclNw YWNlKCksIGltYWdlQnVmZmVyLnBpeGVsRm9ybWF0KCksIGltYWdlQnVmZmVyLnJlbmRlcmluZ1Jl c291cmNlSWRlbnRpZmllcigpKSk7CisgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIGJlIGFuIG5v cm1hbCAoYXN5bmMpIHN0cmVhbSBtZXNzYWdlLiBIb3dldmVyLCBkb2luZyBzbyBtYXkgY2F1c2Ug c3Vic2VxdWVudCBvdXQtb2Ytc3RyZWFtIG1lc3NhZ2VzIHNlbnQgdG8gdGhlIG5ld2x5IGNyZWF0 ZWQgaW1hZ2UKKyAgICAvLyBidWZmZXIgdG8gYmUgZHJvcHBlZCBieSB0aGUgSVBDIGNvbm5lY3Rp b24uIEZvciB0aGUgdGltZSBiZWluZywgd29yayBhcm91bmQgdGhpcyBieSB1c2luZyBzeW5jIElQ QyAoc2VlIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMzE2ODE+IGZvciBtb3JlIGRldGFpbHMpLgor ICAgIHNlbmRTeW5jVG9TdHJlYW0oTWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OkNy ZWF0ZUltYWdlQnVmZmVyKGltYWdlQnVmZmVyLmxvZ2ljYWxTaXplKCksIGltYWdlQnVmZmVyLnJl bmRlcmluZ01vZGUoKSwgaW1hZ2VCdWZmZXIucmVzb2x1dGlvblNjYWxlKCksIGltYWdlQnVmZmVy LmNvbG9yU3BhY2UoKSwgaW1hZ2VCdWZmZXIucGl4ZWxGb3JtYXQoKSwgaW1hZ2VCdWZmZXIucmVu ZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyKCkpLCBNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFj a2VuZDo6Q3JlYXRlSW1hZ2VCdWZmZXI6OlJlcGx5KCksIDNfcyk7CiB9CiAKIFJlZlB0cjxJbWFn ZUJ1ZmZlcj4gUmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5OjpjcmVhdGVJbWFnZUJ1ZmZlcihj b25zdCBGbG9hdFNpemUmIHNpemUsIFJlbmRlcmluZ01vZGUgcmVuZGVyaW5nTW9kZSwgZmxvYXQg cmVzb2x1dGlvblNjYWxlLCBjb25zdCBEZXN0aW5hdGlvbkNvbG9yU3BhY2UmIGNvbG9yU3BhY2Us IFBpeGVsRm9ybWF0IHBpeGVsRm9ybWF0KQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDU5YTk4YTY5MDZjNWMwNWNkMDcwYTlj OWMzOWQ4YjdjZTVhMzdjOGIuLjdjOGZlMGI0NTJhYTViYThmNzljY2ZhNGY3YTMyOTY4Zjk4YjNm YjggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAyMS0xMC0xOCAgV2Vuc29uIEhzaWVoICA8d2Vu c29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OIChyMjg0MDc5KTogZmFz dC9jYW52YXMvZ3JhZGllbnQtd2l0aC1jbGlwLmh0bWwgYW5kIGZhc3QvY2FudmFzL2dyYWRpZW50 LXRleHQtd2l0aC1zaGFkb3cuaHRtbCBhcmUgZmxha3kgZmFpbHVyZXMKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMTY4MQorICAgICAgICByZGFyOi8v ODQyMDI0NzgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBSZW1vdmUgdGhlIGZsYWt5IGZhaWx1cmUgZW50cmllcyBpbiB0ZXN0IGV4cGVjdGF0aW9ucy4g U2VlIFdlYktpdDIgQ2hhbmdlTG9nIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICAgICAgKiBwbGF0 Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnM6CisgICAgICAgICogcGxhdGZvcm0vbWFjLXdr Mi9UZXN0RXhwZWN0YXRpb25zOgorCiAyMDIxLTEwLTE3ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5m cmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04gKHIyNzA4NTApOiBSZWZlcmVu Y2UgY2xpcCBwYXRoIGNsaXBzIGluIHRoZSB3cm9uZyBwbGFjZSB3aGVuIGluc2lkZSBub24tdmlz aWJsZSBvdmVyZmxvdwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zLXdrMi9U ZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0 YXRpb25zCmluZGV4IDEzZjRlYzBjOWMzNWI4NTI0YWJkN2U4OWRmZDE1MzhhODBhOWJjZmUuLjZj NWMyYjIzY2QwOTNjMzY2ZmE5YjI0NTM2Y2RmN2MxOWI3ZGM0YTIgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2lvcy13azIvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTIwMzIsOSArMjAzMiw2IEBA IHdlYmtpdC5vcmcvYi8yMTk0MzggWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvY2FudmFzLW92ZXJm bG93LWhpZGRlbi1hbmltYXRpb24uaHRtCiAKIHdlYmtpdC5vcmcvYi8yMzA0MTMgWyBEZWJ1ZyBd IGZhc3QvY2FudmFzL2NhbnZhcy1kcmF3SW1hZ2UtZGV0YWNoZWQtbGVhay5odG1sIFsgUGFzcyBG YWlsdXJlIF0KIAotd2Via2l0Lm9yZy9iLzIzMTY4MSBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9n cmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgWyBQYXNzIEZhaWx1cmUgXQotd2Via2l0Lm9y Zy9iLzIzMTY4MSBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9ncmFkaWVudC13aXRoLWNsaXAuaHRt bCBbIFBhc3MgRmFpbHVyZSBdCi0KIHdlYmFuaW1hdGlvbnMvbXVsdGlwbGUtdHJhbnNmb3JtLXBy b3BlcnRpZXMtYW5kLW11bHRpcGxlLXRyYW5zZm9ybS1wcm9wZXJ0aWVzLWFuaW1hdGlvbi13aXRo LWRlbGF5LW9uLWZvcmNlZC1sYXllci5odG1sIFsgUGFzcyBdCiB3ZWJhbmltYXRpb25zL3JvdGF0 ZS1wcm9wZXJ0eS1hbmQtcm90YXRlLWFuaW1hdGlvbi13aXRoLWRlbGF5LW9uLWZvcmNlZC1sYXll ci5odG1sIFsgUGFzcyBdCiB3ZWJhbmltYXRpb25zL3NjYWxlLXByb3BlcnR5LWFuZC1zY2FsZS1h bmltYXRpb24td2l0aC1kZWxheS1vbi1mb3JjZWQtbGF5ZXIuaHRtbCBbIFBhc3MgXQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRpb25zIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRpb25zCmluZGV4IDg4OTVlYzJm M2RiMDdmYzA5NTQ0OGE1MzJmZjExMTM1YzEyMmFlYzUuLjlhNGY5MmE1OWIyMWJlNDNkNjhkY2Rj ODBjYzhhMTQwNzhkODExYjkgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy13 azIvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtd2syL1Rl c3RFeHBlY3RhdGlvbnMKQEAgLTE1MTMsOSArMTUxMyw2IEBAIHdlYmtpdC5vcmcvYi8yMjc4MDUg WyBEZWJ1ZyBdIGZhc3QvY2FudmFzL2NhbnZhcy1jb21wb3NpdGUtaW1hZ2UuaHRtbCBbIFBhc3Mg Q3JhCiB3ZWJraXQub3JnL2IvMjMwMzY2IFsgUmVsZWFzZSBdIGZhc3QvY2FudmFzL2NhbnZhcy1i bGVuZGluZy10ZXh0Lmh0bWwgWyBQYXNzIEZhaWx1cmUgQ3Jhc2ggXQogd2Via2l0Lm9yZy9iLzIz MDM2NiBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9jYW52YXMtY29tcG9zaXRlLXRleHQtYWxwaGEu aHRtbCBbIFBhc3MgRmFpbHVyZSBdCiAKLXdlYmtpdC5vcmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0g ZmFzdC9jYW52YXMvZ3JhZGllbnQtdGV4dC13aXRoLXNoYWRvdy5odG1sIFsgUGFzcyBGYWlsdXJl IF0KLXdlYmtpdC5vcmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvZ3JhZGllbnQt d2l0aC1jbGlwLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQotCiB3ZWJraXQub3JnL2IvMjMwNDEzIGZh c3QvY2FudmFzL2NhbnZhcy1kcmF3SW1hZ2UtZGV0YWNoZWQtbGVhay5odG1sIFsgUGFzcyBGYWls dXJlIF0KIAogd2Via2l0Lm9yZy9iLzIyNjgyOCBbIEJpZ1N1cisgXSBtZWRpYS9tb2Rlcm4tbWVk aWEtY29udHJvbHMvb3ZlcmZsb3ctc3VwcG9ydC9jaGFwdGVycy5odG1sIFsgUGFzcyBGYWlsdXJl IFRpbWVvdXQgXQo= 441754 2021-10-19 10:38:32 -0700 2021-10-19 10:45:29 -0700 Async approach, v2 bug-231681-20211019103832.patch text/plain 15402 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0NDU2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDIyMDk4OGRjYjZjNmYzMDBl YTI5YTk2YjU1MjkxNzA0NDI5YzkwOWUuLmQ2ZWVkMWRlNjY3NTMwNDE1OGU1M2UzZTliZWZjNGU5 NGQ4YjU5MmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjMgQEAKKzIwMjEtMTAtMTkgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAocjI4 NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIGFuZCBmYXN0L2NhbnZh cy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5IGZhaWx1cmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2ODEKKyAgICAg ICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhlc2UgdGVzdHMgb2NjYXNpb25hbGx5IGZhaWwgd2hlbiB3ZSB0aW1lIG91 dCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgcGl4ZWwgYnVmZmVyIHRvIGJlIHBvcHVsYXRlZCB1bmRl cm5lYXRoCisgICAgICAgIGBSZW1vdGVJbWFnZUJ1ZmZlclByb3h5OjpnZXRQaXhlbEJ1ZmZlcmA7 IHRoaXMgaGFwcGVucyBiZWNhdXNlIHRoZSBHUFUgcHJvY2VzcyBzb21ldGltZXMgaGFsdHMgKGFu ZCBuZXZlcgorICAgICAgICByZXN1bWVzKSB3aGlsZSBwcm9jZXNzaW5nIHN0cmVhbSBtZXNzYWdl cywgYW5kIGNvbnNlcXVlbnRseSBuZXZlciBlbmRzIHVwIHByb2Nlc3NpbmcgdGhlIEdldFBpeGVs QnVmZmVyIElQQworICAgICAgICBzdHJlYW0gbWVzc2FnZSB0aGF0J3MgbmVjZXNzYXJ5IHRvIHBv cHVsYXRlIHRoZSBzaGFyZWQgbWVtb3J5IGJ1ZmZlciBmb3IgR2V0UGl4ZWxCdWZmZXIuCisKKyAg ICAgICAgVGhpcywgaW4gdHVybiwgaGFwcGVucyB3aGVuIHRoZSBJUEMgc3RyZWFtIGJ1ZmZlciBp cyBhYm91dCB0byBleGhhdXN0IGFsbCBhdmFpbGFibGUgY2FwYWNpdHkgKGkuZS4gdGhlIHdyaXRl CisgICAgICAgIGN1cnNvciBpcyBuZWFyaW5nIHRoZSBlbmQgb2YgdGhlIDJNQiBidWZmZXIpLCBh bmQgYXMgYSByZXN1bHQsIHdlIHNlbmQgbWVzc2FnZXMgdGhhdCB3b3VsZCBub3JtYWxseSBiZSBl bmNvZGVkCisgICAgICAgIGluIHRoZSBJUEMgc3RyZWFtIGFzIG91dC1vZi1saW5lIElQQyBtZXNz YWdlcyBpbnN0ZWFkLCB3aGljaCBhcmUgcmVjZWl2ZWQgaW4gdGhlIEdQVSBwcm9jZXNzIG9uIHRo ZSBJUEMgdGhyZWFkCisgICAgICAgIGFuZCBhcHBlbmRlZCB0byB0aGUgcmVjZWl2ZSBxdWV1ZSBj b3JyZXNwb25kaW5nIHRvIHRoZSBkZXN0aW5hdGlvbiBJRCBpbiBgQ29ubmVjdGlvbjo6cHJvY2Vz c0luY29taW5nTWVzc2FnZSgpYC4KKworICAgICAgICBJZiB3ZSBoYXBwZW4gdG8gaGF2ZSBzZW50 IGBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFnZUJ1ZmZlcihhKWAgcmlnaHQgYmVm b3JlIGV4aGF1c3RpbmcgY2FwYWNpdHkgYW5kCisgICAgICAgIHNlbmRpbmcgb3V0LW9mLWxpbmUg bWVzc2FnZXMgdGFyZ2V0aW5nIHRoZSBSZW1vdGVEaXNwbGF5TGlzdFJlY29yZGVyIGNvcnJlc3Bv bmRpbmcgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgaW1hZ2UKKyAgICAgICAgYnVmZmVyIGBhYCwgd2Un bGwgZW5kIHVwIHdpdGggYSByYWNlIGNvbmRpdGlvbiB3aGVyZSB0aGUgSVBDIHRocmVhZCBtYXkg cmVjZWl2ZSB0aGUgb3V0LW9mLWxpbmUgbWVzc2FnZXMgbWVhbnQKKyAgICAgICAgZm9yIHRoZSBu ZXcgcmVtb3RlIGRpc3BsYXkgbGlzdCBkZXN0aW5hdGlvbiAqYmVmb3JlKiB0aGUgbmV3IHJlbW90 ZSBkaXNwbGF5IGxpc3QgaGFzIGFkZGVkIGl0c2VsZiBhcyBhbiBJUEMKKyAgICAgICAgcmVjZWl2 ZSBxdWV1ZSBieSBjYWxsaW5nIGludG8gYFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OnN0YXJ0UmVj ZWl2aW5nTWVzc2FnZXMoKWAuCisKKyAgICAgICAgSW4gdGhpcyBwYXJ0aWN1bGFyIHNjZW5hcmlv ICh3aGVyZSB3ZSAibG9zZSIgdGhlIHJhY2UpLCBgQ29ubmVjdGlvbjo6cHJvY2Vzc0luY29taW5n TWVzc2FnZWAgd2lsbCBza2lwIHBhc3QgdGhlCisgICAgICAgIGVhcmx5IHJldHVybiB3aGVyZSBp dCB3b3VsZCBub3JtYWxseSBmaW5kIGl0cyBjb3JyZXNwb25kaW5nIHJlY2VpdmUgcXVldWUgdmlh IGBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKWAsCisgICAgICAgIGFuZCBpbnN0ZWFkIGZh bGxzIHRocm91Z2ggdG8gYENvbm5lY3Rpb246OlN5bmNNZXNzYWdlU3RhdGU6OnByb2Nlc3NJbmNv bWluZ01lc3NhZ2UoKWAsIHdoaWNoIHdpbGwgYXR0ZW1wdCB0bworICAgICAgICBkaXNwYXRjaCB0 aGUgaW5jb21pbmcgbWVzc2FnZSB0byB0aGUgQ29ubmVjdGlvbidzIGNsaWVudCAoR1BVQ29ubmVj dGlvblRvV2ViUHJvY2VzcykuIE9mIGNvdXJzZSwgdGhlCisgICAgICAgIEdQVUNvbm5lY3Rpb25U b1dlYlByb2Nlc3MgaXNuJ3QgYXdhcmUgb2YgaG93IHRvIHByb2Nlc3MgdGhpcyBpbmNvbWluZyBt ZXNzYWdlLCBzbyBpdCBzaW1wbHkgZ2V0cyBkcm9wcGVkLiBCeSB0aGUKKyAgICAgICAgdGltZSB0 aGUgcmVjZWl2ZSBxdWV1ZSBpcyBhZGRlZCBmb3IgdGhlIG5ldyBSZW1vdGVEaXNwbGF5TGlzdFJl Y29yZGVyLCB3ZSdsbCBvYnNlcnZlIGEgUHJvY2Vzc091dE9mU3RyZWFtTWVzc2FnZQorICAgICAg ICBhbmQgZW5kIHVwIHdhaXRpbmcgZm9yZXZlciBmb3IgdGhpcyBvdXQtb2YtbGluZSBtZXNzYWdl IHRvIGJlIGFkZGVkIHRvIHRoZSByZWNlaXZlIHF1ZXVlLCBidXQgdGhpcyBuZXZlciBlbmRzIHVw CisgICAgICAgIGhhcHBlbmluZyBiZWNhdXNlIGl0IGhhcyBhbHJlYWR5IGJlZW4gcmVjZWl2ZWQg YW5kIGRyb3BwZWQgYnkgR1BVQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy4KKworICAgICAgICBUbyBw cmV2ZW50IHRoaXMgcmFjZSBmcm9tIGhhcHBlbmluZywgd2UgY2FuIGVucXVldWUgYSBzdHJlYW0g bWVzc2FnZSB0aGF0IGRvZXMgbm90IHlldCBoYXZlIGEgY29ycmVzcG9uZGluZworICAgICAgICBy ZWNlaXZlciBvbiBgbV9pbmNvbWluZ1JlY2VpdmVRdWV1ZU1lc3NhZ2VzYCBpbnN0ZWFkIG9mIHNr aXBwaW5nIHRoZSBlYXJseSByZXR1cm4uIFRoaXMgYWxsb3dzIHVzIHRvIGVucXVldWUgdGhlCisg ICAgICAgIGluY29taW5nIG1lc3NhZ2UgbGF0ZXIsIHVuZGVybmVhdGggYENvbm5lY3Rpb246OmVu cXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlYC4gV2UgZG8gdGhpcwor ICAgICAgICBzcGVjaWZpY2FsbHkgZm9yIG91dC1vZi1saW5lIHN0cmVhbSBtZXNzYWdlcyAoYW5k IG5vdCBhbGwgSVBDIG1lc3NhZ2VzKSwgc2luY2Ugd2Uga25vdyBhLXByaW9yaSB0aGF0IHRoZXNl CisgICAgICAgIG1lc3NhZ2VzIHJlcXVpcmUgYSByZWNlaXZlIHF1ZXVlLCBhbmQgc2hvdWxkIG5l dmVyIGJlIGhhbmRsZWQgYXMgYSByZWd1bGFyIElQQyBtZXNzYWdlLgorCisgICAgICAgICogUGxh dGZvcm0vSVBDL0Nvbm5lY3Rpb24uY3BwOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjplbnF1 ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZSk6CisKKyAgICAgICAgUmVm YWN0b3IgdGhpcyB0byB0YWtlIGEgYERlcXVlPHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4mYCwg d2hpY2ggaXMgZWl0aGVyIGBtX2luY29taW5nUmVjZWl2ZVF1ZXVlTWVzc2FnZXNgIG9yCisgICAg ICAgIGBtX2luY29taW5nTWVzc2FnZXNgLgorCisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmFk ZE1lc3NhZ2VSZWNlaXZlUXVldWUpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjphZGRXb3Jr UXVldWVNZXNzYWdlUmVjZWl2ZXIpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjphZGRUaHJl YWRNZXNzYWdlUmVjZWl2ZXIpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjpwcm9jZXNzSW5j b21pbmdNZXNzYWdlKToKKyAgICAgICAgKiBQbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oOgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5OgorCisgICAgICAgIEFkZCBhIGhlbHBl ciBmdW5jdGlvbiB0byBkZXRlcm1pbmUgd2hldGhlciBhIGdpdmVuIE1lc3NhZ2VSZWNlaXZlciBy ZWNlaXZlcyBzdHJlYW0gbWVzc2FnZXMuCisKKyAgICAgICAgKGdlbmVyYXRlX21lc3NhZ2VfbmFt ZXNfaGVhZGVyKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdlTmFtZXMu aDoKKyAgICAgICAgKElQQzo6aXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIpOgorCisgICAgICAgIFJl YmFzZWxpbmUgYSB1bml0IHRlc3QgcmVzdWx0IGZvciB0aGUgSVBDIG1lc3NhZ2UgY29kZSBnZW5l cmF0b3Igc2NyaXB0cy4KKwogMjAyMS0xMC0xOSAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUu Y29tPgogCiAgICAgICAgIGNhY2hlZENHQ29sb3IoKSBhbmQgbnNDb2xvcigpIHNob3VsZCByZXR1 cm4gc21hcnQgcG9pbnRlcnMKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9EZXJp dmVkU291cmNlcy1pbnB1dC54Y2ZpbGVsaXN0IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0Rlcml2 ZWRTb3VyY2VzLWlucHV0LnhjZmlsZWxpc3QKaW5kZXggOTIyYzVjNDdlNDNmNjM5MTFlYTczOGU1 NzA0Y2ZkZTY4NzQwZjRhMC4uNWM0N2FmOTlkNDE3OGIyYzllNjRkMjU1ZThlOTMzYzA4MDEyNDFk NiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0Rlcml2ZWRTb3VyY2VzLWlucHV0 LnhjZmlsZWxpc3QKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0Rlcml2ZWRTb3VyY2VzLWlu cHV0LnhjZmlsZWxpc3QKQEAgLTE2Niw2ICsxNjYsNyBAQCAkKFBST0pFQ1RfRElSKS9ydW50aW1l L09iamVjdENvbnN0cnVjdG9yLmNwcAogJChQUk9KRUNUX0RJUikvcnVudGltZS9SZWZsZWN0T2Jq ZWN0LmNwcAogJChQUk9KRUNUX0RJUikvcnVudGltZS9SZWdFeHBDb25zdHJ1Y3Rvci5jcHAKICQo UFJPSkVDVF9ESVIpL3J1bnRpbWUvU2V0UHJvdG90eXBlLmNwcAorJChQUk9KRUNUX0RJUikvcnVu dGltZS9TaGFkb3dSZWFsbVByb3RvdHlwZS5jcHAKICQoUFJPSkVDVF9ESVIpL3J1bnRpbWUvU3Ry aW5nQ29uc3RydWN0b3IuY3BwCiAkKFBST0pFQ1RfRElSKS9ydW50aW1lL1N0cmluZ1Byb3RvdHlw ZS5jcHAKICQoUFJPSkVDVF9ESVIpL3J1bnRpbWUvU3ltYm9sQ29uc3RydWN0b3IuY3BwCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmNwcCBiL1NvdXJj ZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uY3BwCmluZGV4IGZjYTJiNTRkMGYzYmY5 MzA5OTdhZTA5ODk3MzRmZDVlYWZmZDU3MjcuLjBiMjI4MmIyNWQzNDIxNGU0ZTEwMDVhYTgzNjE2 YWVmY2Y0MWNiMWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5l Y3Rpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uY3Bw CkBAIC0zNDAsMjYgKzM0MCwyNiBAQCB2b2lkIENvbm5lY3Rpb246OnNldFNob3VsZEV4aXRPblN5 bmNNZXNzYWdlU2VuZEZhaWx1cmUoYm9vbCBzaG91bGRFeGl0T25TeW5jTWVzcwogCiAvLyBFbnF1 ZXVlIGFueSBwZW5kaW5nIG1lc3NhZ2UgdG8gdGhlIE1lc3NhZ2VSZWNlaXZlUXVldWUgdGhhdCBp cyBtZWFudCB0byBnbyBvbiB0aGF0IHF1ZXVlLiBUaGlzIGlzIGltcG9ydGFudCB0byBtYWludGFp biB0aGUgb3JkZXJpbmcgb2YKIC8vIElQQyBtZXNzYWdlcyBhcyBzb21lIG1lc3NhZ2VzIG1heSBn ZXQgcmVjZWl2ZWQgb24gdGhlIElQQyB0aHJlYWQgYmVmb3JlIHRoZSBtZXNzYWdlIHJlY2VpdmVy IHJlZ2lzdGVyZWQgaXRzZWxmIG9uIHRoZSBtYWluIHRocmVhZC4KLXZvaWQgQ29ubmVjdGlvbjo6 ZW5xdWV1ZU1hdGNoaW5nTWVzc2FnZXNUb01lc3NhZ2VSZWNlaXZlUXVldWUoTWVzc2FnZVJlY2Vp dmVRdWV1ZSYgcmVjZWl2ZVF1ZXVlLCBSZWNlaXZlck5hbWUgcmVjZWl2ZXJOYW1lLCB1aW50NjRf dCBkZXN0aW5hdGlvbklEKQordm9pZCBDb25uZWN0aW9uOjplbnF1ZXVlTWF0Y2hpbmdNZXNzYWdl c1RvTWVzc2FnZVJlY2VpdmVRdWV1ZShNZXNzYWdlUmVjZWl2ZVF1ZXVlJiByZWNlaXZlUXVldWUs IERlcXVlPHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4mIHF1ZXVlZE1lc3NhZ2VzLCBSZWNlaXZl ck5hbWUgcmVjZWl2ZXJOYW1lLCB1aW50NjRfdCBkZXN0aW5hdGlvbklEKQogewogICAgIEFTU0VS VChpc01haW5SdW5Mb29wKCkpOwogCiAgICAgU3luY01lc3NhZ2VTdGF0ZTo6c2luZ2xldG9uKCku ZW5xdWV1ZU1hdGNoaW5nTWVzc2FnZXMoKnRoaXMsIHJlY2VpdmVRdWV1ZSwgcmVjZWl2ZXJOYW1l LCBkZXN0aW5hdGlvbklEKTsKIAogICAgIERlcXVlPHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4g cmVtYWluaW5nSW5jb21pbmdNZXNzYWdlczsKLSAgICBmb3IgKGF1dG8mIG1lc3NhZ2UgOiBtX2lu Y29taW5nTWVzc2FnZXMpIHsKKyAgICBmb3IgKGF1dG8mIG1lc3NhZ2UgOiBxdWV1ZWRNZXNzYWdl cykgewogICAgICAgICBpZiAobWVzc2FnZS0+bWVzc2FnZVJlY2VpdmVyTmFtZSgpID09IHJlY2Vp dmVyTmFtZSAmJiAobWVzc2FnZS0+ZGVzdGluYXRpb25JRCgpID09IGRlc3RpbmF0aW9uSUQgfHwg IWRlc3RpbmF0aW9uSUQpKQogICAgICAgICAgICAgcmVjZWl2ZVF1ZXVlLmVucXVldWVNZXNzYWdl KCp0aGlzLCBXVEZNb3ZlKG1lc3NhZ2UpKTsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgcmVt YWluaW5nSW5jb21pbmdNZXNzYWdlcy5hcHBlbmQoV1RGTW92ZShtZXNzYWdlKSk7CiAgICAgfQot ICAgIG1faW5jb21pbmdNZXNzYWdlcyA9IFdURk1vdmUocmVtYWluaW5nSW5jb21pbmdNZXNzYWdl cyk7CisgICAgcXVldWVkTWVzc2FnZXMgPSBXVEZNb3ZlKHJlbWFpbmluZ0luY29taW5nTWVzc2Fn ZXMpOwogfQogCiB2b2lkIENvbm5lY3Rpb246OmFkZE1lc3NhZ2VSZWNlaXZlUXVldWUoTWVzc2Fn ZVJlY2VpdmVRdWV1ZSYgcmVjZWl2ZVF1ZXVlLCBSZWNlaXZlck5hbWUgcmVjZWl2ZXJOYW1lLCB1 aW50NjRfdCBkZXN0aW5hdGlvbklEKQogewogICAgIExvY2tlciBpbmNvbWluZ01lc3NhZ2VzTG9j a2VyIHsgbV9pbmNvbWluZ01lc3NhZ2VzTG9jayB9OwotICAgIGVucXVldWVNYXRjaGluZ01lc3Nh Z2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlKHJlY2VpdmVRdWV1ZSwgcmVjZWl2ZXJOYW1lLCBkZXN0 aW5hdGlvbklEKTsKKyAgICBlbnF1ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVR dWV1ZShyZWNlaXZlUXVldWUsIG1faW5jb21pbmdSZWNlaXZlUXVldWVNZXNzYWdlcywgcmVjZWl2 ZXJOYW1lLCBkZXN0aW5hdGlvbklEKTsKICAgICBtX3JlY2VpdmVRdWV1ZXMuYWRkKHJlY2VpdmVR dWV1ZSwgcmVjZWl2ZXJOYW1lLCBkZXN0aW5hdGlvbklEKTsKIH0KIApAQCAtMzY3LDcgKzM2Nyw3 IEBAIHZvaWQgQ29ubmVjdGlvbjo6YWRkV29ya1F1ZXVlTWVzc2FnZVJlY2VpdmVyKFJlY2VpdmVy TmFtZSByZWNlaXZlck5hbWUsIFdvcmtRdWV1CiB7CiAgICAgYXV0byByZWNlaXZlUXVldWUgPSBt YWtlVW5pcXVlPFdvcmtRdWV1ZU1lc3NhZ2VSZWNlaXZlclF1ZXVlPih3b3JrUXVldWUsICpyZWNl aXZlcik7CiAgICAgTG9ja2VyIGluY29taW5nTWVzc2FnZXNMb2NrZXIgeyBtX2luY29taW5nTWVz c2FnZXNMb2NrIH07Ci0gICAgZW5xdWV1ZU1hdGNoaW5nTWVzc2FnZXNUb01lc3NhZ2VSZWNlaXZl UXVldWUoKnJlY2VpdmVRdWV1ZSwgcmVjZWl2ZXJOYW1lLCBkZXN0aW5hdGlvbklEKTsKKyAgICBl bnF1ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZSgqcmVjZWl2ZVF1ZXVl LCBtX2luY29taW5nTWVzc2FnZXMsIHJlY2VpdmVyTmFtZSwgZGVzdGluYXRpb25JRCk7CiAgICAg bV9yZWNlaXZlUXVldWVzLmFkZChXVEZNb3ZlKHJlY2VpdmVRdWV1ZSksIHJlY2VpdmVyTmFtZSwg ZGVzdGluYXRpb25JRCk7CiB9CiAKQEAgLTM3NSw3ICszNzUsNyBAQCB2b2lkIENvbm5lY3Rpb246 OmFkZFRocmVhZE1lc3NhZ2VSZWNlaXZlcihSZWNlaXZlck5hbWUgcmVjZWl2ZXJOYW1lLCBUaHJl YWRNZXNzYQogewogICAgIGF1dG8gcmVjZWl2ZVF1ZXVlID0gbWFrZVVuaXF1ZTxUaHJlYWRNZXNz YWdlUmVjZWl2ZXJRdWV1ZT4oKnJlY2VpdmVyKTsKICAgICBMb2NrZXIgaW5jb21pbmdNZXNzYWdl c0xvY2tlciB7IG1faW5jb21pbmdNZXNzYWdlc0xvY2sgfTsKLSAgICBlbnF1ZXVlTWF0Y2hpbmdN ZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZSgqcmVjZWl2ZVF1ZXVlLCByZWNlaXZlck5hbWUs IGRlc3RpbmF0aW9uSUQpOworICAgIGVucXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVj ZWl2ZVF1ZXVlKCpyZWNlaXZlUXVldWUsIG1faW5jb21pbmdNZXNzYWdlcywgcmVjZWl2ZXJOYW1l LCBkZXN0aW5hdGlvbklEKTsKICAgICBtX3JlY2VpdmVRdWV1ZXMuYWRkKFdURk1vdmUocmVjZWl2 ZVF1ZXVlKSwgcmVjZWl2ZXJOYW1lLCBkZXN0aW5hdGlvbklEKTsKIH0KIApAQCAtNzY5LDYgKzc2 OSwxNCBAQCB2b2lkIENvbm5lY3Rpb246OnByb2Nlc3NJbmNvbWluZ01lc3NhZ2Uoc3RkOjp1bmlx dWVfcHRyPERlY29kZXI+IG1lc3NhZ2UpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKKyAgICBp ZiAoaXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIobWVzc2FnZS0+bWVzc2FnZVJlY2VpdmVyTmFtZSgp KSkgeworICAgICAgICAvLyBXZSBtaWdodCBoYXZlIHJlY2VpdmVkIHRoaXMgbWVzc2FnZSBvbiB0 aGUgSVBDIHRocmVhZCBiZWZvcmUgdGhlIHN0cmVhbSBkZXN0aW5hdGlvbiBoYXMgYWRkZWQgaXRz ZWxmIGFzCisgICAgICAgIC8vIGEgcmVjZWl2ZSBxdWV1ZSBvbiB0aGUgY29ubmVjdGlvbjsgaW4g dGhpcyBjYXNlLCBhcHBlbmQgdGhlIG1lc3NhZ2UgdG8gdGhlIGluY29taW5nIG1lc3NhZ2UgcXVl dWU7IHdoZW4KKyAgICAgICAgLy8gdGhlIHJlY2VpdmUgcXVldWUgaXMgYWRkZWQsIHdlJ2xsIHRh a2UgdGhpcyBxdWV1ZWQgbWVzc2FnZSBhbmQgYXBwZW5kIGl0IHRvIHRoZSByZWNlaXZlIHF1ZXVl LgorICAgICAgICBtX2luY29taW5nUmVjZWl2ZVF1ZXVlTWVzc2FnZXMuYXBwZW5kKFdURk1vdmUo bWVzc2FnZSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgaWYgKG1lc3NhZ2UtPmlz U3luY01lc3NhZ2UoKSkgewogICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9pbmNvbWluZ1N5bmNN ZXNzYWdlQ2FsbGJhY2tMb2NrIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvUGxhdGZv cm0vSVBDL0Nvbm5lY3Rpb24uaCBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rp b24uaAppbmRleCAyMjBlNWVhYmNjNDA5OTY4ZWY3YmZmMDA5ZWM3NjI4MjVjM2UwYzU1Li43OThl YmE0YjI3Mzg4ZWY0YTVmNzE1NmU2ZjU4OTRjNzZlMWUyZjc1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmgKKysrIGIvU291cmNlL1dlYktpdC9QbGF0 Zm9ybS9JUEMvQ29ubmVjdGlvbi5oCkBAIC0zNDMsNyArMzQzLDcgQEAgcHJpdmF0ZToKICAgICB2 b2lkIHBvcFBlbmRpbmdTeW5jUmVxdWVzdElEKFN5bmNSZXF1ZXN0SUQpOwogICAgIHN0ZDo6dW5p cXVlX3B0cjxEZWNvZGVyPiB3YWl0Rm9yU3luY1JlcGx5KFN5bmNSZXF1ZXN0SUQsIE1lc3NhZ2VO YW1lLCBUaW1lb3V0LCBPcHRpb25TZXQ8U2VuZFN5bmNPcHRpb24+KTsKIAotICAgIHZvaWQgZW5x dWV1ZU1hdGNoaW5nTWVzc2FnZXNUb01lc3NhZ2VSZWNlaXZlUXVldWUoTWVzc2FnZVJlY2VpdmVR dWV1ZSYsIFJlY2VpdmVyTmFtZSwgdWludDY0X3QgZGVzdGluYXRpb25JRCkgV1RGX1JFUVVJUkVT X0xPQ0sobV9pbmNvbWluZ01lc3NhZ2VzTG9jayk7CisgICAgdm9pZCBlbnF1ZXVlTWF0Y2hpbmdN ZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZShNZXNzYWdlUmVjZWl2ZVF1ZXVlJiwgRGVxdWU8 c3RkOjp1bmlxdWVfcHRyPERlY29kZXI+PiYsIFJlY2VpdmVyTmFtZSwgdWludDY0X3QgZGVzdGlu YXRpb25JRCkgV1RGX1JFUVVJUkVTX0xPQ0sobV9pbmNvbWluZ01lc3NhZ2VzTG9jayk7CiAKICAg ICAvLyBDYWxsZWQgb24gdGhlIGNvbm5lY3Rpb24gd29yayBxdWV1ZS4KICAgICB2b2lkIHByb2Nl c3NJbmNvbWluZ01lc3NhZ2Uoc3RkOjp1bmlxdWVfcHRyPERlY29kZXI+KTsKQEAgLTQxNyw2ICs0 MTcsNyBAQCBwcml2YXRlOgogICAgIC8vIEluY29taW5nIG1lc3NhZ2VzLgogICAgIExvY2sgbV9p bmNvbWluZ01lc3NhZ2VzTG9jazsKICAgICBEZXF1ZTxzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4+ IG1faW5jb21pbmdNZXNzYWdlcyBXVEZfR1VBUkRFRF9CWV9MT0NLKG1faW5jb21pbmdNZXNzYWdl c0xvY2spOworICAgIERlcXVlPHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4gbV9pbmNvbWluZ1Jl Y2VpdmVRdWV1ZU1lc3NhZ2VzIFdURl9HVUFSREVEX0JZX0xPQ0sobV9pbmNvbWluZ01lc3NhZ2Vz TG9jayk7CiAgICAgc3RkOjp1bmlxdWVfcHRyPE1lc3NhZ2VzVGhyb3R0bGVyPiBtX2luY29taW5n TWVzc2FnZXNUaHJvdHRsZXI7CiAgICAgTWVzc2FnZVJlY2VpdmVRdWV1ZU1hcCBtX3JlY2VpdmVR dWV1ZXMgV1RGX0dVQVJERURfQllfTE9DSyhtX2luY29taW5nTWVzc2FnZXNMb2NrKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC9tZXNzYWdlcy5weSBiL1NvdXJj ZS9XZWJLaXQvU2NyaXB0cy93ZWJraXQvbWVzc2FnZXMucHkKaW5kZXggNjU4NGQxYWQ3ZTE1NGVi MDkyMDIzMTBkZGZhNmI1ZTEyMWFkMmMzOS4uZjdjY2RjOGM2N2QyYmEyYzNkZWY4ZGEyZWMyZGU0 YmY4YTUyNjBiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC9tZXNz YWdlcy5weQorKysgYi9Tb3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5CkBA IC0xMDkzLDYgKzEwOTMsMTggQEAgZGVmIGdlbmVyYXRlX21lc3NhZ2VfbmFtZXNfaGVhZGVyKHJl Y2VpdmVycyk6CiAgICAgICAgIHJlc3VsdC5hcHBlbmQoJyAgICByZXR1cm4gZmFsc2U7XG4nKQog ICAgIHJlc3VsdC5hcHBlbmQoJ31cbicpCiAgICAgcmVzdWx0LmFwcGVuZCgnXG4nKQorICAgIHJl c3VsdC5hcHBlbmQoJ2NvbnN0ZXhwciBib29sIGlzU3RyZWFtTWVzc2FnZVJlY2VpdmVyKFJlY2Vp dmVyTmFtZSBuYW1lKVxuJykKKyAgICByZXN1bHQuYXBwZW5kKCd7XG4nKQorICAgIHJlc3VsdC5h cHBlbmQoJyAgICBzd2l0Y2ggKG5hbWUpIHtcbicpCisgICAgZm9yIG5hbWUgaW4gW3JlY2VpdmVy Lm5hbWUgZm9yIHJlY2VpdmVyIGluIHJlY2VpdmVycyBpZiByZWNlaXZlci5oYXNfYXR0cmlidXRl KFNUUkVBTV9BVFRSSUJVVEUpXToKKyAgICAgICAgcmVzdWx0LmFwcGVuZCgnICAgIGNhc2UgUmVj ZWl2ZXJOYW1lOjolczpcbicgJSBuYW1lKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICAgICAgcmV0 dXJuIHRydWU7XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICBkZWZhdWx0OlxuJykKKyAgICBy ZXN1bHQuYXBwZW5kKCcgICAgICAgIGJyZWFrO1xuJykKKyAgICByZXN1bHQuYXBwZW5kKCcgICAg fVxuJykKKyAgICByZXN1bHQuYXBwZW5kKCcgICAgcmV0dXJuIGZhbHNlO1xuJykKKyAgICByZXN1 bHQuYXBwZW5kKCd9XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJ1xuJykKICAgICByZXN1bHQuYXBw ZW5kKCd9IC8vIG5hbWVzcGFjZSBJUENcbicpCiAgICAgcmVzdWx0LmFwcGVuZCgnXG4nKQogICAg IHJlc3VsdC5hcHBlbmQoJ25hbWVzcGFjZSBXVEYge1xuJykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvU2NyaXB0cy93ZWJraXQvdGVzdHMvTWVzc2FnZU5hbWVzLmggYi9Tb3VyY2UvV2ViS2l0 L1NjcmlwdHMvd2Via2l0L3Rlc3RzL01lc3NhZ2VOYW1lcy5oCmluZGV4IDJlZmQ1ZTA0OTBmMTA2 YWMwNmFmMWU5YzI0YWZlNzQ2MDE1MTc5MzYuLmRiNDE3ODEwMzgyYzMyMmJhNjk4YWYyYTA4Njdm MjRlMmZmOTZhYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU2NyaXB0cy93ZWJraXQvdGVz dHMvTWVzc2FnZU5hbWVzLmgKKysrIGIvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC90ZXN0 cy9NZXNzYWdlTmFtZXMuaApAQCAtMTI5LDYgKzEyOSwxNyBAQCBjb25zdGV4cHIgYm9vbCBtZXNz YWdlSXNTeW5jKE1lc3NhZ2VOYW1lIG5hbWUpCiAgICAgcmV0dXJuIG5hbWUgPj0gTWVzc2FnZU5h bWU6OlRlc3RXaXRoTGVnYWN5UmVjZWl2ZXJfR2V0UGx1Z2luUHJvY2Vzc0Nvbm5lY3Rpb247CiB9 CiAKK2NvbnN0ZXhwciBib29sIGlzU3RyZWFtTWVzc2FnZVJlY2VpdmVyKFJlY2VpdmVyTmFtZSBu YW1lKQoreworICAgIHN3aXRjaCAobmFtZSkgeworICAgIGNhc2UgUmVjZWl2ZXJOYW1lOjpUZXN0 V2l0aFN0cmVhbToKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgZGVmYXVsdDoKKyAgICAgICAg YnJlYWs7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKwogfSAvLyBuYW1lc3BhY2UgSVBD CiAKIG5hbWVzcGFjZSBXVEYgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDY3MmIwNGY2MzNlZDdkYjk4NmRjZjg3MGZkOGYy OTg1MmUzNjE3NDcuLmM5ZTc5MGJmNTQwOTkzYTcxZDJiYzU1MmUxMTU0OWRhODE4Y2E4M2IgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNiBAQAorMjAyMS0xMC0xOSAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hz aWVoQGFwcGxlLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OIChyMjg0MDc5KTogZmFzdC9jYW52 YXMvZ3JhZGllbnQtd2l0aC1jbGlwLmh0bWwgYW5kIGZhc3QvY2FudmFzL2dyYWRpZW50LXRleHQt d2l0aC1zaGFkb3cuaHRtbCBhcmUgZmxha3kgZmFpbHVyZXMKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMTY4MQorICAgICAgICByZGFyOi8vODQyMDI0 NzgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1v dmUgdGhlIGZsYWt5IGZhaWx1cmUgZW50cmllcyBpbiB0ZXN0IGV4cGVjdGF0aW9ucy4gU2VlIFdl YktpdDIgQ2hhbmdlTG9nIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9p b3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnM6CisgICAgICAgICogcGxhdGZvcm0vbWFjLXdrMi9UZXN0 RXhwZWN0YXRpb25zOgorCiAyMDIxLTEwLTE5ICBSb2IgQnVpcyAgPHJidWlzQGlnYWxpYS5jb20+ CiAKICAgICAgICAgVW5za2lwIHBhc3NpbmcgZmxleC1iYXNpczogY29udGVudCArIGFzcGVjdCBy YXRpbyBXUFQgdGVzdHMKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy13azIv VGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy13azIvVGVzdEV4cGVj dGF0aW9ucwppbmRleCAxM2Y0ZWMwYzljMzViODUyNGFiZDdlODlkZmQxNTM4YTgwYTliY2ZlLi42 YzVjMmIyM2NkMDkzYzM2NmZhOWIyNDUzNmNkZjdjMTliN2RjNGEyIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVz dHMvcGxhdGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0YXRpb25zCkBAIC0yMDMyLDkgKzIwMzIsNiBA QCB3ZWJraXQub3JnL2IvMjE5NDM4IFsgUmVsZWFzZSBdIGZhc3QvY2FudmFzL2NhbnZhcy1vdmVy Zmxvdy1oaWRkZW4tYW5pbWF0aW9uLmh0bQogCiB3ZWJraXQub3JnL2IvMjMwNDEzIFsgRGVidWcg XSBmYXN0L2NhbnZhcy9jYW52YXMtZHJhd0ltYWdlLWRldGFjaGVkLWxlYWsuaHRtbCBbIFBhc3Mg RmFpbHVyZSBdCiAKLXdlYmtpdC5vcmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMv Z3JhZGllbnQtdGV4dC13aXRoLXNoYWRvdy5odG1sIFsgUGFzcyBGYWlsdXJlIF0KLXdlYmtpdC5v cmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvZ3JhZGllbnQtd2l0aC1jbGlwLmh0 bWwgWyBQYXNzIEZhaWx1cmUgXQotCiB3ZWJhbmltYXRpb25zL211bHRpcGxlLXRyYW5zZm9ybS1w cm9wZXJ0aWVzLWFuZC1tdWx0aXBsZS10cmFuc2Zvcm0tcHJvcGVydGllcy1hbmltYXRpb24td2l0 aC1kZWxheS1vbi1mb3JjZWQtbGF5ZXIuaHRtbCBbIFBhc3MgXQogd2ViYW5pbWF0aW9ucy9yb3Rh dGUtcHJvcGVydHktYW5kLXJvdGF0ZS1hbmltYXRpb24td2l0aC1kZWxheS1vbi1mb3JjZWQtbGF5 ZXIuaHRtbCBbIFBhc3MgXQogd2ViYW5pbWF0aW9ucy9zY2FsZS1wcm9wZXJ0eS1hbmQtc2NhbGUt YW5pbWF0aW9uLXdpdGgtZGVsYXktb24tZm9yY2VkLWxheWVyLmh0bWwgWyBQYXNzIF0KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvVGVzdEV4cGVjdGF0aW9ucyBiL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvVGVzdEV4cGVjdGF0aW9ucwppbmRleCA0NDhjYmRi ZTcxMTQ0ODU1ZjkxMDczZmVkNzM4ODcyNmQ2OTU2Y2M0Li43YWRkNjkzMTkwYWNkZjIxYzA0NDNk OWIyZjJkYjBhZjc4NGIxNTMxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMt d2syL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9U ZXN0RXhwZWN0YXRpb25zCkBAIC0xNTA4LDkgKzE1MDgsNiBAQCB3ZWJraXQub3JnL2IvMjI3ODA1 IFsgRGVidWcgXSBmYXN0L2NhbnZhcy9jYW52YXMtY29tcG9zaXRlLWltYWdlLmh0bWwgWyBQYXNz IENyYQogd2Via2l0Lm9yZy9iLzIzMDM2NiBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9jYW52YXMt YmxlbmRpbmctdGV4dC5odG1sIFsgUGFzcyBGYWlsdXJlIENyYXNoIF0KIHdlYmtpdC5vcmcvYi8y MzAzNjYgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvY2FudmFzLWNvbXBvc2l0ZS10ZXh0LWFscGhh Lmh0bWwgWyBQYXNzIEZhaWx1cmUgXQogCi13ZWJraXQub3JnL2IvMjMxNjgxIFsgUmVsZWFzZSBd IGZhc3QvY2FudmFzL2dyYWRpZW50LXRleHQtd2l0aC1zaGFkb3cuaHRtbCBbIFBhc3MgRmFpbHVy ZSBdCi13ZWJraXQub3JnL2IvMjMxNjgxIFsgUmVsZWFzZSBdIGZhc3QvY2FudmFzL2dyYWRpZW50 LXdpdGgtY2xpcC5odG1sIFsgUGFzcyBGYWlsdXJlIF0KLQogd2Via2l0Lm9yZy9iLzIzMDQxMyBm YXN0L2NhbnZhcy9jYW52YXMtZHJhd0ltYWdlLWRldGFjaGVkLWxlYWsuaHRtbCBbIFBhc3MgRmFp bHVyZSBdCiAKIHdlYmtpdC5vcmcvYi8yMjY4MjggWyBCaWdTdXIrIF0gbWVkaWEvbW9kZXJuLW1l ZGlhLWNvbnRyb2xzL292ZXJmbG93LXN1cHBvcnQvY2hhcHRlcnMuaHRtbCBbIFBhc3MgRmFpbHVy ZSBUaW1lb3V0IF0K 441755 2021-10-19 10:45:53 -0700 2021-10-19 11:18:42 -0700 Async approach, v2 bug-231681-20211019104552.patch text/plain 14684 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0NDU2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDIyMDk4OGRjYjZjNmYzMDBl YTI5YTk2YjU1MjkxNzA0NDI5YzkwOWUuLmQ2ZWVkMWRlNjY3NTMwNDE1OGU1M2UzZTliZWZjNGU5 NGQ4YjU5MmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjMgQEAKKzIwMjEtMTAtMTkgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAocjI4 NDA3OSk6IGZhc3QvY2FudmFzL2dyYWRpZW50LXdpdGgtY2xpcC5odG1sIGFuZCBmYXN0L2NhbnZh cy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgYXJlIGZsYWt5IGZhaWx1cmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzE2ODEKKyAgICAg ICAgcmRhcjovLzg0MjAyNDc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhlc2UgdGVzdHMgb2NjYXNpb25hbGx5IGZhaWwgd2hlbiB3ZSB0aW1lIG91 dCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgcGl4ZWwgYnVmZmVyIHRvIGJlIHBvcHVsYXRlZCB1bmRl cm5lYXRoCisgICAgICAgIGBSZW1vdGVJbWFnZUJ1ZmZlclByb3h5OjpnZXRQaXhlbEJ1ZmZlcmA7 IHRoaXMgaGFwcGVucyBiZWNhdXNlIHRoZSBHUFUgcHJvY2VzcyBzb21ldGltZXMgaGFsdHMgKGFu ZCBuZXZlcgorICAgICAgICByZXN1bWVzKSB3aGlsZSBwcm9jZXNzaW5nIHN0cmVhbSBtZXNzYWdl cywgYW5kIGNvbnNlcXVlbnRseSBuZXZlciBlbmRzIHVwIHByb2Nlc3NpbmcgdGhlIEdldFBpeGVs QnVmZmVyIElQQworICAgICAgICBzdHJlYW0gbWVzc2FnZSB0aGF0J3MgbmVjZXNzYXJ5IHRvIHBv cHVsYXRlIHRoZSBzaGFyZWQgbWVtb3J5IGJ1ZmZlciBmb3IgR2V0UGl4ZWxCdWZmZXIuCisKKyAg ICAgICAgVGhpcywgaW4gdHVybiwgaGFwcGVucyB3aGVuIHRoZSBJUEMgc3RyZWFtIGJ1ZmZlciBp cyBhYm91dCB0byBleGhhdXN0IGFsbCBhdmFpbGFibGUgY2FwYWNpdHkgKGkuZS4gdGhlIHdyaXRl CisgICAgICAgIGN1cnNvciBpcyBuZWFyaW5nIHRoZSBlbmQgb2YgdGhlIDJNQiBidWZmZXIpLCBh bmQgYXMgYSByZXN1bHQsIHdlIHNlbmQgbWVzc2FnZXMgdGhhdCB3b3VsZCBub3JtYWxseSBiZSBl bmNvZGVkCisgICAgICAgIGluIHRoZSBJUEMgc3RyZWFtIGFzIG91dC1vZi1saW5lIElQQyBtZXNz YWdlcyBpbnN0ZWFkLCB3aGljaCBhcmUgcmVjZWl2ZWQgaW4gdGhlIEdQVSBwcm9jZXNzIG9uIHRo ZSBJUEMgdGhyZWFkCisgICAgICAgIGFuZCBhcHBlbmRlZCB0byB0aGUgcmVjZWl2ZSBxdWV1ZSBj b3JyZXNwb25kaW5nIHRvIHRoZSBkZXN0aW5hdGlvbiBJRCBpbiBgQ29ubmVjdGlvbjo6cHJvY2Vz c0luY29taW5nTWVzc2FnZSgpYC4KKworICAgICAgICBJZiB3ZSBoYXBwZW4gdG8gaGF2ZSBzZW50 IGBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpDcmVhdGVJbWFnZUJ1ZmZlcihhKWAgcmlnaHQgYmVm b3JlIGV4aGF1c3RpbmcgY2FwYWNpdHkgYW5kCisgICAgICAgIHNlbmRpbmcgb3V0LW9mLWxpbmUg bWVzc2FnZXMgdGFyZ2V0aW5nIHRoZSBSZW1vdGVEaXNwbGF5TGlzdFJlY29yZGVyIGNvcnJlc3Bv bmRpbmcgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgaW1hZ2UKKyAgICAgICAgYnVmZmVyIGBhYCwgd2Un bGwgZW5kIHVwIHdpdGggYSByYWNlIGNvbmRpdGlvbiB3aGVyZSB0aGUgSVBDIHRocmVhZCBtYXkg cmVjZWl2ZSB0aGUgb3V0LW9mLWxpbmUgbWVzc2FnZXMgbWVhbnQKKyAgICAgICAgZm9yIHRoZSBu ZXcgcmVtb3RlIGRpc3BsYXkgbGlzdCBkZXN0aW5hdGlvbiAqYmVmb3JlKiB0aGUgbmV3IHJlbW90 ZSBkaXNwbGF5IGxpc3QgaGFzIGFkZGVkIGl0c2VsZiBhcyBhbiBJUEMKKyAgICAgICAgcmVjZWl2 ZSBxdWV1ZSBieSBjYWxsaW5nIGludG8gYFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OnN0YXJ0UmVj ZWl2aW5nTWVzc2FnZXMoKWAuCisKKyAgICAgICAgSW4gdGhpcyBwYXJ0aWN1bGFyIHNjZW5hcmlv ICh3aGVyZSB3ZSAibG9zZSIgdGhlIHJhY2UpLCBgQ29ubmVjdGlvbjo6cHJvY2Vzc0luY29taW5n TWVzc2FnZWAgd2lsbCBza2lwIHBhc3QgdGhlCisgICAgICAgIGVhcmx5IHJldHVybiB3aGVyZSBp dCB3b3VsZCBub3JtYWxseSBmaW5kIGl0cyBjb3JyZXNwb25kaW5nIHJlY2VpdmUgcXVldWUgdmlh IGBtX3JlY2VpdmVRdWV1ZXMuZ2V0KCptZXNzYWdlKWAsCisgICAgICAgIGFuZCBpbnN0ZWFkIGZh bGxzIHRocm91Z2ggdG8gYENvbm5lY3Rpb246OlN5bmNNZXNzYWdlU3RhdGU6OnByb2Nlc3NJbmNv bWluZ01lc3NhZ2UoKWAsIHdoaWNoIHdpbGwgYXR0ZW1wdCB0bworICAgICAgICBkaXNwYXRjaCB0 aGUgaW5jb21pbmcgbWVzc2FnZSB0byB0aGUgQ29ubmVjdGlvbidzIGNsaWVudCAoR1BVQ29ubmVj dGlvblRvV2ViUHJvY2VzcykuIE9mIGNvdXJzZSwgdGhlCisgICAgICAgIEdQVUNvbm5lY3Rpb25U b1dlYlByb2Nlc3MgaXNuJ3QgYXdhcmUgb2YgaG93IHRvIHByb2Nlc3MgdGhpcyBpbmNvbWluZyBt ZXNzYWdlLCBzbyBpdCBzaW1wbHkgZ2V0cyBkcm9wcGVkLiBCeSB0aGUKKyAgICAgICAgdGltZSB0 aGUgcmVjZWl2ZSBxdWV1ZSBpcyBhZGRlZCBmb3IgdGhlIG5ldyBSZW1vdGVEaXNwbGF5TGlzdFJl Y29yZGVyLCB3ZSdsbCBvYnNlcnZlIGEgUHJvY2Vzc091dE9mU3RyZWFtTWVzc2FnZQorICAgICAg ICBhbmQgZW5kIHVwIHdhaXRpbmcgZm9yZXZlciBmb3IgdGhpcyBvdXQtb2YtbGluZSBtZXNzYWdl IHRvIGJlIGFkZGVkIHRvIHRoZSByZWNlaXZlIHF1ZXVlLCBidXQgdGhpcyBuZXZlciBlbmRzIHVw CisgICAgICAgIGhhcHBlbmluZyBiZWNhdXNlIGl0IGhhcyBhbHJlYWR5IGJlZW4gcmVjZWl2ZWQg YW5kIGRyb3BwZWQgYnkgR1BVQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy4KKworICAgICAgICBUbyBw cmV2ZW50IHRoaXMgcmFjZSBmcm9tIGhhcHBlbmluZywgd2UgY2FuIGVucXVldWUgYSBzdHJlYW0g bWVzc2FnZSB0aGF0IGRvZXMgbm90IHlldCBoYXZlIGEgY29ycmVzcG9uZGluZworICAgICAgICBy ZWNlaXZlciBvbiBgbV9pbmNvbWluZ1JlY2VpdmVRdWV1ZU1lc3NhZ2VzYCBpbnN0ZWFkIG9mIHNr aXBwaW5nIHRoZSBlYXJseSByZXR1cm4uIFRoaXMgYWxsb3dzIHVzIHRvIGVucXVldWUgdGhlCisg ICAgICAgIGluY29taW5nIG1lc3NhZ2UgbGF0ZXIsIHVuZGVybmVhdGggYENvbm5lY3Rpb246OmVu cXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlYC4gV2UgZG8gdGhpcwor ICAgICAgICBzcGVjaWZpY2FsbHkgZm9yIG91dC1vZi1saW5lIHN0cmVhbSBtZXNzYWdlcyAoYW5k IG5vdCBhbGwgSVBDIG1lc3NhZ2VzKSwgc2luY2Ugd2Uga25vdyBhLXByaW9yaSB0aGF0IHRoZXNl CisgICAgICAgIG1lc3NhZ2VzIHJlcXVpcmUgYSByZWNlaXZlIHF1ZXVlLCBhbmQgc2hvdWxkIG5l dmVyIGJlIGhhbmRsZWQgYXMgYSByZWd1bGFyIElQQyBtZXNzYWdlLgorCisgICAgICAgICogUGxh dGZvcm0vSVBDL0Nvbm5lY3Rpb24uY3BwOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjplbnF1 ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZSk6CisKKyAgICAgICAgUmVm YWN0b3IgdGhpcyB0byB0YWtlIGEgYERlcXVlPHN0ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4mYCwg d2hpY2ggaXMgZWl0aGVyIGBtX2luY29taW5nUmVjZWl2ZVF1ZXVlTWVzc2FnZXNgIG9yCisgICAg ICAgIGBtX2luY29taW5nTWVzc2FnZXNgLgorCisgICAgICAgIChJUEM6OkNvbm5lY3Rpb246OmFk ZE1lc3NhZ2VSZWNlaXZlUXVldWUpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjphZGRXb3Jr UXVldWVNZXNzYWdlUmVjZWl2ZXIpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjphZGRUaHJl YWRNZXNzYWdlUmVjZWl2ZXIpOgorICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjpwcm9jZXNzSW5j b21pbmdNZXNzYWdlKToKKyAgICAgICAgKiBQbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oOgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5OgorCisgICAgICAgIEFkZCBhIGhlbHBl ciBmdW5jdGlvbiB0byBkZXRlcm1pbmUgd2hldGhlciBhIGdpdmVuIE1lc3NhZ2VSZWNlaXZlciBy ZWNlaXZlcyBzdHJlYW0gbWVzc2FnZXMuCisKKyAgICAgICAgKGdlbmVyYXRlX21lc3NhZ2VfbmFt ZXNfaGVhZGVyKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdlTmFtZXMu aDoKKyAgICAgICAgKElQQzo6aXNTdHJlYW1NZXNzYWdlUmVjZWl2ZXIpOgorCisgICAgICAgIFJl YmFzZWxpbmUgYSB1bml0IHRlc3QgcmVzdWx0IGZvciB0aGUgSVBDIG1lc3NhZ2UgY29kZSBnZW5l cmF0b3Igc2NyaXB0cy4KKwogMjAyMS0xMC0xOSAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUu Y29tPgogCiAgICAgICAgIGNhY2hlZENHQ29sb3IoKSBhbmQgbnNDb2xvcigpIHNob3VsZCByZXR1 cm4gc21hcnQgcG9pbnRlcnMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBD L0Nvbm5lY3Rpb24uY3BwIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5j cHAKaW5kZXggZmNhMmI1NGQwZjNiZjkzMDk5N2FlMDk4OTczNGZkNWVhZmZkNTcyNy4uMGIyMjgy YjI1ZDM0MjE0ZTRlMTAwNWFhODM2MTZhZWZjZjQxY2IxZSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYktpdC9QbGF0 Zm9ybS9JUEMvQ29ubmVjdGlvbi5jcHAKQEAgLTM0MCwyNiArMzQwLDI2IEBAIHZvaWQgQ29ubmVj dGlvbjo6c2V0U2hvdWxkRXhpdE9uU3luY01lc3NhZ2VTZW5kRmFpbHVyZShib29sIHNob3VsZEV4 aXRPblN5bmNNZXNzCiAKIC8vIEVucXVldWUgYW55IHBlbmRpbmcgbWVzc2FnZSB0byB0aGUgTWVz c2FnZVJlY2VpdmVRdWV1ZSB0aGF0IGlzIG1lYW50IHRvIGdvIG9uIHRoYXQgcXVldWUuIFRoaXMg aXMgaW1wb3J0YW50IHRvIG1haW50YWluIHRoZSBvcmRlcmluZyBvZgogLy8gSVBDIG1lc3NhZ2Vz IGFzIHNvbWUgbWVzc2FnZXMgbWF5IGdldCByZWNlaXZlZCBvbiB0aGUgSVBDIHRocmVhZCBiZWZv cmUgdGhlIG1lc3NhZ2UgcmVjZWl2ZXIgcmVnaXN0ZXJlZCBpdHNlbGYgb24gdGhlIG1haW4gdGhy ZWFkLgotdm9pZCBDb25uZWN0aW9uOjplbnF1ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJl Y2VpdmVRdWV1ZShNZXNzYWdlUmVjZWl2ZVF1ZXVlJiByZWNlaXZlUXVldWUsIFJlY2VpdmVyTmFt ZSByZWNlaXZlck5hbWUsIHVpbnQ2NF90IGRlc3RpbmF0aW9uSUQpCit2b2lkIENvbm5lY3Rpb246 OmVucXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlKE1lc3NhZ2VSZWNl aXZlUXVldWUmIHJlY2VpdmVRdWV1ZSwgRGVxdWU8c3RkOjp1bmlxdWVfcHRyPERlY29kZXI+PiYg cXVldWVkTWVzc2FnZXMsIFJlY2VpdmVyTmFtZSByZWNlaXZlck5hbWUsIHVpbnQ2NF90IGRlc3Rp bmF0aW9uSUQpCiB7CiAgICAgQVNTRVJUKGlzTWFpblJ1bkxvb3AoKSk7CiAKICAgICBTeW5jTWVz c2FnZVN0YXRlOjpzaW5nbGV0b24oKS5lbnF1ZXVlTWF0Y2hpbmdNZXNzYWdlcygqdGhpcywgcmVj ZWl2ZVF1ZXVlLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9uSUQpOwogCiAgICAgRGVxdWU8c3Rk Ojp1bmlxdWVfcHRyPERlY29kZXI+PiByZW1haW5pbmdJbmNvbWluZ01lc3NhZ2VzOwotICAgIGZv ciAoYXV0byYgbWVzc2FnZSA6IG1faW5jb21pbmdNZXNzYWdlcykgeworICAgIGZvciAoYXV0byYg bWVzc2FnZSA6IHF1ZXVlZE1lc3NhZ2VzKSB7CiAgICAgICAgIGlmIChtZXNzYWdlLT5tZXNzYWdl UmVjZWl2ZXJOYW1lKCkgPT0gcmVjZWl2ZXJOYW1lICYmIChtZXNzYWdlLT5kZXN0aW5hdGlvbklE KCkgPT0gZGVzdGluYXRpb25JRCB8fCAhZGVzdGluYXRpb25JRCkpCiAgICAgICAgICAgICByZWNl aXZlUXVldWUuZW5xdWV1ZU1lc3NhZ2UoKnRoaXMsIFdURk1vdmUobWVzc2FnZSkpOwogICAgICAg ICBlbHNlCiAgICAgICAgICAgICByZW1haW5pbmdJbmNvbWluZ01lc3NhZ2VzLmFwcGVuZChXVEZN b3ZlKG1lc3NhZ2UpKTsKICAgICB9Ci0gICAgbV9pbmNvbWluZ01lc3NhZ2VzID0gV1RGTW92ZShy ZW1haW5pbmdJbmNvbWluZ01lc3NhZ2VzKTsKKyAgICBxdWV1ZWRNZXNzYWdlcyA9IFdURk1vdmUo cmVtYWluaW5nSW5jb21pbmdNZXNzYWdlcyk7CiB9CiAKIHZvaWQgQ29ubmVjdGlvbjo6YWRkTWVz c2FnZVJlY2VpdmVRdWV1ZShNZXNzYWdlUmVjZWl2ZVF1ZXVlJiByZWNlaXZlUXVldWUsIFJlY2Vp dmVyTmFtZSByZWNlaXZlck5hbWUsIHVpbnQ2NF90IGRlc3RpbmF0aW9uSUQpCiB7CiAgICAgTG9j a2VyIGluY29taW5nTWVzc2FnZXNMb2NrZXIgeyBtX2luY29taW5nTWVzc2FnZXNMb2NrIH07Ci0g ICAgZW5xdWV1ZU1hdGNoaW5nTWVzc2FnZXNUb01lc3NhZ2VSZWNlaXZlUXVldWUocmVjZWl2ZVF1 ZXVlLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9uSUQpOworICAgIGVucXVldWVNYXRjaGluZ01l c3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlKHJlY2VpdmVRdWV1ZSwgbV9pbmNvbWluZ1JlY2Vp dmVRdWV1ZU1lc3NhZ2VzLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9uSUQpOwogICAgIG1fcmVj ZWl2ZVF1ZXVlcy5hZGQocmVjZWl2ZVF1ZXVlLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9uSUQp OwogfQogCkBAIC0zNjcsNyArMzY3LDcgQEAgdm9pZCBDb25uZWN0aW9uOjphZGRXb3JrUXVldWVN ZXNzYWdlUmVjZWl2ZXIoUmVjZWl2ZXJOYW1lIHJlY2VpdmVyTmFtZSwgV29ya1F1ZXUKIHsKICAg ICBhdXRvIHJlY2VpdmVRdWV1ZSA9IG1ha2VVbmlxdWU8V29ya1F1ZXVlTWVzc2FnZVJlY2VpdmVy UXVldWU+KHdvcmtRdWV1ZSwgKnJlY2VpdmVyKTsKICAgICBMb2NrZXIgaW5jb21pbmdNZXNzYWdl c0xvY2tlciB7IG1faW5jb21pbmdNZXNzYWdlc0xvY2sgfTsKLSAgICBlbnF1ZXVlTWF0Y2hpbmdN ZXNzYWdlc1RvTWVzc2FnZVJlY2VpdmVRdWV1ZSgqcmVjZWl2ZVF1ZXVlLCByZWNlaXZlck5hbWUs IGRlc3RpbmF0aW9uSUQpOworICAgIGVucXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVj ZWl2ZVF1ZXVlKCpyZWNlaXZlUXVldWUsIG1faW5jb21pbmdNZXNzYWdlcywgcmVjZWl2ZXJOYW1l LCBkZXN0aW5hdGlvbklEKTsKICAgICBtX3JlY2VpdmVRdWV1ZXMuYWRkKFdURk1vdmUocmVjZWl2 ZVF1ZXVlKSwgcmVjZWl2ZXJOYW1lLCBkZXN0aW5hdGlvbklEKTsKIH0KIApAQCAtMzc1LDcgKzM3 NSw3IEBAIHZvaWQgQ29ubmVjdGlvbjo6YWRkVGhyZWFkTWVzc2FnZVJlY2VpdmVyKFJlY2VpdmVy TmFtZSByZWNlaXZlck5hbWUsIFRocmVhZE1lc3NhCiB7CiAgICAgYXV0byByZWNlaXZlUXVldWUg PSBtYWtlVW5pcXVlPFRocmVhZE1lc3NhZ2VSZWNlaXZlclF1ZXVlPigqcmVjZWl2ZXIpOwogICAg IExvY2tlciBpbmNvbWluZ01lc3NhZ2VzTG9ja2VyIHsgbV9pbmNvbWluZ01lc3NhZ2VzTG9jayB9 OwotICAgIGVucXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlKCpyZWNl aXZlUXVldWUsIHJlY2VpdmVyTmFtZSwgZGVzdGluYXRpb25JRCk7CisgICAgZW5xdWV1ZU1hdGNo aW5nTWVzc2FnZXNUb01lc3NhZ2VSZWNlaXZlUXVldWUoKnJlY2VpdmVRdWV1ZSwgbV9pbmNvbWlu Z01lc3NhZ2VzLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9uSUQpOwogICAgIG1fcmVjZWl2ZVF1 ZXVlcy5hZGQoV1RGTW92ZShyZWNlaXZlUXVldWUpLCByZWNlaXZlck5hbWUsIGRlc3RpbmF0aW9u SUQpOwogfQogCkBAIC03NjksNiArNzY5LDE0IEBAIHZvaWQgQ29ubmVjdGlvbjo6cHJvY2Vzc0lu Y29taW5nTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4gbWVzc2FnZSkKICAgICAgICAg cmV0dXJuOwogICAgIH0KIAorICAgIGlmIChpc1N0cmVhbU1lc3NhZ2VSZWNlaXZlcihtZXNzYWdl LT5tZXNzYWdlUmVjZWl2ZXJOYW1lKCkpKSB7CisgICAgICAgIC8vIFdlIG1pZ2h0IGhhdmUgcmVj ZWl2ZWQgdGhpcyBtZXNzYWdlIG9uIHRoZSBJUEMgdGhyZWFkIGJlZm9yZSB0aGUgc3RyZWFtIGRl c3RpbmF0aW9uIGhhcyBhZGRlZCBpdHNlbGYgYXMKKyAgICAgICAgLy8gYSByZWNlaXZlIHF1ZXVl IG9uIHRoZSBjb25uZWN0aW9uOyBpbiB0aGlzIGNhc2UsIGFwcGVuZCB0aGUgbWVzc2FnZSB0byB0 aGUgaW5jb21pbmcgbWVzc2FnZSBxdWV1ZTsgd2hlbgorICAgICAgICAvLyB0aGUgcmVjZWl2ZSBx dWV1ZSBpcyBhZGRlZCwgd2UnbGwgdGFrZSB0aGlzIHF1ZXVlZCBtZXNzYWdlIGFuZCBhcHBlbmQg aXQgdG8gdGhlIHJlY2VpdmUgcXVldWUuCisgICAgICAgIG1faW5jb21pbmdSZWNlaXZlUXVldWVN ZXNzYWdlcy5hcHBlbmQoV1RGTW92ZShtZXNzYWdlKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKICAgICBpZiAobWVzc2FnZS0+aXNTeW5jTWVzc2FnZSgpKSB7CiAgICAgICAgIExvY2tlciBs b2NrZXIgeyBtX2luY29taW5nU3luY01lc3NhZ2VDYWxsYmFja0xvY2sgfTsKIApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oIGIvU291cmNlL1dlYktp dC9QbGF0Zm9ybS9JUEMvQ29ubmVjdGlvbi5oCmluZGV4IDIyMGU1ZWFiY2M0MDk5NjhlZjdiZmYw MDllYzc2MjgyNWMzZTBjNTUuLjc5OGViYTRiMjczODhlZjRhNWY3MTU2ZTZmNTg5NGM3NmUxZTJm NzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nvbm5lY3Rpb24uaAor KysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmgKQEAgLTM0Myw3ICsz NDMsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgcG9wUGVuZGluZ1N5bmNSZXF1ZXN0SUQoU3luY1Jl cXVlc3RJRCk7CiAgICAgc3RkOjp1bmlxdWVfcHRyPERlY29kZXI+IHdhaXRGb3JTeW5jUmVwbHko U3luY1JlcXVlc3RJRCwgTWVzc2FnZU5hbWUsIFRpbWVvdXQsIE9wdGlvblNldDxTZW5kU3luY09w dGlvbj4pOwogCi0gICAgdm9pZCBlbnF1ZXVlTWF0Y2hpbmdNZXNzYWdlc1RvTWVzc2FnZVJlY2Vp dmVRdWV1ZShNZXNzYWdlUmVjZWl2ZVF1ZXVlJiwgUmVjZWl2ZXJOYW1lLCB1aW50NjRfdCBkZXN0 aW5hdGlvbklEKSBXVEZfUkVRVUlSRVNfTE9DSyhtX2luY29taW5nTWVzc2FnZXNMb2NrKTsKKyAg ICB2b2lkIGVucXVldWVNYXRjaGluZ01lc3NhZ2VzVG9NZXNzYWdlUmVjZWl2ZVF1ZXVlKE1lc3Nh Z2VSZWNlaXZlUXVldWUmLCBEZXF1ZTxzdGQ6OnVuaXF1ZV9wdHI8RGVjb2Rlcj4+JiwgUmVjZWl2 ZXJOYW1lLCB1aW50NjRfdCBkZXN0aW5hdGlvbklEKSBXVEZfUkVRVUlSRVNfTE9DSyhtX2luY29t aW5nTWVzc2FnZXNMb2NrKTsKIAogICAgIC8vIENhbGxlZCBvbiB0aGUgY29ubmVjdGlvbiB3b3Jr IHF1ZXVlLgogICAgIHZvaWQgcHJvY2Vzc0luY29taW5nTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8 RGVjb2Rlcj4pOwpAQCAtNDE3LDYgKzQxNyw3IEBAIHByaXZhdGU6CiAgICAgLy8gSW5jb21pbmcg bWVzc2FnZXMuCiAgICAgTG9jayBtX2luY29taW5nTWVzc2FnZXNMb2NrOwogICAgIERlcXVlPHN0 ZDo6dW5pcXVlX3B0cjxEZWNvZGVyPj4gbV9pbmNvbWluZ01lc3NhZ2VzIFdURl9HVUFSREVEX0JZ X0xPQ0sobV9pbmNvbWluZ01lc3NhZ2VzTG9jayk7CisgICAgRGVxdWU8c3RkOjp1bmlxdWVfcHRy PERlY29kZXI+PiBtX2luY29taW5nUmVjZWl2ZVF1ZXVlTWVzc2FnZXMgV1RGX0dVQVJERURfQllf TE9DSyhtX2luY29taW5nTWVzc2FnZXNMb2NrKTsKICAgICBzdGQ6OnVuaXF1ZV9wdHI8TWVzc2Fn ZXNUaHJvdHRsZXI+IG1faW5jb21pbmdNZXNzYWdlc1Rocm90dGxlcjsKICAgICBNZXNzYWdlUmVj ZWl2ZVF1ZXVlTWFwIG1fcmVjZWl2ZVF1ZXVlcyBXVEZfR1VBUkRFRF9CWV9MT0NLKG1faW5jb21p bmdNZXNzYWdlc0xvY2spOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NjcmlwdHMvd2Vi a2l0L21lc3NhZ2VzLnB5IGIvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC9tZXNzYWdlcy5w eQppbmRleCA2NTg0ZDFhZDdlMTU0ZWIwOTIwMjMxMGRkZmE2YjVlMTIxYWQyYzM5Li5mN2NjZGM4 YzY3ZDJiYTJjM2RlZjhkYTJlYzJkZTRiZjhhNTI2MGJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L1NjcmlwdHMvd2Via2l0L21lc3NhZ2VzLnB5CisrKyBiL1NvdXJjZS9XZWJLaXQvU2NyaXB0 cy93ZWJraXQvbWVzc2FnZXMucHkKQEAgLTEwOTMsNiArMTA5MywxOCBAQCBkZWYgZ2VuZXJhdGVf bWVzc2FnZV9uYW1lc19oZWFkZXIocmVjZWl2ZXJzKToKICAgICAgICAgcmVzdWx0LmFwcGVuZCgn ICAgIHJldHVybiBmYWxzZTtcbicpCiAgICAgcmVzdWx0LmFwcGVuZCgnfVxuJykKICAgICByZXN1 bHQuYXBwZW5kKCdcbicpCisgICAgcmVzdWx0LmFwcGVuZCgnY29uc3RleHByIGJvb2wgaXNTdHJl YW1NZXNzYWdlUmVjZWl2ZXIoUmVjZWl2ZXJOYW1lIG5hbWUpXG4nKQorICAgIHJlc3VsdC5hcHBl bmQoJ3tcbicpCisgICAgcmVzdWx0LmFwcGVuZCgnICAgIHN3aXRjaCAobmFtZSkge1xuJykKKyAg ICBmb3IgbmFtZSBpbiBbcmVjZWl2ZXIubmFtZSBmb3IgcmVjZWl2ZXIgaW4gcmVjZWl2ZXJzIGlm IHJlY2VpdmVyLmhhc19hdHRyaWJ1dGUoU1RSRUFNX0FUVFJJQlVURSldOgorICAgICAgICByZXN1 bHQuYXBwZW5kKCcgICAgY2FzZSBSZWNlaXZlck5hbWU6OiVzOlxuJyAlIG5hbWUpCisgICAgcmVz dWx0LmFwcGVuZCgnICAgICAgICByZXR1cm4gdHJ1ZTtcbicpCisgICAgcmVzdWx0LmFwcGVuZCgn ICAgIGRlZmF1bHQ6XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICAgICAgYnJlYWs7XG4nKQor ICAgIHJlc3VsdC5hcHBlbmQoJyAgICB9XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJyAgICByZXR1 cm4gZmFsc2U7XG4nKQorICAgIHJlc3VsdC5hcHBlbmQoJ31cbicpCisgICAgcmVzdWx0LmFwcGVu ZCgnXG4nKQogICAgIHJlc3VsdC5hcHBlbmQoJ30gLy8gbmFtZXNwYWNlIElQQ1xuJykKICAgICBy ZXN1bHQuYXBwZW5kKCdcbicpCiAgICAgcmVzdWx0LmFwcGVuZCgnbmFtZXNwYWNlIFdURiB7XG4n KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TY3JpcHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdl TmFtZXMuaCBiL1NvdXJjZS9XZWJLaXQvU2NyaXB0cy93ZWJraXQvdGVzdHMvTWVzc2FnZU5hbWVz LmgKaW5kZXggMmVmZDVlMDQ5MGYxMDZhYzA2YWYxZTljMjRhZmU3NDYwMTUxNzkzNi4uZGI0MTc4 MTAzODJjMzIyYmE2OThhZjJhMDg2N2YyNGUyZmY5NmFhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9TY3JpcHRzL3dlYmtpdC90ZXN0cy9NZXNzYWdlTmFtZXMuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L1NjcmlwdHMvd2Via2l0L3Rlc3RzL01lc3NhZ2VOYW1lcy5oCkBAIC0xMjksNiArMTI5LDE3 IEBAIGNvbnN0ZXhwciBib29sIG1lc3NhZ2VJc1N5bmMoTWVzc2FnZU5hbWUgbmFtZSkKICAgICBy ZXR1cm4gbmFtZSA+PSBNZXNzYWdlTmFtZTo6VGVzdFdpdGhMZWdhY3lSZWNlaXZlcl9HZXRQbHVn aW5Qcm9jZXNzQ29ubmVjdGlvbjsKIH0KIAorY29uc3RleHByIGJvb2wgaXNTdHJlYW1NZXNzYWdl UmVjZWl2ZXIoUmVjZWl2ZXJOYW1lIG5hbWUpCit7CisgICAgc3dpdGNoIChuYW1lKSB7CisgICAg Y2FzZSBSZWNlaXZlck5hbWU6OlRlc3RXaXRoU3RyZWFtOgorICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICBkZWZhdWx0OgorICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIGZhbHNlOwor fQorCiB9IC8vIG5hbWVzcGFjZSBJUEMKIAogbmFtZXNwYWNlIFdURiB7CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggNjcyYjA0 ZjYzM2VkN2RiOTg2ZGNmODcwZmQ4ZjI5ODUyZTM2MTc0Ny4uYzllNzkwYmY1NDA5OTNhNzFkMmJj NTUyZTExNTQ5ZGE4MThjYTgzYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisr KyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTEwLTE5ICBX ZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFJFR1JFU1NJ T04gKHIyODQwNzkpOiBmYXN0L2NhbnZhcy9ncmFkaWVudC13aXRoLWNsaXAuaHRtbCBhbmQgZmFz dC9jYW52YXMvZ3JhZGllbnQtdGV4dC13aXRoLXNoYWRvdy5odG1sIGFyZSBmbGFreSBmYWlsdXJl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMxNjgx CisgICAgICAgIHJkYXI6Ly84NDIwMjQ3OAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFJlbW92ZSB0aGUgZmxha3kgZmFpbHVyZSBlbnRyaWVzIGluIHRl c3QgZXhwZWN0YXRpb25zLiBTZWUgV2ViS2l0MiBDaGFuZ2VMb2cgZm9yIG1vcmUgZGV0YWlscy4K KworICAgICAgICAqIHBsYXRmb3JtL2lvcy13azIvVGVzdEV4cGVjdGF0aW9uczoKKyAgICAgICAg KiBwbGF0Zm9ybS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlvbnM6CisKIDIwMjEtMTAtMTkgIFJvYiBC dWlzICA8cmJ1aXNAaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnNraXAgcGFzc2luZyBmbGV4LWJh c2lzOiBjb250ZW50ICsgYXNwZWN0IHJhdGlvIFdQVCB0ZXN0cwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vaW9zLXdrMi9UZXN0RXhwZWN0YXRpb25zCmluZGV4IDEzZjRlYzBjOWMzNWI4NTI0YWJk N2U4OWRmZDE1MzhhODBhOWJjZmUuLjZjNWMyYjIzY2QwOTNjMzY2ZmE5YjI0NTM2Y2RmN2MxOWI3 ZGM0YTIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy13azIvVGVzdEV4cGVj dGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL1Rlc3RFeHBlY3RhdGlv bnMKQEAgLTIwMzIsOSArMjAzMiw2IEBAIHdlYmtpdC5vcmcvYi8yMTk0MzggWyBSZWxlYXNlIF0g ZmFzdC9jYW52YXMvY2FudmFzLW92ZXJmbG93LWhpZGRlbi1hbmltYXRpb24uaHRtCiAKIHdlYmtp dC5vcmcvYi8yMzA0MTMgWyBEZWJ1ZyBdIGZhc3QvY2FudmFzL2NhbnZhcy1kcmF3SW1hZ2UtZGV0 YWNoZWQtbGVhay5odG1sIFsgUGFzcyBGYWlsdXJlIF0KIAotd2Via2l0Lm9yZy9iLzIzMTY4MSBb IFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9ncmFkaWVudC10ZXh0LXdpdGgtc2hhZG93Lmh0bWwgWyBQ YXNzIEZhaWx1cmUgXQotd2Via2l0Lm9yZy9iLzIzMTY4MSBbIFJlbGVhc2UgXSBmYXN0L2NhbnZh cy9ncmFkaWVudC13aXRoLWNsaXAuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCi0KIHdlYmFuaW1hdGlv bnMvbXVsdGlwbGUtdHJhbnNmb3JtLXByb3BlcnRpZXMtYW5kLW11bHRpcGxlLXRyYW5zZm9ybS1w cm9wZXJ0aWVzLWFuaW1hdGlvbi13aXRoLWRlbGF5LW9uLWZvcmNlZC1sYXllci5odG1sIFsgUGFz cyBdCiB3ZWJhbmltYXRpb25zL3JvdGF0ZS1wcm9wZXJ0eS1hbmQtcm90YXRlLWFuaW1hdGlvbi13 aXRoLWRlbGF5LW9uLWZvcmNlZC1sYXllci5odG1sIFsgUGFzcyBdCiB3ZWJhbmltYXRpb25zL3Nj YWxlLXByb3BlcnR5LWFuZC1zY2FsZS1hbmltYXRpb24td2l0aC1kZWxheS1vbi1mb3JjZWQtbGF5 ZXIuaHRtbCBbIFBhc3MgXQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdr Mi9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhw ZWN0YXRpb25zCmluZGV4IDQ0OGNiZGJlNzExNDQ4NTVmOTEwNzNmZWQ3Mzg4NzI2ZDY5NTZjYzQu LjdhZGQ2OTMxOTBhY2RmMjFjMDQ0M2Q5YjJmMmRiMGFmNzg0YjE1MzEgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMtd2syL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTE1MDgsOSArMTUwOCw2 IEBAIHdlYmtpdC5vcmcvYi8yMjc4MDUgWyBEZWJ1ZyBdIGZhc3QvY2FudmFzL2NhbnZhcy1jb21w b3NpdGUtaW1hZ2UuaHRtbCBbIFBhc3MgQ3JhCiB3ZWJraXQub3JnL2IvMjMwMzY2IFsgUmVsZWFz ZSBdIGZhc3QvY2FudmFzL2NhbnZhcy1ibGVuZGluZy10ZXh0Lmh0bWwgWyBQYXNzIEZhaWx1cmUg Q3Jhc2ggXQogd2Via2l0Lm9yZy9iLzIzMDM2NiBbIFJlbGVhc2UgXSBmYXN0L2NhbnZhcy9jYW52 YXMtY29tcG9zaXRlLXRleHQtYWxwaGEuaHRtbCBbIFBhc3MgRmFpbHVyZSBdCiAKLXdlYmtpdC5v cmcvYi8yMzE2ODEgWyBSZWxlYXNlIF0gZmFzdC9jYW52YXMvZ3JhZGllbnQtdGV4dC13aXRoLXNo YWRvdy5odG1sIFsgUGFzcyBGYWlsdXJlIF0KLXdlYmtpdC5vcmcvYi8yMzE2ODEgWyBSZWxlYXNl IF0gZmFzdC9jYW52YXMvZ3JhZGllbnQtd2l0aC1jbGlwLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQot CiB3ZWJraXQub3JnL2IvMjMwNDEzIGZhc3QvY2FudmFzL2NhbnZhcy1kcmF3SW1hZ2UtZGV0YWNo ZWQtbGVhay5odG1sIFsgUGFzcyBGYWlsdXJlIF0KIAogd2Via2l0Lm9yZy9iLzIyNjgyOCBbIEJp Z1N1cisgXSBtZWRpYS9tb2Rlcm4tbWVkaWEtY29udHJvbHMvb3ZlcmZsb3ctc3VwcG9ydC9jaGFw dGVycy5odG1sIFsgUGFzcyBGYWlsdXJlIFRpbWVvdXQgXQo=