174291 2017-07-08 11:28:19 -0700 [WTF] Remove unnecessary indirection of WTF::Thread entry point 2017-07-19 03:45:06 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 173975 174303 1 ysuzuki ysuzuki benjamin buildbot cdumez cmarcelo darin dbates fpizlo ggaren mark.lam sam oldest_to_newest 1326791 0 ysuzuki 2017-07-08 11:28:19 -0700 [WTF] Remove unnecessary indirection of WTF::Thread entry point 1326793 1 314923 ysuzuki 2017-07-08 11:34:23 -0700 Created attachment 314923 Patch 1326835 2 314936 ysuzuki 2017-07-08 21:02:22 -0700 Created attachment 314936 Patch 1326863 3 314936 mark.lam 2017-07-09 08:04:15 -0700 Comment on attachment 314936 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314936&action=review > Source/WTF/ChangeLog:13 > + Now wtfThreadEntryPoint is almost the same. Only the difference is function signature due to platform APIs. > + We remove ThreadFunctionInvocation indirection in ThreadingPthread.cpp and ThreadingWin.cpp. > + > + And we also simplify ThreadHolder::initialize a bit. Now Thread::create waits for the completion of Thread > + initialization. So, after establishing thread handle, we can call ThreadHolder::initialize before completing > + Thread initialization. I think it is useful to add: "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the Thread object alive until the thread itself could install the ThreadHolder into its thread local storage. The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation." Hmmm ... now that I've written that, I vaguely remember Geoff telling me a long time ago that the purpose for the ThreadFunctionInvocation is so that the main thread doesn't need to wait for the new thread to start before continuing. This reduces the amount of forced context switching every time we start a thread. Can you explain again why we need to synchronize thread creation and initialization? I wonder if this is bad for perf somewhere (especially with worker threads). > Source/WTF/wtf/Threading.cpp:50 > + Start, Established, Initialized Let's rename "Established" to "EstablishedHandle". I think this is clearer about what that stage does. Saying that the thread is Established vs Initialized is a bit ambiguous without first digging to find out what it means. > Source/WTF/wtf/Threading.cpp:116 > + if (!thread->launch(&context)) Let's name this "establishHandle" instead of "launch" since the result of calling it is that it is that the stage is established. > Source/WTF/wtf/Threading.cpp:118 > + context.stage = Stage::Established; Let's rename Stage::Established to Stage::EstablishedHandle. > Source/WTF/wtf/Threading.h:139 > + static void entryPoint(void* data); Let's add "struct NewThreadContext;" at the top of this file, and make this "NewThreadContext*" instead of "void* data". I think this improves documentation on the intent of what is passed around. > Source/WTF/wtf/Threading.h:144 > + bool launch(void* data); Let's rename this to "establishHandle". Let's make this "NewThreadContext*" instead of "void* data". > Source/WTF/wtf/Threading.h:147 > void establish(pthread_t); Let's rename this establishPlatformSpecificHandle. Ditto for non-PTHREADS version (which is really the Windows version) below. > Source/WTF/wtf/ThreadingPthreads.cpp:203 > + Thread::entryPoint(data); Let's cast data to NewThreadContext* here: Thread::entryPoint(reinterpret_cast<NewThreadContext*>(data)); > Source/WTF/wtf/ThreadingPthreads.cpp:207 > +bool Thread::launch(void* data) Let's rename this to "establishHandle" and make it take "NewThreadContext* context" instead of "void* data". > Source/WTF/wtf/ThreadingPthreads.cpp:221 > + establish(threadHandle); Let's rename this to "establishPlatformSpecificHandle". > Source/WTF/wtf/ThreadingWin.cpp:158 > + Thread::entryPoint(data); Let's cast data to NewThreadContext* here: Thread::entryPoint(reinterpret_cast<NewThreadContext*>(data)); > Source/WTF/wtf/ThreadingWin.cpp:162 > +bool Thread::launch(void* data) Let's rename to establishHandle, and change "void* data" to "NewThreadContext* context". > Source/WTF/wtf/ThreadingWin.cpp:170 > + establish(threadHandle, threadIdentifier); Let's rename this to "establishPlatformSpecificHandle". 1326864 4 mark.lam 2017-07-09 08:14:23 -0700 (In reply to Mark Lam from comment #3) > Comment on attachment 314936 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=314936&action=review > > > Source/WTF/ChangeLog:13 > > + Now wtfThreadEntryPoint is almost the same. Only the difference is function signature due to platform APIs. > > + We remove ThreadFunctionInvocation indirection in ThreadingPthread.cpp and ThreadingWin.cpp. > > + > > + And we also simplify ThreadHolder::initialize a bit. Now Thread::create waits for the completion of Thread > > + initialization. So, after establishing thread handle, we can call ThreadHolder::initialize before completing > > + Thread initialization. > > I think it is useful to add: > "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This > was previously needed to keep the Thread object alive until the thread > itself could install the ThreadHolder into its thread local storage. The > ThreadHolder has a Ref that keeps the Thread object alive for the lifetime > of the thread. Since Thread::create() now waits for the thread to be > initialized before returning and Thread::create() hold a Ref to the Thread > object, we are guaranteed that the Thread object will be alive long enough > for it to be installed in the thread's ThreadHolder, and we no longer need > ThreadFunctionInvocation." > > Hmmm ... now that I've written that, I vaguely remember Geoff telling me a > long time ago that the purpose for the ThreadFunctionInvocation is so that > the main thread doesn't need to wait for the new thread to start before > continuing. This reduces the amount of forced context switching every time > we start a thread. > > Can you explain again why we need to synchronize thread creation and > initialization? I wonder if this is bad for perf somewhere (especially with > worker threads). For reference, thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. 1326865 5 mark.lam 2017-07-09 08:15:16 -0700 (In reply to Mark Lam from comment #4) > For reference, thread creation and establishment/initialization was > introduced in r219176: <http://trac.webkit.org/changeset/219176> for > https://bugs.webkit.org/show_bug.cgi?id=173975. I meant to say: For reference, synchronization of thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. 1326866 6 314936 mark.lam 2017-07-09 08:25:31 -0700 Comment on attachment 314936 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314936&action=review > Source/WTF/wtf/ThreadHolderWin.cpp:94 > // Since Thread is not established yet, we use the given id instead of thread->id(). This comment is now stale in this patch. 1326893 7 314936 ysuzuki 2017-07-09 14:39:36 -0700 Comment on attachment 314936 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314936&action=review >>> Source/WTF/ChangeLog:13 >>> + Thread initialization. >> >> I think it is useful to add: >> "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the Thread object alive until the thread itself could install the ThreadHolder into its thread local storage. The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation." >> >> Hmmm ... now that I've written that, I vaguely remember Geoff telling me a long time ago that the purpose for the ThreadFunctionInvocation is so that the main thread doesn't need to wait for the new thread to start before continuing. This reduces the amount of forced context switching every time we start a thread. >> >> Can you explain again why we need to synchronize thread creation and initialization? I wonder if this is bad for perf somewhere (especially with worker threads). > > For reference, thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. Waiting for thread initialization in the caller side is important to move stack from wtfThreadData to Thread. StackBounds information is only collected in the thread itself. If the caller accesses thread->stack() before the target thread initializes it, we have a bad time. This is why the caller waits for the target thread initialization. The other possible design is guard thread->stack() with lock. In that case, we should use globalStaticLock heled in ::suspend()/resume() functions. If we use the other locks (like thread->m_mutex), we encounter dead locks. The reason is described in https://bugs.webkit.org/show_bug.cgi?id=174081's ChangeLog. In that case, stack() is guarded by the global lock. BTW, while waiting for initialization is necessary, we can drop waiting for establishment. I'll change this part in a separate patch. >> Source/WTF/wtf/ThreadHolderWin.cpp:94 >> // Since Thread is not established yet, we use the given id instead of thread->id(). > > This comment is now stale in this patch. Fixed. >> Source/WTF/wtf/Threading.cpp:50 >> + Start, Established, Initialized > > Let's rename "Established" to "EstablishedHandle". I think this is clearer about what that stage does. Saying that the thread is Established vs Initialized is a bit ambiguous without first digging to find out what it means. Fixed. >> Source/WTF/wtf/Threading.cpp:116 >> + if (!thread->launch(&context)) > > Let's name this "establishHandle" instead of "launch" since the result of calling it is that it is that the stage is established. Fixed. >> Source/WTF/wtf/Threading.cpp:118 >> + context.stage = Stage::Established; > > Let's rename Stage::Established to Stage::EstablishedHandle. Fixed. >> Source/WTF/wtf/Threading.h:139 >> + static void entryPoint(void* data); > > Let's add "struct NewThreadContext;" at the top of this file, and make this "NewThreadContext*" instead of "void* data". I think this improves documentation on the intent of what is passed around. Fixed. >> Source/WTF/wtf/Threading.h:144 >> + bool launch(void* data); > > Let's rename this to "establishHandle". > Let's make this "NewThreadContext*" instead of "void* data". Fixed. >> Source/WTF/wtf/Threading.h:147 >> void establish(pthread_t); > > Let's rename this establishPlatformSpecificHandle. Ditto for non-PTHREADS version (which is really the Windows version) below. Fixed. >> Source/WTF/wtf/ThreadingPthreads.cpp:203 >> + Thread::entryPoint(data); > > Let's cast data to NewThreadContext* here: > Thread::entryPoint(reinterpret_cast<NewThreadContext*>(data)); Fixed. >> Source/WTF/wtf/ThreadingPthreads.cpp:207 >> +bool Thread::launch(void* data) > > Let's rename this to "establishHandle" and make it take "NewThreadContext* context" instead of "void* data". Fixed. >> Source/WTF/wtf/ThreadingPthreads.cpp:221 >> + establish(threadHandle); > > Let's rename this to "establishPlatformSpecificHandle". Fixed. >> Source/WTF/wtf/ThreadingWin.cpp:158 >> + Thread::entryPoint(data); > > Let's cast data to NewThreadContext* here: > Thread::entryPoint(reinterpret_cast<NewThreadContext*>(data)); Fixed. >> Source/WTF/wtf/ThreadingWin.cpp:162 >> +bool Thread::launch(void* data) > > Let's rename to establishHandle, and change "void* data" to "NewThreadContext* context". Fixed. >> Source/WTF/wtf/ThreadingWin.cpp:170 >> + establish(threadHandle, threadIdentifier); > > Let's rename this to "establishPlatformSpecificHandle". Fixed. 1326903 8 314956 ysuzuki 2017-07-09 15:34:41 -0700 Created attachment 314956 Patch 1326910 9 314936 ysuzuki 2017-07-09 17:57:05 -0700 Comment on attachment 314936 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314936&action=review >>>> Source/WTF/ChangeLog:13 >>>> + Thread initialization. >>> >>> I think it is useful to add: >>> "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the Thread object alive until the thread itself could install the ThreadHolder into its thread local storage. The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation." >>> >>> Hmmm ... now that I've written that, I vaguely remember Geoff telling me a long time ago that the purpose for the ThreadFunctionInvocation is so that the main thread doesn't need to wait for the new thread to start before continuing. This reduces the amount of forced context switching every time we start a thread. >>> >>> Can you explain again why we need to synchronize thread creation and initialization? I wonder if this is bad for perf somewhere (especially with worker threads). >> >> For reference, thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. > > Waiting for thread initialization in the caller side is important to move stack from wtfThreadData to Thread. > StackBounds information is only collected in the thread itself. If the caller accesses thread->stack() before the target thread initializes it, we have a bad time. > This is why the caller waits for the target thread initialization. > > The other possible design is guard thread->stack() with lock. In that case, we should use globalStaticLock heled in ::suspend()/resume() functions. > If we use the other locks (like thread->m_mutex), we encounter dead locks. The reason is described in https://bugs.webkit.org/show_bug.cgi?id=174081's ChangeLog. > In that case, stack() is guarded by the global lock. > > BTW, while waiting for initialization is necessary, we can drop waiting for establishment. I'll change this part in a separate patch. In the case of non-Solaris UNIX, we can get StackBounds from the platform thread handle. So, we can merge this initialiation phase to establishment phase. In that implementation, the caller no longer need to wait the initialiation. But it requires tweaks in StackBounds for Solaris and Windows. So it should be done after introducing this refactoring. 1326924 10 mark.lam 2017-07-09 19:45:29 -0700 (In reply to Yusuke Suzuki from comment #9) > Comment on attachment 314936 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=314936&action=review > > >>>> Source/WTF/ChangeLog:13 > >>>> + Thread initialization. > >>> > >>> I think it is useful to add: > >>> "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the Thread object alive until the thread itself could install the ThreadHolder into its thread local storage. The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation." > >>> > >>> Hmmm ... now that I've written that, I vaguely remember Geoff telling me a long time ago that the purpose for the ThreadFunctionInvocation is so that the main thread doesn't need to wait for the new thread to start before continuing. This reduces the amount of forced context switching every time we start a thread. > >>> > >>> Can you explain again why we need to synchronize thread creation and initialization? I wonder if this is bad for perf somewhere (especially with worker threads). > >> > >> For reference, thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. > > > > Waiting for thread initialization in the caller side is important to move stack from wtfThreadData to Thread. > > StackBounds information is only collected in the thread itself. If the caller accesses thread->stack() before the target thread initializes it, we have a bad time. > > This is why the caller waits for the target thread initialization. > > > > The other possible design is guard thread->stack() with lock. In that case, we should use globalStaticLock heled in ::suspend()/resume() functions. > > If we use the other locks (like thread->m_mutex), we encounter dead locks. The reason is described in https://bugs.webkit.org/show_bug.cgi?id=174081's ChangeLog. > > In that case, stack() is guarded by the global lock. > > > > BTW, while waiting for initialization is necessary, we can drop waiting for establishment. I'll change this part in a separate patch. > > In the case of non-Solaris UNIX, we can get StackBounds from the platform > thread handle. > So, we can merge this initialiation phase to establishment phase. In that > implementation, the caller no longer need to wait the initialiation. > > But it requires tweaks in StackBounds for Solaris and Windows. So it should > be done after introducing this refactoring. I still don't understand why the thread creator needs to wait for the created thread to start. Let's consider the following: Let's say Thread A creates Thread B. How things work now is that A instantiates a new Thread object with its StackBounds set to empty, and passes this Thread object to B to be initialized. 1. If B has initialized its StackBounds by the time A suspends B and asks for the stack, everything works as we expect. Nothing special here. 2. If B has NOT initialized its StackBounds by the time A suspends B and asks for the stack, B's thread will have an empty stack bounds, and A should be fine with iterating an empty stack (i.e. a no-op). The only issue that can arise is a potential race condition where B has only partially initialized its StackBounds when A suspends B. As a result, A may read an inconsistent stack bounds for B. We can prevent this by simply having the thread initialization code hold the global suspension lock while initializing. That ensures that Thread A will only see an empty stack or a properly initialized stack for Thread B because A should only read B's thread data after suspending B. We also currently set the ThreadID in the new thread (Thread B). We can also change to setting the TheadID in the constructor for the Thread object (i.e. do it in Thread A) even before the new thread (Thread B) starts running. Given the above, why does Thread A have to wait for Thread B to be initialized at all? If it is true that Thread A doesn't have to wait for Thread B to be initialized, then I think we should not get rid of ThreadFunctionInvocation. ThreadFunctionInvocation allows Thread A create Thread B without forcing a context switch immediately back and forth between the 2 (which is a perf benefit). What do you think? Am I missing something? 1326927 11 314936 ysuzuki 2017-07-09 20:09:46 -0700 Comment on attachment 314936 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314936&action=review >>>>>> Source/WTF/ChangeLog:13 >>>>>> + Thread initialization. >>>>> >>>>> I think it is useful to add: >>>>> "Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the Thread object alive until the thread itself could install the ThreadHolder into its thread local storage. The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation." >>>>> >>>>> Hmmm ... now that I've written that, I vaguely remember Geoff telling me a long time ago that the purpose for the ThreadFunctionInvocation is so that the main thread doesn't need to wait for the new thread to start before continuing. This reduces the amount of forced context switching every time we start a thread. >>>>> >>>>> Can you explain again why we need to synchronize thread creation and initialization? I wonder if this is bad for perf somewhere (especially with worker threads). >>>> >>>> For reference, thread creation and establishment/initialization was introduced in r219176: <http://trac.webkit.org/changeset/219176> for https://bugs.webkit.org/show_bug.cgi?id=173975. >>> >>> Waiting for thread initialization in the caller side is important to move stack from wtfThreadData to Thread. >>> StackBounds information is only collected in the thread itself. If the caller accesses thread->stack() before the target thread initializes it, we have a bad time. >>> This is why the caller waits for the target thread initialization. >>> >>> The other possible design is guard thread->stack() with lock. In that case, we should use globalStaticLock heled in ::suspend()/resume() functions. >>> If we use the other locks (like thread->m_mutex), we encounter dead locks. The reason is described in https://bugs.webkit.org/show_bug.cgi?id=174081's ChangeLog. >>> In that case, stack() is guarded by the global lock. >>> >>> BTW, while waiting for initialization is necessary, we can drop waiting for establishment. I'll change this part in a separate patch. >> >> In the case of non-Solaris UNIX, we can get StackBounds from the platform thread handle. >> So, we can merge this initialiation phase to establishment phase. In that implementation, the caller no longer need to wait the initialiation. >> >> But it requires tweaks in StackBounds for Solaris and Windows. So it should be done after introducing this refactoring. > > I still don't understand why the thread creator needs to wait for the created thread to start. Let's consider the following: > > Let's say Thread A creates Thread B. > How things work now is that A instantiates a new Thread object with its StackBounds set to empty, and passes this Thread object to B to be initialized. > > 1. If B has initialized its StackBounds by the time A suspends B and asks for the stack, everything works as we expect. Nothing special here. > 2. If B has NOT initialized its StackBounds by the time A suspends B and asks for the stack, B's thread will have an empty stack bounds, and A should be fine with iterating an empty stack (i.e. a no-op). > > The only issue that can arise is a potential race condition where B has only partially initialized its StackBounds when A suspends B. As a result, A may read an inconsistent stack bounds for B. We can prevent this by simply having the thread initialization code hold the global suspension lock while initializing. That ensures that Thread A will only see an empty stack or a properly initialized stack for Thread B because A should only read B's thread data after suspending B. > > We also currently set the ThreadID in the new thread (Thread B). We can also change to setting the TheadID in the constructor for the Thread object (i.e. do it in Thread A) even before the new thread (Thread B) starts running. > > Given the above, why does Thread A have to wait for Thread B to be initialized at all? > > If it is true that Thread A doesn't have to wait for Thread B to be initialized, then I think we should not get rid of ThreadFunctionInvocation. ThreadFunctionInvocation allows Thread A create Thread B without forcing a context switch immediately back and forth between the 2 (which is a perf benefit). > > What do you think? Am I missing something? Currently, we do not assume that this 'stack' is only accessed when suspending the thread. And we also do not assume that the stack value returned from Thread can be changed. It is difficult to understand this semantics from the `Thread::stack()` signature. So I would like to take the safer way: `Thread::stack()` always returns the desired value. Furthermore, I think we can drop this initialization waiting for Darwin and UNIX envirnoments (excluding Solaris), by adding a new static function, StackBounds::stackBounds(Thread&) which takes arbitrary thread. Once StackBounds change is done, we can have non-waiting threads (for initialization) and they always get desired stack values. (At least on non-Solaris UNIX environments) I prefer this design because Thread::stack() can always return desired values without waiting thread initialization. 1327637 12 314956 mark.lam 2017-07-11 12:03:18 -0700 Comment on attachment 314956 Patch r=me 1330344 13 ysuzuki 2017-07-19 03:45:06 -0700 Committed r219654: <http://trac.webkit.org/changeset/219654> 314923 2017-07-08 11:34:23 -0700 2017-07-08 21:02:20 -0700 Patch bug-174291-20170709033422.patch text/plain 19858 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjE5Mjc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDAyMTFhMjA3Yzc0ZTU1NGZhNWVkNWY0 ODA1ZWRmOTQzYmZhNmQ2NmIuLjRiOGFkMDQzZDUyNjEwYTAyMTdhOWEyZWI0Mjc1ZjUzZWZmYThj OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNDQgQEAKKzIwMTctMDctMDggIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gUmVtb3ZlIHVubmVjZXNzYXJ5IGlu ZGlyZWN0aW9uIG9mIFdURjo6VGhyZWFkIGVudHJ5IHBvaW50CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzQyOTEKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOb3cgd3RmVGhyZWFkRW50cnlQb2ludCBpcyBh bG1vc3QgdGhlIHNhbWUuIE9ubHkgdGhlIGRpZmZlcmVuY2UgaXMgZnVuY3Rpb24gc2lnbmF0dXJl IGR1ZSB0byBwbGF0Zm9ybSBBUElzLgorICAgICAgICBXZSByZW1vdmUgVGhyZWFkRnVuY3Rpb25J bnZvY2F0aW9uIGluZGlyZWN0aW9uIGluIFRocmVhZGluZ1B0aHJlYWQuY3BwIGFuZCBUaHJlYWRp bmdXaW4uY3BwLgorCisgICAgICAgIEFuZCB3ZSBhbHNvIHNpbXBsaWZ5IFRocmVhZEhvbGRlcjo6 aW5pdGlhbGl6ZSBhIGJpdC4gTm93IFRocmVhZDo6Y3JlYXRlIHdhaXRzIGZvciB0aGUgY29tcGxl dGlvbiBvZiBUaHJlYWQKKyAgICAgICAgaW5pdGlhbGl6YXRpb24uIFNvLCBhZnRlciBlc3RhYmxp c2hpbmcgdGhyZWFkIGhhbmRsZSwgd2UgY2FuIGNhbGwgVGhyZWFkSG9sZGVyOjppbml0aWFsaXpl IGJlZm9yZSBjb21wbGV0aW5nCisgICAgICAgIFRocmVhZCBpbml0aWFsaXphdGlvbi4KKworICAg ICAgICBBbHNvIHdlIGRyb3AgZXJybm8uaCBpZmRlZnMgaW4gVGhyZWFkaW5nV2luLmNwcC4gVGhp cyBpcyBpbnRyb2R1Y2VkIHRvIHN1cHBvcnQgV2luQ0UuIEJ1dCBub3cgV2luQ0UgcG9ydCBpcyBy ZW1vdmVkLgorCisgICAgICAgICogV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAg ICAgICogd3RmL1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oOiBSZW1vdmVkLgorICAgICAgICAq IHd0Zi9UaHJlYWRIb2xkZXIuaDoKKyAgICAgICAgKiB3dGYvVGhyZWFkSG9sZGVyV2luLmNwcDoK KyAgICAgICAgKFdURjo6VGhyZWFkSG9sZGVyOjppbml0aWFsaXplKToKKyAgICAgICAgKiB3dGYv VGhyZWFkaW5nLmNwcDoKKyAgICAgICAgKFdURjo6VGhyZWFkOjplbnRyeVBvaW50KToKKyAgICAg ICAgKFdURjo6VGhyZWFkOjpjcmVhdGUpOgorICAgICAgICAoV1RGOjp0aHJlYWRFbnRyeVBvaW50 KTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvVGhyZWFkaW5nLmg6CisgICAgICAgICogd3RmL1Ro cmVhZGluZ1B0aHJlYWRzLmNwcDoKKyAgICAgICAgKFdURjo6VGhyZWFkOjppbml0aWFsaXplQ3Vy cmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQpOgorICAgICAgICAoV1RGOjp3dGZUaHJlYWRF bnRyeVBvaW50KToKKyAgICAgICAgKFdURjo6VGhyZWFkOjpsYXVuY2gpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmN1cnJlbnQpOgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmNyZWF0ZUludGVybmFs KTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvVGhyZWFkaW5nV2luLmNwcDoKKyAgICAgICAgKFdU Rjo6VGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQpOgor ICAgICAgICAoV1RGOjpUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwpOgor ICAgICAgICAoV1RGOjp3dGZUaHJlYWRFbnRyeVBvaW50KToKKyAgICAgICAgKFdURjo6VGhyZWFk OjpsYXVuY2gpOgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmN1cnJlbnQpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmNyZWF0ZUludGVybmFsKTogRGVsZXRlZC4KKwogMjAxNy0wNy0wNyAgQnJlbnQg RnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbV0syXSBVc2UgYSByb2xs aW5nIDMwLWRheSB1cHRpbWUgZm9yIHByb2Nlc3Npbmcgc3RhdGlzdGljcwpkaWZmIC0tZ2l0IGEv U291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XVEYvV1RG Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMmU5NmM4MzA1YzBhOGIxZTQ0ODNkNjNj NThhOGM3YTFkM2ZjYTAyZi4uZjMwYjNjMDIzMDE1MTkxNDI2YTZkZmJjMjJmM2I3ZjBmMmFmZjAw NiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagor KysgYi9Tb3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00OTEsNyAr NDkxLDYgQEAKIAkJQThBNDczMkMxNTFBODI1QjAwNDEyM0ZGIC8qIFRleHRQb3NpdGlvbi5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBUZXh0UG9zaXRpb24uaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQThBNDczMkQxNTFBODI1QjAwNDEyM0ZGIC8qIFdURlN0cmlu Zy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXVEZTdHJpbmcuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzMyRTE1MUE4MjVCMDA0MTIzRkYg LyogV1RGU3RyaW5nLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdURlN0cmlu Zy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQlBOEE0NzMyRjE1MUE4MjVCMDA0MTIz RkYgLyogVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlBOEE0NzMzMDE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkSG9sZGVyUHRocmVh ZHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gVGhyZWFkSG9sZGVy UHRocmVhZHMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzMzMjE1MUE4 MjVCMDA0MTIzRkYgLyogVGhyZWFkaW5nLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFRocmVhZGluZy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4 QTQ3MzMzMTUxQTgyNUIwMDQxMjNGRiAvKiBUaHJlYWRpbmcuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gVGhyZWFkaW5nLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBA IC05NTUsNyArOTU0LDYgQEAKIAkJCQk1NTk3RjgyQzFEOTRCOTk3MDA2NkJDMjEgLyogU3luY2hy b25pemVkRml4ZWRRdWV1ZS5oICovLAogCQkJCUUzRTE1ODI1MUVBREE1M0MwMDRBMDc5RCAvKiBT eXN0ZW1GcmVlLmggKi8sCiAJCQkJMEZCMzE3QzMxQzQ4ODAwMTAwN0UzOTVBIC8qIFN5c3RlbVRy YWNpbmcuaCAqLywKLQkJCQlBOEE0NzMyRjE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkRnVuY3Rp b25JbnZvY2F0aW9uLmggKi8sCiAJCQkJRTMyMDBBQjUxRTlBNTM2RDAwM0I1OUQyIC8qIFRocmVh ZEhvbGRlci5jcHAgKi8sCiAJCQkJRTMyMDBBQjYxRTlBNTM2RDAwM0I1OUQyIC8qIFRocmVhZEhv bGRlci5oICovLAogCQkJCUE4QTQ3MzMwMTUxQTgyNUIwMDQxMjNGRiAvKiBUaHJlYWRIb2xkZXJQ dGhyZWFkcy5jcHAgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRGdW5jdGlv bkludm9jYXRpb24uaCBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5o CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjYjI3NWY3MDEyY2ZlNTY2MWU0OWUwYjRm ZjBkOWM2MjFiMGU0OTlmLi4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oCisrKyAvZGV2 L251bGwKQEAgLTEsNTUgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLiAKLSAqIDIu ICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLiAKLSAqIDMu ICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMg b2YKLSAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkCi0gKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQg c3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLiAKLSAqCi0gKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFO WQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORAotICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBP RgotICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbl9o Ci0jZGVmaW5lIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbl9oCi0KLSNpbmNsdWRlICJUaHJlYWRp bmcuaCIKLQotbmFtZXNwYWNlIFdURiB7Ci0KLXR5cGVkZWYgdm9pZCAoKlRocmVhZEZ1bmN0aW9u KSh2b2lkKiBhcmd1bWVudCk7Ci0KLXN0cnVjdCBUaHJlYWRGdW5jdGlvbkludm9jYXRpb24gewot ICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwotcHVibGljOgotICAgIFRocmVhZEZ1bmN0aW9u SW52b2NhdGlvbihUaHJlYWRGdW5jdGlvbiBmdW5jdGlvbiwgUmVmUHRyPFRocmVhZD4mJiB0aHJl YWQsIHZvaWQqIGRhdGEpCi0gICAgICAgIDogZnVuY3Rpb24oZnVuY3Rpb24pCi0gICAgICAgICwg dGhyZWFkKFdURk1vdmUodGhyZWFkKSkKLSAgICAgICAgLCBkYXRhKGRhdGEpCi0gICAgewotICAg IH0KLQotICAgIFRocmVhZEZ1bmN0aW9uIGZ1bmN0aW9uOwotICAgIFJlZlB0cjxUaHJlYWQ+IHRo cmVhZDsKLSAgICB2b2lkKiBkYXRhOwotfTsKLQotfSAvLyBuYW1lc3BhY2UgV1RGCi0KLSNlbmRp ZiAvLyBUaHJlYWRGdW5jdGlvbkludm9jYXRpb25faApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93 dGYvVGhyZWFkSG9sZGVyLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRIb2xkZXIuaAppbmRleCBk Y2Y4Nzk0MWI5MjhiZTJjNmM3YjI3ZjE0ZmQ3NDY3MjJhZjJjNGU0Li5iMmY4ZGU2ODg1MGM2YWZk Yzc5ZWZkYWRhMDliZTZkZWZiMTgyNmE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJl YWRIb2xkZXIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRIb2xkZXIuaApAQCAtNTAsMTEg KzUwLDcgQEAgY2xhc3MgVGhyZWFkSG9sZGVyIHsKICAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXpl T25jZSgpOwogCiAgICAgLy8gQ3JlYXRlcyBhbmQgcHV0cyBhbiBpbnN0YW5jZSBvZiBUaHJlYWRI b2xkZXIgaW50byB0aHJlYWQtc3BlY2lmaWMgc3RvcmFnZS4KLSNpZiBPUyhXSU5ET1dTKQotICAg IHN0YXRpYyB2b2lkIGluaXRpYWxpemUoVGhyZWFkJiwgVGhyZWFkSWRlbnRpZmllcik7Ci0jZWxz ZQogICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemUoVGhyZWFkJik7Ci0jZW5kaWYKIAogICAgIC8v IFJldHVybnMgMCBpZiB0aHJlYWQtc3BlY2lmaWMgc3RvcmFnZSB3YXMgbm90IGluaXRpYWxpemVk LgogICAgIHN0YXRpYyBUaHJlYWRIb2xkZXIqIGN1cnJlbnQoKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XVEYvd3RmL1RocmVhZEhvbGRlcldpbi5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRIb2xk ZXJXaW4uY3BwCmluZGV4IGNlZGRhNjU2OGZjMGIzYWIxMWVhZGZkN2Q2NTQ4ZjI2ZjExMzczMjIu LmFiM2M0YTFjNjIxN2I5M2Y4ZGIzMmYxNmMwNDgwY2VhZTk4MzE4ODQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XVEYvd3RmL1RocmVhZEhvbGRlcldpbi5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVGhy ZWFkSG9sZGVyV2luLmNwcApAQCAtODAsNyArODAsNyBAQCBSZWZQdHI8VGhyZWFkPiBUaHJlYWRI b2xkZXI6OmdldChUaHJlYWRJZGVudGlmaWVyIGlkKQogICAgIHJldHVybiBudWxscHRyOwogfQog Ci12b2lkIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZShUaHJlYWQmIHRocmVhZCwgVGhyZWFkSWRl bnRpZmllciBpZCkKK3ZvaWQgVGhyZWFkSG9sZGVyOjppbml0aWFsaXplKFRocmVhZCYgdGhyZWFk KQogewogICAgIGlmICghY3VycmVudCgpKSB7CiAgICAgICAgIC8vIElkZWFsbHkgd2UnZCBoYXZl IHRoaXMgYXMgYSByZWxlYXNlIGFzc2VydCBldmVyeXdoZXJlLCBidXQgdGhhdCB3b3VsZCBodXJ0 IHBlcmZvcm1hbmNlLgpAQCAtOTQsNyArOTQsNyBAQCB2b2lkIFRocmVhZEhvbGRlcjo6aW5pdGlh bGl6ZShUaHJlYWQmIHRocmVhZCwgVGhyZWFkSWRlbnRpZmllciBpZCkKICAgICAgICAgLy8gU2lu Y2UgVGhyZWFkIGlzIG5vdCBlc3RhYmxpc2hlZCB5ZXQsIHdlIHVzZSB0aGUgZ2l2ZW4gaWQgaW5z dGVhZCBvZiB0aHJlYWQtPmlkKCkuCiAgICAgICAgIHsKICAgICAgICAgICAgIHN0ZDo6bG9ja19n dWFyZDxzdGQ6Om11dGV4PiBsb2NrZXIodGhyZWFkTWFwTXV0ZXgoKSk7Ci0gICAgICAgICAgICB0 aHJlYWRNYXAoKS5hZGQoaWQsIGhvbGRlcik7CisgICAgICAgICAgICB0aHJlYWRNYXAoKS5hZGQo dGhyZWFkLmlkKCksIGhvbGRlcik7CiAgICAgICAgIH0KICAgICB9CiB9CmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmcuY3BwIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNw cAppbmRleCA4MzYyZWUzOGY4NWMwNzg2MzMwNzFlOTBkMjI0NDFlMDc3ODk0ZTNjLi40ZWQzMWQz NWZlYTdhZmFiYzhjMDA2YWU3MGQzZjUxOGYwNmVhZGNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RG L3d0Zi9UaHJlYWRpbmcuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAKQEAg LTQ3LDcgKzQ3LDcgQEAKIG5hbWVzcGFjZSBXVEYgewogCiBlbnVtIGNsYXNzIFN0YWdlIHsKLSAg ICBTdGFydCwgSW5pdGlhbGl6ZWQKKyAgICBTdGFydCwgRXN0YWJsaXNoZWQsIEluaXRpYWxpemVk CiB9OwogCiBzdHJ1Y3QgTmV3VGhyZWFkQ29udGV4dCB7CkBAIC01Niw2ICs1Niw3IEBAIHN0cnVj dCBOZXdUaHJlYWRDb250ZXh0IHsKICAgICBTdGFnZSBzdGFnZTsKICAgICBNdXRleCBtdXRleDsK ICAgICBUaHJlYWRDb25kaXRpb24gY29uZGl0aW9uOworICAgIFRocmVhZCYgdGhyZWFkOwogfTsK IAogY29uc3QgY2hhciogVGhyZWFkOjpub3JtYWxpemVUaHJlYWROYW1lKGNvbnN0IGNoYXIqIHRo cmVhZE5hbWUpCkBAIC04NSwzNiArODYsNDAgQEAgY29uc3QgY2hhciogVGhyZWFkOjpub3JtYWxp emVUaHJlYWROYW1lKGNvbnN0IGNoYXIqIHRocmVhZE5hbWUpCiAjZW5kaWYKIH0KIAotc3RhdGlj IHZvaWQgdGhyZWFkRW50cnlQb2ludCh2b2lkKiBjb250ZXh0RGF0YSkKK3ZvaWQgVGhyZWFkOjpl bnRyeVBvaW50KHZvaWQqIGNvbnRleHREYXRhKQogewogICAgIE5ld1RocmVhZENvbnRleHQqIGNv bnRleHQgPSBzdGF0aWNfY2FzdDxOZXdUaHJlYWRDb250ZXh0Kj4oY29udGV4dERhdGEpOwotICAg IEZ1bmN0aW9uPHZvaWQoKT4gZW50cnlQb2ludDsKKyAgICBGdW5jdGlvbjx2b2lkKCk+IGZ1bmN0 aW9uOwogICAgIHsKICAgICAgICAgLy8gQmxvY2sgdW50aWwgb3VyIGNyZWF0aW5nIHRocmVhZCBo YXMgY29tcGxldGVkIGFueSBleHRyYSBzZXR1cCB3b3JrLCBpbmNsdWRpbmcgZXN0YWJsaXNoaW5n IFRocmVhZElkZW50aWZpZXIuCiAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihjb250ZXh0LT5t dXRleCk7CisgICAgICAgIEFTU0VSVChjb250ZXh0LT5zdGFnZSA9PSBTdGFnZTo6RXN0YWJsaXNo ZWQpOworCisgICAgICAgIC8vIEluaXRpYWxpemUgdGhyZWFkIGhvbGRlciB3aXRoIGVzdGFibGlz aGVkIElELgorICAgICAgICBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUoY29udGV4dC0+dGhyZWFk KTsKIAotICAgICAgICBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29u dGV4dC0+bmFtZSk7Ci0gICAgICAgIGVudHJ5UG9pbnQgPSBXVEZNb3ZlKGNvbnRleHQtPmVudHJ5 UG9pbnQpOworICAgICAgICBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwo Y29udGV4dC0+dGhyZWFkLCBjb250ZXh0LT5uYW1lKTsKKyAgICAgICAgZnVuY3Rpb24gPSBXVEZN b3ZlKGNvbnRleHQtPmVudHJ5UG9pbnQpOwogCiAgICAgICAgIC8vIEFjayBjb21wbGV0aW9uIG9m IGluaXRpYWxpemF0aW9uIHRvIHRoZSBjcmVhdGluZyB0aHJlYWQuCiAgICAgICAgIGNvbnRleHQt PnN0YWdlID0gU3RhZ2U6OkluaXRpYWxpemVkOwogICAgICAgICBjb250ZXh0LT5jb25kaXRpb24u c2lnbmFsKCk7CiAgICAgfQotCi0gICAgZW50cnlQb2ludCgpOworICAgIGZ1bmN0aW9uKCk7CiB9 CiAKIFJlZlB0cjxUaHJlYWQ+IFRocmVhZDo6Y3JlYXRlKGNvbnN0IGNoYXIqIG5hbWUsIEZ1bmN0 aW9uPHZvaWQoKT4mJiBlbnRyeVBvaW50KQogewotICAgIE5ld1RocmVhZENvbnRleHQgY29udGV4 dCB7IG5hbWUsIFdURk1vdmUoZW50cnlQb2ludCksIFN0YWdlOjpTdGFydCwgeyB9LCB7IH0gfTsK LQorICAgIFJlZjxUaHJlYWQ+IHRocmVhZCA9IGFkb3B0UmVmKCpuZXcgVGhyZWFkKCkpOworICAg IE5ld1RocmVhZENvbnRleHQgY29udGV4dCB7IG5hbWUsIFdURk1vdmUoZW50cnlQb2ludCksIFN0 YWdlOjpTdGFydCwgeyB9LCB7IH0sIHRocmVhZC5nZXQoKSB9OwogICAgIE11dGV4TG9ja2VyIGxv Y2tlcihjb250ZXh0Lm11dGV4KTsKLSAgICBSZWZQdHI8VGhyZWFkPiByZXN1bHQgPSBUaHJlYWQ6 OmNyZWF0ZUludGVybmFsKHRocmVhZEVudHJ5UG9pbnQsICZjb250ZXh0LCBuYW1lKTsKKyAgICBp ZiAoIXRocmVhZC0+bGF1bmNoKCZjb250ZXh0KSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7Cisg ICAgY29udGV4dC5zdGFnZSA9IFN0YWdlOjpFc3RhYmxpc2hlZDsKICAgICAvLyBBZnRlciBlc3Rh Ymxpc2hpbmcgVGhyZWFkLCByZWxlYXNlIHRoZSBtdXRleCBhbmQgd2FpdCBmb3IgY29tcGxldGlv biBvZiBpbml0aWFsaXphdGlvbi4KICAgICB3aGlsZSAoY29udGV4dC5zdGFnZSAhPSBTdGFnZTo6 SW5pdGlhbGl6ZWQpCiAgICAgICAgIGNvbnRleHQuY29uZGl0aW9uLndhaXQoY29udGV4dC5tdXRl eCk7Ci0KLSAgICByZXR1cm4gcmVzdWx0OworICAgIHJldHVybiBXVEZNb3ZlKHRocmVhZCk7CiB9 CiAKIFRocmVhZCogVGhyZWFkOjpjdXJyZW50TWF5QmVOdWxsKCkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XVEYvd3RmL1RocmVhZGluZy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKaW5kZXgg ODg4MWNjZWU4ZGE0MGUzZDBmNDJhYjgwNjg0ODMwMDk4NzY2OWFiYS4uMGQ3MzNhMDk1MzkzNTI5 ZGE2ZWVjYTRlMDMxZDlkZTAzZGZmODljNiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVGhy ZWFkaW5nLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKQEAgLTEwOCw4ICsxMDgs OCBAQCBjbGFzcyBUaHJlYWQgOiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7 CiAKICAgICAvLyBDYWxsZWQgaW4gdGhlIHRocmVhZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24uCiAg ICAgLy8gSGVscGZ1bCBmb3IgcGxhdGZvcm1zIHdoZXJlIHRoZSB0aHJlYWQgbmFtZSBtdXN0IGJl IHNldCBmcm9tIHdpdGhpbiB0aGUgdGhyZWFkLgotICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemVD dXJyZW50VGhyZWFkSW50ZXJuYWwoY29uc3QgY2hhciogdGhyZWFkTmFtZSk7Ci0gICAgc3RhdGlj IHZvaWQgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCk7CisgICAg c3RhdGljIHZvaWQgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbChUaHJlYWQmLCBjb25z dCBjaGFyKiB0aHJlYWROYW1lKTsKKyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplQ3VycmVudFRo cmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoVGhyZWFkJik7CiAKICAgICBXVEZfRVhQT1JUX1BSSVZB VEUgdm9pZCBkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0OwogCkBAIC0xMzYsMTEgKzEzNiwx MiBAQCBjbGFzcyBUaHJlYWQgOiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7 CiAgICAgbWFjaF9wb3J0X3QgbWFjaFRocmVhZCgpIHsgcmV0dXJuIG1fcGxhdGZvcm1UaHJlYWQ7 IH0KICNlbmRpZgogCisgICAgc3RhdGljIHZvaWQgZW50cnlQb2ludCh2b2lkKiBkYXRhKTsKIHBy b3RlY3RlZDoKICAgICBUaHJlYWQoKTsKIAotICAgIC8vIEludGVybmFsIHBsYXRmb3JtLXNwZWNp ZmljIFRocmVhZDo6Y3JlYXRlIGltcGxlbWVudGF0aW9uLgotICAgIHN0YXRpYyBSZWZQdHI8VGhy ZWFkPiBjcmVhdGVJbnRlcm5hbChUaHJlYWRGdW5jdGlvbiwgdm9pZCosIGNvbnN0IGNoYXIqIHRo cmVhZE5hbWUpOworICAgIC8vIEludGVybmFsIHBsYXRmb3JtLXNwZWNpZmljIFRocmVhZCBsYXVu Y2hpbmcgaW1wbGVtZW50YXRpb24uCisgICAgYm9vbCBsYXVuY2godm9pZCogZGF0YSk7CiAKICNp ZiBVU0UoUFRIUkVBRFMpCiAgICAgdm9pZCBlc3RhYmxpc2gocHRocmVhZF90KTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1B0aHJlYWRzLmNwcCBiL1NvdXJjZS9XVEYvd3Rm L1RocmVhZGluZ1B0aHJlYWRzLmNwcAppbmRleCBmYTgwYzA0ODAxOWQ4OWQzYTk4MDI5NjkzYjc2 ZGIyODljYTcxNTI0Li4xMGE4ZDJmMDI1ODQwOTEyMzFlOTI3MTI0ZTA3YzVhNTIxMDMyNmY1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmdQdGhyZWFkcy5jcHAKKysrIGIvU291 cmNlL1dURi93dGYvVGhyZWFkaW5nUHRocmVhZHMuY3BwCkBAIC00MCw3ICs0MCw2IEBACiAjaW5j bHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8d3RmL1Jhd1BvaW50ZXIuaD4K ICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+Ci0jaW5jbHVkZSA8d3RmL1RocmVhZEZ1bmN0 aW9uSW52b2NhdGlvbi5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRIb2xkZXIuaD4KICNpbmNsdWRl IDx3dGYvVGhyZWFkaW5nUHJpbWl0aXZlcy5oPgogI2luY2x1ZGUgPHd0Zi9Xb3JkTG9jay5oPgpA QCAtMTg4LDkgKzE4Nyw5IEBAIHZvaWQgVGhyZWFkOjppbml0aWFsaXplUGxhdGZvcm1UaHJlYWRp bmcoKQogI2VuZGlmCiB9CiAKLXZvaWQgVGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEV2 ZW5JZk5vbldURkNyZWF0ZWQoKQordm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFk RXZlbklmTm9uV1RGQ3JlYXRlZChUaHJlYWQmIHRocmVhZCkKIHsKLSAgICBUaHJlYWQ6OmN1cnJl bnQoKS5pbml0aWFsaXplKCk7CisgICAgdGhyZWFkLmluaXRpYWxpemUoKTsKICNpZiAhT1MoREFS V0lOKQogICAgIHNpZ3NldF90IG1hc2s7CiAgICAgc2lnZW1wdHlzZXQoJm1hc2spOwpAQCAtMTk5 LDQ0ICsxOTgsMzEgQEAgdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklm Tm9uV1RGQ3JlYXRlZCgpCiAjZW5kaWYKIH0KIAotc3RhdGljIHZvaWQqIHd0ZlRocmVhZEVudHJ5 UG9pbnQodm9pZCogcGFyYW0pCitzdGF0aWMgdm9pZCogd3RmVGhyZWFkRW50cnlQb2ludCh2b2lk KiBkYXRhKQogewotICAgIC8vIEJhbGFuY2VkIGJ5IC5sZWFrUHRyKCkgaW4gVGhyZWFkOjpjcmVh dGVJbnRlcm5hbC4KLSAgICBhdXRvIGludm9jYXRpb24gPSBzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFk RnVuY3Rpb25JbnZvY2F0aW9uPihzdGF0aWNfY2FzdDxUaHJlYWRGdW5jdGlvbkludm9jYXRpb24q PihwYXJhbSkpOwotCi0gICAgVGhyZWFkSG9sZGVyOjppbml0aWFsaXplKCppbnZvY2F0aW9uLT50 aHJlYWQpOwotICAgIGludm9jYXRpb24tPnRocmVhZCA9IG51bGxwdHI7Ci0KLSAgICBpbnZvY2F0 aW9uLT5mdW5jdGlvbihpbnZvY2F0aW9uLT5kYXRhKTsKKyAgICBUaHJlYWQ6OmVudHJ5UG9pbnQo ZGF0YSk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKLVJlZlB0cjxUaHJlYWQ+IFRocmVhZDo6 Y3JlYXRlSW50ZXJuYWwoVGhyZWFkRnVuY3Rpb24gZW50cnlQb2ludCwgdm9pZCogZGF0YSwgY29u c3QgY2hhciopCitib29sIFRocmVhZDo6bGF1bmNoKHZvaWQqIGRhdGEpCiB7Ci0gICAgUmVmUHRy PFRocmVhZD4gdGhyZWFkID0gYWRvcHRSZWYobmV3IFRocmVhZCgpKTsKLSAgICBhdXRvIGludm9j YXRpb24gPSBzdGQ6Om1ha2VfdW5pcXVlPFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbj4oZW50cnlQ b2ludCwgdGhyZWFkLmdldCgpLCBkYXRhKTsKICAgICBwdGhyZWFkX3QgdGhyZWFkSGFuZGxlOwog ICAgIHB0aHJlYWRfYXR0cl90IGF0dHI7CiAgICAgcHRocmVhZF9hdHRyX2luaXQoJmF0dHIpOwog I2lmIEhBVkUoUU9TX0NMQVNTRVMpCiAgICAgcHRocmVhZF9hdHRyX3NldF9xb3NfY2xhc3NfbnAo JmF0dHIsIGFkanVzdGVkUU9TQ2xhc3MoUU9TX0NMQVNTX1VTRVJfSU5JVElBVEVEKSwgMCk7CiAj ZW5kaWYKLSAgICBpbnQgZXJyb3IgPSBwdGhyZWFkX2NyZWF0ZSgmdGhyZWFkSGFuZGxlLCAmYXR0 ciwgd3RmVGhyZWFkRW50cnlQb2ludCwgaW52b2NhdGlvbi5nZXQoKSk7CisgICAgaW50IGVycm9y ID0gcHRocmVhZF9jcmVhdGUoJnRocmVhZEhhbmRsZSwgJmF0dHIsIHd0ZlRocmVhZEVudHJ5UG9p bnQsIGRhdGEpOwogICAgIHB0aHJlYWRfYXR0cl9kZXN0cm95KCZhdHRyKTsKICAgICBpZiAoZXJy b3IpIHsKLSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHB0aHJlYWQgYXQgZW50 cnkgcG9pbnQgJXAgd2l0aCBkYXRhICVwIiwgd3RmVGhyZWFkRW50cnlQb2ludCwgaW52b2NhdGlv bi5nZXQoKSk7Ci0gICAgICAgIHJldHVybiBudWxscHRyOworICAgICAgICBMT0dfRVJST1IoIkZh aWxlZCB0byBjcmVhdGUgcHRocmVhZCBhdCBlbnRyeSBwb2ludCAlcCB3aXRoIGRhdGEgJXAiLCB3 dGZUaHJlYWRFbnRyeVBvaW50LCBkYXRhKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0K LQotICAgIC8vIEJhbGFuY2VkIGJ5IHN0ZDo6dW5pcXVlX3B0ciBjb25zdHJ1Y3RvciBpbiB3dGZU aHJlYWRFbnRyeVBvaW50LgotICAgIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbiogbGVha2VkSW52 b2NhdGlvbiA9IGludm9jYXRpb24ucmVsZWFzZSgpOwotICAgIFVOVVNFRF9QQVJBTShsZWFrZWRJ bnZvY2F0aW9uKTsKLQotICAgIHRocmVhZC0+ZXN0YWJsaXNoKHRocmVhZEhhbmRsZSk7Ci0gICAg cmV0dXJuIHRocmVhZDsKKyAgICBlc3RhYmxpc2godGhyZWFkSGFuZGxlKTsKKyAgICByZXR1cm4g dHJ1ZTsKIH0KIAotdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwo Y29uc3QgY2hhciogdGhyZWFkTmFtZSkKK3ZvaWQgVGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRo cmVhZEludGVybmFsKFRocmVhZCYgdGhyZWFkLCBjb25zdCBjaGFyKiB0aHJlYWROYW1lKQogewog I2lmIEhBVkUoUFRIUkVBRF9TRVROQU1FX05QKQogICAgIHB0aHJlYWRfc2V0bmFtZV9ucChub3Jt YWxpemVUaHJlYWROYW1lKHRocmVhZE5hbWUpKTsKQEAgLTI0NSw3ICsyMzEsNyBAQCB2b2lkIFRo cmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbChjb25zdCBjaGFyKiB0aHJlYWRO YW1lKQogI2Vsc2UKICAgICBVTlVTRURfUEFSQU0odGhyZWFkTmFtZSk7CiAjZW5kaWYKLSAgICBp bml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoKTsKKyAgICBpbml0aWFs aXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQodGhyZWFkKTsKIH0KIAogdm9pZCBU aHJlYWQ6OmNoYW5nZVByaW9yaXR5KGludCBkZWx0YSkKQEAgLTMwOSw3ICsyOTUsNyBAQCBUaHJl YWQmIFRocmVhZDo6Y3VycmVudCgpCiAgICAgUmVmPFRocmVhZD4gdGhyZWFkID0gYWRvcHRSZWYo Km5ldyBUaHJlYWQoKSk7CiAgICAgdGhyZWFkLT5lc3RhYmxpc2gocHRocmVhZF9zZWxmKCkpOwog ICAgIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZSh0aHJlYWQuZ2V0KCkpOwotICAgIGluaXRpYWxp emVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCgpOworICAgIGluaXRpYWxpemVDdXJy ZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCh0aHJlYWQuZ2V0KCkpOwogICAgIHJldHVybiB0 aHJlYWQuZ2V0KCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1dp bi5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmdXaW4uY3BwCmluZGV4IGVlMWM0ZDQzZmU3 ZjE1MjM2YWQ5NWJhOWE3YmFkN2ExZTQxMzY0NzIuLjc1OWIyMjM2ZTdiYjQ4ZDQxNjNlYzZhYWFj NWFhYTIzYzU1MmRlY2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1dpbi5j cHAKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nV2luLmNwcApAQCAtODgsMjAgKzg4LDE2 IEBACiAKICNpZiBPUyhXSU5ET1dTKQogCisjaW5jbHVkZSA8ZXJybm8uaD4KICNpbmNsdWRlIDxw cm9jZXNzLmg+CiAjaW5jbHVkZSA8d2luZG93cy5oPgogI2luY2x1ZGUgPHd0Zi9DdXJyZW50VGlt ZS5oPgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAjaW5jbHVkZSA8d3RmL01hdGhFeHRy YXMuaD4KICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KLSNpbmNsdWRlIDx3dGYvVGhy ZWFkRnVuY3Rpb25JbnZvY2F0aW9uLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZEhvbGRlci5oPgog I2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmdQcmltaXRpdmVzLmg+CiAKLSNpZiBIQVZFKEVSUk5PX0gp Ci0jaW5jbHVkZSA8ZXJybm8uaD4KLSNlbmRpZgotCiBuYW1lc3BhY2UgV1RGIHsKIAogVGhyZWFk OjpUaHJlYWQoKQpAQCAtMTE2LDkgKzExMiw5IEBAIFRocmVhZDo6flRocmVhZCgpCiAgICAgICAg IENsb3NlSGFuZGxlKG1faGFuZGxlKTsKIH0KIAotdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJy ZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCgpCit2b2lkIFRocmVhZDo6aW5pdGlhbGl6ZUN1 cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKFRocmVhZCYgdGhyZWFkKQogewotICAgIFRo cmVhZDo6Y3VycmVudCgpLmluaXRpYWxpemUoKTsKKyAgICB0aHJlYWQuaW5pdGlhbGl6ZSgpOwog fQogCiAvLyBNU19WQ19FWENFUFRJT04sIFRIUkVBRE5BTUVfSU5GTywgYW5kIHNldFRocmVhZE5h bWVJbnRlcm5hbCBhbGwgY29tZSBmcm9tIDxodHRwOi8vbXNkbi5taWNyb3NvZnQuY29tL2VuLXVz L2xpYnJhcnkveGNiMno4aHMuYXNweD4uCkBAIC0xMzMsNyArMTI5LDcgQEAgdHlwZWRlZiBzdHJ1 Y3QgdGFnVEhSRUFETkFNRV9JTkZPIHsKIH0gVEhSRUFETkFNRV9JTkZPOwogI3ByYWdtYSBwYWNr KHBvcCkKIAotdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29u c3QgY2hhciogc3pUaHJlYWROYW1lKQordm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhy ZWFkSW50ZXJuYWwoVGhyZWFkJiB0aHJlYWQsIGNvbnN0IGNoYXIqIHN6VGhyZWFkTmFtZSkKIHsK ICNpZiBDT01QSUxFUihNSU5HVykKICAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRocmVhZCBuYW1l IHNldHRpbmcgd2l0aCBNaW5nVy4KQEAgLTE1MCw0OSArMTQ2LDI5IEBAIHZvaWQgVGhyZWFkOjpp bml0aWFsaXplQ3VycmVudFRocmVhZEludGVybmFsKGNvbnN0IGNoYXIqIHN6VGhyZWFkTmFtZSkK ICAgICB9IF9fZXhjZXB0IChFWENFUFRJT05fQ09OVElOVUVfRVhFQ1VUSU9OKSB7CiAgICAgfQog I2VuZGlmCi0gICAgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCk7 CisgICAgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKHRocmVhZCk7 CiB9CiAKIHZvaWQgVGhyZWFkOjppbml0aWFsaXplUGxhdGZvcm1UaHJlYWRpbmcoKQogewogfQog Ci1zdGF0aWMgdW5zaWduZWQgX19zdGRjYWxsIHd0ZlRocmVhZEVudHJ5UG9pbnQodm9pZCogcGFy YW0pCitzdGF0aWMgdW5zaWduZWQgX19zdGRjYWxsIHd0ZlRocmVhZEVudHJ5UG9pbnQodm9pZCog ZGF0YSkKIHsKLSAgICAvLyBCYWxhbmNlZCBieSAubGVha1B0cigpIGluIFRocmVhZDo6Y3JlYXRl SW50ZXJuYWwuCi0gICAgYXV0byBpbnZvY2F0aW9uID0gc3RkOjp1bmlxdWVfcHRyPFRocmVhZEZ1 bmN0aW9uSW52b2NhdGlvbj4oc3RhdGljX2Nhc3Q8VGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uKj4o cGFyYW0pKTsKLQotICAgIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZSgqaW52b2NhdGlvbi0+dGhy ZWFkLCBUaHJlYWQ6OmN1cnJlbnRJRCgpKTsKLSAgICBpbnZvY2F0aW9uLT50aHJlYWQgPSBudWxs cHRyOwotCi0gICAgaW52b2NhdGlvbi0+ZnVuY3Rpb24oaW52b2NhdGlvbi0+ZGF0YSk7CisgICAg VGhyZWFkOjplbnRyeVBvaW50KGRhdGEpOwogICAgIHJldHVybiAwOwogfQogCi1SZWZQdHI8VGhy ZWFkPiBUaHJlYWQ6OmNyZWF0ZUludGVybmFsKFRocmVhZEZ1bmN0aW9uIGVudHJ5UG9pbnQsIHZv aWQqIGRhdGEsIGNvbnN0IGNoYXIqIHRocmVhZE5hbWUpCitib29sIFRocmVhZDo6bGF1bmNoKHZv aWQqIGRhdGEpCiB7Ci0gICAgUmVmPFRocmVhZD4gdGhyZWFkID0gYWRvcHRSZWYoKm5ldyBUaHJl YWQoKSk7CiAgICAgdW5zaWduZWQgdGhyZWFkSWRlbnRpZmllciA9IDA7Ci0gICAgVGhyZWFkSWRl bnRpZmllciB0aHJlYWRJRCA9IDA7Ci0gICAgYXV0byBpbnZvY2F0aW9uID0gc3RkOjptYWtlX3Vu aXF1ZTxUaHJlYWRGdW5jdGlvbkludm9jYXRpb24+KGVudHJ5UG9pbnQsIHRocmVhZC5wdHIoKSwg ZGF0YSk7Ci0gICAgSEFORExFIHRocmVhZEhhbmRsZSA9IHJlaW50ZXJwcmV0X2Nhc3Q8SEFORExF PihfYmVnaW50aHJlYWRleCgwLCAwLCB3dGZUaHJlYWRFbnRyeVBvaW50LCBpbnZvY2F0aW9uLmdl dCgpLCAwLCAmdGhyZWFkSWRlbnRpZmllcikpOworICAgIEhBTkRMRSB0aHJlYWRIYW5kbGUgPSBy ZWludGVycHJldF9jYXN0PEhBTkRMRT4oX2JlZ2ludGhyZWFkZXgoMCwgMCwgd3RmVGhyZWFkRW50 cnlQb2ludCwgZGF0YSwgMCwgJnRocmVhZElkZW50aWZpZXIpKTsKICAgICBpZiAoIXRocmVhZEhh bmRsZSkgewotI2lmICFIQVZFKEVSUk5PX0gpCi0gICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRv IGNyZWF0ZSB0aHJlYWQgYXQgZW50cnkgcG9pbnQgJXAgd2l0aCBkYXRhICVwLiIsIGVudHJ5UG9p bnQsIGRhdGEpOwotI2Vsc2UKLSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRo cmVhZCBhdCBlbnRyeSBwb2ludCAlcCB3aXRoIGRhdGEgJXA6ICVsZCIsIGVudHJ5UG9pbnQsIGRh dGEsIGVycm5vKTsKLSNlbmRpZgotICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgTE9HX0VSUk9S KCJGYWlsZWQgdG8gY3JlYXRlIHRocmVhZCBhdCBlbnRyeSBwb2ludCAlcCB3aXRoIGRhdGEgJXA6 ICVsZCIsIHd0ZlRocmVhZEVudHJ5UG9pbnQsIGRhdGEsIGVycm5vKTsKKyAgICAgICAgcmV0dXJu IGZhbHNlOwogICAgIH0KLQotICAgIC8vIFRoZSB0aHJlYWQgd2lsbCB0YWtlIG93bmVyc2hpcCBv ZiBpbnZvY2F0aW9uLgotICAgIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbiogbGVha2VkSW52b2Nh dGlvbiA9IGludm9jYXRpb24ucmVsZWFzZSgpOwotICAgIFVOVVNFRF9QQVJBTShsZWFrZWRJbnZv Y2F0aW9uKTsKLQotICAgIHRocmVhZElEID0gc3RhdGljX2Nhc3Q8VGhyZWFkSWRlbnRpZmllcj4o dGhyZWFkSWRlbnRpZmllcik7Ci0KLSAgICB0aHJlYWQtPmVzdGFibGlzaCh0aHJlYWRIYW5kbGUs IHRocmVhZElkZW50aWZpZXIpOwotICAgIHJldHVybiB0aHJlYWQ7CisgICAgZXN0YWJsaXNoKHRo cmVhZEhhbmRsZSwgdGhyZWFkSWRlbnRpZmllcik7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIHZv aWQgVGhyZWFkOjpjaGFuZ2VQcmlvcml0eShpbnQgZGVsdGEpCkBAIC0yNzgsOCArMjU0LDggQEAg VGhyZWFkJiBUaHJlYWQ6OmN1cnJlbnQoKQogICAgIFJFTEVBU0VfQVNTRVJUKGlzU3VjY2Vzc2Z1 bCk7CiAKICAgICB0aHJlYWQtPmVzdGFibGlzaChoYW5kbGUsIGN1cnJlbnRJRCgpKTsKLSAgICBU aHJlYWRIb2xkZXI6OmluaXRpYWxpemUodGhyZWFkLmdldCgpLCBUaHJlYWQ6OmN1cnJlbnRJRCgp KTsKLSAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoKTsKKyAg ICBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUodGhyZWFkLmdldCgpKTsKKyAgICBpbml0aWFsaXpl Q3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQodGhyZWFkLmdldCgpKTsKICAgICByZXR1 cm4gdGhyZWFkLmdldCgpOwogfQogCg== 314936 2017-07-08 21:02:22 -0700 2017-07-09 15:34:38 -0700 Patch bug-174291-20170709130221.patch text/plain 20620 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjE5Mjc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDAyMTFhMjA3Yzc0ZTU1NGZhNWVkNWY0 ODA1ZWRmOTQzYmZhNmQ2NmIuLjg0ZTY5OThmMjQ4NDI0YmU1NTMyNTZkNDkzYWNjZDM3Mzg2YjI0 MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNDYgQEAKKzIwMTctMDctMDggIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gUmVtb3ZlIHVubmVjZXNzYXJ5IGlu ZGlyZWN0aW9uIG9mIFdURjo6VGhyZWFkIGVudHJ5IHBvaW50CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzQyOTEKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOb3cgd3RmVGhyZWFkRW50cnlQb2ludCBpcyBh bG1vc3QgdGhlIHNhbWUuIE9ubHkgdGhlIGRpZmZlcmVuY2UgaXMgZnVuY3Rpb24gc2lnbmF0dXJl IGR1ZSB0byBwbGF0Zm9ybSBBUElzLgorICAgICAgICBXZSByZW1vdmUgVGhyZWFkRnVuY3Rpb25J bnZvY2F0aW9uIGluZGlyZWN0aW9uIGluIFRocmVhZGluZ1B0aHJlYWQuY3BwIGFuZCBUaHJlYWRp bmdXaW4uY3BwLgorCisgICAgICAgIEFuZCB3ZSBhbHNvIHNpbXBsaWZ5IFRocmVhZEhvbGRlcjo6 aW5pdGlhbGl6ZSBhIGJpdC4gTm93IFRocmVhZDo6Y3JlYXRlIHdhaXRzIGZvciB0aGUgY29tcGxl dGlvbiBvZiBUaHJlYWQKKyAgICAgICAgaW5pdGlhbGl6YXRpb24uIFNvLCBhZnRlciBlc3RhYmxp c2hpbmcgdGhyZWFkIGhhbmRsZSwgd2UgY2FuIGNhbGwgVGhyZWFkSG9sZGVyOjppbml0aWFsaXpl IGJlZm9yZSBjb21wbGV0aW5nCisgICAgICAgIFRocmVhZCBpbml0aWFsaXphdGlvbi4KKworICAg ICAgICBBbHNvIHdlIGRyb3AgZXJybm8uaCBpZmRlZnMgaW4gVGhyZWFkaW5nV2luLmNwcC4gVGhp cyBpcyBpbnRyb2R1Y2VkIHRvIHN1cHBvcnQgV2luQ0UuIEJ1dCBub3cgV2luQ0UgcG9ydCBpcyBy ZW1vdmVkLgorCisgICAgICAgICogV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAg ICAgICogd3RmL1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oOiBSZW1vdmVkLgorICAgICAgICAq IHd0Zi9UaHJlYWRIb2xkZXIuaDoKKyAgICAgICAgKiB3dGYvVGhyZWFkSG9sZGVyV2luLmNwcDoK KyAgICAgICAgKFdURjo6VGhyZWFkSG9sZGVyOjppbml0aWFsaXplKToKKyAgICAgICAgKiB3dGYv VGhyZWFkaW5nLmNwcDoKKyAgICAgICAgKFdURjo6VGhyZWFkOjplbnRyeVBvaW50KToKKyAgICAg ICAgKFdURjo6VGhyZWFkOjpjcmVhdGUpOgorICAgICAgICAoV1RGOjp0aHJlYWRFbnRyeVBvaW50 KTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvVGhyZWFkaW5nLmg6CisgICAgICAgICogd3RmL1Ro cmVhZGluZ1B0aHJlYWRzLmNwcDoKKyAgICAgICAgKFdURjo6VGhyZWFkOjppbml0aWFsaXplQ3Vy cmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQpOgorICAgICAgICAoV1RGOjp3dGZUaHJlYWRF bnRyeVBvaW50KToKKyAgICAgICAgKFdURjo6VGhyZWFkOjpsYXVuY2gpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmN1cnJlbnQpOgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmNyZWF0ZUludGVybmFs KTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvVGhyZWFkaW5nV2luLmNwcDoKKyAgICAgICAgKFdU Rjo6VGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQpOgor ICAgICAgICAoV1RGOjpUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwpOgor ICAgICAgICAoV1RGOjp3dGZUaHJlYWRFbnRyeVBvaW50KToKKyAgICAgICAgKFdURjo6VGhyZWFk OjpsYXVuY2gpOgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmN1cnJlbnQpOgorICAgICAgICAoV1RG OjpUaHJlYWQ6OmNyZWF0ZUludGVybmFsKTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvd2luL01h aW5UaHJlYWRXaW4uY3BwOgorICAgICAgICAoV1RGOjppbml0aWFsaXplTWFpblRocmVhZFBsYXRm b3JtKToKKwogMjAxNy0wNy0wNyAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4K IAogICAgICAgICBbV0syXSBVc2UgYSByb2xsaW5nIDMwLWRheSB1cHRpbWUgZm9yIHByb2Nlc3Np bmcgc3RhdGlzdGljcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvaiBiL1NvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5k ZXggMmU5NmM4MzA1YzBhOGIxZTQ0ODNkNjNjNThhOGM3YTFkM2ZjYTAyZi4uZjMwYjNjMDIzMDE1 MTkxNDI2YTZkZmJjMjJmM2I3ZjBmMmFmZjAwNiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9XVEYu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV1RGL1dURi54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCkBAIC00OTEsNyArNDkxLDYgQEAKIAkJQThBNDczMkMxNTFBODI1QjAw NDEyM0ZGIC8qIFRleHRQb3NpdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBUZXh0UG9zaXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQThBNDczMkQx NTFBODI1QjAwNDEyM0ZGIC8qIFdURlN0cmluZy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBXVEZTdHJpbmcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlBOEE0NzMyRTE1MUE4MjVCMDA0MTIzRkYgLyogV1RGU3RyaW5nLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IFdURlN0cmluZy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwotCQlBOEE0NzMyRjE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9u LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFRocmVhZEZ1bmN0aW9uSW52b2Nh dGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzMzMDE1MUE4MjVCMDA0 MTIzRkYgLyogVGhyZWFkSG9sZGVyUHRocmVhZHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gVGhyZWFkSG9sZGVyUHRocmVhZHMuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlBOEE0NzMzMjE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkaW5nLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFRocmVhZGluZy5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3MzMzMTUxQTgyNUIwMDQxMjNGRiAvKiBUaHJl YWRpbmcuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVGhyZWFkaW5nLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC05NTUsNyArOTU0LDYgQEAKIAkJCQk1NTk3Rjgy QzFEOTRCOTk3MDA2NkJDMjEgLyogU3luY2hyb25pemVkRml4ZWRRdWV1ZS5oICovLAogCQkJCUUz RTE1ODI1MUVBREE1M0MwMDRBMDc5RCAvKiBTeXN0ZW1GcmVlLmggKi8sCiAJCQkJMEZCMzE3QzMx QzQ4ODAwMTAwN0UzOTVBIC8qIFN5c3RlbVRyYWNpbmcuaCAqLywKLQkJCQlBOEE0NzMyRjE1MUE4 MjVCMDA0MTIzRkYgLyogVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uLmggKi8sCiAJCQkJRTMyMDBB QjUxRTlBNTM2RDAwM0I1OUQyIC8qIFRocmVhZEhvbGRlci5jcHAgKi8sCiAJCQkJRTMyMDBBQjYx RTlBNTM2RDAwM0I1OUQyIC8qIFRocmVhZEhvbGRlci5oICovLAogCQkJCUE4QTQ3MzMwMTUxQTgy NUIwMDQxMjNGRiAvKiBUaHJlYWRIb2xkZXJQdGhyZWFkcy5jcHAgKi8sCmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9UaHJlYWRGdW5jdGlvbkludm9jYXRpb24uaCBiL1NvdXJjZS9XVEYvd3Rm L1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCBjYjI3NWY3MDEyY2ZlNTY2MWU0OWUwYjRmZjBkOWM2MjFiMGU0OTlmLi4wMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZEZ1 bmN0aW9uSW52b2NhdGlvbi5oCisrKyAvZGV2L251bGwKQEAgLTEsNTUgKzAsMCBAQAotLyoKLSAq IENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu Ci0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKgotICogMS4g IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLiAKLSAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK LSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLiAKLSAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIElu Yy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKLSAqICAgICBpdHMgY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCi0gKiAgICAg ZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNz aW9uLiAKLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMg Q09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRQotICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRT IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAq IChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAotICogT04gQU5ZIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgotICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVm IFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbl9oCi0jZGVmaW5lIFRocmVhZEZ1bmN0aW9uSW52b2Nh dGlvbl9oCi0KLSNpbmNsdWRlICJUaHJlYWRpbmcuaCIKLQotbmFtZXNwYWNlIFdURiB7Ci0KLXR5 cGVkZWYgdm9pZCAoKlRocmVhZEZ1bmN0aW9uKSh2b2lkKiBhcmd1bWVudCk7Ci0KLXN0cnVjdCBU aHJlYWRGdW5jdGlvbkludm9jYXRpb24gewotICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwot cHVibGljOgotICAgIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbihUaHJlYWRGdW5jdGlvbiBmdW5j dGlvbiwgUmVmUHRyPFRocmVhZD4mJiB0aHJlYWQsIHZvaWQqIGRhdGEpCi0gICAgICAgIDogZnVu Y3Rpb24oZnVuY3Rpb24pCi0gICAgICAgICwgdGhyZWFkKFdURk1vdmUodGhyZWFkKSkKLSAgICAg ICAgLCBkYXRhKGRhdGEpCi0gICAgewotICAgIH0KLQotICAgIFRocmVhZEZ1bmN0aW9uIGZ1bmN0 aW9uOwotICAgIFJlZlB0cjxUaHJlYWQ+IHRocmVhZDsKLSAgICB2b2lkKiBkYXRhOwotfTsKLQot fSAvLyBuYW1lc3BhY2UgV1RGCi0KLSNlbmRpZiAvLyBUaHJlYWRGdW5jdGlvbkludm9jYXRpb25f aApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvVGhyZWFkSG9sZGVyLmggYi9Tb3VyY2UvV1RG L3d0Zi9UaHJlYWRIb2xkZXIuaAppbmRleCBkY2Y4Nzk0MWI5MjhiZTJjNmM3YjI3ZjE0ZmQ3NDY3 MjJhZjJjNGU0Li5iMmY4ZGU2ODg1MGM2YWZkYzc5ZWZkYWRhMDliZTZkZWZiMTgyNmE5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRIb2xkZXIuaAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9UaHJlYWRIb2xkZXIuaApAQCAtNTAsMTEgKzUwLDcgQEAgY2xhc3MgVGhyZWFkSG9sZGVyIHsK ICAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplT25jZSgpOwogCiAgICAgLy8gQ3JlYXRlcyBhbmQg cHV0cyBhbiBpbnN0YW5jZSBvZiBUaHJlYWRIb2xkZXIgaW50byB0aHJlYWQtc3BlY2lmaWMgc3Rv cmFnZS4KLSNpZiBPUyhXSU5ET1dTKQotICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemUoVGhyZWFk JiwgVGhyZWFkSWRlbnRpZmllcik7Ci0jZWxzZQogICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemUo VGhyZWFkJik7Ci0jZW5kaWYKIAogICAgIC8vIFJldHVybnMgMCBpZiB0aHJlYWQtc3BlY2lmaWMg c3RvcmFnZSB3YXMgbm90IGluaXRpYWxpemVkLgogICAgIHN0YXRpYyBUaHJlYWRIb2xkZXIqIGN1 cnJlbnQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZEhvbGRlcldpbi5jcHAg Yi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRIb2xkZXJXaW4uY3BwCmluZGV4IGNlZGRhNjU2OGZjMGIz YWIxMWVhZGZkN2Q2NTQ4ZjI2ZjExMzczMjIuLmFiM2M0YTFjNjIxN2I5M2Y4ZGIzMmYxNmMwNDgw Y2VhZTk4MzE4ODQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZEhvbGRlcldpbi5j cHAKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkSG9sZGVyV2luLmNwcApAQCAtODAsNyArODAs NyBAQCBSZWZQdHI8VGhyZWFkPiBUaHJlYWRIb2xkZXI6OmdldChUaHJlYWRJZGVudGlmaWVyIGlk KQogICAgIHJldHVybiBudWxscHRyOwogfQogCi12b2lkIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6 ZShUaHJlYWQmIHRocmVhZCwgVGhyZWFkSWRlbnRpZmllciBpZCkKK3ZvaWQgVGhyZWFkSG9sZGVy Ojppbml0aWFsaXplKFRocmVhZCYgdGhyZWFkKQogewogICAgIGlmICghY3VycmVudCgpKSB7CiAg ICAgICAgIC8vIElkZWFsbHkgd2UnZCBoYXZlIHRoaXMgYXMgYSByZWxlYXNlIGFzc2VydCBldmVy eXdoZXJlLCBidXQgdGhhdCB3b3VsZCBodXJ0IHBlcmZvcm1hbmNlLgpAQCAtOTQsNyArOTQsNyBA QCB2b2lkIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZShUaHJlYWQmIHRocmVhZCwgVGhyZWFkSWRl bnRpZmllciBpZCkKICAgICAgICAgLy8gU2luY2UgVGhyZWFkIGlzIG5vdCBlc3RhYmxpc2hlZCB5 ZXQsIHdlIHVzZSB0aGUgZ2l2ZW4gaWQgaW5zdGVhZCBvZiB0aHJlYWQtPmlkKCkuCiAgICAgICAg IHsKICAgICAgICAgICAgIHN0ZDo6bG9ja19ndWFyZDxzdGQ6Om11dGV4PiBsb2NrZXIodGhyZWFk TWFwTXV0ZXgoKSk7Ci0gICAgICAgICAgICB0aHJlYWRNYXAoKS5hZGQoaWQsIGhvbGRlcik7Cisg ICAgICAgICAgICB0aHJlYWRNYXAoKS5hZGQodGhyZWFkLmlkKCksIGhvbGRlcik7CiAgICAgICAg IH0KICAgICB9CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmcuY3BwIGIv U291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcAppbmRleCA4MzYyZWUzOGY4NWMwNzg2MzMwNzFl OTBkMjI0NDFlMDc3ODk0ZTNjLi40ZWQzMWQzNWZlYTdhZmFiYzhjMDA2YWU3MGQzZjUxOGYwNmVh ZGNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmcuY3BwCisrKyBiL1NvdXJj ZS9XVEYvd3RmL1RocmVhZGluZy5jcHAKQEAgLTQ3LDcgKzQ3LDcgQEAKIG5hbWVzcGFjZSBXVEYg ewogCiBlbnVtIGNsYXNzIFN0YWdlIHsKLSAgICBTdGFydCwgSW5pdGlhbGl6ZWQKKyAgICBTdGFy dCwgRXN0YWJsaXNoZWQsIEluaXRpYWxpemVkCiB9OwogCiBzdHJ1Y3QgTmV3VGhyZWFkQ29udGV4 dCB7CkBAIC01Niw2ICs1Niw3IEBAIHN0cnVjdCBOZXdUaHJlYWRDb250ZXh0IHsKICAgICBTdGFn ZSBzdGFnZTsKICAgICBNdXRleCBtdXRleDsKICAgICBUaHJlYWRDb25kaXRpb24gY29uZGl0aW9u OworICAgIFRocmVhZCYgdGhyZWFkOwogfTsKIAogY29uc3QgY2hhciogVGhyZWFkOjpub3JtYWxp emVUaHJlYWROYW1lKGNvbnN0IGNoYXIqIHRocmVhZE5hbWUpCkBAIC04NSwzNiArODYsNDAgQEAg Y29uc3QgY2hhciogVGhyZWFkOjpub3JtYWxpemVUaHJlYWROYW1lKGNvbnN0IGNoYXIqIHRocmVh ZE5hbWUpCiAjZW5kaWYKIH0KIAotc3RhdGljIHZvaWQgdGhyZWFkRW50cnlQb2ludCh2b2lkKiBj b250ZXh0RGF0YSkKK3ZvaWQgVGhyZWFkOjplbnRyeVBvaW50KHZvaWQqIGNvbnRleHREYXRhKQog ewogICAgIE5ld1RocmVhZENvbnRleHQqIGNvbnRleHQgPSBzdGF0aWNfY2FzdDxOZXdUaHJlYWRD b250ZXh0Kj4oY29udGV4dERhdGEpOwotICAgIEZ1bmN0aW9uPHZvaWQoKT4gZW50cnlQb2ludDsK KyAgICBGdW5jdGlvbjx2b2lkKCk+IGZ1bmN0aW9uOwogICAgIHsKICAgICAgICAgLy8gQmxvY2sg dW50aWwgb3VyIGNyZWF0aW5nIHRocmVhZCBoYXMgY29tcGxldGVkIGFueSBleHRyYSBzZXR1cCB3 b3JrLCBpbmNsdWRpbmcgZXN0YWJsaXNoaW5nIFRocmVhZElkZW50aWZpZXIuCiAgICAgICAgIE11 dGV4TG9ja2VyIGxvY2tlcihjb250ZXh0LT5tdXRleCk7CisgICAgICAgIEFTU0VSVChjb250ZXh0 LT5zdGFnZSA9PSBTdGFnZTo6RXN0YWJsaXNoZWQpOworCisgICAgICAgIC8vIEluaXRpYWxpemUg dGhyZWFkIGhvbGRlciB3aXRoIGVzdGFibGlzaGVkIElELgorICAgICAgICBUaHJlYWRIb2xkZXI6 OmluaXRpYWxpemUoY29udGV4dC0+dGhyZWFkKTsKIAotICAgICAgICBUaHJlYWQ6OmluaXRpYWxp emVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29udGV4dC0+bmFtZSk7Ci0gICAgICAgIGVudHJ5UG9p bnQgPSBXVEZNb3ZlKGNvbnRleHQtPmVudHJ5UG9pbnQpOworICAgICAgICBUaHJlYWQ6OmluaXRp YWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29udGV4dC0+dGhyZWFkLCBjb250ZXh0LT5uYW1l KTsKKyAgICAgICAgZnVuY3Rpb24gPSBXVEZNb3ZlKGNvbnRleHQtPmVudHJ5UG9pbnQpOwogCiAg ICAgICAgIC8vIEFjayBjb21wbGV0aW9uIG9mIGluaXRpYWxpemF0aW9uIHRvIHRoZSBjcmVhdGlu ZyB0aHJlYWQuCiAgICAgICAgIGNvbnRleHQtPnN0YWdlID0gU3RhZ2U6OkluaXRpYWxpemVkOwog ICAgICAgICBjb250ZXh0LT5jb25kaXRpb24uc2lnbmFsKCk7CiAgICAgfQotCi0gICAgZW50cnlQ b2ludCgpOworICAgIGZ1bmN0aW9uKCk7CiB9CiAKIFJlZlB0cjxUaHJlYWQ+IFRocmVhZDo6Y3Jl YXRlKGNvbnN0IGNoYXIqIG5hbWUsIEZ1bmN0aW9uPHZvaWQoKT4mJiBlbnRyeVBvaW50KQogewot ICAgIE5ld1RocmVhZENvbnRleHQgY29udGV4dCB7IG5hbWUsIFdURk1vdmUoZW50cnlQb2ludCks IFN0YWdlOjpTdGFydCwgeyB9LCB7IH0gfTsKLQorICAgIFJlZjxUaHJlYWQ+IHRocmVhZCA9IGFk b3B0UmVmKCpuZXcgVGhyZWFkKCkpOworICAgIE5ld1RocmVhZENvbnRleHQgY29udGV4dCB7IG5h bWUsIFdURk1vdmUoZW50cnlQb2ludCksIFN0YWdlOjpTdGFydCwgeyB9LCB7IH0sIHRocmVhZC5n ZXQoKSB9OwogICAgIE11dGV4TG9ja2VyIGxvY2tlcihjb250ZXh0Lm11dGV4KTsKLSAgICBSZWZQ dHI8VGhyZWFkPiByZXN1bHQgPSBUaHJlYWQ6OmNyZWF0ZUludGVybmFsKHRocmVhZEVudHJ5UG9p bnQsICZjb250ZXh0LCBuYW1lKTsKKyAgICBpZiAoIXRocmVhZC0+bGF1bmNoKCZjb250ZXh0KSkK KyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgY29udGV4dC5zdGFnZSA9IFN0YWdlOjpFc3Rh Ymxpc2hlZDsKICAgICAvLyBBZnRlciBlc3RhYmxpc2hpbmcgVGhyZWFkLCByZWxlYXNlIHRoZSBt dXRleCBhbmQgd2FpdCBmb3IgY29tcGxldGlvbiBvZiBpbml0aWFsaXphdGlvbi4KICAgICB3aGls ZSAoY29udGV4dC5zdGFnZSAhPSBTdGFnZTo6SW5pdGlhbGl6ZWQpCiAgICAgICAgIGNvbnRleHQu Y29uZGl0aW9uLndhaXQoY29udGV4dC5tdXRleCk7Ci0KLSAgICByZXR1cm4gcmVzdWx0OworICAg IHJldHVybiBXVEZNb3ZlKHRocmVhZCk7CiB9CiAKIFRocmVhZCogVGhyZWFkOjpjdXJyZW50TWF5 QmVOdWxsKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5oIGIvU291cmNl L1dURi93dGYvVGhyZWFkaW5nLmgKaW5kZXggODg4MWNjZWU4ZGE0MGUzZDBmNDJhYjgwNjg0ODMw MDk4NzY2OWFiYS4uMGQ3MzNhMDk1MzkzNTI5ZGE2ZWVjYTRlMDMxZDlkZTAzZGZmODljNiAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKKysrIGIvU291cmNlL1dURi93dGYv VGhyZWFkaW5nLmgKQEAgLTEwOCw4ICsxMDgsOCBAQCBjbGFzcyBUaHJlYWQgOiBwdWJsaWMgVGhy ZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7CiAKICAgICAvLyBDYWxsZWQgaW4gdGhlIHRocmVh ZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24uCiAgICAgLy8gSGVscGZ1bCBmb3IgcGxhdGZvcm1zIHdo ZXJlIHRoZSB0aHJlYWQgbmFtZSBtdXN0IGJlIHNldCBmcm9tIHdpdGhpbiB0aGUgdGhyZWFkLgot ICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29uc3QgY2hh ciogdGhyZWFkTmFtZSk7Ci0gICAgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRF dmVuSWZOb25XVEZDcmVhdGVkKCk7CisgICAgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZUN1cnJlbnRU aHJlYWRJbnRlcm5hbChUaHJlYWQmLCBjb25zdCBjaGFyKiB0aHJlYWROYW1lKTsKKyAgICBzdGF0 aWMgdm9pZCBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoVGhyZWFk Jik7CiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgdm9pZCBkdW1wKFByaW50U3RyZWFtJiBvdXQp IGNvbnN0OwogCkBAIC0xMzYsMTEgKzEzNiwxMiBAQCBjbGFzcyBUaHJlYWQgOiBwdWJsaWMgVGhy ZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7CiAgICAgbWFjaF9wb3J0X3QgbWFjaFRocmVhZCgp IHsgcmV0dXJuIG1fcGxhdGZvcm1UaHJlYWQ7IH0KICNlbmRpZgogCisgICAgc3RhdGljIHZvaWQg ZW50cnlQb2ludCh2b2lkKiBkYXRhKTsKIHByb3RlY3RlZDoKICAgICBUaHJlYWQoKTsKIAotICAg IC8vIEludGVybmFsIHBsYXRmb3JtLXNwZWNpZmljIFRocmVhZDo6Y3JlYXRlIGltcGxlbWVudGF0 aW9uLgotICAgIHN0YXRpYyBSZWZQdHI8VGhyZWFkPiBjcmVhdGVJbnRlcm5hbChUaHJlYWRGdW5j dGlvbiwgdm9pZCosIGNvbnN0IGNoYXIqIHRocmVhZE5hbWUpOworICAgIC8vIEludGVybmFsIHBs YXRmb3JtLXNwZWNpZmljIFRocmVhZCBsYXVuY2hpbmcgaW1wbGVtZW50YXRpb24uCisgICAgYm9v bCBsYXVuY2godm9pZCogZGF0YSk7CiAKICNpZiBVU0UoUFRIUkVBRFMpCiAgICAgdm9pZCBlc3Rh Ymxpc2gocHRocmVhZF90KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1B0 aHJlYWRzLmNwcCBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1B0aHJlYWRzLmNwcAppbmRleCBm YTgwYzA0ODAxOWQ4OWQzYTk4MDI5NjkzYjc2ZGIyODljYTcxNTI0Li4xMGE4ZDJmMDI1ODQwOTEy MzFlOTI3MTI0ZTA3YzVhNTIxMDMyNmY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJl YWRpbmdQdGhyZWFkcy5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nUHRocmVhZHMu Y3BwCkBAIC00MCw3ICs0MCw2IEBACiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAj aW5jbHVkZSA8d3RmL1Jhd1BvaW50ZXIuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+ Ci0jaW5jbHVkZSA8d3RmL1RocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oPgogI2luY2x1ZGUgPHd0 Zi9UaHJlYWRIb2xkZXIuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nUHJpbWl0aXZlcy5oPgog I2luY2x1ZGUgPHd0Zi9Xb3JkTG9jay5oPgpAQCAtMTg4LDkgKzE4Nyw5IEBAIHZvaWQgVGhyZWFk Ojppbml0aWFsaXplUGxhdGZvcm1UaHJlYWRpbmcoKQogI2VuZGlmCiB9CiAKLXZvaWQgVGhyZWFk Ojppbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoKQordm9pZCBUaHJl YWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZChUaHJlYWQmIHRo cmVhZCkKIHsKLSAgICBUaHJlYWQ6OmN1cnJlbnQoKS5pbml0aWFsaXplKCk7CisgICAgdGhyZWFk LmluaXRpYWxpemUoKTsKICNpZiAhT1MoREFSV0lOKQogICAgIHNpZ3NldF90IG1hc2s7CiAgICAg c2lnZW1wdHlzZXQoJm1hc2spOwpAQCAtMTk5LDQ0ICsxOTgsMzEgQEAgdm9pZCBUaHJlYWQ6Omlu aXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCgpCiAjZW5kaWYKIH0KIAot c3RhdGljIHZvaWQqIHd0ZlRocmVhZEVudHJ5UG9pbnQodm9pZCogcGFyYW0pCitzdGF0aWMgdm9p ZCogd3RmVGhyZWFkRW50cnlQb2ludCh2b2lkKiBkYXRhKQogewotICAgIC8vIEJhbGFuY2VkIGJ5 IC5sZWFrUHRyKCkgaW4gVGhyZWFkOjpjcmVhdGVJbnRlcm5hbC4KLSAgICBhdXRvIGludm9jYXRp b24gPSBzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uPihzdGF0aWNfY2Fz dDxUaHJlYWRGdW5jdGlvbkludm9jYXRpb24qPihwYXJhbSkpOwotCi0gICAgVGhyZWFkSG9sZGVy Ojppbml0aWFsaXplKCppbnZvY2F0aW9uLT50aHJlYWQpOwotICAgIGludm9jYXRpb24tPnRocmVh ZCA9IG51bGxwdHI7Ci0KLSAgICBpbnZvY2F0aW9uLT5mdW5jdGlvbihpbnZvY2F0aW9uLT5kYXRh KTsKKyAgICBUaHJlYWQ6OmVudHJ5UG9pbnQoZGF0YSk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9 CiAKLVJlZlB0cjxUaHJlYWQ+IFRocmVhZDo6Y3JlYXRlSW50ZXJuYWwoVGhyZWFkRnVuY3Rpb24g ZW50cnlQb2ludCwgdm9pZCogZGF0YSwgY29uc3QgY2hhciopCitib29sIFRocmVhZDo6bGF1bmNo KHZvaWQqIGRhdGEpCiB7Ci0gICAgUmVmUHRyPFRocmVhZD4gdGhyZWFkID0gYWRvcHRSZWYobmV3 IFRocmVhZCgpKTsKLSAgICBhdXRvIGludm9jYXRpb24gPSBzdGQ6Om1ha2VfdW5pcXVlPFRocmVh ZEZ1bmN0aW9uSW52b2NhdGlvbj4oZW50cnlQb2ludCwgdGhyZWFkLmdldCgpLCBkYXRhKTsKICAg ICBwdGhyZWFkX3QgdGhyZWFkSGFuZGxlOwogICAgIHB0aHJlYWRfYXR0cl90IGF0dHI7CiAgICAg cHRocmVhZF9hdHRyX2luaXQoJmF0dHIpOwogI2lmIEhBVkUoUU9TX0NMQVNTRVMpCiAgICAgcHRo cmVhZF9hdHRyX3NldF9xb3NfY2xhc3NfbnAoJmF0dHIsIGFkanVzdGVkUU9TQ2xhc3MoUU9TX0NM QVNTX1VTRVJfSU5JVElBVEVEKSwgMCk7CiAjZW5kaWYKLSAgICBpbnQgZXJyb3IgPSBwdGhyZWFk X2NyZWF0ZSgmdGhyZWFkSGFuZGxlLCAmYXR0ciwgd3RmVGhyZWFkRW50cnlQb2ludCwgaW52b2Nh dGlvbi5nZXQoKSk7CisgICAgaW50IGVycm9yID0gcHRocmVhZF9jcmVhdGUoJnRocmVhZEhhbmRs ZSwgJmF0dHIsIHd0ZlRocmVhZEVudHJ5UG9pbnQsIGRhdGEpOwogICAgIHB0aHJlYWRfYXR0cl9k ZXN0cm95KCZhdHRyKTsKICAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgTE9HX0VSUk9SKCJGYWls ZWQgdG8gY3JlYXRlIHB0aHJlYWQgYXQgZW50cnkgcG9pbnQgJXAgd2l0aCBkYXRhICVwIiwgd3Rm VGhyZWFkRW50cnlQb2ludCwgaW52b2NhdGlvbi5nZXQoKSk7Ci0gICAgICAgIHJldHVybiBudWxs cHRyOworICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBjcmVhdGUgcHRocmVhZCBhdCBlbnRy eSBwb2ludCAlcCB3aXRoIGRhdGEgJXAiLCB3dGZUaHJlYWRFbnRyeVBvaW50LCBkYXRhKTsKKyAg ICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KLQotICAgIC8vIEJhbGFuY2VkIGJ5IHN0ZDo6dW5p cXVlX3B0ciBjb25zdHJ1Y3RvciBpbiB3dGZUaHJlYWRFbnRyeVBvaW50LgotICAgIFRocmVhZEZ1 bmN0aW9uSW52b2NhdGlvbiogbGVha2VkSW52b2NhdGlvbiA9IGludm9jYXRpb24ucmVsZWFzZSgp OwotICAgIFVOVVNFRF9QQVJBTShsZWFrZWRJbnZvY2F0aW9uKTsKLQotICAgIHRocmVhZC0+ZXN0 YWJsaXNoKHRocmVhZEhhbmRsZSk7Ci0gICAgcmV0dXJuIHRocmVhZDsKKyAgICBlc3RhYmxpc2go dGhyZWFkSGFuZGxlKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBUaHJlYWQ6OmluaXRp YWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29uc3QgY2hhciogdGhyZWFkTmFtZSkKK3ZvaWQg VGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEludGVybmFsKFRocmVhZCYgdGhyZWFkLCBj b25zdCBjaGFyKiB0aHJlYWROYW1lKQogewogI2lmIEhBVkUoUFRIUkVBRF9TRVROQU1FX05QKQog ICAgIHB0aHJlYWRfc2V0bmFtZV9ucChub3JtYWxpemVUaHJlYWROYW1lKHRocmVhZE5hbWUpKTsK QEAgLTI0NSw3ICsyMzEsNyBAQCB2b2lkIFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJ bnRlcm5hbChjb25zdCBjaGFyKiB0aHJlYWROYW1lKQogI2Vsc2UKICAgICBVTlVTRURfUEFSQU0o dGhyZWFkTmFtZSk7CiAjZW5kaWYKLSAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5v bldURkNyZWF0ZWQoKTsKKyAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNy ZWF0ZWQodGhyZWFkKTsKIH0KIAogdm9pZCBUaHJlYWQ6OmNoYW5nZVByaW9yaXR5KGludCBkZWx0 YSkKQEAgLTMwOSw3ICsyOTUsNyBAQCBUaHJlYWQmIFRocmVhZDo6Y3VycmVudCgpCiAgICAgUmVm PFRocmVhZD4gdGhyZWFkID0gYWRvcHRSZWYoKm5ldyBUaHJlYWQoKSk7CiAgICAgdGhyZWFkLT5l c3RhYmxpc2gocHRocmVhZF9zZWxmKCkpOwogICAgIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZSh0 aHJlYWQuZ2V0KCkpOwotICAgIGluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3Jl YXRlZCgpOworICAgIGluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCh0 aHJlYWQuZ2V0KCkpOwogICAgIHJldHVybiB0aHJlYWQuZ2V0KCk7CiB9CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1dpbi5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRp bmdXaW4uY3BwCmluZGV4IGVlMWM0ZDQzZmU3ZjE1MjM2YWQ5NWJhOWE3YmFkN2ExZTQxMzY0NzIu Ljc1OWIyMjM2ZTdiYjQ4ZDQxNjNlYzZhYWFjNWFhYTIzYzU1MmRlY2EgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XVEYvd3RmL1RocmVhZGluZ1dpbi5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFk aW5nV2luLmNwcApAQCAtODgsMjAgKzg4LDE2IEBACiAKICNpZiBPUyhXSU5ET1dTKQogCisjaW5j bHVkZSA8ZXJybm8uaD4KICNpbmNsdWRlIDxwcm9jZXNzLmg+CiAjaW5jbHVkZSA8d2luZG93cy5o PgogI2luY2x1ZGUgPHd0Zi9DdXJyZW50VGltZS5oPgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFk Lmg+CiAjaW5jbHVkZSA8d3RmL01hdGhFeHRyYXMuaD4KICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0 cm95ZWQuaD4KLSNpbmNsdWRlIDx3dGYvVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uLmg+CiAjaW5j bHVkZSA8d3RmL1RocmVhZEhvbGRlci5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmdQcmltaXRp dmVzLmg+CiAKLSNpZiBIQVZFKEVSUk5PX0gpCi0jaW5jbHVkZSA8ZXJybm8uaD4KLSNlbmRpZgot CiBuYW1lc3BhY2UgV1RGIHsKIAogVGhyZWFkOjpUaHJlYWQoKQpAQCAtMTE2LDkgKzExMiw5IEBA IFRocmVhZDo6flRocmVhZCgpCiAgICAgICAgIENsb3NlSGFuZGxlKG1faGFuZGxlKTsKIH0KIAot dm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCgp Cit2b2lkIFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVk KFRocmVhZCYgdGhyZWFkKQogewotICAgIFRocmVhZDo6Y3VycmVudCgpLmluaXRpYWxpemUoKTsK KyAgICB0aHJlYWQuaW5pdGlhbGl6ZSgpOwogfQogCiAvLyBNU19WQ19FWENFUFRJT04sIFRIUkVB RE5BTUVfSU5GTywgYW5kIHNldFRocmVhZE5hbWVJbnRlcm5hbCBhbGwgY29tZSBmcm9tIDxodHRw Oi8vbXNkbi5taWNyb3NvZnQuY29tL2VuLXVzL2xpYnJhcnkveGNiMno4aHMuYXNweD4uCkBAIC0x MzMsNyArMTI5LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgdGFnVEhSRUFETkFNRV9JTkZPIHsKIH0gVEhS RUFETkFNRV9JTkZPOwogI3ByYWdtYSBwYWNrKHBvcCkKIAotdm9pZCBUaHJlYWQ6OmluaXRpYWxp emVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29uc3QgY2hhciogc3pUaHJlYWROYW1lKQordm9pZCBU aHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoVGhyZWFkJiB0aHJlYWQsIGNv bnN0IGNoYXIqIHN6VGhyZWFkTmFtZSkKIHsKICNpZiBDT01QSUxFUihNSU5HVykKICAgICAvLyBG SVhNRTogSW1wbGVtZW50IHRocmVhZCBuYW1lIHNldHRpbmcgd2l0aCBNaW5nVy4KQEAgLTE1MCw0 OSArMTQ2LDI5IEBAIHZvaWQgVGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEludGVybmFs KGNvbnN0IGNoYXIqIHN6VGhyZWFkTmFtZSkKICAgICB9IF9fZXhjZXB0IChFWENFUFRJT05fQ09O VElOVUVfRVhFQ1VUSU9OKSB7CiAgICAgfQogI2VuZGlmCi0gICAgaW5pdGlhbGl6ZUN1cnJlbnRU aHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCk7CisgICAgaW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRF dmVuSWZOb25XVEZDcmVhdGVkKHRocmVhZCk7CiB9CiAKIHZvaWQgVGhyZWFkOjppbml0aWFsaXpl UGxhdGZvcm1UaHJlYWRpbmcoKQogewogfQogCi1zdGF0aWMgdW5zaWduZWQgX19zdGRjYWxsIHd0 ZlRocmVhZEVudHJ5UG9pbnQodm9pZCogcGFyYW0pCitzdGF0aWMgdW5zaWduZWQgX19zdGRjYWxs IHd0ZlRocmVhZEVudHJ5UG9pbnQodm9pZCogZGF0YSkKIHsKLSAgICAvLyBCYWxhbmNlZCBieSAu bGVha1B0cigpIGluIFRocmVhZDo6Y3JlYXRlSW50ZXJuYWwuCi0gICAgYXV0byBpbnZvY2F0aW9u ID0gc3RkOjp1bmlxdWVfcHRyPFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbj4oc3RhdGljX2Nhc3Q8 VGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uKj4ocGFyYW0pKTsKLQotICAgIFRocmVhZEhvbGRlcjo6 aW5pdGlhbGl6ZSgqaW52b2NhdGlvbi0+dGhyZWFkLCBUaHJlYWQ6OmN1cnJlbnRJRCgpKTsKLSAg ICBpbnZvY2F0aW9uLT50aHJlYWQgPSBudWxscHRyOwotCi0gICAgaW52b2NhdGlvbi0+ZnVuY3Rp b24oaW52b2NhdGlvbi0+ZGF0YSk7CisgICAgVGhyZWFkOjplbnRyeVBvaW50KGRhdGEpOwogICAg IHJldHVybiAwOwogfQogCi1SZWZQdHI8VGhyZWFkPiBUaHJlYWQ6OmNyZWF0ZUludGVybmFsKFRo cmVhZEZ1bmN0aW9uIGVudHJ5UG9pbnQsIHZvaWQqIGRhdGEsIGNvbnN0IGNoYXIqIHRocmVhZE5h bWUpCitib29sIFRocmVhZDo6bGF1bmNoKHZvaWQqIGRhdGEpCiB7Ci0gICAgUmVmPFRocmVhZD4g dGhyZWFkID0gYWRvcHRSZWYoKm5ldyBUaHJlYWQoKSk7CiAgICAgdW5zaWduZWQgdGhyZWFkSWRl bnRpZmllciA9IDA7Ci0gICAgVGhyZWFkSWRlbnRpZmllciB0aHJlYWRJRCA9IDA7Ci0gICAgYXV0 byBpbnZvY2F0aW9uID0gc3RkOjptYWtlX3VuaXF1ZTxUaHJlYWRGdW5jdGlvbkludm9jYXRpb24+ KGVudHJ5UG9pbnQsIHRocmVhZC5wdHIoKSwgZGF0YSk7Ci0gICAgSEFORExFIHRocmVhZEhhbmRs ZSA9IHJlaW50ZXJwcmV0X2Nhc3Q8SEFORExFPihfYmVnaW50aHJlYWRleCgwLCAwLCB3dGZUaHJl YWRFbnRyeVBvaW50LCBpbnZvY2F0aW9uLmdldCgpLCAwLCAmdGhyZWFkSWRlbnRpZmllcikpOwor ICAgIEhBTkRMRSB0aHJlYWRIYW5kbGUgPSByZWludGVycHJldF9jYXN0PEhBTkRMRT4oX2JlZ2lu dGhyZWFkZXgoMCwgMCwgd3RmVGhyZWFkRW50cnlQb2ludCwgZGF0YSwgMCwgJnRocmVhZElkZW50 aWZpZXIpKTsKICAgICBpZiAoIXRocmVhZEhhbmRsZSkgewotI2lmICFIQVZFKEVSUk5PX0gpCi0g ICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGNyZWF0ZSB0aHJlYWQgYXQgZW50cnkgcG9pbnQg JXAgd2l0aCBkYXRhICVwLiIsIGVudHJ5UG9pbnQsIGRhdGEpOwotI2Vsc2UKLSAgICAgICAgTE9H X0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRocmVhZCBhdCBlbnRyeSBwb2ludCAlcCB3aXRoIGRh dGEgJXA6ICVsZCIsIGVudHJ5UG9pbnQsIGRhdGEsIGVycm5vKTsKLSNlbmRpZgotICAgICAgICBy ZXR1cm4gMDsKKyAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRocmVhZCBhdCBl bnRyeSBwb2ludCAlcCB3aXRoIGRhdGEgJXA6ICVsZCIsIHd0ZlRocmVhZEVudHJ5UG9pbnQsIGRh dGEsIGVycm5vKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KLQotICAgIC8vIFRoZSB0 aHJlYWQgd2lsbCB0YWtlIG93bmVyc2hpcCBvZiBpbnZvY2F0aW9uLgotICAgIFRocmVhZEZ1bmN0 aW9uSW52b2NhdGlvbiogbGVha2VkSW52b2NhdGlvbiA9IGludm9jYXRpb24ucmVsZWFzZSgpOwot ICAgIFVOVVNFRF9QQVJBTShsZWFrZWRJbnZvY2F0aW9uKTsKLQotICAgIHRocmVhZElEID0gc3Rh dGljX2Nhc3Q8VGhyZWFkSWRlbnRpZmllcj4odGhyZWFkSWRlbnRpZmllcik7Ci0KLSAgICB0aHJl YWQtPmVzdGFibGlzaCh0aHJlYWRIYW5kbGUsIHRocmVhZElkZW50aWZpZXIpOwotICAgIHJldHVy biB0aHJlYWQ7CisgICAgZXN0YWJsaXNoKHRocmVhZEhhbmRsZSwgdGhyZWFkSWRlbnRpZmllcik7 CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIHZvaWQgVGhyZWFkOjpjaGFuZ2VQcmlvcml0eShpbnQg ZGVsdGEpCkBAIC0yNzgsOCArMjU0LDggQEAgVGhyZWFkJiBUaHJlYWQ6OmN1cnJlbnQoKQogICAg IFJFTEVBU0VfQVNTRVJUKGlzU3VjY2Vzc2Z1bCk7CiAKICAgICB0aHJlYWQtPmVzdGFibGlzaCho YW5kbGUsIGN1cnJlbnRJRCgpKTsKLSAgICBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUodGhyZWFk LmdldCgpLCBUaHJlYWQ6OmN1cnJlbnRJRCgpKTsKLSAgICBpbml0aWFsaXplQ3VycmVudFRocmVh ZEV2ZW5JZk5vbldURkNyZWF0ZWQoKTsKKyAgICBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUodGhy ZWFkLmdldCgpKTsKKyAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0 ZWQodGhyZWFkLmdldCgpKTsKICAgICByZXR1cm4gdGhyZWFkLmdldCgpOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi93aW4vTWFpblRocmVhZFdpbi5jcHAgYi9Tb3VyY2UvV1RGL3d0 Zi93aW4vTWFpblRocmVhZFdpbi5jcHAKaW5kZXggYTY0NzNkMDdiNjdlYWNjODZiZTdhNGViNjk3 NDk4OTNlYzYxNDk3Zi4uZWY1NDliZmQ2NjlmNzE0MWMwNWFmZmM2MjA5MGU5OTIxMjVhOGRiMiAx MDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvd2luL01haW5UaHJlYWRXaW4uY3BwCisrKyBiL1Nv dXJjZS9XVEYvd3RmL3dpbi9NYWluVGhyZWFkV2luLmNwcApAQCAtNjQsNyArNjQsNyBAQCB2b2lk IGluaXRpYWxpemVNYWluVGhyZWFkUGxhdGZvcm0oKQogICAgICAgICBDV19VU0VERUZBVUxULCAw LCBDV19VU0VERUZBVUxULCAwLCBIV05EX01FU1NBR0UsIDAsIDAsIDApOwogICAgIHRocmVhZGlu Z0ZpcmVkTWVzc2FnZSA9IFJlZ2lzdGVyV2luZG93TWVzc2FnZVcoTCJjb20uYXBwbGUuV2ViS2l0 Lk1haW5UaHJlYWRGaXJlZCIpOwogCi0gICAgVGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVh ZEludGVybmFsKCJNYWluIFRocmVhZCIpOworICAgIFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRU aHJlYWRJbnRlcm5hbChUaHJlYWQ6OmN1cnJlbnQoKSwgIk1haW4gVGhyZWFkIik7CiB9CiAKIHZv aWQgc2NoZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCgpCg== 314956 2017-07-09 15:34:41 -0700 2017-07-11 12:03:18 -0700 Patch bug-174291-20170710073440.patch text/plain 23267 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjE5MjgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDZmZjU5MDk5ODBlNDY0NmMxYmJkMWUx NDcxMTU0NjU5Y2ZkMGM3ZmYuLjgwNDVjOWI4ZjY1M2NjNjUyOTZkZjI0ZjM4NmIyNTZmMWMxOWUz NDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDUgKzEsNTkgQEAKIDIwMTctMDctMDkgIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CiAKKyAgICAgICAgW1dURl0gUmVtb3ZlIHVubmVjZXNzYXJ5IGlu ZGlyZWN0aW9uIG9mIFdURjo6VGhyZWFkIGVudHJ5IHBvaW50CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzQyOTEKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOb3cgd3RmVGhyZWFkRW50cnlQb2ludCBpcyBh bG1vc3QgdGhlIHNhbWUuIE9ubHkgdGhlIGRpZmZlcmVuY2UgaXMgZnVuY3Rpb24gc2lnbmF0dXJl IGR1ZSB0byBwbGF0Zm9ybSBBUElzLgorICAgICAgICBXZSByZW1vdmUgVGhyZWFkRnVuY3Rpb25J bnZvY2F0aW9uIGluZGlyZWN0aW9uIGluIFRocmVhZGluZ1B0aHJlYWQuY3BwIGFuZCBUaHJlYWRp bmdXaW4uY3BwLgorCisgICAgICAgIEFsc28sIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbiBrZWVw cyBhIFJlZlB0ciB0byB0aGUgVGhyZWFkIG9iamVjdC4gVGhpcyB3YXMgcHJldmlvdXNseSBuZWVk ZWQgdG8ga2VlcCB0aGUKKyAgICAgICAgVGhyZWFkIG9iamVjdCBhbGl2ZSB1bnRpbCB0aGUgdGhy ZWFkIGl0c2VsZiBjb3VsZCBpbnN0YWxsIHRoZSBUaHJlYWRIb2xkZXIgaW50byBpdHMgdGhyZWFk IGxvY2FsIHN0b3JhZ2UuCisgICAgICAgIFRoZSBUaHJlYWRIb2xkZXIgaGFzIGEgUmVmIHRoYXQg a2VlcHMgdGhlIFRocmVhZCBvYmplY3QgYWxpdmUgZm9yIHRoZSBsaWZldGltZSBvZiB0aGUgdGhy ZWFkLiBTaW5jZQorICAgICAgICBUaHJlYWQ6OmNyZWF0ZSgpIG5vdyB3YWl0cyBmb3IgdGhlIHRo cmVhZCB0byBiZSBpbml0aWFsaXplZCBiZWZvcmUgcmV0dXJuaW5nIGFuZCBUaHJlYWQ6OmNyZWF0 ZSgpIGhvbGQgYSBSZWYKKyAgICAgICAgdG8gdGhlIFRocmVhZCBvYmplY3QsIHdlIGFyZSBndWFy YW50ZWVkIHRoYXQgdGhlIFRocmVhZCBvYmplY3Qgd2lsbCBiZSBhbGl2ZSBsb25nIGVub3VnaCBm b3IgaXQgdG8gYmUgaW5zdGFsbGVkCisgICAgICAgIGluIHRoZSB0aHJlYWQncyBUaHJlYWRIb2xk ZXIsIGFuZCB3ZSBubyBsb25nZXIgbmVlZCBUaHJlYWRGdW5jdGlvbkludm9jYXRpb24uCisKKyAg ICAgICAgQW5kIHdlIGFsc28gc2ltcGxpZnkgVGhyZWFkSG9sZGVyOjppbml0aWFsaXplIGEgYml0 LiBOb3cgVGhyZWFkOjpjcmVhdGUgd2FpdHMgZm9yIHRoZSBjb21wbGV0aW9uIG9mIFRocmVhZAor ICAgICAgICBpbml0aWFsaXphdGlvbi4gU28sIGFmdGVyIGVzdGFibGlzaGluZyB0aHJlYWQgaGFu ZGxlLCB3ZSBjYW4gY2FsbCBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUgYmVmb3JlIGNvbXBsZXRp bmcKKyAgICAgICAgVGhyZWFkIGluaXRpYWxpemF0aW9uLgorCisgICAgICAgIEFsc28gd2UgZHJv cCBlcnJuby5oIGlmZGVmcyBpbiBUaHJlYWRpbmdXaW4uY3BwLiBUaGlzIGlzIGludHJvZHVjZWQg dG8gc3VwcG9ydCBXaW5DRS4gQnV0IG5vdyBXaW5DRSBwb3J0IGlzIHJlbW92ZWQuCisKKyAgICAg ICAgKiBXVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiB3dGYvVGhyZWFk RnVuY3Rpb25JbnZvY2F0aW9uLmg6IFJlbW92ZWQuCisgICAgICAgICogd3RmL1RocmVhZEhvbGRl ci5oOgorICAgICAgICAqIHd0Zi9UaHJlYWRIb2xkZXJXaW4uY3BwOgorICAgICAgICAoV1RGOjpU aHJlYWRIb2xkZXI6OmluaXRpYWxpemUpOgorICAgICAgICAqIHd0Zi9UaHJlYWRpbmcuY3BwOgor ICAgICAgICAoV1RGOjpUaHJlYWQ6OmVudHJ5UG9pbnQpOgorICAgICAgICAoV1RGOjpUaHJlYWQ6 OmNyZWF0ZSk6CisgICAgICAgIChXVEY6OnRocmVhZEVudHJ5UG9pbnQpOiBEZWxldGVkLgorICAg ICAgICAqIHd0Zi9UaHJlYWRpbmcuaDoKKyAgICAgICAgKiB3dGYvVGhyZWFkaW5nUHRocmVhZHMu Y3BwOgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklm Tm9uV1RGQ3JlYXRlZCk6CisgICAgICAgIChXVEY6Ond0ZlRocmVhZEVudHJ5UG9pbnQpOgorICAg ICAgICAoV1RGOjpUaHJlYWQ6OmVzdGFibGlzaEhhbmRsZSk6CisgICAgICAgIChXVEY6OlRocmVh ZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbCk6CisgICAgICAgIChXVEY6OlRocmVh ZDo6Y3VycmVudCk6CisgICAgICAgIChXVEY6OlRocmVhZDo6ZXN0YWJsaXNoUGxhdGZvcm1TcGVj aWZpY0hhbmRsZSk6CisgICAgICAgIChXVEY6OlRocmVhZDo6Y3JlYXRlSW50ZXJuYWwpOiBEZWxl dGVkLgorICAgICAgICAoV1RGOjpUaHJlYWQ6OmVzdGFibGlzaCk6IERlbGV0ZWQuCisgICAgICAg ICogd3RmL1RocmVhZGluZ1dpbi5jcHA6CisgICAgICAgIChXVEY6OlRocmVhZDo6aW5pdGlhbGl6 ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKToKKyAgICAgICAgKFdURjo6VGhyZWFk Ojppbml0aWFsaXplQ3VycmVudFRocmVhZEludGVybmFsKToKKyAgICAgICAgKFdURjo6d3RmVGhy ZWFkRW50cnlQb2ludCk6CisgICAgICAgIChXVEY6OlRocmVhZDo6ZXN0YWJsaXNoSGFuZGxlKToK KyAgICAgICAgKFdURjo6VGhyZWFkOjpjdXJyZW50KToKKyAgICAgICAgKFdURjo6VGhyZWFkOjpl c3RhYmxpc2hQbGF0Zm9ybVNwZWNpZmljSGFuZGxlKToKKyAgICAgICAgKFdURjo6VGhyZWFkOjpj cmVhdGVJbnRlcm5hbCk6IERlbGV0ZWQuCisgICAgICAgIChXVEY6OlRocmVhZDo6ZXN0YWJsaXNo KTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvd2luL01haW5UaHJlYWRXaW4uY3BwOgorICAgICAg ICAoV1RGOjppbml0aWFsaXplTWFpblRocmVhZFBsYXRmb3JtKToKKworMjAxNy0wNy0wOSAgWXVz dWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWlsLmNvbT4KKwogICAgICAgICBbSlNDXSBVc2Ug ZmFzdE1hbGxvYyAvIGZhc3RGcmVlIGZvciBTVEwgY29udGFpbmVycwogICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc0Mjk3CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV1RGL1dURi54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDJlOTZjODMwNWMwYThiMWU0NDgzZDYzYzU4 YThjN2ExZDNmY2EwMmYuLmYzMGIzYzAyMzAxNTE5MTQyNmE2ZGZiYzIyZjNiN2YwZjJhZmYwMDYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysr IGIvU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNDkxLDcgKzQ5 MSw2IEBACiAJCUE4QTQ3MzJDMTUxQTgyNUIwMDQxMjNGRiAvKiBUZXh0UG9zaXRpb24uaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVGV4dFBvc2l0aW9uLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3MzJEMTUxQTgyNUIwMDQxMjNGRiAvKiBXVEZTdHJpbmcu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV1RGU3RyaW5nLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQThBNDczMkUxNTFBODI1QjAwNDEyM0ZGIC8q IFdURlN0cmluZy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXVEZTdHJpbmcu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJQThBNDczMkYxNTFBODI1QjAwNDEyM0ZG IC8qIFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBUaHJlYWRGdW5jdGlvbkludm9jYXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJQThBNDczMzAxNTFBODI1QjAwNDEyM0ZGIC8qIFRocmVhZEhvbGRlclB0aHJlYWRz LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFRocmVhZEhvbGRlclB0 aHJlYWRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQThBNDczMzIxNTFBODI1 QjAwNDEyM0ZGIC8qIFRocmVhZGluZy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IHBhdGggPSBUaHJlYWRpbmcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0 NzMzMzE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkaW5nLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IFRocmVhZGluZy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt OTU1LDcgKzk1NCw2IEBACiAJCQkJNTU5N0Y4MkMxRDk0Qjk5NzAwNjZCQzIxIC8qIFN5bmNocm9u aXplZEZpeGVkUXVldWUuaCAqLywKIAkJCQlFM0UxNTgyNTFFQURBNTNDMDA0QTA3OUQgLyogU3lz dGVtRnJlZS5oICovLAogCQkJCTBGQjMxN0MzMUM0ODgwMDEwMDdFMzk1QSAvKiBTeXN0ZW1UcmFj aW5nLmggKi8sCi0JCQkJQThBNDczMkYxNTFBODI1QjAwNDEyM0ZGIC8qIFRocmVhZEZ1bmN0aW9u SW52b2NhdGlvbi5oICovLAogCQkJCUUzMjAwQUI1MUU5QTUzNkQwMDNCNTlEMiAvKiBUaHJlYWRI b2xkZXIuY3BwICovLAogCQkJCUUzMjAwQUI2MUU5QTUzNkQwMDNCNTlEMiAvKiBUaHJlYWRIb2xk ZXIuaCAqLywKIAkJCQlBOEE0NzMzMDE1MUE4MjVCMDA0MTIzRkYgLyogVGhyZWFkSG9sZGVyUHRo cmVhZHMuY3BwICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvVGhyZWFkRnVuY3Rpb25J bnZvY2F0aW9uLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRGdW5jdGlvbkludm9jYXRpb24uaApk ZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2IyNzVmNzAxMmNmZTU2NjFlNDllMGI0ZmYw ZDljNjIxYjBlNDk5Zi4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAot LS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRGdW5jdGlvbkludm9jYXRpb24uaAorKysgL2Rldi9u dWxsCkBAIC0xLDU1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCi0gKiBhcmUgbWV0OgotICoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4gCi0gKiAyLiAg UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4gCi0gKiAzLiAg TmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9m Ci0gKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21v dGUgcHJvZHVjdHMgZGVyaXZlZAotICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4gCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkK LSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQKLSAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YK LSAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBUaHJlYWRGdW5jdGlvbkludm9jYXRpb25faAot I2RlZmluZSBUaHJlYWRGdW5jdGlvbkludm9jYXRpb25faAotCi0jaW5jbHVkZSAiVGhyZWFkaW5n LmgiCi0KLW5hbWVzcGFjZSBXVEYgewotCi10eXBlZGVmIHZvaWQgKCpUaHJlYWRGdW5jdGlvbiko dm9pZCogYXJndW1lbnQpOwotCi1zdHJ1Y3QgVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uIHsKLSAg ICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKLXB1YmxpYzoKLSAgICBUaHJlYWRGdW5jdGlvbklu dm9jYXRpb24oVGhyZWFkRnVuY3Rpb24gZnVuY3Rpb24sIFJlZlB0cjxUaHJlYWQ+JiYgdGhyZWFk LCB2b2lkKiBkYXRhKQotICAgICAgICA6IGZ1bmN0aW9uKGZ1bmN0aW9uKQotICAgICAgICAsIHRo cmVhZChXVEZNb3ZlKHRocmVhZCkpCi0gICAgICAgICwgZGF0YShkYXRhKQotICAgIHsKLSAgICB9 Ci0KLSAgICBUaHJlYWRGdW5jdGlvbiBmdW5jdGlvbjsKLSAgICBSZWZQdHI8VGhyZWFkPiB0aHJl YWQ7Ci0gICAgdm9pZCogZGF0YTsKLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdURgotCi0jZW5kaWYg Ly8gVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3Rm L1RocmVhZEhvbGRlci5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkSG9sZGVyLmgKaW5kZXggZGNm ODc5NDFiOTI4YmUyYzZjN2IyN2YxNGZkNzQ2NzIyYWYyYzRlNC4uYjJmOGRlNjg4NTBjNmFmZGM3 OWVmZGFkYTA5YmU2ZGVmYjE4MjZhOSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVGhyZWFk SG9sZGVyLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkSG9sZGVyLmgKQEAgLTUwLDExICs1 MCw3IEBAIGNsYXNzIFRocmVhZEhvbGRlciB7CiAgICAgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZU9u Y2UoKTsKIAogICAgIC8vIENyZWF0ZXMgYW5kIHB1dHMgYW4gaW5zdGFuY2Ugb2YgVGhyZWFkSG9s ZGVyIGludG8gdGhyZWFkLXNwZWNpZmljIHN0b3JhZ2UuCi0jaWYgT1MoV0lORE9XUykKLSAgICBz dGF0aWMgdm9pZCBpbml0aWFsaXplKFRocmVhZCYsIFRocmVhZElkZW50aWZpZXIpOwotI2Vsc2UK ICAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplKFRocmVhZCYpOwotI2VuZGlmCiAKICAgICAvLyBS ZXR1cm5zIDAgaWYgdGhyZWFkLXNwZWNpZmljIHN0b3JhZ2Ugd2FzIG5vdCBpbml0aWFsaXplZC4K ICAgICBzdGF0aWMgVGhyZWFkSG9sZGVyKiBjdXJyZW50KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL3d0Zi9UaHJlYWRIb2xkZXJXaW4uY3BwIGIvU291cmNlL1dURi93dGYvVGhyZWFkSG9sZGVy V2luLmNwcAppbmRleCBjZWRkYTY1NjhmYzBiM2FiMTFlYWRmZDdkNjU0OGYyNmYxMTM3MzIyLi5m MDZiNjJmNjhlMjAxMzYzNWM2MzUxNWU4YzBlNGYxNWZlNDYxNmRhIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV1RGL3d0Zi9UaHJlYWRIb2xkZXJXaW4uY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1RocmVh ZEhvbGRlcldpbi5jcHAKQEAgLTgwLDcgKzgwLDcgQEAgUmVmUHRyPFRocmVhZD4gVGhyZWFkSG9s ZGVyOjpnZXQoVGhyZWFkSWRlbnRpZmllciBpZCkKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAot dm9pZCBUaHJlYWRIb2xkZXI6OmluaXRpYWxpemUoVGhyZWFkJiB0aHJlYWQsIFRocmVhZElkZW50 aWZpZXIgaWQpCit2b2lkIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZShUaHJlYWQmIHRocmVhZCkK IHsKICAgICBpZiAoIWN1cnJlbnQoKSkgewogICAgICAgICAvLyBJZGVhbGx5IHdlJ2QgaGF2ZSB0 aGlzIGFzIGEgcmVsZWFzZSBhc3NlcnQgZXZlcnl3aGVyZSwgYnV0IHRoYXQgd291bGQgaHVydCBw ZXJmb3JtYW5jZS4KQEAgLTkwLDExICs5MCw5IEBAIHZvaWQgVGhyZWFkSG9sZGVyOjppbml0aWFs aXplKFRocmVhZCYgdGhyZWFkLCBUaHJlYWRJZGVudGlmaWVyIGlkKQogICAgICAgICAvLyBGSVhN RTogUmVtb3ZlIHRoaXMgd29ya2Fyb3VuZCBjb2RlIG9uY2UgPHJkYXI6Ly9wcm9ibGVtLzMxNzkz MjEzPiBpcyBmaXhlZC4KICAgICAgICAgYXV0byogaG9sZGVyID0gbmV3IFRocmVhZEhvbGRlcih0 aHJlYWQpOwogICAgICAgICB0aHJlYWRTcGVjaWZpY1NldChtX2tleSwgaG9sZGVyKTsKLQotICAg ICAgICAvLyBTaW5jZSBUaHJlYWQgaXMgbm90IGVzdGFibGlzaGVkIHlldCwgd2UgdXNlIHRoZSBn aXZlbiBpZCBpbnN0ZWFkIG9mIHRocmVhZC0+aWQoKS4KICAgICAgICAgewogICAgICAgICAgICAg c3RkOjpsb2NrX2d1YXJkPHN0ZDo6bXV0ZXg+IGxvY2tlcih0aHJlYWRNYXBNdXRleCgpKTsKLSAg ICAgICAgICAgIHRocmVhZE1hcCgpLmFkZChpZCwgaG9sZGVyKTsKKyAgICAgICAgICAgIHRocmVh ZE1hcCgpLmFkZCh0aHJlYWQuaWQoKSwgaG9sZGVyKTsKICAgICAgICAgfQogICAgIH0KIH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9U aHJlYWRpbmcuY3BwCmluZGV4IDgzNjJlZTM4Zjg1YzA3ODYzMzA3MWU5MGQyMjQ0MWUwNzc4OTRl M2MuLjIyMmQ4OTUyYzE1MDA4NGYyMGM0YzljMWM5NzZkMmM1MGVlMWNkMGEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFk aW5nLmNwcApAQCAtNDcsMTUgKzQ3LDE2IEBACiBuYW1lc3BhY2UgV1RGIHsKIAogZW51bSBjbGFz cyBTdGFnZSB7Ci0gICAgU3RhcnQsIEluaXRpYWxpemVkCisgICAgU3RhcnQsIEVzdGFibGlzaGVk SGFuZGxlLCBJbml0aWFsaXplZAogfTsKIAotc3RydWN0IE5ld1RocmVhZENvbnRleHQgeworc3Ry dWN0IFRocmVhZDo6TmV3VGhyZWFkQ29udGV4dCB7CiAgICAgY29uc3QgY2hhciogbmFtZTsKICAg ICBGdW5jdGlvbjx2b2lkKCk+IGVudHJ5UG9pbnQ7CiAgICAgU3RhZ2Ugc3RhZ2U7CiAgICAgTXV0 ZXggbXV0ZXg7CiAgICAgVGhyZWFkQ29uZGl0aW9uIGNvbmRpdGlvbjsKKyAgICBUaHJlYWQmIHRo cmVhZDsKIH07CiAKIGNvbnN0IGNoYXIqIFRocmVhZDo6bm9ybWFsaXplVGhyZWFkTmFtZShjb25z dCBjaGFyKiB0aHJlYWROYW1lKQpAQCAtODUsMzYgKzg2LDM5IEBAIGNvbnN0IGNoYXIqIFRocmVh ZDo6bm9ybWFsaXplVGhyZWFkTmFtZShjb25zdCBjaGFyKiB0aHJlYWROYW1lKQogI2VuZGlmCiB9 CiAKLXN0YXRpYyB2b2lkIHRocmVhZEVudHJ5UG9pbnQodm9pZCogY29udGV4dERhdGEpCit2b2lk IFRocmVhZDo6ZW50cnlQb2ludChOZXdUaHJlYWRDb250ZXh0KiBjb250ZXh0KQogewotICAgIE5l d1RocmVhZENvbnRleHQqIGNvbnRleHQgPSBzdGF0aWNfY2FzdDxOZXdUaHJlYWRDb250ZXh0Kj4o Y29udGV4dERhdGEpOwotICAgIEZ1bmN0aW9uPHZvaWQoKT4gZW50cnlQb2ludDsKKyAgICBGdW5j dGlvbjx2b2lkKCk+IGZ1bmN0aW9uOwogICAgIHsKICAgICAgICAgLy8gQmxvY2sgdW50aWwgb3Vy IGNyZWF0aW5nIHRocmVhZCBoYXMgY29tcGxldGVkIGFueSBleHRyYSBzZXR1cCB3b3JrLCBpbmNs dWRpbmcgZXN0YWJsaXNoaW5nIFRocmVhZElkZW50aWZpZXIuCiAgICAgICAgIE11dGV4TG9ja2Vy IGxvY2tlcihjb250ZXh0LT5tdXRleCk7CisgICAgICAgIEFTU0VSVChjb250ZXh0LT5zdGFnZSA9 PSBTdGFnZTo6RXN0YWJsaXNoZWRIYW5kbGUpOworCisgICAgICAgIC8vIEluaXRpYWxpemUgdGhy ZWFkIGhvbGRlciB3aXRoIGVzdGFibGlzaGVkIElELgorICAgICAgICBUaHJlYWRIb2xkZXI6Omlu aXRpYWxpemUoY29udGV4dC0+dGhyZWFkKTsKIAotICAgICAgICBUaHJlYWQ6OmluaXRpYWxpemVD dXJyZW50VGhyZWFkSW50ZXJuYWwoY29udGV4dC0+bmFtZSk7Ci0gICAgICAgIGVudHJ5UG9pbnQg PSBXVEZNb3ZlKGNvbnRleHQtPmVudHJ5UG9pbnQpOworICAgICAgICBUaHJlYWQ6OmluaXRpYWxp emVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29udGV4dC0+dGhyZWFkLCBjb250ZXh0LT5uYW1lKTsK KyAgICAgICAgZnVuY3Rpb24gPSBXVEZNb3ZlKGNvbnRleHQtPmVudHJ5UG9pbnQpOwogCiAgICAg ICAgIC8vIEFjayBjb21wbGV0aW9uIG9mIGluaXRpYWxpemF0aW9uIHRvIHRoZSBjcmVhdGluZyB0 aHJlYWQuCiAgICAgICAgIGNvbnRleHQtPnN0YWdlID0gU3RhZ2U6OkluaXRpYWxpemVkOwogICAg ICAgICBjb250ZXh0LT5jb25kaXRpb24uc2lnbmFsKCk7CiAgICAgfQotCi0gICAgZW50cnlQb2lu dCgpOworICAgIGZ1bmN0aW9uKCk7CiB9CiAKIFJlZlB0cjxUaHJlYWQ+IFRocmVhZDo6Y3JlYXRl KGNvbnN0IGNoYXIqIG5hbWUsIEZ1bmN0aW9uPHZvaWQoKT4mJiBlbnRyeVBvaW50KQogewotICAg IE5ld1RocmVhZENvbnRleHQgY29udGV4dCB7IG5hbWUsIFdURk1vdmUoZW50cnlQb2ludCksIFN0 YWdlOjpTdGFydCwgeyB9LCB7IH0gfTsKLQorICAgIFJlZjxUaHJlYWQ+IHRocmVhZCA9IGFkb3B0 UmVmKCpuZXcgVGhyZWFkKCkpOworICAgIE5ld1RocmVhZENvbnRleHQgY29udGV4dCB7IG5hbWUs IFdURk1vdmUoZW50cnlQb2ludCksIFN0YWdlOjpTdGFydCwgeyB9LCB7IH0sIHRocmVhZC5nZXQo KSB9OwogICAgIE11dGV4TG9ja2VyIGxvY2tlcihjb250ZXh0Lm11dGV4KTsKLSAgICBSZWZQdHI8 VGhyZWFkPiByZXN1bHQgPSBUaHJlYWQ6OmNyZWF0ZUludGVybmFsKHRocmVhZEVudHJ5UG9pbnQs ICZjb250ZXh0LCBuYW1lKTsKKyAgICBpZiAoIXRocmVhZC0+ZXN0YWJsaXNoSGFuZGxlKCZjb250 ZXh0KSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgY29udGV4dC5zdGFnZSA9IFN0YWdl OjpFc3RhYmxpc2hlZEhhbmRsZTsKICAgICAvLyBBZnRlciBlc3RhYmxpc2hpbmcgVGhyZWFkLCBy ZWxlYXNlIHRoZSBtdXRleCBhbmQgd2FpdCBmb3IgY29tcGxldGlvbiBvZiBpbml0aWFsaXphdGlv bi4KICAgICB3aGlsZSAoY29udGV4dC5zdGFnZSAhPSBTdGFnZTo6SW5pdGlhbGl6ZWQpCiAgICAg ICAgIGNvbnRleHQuY29uZGl0aW9uLndhaXQoY29udGV4dC5tdXRleCk7Ci0KLSAgICByZXR1cm4g cmVzdWx0OworICAgIHJldHVybiBXVEZNb3ZlKHRocmVhZCk7CiB9CiAKIFRocmVhZCogVGhyZWFk OjpjdXJyZW50TWF5QmVOdWxsKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGlu Zy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKaW5kZXggODg4MWNjZWU4ZGE0MGUzZDBm NDJhYjgwNjg0ODMwMDk4NzY2OWFiYS4uMGU2OWNkYzdiMDlhNWE0NzllNDZiYzZhNjA0M2E1MTY5 ZjExZjQzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKKysrIGIvU291 cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKQEAgLTEwOCw4ICsxMDgsOCBAQCBjbGFzcyBUaHJlYWQg OiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7CiAKICAgICAvLyBDYWxsZWQg aW4gdGhlIHRocmVhZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24uCiAgICAgLy8gSGVscGZ1bCBmb3Ig cGxhdGZvcm1zIHdoZXJlIHRoZSB0aHJlYWQgbmFtZSBtdXN0IGJlIHNldCBmcm9tIHdpdGhpbiB0 aGUgdGhyZWFkLgotICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJu YWwoY29uc3QgY2hhciogdGhyZWFkTmFtZSk7Ci0gICAgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZUN1 cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCk7CisgICAgc3RhdGljIHZvaWQgaW5pdGlh bGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbChUaHJlYWQmLCBjb25zdCBjaGFyKiB0aHJlYWROYW1l KTsKKyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNy ZWF0ZWQoVGhyZWFkJik7CiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgdm9pZCBkdW1wKFByaW50 U3RyZWFtJiBvdXQpIGNvbnN0OwogCkBAIC0xMzYsMTYgKzEzNiwxOCBAQCBjbGFzcyBUaHJlYWQg OiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8VGhyZWFkPiB7CiAgICAgbWFjaF9wb3J0X3Qg bWFjaFRocmVhZCgpIHsgcmV0dXJuIG1fcGxhdGZvcm1UaHJlYWQ7IH0KICNlbmRpZgogCisgICAg c3RydWN0IE5ld1RocmVhZENvbnRleHQ7CisgICAgc3RhdGljIHZvaWQgZW50cnlQb2ludChOZXdU aHJlYWRDb250ZXh0KiBkYXRhKTsKIHByb3RlY3RlZDoKICAgICBUaHJlYWQoKTsKIAotICAgIC8v IEludGVybmFsIHBsYXRmb3JtLXNwZWNpZmljIFRocmVhZDo6Y3JlYXRlIGltcGxlbWVudGF0aW9u LgotICAgIHN0YXRpYyBSZWZQdHI8VGhyZWFkPiBjcmVhdGVJbnRlcm5hbChUaHJlYWRGdW5jdGlv biwgdm9pZCosIGNvbnN0IGNoYXIqIHRocmVhZE5hbWUpOworICAgIC8vIEludGVybmFsIHBsYXRm b3JtLXNwZWNpZmljIFRocmVhZCBlc3RhYmxpc2htZW50IGltcGxlbWVudGF0aW9uLgorICAgIGJv b2wgZXN0YWJsaXNoSGFuZGxlKE5ld1RocmVhZENvbnRleHQqIGRhdGEpOwogCiAjaWYgVVNFKFBU SFJFQURTKQotICAgIHZvaWQgZXN0YWJsaXNoKHB0aHJlYWRfdCk7CisgICAgdm9pZCBlc3RhYmxp c2hQbGF0Zm9ybVNwZWNpZmljSGFuZGxlKHB0aHJlYWRfdCk7CiAjZWxzZQotICAgIHZvaWQgZXN0 YWJsaXNoKEhBTkRMRSwgVGhyZWFkSWRlbnRpZmllcik7CisgICAgdm9pZCBlc3RhYmxpc2hQbGF0 Zm9ybVNwZWNpZmljSGFuZGxlKEhBTkRMRSwgVGhyZWFkSWRlbnRpZmllcik7CiAjZW5kaWYKICAg ICB2b2lkIGluaXRpYWxpemUoKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvVGhyZWFk aW5nUHRocmVhZHMuY3BwIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nUHRocmVhZHMuY3BwCmlu ZGV4IGZhODBjMDQ4MDE5ZDg5ZDNhOTgwMjk2OTNiNzZkYjI4OWNhNzE1MjQuLmU1Mzc1MzZiZDg1 NjFlNWYzYTg0NzE3NzE3YWUzOTczMjc4OWVmNzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L1RocmVhZGluZ1B0aHJlYWRzLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmdQdGhy ZWFkcy5jcHAKQEAgLTQwLDcgKzQwLDYgQEAKICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQu aD4KICNpbmNsdWRlIDx3dGYvUmF3UG9pbnRlci5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRy YXMuaD4KLSNpbmNsdWRlIDx3dGYvVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uLmg+CiAjaW5jbHVk ZSA8d3RmL1RocmVhZEhvbGRlci5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmdQcmltaXRpdmVz Lmg+CiAjaW5jbHVkZSA8d3RmL1dvcmRMb2NrLmg+CkBAIC0xODgsOSArMTg3LDkgQEAgdm9pZCBU aHJlYWQ6OmluaXRpYWxpemVQbGF0Zm9ybVRocmVhZGluZygpCiAjZW5kaWYKIH0KIAotdm9pZCBU aHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkRXZlbklmTm9uV1RGQ3JlYXRlZCgpCit2b2lk IFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKFRocmVh ZCYgdGhyZWFkKQogewotICAgIFRocmVhZDo6Y3VycmVudCgpLmluaXRpYWxpemUoKTsKKyAgICB0 aHJlYWQuaW5pdGlhbGl6ZSgpOwogI2lmICFPUyhEQVJXSU4pCiAgICAgc2lnc2V0X3QgbWFzazsK ICAgICBzaWdlbXB0eXNldCgmbWFzayk7CkBAIC0xOTksNDQgKzE5OCwzMSBAQCB2b2lkIFRocmVh ZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCkKICNlbmRpZgog fQogCi1zdGF0aWMgdm9pZCogd3RmVGhyZWFkRW50cnlQb2ludCh2b2lkKiBwYXJhbSkKK3N0YXRp YyB2b2lkKiB3dGZUaHJlYWRFbnRyeVBvaW50KHZvaWQqIGRhdGEpCiB7Ci0gICAgLy8gQmFsYW5j ZWQgYnkgLmxlYWtQdHIoKSBpbiBUaHJlYWQ6OmNyZWF0ZUludGVybmFsLgotICAgIGF1dG8gaW52 b2NhdGlvbiA9IHN0ZDo6dW5pcXVlX3B0cjxUaHJlYWRGdW5jdGlvbkludm9jYXRpb24+KHN0YXRp Y19jYXN0PFRocmVhZEZ1bmN0aW9uSW52b2NhdGlvbio+KHBhcmFtKSk7Ci0KLSAgICBUaHJlYWRI b2xkZXI6OmluaXRpYWxpemUoKmludm9jYXRpb24tPnRocmVhZCk7Ci0gICAgaW52b2NhdGlvbi0+ dGhyZWFkID0gbnVsbHB0cjsKLQotICAgIGludm9jYXRpb24tPmZ1bmN0aW9uKGludm9jYXRpb24t PmRhdGEpOworICAgIFRocmVhZDo6ZW50cnlQb2ludChyZWludGVycHJldF9jYXN0PFRocmVhZDo6 TmV3VGhyZWFkQ29udGV4dCo+KGRhdGEpKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAotUmVm UHRyPFRocmVhZD4gVGhyZWFkOjpjcmVhdGVJbnRlcm5hbChUaHJlYWRGdW5jdGlvbiBlbnRyeVBv aW50LCB2b2lkKiBkYXRhLCBjb25zdCBjaGFyKikKK2Jvb2wgVGhyZWFkOjplc3RhYmxpc2hIYW5k bGUoTmV3VGhyZWFkQ29udGV4dCogZGF0YSkKIHsKLSAgICBSZWZQdHI8VGhyZWFkPiB0aHJlYWQg PSBhZG9wdFJlZihuZXcgVGhyZWFkKCkpOwotICAgIGF1dG8gaW52b2NhdGlvbiA9IHN0ZDo6bWFr ZV91bmlxdWU8VGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uPihlbnRyeVBvaW50LCB0aHJlYWQuZ2V0 KCksIGRhdGEpOwogICAgIHB0aHJlYWRfdCB0aHJlYWRIYW5kbGU7CiAgICAgcHRocmVhZF9hdHRy X3QgYXR0cjsKICAgICBwdGhyZWFkX2F0dHJfaW5pdCgmYXR0cik7CiAjaWYgSEFWRShRT1NfQ0xB U1NFUykKICAgICBwdGhyZWFkX2F0dHJfc2V0X3Fvc19jbGFzc19ucCgmYXR0ciwgYWRqdXN0ZWRR T1NDbGFzcyhRT1NfQ0xBU1NfVVNFUl9JTklUSUFURUQpLCAwKTsKICNlbmRpZgotICAgIGludCBl cnJvciA9IHB0aHJlYWRfY3JlYXRlKCZ0aHJlYWRIYW5kbGUsICZhdHRyLCB3dGZUaHJlYWRFbnRy eVBvaW50LCBpbnZvY2F0aW9uLmdldCgpKTsKKyAgICBpbnQgZXJyb3IgPSBwdGhyZWFkX2NyZWF0 ZSgmdGhyZWFkSGFuZGxlLCAmYXR0ciwgd3RmVGhyZWFkRW50cnlQb2ludCwgZGF0YSk7CiAgICAg cHRocmVhZF9hdHRyX2Rlc3Ryb3koJmF0dHIpOwogICAgIGlmIChlcnJvcikgewotICAgICAgICBM T0dfRVJST1IoIkZhaWxlZCB0byBjcmVhdGUgcHRocmVhZCBhdCBlbnRyeSBwb2ludCAlcCB3aXRo IGRhdGEgJXAiLCB3dGZUaHJlYWRFbnRyeVBvaW50LCBpbnZvY2F0aW9uLmdldCgpKTsKLSAgICAg ICAgcmV0dXJuIG51bGxwdHI7CisgICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGNyZWF0ZSBw dGhyZWFkIGF0IGVudHJ5IHBvaW50ICVwIHdpdGggZGF0YSAlcCIsIHd0ZlRocmVhZEVudHJ5UG9p bnQsIGRhdGEpOworICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotCi0gICAgLy8gQmFsYW5j ZWQgYnkgc3RkOjp1bmlxdWVfcHRyIGNvbnN0cnVjdG9yIGluIHd0ZlRocmVhZEVudHJ5UG9pbnQu Ci0gICAgVGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uKiBsZWFrZWRJbnZvY2F0aW9uID0gaW52b2Nh dGlvbi5yZWxlYXNlKCk7Ci0gICAgVU5VU0VEX1BBUkFNKGxlYWtlZEludm9jYXRpb24pOwotCi0g ICAgdGhyZWFkLT5lc3RhYmxpc2godGhyZWFkSGFuZGxlKTsKLSAgICByZXR1cm4gdGhyZWFkOwor ICAgIGVzdGFibGlzaFBsYXRmb3JtU3BlY2lmaWNIYW5kbGUodGhyZWFkSGFuZGxlKTsKKyAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50 ZXJuYWwoY29uc3QgY2hhciogdGhyZWFkTmFtZSkKK3ZvaWQgVGhyZWFkOjppbml0aWFsaXplQ3Vy cmVudFRocmVhZEludGVybmFsKFRocmVhZCYgdGhyZWFkLCBjb25zdCBjaGFyKiB0aHJlYWROYW1l KQogewogI2lmIEhBVkUoUFRIUkVBRF9TRVROQU1FX05QKQogICAgIHB0aHJlYWRfc2V0bmFtZV9u cChub3JtYWxpemVUaHJlYWROYW1lKHRocmVhZE5hbWUpKTsKQEAgLTI0NSw3ICsyMzEsNyBAQCB2 b2lkIFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbChjb25zdCBjaGFyKiB0 aHJlYWROYW1lKQogI2Vsc2UKICAgICBVTlVTRURfUEFSQU0odGhyZWFkTmFtZSk7CiAjZW5kaWYK LSAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoKTsKKyAgICBp bml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQodGhyZWFkKTsKIH0KIAog dm9pZCBUaHJlYWQ6OmNoYW5nZVByaW9yaXR5KGludCBkZWx0YSkKQEAgLTMwNyw5ICsyOTMsOSBA QCBUaHJlYWQmIFRocmVhZDo6Y3VycmVudCgpCiAKICAgICAvLyBOb3QgYSBXVEYtY3JlYXRlZCB0 aHJlYWQsIFRocmVhZElkZW50aWZpZXIgaXMgbm90IGVzdGFibGlzaGVkIHlldC4KICAgICBSZWY8 VGhyZWFkPiB0aHJlYWQgPSBhZG9wdFJlZigqbmV3IFRocmVhZCgpKTsKLSAgICB0aHJlYWQtPmVz dGFibGlzaChwdGhyZWFkX3NlbGYoKSk7CisgICAgdGhyZWFkLT5lc3RhYmxpc2hQbGF0Zm9ybVNw ZWNpZmljSGFuZGxlKHB0aHJlYWRfc2VsZigpKTsKICAgICBUaHJlYWRIb2xkZXI6OmluaXRpYWxp emUodGhyZWFkLmdldCgpKTsKLSAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldU RkNyZWF0ZWQoKTsKKyAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0 ZWQodGhyZWFkLmdldCgpKTsKICAgICByZXR1cm4gdGhyZWFkLmdldCgpOwogfQogCkBAIC00NDMs NyArNDI5LDcgQEAgc2l6ZV90IFRocmVhZDo6Z2V0UmVnaXN0ZXJzKFBsYXRmb3JtUmVnaXN0ZXJz JiByZWdpc3RlcnMpCiAjZW5kaWYKIH0KIAotdm9pZCBUaHJlYWQ6OmVzdGFibGlzaChwdGhyZWFk X3QgaGFuZGxlKQordm9pZCBUaHJlYWQ6OmVzdGFibGlzaFBsYXRmb3JtU3BlY2lmaWNIYW5kbGUo cHRocmVhZF90IGhhbmRsZSkKIHsKICAgICBzdGQ6OmxvY2tfZ3VhcmQ8c3RkOjptdXRleD4gbG9j a2VyKG1fbXV0ZXgpOwogICAgIG1faGFuZGxlID0gaGFuZGxlOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvVGhyZWFkaW5nV2luLmNwcCBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZ1dpbi5j cHAKaW5kZXggZWUxYzRkNDNmZTdmMTUyMzZhZDk1YmE5YTdiYWQ3YTFlNDEzNjQ3Mi4uNzdjZDc0 ZTZiNzlhNGE4NjU0MmNhMTllNTVhODY5MmJkZWM0ZGM4MyAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri93dGYvVGhyZWFkaW5nV2luLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmdXaW4u Y3BwCkBAIC04OCwyMCArODgsMTYgQEAKIAogI2lmIE9TKFdJTkRPV1MpCiAKKyNpbmNsdWRlIDxl cnJuby5oPgogI2luY2x1ZGUgPHByb2Nlc3MuaD4KICNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjaW5j bHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KICNp bmNsdWRlIDx3dGYvTWF0aEV4dHJhcy5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5o PgotI2luY2x1ZGUgPHd0Zi9UaHJlYWRGdW5jdGlvbkludm9jYXRpb24uaD4KICNpbmNsdWRlIDx3 dGYvVGhyZWFkSG9sZGVyLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZ1ByaW1pdGl2ZXMuaD4K IAotI2lmIEhBVkUoRVJSTk9fSCkKLSNpbmNsdWRlIDxlcnJuby5oPgotI2VuZGlmCi0KIG5hbWVz cGFjZSBXVEYgewogCiBUaHJlYWQ6OlRocmVhZCgpCkBAIC0xMTYsOSArMTEyLDkgQEAgVGhyZWFk Ojp+VGhyZWFkKCkKICAgICAgICAgQ2xvc2VIYW5kbGUobV9oYW5kbGUpOwogfQogCi12b2lkIFRo cmVhZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRFdmVuSWZOb25XVEZDcmVhdGVkKCkKK3ZvaWQg VGhyZWFkOjppbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5vbldURkNyZWF0ZWQoVGhyZWFk JiB0aHJlYWQpCiB7Ci0gICAgVGhyZWFkOjpjdXJyZW50KCkuaW5pdGlhbGl6ZSgpOworICAgIHRo cmVhZC5pbml0aWFsaXplKCk7CiB9CiAKIC8vIE1TX1ZDX0VYQ0VQVElPTiwgVEhSRUFETkFNRV9J TkZPLCBhbmQgc2V0VGhyZWFkTmFtZUludGVybmFsIGFsbCBjb21lIGZyb20gPGh0dHA6Ly9tc2Ru Lm1pY3Jvc29mdC5jb20vZW4tdXMvbGlicmFyeS94Y2Iyejhocy5hc3B4Pi4KQEAgLTEzMyw3ICsx MjksNyBAQCB0eXBlZGVmIHN0cnVjdCB0YWdUSFJFQUROQU1FX0lORk8gewogfSBUSFJFQUROQU1F X0lORk87CiAjcHJhZ21hIHBhY2socG9wKQogCi12b2lkIFRocmVhZDo6aW5pdGlhbGl6ZUN1cnJl bnRUaHJlYWRJbnRlcm5hbChjb25zdCBjaGFyKiBzelRocmVhZE5hbWUpCit2b2lkIFRocmVhZDo6 aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbChUaHJlYWQmIHRocmVhZCwgY29uc3QgY2hh ciogc3pUaHJlYWROYW1lKQogewogI2lmIENPTVBJTEVSKE1JTkdXKQogICAgIC8vIEZJWE1FOiBJ bXBsZW1lbnQgdGhyZWFkIG5hbWUgc2V0dGluZyB3aXRoIE1pbmdXLgpAQCAtMTUwLDQ5ICsxNDYs MjkgQEAgdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoY29uc3Qg Y2hhciogc3pUaHJlYWROYW1lKQogICAgIH0gX19leGNlcHQgKEVYQ0VQVElPTl9DT05USU5VRV9F WEVDVVRJT04pIHsKICAgICB9CiAjZW5kaWYKLSAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2 ZW5JZk5vbldURkNyZWF0ZWQoKTsKKyAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5v bldURkNyZWF0ZWQodGhyZWFkKTsKIH0KIAogdm9pZCBUaHJlYWQ6OmluaXRpYWxpemVQbGF0Zm9y bVRocmVhZGluZygpCiB7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBfX3N0ZGNhbGwgd3RmVGhyZWFk RW50cnlQb2ludCh2b2lkKiBwYXJhbSkKK3N0YXRpYyB1bnNpZ25lZCBfX3N0ZGNhbGwgd3RmVGhy ZWFkRW50cnlQb2ludCh2b2lkKiBkYXRhKQogewotICAgIC8vIEJhbGFuY2VkIGJ5IC5sZWFrUHRy KCkgaW4gVGhyZWFkOjpjcmVhdGVJbnRlcm5hbC4KLSAgICBhdXRvIGludm9jYXRpb24gPSBzdGQ6 OnVuaXF1ZV9wdHI8VGhyZWFkRnVuY3Rpb25JbnZvY2F0aW9uPihzdGF0aWNfY2FzdDxUaHJlYWRG dW5jdGlvbkludm9jYXRpb24qPihwYXJhbSkpOwotCi0gICAgVGhyZWFkSG9sZGVyOjppbml0aWFs aXplKCppbnZvY2F0aW9uLT50aHJlYWQsIFRocmVhZDo6Y3VycmVudElEKCkpOwotICAgIGludm9j YXRpb24tPnRocmVhZCA9IG51bGxwdHI7Ci0KLSAgICBpbnZvY2F0aW9uLT5mdW5jdGlvbihpbnZv Y2F0aW9uLT5kYXRhKTsKKyAgICBUaHJlYWQ6OmVudHJ5UG9pbnQocmVpbnRlcnByZXRfY2FzdDxU aHJlYWQ6Ok5ld1RocmVhZENvbnRleHQqPihkYXRhKSk7CiAgICAgcmV0dXJuIDA7CiB9CiAKLVJl ZlB0cjxUaHJlYWQ+IFRocmVhZDo6Y3JlYXRlSW50ZXJuYWwoVGhyZWFkRnVuY3Rpb24gZW50cnlQ b2ludCwgdm9pZCogZGF0YSwgY29uc3QgY2hhciogdGhyZWFkTmFtZSkKK2Jvb2wgVGhyZWFkOjpl c3RhYmxpc2hIYW5kbGUoTmV3VGhyZWFkQ29udGV4dCogZGF0YSkKIHsKLSAgICBSZWY8VGhyZWFk PiB0aHJlYWQgPSBhZG9wdFJlZigqbmV3IFRocmVhZCgpKTsKICAgICB1bnNpZ25lZCB0aHJlYWRJ ZGVudGlmaWVyID0gMDsKLSAgICBUaHJlYWRJZGVudGlmaWVyIHRocmVhZElEID0gMDsKLSAgICBh dXRvIGludm9jYXRpb24gPSBzdGQ6Om1ha2VfdW5pcXVlPFRocmVhZEZ1bmN0aW9uSW52b2NhdGlv bj4oZW50cnlQb2ludCwgdGhyZWFkLnB0cigpLCBkYXRhKTsKLSAgICBIQU5ETEUgdGhyZWFkSGFu ZGxlID0gcmVpbnRlcnByZXRfY2FzdDxIQU5ETEU+KF9iZWdpbnRocmVhZGV4KDAsIDAsIHd0ZlRo cmVhZEVudHJ5UG9pbnQsIGludm9jYXRpb24uZ2V0KCksIDAsICZ0aHJlYWRJZGVudGlmaWVyKSk7 CisgICAgSEFORExFIHRocmVhZEhhbmRsZSA9IHJlaW50ZXJwcmV0X2Nhc3Q8SEFORExFPihfYmVn aW50aHJlYWRleCgwLCAwLCB3dGZUaHJlYWRFbnRyeVBvaW50LCBkYXRhLCAwLCAmdGhyZWFkSWRl bnRpZmllcikpOwogICAgIGlmICghdGhyZWFkSGFuZGxlKSB7Ci0jaWYgIUhBVkUoRVJSTk9fSCkK LSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRocmVhZCBhdCBlbnRyeSBwb2lu dCAlcCB3aXRoIGRhdGEgJXAuIiwgZW50cnlQb2ludCwgZGF0YSk7Ci0jZWxzZQotICAgICAgICBM T0dfRVJST1IoIkZhaWxlZCB0byBjcmVhdGUgdGhyZWFkIGF0IGVudHJ5IHBvaW50ICVwIHdpdGgg ZGF0YSAlcDogJWxkIiwgZW50cnlQb2ludCwgZGF0YSwgZXJybm8pOwotI2VuZGlmCi0gICAgICAg IHJldHVybiAwOworICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBjcmVhdGUgdGhyZWFkIGF0 IGVudHJ5IHBvaW50ICVwIHdpdGggZGF0YSAlcDogJWxkIiwgd3RmVGhyZWFkRW50cnlQb2ludCwg ZGF0YSwgZXJybm8pOworICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotCi0gICAgLy8gVGhl IHRocmVhZCB3aWxsIHRha2Ugb3duZXJzaGlwIG9mIGludm9jYXRpb24uCi0gICAgVGhyZWFkRnVu Y3Rpb25JbnZvY2F0aW9uKiBsZWFrZWRJbnZvY2F0aW9uID0gaW52b2NhdGlvbi5yZWxlYXNlKCk7 Ci0gICAgVU5VU0VEX1BBUkFNKGxlYWtlZEludm9jYXRpb24pOwotCi0gICAgdGhyZWFkSUQgPSBz dGF0aWNfY2FzdDxUaHJlYWRJZGVudGlmaWVyPih0aHJlYWRJZGVudGlmaWVyKTsKLQotICAgIHRo cmVhZC0+ZXN0YWJsaXNoKHRocmVhZEhhbmRsZSwgdGhyZWFkSWRlbnRpZmllcik7Ci0gICAgcmV0 dXJuIHRocmVhZDsKKyAgICBlc3RhYmxpc2hQbGF0Zm9ybVNwZWNpZmljSGFuZGxlKHRocmVhZEhh bmRsZSwgdGhyZWFkSWRlbnRpZmllcik7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIHZvaWQgVGhy ZWFkOjpjaGFuZ2VQcmlvcml0eShpbnQgZGVsdGEpCkBAIC0yNzcsOSArMjUzLDkgQEAgVGhyZWFk JiBUaHJlYWQ6OmN1cnJlbnQoKQogICAgIGJvb2wgaXNTdWNjZXNzZnVsID0gRHVwbGljYXRlSGFu ZGxlKEdldEN1cnJlbnRQcm9jZXNzKCksIEdldEN1cnJlbnRUaHJlYWQoKSwgR2V0Q3VycmVudFBy b2Nlc3MoKSwgJmhhbmRsZSwgMCwgRkFMU0UsIERVUExJQ0FURV9TQU1FX0FDQ0VTUyk7CiAgICAg UkVMRUFTRV9BU1NFUlQoaXNTdWNjZXNzZnVsKTsKIAotICAgIHRocmVhZC0+ZXN0YWJsaXNoKGhh bmRsZSwgY3VycmVudElEKCkpOwotICAgIFRocmVhZEhvbGRlcjo6aW5pdGlhbGl6ZSh0aHJlYWQu Z2V0KCksIFRocmVhZDo6Y3VycmVudElEKCkpOwotICAgIGluaXRpYWxpemVDdXJyZW50VGhyZWFk RXZlbklmTm9uV1RGQ3JlYXRlZCgpOworICAgIHRocmVhZC0+ZXN0YWJsaXNoUGxhdGZvcm1TcGVj aWZpY0hhbmRsZShoYW5kbGUsIGN1cnJlbnRJRCgpKTsKKyAgICBUaHJlYWRIb2xkZXI6OmluaXRp YWxpemUodGhyZWFkLmdldCgpKTsKKyAgICBpbml0aWFsaXplQ3VycmVudFRocmVhZEV2ZW5JZk5v bldURkNyZWF0ZWQodGhyZWFkLmdldCgpKTsKICAgICByZXR1cm4gdGhyZWFkLmdldCgpOwogfQog CkBAIC0yODgsNyArMjY0LDcgQEAgVGhyZWFkSWRlbnRpZmllciBUaHJlYWQ6OmN1cnJlbnRJRCgp CiAgICAgcmV0dXJuIHN0YXRpY19jYXN0PFRocmVhZElkZW50aWZpZXI+KEdldEN1cnJlbnRUaHJl YWRJZCgpKTsKIH0KIAotdm9pZCBUaHJlYWQ6OmVzdGFibGlzaChIQU5ETEUgaGFuZGxlLCBUaHJl YWRJZGVudGlmaWVyIHRocmVhZElEKQordm9pZCBUaHJlYWQ6OmVzdGFibGlzaFBsYXRmb3JtU3Bl Y2lmaWNIYW5kbGUoSEFORExFIGhhbmRsZSwgVGhyZWFkSWRlbnRpZmllciB0aHJlYWRJRCkKIHsK ICAgICBzdGQ6OmxvY2tfZ3VhcmQ8c3RkOjptdXRleD4gbG9ja2VyKG1fbXV0ZXgpOwogICAgIG1f aGFuZGxlID0gaGFuZGxlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvd2luL01haW5UaHJl YWRXaW4uY3BwIGIvU291cmNlL1dURi93dGYvd2luL01haW5UaHJlYWRXaW4uY3BwCmluZGV4IGE2 NDczZDA3YjY3ZWFjYzg2YmU3YTRlYjY5NzQ5ODkzZWM2MTQ5N2YuLmVmNTQ5YmZkNjY5ZjcxNDFj MDVhZmZjNjIwOTBlOTkyMTI1YThkYjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL3dpbi9N YWluVGhyZWFkV2luLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi93aW4vTWFpblRocmVhZFdpbi5j cHAKQEAgLTY0LDcgKzY0LDcgQEAgdm9pZCBpbml0aWFsaXplTWFpblRocmVhZFBsYXRmb3JtKCkK ICAgICAgICAgQ1dfVVNFREVGQVVMVCwgMCwgQ1dfVVNFREVGQVVMVCwgMCwgSFdORF9NRVNTQUdF LCAwLCAwLCAwKTsKICAgICB0aHJlYWRpbmdGaXJlZE1lc3NhZ2UgPSBSZWdpc3RlcldpbmRvd01l c3NhZ2VXKEwiY29tLmFwcGxlLldlYktpdC5NYWluVGhyZWFkRmlyZWQiKTsKIAotICAgIFRocmVh ZDo6aW5pdGlhbGl6ZUN1cnJlbnRUaHJlYWRJbnRlcm5hbCgiTWFpbiBUaHJlYWQiKTsKKyAgICBU aHJlYWQ6OmluaXRpYWxpemVDdXJyZW50VGhyZWFkSW50ZXJuYWwoVGhyZWFkOjpjdXJyZW50KCks ICJNYWluIFRocmVhZCIpOwogfQogCiB2b2lkIHNjaGVkdWxlRGlzcGF0Y2hGdW5jdGlvbnNPbk1h aW5UaHJlYWQoKQo=