227552 2021-06-30 15:49:12 -0700 Take a process assertion in the network process when holding locked files 2021-07-02 16:06:20 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=225324 https://bugs.webkit.org/show_bug.cgi?id=215239 https://bugs.webkit.org/show_bug.cgi?id=227632 InRadar P2 Normal --- 1 cdumez cdumez ggaren kkinnunen sihui_liu webkit-bug-importer oldest_to_newest 1773915 0 cdumez 2021-06-30 15:49:12 -0700 Take a process assertion in the network process when holding locked files. Previously, we'd send an IPC to the UIProcess and the UIProcess would take the assertion on behalf of the network process. However, our previous approach was racy and could cause the network process to get suspended while still holding locked files (which would get it killed). 1773921 1 432637 cdumez 2021-06-30 16:01:35 -0700 Created attachment 432637 Patch 1773946 2 432645 cdumez 2021-06-30 16:56:32 -0700 Created attachment 432645 Patch 1774131 3 432700 cdumez 2021-07-01 08:49:21 -0700 Created attachment 432700 Patch 1774150 4 432705 cdumez 2021-07-01 10:13:47 -0700 Created attachment 432705 Patch 1774476 5 432705 sihui_liu 2021-07-02 08:27:19 -0700 Comment on attachment 432705 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=432705&action=review > Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) 1774480 6 432705 cdumez 2021-07-02 08:36:07 -0700 Comment on attachment 432705 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=432705&action=review >> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 >> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > Does UI process always send prepareToSuspend before marking network process suspendible? Yes. 1774486 7 cdumez 2021-07-02 08:51:19 -0700 Seems we may want to revert Bug 215239 afterwards? 1774491 8 432705 sihui_liu 2021-07-02 10:09:43 -0700 Comment on attachment 432705 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=432705&action=review >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); >> >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). My understanding is prepareToSuspend means the process should be safe to suspend afterwards, so we make sure no SQLite activities after this by suspending storage threads (no new activity can start) and aborting ongoing transactions (no old activity can continue). With current patch, I think our behavior is: network process's database activities gets aborted whenever UI process thinks it can be suspended (prepareToSuspend). Since UI process does not know about the database state in network process now, it decides the suspended state by other network process's activities that requires assertion. Then why do we acquire assertion for all database activities in network process? If we want make sure it has enough time to abort, shouldn't we only acquire assertion in NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? 1774492 9 sihui_liu 2021-07-02 10:20:57 -0700 (In reply to Chris Dumez from comment #7) > Seems we may want to revert Bug 215239 afterwards? Why? It seems imminent or not, UI process can drop the assertion of network process. Then assertion in network process can expire/time out after that, and there's no guarantee IDB will finish in timeout (and we don't have invalidation handler here). 1774493 10 cdumez 2021-07-02 10:22:55 -0700 (In reply to Sihui Liu from comment #8) > Comment on attachment 432705 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > >> > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > My understanding is prepareToSuspend means the process should be safe to > suspend afterwards, so we make sure no SQLite activities after this by > suspending storage threads (no new activity can start) and aborting ongoing > transactions (no old activity can continue). > > With current patch, I think our behavior is: network process's database > activities gets aborted whenever UI process thinks it can be suspended > (prepareToSuspend). Since UI process does not know about the database state > in network process now, it decides the suspended state by other network > process's activities that requires assertion. Then why do we acquire > assertion for all database activities in network process? If we want make > sure it has enough time to abort, shouldn't we only acquire assertion in > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? With your alternative proposal, there is no guarantee the network process will receive the PrepareToSuspend before suspension, especially in the imminent suspension case. In the imminent suspension case, the UIProcess will get suspended almost immediately. It does its best to send out an imminent suspension IPC to its child processes before getting suspended but at this point RunningBoard is not giving us a choice and the UIProcess might get suspended before it has a chance to send out the PrepareToSuspend IPC. There is also a chance the child process gets suspended before it has a chance to process the PrepareToSuspend IPC. Note that this is exactly the issue we see in the logs and this is exactly WHY I am proposing this change. 1774494 11 cdumez 2021-07-02 10:24:17 -0700 (In reply to Sihui Liu from comment #9) > (In reply to Chris Dumez from comment #7) > > Seems we may want to revert Bug 215239 afterwards? > > Why? It seems imminent or not, UI process can drop the assertion of network > process. Then assertion in network process can expire/time out after that, > and there's no guarantee IDB will finish in timeout (and we don't have > invalidation handler here). I meant reverting Bug 215239 and adding an invalidation handler for the new database activity assertion to abort transactions. 1774500 12 sihui_liu 2021-07-02 10:53:49 -0700 (In reply to Chris Dumez from comment #10) > (In reply to Sihui Liu from comment #8) > > Comment on attachment 432705 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > >> > > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > > > My understanding is prepareToSuspend means the process should be safe to > > suspend afterwards, so we make sure no SQLite activities after this by > > suspending storage threads (no new activity can start) and aborting ongoing > > transactions (no old activity can continue). > > > > With current patch, I think our behavior is: network process's database > > activities gets aborted whenever UI process thinks it can be suspended > > (prepareToSuspend). Since UI process does not know about the database state > > in network process now, it decides the suspended state by other network > > process's activities that requires assertion. Then why do we acquire > > assertion for all database activities in network process? If we want make > > sure it has enough time to abort, shouldn't we only acquire assertion in > > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? > > With your alternative proposal, there is no guarantee the network process > will receive the PrepareToSuspend before suspension, especially in the > imminent suspension case. In the imminent suspension case, the UIProcess > will get suspended almost immediately. It does its best to send out an > imminent suspension IPC to its child processes before getting suspended but > at this point RunningBoard is not giving us a choice and the UIProcess might > get suspended before it has a chance to send out the PrepareToSuspend IPC. > There is also a chance the child process gets suspended before it has a > chance to process the PrepareToSuspend IPC. > > Note that this is exactly the issue we see in the logs and this is exactly > WHY I am proposing this change. I see, so the purpose of assertion in network process is to make sure process is not suspended before receiving prepareToSuspend message. That makes sense. Have you manually tested the change? I notice a thing that may make this patch not work as expected. If network process acquires the assertion on first transaction, get a prepareToSuspend, get a processDidResume, start a new transaction and new assertion may not be acquired, if the first transaction is not aborted or committed (e.g. LocalStorage commits transaction after some duration)? 1774504 13 cdumez 2021-07-02 10:58:30 -0700 (In reply to Sihui Liu from comment #12) > (In reply to Chris Dumez from comment #10) > > (In reply to Sihui Liu from comment #8) > > > Comment on attachment 432705 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > > > > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > > > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > > >> > > > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > > > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > > > > > My understanding is prepareToSuspend means the process should be safe to > > > suspend afterwards, so we make sure no SQLite activities after this by > > > suspending storage threads (no new activity can start) and aborting ongoing > > > transactions (no old activity can continue). > > > > > > With current patch, I think our behavior is: network process's database > > > activities gets aborted whenever UI process thinks it can be suspended > > > (prepareToSuspend). Since UI process does not know about the database state > > > in network process now, it decides the suspended state by other network > > > process's activities that requires assertion. Then why do we acquire > > > assertion for all database activities in network process? If we want make > > > sure it has enough time to abort, shouldn't we only acquire assertion in > > > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? > > > > With your alternative proposal, there is no guarantee the network process > > will receive the PrepareToSuspend before suspension, especially in the > > imminent suspension case. In the imminent suspension case, the UIProcess > > will get suspended almost immediately. It does its best to send out an > > imminent suspension IPC to its child processes before getting suspended but > > at this point RunningBoard is not giving us a choice and the UIProcess might > > get suspended before it has a chance to send out the PrepareToSuspend IPC. > > There is also a chance the child process gets suspended before it has a > > chance to process the PrepareToSuspend IPC. > > > > Note that this is exactly the issue we see in the logs and this is exactly > > WHY I am proposing this change. > > I see, so the purpose of assertion in network process is to make sure > process is not suspended before receiving prepareToSuspend message. That > makes sense. > > Have you manually tested the change? Of course. > > I notice a thing that may make this patch not work as expected. If network > process acquires the assertion on first transaction, get a prepareToSuspend, > get a processDidResume, start a new transaction and new assertion may not be > acquired, if the first transaction is not aborted or committed (e.g. > LocalStorage commits transaction after some duration)? Could you elaborate on this? I don't think I understand. In my patch, we always take an assertion when a transaction starts (unless we already hold a valid assertion), as far as I can tell. 1774506 14 sihui_liu 2021-07-02 11:07:41 -0700 (In reply to Chris Dumez from comment #13) > (In reply to Sihui Liu from comment #12) > > (In reply to Chris Dumez from comment #10) > > > (In reply to Sihui Liu from comment #8) > > > > Comment on attachment 432705 [details] > > > > Patch > > > > > > > > View in context: > > > > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > > > > > > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > > > > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > > > >> > > > > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > > > > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > > > > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > > > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > > > > > > > My understanding is prepareToSuspend means the process should be safe to > > > > suspend afterwards, so we make sure no SQLite activities after this by > > > > suspending storage threads (no new activity can start) and aborting ongoing > > > > transactions (no old activity can continue). > > > > > > > > With current patch, I think our behavior is: network process's database > > > > activities gets aborted whenever UI process thinks it can be suspended > > > > (prepareToSuspend). Since UI process does not know about the database state > > > > in network process now, it decides the suspended state by other network > > > > process's activities that requires assertion. Then why do we acquire > > > > assertion for all database activities in network process? If we want make > > > > sure it has enough time to abort, shouldn't we only acquire assertion in > > > > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? > > > > > > With your alternative proposal, there is no guarantee the network process > > > will receive the PrepareToSuspend before suspension, especially in the > > > imminent suspension case. In the imminent suspension case, the UIProcess > > > will get suspended almost immediately. It does its best to send out an > > > imminent suspension IPC to its child processes before getting suspended but > > > at this point RunningBoard is not giving us a choice and the UIProcess might > > > get suspended before it has a chance to send out the PrepareToSuspend IPC. > > > There is also a chance the child process gets suspended before it has a > > > chance to process the PrepareToSuspend IPC. > > > > > > Note that this is exactly the issue we see in the logs and this is exactly > > > WHY I am proposing this change. > > > > I see, so the purpose of assertion in network process is to make sure > > process is not suspended before receiving prepareToSuspend message. That > > makes sense. > > > > Have you manually tested the change? > > Of course. > > > > > I notice a thing that may make this patch not work as expected. If network > > process acquires the assertion on first transaction, get a prepareToSuspend, > > get a processDidResume, start a new transaction and new assertion may not be > > acquired, if the first transaction is not aborted or committed (e.g. > > LocalStorage commits transaction after some duration)? > > Could you elaborate on this? I don't think I understand. In my patch, we > always take an assertion when a transaction starts (unless we already hold a > valid assertion), as far as I can tell. Let's say a LocalStorage transaction begin() (schedule a 500ms task to commit), transaction count is 1 and assertion is acquired. Network process receives prepareToSuspend, hangs the storage thread, After a long time, Network process receives processDidResume. (assertion is already timed out) IDB thread begin() a new transaction, transaction count is 2. No assertion at this point. Then LocalStorage transaction commit(), transaction count is 1. No assertion at this point. So prepareToSuspend may still be not received? 1774508 15 cdumez 2021-07-02 11:30:30 -0700 (In reply to Sihui Liu from comment #14) > (In reply to Chris Dumez from comment #13) > > (In reply to Sihui Liu from comment #12) > > > (In reply to Chris Dumez from comment #10) > > > > (In reply to Sihui Liu from comment #8) > > > > > Comment on attachment 432705 [details] > > > > > Patch > > > > > > > > > > View in context: > > > > > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > > > > > > > > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > > > > > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > > > > >> > > > > > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > > > > > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > > > > > > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > > > > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > > > > > > > > > My understanding is prepareToSuspend means the process should be safe to > > > > > suspend afterwards, so we make sure no SQLite activities after this by > > > > > suspending storage threads (no new activity can start) and aborting ongoing > > > > > transactions (no old activity can continue). > > > > > > > > > > With current patch, I think our behavior is: network process's database > > > > > activities gets aborted whenever UI process thinks it can be suspended > > > > > (prepareToSuspend). Since UI process does not know about the database state > > > > > in network process now, it decides the suspended state by other network > > > > > process's activities that requires assertion. Then why do we acquire > > > > > assertion for all database activities in network process? If we want make > > > > > sure it has enough time to abort, shouldn't we only acquire assertion in > > > > > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? > > > > > > > > With your alternative proposal, there is no guarantee the network process > > > > will receive the PrepareToSuspend before suspension, especially in the > > > > imminent suspension case. In the imminent suspension case, the UIProcess > > > > will get suspended almost immediately. It does its best to send out an > > > > imminent suspension IPC to its child processes before getting suspended but > > > > at this point RunningBoard is not giving us a choice and the UIProcess might > > > > get suspended before it has a chance to send out the PrepareToSuspend IPC. > > > > There is also a chance the child process gets suspended before it has a > > > > chance to process the PrepareToSuspend IPC. > > > > > > > > Note that this is exactly the issue we see in the logs and this is exactly > > > > WHY I am proposing this change. > > > > > > I see, so the purpose of assertion in network process is to make sure > > > process is not suspended before receiving prepareToSuspend message. That > > > makes sense. > > > > > > Have you manually tested the change? > > > > Of course. > > > > > > > > I notice a thing that may make this patch not work as expected. If network > > > process acquires the assertion on first transaction, get a prepareToSuspend, > > > get a processDidResume, start a new transaction and new assertion may not be > > > acquired, if the first transaction is not aborted or committed (e.g. > > > LocalStorage commits transaction after some duration)? > > > > Could you elaborate on this? I don't think I understand. In my patch, we > > always take an assertion when a transaction starts (unless we already hold a > > valid assertion), as far as I can tell. > > Let's say a LocalStorage transaction begin() (schedule a 500ms task to > commit), transaction count is 1 and assertion is acquired. > Network process receives prepareToSuspend, hangs the storage thread, > After a long time, Network process receives processDidResume. (assertion is > already timed out) > IDB thread begin() a new transaction, transaction count is 2. No assertion > at this point. > Then LocalStorage transaction commit(), transaction count is 1. No assertion > at this point. > So prepareToSuspend may still be not received? Oh, I understand now. Thanks for explaining. I agree this is a problem. However, this is a problem right now without my change. PrepareToSuspend() should really cause the LocalStorageDatabase to commit its transaction *before* it suspends the storage thread. Suspending the thread (when there is a scheduled task to commit a transaction) actually prevents the transaction from getting committed and guarantees the process will suspend with a locked file. I can look into fixing this one separately as this doesn't really have much to do with this patch. 1774514 16 cdumez 2021-07-02 11:36:55 -0700 (In reply to Chris Dumez from comment #15) > (In reply to Sihui Liu from comment #14) > > (In reply to Chris Dumez from comment #13) > > > (In reply to Sihui Liu from comment #12) > > > > (In reply to Chris Dumez from comment #10) > > > > > (In reply to Sihui Liu from comment #8) > > > > > > Comment on attachment 432705 [details] > > > > > > Patch > > > > > > > > > > > > View in context: > > > > > > https://bugs.webkit.org/attachment.cgi?id=432705&action=review > > > > > > > > > > > > >>> Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm:112 > > > > > > >>> + m_holdingLockedFileAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskUninterruptable); > > > > > > >> > > > > > > >> Do we want to set invalidation handler to abort transactions, instead of doing it in NetworkProcess::prepareToSuspend? Since prepareToSuspend may be sent more often now > > > > > > >> Does UI process always send prepareToSuspend before marking network process suspendible? (Is it possible network process starts transaction and acquires assertion after UI process acquires suspended assertion for network process?) > > > > > > > > > > > > > > AS I mentioned to you offline, I think NetworkProcess::prepareToSuspend should suspend the storage threads, not abort the transactions, at least in the non-imminent suspension case. > > > > > > > We could indeed add a invalidation handler here to abort transactions. Maybe you can do this in a follow-up since you are more familiar with that? Similarly, I was hoping you could make the changes to prepareToSuspend (to not abort transactions so eagerly). > > > > > > > > > > > > My understanding is prepareToSuspend means the process should be safe to > > > > > > suspend afterwards, so we make sure no SQLite activities after this by > > > > > > suspending storage threads (no new activity can start) and aborting ongoing > > > > > > transactions (no old activity can continue). > > > > > > > > > > > > With current patch, I think our behavior is: network process's database > > > > > > activities gets aborted whenever UI process thinks it can be suspended > > > > > > (prepareToSuspend). Since UI process does not know about the database state > > > > > > in network process now, it decides the suspended state by other network > > > > > > process's activities that requires assertion. Then why do we acquire > > > > > > assertion for all database activities in network process? If we want make > > > > > > sure it has enough time to abort, shouldn't we only acquire assertion in > > > > > > NetworkProcess::prepareToSuspend and release it in ~CallbackAggregator? > > > > > > > > > > With your alternative proposal, there is no guarantee the network process > > > > > will receive the PrepareToSuspend before suspension, especially in the > > > > > imminent suspension case. In the imminent suspension case, the UIProcess > > > > > will get suspended almost immediately. It does its best to send out an > > > > > imminent suspension IPC to its child processes before getting suspended but > > > > > at this point RunningBoard is not giving us a choice and the UIProcess might > > > > > get suspended before it has a chance to send out the PrepareToSuspend IPC. > > > > > There is also a chance the child process gets suspended before it has a > > > > > chance to process the PrepareToSuspend IPC. > > > > > > > > > > Note that this is exactly the issue we see in the logs and this is exactly > > > > > WHY I am proposing this change. > > > > > > > > I see, so the purpose of assertion in network process is to make sure > > > > process is not suspended before receiving prepareToSuspend message. That > > > > makes sense. > > > > > > > > Have you manually tested the change? > > > > > > Of course. > > > > > > > > > > > I notice a thing that may make this patch not work as expected. If network > > > > process acquires the assertion on first transaction, get a prepareToSuspend, > > > > get a processDidResume, start a new transaction and new assertion may not be > > > > acquired, if the first transaction is not aborted or committed (e.g. > > > > LocalStorage commits transaction after some duration)? > > > > > > Could you elaborate on this? I don't think I understand. In my patch, we > > > always take an assertion when a transaction starts (unless we already hold a > > > valid assertion), as far as I can tell. > > > > Let's say a LocalStorage transaction begin() (schedule a 500ms task to > > commit), transaction count is 1 and assertion is acquired. > > Network process receives prepareToSuspend, hangs the storage thread, > > After a long time, Network process receives processDidResume. (assertion is > > already timed out) > > IDB thread begin() a new transaction, transaction count is 2. No assertion > > at this point. > > Then LocalStorage transaction commit(), transaction count is 1. No assertion > > at this point. > > So prepareToSuspend may still be not received? > > Oh, I understand now. Thanks for explaining. I agree this is a problem. > However, this is a problem right now without my change. > > PrepareToSuspend() should really cause the LocalStorageDatabase to commit > its transaction *before* it suspends the storage thread. Suspending the > thread (when there is a scheduled task to commit a transaction) actually > prevents the transaction from getting committed and guarantees the process > will suspend with a locked file. > > I can look into fixing this one separately as this doesn't really have much > to do with this patch. I filed Bug 227632 and am working on a patch. 1774523 17 cdumez 2021-07-02 12:15:38 -0700 > I meant reverting Bug 215239 and adding an invalidation handler for the new > database activity assertion to abort transactions. @Sihui, do you think we should make this change in a follow-up? If you do, go you want to do it or should I? 1774549 18 ews-feeder 2021-07-02 13:35:12 -0700 Committed r279514 (239366@main): <https://commits.webkit.org/239366@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 432705. 1774551 19 webkit-bug-importer 2021-07-02 13:36:19 -0700 <rdar://problem/80100475> 1774565 20 sihui_liu 2021-07-02 14:13:19 -0700 (In reply to Chris Dumez from comment #17) > > I meant reverting Bug 215239 and adding an invalidation handler for the new > > database activity assertion to abort transactions. > > @Sihui, do you think we should make this change in a follow-up? > If you do, go you want to do it or should I? Yes, follow-up to not eagerly abort transactions on prepareToSuspend. This change I am not sure; seems better if we can do the same thing for all storage threads I will follow up. 1774581 21 cdumez 2021-07-02 14:31:08 -0700 (In reply to Sihui Liu from comment #20) > (In reply to Chris Dumez from comment #17) > > > I meant reverting Bug 215239 and adding an invalidation handler for the new > > > database activity assertion to abort transactions. > > > > @Sihui, do you think we should make this change in a follow-up? > > If you do, go you want to do it or should I? > > Yes, follow-up to not eagerly abort transactions on prepareToSuspend. This > change I am not sure; seems better if we can do the same thing for all > storage threads > > I will follow up. Ok, thanks. 1774611 22 cdumez 2021-07-02 16:06:20 -0700 Follow-up Catalyst build fix in <https://commits.webkit.org/r279523>. 432637 2021-06-30 16:01:35 -0700 2021-06-30 16:25:48 -0700 Patch bug-227552-20210630160134.patch text/plain 16881 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5NDI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGUxMjA5ZDNjYzBjNTlkZjg4 ZGIyOTE0YjZmMWJlM2FmYjMwZDBmNWUuLjcxNzRkOWNiYTFjNzc5Yjc3MjJiNjZjZTVhOTJjYzE5 NTQyMmVkNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMjEtMDYtMzAgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBUYWtlIGEgcHJvY2VzcyBhc3NlcnRp b24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZpbGVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjc1NTIKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYWtlIGEgcHJvY2Vz cyBhc3NlcnRpb24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZp bGVzLiBQcmV2aW91c2x5LCB3ZSdkCisgICAgICAgIHNlbmQgYW4gSVBDIHRvIHRoZSBVSVByb2Nl c3MgYW5kIHRoZSBVSVByb2Nlc3Mgd291bGQgdGFrZSB0aGUgYXNzZXJ0aW9uIG9uIGJlaGFsZiBv ZiB0aGUKKyAgICAgICAgbmV0d29yayBwcm9jZXNzLiBIb3dldmVyLCBvdXIgcHJldmlvdXMgYXBw cm9hY2ggd2FzIHJhY3kgYW5kIGNvdWxkIGNhdXNlIHRoZSBuZXR3b3JrIHByb2Nlc3MKKyAgICAg ICAgdG8gc3RpbGwgZ2V0IHN1c3BlbmRlZCB3aGlsZSBzdGlsbCBob2xkaW5nIGxvY2tlZCBmaWxl cyAod2hpY2ggd291bGQgZ2V0IGl0IGtpbGxlZCkuCisKKyAgICAgICAgV2UgaGF2ZSBldmlkZW5j ZSB0aGF0IHRoZSBuZXR3b3JrIHByb2Nlc3MgaXMgZ2V0dGluZyBraWxsZWQgYSBsb3QgZm9yIHRo aXMgcmVhc29uCisgICAgICAgIChyZGFyOi8vNzk3ODcxMjMpLgorCisgICAgICAgICogTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJv Y2Vzczo6TmV0d29ya1Byb2Nlc3MpOgorICAgICAgICBDYWxsIHNldElzSG9sZGluZ0xvY2tlZEZp bGVzKCkgd2hlbiB0aGUgImlzSG9sZGluZ0xvY2tlZEZpbGVzIiBzdGF0ZSBjaGFuZ2VzIGluc3Rl YWQgb2Ygc2VuZGluZworICAgICAgICBhbiBJUEMgdG8gdGhlIFVJUHJvY2Vzcy4gc2V0SXNIb2xk aW5nTG9ja2VkRmlsZXMoKSB0YWtlcyBjYXJlIG9mIHRha2luZyBvciByZWxlYXNpbmcgYQorICAg ICAgICBSdW5uaW5nQm9hcmQgYXNzZXJ0aW9uLgorCisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQ cm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKToKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nl c3M6OnJlc3VtZSk6CisgICAgICAgIFN0b3AgY2FsbGluZyBzZXRTdXNwZW5kZWQoKSBvbiB0aGUg V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLiBUaGUgcHVycG9zZSB3YXMgdG8gYXZvaWQgc2VuZGlu ZworICAgICAgICB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBDIHRvIHRoZSBVSVByb2Nl c3MgYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQcmVwYXJlVG9TdXNwZW5kIElQQy4KKyAgICAgICAgSG93 ZXZlciwgaXQgaXMgbm93IGFjY2VwdGFibGUgdG8gdGFrZSBhIHByb2Nlc3MgYXNzZXJ0aW9uIGFm dGVyIFByZXBhcmVUb1N1c3BlbmQgSVBDIGhhcyBiZWVuCisgICAgICAgIHJlY2VpdmVkLgorCisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaDoKKworICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbToKKyAgICAgICAgKFdlYktpdDo6 TmV0d29ya1Byb2Nlc3M6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgV2hlbiBz ZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyh0cnVlKSBnZXRzIGNhbGxlZCwgd2UgdGFrZSBhIHJ1bm5p bmdib2FyZCBhc3NlcnRpb24gdG8gcHJldmVudAorICAgICAgICBzdXNwZW5zaW9uLiBOb3RlIHRo YXQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSkgZ2V0cyBvbiB0aGUgc3RvcmFnZSB0aHJl YWQgKHdoaWNoIHN0YXJ0ZWQKKyAgICAgICAgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbikgc28gd2Ug dGFrZSB0aGUgYXNzZXJ0aW9uIHN5bmNocm9ub3VzbHkgdG8gbWFrZSBzdXJlIHdlIGNhbm5vdCBn ZXQKKyAgICAgICAgc3VzcGVuZGVkIGR1cmluZyBhIFNRTGl0ZSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgV2hlbiBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSkgZ2V0cyBjYWxsZWQsIHdlIHJl bGVhc2UgdGhlIHJ1bm5pbmdib2FyZCBhc3NlcnRpb24uCisKKyAgICAgICAgKiBTaGFyZWQvV2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0 YWJhc2VUcmFja2VyOjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgorICAgICAgICAoV2ViS2l0 OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldElzU3VzcGVuZGVk KToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp3aWxsQmVnaW5G aXJzdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFj a2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXI6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgKiBT aGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmg6CisgICAgICAgIFVwZGF0ZSBXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIgc28gdGhhdCBpdCBjYWxsZWQgaXRzIGlzSG9sZGluZ0xvY2tlZEZp bGVzSGFuZGxlciBsYW1iZGEKKyAgICAgICAgZGlyZWN0bHkgb24gdGhlIHN0b3JhZ2UgdGhyZWFk IHdoZW4gdGhlIGZpcnN0IHRyYW5zYWN0aW9uIHN0YXJ0cywgaW5zdGVhZCBvZiBkaXNwYXRjaGlu ZworICAgICAgICB0byB0aGUgbWFpbiB0aHJlYWQuIERpc3BhdGNoaW5nIHRvIHRoZSBtYWluIHRo cmVhZCB3b3VsZCBiZSByYWN5IGFzIGl0IHdvdWxkIG1lYW4gdGFraW5nCisgICAgICAgIHRoZSBw cm9jZXNzIGFzc2VydGlvbiBhc3luY2hyb25vdXNseSAob24gdGhlIG1haW4gdGhyZWFkKSwgYWZ0 ZXIgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbgorICAgICAgICBoYXMgYmVndW4gb24gdGhlIHN0b3Jh Z2UgdGhyZWFkLgorICAgICAgICBBcyBhIHJlc3VsdCwgb2YgdGhpcyBjaGFuZ2UsIEkgYW0gbm90 IHVzaW5nIHRoZSBIeXN0ZXJpc0FjdGl2aXR5IGNsYXNzIGFueW1vcmUgYW5kIHVzaW5nCisgICAg ICAgIG15IG93biB0aHJlYWQtc2FmZSBoeXN0ZXJlc2lzIGFjdGl2aXR5IHVzaW5nIFJ1bkxvb3A6 OmRpc3BhdGNoQWZ0ZXIoKSB3aXRoIGFuIGludGVnZXIKKyAgICAgICAgYW5kIGEgbG9jay4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpuZXR3b3JrUHJvY2Vzc0RpZFRlcm1p bmF0ZSk6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNz RGlkUmVzdW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5t ZXNzYWdlcy5pbjoKKyAgICAgICAgRHJvcCB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBD IGFuZCBpdHMgaGFuZGxpbmcgb24gVUlQcm9jZXNzIHNpZGUgc2luY2UgdGhlIG5ldHdvcmsKKyAg ICAgICAgcHJvY2VzcyBub3cgdGFrZXMgdGhlIGFzc2VydGlvbiBieSBpdHNlbGYuCisKIDIwMjEt MDYtMzAgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAgICAg W2lPU10gW0xpdmUgVGV4dF0gIlRleHQgZnJvbSBDYW1lcmEiIHNob3VsZCBub3QgYmUgc2hvd24g aW4gY2FsbG91dCBiYXIgd2hlbiBzZWxlY3RpbmcgdGV4dApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAgYi9Tb3VyY2UvV2ViS2l0L05l dHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcAppbmRleCA0OWJkZDNmZWM2ODEzN2NlNDM1 Mzk1MDAzNGFkYzZiMjc1MmFmOWU1Li5kZDQyZTIxNTU5MzMzZDMyNWI1YmQ0ZDI1YjBmZWE0MjM2 NjY1NGM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQ cm9jZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9j ZXNzLmNwcApAQCAtMTU5LDcgKzE1OSw3IEBAIE5ldHdvcmtQcm9jZXNzOjpOZXR3b3JrUHJvY2Vz cyhBdXhpbGlhcnlQcm9jZXNzSW5pdGlhbGl6YXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1lCiAgICAg LCBtX25ldHdvcmtDb250ZW50UnVsZUxpc3RNYW5hZ2VyKCp0aGlzKQogI2VuZGlmCiAjaWYgUExB VEZPUk0oSU9TX0ZBTUlMWSkKLSAgICAsIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyKFt0aGlz XShib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKSB7IHBhcmVudFByb2Nlc3NDb25uZWN0aW9uKCkt PnNlbmQoTWVzc2FnZXM6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OlNldElzSG9sZGluZ0xvY2tlZEZp bGVzKGlzSG9sZGluZ0xvY2tlZEZpbGVzKSwgMCk7IH0pCisgICAgLCBtX3dlYlNRTGl0ZURhdGFi YXNlVHJhY2tlcihbdGhpc10oYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykgeyBzZXRJc0hvbGRp bmdMb2NrZWRGaWxlcyhpc0hvbGRpbmdMb2NrZWRGaWxlcyk7IH0pCiAjZW5kaWYKICAgICAsIG1f bWVzc2FnZVBvcnRDaGFubmVsUmVnaXN0cnkoY3JlYXRlTWVzc2FnZVBvcnRDaGFubmVsUmVnaXN0 cnkoKnRoaXMpKQogewpAQCAtMjIxOSwxMCArMjIxOSw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3M6 OnByZXBhcmVUb1N1c3BlbmQoYm9vbCBpc1N1c3BlbnNpb25JbW1pbmVudCwgQ29tcGxldGlvbkhh bmRsCiAgICAgICAgIHNlcnZlci0+c3VzcGVuZCgpOwogI2VuZGlmCiAKLSNpZiBQTEFURk9STShJ T1NfRkFNSUxZKQotICAgIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLnNldElzU3VzcGVuZGVk KHRydWUpOwotI2VuZGlmCi0KICAgICBsb3dNZW1vcnlIYW5kbGVyKENyaXRpY2FsOjpZZXMpOwog CiAgICAgUmVmUHRyPENhbGxiYWNrQWdncmVnYXRvcj4gY2FsbGJhY2tBZ2dyZWdhdG9yID0gQ2Fs bGJhY2tBZ2dyZWdhdG9yOjpjcmVhdGUoW3RoaXMsIGNvbXBsZXRpb25IYW5kbGVyID0gV1RGTW92 ZShjb21wbGV0aW9uSGFuZGxlcildKCkgbXV0YWJsZSB7CkBAIC0yMjcwLDEwICsyMjY2LDYgQEAg dm9pZCBOZXR3b3JrUHJvY2Vzczo6cHJvY2Vzc0RpZFJlc3VtZSgpCiAKIHZvaWQgTmV0d29ya1By b2Nlc3M6OnJlc3VtZSgpCiB7Ci0jaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKLSAgICBtX3dlYlNR TGl0ZURhdGFiYXNlVHJhY2tlci5zZXRJc1N1c3BlbmRlZChmYWxzZSk7Ci0jZW5kaWYKLQogICAg IGZvciAoYXV0byYgY29ubmVjdGlvbiA6IG1fd2ViUHJvY2Vzc0Nvbm5lY3Rpb25zLnZhbHVlcygp KQogICAgICAgICBjb25uZWN0aW9uLT5lbmRTdXNwZW5zaW9uKCk7CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaCBiL1NvdXJjZS9XZWJL aXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaAppbmRleCA0NDc3ODRiMWE3ODM4ZGQ3 YmRjOTVjZjM3NDA1N2JjYzU5ZDhhMzNkLi5mYzM0NzQ1NDg4Y2U0OTFkODQ2ZThiOGIwZWFjYWZk NzYwOGM1YTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdv cmtQcm9jZXNzLmgKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJv Y2Vzcy5oCkBAIC02Miw2ICs2Miw4IEBACiAKICNpZiBQTEFURk9STShJT1NfRkFNSUxZKQogI2lu Y2x1ZGUgIldlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oIgorCitPQkpDX0NMQVNTIFJCU0Fzc2Vy dGlvbjsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oQ09DT0EpCkBAIC00OTcsNiArNDk5LDEwIEBA IHByaXZhdGU6CiAgICAgdm9pZCBhZGRTZXJ2aWNlV29ya2VyU2Vzc2lvbihQQUw6OlNlc3Npb25J RCwgYm9vbCBwcm9jZXNzVGVybWluYXRpb25EZWxheUVuYWJsZWQsIFN0cmluZyYmIHNlcnZpY2VX b3JrZXJSZWdpc3RyYXRpb25EaXJlY3RvcnksIGNvbnN0IFNhbmRib3hFeHRlbnNpb246OkhhbmRs ZSYpOwogI2VuZGlmCiAKKyNpZiBQTEFURk9STShJT1NfRkFNSUxZKQorICAgIHZvaWQgc2V0SXNI b2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7CisjZW5kaWYKKwogICAgIHZvaWQgZmlyZVByaXZhdGVD bGlja01lYXN1cmVtZW50VGltZXJJbW1lZGlhdGVseShQQUw6OlNlc3Npb25JRCk7CiAKICAgICBj bGFzcyBTZXNzaW9uU3RvcmFnZVF1b3RhTWFuYWdlciB7CkBAIC01NzIsNiArNTc4LDcgQEAgcHJp dmF0ZToKIAogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCiAgICAgV2ViU1FMaXRlRGF0YWJhc2VU cmFja2VyIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOworICAgIFJldGFpblB0cjxSQlNBc3Nl cnRpb24+IG1faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb247CiAjZW5kaWYKIAogICAgIEhhc2hN YXA8UEFMOjpTZXNzaW9uSUQsIFN0cmluZz4gbV9pZGJEYXRhYmFzZVBhdGhzOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0d29ya1Byb2Nlc3NJT1MubW0g Yi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQpp bmRleCBhMGZiZjk3NWY5ZDRhYjQ3M2I0MDc1YThhN2Y2OTcyYTI2YzRmOGFiLi4zNmQyNmJhZjk2 ZTQxZTE3YzE3MWRmYzk3ZDc4MmUwMDQwMjRkYzUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQorKysgYi9Tb3VyY2UvV2Vi S2l0L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQpAQCAtMzAsNiArMzAs NyBAQAogCiAjaW1wb3J0ICJOZXR3b3JrQ2FjaGUuaCIKICNpbXBvcnQgIk5ldHdvcmtQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmgiCisjaW1wb3J0ICJSdW5uaW5nQm9hcmRTZXJ2aWNlc1NQSS5o IgogI2ltcG9ydCAiU2FuZGJveEluaXRpYWxpemF0aW9uUGFyYW1ldGVycy5oIgogI2ltcG9ydCAi U2VjSXRlbVNoaW0uaCIKICNpbXBvcnQgPFdlYkNvcmUvQ2VydGlmaWNhdGVJbmZvLmg+CkBAIC05 Niw2ICs5NywyNyBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzOjpjbGVhclNlcnZpY2VXb3JrZXJFbnRp dGxlbWVudE92ZXJyaWRlKENvbXBsZXRpb25IYW5kbGVyPHZvaQogICAgIGNvbXBsZXRpb25IYW5k bGVyKCk7CiB9CiAKK3ZvaWQgTmV0d29ya1Byb2Nlc3M6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVz KGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMpCit7CisgICAgaWYgKCFpc0hvbGRpbmdMb2NrZWRG aWxlcykgeworICAgICAgICBtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uID0gbnVsbHB0cjsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChtX2hvbGRpbmdMb2NrZWRGaWxlQXNz ZXJ0aW9uICYmIFttX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uIGlzVmFsaWRdKQorICAgICAg ICByZXR1cm47CisKKyAgICAvLyBXZSBzeW5jaHJvbm91c2x5IHRha2UgYSBwcm9jZXNzIGFzc2Vy dGlvbiB3aGVuIGJlZ2lubmluZyBhIFNRTGl0ZSB0cmFuc2FjdGlvbiBzbyB0aGF0IHdlIGRvbid0 IGdldCBzdXNwZW5kZWQKKyAgICAvLyB3aGlsZSBob2xkaW5nIGEgbG9ja2VkIGZpbGUuIFdlIHdv dWxkIGdldCBraWxsZWQgaWYgc3VzcGVuZGVkIHdoaWxlIGhvbGRpbmcgbG9ja2VkIGZpbGVzLgor ICAgIFJCU1RhcmdldCAqdGFyZ2V0ID0gW1JCU1RhcmdldCBjdXJyZW50UHJvY2Vzc107CisgICAg UkJTRG9tYWluQXR0cmlidXRlICpkb21haW5BdHRyaWJ1dGUgPSBbUkJTRG9tYWluQXR0cmlidXRl IGF0dHJpYnV0ZVdpdGhEb21haW46QCJjb20uYXBwbGUuY29tbW9uIiBuYW1lOkAiRmluaXNoVGFz a1VuaW50ZXJydXB0YWJsZSJdOworICAgIG1faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb24gPSBh ZG9wdE5TKFtbUkJTQXNzZXJ0aW9uIGFsbG9jXSBpbml0V2l0aEV4cGxhbmF0aW9uOkAiV2ViS2l0 IFVJUHJvY2VzcyBiYWNrZ3JvdW5kIHRhc2siIHRhcmdldDp0YXJnZXQgYXR0cmlidXRlczpAW2Rv bWFpbkF0dHJpYnV0ZV1dKTsKKworICAgIE5TRXJyb3IgKmFjcXVpc2l0aW9uRXJyb3IgPSBuaWw7 CisgICAgaWYgKCFbbV9ob2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbiBhY3F1aXJlV2l0aEVycm9y OiZhY3F1aXNpdGlvbkVycm9yXSkKKyAgICAgICAgUkVMRUFTRV9MT0dfRVJST1IoUHJvY2Vzc1N1 c3BlbnNpb24sICJOZXR3b3JrUHJvY2Vzczo6c2V0SXNIb2xkaW5nTG9ja2VkRmlsZXM6IEZhaWxl ZCB0byBhY3F1aXJlIEZpbmlzaFRhc2tVbmludGVycnVwdGFibGUgYXNzZXJ0aW9uIGZvciBvd24g cHJvY2VzcywgZXJyb3I6ICV7cHVibGljfUAiLCBhY3F1aXNpdGlvbkVycm9yKTsKK30KKwogfSAv LyBuYW1lc3BhY2UgV2ViS2l0CiAKICNlbmRpZiAvLyBQTEFURk9STShJT1NfRkFNSUxZKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmNw cCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5jcHAKaW5k ZXggYTA0MThhYTkwNzMyYTllMzJlMTgyZWIzOGM4OTM3ZWVkNmNhNzdjZC4uNDAyMWVlMzRlZGEz MjNjMmZjNDI0NWVlNGRhYzFmMGQ2MzY3ODU3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9T aGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1No YXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuY3BwCkBAIC0yNiwxMCArMjYsNiBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oIgog Ci0jaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3MuaCIKLSNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzc1By b3h5TWVzc2FnZXMuaCIKLSNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCi0jaW5jbHVkZSAiV2ViUHJv Y2Vzc1Byb3h5TWVzc2FnZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL1NRTGl0ZURhdGFiYXNlVHJh Y2tlci5oPgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTM3LDcgKzMzLDYgQEAgdXNpbmcgbmFt ZXNwYWNlIFdlYkNvcmU7CiAKIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6V2ViU1FMaXRlRGF0 YWJhc2VUcmFja2VyKElzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlciYmIGlzSG9sZGluZ0xvY2tl ZEZpbGVzSGFuZGxlcikKICAgICA6IG1faXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyKFdURk1v dmUoaXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyKSkKLSAgICAsIG1faHlzdGVyZXNpcyhbdGhp c10oUEFMOjpIeXN0ZXJlc2lzU3RhdGUgc3RhdGUpIHsgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMo c3RhdGUgPT0gUEFMOjpIeXN0ZXJlc2lzU3RhdGU6OlN0YXJ0ZWQpOyB9LCAxX3MpCiB7CiAgICAg QVNTRVJUKFJ1bkxvb3A6OmlzTWFpbigpKTsKICAgICBTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNl dENsaWVudCh0aGlzKTsKQEAgLTQ4LDM2ICs0Myw0OCBAQCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNr ZXI6On5XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIoKQogICAgIEFTU0VSVChSdW5Mb29wOjppc01h aW4oKSk7CiAgICAgU1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRDbGllbnQobnVsbHB0cik7CiAK LSAgICBpZiAobV9oeXN0ZXJlc2lzLnN0YXRlKCkgPT0gUEFMOjpIeXN0ZXJlc2lzU3RhdGU6OlN0 YXJ0ZWQpCisgICAgaWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCkKICAgICAgICAgc2V0SXNIb2xk aW5nTG9ja2VkRmlsZXMoZmFsc2UpOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tl cjo6c2V0SXNTdXNwZW5kZWQoYm9vbCBpc1N1c3BlbmRlZCkKIHsKICAgICBBU1NFUlQoUnVuTG9v cDo6aXNNYWluKCkpOworCisgICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OwogICAgIG1faXNT dXNwZW5kZWQgPSBpc1N1c3BlbmRlZDsKIH0KIAogdm9pZCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNr ZXI6OndpbGxCZWdpbkZpcnN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1bkxvb3A6Om1haW4oKS5k aXNwYXRjaChbd2Vha1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKLSAgICAgICAgaWYgKHdl YWtUaGlzKQotICAgICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNpcy5zdGFydCgpOwotICAg IH0pOworICAgIExvY2tlciBsb2NrZXIgeyBtX2xvY2sgfTsKKyAgICBpZiAobV9jdXJyZW50SHlz dGVyZXJpc0lEKSB7CisgICAgICAgIC8vIENhbmNlbCBwcmV2aW91cyBoeXN0ZXJlc2lzIHRhc2su CisgICAgICAgICsrbV9jdXJyZW50SHlzdGVyZXJpc0lEOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSk7CiB9CiAKIHZvaWQgV2ViU1FM aXRlRGF0YWJhc2VUcmFja2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1 bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbd2Vha1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsK LSAgICAgICAgaWYgKHdlYWtUaGlzKQotICAgICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNp cy5zdG9wKCk7CisgICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OworICAgIFJ1bkxvb3A6Om1h aW4oKS5kaXNwYXRjaEFmdGVyKDFfcywgW3RoaXMsIHdlYWtUaGlzID0gbWFrZVdlYWtQdHIoKnRo aXMpLCBoeXN0ZXJlcmlzSUQgPSBtX2N1cnJlbnRIeXN0ZXJlcmlzSURdIHsKKyAgICAgICAgaWYg KCF3ZWFrVGhpcykKKyAgICAgICAgICAgIHJldHVybjsKKworICAgICAgICBMb2NrZXIgbG9ja2Vy IHsgbV9sb2NrIH07CisgICAgICAgIGlmIChtX2N1cnJlbnRIeXN0ZXJlcmlzSUQgIT0gaHlzdGVy ZXJpc0lEKQorICAgICAgICAgICAgcmV0dXJuOyAvLyBDYW5jZWxsZWQuCisKKyAgICAgICAgbV9j dXJyZW50SHlzdGVyZXJpc0lEID0gMDsKKyAgICAgICAgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMo ZmFsc2UpOwogICAgIH0pOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6c2V0 SXNIb2xkaW5nTG9ja2VkRmlsZXMoYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykKIHsKLSAgICBB U1NFUlQoUnVuTG9vcDo6aXNNYWluKCkpOwotCiAgICAgaWYgKG1faXNTdXNwZW5kZWQpCiAgICAg ICAgIHJldHVybjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FMaXRl RGF0YWJhc2VUcmFja2VyLmggYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFz ZVRyYWNrZXIuaAppbmRleCBiMmJmZDMyM2RlNTNlNjUyMzIxMzkxMzM4ODdkYzU0ZTgxMTJjOTJk Li5hM2U1ZWUyZTQyNDJlZmE4N2QyNDYyZjkyNDVhNjEwY2E5ZDUxY2JlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuaApAQCAtMjYsOCArMjYs MTAgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSA8V2ViQ29yZS9TUUxpdGVEYXRhYmFzZVRy YWNrZXJDbGllbnQuaD4KLSNpbmNsdWRlIDxwYWwvSHlzdGVyZXNpc0FjdGl2aXR5Lmg+CisjaW5j bHVkZSA8d3RmL0ZvcndhcmQuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0 Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9SdW5Mb29wLmg+CiAjaW5jbHVkZSA8d3Rm L1dlYWtQdHIuaD4KIAogbmFtZXNwYWNlIFdlYktpdCB7CkBAIC0zNiw2ICszOCw3IEBAIG5hbWVz cGFjZSBXZWJLaXQgewogY2xhc3MgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyIGZpbmFsIDogcHVi bGljIFdlYkNvcmU6OlNRTGl0ZURhdGFiYXNlVHJhY2tlckNsaWVudCwgcHVibGljIENhbk1ha2VX ZWFrUHRyPFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlciwgV2Vha1B0ckZhY3RvcnlJbml0aWFsaXph dGlvbjo6RWFnZXI+IHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShXZWJTUUxpdGVEYXRhYmFz ZVRyYWNrZXIpCiBwdWJsaWM6CisgICAgLy8gSXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyIG1h eSBnZXQgY2FsbGVkIG9uIGEgbm9uLW1haW4gdGhyZWFkLCBidXQgd2hpbGUgaG9sZGluZyBhIExv Y2suCiAgICAgdXNpbmcgSXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyID0gRnVuY3Rpb248dm9p ZChib29sKT47CiAgICAgZXhwbGljaXQgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyKElzSG9sZGlu Z0xvY2tlZEZpbGVzSGFuZGxlciYmKTsKIApAQCAtNDQsMTUgKzQ3LDE2IEBAIHB1YmxpYzoKICAg ICB2b2lkIHNldElzU3VzcGVuZGVkKGJvb2wpOwogCiBwcml2YXRlOgotICAgIHZvaWQgc2V0SXNI b2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7CisgICAgdm9pZCBzZXRJc0hvbGRpbmdMb2NrZWRGaWxl cyhib29sKSBXVEZfUkVRVUlSRVNfTE9DSyhtX2xvY2spOwogCiAgICAgLy8gV2ViQ29yZTo6U1FM aXRlRGF0YWJhc2VUcmFja2VyQ2xpZW50LgogICAgIHZvaWQgd2lsbEJlZ2luRmlyc3RUcmFuc2Fj dGlvbigpIGZpbmFsOwogICAgIHZvaWQgZGlkRmluaXNoTGFzdFRyYW5zYWN0aW9uKCkgZmluYWw7 CiAKICAgICBJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgbV9pc0hvbGRpbmdMb2NrZWRGaWxl c0hhbmRsZXI7Ci0gICAgUEFMOjpIeXN0ZXJlc2lzQWN0aXZpdHkgbV9oeXN0ZXJlc2lzOwotICAg IGJvb2wgbV9pc1N1c3BlbmRlZCB7IGZhbHNlIH07CisgICAgTG9jayBtX2xvY2s7CisgICAgdWlu dDY0X3QgbV9jdXJyZW50SHlzdGVyZXJpc0lEIFdURl9HVUFSREVEX0JZX0xPQ0sobV9sb2NrKSB7 IGZhbHNlIH07CisgICAgYm9vbCBtX2lzU3VzcGVuZGVkIFdURl9HVUFSREVEX0JZX0xPQ0sobV9s b2NrKSB7IGZhbHNlIH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAg Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3Bw CmluZGV4IGU2MDZiOTFlMTZjZGU0YTM0YWNiOTViZDAyMWQzNjYxYzIxYjY5NWQuLmRjYTdmNWIz MjE3YTU2NjQxZDhmMTM3Zjc2NDYzNzY1ODI2MWZkODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcApAQCAtMzE2 LDggKzMxNiw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3NQcm94eTo6bmV0d29ya1Byb2Nlc3NEaWRU ZXJtaW5hdGUoVGVybWluYXRpb25SZWFzb24gcmVhc29uKQogICAgIG1fY3VzdG9tUHJvdG9jb2xN YW5hZ2VyUHJveHkuaW52YWxpZGF0ZSgpOwogI2VuZGlmCiAKLSAgICBtX2FjdGl2aXR5Rm9ySG9s ZGluZ0xvY2tlZEZpbGVzID0gbnVsbHB0cjsKLQogICAgIG1fdXBsb2FkQWN0aXZpdHkgPSBzdGQ6 Om51bGxvcHQ7CiAKICAgICBpZiAoZGVmYXVsdE5ldHdvcmtQcm9jZXNzKCkgPT0gdGhpcykKQEAg LTEyNTYsMTkgKzEyNTQsNiBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNz RGlkUmVzdW1lKCkKICAgICBpZiAoY2FuU2VuZE1lc3NhZ2UoKSkKICAgICAgICAgc2VuZChNZXNz YWdlczo6TmV0d29ya1Byb2Nlc3M6OlByb2Nlc3NEaWRSZXN1bWUoKSwgMCk7CiB9Ci0gICAgCi12 b2lkIE5ldHdvcmtQcm9jZXNzUHJveHk6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wgaXNI b2xkaW5nTG9ja2VkRmlsZXMpCi17Ci0gICAgaWYgKCFpc0hvbGRpbmdMb2NrZWRGaWxlcykgewot ICAgICAgICBSRUxFQVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwgIlVJUHJvY2VzcyBpcyByZWxl YXNpbmcgYSBiYWNrZ3JvdW5kIGFzc2VydGlvbiBiZWNhdXNlIHRoZSBOZXR3b3JrIHByb2Nlc3Mg aXMgbm8gbG9uZ2VyIGhvbGRpbmcgbG9ja2VkIGZpbGVzIik7Ci0gICAgICAgIG1fYWN0aXZpdHlG b3JIb2xkaW5nTG9ja2VkRmlsZXMgPSBudWxscHRyOwotICAgICAgICByZXR1cm47Ci0gICAgfQot ICAgIGlmICghbV9hY3Rpdml0eUZvckhvbGRpbmdMb2NrZWRGaWxlcykgewotICAgICAgICBSRUxF QVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwgIlVJUHJvY2VzcyBpcyB0YWtpbmcgYSBiYWNrZ3Jv dW5kIGFzc2VydGlvbiBiZWNhdXNlIHRoZSBOZXR3b3JrIHByb2Nlc3MgaXMgaG9sZGluZyBsb2Nr ZWQgZmlsZXMiKTsKLSAgICAgICAgbV9hY3Rpdml0eUZvckhvbGRpbmdMb2NrZWRGaWxlcyA9IG1f dGhyb3R0bGVyLmJhY2tncm91bmRBY3Rpdml0eSgiSG9sZGluZyBsb2NrZWQgZmlsZXMiX3MpLm1v dmVUb1VuaXF1ZVB0cigpOwotICAgIH0KLX0KIAogdm9pZCBOZXR3b3JrUHJvY2Vzc1Byb3h5Ojpm bHVzaENvb2tpZXMoUEFMOjpTZXNzaW9uSUQgc2Vzc2lvbklELCBDb21wbGV0aW9uSGFuZGxlcjx2 b2lkKCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5oCmluZGV4IDhjZmU1M2JiNDk0 ZjhjY2NmNGE3MzY0ZTg5ZTRmZWEwM2NjMDUxMDMuLjg0NjI0NWNiYWM3YzA2OWFiYzA0ZjEwZmU3 M2I2Mzc3MjMwMTliYzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdv cmsvTmV0d29ya1Byb2Nlc3NQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05l dHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5oCkBAIC0yMDgsOCArMjA4LDYgQEAgcHVibGljOgog ICAgIAogICAgIHZvaWQgc3ludGhlc2l6ZUFwcElzQmFja2dyb3VuZChib29sIGJhY2tncm91bmQp OwogCi0gICAgdm9pZCBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhib29sKTsKLQogICAgIHZvaWQg Zmx1c2hDb29raWVzKFBBTDo6U2Vzc2lvbklELCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYp OwogCiAgICAgdm9pZCB0ZXN0UHJvY2Vzc0luY29taW5nU3luY01lc3NhZ2VzV2hlbldhaXRpbmdG b3JTeW5jUmVwbHkoV2ViUGFnZVByb3h5SWRlbnRpZmllciwgTWVzc2FnZXM6Ok5ldHdvcmtQcm9j ZXNzUHJveHk6OlRlc3RQcm9jZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5 bmNSZXBseURlbGF5ZWRSZXBseSYmKTsKQEAgLTMzOSw3ICszMzcsNiBAQCBwcml2YXRlOgogI2Vu ZGlmCiAKICAgICBQcm9jZXNzVGhyb3R0bGVyIG1fdGhyb3R0bGVyOwotICAgIHN0ZDo6dW5pcXVl X3B0cjxQcm9jZXNzVGhyb3R0bGVyOjpCYWNrZ3JvdW5kQWN0aXZpdHk+IG1fYWN0aXZpdHlGb3JI b2xkaW5nTG9ja2VkRmlsZXM7CiAgICAgUHJvY2Vzc1Rocm90dGxlcjo6QWN0aXZpdHlWYXJpYW50 IG1fYWN0aXZpdHlGcm9tV2ViUHJvY2Vzc2VzOwogCiAjaWYgRU5BQkxFKENPTlRFTlRfRVhURU5T SU9OUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29y a1Byb2Nlc3NQcm94eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdv cmsvTmV0d29ya1Byb2Nlc3NQcm94eS5tZXNzYWdlcy5pbgppbmRleCBlYTdlZGU5YTM5ZTE0YmM4 NzgyYjIzYjdkOWU5Y2Q1M2UxNzc4N2FkLi4wNTFlMWE0YzM0ZGY1OTg4YmYzNmJiMTYzYzNhMDVi ZWVlZmEyMTQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05l dHdvcmtQcm9jZXNzUHJveHkubWVzc2FnZXMuaW4KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5Lm1lc3NhZ2VzLmluCkBAIC0yOCw4ICsyOCw2 IEBAIG1lc3NhZ2VzIC0+IE5ldHdvcmtQcm9jZXNzUHJveHkgTGVnYWN5UmVjZWl2ZXIgewogICAg IFRlc3RQcm9jZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5bmNSZXBseShX ZWJLaXQ6OldlYlBhZ2VQcm94eUlkZW50aWZpZXIgcGFnZUlEKSAtPiAoYm9vbCBoYW5kbGVkKSBT eW5jaHJvbm91cwogICAgIFRlcm1pbmF0ZVVucmVzcG9uc2l2ZVNlcnZpY2VXb3JrZXJQcm9jZXNz ZXMoV2ViQ29yZTo6UHJvY2Vzc0lkZW50aWZpZXIgcHJvY2Vzc0lkZW50aWZpZXIpCiAKLSAgICBT ZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKQotCiAgICAg IyBEaWFnbm9zdGljIG1lc3NhZ2VzIGxvZ2dpbmcKICAgICBMb2dEaWFnbm9zdGljTWVzc2FnZShX ZWJLaXQ6OldlYlBhZ2VQcm94eUlkZW50aWZpZXIgcGFnZUlELCBTdHJpbmcgbWVzc2FnZSwgU3Ry aW5nIGRlc2NyaXB0aW9uLCBlbnVtOmJvb2wgV2ViQ29yZTo6U2hvdWxkU2FtcGxlIHNob3VsZFNh bXBsZSkKICAgICBMb2dEaWFnbm9zdGljTWVzc2FnZVdpdGhSZXN1bHQoV2ViS2l0OjpXZWJQYWdl UHJveHlJZGVudGlmaWVyIHBhZ2VJRCwgU3RyaW5nIG1lc3NhZ2UsIFN0cmluZyBkZXNjcmlwdGlv biwgdWludDMyX3QgcmVzdWx0LCBlbnVtOmJvb2wgV2ViQ29yZTo6U2hvdWxkU2FtcGxlIHNob3Vs ZFNhbXBsZSkK 432645 2021-06-30 16:56:32 -0700 2021-07-01 08:49:19 -0700 Patch bug-227552-20210630165632.patch text/plain 18696 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5NDI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGUxMjA5ZDNjYzBjNTlkZjg4 ZGIyOTE0YjZmMWJlM2FmYjMwZDBmNWUuLjcxNzRkOWNiYTFjNzc5Yjc3MjJiNjZjZTVhOTJjYzE5 NTQyMmVkNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMjEtMDYtMzAgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBUYWtlIGEgcHJvY2VzcyBhc3NlcnRp b24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZpbGVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjc1NTIKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYWtlIGEgcHJvY2Vz cyBhc3NlcnRpb24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZp bGVzLiBQcmV2aW91c2x5LCB3ZSdkCisgICAgICAgIHNlbmQgYW4gSVBDIHRvIHRoZSBVSVByb2Nl c3MgYW5kIHRoZSBVSVByb2Nlc3Mgd291bGQgdGFrZSB0aGUgYXNzZXJ0aW9uIG9uIGJlaGFsZiBv ZiB0aGUKKyAgICAgICAgbmV0d29yayBwcm9jZXNzLiBIb3dldmVyLCBvdXIgcHJldmlvdXMgYXBw cm9hY2ggd2FzIHJhY3kgYW5kIGNvdWxkIGNhdXNlIHRoZSBuZXR3b3JrIHByb2Nlc3MKKyAgICAg ICAgdG8gc3RpbGwgZ2V0IHN1c3BlbmRlZCB3aGlsZSBzdGlsbCBob2xkaW5nIGxvY2tlZCBmaWxl cyAod2hpY2ggd291bGQgZ2V0IGl0IGtpbGxlZCkuCisKKyAgICAgICAgV2UgaGF2ZSBldmlkZW5j ZSB0aGF0IHRoZSBuZXR3b3JrIHByb2Nlc3MgaXMgZ2V0dGluZyBraWxsZWQgYSBsb3QgZm9yIHRo aXMgcmVhc29uCisgICAgICAgIChyZGFyOi8vNzk3ODcxMjMpLgorCisgICAgICAgICogTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJv Y2Vzczo6TmV0d29ya1Byb2Nlc3MpOgorICAgICAgICBDYWxsIHNldElzSG9sZGluZ0xvY2tlZEZp bGVzKCkgd2hlbiB0aGUgImlzSG9sZGluZ0xvY2tlZEZpbGVzIiBzdGF0ZSBjaGFuZ2VzIGluc3Rl YWQgb2Ygc2VuZGluZworICAgICAgICBhbiBJUEMgdG8gdGhlIFVJUHJvY2Vzcy4gc2V0SXNIb2xk aW5nTG9ja2VkRmlsZXMoKSB0YWtlcyBjYXJlIG9mIHRha2luZyBvciByZWxlYXNpbmcgYQorICAg ICAgICBSdW5uaW5nQm9hcmQgYXNzZXJ0aW9uLgorCisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQ cm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKToKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nl c3M6OnJlc3VtZSk6CisgICAgICAgIFN0b3AgY2FsbGluZyBzZXRTdXNwZW5kZWQoKSBvbiB0aGUg V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLiBUaGUgcHVycG9zZSB3YXMgdG8gYXZvaWQgc2VuZGlu ZworICAgICAgICB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBDIHRvIHRoZSBVSVByb2Nl c3MgYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQcmVwYXJlVG9TdXNwZW5kIElQQy4KKyAgICAgICAgSG93 ZXZlciwgaXQgaXMgbm93IGFjY2VwdGFibGUgdG8gdGFrZSBhIHByb2Nlc3MgYXNzZXJ0aW9uIGFm dGVyIFByZXBhcmVUb1N1c3BlbmQgSVBDIGhhcyBiZWVuCisgICAgICAgIHJlY2VpdmVkLgorCisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaDoKKworICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbToKKyAgICAgICAgKFdlYktpdDo6 TmV0d29ya1Byb2Nlc3M6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgV2hlbiBz ZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyh0cnVlKSBnZXRzIGNhbGxlZCwgd2UgdGFrZSBhIHJ1bm5p bmdib2FyZCBhc3NlcnRpb24gdG8gcHJldmVudAorICAgICAgICBzdXNwZW5zaW9uLiBOb3RlIHRo YXQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSkgZ2V0cyBvbiB0aGUgc3RvcmFnZSB0aHJl YWQgKHdoaWNoIHN0YXJ0ZWQKKyAgICAgICAgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbikgc28gd2Ug dGFrZSB0aGUgYXNzZXJ0aW9uIHN5bmNocm9ub3VzbHkgdG8gbWFrZSBzdXJlIHdlIGNhbm5vdCBn ZXQKKyAgICAgICAgc3VzcGVuZGVkIGR1cmluZyBhIFNRTGl0ZSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgV2hlbiBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSkgZ2V0cyBjYWxsZWQsIHdlIHJl bGVhc2UgdGhlIHJ1bm5pbmdib2FyZCBhc3NlcnRpb24uCisKKyAgICAgICAgKiBTaGFyZWQvV2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0 YWJhc2VUcmFja2VyOjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgorICAgICAgICAoV2ViS2l0 OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldElzU3VzcGVuZGVk KToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp3aWxsQmVnaW5G aXJzdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFj a2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXI6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgKiBT aGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmg6CisgICAgICAgIFVwZGF0ZSBXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIgc28gdGhhdCBpdCBjYWxsZWQgaXRzIGlzSG9sZGluZ0xvY2tlZEZp bGVzSGFuZGxlciBsYW1iZGEKKyAgICAgICAgZGlyZWN0bHkgb24gdGhlIHN0b3JhZ2UgdGhyZWFk IHdoZW4gdGhlIGZpcnN0IHRyYW5zYWN0aW9uIHN0YXJ0cywgaW5zdGVhZCBvZiBkaXNwYXRjaGlu ZworICAgICAgICB0byB0aGUgbWFpbiB0aHJlYWQuIERpc3BhdGNoaW5nIHRvIHRoZSBtYWluIHRo cmVhZCB3b3VsZCBiZSByYWN5IGFzIGl0IHdvdWxkIG1lYW4gdGFraW5nCisgICAgICAgIHRoZSBw cm9jZXNzIGFzc2VydGlvbiBhc3luY2hyb25vdXNseSAob24gdGhlIG1haW4gdGhyZWFkKSwgYWZ0 ZXIgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbgorICAgICAgICBoYXMgYmVndW4gb24gdGhlIHN0b3Jh Z2UgdGhyZWFkLgorICAgICAgICBBcyBhIHJlc3VsdCwgb2YgdGhpcyBjaGFuZ2UsIEkgYW0gbm90 IHVzaW5nIHRoZSBIeXN0ZXJpc0FjdGl2aXR5IGNsYXNzIGFueW1vcmUgYW5kIHVzaW5nCisgICAg ICAgIG15IG93biB0aHJlYWQtc2FmZSBoeXN0ZXJlc2lzIGFjdGl2aXR5IHVzaW5nIFJ1bkxvb3A6 OmRpc3BhdGNoQWZ0ZXIoKSB3aXRoIGFuIGludGVnZXIKKyAgICAgICAgYW5kIGEgbG9jay4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpuZXR3b3JrUHJvY2Vzc0RpZFRlcm1p bmF0ZSk6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNz RGlkUmVzdW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5t ZXNzYWdlcy5pbjoKKyAgICAgICAgRHJvcCB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBD IGFuZCBpdHMgaGFuZGxpbmcgb24gVUlQcm9jZXNzIHNpZGUgc2luY2UgdGhlIG5ldHdvcmsKKyAg ICAgICAgcHJvY2VzcyBub3cgdGFrZXMgdGhlIGFzc2VydGlvbiBieSBpdHNlbGYuCisKIDIwMjEt MDYtMzAgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAgICAg W2lPU10gW0xpdmUgVGV4dF0gIlRleHQgZnJvbSBDYW1lcmEiIHNob3VsZCBub3QgYmUgc2hvd24g aW4gY2FsbG91dCBiYXIgd2hlbiBzZWxlY3RpbmcgdGV4dApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAgYi9Tb3VyY2UvV2ViS2l0L05l dHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcAppbmRleCA0OWJkZDNmZWM2ODEzN2NlNDM1 Mzk1MDAzNGFkYzZiMjc1MmFmOWU1Li5kZDQyZTIxNTU5MzMzZDMyNWI1YmQ0ZDI1YjBmZWE0MjM2 NjY1NGM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQ cm9jZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9j ZXNzLmNwcApAQCAtMTU5LDcgKzE1OSw3IEBAIE5ldHdvcmtQcm9jZXNzOjpOZXR3b3JrUHJvY2Vz cyhBdXhpbGlhcnlQcm9jZXNzSW5pdGlhbGl6YXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1lCiAgICAg LCBtX25ldHdvcmtDb250ZW50UnVsZUxpc3RNYW5hZ2VyKCp0aGlzKQogI2VuZGlmCiAjaWYgUExB VEZPUk0oSU9TX0ZBTUlMWSkKLSAgICAsIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyKFt0aGlz XShib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKSB7IHBhcmVudFByb2Nlc3NDb25uZWN0aW9uKCkt PnNlbmQoTWVzc2FnZXM6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OlNldElzSG9sZGluZ0xvY2tlZEZp bGVzKGlzSG9sZGluZ0xvY2tlZEZpbGVzKSwgMCk7IH0pCisgICAgLCBtX3dlYlNRTGl0ZURhdGFi YXNlVHJhY2tlcihbdGhpc10oYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykgeyBzZXRJc0hvbGRp bmdMb2NrZWRGaWxlcyhpc0hvbGRpbmdMb2NrZWRGaWxlcyk7IH0pCiAjZW5kaWYKICAgICAsIG1f bWVzc2FnZVBvcnRDaGFubmVsUmVnaXN0cnkoY3JlYXRlTWVzc2FnZVBvcnRDaGFubmVsUmVnaXN0 cnkoKnRoaXMpKQogewpAQCAtMjIxOSwxMCArMjIxOSw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3M6 OnByZXBhcmVUb1N1c3BlbmQoYm9vbCBpc1N1c3BlbnNpb25JbW1pbmVudCwgQ29tcGxldGlvbkhh bmRsCiAgICAgICAgIHNlcnZlci0+c3VzcGVuZCgpOwogI2VuZGlmCiAKLSNpZiBQTEFURk9STShJ T1NfRkFNSUxZKQotICAgIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLnNldElzU3VzcGVuZGVk KHRydWUpOwotI2VuZGlmCi0KICAgICBsb3dNZW1vcnlIYW5kbGVyKENyaXRpY2FsOjpZZXMpOwog CiAgICAgUmVmUHRyPENhbGxiYWNrQWdncmVnYXRvcj4gY2FsbGJhY2tBZ2dyZWdhdG9yID0gQ2Fs bGJhY2tBZ2dyZWdhdG9yOjpjcmVhdGUoW3RoaXMsIGNvbXBsZXRpb25IYW5kbGVyID0gV1RGTW92 ZShjb21wbGV0aW9uSGFuZGxlcildKCkgbXV0YWJsZSB7CkBAIC0yMjcwLDEwICsyMjY2LDYgQEAg dm9pZCBOZXR3b3JrUHJvY2Vzczo6cHJvY2Vzc0RpZFJlc3VtZSgpCiAKIHZvaWQgTmV0d29ya1By b2Nlc3M6OnJlc3VtZSgpCiB7Ci0jaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKLSAgICBtX3dlYlNR TGl0ZURhdGFiYXNlVHJhY2tlci5zZXRJc1N1c3BlbmRlZChmYWxzZSk7Ci0jZW5kaWYKLQogICAg IGZvciAoYXV0byYgY29ubmVjdGlvbiA6IG1fd2ViUHJvY2Vzc0Nvbm5lY3Rpb25zLnZhbHVlcygp KQogICAgICAgICBjb25uZWN0aW9uLT5lbmRTdXNwZW5zaW9uKCk7CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaCBiL1NvdXJjZS9XZWJL aXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaAppbmRleCA0NDc3ODRiMWE3ODM4ZGQ3 YmRjOTVjZjM3NDA1N2JjYzU5ZDhhMzNkLi5mYzM0NzQ1NDg4Y2U0OTFkODQ2ZThiOGIwZWFjYWZk NzYwOGM1YTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdv cmtQcm9jZXNzLmgKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJv Y2Vzcy5oCkBAIC02Miw2ICs2Miw4IEBACiAKICNpZiBQTEFURk9STShJT1NfRkFNSUxZKQogI2lu Y2x1ZGUgIldlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oIgorCitPQkpDX0NMQVNTIFJCU0Fzc2Vy dGlvbjsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oQ09DT0EpCkBAIC00OTcsNiArNDk5LDEwIEBA IHByaXZhdGU6CiAgICAgdm9pZCBhZGRTZXJ2aWNlV29ya2VyU2Vzc2lvbihQQUw6OlNlc3Npb25J RCwgYm9vbCBwcm9jZXNzVGVybWluYXRpb25EZWxheUVuYWJsZWQsIFN0cmluZyYmIHNlcnZpY2VX b3JrZXJSZWdpc3RyYXRpb25EaXJlY3RvcnksIGNvbnN0IFNhbmRib3hFeHRlbnNpb246OkhhbmRs ZSYpOwogI2VuZGlmCiAKKyNpZiBQTEFURk9STShJT1NfRkFNSUxZKQorICAgIHZvaWQgc2V0SXNI b2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7CisjZW5kaWYKKwogICAgIHZvaWQgZmlyZVByaXZhdGVD bGlja01lYXN1cmVtZW50VGltZXJJbW1lZGlhdGVseShQQUw6OlNlc3Npb25JRCk7CiAKICAgICBj bGFzcyBTZXNzaW9uU3RvcmFnZVF1b3RhTWFuYWdlciB7CkBAIC01NzIsNiArNTc4LDcgQEAgcHJp dmF0ZToKIAogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCiAgICAgV2ViU1FMaXRlRGF0YWJhc2VU cmFja2VyIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOworICAgIFJldGFpblB0cjxSQlNBc3Nl cnRpb24+IG1faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb247CiAjZW5kaWYKIAogICAgIEhhc2hN YXA8UEFMOjpTZXNzaW9uSUQsIFN0cmluZz4gbV9pZGJEYXRhYmFzZVBhdGhzOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0d29ya1Byb2Nlc3NJT1MubW0g Yi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQpp bmRleCBhMGZiZjk3NWY5ZDRhYjQ3M2I0MDc1YThhN2Y2OTcyYTI2YzRmOGFiLi43YTk4YjE5NDlk MjNkZWYzM2NjODRlNWQ0YjJlNWRlN2FlMmUxNGJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQorKysgYi9Tb3VyY2UvV2Vi S2l0L05ldHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbQpAQCAtMzAsNiArMzAs NyBAQAogCiAjaW1wb3J0ICJOZXR3b3JrQ2FjaGUuaCIKICNpbXBvcnQgIk5ldHdvcmtQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmgiCisjaW1wb3J0ICJSdW5uaW5nQm9hcmRTZXJ2aWNlc1NQSS5o IgogI2ltcG9ydCAiU2FuZGJveEluaXRpYWxpemF0aW9uUGFyYW1ldGVycy5oIgogI2ltcG9ydCAi U2VjSXRlbVNoaW0uaCIKICNpbXBvcnQgPFdlYkNvcmUvQ2VydGlmaWNhdGVJbmZvLmg+CkBAIC0z OCw2ICszOSwyNSBAQAogI2ltcG9ydCA8cGFsL3NwaS9jZi9DRk5ldHdvcmtTUEkuaD4KICNpbXBv cnQgPHd0Zi9jb2NvYS9FbnRpdGxlbWVudHMuaD4KIAordHlwZWRlZiB2b2lkKF5SQlNBc3NlcnRp b25JbnZhbGlkYXRpb25DYWxsYmFja1R5cGUpKCk7CisKK0BpbnRlcmZhY2UgV0tIb2xkaW5nTG9j a2VkRmlsZUFzc2VydGlvbkRlbGVnYXRlIDogTlNPYmplY3Q8UkJTQXNzZXJ0aW9uT2JzZXJ2aW5n PgorQGVuZAorCitAaW1wbGVtZW50YXRpb24gV0tIb2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbkRl bGVnYXRlCistICh2b2lkKWFzc2VydGlvbldpbGxJbnZhbGlkYXRlOihSQlNBc3NlcnRpb24gKilh c3NlcnRpb24KK3sKKyAgICBSRUxFQVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwgIiVwIC0gV0tI b2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbkRlbGVnYXRlOiBhc3NlcnRpb25XaWxsSW52YWxpZGF0 ZSIsIHNlbGYpOworfQorCistICh2b2lkKWFzc2VydGlvbjooUkJTQXNzZXJ0aW9uICopYXNzZXJ0 aW9uIGRpZEludmFsaWRhdGVXaXRoRXJyb3I6KE5TRXJyb3IgKillcnJvcgoreworICAgIFJFTEVB U0VfTE9HX0VSUk9SKFByb2Nlc3NTdXNwZW5zaW9uLCAiJXAgLSBXS0hvbGRpbmdMb2NrZWRGaWxl QXNzZXJ0aW9uRGVsZWdhdGU6IGFzc2VydGlvbiB3YXMgaW52YWxpZGF0ZWQsIGVycm9yOiAle3B1 YmxpY31AIiwgZXJyb3IsIHNlbGYpOworfQorQGVuZAorCitzdGF0aWMgV0tIb2xkaW5nTG9ja2Vk RmlsZUFzc2VydGlvbkRlbGVnYXRlKiBob2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbkRlbGVnYXRl OworCiBuYW1lc3BhY2UgV2ViS2l0IHsKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCkBAIC05 Niw2ICsxMTYsNDQgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzczo6Y2xlYXJTZXJ2aWNlV29ya2VyRW50 aXRsZW1lbnRPdmVycmlkZShDb21wbGV0aW9uSGFuZGxlcjx2b2kKICAgICBjb21wbGV0aW9uSGFu ZGxlcigpOwogfQogCit2b2lkIE5ldHdvcmtQcm9jZXNzOjpzZXRJc0hvbGRpbmdMb2NrZWRGaWxl cyhib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKQoreworICAgIGlmICghaXNIb2xkaW5nTG9ja2Vk RmlsZXMpIHsKKyAgICAgICAgaWYgKG1faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb24pIHsKKyAg ICAgICAgICAgIFttX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uIGludmFsaWRhdGVdOworICAg ICAgICAgICAgbV9ob2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbiA9IG51bGxwdHI7CisgICAgICAg ICAgICBSRUxFQVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwgIk5ldHdvcmtQcm9jZXNzOjpzZXRJ c0hvbGRpbmdMb2NrZWRGaWxlczogU3RvcHBlZCBhIEZpbmlzaFRhc2tVbmludGVycnVwdGFibGUg YmVjYXVzZSB0aGUgcHJvY2VzcyBpcyBubyBsb25nZXIgaG9sZGluZyBsb2NrZWQgZmlsZXMiKTsK KyAgICAgICAgfQorICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKG1faG9sZGluZ0xv Y2tlZEZpbGVBc3NlcnRpb24gJiYgW21faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb24gaXNWYWxp ZF0pCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0 aW9uKSB7CisgICAgICAgIFttX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uIGludmFsaWRhdGVd OworICAgICAgICBbbV9ob2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbiByZW1vdmVPYnNlcnZlcjpo b2xkaW5nTG9ja2VkRmlsZUFzc2VydGlvbkRlbGVnYXRlXTsKKyAgICB9CisKKyAgICAvLyBXZSBz eW5jaHJvbm91c2x5IHRha2UgYSBwcm9jZXNzIGFzc2VydGlvbiB3aGVuIGJlZ2lubmluZyBhIFNR TGl0ZSB0cmFuc2FjdGlvbiBzbyB0aGF0IHdlIGRvbid0IGdldCBzdXNwZW5kZWQKKyAgICAvLyB3 aGlsZSBob2xkaW5nIGEgbG9ja2VkIGZpbGUuIFdlIHdvdWxkIGdldCBraWxsZWQgaWYgc3VzcGVu ZGVkIHdoaWxlIGhvbGRpbmcgbG9ja2VkIGZpbGVzLgorICAgIFJCU1RhcmdldCAqdGFyZ2V0ID0g W1JCU1RhcmdldCBjdXJyZW50UHJvY2Vzc107CisgICAgUkJTRG9tYWluQXR0cmlidXRlICpkb21h aW5BdHRyaWJ1dGUgPSBbUkJTRG9tYWluQXR0cmlidXRlIGF0dHJpYnV0ZVdpdGhEb21haW46QCJj b20uYXBwbGUuY29tbW9uIiBuYW1lOkAiRmluaXNoVGFza1VuaW50ZXJydXB0YWJsZSJdOworICAg IG1faG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb24gPSBhZG9wdE5TKFtbUkJTQXNzZXJ0aW9uIGFs bG9jXSBpbml0V2l0aEV4cGxhbmF0aW9uOkAiV2ViS2l0IFVJUHJvY2VzcyBiYWNrZ3JvdW5kIHRh c2siIHRhcmdldDp0YXJnZXQgYXR0cmlidXRlczpAW2RvbWFpbkF0dHJpYnV0ZV1dKTsKKworICAg IGlmICghaG9sZGluZ0xvY2tlZEZpbGVBc3NlcnRpb25EZWxlZ2F0ZSkKKyAgICAgICAgaG9sZGlu Z0xvY2tlZEZpbGVBc3NlcnRpb25EZWxlZ2F0ZSA9IFtbV0tIb2xkaW5nTG9ja2VkRmlsZUFzc2Vy dGlvbkRlbGVnYXRlIGFsbG9jXSBpbml0XTsKKworICAgIC8vIExpc3RlbiBmb3IgZXhwaXJhdGlv biBzbyB3ZSBjYW4gZG8gc29tZSBsb2dnaW5nLgorICAgIFttX2hvbGRpbmdMb2NrZWRGaWxlQXNz ZXJ0aW9uIGFkZE9ic2VydmVyOmhvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uRGVsZWdhdGVdOwor CisgICAgTlNFcnJvciAqYWNxdWlzaXRpb25FcnJvciA9IG5pbDsKKyAgICBpZiAoIVttX2hvbGRp bmdMb2NrZWRGaWxlQXNzZXJ0aW9uIGFjcXVpcmVXaXRoRXJyb3I6JmFjcXVpc2l0aW9uRXJyb3Jd KQorICAgICAgICBSRUxFQVNFX0xPR19FUlJPUihQcm9jZXNzU3VzcGVuc2lvbiwgIk5ldHdvcmtQ cm9jZXNzOjpzZXRJc0hvbGRpbmdMb2NrZWRGaWxlczogRmFpbGVkIHRvIGFjcXVpcmUgRmluaXNo VGFza1VuaW50ZXJydXB0YWJsZSBhc3NlcnRpb24gZm9yIG93biBwcm9jZXNzLCBlcnJvcjogJXtw dWJsaWN9QCIsIGFjcXVpc2l0aW9uRXJyb3IpOworICAgIGVsc2UKKyAgICAgICAgUkVMRUFTRV9M T0coUHJvY2Vzc1N1c3BlbnNpb24sICJOZXR3b3JrUHJvY2Vzczo6c2V0SXNIb2xkaW5nTG9ja2Vk RmlsZXM6IFN0YXJ0ZWQgYSBGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlIGJlY2F1c2UgdGhlIHBy b2Nlc3MgaXMgbm93IGhvbGRpbmcgbG9ja2VkIGZpbGVzIik7Cit9CisKIH0gLy8gbmFtZXNwYWNl IFdlYktpdAogCiAjZW5kaWYgLy8gUExBVEZPUk0oSU9TX0ZBTUlMWSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5jcHAgYi9Tb3VyY2Uv V2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuY3BwCmluZGV4IGEwNDE4YWE5 MDczMmE5ZTMyZTE4MmViMzhjODkzN2VlZDZjYTc3Y2QuLjQ2MDEzMzRiMzM1N2MwMDNkMWVlN2Zh Yzg4NjhiNjZiOTZjZTUwMTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlNR TGl0ZURhdGFiYXNlVHJhY2tlci5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FM aXRlRGF0YWJhc2VUcmFja2VyLmNwcApAQCAtMjYsMTAgKzI2LDYgQEAKICNpbmNsdWRlICJjb25m aWcuaCIKICNpbmNsdWRlICJXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuaCIKIAotI2luY2x1ZGUg Ik5ldHdvcmtQcm9jZXNzLmgiCi0jaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3NQcm94eU1lc3NhZ2Vz LmgiCi0jaW5jbHVkZSAiV2ViUHJvY2Vzcy5oIgotI2luY2x1ZGUgIldlYlByb2Nlc3NQcm94eU1l c3NhZ2VzLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9TUUxpdGVEYXRhYmFzZVRyYWNrZXIuaD4KIAog bmFtZXNwYWNlIFdlYktpdCB7CkBAIC0zNyw3ICszMyw2IEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCiBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OldlYlNRTGl0ZURhdGFiYXNlVHJhY2tl cihJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXImJiBpc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRs ZXIpCiAgICAgOiBtX2lzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlcihXVEZNb3ZlKGlzSG9sZGlu Z0xvY2tlZEZpbGVzSGFuZGxlcikpCi0gICAgLCBtX2h5c3RlcmVzaXMoW3RoaXNdKFBBTDo6SHlz dGVyZXNpc1N0YXRlIHN0YXRlKSB7IHNldElzSG9sZGluZ0xvY2tlZEZpbGVzKHN0YXRlID09IFBB TDo6SHlzdGVyZXNpc1N0YXRlOjpTdGFydGVkKTsgfSwgMV9zKQogewogICAgIEFTU0VSVChSdW5M b29wOjppc01haW4oKSk7CiAgICAgU1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRDbGllbnQodGhp cyk7CkBAIC00OCwzNiArNDMsNDggQEAgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp+V2ViU1FM aXRlRGF0YWJhc2VUcmFja2VyKCkKICAgICBBU1NFUlQoUnVuTG9vcDo6aXNNYWluKCkpOwogICAg IFNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6c2V0Q2xpZW50KG51bGxwdHIpOwogCi0gICAgaWYgKG1f aHlzdGVyZXNpcy5zdGF0ZSgpID09IFBBTDo6SHlzdGVyZXNpc1N0YXRlOjpTdGFydGVkKQorICAg IGlmIChtX2N1cnJlbnRIeXN0ZXJlcmlzSUQpCiAgICAgICAgIHNldElzSG9sZGluZ0xvY2tlZEZp bGVzKGZhbHNlKTsKIH0KIAogdm9pZCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldElzU3Vz cGVuZGVkKGJvb2wgaXNTdXNwZW5kZWQpCiB7CiAgICAgQVNTRVJUKFJ1bkxvb3A6OmlzTWFpbigp KTsKKworICAgIExvY2tlciBsb2NrZXIgeyBtX2xvY2sgfTsKICAgICBtX2lzU3VzcGVuZGVkID0g aXNTdXNwZW5kZWQ7CiB9CiAKIHZvaWQgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp3aWxsQmVn aW5GaXJzdFRyYW5zYWN0aW9uKCkKIHsKLSAgICBSdW5Mb29wOjptYWluKCkuZGlzcGF0Y2goW3dl YWtUaGlzID0gbWFrZVdlYWtQdHIoKnRoaXMpXSB7Ci0gICAgICAgIGlmICh3ZWFrVGhpcykKLSAg ICAgICAgICAgIHdlYWtUaGlzLT5tX2h5c3RlcmVzaXMuc3RhcnQoKTsKLSAgICB9KTsKKyAgICBM b2NrZXIgbG9ja2VyIHsgbV9sb2NrIH07CisgICAgaWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCkg eworICAgICAgICAvLyBDYW5jZWwgcHJldmlvdXMgaHlzdGVyZXNpcyB0YXNrLgorICAgICAgICAr K21fY3VycmVudEh5c3RlcmVyaXNJRDsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHNl dElzSG9sZGluZ0xvY2tlZEZpbGVzKHRydWUpOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNl VHJhY2tlcjo6ZGlkRmluaXNoTGFzdFRyYW5zYWN0aW9uKCkKIHsKLSAgICBSdW5Mb29wOjptYWlu KCkuZGlzcGF0Y2goW3dlYWtUaGlzID0gbWFrZVdlYWtQdHIoKnRoaXMpXSB7Ci0gICAgICAgIGlm ICh3ZWFrVGhpcykKLSAgICAgICAgICAgIHdlYWtUaGlzLT5tX2h5c3RlcmVzaXMuc3RvcCgpOwor ICAgIExvY2tlciBsb2NrZXIgeyBtX2xvY2sgfTsKKyAgICBSdW5Mb29wOjptYWluKCkuZGlzcGF0 Y2hBZnRlcigxX3MsIFt0aGlzLCB3ZWFrVGhpcyA9IG1ha2VXZWFrUHRyKCp0aGlzKSwgaHlzdGVy ZXJpc0lEID0gKyttX2N1cnJlbnRIeXN0ZXJlcmlzSURdIHsKKyAgICAgICAgaWYgKCF3ZWFrVGhp cykKKyAgICAgICAgICAgIHJldHVybjsKKworICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9sb2Nr IH07CisgICAgICAgIGlmIChtX2N1cnJlbnRIeXN0ZXJlcmlzSUQgIT0gaHlzdGVyZXJpc0lEKQor ICAgICAgICAgICAgcmV0dXJuOyAvLyBDYW5jZWxsZWQuCisKKyAgICAgICAgbV9jdXJyZW50SHlz dGVyZXJpc0lEID0gMDsKKyAgICAgICAgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoZmFsc2UpOwog ICAgIH0pOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6c2V0SXNIb2xkaW5n TG9ja2VkRmlsZXMoYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykKIHsKLSAgICBBU1NFUlQoUnVu TG9vcDo6aXNNYWluKCkpOwotCiAgICAgaWYgKG1faXNTdXNwZW5kZWQpCiAgICAgICAgIHJldHVy bjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VU cmFja2VyLmggYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIu aAppbmRleCBiMmJmZDMyM2RlNTNlNjUyMzIxMzkxMzM4ODdkYzU0ZTgxMTJjOTJkLi5hM2U1ZWUy ZTQyNDJlZmE4N2QyNDYyZjkyNDVhNjEwY2E5ZDUxY2JlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0 L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuaApAQCAtMjYsOCArMjYsMTAgQEAKICNw cmFnbWEgb25jZQogCiAjaW5jbHVkZSA8V2ViQ29yZS9TUUxpdGVEYXRhYmFzZVRyYWNrZXJDbGll bnQuaD4KLSNpbmNsdWRlIDxwYWwvSHlzdGVyZXNpc0FjdGl2aXR5Lmg+CisjaW5jbHVkZSA8d3Rm L0ZvcndhcmQuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5 YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9SdW5Mb29wLmg+CiAjaW5jbHVkZSA8d3RmL1dlYWtQdHIu aD4KIAogbmFtZXNwYWNlIFdlYktpdCB7CkBAIC0zNiw2ICszOCw3IEBAIG5hbWVzcGFjZSBXZWJL aXQgewogY2xhc3MgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyIGZpbmFsIDogcHVibGljIFdlYkNv cmU6OlNRTGl0ZURhdGFiYXNlVHJhY2tlckNsaWVudCwgcHVibGljIENhbk1ha2VXZWFrUHRyPFdl YlNRTGl0ZURhdGFiYXNlVHJhY2tlciwgV2Vha1B0ckZhY3RvcnlJbml0aWFsaXphdGlvbjo6RWFn ZXI+IHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIp CiBwdWJsaWM6CisgICAgLy8gSXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyIG1heSBnZXQgY2Fs bGVkIG9uIGEgbm9uLW1haW4gdGhyZWFkLCBidXQgd2hpbGUgaG9sZGluZyBhIExvY2suCiAgICAg dXNpbmcgSXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyID0gRnVuY3Rpb248dm9pZChib29sKT47 CiAgICAgZXhwbGljaXQgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyKElzSG9sZGluZ0xvY2tlZEZp bGVzSGFuZGxlciYmKTsKIApAQCAtNDQsMTUgKzQ3LDE2IEBAIHB1YmxpYzoKICAgICB2b2lkIHNl dElzU3VzcGVuZGVkKGJvb2wpOwogCiBwcml2YXRlOgotICAgIHZvaWQgc2V0SXNIb2xkaW5nTG9j a2VkRmlsZXMoYm9vbCk7CisgICAgdm9pZCBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhib29sKSBX VEZfUkVRVUlSRVNfTE9DSyhtX2xvY2spOwogCiAgICAgLy8gV2ViQ29yZTo6U1FMaXRlRGF0YWJh c2VUcmFja2VyQ2xpZW50LgogICAgIHZvaWQgd2lsbEJlZ2luRmlyc3RUcmFuc2FjdGlvbigpIGZp bmFsOwogICAgIHZvaWQgZGlkRmluaXNoTGFzdFRyYW5zYWN0aW9uKCkgZmluYWw7CiAKICAgICBJ c0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgbV9pc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXI7 Ci0gICAgUEFMOjpIeXN0ZXJlc2lzQWN0aXZpdHkgbV9oeXN0ZXJlc2lzOwotICAgIGJvb2wgbV9p c1N1c3BlbmRlZCB7IGZhbHNlIH07CisgICAgTG9jayBtX2xvY2s7CisgICAgdWludDY0X3QgbV9j dXJyZW50SHlzdGVyZXJpc0lEIFdURl9HVUFSREVEX0JZX0xPQ0sobV9sb2NrKSB7IGZhbHNlIH07 CisgICAgYm9vbCBtX2lzU3VzcGVuZGVkIFdURl9HVUFSREVEX0JZX0xPQ0sobV9sb2NrKSB7IGZh bHNlIH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAgYi9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwCmluZGV4IGU2 MDZiOTFlMTZjZGU0YTM0YWNiOTViZDAyMWQzNjYxYzIxYjY5NWQuLmRjYTdmNWIzMjE3YTU2NjQx ZDhmMTM3Zjc2NDYzNzY1ODI2MWZkODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcApAQCAtMzE2LDggKzMxNiw2 IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3NQcm94eTo6bmV0d29ya1Byb2Nlc3NEaWRUZXJtaW5hdGUo VGVybWluYXRpb25SZWFzb24gcmVhc29uKQogICAgIG1fY3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJv eHkuaW52YWxpZGF0ZSgpOwogI2VuZGlmCiAKLSAgICBtX2FjdGl2aXR5Rm9ySG9sZGluZ0xvY2tl ZEZpbGVzID0gbnVsbHB0cjsKLQogICAgIG1fdXBsb2FkQWN0aXZpdHkgPSBzdGQ6Om51bGxvcHQ7 CiAKICAgICBpZiAoZGVmYXVsdE5ldHdvcmtQcm9jZXNzKCkgPT0gdGhpcykKQEAgLTEyNTYsMTkg KzEyNTQsNiBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNzRGlkUmVzdW1l KCkKICAgICBpZiAoY2FuU2VuZE1lc3NhZ2UoKSkKICAgICAgICAgc2VuZChNZXNzYWdlczo6TmV0 d29ya1Byb2Nlc3M6OlByb2Nlc3NEaWRSZXN1bWUoKSwgMCk7CiB9Ci0gICAgCi12b2lkIE5ldHdv cmtQcm9jZXNzUHJveHk6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wgaXNIb2xkaW5nTG9j a2VkRmlsZXMpCi17Ci0gICAgaWYgKCFpc0hvbGRpbmdMb2NrZWRGaWxlcykgewotICAgICAgICBS RUxFQVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwgIlVJUHJvY2VzcyBpcyByZWxlYXNpbmcgYSBi YWNrZ3JvdW5kIGFzc2VydGlvbiBiZWNhdXNlIHRoZSBOZXR3b3JrIHByb2Nlc3MgaXMgbm8gbG9u Z2VyIGhvbGRpbmcgbG9ja2VkIGZpbGVzIik7Ci0gICAgICAgIG1fYWN0aXZpdHlGb3JIb2xkaW5n TG9ja2VkRmlsZXMgPSBudWxscHRyOwotICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIGlmICgh bV9hY3Rpdml0eUZvckhvbGRpbmdMb2NrZWRGaWxlcykgewotICAgICAgICBSRUxFQVNFX0xPRyhQ cm9jZXNzU3VzcGVuc2lvbiwgIlVJUHJvY2VzcyBpcyB0YWtpbmcgYSBiYWNrZ3JvdW5kIGFzc2Vy dGlvbiBiZWNhdXNlIHRoZSBOZXR3b3JrIHByb2Nlc3MgaXMgaG9sZGluZyBsb2NrZWQgZmlsZXMi KTsKLSAgICAgICAgbV9hY3Rpdml0eUZvckhvbGRpbmdMb2NrZWRGaWxlcyA9IG1fdGhyb3R0bGVy LmJhY2tncm91bmRBY3Rpdml0eSgiSG9sZGluZyBsb2NrZWQgZmlsZXMiX3MpLm1vdmVUb1VuaXF1 ZVB0cigpOwotICAgIH0KLX0KIAogdm9pZCBOZXR3b3JrUHJvY2Vzc1Byb3h5OjpmbHVzaENvb2tp ZXMoUEFMOjpTZXNzaW9uSUQgc2Vzc2lvbklELCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYg Y29tcGxldGlvbkhhbmRsZXIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5oCmluZGV4IDhjZmU1M2JiNDk0ZjhjY2NmNGE3 MzY0ZTg5ZTRmZWEwM2NjMDUxMDMuLjg0NjI0NWNiYWM3YzA2OWFiYzA0ZjEwZmU3M2I2Mzc3MjMw MTliYzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29y a1Byb2Nlc3NQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0 d29ya1Byb2Nlc3NQcm94eS5oCkBAIC0yMDgsOCArMjA4LDYgQEAgcHVibGljOgogICAgIAogICAg IHZvaWQgc3ludGhlc2l6ZUFwcElzQmFja2dyb3VuZChib29sIGJhY2tncm91bmQpOwogCi0gICAg dm9pZCBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhib29sKTsKLQogICAgIHZvaWQgZmx1c2hDb29r aWVzKFBBTDo6U2Vzc2lvbklELCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYpOwogCiAgICAg dm9pZCB0ZXN0UHJvY2Vzc0luY29taW5nU3luY01lc3NhZ2VzV2hlbldhaXRpbmdGb3JTeW5jUmVw bHkoV2ViUGFnZVByb3h5SWRlbnRpZmllciwgTWVzc2FnZXM6Ok5ldHdvcmtQcm9jZXNzUHJveHk6 OlRlc3RQcm9jZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5bmNSZXBseURl bGF5ZWRSZXBseSYmKTsKQEAgLTMzOSw3ICszMzcsNiBAQCBwcml2YXRlOgogI2VuZGlmCiAKICAg ICBQcm9jZXNzVGhyb3R0bGVyIG1fdGhyb3R0bGVyOwotICAgIHN0ZDo6dW5pcXVlX3B0cjxQcm9j ZXNzVGhyb3R0bGVyOjpCYWNrZ3JvdW5kQWN0aXZpdHk+IG1fYWN0aXZpdHlGb3JIb2xkaW5nTG9j a2VkRmlsZXM7CiAgICAgUHJvY2Vzc1Rocm90dGxlcjo6QWN0aXZpdHlWYXJpYW50IG1fYWN0aXZp dHlGcm9tV2ViUHJvY2Vzc2VzOwogCiAjaWYgRU5BQkxFKENPTlRFTlRfRVhURU5TSU9OUykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQ cm94eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29y a1Byb2Nlc3NQcm94eS5tZXNzYWdlcy5pbgppbmRleCBlYTdlZGU5YTM5ZTE0YmM4NzgyYjIzYjdk OWU5Y2Q1M2UxNzc4N2FkLi4wNTFlMWE0YzM0ZGY1OTg4YmYzNmJiMTYzYzNhMDViZWVlZmEyMTQ0 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9j ZXNzUHJveHkubWVzc2FnZXMuaW4KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29y ay9OZXR3b3JrUHJvY2Vzc1Byb3h5Lm1lc3NhZ2VzLmluCkBAIC0yOCw4ICsyOCw2IEBAIG1lc3Nh Z2VzIC0+IE5ldHdvcmtQcm9jZXNzUHJveHkgTGVnYWN5UmVjZWl2ZXIgewogICAgIFRlc3RQcm9j ZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5bmNSZXBseShXZWJLaXQ6Oldl YlBhZ2VQcm94eUlkZW50aWZpZXIgcGFnZUlEKSAtPiAoYm9vbCBoYW5kbGVkKSBTeW5jaHJvbm91 cwogICAgIFRlcm1pbmF0ZVVucmVzcG9uc2l2ZVNlcnZpY2VXb3JrZXJQcm9jZXNzZXMoV2ViQ29y ZTo6UHJvY2Vzc0lkZW50aWZpZXIgcHJvY2Vzc0lkZW50aWZpZXIpCiAKLSAgICBTZXRJc0hvbGRp bmdMb2NrZWRGaWxlcyhib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKQotCiAgICAgIyBEaWFnbm9z dGljIG1lc3NhZ2VzIGxvZ2dpbmcKICAgICBMb2dEaWFnbm9zdGljTWVzc2FnZShXZWJLaXQ6Oldl YlBhZ2VQcm94eUlkZW50aWZpZXIgcGFnZUlELCBTdHJpbmcgbWVzc2FnZSwgU3RyaW5nIGRlc2Ny aXB0aW9uLCBlbnVtOmJvb2wgV2ViQ29yZTo6U2hvdWxkU2FtcGxlIHNob3VsZFNhbXBsZSkKICAg ICBMb2dEaWFnbm9zdGljTWVzc2FnZVdpdGhSZXN1bHQoV2ViS2l0OjpXZWJQYWdlUHJveHlJZGVu dGlmaWVyIHBhZ2VJRCwgU3RyaW5nIG1lc3NhZ2UsIFN0cmluZyBkZXNjcmlwdGlvbiwgdWludDMy X3QgcmVzdWx0LCBlbnVtOmJvb2wgV2ViQ29yZTo6U2hvdWxkU2FtcGxlIHNob3VsZFNhbXBsZSkK 432700 2021-07-01 08:49:21 -0700 2021-07-01 10:13:46 -0700 Patch bug-227552-20210701084920.patch text/plain 21894 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5NDYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGI3MTRhOGJhNTRkMmU5Y2Vh NWM3YjE0MTdkNmY0NDg5OThmNjQyYWIuLmE2Y2Q4ZTkzNGE5OWYxNTI1YjhiZjRmYjlmM2RiN2Zk NTZjMmZhZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMjEtMDYtMzAgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBUYWtlIGEgcHJvY2VzcyBhc3NlcnRp b24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZpbGVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjc1NTIKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYWtlIGEgcHJvY2Vz cyBhc3NlcnRpb24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZp bGVzLiBQcmV2aW91c2x5LCB3ZSdkCisgICAgICAgIHNlbmQgYW4gSVBDIHRvIHRoZSBVSVByb2Nl c3MgYW5kIHRoZSBVSVByb2Nlc3Mgd291bGQgdGFrZSB0aGUgYXNzZXJ0aW9uIG9uIGJlaGFsZiBv ZiB0aGUKKyAgICAgICAgbmV0d29yayBwcm9jZXNzLiBIb3dldmVyLCBvdXIgcHJldmlvdXMgYXBw cm9hY2ggd2FzIHJhY3kgYW5kIGNvdWxkIGNhdXNlIHRoZSBuZXR3b3JrIHByb2Nlc3MKKyAgICAg ICAgdG8gc3RpbGwgZ2V0IHN1c3BlbmRlZCB3aGlsZSBzdGlsbCBob2xkaW5nIGxvY2tlZCBmaWxl cyAod2hpY2ggd291bGQgZ2V0IGl0IGtpbGxlZCkuCisKKyAgICAgICAgV2UgaGF2ZSBldmlkZW5j ZSB0aGF0IHRoZSBuZXR3b3JrIHByb2Nlc3MgaXMgZ2V0dGluZyBraWxsZWQgYSBsb3QgZm9yIHRo aXMgcmVhc29uCisgICAgICAgIChyZGFyOi8vNzk3ODcxMjMpLgorCisgICAgICAgICogTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJv Y2Vzczo6TmV0d29ya1Byb2Nlc3MpOgorICAgICAgICBDYWxsIHNldElzSG9sZGluZ0xvY2tlZEZp bGVzKCkgd2hlbiB0aGUgImlzSG9sZGluZ0xvY2tlZEZpbGVzIiBzdGF0ZSBjaGFuZ2VzIGluc3Rl YWQgb2Ygc2VuZGluZworICAgICAgICBhbiBJUEMgdG8gdGhlIFVJUHJvY2Vzcy4gc2V0SXNIb2xk aW5nTG9ja2VkRmlsZXMoKSB0YWtlcyBjYXJlIG9mIHRha2luZyBvciByZWxlYXNpbmcgYQorICAg ICAgICBSdW5uaW5nQm9hcmQgYXNzZXJ0aW9uLgorCisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQ cm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKToKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nl c3M6OnJlc3VtZSk6CisgICAgICAgIFN0b3AgY2FsbGluZyBzZXRTdXNwZW5kZWQoKSBvbiB0aGUg V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLiBUaGUgcHVycG9zZSB3YXMgdG8gYXZvaWQgc2VuZGlu ZworICAgICAgICB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBDIHRvIHRoZSBVSVByb2Nl c3MgYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQcmVwYXJlVG9TdXNwZW5kIElQQy4KKyAgICAgICAgSG93 ZXZlciwgaXQgaXMgbm93IGFjY2VwdGFibGUgdG8gdGFrZSBhIHByb2Nlc3MgYXNzZXJ0aW9uIGFm dGVyIFByZXBhcmVUb1N1c3BlbmQgSVBDIGhhcyBiZWVuCisgICAgICAgIHJlY2VpdmVkLgorCisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaDoKKworICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbToKKyAgICAgICAgKFdlYktpdDo6 TmV0d29ya1Byb2Nlc3M6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgV2hlbiBz ZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyh0cnVlKSBnZXRzIGNhbGxlZCwgd2UgdGFrZSBhIHJ1bm5p bmdib2FyZCBhc3NlcnRpb24gdG8gcHJldmVudAorICAgICAgICBzdXNwZW5zaW9uLiBOb3RlIHRo YXQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSkgZ2V0cyBvbiB0aGUgc3RvcmFnZSB0aHJl YWQgKHdoaWNoIHN0YXJ0ZWQKKyAgICAgICAgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbikgc28gd2Ug dGFrZSB0aGUgYXNzZXJ0aW9uIHN5bmNocm9ub3VzbHkgdG8gbWFrZSBzdXJlIHdlIGNhbm5vdCBn ZXQKKyAgICAgICAgc3VzcGVuZGVkIGR1cmluZyBhIFNRTGl0ZSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgV2hlbiBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSkgZ2V0cyBjYWxsZWQsIHdlIHJl bGVhc2UgdGhlIHJ1bm5pbmdib2FyZCBhc3NlcnRpb24uCisKKyAgICAgICAgKiBTaGFyZWQvV2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0 YWJhc2VUcmFja2VyOjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgorICAgICAgICAoV2ViS2l0 OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldElzU3VzcGVuZGVk KToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp3aWxsQmVnaW5G aXJzdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFj a2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXI6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgKiBT aGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmg6CisgICAgICAgIFVwZGF0ZSBXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIgc28gdGhhdCBpdCBjYWxsZWQgaXRzIGlzSG9sZGluZ0xvY2tlZEZp bGVzSGFuZGxlciBsYW1iZGEKKyAgICAgICAgZGlyZWN0bHkgb24gdGhlIHN0b3JhZ2UgdGhyZWFk IHdoZW4gdGhlIGZpcnN0IHRyYW5zYWN0aW9uIHN0YXJ0cywgaW5zdGVhZCBvZiBkaXNwYXRjaGlu ZworICAgICAgICB0byB0aGUgbWFpbiB0aHJlYWQuIERpc3BhdGNoaW5nIHRvIHRoZSBtYWluIHRo cmVhZCB3b3VsZCBiZSByYWN5IGFzIGl0IHdvdWxkIG1lYW4gdGFraW5nCisgICAgICAgIHRoZSBw cm9jZXNzIGFzc2VydGlvbiBhc3luY2hyb25vdXNseSAob24gdGhlIG1haW4gdGhyZWFkKSwgYWZ0 ZXIgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbgorICAgICAgICBoYXMgYmVndW4gb24gdGhlIHN0b3Jh Z2UgdGhyZWFkLgorICAgICAgICBBcyBhIHJlc3VsdCwgb2YgdGhpcyBjaGFuZ2UsIEkgYW0gbm90 IHVzaW5nIHRoZSBIeXN0ZXJpc0FjdGl2aXR5IGNsYXNzIGFueW1vcmUgYW5kIHVzaW5nCisgICAg ICAgIG15IG93biB0aHJlYWQtc2FmZSBoeXN0ZXJlc2lzIGFjdGl2aXR5IHVzaW5nIFJ1bkxvb3A6 OmRpc3BhdGNoQWZ0ZXIoKSB3aXRoIGFuIGludGVnZXIKKyAgICAgICAgYW5kIGEgbG9jay4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpuZXR3b3JrUHJvY2Vzc0RpZFRlcm1p bmF0ZSk6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNz RGlkUmVzdW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5t ZXNzYWdlcy5pbjoKKyAgICAgICAgRHJvcCB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBD IGFuZCBpdHMgaGFuZGxpbmcgb24gVUlQcm9jZXNzIHNpZGUgc2luY2UgdGhlIG5ldHdvcmsKKyAg ICAgICAgcHJvY2VzcyBub3cgdGFrZXMgdGhlIGFzc2VydGlvbiBieSBpdHNlbGYuCisKIDIwMjEt MDctMDEgIFlvdWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIFtDb2Nv YV0gTWlncmF0ZSBXZWJSVEMgVURQIHNvY2tldCBoYW5kbGluZyB0byBOVyBBUEkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwIGIvU291 cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAKaW5kZXggNDliZGQz ZmVjNjgxMzdjZTQzNTM5NTAwMzRhZGM2YjI3NTJhZjllNS4uZGQ0MmUyMTU1OTMzM2QzMjViNWJk NGQyNWIwZmVhNDIzNjY2NTRjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vz cy9OZXR3b3JrUHJvY2Vzcy5jcHAKQEAgLTE1OSw3ICsxNTksNyBAQCBOZXR3b3JrUHJvY2Vzczo6 TmV0d29ya1Byb2Nlc3MoQXV4aWxpYXJ5UHJvY2Vzc0luaXRpYWxpemF0aW9uUGFyYW1ldGVycyYm IHBhcmFtZQogICAgICwgbV9uZXR3b3JrQ29udGVudFJ1bGVMaXN0TWFuYWdlcigqdGhpcykKICNl bmRpZgogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCi0gICAgLCBtX3dlYlNRTGl0ZURhdGFiYXNl VHJhY2tlcihbdGhpc10oYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykgeyBwYXJlbnRQcm9jZXNz Q29ubmVjdGlvbigpLT5zZW5kKE1lc3NhZ2VzOjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpTZXRJc0hv bGRpbmdMb2NrZWRGaWxlcyhpc0hvbGRpbmdMb2NrZWRGaWxlcyksIDApOyB9KQorICAgICwgbV93 ZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIoW3RoaXNdKGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMp IHsgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoaXNIb2xkaW5nTG9ja2VkRmlsZXMpOyB9KQogI2Vu ZGlmCiAgICAgLCBtX21lc3NhZ2VQb3J0Q2hhbm5lbFJlZ2lzdHJ5KGNyZWF0ZU1lc3NhZ2VQb3J0 Q2hhbm5lbFJlZ2lzdHJ5KCp0aGlzKSkKIHsKQEAgLTIyMTksMTAgKzIyMTksNiBAQCB2b2lkIE5l dHdvcmtQcm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKGJvb2wgaXNTdXNwZW5zaW9uSW1taW5lbnQs IENvbXBsZXRpb25IYW5kbAogICAgICAgICBzZXJ2ZXItPnN1c3BlbmQoKTsKICNlbmRpZgogCi0j aWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKLSAgICBtX3dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5z ZXRJc1N1c3BlbmRlZCh0cnVlKTsKLSNlbmRpZgotCiAgICAgbG93TWVtb3J5SGFuZGxlcihDcml0 aWNhbDo6WWVzKTsKIAogICAgIFJlZlB0cjxDYWxsYmFja0FnZ3JlZ2F0b3I+IGNhbGxiYWNrQWdn cmVnYXRvciA9IENhbGxiYWNrQWdncmVnYXRvcjo6Y3JlYXRlKFt0aGlzLCBjb21wbGV0aW9uSGFu ZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpXSgpIG11dGFibGUgewpAQCAtMjI3MCwx MCArMjI2Niw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3M6OnByb2Nlc3NEaWRSZXN1bWUoKQogCiB2 b2lkIE5ldHdvcmtQcm9jZXNzOjpyZXN1bWUoKQogewotI2lmIFBMQVRGT1JNKElPU19GQU1JTFkp Ci0gICAgbV93ZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuc2V0SXNTdXNwZW5kZWQoZmFsc2UpOwot I2VuZGlmCi0KICAgICBmb3IgKGF1dG8mIGNvbm5lY3Rpb24gOiBtX3dlYlByb2Nlc3NDb25uZWN0 aW9ucy52YWx1ZXMoKSkKICAgICAgICAgY29ubmVjdGlvbi0+ZW5kU3VzcGVuc2lvbigpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgg Yi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgKaW5kZXggNDQ3 Nzg0YjFhNzgzOGRkN2JkYzk1Y2YzNzQwNTdiY2M1OWQ4YTMzZC4uYWRmMDkzODQ3NDA3NGZjNjJi OWUwYjFjYzBhZWIyNDk5NWZiZWMyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3Jr UHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nl c3MvTmV0d29ya1Byb2Nlc3MuaApAQCAtMTA1LDYgKzEwNSw3IEBAIGNsYXNzIE5ldHdvcmtDb25u ZWN0aW9uVG9XZWJQcm9jZXNzOwogY2xhc3MgTmV0d29ya1Byb2Nlc3NTdXBwbGVtZW50OwogY2xh c3MgTmV0d29ya1Byb3hpbWl0eU1hbmFnZXI7CiBjbGFzcyBOZXR3b3JrUmVzb3VyY2VMb2FkZXI7 CitjbGFzcyBQcm9jZXNzQXNzZXJ0aW9uOwogY2xhc3MgU3RvcmFnZU1hbmFnZXJTZXQ7CiBjbGFz cyBXZWJQYWdlTmV0d29ya1BhcmFtZXRlcnM7CiBjbGFzcyBXZWJTV1NlcnZlckNvbm5lY3Rpb247 CkBAIC00OTcsNiArNDk4LDEwIEBAIHByaXZhdGU6CiAgICAgdm9pZCBhZGRTZXJ2aWNlV29ya2Vy U2Vzc2lvbihQQUw6OlNlc3Npb25JRCwgYm9vbCBwcm9jZXNzVGVybWluYXRpb25EZWxheUVuYWJs ZWQsIFN0cmluZyYmIHNlcnZpY2VXb3JrZXJSZWdpc3RyYXRpb25EaXJlY3RvcnksIGNvbnN0IFNh bmRib3hFeHRlbnNpb246OkhhbmRsZSYpOwogI2VuZGlmCiAKKyNpZiBQTEFURk9STShJT1NfRkFN SUxZKQorICAgIHZvaWQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7CisjZW5kaWYKKwog ICAgIHZvaWQgZmlyZVByaXZhdGVDbGlja01lYXN1cmVtZW50VGltZXJJbW1lZGlhdGVseShQQUw6 OlNlc3Npb25JRCk7CiAKICAgICBjbGFzcyBTZXNzaW9uU3RvcmFnZVF1b3RhTWFuYWdlciB7CkBA IC01NzIsNiArNTc3LDcgQEAgcHJpdmF0ZToKIAogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCiAg ICAgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOwor ICAgIHN0ZDo6dW5pcXVlX3B0cjxQcm9jZXNzQXNzZXJ0aW9uPiBtX2hvbGRpbmdMb2NrZWRGaWxl QXNzZXJ0aW9uOwogI2VuZGlmCiAKICAgICBIYXNoTWFwPFBBTDo6U2Vzc2lvbklELCBTdHJpbmc+ IG1faWRiRGF0YWJhc2VQYXRoczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1By b2Nlc3MvaW9zL05ldHdvcmtQcm9jZXNzSU9TLm1tIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9pb3MvTmV0d29ya1Byb2Nlc3NJT1MubW0KaW5kZXggYTBmYmY5NzVmOWQ0YWI0NzNiNDA3 NWE4YTdmNjk3MmEyNmM0ZjhhYi4uYmE2ZDRiOTZkMzZkZDJmMjIwMjNlNWMwYjMxNTNkZDk5NGY3 ZDAzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0d29y a1Byb2Nlc3NJT1MubW0KKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0 d29ya1Byb2Nlc3NJT1MubW0KQEAgLTMwLDYgKzMwLDcgQEAKIAogI2ltcG9ydCAiTmV0d29ya0Nh Y2hlLmgiCiAjaW1wb3J0ICJOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIgorI2lt cG9ydCAiUHJvY2Vzc0Fzc2VydGlvbi5oIgogI2ltcG9ydCAiU2FuZGJveEluaXRpYWxpemF0aW9u UGFyYW1ldGVycy5oIgogI2ltcG9ydCAiU2VjSXRlbVNoaW0uaCIKICNpbXBvcnQgPFdlYkNvcmUv Q2VydGlmaWNhdGVJbmZvLmg+CkBAIC05Niw2ICs5NywyMSBAQCB2b2lkIE5ldHdvcmtQcm9jZXNz OjpjbGVhclNlcnZpY2VXb3JrZXJFbnRpdGxlbWVudE92ZXJyaWRlKENvbXBsZXRpb25IYW5kbGVy PHZvaQogICAgIGNvbXBsZXRpb25IYW5kbGVyKCk7CiB9CiAKK3ZvaWQgTmV0d29ya1Byb2Nlc3M6 OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMpCit7Cisg ICAgaWYgKCFpc0hvbGRpbmdMb2NrZWRGaWxlcykgeworICAgICAgICBtX2hvbGRpbmdMb2NrZWRG aWxlQXNzZXJ0aW9uID0gbnVsbHB0cjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlm IChtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uICYmIG1faG9sZGluZ0xvY2tlZEZpbGVBc3Nl cnRpb24tPmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gV2Ugc3luY2hyb25v dXNseSB0YWtlIGEgcHJvY2VzcyBhc3NlcnRpb24gd2hlbiBiZWdpbm5pbmcgYSBTUUxpdGUgdHJh bnNhY3Rpb24gc28gdGhhdCB3ZSBkb24ndCBnZXQgc3VzcGVuZGVkCisgICAgLy8gd2hpbGUgaG9s ZGluZyBhIGxvY2tlZCBmaWxlLiBXZSB3b3VsZCBnZXQga2lsbGVkIGlmIHN1c3BlbmRlZCB3aGls ZSBob2xkaW5nIGxvY2tlZCBmaWxlcy4KKyAgICBtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9u ID0gbWFrZVVuaXF1ZTxQcm9jZXNzQXNzZXJ0aW9uPihnZXRDdXJyZW50UHJvY2Vzc0lEKCksICJO ZXR3b3JrIFByb2Nlc3MgaXMgaG9sZGluZyBsb2NrZWQgZmlsZXMiX3MsIFByb2Nlc3NBc3NlcnRp b25UeXBlOjpGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0CiAKICNlbmRpZiAvLyBQTEFURk9STShJT1NfRkFNSUxZKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcCBiL1NvdXJjZS9X ZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5jcHAKaW5kZXggYTA0MThhYTkw NzMyYTllMzJlMTgyZWIzOGM4OTM3ZWVkNmNhNzdjZC4uNDYwMTMzNGIzMzU3YzAwM2QxZWU3ZmFj ODg2OGI2NmI5NmNlNTAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FM aXRlRGF0YWJhc2VUcmFja2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIuY3BwCkBAIC0yNiwxMCArMjYsNiBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIldlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oIgogCi0jaW5jbHVkZSAi TmV0d29ya1Byb2Nlc3MuaCIKLSNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzc1Byb3h5TWVzc2FnZXMu aCIKLSNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCi0jaW5jbHVkZSAiV2ViUHJvY2Vzc1Byb3h5TWVz c2FnZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL1NRTGl0ZURhdGFiYXNlVHJhY2tlci5oPgogCiBu YW1lc3BhY2UgV2ViS2l0IHsKQEAgLTM3LDcgKzMzLDYgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNv cmU7CiAKIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2Vy KElzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlciYmIGlzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxl cikKICAgICA6IG1faXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyKFdURk1vdmUoaXNIb2xkaW5n TG9ja2VkRmlsZXNIYW5kbGVyKSkKLSAgICAsIG1faHlzdGVyZXNpcyhbdGhpc10oUEFMOjpIeXN0 ZXJlc2lzU3RhdGUgc3RhdGUpIHsgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoc3RhdGUgPT0gUEFM OjpIeXN0ZXJlc2lzU3RhdGU6OlN0YXJ0ZWQpOyB9LCAxX3MpCiB7CiAgICAgQVNTRVJUKFJ1bkxv b3A6OmlzTWFpbigpKTsKICAgICBTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldENsaWVudCh0aGlz KTsKQEAgLTQ4LDM2ICs0Myw0OCBAQCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIoKQogICAgIEFTU0VSVChSdW5Mb29wOjppc01haW4oKSk7CiAgICAg U1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRDbGllbnQobnVsbHB0cik7CiAKLSAgICBpZiAobV9o eXN0ZXJlc2lzLnN0YXRlKCkgPT0gUEFMOjpIeXN0ZXJlc2lzU3RhdGU6OlN0YXJ0ZWQpCisgICAg aWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCkKICAgICAgICAgc2V0SXNIb2xkaW5nTG9ja2VkRmls ZXMoZmFsc2UpOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6c2V0SXNTdXNw ZW5kZWQoYm9vbCBpc1N1c3BlbmRlZCkKIHsKICAgICBBU1NFUlQoUnVuTG9vcDo6aXNNYWluKCkp OworCisgICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OwogICAgIG1faXNTdXNwZW5kZWQgPSBp c1N1c3BlbmRlZDsKIH0KIAogdm9pZCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OndpbGxCZWdp bkZpcnN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbd2Vh a1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKLSAgICAgICAgaWYgKHdlYWtUaGlzKQotICAg ICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNpcy5zdGFydCgpOwotICAgIH0pOworICAgIExv Y2tlciBsb2NrZXIgeyBtX2xvY2sgfTsKKyAgICBpZiAobV9jdXJyZW50SHlzdGVyZXJpc0lEKSB7 CisgICAgICAgIC8vIENhbmNlbCBwcmV2aW91cyBoeXN0ZXJlc2lzIHRhc2suCisgICAgICAgICsr bV9jdXJyZW50SHlzdGVyZXJpc0lEOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgc2V0 SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSk7CiB9CiAKIHZvaWQgV2ViU1FMaXRlRGF0YWJhc2VU cmFja2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1bkxvb3A6Om1haW4o KS5kaXNwYXRjaChbd2Vha1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKLSAgICAgICAgaWYg KHdlYWtUaGlzKQotICAgICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNpcy5zdG9wKCk7Cisg ICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OworICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRj aEFmdGVyKDFfcywgW3RoaXMsIHdlYWtUaGlzID0gbWFrZVdlYWtQdHIoKnRoaXMpLCBoeXN0ZXJl cmlzSUQgPSArK21fY3VycmVudEh5c3RlcmVyaXNJRF0geworICAgICAgICBpZiAoIXdlYWtUaGlz KQorICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgIExvY2tlciBsb2NrZXIgeyBtX2xvY2sg fTsKKyAgICAgICAgaWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCAhPSBoeXN0ZXJlcmlzSUQpCisg ICAgICAgICAgICByZXR1cm47IC8vIENhbmNlbGxlZC4KKworICAgICAgICBtX2N1cnJlbnRIeXN0 ZXJlcmlzSUQgPSAwOworICAgICAgICBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSk7CiAg ICAgfSk7CiB9CiAKIHZvaWQgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRJc0hvbGRpbmdM b2NrZWRGaWxlcyhib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKQogewotICAgIEFTU0VSVChSdW5M b29wOjppc01haW4oKSk7Ci0KICAgICBpZiAobV9pc1N1c3BlbmRlZCkKICAgICAgICAgcmV0dXJu OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRy YWNrZXIuaCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5o CmluZGV4IGIyYmZkMzIzZGU1M2U2NTIzMjEzOTEzMzg4N2RjNTRlODExMmM5MmQuLmEzZTVlZTJl NDI0MmVmYTg3ZDI0NjJmOTI0NWE2MTBjYTlkNTFjYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQv U2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oCkBAIC0yNiw4ICsyNiwxMCBAQAogI3By YWdtYSBvbmNlCiAKICNpbmNsdWRlIDxXZWJDb3JlL1NRTGl0ZURhdGFiYXNlVHJhY2tlckNsaWVu dC5oPgotI2luY2x1ZGUgPHBhbC9IeXN0ZXJlc2lzQWN0aXZpdHkuaD4KKyNpbmNsdWRlIDx3dGYv Rm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NrLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlh YmxlLmg+CisjaW5jbHVkZSA8d3RmL1J1bkxvb3AuaD4KICNpbmNsdWRlIDx3dGYvV2Vha1B0ci5o PgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTM2LDYgKzM4LDcgQEAgbmFtZXNwYWNlIFdlYktp dCB7CiBjbGFzcyBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIgZmluYWwgOiBwdWJsaWMgV2ViQ29y ZTo6U1FMaXRlRGF0YWJhc2VUcmFja2VyQ2xpZW50LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8V2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLCBXZWFrUHRyRmFjdG9yeUluaXRpYWxpemF0aW9uOjpFYWdl cj4gewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcikK IHB1YmxpYzoKKyAgICAvLyBJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgbWF5IGdldCBjYWxs ZWQgb24gYSBub24tbWFpbiB0aHJlYWQsIGJ1dCB3aGlsZSBob2xkaW5nIGEgTG9jay4KICAgICB1 c2luZyBJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgPSBGdW5jdGlvbjx2b2lkKGJvb2wpPjsK ICAgICBleHBsaWNpdCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIoSXNIb2xkaW5nTG9ja2VkRmls ZXNIYW5kbGVyJiYpOwogCkBAIC00NCwxNSArNDcsMTYgQEAgcHVibGljOgogICAgIHZvaWQgc2V0 SXNTdXNwZW5kZWQoYm9vbCk7CiAKIHByaXZhdGU6Ci0gICAgdm9pZCBzZXRJc0hvbGRpbmdMb2Nr ZWRGaWxlcyhib29sKTsKKyAgICB2b2lkIHNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wpIFdU Rl9SRVFVSVJFU19MT0NLKG1fbG9jayk7CiAKICAgICAvLyBXZWJDb3JlOjpTUUxpdGVEYXRhYmFz ZVRyYWNrZXJDbGllbnQuCiAgICAgdm9pZCB3aWxsQmVnaW5GaXJzdFRyYW5zYWN0aW9uKCkgZmlu YWw7CiAgICAgdm9pZCBkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24oKSBmaW5hbDsKIAogICAgIElz SG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlciBtX2lzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlcjsK LSAgICBQQUw6Okh5c3RlcmVzaXNBY3Rpdml0eSBtX2h5c3RlcmVzaXM7Ci0gICAgYm9vbCBtX2lz U3VzcGVuZGVkIHsgZmFsc2UgfTsKKyAgICBMb2NrIG1fbG9jazsKKyAgICB1aW50NjRfdCBtX2N1 cnJlbnRIeXN0ZXJlcmlzSUQgV1RGX0dVQVJERURfQllfTE9DSyhtX2xvY2spIHsgZmFsc2UgfTsK KyAgICBib29sIG1faXNTdXNwZW5kZWQgV1RGX0dVQVJERURfQllfTE9DSyhtX2xvY2spIHsgZmFs c2UgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAKaW5kZXggZTYw NmI5MWUxNmNkZTRhMzRhY2I5NWJkMDIxZDM2NjFjMjFiNjk1ZC4uZGNhN2Y1YjMyMTdhNTY2NDFk OGYxMzdmNzY0NjM3NjU4MjYxZmQ4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwCkBAIC0zMTYsOCArMzE2LDYg QEAgdm9pZCBOZXR3b3JrUHJvY2Vzc1Byb3h5OjpuZXR3b3JrUHJvY2Vzc0RpZFRlcm1pbmF0ZShU ZXJtaW5hdGlvblJlYXNvbiByZWFzb24pCiAgICAgbV9jdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94 eS5pbnZhbGlkYXRlKCk7CiAjZW5kaWYKIAotICAgIG1fYWN0aXZpdHlGb3JIb2xkaW5nTG9ja2Vk RmlsZXMgPSBudWxscHRyOwotCiAgICAgbV91cGxvYWRBY3Rpdml0eSA9IHN0ZDo6bnVsbG9wdDsK IAogICAgIGlmIChkZWZhdWx0TmV0d29ya1Byb2Nlc3MoKSA9PSB0aGlzKQpAQCAtMTI1NiwxOSAr MTI1NCw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3NQcm94eTo6c2VuZFByb2Nlc3NEaWRSZXN1bWUo KQogICAgIGlmIChjYW5TZW5kTWVzc2FnZSgpKQogICAgICAgICBzZW5kKE1lc3NhZ2VzOjpOZXR3 b3JrUHJvY2Vzczo6UHJvY2Vzc0RpZFJlc3VtZSgpLCAwKTsKIH0KLSAgICAKLXZvaWQgTmV0d29y a1Byb2Nlc3NQcm94eTo6c2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoYm9vbCBpc0hvbGRpbmdMb2Nr ZWRGaWxlcykKLXsKLSAgICBpZiAoIWlzSG9sZGluZ0xvY2tlZEZpbGVzKSB7Ci0gICAgICAgIFJF TEVBU0VfTE9HKFByb2Nlc3NTdXNwZW5zaW9uLCAiVUlQcm9jZXNzIGlzIHJlbGVhc2luZyBhIGJh Y2tncm91bmQgYXNzZXJ0aW9uIGJlY2F1c2UgdGhlIE5ldHdvcmsgcHJvY2VzcyBpcyBubyBsb25n ZXIgaG9sZGluZyBsb2NrZWQgZmlsZXMiKTsKLSAgICAgICAgbV9hY3Rpdml0eUZvckhvbGRpbmdM b2NrZWRGaWxlcyA9IG51bGxwdHI7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0gICAgaWYgKCFt X2FjdGl2aXR5Rm9ySG9sZGluZ0xvY2tlZEZpbGVzKSB7Ci0gICAgICAgIFJFTEVBU0VfTE9HKFBy b2Nlc3NTdXNwZW5zaW9uLCAiVUlQcm9jZXNzIGlzIHRha2luZyBhIGJhY2tncm91bmQgYXNzZXJ0 aW9uIGJlY2F1c2UgdGhlIE5ldHdvcmsgcHJvY2VzcyBpcyBob2xkaW5nIGxvY2tlZCBmaWxlcyIp OwotICAgICAgICBtX2FjdGl2aXR5Rm9ySG9sZGluZ0xvY2tlZEZpbGVzID0gbV90aHJvdHRsZXIu YmFja2dyb3VuZEFjdGl2aXR5KCJIb2xkaW5nIGxvY2tlZCBmaWxlcyJfcykubW92ZVRvVW5pcXVl UHRyKCk7Ci0gICAgfQotfQogCiB2b2lkIE5ldHdvcmtQcm9jZXNzUHJveHk6OmZsdXNoQ29va2ll cyhQQUw6OlNlc3Npb25JRCBzZXNzaW9uSUQsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoKT4mJiBj b21wbGV0aW9uSGFuZGxlcikKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmgKaW5kZXggOGNmZTUzYmI0OTRmOGNjY2Y0YTcz NjRlODllNGZlYTAzY2MwNTEwMy4uODQ2MjQ1Y2JhYzdjMDY5YWJjMDRmMTBmZTczYjYzNzcyMzAx OWJjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3Jr UHJvY2Vzc1Byb3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3 b3JrUHJvY2Vzc1Byb3h5LmgKQEAgLTIwOCw4ICsyMDgsNiBAQCBwdWJsaWM6CiAgICAgCiAgICAg dm9pZCBzeW50aGVzaXplQXBwSXNCYWNrZ3JvdW5kKGJvb2wgYmFja2dyb3VuZCk7CiAKLSAgICB2 b2lkIHNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wpOwotCiAgICAgdm9pZCBmbHVzaENvb2tp ZXMoUEFMOjpTZXNzaW9uSUQsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoKT4mJik7CiAKICAgICB2 b2lkIHRlc3RQcm9jZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5bmNSZXBs eShXZWJQYWdlUHJveHlJZGVudGlmaWVyLCBNZXNzYWdlczo6TmV0d29ya1Byb2Nlc3NQcm94eTo6 VGVzdFByb2Nlc3NJbmNvbWluZ1N5bmNNZXNzYWdlc1doZW5XYWl0aW5nRm9yU3luY1JlcGx5RGVs YXllZFJlcGx5JiYpOwpAQCAtMzM5LDcgKzMzNyw2IEBAIHByaXZhdGU6CiAjZW5kaWYKIAogICAg IFByb2Nlc3NUaHJvdHRsZXIgbV90aHJvdHRsZXI7Ci0gICAgc3RkOjp1bmlxdWVfcHRyPFByb2Nl c3NUaHJvdHRsZXI6OkJhY2tncm91bmRBY3Rpdml0eT4gbV9hY3Rpdml0eUZvckhvbGRpbmdMb2Nr ZWRGaWxlczsKICAgICBQcm9jZXNzVGhyb3R0bGVyOjpBY3Rpdml0eVZhcmlhbnQgbV9hY3Rpdml0 eUZyb21XZWJQcm9jZXNzZXM7CiAKICNpZiBFTkFCTEUoQ09OVEVOVF9FWFRFTlNJT05TKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lm1lc3NhZ2VzLmluIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3Jr UHJvY2Vzc1Byb3h5Lm1lc3NhZ2VzLmluCmluZGV4IGVhN2VkZTlhMzllMTRiYzg3ODJiMjNiN2Q5 ZTljZDUzZTE3Nzg3YWQuLjA1MWUxYTRjMzRkZjU5ODhiZjM2YmIxNjNjM2EwNWJlZWVmYTIxNDQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nl c3NQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3Jr L05ldHdvcmtQcm9jZXNzUHJveHkubWVzc2FnZXMuaW4KQEAgLTI4LDggKzI4LDYgQEAgbWVzc2Fn ZXMgLT4gTmV0d29ya1Byb2Nlc3NQcm94eSBMZWdhY3lSZWNlaXZlciB7CiAgICAgVGVzdFByb2Nl c3NJbmNvbWluZ1N5bmNNZXNzYWdlc1doZW5XYWl0aW5nRm9yU3luY1JlcGx5KFdlYktpdDo6V2Vi UGFnZVByb3h5SWRlbnRpZmllciBwYWdlSUQpIC0+IChib29sIGhhbmRsZWQpIFN5bmNocm9ub3Vz CiAgICAgVGVybWluYXRlVW5yZXNwb25zaXZlU2VydmljZVdvcmtlclByb2Nlc3NlcyhXZWJDb3Jl OjpQcm9jZXNzSWRlbnRpZmllciBwcm9jZXNzSWRlbnRpZmllcikKIAotICAgIFNldElzSG9sZGlu Z0xvY2tlZEZpbGVzKGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMpCi0KICAgICAjIERpYWdub3N0 aWMgbWVzc2FnZXMgbG9nZ2luZwogICAgIExvZ0RpYWdub3N0aWNNZXNzYWdlKFdlYktpdDo6V2Vi UGFnZVByb3h5SWRlbnRpZmllciBwYWdlSUQsIFN0cmluZyBtZXNzYWdlLCBTdHJpbmcgZGVzY3Jp cHRpb24sIGVudW06Ym9vbCBXZWJDb3JlOjpTaG91bGRTYW1wbGUgc2hvdWxkU2FtcGxlKQogICAg IExvZ0RpYWdub3N0aWNNZXNzYWdlV2l0aFJlc3VsdChXZWJLaXQ6OldlYlBhZ2VQcm94eUlkZW50 aWZpZXIgcGFnZUlELCBTdHJpbmcgbWVzc2FnZSwgU3RyaW5nIGRlc2NyaXB0aW9uLCB1aW50MzJf dCByZXN1bHQsIGVudW06Ym9vbCBXZWJDb3JlOjpTaG91bGRTYW1wbGUgc2hvdWxkU2FtcGxlKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvY2Vzc0Fzc2VydGlvbi5jcHAg Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9jZXNzQXNzZXJ0aW9uLmNwcAppbmRleCBmYThl MDM3MDExZTM2NDkwYWU3NDc4OTZmMDI4NTc1ZThiYWRmYWIyLi5kYzIyZWU5YTAyNDk4MDJhOTBh ZmZlOTlmMDEwYzIxNzMwNjNlOWQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9Qcm9jZXNzQXNzZXJ0aW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9j ZXNzQXNzZXJ0aW9uLmNwcApAQCAtMzIsOSArMzIsMTAgQEAKIAogbmFtZXNwYWNlIFdlYktpdCB7 CiAKLVByb2Nlc3NBc3NlcnRpb246OlByb2Nlc3NBc3NlcnRpb24oUHJvY2Vzc0lEIHBpZCwgY29u c3QgU3RyaW5nJiwgUHJvY2Vzc0Fzc2VydGlvblR5cGUgYXNzZXJ0aW9uVHlwZSkKK1Byb2Nlc3NB c3NlcnRpb246OlByb2Nlc3NBc3NlcnRpb24oUHJvY2Vzc0lEIHBpZCwgY29uc3QgU3RyaW5nJiBy ZWFzb24sIFByb2Nlc3NBc3NlcnRpb25UeXBlIGFzc2VydGlvblR5cGUpCiAgICAgOiBtX2Fzc2Vy dGlvblR5cGUoYXNzZXJ0aW9uVHlwZSkKICAgICAsIG1fcGlkKHBpZCkKKyAgICAsIG1fcmVhc29u KHJlYXNvbikKIHsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJv Y2Vzc0Fzc2VydGlvbi5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvY2Vzc0Fzc2VydGlv bi5oCmluZGV4IGViNzVjMmEyZTk1NTRmZDI1OWVmZWQyNzU1NzAyNmVlOWNhMDQ2MDMuLmMzY2E2 NDI2ODhhMzY0Mjc3YWE4MDBhYWNlZDI0MTE1MWY5YWExZmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL1Byb2Nlc3NBc3NlcnRpb24uaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9Qcm9jZXNzQXNzZXJ0aW9uLmgKQEAgLTQ5LDYgKzQ5LDcgQEAgZW51bSBjbGFzcyBQ cm9jZXNzQXNzZXJ0aW9uVHlwZSB7CiAgICAgVW5ib3VuZGVkTmV0d29ya2luZywKICAgICBGb3Jl Z3JvdW5kLAogICAgIE1lZGlhUGxheWJhY2ssCisgICAgRmluaXNoVGFza1VuaW50ZXJydXB0YWJs ZSwKIH07CiAKIGNsYXNzIFByb2Nlc3NBc3NlcnRpb24gOiBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8 UHJvY2Vzc0Fzc2VydGlvbj4gewpAQCAtNzIsNiArNzMsNyBAQCBwcm90ZWN0ZWQ6CiBwcml2YXRl OgogICAgIGNvbnN0IFByb2Nlc3NBc3NlcnRpb25UeXBlIG1fYXNzZXJ0aW9uVHlwZTsKICAgICBj b25zdCBQcm9jZXNzSUQgbV9waWQ7CisgICAgY29uc3QgU3RyaW5nIG1fcmVhc29uOwogI2lmIFBM QVRGT1JNKElPU19GQU1JTFkpCiAgICAgUmV0YWluUHRyPFJCU0Fzc2VydGlvbj4gbV9yYnNBc3Nl cnRpb247CiAgICAgUmV0YWluUHRyPFdLUkJTQXNzZXJ0aW9uRGVsZWdhdGU+IG1fZGVsZWdhdGU7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9jZXNzVGhyb3R0bGVyLmNw cCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb2Nlc3NUaHJvdHRsZXIuY3BwCmluZGV4IGMw OTE1OWZhOGUwMDBiZTQ3Nzc3NmUzZDM2ZGJmNWJkZDI2NzEyZGYuLmUxMzExYWJhY2UxZmQyZmM4 OTIwMzBiNWRhNDZhZGY3MTQwNmFiNTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1Byb2Nlc3NUaHJvdHRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1By b2Nlc3NUaHJvdHRsZXIuY3BwCkBAIC0xMTIsNiArMTEyLDcgQEAgU3RyaW5nIFByb2Nlc3NUaHJv dHRsZXI6OmFzc2VydGlvbk5hbWUoUHJvY2Vzc0Fzc2VydGlvblR5cGUgdHlwZSkgY29uc3QKICAg ICAgICAgICAgIHJldHVybiAiU3VzcGVuZGVkIl9zOwogICAgICAgICBjYXNlIFByb2Nlc3NBc3Nl cnRpb25UeXBlOjpVbmJvdW5kZWROZXR3b3JraW5nOgogICAgICAgICBjYXNlIFByb2Nlc3NBc3Nl cnRpb25UeXBlOjpNZWRpYVBsYXliYWNrOgorICAgICAgICBjYXNlIFByb2Nlc3NBc3NlcnRpb25U eXBlOjpGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlOgogICAgICAgICAgICAgQVNTRVJUX05PVF9S RUFDSEVEKCk7IC8vIFRoZXNlIG90aGVyIGFzc2VydGlvbiB0eXBlcyBhcmUgbm90IHVzZWQgYnkg dGhlIFByb2Nlc3NUaHJvdHRsZXIuCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcCBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKaW5kZXggOThiODM2OTBl YzUwYmNjZDg4NjZjZGI0YzdkYzlkODNjNzgyOTJkZS4uMDEyOGZkMmFlYzA5MGViZjE2ZDViMjZh NmUzNWJjNWIyODY1NGRkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2Vi UHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQcm9jZXNz UHJveHkuY3BwCkBAIC0xNDcwLDYgKzE0NzAsNyBAQCB2b2lkIFdlYlByb2Nlc3NQcm94eTo6ZGlk U2V0QXNzZXJ0aW9uVHlwZShQcm9jZXNzQXNzZXJ0aW9uVHlwZSB0eXBlKQogICAgIAogICAgIGNh c2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6Ok1lZGlhUGxheWJhY2s6CiAgICAgY2FzZSBQcm9jZXNz QXNzZXJ0aW9uVHlwZTo6VW5ib3VuZGVkTmV0d29ya2luZzoKKyAgICBjYXNlIFByb2Nlc3NBc3Nl cnRpb25UeXBlOjpGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlOgogICAgICAgICBBU1NFUlRfTk9U X1JFQUNIRUQoKTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L2lvcy9Qcm9jZXNzQXNzZXJ0aW9uSU9TLm1tIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9z L1Byb2Nlc3NBc3NlcnRpb25JT1MubW0KaW5kZXggYWIyN2VkZWJhMmFlNmU1Y2YyYWI4YWUwY2Qx MzcyODNmZTEyODNlMS4uNTZhZTYyZTQ1ZDcxM2RjYjNjNDE4YWY0MWE4ZGQ4ZTExMDFhMzY4MiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9zL1Byb2Nlc3NBc3NlcnRpb25J T1MubW0KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9zL1Byb2Nlc3NBc3NlcnRpb25J T1MubW0KQEAgLTI5MSwxMiArMjkxLDI5IEBAIHN0YXRpYyBOU1N0cmluZyAqcnVubmluZ0JvYXJk TmFtZUZvckFzc2VydGlvblR5cGUoUHJvY2Vzc0Fzc2VydGlvblR5cGUgYXNzZXJ0aW9uCiAgICAg ICAgIHJldHVybiBAIkZvcmVncm91bmQiOwogICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6 Ok1lZGlhUGxheWJhY2s6CiAgICAgICAgIHJldHVybiBAIk1lZGlhUGxheWJhY2siOworICAgIGNh c2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6OkZpbmlzaFRhc2tVbmludGVycnVwdGFibGU6CisgICAg ICAgIHJldHVybiBAIkZpbmlzaFRhc2tVbmludGVycnVwdGFibGUiOworICAgIH0KK30KKworc3Rh dGljIE5TU3RyaW5nICpydW5uaW5nQm9hcmREb21haW5Gb3JBc3NlcnRpb25UeXBlKFByb2Nlc3NB c3NlcnRpb25UeXBlIGFzc2VydGlvblR5cGUpCit7CisgICAgc3dpdGNoIChhc3NlcnRpb25UeXBl KSB7CisgICAgY2FzZSBQcm9jZXNzQXNzZXJ0aW9uVHlwZTo6U3VzcGVuZGVkOgorICAgIGNhc2Ug UHJvY2Vzc0Fzc2VydGlvblR5cGU6OkJhY2tncm91bmQ6CisgICAgY2FzZSBQcm9jZXNzQXNzZXJ0 aW9uVHlwZTo6VW5ib3VuZGVkTmV0d29ya2luZzoKKyAgICBjYXNlIFByb2Nlc3NBc3NlcnRpb25U eXBlOjpGb3JlZ3JvdW5kOgorICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6Ok1lZGlhUGxh eWJhY2s6CisgICAgICAgIHJldHVybiBAImNvbS5hcHBsZS53ZWJraXQiOworICAgIGNhc2UgUHJv Y2Vzc0Fzc2VydGlvblR5cGU6OkZpbmlzaFRhc2tVbmludGVycnVwdGFibGU6CisgICAgICAgIHJl dHVybiBAImNvbS5hcHBsZS5jb21tb24iOwogICAgIH0KIH0KIAogUHJvY2Vzc0Fzc2VydGlvbjo6 UHJvY2Vzc0Fzc2VydGlvbihwaWRfdCBwaWQsIGNvbnN0IFN0cmluZyYgcmVhc29uLCBQcm9jZXNz QXNzZXJ0aW9uVHlwZSBhc3NlcnRpb25UeXBlKQogICAgIDogbV9hc3NlcnRpb25UeXBlKGFzc2Vy dGlvblR5cGUpCiAgICAgLCBtX3BpZChwaWQpCisgICAgLCBtX3JlYXNvbihyZWFzb24pCiB7CiAg ICAgTlNTdHJpbmcgKnJ1bm5pbmdCb2FyZEFzc2VydGlvbk5hbWUgPSBydW5uaW5nQm9hcmROYW1l Rm9yQXNzZXJ0aW9uVHlwZShhc3NlcnRpb25UeXBlKTsKICAgICBBU1NFUlQocnVubmluZ0JvYXJk QXNzZXJ0aW9uTmFtZSk7CkBAIC0zMDYsNyArMzIzLDcgQEAgUHJvY2Vzc0Fzc2VydGlvbjo6UHJv Y2Vzc0Fzc2VydGlvbihwaWRfdCBwaWQsIGNvbnN0IFN0cmluZyYgcmVhc29uLCBQcm9jZXNzQXNz ZXIKICAgICB9CiAKICAgICBSQlNUYXJnZXQgKnRhcmdldCA9IFtSQlNUYXJnZXQgdGFyZ2V0V2l0 aFBpZDpwaWRdOwotICAgIFJCU0RvbWFpbkF0dHJpYnV0ZSAqZG9tYWluQXR0cmlidXRlID0gW1JC U0RvbWFpbkF0dHJpYnV0ZSBhdHRyaWJ1dGVXaXRoRG9tYWluOkAiY29tLmFwcGxlLndlYmtpdCIg bmFtZTpydW5uaW5nQm9hcmRBc3NlcnRpb25OYW1lXTsKKyAgICBSQlNEb21haW5BdHRyaWJ1dGUg KmRvbWFpbkF0dHJpYnV0ZSA9IFtSQlNEb21haW5BdHRyaWJ1dGUgYXR0cmlidXRlV2l0aERvbWFp bjpydW5uaW5nQm9hcmREb21haW5Gb3JBc3NlcnRpb25UeXBlKGFzc2VydGlvblR5cGUpIG5hbWU6 cnVubmluZ0JvYXJkQXNzZXJ0aW9uTmFtZV07CiAgICAgbV9yYnNBc3NlcnRpb24gPSBhZG9wdE5T KFtbUkJTQXNzZXJ0aW9uIGFsbG9jXSBpbml0V2l0aEV4cGxhbmF0aW9uOnJlYXNvbiB0YXJnZXQ6 dGFyZ2V0IGF0dHJpYnV0ZXM6QFtkb21haW5BdHRyaWJ1dGVdXSk7CiAKICAgICBtX2RlbGVnYXRl ID0gYWRvcHROUyhbW1dLUkJTQXNzZXJ0aW9uRGVsZWdhdGUgYWxsb2NdIGluaXRdKTsKQEAgLTMy OSw3ICszNDYsNyBAQCBQcm9jZXNzQXNzZXJ0aW9uOjpQcm9jZXNzQXNzZXJ0aW9uKHBpZF90IHBp ZCwgY29uc3QgU3RyaW5nJiByZWFzb24sIFByb2Nlc3NBc3NlcgogCiBQcm9jZXNzQXNzZXJ0aW9u Ojp+UHJvY2Vzc0Fzc2VydGlvbigpCiB7Ci0gICAgUkVMRUFTRV9MT0coUHJvY2Vzc1N1c3BlbnNp b24sICIlcCAtIH5Qcm9jZXNzQXNzZXJ0aW9uKCkgUmVsZWFzaW5nIHByb2Nlc3MgYXNzZXJ0aW9u IGZvciBwcm9jZXNzIHdpdGggUElEPSVkIiwgdGhpcywgbV9waWQpOworICAgIFJFTEVBU0VfTE9H KFByb2Nlc3NTdXNwZW5zaW9uLCAiJXAgLSB+UHJvY2Vzc0Fzc2VydGlvbigpIFJlbGVhc2luZyBw cm9jZXNzIGFzc2VydGlvbiAnJXtwdWJsaWN9cycgZm9yIHByb2Nlc3Mgd2l0aCBQSUQ9JWQiLCB0 aGlzLCBtX3JlYXNvbi51dGY4KCkuZGF0YSgpLCBtX3BpZCk7CiAKICAgICBpZiAobV9yYnNBc3Nl cnRpb24pIHsKICAgICAgICAgbV9kZWxlZ2F0ZS5nZXQoKS5pbnZhbGlkYXRpb25DYWxsYmFjayA9 IG5pbDsK 432705 2021-07-01 10:13:47 -0700 2021-07-02 13:35:13 -0700 Patch bug-227552-20210701101347.patch text/plain 21890 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5NDYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGI3MTRhOGJhNTRkMmU5Y2Vh NWM3YjE0MTdkNmY0NDg5OThmNjQyYWIuLmE2Y2Q4ZTkzNGE5OWYxNTI1YjhiZjRmYjlmM2RiN2Zk NTZjMmZhZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMjEtMDYtMzAgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBUYWtlIGEgcHJvY2VzcyBhc3NlcnRp b24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZpbGVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjc1NTIKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYWtlIGEgcHJvY2Vz cyBhc3NlcnRpb24gaW4gdGhlIG5ldHdvcmsgcHJvY2VzcyB3aGVuIGhvbGRpbmcgbG9ja2VkIGZp bGVzLiBQcmV2aW91c2x5LCB3ZSdkCisgICAgICAgIHNlbmQgYW4gSVBDIHRvIHRoZSBVSVByb2Nl c3MgYW5kIHRoZSBVSVByb2Nlc3Mgd291bGQgdGFrZSB0aGUgYXNzZXJ0aW9uIG9uIGJlaGFsZiBv ZiB0aGUKKyAgICAgICAgbmV0d29yayBwcm9jZXNzLiBIb3dldmVyLCBvdXIgcHJldmlvdXMgYXBw cm9hY2ggd2FzIHJhY3kgYW5kIGNvdWxkIGNhdXNlIHRoZSBuZXR3b3JrIHByb2Nlc3MKKyAgICAg ICAgdG8gc3RpbGwgZ2V0IHN1c3BlbmRlZCB3aGlsZSBzdGlsbCBob2xkaW5nIGxvY2tlZCBmaWxl cyAod2hpY2ggd291bGQgZ2V0IGl0IGtpbGxlZCkuCisKKyAgICAgICAgV2UgaGF2ZSBldmlkZW5j ZSB0aGF0IHRoZSBuZXR3b3JrIHByb2Nlc3MgaXMgZ2V0dGluZyBraWxsZWQgYSBsb3QgZm9yIHRo aXMgcmVhc29uCisgICAgICAgIChyZGFyOi8vNzk3ODcxMjMpLgorCisgICAgICAgICogTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJv Y2Vzczo6TmV0d29ya1Byb2Nlc3MpOgorICAgICAgICBDYWxsIHNldElzSG9sZGluZ0xvY2tlZEZp bGVzKCkgd2hlbiB0aGUgImlzSG9sZGluZ0xvY2tlZEZpbGVzIiBzdGF0ZSBjaGFuZ2VzIGluc3Rl YWQgb2Ygc2VuZGluZworICAgICAgICBhbiBJUEMgdG8gdGhlIFVJUHJvY2Vzcy4gc2V0SXNIb2xk aW5nTG9ja2VkRmlsZXMoKSB0YWtlcyBjYXJlIG9mIHRha2luZyBvciByZWxlYXNpbmcgYQorICAg ICAgICBSdW5uaW5nQm9hcmQgYXNzZXJ0aW9uLgorCisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQ cm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKToKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nl c3M6OnJlc3VtZSk6CisgICAgICAgIFN0b3AgY2FsbGluZyBzZXRTdXNwZW5kZWQoKSBvbiB0aGUg V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLiBUaGUgcHVycG9zZSB3YXMgdG8gYXZvaWQgc2VuZGlu ZworICAgICAgICB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBDIHRvIHRoZSBVSVByb2Nl c3MgYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQcmVwYXJlVG9TdXNwZW5kIElQQy4KKyAgICAgICAgSG93 ZXZlciwgaXQgaXMgbm93IGFjY2VwdGFibGUgdG8gdGFrZSBhIHByb2Nlc3MgYXNzZXJ0aW9uIGFm dGVyIFByZXBhcmVUb1N1c3BlbmQgSVBDIGhhcyBiZWVuCisgICAgICAgIHJlY2VpdmVkLgorCisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaDoKKworICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL2lvcy9OZXR3b3JrUHJvY2Vzc0lPUy5tbToKKyAgICAgICAgKFdlYktpdDo6 TmV0d29ya1Byb2Nlc3M6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgV2hlbiBz ZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyh0cnVlKSBnZXRzIGNhbGxlZCwgd2UgdGFrZSBhIHJ1bm5p bmdib2FyZCBhc3NlcnRpb24gdG8gcHJldmVudAorICAgICAgICBzdXNwZW5zaW9uLiBOb3RlIHRo YXQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSkgZ2V0cyBvbiB0aGUgc3RvcmFnZSB0aHJl YWQgKHdoaWNoIHN0YXJ0ZWQKKyAgICAgICAgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbikgc28gd2Ug dGFrZSB0aGUgYXNzZXJ0aW9uIHN5bmNocm9ub3VzbHkgdG8gbWFrZSBzdXJlIHdlIGNhbm5vdCBn ZXQKKyAgICAgICAgc3VzcGVuZGVkIGR1cmluZyBhIFNRTGl0ZSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgV2hlbiBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSkgZ2V0cyBjYWxsZWQsIHdlIHJl bGVhc2UgdGhlIHJ1bm5pbmdib2FyZCBhc3NlcnRpb24uCisKKyAgICAgICAgKiBTaGFyZWQvV2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0 YWJhc2VUcmFja2VyOjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgorICAgICAgICAoV2ViS2l0 OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldElzU3VzcGVuZGVk KToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjp3aWxsQmVnaW5G aXJzdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViU1FMaXRlRGF0YWJhc2VUcmFj a2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXI6OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKToKKyAgICAgICAgKiBT aGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmg6CisgICAgICAgIFVwZGF0ZSBXZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIgc28gdGhhdCBpdCBjYWxsZWQgaXRzIGlzSG9sZGluZ0xvY2tlZEZp bGVzSGFuZGxlciBsYW1iZGEKKyAgICAgICAgZGlyZWN0bHkgb24gdGhlIHN0b3JhZ2UgdGhyZWFk IHdoZW4gdGhlIGZpcnN0IHRyYW5zYWN0aW9uIHN0YXJ0cywgaW5zdGVhZCBvZiBkaXNwYXRjaGlu ZworICAgICAgICB0byB0aGUgbWFpbiB0aHJlYWQuIERpc3BhdGNoaW5nIHRvIHRoZSBtYWluIHRo cmVhZCB3b3VsZCBiZSByYWN5IGFzIGl0IHdvdWxkIG1lYW4gdGFraW5nCisgICAgICAgIHRoZSBw cm9jZXNzIGFzc2VydGlvbiBhc3luY2hyb25vdXNseSAob24gdGhlIG1haW4gdGhyZWFkKSwgYWZ0 ZXIgdGhlIFNRTGl0ZSB0cmFuc2FjdGlvbgorICAgICAgICBoYXMgYmVndW4gb24gdGhlIHN0b3Jh Z2UgdGhyZWFkLgorICAgICAgICBBcyBhIHJlc3VsdCwgb2YgdGhpcyBjaGFuZ2UsIEkgYW0gbm90 IHVzaW5nIHRoZSBIeXN0ZXJpc0FjdGl2aXR5IGNsYXNzIGFueW1vcmUgYW5kIHVzaW5nCisgICAg ICAgIG15IG93biB0aHJlYWQtc2FmZSBoeXN0ZXJlc2lzIGFjdGl2aXR5IHVzaW5nIFJ1bkxvb3A6 OmRpc3BhdGNoQWZ0ZXIoKSB3aXRoIGFuIGludGVnZXIKKyAgICAgICAgYW5kIGEgbG9jay4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpuZXR3b3JrUHJvY2Vzc0RpZFRlcm1p bmF0ZSk6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzUHJveHk6OnNlbmRQcm9jZXNz RGlkUmVzdW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5t ZXNzYWdlcy5pbjoKKyAgICAgICAgRHJvcCB0aGUgU2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMgSVBD IGFuZCBpdHMgaGFuZGxpbmcgb24gVUlQcm9jZXNzIHNpZGUgc2luY2UgdGhlIG5ldHdvcmsKKyAg ICAgICAgcHJvY2VzcyBub3cgdGFrZXMgdGhlIGFzc2VydGlvbiBieSBpdHNlbGYuCisKIDIwMjEt MDctMDEgIFlvdWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIFtDb2Nv YV0gTWlncmF0ZSBXZWJSVEMgVURQIHNvY2tldCBoYW5kbGluZyB0byBOVyBBUEkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwIGIvU291 cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAKaW5kZXggNDliZGQz ZmVjNjgxMzdjZTQzNTM5NTAwMzRhZGM2YjI3NTJhZjllNS4uZGQ0MmUyMTU1OTMzM2QzMjViNWJk NGQyNWIwZmVhNDIzNjY2NTRjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vz cy9OZXR3b3JrUHJvY2Vzcy5jcHAKQEAgLTE1OSw3ICsxNTksNyBAQCBOZXR3b3JrUHJvY2Vzczo6 TmV0d29ya1Byb2Nlc3MoQXV4aWxpYXJ5UHJvY2Vzc0luaXRpYWxpemF0aW9uUGFyYW1ldGVycyYm IHBhcmFtZQogICAgICwgbV9uZXR3b3JrQ29udGVudFJ1bGVMaXN0TWFuYWdlcigqdGhpcykKICNl bmRpZgogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCi0gICAgLCBtX3dlYlNRTGl0ZURhdGFiYXNl VHJhY2tlcihbdGhpc10oYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykgeyBwYXJlbnRQcm9jZXNz Q29ubmVjdGlvbigpLT5zZW5kKE1lc3NhZ2VzOjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpTZXRJc0hv bGRpbmdMb2NrZWRGaWxlcyhpc0hvbGRpbmdMb2NrZWRGaWxlcyksIDApOyB9KQorICAgICwgbV93 ZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIoW3RoaXNdKGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMp IHsgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoaXNIb2xkaW5nTG9ja2VkRmlsZXMpOyB9KQogI2Vu ZGlmCiAgICAgLCBtX21lc3NhZ2VQb3J0Q2hhbm5lbFJlZ2lzdHJ5KGNyZWF0ZU1lc3NhZ2VQb3J0 Q2hhbm5lbFJlZ2lzdHJ5KCp0aGlzKSkKIHsKQEAgLTIyMTksMTAgKzIyMTksNiBAQCB2b2lkIE5l dHdvcmtQcm9jZXNzOjpwcmVwYXJlVG9TdXNwZW5kKGJvb2wgaXNTdXNwZW5zaW9uSW1taW5lbnQs IENvbXBsZXRpb25IYW5kbAogICAgICAgICBzZXJ2ZXItPnN1c3BlbmQoKTsKICNlbmRpZgogCi0j aWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKLSAgICBtX3dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5z ZXRJc1N1c3BlbmRlZCh0cnVlKTsKLSNlbmRpZgotCiAgICAgbG93TWVtb3J5SGFuZGxlcihDcml0 aWNhbDo6WWVzKTsKIAogICAgIFJlZlB0cjxDYWxsYmFja0FnZ3JlZ2F0b3I+IGNhbGxiYWNrQWdn cmVnYXRvciA9IENhbGxiYWNrQWdncmVnYXRvcjo6Y3JlYXRlKFt0aGlzLCBjb21wbGV0aW9uSGFu ZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpXSgpIG11dGFibGUgewpAQCAtMjI3MCwx MCArMjI2Niw2IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3M6OnByb2Nlc3NEaWRSZXN1bWUoKQogCiB2 b2lkIE5ldHdvcmtQcm9jZXNzOjpyZXN1bWUoKQogewotI2lmIFBMQVRGT1JNKElPU19GQU1JTFkp Ci0gICAgbV93ZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIuc2V0SXNTdXNwZW5kZWQoZmFsc2UpOwot I2VuZGlmCi0KICAgICBmb3IgKGF1dG8mIGNvbm5lY3Rpb24gOiBtX3dlYlByb2Nlc3NDb25uZWN0 aW9ucy52YWx1ZXMoKSkKICAgICAgICAgY29ubmVjdGlvbi0+ZW5kU3VzcGVuc2lvbigpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgg Yi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgKaW5kZXggNDQ3 Nzg0YjFhNzgzOGRkN2JkYzk1Y2YzNzQwNTdiY2M1OWQ4YTMzZC4uYWRmMDkzODQ3NDA3NGZjNjJi OWUwYjFjYzBhZWIyNDk5NWZiZWMyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3Jr UHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nl c3MvTmV0d29ya1Byb2Nlc3MuaApAQCAtMTA1LDYgKzEwNSw3IEBAIGNsYXNzIE5ldHdvcmtDb25u ZWN0aW9uVG9XZWJQcm9jZXNzOwogY2xhc3MgTmV0d29ya1Byb2Nlc3NTdXBwbGVtZW50OwogY2xh c3MgTmV0d29ya1Byb3hpbWl0eU1hbmFnZXI7CiBjbGFzcyBOZXR3b3JrUmVzb3VyY2VMb2FkZXI7 CitjbGFzcyBQcm9jZXNzQXNzZXJ0aW9uOwogY2xhc3MgU3RvcmFnZU1hbmFnZXJTZXQ7CiBjbGFz cyBXZWJQYWdlTmV0d29ya1BhcmFtZXRlcnM7CiBjbGFzcyBXZWJTV1NlcnZlckNvbm5lY3Rpb247 CkBAIC00OTcsNiArNDk4LDEwIEBAIHByaXZhdGU6CiAgICAgdm9pZCBhZGRTZXJ2aWNlV29ya2Vy U2Vzc2lvbihQQUw6OlNlc3Npb25JRCwgYm9vbCBwcm9jZXNzVGVybWluYXRpb25EZWxheUVuYWJs ZWQsIFN0cmluZyYmIHNlcnZpY2VXb3JrZXJSZWdpc3RyYXRpb25EaXJlY3RvcnksIGNvbnN0IFNh bmRib3hFeHRlbnNpb246OkhhbmRsZSYpOwogI2VuZGlmCiAKKyNpZiBQTEFURk9STShJT1NfRkFN SUxZKQorICAgIHZvaWQgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7CisjZW5kaWYKKwog ICAgIHZvaWQgZmlyZVByaXZhdGVDbGlja01lYXN1cmVtZW50VGltZXJJbW1lZGlhdGVseShQQUw6 OlNlc3Npb25JRCk7CiAKICAgICBjbGFzcyBTZXNzaW9uU3RvcmFnZVF1b3RhTWFuYWdlciB7CkBA IC01NzIsNiArNTc3LDcgQEAgcHJpdmF0ZToKIAogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCiAg ICAgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyIG1fd2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOwor ICAgIHN0ZDo6dW5pcXVlX3B0cjxQcm9jZXNzQXNzZXJ0aW9uPiBtX2hvbGRpbmdMb2NrZWRGaWxl QXNzZXJ0aW9uOwogI2VuZGlmCiAKICAgICBIYXNoTWFwPFBBTDo6U2Vzc2lvbklELCBTdHJpbmc+ IG1faWRiRGF0YWJhc2VQYXRoczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1By b2Nlc3MvaW9zL05ldHdvcmtQcm9jZXNzSU9TLm1tIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9pb3MvTmV0d29ya1Byb2Nlc3NJT1MubW0KaW5kZXggYTBmYmY5NzVmOWQ0YWI0NzNiNDA3 NWE4YTdmNjk3MmEyNmM0ZjhhYi4uYmE2ZDRiOTZkMzZkZDJmMjIwMjNlNWMwYjMxNTNkZDk5NGY3 ZDAzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0d29y a1Byb2Nlc3NJT1MubW0KKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9pb3MvTmV0 d29ya1Byb2Nlc3NJT1MubW0KQEAgLTMwLDYgKzMwLDcgQEAKIAogI2ltcG9ydCAiTmV0d29ya0Nh Y2hlLmgiCiAjaW1wb3J0ICJOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIgorI2lt cG9ydCAiUHJvY2Vzc0Fzc2VydGlvbi5oIgogI2ltcG9ydCAiU2FuZGJveEluaXRpYWxpemF0aW9u UGFyYW1ldGVycy5oIgogI2ltcG9ydCAiU2VjSXRlbVNoaW0uaCIKICNpbXBvcnQgPFdlYkNvcmUv Q2VydGlmaWNhdGVJbmZvLmg+CkBAIC05Niw2ICs5NywyMSBAQCB2b2lkIE5ldHdvcmtQcm9jZXNz OjpjbGVhclNlcnZpY2VXb3JrZXJFbnRpdGxlbWVudE92ZXJyaWRlKENvbXBsZXRpb25IYW5kbGVy PHZvaQogICAgIGNvbXBsZXRpb25IYW5kbGVyKCk7CiB9CiAKK3ZvaWQgTmV0d29ya1Byb2Nlc3M6 OnNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wgaXNIb2xkaW5nTG9ja2VkRmlsZXMpCit7Cisg ICAgaWYgKCFpc0hvbGRpbmdMb2NrZWRGaWxlcykgeworICAgICAgICBtX2hvbGRpbmdMb2NrZWRG aWxlQXNzZXJ0aW9uID0gbnVsbHB0cjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlm IChtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9uICYmIG1faG9sZGluZ0xvY2tlZEZpbGVBc3Nl cnRpb24tPmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gV2Ugc3luY2hyb25v dXNseSB0YWtlIGEgcHJvY2VzcyBhc3NlcnRpb24gd2hlbiBiZWdpbm5pbmcgYSBTUUxpdGUgdHJh bnNhY3Rpb24gc28gdGhhdCB3ZSBkb24ndCBnZXQgc3VzcGVuZGVkCisgICAgLy8gd2hpbGUgaG9s ZGluZyBhIGxvY2tlZCBmaWxlLiBXZSB3b3VsZCBnZXQga2lsbGVkIGlmIHN1c3BlbmRlZCB3aGls ZSBob2xkaW5nIGxvY2tlZCBmaWxlcy4KKyAgICBtX2hvbGRpbmdMb2NrZWRGaWxlQXNzZXJ0aW9u ID0gbWFrZVVuaXF1ZTxQcm9jZXNzQXNzZXJ0aW9uPihnZXRDdXJyZW50UHJvY2Vzc0lEKCksICJO ZXR3b3JrIFByb2Nlc3MgaXMgaG9sZGluZyBsb2NrZWQgZmlsZXMiX3MsIFByb2Nlc3NBc3NlcnRp b25UeXBlOjpGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0CiAKICNlbmRpZiAvLyBQTEFURk9STShJT1NfRkFNSUxZKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyLmNwcCBiL1NvdXJjZS9X ZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5jcHAKaW5kZXggYTA0MThhYTkw NzMyYTllMzJlMTgyZWIzOGM4OTM3ZWVkNmNhNzdjZC4uNDYwMTMzNGIzMzU3YzAwM2QxZWU3ZmFj ODg2OGI2NmI5NmNlNTAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViU1FM aXRlRGF0YWJhc2VUcmFja2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIuY3BwCkBAIC0yNiwxMCArMjYsNiBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIldlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oIgogCi0jaW5jbHVkZSAi TmV0d29ya1Byb2Nlc3MuaCIKLSNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzc1Byb3h5TWVzc2FnZXMu aCIKLSNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCi0jaW5jbHVkZSAiV2ViUHJvY2Vzc1Byb3h5TWVz c2FnZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL1NRTGl0ZURhdGFiYXNlVHJhY2tlci5oPgogCiBu YW1lc3BhY2UgV2ViS2l0IHsKQEAgLTM3LDcgKzMzLDYgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNv cmU7CiAKIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6V2ViU1FMaXRlRGF0YWJhc2VUcmFja2Vy KElzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlciYmIGlzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxl cikKICAgICA6IG1faXNIb2xkaW5nTG9ja2VkRmlsZXNIYW5kbGVyKFdURk1vdmUoaXNIb2xkaW5n TG9ja2VkRmlsZXNIYW5kbGVyKSkKLSAgICAsIG1faHlzdGVyZXNpcyhbdGhpc10oUEFMOjpIeXN0 ZXJlc2lzU3RhdGUgc3RhdGUpIHsgc2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoc3RhdGUgPT0gUEFM OjpIeXN0ZXJlc2lzU3RhdGU6OlN0YXJ0ZWQpOyB9LCAxX3MpCiB7CiAgICAgQVNTRVJUKFJ1bkxv b3A6OmlzTWFpbigpKTsKICAgICBTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OnNldENsaWVudCh0aGlz KTsKQEAgLTQ4LDM2ICs0Myw0OCBAQCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6On5XZWJTUUxp dGVEYXRhYmFzZVRyYWNrZXIoKQogICAgIEFTU0VSVChSdW5Mb29wOjppc01haW4oKSk7CiAgICAg U1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRDbGllbnQobnVsbHB0cik7CiAKLSAgICBpZiAobV9o eXN0ZXJlc2lzLnN0YXRlKCkgPT0gUEFMOjpIeXN0ZXJlc2lzU3RhdGU6OlN0YXJ0ZWQpCisgICAg aWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCkKICAgICAgICAgc2V0SXNIb2xkaW5nTG9ja2VkRmls ZXMoZmFsc2UpOwogfQogCiB2b2lkIFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcjo6c2V0SXNTdXNw ZW5kZWQoYm9vbCBpc1N1c3BlbmRlZCkKIHsKICAgICBBU1NFUlQoUnVuTG9vcDo6aXNNYWluKCkp OworCisgICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OwogICAgIG1faXNTdXNwZW5kZWQgPSBp c1N1c3BlbmRlZDsKIH0KIAogdm9pZCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXI6OndpbGxCZWdp bkZpcnN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRjaChbd2Vh a1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKLSAgICAgICAgaWYgKHdlYWtUaGlzKQotICAg ICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNpcy5zdGFydCgpOwotICAgIH0pOworICAgIExv Y2tlciBsb2NrZXIgeyBtX2xvY2sgfTsKKyAgICBpZiAobV9jdXJyZW50SHlzdGVyZXJpc0lEKSB7 CisgICAgICAgIC8vIENhbmNlbCBwcmV2aW91cyBoeXN0ZXJlc2lzIHRhc2suCisgICAgICAgICsr bV9jdXJyZW50SHlzdGVyZXJpc0lEOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgc2V0 SXNIb2xkaW5nTG9ja2VkRmlsZXModHJ1ZSk7CiB9CiAKIHZvaWQgV2ViU1FMaXRlRGF0YWJhc2VU cmFja2VyOjpkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24oKQogewotICAgIFJ1bkxvb3A6Om1haW4o KS5kaXNwYXRjaChbd2Vha1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKLSAgICAgICAgaWYg KHdlYWtUaGlzKQotICAgICAgICAgICAgd2Vha1RoaXMtPm1faHlzdGVyZXNpcy5zdG9wKCk7Cisg ICAgTG9ja2VyIGxvY2tlciB7IG1fbG9jayB9OworICAgIFJ1bkxvb3A6Om1haW4oKS5kaXNwYXRj aEFmdGVyKDFfcywgW3RoaXMsIHdlYWtUaGlzID0gbWFrZVdlYWtQdHIoKnRoaXMpLCBoeXN0ZXJl cmlzSUQgPSArK21fY3VycmVudEh5c3RlcmVyaXNJRF0geworICAgICAgICBpZiAoIXdlYWtUaGlz KQorICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgIExvY2tlciBsb2NrZXIgeyBtX2xvY2sg fTsKKyAgICAgICAgaWYgKG1fY3VycmVudEh5c3RlcmVyaXNJRCAhPSBoeXN0ZXJlcmlzSUQpCisg ICAgICAgICAgICByZXR1cm47IC8vIENhbmNlbGxlZC4KKworICAgICAgICBtX2N1cnJlbnRIeXN0 ZXJlcmlzSUQgPSAwOworICAgICAgICBzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhmYWxzZSk7CiAg ICAgfSk7CiB9CiAKIHZvaWQgV2ViU1FMaXRlRGF0YWJhc2VUcmFja2VyOjpzZXRJc0hvbGRpbmdM b2NrZWRGaWxlcyhib29sIGlzSG9sZGluZ0xvY2tlZEZpbGVzKQogewotICAgIEFTU0VSVChSdW5M b29wOjppc01haW4oKSk7Ci0KICAgICBpZiAobV9pc1N1c3BlbmRlZCkKICAgICAgICAgcmV0dXJu OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJTUUxpdGVEYXRhYmFzZVRy YWNrZXIuaCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5o CmluZGV4IGIyYmZkMzIzZGU1M2U2NTIzMjEzOTEzMzg4N2RjNTRlODExMmM5MmQuLmIwNWIwZDE5 ZWVkMGZiYTg1YjRjMjk1MzRmOWNiNDczMTBlN2MwOWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvU2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQv U2hhcmVkL1dlYlNRTGl0ZURhdGFiYXNlVHJhY2tlci5oCkBAIC0yNiw4ICsyNiwxMCBAQAogI3By YWdtYSBvbmNlCiAKICNpbmNsdWRlIDxXZWJDb3JlL1NRTGl0ZURhdGFiYXNlVHJhY2tlckNsaWVu dC5oPgotI2luY2x1ZGUgPHBhbC9IeXN0ZXJlc2lzQWN0aXZpdHkuaD4KKyNpbmNsdWRlIDx3dGYv Rm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NrLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlh YmxlLmg+CisjaW5jbHVkZSA8d3RmL1J1bkxvb3AuaD4KICNpbmNsdWRlIDx3dGYvV2Vha1B0ci5o PgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTM2LDYgKzM4LDcgQEAgbmFtZXNwYWNlIFdlYktp dCB7CiBjbGFzcyBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIgZmluYWwgOiBwdWJsaWMgV2ViQ29y ZTo6U1FMaXRlRGF0YWJhc2VUcmFja2VyQ2xpZW50LCBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8V2Vi U1FMaXRlRGF0YWJhc2VUcmFja2VyLCBXZWFrUHRyRmFjdG9yeUluaXRpYWxpemF0aW9uOjpFYWdl cj4gewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFdlYlNRTGl0ZURhdGFiYXNlVHJhY2tlcikK IHB1YmxpYzoKKyAgICAvLyBJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgbWF5IGdldCBjYWxs ZWQgb24gYSBub24tbWFpbiB0aHJlYWQsIGJ1dCB3aGlsZSBob2xkaW5nIGEgTG9jay4KICAgICB1 c2luZyBJc0hvbGRpbmdMb2NrZWRGaWxlc0hhbmRsZXIgPSBGdW5jdGlvbjx2b2lkKGJvb2wpPjsK ICAgICBleHBsaWNpdCBXZWJTUUxpdGVEYXRhYmFzZVRyYWNrZXIoSXNIb2xkaW5nTG9ja2VkRmls ZXNIYW5kbGVyJiYpOwogCkBAIC00NCwxNSArNDcsMTYgQEAgcHVibGljOgogICAgIHZvaWQgc2V0 SXNTdXNwZW5kZWQoYm9vbCk7CiAKIHByaXZhdGU6Ci0gICAgdm9pZCBzZXRJc0hvbGRpbmdMb2Nr ZWRGaWxlcyhib29sKTsKKyAgICB2b2lkIHNldElzSG9sZGluZ0xvY2tlZEZpbGVzKGJvb2wpIFdU Rl9SRVFVSVJFU19MT0NLKG1fbG9jayk7CiAKICAgICAvLyBXZWJDb3JlOjpTUUxpdGVEYXRhYmFz ZVRyYWNrZXJDbGllbnQuCiAgICAgdm9pZCB3aWxsQmVnaW5GaXJzdFRyYW5zYWN0aW9uKCkgZmlu YWw7CiAgICAgdm9pZCBkaWRGaW5pc2hMYXN0VHJhbnNhY3Rpb24oKSBmaW5hbDsKIAogICAgIElz SG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlciBtX2lzSG9sZGluZ0xvY2tlZEZpbGVzSGFuZGxlcjsK LSAgICBQQUw6Okh5c3RlcmVzaXNBY3Rpdml0eSBtX2h5c3RlcmVzaXM7Ci0gICAgYm9vbCBtX2lz U3VzcGVuZGVkIHsgZmFsc2UgfTsKKyAgICBMb2NrIG1fbG9jazsKKyAgICB1aW50NjRfdCBtX2N1 cnJlbnRIeXN0ZXJlcmlzSUQgV1RGX0dVQVJERURfQllfTE9DSyhtX2xvY2spIHsgMCB9OworICAg IGJvb2wgbV9pc1N1c3BlbmRlZCBXVEZfR1VBUkRFRF9CWV9MT0NLKG1fbG9jaykgeyBmYWxzZSB9 OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcAppbmRleCBlNjA2Yjkx ZTE2Y2RlNGEzNGFjYjk1YmQwMjFkMzY2MWMyMWI2OTVkLi5kY2E3ZjViMzIxN2E1NjY0MWQ4ZjEz N2Y3NjQ2Mzc2NTgyNjFmZDg3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9O ZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAKQEAgLTMxNiw4ICszMTYsNiBAQCB2 b2lkIE5ldHdvcmtQcm9jZXNzUHJveHk6Om5ldHdvcmtQcm9jZXNzRGlkVGVybWluYXRlKFRlcm1p bmF0aW9uUmVhc29uIHJlYXNvbikKICAgICBtX2N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5Lmlu dmFsaWRhdGUoKTsKICNlbmRpZgogCi0gICAgbV9hY3Rpdml0eUZvckhvbGRpbmdMb2NrZWRGaWxl cyA9IG51bGxwdHI7Ci0KICAgICBtX3VwbG9hZEFjdGl2aXR5ID0gc3RkOjpudWxsb3B0OwogCiAg ICAgaWYgKGRlZmF1bHROZXR3b3JrUHJvY2VzcygpID09IHRoaXMpCkBAIC0xMjU2LDE5ICsxMjU0 LDYgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzc1Byb3h5OjpzZW5kUHJvY2Vzc0RpZFJlc3VtZSgpCiAg ICAgaWYgKGNhblNlbmRNZXNzYWdlKCkpCiAgICAgICAgIHNlbmQoTWVzc2FnZXM6Ok5ldHdvcmtQ cm9jZXNzOjpQcm9jZXNzRGlkUmVzdW1lKCksIDApOwogfQotICAgIAotdm9pZCBOZXR3b3JrUHJv Y2Vzc1Byb3h5OjpzZXRJc0hvbGRpbmdMb2NrZWRGaWxlcyhib29sIGlzSG9sZGluZ0xvY2tlZEZp bGVzKQotewotICAgIGlmICghaXNIb2xkaW5nTG9ja2VkRmlsZXMpIHsKLSAgICAgICAgUkVMRUFT RV9MT0coUHJvY2Vzc1N1c3BlbnNpb24sICJVSVByb2Nlc3MgaXMgcmVsZWFzaW5nIGEgYmFja2dy b3VuZCBhc3NlcnRpb24gYmVjYXVzZSB0aGUgTmV0d29yayBwcm9jZXNzIGlzIG5vIGxvbmdlciBo b2xkaW5nIGxvY2tlZCBmaWxlcyIpOwotICAgICAgICBtX2FjdGl2aXR5Rm9ySG9sZGluZ0xvY2tl ZEZpbGVzID0gbnVsbHB0cjsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLSAgICBpZiAoIW1fYWN0 aXZpdHlGb3JIb2xkaW5nTG9ja2VkRmlsZXMpIHsKLSAgICAgICAgUkVMRUFTRV9MT0coUHJvY2Vz c1N1c3BlbnNpb24sICJVSVByb2Nlc3MgaXMgdGFraW5nIGEgYmFja2dyb3VuZCBhc3NlcnRpb24g YmVjYXVzZSB0aGUgTmV0d29yayBwcm9jZXNzIGlzIGhvbGRpbmcgbG9ja2VkIGZpbGVzIik7Ci0g ICAgICAgIG1fYWN0aXZpdHlGb3JIb2xkaW5nTG9ja2VkRmlsZXMgPSBtX3Rocm90dGxlci5iYWNr Z3JvdW5kQWN0aXZpdHkoIkhvbGRpbmcgbG9ja2VkIGZpbGVzIl9zKS5tb3ZlVG9VbmlxdWVQdHIo KTsKLSAgICB9Ci19CiAKIHZvaWQgTmV0d29ya1Byb2Nlc3NQcm94eTo6Zmx1c2hDb29raWVzKFBB TDo6U2Vzc2lvbklEIHNlc3Npb25JRCwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgpPiYmIGNvbXBs ZXRpb25IYW5kbGVyKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0 d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3 b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuaAppbmRleCA4Y2ZlNTNiYjQ5NGY4Y2NjZjRhNzM2NGU4 OWU0ZmVhMDNjYzA1MTAzLi44NDYyNDVjYmFjN2MwNjlhYmMwNGYxMGZlNzNiNjM3NzIzMDE5YmMw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9j ZXNzUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQ cm9jZXNzUHJveHkuaApAQCAtMjA4LDggKzIwOCw2IEBAIHB1YmxpYzoKICAgICAKICAgICB2b2lk IHN5bnRoZXNpemVBcHBJc0JhY2tncm91bmQoYm9vbCBiYWNrZ3JvdW5kKTsKIAotICAgIHZvaWQg c2V0SXNIb2xkaW5nTG9ja2VkRmlsZXMoYm9vbCk7Ci0KICAgICB2b2lkIGZsdXNoQ29va2llcyhQ QUw6OlNlc3Npb25JRCwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgpPiYmKTsKIAogICAgIHZvaWQg dGVzdFByb2Nlc3NJbmNvbWluZ1N5bmNNZXNzYWdlc1doZW5XYWl0aW5nRm9yU3luY1JlcGx5KFdl YlBhZ2VQcm94eUlkZW50aWZpZXIsIE1lc3NhZ2VzOjpOZXR3b3JrUHJvY2Vzc1Byb3h5OjpUZXN0 UHJvY2Vzc0luY29taW5nU3luY01lc3NhZ2VzV2hlbldhaXRpbmdGb3JTeW5jUmVwbHlEZWxheWVk UmVwbHkmJik7CkBAIC0zMzksNyArMzM3LDYgQEAgcHJpdmF0ZToKICNlbmRpZgogCiAgICAgUHJv Y2Vzc1Rocm90dGxlciBtX3Rocm90dGxlcjsKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8UHJvY2Vzc1Ro cm90dGxlcjo6QmFja2dyb3VuZEFjdGl2aXR5PiBtX2FjdGl2aXR5Rm9ySG9sZGluZ0xvY2tlZEZp bGVzOwogICAgIFByb2Nlc3NUaHJvdHRsZXI6OkFjdGl2aXR5VmFyaWFudCBtX2FjdGl2aXR5RnJv bVdlYlByb2Nlc3NlczsKIAogI2lmIEVOQUJMRShDT05URU5UX0VYVEVOU0lPTlMpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHku bWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQcm9j ZXNzUHJveHkubWVzc2FnZXMuaW4KaW5kZXggZWE3ZWRlOWEzOWUxNGJjODc4MmIyM2I3ZDllOWNk NTNlMTc3ODdhZC4uMDUxZTFhNGMzNGRmNTk4OGJmMzZiYjE2M2MzYTA1YmVlZWZhMjE0NCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1By b3h5Lm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL05ldHdvcmsvTmV0 d29ya1Byb2Nlc3NQcm94eS5tZXNzYWdlcy5pbgpAQCAtMjgsOCArMjgsNiBAQCBtZXNzYWdlcyAt PiBOZXR3b3JrUHJvY2Vzc1Byb3h5IExlZ2FjeVJlY2VpdmVyIHsKICAgICBUZXN0UHJvY2Vzc0lu Y29taW5nU3luY01lc3NhZ2VzV2hlbldhaXRpbmdGb3JTeW5jUmVwbHkoV2ViS2l0OjpXZWJQYWdl UHJveHlJZGVudGlmaWVyIHBhZ2VJRCkgLT4gKGJvb2wgaGFuZGxlZCkgU3luY2hyb25vdXMKICAg ICBUZXJtaW5hdGVVbnJlc3BvbnNpdmVTZXJ2aWNlV29ya2VyUHJvY2Vzc2VzKFdlYkNvcmU6OlBy b2Nlc3NJZGVudGlmaWVyIHByb2Nlc3NJZGVudGlmaWVyKQogCi0gICAgU2V0SXNIb2xkaW5nTG9j a2VkRmlsZXMoYm9vbCBpc0hvbGRpbmdMb2NrZWRGaWxlcykKLQogICAgICMgRGlhZ25vc3RpYyBt ZXNzYWdlcyBsb2dnaW5nCiAgICAgTG9nRGlhZ25vc3RpY01lc3NhZ2UoV2ViS2l0OjpXZWJQYWdl UHJveHlJZGVudGlmaWVyIHBhZ2VJRCwgU3RyaW5nIG1lc3NhZ2UsIFN0cmluZyBkZXNjcmlwdGlv biwgZW51bTpib29sIFdlYkNvcmU6OlNob3VsZFNhbXBsZSBzaG91bGRTYW1wbGUpCiAgICAgTG9n RGlhZ25vc3RpY01lc3NhZ2VXaXRoUmVzdWx0KFdlYktpdDo6V2ViUGFnZVByb3h5SWRlbnRpZmll ciBwYWdlSUQsIFN0cmluZyBtZXNzYWdlLCBTdHJpbmcgZGVzY3JpcHRpb24sIHVpbnQzMl90IHJl c3VsdCwgZW51bTpib29sIFdlYkNvcmU6OlNob3VsZFNhbXBsZSBzaG91bGRTYW1wbGUpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9jZXNzQXNzZXJ0aW9uLmNwcCBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb2Nlc3NBc3NlcnRpb24uY3BwCmluZGV4IGZhOGUwMzcw MTFlMzY0OTBhZTc0Nzg5NmYwMjg1NzVlOGJhZGZhYjIuLmRjMjJlZTlhMDI0OTgwMmE5MGFmZmU5 OWYwMTBjMjE3MzA2M2U5ZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1By b2Nlc3NBc3NlcnRpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb2Nlc3NB c3NlcnRpb24uY3BwCkBAIC0zMiw5ICszMiwxMCBAQAogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAot UHJvY2Vzc0Fzc2VydGlvbjo6UHJvY2Vzc0Fzc2VydGlvbihQcm9jZXNzSUQgcGlkLCBjb25zdCBT dHJpbmcmLCBQcm9jZXNzQXNzZXJ0aW9uVHlwZSBhc3NlcnRpb25UeXBlKQorUHJvY2Vzc0Fzc2Vy dGlvbjo6UHJvY2Vzc0Fzc2VydGlvbihQcm9jZXNzSUQgcGlkLCBjb25zdCBTdHJpbmcmIHJlYXNv biwgUHJvY2Vzc0Fzc2VydGlvblR5cGUgYXNzZXJ0aW9uVHlwZSkKICAgICA6IG1fYXNzZXJ0aW9u VHlwZShhc3NlcnRpb25UeXBlKQogICAgICwgbV9waWQocGlkKQorICAgICwgbV9yZWFzb24ocmVh c29uKQogewogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9jZXNz QXNzZXJ0aW9uLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm9jZXNzQXNzZXJ0aW9uLmgK aW5kZXggZWI3NWMyYTJlOTU1NGZkMjU5ZWZlZDI3NTU3MDI2ZWU5Y2EwNDYwMy4uYzNjYTY0MjY4 OGEzNjQyNzdhYTgwMGFhY2VkMjQxMTUxZjlhYTFmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvUHJvY2Vzc0Fzc2VydGlvbi5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1Byb2Nlc3NBc3NlcnRpb24uaApAQCAtNDksNiArNDksNyBAQCBlbnVtIGNsYXNzIFByb2Nl c3NBc3NlcnRpb25UeXBlIHsKICAgICBVbmJvdW5kZWROZXR3b3JraW5nLAogICAgIEZvcmVncm91 bmQsCiAgICAgTWVkaWFQbGF5YmFjaywKKyAgICBGaW5pc2hUYXNrVW5pbnRlcnJ1cHRhYmxlLAog fTsKIAogY2xhc3MgUHJvY2Vzc0Fzc2VydGlvbiA6IHB1YmxpYyBDYW5NYWtlV2Vha1B0cjxQcm9j ZXNzQXNzZXJ0aW9uPiB7CkBAIC03Miw2ICs3Myw3IEBAIHByb3RlY3RlZDoKIHByaXZhdGU6CiAg ICAgY29uc3QgUHJvY2Vzc0Fzc2VydGlvblR5cGUgbV9hc3NlcnRpb25UeXBlOwogICAgIGNvbnN0 IFByb2Nlc3NJRCBtX3BpZDsKKyAgICBjb25zdCBTdHJpbmcgbV9yZWFzb247CiAjaWYgUExBVEZP Uk0oSU9TX0ZBTUlMWSkKICAgICBSZXRhaW5QdHI8UkJTQXNzZXJ0aW9uPiBtX3Jic0Fzc2VydGlv bjsKICAgICBSZXRhaW5QdHI8V0tSQlNBc3NlcnRpb25EZWxlZ2F0ZT4gbV9kZWxlZ2F0ZTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb2Nlc3NUaHJvdHRsZXIuY3BwIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvY2Vzc1Rocm90dGxlci5jcHAKaW5kZXggYzA5MTU5 ZmE4ZTAwMGJlNDc3Nzc2ZTNkMzZkYmY1YmRkMjY3MTJkZi4uZTEzMTFhYmFjZTFmZDJmYzg5MjAz MGI1ZGE0NmFkZjcxNDA2YWI1OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv UHJvY2Vzc1Rocm90dGxlci5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvY2Vz c1Rocm90dGxlci5jcHAKQEAgLTExMiw2ICsxMTIsNyBAQCBTdHJpbmcgUHJvY2Vzc1Rocm90dGxl cjo6YXNzZXJ0aW9uTmFtZShQcm9jZXNzQXNzZXJ0aW9uVHlwZSB0eXBlKSBjb25zdAogICAgICAg ICAgICAgcmV0dXJuICJTdXNwZW5kZWQiX3M7CiAgICAgICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlv blR5cGU6OlVuYm91bmRlZE5ldHdvcmtpbmc6CiAgICAgICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlv blR5cGU6Ok1lZGlhUGxheWJhY2s6CisgICAgICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6 OkZpbmlzaFRhc2tVbmludGVycnVwdGFibGU6CiAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsgLy8gVGhlc2Ugb3RoZXIgYXNzZXJ0aW9uIHR5cGVzIGFyZSBub3QgdXNlZCBieSB0aGUg UHJvY2Vzc1Rocm90dGxlci4KICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcAppbmRleCA5OGI4MzY5MGVjNTBi Y2NkODg2NmNkYjRjN2RjOWQ4M2M3ODI5MmRlLi4wMTI4ZmQyYWVjMDkwZWJmMTZkNWIyNmE2ZTM1 YmM1YjI4NjU0ZGQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQcm9j ZXNzUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94 eS5jcHAKQEAgLTE0NzAsNiArMTQ3MCw3IEBAIHZvaWQgV2ViUHJvY2Vzc1Byb3h5OjpkaWRTZXRB c3NlcnRpb25UeXBlKFByb2Nlc3NBc3NlcnRpb25UeXBlIHR5cGUpCiAgICAgCiAgICAgY2FzZSBQ cm9jZXNzQXNzZXJ0aW9uVHlwZTo6TWVkaWFQbGF5YmFjazoKICAgICBjYXNlIFByb2Nlc3NBc3Nl cnRpb25UeXBlOjpVbmJvdW5kZWROZXR3b3JraW5nOgorICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlv blR5cGU6OkZpbmlzaFRhc2tVbmludGVycnVwdGFibGU6CiAgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9z L1Byb2Nlc3NBc3NlcnRpb25JT1MubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9pb3MvUHJv Y2Vzc0Fzc2VydGlvbklPUy5tbQppbmRleCBhYjI3ZWRlYmEyYWU2ZTVjZjJhYjhhZTBjZDEzNzI4 M2ZlMTI4M2UxLi41NmFlNjJlNDVkNzEzZGNiM2M0MThhZjQxYThkZDhlMTEwMWEzNjgyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9pb3MvUHJvY2Vzc0Fzc2VydGlvbklPUy5t bQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9pb3MvUHJvY2Vzc0Fzc2VydGlvbklPUy5t bQpAQCAtMjkxLDEyICsyOTEsMjkgQEAgc3RhdGljIE5TU3RyaW5nICpydW5uaW5nQm9hcmROYW1l Rm9yQXNzZXJ0aW9uVHlwZShQcm9jZXNzQXNzZXJ0aW9uVHlwZSBhc3NlcnRpb24KICAgICAgICAg cmV0dXJuIEAiRm9yZWdyb3VuZCI7CiAgICAgY2FzZSBQcm9jZXNzQXNzZXJ0aW9uVHlwZTo6TWVk aWFQbGF5YmFjazoKICAgICAgICAgcmV0dXJuIEAiTWVkaWFQbGF5YmFjayI7CisgICAgY2FzZSBQ cm9jZXNzQXNzZXJ0aW9uVHlwZTo6RmluaXNoVGFza1VuaW50ZXJydXB0YWJsZToKKyAgICAgICAg cmV0dXJuIEAiRmluaXNoVGFza1VuaW50ZXJydXB0YWJsZSI7CisgICAgfQorfQorCitzdGF0aWMg TlNTdHJpbmcgKnJ1bm5pbmdCb2FyZERvbWFpbkZvckFzc2VydGlvblR5cGUoUHJvY2Vzc0Fzc2Vy dGlvblR5cGUgYXNzZXJ0aW9uVHlwZSkKK3sKKyAgICBzd2l0Y2ggKGFzc2VydGlvblR5cGUpIHsK KyAgICBjYXNlIFByb2Nlc3NBc3NlcnRpb25UeXBlOjpTdXNwZW5kZWQ6CisgICAgY2FzZSBQcm9j ZXNzQXNzZXJ0aW9uVHlwZTo6QmFja2dyb3VuZDoKKyAgICBjYXNlIFByb2Nlc3NBc3NlcnRpb25U eXBlOjpVbmJvdW5kZWROZXR3b3JraW5nOgorICAgIGNhc2UgUHJvY2Vzc0Fzc2VydGlvblR5cGU6 OkZvcmVncm91bmQ6CisgICAgY2FzZSBQcm9jZXNzQXNzZXJ0aW9uVHlwZTo6TWVkaWFQbGF5YmFj azoKKyAgICAgICAgcmV0dXJuIEAiY29tLmFwcGxlLndlYmtpdCI7CisgICAgY2FzZSBQcm9jZXNz QXNzZXJ0aW9uVHlwZTo6RmluaXNoVGFza1VuaW50ZXJydXB0YWJsZToKKyAgICAgICAgcmV0dXJu IEAiY29tLmFwcGxlLmNvbW1vbiI7CiAgICAgfQogfQogCiBQcm9jZXNzQXNzZXJ0aW9uOjpQcm9j ZXNzQXNzZXJ0aW9uKHBpZF90IHBpZCwgY29uc3QgU3RyaW5nJiByZWFzb24sIFByb2Nlc3NBc3Nl cnRpb25UeXBlIGFzc2VydGlvblR5cGUpCiAgICAgOiBtX2Fzc2VydGlvblR5cGUoYXNzZXJ0aW9u VHlwZSkKICAgICAsIG1fcGlkKHBpZCkKKyAgICAsIG1fcmVhc29uKHJlYXNvbikKIHsKICAgICBO U1N0cmluZyAqcnVubmluZ0JvYXJkQXNzZXJ0aW9uTmFtZSA9IHJ1bm5pbmdCb2FyZE5hbWVGb3JB c3NlcnRpb25UeXBlKGFzc2VydGlvblR5cGUpOwogICAgIEFTU0VSVChydW5uaW5nQm9hcmRBc3Nl cnRpb25OYW1lKTsKQEAgLTMwNiw3ICszMjMsNyBAQCBQcm9jZXNzQXNzZXJ0aW9uOjpQcm9jZXNz QXNzZXJ0aW9uKHBpZF90IHBpZCwgY29uc3QgU3RyaW5nJiByZWFzb24sIFByb2Nlc3NBc3Nlcgog ICAgIH0KIAogICAgIFJCU1RhcmdldCAqdGFyZ2V0ID0gW1JCU1RhcmdldCB0YXJnZXRXaXRoUGlk OnBpZF07Ci0gICAgUkJTRG9tYWluQXR0cmlidXRlICpkb21haW5BdHRyaWJ1dGUgPSBbUkJTRG9t YWluQXR0cmlidXRlIGF0dHJpYnV0ZVdpdGhEb21haW46QCJjb20uYXBwbGUud2Via2l0IiBuYW1l OnJ1bm5pbmdCb2FyZEFzc2VydGlvbk5hbWVdOworICAgIFJCU0RvbWFpbkF0dHJpYnV0ZSAqZG9t YWluQXR0cmlidXRlID0gW1JCU0RvbWFpbkF0dHJpYnV0ZSBhdHRyaWJ1dGVXaXRoRG9tYWluOnJ1 bm5pbmdCb2FyZERvbWFpbkZvckFzc2VydGlvblR5cGUoYXNzZXJ0aW9uVHlwZSkgbmFtZTpydW5u aW5nQm9hcmRBc3NlcnRpb25OYW1lXTsKICAgICBtX3Jic0Fzc2VydGlvbiA9IGFkb3B0TlMoW1tS QlNBc3NlcnRpb24gYWxsb2NdIGluaXRXaXRoRXhwbGFuYXRpb246cmVhc29uIHRhcmdldDp0YXJn ZXQgYXR0cmlidXRlczpAW2RvbWFpbkF0dHJpYnV0ZV1dKTsKIAogICAgIG1fZGVsZWdhdGUgPSBh ZG9wdE5TKFtbV0tSQlNBc3NlcnRpb25EZWxlZ2F0ZSBhbGxvY10gaW5pdF0pOwpAQCAtMzI5LDcg KzM0Niw3IEBAIFByb2Nlc3NBc3NlcnRpb246OlByb2Nlc3NBc3NlcnRpb24ocGlkX3QgcGlkLCBj b25zdCBTdHJpbmcmIHJlYXNvbiwgUHJvY2Vzc0Fzc2VyCiAKIFByb2Nlc3NBc3NlcnRpb246On5Q cm9jZXNzQXNzZXJ0aW9uKCkKIHsKLSAgICBSRUxFQVNFX0xPRyhQcm9jZXNzU3VzcGVuc2lvbiwg IiVwIC0gflByb2Nlc3NBc3NlcnRpb24oKSBSZWxlYXNpbmcgcHJvY2VzcyBhc3NlcnRpb24gZm9y IHByb2Nlc3Mgd2l0aCBQSUQ9JWQiLCB0aGlzLCBtX3BpZCk7CisgICAgUkVMRUFTRV9MT0coUHJv Y2Vzc1N1c3BlbnNpb24sICIlcCAtIH5Qcm9jZXNzQXNzZXJ0aW9uKCkgUmVsZWFzaW5nIHByb2Nl c3MgYXNzZXJ0aW9uICcle3B1YmxpY31zJyBmb3IgcHJvY2VzcyB3aXRoIFBJRD0lZCIsIHRoaXMs IG1fcmVhc29uLnV0ZjgoKS5kYXRhKCksIG1fcGlkKTsKIAogICAgIGlmIChtX3Jic0Fzc2VydGlv bikgewogICAgICAgICBtX2RlbGVnYXRlLmdldCgpLmludmFsaWRhdGlvbkNhbGxiYWNrID0gbmls Owo=