92365 2012-07-26 04:16:36 -0700 Refactor cross thread communication 2012-08-16 09:28:36 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Unspecified Unspecified UNCONFIRMED P2 Normal --- 0 gram webkit-unassigned andersca ap cwhong893 dev dongseong.hwang jaepark joenotcharles levin mburtin skyul yoon zoltan oldest_to_newest 679141 0 gram 2012-07-26 04:16:36 -0700 1. Introduction In WebCore, there are several implementations of threads, tasks and cross thread communication. For example, FileThread, DatabaseThread and StorageThread perform blocking IO asynchronously and invoke callbacks using ScriptExecutionContext. Unfortunately, there is no code sharing at all though each of these implementation is pretty similar. Every thread has its own slightly different cross thread communication mechanism. We will be better off if we could unify the cross thread communication mechanism and reuse it. Levin’s sample proposal looks promising, but I think the very first step is to refactor common code into reusable components and combine various task classes into one. Levin filed a bug on Bug 51857 and wrote a wiki on this issue: https://trac.webkit.org/wiki/ThreadCommunication 2. Requirements I analyzed the current task threads code and extracted basic requirements: - Add a task to the end of the task queue (append) - Add a task to the front of the task queue (prepend) - Cancel a group of tasks that are pending in the task queue - Specify an action that will performed on thread termination 3. API Proposal 3.1 Task Instead of creating a task type for each use case, WTF::Function is used everywhere. CrossThreadTask is merged into WTF::Function because they play essentially the same role. However, there is one problem with WTF::Function. When binding a non-static method with WTF::Function, if the receiver object’s class has ref/deref methods, the object’s reference count is incremented and decremented on WTF::Function construction and destruction respectively. If the object’s class is not a subclass of ThreadSafeRefCounted, this behavior can cause a race condition. We must modify WTF::Function to perform ref/deref only for ThreadSafeRefCounted. 3.2 TaskGroup From the requirement above, we must be able to cancel a group of task. TaskGroup is introduced to specify the group of a task. When posting a task, we can specify the task group where the task belongs. See TaskThread::postTask(const Function<void()>& task, PassRefPtr<TaskGroup> group) method below. class TaskGroup : public ThreadSafeRefCounted<TaskGroup> { }; 3.3 Thread TaskThread is our new abstraction for task thread. FileThread, DatabaseThread and other task threads reuse the code by inheriting from TaskThread. class TaskThread : public ThreadSafeRefCounted<TaskThread> { public: ~TaskThread(); void start(); void stop(); // Schedule a task to be executed by the task thread. void postTask(const Function<void()>& task); // Schedule a task to be executed by the task thread and also specify the task group. // Tasks scheduled with this method can be cancelled by removeTasks() method. void postTask(const Function<void()>& task, PassRefPtr<TaskGroup> group); // Schedule a task to be immediately executed by the task thread. void postImmediateTask(PassOwnPtr<TaskThreadTask> task); // Schedule a task to be executed by the task thread and also specify the task group. // Tasks scheduled with this method can be cancelled by removeTasks() method. void postImmediateTask(const Function<void()>& task, PassRefPtr<TaskGroup> group); // Cancel pending tasks that belong to the given group. void removeTasks(PassRefPtr<TaskGroup> group); protected: TaskThread(); // Subclasses can override this method to specify an action to be executed // on thread termination virtual void onRunLoopTerminated(); }; 3.4 Callback to ScriptExecutionContext ScriptExecutionContext::postTask() now takes a WTF::Function as an argument because WTF::Function replaced CrossThreadTask. class ScriptExecutionContext : public SecurityContext, public Supplementable<ScriptExecutionContext> { public: … virtual void postTask(const Function<void()>&) = 0; ... }; There is a small change in usage. CrossThreadTask does not bind the pointer to ScriptExecutionContext because it is automatically passed as the first argument when the task is invoked. However, since WTF::Function does not support partial application, the pointer to ScriptExecutionContext must be bound as the first argument when binding parameters to a task. This is possible because task threads already know the pointer. See the example below. void AsyncFileStream::openForReadOnFileThread(const String& path, long long offset, long long length) { bool success = m_stream->openForRead(path, offset, length); m_context->postTask(createCallbackTask(&didOpen, AllowCrossThreadAccess(this), success)); } => void AsyncFileStream::openForReadOnFileThread(const String& path, long long offset, long long length) { bool success = m_stream->openForRead(path, offset, length); m_context->postTask(bind(&didOpen, m_context, this, success)); } 3.5 CrossThreadCopyable If the parameter type is a subclass of CrossThreadCopyable, the parameter is copied by calling crossThreadCopy(). template<typename Orig, New> class CrossThreadCopyable<Orig, New> { public: virtual New crossThreadCopy(); } AllowCrossThreadAccess is no longer needed because WTF::Function ref counts only the first parameter. 3.6 deepCopy If a class can’t be a subclass of CrossThreadCopyable, deepCopy() can be used to pass thread-unsafe instances by calling custom copy methods. For example, we can pass String and KURL instances thread-safely by wrapping them with deepCopy. For a string s, deepCopy(s) returns s.isolatedCopy(). void LocalFileSystem::readFileSystem(ScriptExecutionContext* context, FileSystemType, PassOwnPtr<AsyncFileSystemCallbacks> callbacks, FileSystemSynchronousType) { context->postTask(bind(&openFileSystem, context, deepCopy(fileSystemBasePath()), deepCopy(fcontext->securityOrigin()->databaseIdentifier()), false, callbacks)); } 4. Plan This proposal does not add any new mechanism except for a few minor changes in WTF::Function. It simply removes duplicated code and extracts common code into reusable components. Once we have this refactoring done successfully, we can move on to fancier cross thread communication mechanism. Before I take an initiative to work hard on this proposal, I want to hear opinions from reviewers and committers who understand WebKit threads very well. Also if you have any concerns on implementation level details, please let me know before I struggle with C++ template hacks :) 680030 1 gram 2012-07-26 19:37:54 -0700 Correct some mistakes and change the name of the virtual method. > class TaskThread : public ThreadSafeRefCounted<TaskThread> { > public: > ~TaskThread(); virtual ~TaskThread(); > void start(); > void stop(); > > // Schedule a task to be executed by the task thread. > void postTask(const Function<void()>& task); > // Schedule a task to be executed by the task thread and also specify the task group. > // Tasks scheduled with this method can be cancelled by removeTasks() method. > void postTask(const Function<void()>& task, PassRefPtr<TaskGroup> group); > > // Schedule a task to be immediately executed by the task thread. > void postImmediateTask(PassOwnPtr<TaskThreadTask> task); void postImmediateTask(const Function<void()>& task); > // Schedule a task to be executed by the task thread and also specify the task group. > // Tasks scheduled with this method can be cancelled by removeTasks() method. > void postImmediateTask(const Function<void()>& task, PassRefPtr<TaskGroup> group); > > // Cancel pending tasks that belong to the given group. > void removeTasks(PassRefPtr<TaskGroup> group); > > protected: > TaskThread(); > // Subclasses can override this method to specify an action to be executed > // on thread termination > virtual void onRunLoopTerminated(); virtual void didStopThread(); > }; 680037 2 levin 2012-07-26 19:44:58 -0700 This makes every task implement ThreadSafeRefCounted solely in order to support this "Cancel a group of tasks that are pending in the task queue." Could that be done in a different way in order to avoid this? Also, what is the scenario in which this is needed? It also looks like you're proposing getting rid of the fact that all the copying was done automatically so that people couldn't mess that up by accident. Is that true? 680179 3 gram 2012-07-27 00:01:54 -0700 (In reply to comment #2) > This makes every task implement ThreadSafeRefCounted solely in order to support this > "Cancel a group of tasks that are pending in the task queue." > > Could that be done in a different way in order to avoid this? Also, what is the scenario in which this is needed? I can't understand your question exactly. In my proposal, the task is just a WTF::Function instance. Implementing new class for a task isn't needed. There are some cases canceling a group of the tasks. AsyncFileStream::stop() method unschedules all tasks related to specific FileStream instance by calling FileThread::unscheduleTasks() method. DatabaseThread also has an API for unscheduling all tasks related to specific Database instance. > It also looks like you're proposing getting rid of the fact that all the copying was done automatically so that people couldn't mess that up by accident. Is that true? I don't want to get rid of it so I add CrossThreadCopyable class for automatic parameter copying. But I have to keep the behavior of WTF::Function. For some types like WTF::String, because of that, parameters are copied manually using deepCopy() function. Thank you for your comment. 680194 4 levin 2012-07-27 00:26:30 -0700 (In reply to comment #3) > There are some cases canceling a group of the tasks. > AsyncFileStream::stop() method unschedules all tasks related to specific FileStream instance by calling FileThread::unscheduleTasks() method. DatabaseThread also has an API for unscheduling all tasks related to specific Database instance. > Ok. I misread thing before anyway. I kind of like the TaskGroup thing but I wonder why: 1. I can't just call cancel on it. 2. Why it is called TaskGroup when its sole purpose is to be able to cancel tasks? 3. If there is some error check to determine if it is passed to more than one TaskThread (or perhaps that is ok). > But I have to keep the behavior of WTF::Function. For some types like WTF::String, because of that, parameters are copied manually using deepCopy() function. > Only refer counting the first item seems odd and error prone. I'm all for getting rid of CrossThreadTask but I don't think that WTF::Function plays the same role with this odd behavior. (Actually, I think the CrossThreadTask isn't bad but ScriptExecutionContext should be removed from it.) If WTF::Function is used like CrossThreadTask, then perhaps it should get the functionality to copy/ref every parameter instead of just the first (and CrossThreadTask can go away). One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. btw, thanks for taking this up. I didn't have time to complete all of this and more recently my time on WebKit, etc. has been vastly reduced (largely to making comment like this :).), so I'll admit that perhaps my views may be out of touch with any new thinking that has happened. btw, https://trac.webkit.org/wiki/ThreadCommunication was meant to be the highest level of abstraction with lower level things that could be used. But perhaps it is ok just to go for this lower level but there were some common error prone patterns that kept emerging which insipred it. PS I think this " void postImmediateTask(PassOwnPtr<TaskThreadTask> task);" is a typo (i.e. TaskThreadTask). 680210 5 skyul 2012-07-27 00:44:07 -0700 (In reply to comment #4) > Only refer counting the first item seems odd and error prone. I'm all for getting rid of CrossThreadTask but I don't think that WTF::Function plays the same role with this odd behavior. (Actually, I think the CrossThreadTask isn't bad but ScriptExecutionContext should be removed from it.) If WTF::Function is used like CrossThreadTask, then perhaps it should get the functionality to copy/ref every parameter instead of just the first (and CrossThreadTask can go away). I agree. It seems hard to merge CrossThreadTask into WTF::Function while maintaining the original behavior of WTF::Function. Because WTF::Function is not used frequently in WebKit, we can change the behavior of WTF::Function and modify the corresponding call sites. 680213 6 levin 2012-07-27 00:47:10 -0700 (In reply to comment #5) > (In reply to comment #4) > > Only refer counting the first item seems odd and error prone. I'm all for getting rid of CrossThreadTask but I don't think that WTF::Function plays the same role with this odd behavior. (Actually, I think the CrossThreadTask isn't bad but ScriptExecutionContext should be removed from it.) If WTF::Function is used like CrossThreadTask, then perhaps it should get the functionality to copy/ref every parameter instead of just the first (and CrossThreadTask can go away). > > I agree. It seems hard to merge CrossThreadTask into WTF::Function while maintaining the original behavior of WTF::Function. Because WTF::Function is not used frequently in WebKit, we can change the behavior of WTF::Function and modify the corresponding call sites. Alternatively, you could put a layer on top of WTF::Function to do the copy/ref (but then I would believe that the ref of the first parameter in WTF::Function shouldn't be there and anyone who wants it should use the layer on top of it). I haven't thought deeply about this. Also, if WTF::Function is used within one thread, then it would not be good to have to do CrossThreadCopy for every parameter. 680230 7 skyul 2012-07-27 00:59:06 -0700 (In reply to comment #6) > I haven't thought deeply about this. Also, if WTF::Function is used within one thread, then it would not be good to have to do CrossThreadCopy for every parameter. That's a big problem. Because the name WTF::Function seems not relevant to cross thread communication, people will be surprised to know that every argument of WTF::Function is copied in a cross-thread safe way. 680232 8 levin 2012-07-27 01:00:53 -0700 (In reply to comment #7) > (In reply to comment #6) > > I haven't thought deeply about this. Also, if WTF::Function is used within one thread, then it would not be good to have to do CrossThreadCopy for every parameter. > > That's a big problem. Because the name WTF::Function seems not relevant to cross thread communication, people will be surprised to know that every argument of WTF::Function is copied in a cross-thread safe way. Then perhaps there should just be a WTF::CrossThreadFunction (which does the copy/ref thing) and then uses WTF::Function? 680233 9 skyul 2012-07-27 01:01:56 -0700 (In reply to comment #8) > Then perhaps there should just be a WTF::CrossThreadFunction (which does the copy/ref thing) and then uses WTF::Function? It sounds good to me! Let's listen to Kwonjin's opinion. 680249 10 gram 2012-07-27 01:10:45 -0700 (In reply to comment #9) > (In reply to comment #8) > > Then perhaps there should just be a WTF::CrossThreadFunction (which does the copy/ref thing) and then uses WTF::Function? > > It sounds good to me! Let's listen to Kwonjin's opinion. I also agree on yours. 680317 11 gram 2012-07-27 02:05:12 -0700 (In reply to comment #4) > One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. It's a good idea. But in this step, I just want to refactor current code. I will consider further improvements in the next step. 680329 12 skyul 2012-07-27 02:13:49 -0700 (In reply to comment #11) > (In reply to comment #4) > > One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. > > It's a good idea. But in this step, I just want to refactor current code. > I will consider further improvements in the next step. I think it is important to proceed this refactoring efforts step by step. As Kwonjin mentioned in the design document, the first step is to extract common code into reusable components. Once we have WTF::CrossThreadFunction, TaskGroup and TaskThread in hand, we can easily add fancier features. BTW, Levein, do you know actual WebKit code that can benefit from TaskThreadProxy? 680755 13 levin 2012-07-27 10:02:41 -0700 (In reply to comment #12) > (In reply to comment #11) > > (In reply to comment #4) > > > One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. > > > > It's a good idea. But in this step, I just want to refactor current code. > > I will consider further improvements in the next step. > > I think it is important to proceed this refactoring efforts step by step. As Kwonjin mentioned in the design document, the first step is to extract common code into reusable components. Once we have WTF::CrossThreadFunction, TaskGroup and TaskThread in hand, we can easily add fancier features. > > > BTW, Levein, do you know actual WebKit code that can benefit from TaskThreadProxy? I don't believe that the current implementations of TaskThread are ThreadSafeRefCounted so that would be a change and may introduce some issues when it may be deleted on any thread. So the idea was that other threads would use a TaskThreadProxy instead of the TaskThread itself. (I was inspired by this http://code.google.com/searchframe#OAMlx_jo-ck/src/base/message_loop_proxy.h&l=1 with a little more info here: http://dev.chromium.org/developers/coding-style/important-abstractions-and-data-structures). 681307 14 gram 2012-07-27 20:06:42 -0700 (In reply to comment #13) > (In reply to comment #12) > > (In reply to comment #11) > > > (In reply to comment #4) > > > > One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. > > > > > > It's a good idea. But in this step, I just want to refactor current code. > > > I will consider further improvements in the next step. > > > > I think it is important to proceed this refactoring efforts step by step. As Kwonjin mentioned in the design document, the first step is to extract common code into reusable components. Once we have WTF::CrossThreadFunction, TaskGroup and TaskThread in hand, we can easily add fancier features. > > > > > > BTW, Levein, do you know actual WebKit code that can benefit from TaskThreadProxy? > > I don't believe that the current implementations of TaskThread are ThreadSafeRefCounted so that would be a change and may introduce some issues when it may be deleted on any thread. The sole reason why TaskThread inherits ThreadSafeRefCounted is to prevent TaskThread instance from being deleted while the thread is running. TaskThread holds a RefPtr for itself all the while so TaskThread isn't deleted. You can find the similar implementations on FileThread and DatabaseThread. 681568 15 levin 2012-07-29 10:25:18 -0700 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > (In reply to comment #11) > > > > (In reply to comment #4) > > > > > One more comment re TaskThread, instead of making it ThreadSafeRefCounted, I'd suggest make a TaskThreadProxy that other threads could use. (The Proxy would hold some sort of weak pointer to a TaskThread.) From what I've seen typically it is nice for a run loop to know which thread it will be destroyed on. > > > > > > > > It's a good idea. But in this step, I just want to refactor current code. > > > > I will consider further improvements in the next step. > > > > > > I think it is important to proceed this refactoring efforts step by step. As Kwonjin mentioned in the design document, the first step is to extract common code into reusable components. Once we have WTF::CrossThreadFunction, TaskGroup and TaskThread in hand, we can easily add fancier features. > > > > > > > > > BTW, Levein, do you know actual WebKit code that can benefit from TaskThreadProxy? > > > > I don't believe that the current implementations of TaskThread are ThreadSafeRefCounted so that would be a change and may introduce some issues when it may be deleted on any thread. > > The sole reason why TaskThread inherits ThreadSafeRefCounted is to prevent TaskThread instance from being deleted while the thread is running. > TaskThread holds a RefPtr for itself all the while so TaskThread isn't deleted. You can find the similar implementations on FileThread and DatabaseThread. Only one thread should have access to it. Then it won't need to be ThreadSafeRefCounted. 686261 16 gram 2012-08-02 23:32:08 -0700 (In reply to comment #15) > Only one thread should have access to it. Then it won't need to be ThreadSafeRefCounted. There are two threads that access to it. 1) TaskThread - has a reference to keep it alive while running. 2) Owner thread - has a reference to post tasks to the TaskThread. 693563 17 157969 gram 2012-08-13 05:25:10 -0700 Created attachment 157969 This patch is not for committing. 157969 2012-08-13 05:25:10 -0700 2012-08-13 05:25:10 -0700 This patch is not for committing. bug-92365-20120813212433.patch text/plain 63222 gram U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxNDEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjc3NjU2YzRmZjdhYjAx NmU0NjY3MDEzNDI4ZDdmZjJhMDAyYzk3Ny4uNTk3MWYyZDhmZDJmNWNhZTE2MjcxODI3NTkxYzRh YzE1NDU2ZDk3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDExMSBAQAorMjAxMi0wOC0xMyAgS3dv bmppbiBKZW9uZyAgPGdyYW1AY29tcGFueTEwMC5uZXQ+CisKKyAgICAgICAgUmVmYWN0b3IgY3Jv c3MgdGhyZWFkIGNvbW11bmljYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTkyMzY1CisKKyAgICAgICAgSW1wbGVtZW50IG5ldyB0aHJlYWQgY29t bXVuaWNhdGlvbiBtb2RlbCBhbmQgYXBwbHkgaXQgdG8gRmlsZSBBUEkgY29kZS4KKworICAgICAg ICBUaGlzIHBhdGNoIGlzIGEgV0lQIGltcGxlbWVudGF0aW9uIG9mIGEgbmV3IHRocmVhZCBjb21t dW5pY2F0aW9uIG1vZGVsIGRlc2NyaWJlZCBpbiB0aGUgbGluayBhYm92ZS4KKyAgICAgICAgQWxz byByZXBsYWNlZCB0aGUgZmlsZSB0aHJlYWQgd2l0aCB0aGlzIG5ldyB0aHJlYWQgY29tbXVuaWNh dGlvbiBtb2RlbC4KKworICAgICAgICAqIFRhcmdldC5wcmk6CisgICAgICAgICogZG9tL0RvY3Vt ZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBlcmZvcm1UYXNrQ29udGV4dDo6UGVyZm9ybVRh c2tDb250ZXh0KToKKyAgICAgICAgKFBlcmZvcm1UYXNrQ29udGV4dCk6CisgICAgICAgIChXZWJD b3JlOjpEb2N1bWVudDo6ZGlkUmVjZWl2ZVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1l bnQ6OnBvc3RUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OnJ1blNjcmlwdEV4ZWN1dGlvbkNvbnRl eHRUYXNrKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OnBlbmRpbmdUYXNrc1RpbWVyRmlyZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAg ICAgICAoRG9jdW1lbnQpOgorICAgICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OmZpbGVUaHJlYWQp OgorICAgICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAqIGZpbGVh cGkvQXN5bmNGaWxlU3RyZWFtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVh bTo6QXN5bmNGaWxlU3RyZWFtKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVhbTo6 Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVhbTo6ZmlsZVRocmVhZCk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTdHJlYW06OnN0YXJ0T25GaWxlVGhyZWFkKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVhbTo6c3RvcCk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTdHJlYW06OnN0b3BPbkZpbGVUaHJlYWQpOgorICAgICAgICAoV2ViQ29y ZTo6QXN5bmNGaWxlU3RyZWFtOjpnZXRTaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN0cmVhbTo6Z2V0U2l6ZU9uRmlsZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVhbTo6b3BlbkZvclJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3RyZWFtOjpvcGVuRm9yUmVhZE9uRmlsZVRocmVhZCk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTdHJlYW06Om9wZW5Gb3JXcml0ZSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTdHJlYW06Om9wZW5Gb3JXcml0ZU9uRmlsZVRocmVhZCk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTdHJlYW06OmNsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN0cmVhbTo6cmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTdHJlYW06 OnJlYWRPbkZpbGVUaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3RyZWFtOjp3 cml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTdHJlYW06OndyaXRlT25GaWxlVGhy ZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN0cmVhbTo6dHJ1bmNhdGUpOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3RyZWFtOjp0cnVuY2F0ZU9uRmlsZVRocmVhZCk6Cisg ICAgICAgICogZmlsZWFwaS9Bc3luY0ZpbGVTdHJlYW0uaDoKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoQXN5bmNGaWxlU3RyZWFtKToKKyAgICAgICAgKiBmaWxlYXBpL0ZpbGVUaHJlYWQu Y3BwOiBSZW1vdmVkLgorICAgICAgICAqIGZpbGVhcGkvRmlsZVRocmVhZC5oOiBSZW1vdmVkLgor ICAgICAgICAqIHBsYXRmb3JtL0Nyb3NzVGhyZWFkRnVuY3Rpb25hbC5oOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoQ3Jvc3NUaHJlYWRDb3B5YWJsZSk6CisgICAgICAgIChX ZWJDb3JlOjpSKToKKyAgICAgICAgKFdlYkNvcmU6OkM6Oik6CisgICAgICAgIChGdW5jdGlvbklt cGxCYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkZ1bmN0aW9uSW1wbEJhc2U6On5GdW5jdGlvbklt cGxCYXNlKToKKyAgICAgICAgKEZ1bmN0aW9uQmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpGdW5j dGlvbkJhc2U6OmlzTnVsbCk6CisgICAgICAgIChXZWJDb3JlOjpGdW5jdGlvbkJhc2U6OkZ1bmN0 aW9uQmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpGdW5jdGlvbkJhc2U6OmltcGwpOgorICAgICAg ICAoV2ViQ29yZTo6YmluZCk6CisgICAgICAgICogcGxhdGZvcm0vS1VSTC5oOgorICAgICAgICAo V2ViQ29yZTo6S1VSTDo6Y3Jvc3NUaHJlYWRDb3B5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9UYXNr VGhyZWFkLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFRhc2tUaHJl YWRUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OlRhc2tUaHJlYWRUYXNrOjpUYXNrVGhyZWFkVGFz ayk6CisgICAgICAgIChXZWJDb3JlOjpUYXNrVGhyZWFkVGFzazo6flRhc2tUaHJlYWRUYXNrKToK KyAgICAgICAgKFdlYkNvcmU6OlRhc2tUaHJlYWRUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpUYXNrVGhyZWFkVGFzazo6Z3JvdXApOgorICAgICAgICAoV2ViQ29yZTo6VGFz a1RocmVhZDo6VGFza1RocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpUYXNrVGhyZWFkOjp+VGFz a1RocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpUYXNrVGhyZWFkOjpzdGFydCk6CisgICAgICAg IChXZWJDb3JlOjpUYXNrVGhyZWFkOjpzdG9wKToKKyAgICAgICAgKFdlYkNvcmU6OlRhc2tUaHJl YWQ6OnBvc3RUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OlRhc2tUaHJlYWQ6OnBvc3RJbW1lZGlh dGVUYXNrKToKKyAgICAgICAgKFNhbWVJbnN0YW5jZVByZWRpY2F0ZSk6CisgICAgICAgIChXZWJD b3JlOjpTYW1lSW5zdGFuY2VQcmVkaWNhdGU6OlNhbWVJbnN0YW5jZVByZWRpY2F0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpTYW1lSW5zdGFuY2VQcmVkaWNhdGU6Om9wZXJhdG9yKCkpOgorICAgICAg ICAoV2ViQ29yZTo6VGFza1RocmVhZDo6cmVtb3ZlVGFza0dydW9wKToKKyAgICAgICAgKFdlYkNv cmU6OlRhc2tUaHJlYWQ6OnRhc2tUaHJlYWRTdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpUYXNr VGhyZWFkOjpydW5Mb29wKToKKyAgICAgICAgKiBwbGF0Zm9ybS9UYXNrVGhyZWFkLmg6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChUYXNrR3JvdXApOgorICAgICAgICAoV2Vi Q29yZTo6VGFza0dyb3VwOjpjcmVhdGUpOgorICAgICAgICAoVGFza1RocmVhZCk6CisgICAgICAg IChXZWJDb3JlOjpUYXNrVGhyZWFkOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6VGFza1Ro cmVhZDo6ZGlkU3RvcFRocmVhZCk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnBvc3RUYXNrKToKKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAo V29ya2VyQ29udGV4dCk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJSdW5Mb29wLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OldvcmtlclJ1bkxvb3A6OnBvc3RUYXNrKToKKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyUnVuTG9vcDo6cG9zdFRhc2tGb3JNb2RlKToK KyAgICAgICAgKFdlYkNvcmU6OldvcmtlclJ1bkxvb3A6OlRhc2s6OmNyZWF0ZSk6CisgICAgICAg IChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChX ZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpUYXNrOjpUYXNrKToKKyAgICAgICAgKiB3b3JrZXJzL1dv cmtlclJ1bkxvb3AuaDoKKyAgICAgICAgKFdvcmtlclJ1bkxvb3ApOgorICAgICAgICAoVGFzayk6 CisKIDIwMTItMDYtMjcgIEtlbnRhcm8gSGFyYSAgPGhhcmFrZW5AY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFBlcmZvcm1hbmNlOiBPcHRpbWl6ZSBEcm9tYWVvL2RvbS1xdWVyeS5odG1sIGJ5IGNh Y2hpbmcgTm9kZVJhcmVEYXRhIG9uIERvY3VtZW50CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9UYXJnZXQucHJpIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCA3Yjk2Yjc2MjQz MDg5ODhiZTQ1MDZiYWY1ZGUzMDJhZjIxYmQwNGRjLi5jNjRjYWEyY2Y2OTI0NDFkNjAzZTM0ZWI0 ZTk4N2M2OWNjNjAzNTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisr KyBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKQEAgLTcwMiw3ICs3MDIsNiBAQCBTT1VSQ0VT ICs9IFwKICAgICBmaWxlYXBpL0ZpbGVSZWFkZXIuY3BwIFwKICAgICBmaWxlYXBpL0ZpbGVSZWFk ZXJMb2FkZXIuY3BwIFwKICAgICBmaWxlYXBpL0ZpbGVSZWFkZXJTeW5jLmNwcCBcCi0gICAgZmls ZWFwaS9GaWxlVGhyZWFkLmNwcCBcCiAgICAgZmlsZWFwaS9UaHJlYWRhYmxlQmxvYlJlZ2lzdHJ5 LmNwcCBcCiAgICAgZmlsZWFwaS9XZWJLaXRCbG9iQnVpbGRlci5jcHAgXAogICAgIGhpc3Rvcnkv QmFja0ZvcndhcmRDb250cm9sbGVyLmNwcCBcCkBAIC0xMjEyLDYgKzEyMTEsNyBAQCBTT1VSQ0VT ICs9IFwKICAgICBwbGF0Zm9ybS9zcWwvU1FMaXRlU3RhdGVtZW50LmNwcCBcCiAgICAgcGxhdGZv cm0vc3FsL1NRTGl0ZVRyYW5zYWN0aW9uLmNwcCBcCiAgICAgcGxhdGZvcm0vc3FsL1NRTFZhbHVl LmNwcCBcCisgICAgcGxhdGZvcm0vVGFza1RocmVhZC5jcHAgXAogICAgIHBsYXRmb3JtL3RleHQv U2VnbWVudGVkU3RyaW5nLmNwcCBcCiAgICAgcGxhdGZvcm0vdGV4dC9TdHJpbmcuY3BwIFwKICAg ICBwbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmNwcCBcCkBAIC0xODc2LDcgKzE4NzYsNiBA QCBIRUFERVJTICs9IFwKICAgICBmaWxlYXBpL0ZpbGVSZWFkZXJMb2FkZXIuaCBcCiAgICAgZmls ZWFwaS9GaWxlUmVhZGVyTG9hZGVyQ2xpZW50LmggXAogICAgIGZpbGVhcGkvRmlsZVJlYWRlclN5 bmMuaCBcCi0gICAgZmlsZWFwaS9GaWxlVGhyZWFkLmggXAogICAgIGZpbGVhcGkvRmlsZVRocmVh ZFRhc2suaCBcCiAgICAgZmlsZWFwaS9XZWJLaXRCbG9iQnVpbGRlci5oIFwKICAgICBoaXN0b3J5 L0JhY2tGb3J3YXJkQ29udHJvbGxlci5oIFwKQEAgLTIyMTgsNiArMjIxNyw3IEBAIEhFQURFUlMg Kz0gXAogICAgIHBsYXRmb3JtL0NvbnRlbnRUeXBlLmggXAogICAgIHBsYXRmb3JtL0NvbnRleHRN ZW51LmggXAogICAgIHBsYXRmb3JtL0Nyb3NzVGhyZWFkQ29waWVyLmggXAorICAgIHBsYXRmb3Jt L0Nyb3NzVGhyZWFkRnVuY3Rpb25hbC5oIFwKICAgICBwbGF0Zm9ybS9EYXRlQ29tcG9uZW50cy5o IFwKICAgICBwbGF0Zm9ybS9EZWNpbWFsLmggXAogICAgIHBsYXRmb3JtL0RyYWdEYXRhLmggXApA QCAtMjQwOSw2ICsyNDA5LDcgQEAgSEVBREVSUyArPSBcCiAgICAgcGxhdGZvcm0vc3FsL1NRTGl0 ZVN0YXRlbWVudC5oIFwKICAgICBwbGF0Zm9ybS9zcWwvU1FMaXRlVHJhbnNhY3Rpb24uaCBcCiAg ICAgcGxhdGZvcm0vc3FsL1NRTFZhbHVlLmggXAorICAgIHBsYXRmb3JtL1Rhc2tUaHJlYWQuaCBc CiAgICAgcGxhdGZvcm0vdGV4dC9CYXNlNjQuaCBcCiAgICAgcGxhdGZvcm0vdGV4dC9CaWRpQ29u dGV4dC5oIFwKICAgICBwbGF0Zm9ybS90ZXh0L0RlY29kZUVzY2FwZVNlcXVlbmNlcy5oIFwKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IGU5MjEwOTA2MjQ1ZDk1OWFkMDhhZjQ2YzQ1YjVjYjFk ZDI0YTYwYzYuLmIxNmJhMzE0ZThmZjdlNGRjOGVlNmExZjE5ZGUzYTE4YzM2MTExMTcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvZG9tL0RvY3VtZW50LmNwcApAQCAtNTEyMCwxNCArNTEyMCwxNCBAQCB2b2lkIERvY3VtZW50 OjphZGRNZXNzYWdlKE1lc3NhZ2VTb3VyY2Ugc291cmNlLCBNZXNzYWdlVHlwZSB0eXBlLCBNZXNz YWdlTGV2ZWwgbAogc3RydWN0IFBlcmZvcm1UYXNrQ29udGV4dCB7CiAgICAgV1RGX01BS0VfTk9O Q09QWUFCTEUoUGVyZm9ybVRhc2tDb250ZXh0KTsgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBw dWJsaWM6Ci0gICAgUGVyZm9ybVRhc2tDb250ZXh0KFBhc3NSZWZQdHI8RG9jdW1lbnRXZWFrUmVm ZXJlbmNlPiBkb2N1bWVudFJlZmVyZW5jZSwgUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250 ZXh0OjpUYXNrPiB0YXNrKQorICAgIFBlcmZvcm1UYXNrQ29udGV4dChQYXNzUmVmUHRyPERvY3Vt ZW50V2Vha1JlZmVyZW5jZT4gZG9jdW1lbnRSZWZlcmVuY2UsIGNvbnN0IENyb3NzVGhyZWFkRnVu Y3Rpb248dm9pZCgpPiYgdGFzaykKICAgICAgICAgOiBkb2N1bWVudFJlZmVyZW5jZShkb2N1bWVu dFJlZmVyZW5jZSkKICAgICAgICAgLCB0YXNrKHRhc2spCiAgICAgewogICAgIH0KIAogICAgIFJl ZlB0cjxEb2N1bWVudFdlYWtSZWZlcmVuY2U+IGRvY3VtZW50UmVmZXJlbmNlOwotICAgIE93blB0 cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrOworICAgIENyb3NzVGhyZWFkRnVu Y3Rpb248dm9pZCgpPiB0YXNrOwogfTsKIAogdm9pZCBEb2N1bWVudDo6ZGlkUmVjZWl2ZVRhc2so dm9pZCogdW50eXBlZENvbnRleHQpCkBAIC01MTQzLDI0ICs1MTQzLDM0IEBAIHZvaWQgRG9jdW1l bnQ6OmRpZFJlY2VpdmVUYXNrKHZvaWQqIHVudHlwZWRDb250ZXh0KQogCiAgICAgUGFnZSogcGFn ZSA9IGRvY3VtZW50LT5wYWdlKCk7CiAgICAgaWYgKChwYWdlICYmIHBhZ2UtPmRlZmVyc0xvYWRp bmcoKSkgfHwgIWRvY3VtZW50LT5tX3BlbmRpbmdUYXNrcy5pc0VtcHR5KCkpIHsKLSAgICAgICAg ZG9jdW1lbnQtPm1fcGVuZGluZ1Rhc2tzLmFwcGVuZChjb250ZXh0LT50YXNrLnJlbGVhc2UoKSk7 CisgICAgICAgIGRvY3VtZW50LT5tX3BlbmRpbmdUYXNrcy5hcHBlbmQoY29udGV4dC0+dGFzayk7 CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBjb250ZXh0LT50YXNrLT5wZXJmb3JtVGFz ayhkb2N1bWVudCk7CisgICAgY29udGV4dC0+dGFzaygpOwogfQogCi12b2lkIERvY3VtZW50Ojpw b3N0VGFzayhQYXNzT3duUHRyPFRhc2s+IHRhc2spCit2b2lkIERvY3VtZW50Ojpwb3N0VGFzayhj b25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mIHRhc2spCiB7CiAgICAgY2FsbE9uTWFp blRocmVhZChkaWRSZWNlaXZlVGFzaywgbmV3IFBlcmZvcm1UYXNrQ29udGV4dChtX3dlYWtSZWZl cmVuY2UsIHRhc2spKTsKIH0KIAorc3RhdGljIHZvaWQgcnVuU2NyaXB0RXhlY3V0aW9uQ29udGV4 dFRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBEb2N1 bWVudCogZG9jdW1lbnQpCit7CisgICAgdGFzay0+cGVyZm9ybVRhc2soZG9jdW1lbnQpOworfQor Cit2b2lkIERvY3VtZW50Ojpwb3N0VGFzayhQYXNzT3duUHRyPFRhc2s+IHRhc2spCit7CisgICAg Y2FsbE9uTWFpblRocmVhZChkaWRSZWNlaXZlVGFzaywgbmV3IFBlcmZvcm1UYXNrQ29udGV4dCht X3dlYWtSZWZlcmVuY2UsIFdlYkNvcmU6OmJpbmQocnVuU2NyaXB0RXhlY3V0aW9uQ29udGV4dFRh c2ssIHRhc2ssIHRoaXMpKSk7Cit9CisKIHZvaWQgRG9jdW1lbnQ6OnBlbmRpbmdUYXNrc1RpbWVy RmlyZWQoVGltZXI8RG9jdW1lbnQ+KikKIHsKICAgICB3aGlsZSAoIW1fcGVuZGluZ1Rhc2tzLmlz RW1wdHkoKSkgewotICAgICAgICBPd25QdHI8VGFzaz4gdGFzayA9IG1fcGVuZGluZ1Rhc2tzWzBd LnJlbGVhc2UoKTsKKyAgICAgICAgQ3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+IHRhc2sgPSBt X3BlbmRpbmdUYXNrc1swXTsKICAgICAgICAgbV9wZW5kaW5nVGFza3MucmVtb3ZlKDApOwotICAg ICAgICB0YXNrLT5wZXJmb3JtVGFzayh0aGlzKTsKKyAgICAgICAgdGFzaygpOwogICAgIH0KIH0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmggYi9Tb3VyY2UvV2Vi Q29yZS9kb20vRG9jdW1lbnQuaAppbmRleCBlY2NmOGE3NzZiYmE1NGZkMGJjZTNlYjFhMDAzMWIz MTY5ZTE5MDc0Li5kOWM1MTNjODI2OTU5ZjllYWY4NjVhY2NjZDE5ZjY4NTQ3Y2U1NTkyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuaApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkNvbGxlY3Rpb25U eXBlLmgiCiAjaW5jbHVkZSAiQ29sb3IuaCIKICNpbmNsdWRlICJDb250YWluZXJOb2RlLmgiCisj aW5jbHVkZSAiQ3Jvc3NUaHJlYWRGdW5jdGlvbmFsLmgiCiAjaW5jbHVkZSAiRE9NVGltZVN0YW1w LmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRU aW1pbmcuaCIKQEAgLTk0OSw2ICs5NTAsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBwYXJzZUROU1By ZWZldGNoQ29udHJvbEhlYWRlcihjb25zdCBTdHJpbmcmKTsKIAogICAgIHZpcnR1YWwgdm9pZCBw b3N0VGFzayhQYXNzT3duUHRyPFRhc2s+KTsgLy8gRXhlY3V0ZXMgdGhlIHRhc2sgb24gY29udGV4 dCdzIHRocmVhZCBhc3luY2hyb25vdXNseS4KKyAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soY29u c3QgQ3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+Jik7IC8vIEV4ZWN1dGVzIHRoZSB0YXNrIG9u IGNvbnRleHQncyB0aHJlYWQgYXN5bmNocm9ub3VzbHkuCiAKICAgICB2aXJ0dWFsIHZvaWQgc3Vz cGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcygpOwogICAgIHZpcnR1YWwg dm9pZCByZXN1bWVTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJDYWxsYmFja3MoKTsKQEAgLTE0 ODksNyArMTQ5MSw3IEBAIHByaXZhdGU6CiAjZW5kaWYKIAogICAgIFRpbWVyPERvY3VtZW50PiBt X3BlbmRpbmdUYXNrc1RpbWVyOwotICAgIFZlY3RvcjxPd25QdHI8VGFzaz4gPiBtX3BlbmRpbmdU YXNrczsKKyAgICBWZWN0b3I8Q3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+ID4gbV9wZW5kaW5n VGFza3M7CiAKICNpZiBFTkFCTEUoTElOS19QUkVSRU5ERVIpCiAgICAgT3duUHRyPFByZXJlbmRl cmVyPiBtX3ByZXJlbmRlcmVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1Njcmlw dEV4ZWN1dGlvbkNvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlv bkNvbnRleHQuY3BwCmluZGV4IDkyNDQ1Y2E4MGRhZjYzMzIzOWQyZjc5Y2VlOThkZDlkZDQ0MWIz MjMuLjUxNGU1YTZmMmQ4Yzc4NmI4OGUxNzliZTZkZjhhMTM3ZTE4YzE5NWYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHAKQEAgLTM0LDEyICszNCwx MiBAQAogI2luY2x1ZGUgIkVycm9yRXZlbnQuaCIKICNpbmNsdWRlICJFdmVudExpc3RlbmVyLmgi CiAjaW5jbHVkZSAiRXZlbnRUYXJnZXQuaCIKLSNpbmNsdWRlICJGaWxlVGhyZWFkLmgiCiAjaW5j bHVkZSAiTWVzc2FnZVBvcnQuaCIKICNpbmNsdWRlICJQdWJsaWNVUkxNYW5hZ2VyLmgiCiAjaW5j bHVkZSAiU2NyaXB0Q2FsbFN0YWNrLmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNp bmNsdWRlICJTZXR0aW5ncy5oIgorI2luY2x1ZGUgIlRhc2tUaHJlYWQuaCIKICNpbmNsdWRlICJX b3JrZXJDb250ZXh0LmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8d3Rm L01haW5UaHJlYWQuaD4KQEAgLTM1OCwxMCArMzU4LDEwIEBAIERPTVRpbWVyKiBTY3JpcHRFeGVj dXRpb25Db250ZXh0OjpmaW5kVGltZW91dChpbnQgdGltZW91dElkKQogfQogCiAjaWYgRU5BQkxF KEJMT0IpCi1GaWxlVGhyZWFkKiBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpmaWxlVGhyZWFkKCkK K1Rhc2tUaHJlYWQqIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OmZpbGVUaHJlYWQoKQogewogICAg IGlmICghbV9maWxlVGhyZWFkKSB7Ci0gICAgICAgIG1fZmlsZVRocmVhZCA9IEZpbGVUaHJlYWQ6 OmNyZWF0ZSgpOworICAgICAgICBtX2ZpbGVUaHJlYWQgPSBUYXNrVGhyZWFkOjpjcmVhdGUoKTsK ICAgICAgICAgaWYgKCFtX2ZpbGVUaHJlYWQtPnN0YXJ0KCkpCiAgICAgICAgICAgICBtX2ZpbGVU aHJlYWQgPSAwOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRF eGVjdXRpb25Db250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29u dGV4dC5oCmluZGV4IDIzOGZhNmQyYjNjNDFmZmI0NzM3NDk4NTZjNDg2ZjRjYmZmODA3M2QuLjlk MTUyMWNkOWI5OTBjODIxMTBlY2FhYmJmOWEwNWRmMjM1YmIzMzMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNv cmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaApAQCAtMzAsNiArMzAsNyBAQAogCiAjaW5j bHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCiAjaW5jbHVkZSAiQ29uc29sZVR5cGVzLmgiCisjaW5j bHVkZSAiQ3Jvc3NUaHJlYWRGdW5jdGlvbmFsLmgiCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1 ZGUgIlNjcmlwdENhbGxTdGFjay5oIgogI2luY2x1ZGUgIlNlY3VyaXR5Q29udGV4dC5oIgpAQCAt NjAsNyArNjEsNyBAQCBjbGFzcyBQdWJsaWNVUkxNYW5hZ2VyOwogI2VuZGlmCiAKICNpZiBFTkFC TEUoQkxPQikKLWNsYXNzIEZpbGVUaHJlYWQ7CitjbGFzcyBUYXNrVGhyZWFkOwogI2VuZGlmCiAK IGNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgOiBwdWJsaWMgU2VjdXJpdHlDb250ZXh0LCBw dWJsaWMgU3VwcGxlbWVudGFibGU8U2NyaXB0RXhlY3V0aW9uQ29udGV4dD4gewpAQCAtMTM4LDYg KzEzOSw3IEBAIHB1YmxpYzoKICAgICB9OwogCiAgICAgdmlydHVhbCB2b2lkIHBvc3RUYXNrKFBh c3NPd25QdHI8VGFzaz4pID0gMDsgLy8gRXhlY3V0ZXMgdGhlIHRhc2sgb24gY29udGV4dCdzIHRo cmVhZCBhc3luY2hyb25vdXNseS4KKyAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soY29uc3QgQ3Jv c3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+JikgPSAwOyAvLyBFeGVjdXRlcyB0aGUgdGFzayBvbiBj b250ZXh0J3MgdGhyZWFkIGFzeW5jaHJvbm91c2x5LgogCiAgICAgdm9pZCBhZGRUaW1lb3V0KGlu dCB0aW1lb3V0SWQsIERPTVRpbWVyKik7CiAgICAgdm9pZCByZW1vdmVUaW1lb3V0KGludCB0aW1l b3V0SWQpOwpAQCAtMTQ4LDcgKzE1MCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxF KEJMT0IpCi0gICAgRmlsZVRocmVhZCogZmlsZVRocmVhZCgpOworICAgIFRhc2tUaHJlYWQqIGZp bGVUaHJlYWQoKTsKICAgICB2b2lkIHN0b3BGaWxlVGhyZWFkKCk7CiAjZW5kaWYKIApAQCAtMjE1 LDcgKzIxNyw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX2FjdGl2ZURPTU9iamVjdHNBcmVTdG9w cGVkOwogCiAjaWYgRU5BQkxFKEJMT0IpCi0gICAgUmVmUHRyPEZpbGVUaHJlYWQ+IG1fZmlsZVRo cmVhZDsKKyAgICBSZWZQdHI8VGFza1RocmVhZD4gbV9maWxlVGhyZWFkOwogI2VuZGlmCiB9Owog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9maWxlYXBpL0FzeW5jRmlsZVN0cmVhbS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9maWxlYXBpL0FzeW5jRmlsZVN0cmVhbS5jcHAKaW5kZXggMWIwMzVj Y2MzMjBjYjkxZmJjNDg2ZWYxOGI2OGY1M2NiYzdmYjU4Yi4uM2EzODkzNDZkNjFkNmFlZWM1NjRm MjE3NWFhMWY0MmNiMTU5NTQ2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZmlsZWFwaS9B c3luY0ZpbGVTdHJlYW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2ZpbGVhcGkvQXN5bmNGaWxl U3RyZWFtLmNwcApAQCAtMzksMTAgKzM5LDkgQEAKICNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2su aCIKICNpbmNsdWRlICJGaWxlU3RyZWFtLmgiCiAjaW5jbHVkZSAiRmlsZVN0cmVhbUNsaWVudC5o IgotI2luY2x1ZGUgIkZpbGVUaHJlYWQuaCIKLSNpbmNsdWRlICJGaWxlVGhyZWFkVGFzay5oIgog I2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29u dGV4dC5oIgorI2luY2x1ZGUgIlRhc2tUaHJlYWQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog CkBAIC01MCw2ICs0OSw3IEBAIGlubGluZSBBc3luY0ZpbGVTdHJlYW06OkFzeW5jRmlsZVN0cmVh bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBGaWxlU3RyCiAgICAgOiBtX2NvbnRl eHQoY29udGV4dCkKICAgICAsIG1fc3RyZWFtKEZpbGVTdHJlYW06OmNyZWF0ZSgpKQogICAgICwg bV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrR3JvdXAoVGFza0dyb3VwOjpjcmVhdGUoKSkK IHsKIH0KIApAQCAtNjEsNyArNjEsNyBAQCBQYXNzUmVmUHRyPEFzeW5jRmlsZVN0cmVhbT4gQXN5 bmNGaWxlU3RyZWFtOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udAogICAgIC8v IFRoaXMgaXMgYmFsYW5jZWQgYnkgdGhlIGRlcmVmIGluIGRlcmVmUHJveHlPbkNvbnRleHQgYmVs b3cuCiAgICAgcHJveHktPnJlZigpOwogCi0gICAgcHJveHktPmZpbGVUaHJlYWQoKS0+cG9zdFRh c2soY3JlYXRlRmlsZVRocmVhZFRhc2socHJveHkuZ2V0KCksICZBc3luY0ZpbGVTdHJlYW06OnN0 YXJ0T25GaWxlVGhyZWFkKSk7CisgICAgcHJveHktPmZpbGVUaHJlYWQoKS0+cG9zdFRhc2soV2Vi Q29yZTo6YmluZCgmQXN5bmNGaWxlU3RyZWFtOjpzdGFydE9uRmlsZVRocmVhZCwgcHJveHkuZ2V0 KCkpLCBwcm94eS0+bV90YXNrR3JvdXApOwogCiAgICAgcmV0dXJuIHByb3h5LnJlbGVhc2UoKTsK IH0KQEAgLTcwLDcgKzcwLDcgQEAgQXN5bmNGaWxlU3RyZWFtOjp+QXN5bmNGaWxlU3RyZWFtKCkK IHsKIH0KIAotRmlsZVRocmVhZCogQXN5bmNGaWxlU3RyZWFtOjpmaWxlVGhyZWFkKCkKK1Rhc2tU aHJlYWQqIEFzeW5jRmlsZVN0cmVhbTo6ZmlsZVRocmVhZCgpCiB7CiAgICAgQVNTRVJUKG1fY29u dGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIEFTU0VSVChtX2NvbnRleHQtPmZpbGVUaHJl YWQoKSk7CkBAIC04OCw3ICs4OCw3IEBAIHZvaWQgQXN5bmNGaWxlU3RyZWFtOjpzdGFydE9uRmls ZVRocmVhZCgpCiAgICAgaWYgKCFjbGllbnQoKSkKICAgICAgICAgcmV0dXJuOwogICAgIG1fc3Ry ZWFtLT5zdGFydCgpOwotICAgIG1fY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNr KCZkaWRTdGFydCwgQWxsb3dDcm9zc1RocmVhZEFjY2Vzcyh0aGlzKSkpOworICAgIG1fY29udGV4 dC0+cG9zdFRhc2soV2ViQ29yZTo6YmluZChkaWRTdGFydCwgbV9jb250ZXh0LmdldCgpLCB0aGlz KSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3RyZWFtOjpzdG9wKCkKQEAgLTk2LDggKzk2LDggQEAg dm9pZCBBc3luY0ZpbGVTdHJlYW06OnN0b3AoKQogICAgIC8vIENsZWFyIHRoZSBjbGllbnQgc28g dGhhdCB3ZSB3b24ndCBiZSBjYWxsaW5nIGNhbGxiYWNrcyBvbiB0aGUgY2xpZW50LgogICAgIHNl dENsaWVudCgwKTsKIAotICAgIGZpbGVUaHJlYWQoKS0+dW5zY2hlZHVsZVRhc2tzKG1fc3RyZWFt LmdldCgpKTsKLSAgICBmaWxlVGhyZWFkKCktPnBvc3RUYXNrKGNyZWF0ZUZpbGVUaHJlYWRUYXNr KHRoaXMsICZBc3luY0ZpbGVTdHJlYW06OnN0b3BPbkZpbGVUaHJlYWQpKTsKKyAgICBmaWxlVGhy ZWFkKCktPnJlbW92ZVRhc2tHcnVvcChtX3Rhc2tHcm91cCk7CisgICAgZmlsZVRocmVhZCgpLT5w b3N0VGFzayhXZWJDb3JlOjpiaW5kKCZBc3luY0ZpbGVTdHJlYW06OnN0b3BPbkZpbGVUaHJlYWQs IHRoaXMpLCBtX3Rhc2tHcm91cCk7CiB9CiAKIHN0YXRpYyB2b2lkIGRlcmVmUHJveHlPbkNvbnRl eHQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVN0cmVhbSogcHJveHkpCkBAIC0x MDksNyArMTA5LDcgQEAgc3RhdGljIHZvaWQgZGVyZWZQcm94eU9uQ29udGV4dChTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3RyZWFtKiBwcm94eSkKIHZvaWQgQXN5bmNGaWxlU3Ry ZWFtOjpzdG9wT25GaWxlVGhyZWFkKCkKIHsKICAgICBtX3N0cmVhbS0+c3RvcCgpOwotICAgIG1f Y29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZkZXJlZlByb3h5T25Db250ZXh0 LCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpKSk7CisgICAgbV9jb250ZXh0LT5wb3N0VGFz ayhXZWJDb3JlOjpiaW5kKGRlcmVmUHJveHlPbkNvbnRleHQsIG1fY29udGV4dC5nZXQoKSwgdGhp cykpOwogfQogCiBzdGF0aWMgdm9pZCBkaWRHZXRTaXplKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBBc3luY0ZpbGVTdHJlYW0qIHByb3h5LCBsb25nIGxvbmcgc2l6ZSkKQEAgLTEyMCwxNSArMTIw LDE2IEBAIHN0YXRpYyB2b2lkIGRpZEdldFNpemUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFz eW5jRmlsZVN0cmVhbSogcHJveHksIGxvbmcgbG9uCiAKIHZvaWQgQXN5bmNGaWxlU3RyZWFtOjpn ZXRTaXplKGNvbnN0IFN0cmluZyYgcGF0aCwgZG91YmxlIGV4cGVjdGVkTW9kaWZpY2F0aW9uVGlt ZSkKIHsKLSAgICBmaWxlVGhyZWFkKCktPnBvc3RUYXNrKGNyZWF0ZUZpbGVUaHJlYWRUYXNrKHRo aXMsICZBc3luY0ZpbGVTdHJlYW06OmdldFNpemVPbkZpbGVUaHJlYWQsIHBhdGgsIGV4cGVjdGVk TW9kaWZpY2F0aW9uVGltZSkpOworICAgIGZpbGVUaHJlYWQoKS0+cG9zdFRhc2soV2ViQ29yZTo6 YmluZCgmQXN5bmNGaWxlU3RyZWFtOjpnZXRTaXplT25GaWxlVGhyZWFkLCB0aGlzLCBwYXRoLCBl eHBlY3RlZE1vZGlmaWNhdGlvblRpbWUpLCBtX3Rhc2tHcm91cCk7CiB9CiAKIHZvaWQgQXN5bmNG aWxlU3RyZWFtOjpnZXRTaXplT25GaWxlVGhyZWFkKGNvbnN0IFN0cmluZyYgcGF0aCwgZG91Ymxl IGV4cGVjdGVkTW9kaWZpY2F0aW9uVGltZSkKIHsKICAgICBsb25nIGxvbmcgc2l6ZSA9IG1fc3Ry ZWFtLT5nZXRTaXplKHBhdGgsIGV4cGVjdGVkTW9kaWZpY2F0aW9uVGltZSk7Ci0gICAgbV9jb250 ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJmRpZEdldFNpemUsIEFsbG93Q3Jvc3NU aHJlYWRBY2Nlc3ModGhpcyksIHNpemUpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKFdlYkNv cmU6OmJpbmQoZGlkR2V0U2l6ZSwgbV9jb250ZXh0LmdldCgpLCB0aGlzLCBzaXplKSk7CiB9CiAK Ky8vIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgaXMgbm90IG5lZWRlZC4KIHN0YXRpYyB2b2lkIGRp ZE9wZW4oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVN0cmVhbSogcHJveHksIGJv b2wgc3VjY2VzcykKIHsKICAgICBpZiAocHJveHktPmNsaWVudCgpKQpAQCAtMTM3LDMxICsxMzgs MjkgQEAgc3RhdGljIHZvaWQgZGlkT3BlbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNG aWxlU3RyZWFtKiBwcm94eSwgYm9vbCBzdWNjZXMKIAogdm9pZCBBc3luY0ZpbGVTdHJlYW06Om9w ZW5Gb3JSZWFkKGNvbnN0IFN0cmluZyYgcGF0aCwgbG9uZyBsb25nIG9mZnNldCwgbG9uZyBsb25n IGxlbmd0aCkKIHsKLSAgICBmaWxlVGhyZWFkKCktPnBvc3RUYXNrKGNyZWF0ZUZpbGVUaHJlYWRU YXNrKHRoaXMsICZBc3luY0ZpbGVTdHJlYW06Om9wZW5Gb3JSZWFkT25GaWxlVGhyZWFkLCBwYXRo LCBvZmZzZXQsIGxlbmd0aCkpOworICAgIGZpbGVUaHJlYWQoKS0+cG9zdFRhc2soV2ViQ29yZTo6 YmluZCgmQXN5bmNGaWxlU3RyZWFtOjpvcGVuRm9yUmVhZE9uRmlsZVRocmVhZCwgdGhpcywgcGF0 aCwgb2Zmc2V0LCBsZW5ndGgpLCBtX3Rhc2tHcm91cCk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3Ry ZWFtOjpvcGVuRm9yUmVhZE9uRmlsZVRocmVhZChjb25zdCBTdHJpbmcmIHBhdGgsIGxvbmcgbG9u ZyBvZmZzZXQsIGxvbmcgbG9uZyBsZW5ndGgpCiB7CiAgICAgYm9vbCBzdWNjZXNzID0gbV9zdHJl YW0tPm9wZW5Gb3JSZWFkKHBhdGgsIG9mZnNldCwgbGVuZ3RoKTsKLSAgICBtX2NvbnRleHQtPnBv c3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkT3BlbiwgQWxsb3dDcm9zc1RocmVhZEFjY2Vz cyh0aGlzKSwgc3VjY2VzcykpOworICAgIG1fY29udGV4dC0+cG9zdFRhc2soV2ViQ29yZTo6Ymlu ZChkaWRPcGVuLCBtX2NvbnRleHQuZ2V0KCksIHRoaXMsIHN1Y2Nlc3MpKTsKIH0KIAogdm9pZCBB c3luY0ZpbGVTdHJlYW06Om9wZW5Gb3JXcml0ZShjb25zdCBTdHJpbmcmIHBhdGgpCiB7Ci0gICAg ZmlsZVRocmVhZCgpLT5wb3N0VGFzaygKLSAgICAgICAgY3JlYXRlRmlsZVRocmVhZFRhc2sodGhp cywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJkFzeW5jRmlsZVN0cmVhbTo6b3BlbkZv cldyaXRlT25GaWxlVGhyZWFkLCBwYXRoKSk7CisgICAgZmlsZVRocmVhZCgpLT5wb3N0VGFzayhX ZWJDb3JlOjpiaW5kKCZBc3luY0ZpbGVTdHJlYW06Om9wZW5Gb3JXcml0ZU9uRmlsZVRocmVhZCwg dGhpcywgcGF0aCksIG1fdGFza0dyb3VwKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTdHJlYW06Om9w ZW5Gb3JXcml0ZU9uRmlsZVRocmVhZChjb25zdCBTdHJpbmcmIHBhdGgpCiB7CiAgICAgYm9vbCBz dWNjZXNzID0gbV9zdHJlYW0tPm9wZW5Gb3JXcml0ZShwYXRoKTsKLSAgICBtX2NvbnRleHQtPnBv c3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkT3BlbiwgQWxsb3dDcm9zc1RocmVhZEFjY2Vz cyh0aGlzKSwgc3VjY2VzcykpOworICAgIG1fY29udGV4dC0+cG9zdFRhc2soV2ViQ29yZTo6Ymlu ZChkaWRPcGVuLCBtX2NvbnRleHQuZ2V0KCksIHRoaXMsIHN1Y2Nlc3MpKTsKIH0KIAogdm9pZCBB c3luY0ZpbGVTdHJlYW06OmNsb3NlKCkKIHsKLSAgICBmaWxlVGhyZWFkKCktPnBvc3RUYXNrKGNy ZWF0ZUZpbGVUaHJlYWRUYXNrKHRoaXMsICZBc3luY0ZpbGVTdHJlYW06OmNsb3NlT25GaWxlVGhy ZWFkKSk7CisgICAgZmlsZVRocmVhZCgpLT5wb3N0VGFzayhXZWJDb3JlOjpiaW5kKCZBc3luY0Zp bGVTdHJlYW06OmNsb3NlT25GaWxlVGhyZWFkLCB0aGlzKSwgbV90YXNrR3JvdXApOwogfQogCiB2 b2lkIEFzeW5jRmlsZVN0cmVhbTo6Y2xvc2VPbkZpbGVUaHJlYWQoKQpAQCAtMTc3LDE1ICsxNzYs MTMgQEAgc3RhdGljIHZvaWQgZGlkUmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNG aWxlU3RyZWFtKiBwcm94eSwgaW50IGJ5dGVzUmUKIAogdm9pZCBBc3luY0ZpbGVTdHJlYW06OnJl YWQoY2hhciogYnVmZmVyLCBpbnQgbGVuZ3RoKQogewotICAgIGZpbGVUaHJlYWQoKS0+cG9zdFRh c2soCi0gICAgICAgIGNyZWF0ZUZpbGVUaHJlYWRUYXNrKHRoaXMsICZBc3luY0ZpbGVTdHJlYW06 OnJlYWRPbkZpbGVUaHJlYWQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFsbG93Q3Jv c3NUaHJlYWRBY2Nlc3MoYnVmZmVyKSwgbGVuZ3RoKSk7CisgICAgZmlsZVRocmVhZCgpLT5wb3N0 VGFzayhXZWJDb3JlOjpiaW5kKCZBc3luY0ZpbGVTdHJlYW06OnJlYWRPbkZpbGVUaHJlYWQsIHRo aXMsIGJ1ZmZlciwgbGVuZ3RoKSwgbV90YXNrR3JvdXApOwogfQogCiB2b2lkIEFzeW5jRmlsZVN0 cmVhbTo6cmVhZE9uRmlsZVRocmVhZChjaGFyKiBidWZmZXIsIGludCBsZW5ndGgpCiB7CiAgICAg aW50IGJ5dGVzUmVhZCA9IG1fc3RyZWFtLT5yZWFkKGJ1ZmZlciwgbGVuZ3RoKTsKLSAgICBtX2Nv bnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkUmVhZCwgQWxsb3dDcm9zc1Ro cmVhZEFjY2Vzcyh0aGlzKSwgYnl0ZXNSZWFkKSk7CisgICAgbV9jb250ZXh0LT5wb3N0VGFzayhX ZWJDb3JlOjpiaW5kKGRpZFJlYWQsIG1fY29udGV4dC5nZXQoKSwgdGhpcywgYnl0ZXNSZWFkKSk7 CiB9CiAKIHN0YXRpYyB2b2lkIGRpZFdyaXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3lu Y0ZpbGVTdHJlYW0qIHByb3h5LCBpbnQgYnl0ZXNXcml0dGVuKQpAQCAtMTk2LDEzICsxOTMsMTMg QEAgc3RhdGljIHZvaWQgZGlkV3JpdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmls ZVN0cmVhbSogcHJveHksIGludCBieXRlc1cKIAogdm9pZCBBc3luY0ZpbGVTdHJlYW06OndyaXRl KGNvbnN0IEtVUkwmIGJsb2JVUkwsIGxvbmcgbG9uZyBwb3NpdGlvbiwgaW50IGxlbmd0aCkKIHsK LSAgICBmaWxlVGhyZWFkKCktPnBvc3RUYXNrKGNyZWF0ZUZpbGVUaHJlYWRUYXNrKHRoaXMsICZB c3luY0ZpbGVTdHJlYW06OndyaXRlT25GaWxlVGhyZWFkLCBibG9iVVJMLCBwb3NpdGlvbiwgbGVu Z3RoKSk7CisgICAgZmlsZVRocmVhZCgpLT5wb3N0VGFzayhXZWJDb3JlOjpiaW5kKCZBc3luY0Zp bGVTdHJlYW06OndyaXRlT25GaWxlVGhyZWFkLCB0aGlzLCBibG9iVVJMLCBwb3NpdGlvbiwgbGVu Z3RoKSwgbV90YXNrR3JvdXApOwogfQogCiB2b2lkIEFzeW5jRmlsZVN0cmVhbTo6d3JpdGVPbkZp bGVUaHJlYWQoY29uc3QgS1VSTCYgYmxvYlVSTCwgbG9uZyBsb25nIHBvc2l0aW9uLCBpbnQgbGVu Z3RoKQogewogICAgIGludCBieXRlc1dyaXR0ZW4gPSBtX3N0cmVhbS0+d3JpdGUoYmxvYlVSTCwg cG9zaXRpb24sIGxlbmd0aCk7Ci0gICAgbV9jb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFj a1Rhc2soJmRpZFdyaXRlLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpLCBieXRlc1dyaXR0 ZW4pKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKFdlYkNvcmU6OmJpbmQoZGlkV3JpdGUsIG1f Y29udGV4dC5nZXQoKSwgdGhpcywgYnl0ZXNXcml0dGVuKSk7CiB9CiAKIHN0YXRpYyB2b2lkIGRp ZFRydW5jYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVTdHJlYW0qIHByb3h5 LCBib29sIHN1Y2Nlc3MpCkBAIC0yMTMsMTMgKzIxMCwxMyBAQCBzdGF0aWMgdm9pZCBkaWRUcnVu Y2F0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3RyZWFtKiBwcm94eSwgYm9v bCBzdQogCiB2b2lkIEFzeW5jRmlsZVN0cmVhbTo6dHJ1bmNhdGUobG9uZyBsb25nIHBvc2l0aW9u KQogewotICAgIGZpbGVUaHJlYWQoKS0+cG9zdFRhc2soY3JlYXRlRmlsZVRocmVhZFRhc2sodGhp cywgJkFzeW5jRmlsZVN0cmVhbTo6dHJ1bmNhdGVPbkZpbGVUaHJlYWQsIHBvc2l0aW9uKSk7Cisg ICAgZmlsZVRocmVhZCgpLT5wb3N0VGFzayhXZWJDb3JlOjpiaW5kKCZBc3luY0ZpbGVTdHJlYW06 OnRydW5jYXRlT25GaWxlVGhyZWFkLCB0aGlzLCBwb3NpdGlvbiksIG1fdGFza0dyb3VwKTsKIH0K IAogdm9pZCBBc3luY0ZpbGVTdHJlYW06OnRydW5jYXRlT25GaWxlVGhyZWFkKGxvbmcgbG9uZyBw b3NpdGlvbikKIHsKICAgICBib29sIHN1Y2Nlc3MgPSBtX3N0cmVhbS0+dHJ1bmNhdGUocG9zaXRp b24pOwotICAgIG1fY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRUcnVu Y2F0ZSwgQWxsb3dDcm9zc1RocmVhZEFjY2Vzcyh0aGlzKSwgc3VjY2VzcykpOworICAgIG1fY29u dGV4dC0+cG9zdFRhc2soV2ViQ29yZTo6YmluZChkaWRUcnVuY2F0ZSwgbV9jb250ZXh0LmdldCgp LCB0aGlzLCBzdWNjZXNzKSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2ZpbGVhcGkvQXN5bmNGaWxlU3RyZWFtLmggYi9Tb3VyY2UvV2Vi Q29yZS9maWxlYXBpL0FzeW5jRmlsZVN0cmVhbS5oCmluZGV4IDA0YmUyZGIwYzEyOWVmNGQ2N2Fk Y2Y3ZGE4MTQ0NTg0NGEzMjlhOWIuLjhiZDIwMzJkMTlmNDZlOTVhMzM4MTk3ODZkNDk5NGNjMzg1 N2FmMmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2ZpbGVhcGkvQXN5bmNGaWxlU3RyZWFt LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZmlsZWFwaS9Bc3luY0ZpbGVTdHJlYW0uaApAQCAtMzQs NiArMzQsOCBAQAogCiAjaWYgRU5BQkxFKEJMT0IpCiAKKyNpbmNsdWRlICJUYXNrVGhyZWFkLmgi CisKICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+ CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgpAQCAtNDIsNyArNDQsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIGNsYXNzIEZpbGVTdHJlYW1DbGllbnQ7CiBjbGFzcyBGaWxlU3RyZWFtOwotY2xh c3MgRmlsZVRocmVhZDsKIGNsYXNzIEtVUkw7CiBjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0 OwogCkBAIC02OSw3ICs3MCw3IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgQXN5bmNGaWxlU3Ry ZWFtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBGaWxlU3RyZWFtQ2xpZW50Kik7CiAKLSAgICBG aWxlVGhyZWFkKiBmaWxlVGhyZWFkKCk7CisgICAgVGFza1RocmVhZCogZmlsZVRocmVhZCgpOwog CiAgICAgLy8gQ2FsbGVkIG9uIEZpbGUgdGhyZWFkLgogICAgIHZvaWQgc3RhcnRPbkZpbGVUaHJl YWQoKTsKQEAgLTg2LDYgKzg3LDcgQEAgcHJpdmF0ZToKICAgICBSZWZQdHI8RmlsZVN0cmVhbT4g bV9zdHJlYW07CiAKICAgICBGaWxlU3RyZWFtQ2xpZW50KiBtX2NsaWVudDsKKyAgICBSZWZQdHI8 VGFza0dyb3VwPiBtX3Rhc2tHcm91cDsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2ZpbGVhcGkvRmlsZVRocmVhZC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9maWxlYXBpL0ZpbGVUaHJlYWQuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NApp bmRleCA0ZjRmNDczZmRlYThkNzRlZTAzZTBiMWE2MjlmMzYyNjRmMmY0M2ViLi4wMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL2ZpbGVh cGkvRmlsZVRocmVhZC5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSwxMTcgKzAsMCBAQAotLyoKLSAq IENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAq Ci0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKLSAqIG1ldDoKLSAqCi0gKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAotICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgotICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQotICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgotICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQotICogZGlz dHJpYnV0aW9uLgotICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cwotICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KLSAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCi0gKgotICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwot ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKLSAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgotICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKLSAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAotICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAotICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCi0gKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKLSAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVk ZSAiY29uZmlnLmgiCi0KLSNpZiBFTkFCTEUoQkxPQikKLQotI2luY2x1ZGUgIkZpbGVUaHJlYWQu aCIKLQotI2luY2x1ZGUgIkF1dG9kcmFpbmVkUG9vbC5oIgotI2luY2x1ZGUgIkxvZ2dpbmcuaCIK LQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1GaWxlVGhyZWFkOjpGaWxlVGhyZWFkKCkKLSAgICA6 IG1fdGhyZWFkSUQoMCkKLXsKLSAgICBtX3NlbGZSZWYgPSB0aGlzOwotfQotCi1GaWxlVGhyZWFk Ojp+RmlsZVRocmVhZCgpCi17Ci0gICAgQVNTRVJUKG1fcXVldWUua2lsbGVkKCkpOwotfQotCi1i b29sIEZpbGVUaHJlYWQ6OnN0YXJ0KCkKLXsKLSAgICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFk Q3JlYXRpb25NdXRleCk7Ci0gICAgaWYgKG1fdGhyZWFkSUQpCi0gICAgICAgIHJldHVybiB0cnVl OwotICAgIG1fdGhyZWFkSUQgPSBjcmVhdGVUaHJlYWQoRmlsZVRocmVhZDo6ZmlsZVRocmVhZFN0 YXJ0LCB0aGlzLCAiV2ViQ29yZTogRmlsZSIpOwotICAgIHJldHVybiBtX3RocmVhZElEOwotfQot Ci12b2lkIEZpbGVUaHJlYWQ6OnN0b3AoKQotewotICAgIG1fcXVldWUua2lsbCgpOwotfQotCi12 b2lkIEZpbGVUaHJlYWQ6OnBvc3RUYXNrKFBhc3NPd25QdHI8VGFzaz4gdGFzaykKLXsKLSAgICBt X3F1ZXVlLmFwcGVuZCh0YXNrKTsKLX0KLQotY2xhc3MgU2FtZUluc3RhbmNlUHJlZGljYXRlIHsK LXB1YmxpYzoKLSAgICBTYW1lSW5zdGFuY2VQcmVkaWNhdGUoY29uc3Qgdm9pZCogaW5zdGFuY2Up IDogbV9pbnN0YW5jZShpbnN0YW5jZSkgeyB9Ci0gICAgYm9vbCBvcGVyYXRvcigpKEZpbGVUaHJl YWQ6OlRhc2sqIHRhc2spIGNvbnN0IHsgcmV0dXJuIHRhc2stPmluc3RhbmNlKCkgPT0gbV9pbnN0 YW5jZTsgfQotcHJpdmF0ZToKLSAgICBjb25zdCB2b2lkKiBtX2luc3RhbmNlOwotfTsKLQotdm9p ZCBGaWxlVGhyZWFkOjp1bnNjaGVkdWxlVGFza3MoY29uc3Qgdm9pZCogaW5zdGFuY2UpCi17Ci0g ICAgU2FtZUluc3RhbmNlUHJlZGljYXRlIHByZWRpY2F0ZShpbnN0YW5jZSk7Ci0gICAgbV9xdWV1 ZS5yZW1vdmVJZihwcmVkaWNhdGUpOwotfQotCi12b2lkIEZpbGVUaHJlYWQ6OmZpbGVUaHJlYWRT dGFydCh2b2lkKiBhcmcpCi17Ci0gICAgRmlsZVRocmVhZCogZmlsZVRocmVhZCA9IHN0YXRpY19j YXN0PEZpbGVUaHJlYWQqPihhcmcpOwotICAgIGZpbGVUaHJlYWQtPnJ1bkxvb3AoKTsKLX0KLQot dm9pZCBGaWxlVGhyZWFkOjpydW5Mb29wKCkKLXsKLSAgICB7Ci0gICAgICAgIC8vIFdhaXQgZm9y IEZpbGVUaHJlYWQ6OnN0YXJ0KCkgdG8gY29tcGxldGUgdG8gaGF2ZSBtX3RocmVhZElECi0gICAg ICAgIC8vIGVzdGFibGlzaGVkIGJlZm9yZSBzdGFydGluZyB0aGUgbWFpbiBsb29wLgotICAgICAg ICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFkQ3JlYXRpb25NdXRleCk7Ci0gICAgICAgIExPRyhG aWxlQVBJLCAiU3RhcnRlZCBGaWxlVGhyZWFkICVwIiwgdGhpcyk7Ci0gICAgfQotCi0gICAgQXV0 b2RyYWluZWRQb29sIHBvb2w7Ci0gICAgd2hpbGUgKE93blB0cjxUYXNrPiB0YXNrID0gbV9xdWV1 ZS53YWl0Rm9yTWVzc2FnZSgpKSB7Ci0gICAgICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAg ICAgIHBvb2wuY3ljbGUoKTsKLSAgICB9Ci0KLSAgICBMT0coRmlsZUFQSSwgIkFib3V0IHRvIGRl dGFjaCB0aHJlYWQgJWkgYW5kIGNsZWFyIHRoZSByZWYgdG8gRmlsZVRocmVhZCAlcCwgd2hpY2gg Y3VycmVudGx5IGhhcyAlaSByZWYocykiLCBtX3RocmVhZElELCB0aGlzLCByZWZDb3VudCgpKTsK LQotICAgIGRldGFjaFRocmVhZChtX3RocmVhZElEKTsKLQotICAgIC8vIENsZWFyIHRoZSBzZWxm IHJlZnB0ciwgcG9zc2libHkgcmVzdWx0aW5nIGluIGRlbGV0aW9uCi0gICAgbV9zZWxmUmVmID0g MDsKLX0KLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKEJMT0Ip CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9maWxlYXBpL0ZpbGVUaHJlYWQuaCBiL1NvdXJj ZS9XZWJDb3JlL2ZpbGVhcGkvRmlsZVRocmVhZC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NApp bmRleCBkNGUyNGJjYTMwYjZhYTI5NjhiZDc4ZTQ4NDgxYmFjZjI2NWYyYjZkLi4wMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL2ZpbGVh cGkvRmlsZVRocmVhZC5oCisrKyAvZGV2L251bGwKQEAgLTEsODkgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0g KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKLSAqIG1ldDoKLSAqCi0gKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAotICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgotICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQotICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgotICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQotICogZGlzdHJp YnV0aW9uLgotICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhl IG5hbWVzIG9mIGl0cwotICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3Ig cHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KLSAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwotICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKLSAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgotICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKLSAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAotICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAotICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCi0gKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKLSAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIEZp bGVUaHJlYWRfaAotI2RlZmluZSBGaWxlVGhyZWFkX2gKLQotI2lmIEVOQUJMRShCTE9CKQotCi0j aW5jbHVkZSA8d3RmL01lc3NhZ2VRdWV1ZS5oPgotI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+ Ci0jaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KLSNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+ Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgRmlsZVN0cmVhbTsKLQotY2xhc3MgRmls ZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxGaWxlVGhyZWFkPiB7Ci1wdWJs aWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8RmlsZVRocmVhZD4gY3JlYXRlKCkKLSAgICB7Ci0g ICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgRmlsZVRocmVhZCgpKTsKLSAgICB9Ci0KLSAgICB+ RmlsZVRocmVhZCgpOwotCi0gICAgYm9vbCBzdGFydCgpOwotICAgIHZvaWQgc3RvcCgpOwotCi0g ICAgY2xhc3MgVGFzayB7Ci0gICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFRhc2spOwotICAg IHB1YmxpYzoKLSAgICAgICAgdmlydHVhbCB+VGFzaygpIHsgfQotICAgICAgICB2aXJ0dWFsIHZv aWQgcGVyZm9ybVRhc2soKSA9IDA7Ci0gICAgICAgIHZvaWQqIGluc3RhbmNlKCkgY29uc3QgeyBy ZXR1cm4gbV9pbnN0YW5jZTsgfQotICAgIHByb3RlY3RlZDoKLSAgICAgICAgVGFzayh2b2lkKiBp bnN0YW5jZSkgOiBtX2luc3RhbmNlKGluc3RhbmNlKSB7IH0KLSAgICAgICAgdm9pZCogbV9pbnN0 YW5jZTsKLSAgICB9OwotCi0gICAgdm9pZCBwb3N0VGFzayhQYXNzT3duUHRyPFRhc2s+IHRhc2sp OwotCi0gICAgdm9pZCB1bnNjaGVkdWxlVGFza3MoY29uc3Qgdm9pZCogaW5zdGFuY2UpOwotCi1w cml2YXRlOgotICAgIEZpbGVUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lkIGZpbGVUaHJlYWRT dGFydCh2b2lkKik7Ci0gICAgdm9pZCBydW5Mb29wKCk7Ci0KLSAgICBUaHJlYWRJZGVudGlmaWVy IG1fdGhyZWFkSUQ7Ci0gICAgUmVmUHRyPEZpbGVUaHJlYWQ+IG1fc2VsZlJlZjsKLSAgICBNZXNz YWdlUXVldWU8VGFzaz4gbV9xdWV1ZTsKLQotICAgIE11dGV4IG1fdGhyZWFkQ3JlYXRpb25NdXRl eDsKLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVOQUJMRShCTE9C KQotCi0jZW5kaWYgLy8gRmlsZVRocmVhZF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9Dcm9zc1RocmVhZEZ1bmN0aW9uYWwuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L0Nyb3NzVGhyZWFkRnVuY3Rpb25hbC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhlNjA4ODA4ZmIwMDlkYzZhNmUx NTQ1Yzc3NWJjODJlYzkxM2ZhYTAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9Dcm9zc1RocmVhZEZ1bmN0aW9uYWwuaApAQCAtMCwwICsxLDY0MyBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgQ3Jvc3NUaHJlYWRGdW5jdGlvbmFsX2gKKyNkZWZpbmUgQ3Jvc3NUaHJl YWRGdW5jdGlvbmFsX2gKKworI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8 d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8d3Rm L1RocmVhZFNhZmVSZWZDb3VudGVkLmg+CisKKyNpZiBQTEFURk9STShNQUMpICYmIENPTVBJTEVS X1NVUFBPUlRTKEJMT0NLUykKKyNpbmNsdWRlIDxCbG9jay5oPgorI2luY2x1ZGUgPG9iamMvb2Jq Yy1ydW50aW1lLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit0ZW1wbGF0ZTx0 eXBlbmFtZSBUPgorY2xhc3MgQ3Jvc3NUaHJlYWRDb3B5YWJsZSB7CitwdWJsaWM6CisgICAgdHlw ZWRlZiBUIFN0b3JhZ2VUeXBlOworICAgIHZpcnR1YWwgVCBjcm9zc1RocmVhZENvcHkoKSBjb25z dCA9IDA7Cit9OworCisvLyBGdW5jdGlvbmFsLmggcHJvdmlkZXMgYSB2ZXJ5IHNpbXBsZSB3YXkg dG8gYmluZCBhIGZ1bmN0aW9uIHBvaW50ZXIgYW5kIGFyZ3VtZW50cyB0b2dldGhlciBpbnRvIGEg ZnVuY3Rpb24gb2JqZWN0CisvLyB0aGF0IGNhbiBiZSBzdG9yZWQsIGNvcGllZCBhbmQgaW52b2tl ZCwgc2ltaWxhciB0byBob3cgYm9vc3Q6OmJpbmQgYW5kIHN0ZDo6YmluZCBpbiBDKysxMS4KKwor Ly8gQSBGdW5jdGlvbldyYXBwZXIgaXMgYSBjbGFzcyB0ZW1wbGF0ZSB0aGF0IGNhbiB3cmFwIGEg ZnVuY3Rpb24gcG9pbnRlciBvciBhIG1lbWJlciBmdW5jdGlvbiBwb2ludGVyIGFuZAorLy8gcHJv dmlkZSBhIHVuaWZpZWQgaW50ZXJmYWNlIGZvciBjYWxsaW5nIHRoYXQgZnVuY3Rpb24uCit0ZW1w bGF0ZTx0eXBlbmFtZT4KK2NsYXNzIEZ1bmN0aW9uV3JhcHBlcjsKKwordGVtcGxhdGU8dHlwZW5h bWUgUj4KK2NsYXNzIEZ1bmN0aW9uV3JhcHBlcjxSICgqKSgpPiB7CitwdWJsaWM6CisgICAgdHlw ZWRlZiBSIFJlc3VsdFR5cGU7CisKKyAgICBleHBsaWNpdCBGdW5jdGlvbldyYXBwZXIoUiAoKmZ1 bmN0aW9uKSgpKQorICAgICAgICA6IG1fZnVuY3Rpb24oZnVuY3Rpb24pCisgICAgeworICAgIH0K KworICAgIFIgb3BlcmF0b3IoKSgpCisgICAgeworICAgICAgICByZXR1cm4gbV9mdW5jdGlvbigp OworICAgIH0KKworcHJpdmF0ZToKKyAgICBSICgqbV9mdW5jdGlvbikoKTsKK307CisKK3RlbXBs YXRlPHR5cGVuYW1lIFIsIHR5cGVuYW1lIFAxPgorY2xhc3MgRnVuY3Rpb25XcmFwcGVyPFIgKCop KFAxKT4geworcHVibGljOgorICAgIHR5cGVkZWYgUiBSZXN1bHRUeXBlOworCisgICAgZXhwbGlj aXQgRnVuY3Rpb25XcmFwcGVyKFIgKCpmdW5jdGlvbikoUDEpKQorICAgICAgICA6IG1fZnVuY3Rp b24oZnVuY3Rpb24pCisgICAgeworICAgIH0KKworICAgIFIgb3BlcmF0b3IoKShQMSBwMSkKKyAg ICB7CisgICAgICAgIHJldHVybiBtX2Z1bmN0aW9uKHAxKTsKKyAgICB9CisKK3ByaXZhdGU6Cisg ICAgUiAoKm1fZnVuY3Rpb24pKFAxKTsKK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIFIsIHR5cGVu YW1lIFAxLCB0eXBlbmFtZSBQMj4KK2NsYXNzIEZ1bmN0aW9uV3JhcHBlcjxSICgqKShQMSwgUDIp PiB7CitwdWJsaWM6CisgICAgdHlwZWRlZiBSIFJlc3VsdFR5cGU7CisKKyAgICBleHBsaWNpdCBG dW5jdGlvbldyYXBwZXIoUiAoKmZ1bmN0aW9uKShQMSwgUDIpKQorICAgICAgICA6IG1fZnVuY3Rp b24oZnVuY3Rpb24pCisgICAgeworICAgIH0KKworICAgIFIgb3BlcmF0b3IoKShQMSBwMSwgUDIg cDIpCisgICAgeworICAgICAgICByZXR1cm4gbV9mdW5jdGlvbihwMSwgcDIpOworICAgIH0KKwor cHJpdmF0ZToKKyAgICBSICgqbV9mdW5jdGlvbikoUDEsIFAyKTsKK307CisKK3RlbXBsYXRlPHR5 cGVuYW1lIFIsIHR5cGVuYW1lIFAxLCB0eXBlbmFtZSBQMiwgdHlwZW5hbWUgUDM+CitjbGFzcyBG dW5jdGlvbldyYXBwZXI8UiAoKikoUDEsIFAyLCBQMyk+IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVm IFIgUmVzdWx0VHlwZTsKKworICAgIGV4cGxpY2l0IEZ1bmN0aW9uV3JhcHBlcihSICgqZnVuY3Rp b24pKFAxLCBQMiwgUDMpKQorICAgICAgICA6IG1fZnVuY3Rpb24oZnVuY3Rpb24pCisgICAgewor ICAgIH0KKworICAgIFIgb3BlcmF0b3IoKShQMSBwMSwgUDIgcDIsIFAzIHAzKQorICAgIHsKKyAg ICAgICAgcmV0dXJuIG1fZnVuY3Rpb24ocDEsIHAyLCBwMyk7CisgICAgfQorCitwcml2YXRlOgor ICAgIFIgKCptX2Z1bmN0aW9uKShQMSwgUDIsIFAzKTsKK307CisKK3RlbXBsYXRlPHR5cGVuYW1l IFIsIHR5cGVuYW1lIEM+CitjbGFzcyBGdW5jdGlvbldyYXBwZXI8UiAoQzo6KikoKT4geworcHVi bGljOgorICAgIHR5cGVkZWYgUiBSZXN1bHRUeXBlOworCisgICAgZXhwbGljaXQgRnVuY3Rpb25X cmFwcGVyKFIgKEM6OipmdW5jdGlvbikoKSkKKyAgICAgICAgOiBtX2Z1bmN0aW9uKGZ1bmN0aW9u KQorICAgIHsKKyAgICB9CisKKyAgICBSIG9wZXJhdG9yKCkoQyogYykKKyAgICB7CisgICAgICAg IHJldHVybiAoYy0+Km1fZnVuY3Rpb24pKCk7CisgICAgfQorCitwcml2YXRlOgorICAgIFIgKEM6 OiptX2Z1bmN0aW9uKSgpOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgUiwgdHlwZW5hbWUgQywg dHlwZW5hbWUgUDE+CitjbGFzcyBGdW5jdGlvbldyYXBwZXI8UiAoQzo6KikoUDEpPiB7CitwdWJs aWM6CisgICAgdHlwZWRlZiBSIFJlc3VsdFR5cGU7CisKKyAgICBleHBsaWNpdCBGdW5jdGlvbldy YXBwZXIoUiAoQzo6KmZ1bmN0aW9uKShQMSkpCisgICAgICAgIDogbV9mdW5jdGlvbihmdW5jdGlv bikKKyAgICB7CisgICAgfQorCisgICAgUiBvcGVyYXRvcigpKEMqIGMsIFAxIHAxKQorICAgIHsK KyAgICAgICAgcmV0dXJuIChjLT4qbV9mdW5jdGlvbikocDEpOworICAgIH0KKworcHJpdmF0ZToK KyAgICBSIChDOjoqbV9mdW5jdGlvbikoUDEpOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgUiwg dHlwZW5hbWUgQywgdHlwZW5hbWUgUDEsIHR5cGVuYW1lIFAyPgorY2xhc3MgRnVuY3Rpb25XcmFw cGVyPFIgKEM6OiopKFAxLCBQMik+IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIFIgUmVzdWx0VHlw ZTsKKworICAgIGV4cGxpY2l0IEZ1bmN0aW9uV3JhcHBlcihSIChDOjoqZnVuY3Rpb24pKFAxLCBQ MikpCisgICAgICAgIDogbV9mdW5jdGlvbihmdW5jdGlvbikKKyAgICB7CisgICAgfQorCisgICAg UiBvcGVyYXRvcigpKEMqIGMsIFAxIHAxLCBQMiBwMikKKyAgICB7CisgICAgICAgIHJldHVybiAo Yy0+Km1fZnVuY3Rpb24pKHAxLCBwMik7CisgICAgfQorCitwcml2YXRlOgorICAgIFIgKEM6Oipt X2Z1bmN0aW9uKShQMSwgUDIpOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgUiwgdHlwZW5hbWUg QywgdHlwZW5hbWUgUDEsIHR5cGVuYW1lIFAyLCB0eXBlbmFtZSBQMz4KK2NsYXNzIEZ1bmN0aW9u V3JhcHBlcjxSIChDOjoqKShQMSwgUDIsIFAzKT4geworcHVibGljOgorICAgIHR5cGVkZWYgUiBS ZXN1bHRUeXBlOworCisgICAgZXhwbGljaXQgRnVuY3Rpb25XcmFwcGVyKFIgKEM6OipmdW5jdGlv bikoUDEsIFAyLCBQMykpCisgICAgICAgIDogbV9mdW5jdGlvbihmdW5jdGlvbikKKyAgICB7Cisg ICAgfQorCisgICAgUiBvcGVyYXRvcigpKEMqIGMsIFAxIHAxLCBQMiBwMiwgUDMgcDMpCisgICAg eworICAgICAgICByZXR1cm4gKGMtPiptX2Z1bmN0aW9uKShwMSwgcDIsIHAzKTsKKyAgICB9CisK K3ByaXZhdGU6CisgICAgUiAoQzo6Km1fZnVuY3Rpb24pKFAxLCBQMiwgUDMpOworfTsKKwordGVt cGxhdGU8dHlwZW5hbWUgUiwgdHlwZW5hbWUgQywgdHlwZW5hbWUgUDEsIHR5cGVuYW1lIFAyLCB0 eXBlbmFtZSBQMywgdHlwZW5hbWUgUDQ+CitjbGFzcyBGdW5jdGlvbldyYXBwZXI8UiAoQzo6Kiko UDEsIFAyLCBQMywgUDQpPiB7CitwdWJsaWM6CisgICAgdHlwZWRlZiBSIFJlc3VsdFR5cGU7CisK KyAgICBleHBsaWNpdCBGdW5jdGlvbldyYXBwZXIoUiAoQzo6KmZ1bmN0aW9uKShQMSwgUDIsIFAz LCBQNCkpCisgICAgICAgIDogbV9mdW5jdGlvbihmdW5jdGlvbikKKyAgICB7CisgICAgfQorCisg ICAgUiBvcGVyYXRvcigpKEMqIGMsIFAxIHAxLCBQMiBwMiwgUDMgcDMsIFA0IHA0KQorICAgIHsK KyAgICAgICAgcmV0dXJuIChjLT4qbV9mdW5jdGlvbikocDEsIHAyLCBwMywgcDQpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBSIChDOjoqbV9mdW5jdGlvbikoUDEsIFAyLCBQMywgUDQpOworfTsK KwordGVtcGxhdGU8dHlwZW5hbWUgUiwgdHlwZW5hbWUgQywgdHlwZW5hbWUgUDEsIHR5cGVuYW1l IFAyLCB0eXBlbmFtZSBQMywgdHlwZW5hbWUgUDQsIHR5cGVuYW1lIFA1PgorY2xhc3MgRnVuY3Rp b25XcmFwcGVyPFIgKEM6OiopKFAxLCBQMiwgUDMsIFA0LCBQNSk+IHsKK3B1YmxpYzoKKyAgICB0 eXBlZGVmIFIgUmVzdWx0VHlwZTsKKworICAgIGV4cGxpY2l0IEZ1bmN0aW9uV3JhcHBlcihSIChD OjoqZnVuY3Rpb24pKFAxLCBQMiwgUDMsIFA0LCBQNSkpCisgICAgICAgIDogbV9mdW5jdGlvbihm dW5jdGlvbikKKyAgICB7CisgICAgfQorCisgICAgUiBvcGVyYXRvcigpKEMqIGMsIFAxIHAxLCBQ MiBwMiwgUDMgcDMsIFA0IHA0LCBQNSBwNSkKKyAgICB7CisgICAgICAgIHJldHVybiAoYy0+Km1f ZnVuY3Rpb24pKHAxLCBwMiwgcDMsIHA0LCBwNSk7CisgICAgfQorCitwcml2YXRlOgorICAgIFIg KEM6OiptX2Z1bmN0aW9uKShQMSwgUDIsIFAzLCBQNCwgUDUpOworfTsKKworI2lmIFBMQVRGT1JN KE1BQykgJiYgQ09NUElMRVJfU1VQUE9SVFMoQkxPQ0tTKQordGVtcGxhdGU8dHlwZW5hbWUgUj4K K2NsYXNzIEZ1bmN0aW9uV3JhcHBlcjxSICheKSgpPiB7CitwdWJsaWM6CisgICAgdHlwZWRlZiBS IFJlc3VsdFR5cGU7CisKKyAgICBleHBsaWNpdCBGdW5jdGlvbldyYXBwZXIoUiAoXmJsb2NrKSgp KQorICAgICAgICA6IG1fYmxvY2soQmxvY2tfY29weShibG9jaykpCisgICAgeworICAgIH0KKwor ICAgIEZ1bmN0aW9uV3JhcHBlcihjb25zdCBGdW5jdGlvbldyYXBwZXImIG90aGVyKQorICAgICAg ICA6IG1fYmxvY2soQmxvY2tfY29weShvdGhlci5tX2Jsb2NrKSkKKyAgICB7CisgICAgfQorCisg ICAgfkZ1bmN0aW9uV3JhcHBlcigpCisgICAgeworICAgICAgICBCbG9ja19yZWxlYXNlKG1fYmxv Y2spOworICAgIH0KKworICAgIFIgb3BlcmF0b3IoKSgpCisgICAgeworICAgICAgICByZXR1cm4g bV9ibG9jaygpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBSIChebV9ibG9jaykoKTsKK307Cisj ZW5kaWYKKwordGVtcGxhdGU8Ym9vbCBpc0Nyb3NzVGhyZWFkQ29weWFibGUsIHR5cGVuYW1lIFQ+ IHN0cnVjdCBQYXJhbVN0b3JhZ2VUcmFpdHNCYXNlOworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBz dHJ1Y3QgUGFyYW1TdG9yYWdlVHJhaXRzQmFzZTxmYWxzZSwgVD4geworICAgIHR5cGVkZWYgVCBT dG9yYWdlVHlwZTsKKworICAgIHN0YXRpYyBTdG9yYWdlVHlwZSB3cmFwKGNvbnN0IFQmIHZhbHVl KSB7IHJldHVybiB2YWx1ZTsgfQorICAgIHN0YXRpYyBjb25zdCBUJiB1bndyYXAoY29uc3QgU3Rv cmFnZVR5cGUmIHZhbHVlKSB7IHJldHVybiB2YWx1ZTsgfQorfTsKKwordGVtcGxhdGU8dHlwZW5h bWUgVD4gc3RydWN0IFBhcmFtU3RvcmFnZVRyYWl0c0Jhc2U8ZmFsc2UsIFBhc3NSZWZQdHI8VD4g PiB7CisgICAgdHlwZWRlZiBSZWZQdHI8VD4gU3RvcmFnZVR5cGU7CisKKyAgICBzdGF0aWMgU3Rv cmFnZVR5cGUgd3JhcChQYXNzUmVmUHRyPFQ+IHZhbHVlKSB7IHJldHVybiB2YWx1ZTsgfQorICAg IHN0YXRpYyBUKiB1bndyYXAoY29uc3QgU3RvcmFnZVR5cGUmIHZhbHVlKSB7IHJldHVybiB2YWx1 ZS5nZXQoKTsgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4gc3RydWN0IFBhcmFtU3RvcmFn ZVRyYWl0c0Jhc2U8ZmFsc2UsIFJlZlB0cjxUPiA+IHsKKyAgICB0eXBlZGVmIFJlZlB0cjxUPiBT dG9yYWdlVHlwZTsKKworICAgIHN0YXRpYyBTdG9yYWdlVHlwZSB3cmFwKFJlZlB0cjxUPiB2YWx1 ZSkgeyByZXR1cm4gdmFsdWUucmVsZWFzZSgpOyB9CisgICAgc3RhdGljIFQqIHVud3JhcChjb25z dCBTdG9yYWdlVHlwZSYgdmFsdWUpIHsgcmV0dXJuIHZhbHVlLmdldCgpOyB9Cit9OworCit0ZW1w bGF0ZTx0eXBlbmFtZT4gY2xhc3MgUmV0YWluUHRyOworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBz dHJ1Y3QgUGFyYW1TdG9yYWdlVHJhaXRzQmFzZTxmYWxzZSwgUmV0YWluUHRyPFQ+ID4geworICAg IHR5cGVkZWYgUmV0YWluUHRyPFQ+IFN0b3JhZ2VUeXBlOworCisgICAgc3RhdGljIFN0b3JhZ2VU eXBlIHdyYXAoY29uc3QgUmV0YWluUHRyPFQ+JiB2YWx1ZSkgeyByZXR1cm4gdmFsdWU7IH0KKyAg ICBzdGF0aWMgdHlwZW5hbWUgUmV0YWluUHRyPFQ+OjpQdHJUeXBlIHVud3JhcChjb25zdCBTdG9y YWdlVHlwZSYgdmFsdWUpIHsgcmV0dXJuIHZhbHVlLmdldCgpOyB9Cit9OworCit0ZW1wbGF0ZTx0 eXBlbmFtZSBUPiBzdHJ1Y3QgUGFyYW1TdG9yYWdlVHJhaXRzQmFzZTx0cnVlLCBUPiB7CisgICAg dHlwZWRlZiB0eXBlbmFtZSBUOjpTdG9yYWdlVHlwZSBTdG9yYWdlVHlwZTsKKworICAgIHN0YXRp YyBTdG9yYWdlVHlwZSB3cmFwKGNvbnN0IFQmIHZhbHVlKSB7IHJldHVybiB2YWx1ZS5jcm9zc1Ro cmVhZENvcHkoKTsgfQorICAgIHN0YXRpYyBTdG9yYWdlVHlwZSB1bndyYXAoY29uc3QgU3RvcmFn ZVR5cGUmIHZhbHVlKSB7IHJldHVybiB2YWx1ZTsgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUg VD4gc3RydWN0IFBhcmFtU3RvcmFnZVRyYWl0cyA6CisgICAgcHVibGljIFBhcmFtU3RvcmFnZVRy YWl0c0Jhc2U8V1RGOjpJc1N1YmNsYXNzT2ZUZW1wbGF0ZTxULCBDcm9zc1RocmVhZENvcHlhYmxl Pjo6dmFsdWUsIFQ+IHsKK307CisKK2NsYXNzIEZ1bmN0aW9uSW1wbEJhc2UgOiBwdWJsaWMgVGhy ZWFkU2FmZVJlZkNvdW50ZWQ8RnVuY3Rpb25JbXBsQmFzZT4geworcHVibGljOgorICAgIHZpcnR1 YWwgfkZ1bmN0aW9uSW1wbEJhc2UoKSB7IH0KK307CisKK3RlbXBsYXRlPHR5cGVuYW1lPgorY2xh c3MgRnVuY3Rpb25JbXBsOworCit0ZW1wbGF0ZTx0eXBlbmFtZSBSPgorY2xhc3MgRnVuY3Rpb25J bXBsPFIgKCk+IDogcHVibGljIEZ1bmN0aW9uSW1wbEJhc2UgeworcHVibGljOgorICAgIHZpcnR1 YWwgUiBvcGVyYXRvcigpKCkgPSAwOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgRnVuY3Rpb25X cmFwcGVyLCB0eXBlbmFtZSBGdW5jdGlvblR5cGU+CitjbGFzcyBCb3VuZEZ1bmN0aW9uSW1wbDsK KwordGVtcGxhdGU8dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyLCB0eXBlbmFtZSBSPgorY2xhc3Mg Qm91bmRGdW5jdGlvbkltcGw8RnVuY3Rpb25XcmFwcGVyLCBSICgpPiA6IHB1YmxpYyBGdW5jdGlv bkltcGw8dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyOjpSZXN1bHRUeXBlICgpPiB7CitwdWJsaWM6 CisgICAgZXhwbGljaXQgQm91bmRGdW5jdGlvbkltcGwoRnVuY3Rpb25XcmFwcGVyIGZ1bmN0aW9u V3JhcHBlcikKKyAgICAgICAgOiBtX2Z1bmN0aW9uV3JhcHBlcihmdW5jdGlvbldyYXBwZXIpCisg ICAgeworICAgIH0KKworICAgIHZpcnR1YWwgUiBvcGVyYXRvcigpKCkKKyAgICB7CisgICAgICAg IHJldHVybiBtX2Z1bmN0aW9uV3JhcHBlcigpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBGdW5j dGlvbldyYXBwZXIgbV9mdW5jdGlvbldyYXBwZXI7Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBG dW5jdGlvbldyYXBwZXIsIHR5cGVuYW1lIFIsIHR5cGVuYW1lIFAxPgorY2xhc3MgQm91bmRGdW5j dGlvbkltcGw8RnVuY3Rpb25XcmFwcGVyLCBSIChQMSk+IDogcHVibGljIEZ1bmN0aW9uSW1wbDx0 eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI6OlJlc3VsdFR5cGUgKCk+IHsKKworcHVibGljOgorICAg IEJvdW5kRnVuY3Rpb25JbXBsKEZ1bmN0aW9uV3JhcHBlciBmdW5jdGlvbldyYXBwZXIsIGNvbnN0 IFAxJiBwMSkKKyAgICAgICAgOiBtX2Z1bmN0aW9uV3JhcHBlcihmdW5jdGlvbldyYXBwZXIpCisg ICAgICAgICwgbV9wMShQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+Ojp3cmFwKHAxKSkKKyAgICB7Cisg ICAgfQorCisgICAgfkJvdW5kRnVuY3Rpb25JbXBsKCkKKyAgICB7CisgICAgfQorCisgICAgdmly dHVhbCBSIG9wZXJhdG9yKCkoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fZnVuY3Rpb25XcmFw cGVyKFBhcmFtU3RvcmFnZVRyYWl0czxQMT46OnVud3JhcChtX3AxKSk7CisgICAgfQorCitwcml2 YXRlOgorICAgIEZ1bmN0aW9uV3JhcHBlciBtX2Z1bmN0aW9uV3JhcHBlcjsKKyAgICB0eXBlbmFt ZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+OjpTdG9yYWdlVHlwZSBtX3AxOworfTsKKwordGVtcGxh dGU8dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyLCB0eXBlbmFtZSBSLCB0eXBlbmFtZSBQMSwgdHlw ZW5hbWUgUDI+CitjbGFzcyBCb3VuZEZ1bmN0aW9uSW1wbDxGdW5jdGlvbldyYXBwZXIsIFIgKFAx LCBQMik+IDogcHVibGljIEZ1bmN0aW9uSW1wbDx0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI6OlJl c3VsdFR5cGUgKCk+IHsKK3B1YmxpYzoKKyAgICBCb3VuZEZ1bmN0aW9uSW1wbChGdW5jdGlvbldy YXBwZXIgZnVuY3Rpb25XcmFwcGVyLCBjb25zdCBQMSYgcDEsIGNvbnN0IFAyJiBwMikKKyAgICAg ICAgOiBtX2Z1bmN0aW9uV3JhcHBlcihmdW5jdGlvbldyYXBwZXIpCisgICAgICAgICwgbV9wMShQ YXJhbVN0b3JhZ2VUcmFpdHM8UDE+Ojp3cmFwKHAxKSkKKyAgICAgICAgLCBtX3AyKFBhcmFtU3Rv cmFnZVRyYWl0czxQMj46OndyYXAocDIpKQorICAgIHsKKyAgICB9CisgICAgCisgICAgfkJvdW5k RnVuY3Rpb25JbXBsKCkKKyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB0eXBlbmFtZSBGdW5j dGlvbldyYXBwZXI6OlJlc3VsdFR5cGUgb3BlcmF0b3IoKSgpCisgICAgeworICAgICAgICByZXR1 cm4gbV9mdW5jdGlvbldyYXBwZXIoUGFyYW1TdG9yYWdlVHJhaXRzPFAxPjo6dW53cmFwKG1fcDEp LCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+Ojp1bndyYXAobV9wMikpOworICAgIH0KKworcHJpdmF0 ZToKKyAgICBGdW5jdGlvbldyYXBwZXIgbV9mdW5jdGlvbldyYXBwZXI7CisgICAgdHlwZW5hbWUg UGFyYW1TdG9yYWdlVHJhaXRzPFAxPjo6U3RvcmFnZVR5cGUgbV9wMTsKKyAgICB0eXBlbmFtZSBQ YXJhbVN0b3JhZ2VUcmFpdHM8UDI+OjpTdG9yYWdlVHlwZSBtX3AyOworfTsKKwordGVtcGxhdGU8 dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyLCB0eXBlbmFtZSBSLCB0eXBlbmFtZSBQMSwgdHlwZW5h bWUgUDIsIHR5cGVuYW1lIFAzPgorY2xhc3MgQm91bmRGdW5jdGlvbkltcGw8RnVuY3Rpb25XcmFw cGVyLCBSIChQMSwgUDIsIFAzKT4gOiBwdWJsaWMgRnVuY3Rpb25JbXBsPHR5cGVuYW1lIEZ1bmN0 aW9uV3JhcHBlcjo6UmVzdWx0VHlwZSAoKT4geworcHVibGljOgorICAgIEJvdW5kRnVuY3Rpb25J bXBsKEZ1bmN0aW9uV3JhcHBlciBmdW5jdGlvbldyYXBwZXIsIGNvbnN0IFAxJiBwMSwgY29uc3Qg UDImIHAyLCBjb25zdCBQMyYgcDMpCisgICAgICAgIDogbV9mdW5jdGlvbldyYXBwZXIoZnVuY3Rp b25XcmFwcGVyKQorICAgICAgICAsIG1fcDEoUGFyYW1TdG9yYWdlVHJhaXRzPFAxPjo6d3JhcChw MSkpCisgICAgICAgICwgbV9wMihQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+Ojp3cmFwKHAyKSkKKyAg ICAgICAgLCBtX3AzKFBhcmFtU3RvcmFnZVRyYWl0czxQMz46OndyYXAocDMpKQorICAgIHsKKyAg ICB9CisgICAgCisgICAgfkJvdW5kRnVuY3Rpb25JbXBsKCkKKyAgICB7CisgICAgfQorCisgICAg dmlydHVhbCB0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI6OlJlc3VsdFR5cGUgb3BlcmF0b3IoKSgp CisgICAgeworICAgICAgICByZXR1cm4gbV9mdW5jdGlvbldyYXBwZXIoUGFyYW1TdG9yYWdlVHJh aXRzPFAxPjo6dW53cmFwKG1fcDEpLCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+Ojp1bndyYXAobV9w MiksIFBhcmFtU3RvcmFnZVRyYWl0czxQMz46OnVud3JhcChtX3AzKSk7CisgICAgfQorCitwcml2 YXRlOgorICAgIEZ1bmN0aW9uV3JhcHBlciBtX2Z1bmN0aW9uV3JhcHBlcjsKKyAgICB0eXBlbmFt ZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+OjpTdG9yYWdlVHlwZSBtX3AxOworICAgIHR5cGVuYW1l IFBhcmFtU3RvcmFnZVRyYWl0czxQMj46OlN0b3JhZ2VUeXBlIG1fcDI7CisgICAgdHlwZW5hbWUg UGFyYW1TdG9yYWdlVHJhaXRzPFAzPjo6U3RvcmFnZVR5cGUgbV9wMzsKK307CisKK3RlbXBsYXRl PHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBlciwgdHlwZW5hbWUgUiwgdHlwZW5hbWUgUDEsIHR5cGVu YW1lIFAyLCB0eXBlbmFtZSBQMywgdHlwZW5hbWUgUDQ+CitjbGFzcyBCb3VuZEZ1bmN0aW9uSW1w bDxGdW5jdGlvbldyYXBwZXIsIFIgKFAxLCBQMiwgUDMsIFA0KT4gOiBwdWJsaWMgRnVuY3Rpb25J bXBsPHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBlcjo6UmVzdWx0VHlwZSAoKT4geworcHVibGljOgor ICAgIEJvdW5kRnVuY3Rpb25JbXBsKEZ1bmN0aW9uV3JhcHBlciBmdW5jdGlvbldyYXBwZXIsIGNv bnN0IFAxJiBwMSwgY29uc3QgUDImIHAyLCBjb25zdCBQMyYgcDMsIGNvbnN0IFA0JiBwNCkKKyAg ICAgICAgOiBtX2Z1bmN0aW9uV3JhcHBlcihmdW5jdGlvbldyYXBwZXIpCisgICAgICAgICwgbV9w MShQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+Ojp3cmFwKHAxKSkKKyAgICAgICAgLCBtX3AyKFBhcmFt U3RvcmFnZVRyYWl0czxQMj46OndyYXAocDIpKQorICAgICAgICAsIG1fcDMoUGFyYW1TdG9yYWdl VHJhaXRzPFAzPjo6d3JhcChwMykpCisgICAgICAgICwgbV9wNChQYXJhbVN0b3JhZ2VUcmFpdHM8 UDQ+Ojp3cmFwKHA0KSkKKyAgICB7CisgICAgfQorICAgIAorICAgIH5Cb3VuZEZ1bmN0aW9uSW1w bCgpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgdHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVy OjpSZXN1bHRUeXBlIG9wZXJhdG9yKCkoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fZnVuY3Rp b25XcmFwcGVyKFBhcmFtU3RvcmFnZVRyYWl0czxQMT46OnVud3JhcChtX3AxKSwgUGFyYW1TdG9y YWdlVHJhaXRzPFAyPjo6dW53cmFwKG1fcDIpLCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDM+Ojp1bndy YXAobV9wMyksIFBhcmFtU3RvcmFnZVRyYWl0czxQND46OnVud3JhcChtX3A0KSk7CisgICAgfQor Citwcml2YXRlOgorICAgIEZ1bmN0aW9uV3JhcHBlciBtX2Z1bmN0aW9uV3JhcHBlcjsKKyAgICB0 eXBlbmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+OjpTdG9yYWdlVHlwZSBtX3AxOworICAgIHR5 cGVuYW1lIFBhcmFtU3RvcmFnZVRyYWl0czxQMj46OlN0b3JhZ2VUeXBlIG1fcDI7CisgICAgdHlw ZW5hbWUgUGFyYW1TdG9yYWdlVHJhaXRzPFAzPjo6U3RvcmFnZVR5cGUgbV9wMzsKKyAgICB0eXBl bmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDQ+OjpTdG9yYWdlVHlwZSBtX3A0OworfTsKKwordGVt cGxhdGU8dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyLCB0eXBlbmFtZSBSLCB0eXBlbmFtZSBQMSwg dHlwZW5hbWUgUDIsIHR5cGVuYW1lIFAzLCB0eXBlbmFtZSBQNCwgdHlwZW5hbWUgUDU+CitjbGFz cyBCb3VuZEZ1bmN0aW9uSW1wbDxGdW5jdGlvbldyYXBwZXIsIFIgKFAxLCBQMiwgUDMsIFA0LCBQ NSk+IDogcHVibGljIEZ1bmN0aW9uSW1wbDx0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI6OlJlc3Vs dFR5cGUgKCk+IHsKK3B1YmxpYzoKKyAgICBCb3VuZEZ1bmN0aW9uSW1wbChGdW5jdGlvbldyYXBw ZXIgZnVuY3Rpb25XcmFwcGVyLCBjb25zdCBQMSYgcDEsIGNvbnN0IFAyJiBwMiwgY29uc3QgUDMm IHAzLCBjb25zdCBQNCYgcDQsIGNvbnN0IFA1JiBwNSkKKyAgICAgICAgOiBtX2Z1bmN0aW9uV3Jh cHBlcihmdW5jdGlvbldyYXBwZXIpCisgICAgICAgICwgbV9wMShQYXJhbVN0b3JhZ2VUcmFpdHM8 UDE+Ojp3cmFwKHAxKSkKKyAgICAgICAgLCBtX3AyKFBhcmFtU3RvcmFnZVRyYWl0czxQMj46Ondy YXAocDIpKQorICAgICAgICAsIG1fcDMoUGFyYW1TdG9yYWdlVHJhaXRzPFAzPjo6d3JhcChwMykp CisgICAgICAgICwgbV9wNChQYXJhbVN0b3JhZ2VUcmFpdHM8UDQ+Ojp3cmFwKHA0KSkKKyAgICAg ICAgLCBtX3A1KFBhcmFtU3RvcmFnZVRyYWl0czxQNT46OndyYXAocDUpKQorICAgIHsKKyAgICB9 CisgICAgCisgICAgfkJvdW5kRnVuY3Rpb25JbXBsKCkKKyAgICB7CisgICAgfQorCisgICAgdmly dHVhbCB0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI6OlJlc3VsdFR5cGUgb3BlcmF0b3IoKSgpCisg ICAgeworICAgICAgICByZXR1cm4gbV9mdW5jdGlvbldyYXBwZXIoUGFyYW1TdG9yYWdlVHJhaXRz PFAxPjo6dW53cmFwKG1fcDEpLCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+Ojp1bndyYXAobV9wMiks IFBhcmFtU3RvcmFnZVRyYWl0czxQMz46OnVud3JhcChtX3AzKSwgUGFyYW1TdG9yYWdlVHJhaXRz PFA0Pjo6dW53cmFwKG1fcDQpLCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDU+Ojp1bndyYXAobV9wNSkp OworICAgIH0KKworcHJpdmF0ZToKKyAgICBGdW5jdGlvbldyYXBwZXIgbV9mdW5jdGlvbldyYXBw ZXI7CisgICAgdHlwZW5hbWUgUGFyYW1TdG9yYWdlVHJhaXRzPFAxPjo6U3RvcmFnZVR5cGUgbV9w MTsKKyAgICB0eXBlbmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+OjpTdG9yYWdlVHlwZSBtX3Ay OworICAgIHR5cGVuYW1lIFBhcmFtU3RvcmFnZVRyYWl0czxQMz46OlN0b3JhZ2VUeXBlIG1fcDM7 CisgICAgdHlwZW5hbWUgUGFyYW1TdG9yYWdlVHJhaXRzPFA0Pjo6U3RvcmFnZVR5cGUgbV9wNDsK KyAgICB0eXBlbmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDU+OjpTdG9yYWdlVHlwZSBtX3A1Owor fTsKKwordGVtcGxhdGU8dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyLCB0eXBlbmFtZSBSLCB0eXBl bmFtZSBQMSwgdHlwZW5hbWUgUDIsIHR5cGVuYW1lIFAzLCB0eXBlbmFtZSBQNCwgdHlwZW5hbWUg UDUsIHR5cGVuYW1lIFA2PgorY2xhc3MgQm91bmRGdW5jdGlvbkltcGw8RnVuY3Rpb25XcmFwcGVy LCBSIChQMSwgUDIsIFAzLCBQNCwgUDUsIFA2KT4gOiBwdWJsaWMgRnVuY3Rpb25JbXBsPHR5cGVu YW1lIEZ1bmN0aW9uV3JhcHBlcjo6UmVzdWx0VHlwZSAoKT4geworcHVibGljOgorICAgIEJvdW5k RnVuY3Rpb25JbXBsKEZ1bmN0aW9uV3JhcHBlciBmdW5jdGlvbldyYXBwZXIsIGNvbnN0IFAxJiBw MSwgY29uc3QgUDImIHAyLCBjb25zdCBQMyYgcDMsIGNvbnN0IFA0JiBwNCwgY29uc3QgUDUmIHA1 LCBjb25zdCBQNiYgcDYpCisgICAgICAgIDogbV9mdW5jdGlvbldyYXBwZXIoZnVuY3Rpb25XcmFw cGVyKQorICAgICAgICAsIG1fcDEoUGFyYW1TdG9yYWdlVHJhaXRzPFAxPjo6d3JhcChwMSkpCisg ICAgICAgICwgbV9wMihQYXJhbVN0b3JhZ2VUcmFpdHM8UDI+Ojp3cmFwKHAyKSkKKyAgICAgICAg LCBtX3AzKFBhcmFtU3RvcmFnZVRyYWl0czxQMz46OndyYXAocDMpKQorICAgICAgICAsIG1fcDQo UGFyYW1TdG9yYWdlVHJhaXRzPFA0Pjo6d3JhcChwNCkpCisgICAgICAgICwgbV9wNShQYXJhbVN0 b3JhZ2VUcmFpdHM8UDU+Ojp3cmFwKHA1KSkKKyAgICAgICAgLCBtX3A2KFBhcmFtU3RvcmFnZVRy YWl0czxQNj46OndyYXAocDYpKQorICAgIHsKKyAgICB9CisKKyAgICB+Qm91bmRGdW5jdGlvbklt cGwoKQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBl cjo6UmVzdWx0VHlwZSBvcGVyYXRvcigpKCkKKyAgICB7CisgICAgICAgIHJldHVybiBtX2Z1bmN0 aW9uV3JhcHBlcihQYXJhbVN0b3JhZ2VUcmFpdHM8UDE+Ojp1bndyYXAobV9wMSksIFBhcmFtU3Rv cmFnZVRyYWl0czxQMj46OnVud3JhcChtX3AyKSwgUGFyYW1TdG9yYWdlVHJhaXRzPFAzPjo6dW53 cmFwKG1fcDMpLCBQYXJhbVN0b3JhZ2VUcmFpdHM8UDQ+Ojp1bndyYXAobV9wNCksIFBhcmFtU3Rv cmFnZVRyYWl0czxQNT46OnVud3JhcChtX3A1KSwgUGFyYW1TdG9yYWdlVHJhaXRzPFA2Pjo6dW53 cmFwKG1fcDYpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgRnVuY3Rpb25XcmFwcGVyIG1fZnVu Y3Rpb25XcmFwcGVyOworICAgIHR5cGVuYW1lIFBhcmFtU3RvcmFnZVRyYWl0czxQMT46OlN0b3Jh Z2VUeXBlIG1fcDE7CisgICAgdHlwZW5hbWUgUGFyYW1TdG9yYWdlVHJhaXRzPFAyPjo6U3RvcmFn ZVR5cGUgbV9wMjsKKyAgICB0eXBlbmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDM+OjpTdG9yYWdl VHlwZSBtX3AzOworICAgIHR5cGVuYW1lIFBhcmFtU3RvcmFnZVRyYWl0czxQND46OlN0b3JhZ2VU eXBlIG1fcDQ7CisgICAgdHlwZW5hbWUgUGFyYW1TdG9yYWdlVHJhaXRzPFA1Pjo6U3RvcmFnZVR5 cGUgbV9wNTsKKyAgICB0eXBlbmFtZSBQYXJhbVN0b3JhZ2VUcmFpdHM8UDY+OjpTdG9yYWdlVHlw ZSBtX3A2OworfTsKKworY2xhc3MgRnVuY3Rpb25CYXNlIHsKK3B1YmxpYzoKKyAgICBib29sIGlz TnVsbCgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gIW1faW1wbDsKKyAgICB9CisKK3By b3RlY3RlZDoKKyAgICBGdW5jdGlvbkJhc2UoKQorICAgIHsKKyAgICB9CisKKyAgICBleHBsaWNp dCBGdW5jdGlvbkJhc2UoUGFzc1JlZlB0cjxGdW5jdGlvbkltcGxCYXNlPiBpbXBsKQorICAgICAg ICA6IG1faW1wbChpbXBsKQorICAgIHsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBG dW5jdGlvblR5cGU+IEZ1bmN0aW9uSW1wbDxGdW5jdGlvblR5cGU+KiBpbXBsKCkgY29uc3QKKyAg ICB7IAorICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8RnVuY3Rpb25JbXBsPEZ1bmN0aW9uVHlw ZT4qPihtX2ltcGwuZ2V0KCkpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBSZWZQdHI8RnVuY3Rp b25JbXBsQmFzZT4gbV9pbXBsOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWU+CitjbGFzcyBDcm9z c1RocmVhZEZ1bmN0aW9uOworCit0ZW1wbGF0ZTx0eXBlbmFtZSBSPgorY2xhc3MgQ3Jvc3NUaHJl YWRGdW5jdGlvbjxSICgpPiA6IHB1YmxpYyBGdW5jdGlvbkJhc2UgeworcHVibGljOgorICAgIENy b3NzVGhyZWFkRnVuY3Rpb24oKQorICAgIHsKKyAgICB9CisKKyAgICBDcm9zc1RocmVhZEZ1bmN0 aW9uKFBhc3NSZWZQdHI8RnVuY3Rpb25JbXBsPFIgKCk+ID4gaW1wbCkKKyAgICAgICAgOiBGdW5j dGlvbkJhc2UoaW1wbCkKKyAgICB7CisgICAgfQorCisgICAgUiBvcGVyYXRvcigpKCkgY29uc3QK KyAgICB7CisgICAgICAgIEFTU0VSVCghaXNOdWxsKCkpOworCisgICAgICAgIHJldHVybiBpbXBs PFIgKCk+KCktPm9wZXJhdG9yKCkoKTsKKyAgICB9CisKKyNpZiBQTEFURk9STShNQUMpICYmIENP TVBJTEVSX1NVUFBPUlRTKEJMT0NLUykKKyAgICB0eXBlZGVmIHZvaWQgKF5CbG9ja1R5cGUpKCk7 CisgICAgb3BlcmF0b3IgQmxvY2tUeXBlKCkgY29uc3QKKyAgICB7CisgICAgICAgIC8vIERlY2xh cmUgYSBSZWZQdHIgaGVyZSBzbyB3ZSdsbCBiZSBzdXJlIHRoYXQgdGhlIHVuZGVybHlpbmcgRnVu Y3Rpb25JbXBsIG9iamVjdCdzCisgICAgICAgIC8vIGxpZmVjeWNsZSBpcyBtYW5hZ2VkIGNvcnJl Y3RseS4KKyAgICAgICAgUmVmUHRyPEZ1bmN0aW9uSW1wbDxSICgpPiA+IGZ1bmN0aW9uSW1wbCA9 IGltcGw8UiAoKT4oKTsKKyAgICAgICAgQmxvY2tUeXBlIGJsb2NrID0gXnsKKyAgICAgICAgICAg ZnVuY3Rpb25JbXBsLT5vcGVyYXRvcigpKCk7CisgICAgICAgIH07CisKKyAgICAgICAgLy8gVGhp cyBpcyBlcXVpdmFsZW50IHRvOgorICAgICAgICAvLworICAgICAgICAvLyAgIHJldHVybiBbW2Js b2NrIGNvcHldIGF1dG9yZWxlYXNlXTsKKyAgICAgICAgLy8KKyAgICAgICAgLy8gV2UncmUgdXNp bmcgbWFudWFsIG9iamNfbXNnU2VuZCBjYWxscyBoZXJlIGJlY2F1c2Ugd2UgZG9uJ3Qgd2FudCB0 byBtYWtlIHRoZSBlbnRpcmUKKyAgICAgICAgLy8gZmlsZSBPYmplY3RpdmUtQy4gSXQncyB1c2Vm dWwgdG8gYmUgYWJsZSB0byBpbXBsaWNpdGx5IGNvbnZlcnQgYSBGdW5jdGlvbiB0bworICAgICAg ICAvLyBhIGJsb2NrIGV2ZW4gaW4gQysrIGNvZGUsIHNpbmNlIHRoYXQgYWxsb3dzIHVzIHRvIGRv IHRoaW5ncyBsaWtlOgorICAgICAgICAvLworICAgICAgICAvLyAgIGRpc3BhdGNoX2FzeW5jKHF1 ZXVlLCBiaW5kKC4uLikpOworICAgICAgICAvLworICAgICAgICBpZCBjb3BpZWRCbG9jayA9IG9i amNfbXNnU2VuZCgoaWQpYmxvY2ssIHNlbF9yZWdpc3Rlck5hbWUoImNvcHkiKSk7CisgICAgICAg IGlkIGF1dG9yZWxlYXNlZEJsb2NrID0gb2JqY19tc2dTZW5kKGNvcGllZEJsb2NrLCBzZWxfcmVn aXN0ZXJOYW1lKCJhdXRvcmVsZWFzZSIpKTsKKyAgICAgICAgcmV0dXJuIChCbG9ja1R5cGUpYXV0 b3JlbGVhc2VkQmxvY2s7CisgICAgfQorI2VuZGlmCit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBG dW5jdGlvblR5cGU+CitDcm9zc1RocmVhZEZ1bmN0aW9uPHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBl cjxGdW5jdGlvblR5cGU+OjpSZXN1bHRUeXBlICgpPiBiaW5kKEZ1bmN0aW9uVHlwZSBmdW5jdGlv bikKK3sKKyAgICByZXR1cm4gQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0eXBlbmFtZSBGdW5jdGlvbldy YXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4oYWRvcHRSZWYobmV3IEJvdW5kRnVu Y3Rpb25JbXBsPEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+LCB0eXBlbmFtZSBGdW5jdGlv bldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4oRnVuY3Rpb25XcmFwcGVyPEZ1 bmN0aW9uVHlwZT4oZnVuY3Rpb24pKSkpOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBGdW5jdGlv blR5cGUsIHR5cGVuYW1lIEExPgorQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0eXBlbmFtZSBGdW5jdGlv bldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4gYmluZChGdW5jdGlvblR5cGUg ZnVuY3Rpb24sIGNvbnN0IEExJiBhMSkKK3sKKyAgICByZXR1cm4gQ3Jvc3NUaHJlYWRGdW5jdGlv bjx0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4o YWRvcHRSZWYobmV3IEJvdW5kRnVuY3Rpb25JbXBsPEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5 cGU+LCB0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAo QTEpPihGdW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPihmdW5jdGlvbiksIGExKSkpOworfQor Cit0ZW1wbGF0ZTx0eXBlbmFtZSBGdW5jdGlvblR5cGUsIHR5cGVuYW1lIEExLCB0eXBlbmFtZSBB Mj4KK0Nyb3NzVGhyZWFkRnVuY3Rpb248dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9u VHlwZT46OlJlc3VsdFR5cGUgKCk+IGJpbmQoRnVuY3Rpb25UeXBlIGZ1bmN0aW9uLCBjb25zdCBB MSYgYTEsIGNvbnN0IEEyJiBhMikKK3sKKyAgICByZXR1cm4gQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0 eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4oYWRv cHRSZWYobmV3IEJvdW5kRnVuY3Rpb25JbXBsPEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+ LCB0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoQTEs IEEyKT4oRnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlwZT4oZnVuY3Rpb24pLCBhMSwgYTIpKSk7 Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIEZ1bmN0aW9uVHlwZSwgdHlwZW5hbWUgQTEsIHR5cGVu YW1lIEEyLCB0eXBlbmFtZSBBMz4KK0Nyb3NzVGhyZWFkRnVuY3Rpb248dHlwZW5hbWUgRnVuY3Rp b25XcmFwcGVyPEZ1bmN0aW9uVHlwZT46OlJlc3VsdFR5cGUgKCk+IGJpbmQoRnVuY3Rpb25UeXBl IGZ1bmN0aW9uLCBjb25zdCBBMSYgYTEsIGNvbnN0IEEyJiBhMiwgY29uc3QgQTMmIGEzKQorewor ICAgIHJldHVybiBDcm9zc1RocmVhZEZ1bmN0aW9uPHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBlcjxG dW5jdGlvblR5cGU+OjpSZXN1bHRUeXBlICgpPihhZG9wdFJlZihuZXcgQm91bmRGdW5jdGlvbklt cGw8RnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlwZT4sIHR5cGVuYW1lIEZ1bmN0aW9uV3JhcHBl cjxGdW5jdGlvblR5cGU+OjpSZXN1bHRUeXBlIChBMSwgQTIsIEEzKT4oRnVuY3Rpb25XcmFwcGVy PEZ1bmN0aW9uVHlwZT4oZnVuY3Rpb24pLCBhMSwgYTIsIGEzKSkpOworfQorCit0ZW1wbGF0ZTx0 eXBlbmFtZSBGdW5jdGlvblR5cGUsIHR5cGVuYW1lIEExLCB0eXBlbmFtZSBBMiwgdHlwZW5hbWUg QTMsIHR5cGVuYW1lIEE0PgorQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0eXBlbmFtZSBGdW5jdGlvbldy YXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4gYmluZChGdW5jdGlvblR5cGUgZnVu Y3Rpb24sIGNvbnN0IEExJiBhMSwgY29uc3QgQTImIGEyLCBjb25zdCBBMyYgYTMsIGNvbnN0IEE0 JiBhNCkKK3sKKyAgICByZXR1cm4gQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0eXBlbmFtZSBGdW5jdGlv bldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4oYWRvcHRSZWYobmV3IEJvdW5k RnVuY3Rpb25JbXBsPEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+LCB0eXBlbmFtZSBGdW5j dGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoQTEsIEEyLCBBMywgQTQpPihG dW5jdGlvbldyYXBwZXI8RnVuY3Rpb25UeXBlPihmdW5jdGlvbiksIGExLCBhMiwgYTMsIGE0KSkp OworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBGdW5jdGlvblR5cGUsIHR5cGVuYW1lIEExLCB0eXBl bmFtZSBBMiwgdHlwZW5hbWUgQTMsIHR5cGVuYW1lIEE0LCB0eXBlbmFtZSBBNT4KK0Nyb3NzVGhy ZWFkRnVuY3Rpb248dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlwZT46OlJlc3Vs dFR5cGUgKCk+IGJpbmQoRnVuY3Rpb25UeXBlIGZ1bmN0aW9uLCBjb25zdCBBMSYgYTEsIGNvbnN0 IEEyJiBhMiwgY29uc3QgQTMmIGEzLCBjb25zdCBBNCYgYTQsIGNvbnN0IEE1JiBhNSkKK3sKKyAg ICByZXR1cm4gQ3Jvc3NUaHJlYWRGdW5jdGlvbjx0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8RnVu Y3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoKT4oYWRvcHRSZWYobmV3IEJvdW5kRnVuY3Rpb25JbXBs PEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+LCB0eXBlbmFtZSBGdW5jdGlvbldyYXBwZXI8 RnVuY3Rpb25UeXBlPjo6UmVzdWx0VHlwZSAoQTEsIEEyLCBBMywgQTQsIEE1KT4oRnVuY3Rpb25X cmFwcGVyPEZ1bmN0aW9uVHlwZT4oZnVuY3Rpb24pLCBhMSwgYTIsIGEzLCBhNCwgYTUpKSk7Cit9 CisKK3RlbXBsYXRlPHR5cGVuYW1lIEZ1bmN0aW9uVHlwZSwgdHlwZW5hbWUgQTEsIHR5cGVuYW1l IEEyLCB0eXBlbmFtZSBBMywgdHlwZW5hbWUgQTQsIHR5cGVuYW1lIEE1LCB0eXBlbmFtZSBBNj4K K0Nyb3NzVGhyZWFkRnVuY3Rpb248dHlwZW5hbWUgRnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlw ZT46OlJlc3VsdFR5cGUgKCk+IGJpbmQoRnVuY3Rpb25UeXBlIGZ1bmN0aW9uLCBjb25zdCBBMSYg YTEsIGNvbnN0IEEyJiBhMiwgY29uc3QgQTMmIGEzLCBjb25zdCBBNCYgYTQsIGNvbnN0IEE1JiBh NSwgY29uc3QgQTYmIGE2KQoreworICAgIHJldHVybiBDcm9zc1RocmVhZEZ1bmN0aW9uPHR5cGVu YW1lIEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+OjpSZXN1bHRUeXBlICgpPihhZG9wdFJl ZihuZXcgQm91bmRGdW5jdGlvbkltcGw8RnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlwZT4sIHR5 cGVuYW1lIEZ1bmN0aW9uV3JhcHBlcjxGdW5jdGlvblR5cGU+OjpSZXN1bHRUeXBlIChBMSwgQTIs IEEzLCBBNCwgQTUsIEE2KT4oRnVuY3Rpb25XcmFwcGVyPEZ1bmN0aW9uVHlwZT4oZnVuY3Rpb24p LCBhMSwgYTIsIGEzLCBhNCwgYTUsIGE2KSkpOworfQorCit9CisKKyNlbmRpZiAvLyBDcm9zc1Ro cmVhZEZ1bmN0aW9uYWxfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vS1VS TC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vS1VSTC5oCmluZGV4IGVlNjdlMTZmYzlmMDRj MzQ0NmExNzZiOWQ0ZjZkOTVmNDNiMWEwNmEuLjExNTJiYTI3YThmOTg0ZGUwYWU5MjJmOTNmOWFj ZjAwY2RjZTc3NDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0tVUkwuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9LVVJMLmgKQEAgLTI2LDYgKzI2LDcgQEAKICNp Zm5kZWYgS1VSTF9oCiAjZGVmaW5lIEtVUkxfaAogCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRGdW5j dGlvbmFsLmgiCiAjaW5jbHVkZSAiS1VSTFdURlVSTEltcGwuaCIKICNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CkBAIC01OSw3ICs2MCw3IEBAIHN0 cnVjdCBLVVJMSGFzaDsKIAogZW51bSBQYXJzZWRVUkxTdHJpbmdUYWcgeyBQYXJzZWRVUkxTdHJp bmcgfTsKIAotY2xhc3MgS1VSTCB7CitjbGFzcyBLVVJMIDogcHVibGljIENyb3NzVGhyZWFkQ29w eWFibGU8S1VSTD4gewogcHVibGljOgogICAgIC8vIEdlbmVyYXRlcyBhIFVSTCB3aGljaCBjb250 YWlucyBhIG51bGwgc3RyaW5nLgogICAgIEtVUkwoKSB7IGludmFsaWRhdGUoKTsgfQpAQCAtMTA4 LDYgKzEwOSw3IEBAIHB1YmxpYzoKICAgICAvLyB0aHJlYWQuICBTaW5jZSB0aGUgdW5kZXJseWlu ZyBTdHJpbmdJbXBsIG9iamVjdHMgYXJlIGltbXV0YWJsZSwgdGhlcmUncwogICAgIC8vIG5vIG90 aGVyIHJlYXNvbiB0byBldmVyIHByZWZlciBjb3B5KCkgb3ZlciBwbGFpbiBvbGQgYXNzaWdubWVu dC4KICAgICBLVVJMIGNvcHkoKSBjb25zdDsKKyAgICBLVVJMIGNyb3NzVGhyZWFkQ29weSgpIGNv bnN0IHsgcmV0dXJuIGNvcHkoKTsgfQogCiAgICAgYm9vbCBpc051bGwoKSBjb25zdDsKICAgICBi b29sIGlzRW1wdHkoKSBjb25zdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1Rhc2tUaHJlYWQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGFza1RocmVhZC5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uYzQxM2JjY2IwNzM2Zjc3OTY4ZDEzYTFlOTVlOWRhZjdlNDlkMjlkNwotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Rhc2tUaHJlYWQuY3BwCkBA IC0wLDAgKzEsMTQxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIENvbXBhbnkgMTAwIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiVGFza1RocmVhZC5o IgorCisjaW5jbHVkZSAiQXV0b2RyYWluZWRQb29sLmgiCisjaW5jbHVkZSAiTG9nZ2luZy5oIgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFRhc2tUaHJlYWRUYXNrIHsKKyAgICBXVEZf TUFLRV9OT05DT1BZQUJMRShUYXNrVGhyZWFkVGFzayk7CisgICAgV1RGX01BS0VfRkFTVF9BTExP Q0FURUQ7CitwdWJsaWM6CisgICAgVGFza1RocmVhZFRhc2soY29uc3QgQ3Jvc3NUaHJlYWRGdW5j dGlvbjx2b2lkKCk+JiBmdW5jdGlvbiwgUGFzc1JlZlB0cjxUYXNrR3JvdXA+IGdyb3VwID0gMCkK KyAgICAgICAgOiBtX2Z1bmN0aW9uKGZ1bmN0aW9uKQorICAgICAgICAsIG1fZ3JvdXAoZ3JvdXAp CisgICAgeworICAgIH0KKyAgICB2aXJ0dWFsIH5UYXNrVGhyZWFkVGFzaygpIHsgfQorCisgICAg dm9pZCBwZXJmb3JtVGFzaygpCisgICAgeworICAgICAgICBtX2Z1bmN0aW9uKCk7CisgICAgfQor CisgICAgUGFzc1JlZlB0cjxUYXNrR3JvdXA+IGdyb3VwKCkKKyAgICB7CisgICAgICAgIHJldHVy biBtX2dyb3VwOworICAgIH0KKworcHJpdmF0ZToKKyAgICBDcm9zc1RocmVhZEZ1bmN0aW9uPHZv aWQoKT4gbV9mdW5jdGlvbjsKKyAgICBSZWZQdHI8VGFza0dyb3VwPiBtX2dyb3VwOworfTsKKwor VGFza1RocmVhZDo6VGFza1RocmVhZCgpCisgICAgOiBtX3RocmVhZElEKDApCit7CisgICAgbV9z ZWxmUmVmID0gdGhpczsKK30KKworVGFza1RocmVhZDo6flRhc2tUaHJlYWQoKQoreworICAgIEFT U0VSVChtX3F1ZXVlLmtpbGxlZCgpKTsKK30KKworYm9vbCBUYXNrVGhyZWFkOjpzdGFydCgpCit7 CisgICAgTXV0ZXhMb2NrZXIgbG9jayhtX3RocmVhZENyZWF0aW9uTXV0ZXgpOworICAgIGlmICht X3RocmVhZElEKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBtX3RocmVhZElEID0gY3JlYXRl VGhyZWFkKFRhc2tUaHJlYWQ6OnRhc2tUaHJlYWRTdGFydCwgdGhpcywgIldlYkNvcmU6IFRhc2si KTsKKyAgICByZXR1cm4gbV90aHJlYWRJRDsKK30KKwordm9pZCBUYXNrVGhyZWFkOjpzdG9wKCkK K3sKKyAgICBtX3F1ZXVlLmtpbGwoKTsKK30KKwordm9pZCBUYXNrVGhyZWFkOjpwb3N0VGFzayhj b25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mIHRhc2ssIFBhc3NSZWZQdHI8VGFza0dy b3VwPiBncm91cCkKK3sKKyAgICBtX3F1ZXVlLmFwcGVuZChhZG9wdFB0cihuZXcgVGFza1RocmVh ZFRhc2sodGFzaywgZ3JvdXApKSk7Cit9CisKK3ZvaWQgVGFza1RocmVhZDo6cG9zdEltbWVkaWF0 ZVRhc2soY29uc3QgQ3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+JiB0YXNrLCBQYXNzUmVmUHRy PFRhc2tHcm91cD4gZ3JvdXApCit7CisgICAgbV9xdWV1ZS5wcmVwZW5kKGFkb3B0UHRyKG5ldyBU YXNrVGhyZWFkVGFzayh0YXNrLCBncm91cCkpKTsKK30KKworY2xhc3MgU2FtZUluc3RhbmNlUHJl ZGljYXRlIHsKK3B1YmxpYzoKKyAgICBTYW1lSW5zdGFuY2VQcmVkaWNhdGUoUGFzc1JlZlB0cjxU YXNrR3JvdXA+IGdyb3VwKSA6IG1fZ3JvdXAoZ3JvdXApIHsgfQorICAgIGJvb2wgb3BlcmF0b3Io KShUYXNrVGhyZWFkVGFzayogdGFzaykgY29uc3QgeyByZXR1cm4gdGFzay0+Z3JvdXAoKSA9PSBt X2dyb3VwOyB9Citwcml2YXRlOgorICAgIGNvbnN0IFJlZlB0cjxUYXNrR3JvdXA+IG1fZ3JvdXA7 Cit9OworCit2b2lkIFRhc2tUaHJlYWQ6OnJlbW92ZVRhc2tHcnVvcChQYXNzUmVmUHRyPFRhc2tH cm91cD4gZ3JvdXApCit7CisgICAgU2FtZUluc3RhbmNlUHJlZGljYXRlIHByZWRpY2F0ZShncm91 cCk7CisgICAgbV9xdWV1ZS5yZW1vdmVJZihwcmVkaWNhdGUpOworfQorCit2b2lkIFRhc2tUaHJl YWQ6OnRhc2tUaHJlYWRTdGFydCh2b2lkKiBhcmcpCit7CisgICAgVGFza1RocmVhZCogdGFza1Ro cmVhZCA9IHN0YXRpY19jYXN0PFRhc2tUaHJlYWQqPihhcmcpOworICAgIHRhc2tUaHJlYWQtPnJ1 bkxvb3AoKTsKK30KKwordm9pZCBUYXNrVGhyZWFkOjpydW5Mb29wKCkKK3sKKyAgICB7CisgICAg ICAgIC8vIFdhaXQgZm9yIFRhc2tUaHJlYWQ6OnN0YXJ0KCkgdG8gY29tcGxldGUgdG8gaGF2ZSBt X3RocmVhZElECisgICAgICAgIC8vIGVzdGFibGlzaGVkIGJlZm9yZSBzdGFydGluZyB0aGUgbWFp biBsb29wLgorICAgICAgICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFkQ3JlYXRpb25NdXRleCk7 CisgICAgICAgIExPRyhUaHJlYWRpbmcsICJTdGFydGVkIFRhc2tUaHJlYWQgJXAiLCB0aGlzKTsK KyAgICB9CisKKyAgICBBdXRvZHJhaW5lZFBvb2wgcG9vbDsKKyAgICB3aGlsZSAoT3duUHRyPFRh c2tUaHJlYWRUYXNrPiB0YXNrID0gbV9xdWV1ZS53YWl0Rm9yTWVzc2FnZSgpKSB7CisgICAgICAg IHRhc2stPnBlcmZvcm1UYXNrKCk7CisgICAgICAgIHBvb2wuY3ljbGUoKTsKKyAgICB9CisKKyAg ICBMT0coVGhyZWFkaW5nLCAiQWJvdXQgdG8gZGV0YWNoIHRocmVhZCAlaSBhbmQgY2xlYXIgdGhl IHJlZiB0byBUYXNrVGhyZWFkICVwLCB3aGljaCBjdXJyZW50bHkgaGFzICVpIHJlZihzKSIsIG1f dGhyZWFkSUQsIHRoaXMsIHJlZkNvdW50KCkpOworCisgICAgZGV0YWNoVGhyZWFkKG1fdGhyZWFk SUQpOworCisgICAgZGlkU3RvcFRocmVhZCgpOworCisgICAgLy8gQ2xlYXIgdGhlIHNlbGYgcmVm cHRyLCBwb3NzaWJseSByZXN1bHRpbmcgaW4gZGVsZXRpb24KKyAgICBtX3NlbGZSZWYgPSAwOwor fQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9UYXNrVGhyZWFkLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UYXNrVGhyZWFk LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMGE4ZTJiZTRlMTBlYzg4ZDFhNGM0OWQ5YjNkYzNiNTY3YzRiMTRjMAot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Rhc2tUaHJlYWQuaApA QCAtMCwwICsxLDgzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIENvbXBhbnkgMTAwIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2lmbmRlZiBUYXNrVGhyZWFkX2gKKyNkZWZpbmUgVGFza1RocmVhZF9oCisK KyNpbmNsdWRlICJDcm9zc1RocmVhZEZ1bmN0aW9uYWwuaCIKKworI2luY2x1ZGUgPHd0Zi9NZXNz YWdlUXVldWUuaD4KKyNpbmNsdWRlIDx3dGYvTnVsbFB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNz T3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhy ZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgVGFza0dyb3VwIDogcHVi bGljIFRocmVhZFNhZmVSZWZDb3VudGVkPFRhc2tHcm91cD4geworcHVibGljOgorICAgIHN0YXRp YyBQYXNzUmVmUHRyPFRhc2tHcm91cD4gY3JlYXRlKCkKKyAgICB7CisgICAgICAgIHJldHVybiBh ZG9wdFJlZihuZXcgVGFza0dyb3VwKCkpOworICAgIH0KK307CisKK2NsYXNzIFRhc2tUaHJlYWRU YXNrOworCitjbGFzcyBUYXNrVGhyZWFkIDogcHVibGljIFRocmVhZFNhZmVSZWZDb3VudGVkPFRh c2tUaHJlYWQ+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUYXNrVGhyZWFkPiBj cmVhdGUoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUYXNrVGhyZWFkKCkp OworICAgIH0KKworICAgIHZpcnR1YWwgflRhc2tUaHJlYWQoKTsKKworICAgIGJvb2wgc3RhcnQo KTsKKyAgICB2b2lkIHN0b3AoKTsKKworICAgIHZvaWQgcG9zdFRhc2soY29uc3QgQ3Jvc3NUaHJl YWRGdW5jdGlvbjx2b2lkKCk+JiwgUGFzc1JlZlB0cjxUYXNrR3JvdXA+ID0gMCk7CisgICAgdm9p ZCBwb3N0SW1tZWRpYXRlVGFzayhjb25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mLCBQ YXNzUmVmUHRyPFRhc2tHcm91cD4gPSAwKTsKKyAgICB2b2lkIHJlbW92ZVRhc2tHcnVvcChQYXNz UmVmUHRyPFRhc2tHcm91cD4pOworCitwcm90ZWN0ZWQ6CisgICAgdmlydHVhbCB2b2lkIGRpZFN0 b3BUaHJlYWQoKSB7IH0KKyAgICBUYXNrVGhyZWFkKCk7CisKK3ByaXZhdGU6CisKKyAgICBzdGF0 aWMgdm9pZCB0YXNrVGhyZWFkU3RhcnQodm9pZCopOworICAgIHZvaWQgcnVuTG9vcCgpOworCisg ICAgVGhyZWFkSWRlbnRpZmllciBtX3RocmVhZElEOworICAgIFJlZlB0cjxUYXNrVGhyZWFkPiBt X3NlbGZSZWY7CisgICAgTWVzc2FnZVF1ZXVlPFRhc2tUaHJlYWRUYXNrPiBtX3F1ZXVlOworCisg ICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gVGFza1RocmVhZF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmNwcAppbmRleCBiMTBjMTQ3MGVkNDhlYjhiODBmOGZjOWEyZTU3OTYxOWYxOWRk ZGNjLi5hMTUzNWIxNDgzYTcyMzE1NjM5YWVlMDVhNzllZDVlMDdmYTdhMzg4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKQEAgLTE5Niw2ICsxOTYsMTEgQEAgdm9p ZCBXb3JrZXJDb250ZXh0Ojpwb3N0VGFzayhQYXNzT3duUHRyPFRhc2s+IHRhc2spCiAgICAgdGhy ZWFkKCktPnJ1bkxvb3AoKS5wb3N0VGFzayh0YXNrKTsKIH0KIAordm9pZCBXb3JrZXJDb250ZXh0 Ojpwb3N0VGFzayhjb25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mIHRhc2spCit7Cisg ICAgdGhyZWFkKCktPnJ1bkxvb3AoKS5wb3N0VGFzayh0YXNrKTsKK30KKwogaW50IFdvcmtlckNv bnRleHQ6OnNldFRpbWVvdXQoUGFzc093blB0cjxTY2hlZHVsZWRBY3Rpb24+IGFjdGlvbiwgaW50 IHRpbWVvdXQpCiB7CiAgICAgcmV0dXJuIERPTVRpbWVyOjppbnN0YWxsKHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKSwgYWN0aW9uLCB0aW1lb3V0LCB0cnVlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmgKaW5kZXggMGIyZjZhMWQ0NjljYzY2MWNkZmUxNmE4MmVhZTg2YTk4OWYx MzliYy4uNjVkZWIyZjBlNGVmNTM3Nzc3OGRjN2I3ZGZmNjQ4M2Y3ODc1ZWIzOSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKKysrIGIvU291cmNlL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKQEAgLTgzLDYgKzgzLDcgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIGNvbnN0OwogCiAg ICAgICAgIHZpcnR1YWwgdm9pZCBwb3N0VGFzayhQYXNzT3duUHRyPFRhc2s+KTsgLy8gRXhlY3V0 ZXMgdGhlIHRhc2sgb24gY29udGV4dCdzIHRocmVhZCBhc3luY2hyb25vdXNseS4KKyAgICAgICAg dmlydHVhbCB2b2lkIHBvc3RUYXNrKGNvbnN0IENyb3NzVGhyZWFkRnVuY3Rpb248dm9pZCgpPiYp OyAvLyBFeGVjdXRlcyB0aGUgdGFzayBvbiBjb250ZXh0J3MgdGhyZWFkIGFzeW5jaHJvbm91c2x5 LgogCiAgICAgICAgIC8vIFdvcmtlckdsb2JhbFNjb3BlCiAgICAgICAgIFdvcmtlckNvbnRleHQq IHNlbGYoKSB7IHJldHVybiB0aGlzOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlclJ1bkxvb3AuY3BwIGIvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5M b29wLmNwcAppbmRleCBlYjY2NWQyNmI4MWY2ZjBlNTM0ZGNlZWY2Y2M0NzYwODY0NGM1YWEwLi43 YWQ1ZjlmM2I4NzU0NTljYmFmZDg0N2NkMTBhYTA4NmM2ODM1YzQ5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKQEAgLTIwMSwyMSArMjAxLDQwIEBAIHZvaWQgV29y a2VyUnVuTG9vcDo6cG9zdFRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpU YXNrPiB0YXNrKQogICAgIHBvc3RUYXNrRm9yTW9kZSh0YXNrLCBkZWZhdWx0TW9kZSgpKTsKIH0K IAordm9pZCBXb3JrZXJSdW5Mb29wOjpwb3N0VGFzayhjb25zdCBDcm9zc1RocmVhZEZ1bmN0aW9u PHZvaWQoKT4mIGZ1bmN0aW9uKQoreworICAgIHBvc3RUYXNrRm9yTW9kZShmdW5jdGlvbiwgZGVm YXVsdE1vZGUoKSk7Cit9CisKIHZvaWQgV29ya2VyUnVuTG9vcDo6cG9zdFRhc2tGb3JNb2RlKFBh c3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3RyaW5n JiBtb2RlKQogewogICAgIG1fbWVzc2FnZVF1ZXVlLmFwcGVuZChUYXNrOjpjcmVhdGUodGFzaywg bW9kZS5pc29sYXRlZENvcHkoKSkpOwogfQogCit2b2lkIFdvcmtlclJ1bkxvb3A6OnBvc3RUYXNr Rm9yTW9kZShjb25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mIGZ1bmN0aW9uLCBjb25z dCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9tZXNzYWdlUXVldWUuYXBwZW5kKFRhc2s6OmNyZWF0 ZShmdW5jdGlvbiwgbW9kZS5pc29sYXRlZENvcHkoKSkpOworfQorCiBQYXNzT3duUHRyPFdvcmtl clJ1bkxvb3A6OlRhc2s+IFdvcmtlclJ1bkxvb3A6OlRhc2s6OmNyZWF0ZShQYXNzT3duUHRyPFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2ssIGNvbnN0IFN0cmluZyYgbW9kZSkKIHsK ICAgICByZXR1cm4gYWRvcHRQdHIobmV3IFRhc2sodGFzaywgbW9kZSkpOwogfQogCitQYXNzT3du UHRyPFdvcmtlclJ1bkxvb3A6OlRhc2s+IFdvcmtlclJ1bkxvb3A6OlRhc2s6OmNyZWF0ZShjb25z dCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mIGZ1bmN0aW9uLCBjb25zdCBTdHJpbmcmIG1v ZGUpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBUYXNrKGZ1bmN0aW9uLCBtb2RlKSk7Cit9 CisKIHZvaWQgV29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9ybVRhc2soY29uc3QgV29ya2VyUnVu TG9vcCYgcnVuTG9vcCwgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKIHsKICAgICBX b3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCAq Pihjb250ZXh0KTsKLSAgICBpZiAoKCF3b3JrZXJDb250ZXh0LT5pc0Nsb3NpbmcoKSAmJiAhcnVu TG9vcC50ZXJtaW5hdGVkKCkpIHx8IG1fdGFzay0+aXNDbGVhbnVwVGFzaygpKQotICAgICAgICBt X3Rhc2stPnBlcmZvcm1UYXNrKGNvbnRleHQpOworICAgIGlmICgoIXdvcmtlckNvbnRleHQtPmlz Q2xvc2luZygpICYmICFydW5Mb29wLnRlcm1pbmF0ZWQoKSkgfHwgbV90YXNrLT5pc0NsZWFudXBU YXNrKCkpIHsKKyAgICAgICAgaWYgKG1fdGFzaykKKyAgICAgICAgICAgIG1fdGFzay0+cGVyZm9y bVRhc2soY29udGV4dCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIG1fZnVuY3Rpb24oKTsK KyAgICB9CiB9CiAKIFdvcmtlclJ1bkxvb3A6OlRhc2s6OlRhc2soUGFzc093blB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpCkBAIC0yMjQs NiArMjQzLDEzIEBAIFdvcmtlclJ1bkxvb3A6OlRhc2s6OlRhc2soUGFzc093blB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTCiB7CiB9CiAKK1dvcmtlclJ1bkxv b3A6OlRhc2s6OlRhc2soY29uc3QgQ3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+JiBmdW5jdGlv biwgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIDogbV90YXNrKG51bGxwdHIpCisgICAgLCBtX2Z1 bmN0aW9uKGZ1bmN0aW9uKQorICAgICwgbV9tb2RlKG1vZGUuaXNvbGF0ZWRDb3B5KCkpCit7Cit9 CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5Mb29wLmggYi9Tb3Vy Y2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuaAppbmRleCAzOTE2ZDZhYzU3M2Q1ZDdl N2VlNGE3ZDVlY2Q2MTg3NTZhNTY5YTlmLi43ZTNjN2JkYzJlMDA3ODY3MzMwY2Q1YWFlOGFlMGZj ODRkNjg0ZDYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxv b3AuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuaApAQCAtMzMs NiArMzMsNyBAQAogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJDcm9zc1RocmVh ZEZ1bmN0aW9uYWwuaCIKICNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5j bHVkZSA8d3RmL01lc3NhZ2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KQEAgLTYx LDcgKzYyLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIHRlcm1pbmF0ZWQo KSBjb25zdCB7IHJldHVybiBtX21lc3NhZ2VRdWV1ZS5raWxsZWQoKTsgfQogCiAgICAgICAgIHZv aWQgcG9zdFRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7Cisg ICAgICAgIHZvaWQgcG9zdFRhc2soY29uc3QgQ3Jvc3NUaHJlYWRGdW5jdGlvbjx2b2lkKCk+Jik7 CiAgICAgICAgIHZvaWQgcG9zdFRhc2tGb3JNb2RlKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6VGFzaz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisgICAgICAgIHZvaWQgcG9zdFRh c2tGb3JNb2RlKGNvbnN0IENyb3NzVGhyZWFkRnVuY3Rpb248dm9pZCgpPiYsIGNvbnN0IFN0cmlu ZyYgbW9kZSk7CiAKICAgICAgICAgdW5zaWduZWQgbG9uZyBjcmVhdGVVbmlxdWVJZCgpIHsgcmV0 dXJuICsrbV91bmlxdWVJZDsgfQogCkBAIC03MSwxNCArNzQsMTcgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgICAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGFzayk7IFdURl9NQUtFX0ZB U1RfQUxMT0NBVEVEOwogICAgICAgICBwdWJsaWM6CiAgICAgICAgICAgICBzdGF0aWMgUGFzc093 blB0cjxUYXNrPiBjcmVhdGUoUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNr PiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpOworICAgICAgICAgICAgc3RhdGljIFBhc3NPd25Q dHI8VGFzaz4gY3JlYXRlKGNvbnN0IENyb3NzVGhyZWFkRnVuY3Rpb248dm9pZCgpPiYsIGNvbnN0 IFN0cmluZyYgbW9kZSk7CiAgICAgICAgICAgICB+VGFzaygpIHsgfQogICAgICAgICAgICAgY29u c3QgU3RyaW5nJiBtb2RlKCkgY29uc3QgeyByZXR1cm4gbV9tb2RlOyB9CiAgICAgICAgICAgICB2 b2lkIHBlcmZvcm1UYXNrKGNvbnN0IFdvcmtlclJ1bkxvb3AmLCBTY3JpcHRFeGVjdXRpb25Db250 ZXh0Kik7CiAKICAgICAgICAgcHJpdmF0ZToKICAgICAgICAgICAgIFRhc2soUGFzc093blB0cjxT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpOwor ICAgICAgICAgICAgVGFzayhjb25zdCBDcm9zc1RocmVhZEZ1bmN0aW9uPHZvaWQoKT4mLCBjb25z dCBTdHJpbmcmIG1vZGUpOwogICAgICAgICAKICAgICAgICAgICAgIE93blB0cjxTY3JpcHRFeGVj dXRpb25Db250ZXh0OjpUYXNrPiBtX3Rhc2s7CisgICAgICAgICAgICBDcm9zc1RocmVhZEZ1bmN0 aW9uPHZvaWQoKT4gbV9mdW5jdGlvbjsKICAgICAgICAgICAgIFN0cmluZyBtX21vZGU7CiAgICAg ICAgIH07CiAK