45808 2010-09-14 23:53:39 -0700 Add Worker support for FileSystem API 2010-09-30 13:39:33 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 42903 0 kinuko webkit-unassigned ap dumi ericu fishd levin michaeln oldest_to_newest 279417 0 kinuko 2010-09-14 23:53:39 -0700 Add Worker support for FileSystem API. * requestFileSystem and Flags constructor must be exposed on the worker context. * other FileSystem operations must be supported on workers too. 279431 1 67649 kinuko 2010-09-15 00:26:01 -0700 Created attachment 67649 Patch 279437 2 67651 kinuko 2010-09-15 00:41:57 -0700 Created attachment 67651 Patch 279623 3 ap 2010-09-15 10:59:36 -0700 + ~LocalFileSystem() { } If the intention is for the destructor to never be called, then it shouldn't be defined. + // FIXME: See if access is allowed. This is a scary FIXME to have in code! +COMPILE_ASSERT(int(WorkerContext::TEMPORARY) == int(AsyncFileSystem::Temporary), enum_mismatch); Coding style says that we should use static_cast, not C-style casts. + // They are placed here and in all capital letters to enforce compile-time enum checking. How do capital letters help compile time enum checking? I haven't reviewed the substance of the patch, largely because of naming issues that were making reading too hard. Specifically, "requestFileSystem()" has taken me aback, as a file system is not something I'd expect to be requested. 279665 4 67651 ericu 2010-09-15 12:48:12 -0700 Comment on attachment 67651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67651&action=prettypatch > WebCore/ChangeLog:8 > + Exposed requestFileSystem and Flags constructor on worker contexts. As soon as you expose DOMFileSystem types to workers, you need to add the NoStaticTables modifier in the IDL files for any type thus exposed. About half of the files in fileapi/ have it already [from FileReader/Blob stuff], but they all should. See https://trac.webkit.org/wiki/IdlAttributes for more info. 279757 5 67725 kinuko 2010-09-15 15:13:06 -0700 Created attachment 67725 Patch 279758 6 67726 kinuko 2010-09-15 15:17:33 -0700 Created attachment 67726 Patch 279762 7 67729 kinuko 2010-09-15 15:21:58 -0700 Created attachment 67729 Patch 279766 8 kinuko 2010-09-15 15:28:30 -0700 (In reply to comment #3) > + ~LocalFileSystem() { } > If the intention is for the destructor to never be called, then it shouldn't be defined. Removed. > + // FIXME: See if access is allowed. > This is a scary FIXME to have in code! Added access and availability checks. > +COMPILE_ASSERT(int(WorkerContext::TEMPORARY) == int(AsyncFileSystem::Temporary), enum_mismatch); > Coding style says that we should use static_cast, not C-style casts. Fixed. > + // They are placed here and in all capital letters to enforce compile-time enum checking. > How do capital letters help compile time enum checking? If there're constant attributes in idl the code generator automatically generates enum checking code with the enum values (unless we specify DontCheckEnums). > I haven't reviewed the substance of the patch, largely because of naming issues that were making reading too hard. Specifically, "requestFileSystem()" has taken me aback, as a file system is not something I'd expect to be requested. The names LocalFileSystem and requestFileSystem are taken from its spec: http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#using-localfilesystem In terms of class/file naming there're too many *FileSystem classes and I admit it might be hard to read -- DOMFileSystem corresponds to JavaScript's FileSystem interface in the FileSystem API and AsyncFileSystem is a platform-dependent lower layer implementation for the filesystems. If there're any feedbacks I could do to improve the design / readability I'm glad to change the code. Thanks, 279767 9 kinuko 2010-09-15 15:29:05 -0700 (In reply to comment #4) > (From update of attachment 67651 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67651&action=prettypatch > > > WebCore/ChangeLog:8 > > + Exposed requestFileSystem and Flags constructor on worker contexts. > As soon as you expose DOMFileSystem types to workers, you need to add the NoStaticTables modifier in the IDL files for any type thus exposed. About half of the files in fileapi/ have it already [from FileReader/Blob stuff], but they all should. See https://trac.webkit.org/wiki/IdlAttributes for more info. Right right... thanks for pointing it out. Fixed (for all non-callback interfaces). 280409 10 67729 michaeln 2010-09-16 15:41:18 -0700 Comment on attachment 67729 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67729&action=prettypatch > WebKit/chromium/public/WebCommonWorkerClient.h:90 > + virtual void openFileSystem(WebFrame*, WebFileSystem::Type, long long size, WebFileSystemCallbacks*) As mentioned in the chromium review, I don't think the WebFrame* param is needed or desired here. 280462 11 67862 kinuko 2010-09-16 17:12:46 -0700 Created attachment 67862 Patch Removed Frame parameters from WebCommonWorkerClient::openFileSystem(). 280854 12 67862 michaeln 2010-09-17 14:18:49 -0700 Comment on attachment 67862 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67862&action=prettypatch > WebKit/chromium/src/LocalFileSystemChromium.cpp:70 > + webWorker->openFileSystem(0, static_cast<WebFileSystem::Type>(type), size, new WebFileSystemCallbacksImpl(new FileSystemCallbacks(successCallback, errorCallback, context))); is the first '0' arg value stale now that we've removed the 'frame' parameter? > WebKit/chromium/src/WebWorkerBase.h:95 > + virtual void openFileSystem(WebFrame*, WebFileSystem::Type, long long size, WebFileSystemCallbacks*); ah... can we remove the WebFrame* here too? > WebKit/chromium/src/WebWorkerBase.cpp:338 > +void WebWorkerBase::openFileSystem(WebFrame*, WebFileSystem::Type type, long long size, WebFileSystemCallbacks* callbacks) and here > WebKit/chromium/src/WebWorkerClientImpl.h:102 > + virtual void openFileSystem(WebFrame*, WebFileSystem::Type, long long size, WebFileSystemCallbacks*) and here 280905 13 67862 levin 2010-09-17 15:20:25 -0700 Comment on attachment 67862 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67862&action=prettypatch > WebCore/ChangeLog:10 > + Also changed how to get the base path for Web file systems (in non-chromium ports) so that it works for workers too. This patch assumes each port calls LocalFileSystem::initializeLocalFileSystem() in its initialization phase. In general lines are wrapped some in the ChangeLog (unlike everywhere else in WebKit. > WebCore/ChangeLog:35 > + * workers/WorkerContext.idl: Ideally you would write something (brief) that describes why you did a change in this file (or function). See Darin Adler's ChangeLogs for a good example of what I mean. > WebCore/ChangeLog:1454 > + Added NoStaticTables and changed modulename from storage to fileapi: This change seems very misplaced. > WebCore/fileapi/LocalFileSystem.cpp:62 > + staticLocalFileSystem = new LocalFileSystem(basePath); Is this function called from multiple threads (because it isn't threadsafe)? You can either assert that this is on the main thread or use the macro which takes a mutex to do this in a threadsafe manner. Also here is another plain new. Use OwnPtr... as I mention in another place (below). > WebCore/fileapi/LocalFileSystem.cpp:67 > + if (!staticLocalFileSystem) same comment as the other method which does something like this. > WebCore/workers/WorkerContext.h:127 > + // They are placed here and in all capital letters to enforce compile-time enum checking. Alexey had a question about this comment that seems unanswered (and I have the same question). It may be best to answer the question by fixing the comment since at least two people looking at this code have had the same reaction. > WebKit/chromium/src/WebWorkerBase.cpp:128 > + ASSERT(new OpenFileSystemMainThreadBridge(worker, commonClient, mode, type, size, callbacks)); This isn't going to work in !debug. Also, why ASSERT this at all? Lastly, use OwnPtr().leakPtr() here. WebKit is moving away from having an "new"s that don't use OwnPtr. > WebKit/chromium/src/WebWorkerBase.cpp:150 > + commonClient->openFileSystem(type, size, new MainThreadFileSystemCallbacks(bridge)); Another instance of new. Consider making the constructor for MainThreadFileSystemCallbacks private and adding a create method which returns a PassOwnPtr. > WebKit/chromium/src/WebWorkerBase.cpp:164 > + didFail(WebFileErrorAbort); This call to "didFail" is incorrect. This is the destructor and "didFail" will "delete this" (again). > WebKit/chromium/src/WebWorkerBase.cpp:170 > + m_bridge.leakPtr()->didOpenFileSystemOnMainThread(name, path); Why are these calls doing leak ptr? (A comment may be in order.) I didn't parse/grok the whole patch yet but I felt there were enough things here that it may be good to give this feedback now. 281000 14 67974 kinuko 2010-09-17 17:07:23 -0700 Created attachment 67974 Patch 281006 15 kinuko 2010-09-17 17:14:29 -0700 (In reply to comment #13) > (From update of attachment 67862 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67862&action=prettypatch > > > WebCore/ChangeLog:10 > In general lines are wrapped some in the ChangeLog (unlike everywhere else in WebKit. > Ideally you would write something (brief) that describes why you did a change in this file (or function). Fixed. (Or I tried to fix.) > > WebCore/ChangeLog:1454 > > + Added NoStaticTables and changed modulename from storage to fileapi: > > This change seems very misplaced. Hmm that's true I removed them from this patch. I'm going to file another issue. > > WebCore/fileapi/LocalFileSystem.cpp:62 > > + staticLocalFileSystem = new LocalFileSystem(basePath); > Is this function called from multiple threads (because it isn't threadsafe)? initializeLocalFileSystem is assumed to be called only once before any workers start (as in the header comment). localFileSystem() should have had an assert -- fixed. > Also here is another plain new. Use OwnPtr... as I mention in another place (below). Fixed. > > WebCore/workers/WorkerContext.h:127 > > + // They are placed here and in all capital letters to enforce compile-time enum checking. > > Alexey had a question about this comment that seems unanswered (and I have the same question). > It may be best to answer the question by fixing the comment since at least two people looking at this code have had the same reaction. I tried to answer in comment #8 but seems like it didn't work well :( "If there're constant attributes in idl the code generator automatically generates enum checking code with the enum values (unless we specify DontCheckEnums)." I added some more comment in the header file, hope it makes sense. >> // They are placed here and in all capital letters to enforce compile-time enum checking. >> // The code generator generates the code that performs compile-time enum checking with constant attributes defined in the idl and enum values in the header, and the enum names must match with the attribute names. > > WebKit/chromium/src/WebWorkerBase.cpp:128 > > + ASSERT(new OpenFileSystemMainThreadBridge(worker, commonClient, mode, type, size, callbacks)); > > This isn't going to work in !debug. > Also, why ASSERT this at all? Oops, right it was wrong. Fixed. > Lastly, use OwnPtr().leakPtr() here. WebKit is moving away from having an "new"s that don't use OwnPtr. I fixed my code to explicitly use that. (I had wondered if I should do so even I would never use the return value... but maybe the coding rules should be respected) > > WebKit/chromium/src/WebWorkerBase.cpp:150 > > + commonClient->openFileSystem(type, size, new MainThreadFileSystemCallbacks(bridge)); > > Another instance of new. > Consider making the constructor for MainThreadFileSystemCallbacks private and adding a create method which returns a PassOwnPtr. Fixed. > > WebKit/chromium/src/WebWorkerBase.cpp:164 > > + didFail(WebFileErrorAbort); > > This call to "didFail" is incorrect. > This is the destructor and "didFail" will "delete this" (again). Fixed. > > WebKit/chromium/src/WebWorkerBase.cpp:170 > > + m_bridge.leakPtr()->didOpenFileSystemOnMainThread(name, path); > > Why are these calls doing leak ptr? (A comment may be in order.) The bridge destructs itself on the worker thread, and it shouldn't get deleted on the main thread. I added a comment there. > I didn't parse/grok the whole patch yet but I felt there were enough things here that it may be good to give this feedback now. Thanks. Could I expect more feedbacks then... :) 281076 16 67994 kinuko 2010-09-17 20:28:33 -0700 Created attachment 67994 Patch 281077 17 67995 kinuko 2010-09-17 20:50:49 -0700 Created attachment 67995 Patch Made a few more fixes. 281757 18 levin 2010-09-20 12:49:14 -0700 (In reply to comment #15) > > > WebCore/ChangeLog:1454 > > > + Added NoStaticTables and changed modulename from storage to fileapi: > > > > This change seems very misplaced. > > Hmm that's true I removed them from this patch. I'm going to file another issue. Actually I didn't mean that you needed a new patch. I mean the description in the ChangeLog was very misplaced. (It was ~100 lines below your change log entry in some random spot.) But I'm glad that you created a new patch which was really small. As much as you can break down your big patches into smaller ones, they will be easier to review, more thoroughly reviewed and each one will get through more quickly (though on the whole it may take a little longer). 281856 19 kinuko 2010-09-20 15:29:33 -0700 (In reply to comment #18) > (In reply to comment #15) > > > > WebCore/ChangeLog:1454 > > > > + Added NoStaticTables and changed modulename from storage to fileapi: > > > > > > This change seems very misplaced. > > > > Hmm that's true I removed them from this patch. I'm going to file another issue. > > Actually I didn't mean that you needed a new patch. I mean the description in the ChangeLog was very misplaced. (It was ~100 lines below your change log entry in some random spot.) But I'm glad that you created a new patch which was really small. Oh I see... resolve-ChangeLog somehow placed them at a random place. > As much as you can break down your big patches into smaller ones, they will be easier to review, more thoroughly reviewed and each one will get through more quickly (though on the whole it may take a little longer). Thanks, I'll try doing so. (This one might be still a bit larger) 281882 20 67995 levin 2010-09-20 16:15:20 -0700 Comment on attachment 67995 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67995&action=review Ok, I understand now. Just a few comments to address and then this can get in. Thanks! > WebCore/fileapi/LocalFileSystem.cpp:53 > +static LocalFileSystem* staticLocalFileSystem = 0; Why are you doing a singleton in this manner (as opposed to using a member variable with s_ prefix). > WebCore/page/DOMWindow.idl:-196 > - The only change to this file is a whitespace change? I would just omit this change from this patch. > WebCore/platform/AsyncFileSystem.cpp:44 > + // Each platform should implement this. Put a notImplemented() here (and include NotImplemented.h). (Doing this may make the comment redundant. Your choice.) > WebCore/platform/AsyncFileSystem.cpp:50 > + // Each platform should implement this. Ditto. > WebCore/workers/WorkerContext.h:128 > + // The code generator generates the code that performs compile-time enum checking with constant attributes defined in the idl and enum values in the header, and the enum names must match with the attribute names. I see that you put this in the bug and I didn't notice. I don't think either of these comments is necessary now (especially now that I understand it will general a compile time error if this is changed). Sorry to go back and forth on this. > WebCore/workers/WorkerContext.idl:112 > + attribute [EnabledAtRuntime=FileSystem] FlagsConstructor Flags; Typically attribute is indented to leave "space" for readonly. See the attributes at this top of this file. Sorry that this isn't done consistently in this idl. > WebKit/chromium/src/WebWorkerBase.cpp:121 > +// This class is used to post a openFileSystem request to the main thread and get called back for the request. This must be destructed on the worker thread. Single space after . in WK code. > WebKit/chromium/src/WebWorkerBase.cpp:122 > +class OpenFileSystemMainThreadBridge { How does "OpenFileSystemMainThreadBridge" get cleaned up if the Worker is terminated before the callback happens? It would be nice to add a comment about this. In fact, (although I've figure it out now), I think it would be nice to add a comment to explain how this works overall. > WebKit/chromium/src/WebWorkerBase.cpp:124 > + static void start(WebWorkerBase* worker, WebCommonWorkerClient* commonClient, const WTF::String& mode, WebFileSystem::Type type, long long size, WebFileSystemCallbacks* callbacks) Why is this getting put in WebWorkerBase.cpp (as opposed to its own file)? (I know one other class did that but I wouldn't follow its example.) Also as you do this, I suspect that you will move out methods out of this class definition that shouldn't be inlined. > WebKit/chromium/src/WebWorkerBase.cpp:219 > + OwnPtr<OpenFileSystemMainThreadBridge> bridge(bridgePtr); Why create this local variable? PassOwnPtr will do the destruction (and you can avoid the odd bridgePtr naming then). > WebKit/chromium/src/WebWorkerBase.cpp:227 > + OwnPtr<OpenFileSystemMainThreadBridge> bridge(bridgePtr); Ditto. > WebKit/chromium/src/WebWorkerBase.cpp:233 > + WTF::String m_mode; It would be better imo if m_mode were owned by MainThreadFileSystemCallbacks. Otherwise you are accessing it on the main thread in didFailOnMainThread/didOpenFileSystemOnMainThread but destroying it on the Worker thread. By making it part of MainThreadFileSystemCallbacks, it would get destroyed on the main thread as well. > WebKit/chromium/src/WebWorkerBase.cpp:234 > + WebFileSystemCallbacks* m_workerContextCallbacks; This name "m_workerContextCallbacks" doesn't seem good. When I read it, I think the variable is about callbacks from the worker context, but it isn't. It is about the file system callbacks (on the worker context?). Maybe m_callbacksOnWorkerContext? 282061 21 68182 kinuko 2010-09-20 20:48:54 -0700 Created attachment 68182 Patch 282068 22 68183 kinuko 2010-09-20 21:03:45 -0700 Created attachment 68183 Patch 282069 23 kinuko 2010-09-20 21:04:25 -0700 (In reply to comment #20) > (From update of attachment 67995 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67995&action=review > > > WebCore/fileapi/LocalFileSystem.cpp:53 > > +static LocalFileSystem* staticLocalFileSystem = 0; > Why are you doing a singleton in this manner (as opposed to using a member variable with s_ prefix). Changed to use a static member variable s_instance. (I had borrowed some code from DatabaseTracker, which does something similar to my previous patch.) > > WebCore/page/DOMWindow.idl:-196 > > - > The only change to this file is a whitespace change? > I would just omit this change from this patch. Fixed. > > WebCore/platform/AsyncFileSystem.cpp:44 > > + // Each platform should implement this. > Put a notImplemented() here (and include NotImplemented.h). (Doing this may make the comment redundant. Your choice.) > > > WebCore/platform/AsyncFileSystem.cpp:50 > > + // Each platform should implement this. > Ditto. Fixed. > > WebCore/workers/WorkerContext.h:128 > > + // The code generator generates the code that performs compile-time enum checking with constant attributes defined in the idl and enum values in the header, and the enum names must match with the attribute names. > > I see that you put this in the bug and I didn't notice. I don't think either of these comments is necessary now (especially now that I understand it will general a compile time error if this is changed). Sorry to go back and forth on this. Ok, I removed the comment now. > > WebCore/workers/WorkerContext.idl:112 > > + attribute [EnabledAtRuntime=FileSystem] FlagsConstructor Flags; > > Typically attribute is indented to leave "space" for readonly. See the attributes at this top of this file. Sorry that this isn't done consistently in this idl. Fixed. > > WebKit/chromium/src/WebWorkerBase.cpp:121 > > +// This class is used to post a openFileSystem request to the main thread and get called back for the request. This must be destructed on the worker thread. > > Single space after . in WK code. Fixed. > > WebKit/chromium/src/WebWorkerBase.cpp:122 > > +class OpenFileSystemMainThreadBridge { > > How does "OpenFileSystemMainThreadBridge" get cleaned up if the Worker is terminated before the callback happens? I made the Bridge subclass of ActiveDOMObject to get notified when the context is going to be stopped. (Does it make sense?) Also introduced a wrapper class that is shared by both treads and to be used as a weak reference to the bridge. > It would be nice to add a comment about this. > In fact, (although I've figure it out now), I think it would be nice to add a comment to explain how this works overall. > > WebKit/chromium/src/WebWorkerBase.cpp:124 > > + static void start(WebWorkerBase* worker, WebCommonWorkerClient* commonClient, const WTF::String& mode, WebFileSystem::Type type, long long size, WebFileSystemCallbacks* callbacks) > Why is this getting put in WebWorkerBase.cpp (as opposed to its own file)? (I know one other class did that but I wouldn't follow its example.) > Also as you do this, I suspect that you will move out methods out of this class definition that shouldn't be inlined. I moved the class into a separate class, WorkerFileSystemCallbacksBridge. > > WebKit/chromium/src/WebWorkerBase.cpp:219 > > + OwnPtr<OpenFileSystemMainThreadBridge> bridge(bridgePtr); > Why create this local variable? PassOwnPtr will do the destruction (and you can avoid the odd bridgePtr naming then). > > > WebKit/chromium/src/WebWorkerBase.cpp:227 > > + OwnPtr<OpenFileSystemMainThreadBridge> bridge(bridgePtr); > Ditto. Removed the local variables. Also changed the bridge class to RefCounted -- mainly for the future synchronous implementation. > > WebKit/chromium/src/WebWorkerBase.cpp:233 > > + WTF::String m_mode; > It would be better imo if m_mode were owned by MainThreadFileSystemCallbacks. > Otherwise you are accessing it on the main thread in didFailOnMainThread/didOpenFileSystemOnMainThread but destroying it on the Worker thread. Right... fixed. > > WebKit/chromium/src/WebWorkerBase.cpp:234 > > + WebFileSystemCallbacks* m_workerContextCallbacks; > > This name "m_workerContextCallbacks" doesn't seem good. When I read it, I think the variable is about callbacks from the worker context, but it isn't. It is about the file system callbacks (on the worker context?). > > Maybe m_callbacksOnWorkerContext? Fixed. 282185 24 68211 kinuko 2010-09-21 03:52:32 -0700 Created attachment 68211 Patch 282566 25 68211 levin 2010-09-21 14:39:34 -0700 Comment on attachment 68211 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68211&action=review > WebCore/platform/AsyncFileSystem.cpp:37 > +#include "NotImplemented.h" Out of order. (I wonder why the style bot didn't catch this. Maybe the #if ENABLE messed it up.) > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:65 > + MutexLocker locker(m_mutex); This doesn't work because didFailOnMainThread may have just been called and posted a task to the Worker thread. Here's a solution. Do the following: s/WorkerFileSystemCallbacksBridge/WorkerFileSystemCallbacks/ s/ThreadableCallbacksBridgeWrapper/WorkerFileSystemCallbacksBridge/ s/m_bridge/m_fileSystemCallbacks/ Move the post OnMainThread/OnWorkerThread methods into this class (now called WorkerFileSystemCallbacksBridge). Only use m_fileSystemCallbacks (formerly m_bridge) on the worker thread. You'll still need the m_mutex to guard m_worker which may be cleared from the worker thread but used on the main thread to post tasks. This model is similar to what "AllowDatabaseMainThreadBridge" is doing. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:142 > + PassRefPtr<ThreadableCallbacksBridgeWrapper> m_bridgeWrapper; PassRefPtr should only be used for function parameters. This should be RefPtr. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:45 > +class ThreadableCallbacksBridgeWrapper; Out of order. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:48 > +class WebWorkerBase; Out of order. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:63 > +class WorkerFileSystemCallbacksBridge : public WebCore::ActiveDOMObject, public RefCounted<WorkerFileSystemCallbacksBridge> { Interesting idea about the ActiveDOMObject. I've discussed it with dimich and he indicated that you get a lot of extra stuff that you may not want when you have an ActiveDOMObject. There are two ideas: 1. If this could be owned by a JS class. 2. If that isn't possible, then perhaps adding a callback to ~WorkerContext. You can find several similar things in ~ScriptExecutionContext (WebKit/WebCore/dom/ScriptExecutionContext.cpp) 282740 26 68328 kinuko 2010-09-21 19:34:57 -0700 Created attachment 68328 Patch 282741 27 68329 kinuko 2010-09-21 19:36:36 -0700 Created attachment 68329 Patch 282743 28 68330 kinuko 2010-09-21 19:59:32 -0700 Created attachment 68330 Patch Removed the code for other FS operations, that weren't meant to be added yet. 282745 29 kinuko 2010-09-21 20:00:12 -0700 Thanks for the iteration. (In reply to comment #25) > (From update of attachment 68211 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68211&action=review > > > WebCore/platform/AsyncFileSystem.cpp:37 > > +#include "NotImplemented.h" > Out of order. (I wonder why the style bot didn't catch this. Maybe the #if ENABLE messed it up.) Fixed. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:65 > > + MutexLocker locker(m_mutex); > This doesn't work because didFailOnMainThread may have just been called and posted a task to the Worker thread. > Here's a solution. Do the following: Fixed (not exactly as mentioned, but tried to follow the way). Turned WorkerFileSystemCallbacksBridge into ThreadSafeShared and changed its post methods to use mutex protected m_worker. No wrapper class for worker's callback, and is touched only on the worker thread. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:142 > > + PassRefPtr<ThreadableCallbacksBridgeWrapper> m_bridgeWrapper; > PassRefPtr should only be used for function parameters. This should be RefPtr. Gush, fixed. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:45 > > +class ThreadableCallbacksBridgeWrapper; > Out of order. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:48 > > +class WebWorkerBase; > Out of order. Fixed. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:63 > > +class WorkerFileSystemCallbacksBridge : public WebCore::ActiveDOMObject, public RefCounted<WorkerFileSystemCallbacksBridge> { > > Interesting idea about the ActiveDOMObject. I've discussed it with dimich and he indicated that you get a lot of extra stuff that you may not want when you have an ActiveDOMObject. > > There are two ideas: > 1. If this could be owned by a JS class. > 2. If that isn't possible, then perhaps adding a callback to ~WorkerContext. You can find several similar things in ~ScriptExecutionContext (WebKit/WebCore/dom/ScriptExecutionContext.cpp) Added a WorkerContext::Observer class whose instances are notified when the WorkerThread is stopping. (The class might be a bit overkilling) 282764 30 68338 kinuko 2010-09-21 21:35:53 -0700 Created attachment 68338 Patch Nits fixes 282770 31 68338 levin 2010-09-21 22:36:06 -0700 Comment on attachment 68338 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68338&action=review I almost r+'ed but it feels like there are enough little things to address that it would be good to check it over one last time after the adjustment. Thanks for your patience. It is almost all done! > WebCore/fileapi/LocalFileSystem.h:74 > String m_basePath; What about making a (private) nested class that has this string as a private member? Then access would be forced to got through its accessor. Something like this: class SystemBasePath { public: explicit SystemBasePath(string path) : m_value(path) { } string value() const { return m_value.threadsafeCopy(); } private: String m_value; }; SystemBasePath m_basePath; Then no need for a comment that people probably won't see when adding code or doing reviews :) > WebCore/workers/WorkerContext.cpp:116 > + HashSet<Observer*>::iterator observersEnd = m_workerObservers.end(); > + for (HashSet<Observer*>::iterator iter = m_workerObservers.begin(); iter != observersEnd; ++iter) > + (*iter)->stopObserving(); Just call notifyObserversOfStop. > WebCore/workers/WorkerContext.cpp:385 > + if (m_context) { Consider "fail fast" here. if (!m_context) return; > WebCore/workers/WorkerContext.cpp:386 > + ASSERT(m_context->isContextThread()); Why doesn't this do m_context->unregisterObserver(this); ? > WebCore/workers/WorkerContext.cpp:397 > + HashSet<Observer*>::iterator observersEnd = m_workerObservers.end(); > + for (HashSet<Observer*>::iterator iter = m_workerObservers.begin(); iter != observersEnd; ++iter) { > + (*iter)->notifyStop(); > + (*iter)->stopObserving(); > + } I would make this robust to unregisterObserver being called during notifyStop. For example, an object may delete itself :) Here's a simple change: HashSet<Observer*>::iterator iter = m_workerObservers.begin(); while (iter != m_workerObservers.end()) { (*iter)->notifyStop(); (*iter)->stopObserving(); iter = m_workerObservers.begin(); } Of course, there could be a pathological case in which an object adds something else when it gets the notifyStop but that seems highly unlikely. > WebCore/workers/WorkerContext.cpp:398 > + m_workerObservers.clear(); If the above is done, this should be already done. > WebCore/workers/WorkerContext.h:59 > + class WorkerWeakReference; This doesn't appear to be used (or defined). > WebCore/workers/WorkerContext.h:130 > + // They are placed here and in all capital letters to enforce compile-time enum checking. Is this comment useful? (If anyone tries to change this, they'll get a compile type error.) > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:120 > + if (m_callbacksOnWorkerThread) { How do you know that m_callbacksOnWorkerThread is still valid at this point? > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:126 > +void WorkerFileSystemCallbacksBridge::postOpenFileSystemOnMainThread(WebCommonWorkerClient* commonClient, WebFileSystem::Type type, long long size, const String& mode) Consider making the name postOpenFileSystemToMainThread. OnXThread is being used for methods that run on Thread X but this method is to push something to the main thread. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:134 > +{ Please consider adding asserts to verify that things are called on the correct thread: ASSERT(isMainThread()); and ASSERT(m_worker->isContextThread()); > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:145 > + mayPostTaskToWorker(createCallbackTask(&didFailOnWorkerThread, this, error), mode); I believe you can change s/this/this->m_selfRef.releaseRef()/ and the remove all of the clear calls. or you may only be able to do s/this/this->m_selfRef/ (and just have one clear call in mayPostTaskToWorker). (I should make the former possible in the future if it isn't currently.) (here and in didOpenFileSystemOnMainThread) > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:153 > +void WorkerFileSystemCallbacksBridge::didFailOnWorkerThread(ScriptExecutionContext*, WorkerFileSystemCallbacksBridge* bridge, WebFileError error) s/WorkerFileSystemCallbacksBridge*/PassRefPtr<WorkerFileSystemCallbacksBridge>/ ditto for didOpenFileSystemOnWorkerThread 283325 32 68463 kinuko 2010-09-22 16:00:05 -0700 Created attachment 68463 Patch 283335 33 68467 kinuko 2010-09-22 16:13:41 -0700 Created attachment 68467 Patch 283336 34 kinuko 2010-09-22 16:14:45 -0700 Thanks, updated. (In reply to comment #31) > (From update of attachment 68338 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68338&action=review > > WebCore/fileapi/LocalFileSystem.h:74 > > String m_basePath; > > What about making a (private) nested class that has this string as a private member? Then access would be forced to got through its accessor. > Something like this: > class SystemBasePath { ... Sounds a good idea. Fixed. > > WebCore/workers/WorkerContext.cpp:116 > > + HashSet<Observer*>::iterator observersEnd = m_workerObservers.end(); > > + for (HashSet<Observer*>::iterator iter = m_workerObservers.begin(); iter != observersEnd; ++iter) > > + (*iter)->stopObserving(); > Just call notifyObserversOfStop. Fixed. > > WebCore/workers/WorkerContext.cpp:385 > > + if (m_context) { > Consider "fail fast" here. Fixed. > > WebCore/workers/WorkerContext.cpp:386 > > + ASSERT(m_context->isContextThread()); > > Why doesn't this do > m_context->unregisterObserver(this); > ? Fixed. (I wondered the same thing when I was self-reviewing... :)) > > WebCore/workers/WorkerContext.cpp:397 > > + HashSet<Observer*>::iterator observersEnd = m_workerObservers.end(); > > + for (HashSet<Observer*>::iterator iter = m_workerObservers.begin(); iter != observersEnd; > ... > I would make this robust to unregisterObserver being called during notifyStop. For example, an object may delete itself :) Right. Fixed. > > WebCore/workers/WorkerContext.h:59 > > + class WorkerWeakReference; > This doesn't appear to be used (or defined). Removed. > > WebCore/workers/WorkerContext.h:130 > > + // They are placed here and in all capital letters to enforce compile-time enum checking. > Is this comment useful? (If anyone tries to change this, they'll get a compile type error.) Removed. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:120 > > + if (m_callbacksOnWorkerThread) { > How do you know that m_callbacksOnWorkerThread is still valid at this point? 'Not owned' comment was wrong... it is self-destructed too and the bridge has the responsibility to call any of the callbacks (and the pointer itself should be valid until the bridge fires it). > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:126 > > +void WorkerFileSystemCallbacksBridge::postOpenFileSystemOnMainThread(WebCommonWorkerClient* commonClient, WebFileSystem::Type type, long long size, const String& mode) > Consider making the name postOpenFileSystemToMainThread. > OnXThread is being used for methods that run on Thread X but this method is to push something to the main thread. Fixed. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:134 > > +{ > Please consider adding asserts to verify that things are called on the correct thread: > ASSERT(isMainThread()); and ASSERT(m_worker->isContextThread()); Added. > > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:145 > > + mayPostTaskToWorker(createCallbackTask(&didFailOnWorkerThread, this, error), mode); > > I believe you can change s/this/this->m_selfRef.releaseRef()/ and the remove all of the clear calls. > or you may only be able to do s/this/this->m_selfRef/ (and just have one clear call in mayPostTaskToWorker). (I should make the former possible in the future if it isn't currently.) Ah that's sweet. Seems like the former doesn't work for now, so I changed the code to pass this->m_selfRef and left only one m_selfRef.clear in mayPostTaskToWorker. 283393 35 68467 levin 2010-09-22 17:40:31 -0700 Comment on attachment 68467 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68467&action=review I have a few comments which you can address on landing. Also, *please* get an ok from Darin Fisher on the change to WebKit/chromium/public/WebCommonWorkerClient.h before landing. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:103 > +WorkerFileSystemCallbacksBridge::WorkerFileSystemCallbacksBridge(WebWorkerBase* worker, ScriptExecutionContext* scriptExecutionContext, WebFileSystemCallbacks* callbacks) Consider moving this to be sorted in the same order as the header. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:107 > +{ Please add ASSERT(scriptExecutionContext->isContextThread()); > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:110 > +WorkerFileSystemCallbacksBridge::~WorkerFileSystemCallbacksBridge() Please move this if you move it in the header. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:147 > +{ please add ASSERT(isMainThread()); > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:152 > +{ please add ASSERT(isMainThread()); > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.cpp:180 > + MutexLocker locker(m_mutex); > + if (m_worker) > + m_worker->postTaskForModeToWorkerContext(task, mode); > + m_selfRef.clear(); Please fix this code like this: { // Let go of the mutex before possibly deleting this due to m_selfRef.clear(). MutexLocker locker(m_mutex); if (m_worker) m_worker->postTaskForModeToWorkerContext(task, mode); } m_selfRef.clear(); > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:50 > +struct WebFileInfo; I would put struct after class (sorting the whole string). > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:73 > + ~WorkerFileSystemCallbacksBridge(); fwiw, I would consider making this private and making ThreadSafeShared<WorkerFileSystemCallbacksBridge> a friend (like what is done in chromium for ref counted classes). > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:83 > + // Method that posts an initial request task to the main thread. It is supposed to be called immediately after the bridge is constructed (it doesn't check if the context has been stopped or not). Consider "constructed. (It doesn't ... not.)" Also I'd remove "Method that" here. > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:103 > + // Helper method. Does this comment add anything? (If you want to add something information, fine, but this doesn't seem to be.) > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:106 > + // m_selfRef keeps a reference to itself until callbacks are fired on the worker thread. until tasks are created for the worker thread (at which point the tasks hold the reference). 283513 36 68467 levin 2010-09-22 21:53:21 -0700 Comment on attachment 68467 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68467&action=review One more important change: > WebCore/workers/WorkerContext.cpp:407 > + (*iter)->notifyStop(); > + (*iter)->stopObserving(); (I know I wrote this code but) It isn't quite correct. notifyStop may result in the object being deleted in which case calling stopObserving is really bad. Instead I would suggest WorkerContext::Observer* observer = *iter; m_workerObservers.remove(iter); // It is ok to remove the observer directly because unregisterObserver is ok with the observer not being in m_workerObservers. observer->notifyStop(); 283687 37 68467 fishd 2010-09-23 09:20:24 -0700 Comment on attachment 68467 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68467&action=review > WebKit/chromium/public/WebCommonWorkerClient.h:90 > + virtual void openFileSystem(WebFileSystem::Type, long long size, WebFileSystemCallbacks*) it is actually convention in the webkit API that methods, to be implemented by the embedder, have default implementations. 284004 38 fishd 2010-09-23 15:11:46 -0700 (In reply to comment #37) > (From update of attachment 68467 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68467&action=review > > > WebKit/chromium/public/WebCommonWorkerClient.h:90 > > + virtual void openFileSystem(WebFileSystem::Type, long long size, WebFileSystemCallbacks*) > > it is actually convention in the webkit API that methods, to be implemented by the embedder, have default implementations. This means that you can remove the FIXME comment, and i agree with this addition to WebCommonWorkerClient. Thanks! 284042 39 68608 kinuko 2010-09-23 15:36:22 -0700 Created attachment 68608 Patch 284050 40 68610 kinuko 2010-09-23 15:47:22 -0700 Created attachment 68610 Patch 284053 41 68610 levin 2010-09-23 15:56:24 -0700 Comment on attachment 68610 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68610&action=review Two trivial suggestions. > WebCore/workers/WorkerContext.h:157 > + void registerObserver(Observer* observer); > + void unregisterObserver(Observer* observer); Remove param name "observer". > WebKit/chromium/src/WorkerFileSystemCallbacksBridge.h:107 > + // m_selfRef keeps a reference to itself until tasks are created for the worker thread (at which point the tasks hold the reference). My typo s/tasks/task/ 284151 42 kinuko 2010-09-23 17:46:23 -0700 Committed r68222: <http://trac.webkit.org/changeset/68222> 67649 2010-09-15 00:26:01 -0700 2010-09-15 00:41:54 -0700 Patch bug-45808-20100915002559.patch text/plain 24296 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MmMyM2YxYjRhMmYzMjEwOTI1YTA2MDgxNTU5MTMwNGJiMWM1OGQ4Yy4uMDA0NTFjNjE5ZTMyYWU2 ZTBmNDRjOTliN2UyN2Y3ZjEyMzFlYTVhNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNCBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKToKKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAg ICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKToKKyAgICAg ICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAgICAg ICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmg6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZp bGVTeXN0ZW06On5Mb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAqIHBhZ2UvRE9NV2luZG93LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAg ICAgICAqIHBhZ2UvRE9NV2luZG93Lmg6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuaWRsOgor ICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuaDoK KyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiB3b3Jr ZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaWRs OgorCiAyMDEwLTA5LTE0ICBLaW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBSZXZpZXdlZCBieSBEdW1pdHJ1IERhbmlsaXVjLgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxl U3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2 Li4wOGZhZDQ2ZmViNzYwMjY1Y2QzZGY3OThkNTdmZmQwZmQ2MDg2OWFiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9XZWJDb3JlL2ZpbGVhcGkv TG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMjkgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVh dGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2NhbEZpbGVTeXN0ZW0qIHN0YXRp Y0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXpl TG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCit7CisgICAgLy8gRklYTUU6 IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAgIEFTU0VS VCghc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICBpZiAoc3RhdGljTG9jYWxGaWxlU3lzdGVt KQorICAgICAgICByZXR1cm47CisKKyAgICBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKTsKK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVT eXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgaWYgKCFzdGF0aWNMb2NhbEZpbGVTeXN0 ZW0pCisgICAgICAgIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IG5ldyBMb2NhbEZpbGVTeXN0ZW0o IiIpOworCisgICAgcmV0dXJuICpzdGF0aWNMb2NhbEZpbGVTeXN0ZW07Cit9CisKK1N0cmluZyBM b2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJu IGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9i YXNlUGF0aC50aHJlYWRzYWZlQ29weSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3Rl bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3Qg U3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0 cjxGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OCw3IEBAIHZvaWQg TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVu RmlsZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBu ZWVkcyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2so Y3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+ c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lz dGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsK KyAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVt LCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJh c2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxs YmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJl YTY4Y2Q1MjNkYmI2Li5iMGJmYzQwYjA0MWJhMDA0OGY3N2M0ZjhlNjEwM2IzODU0YzAxNjMzIDEw MDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29y ZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJy b3JDYWxsYmFjazsKIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ7CiAKLWNsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVk PExvY2FsRmlsZVN5c3RlbT4geworLy8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5k IHByb3ZpZGVzIGFuIGVudHJ5IHBvaW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExv Y2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGlj IFBhc3NSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0 aCk7Ci0gICAgdmlydHVhbCB+TG9jYWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBh IHBlci1wcm9jZXNzIGluc3RhbmNlIG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRo YXQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2Fs bGVkIHRvCisgICAgLy8gaW5pdGlhbGl6ZSB0aGUgYmFzZSBwYXRoLgorICAgIHN0YXRpYyBMb2Nh bEZpbGVTeXN0ZW0mIGxvY2FsRmlsZVN5c3RlbSgpOwogCiAgICAgdm9pZCByZXF1ZXN0RmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlLCBsb25n IGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPEVy cm9yQ2FsbGJhY2s+KTsKIAotcHJvdGVjdGVkOgorI2lmICFQTEFURk9STShDSFJPTUlVTSkKKyAg ICAvLyBUaGlzIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNy ZWF0ZWQuCisgICAgdm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYp OworCisgICAgU3RyaW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3By aXZhdGU6CiAgICAgTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAg ICAgIDogbV9iYXNlUGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgfkxvY2FsRmls ZVN5c3RlbSgpIHsgfQorCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2RzIHNob3VsZG4ndCBhY2Nl c3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAgICAvLyBmaWxlU3lzdGVt QmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRoOwogfTsKIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93 LmNwcAppbmRleCAxNWYzZWQxODBlNmZjN2M1MmNlZTI5MDBmNTU0MmM2ODFiZWE4YmQ5Li44ZjFk YzViZDRlNTA1Yzg0NThmZTdkODY3YTJiMTJiMjM4NzRjZmFjIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAt ODksNyArODksNiBAQAogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogI2luY2x1ZGUgIkFzeW5j RmlsZVN5c3RlbS5oIgotI2luY2x1ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlICJFcnJv ckNhbGxiYWNrLmgiCiAjaW5jbHVkZSAiRmlsZUVycm9yLmgiCiAjaW5jbHVkZSAiRmlsZVN5c3Rl bUNhbGxiYWNrLmgiCkBAIC03MjcsMjEgKzcyNiw5IEBAIHZvaWQgRE9NV2luZG93OjpyZXF1ZXN0 RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3Rl CiAgICAgaWYgKCFkb2N1bWVudCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgaWYgKCFtX2xvY2Fs RmlsZVN5c3RlbSkgewotICAgICAgICAvLyBGSVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2Vk LgotCi0gICAgICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgICAgICBpZiAo IXBhZ2UpIHsKLSAgICAgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9j dW1lbnQsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKElOVkFMSURfU1RBVEVfRVJS KSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBGSVhNRTog R2V0IHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgotICAgICAgICBTdHJpbmcgcGF0aCA9IHBh Z2UtPnNldHRpbmdzKCktPmZpbGVTeXN0ZW1Sb290UGF0aCgpOwotICAgICAgICBtX2xvY2FsRmls ZVN5c3RlbSA9IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKHBhdGgpOwotICAgIH0KKyAgICAvLyBG SVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2VkLgogCi0gICAgbV9sb2NhbEZpbGVTeXN0ZW0t PnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06 OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAg IExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0oZG9j dW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1 Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7CiB9CiAKIENPTVBJTEVfQVNTRVJUKGludChE T01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwg ZW51bV9taXNtYXRjaCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmggYi9X ZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZiMjE4 NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAzYSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xh c3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3RvclRp bWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExvY2F0 aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAtNDQ0 LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRB QkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5Owog I2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFyZ2V0 RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5pZGwgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAppbmRleCA3ZTQ4ZjhjNTMxMTJi NmUwMzE3ZTExMjVhZjUxYjBmOTM1MzM0ZjEzLi4wNTMwMjUwMzY0MTU4ZGI1NWJjYjgzODI3MzA5 M2NmYmU4MGRiMzE2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbApAQCAtMTkzLDcgKzE5Myw2IEBAIG1vZHVsZSB3 aW5kb3cgewogICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBURU1QT1JBUlkgPSAwOwogICAg ICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0gMTsKICAgICAgICAgW0VuYWJs ZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4gdW5zaWduZWQgc2hvcnQgdHlw ZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEZpbGVTeXN0ZW1D YWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEVycm9yQ2Fs bGJhY2sgZXJyb3JDYWxsYmFjayk7Ci0KICAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50 aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0b3IgRmxhZ3M7CiAjZW5kaWYKIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5j cHAKaW5kZXggMzI5YzQ3ZjM5ZDE2MjEzNzc0MTYwOGZiNDFhMWYwMGU3ODk2OGYxMi4uZTM0NjA2 OTAzMzE3ZDIyMTNhZWIyZDM3M2ZmMGY0M2JlMTE5NmIzZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTAs MTEgKzQ5MCw2IEBAIHZvaWQgU2V0dGluZ3M6OnNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChj b25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRo OwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5n JiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJvb3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBT ZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVNb2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2lu QXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggOGVjNTEwNmJmNDRkNWEy NjczN2E4ZjM4MTk2Y2ZjNTcyNGU1ODE1ZC4uN2Y1ZmY3YTEzZDAyMmNmYmE4MGZkN2Y5M2FlZWVk ZmUzOTdlNGYwNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTIzOSw5ICsyMzksNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmlu ZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNv bnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9p ZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0 cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9v dFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsK ICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1f aW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApAQCAtMzMxLDcgKzMyOCw2IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1fZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAg ICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRlbXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5n IG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwotICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVt Um9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2VyU3R5bGVTaGVldExvY2F0aW9uOwogICAgICAg ICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRGYW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmlu ZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJi Mjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi5iYjEwNjMwNzQ0YzUzMDVkZGU0 NmNjNTM1YzkzYTk5ZTIxMzBhOWUzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02 Myw2ICs2MywxNCBAQAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAK KyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisj aW5jbHVkZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1 ZGUgIkZpbGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgor I2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3JrZXJDb250ZXh0 VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAgLTMzNSw2ICsz NDMsMTggQEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYg YmxvYlVSTFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQordm9p ZCBXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNp emUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NS ZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICAvLyBGSVhNRTogc2Vl IGlmIGFjY2VzcyBpcyBhbGxvd2VkLgorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVT eXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0 ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwor fQorCitDT01QSUxFX0FTU0VSVChpbnQoV29ya2VyQ29udGV4dDo6VEVNUE9SQVJZKSA9PSBpbnQo QXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNT RVJUKGludChXb3JrZXJDb250ZXh0OjpQRVJTSVNURU5UKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVt OjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAppbmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi44ZDJmNTE5 ZDI1NzQxYzg2NWIwZjkwNjllOGVmY2NlODVmNzM1OTc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dv cmtlcnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0 LmgKQEAgLTQ3LDYgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFi YXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5j OworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNr OwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rp b247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTIzLDE1IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYp OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIC8vIFRoZXkgYXJl IHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGls ZS10aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5c3RlbVR5cGUgeworICAg ICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVOVCwKKyAgICAgICAgfTsK KyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUs IFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNr Pik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBt YXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4K ICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2 aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdl dCgpOyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwgYi9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRhZGI4OGJjMmRmNjdm MjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uOWM5ZWVjMGU4NDFhMjNlNjA1MDVmMzU3ZDM5YTAyNGRl ODFjNGIzNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCisr KyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0LDYgKzEwNCwxMyBA QCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVCbG9iVVJMKGluIEJs b2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01TdHJpbmcgYmxvYlVS TCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVNKSAmJiBFTkFCTEVf RklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVNUE9SQVJZID0gMDsK KyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7CisgICAgICAgIFtF bmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVuc2lnbmVkIHNob3J0 IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBGaWxlU3lz dGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBFcnJv ckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1 bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07 CiAKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCmluZGV4IGIyYjkyMTRiM2ZkOTAxNzgwZDVjZDVkNDA0YjQ0MWJjZTU5 YjIyOTEuLjdiYzgyNDAwMTMzMzdiMjE0ZWY4ZjZjYzg5NmViMWRjNmNjNWFhZTMgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTA5LTE1ICBLaW51a28gWWFzdWRhICA8a2ludWtv QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0gQVBJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgwOAorCisgICAgICAgICog cHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21t b25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xv Y2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5 c3RlbTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4K KyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJD bGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5G aWxlU3lzdGVtKTogQWRkZWQuCisKIDIwMTAtMDktMTQgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJl dmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2 NzUwMy4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5o CmluZGV4IGNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQuLmQ5ZDE2YzYz MTEwNzg2ODM4NmQzY2UyMGM4NWVjYzBiYzY5MDY4OTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzEsNiArMzEsOSBAQAogI2lmbmRl ZiBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogI2RlZmluZSBXZWJDb21tb25Xb3JrZXJDbGllbnRf aAogCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgor CiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CkBA IC04Myw2ICs4NiwxMyBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtp dCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCiAgICAgdmlydHVhbCBib29s IGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdl YlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgPSAwOwog CisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcg YSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUq LCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50 YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVtZW50IHRoaXMuCisgICAgICAg IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKIHByb3RlY3RlZDoKICAgICB+ V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCA0NTM2NWVmMmU2NzlkOTkwYmIzYWVi ZGYzZWNhOWNlODIyMGYyNWIyLi45OTg0M2VhYTk5YzQyMDUwYzQ1MTI4NjQyYTAwNDU1MGM5YTY3 OGRiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9t aXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVt LmNwcApAQCAtNDIsMTQgKzQyLDE4IEBACiAjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNr c0ltcGwuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1l SW1wbC5oIgorI2luY2x1ZGUgIldlYldvcmtlckltcGwuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250 ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJL aXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0aCkKK0xvY2FsRmlsZVN5 c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogewotICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBERUZJTkVfU1RBVElDX0xP Q0FMKExvY2FsRmlsZVN5c3RlbSwgbG9jYWxGaWxlU3lzdGVtLCAoIiIpKTsKKyAgICByZXR1cm4g bG9jYWxGaWxlU3lzdGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVT eXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4g c3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2sp CkBAIC02MCw3ICs2NCwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0 ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJG cmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZy YW1lKCkpOwogICAgICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZy YW1lLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdl YkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAg ICAvLyBGSVhNRTogQWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3Jr ZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNv bnRleHQpOworICAgICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAm d29ya2VyQ29udGV4dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdl YldvcmtlckJhc2UqIHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3Jr ZXJMb2FkZXJQcm94eSk7CisgICAgICAgIHdlYldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oMCwgc3Rh dGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lz dGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ss IGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcAppbmRleCA0MmY0MWQyZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgz OTU1ZTJlLi4zMDkwZDU0YjU3YTA1ZTcxNmZjMjUxZTE3ZTBlZmQxZDkxNDkwNWY1IDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTM3LDYgKzM3LDggQEAKICNpbmNsdWRl ICJQbGF0Zm9ybU1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJj ZUltcGwuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lz dGVtQ2FsbGJhY2tzLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJX ZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJNZXNzYWdlUG9ydENoYW5uZWwuaCIKQEAgLTU2 LDYgKzU4LDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKIHN0 YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUi Oworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0ZW1Nb2RlW10gPSAib3BlbkZpbGVTeXN0 ZW1Nb2RlIjsKKwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiArMTE4LDEwNSBAQCBwcml2YXRl OgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5nIG1fbW9kZTsK IH07CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVx dWVzdCB0byB0aGUgbWFpbiB0aHJlYWQuCisvLyBUaGlzIG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0 aGUgd29ya2VyIHRocmVhZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSB7 CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgc3RhcnQoV2ViV29ya2VyQmFzZSogd29ya2VyLCBX ZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25z dCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAg Ly8gVGhpcyBjbGFzcyBpcyBzZWxmLWRlc3RydWN0ZWQuCisgICAgICAgIEFTU0VSVChuZXcgT3Bl bkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgY29tbW9uQ2xpZW50LCBmcmFtZSwg bW9kZSwgdHlwZSwgc2l6ZSwgY2FsbGJhY2tzKSk7CisgICAgfQorCisgICAgfk9wZW5GaWxlU3lz dGVtTWFpblRocmVhZEJyaWRnZSgpCisgICAgeworICAgICAgICBBU1NFUlQoIW1fd29ya2VyQ29u dGV4dENhbGxiYWNrcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIE9wZW5GaWxlU3lzdGVtTWFp blRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdlYkNvbW1vbldvcmtlckNsaWVu dCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2Rl LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVt Q2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAg ICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNrcyhjYWxsYmFja3MpCisgICAgICAgICwgbV9tb2Rl KG1vZGUpCisgICAgeworICAgICAgICB3b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCB3b3JrZXIsIGNv bW1vbkNsaWVudCwgZnJhbWUsIHR5cGUsIHNpemUsIHRoaXMpKTsKKyAgICB9CisKKyAgICBzdGF0 aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJDbGllbnQq IGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUs IGxvbmcgbG9uZyBzaXplLCBQYXNzT3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRn ZT4gYnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisgICAgICAgICAg ICBicmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAg ICBlbHNlCisgICAgICAgICAgICBjb21tb25DbGllbnQtPm9wZW5GaWxlU3lzdGVtKGZyYW1lLCB0 eXBlLCBzaXplLCBuZXcgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoYnJpZGdlKSk7Cisg ICAgfQorCisgICAgLy8gRmlsZVN5c3RlbUNhbGxiYWNrcyB0aGF0IGFyZSBkaXNwYXRjaGVkIG9u IHRoZSBtYWluIHRocmVhZC4KKyAgICBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNr cyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKKyAgICBwdWJsaWM6CisgICAgICAg IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1N YWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkK KyAgICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB+TWFpblRocmVhZEZpbGVT eXN0ZW1DYWxsYmFja3MoKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAobV9icmlkZ2UpCisg ICAgICAgICAgICAgICAgZGlkRmFpbChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIH0KKwor ICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgV2ViU3RyaW5nJiBu YW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgICAgIHsKKyAgICAgICAgICAgIEFTU0VS VChtX2JyaWRnZSk7CisgICAgICAgICAgICBtX2JyaWRnZS5sZWFrUHRyKCktPmRpZE9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgpOworICAgICAgICAgICAgZGVsZXRlIHRoaXM7 CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJyb3Ig ZXJyb3IpCisgICAgICAgIHsKKyAgICAgICAgICAgIEFTU0VSVChtX2JyaWRnZSk7CisgICAgICAg ICAgICBtX2JyaWRnZS5sZWFrUHRyKCktPmRpZEZhaWxPbk1haW5UaHJlYWQoZXJyb3IpOworICAg ICAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQg ZGlkU3VjY2VlZCgpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisgICAgICAgIHZp cnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgV2ViRmlsZUluZm8mKSB7IFdFQktJVF9B U1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZERpcmVj dG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYsIGJvb2wpIHsgV0VCS0lU X0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKKyAgICBwcml2YXRlOgorICAgICAgICBPd25QdHI8 T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBtX2JyaWRnZTsKKyAgICB9OworICAgIGZy aWVuZCBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKKworICAgIHN0YXRpYyB2 b2lkIGRpZEZhaWxPbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc093blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZVB0ciwg V2ViRmlsZUVycm9yIGVycm9yKQorICAgIHsKKyAgICAgICAgT3duUHRyPE9wZW5GaWxlU3lzdGVt TWFpblRocmVhZEJyaWRnZT4gYnJpZGdlKGJyaWRnZVB0cik7CisgICAgICAgIGJyaWRnZS0+bV93 b3JrZXJDb250ZXh0Q2FsbGJhY2tzLT5kaWRGYWlsKGVycm9yKTsKKyAgICAgICAgYnJpZGdlLT5t X3dvcmtlckNvbnRleHRDYWxsYmFja3MgPSAwOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGRp ZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2VQ dHIsIGNvbnN0IFdURjo6U3RyaW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgp CisgICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBi cmlkZ2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRDYWxsYmFj a3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdlLT5t X3dvcmtlckNvbnRleHRDYWxsYmFja3MgPSAwOworICAgIH0KKworICAgIHZvaWQgZGlkRmFpbE9u TWFpblRocmVhZChXZWJGaWxlRXJyb3IgZXJyb3IpCisgICAgeworICAgICAgICBtX3dvcmtlci0+ cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFp bE9uV29ya2VyVGhyZWFkLCB0aGlzLCBlcnJvciksIG1fbW9kZSk7CisgICAgfQorCisgICAgdm9p ZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwg Y29uc3QgV1RGOjpTdHJpbmcmIHJvb3RQYXRoKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPnBv c3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZE9wZW5G aWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQsIHRoaXMsIG5hbWUsIHJvb3RQYXRoKSwgbV9tb2RlKTsK KyAgICB9CisKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBXZWJGaWxlU3lzdGVt Q2FsbGJhY2tzKiBtX3dvcmtlckNvbnRleHRDYWxsYmFja3M7CisgICAgV1RGOjpTdHJpbmcgbV9t b2RlOworfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbiB0aGUgbWFpbiB0 aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwpAQCAtMjMxLDYgKzMzNCwx MyBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBX ZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVybiBicmlkZ2UtPnJlc3VsdCgp OwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2Vi RmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyogY2FsbGJhY2tzKQoreworICAgIC8vIFRoZSBGcmFtZSBpcyB1c2VkIG9ubHkgdG8gY2hl Y2sgdGhlIHNlY3VyaXR5IG9yaWdpbi4gIFRoZSBmcmFtZSBiYXNpY2FsbHkgYmVsb25ncyB0byB0 aGUgbWFpbiB0aHJlYWQgc28gaGVyZSB3ZSBwYXNzIHRoZSBmcmFtZSBwb2ludGVyIHRvIHRoZSBt YWluIHRocmVhZCAocmF0aGVyIHRoYW4gaXRzIG9yaWdpbikuCisgICAgQVNTRVJUKG1fd2ViVmll dyk7CisgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlOjpzdGFydCh0aGlzLCBjb21t b25DbGllbnQoKSwgbV93ZWJWaWV3LT5tYWluRnJhbWUoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0 eXBlLCBzaXplLCBjYWxsYmFja3MpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2 b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFz ZS5oCmluZGV4IDIyNzExZjlmMjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLmU5OGRh ZjE4ZjBlYTE2MmE5YWJjZjg4NWE5NDRkMmY1ZGZlOWY5MTQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQmFzZS5oCkBAIC05MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3 aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2Vy LgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3Ry aW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVz dGltYXRlZFNpemUpOwogCisgICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZv ciB0aGlzIHdvcmtlci4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUq LCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyopOworCiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhy ZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRy PFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRi MDk5OWZiMjA3NjUyYTVmNTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRj N2QyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwu aAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMs OCArMzMsOCBAQAogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lz dGVtLmgiCiAjaW5jbHVkZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJD b250ZXh0UHJveHkuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KQEAgLTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05P VF9SRUFDSEVEKCk7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZv aWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxv bmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsKKyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2Vy Q2xpZW50SW1wbCgpOwo= 67651 2010-09-15 00:41:57 -0700 2010-09-15 15:13:02 -0700 Patch bug-45808-20100915004156.patch text/plain 24137 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MmMyM2YxYjRhMmYzMjEwOTI1YTA2MDgxNTU5MTMwNGJiMWM1OGQ4Yy4uMDA0NTFjNjE5ZTMyYWU2 ZTBmNDRjOTliN2UyN2Y3ZjEyMzFlYTVhNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNCBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKToKKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAg ICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKToKKyAgICAg ICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAgICAg ICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmg6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZp bGVTeXN0ZW06On5Mb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAqIHBhZ2UvRE9NV2luZG93LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAg ICAgICAqIHBhZ2UvRE9NV2luZG93Lmg6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuaWRsOgor ICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuaDoK KyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiB3b3Jr ZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaWRs OgorCiAyMDEwLTA5LTE0ICBLaW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBSZXZpZXdlZCBieSBEdW1pdHJ1IERhbmlsaXVjLgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxl U3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2 Li4wOGZhZDQ2ZmViNzYwMjY1Y2QzZGY3OThkNTdmZmQwZmQ2MDg2OWFiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9XZWJDb3JlL2ZpbGVhcGkv TG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMjkgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVh dGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2NhbEZpbGVTeXN0ZW0qIHN0YXRp Y0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXpl TG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCit7CisgICAgLy8gRklYTUU6 IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAgIEFTU0VS VCghc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICBpZiAoc3RhdGljTG9jYWxGaWxlU3lzdGVt KQorICAgICAgICByZXR1cm47CisKKyAgICBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKTsKK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVT eXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgaWYgKCFzdGF0aWNMb2NhbEZpbGVTeXN0 ZW0pCisgICAgICAgIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IG5ldyBMb2NhbEZpbGVTeXN0ZW0o IiIpOworCisgICAgcmV0dXJuICpzdGF0aWNMb2NhbEZpbGVTeXN0ZW07Cit9CisKK1N0cmluZyBM b2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJu IGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9i YXNlUGF0aC50aHJlYWRzYWZlQ29weSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3Rl bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3Qg U3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0 cjxGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OCw3IEBAIHZvaWQg TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVu RmlsZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBu ZWVkcyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2so Y3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+ c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lz dGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsK KyAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVt LCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJh c2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxs YmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJl YTY4Y2Q1MjNkYmI2Li5iMGJmYzQwYjA0MWJhMDA0OGY3N2M0ZjhlNjEwM2IzODU0YzAxNjMzIDEw MDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29y ZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJy b3JDYWxsYmFjazsKIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ7CiAKLWNsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVk PExvY2FsRmlsZVN5c3RlbT4geworLy8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5k IHByb3ZpZGVzIGFuIGVudHJ5IHBvaW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExv Y2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGlj IFBhc3NSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0 aCk7Ci0gICAgdmlydHVhbCB+TG9jYWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBh IHBlci1wcm9jZXNzIGluc3RhbmNlIG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRo YXQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2Fs bGVkIHRvCisgICAgLy8gaW5pdGlhbGl6ZSB0aGUgYmFzZSBwYXRoLgorICAgIHN0YXRpYyBMb2Nh bEZpbGVTeXN0ZW0mIGxvY2FsRmlsZVN5c3RlbSgpOwogCiAgICAgdm9pZCByZXF1ZXN0RmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlLCBsb25n IGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPEVy cm9yQ2FsbGJhY2s+KTsKIAotcHJvdGVjdGVkOgorI2lmICFQTEFURk9STShDSFJPTUlVTSkKKyAg ICAvLyBUaGlzIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNy ZWF0ZWQuCisgICAgdm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYp OworCisgICAgU3RyaW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3By aXZhdGU6CiAgICAgTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAg ICAgIDogbV9iYXNlUGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgfkxvY2FsRmls ZVN5c3RlbSgpIHsgfQorCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2RzIHNob3VsZG4ndCBhY2Nl c3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAgICAvLyBmaWxlU3lzdGVt QmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRoOwogfTsKIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93 LmNwcAppbmRleCAxNWYzZWQxODBlNmZjN2M1MmNlZTI5MDBmNTU0MmM2ODFiZWE4YmQ5Li44ZjFk YzViZDRlNTA1Yzg0NThmZTdkODY3YTJiMTJiMjM4NzRjZmFjIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAt ODksNyArODksNiBAQAogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogI2luY2x1ZGUgIkFzeW5j RmlsZVN5c3RlbS5oIgotI2luY2x1ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlICJFcnJv ckNhbGxiYWNrLmgiCiAjaW5jbHVkZSAiRmlsZUVycm9yLmgiCiAjaW5jbHVkZSAiRmlsZVN5c3Rl bUNhbGxiYWNrLmgiCkBAIC03MjcsMjEgKzcyNiw5IEBAIHZvaWQgRE9NV2luZG93OjpyZXF1ZXN0 RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3Rl CiAgICAgaWYgKCFkb2N1bWVudCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgaWYgKCFtX2xvY2Fs RmlsZVN5c3RlbSkgewotICAgICAgICAvLyBGSVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2Vk LgotCi0gICAgICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgICAgICBpZiAo IXBhZ2UpIHsKLSAgICAgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9j dW1lbnQsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKElOVkFMSURfU1RBVEVfRVJS KSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBGSVhNRTog R2V0IHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgotICAgICAgICBTdHJpbmcgcGF0aCA9IHBh Z2UtPnNldHRpbmdzKCktPmZpbGVTeXN0ZW1Sb290UGF0aCgpOwotICAgICAgICBtX2xvY2FsRmls ZVN5c3RlbSA9IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKHBhdGgpOwotICAgIH0KKyAgICAvLyBG SVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2VkLgogCi0gICAgbV9sb2NhbEZpbGVTeXN0ZW0t PnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06 OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAg IExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0oZG9j dW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1 Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7CiB9CiAKIENPTVBJTEVfQVNTRVJUKGludChE T01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwg ZW51bV9taXNtYXRjaCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmggYi9X ZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZiMjE4 NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAzYSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xh c3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3RvclRp bWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExvY2F0 aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAtNDQ0 LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRB QkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5Owog I2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFyZ2V0 RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5pZGwgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAppbmRleCA3ZTQ4ZjhjNTMxMTJi NmUwMzE3ZTExMjVhZjUxYjBmOTM1MzM0ZjEzLi4wNTMwMjUwMzY0MTU4ZGI1NWJjYjgzODI3MzA5 M2NmYmU4MGRiMzE2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbApAQCAtMTkzLDcgKzE5Myw2IEBAIG1vZHVsZSB3 aW5kb3cgewogICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBURU1QT1JBUlkgPSAwOwogICAg ICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0gMTsKICAgICAgICAgW0VuYWJs ZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4gdW5zaWduZWQgc2hvcnQgdHlw ZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEZpbGVTeXN0ZW1D YWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEVycm9yQ2Fs bGJhY2sgZXJyb3JDYWxsYmFjayk7Ci0KICAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50 aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0b3IgRmxhZ3M7CiAjZW5kaWYKIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5j cHAKaW5kZXggMzI5YzQ3ZjM5ZDE2MjEzNzc0MTYwOGZiNDFhMWYwMGU3ODk2OGYxMi4uZTM0NjA2 OTAzMzE3ZDIyMTNhZWIyZDM3M2ZmMGY0M2JlMTE5NmIzZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTAs MTEgKzQ5MCw2IEBAIHZvaWQgU2V0dGluZ3M6OnNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChj b25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRo OwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5n JiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJvb3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBT ZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVNb2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2lu QXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggOGVjNTEwNmJmNDRkNWEy NjczN2E4ZjM4MTk2Y2ZjNTcyNGU1ODE1ZC4uN2Y1ZmY3YTEzZDAyMmNmYmE4MGZkN2Y5M2FlZWVk ZmUzOTdlNGYwNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTIzOSw5ICsyMzksNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmlu ZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNv bnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9p ZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0 cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9v dFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsK ICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1f aW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApAQCAtMzMxLDcgKzMyOCw2IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1fZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAg ICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRlbXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5n IG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwotICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVt Um9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2VyU3R5bGVTaGVldExvY2F0aW9uOwogICAgICAg ICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRGYW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmlu ZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJi Mjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi5iYjEwNjMwNzQ0YzUzMDVkZGU0 NmNjNTM1YzkzYTk5ZTIxMzBhOWUzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02 Myw2ICs2MywxNCBAQAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAK KyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisj aW5jbHVkZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1 ZGUgIkZpbGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgor I2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3JrZXJDb250ZXh0 VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAgLTMzNSw2ICsz NDMsMTggQEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYg YmxvYlVSTFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQordm9p ZCBXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNp emUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NS ZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICAvLyBGSVhNRTogc2Vl IGlmIGFjY2VzcyBpcyBhbGxvd2VkLgorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVT eXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0 ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwor fQorCitDT01QSUxFX0FTU0VSVChpbnQoV29ya2VyQ29udGV4dDo6VEVNUE9SQVJZKSA9PSBpbnQo QXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNT RVJUKGludChXb3JrZXJDb250ZXh0OjpQRVJTSVNURU5UKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVt OjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAppbmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi44ZDJmNTE5 ZDI1NzQxYzg2NWIwZjkwNjllOGVmY2NlODVmNzM1OTc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dv cmtlcnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0 LmgKQEAgLTQ3LDYgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFi YXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5j OworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNr OwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rp b247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTIzLDE1IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYp OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIC8vIFRoZXkgYXJl IHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGls ZS10aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5c3RlbVR5cGUgeworICAg ICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVOVCwKKyAgICAgICAgfTsK KyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUs IFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNr Pik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBt YXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4K ICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2 aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdl dCgpOyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwgYi9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRhZGI4OGJjMmRmNjdm MjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uOWM5ZWVjMGU4NDFhMjNlNjA1MDVmMzU3ZDM5YTAyNGRl ODFjNGIzNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCisr KyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0LDYgKzEwNCwxMyBA QCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVCbG9iVVJMKGluIEJs b2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01TdHJpbmcgYmxvYlVS TCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVNKSAmJiBFTkFCTEVf RklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVNUE9SQVJZID0gMDsK KyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7CisgICAgICAgIFtF bmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVuc2lnbmVkIHNob3J0 IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBGaWxlU3lz dGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBFcnJv ckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1 bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07 CiAKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCmluZGV4IGIyYjkyMTRiM2ZkOTAxNzgwZDVjZDVkNDA0YjQ0MWJjZTU5 YjIyOTEuLjdiYzgyNDAwMTMzMzdiMjE0ZWY4ZjZjYzg5NmViMWRjNmNjNWFhZTMgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTA5LTE1ICBLaW51a28gWWFzdWRhICA8a2ludWtv QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0gQVBJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgwOAorCisgICAgICAgICog cHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21t b25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xv Y2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5 c3RlbTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4K KyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJD bGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5G aWxlU3lzdGVtKTogQWRkZWQuCisKIDIwMTAtMDktMTQgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJl dmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2 NzUwMy4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5o CmluZGV4IGNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQuLmQ5ZDE2YzYz MTEwNzg2ODM4NmQzY2UyMGM4NWVjYzBiYzY5MDY4OTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzEsNiArMzEsOSBAQAogI2lmbmRl ZiBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogI2RlZmluZSBXZWJDb21tb25Xb3JrZXJDbGllbnRf aAogCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgor CiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CkBA IC04Myw2ICs4NiwxMyBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtp dCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCiAgICAgdmlydHVhbCBib29s IGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdl YlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgPSAwOwog CisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcg YSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUq LCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50 YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVtZW50IHRoaXMuCisgICAgICAg IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKIHByb3RlY3RlZDoKICAgICB+ V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCA0NTM2NWVmMmU2NzlkOTkwYmIzYWVi ZGYzZWNhOWNlODIyMGYyNWIyLi45OTg0M2VhYTk5YzQyMDUwYzQ1MTI4NjQyYTAwNDU1MGM5YTY3 OGRiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9t aXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVt LmNwcApAQCAtNDIsMTQgKzQyLDE4IEBACiAjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNr c0ltcGwuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1l SW1wbC5oIgorI2luY2x1ZGUgIldlYldvcmtlckltcGwuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250 ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJL aXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0aCkKK0xvY2FsRmlsZVN5 c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogewotICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBERUZJTkVfU1RBVElDX0xP Q0FMKExvY2FsRmlsZVN5c3RlbSwgbG9jYWxGaWxlU3lzdGVtLCAoIiIpKTsKKyAgICByZXR1cm4g bG9jYWxGaWxlU3lzdGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVT eXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4g c3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2sp CkBAIC02MCw3ICs2NCwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0 ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJG cmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZy YW1lKCkpOwogICAgICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZy YW1lLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdl YkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAg ICAvLyBGSVhNRTogQWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3Jr ZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNv bnRleHQpOworICAgICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAm d29ya2VyQ29udGV4dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdl YldvcmtlckJhc2UqIHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3Jr ZXJMb2FkZXJQcm94eSk7CisgICAgICAgIHdlYldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oMCwgc3Rh dGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lz dGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ss IGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcAppbmRleCA0MmY0MWQyZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgz OTU1ZTJlLi5hZjMwMDBhYmFiYmJiZDRhMTJmYWJlZTdjNjJmYjU2Y2QzYjgwNDcxIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTM3LDYgKzM3LDggQEAKICNpbmNsdWRl ICJQbGF0Zm9ybU1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJj ZUltcGwuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lz dGVtQ2FsbGJhY2tzLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJX ZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJNZXNzYWdlUG9ydENoYW5uZWwuaCIKQEAgLTU2 LDYgKzU4LDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKIHN0 YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUi Oworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0ZW1Nb2RlW10gPSAib3BlbkZpbGVTeXN0 ZW1Nb2RlIjsKKwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiArMTE4LDEwNSBAQCBwcml2YXRl OgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5nIG1fbW9kZTsK IH07CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVx dWVzdCB0byB0aGUgbWFpbiB0aHJlYWQuCisvLyBUaGlzIG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0 aGUgd29ya2VyIHRocmVhZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSB7 CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgc3RhcnQoV2ViV29ya2VyQmFzZSogd29ya2VyLCBX ZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25z dCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAg Ly8gVGhpcyBjbGFzcyBpcyBzZWxmLWRlc3RydWN0ZWQuCisgICAgICAgIEFTU0VSVChuZXcgT3Bl bkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgY29tbW9uQ2xpZW50LCBmcmFtZSwg bW9kZSwgdHlwZSwgc2l6ZSwgY2FsbGJhY2tzKSk7CisgICAgfQorCisgICAgfk9wZW5GaWxlU3lz dGVtTWFpblRocmVhZEJyaWRnZSgpCisgICAgeworICAgICAgICBBU1NFUlQoIW1fd29ya2VyQ29u dGV4dENhbGxiYWNrcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIE9wZW5GaWxlU3lzdGVtTWFp blRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdlYkNvbW1vbldvcmtlckNsaWVu dCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2Rl LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVt Q2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAg ICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNrcyhjYWxsYmFja3MpCisgICAgICAgICwgbV9tb2Rl KG1vZGUpCisgICAgeworICAgICAgICB3b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCB3b3JrZXIsIGNv bW1vbkNsaWVudCwgZnJhbWUsIHR5cGUsIHNpemUsIHRoaXMpKTsKKyAgICB9CisKKyAgICBzdGF0 aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJDbGllbnQq IGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUs IGxvbmcgbG9uZyBzaXplLCBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UqIGJyaWRnZSkK KyAgICB7CisgICAgICAgIGlmICghY29tbW9uQ2xpZW50KQorICAgICAgICAgICAgYnJpZGdlLT5k aWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvckFib3J0KTsKKyAgICAgICAgZWxzZQorICAg ICAgICAgICAgY29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbShmcmFtZSwgdHlwZSwgc2l6ZSwg bmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSkpOworICAgIH0KKworICAg IC8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhhdCBhcmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0 aHJlYWQuCisgICAgY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgOiBwdWJsaWMg V2ViRmlsZVN5c3RlbUNhbGxiYWNrcyB7CisgICAgcHVibGljOgorICAgICAgICBNYWluVGhyZWFk RmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNzT3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJy aWRnZT4gYnJpZGdlKQorICAgICAgICAgICAgOiBtX2JyaWRnZShicmlkZ2UpCisgICAgICAgIHsK KyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJh Y2tzKCkKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKG1fYnJpZGdlKQorICAgICAgICAgICAg ICAgIGRpZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICB9CisKKyAgICAgICAgdmly dHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3Qg V2ViU3RyaW5nJiBwYXRoKQorICAgICAgICB7CisgICAgICAgICAgICBBU1NFUlQobV9icmlkZ2Up OworICAgICAgICAgICAgbV9icmlkZ2UubGVha1B0cigpLT5kaWRPcGVuRmlsZVN5c3RlbU9uTWFp blRocmVhZChuYW1lLCBwYXRoKTsKKyAgICAgICAgICAgIGRlbGV0ZSB0aGlzOworICAgICAgICB9 CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoV2ViRmlsZUVycm9yIGVycm9yKQorICAg ICAgICB7CisgICAgICAgICAgICBBU1NFUlQobV9icmlkZ2UpOworICAgICAgICAgICAgbV9icmlk Z2UubGVha1B0cigpLT5kaWRGYWlsT25NYWluVGhyZWFkKGVycm9yKTsKKyAgICAgICAgICAgIGRl bGV0ZSB0aGlzOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQo KSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQg ZGlkUmVhZE1ldGFkYXRhKGNvbnN0IFdlYkZpbGVJbmZvJikgeyBXRUJLSVRfQVNTRVJUX05PVF9S RUFDSEVEKCk7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3Qg V2ViVmVjdG9yPFdlYkZpbGVTeXN0ZW1FbnRyeT4mLCBib29sKSB7IFdFQktJVF9BU1NFUlRfTk9U X1JFQUNIRUQoKTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgT3duUHRyPE9wZW5GaWxlU3lz dGVtTWFpblRocmVhZEJyaWRnZT4gbV9icmlkZ2U7CisgICAgfTsKKyAgICBmcmllbmQgY2xhc3Mg TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICBzdGF0aWMgdm9pZCBkaWRGYWls T25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIE9wZW5GaWxl U3lzdGVtTWFpblRocmVhZEJyaWRnZSogYnJpZGdlUHRyLCBXZWJGaWxlRXJyb3IgZXJyb3IpCisg ICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlk Z2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRDYWxsYmFja3Mt PmRpZEZhaWwoZXJyb3IpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNr cyA9IDA7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1Pbldvcmtl clRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgT3BlbkZpbGVTeXN0ZW1N YWluVGhyZWFkQnJpZGdlKiBicmlkZ2VQdHIsIGNvbnN0IFdURjo6U3RyaW5nJiBuYW1lLCBjb25z dCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVT eXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdl LT5tX3dvcmtlckNvbnRleHRDYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIHJvb3RQ YXRoKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRDYWxsYmFja3MgPSAwOworICAg IH0KKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3IgZXJyb3IpCisg ICAgeworICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNy ZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29ya2VyVGhyZWFkLCB0aGlzLCBlcnJvciksIG1f bW9kZSk7CisgICAgfQorCisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChj b25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3QgV1RGOjpTdHJpbmcmIHJvb3RQYXRoKQorICAg IHsKKyAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dChjcmVh dGVDYWxsYmFja1Rhc2soJmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQsIHRoaXMsIG5h bWUsIHJvb3RQYXRoKSwgbV9tb2RlKTsKKyAgICB9CisKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dv cmtlcjsKKyAgICBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBtX3dvcmtlckNvbnRleHRDYWxsYmFj a3M7CisgICAgV1RGOjpTdHJpbmcgbV9tb2RlOworfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9u IGlzIGNhbGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21l IHN0YXRpYwpAQCAtMjMxLDYgKzMzNCwxNCBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0 YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAg IHJldHVybiBicmlkZ2UtPnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5G aWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQoreworICAgIEFTU0VSVCht X3dlYlZpZXcpOworCisgICAgLy8gVGhlIG1haW5GcmFtZSBpcyB1c2VkIHRvIGNoZWNrIHRoZSBz ZWN1cml0eSBvcmlnaW4uCisgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlOjpzdGFy dCh0aGlzLCBjb21tb25DbGllbnQoKSwgbV93ZWJWaWV3LT5tYWluRnJhbWUoKSwgb3BlbkZpbGVT eXN0ZW1Nb2RlLCB0eXBlLCBzaXplLCBjYWxsYmFja3MpOworfQorCiAvLyBXb3JrZXJPYmplY3RQ cm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3Qo UGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlmMjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZl MzEyYjMuLmU5OGRhZjE4ZjBlYTE2MmE5YWJjZjg4NWE5NDRkMmY1ZGZlOWY5MTQgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAv LyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9y IHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwg Y29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNp Z25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisgICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZp bGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0 ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24g dGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVh ZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2 OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVmNTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFl ZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudElt cGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRl ICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNs dWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgog I2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAgLTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAg ICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAg ICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpU eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVh bCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwo= 67725 2010-09-15 15:13:06 -0700 2010-09-15 15:17:30 -0700 Patch bug-45808-20100915151304.patch text/plain 37425 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MmMyM2YxYjRhMmYzMjEwOTI1YTA2MDgxNTU5MTMwNGJiMWM1OGQ4Yy4uNWI4MGQ4NDc0NDA5NDQ4 ZDJmNzllOTFjYzJjNzY2NjVlNzI2YzNjNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmZpbGVTeXN0 ZW1FbmFibGVkKTogQ2hhbmdlZCB0byByZWZsZWN0IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFi bGUKKyAgICAgICAgKiBiaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDoK KyAgICAgICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICogZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6fkxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaDoKKyAgICAgICAgKiBwYWdlL0RPTVdpbmRvdy5pZGw6CisgICAgICAg ICogcGFnZS9TZWN1cml0eU9yaWdpbi5oOgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmln aW46OmNhbkFjY2Vzc0ZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdz LmNwcDoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAgICAgICogd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlcXVlc3RG aWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6Cisg ICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKworICAgICAgICBBZGRlZCBOb1N0 YXRpY1RhYmxlcyBhbmQgY2hhbmdlZCBtb2R1bGVuYW1lIGZyb20gc3RvcmFnZSB0byBmaWxlYXBp OgorCisgICAgICAgICogZmlsZWFwaS9ET01GaWxlU3lzdGVtLmlkbDoKKyAgICAgICAgKiBmaWxl YXBpL0RpcmVjdG9yeUVudHJ5LmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0RpcmVjdG9yeVJlYWRl ci5pZGw6CisgICAgICAgICogZmlsZWFwaS9FbnRyaWVzQ2FsbGJhY2suaWRsOgorICAgICAgICAq IGZpbGVhcGkvRW50cnkuaWRsOgorICAgICAgICAqIGZpbGVhcGkvRW50cnlBcnJheS5pZGw6Cisg ICAgICAgICogZmlsZWFwaS9FbnRyeUNhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0Vy cm9yQ2FsbGJhY2suaWRsOgorICAgICAgICAqIGZpbGVhcGkvRmlsZUVudHJ5LmlkbDoKKyAgICAg ICAgKiBmaWxlYXBpL0ZpbGVTeXN0ZW1DYWxsYmFjay5pZGw6CisgICAgICAgICogZmlsZWFwaS9G bGFncy5pZGw6CisgICAgICAgICogZmlsZWFwaS9NZXRhZGF0YS5pZGw6CisgICAgICAgICogZmls ZWFwaS9NZXRhZGF0YUNhbGxiYWNrLmlkbDoKKwogMjAxMC0wOS0xNCAgS2ludWtvIFlhc3VkYSAg PGtpbnVrb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRHVtaXRydSBEYW5p bGl1Yy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxl ZEZlYXR1cmVzLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmNwcAppbmRleCBhMTVmZDZkMDgwMmZiZWVmMTEwOWZjYTljOWQzYjJmM2QzMDIwYzA0 Li45YTk2ZjIyNmQzY2ZmNzI3OGM3OTI2OWExYzgyZTRhY2M3ODQwNjRiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKKysrIGIv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCkBAIC0z Niw2ICszNiwxMCBAQAogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNpbmNs dWRlICJXZWJTb2NrZXQuaCIKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNsdWRlICJB c3luY0ZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wg UnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNMb2NhbFN0b3JhZ2VFbmFibGVkID0gdHJ1ZTsKQEAg LTU3LDYgKzYxLDExIEBAIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNYSFJSZXNwb25z ZUJsb2JFbmFibGVkID0gZmFsc2U7CiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiBib29sIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzRmlsZVN5c3RlbUVuYWJsZWQgPSBmYWxzZTsKKworYm9v bCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCgpCit7CisgICAgcmV0 dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQgJiYgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgp OworfQogI2VuZGlmCiAKICNpZiBFTkFCTEUoVklERU8pCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Jp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIGIvV2ViQ29yZS9iaW5kaW5n cy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAppbmRleCA5MTc2OGIwZTU0ZTdmOTdi YWNkMGE5YmQzMzllMWRjNDIwZDZlZGVlLi5iYTRhNGZiMDVkZjUxZDc0NDRmYjlhM2JhMTAwMmFl NDdhYmQ1ZmM4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVu YWJsZWRGZWF0dXJlcy5oCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5h YmxlZEZlYXR1cmVzLmgKQEAgLTE0OCw3ICsxNDgsNyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogI2lm IEVOQUJMRShGSUxFX1NZU1RFTSkKLSAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgp IHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KKyAgICBzdGF0aWMgYm9vbCBmaWxlU3lz dGVtRW5hYmxlZCgpOwogICAgIHN0YXRpYyB2b2lkIHNldEZpbGVTeXN0ZW1FbmFibGVkKGJvb2wg aXNFbmFibGVkKSB7IGlzRmlsZVN5c3RlbUVuYWJsZWQgPSBpc0VuYWJsZWQ7IH0KICAgICBzdGF0 aWMgYm9vbCByZXF1ZXN0RmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1F bmFibGVkOyB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9ET01GaWxlU3lz dGVtLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9ET01GaWxlU3lzdGVtLmlkbAppbmRleCBiNzMwN2Uy YzE2OTljNWM2MjgwNDgyNTIxZDc5NWM3NWIyNDY3ZTc2Li5lYTMzZjE1MmIzNDUwM2I3YmU2NjA5 ZGYzMWNkMWQzMzg4ZTFjODMwIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRE9NRmlsZVN5 c3RlbS5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0RPTUZpbGVTeXN0ZW0uaWRsCkBAIC0yOCw5 ICsyOCwxMCBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1 bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKLSAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9T WVNURU0KKyAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCisgICAgICAgIE5vU3RhdGlj VGFibGVzCiAgICAgXSBET01GaWxlU3lzdGVtIHsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRl IERPTVN0cmluZyBuYW1lOwogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRGlyZWN0b3J5RW50 cnkgcm9vdDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlFbnRyeS5pZGwg Yi9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRsCmluZGV4IDdhMGVmZGRkMzg5MWFj ZjVmOWM2OTg2Y2E5ZWJlYzQ2ZTIzN2Q4ZWUuLmM5NTk2OTRlNTBhMTk1NTdiMDJiY2Q2MTI5MmQz NzEwMDc1NTM3N2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlFbnRyeS5p ZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeUVudHJ5LmlkbApAQCAtMjgsMTEgKzI4 LDEyIEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBm aWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RF TSwKICAgICAgICAgR2VuZXJhdGVOYXRpdmVDb252ZXJ0ZXIsCi0gICAgICAgIEdlbmVyYXRlVG9K UworICAgICAgICBHZW5lcmF0ZVRvSlMsCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBE aXJlY3RvcnlFbnRyeSA6IEVudHJ5IHsKICAgICAgICAgRGlyZWN0b3J5UmVhZGVyIGNyZWF0ZVJl YWRlcigpOwogICAgICAgICBbQ3VzdG9tXSB2b2lkIGdldEZpbGUoaW4gW0NvbnZlcnRVbmRlZmlu ZWRPck51bGxUb051bGxTdHJpbmddIERPTVN0cmluZyBwYXRoLCBpbiBbT3B0aW9uYWxdIEZsYWdz IGZsYWdzLCBpbiBbT3B0aW9uYWwsIENhbGxiYWNrXSBFbnRyeUNhbGxiYWNrIHN1Y2Nlc3NDYWxs YmFjaywgaW4gW09wdGlvbmFsLCBDYWxsYmFja10gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNr KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsIGIvV2Vi Q29yZS9maWxlYXBpL0RpcmVjdG9yeVJlYWRlci5pZGwKaW5kZXggYzNjNzAxMjAyZGEwOGViNGJj MWI3NTcxZDYyOGExN2YyY2YzNDE5Ni4uZTVmNTNhNjZlNjYzOTVkMWI1ZmMzODNkOTA1NzJkOWNl NWVjOTUwMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeVJlYWRlci5pZGwK KysrIGIvV2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeVJlYWRlci5pZGwKQEAgLTI4LDkgKzI4LDEw IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxl YXBpIHsKICAgICBpbnRlcmZhY2UgWwotICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTQor ICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMK ICAgICBdIERpcmVjdG9yeVJlYWRlciB7CiAgICAgICAgIHZvaWQgcmVhZEVudHJpZXMoaW4gW0Nh bGxiYWNrXSBFbnRyaWVzQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbT3B0aW9uYWwsIENh bGxiYWNrXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwogICAgIH07CmRpZmYgLS1naXQg YS9XZWJDb3JlL2ZpbGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9F bnRyaWVzQ2FsbGJhY2suaWRsCmluZGV4IDczYjM3NGQ3OTI4ZWU0ODA2NjJlYzM5YzMzYzliMWYw NGU4NjgxMzcuLmY5MTRjNDgyODYzNjEyYTAxNmU5Nzc4ZWRhYzUyNGM2MDc3MGZhNmQgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyaWVzQ2FsbGJhY2suaWRsCisrKyBiL1dlYkNvcmUv ZmlsZWFwaS9FbnRyaWVzQ2FsbGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBACiAgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRl cmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgQ2FsbGJh Y2sKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeS5pZGwgYi9XZWJDb3JlL2ZpbGVh cGkvRW50cnkuaWRsCmluZGV4IGI2NzQ0NTUxMmEwNWQyMDBlMTlkYmVjZWEyZThkN2Y3MTM3YTIz NmEuLmE5NzhlNjU5M2Y2MWQ2ODI2YmU1ZTI1MTZmNWIwY2I1MzFmMjI5MzMgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZmlsZWFwaS9FbnRyeS5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0VudHJ5Lmlk bApAQCAtMjgsMTAgKzI4LDExIEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9y YWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRp b25hbD1GSUxFX1NZU1RFTSwKLSAgICAgICAgQ3VzdG9tVG9KUworICAgICAgICBDdXN0b21Ub0pT LAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRW50cnkgewogICAgICAgICByZWFkb25s eSBhdHRyaWJ1dGUgYm9vbGVhbiBpc0ZpbGU7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBi b29sZWFuIGlzRGlyZWN0b3J5OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5QXJy YXkuaWRsIGIvV2ViQ29yZS9maWxlYXBpL0VudHJ5QXJyYXkuaWRsCmluZGV4IGU5ODdlY2VmZWJl ZGJjYWVlYmMzYTdmMTJiOTcwNmVlOTM4YTRkZjAuLmNiNzE5MzZkYTNhYjdkMDZkZWRlNTNjNWJm NjU3MDc2ODExM2EyOWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUFycmF5Lmlk bAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvRW50cnlBcnJheS5pZGwKQEAgLTI4LDEwICsyOCwxMSBA QAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFw aSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCiAg ICAgICAgIEhhc0luZGV4R2V0dGVyLAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRW50 cnlBcnJheSB7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSB1bnNpZ25lZCBsb25nIGxlbmd0 aDsKICAgICAgICAgRW50cnkgaXRlbShpbiBbSXNJbmRleF0gdW5zaWduZWQgbG9uZyBpbmRleCk7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGwgYi9XZWJDb3Jl L2ZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGwKaW5kZXggYmVhM2ZkMTQ3MGVkMGM3YzA0YjliMTFl MmM2MTA1Y2RmZjlhNGE3OS4uNGE4NTM0YmMxY2I4MDA2NTMwOTUxMTBjMjY3MzA5MDQ3NWRiNTA5 ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5Q2FsbGJhY2suaWRsCisrKyBiL1dl YkNvcmUvZmlsZWFwaS9FbnRyeUNhbGxiYWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAogICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAg aW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIENh bGxiYWNrCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGwgYi9X ZWJDb3JlL2ZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGwKaW5kZXggZmM3ZmE4NWM0MDU4MjhhZjcy NzI5NWZlZDZmNjYwMDAyOTQ4Zjc4OC4uN2QzMzkxZTQwYzU5OTU0NDRiZjIzNTFiZjE5YjliYjNh MDNjZWMyMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0Vycm9yQ2FsbGJhY2suaWRsCisr KyBiL1dlYkNvcmUvZmlsZWFwaS9FcnJvckNhbGxiYWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAog ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7 CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAg ICAgIENhbGxiYWNrCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbCBi L1dlYkNvcmUvZmlsZWFwaS9GaWxlRW50cnkuaWRsCmluZGV4IDQxYjlhOTE4YWZkZWZiMWRjMTk1 M2M5M2NjYzE3ZTk3MDM0OGMzMDQuLmFmNGYyYTg2YmJmZGQ5ODBkZmRmNDRkYjI2OTFhNmYwMTJj M2NkMjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9GaWxlRW50cnkuaWRsCisrKyBiL1dl YkNvcmUvZmlsZWFwaS9GaWxlRW50cnkuaWRsCkBAIC0yOCwxMSArMjgsMTIgQEAKICAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGlu dGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBHZW5l cmF0ZU5hdGl2ZUNvbnZlcnRlciwKLSAgICAgICAgR2VuZXJhdGVUb0pTCisgICAgICAgIEdlbmVy YXRlVG9KUywKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIEZpbGVFbnRyeSA6IEVudHJ5 IHsKICNpZiBkZWZpbmVkKEVOQUJMRV9GSUxFX1dSSVRFUikgJiYgRU5BQkxFX0ZJTEVfV1JJVEVS CiAgICAgICAgIHZvaWQgY3JlYXRlV3JpdGVyKGluIFtDYWxsYmFja10gRmlsZVdyaXRlckNhbGxi YWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW09wdGlvbmFsLCBDYWxsYmFja10gRXJyb3JDYWxsYmFj ayBlcnJvckNhbGxiYWNrKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVt Q2FsbGJhY2suaWRsIGIvV2ViQ29yZS9maWxlYXBpL0ZpbGVTeXN0ZW1DYWxsYmFjay5pZGwKaW5k ZXggY2Y2ODZmZjFiZjVmZDA4ODNiYTY4MjQxMjNlZDYzMDE4MGZkM2UyMC4uMmVmNmE5MmY3Y2M4 NDJhNjM0Nzg4YmQ3ZmYxNzMyODc3YWE5YTgxMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBp L0ZpbGVTeXN0ZW1DYWxsYmFjay5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0ZpbGVTeXN0ZW1D YWxsYmFjay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9k dWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGludGVyZmFjZSBbCiAgICAgICAg IENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBDYWxsYmFjawpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9maWxlYXBpL0ZsYWdzLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9GbGFncy5pZGwKaW5k ZXggMjk2NThhMWZlNjY0NGQ3YzkyMTk2NmJkNWY4NzkyZGZhYjAzZjEzYi4uYTE3YmZjYTgwMjNh MTg1M2M3MjQzZGQ2NmQ1ZWVhNGNmOWIxNDYxNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBp L0ZsYWdzLmlkbAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvRmxhZ3MuaWRsCkBAIC0yOCwxMCArMjgs MTEgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZp bGVhcGkgewogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVN LAotICAgICAgICBDYW5CZUNvbnN0cnVjdGVkCisgICAgICAgIENhbkJlQ29uc3RydWN0ZWQsCisg ICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBGbGFncyB7CiAgICAgICAgIGF0dHJpYnV0ZSBi b29sZWFuIGNyZWF0ZTsKICAgICAgICAgYXR0cmlidXRlIGJvb2xlYW4gZXhjbHVzaXZlOwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL2Zp bGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5ZTVl ZTM5OTYwMGY2ZTA0NGY2Li4wOGZhZDQ2ZmViNzYwMjY1Y2QzZGY3OThkNTdmZmQwZmQ2MDg2OWFi IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMjkgQEAKIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxG aWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2NhbEZp bGVTeXN0ZW0qIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxlU3lz dGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCit7 CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3 ZWxsLgorICAgIEFTU0VSVCghc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICBpZiAoc3RhdGlj TG9jYWxGaWxlU3lzdGVtKQorICAgICAgICByZXR1cm47CisKKyAgICBzdGF0aWNMb2NhbEZpbGVT eXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKTsKK30KKworTG9jYWxGaWxlU3lz dGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgaWYgKCFzdGF0 aWNMb2NhbEZpbGVTeXN0ZW0pCisgICAgICAgIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IG5ldyBM b2NhbEZpbGVTeXN0ZW0oIiIpOworCisgICAgcmV0dXJuICpzdGF0aWNMb2NhbEZpbGVTeXN0ZW07 Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0 CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsK KyAgICByZXR1cm4gbV9iYXNlUGF0aC50aHJlYWRzYWZlQ29weSgpOwogfQogCiBzdGF0aWMgdm9p ZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBi YXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUg dHlwZSwgUGFzc093blB0cjxGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCkBAIC02OCw3 ICs4OCw3IEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgfQogCiAgICAgLy8gQXN5bmNG aWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwg c28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCi0gICAgY29u dGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgbV9iYXNl UGF0aCwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5 cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj aywgY29udGV4dCkpKTsKKyAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2so Jm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlP cmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJh Y2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKIH0KIAogfSAv LyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u aCBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaAppbmRleCA0OGNmYThmNjg4NmE2 MGE0MDA0NDRlMmZjZWJlYTY4Y2Q1MjNkYmI2Li5iMGJmYzQwYjA0MWJhMDA0OGY3N2M0ZjhlNjEw M2IzODU0YzAxNjMzIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVt LmgKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCkBAIC00NCwxOSArNDQs MzMgQEAgY2xhc3MgRXJyb3JDYWxsYmFjazsKIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKIGNs YXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAKLWNsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1 YmxpYyBSZWZDb3VudGVkPExvY2FsRmlsZVN5c3RlbT4geworLy8gS2VlcHMgcGVyLXByb2Nlc3Mg aW5mb3JtYXRpb24gYW5kIHByb3ZpZGVzIGFuIGVudHJ5IHBvaW50IHRvIG9wZW4gYSBmaWxlIHN5 c3RlbS4KK2NsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJs aWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3Qg U3RyaW5nJiBiYXNlUGF0aCk7Ci0gICAgdmlydHVhbCB+TG9jYWxGaWxlU3lzdGVtKCkgeyB9Cisg ICAgLy8gUmV0dXJucyBhIHBlci1wcm9jZXNzIGluc3RhbmNlIG9mIExvY2FsRmlsZVN5c3RlbS4K KyAgICAvLyBOb3RlIHRoYXQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lz dGVtIG11c3QgYmUgY2FsbGVkIHRvCisgICAgLy8gaW5pdGlhbGl6ZSB0aGUgYmFzZSBwYXRoLgor ICAgIHN0YXRpYyBMb2NhbEZpbGVTeXN0ZW0mIGxvY2FsRmlsZVN5c3RlbSgpOwogCiAgICAgdm9p ZCByZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3lz dGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+ LCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+KTsKIAotcHJvdGVjdGVkOgorI2lmICFQTEFURk9S TShDSFJPTUlVTSkKKyAgICAvLyBUaGlzIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2Vy IHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAgdm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVt KGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0 OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAgTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYg YmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNlUGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQog CisgICAgfkxvY2FsRmlsZVN5c3RlbSgpIHsgfQorCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2Rz IHNob3VsZG4ndCBhY2Nlc3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAg ICAvLyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRo OwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhLmlkbCBiL1dlYkNv cmUvZmlsZWFwaS9NZXRhZGF0YS5pZGwKaW5kZXggYTVhOTBiYzY2NzEyOWI4OWY3YTEzMWY0NmMx YzYxMmMwYmUyZjBlNS4uMzJiYzg0N2Q0ZTA2YTkyN2E0OGM5NTBmZmJkM2VkZmVhNjVmM2FlZiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhLmlkbAorKysgYi9XZWJDb3JlL2Zp bGVhcGkvTWV0YWRhdGEuaWRsCkBAIC0yOCw5ICsyOCwxMCBAQAogICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAq LwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsK LSAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0KKyAgICAgICAgQ29uZGl0aW9uYWw9RklM RV9TWVNURU0sCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBNZXRhZGF0YSB7CiAgICAg ICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBEYXRlIG1vZGlmaWNhdGlvblRpbWU7CiAgICAgfTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YUNhbGxiYWNrLmlkbCBiL1dlYkNvcmUv ZmlsZWFwaS9NZXRhZGF0YUNhbGxiYWNrLmlkbAppbmRleCA0NGNhMTgwNTQyMGE2YWUwNTRmYjQx ZDg2OGQzZmYwMTU3NGRmYzMzLi45M2M2ZmY1N2UzN2VmOWFiYWZiYjBjYWU3ZWE0MzgyN2IyNzA1 ZDE3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGFDYWxsYmFjay5pZGwKKysr IGIvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhQ2FsbGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBA CiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBp IHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAg ICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwIGIv V2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAKaW5kZXggMTVmM2VkMTgwZTZmYzdjNTJjZWUyOTAw ZjU1NDJjNjgxYmVhOGJkOS4uYjM3ZGU0YmU1NzYxNDRlMTI3NjdiODNlMWZlOWFmN2U4YmRlMDRi YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAKKysrIGIvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5jcHAKQEAgLTcyNywyNSArNzI3LDE2IEBAIHZvaWQgRE9NV2luZG93Ojpy ZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8Rmls ZVN5c3RlCiAgICAgaWYgKCFkb2N1bWVudCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgaWYgKCFt X2xvY2FsRmlsZVN5c3RlbSkgewotICAgICAgICAvLyBGSVhNRTogU2VlIGlmIGFjY2VzcyBpcyBh bGxvd2VkLgotCi0gICAgICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgICAg ICBpZiAoIXBhZ2UpIHsKLSAgICAgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJh Y2soZG9jdW1lbnQsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKElOVkFMSURfU1RB VEVfRVJSKSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBG SVhNRTogR2V0IHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgotICAgICAgICBTdHJpbmcgcGF0 aCA9IHBhZ2UtPnNldHRpbmdzKCktPmZpbGVTeXN0ZW1Sb290UGF0aCgpOwotICAgICAgICBtX2xv Y2FsRmlsZVN5c3RlbSA9IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKHBhdGgpOworICAgIGlmICgh QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8IGRvY3VtZW50LT5zZWN1cml0eU9yaWdp bigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2No ZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUo U0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2xvY2FsRmls ZVN5c3RlbS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmls ZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj ayk7CisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5 c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwg c2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAotQ09NUElMRV9BU1NF UlQoaW50KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVtOjpUZW1w b3JhcnkpLCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlBF UlNJU1RFTlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21h dGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpURU1QT1JB UlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVt X21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpQ RVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVu dCksIGVudW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdl L0RPTVdpbmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4IDE0NzA2Mjg2NWQ5 YjliNzc0NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLjZmZDM3NzUwM2FiNGVlZjFkOWU3NzVmOTgz MDRkMTEzMWZhZmIwM2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFjdG9yeTsKICAgICBj bGFzcyBJbnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2FsRmlsZVN5c3RlbTsK ICAgICBjbGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwogICAgIGNsYXNzIE5h dmlnYXRvcjsKQEAgLTQ0NCw5ICs0NDMsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjaWYgRU5B QkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRyPElEQkZhY3Rvcnk+ IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKLSAgICAgICAg UmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0jZW5kaWYKIAogICAg ICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKaW5k ZXggN2U0OGY4YzUzMTEyYjZlMDMxN2UxMTI1YWY1MWIwZjkzNTMzNGYxMy4uMDUzMDI1MDM2NDE1 OGRiNTViY2I4MzgyNzMwOTNjZmJlODBkYjMxNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RP TVdpbmRvdy5pZGwKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTE5Myw3ICsx OTMsNiBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVN UE9SQVJZID0gMDsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7 CiAgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVu c2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlv bmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9w dGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwotCiAgICAgICAgIGF0dHJpYnV0 ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZsYWdzOwog I2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1NjE5YWJj MTA0ZWI5ODFkY2VkNWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5NzQ3MTY1 MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29y ZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6CiAgICAg Ym9vbCBjYW5BY2Nlc3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsg fQogICAgIGJvb2wgY2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgp OyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJldHVybiAh aXNVbmlxdWUoKTsgfQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0IHsgcmV0 dXJuICFpc1VuaXF1ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxkIGFsd2F5 cyBhbGxvdyBhY2Nlc3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1cnJlbnRs eSBkb24ndCBoYW5kbGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1bmlxdWUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuY3BwCmluZGV4IDMyOWM0N2YzOWQxNjIxMzc3NDE2MDhmYjQxYTFmMDBlNzg5NjhmMTIu LmUzNDYwNjkwMzMxN2QyMjEzYWViMmQzNzNmZjBmNDNiZTExOTZiM2UgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApA QCAtNDkwLDExICs0OTAsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VEYXRhYmFz ZVBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRo ID0gcGF0aDsKIH0KIAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0 IFN0cmluZyYgcGF0aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7Ci19Ci0K IHZvaWQgU2V0dGluZ3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUpCiB7CiAg ICAgbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDhlYzUxMDZi ZjQ0ZDVhMjY3MzdhOGYzODE5NmNmYzU3MjRlNTgxNWQuLjdmNWZmN2ExM2QwMjJjZmJhODBmZDdm OTNhZWVlZGZlMzk3ZTRmMDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCisr KyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCkBAIC0yMzksOSArMjM5LDYgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25z dCBTdHJpbmcmKTsKICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRhYmFzZVBh dGgoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQogCi0gICAg ICAgIHZvaWQgc2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAgICAgICBj b25zdCBTdHJpbmcmIGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZVN5 c3RlbVJvb3RQYXRoOyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUo Ym9vbCk7CiAgICAgICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25zdCB7IHJl dHVybiBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzMSw3ICszMjgsNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5jb2RpbmdO YW1lOwogICAgICAgICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAgICAgICAg IFN0cmluZyBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5nIG1fZmls ZVN5c3RlbVJvb3RQYXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2NhdGlvbjsK ICAgICAgICAgQXRvbWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAgICBBdG9t aWNTdHJpbmcgbV9maXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L0FzeW5jRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5j cHAKaW5kZXggYjRmY2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4uYzRiZmZi ZDJiMDYwOGNiYTZlYmMyZDNjYWM0NDE4ZDYwYjVlZGVmYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNG aWxlU3lzdGVtLmNwcApAQCAtMzgsMTEgKzM4LDE5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAorI2lmICFQTEFURk9STShDSFJPTUlVTSkKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWls YWJsZSgpCit7CisgICAgLy8gRWFjaCBwbGF0Zm9ybSBzaG91bGQgaW1wbGVtZW50IHRoaXMuCisg ICAgcmV0dXJuIGZhbHNlOworfQorCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNG aWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJu IGRlZmF1bHQgQXN5bmNGaWxlU3lzdGVtIGltcGxlbWVudGF0aW9uLgorICAgIC8vIEVhY2ggcGxh dGZvcm0gc2hvdWxkIGltcGxlbWVudCB0aGlzLgogICAgIHJldHVybiAwOwogfQorI2VuZGlmCiAK IC8vIERlZmF1bHQgaW1wbGVtZW50YXRpb24uCiB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZp bGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9yYWdlSWRl bnRpZmllciwgVHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4g Y2FsbGJhY2tzKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u aCBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKaW5kZXggNjAxZjBlYWUzZTVk MGU4YmViODRkNWE5OTNkNzcwNTE3YmQwYTYyZC4uOGM0ZDVkOTkwZmRhNDZjMmI3ODBkZjliMDlh NjA3N2U1NGQ5ZmY1NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0 ZW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCkBAIC01Niw2ICs1 Niw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpIHsgfQogICAgIHZpcnR1YWwg Ym9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKSB7IHJldHVybiBmYWxzZTsgfQogCisgICAgc3RhdGlj IGJvb2wgaXNBdmFpbGFibGUoKTsKKwogICAgIC8vIENyZWF0ZXMgYW5kIHJldHVybnMgYSBuZXcg cGxhdGZvcm0tc3BlY2lmaWMgQXN5bmNGaWxlU3lzdGVtIGluc3RhbmNlIGlmIHRoZSBwbGF0Zm9y bSBoYXMgaXRzIG93biBpbXBsZW1lbnRhdGlvbi4KICAgICBzdGF0aWMgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW0+IGNyZWF0ZShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKTsKIApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwIGIvV2ViQ29yZS93b3JrZXJzL1dv cmtlckNvbnRleHQuY3BwCmluZGV4IGI1MmIyODU0NzVmMmVmOTQ3N2U4MTRiYmU0ZDhiZWI5YzNi OWVhMGEuLjJiZDliNDBhYjQyYzc1ODZkODkwMjg3M2FmMGU4ZTA0OGEzMTI2ZGQgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAorKysgYi9XZWJDb3JlL3dvcmtl cnMvV29ya2VyQ29udGV4dC5jcHAKQEAgLTYzLDYgKzYzLDE1IEBACiAjaW5jbHVkZSAiTm90aWZp Y2F0aW9uQ2VudGVyLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNs dWRlICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJET01GaWxlU3lzdGVtLmgiCisjaW5j bHVkZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1ZGUg IkZpbGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgorI2Vu ZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3JrZXJDb250ZXh0VGFz ayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAgLTMzNSw2ICszNDQs MjEgQEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYgYmxv YlVSTFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQordm9pZCBX b3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUs IFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQ dHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBpZiAoIUFzeW5jRmlsZVN5 c3RlbTo6aXNBdmFpbGFibGUoKSB8fCBzZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lz dGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayh0aGlzLCBl cnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCku cmVxdWVzdEZpbGVTeXN0ZW0odGhpcywgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBl Pih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKK30KKworQ09N UElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpURU1QT1JBUlkpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21h dGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6UEVS U0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQp LCBlbnVtX21pc21hdGNoKTsKKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNl bmRpZiAvLyBFTkFCTEUoV09SS0VSUykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmggYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCmluZGV4IDdmYjhi NDZmMzg3Y2MwNjg0MzFmZDMzNGRjMGZiNWU0ZDBhMTgwM2EuLjhkMmY1MTlkMjU3NDFjODY1YjBm OTA2OWU4ZWZjY2U4NWY3MzU5NzYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmgKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaApAQCAtNDcsNiAr NDcsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgRGF0YWJhc2U7CiAgICAgY2xh c3MgRGF0YWJhc2VDYWxsYmFjazsKICAgICBjbGFzcyBEYXRhYmFzZVN5bmM7CisgICAgY2xhc3Mg RXJyb3JDYWxsYmFjazsKKyAgICBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7CiAgICAgY2xhc3Mg Tm90aWZpY2F0aW9uQ2VudGVyOwogICAgIGNsYXNzIFNjaGVkdWxlZEFjdGlvbjsKICAgICBjbGFz cyBXb3JrZXJMb2NhdGlvbjsKQEAgLTEyMSw2ICsxMjMsMTUgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwoY29uc3QgU3RyaW5nJik7CiAjZW5kaWYKIAor I2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyAgICAgICAgLy8gVGhleSBhcmUgcGxhY2VkIGhlcmUg YW5kIGluIGFsbCBjYXBpdGFsIGxldHRlcnMgdG8gZW5mb3JjZSBjb21waWxlLXRpbWUgZW51bSBj aGVja2luZy4KKyAgICAgICAgZW51bSBGaWxlU3lzdGVtVHlwZSB7CisgICAgICAgICAgICBURU1Q T1JBUlksCisgICAgICAgICAgICBQRVJTSVNURU5ULAorICAgICAgICB9OworICAgICAgICB2b2lk IHJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxG aWxlU3lzdGVtQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+KTsKKyNlbmRpZgor CiAgICAgICAgIC8vIFRoZXNlIG1ldGhvZHMgYXJlIHVzZWQgZm9yIEdDIG1hcmtpbmcuIFNlZSBK U1dvcmtlckNvbnRleHQ6Om1hcmtDaGlsZHJlbihNYXJrU3RhY2smKSBpbgogICAgICAgICAvLyBK U1dvcmtlckNvbnRleHRDdXN0b20uY3BwLgogICAgICAgICBXb3JrZXJOYXZpZ2F0b3IqIG9wdGlv bmFsTmF2aWdhdG9yKCkgY29uc3QgeyByZXR1cm4gbV9uYXZpZ2F0b3IuZ2V0KCk7IH0KZGlmZiAt LWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbCBiL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJDb250ZXh0LmlkbAppbmRleCAwMmFhNGFkYjg4YmMyZGY2N2YyN2Q1ZWNlMmI1YTky MzI4Njc4MTI0Li45YzllZWMwZTg0MWEyM2U2MDUwNWYzNTdkMzlhMDI0ZGU4MWM0YjM2IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKKysrIGIvV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCkBAIC0xMDQsNiArMTA0LDEzIEBAIG1vZHVsZSB0aHJl YWRzIHsKICAgICAgICAgRE9NU3RyaW5nIGNyZWF0ZUJsb2JVUkwoaW4gQmxvYiBibG9iKTsKICAg ICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGluIERPTVN0cmluZyBibG9iVVJMKTsKICNlbmRpZgor CisjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9TWVNURU0pICYmIEVOQUJMRV9GSUxFX1NZU1RFTQor ICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBURU1QT1JBUlkgPSAwOworICAgICAgICBjb25z dCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0gMTsKKyAgICAgICAgW0VuYWJsZWRBdFJ1bnRp bWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4gdW5zaWduZWQgc2hvcnQgdHlwZSwgaW4gbG9u ZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEZpbGVTeXN0ZW1DYWxsYmFjayBz dWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEVycm9yQ2FsbGJhY2sgZXJy b3JDYWxsYmFjayk7CisgICAgICAgIGF0dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lz dGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZsYWdzOworI2VuZGlmCiAgICAgfTsKIAogfQpkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cKaW5kZXggYjJiOTIxNGIzZmQ5MDE3ODBkNWNkNWQ0MDRiNDQxYmNlNTliMjI5MS4uN2JjODI0 MDAxMzMzN2IyMTRlZjhmNmNjODk2ZWIxZGM2Y2M1YWFlMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMjEgQEAKKzIwMTAtMDktMTUgIEtpbnVrbyBZYXN1ZGEgIDxraW51a29AY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBX b3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1ODA4CisKKyAgICAgICAgKiBwdWJsaWMvV2ViQ29t bW9uV29ya2VyQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYkNvbW1vbldvcmtlckNsaWVu dDo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBzcmMvTG9jYWxGaWxlU3lzdGVt Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZp bGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0Rmls ZVN5c3RlbSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAgICAqIHNy Yy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwuaDoK KyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0pOiBB ZGRlZC4KKwogMjAxMC0wOS0xNCAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFp bC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3NTAzLgpkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dl YktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3 MTIzYTUyZjUwMzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZC4uZDlkMTZjNjMxMTA3ODY4Mzg2ZDNj ZTIwYzg1ZWNjMGJjNjkwNjg5OSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJDb21tb25Xb3JrZXJDbGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNv bW1vbldvcmtlckNsaWVudC5oCkBAIC0zMSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldv cmtlckNsaWVudF9oCiAjZGVmaW5lIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRl ICJXZWJDb21tb24uaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBX ZWJLaXQgewogCiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEz IEBAIHB1YmxpYzoKICAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZv cmUgb3BlbmluZyBhIHdlYiBkYXRhYmFzZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFz ZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxs ZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVt LgorICAgIHZpcnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSosIFdlYkZpbGVTeXN0 ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7 CisgICAgICAgIC8vIEZJWE1FOiBXZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBz dWJjbGFzcyBpbiBjaHJvbWl1bSBpbXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VS VF9OT1RfUkVBQ0hFRCgpOworICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3Jr ZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5j RmlsZVN5c3RlbUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lz dGVtQ2hyb21pdW0uY3BwCmluZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0 OGU4M2YuLjBiNzUzYjNkMTUyYzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2 ICs0MywxMSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVt Ojppc0F2YWlsYWJsZSgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3Rl bUNocm9taXVtOjpBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRo KQogICAgIDogQXN5bmNGaWxlU3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVt KFdlYktpdDo6d2ViS2l0Q2xpZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5 MGJiM2FlYmRmM2VjYTljZTgyMjBmMjViMi4uOTk4NDNlYWE5OWM0MjA1MGM0NTEyODY0MmEwMDQ1 NTBjOWE2NzhkYiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0 ZW1DaHJvbWl1bS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1D aHJvbWl1bS5jcHAKQEAgLTQyLDE0ICs0MiwxOCBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJX ZWJGcmFtZUltcGwuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29y a2VyQ29udGV4dC5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogCiB1c2luZyBuYW1lc3Bh Y2UgV2ViS2l0OwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmIHBhdGgpCitMb2Nh bEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKIHsKLSAgICBy ZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3RlbShwYXRoKSk7CisgICAgREVGSU5FX1NU QVRJQ19MT0NBTChMb2NhbEZpbGVTeXN0ZW0sIGxvY2FsRmlsZVN5c3RlbSwgKCIiKSk7CisgICAg cmV0dXJuIGxvY2FsRmlsZVN5c3RlbTsKIH0KIAogdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVl c3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2Fs bGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNh bGxiYWNrKQpAQCAtNjAsNyArNjQsMTAgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RG aWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICAg ICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3Vt ZW50LT5mcmFtZSgpKTsKICAgICAgICAgd2ViRnJhbWUtPmNsaWVudCgpLT5vcGVuRmlsZVN5c3Rl bSh3ZWJGcmFtZSwgc3RhdGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUs IG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhz dWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfSBlbHNlIHsK LSAgICAgICAgLy8gRklYTUU6IEFkZCBpbXBsZW1lbnRhdGlvbiBmb3Igd29ya2Vycy4KKyAgICAg ICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRl eHQqPihjb250ZXh0KTsKKyAgICAgICAgV29ya2VyTG9hZGVyUHJveHkqIHdvcmtlckxvYWRlclBy b3h5ID0gJndvcmtlckNvbnRleHQtPnRocmVhZCgpLT53b3JrZXJMb2FkZXJQcm94eSgpOworICAg ICAgICBXZWJXb3JrZXJCYXNlKiB3ZWJXb3JrZXIgPSBzdGF0aWNfY2FzdDxXZWJXb3JrZXJCYXNl Kj4od29ya2VyTG9hZGVyUHJveHkpOworICAgICAgICB3ZWJXb3JrZXItPm9wZW5GaWxlU3lzdGVt KDAsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2Vi RmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0Nh bGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0KIH0KIApkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcCBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKaW5kZXggNDJmNDFkMmRjNzliNGUzZTQ2M2NlNDlkODJl NjVhNTQ4Mzk1NWUyZS4uYWYzMDAwYWJhYmJiYmQ0YTEyZmFiZWU3YzYyZmI1NmNkM2I4MDQ3MSAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCkBAIC0zNyw2ICszNyw4IEBACiAj aW5jbHVkZSAiUGxhdGZvcm1NZXNzYWdlUG9ydENoYW5uZWwuaCIKIAogI2luY2x1ZGUgIldlYkRh dGFTb3VyY2VJbXBsLmgiCisjaW5jbHVkZSAiV2ViRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiV2Vi RmlsZVN5c3RlbUNhbGxiYWNrcy5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRDaGFubmVsLmgi CkBAIC01Niw2ICs1OCw4IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJMRShXT1JLRVJT KQogCiBzdGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFsbG93RGF0YWJh c2VNb2RlIjsKK3N0YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtdID0gIm9wZW5G aWxlU3lzdGVtTW9kZSI7CisKIAogbmFtZXNwYWNlIHsKIApAQCAtMTE0LDYgKzExOCwxMDUgQEAg cHJpdmF0ZToKICAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKICAgICBXVEY6OlN0cmluZyBt X21vZGU7CiB9OworCisvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcG9zdCBhIG9wZW5GaWxlU3lz dGVtIHJlcXVlc3QgdG8gdGhlIG1haW4gdGhyZWFkLgorLy8gVGhpcyBtdXN0IGJlIGRlc3RydWN0 ZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCitjbGFzcyBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRC cmlkZ2UgeworcHVibGljOgorICAgIHN0YXRpYyB2b2lkIHN0YXJ0KFdlYldvcmtlckJhc2UqIHdv cmtlciwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1lKiBmcmFt ZSwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9u ZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICB7Cisg ICAgICAgIC8vIFRoaXMgY2xhc3MgaXMgc2VsZi1kZXN0cnVjdGVkLgorICAgICAgICBBU1NFUlQo bmV3IE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSh3b3JrZXIsIGNvbW1vbkNsaWVudCwg ZnJhbWUsIG1vZGUsIHR5cGUsIHNpemUsIGNhbGxiYWNrcykpOworICAgIH0KKworICAgIH5PcGVu RmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UoKQorICAgIHsKKyAgICAgICAgQVNTRVJUKCFtX3dv cmtlckNvbnRleHRDYWxsYmFja3MpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBPcGVuRmlsZVN5 c3RlbU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3Jr ZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXVEY6OlN0cmlu ZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgICAgICA6IG1fd29ya2VyKHdvcmtlcikK KyAgICAgICAgLCBtX3dvcmtlckNvbnRleHRDYWxsYmFja3MoY2FsbGJhY2tzKQorICAgICAgICAs IG1fbW9kZShtb2RlKQorICAgIHsKKyAgICAgICAgd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5U aHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCwgd29y a2VyLCBjb21tb25DbGllbnQsIGZyYW1lLCB0eXBlLCBzaXplLCB0aGlzKSk7CisgICAgfQorCisg ICAgc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29yZTo6U2NyaXB0 RXhlY3V0aW9uQ29udGV4dCosIFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29tbW9uV29ya2Vy Q2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1lKiBmcmFtZSwgV2ViRmlsZVN5c3RlbTo6VHlw ZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKiBi cmlkZ2UpCisgICAgeworICAgICAgICBpZiAoIWNvbW1vbkNsaWVudCkKKyAgICAgICAgICAgIGJy aWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIGVs c2UKKyAgICAgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZpbGVTeXN0ZW0oZnJhbWUsIHR5cGUs IHNpemUsIG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2UpKTsKKyAgICB9 CisKKyAgICAvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQgYXJlIGRpc3BhdGNoZWQgb24gdGhl IG1haW4gdGhyZWFkLgorICAgIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzIDog cHVibGljIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MgeworICAgIHB1YmxpYzoKKyAgICAgICAgTWFp blRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoUGFzc093blB0cjxPcGVuRmlsZVN5c3RlbU1haW5U aHJlYWRCcmlkZ2U+IGJyaWRnZSkKKyAgICAgICAgICAgIDogbV9icmlkZ2UoYnJpZGdlKQorICAg ICAgICB7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFsIH5NYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcygpCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmIChtX2JyaWRnZSkKKyAgICAg ICAgICAgICAgICBkaWRGYWlsKFdlYkZpbGVFcnJvckFib3J0KTsKKyAgICAgICAgfQorCisgICAg ICAgIHZpcnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBXZWJTdHJpbmcmIG5hbWUs IGNvbnN0IFdlYlN0cmluZyYgcGF0aCkKKyAgICAgICAgeworICAgICAgICAgICAgQVNTRVJUKG1f YnJpZGdlKTsKKyAgICAgICAgICAgIG1fYnJpZGdlLmxlYWtQdHIoKS0+ZGlkT3BlbkZpbGVTeXN0 ZW1Pbk1haW5UaHJlYWQobmFtZSwgcGF0aCk7CisgICAgICAgICAgICBkZWxldGUgdGhpczsKKyAg ICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKFdlYkZpbGVFcnJvciBlcnJv cikKKyAgICAgICAgeworICAgICAgICAgICAgQVNTRVJUKG1fYnJpZGdlKTsKKyAgICAgICAgICAg IG1fYnJpZGdlLmxlYWtQdHIoKS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvcik7CisgICAgICAg ICAgICBkZWxldGUgdGhpczsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRT dWNjZWVkKCkgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKyAgICAgICAgdmlydHVh bCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYpIHsgV0VCS0lUX0FTU0VS VF9OT1RfUkVBQ0hFRCgpOyB9CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5 KGNvbnN0IFdlYlZlY3RvcjxXZWJGaWxlU3lzdGVtRW50cnk+JiwgYm9vbCkgeyBXRUJLSVRfQVNT RVJUX05PVF9SRUFDSEVEKCk7IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIE93blB0cjxPcGVu RmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IG1fYnJpZGdlOworICAgIH07CisgICAgZnJpZW5k IGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgc3RhdGljIHZvaWQg ZGlkRmFpbE9uV29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBP cGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UqIGJyaWRnZVB0ciwgV2ViRmlsZUVycm9yIGVy cm9yKQorICAgIHsKKyAgICAgICAgT3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRn ZT4gYnJpZGdlKGJyaWRnZVB0cik7CisgICAgICAgIGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2Fs bGJhY2tzLT5kaWRGYWlsKGVycm9yKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRD YWxsYmFja3MgPSAwOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGRpZE9wZW5GaWxlU3lzdGVt T25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIE9wZW5GaWxl U3lzdGVtTWFpblRocmVhZEJyaWRnZSogYnJpZGdlUHRyLCBjb25zdCBXVEY6OlN0cmluZyYgbmFt ZSwgY29uc3QgV1RGOjpTdHJpbmcmIHJvb3RQYXRoKQorICAgIHsKKyAgICAgICAgT3duUHRyPE9w ZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlKGJyaWRnZVB0cik7CisgICAgICAg IGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1l LCByb290UGF0aCk7CisgICAgICAgIGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzID0g MDsKKyAgICB9CisKKyAgICB2b2lkIGRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yIGVy cm9yKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29u dGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZEZhaWxPbldvcmtlclRocmVhZCwgdGhpcywgZXJy b3IpLCBtX21vZGUpOworICAgIH0KKworICAgIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5U aHJlYWQoY29uc3QgV1RGOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0 aCkKKyAgICB7CisgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRl eHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRPcGVuRmlsZVN5c3RlbU9uV29ya2VyVGhyZWFkLCB0 aGlzLCBuYW1lLCByb290UGF0aCksIG1fbW9kZSk7CisgICAgfQorCisgICAgV2ViV29ya2VyQmFz ZSogbV93b3JrZXI7CisgICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV93b3JrZXJDb250ZXh0 Q2FsbGJhY2tzOworICAgIFdURjo6U3RyaW5nIG1fbW9kZTsKK307CisKIH0KIAogLy8gVGhpcyBm dW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxp emUgc29tZSBzdGF0aWMKQEAgLTIzMSw2ICszMzQsMTQgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjph bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHIKICAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQoKTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNl OjpvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSosIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9u ZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKK3sKKyAgICBB U1NFUlQobV93ZWJWaWV3KTsKKworICAgIC8vIFRoZSBtYWluRnJhbWUgaXMgdXNlZCB0byBjaGVj ayB0aGUgc2VjdXJpdHkgb3JpZ2luLgorICAgIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRn ZTo6c3RhcnQodGhpcywgY29tbW9uQ2xpZW50KCksIG1fd2ViVmlldy0+bWFpbkZyYW1lKCksIG9w ZW5GaWxlU3lzdGVtTW9kZSwgdHlwZSwgc2l6ZSwgY2FsbGJhY2tzKTsKK30KKwogLy8gV29ya2Vy T2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2Vy T2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRlYjAyMmM4NWM0 YzMyN2Q2ZTMxMmIzLi5lOThkYWYxOGYwZWExNjJhOWFiY2Y4ODVhOTQ0ZDJmNWRmZTlmOTE0IDEw MDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBAQCBwdWJsaWM6 CiAgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBpcyBhbGxv d2VkIGZvciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJG cmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVlc3RzIHRvIG9w ZW4gYSBmaWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuCisgICAgdmlydHVhbCB2b2lkIG9wZW5G aWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUs IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVzIHRoZSBnaXZlbiB0 YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNwYXRjaFRhc2tUb01h aW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNr Pik7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1w bC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5kZXggNzQx ZDYwNjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgyMzVkYmYyOGZjOWVm ZjM0YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJD bGllbnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShXT1JLRVJTKQogCisj aW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgot CiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25Q dHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6 CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAg ICB9CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5 c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKQorICAg IHsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBwcml2YXRlOgogICAg IHZpcnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsK 67726 2010-09-15 15:17:33 -0700 2010-09-15 15:21:55 -0700 Patch bug-45808-20100915151732.patch text/plain 37493 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MmMyM2YxYjRhMmYzMjEwOTI1YTA2MDgxNTU5MTMwNGJiMWM1OGQ4Yy4uYzVlYzRkNjMxMTU4Yjdm NTk4MTRkYzliNGRhYzVkMzhlMjlmMDA2MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NCBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmZpbGVTeXN0 ZW1FbmFibGVkKTogQ2hhbmdlZCB0byByZWZsZWN0IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFi bGUKKyAgICAgICAgKiBiaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDoK KyAgICAgICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICogZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6fkxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaDoKKyAgICAgICAgKiBwYWdlL0RPTVdpbmRvdy5pZGw6CisgICAgICAg ICogcGFnZS9TZWN1cml0eU9yaWdpbi5oOgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmln aW46OmNhbkFjY2Vzc0ZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdz LmNwcDoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAgICAgICogd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlcXVlc3RG aWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6Cisg ICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKworICAgICAgICBBZGRlZCBOb1N0 YXRpY1RhYmxlcyBhbmQgY2hhbmdlZCBtb2R1bGVuYW1lIGZyb20gc3RvcmFnZSB0byBmaWxlYXBp OgorICAgICAgICAqIGZpbGVhcGkvRE9NRmlsZVN5c3RlbS5pZGw6CisgICAgICAgICogZmlsZWFw aS9EaXJlY3RvcnlFbnRyeS5pZGw6CisgICAgICAgICogZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIu aWRsOgorICAgICAgICAqIGZpbGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBm aWxlYXBpL0VudHJ5LmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0VudHJ5QXJyYXkuaWRsOgorICAg ICAgICAqIGZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGw6CisgICAgICAgICogZmlsZWFwaS9FcnJv ckNhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0ZpbGVFbnRyeS5pZGw6CisgICAgICAg ICogZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsOgorICAgICAgICAqIGZpbGVhcGkvRmxh Z3MuaWRsOgorICAgICAgICAqIGZpbGVhcGkvTWV0YWRhdGEuaWRsOgorICAgICAgICAqIGZpbGVh cGkvTWV0YWRhdGFDYWxsYmFjay5pZGw6CisKIDIwMTAtMDktMTQgIEtpbnVrbyBZYXN1ZGEgIDxr aW51a29AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IER1bWl0cnUgRGFuaWxp dWMuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5jcHAgYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0 dXJlcy5jcHAKaW5kZXggYTE1ZmQ2ZDA4MDJmYmVlZjExMDlmY2E5YzlkM2IyZjNkMzAyMGMwNC4u OWE5NmYyMjZkM2NmZjcyNzhjNzkyNjlhMWM4MmU0YWNjNzg0MDY0YiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCisrKyBiL1dl YkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcApAQCAtMzYs NiArMzYsMTAgQEAKICNpbmNsdWRlICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjaW5jbHVk ZSAiV2ViU29ja2V0LmgiCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBib29sIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzTG9jYWxTdG9yYWdlRW5hYmxlZCA9IHRydWU7CkBAIC01 Nyw2ICs2MSwxMSBAQCBib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzWEhSUmVzcG9uc2VC bG9iRW5hYmxlZCA9IGZhbHNlOwogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogYm9vbCBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjppc0ZpbGVTeXN0ZW1FbmFibGVkID0gZmFsc2U7CisKK2Jvb2wg UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZmlsZVN5c3RlbUVuYWJsZWQoKQoreworICAgIHJldHVy biBpc0ZpbGVTeXN0ZW1FbmFibGVkICYmIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKTsK K30KICNlbmRpZgogCiAjaWYgRU5BQkxFKFZJREVPKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5k aW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaCBiL1dlYkNvcmUvYmluZGluZ3Mv Z2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKaW5kZXggOTE3NjhiMGU1NGU3Zjk3YmFj ZDBhOWJkMzM5ZTFkYzQyMGQ2ZWRlZS4uYmE0YTRmYjA1ZGY1MWQ3NDQ0ZmI5YTNiYTEwMDJhZTQ3 YWJkNWZjOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFi bGVkRmVhdHVyZXMuaAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJs ZWRGZWF0dXJlcy5oCkBAIC0xNDgsNyArMTQ4LDcgQEAgcHVibGljOgogI2VuZGlmCiAKICNpZiBF TkFCTEUoRklMRV9TWVNURU0pCi0gICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKSB7 IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVkOyB9CisgICAgc3RhdGljIGJvb2wgZmlsZVN5c3Rl bUVuYWJsZWQoKTsKICAgICBzdGF0aWMgdm9pZCBzZXRGaWxlU3lzdGVtRW5hYmxlZChib29sIGlz RW5hYmxlZCkgeyBpc0ZpbGVTeXN0ZW1FbmFibGVkID0gaXNFbmFibGVkOyB9CiAgICAgc3RhdGlj IGJvb2wgcmVxdWVzdEZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lzdGVtRW5h YmxlZDsgfQogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRE9NRmlsZVN5c3Rl bS5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRE9NRmlsZVN5c3RlbS5pZGwKaW5kZXggYjczMDdlMmMx Njk5YzVjNjI4MDQ4MjUyMWQ3OTVjNzViMjQ2N2U3Ni4uZWEzM2YxNTJiMzQ1MDNiN2JlNjYwOWRm MzFjZDFkMzM4OGUxYzgzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0RPTUZpbGVTeXN0 ZW0uaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9ET01GaWxlU3lzdGVtLmlkbApAQCAtMjgsOSAr MjgsMTAgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxl IGZpbGVhcGkgewogICAgIGludGVyZmFjZSBbCi0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lT VEVNCisgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1Rh YmxlcwogICAgIF0gRE9NRmlsZVN5c3RlbSB7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBE T01TdHJpbmcgbmFtZTsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIERpcmVjdG9yeUVudHJ5 IHJvb3Q7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRsIGIv V2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeUVudHJ5LmlkbAppbmRleCA3YTBlZmRkZDM4OTFhY2Y1 ZjljNjk4NmNhOWViZWM0NmUyMzdkOGVlLi5jOTU5Njk0ZTUwYTE5NTU3YjAyYmNkNjEyOTJkMzcx MDA3NTUzNzdiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRs CisrKyBiL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlFbnRyeS5pZGwKQEAgLTI4LDExICsyOCwx MiBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmls ZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0s CiAgICAgICAgIEdlbmVyYXRlTmF0aXZlQ29udmVydGVyLAotICAgICAgICBHZW5lcmF0ZVRvSlMK KyAgICAgICAgR2VuZXJhdGVUb0pTLAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRGly ZWN0b3J5RW50cnkgOiBFbnRyeSB7CiAgICAgICAgIERpcmVjdG9yeVJlYWRlciBjcmVhdGVSZWFk ZXIoKTsKICAgICAgICAgW0N1c3RvbV0gdm9pZCBnZXRGaWxlKGluIFtDb252ZXJ0VW5kZWZpbmVk T3JOdWxsVG9OdWxsU3RyaW5nXSBET01TdHJpbmcgcGF0aCwgaW4gW09wdGlvbmFsXSBGbGFncyBm bGFncywgaW4gW09wdGlvbmFsLCBDYWxsYmFja10gRW50cnlDYWxsYmFjayBzdWNjZXNzQ2FsbGJh Y2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5UmVhZGVyLmlkbCBiL1dlYkNv cmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCmluZGV4IGMzYzcwMTIwMmRhMDhlYjRiYzFi NzU3MWQ2MjhhMTdmMmNmMzQxOTYuLmU1ZjUzYTY2ZTY2Mzk1ZDFiNWZjMzgzZDkwNTcyZDljZTVl Yzk1MDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCisr KyBiL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCkBAIC0yOCw5ICsyOCwxMCBA QAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFw aSB7CiAgICAgaW50ZXJmYWNlIFsKLSAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0KKyAg ICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAg ICAgXSBEaXJlY3RvcnlSZWFkZXIgewogICAgICAgICB2b2lkIHJlYWRFbnRyaWVzKGluIFtDYWxs YmFja10gRW50cmllc0NhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW09wdGlvbmFsLCBDYWxs YmFja10gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsKICAgICB9OwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9maWxlYXBpL0VudHJpZXNDYWxsYmFjay5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRW50 cmllc0NhbGxiYWNrLmlkbAppbmRleCA3M2IzNzRkNzkyOGVlNDgwNjYyZWMzOWMzM2M5YjFmMDRl ODY4MTM3Li5mOTE0YzQ4Mjg2MzYxMmEwMTZlOTc3OGVkYWM1MjRjNjA3NzBmYTZkIDEwMDY0NAot LS0gYS9XZWJDb3JlL2ZpbGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbAorKysgYi9XZWJDb3JlL2Zp bGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAogICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJm YWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIENhbGxiYWNr CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnkuaWRsIGIvV2ViQ29yZS9maWxlYXBp L0VudHJ5LmlkbAppbmRleCBiNjc0NDU1MTJhMDVkMjAwZTE5ZGJlY2VhMmU4ZDdmNzEzN2EyMzZh Li5hOTc4ZTY1OTNmNjFkNjgyNmJlNWUyNTE2ZjViMGNiNTMxZjIyOTMzIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvRW50cnkuaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeS5pZGwK QEAgLTI4LDEwICsyOCwxMSBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFn ZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9u YWw9RklMRV9TWVNURU0sCi0gICAgICAgIEN1c3RvbVRvSlMKKyAgICAgICAgQ3VzdG9tVG9KUywK KyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIEVudHJ5IHsKICAgICAgICAgcmVhZG9ubHkg YXR0cmlidXRlIGJvb2xlYW4gaXNGaWxlOwogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgYm9v bGVhbiBpc0RpcmVjdG9yeTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUFycmF5 LmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUFycmF5LmlkbAppbmRleCBlOTg3ZWNlZmViZWRi Y2FlZWJjM2E3ZjEyYjk3MDZlZTkzOGE0ZGYwLi5jYjcxOTM2ZGEzYWI3ZDA2ZGVkZTUzYzViZjY1 NzA3NjgxMTNhMjlmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnlBcnJheS5pZGwK KysrIGIvV2ViQ29yZS9maWxlYXBpL0VudHJ5QXJyYXkuaWRsCkBAIC0yOCwxMCArMjgsMTEgQEAK ICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkg ewogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAg ICAgICBIYXNJbmRleEdldHRlciwKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIEVudHJ5 QXJyYXkgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgdW5zaWduZWQgbG9uZyBsZW5ndGg7 CiAgICAgICAgIEVudHJ5IGl0ZW0oaW4gW0lzSW5kZXhdIHVuc2lnbmVkIGxvbmcgaW5kZXgpOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5Q2FsbGJhY2suaWRsIGIvV2ViQ29yZS9m aWxlYXBpL0VudHJ5Q2FsbGJhY2suaWRsCmluZGV4IGJlYTNmZDE0NzBlZDBjN2MwNGI5YjExZTJj NjEwNWNkZmY5YTRhNzkuLjRhODUzNGJjMWNiODAwNjUzMDk1MTEwYzI2NzMwOTA0NzVkYjUwOWYg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUNhbGxiYWNrLmlkbAorKysgYi9XZWJD b3JlL2ZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGlu dGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBDYWxs YmFjawpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0Vycm9yQ2FsbGJhY2suaWRsIGIvV2Vi Q29yZS9maWxlYXBpL0Vycm9yQ2FsbGJhY2suaWRsCmluZGV4IGZjN2ZhODVjNDA1ODI4YWY3Mjcy OTVmZWQ2ZjY2MDAwMjk0OGY3ODguLjdkMzM5MWU0MGM1OTk1NDQ0YmYyMzUxYmYxOWI5YmIzYTAz Y2VjMjAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FcnJvckNhbGxiYWNrLmlkbAorKysg Yi9XZWJDb3JlL2ZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewog ICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAg ICBDYWxsYmFjawpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0ZpbGVFbnRyeS5pZGwgYi9X ZWJDb3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbAppbmRleCA0MWI5YTkxOGFmZGVmYjFkYzE5NTNj OTNjY2MxN2U5NzAzNDhjMzA0Li5hZjRmMmE4NmJiZmRkOTgwZGZkZjQ0ZGIyNjkxYTZmMDEyYzNj ZDI0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbAorKysgYi9XZWJD b3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbApAQCAtMjgsMTEgKzI4LDEyIEBACiAgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRl cmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgR2VuZXJh dGVOYXRpdmVDb252ZXJ0ZXIsCi0gICAgICAgIEdlbmVyYXRlVG9KUworICAgICAgICBHZW5lcmF0 ZVRvSlMsCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBGaWxlRW50cnkgOiBFbnRyeSB7 CiAjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9XUklURVIpICYmIEVOQUJMRV9GSUxFX1dSSVRFUgog ICAgICAgICB2b2lkIGNyZWF0ZVdyaXRlcihpbiBbQ2FsbGJhY2tdIEZpbGVXcml0ZXJDYWxsYmFj ayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sg ZXJyb3JDYWxsYmFjayk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZVN5c3RlbUNh bGxiYWNrLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsCmluZGV4 IGNmNjg2ZmYxYmY1ZmQwODgzYmE2ODI0MTIzZWQ2MzAxODBmZDNlMjAuLjJlZjZhOTJmN2NjODQy YTYzNDc4OGJkN2ZmMTczMjg3N2FhOWE4MTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9G aWxlU3lzdGVtQ2FsbGJhY2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2Fs bGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVs ZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBD b25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZmlsZWFwaS9GbGFncy5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRmxhZ3MuaWRsCmluZGV4 IDI5NjU4YTFmZTY2NDRkN2M5MjE5NjZiZDVmODc5MmRmYWIwM2YxM2IuLmExN2JmY2E4MDIzYTE4 NTNjNzI0M2RkNjZkNWVlYTRjZjliMTQ2MTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9G bGFncy5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0ZsYWdzLmlkbApAQCAtMjgsMTAgKzI4LDEx IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxl YXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwK LSAgICAgICAgQ2FuQmVDb25zdHJ1Y3RlZAorICAgICAgICBDYW5CZUNvbnN0cnVjdGVkLAorICAg ICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRmxhZ3MgewogICAgICAgICBhdHRyaWJ1dGUgYm9v bGVhbiBjcmVhdGU7CiAgICAgICAgIGF0dHJpYnV0ZSBib29sZWFuIGV4Y2x1c2l2ZTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9maWxl YXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2ZDdiYjE5ZjFkNDgzOWU1ZWUz OTk2MDBmNmUwNDRmNi4uMDhmYWQ0NmZlYjc2MDI2NWNkM2RmNzk4ZDU3ZmZkMGZkNjA4NjlhYiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUwLDkgKzUwLDI5IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2FsRmls ZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCitzdGF0aWMgTG9jYWxGaWxl U3lzdGVtKiBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorewor ICAgIC8vIEZJWE1FOiBTaG91bGQgaW5pdGlhbGl6ZSB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2Vs bC4KKyAgICBBU1NFUlQoIXN0YXRpY0xvY2FsRmlsZVN5c3RlbSk7CisgICAgaWYgKHN0YXRpY0xv Y2FsRmlsZVN5c3RlbSkKKyAgICAgICAgcmV0dXJuOworCisgICAgc3RhdGljTG9jYWxGaWxlU3lz dGVtID0gbmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aCk7Cit9CisKK0xvY2FsRmlsZVN5c3Rl bSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQoreworICAgIGlmICghc3RhdGlj TG9jYWxGaWxlU3lzdGVtKQorICAgICAgICBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9j YWxGaWxlU3lzdGVtKCIiKTsKKworICAgIHJldHVybiAqc3RhdGljTG9jYWxGaWxlU3lzdGVtOwor fQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAog ewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7Cisg ICAgcmV0dXJuIG1fYmFzZVBhdGgudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAogc3RhdGljIHZvaWQg b3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYgYmFz ZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5 cGUsIFBhc3NPd25QdHI8RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQpAQCAtNjgsNyAr ODgsNyBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgIH0KIAogICAgIC8vIEFzeW5jRmls ZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNv IHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAgIGNvbnRl eHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIG1fYmFzZVBh dGgsIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBl LCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ss IGNvbnRleHQpKSk7CisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3Jp Z2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNr cyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiB9CiAKIH0gLy8g bmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgg Yi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggNDhjZmE4ZjY4ODZhNjBh NDAwNDQ0ZTJmY2ViZWE2OGNkNTIzZGJiNi4uZTNmNjg1MjM4MTIxZThkOTQ3MGRkMjZkYmU4NmJk Yzk0NDFkOWI5ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5o CisrKyBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaApAQCAtNDQsMTkgKzQ0LDMx IEBAIGNsYXNzIEVycm9yQ2FsbGJhY2s7CiBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7CiBjbGFz cyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogCi1jbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJs aWMgUmVmQ291bnRlZDxMb2NhbEZpbGVTeXN0ZW0+IHsKKy8vIEtlZXBzIHBlci1wcm9jZXNzIGlu Zm9ybWF0aW9uIGFuZCBwcm92aWRlcyBhbiBlbnRyeSBwb2ludCB0byBvcGVuIGEgZmlsZSBzeXN0 ZW0uCitjbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJsaWMgTm9uY29weWFibGUgewogcHVibGlj OgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0 cmluZyYgYmFzZVBhdGgpOwotICAgIHZpcnR1YWwgfkxvY2FsRmlsZVN5c3RlbSgpIHsgfQorICAg IC8vIFJldHVybnMgYSBwZXItcHJvY2VzcyBpbnN0YW5jZSBvZiBMb2NhbEZpbGVTeXN0ZW0uCisg ICAgLy8gTm90ZSB0aGF0IExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3Rl bSBtdXN0IGJlIGNhbGxlZCB0bworICAgIC8vIGluaXRpYWxpemUgdGhlIGJhc2UgcGF0aC4KKyAg ICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAogICAgIHZvaWQg cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVN5c3Rl bTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwg UGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAhUExBVEZPUk0o Q0hST01JVU0pCisgICAgLy8gVGhpcyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0 aHJlYWRzIGFyZSBjcmVhdGVkLgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShj b25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsK KyNlbmRpZgorCitwcml2YXRlOgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJh c2VQYXRoKQogICAgICAgICA6IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAor ICAgIC8vIFRoZSBtZW1iZXIgbWV0aG9kcyBzaG91bGRuJ3QgYWNjZXNzIHRoaXMgU3RyaW5nIGRp cmVjdGx5IGJ1dCBzaG91bGQgdXNlCisgICAgLy8gZmlsZVN5c3RlbUJhc2VQYXRoKCkgaW5zdGVh ZC4KICAgICBTdHJpbmcgbV9iYXNlUGF0aDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9NZXRhZGF0YS5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGEuaWRsCmluZGV4IGE1 YTkwYmM2NjcxMjliODlmN2ExMzFmNDZjMWM2MTJjMGJlMmYwZTUuLjMyYmM4NDdkNGUwNmE5Mjdh NDhjOTUwZmZiZDNlZGZlYTY1ZjNhZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9NZXRh ZGF0YS5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhLmlkbApAQCAtMjgsOSArMjgs MTAgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZp bGVhcGkgewogICAgIGludGVyZmFjZSBbCi0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVN CisgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1RhYmxl cwogICAgIF0gTWV0YWRhdGEgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRGF0ZSBtb2Rp ZmljYXRpb25UaW1lOwogICAgIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRh dGFDYWxsYmFjay5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGFDYWxsYmFjay5pZGwKaW5k ZXggNDRjYTE4MDU0MjBhNmFlMDU0ZmI0MWQ4NjhkM2ZmMDE1NzRkZmMzMy4uOTNjNmZmNTdlMzdl ZjlhYmFmYmIwY2FlN2VhNDM4MjdiMjcwNWQxNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBp L01ldGFkYXRhQ2FsbGJhY2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YUNhbGxi YWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUg c3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29u ZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIENhbGxiYWNrCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCmluZGV4 IDE1ZjNlZDE4MGU2ZmM3YzUyY2VlMjkwMGY1NTQyYzY4MWJlYThiZDkuLmIzN2RlNGJlNTc2MTQ0 ZTEyNzY3YjgzZTFmZTlhZjdlOGJkZTA0YmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCkBAIC03MjcsMjUgKzcy NywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcg bG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlmICghZG9jdW1lbnQpCiAgICAg ICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0ZW0pIHsKLSAgICAgICAgLy8g RklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAgICAgICBQYWdlKiBwYWdlID0g ZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7Ci0gICAgICAgICAgICBET01G aWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxl RXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAgICAgICAgICAgcmV0dXJuOwot ICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUgcXVvdGEgc2V0dGluZ3MgYXMg d2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0aW5ncygpLT5maWxlU3lzdGVt Um9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0gPSBMb2NhbEZpbGVTeXN0ZW06 OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8 fCBkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRmlsZVN5c3RlbSgpKSB7Cisg ICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9jdW1lbnQsIGVycm9yQ2Fs bGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAgICByZXR1cm47 CiAgICAgfQogCi0gICAgbV9sb2NhbEZpbGVTeXN0ZW0tPnJlcXVlc3RGaWxlU3lzdGVtKGRvY3Vt ZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNj ZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAgIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxG aWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19jYXN0PEFzeW5j RmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxs YmFjayk7CiB9CiAKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0g aW50KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7Ci1DT01QSUxF X0FTU0VSVChpbnQoRE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVt OjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2Fz dDxpbnQ+KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmls ZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChzdGF0 aWNfY2FzdDxpbnQ+KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihB c3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsKIAogI2VuZGlmCiAK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaCBiL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuaAppbmRleCAxNDcwNjI4NjVkOWI5Yjc3NDcxNjlhZmIyMTg0MWQ2NmYxMWQ5Y2Q0Li42 ZmQzNzc1MDNhYjRlZWYxZDllNzc1Zjk4MzA0ZDExMzFmYWZiMDNhIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmgKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCkBAIC01 OCw3ICs1OCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBIaXN0b3J5OwogICAg IGNsYXNzIElEQkZhY3Rvcnk7CiAgICAgY2xhc3MgSW5zcGVjdG9yVGltZWxpbmVBZ2VudDsKLSAg ICBjbGFzcyBMb2NhbEZpbGVTeXN0ZW07CiAgICAgY2xhc3MgTG9jYXRpb247CiAgICAgY2xhc3Mg U3R5bGVNZWRpYTsKICAgICBjbGFzcyBOYXZpZ2F0b3I7CkBAIC00NDQsOSArNDQzLDYgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQogICAgICAgICBt dXRhYmxlIFJlZlB0cjxJREJGYWN0b3J5PiBtX2lkYkZhY3Rvcnk7CiAjZW5kaWYKLSNpZiBFTkFC TEUoRklMRV9TWVNURU0pCi0gICAgICAgIFJlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IG1fbG9jYWxG aWxlU3lzdGVtOwotI2VuZGlmCiAKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1fZXZlbnRUYXJn ZXREYXRhOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbCBiL1dlYkNv cmUvcGFnZS9ET01XaW5kb3cuaWRsCmluZGV4IDdlNDhmOGM1MzExMmI2ZTAzMTdlMTEyNWFmNTFi MGY5MzUzMzRmMTMuLjA1MzAyNTAzNjQxNThkYjU1YmNiODM4MjczMDkzY2ZiZTgwZGIzMTYgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsCisrKyBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuaWRsCkBAIC0xOTMsNyArMTkzLDYgQEAgbW9kdWxlIHdpbmRvdyB7CiAgICAgICAg IGNvbnN0IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7CiAgICAgICAgIGNvbnN0IHVuc2ln bmVkIHNob3J0IFBFUlNJU1RFTlQgPSAxOwogICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0gdm9p ZCByZXF1ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxvbmcg c2l6ZSwgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3ND YWxsYmFjaywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxi YWNrKTsKLQogICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1bnRpbWU9RmlsZVN5c3RlbV0g RmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bh Z2UvU2VjdXJpdHlPcmlnaW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4 IDQ3ODlkM2NlMTFhMGEyMzE1NTYxOWFiYzEwNGViOTgxZGNlZDVlZWYuLjJhNjM5NjZkNDg3YmQz YTZiNzY2MzcxNjIzMzVjNThjOTc0NzE2NTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1 cml0eU9yaWdpbi5oCisrKyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0xMjEs NiArMTIxLDcgQEAgcHVibGljOgogICAgIGJvb2wgY2FuQWNjZXNzTG9jYWxTdG9yYWdlKCkgY29u c3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc0Nvb2tpZXMoKSBj b25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzUGFzc3dvcmRN YW5hZ2VyKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KKyAgICBib29sIGNhbkFjY2Vz c0ZpbGVTeXN0ZW0oKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogCiAgICAgLy8gVGVj aG5pY2FsbHksIHdlIHNob3VsZCBhbHdheXMgYWxsb3cgYWNjZXNzIHRvIHNlc3Npb25TdG9yYWdl LCBidXQgd2UKICAgICAvLyBjdXJyZW50bHkgZG9uJ3QgaGFuZGxlIGNyZWF0aW5nIGEgc2Vzc2lv blN0b3JhZ2UgYXJlYSBmb3IgdW5pcXVlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuY3BwIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCAzMjljNDdmMzlkMTYyMTM3 NzQxNjA4ZmI0MWExZjAwZTc4OTY4ZjEyLi5lMzQ2MDY5MDMzMTdkMjIxM2FlYjJkMzczZmYwZjQz YmUxMTk2YjNlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1dl YkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKQEAgLTQ5MCwxMSArNDkwLDYgQEAgdm9pZCBTZXR0aW5n czo6c2V0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkKICAgICBt X2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCA9IHBhdGg7CiB9CiAKLXZvaWQgU2V0dGluZ3M6OnNl dEZpbGVTeXN0ZW1Sb290UGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCi17Ci0gICAgbV9maWxlU3lz dGVtUm9vdFBhdGggPSBwYXRoOwotfQotCiB2b2lkIFNldHRpbmdzOjpzZXRBcHBsaWNhdGlvbkNo cm9tZU1vZGUoYm9vbCBtb2RlKQogewogICAgIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGUgPSBt b2RlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuaAppbmRleCA4ZWM1MTA2YmY0NGQ1YTI2NzM3YThmMzgxOTZjZmM1NzI0ZTU4MTVk Li43ZjVmZjdhMTNkMDIyY2ZiYTgwZmQ3ZjkzYWVlZWRmZTM5N2U0ZjA2IDEwMDY0NAotLS0gYS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAt MjM5LDkgKzIzOSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRMb2Nh bFN0b3JhZ2VEYXRhYmFzZVBhdGgoY29uc3QgU3RyaW5nJik7CiAgICAgICAgIGNvbnN0IFN0cmlu ZyYgbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9sb2NhbFN0b3Jh Z2VEYXRhYmFzZVBhdGg7IH0KIAotICAgICAgICB2b2lkIHNldEZpbGVTeXN0ZW1Sb290UGF0aChj b25zdCBTdHJpbmcmKTsKLSAgICAgICAgY29uc3QgU3RyaW5nJiBmaWxlU3lzdGVtUm9vdFBhdGgo KSBjb25zdCB7IHJldHVybiBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsgfQotCiAgICAgICAgIHZvaWQg c2V0QXBwbGljYXRpb25DaHJvbWVNb2RlKGJvb2wpOwogICAgICAgICBib29sIGluQXBwbGljYXRp b25DaHJvbWVNb2RlKCkgY29uc3QgeyByZXR1cm4gbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZTsg fQogCkBAIC0zMzEsNyArMzI4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBTdHJp bmcgbV9kZWZhdWx0VGV4dEVuY29kaW5nTmFtZTsKICAgICAgICAgU3RyaW5nIG1fZnRwRGlyZWN0 b3J5VGVtcGxhdGVQYXRoOwogICAgICAgICBTdHJpbmcgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBh dGg7Ci0gICAgICAgIFN0cmluZyBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsKICAgICAgICAgS1VSTCBt X3VzZXJTdHlsZVNoZWV0TG9jYXRpb247CiAgICAgICAgIEF0b21pY1N0cmluZyBtX3N0YW5kYXJk Rm9udEZhbWlseTsKICAgICAgICAgQXRvbWljU3RyaW5nIG1fZml4ZWRGb250RmFtaWx5OwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9w bGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCmluZGV4IGI0ZmNkMGQ0ZDliNGZiY2VkOTQ2MTM4 NWMxM2E2Y2ViYjY5ZmM3YWYuLjg3OTA1NTZjNzU0NDAyY2ZhZjQ2YmFjYTQwM2M0OGU4OGZjMTc4 OTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAorKysg Yi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKQEAgLTM4LDkgKzM4LDE2IEBA CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorI2lmICFQTEFURk9STShDSFJPTUlVTSkKK2Jvb2wg QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7CisgICAgLy8gRWFjaCBwbGF0Zm9ybSBz aG91bGQgaW1wbGVtZW50IHRoaXMuCisgICAgcmV0dXJuIGZhbHNlOworfQorCiBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJikK IHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1bHQgQXN5bmNGaWxlU3lzdGVtIGltcGxlbWVu dGF0aW9uLgorICAgIC8vIEVhY2ggcGxhdGZvcm0gc2hvdWxkIGltcGxlbWVudCB0aGlzLgogICAg IHJldHVybiAwOwogfQogCkBAIC02Miw2ICs2OSw3IEBAIHZvaWQgQXN5bmNGaWxlU3lzdGVtOjpv cGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIHN0b3Jh CiAKICAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIEFzeW5jRmlsZVN5c3Rl bTo6Y3JlYXRlKHJvb3RQYXRoKSk7CiB9CisjZW5kaWYKIAogLy8gRGVmYXVsdCBpbXBsZW1lbnRh dGlvbi4KIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW06OnZpcnR1YWxUb1BsYXRmb3JtUGF0aChjb25z dCBTdHJpbmcmIHBhdGgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5j RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaAppbmRleCA2 MDFmMGVhZTNlNWQwZThiZWI4NGQ1YTk5M2Q3NzA1MTdiZDBhNjJkLi44YzRkNWQ5OTBmZGE0NmMy Yjc4MGRmOWIwOWE2MDc3ZTU0ZDlmZjU1IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0Fz eW5jRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgK QEAgLTU2LDYgKzU2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCkgeyB9CiAg ICAgdmlydHVhbCBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIHsgcmV0dXJuIGZhbHNlOyB9CiAK KyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgLy8gQ3JlYXRlcyBhbmQgcmV0 dXJucyBhIG5ldyBwbGF0Zm9ybS1zcGVjaWZpYyBBc3luY0ZpbGVTeXN0ZW0gaW5zdGFuY2UgaWYg dGhlIHBsYXRmb3JtIGhhcyBpdHMgb3duIGltcGxlbWVudGF0aW9uLgogICAgIHN0YXRpYyBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmluZyYgcm9vdFBhdGgpOwog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAgYi9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5kZXggYjUyYjI4NTQ3NWYyZWY5NDc3ZTgxNGJi ZTRkOGJlYjljM2I5ZWEwYS4uMmJkOWI0MGFiNDJjNzU4NmQ4OTAyODczYWYwZThlMDQ4YTMxMjZk ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCisrKyBiL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtNjMsNiArNjMsMTUgQEAKICNpbmNs dWRlICJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lT VEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgIkRPTUZpbGVTeXN0 ZW0uaCIKKyNpbmNsdWRlICJFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVkZSAiRmlsZUVycm9yLmgi CisjaW5jbHVkZSAiRmlsZVN5c3RlbUNhbGxiYWNrLmgiCisjaW5jbHVkZSAiTG9jYWxGaWxlU3lz dGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBDbG9zZVdvcmtl ckNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgewpAQCAt MzM1LDYgKzM0NCwyMSBAQCB2b2lkIFdvcmtlckNvbnRleHQ6OnJldm9rZUJsb2JVUkwoY29uc3Qg U3RyaW5nJiBibG9iVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNU RU0pCit2b2lkIFdvcmtlckNvbnRleHQ6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25n IGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFj aywgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQoreworICAgIGlmICgh QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8IHNlY3VyaXR5T3JpZ2luKCktPmNhbkFj Y2Vzc0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxi YWNrKHRoaXMsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZp bGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVT eXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2sp OworfQorCitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRF TVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSks IGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJD b250ZXh0OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6 UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgK aW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGQyZjUxOWQy NTc0MWM4NjViMGY5MDY5ZThlZmNjZTg1ZjczNTk3NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5o CkBAIC00Nyw2ICs0Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFz ZTsKICAgICBjbGFzcyBEYXRhYmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsK KyAgICBjbGFzcyBFcnJvckNhbGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsK ICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9u OwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNSBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmKTsK ICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFyZSBw bGFjZWQgaGVyZSBhbmQgaW4gYWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBpbGUt dGltZSBlbnVtIGNoZWNraW5nLgorICAgICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAgICAg ICAgICAgIFRFTVBPUkFSWSwKKyAgICAgICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07Cisg ICAgICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQ YXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4p OworI2VuZGlmCisKICAgICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFy a2luZy4gU2VlIEpTV29ya2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAg ICAgICAgIC8vIEpTV29ya2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmln YXRvciogb3B0aW9uYWxOYXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQo KTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsIGIvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJkZjY3ZjI3 ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjljOWVlYzBlODQxYTIzZTYwNTA1ZjM1N2QzOWEwMjRkZTgx YzRiMzYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAorKysg Yi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQsMTMgQEAg bW9kdWxlIHRocmVhZHMgewogICAgICAgICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChpbiBCbG9i IGJsb2IpOwogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJsb2JVUkwp OwogI2VuZGlmCisKKyNpZiBkZWZpbmVkKEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5BQkxFX0ZJ TEVfU1lTVEVNCisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7Cisg ICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAgICBbRW5h YmxlZEF0UnVudGltZV0gdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0 eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3Rl bUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JD YWxsYmFjayBlcnJvckNhbGxiYWNrKTsKKyAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50 aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9Owog CiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwppbmRleCBiMmI5MjE0YjNmZDkwMTc4MGQ1Y2Q1ZDQwNGI0NDFiY2U1OWIy MjkxLi43YmM4MjQwMDEzMzM3YjIxNGVmOGY2Y2M4OTZlYjFkYzZjYzVhYWUzIDEwMDY0NAotLS0g YS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0xNSAgS2ludWtvIFlhc3VkYSAgPGtpbnVrb0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lzdGVtIEFQSQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU4MDgKKworICAgICAgICAqIHB1 YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViQ29tbW9u V29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAgICAqIHNyYy9Mb2Nh bEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0 ZW06OmxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06 OnJlcXVlc3RGaWxlU3lzdGVtKToKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisg ICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuaDoKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQ2xp ZW50SW1wbC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJDbGllbnRJbXBsOjpvcGVuRmls ZVN5c3RlbSk6IEFkZGVkLgorCiAyMDEwLTA5LTE0ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZp ZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjc1 MDMuCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNs aWVudC5oIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApp bmRleCBjZWE2NDcxMjNhNTJmNTAzMjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi5kOWQxNmM2MzEx MDc4NjgzODZkM2NlMjBjODVlY2MwYmM2OTA2ODk5IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYg V2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gK IAorI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwog bmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAt ODMsNiArODYsMTMgQEAgcHVibGljOgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQg dGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBh bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAor ICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEg ZmlsZSBzeXN0ZW0uCisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwg V2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFj a3MqKQorICAgIHsKKyAgICAgICAgLy8gRklYTUU6IFdlIG5lZWQgYSBzdHViIGltcGxlbWVudGF0 aW9uIHVudGlsIHN1YmNsYXNzIGluIGNocm9taXVtIGltcGxlbWVudCB0aGlzLgorICAgICAgICBX RUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCiBwcm90ZWN0ZWQ6CiAgICAgfldl YkNvbW1vbldvcmtlckNsaWVudCgpIHsgfQogfTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9B c3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggMDhmY2VhNmM5ODVhYzMyMWQyOTE2YzNj MmUyZGE2ZmM4ZDQ4ZTgzZi4uMGI3NTNiM2QxNTJjMWI2NWM3ZmMxNWY5YTM1M2NmYzUxYTYzNjRi YSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1 bS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAKQEAgLTQzLDYgKzQzLDExIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorYm9vbCBBc3lu Y0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogQXN5 bmNGaWxlU3lzdGVtQ2hyb21pdW06OkFzeW5jRmlsZVN5c3RlbUNocm9taXVtKGNvbnN0IFN0cmlu ZyYgcm9vdFBhdGgpCiAgICAgOiBBc3luY0ZpbGVTeXN0ZW0ocm9vdFBhdGgpCiAgICAgLCBtX3dl YkZpbGVTeXN0ZW0oV2ViS2l0Ojp3ZWJLaXRDbGllbnQoKS0+ZmlsZVN5c3RlbSgpKQpkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCA0NTM2 NWVmMmU2NzlkOTkwYmIzYWViZGYzZWNhOWNlODIyMGYyNWIyLi45OTg0M2VhYTk5YzQyMDUwYzQ1 MTI4NjQyYTAwNDU1MGM5YTY3OGRiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xv Y2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2Fs RmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDIsMTQgKzQyLDE4IEBACiAjaW5jbHVkZSAiV2Vi RmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgog I2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgorI2luY2x1ZGUgIldlYldvcmtlckltcGwuaCIKKyNp bmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAKIHVz aW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0 cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYg cGF0aCkKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0o KQogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAg ICBERUZJTkVfU1RBVElDX0xPQ0FMKExvY2FsRmlsZVN5c3RlbSwgbG9jYWxGaWxlU3lzdGVtLCAo IiIpKTsKKyAgICByZXR1cm4gbG9jYWxGaWxlU3lzdGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5 c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg QXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZp bGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJh Y2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2NCwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5 bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9t RnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAgICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9w ZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0 eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVt Q2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAg ICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTogQWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3Jr ZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8 V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAgICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29y a2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclBy b3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2UqIHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdl YldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94eSk7CisgICAgICAgIHdlYldvcmtlci0+b3Bl bkZpbGVTeXN0ZW0oMCwgc3RhdGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNp emUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxiYWNr cyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfQogfQog CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCA0MmY0MWQyZGM3OWI0ZTNl NDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi5hZjMwMDBhYmFiYmJiZDRhMTJmYWJlZTdjNjJmYjU2 Y2QzYjgwNDcxIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu Y3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTM3LDYg KzM3LDggQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5j bHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNp bmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGll bnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJNZXNzYWdlUG9y dENoYW5uZWwuaCIKQEAgLTU2LDYgKzU4LDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAjaWYgRU5B QkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAi YWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0ZW1Nb2Rl W10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKKwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiAr MTE4LDEwNSBAQCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdU Rjo6U3RyaW5nIG1fbW9kZTsKIH07CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEg b3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQuCisvLyBUaGlzIG11c3Qg YmUgZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVt TWFpblRocmVhZEJyaWRnZSB7CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgc3RhcnQoV2ViV29y a2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2Vi RnJhbWUqIGZyYW1lLCBjb25zdCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlw ZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tz KQorICAgIHsKKyAgICAgICAgLy8gVGhpcyBjbGFzcyBpcyBzZWxmLWRlc3RydWN0ZWQuCisgICAg ICAgIEFTU0VSVChuZXcgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgY29t bW9uQ2xpZW50LCBmcmFtZSwgbW9kZSwgdHlwZSwgc2l6ZSwgY2FsbGJhY2tzKSk7CisgICAgfQor CisgICAgfk9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSgpCisgICAgeworICAgICAgICBB U1NFUlQoIW1fd29ya2VyQ29udGV4dENhbGxiYWNrcyk7CisgICAgfQorCitwcml2YXRlOgorICAg IE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdl YkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0 IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBz aXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgICAgIDogbV93b3Jr ZXIod29ya2VyKQorICAgICAgICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNrcyhjYWxsYmFja3Mp CisgICAgICAgICwgbV9tb2RlKG1vZGUpCisgICAgeworICAgICAgICB3b3JrZXItPmRpc3BhdGNo VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWlu VGhyZWFkLCB3b3JrZXIsIGNvbW1vbkNsaWVudCwgZnJhbWUsIHR5cGUsIHNpemUsIHRoaXMpKTsK KyAgICB9CisKKyAgICBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJD b3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJD b21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBPcGVuRmlsZVN5c3RlbU1haW5UaHJl YWRCcmlkZ2UqIGJyaWRnZSkKKyAgICB7CisgICAgICAgIGlmICghY29tbW9uQ2xpZW50KQorICAg ICAgICAgICAgYnJpZGdlLT5kaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvckFib3J0KTsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgY29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbShm cmFtZSwgdHlwZSwgc2l6ZSwgbmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRn ZSkpOworICAgIH0KKworICAgIC8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhhdCBhcmUgZGlzcGF0 Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1D YWxsYmFja3MgOiBwdWJsaWMgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyB7CisgICAgcHVibGljOgor ICAgICAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNzT3duUHRyPE9wZW5GaWxl U3lzdGVtTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlKQorICAgICAgICAgICAgOiBtX2JyaWRnZShi cmlkZ2UpCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgfk1haW5UaHJl YWRGaWxlU3lzdGVtQ2FsbGJhY2tzKCkKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKG1fYnJp ZGdlKQorICAgICAgICAgICAgICAgIGRpZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAg ICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFdlYlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgICAgICB7CisgICAgICAgICAg ICBBU1NFUlQobV9icmlkZ2UpOworICAgICAgICAgICAgbV9icmlkZ2UubGVha1B0cigpLT5kaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChuYW1lLCBwYXRoKTsKKyAgICAgICAgICAgIGRlbGV0 ZSB0aGlzOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoV2ViRmls ZUVycm9yIGVycm9yKQorICAgICAgICB7CisgICAgICAgICAgICBBU1NFUlQobV9icmlkZ2UpOwor ICAgICAgICAgICAgbV9icmlkZ2UubGVha1B0cigpLT5kaWRGYWlsT25NYWluVGhyZWFkKGVycm9y KTsKKyAgICAgICAgICAgIGRlbGV0ZSB0aGlzOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVh bCB2b2lkIGRpZFN1Y2NlZWQoKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAg ICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZE1ldGFkYXRhKGNvbnN0IFdlYkZpbGVJbmZvJikgeyBX RUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJl YWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZpbGVTeXN0ZW1FbnRyeT4mLCBib29sKSB7 IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAg T3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZT4gbV9icmlkZ2U7CisgICAgfTsK KyAgICBmcmllbmQgY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICBz dGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSogYnJpZGdlUHRyLCBXZWJG aWxlRXJyb3IgZXJyb3IpCisgICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWlu VGhyZWFkQnJpZGdlPiBicmlkZ2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtl ckNvbnRleHRDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3IpOworICAgICAgICBicmlkZ2UtPm1fd29y a2VyQ29udGV4dENhbGxiYWNrcyA9IDA7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgZGlkT3Bl bkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKiBicmlkZ2VQdHIsIGNvbnN0IFdURjo6 U3RyaW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAg ICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UoYnJpZGdlUHRy KTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRDYWxsYmFja3MtPmRpZE9wZW5GaWxl U3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRD YWxsYmFja3MgPSAwOworICAgIH0KKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJG aWxlRXJyb3IgZXJyb3IpCisgICAgeworICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2Rl VG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29ya2VyVGhyZWFk LCB0aGlzLCBlcnJvciksIG1fbW9kZSk7CisgICAgfQorCisgICAgdm9pZCBkaWRPcGVuRmlsZVN5 c3RlbU9uTWFpblRocmVhZChjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3QgV1RGOjpTdHJp bmcmIHJvb3RQYXRoKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRv V29ya2VyQ29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZE9wZW5GaWxlU3lzdGVtT25Xb3Jr ZXJUaHJlYWQsIHRoaXMsIG5hbWUsIHJvb3RQYXRoKSwgbV9tb2RlKTsKKyAgICB9CisKKyAgICBX ZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBtX3dv cmtlckNvbnRleHRDYWxsYmFja3M7CisgICAgV1RGOjpTdHJpbmcgbV9tb2RlOworfTsKKwogfQog CiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2Ug dG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwpAQCAtMjMxLDYgKzMzNCwxNCBAQCBib29sIFdlYldv cmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUs IGNvbnN0IFdlYlN0cgogICAgIHJldHVybiBicmlkZ2UtPnJlc3VsdCgpOwogfQogCit2b2lkIFdl YldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3RlbTo6VHlw ZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tz KQoreworICAgIEFTU0VSVChtX3dlYlZpZXcpOworCisgICAgLy8gVGhlIG1haW5GcmFtZSBpcyB1 c2VkIHRvIGNoZWNrIHRoZSBzZWN1cml0eSBvcmlnaW4uCisgICAgT3BlbkZpbGVTeXN0ZW1NYWlu VGhyZWFkQnJpZGdlOjpzdGFydCh0aGlzLCBjb21tb25DbGllbnQoKSwgbV93ZWJWaWV3LT5tYWlu RnJhbWUoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplLCBjYWxsYmFja3MpOworfQor CiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNz YWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3Nh Z2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlmMjJjZjcwNmJk ZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLmU5OGRhZjE4ZjBlYTE2MmE5YWJjZjg4NWE5NDRkMmY1 ZGZlOWY5MTQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05MSw2ICs5MSw5 IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJh c2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0Rh dGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcm IGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisgICAgLy8gUmVx dWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4KKyAgICB2aXJ0dWFs IHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25n IGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAgLy8gRXhlY3V0ZXMg dGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3Bh dGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3Jr ZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwu aAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVmNTQ1Li4wNjA0ODIz NWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAjaWYgRU5BQkxFKFdP UktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiV2ViV29ya2Vy Q2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIKICNpbmNsdWRlIDx3 dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAgLTk5LDYgKzk5LDEw IEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJldHVy biB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUq LCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CiAKIHBy aXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwo= 67729 2010-09-15 15:21:58 -0700 2010-09-16 17:12:41 -0700 Patch bug-45808-20100915152157.patch text/plain 37495 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MmMyM2YxYjRhMmYzMjEwOTI1YTA2MDgxNTU5MTMwNGJiMWM1OGQ4Yy4uYzVlYzRkNjMxMTU4Yjdm NTk4MTRkYzliNGRhYzVkMzhlMjlmMDA2MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NCBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmZpbGVTeXN0 ZW1FbmFibGVkKTogQ2hhbmdlZCB0byByZWZsZWN0IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFi bGUKKyAgICAgICAgKiBiaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDoK KyAgICAgICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICogZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6fkxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaDoKKyAgICAgICAgKiBwYWdlL0RPTVdpbmRvdy5pZGw6CisgICAgICAg ICogcGFnZS9TZWN1cml0eU9yaWdpbi5oOgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmln aW46OmNhbkFjY2Vzc0ZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdz LmNwcDoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAgICAgICogd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlcXVlc3RG aWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6Cisg ICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKworICAgICAgICBBZGRlZCBOb1N0 YXRpY1RhYmxlcyBhbmQgY2hhbmdlZCBtb2R1bGVuYW1lIGZyb20gc3RvcmFnZSB0byBmaWxlYXBp OgorICAgICAgICAqIGZpbGVhcGkvRE9NRmlsZVN5c3RlbS5pZGw6CisgICAgICAgICogZmlsZWFw aS9EaXJlY3RvcnlFbnRyeS5pZGw6CisgICAgICAgICogZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIu aWRsOgorICAgICAgICAqIGZpbGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBm aWxlYXBpL0VudHJ5LmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0VudHJ5QXJyYXkuaWRsOgorICAg ICAgICAqIGZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGw6CisgICAgICAgICogZmlsZWFwaS9FcnJv ckNhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0ZpbGVFbnRyeS5pZGw6CisgICAgICAg ICogZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsOgorICAgICAgICAqIGZpbGVhcGkvRmxh Z3MuaWRsOgorICAgICAgICAqIGZpbGVhcGkvTWV0YWRhdGEuaWRsOgorICAgICAgICAqIGZpbGVh cGkvTWV0YWRhdGFDYWxsYmFjay5pZGw6CisKIDIwMTAtMDktMTQgIEtpbnVrbyBZYXN1ZGEgIDxr aW51a29AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IER1bWl0cnUgRGFuaWxp dWMuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5jcHAgYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0 dXJlcy5jcHAKaW5kZXggYTE1ZmQ2ZDA4MDJmYmVlZjExMDlmY2E5YzlkM2IyZjNkMzAyMGMwNC4u OWE5NmYyMjZkM2NmZjcyNzhjNzkyNjlhMWM4MmU0YWNjNzg0MDY0YiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCisrKyBiL1dl YkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcApAQCAtMzYs NiArMzYsMTAgQEAKICNpbmNsdWRlICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjaW5jbHVk ZSAiV2ViU29ja2V0LmgiCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBib29sIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzTG9jYWxTdG9yYWdlRW5hYmxlZCA9IHRydWU7CkBAIC01 Nyw2ICs2MSwxMSBAQCBib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzWEhSUmVzcG9uc2VC bG9iRW5hYmxlZCA9IGZhbHNlOwogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogYm9vbCBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjppc0ZpbGVTeXN0ZW1FbmFibGVkID0gZmFsc2U7CisKK2Jvb2wg UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZmlsZVN5c3RlbUVuYWJsZWQoKQoreworICAgIHJldHVy biBpc0ZpbGVTeXN0ZW1FbmFibGVkICYmIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKTsK K30KICNlbmRpZgogCiAjaWYgRU5BQkxFKFZJREVPKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5k aW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaCBiL1dlYkNvcmUvYmluZGluZ3Mv Z2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKaW5kZXggOTE3NjhiMGU1NGU3Zjk3YmFj ZDBhOWJkMzM5ZTFkYzQyMGQ2ZWRlZS4uYmE0YTRmYjA1ZGY1MWQ3NDQ0ZmI5YTNiYTEwMDJhZTQ3 YWJkNWZjOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFi bGVkRmVhdHVyZXMuaAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJs ZWRGZWF0dXJlcy5oCkBAIC0xNDgsNyArMTQ4LDcgQEAgcHVibGljOgogI2VuZGlmCiAKICNpZiBF TkFCTEUoRklMRV9TWVNURU0pCi0gICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKSB7 IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVkOyB9CisgICAgc3RhdGljIGJvb2wgZmlsZVN5c3Rl bUVuYWJsZWQoKTsKICAgICBzdGF0aWMgdm9pZCBzZXRGaWxlU3lzdGVtRW5hYmxlZChib29sIGlz RW5hYmxlZCkgeyBpc0ZpbGVTeXN0ZW1FbmFibGVkID0gaXNFbmFibGVkOyB9CiAgICAgc3RhdGlj IGJvb2wgcmVxdWVzdEZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lzdGVtRW5h YmxlZDsgfQogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRE9NRmlsZVN5c3Rl bS5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRE9NRmlsZVN5c3RlbS5pZGwKaW5kZXggYjczMDdlMmMx Njk5YzVjNjI4MDQ4MjUyMWQ3OTVjNzViMjQ2N2U3Ni4uZWEzM2YxNTJiMzQ1MDNiN2JlNjYwOWRm MzFjZDFkMzM4OGUxYzgzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0RPTUZpbGVTeXN0 ZW0uaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9ET01GaWxlU3lzdGVtLmlkbApAQCAtMjgsOSAr MjgsMTAgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxl IGZpbGVhcGkgewogICAgIGludGVyZmFjZSBbCi0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lT VEVNCisgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1Rh YmxlcwogICAgIF0gRE9NRmlsZVN5c3RlbSB7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBE T01TdHJpbmcgbmFtZTsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIERpcmVjdG9yeUVudHJ5 IHJvb3Q7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRsIGIv V2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeUVudHJ5LmlkbAppbmRleCA3YTBlZmRkZDM4OTFhY2Y1 ZjljNjk4NmNhOWViZWM0NmUyMzdkOGVlLi5jOTU5Njk0ZTUwYTE5NTU3YjAyYmNkNjEyOTJkMzcx MDA3NTUzNzdiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRs CisrKyBiL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlFbnRyeS5pZGwKQEAgLTI4LDExICsyOCwx MiBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmls ZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0s CiAgICAgICAgIEdlbmVyYXRlTmF0aXZlQ29udmVydGVyLAotICAgICAgICBHZW5lcmF0ZVRvSlMK KyAgICAgICAgR2VuZXJhdGVUb0pTLAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRGly ZWN0b3J5RW50cnkgOiBFbnRyeSB7CiAgICAgICAgIERpcmVjdG9yeVJlYWRlciBjcmVhdGVSZWFk ZXIoKTsKICAgICAgICAgW0N1c3RvbV0gdm9pZCBnZXRGaWxlKGluIFtDb252ZXJ0VW5kZWZpbmVk T3JOdWxsVG9OdWxsU3RyaW5nXSBET01TdHJpbmcgcGF0aCwgaW4gW09wdGlvbmFsXSBGbGFncyBm bGFncywgaW4gW09wdGlvbmFsLCBDYWxsYmFja10gRW50cnlDYWxsYmFjayBzdWNjZXNzQ2FsbGJh Y2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5UmVhZGVyLmlkbCBiL1dlYkNv cmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCmluZGV4IGMzYzcwMTIwMmRhMDhlYjRiYzFi NzU3MWQ2MjhhMTdmMmNmMzQxOTYuLmU1ZjUzYTY2ZTY2Mzk1ZDFiNWZjMzgzZDkwNTcyZDljZTVl Yzk1MDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCisr KyBiL1dlYkNvcmUvZmlsZWFwaS9EaXJlY3RvcnlSZWFkZXIuaWRsCkBAIC0yOCw5ICsyOCwxMCBA QAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFw aSB7CiAgICAgaW50ZXJmYWNlIFsKLSAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0KKyAg ICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAg ICAgXSBEaXJlY3RvcnlSZWFkZXIgewogICAgICAgICB2b2lkIHJlYWRFbnRyaWVzKGluIFtDYWxs YmFja10gRW50cmllc0NhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW09wdGlvbmFsLCBDYWxs YmFja10gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsKICAgICB9OwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9maWxlYXBpL0VudHJpZXNDYWxsYmFjay5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRW50 cmllc0NhbGxiYWNrLmlkbAppbmRleCA3M2IzNzRkNzkyOGVlNDgwNjYyZWMzOWMzM2M5YjFmMDRl ODY4MTM3Li5mOTE0YzQ4Mjg2MzYxMmEwMTZlOTc3OGVkYWM1MjRjNjA3NzBmYTZkIDEwMDY0NAot LS0gYS9XZWJDb3JlL2ZpbGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbAorKysgYi9XZWJDb3JlL2Zp bGVhcGkvRW50cmllc0NhbGxiYWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAogICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJm YWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIENhbGxiYWNr CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnkuaWRsIGIvV2ViQ29yZS9maWxlYXBp L0VudHJ5LmlkbAppbmRleCBiNjc0NDU1MTJhMDVkMjAwZTE5ZGJlY2VhMmU4ZDdmNzEzN2EyMzZh Li5hOTc4ZTY1OTNmNjFkNjgyNmJlNWUyNTE2ZjViMGNiNTMxZjIyOTMzIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvRW50cnkuaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeS5pZGwK QEAgLTI4LDEwICsyOCwxMSBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFn ZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9u YWw9RklMRV9TWVNURU0sCi0gICAgICAgIEN1c3RvbVRvSlMKKyAgICAgICAgQ3VzdG9tVG9KUywK KyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIEVudHJ5IHsKICAgICAgICAgcmVhZG9ubHkg YXR0cmlidXRlIGJvb2xlYW4gaXNGaWxlOwogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgYm9v bGVhbiBpc0RpcmVjdG9yeTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUFycmF5 LmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUFycmF5LmlkbAppbmRleCBlOTg3ZWNlZmViZWRi Y2FlZWJjM2E3ZjEyYjk3MDZlZTkzOGE0ZGYwLi5jYjcxOTM2ZGEzYWI3ZDA2ZGVkZTUzYzViZjY1 NzA3NjgxMTNhMjlmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnlBcnJheS5pZGwK KysrIGIvV2ViQ29yZS9maWxlYXBpL0VudHJ5QXJyYXkuaWRsCkBAIC0yOCwxMCArMjgsMTEgQEAK ICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkg ewogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAg ICAgICBIYXNJbmRleEdldHRlciwKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIEVudHJ5 QXJyYXkgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgdW5zaWduZWQgbG9uZyBsZW5ndGg7 CiAgICAgICAgIEVudHJ5IGl0ZW0oaW4gW0lzSW5kZXhdIHVuc2lnbmVkIGxvbmcgaW5kZXgpOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5Q2FsbGJhY2suaWRsIGIvV2ViQ29yZS9m aWxlYXBpL0VudHJ5Q2FsbGJhY2suaWRsCmluZGV4IGJlYTNmZDE0NzBlZDBjN2MwNGI5YjExZTJj NjEwNWNkZmY5YTRhNzkuLjRhODUzNGJjMWNiODAwNjUzMDk1MTEwYzI2NzMwOTA0NzVkYjUwOWYg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUNhbGxiYWNrLmlkbAorKysgYi9XZWJD b3JlL2ZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGlu dGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBDYWxs YmFjawpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0Vycm9yQ2FsbGJhY2suaWRsIGIvV2Vi Q29yZS9maWxlYXBpL0Vycm9yQ2FsbGJhY2suaWRsCmluZGV4IGZjN2ZhODVjNDA1ODI4YWY3Mjcy OTVmZWQ2ZjY2MDAwMjk0OGY3ODguLjdkMzM5MWU0MGM1OTk1NDQ0YmYyMzUxYmYxOWI5YmIzYTAz Y2VjMjAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9FcnJvckNhbGxiYWNrLmlkbAorKysg Yi9XZWJDb3JlL2ZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewog ICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAg ICBDYWxsYmFjawpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0ZpbGVFbnRyeS5pZGwgYi9X ZWJDb3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbAppbmRleCA0MWI5YTkxOGFmZGVmYjFkYzE5NTNj OTNjY2MxN2U5NzAzNDhjMzA0Li5hZjRmMmE4NmJiZmRkOTgwZGZkZjQ0ZGIyNjkxYTZmMDEyYzNj ZDI0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbAorKysgYi9XZWJD b3JlL2ZpbGVhcGkvRmlsZUVudHJ5LmlkbApAQCAtMjgsMTEgKzI4LDEyIEBACiAgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRl cmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgR2VuZXJh dGVOYXRpdmVDb252ZXJ0ZXIsCi0gICAgICAgIEdlbmVyYXRlVG9KUworICAgICAgICBHZW5lcmF0 ZVRvSlMsCisgICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBGaWxlRW50cnkgOiBFbnRyeSB7 CiAjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9XUklURVIpICYmIEVOQUJMRV9GSUxFX1dSSVRFUgog ICAgICAgICB2b2lkIGNyZWF0ZVdyaXRlcihpbiBbQ2FsbGJhY2tdIEZpbGVXcml0ZXJDYWxsYmFj ayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sg ZXJyb3JDYWxsYmFjayk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZVN5c3RlbUNh bGxiYWNrLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsCmluZGV4 IGNmNjg2ZmYxYmY1ZmQwODgzYmE2ODI0MTIzZWQ2MzAxODBmZDNlMjAuLjJlZjZhOTJmN2NjODQy YTYzNDc4OGJkN2ZmMTczMjg3N2FhOWE4MTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9G aWxlU3lzdGVtQ2FsbGJhY2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2Fs bGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVs ZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBD b25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZmlsZWFwaS9GbGFncy5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRmxhZ3MuaWRsCmluZGV4 IDI5NjU4YTFmZTY2NDRkN2M5MjE5NjZiZDVmODc5MmRmYWIwM2YxM2IuLmExN2JmY2E4MDIzYTE4 NTNjNzI0M2RkNjZkNWVlYTRjZjliMTQ2MTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9G bGFncy5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0ZsYWdzLmlkbApAQCAtMjgsMTAgKzI4LDEx IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxl YXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwK LSAgICAgICAgQ2FuQmVDb25zdHJ1Y3RlZAorICAgICAgICBDYW5CZUNvbnN0cnVjdGVkLAorICAg ICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRmxhZ3MgewogICAgICAgICBhdHRyaWJ1dGUgYm9v bGVhbiBjcmVhdGU7CiAgICAgICAgIGF0dHJpYnV0ZSBib29sZWFuIGV4Y2x1c2l2ZTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9maWxl YXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2ZDdiYjE5ZjFkNDgzOWU1ZWUz OTk2MDBmNmUwNDRmNi4uMDhmYWQ0NmZlYjc2MDI2NWNkM2RmNzk4ZDU3ZmZkMGZkNjA4NjlhYiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUwLDkgKzUwLDI5IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2FsRmls ZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCitzdGF0aWMgTG9jYWxGaWxl U3lzdGVtKiBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorewor ICAgIC8vIEZJWE1FOiBTaG91bGQgaW5pdGlhbGl6ZSB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2Vs bC4KKyAgICBBU1NFUlQoIXN0YXRpY0xvY2FsRmlsZVN5c3RlbSk7CisgICAgaWYgKHN0YXRpY0xv Y2FsRmlsZVN5c3RlbSkKKyAgICAgICAgcmV0dXJuOworCisgICAgc3RhdGljTG9jYWxGaWxlU3lz dGVtID0gbmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aCk7Cit9CisKK0xvY2FsRmlsZVN5c3Rl bSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQoreworICAgIGlmICghc3RhdGlj TG9jYWxGaWxlU3lzdGVtKQorICAgICAgICBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9j YWxGaWxlU3lzdGVtKCIiKTsKKworICAgIHJldHVybiAqc3RhdGljTG9jYWxGaWxlU3lzdGVtOwor fQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAog ewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7Cisg ICAgcmV0dXJuIG1fYmFzZVBhdGgudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAogc3RhdGljIHZvaWQg b3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYgYmFz ZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5 cGUsIFBhc3NPd25QdHI8RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQpAQCAtNjgsNyAr ODgsNyBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgIH0KIAogICAgIC8vIEFzeW5jRmls ZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNv IHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAgIGNvbnRl eHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIG1fYmFzZVBh dGgsIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBl LCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ss IGNvbnRleHQpKSk7CisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3Jp Z2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNr cyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiB9CiAKIH0gLy8g bmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgg Yi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggNDhjZmE4ZjY4ODZhNjBh NDAwNDQ0ZTJmY2ViZWE2OGNkNTIzZGJiNi4uZTNmNjg1MjM4MTIxZThkOTQ3MGRkMjZkYmU4NmJk Yzk0NDFkOWI5ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5o CisrKyBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaApAQCAtNDQsMTkgKzQ0LDMx IEBAIGNsYXNzIEVycm9yQ2FsbGJhY2s7CiBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7CiBjbGFz cyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogCi1jbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJs aWMgUmVmQ291bnRlZDxMb2NhbEZpbGVTeXN0ZW0+IHsKKy8vIEtlZXBzIHBlci1wcm9jZXNzIGlu Zm9ybWF0aW9uIGFuZCBwcm92aWRlcyBhbiBlbnRyeSBwb2ludCB0byBvcGVuIGEgZmlsZSBzeXN0 ZW0uCitjbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJsaWMgTm9uY29weWFibGUgewogcHVibGlj OgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0 cmluZyYgYmFzZVBhdGgpOwotICAgIHZpcnR1YWwgfkxvY2FsRmlsZVN5c3RlbSgpIHsgfQorICAg IC8vIFJldHVybnMgYSBwZXItcHJvY2VzcyBpbnN0YW5jZSBvZiBMb2NhbEZpbGVTeXN0ZW0uCisg ICAgLy8gTm90ZSB0aGF0IExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3Rl bSBtdXN0IGJlIGNhbGxlZCB0bworICAgIC8vIGluaXRpYWxpemUgdGhlIGJhc2UgcGF0aC4KKyAg ICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAogICAgIHZvaWQg cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVN5c3Rl bTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwg UGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAhUExBVEZPUk0o Q0hST01JVU0pCisgICAgLy8gVGhpcyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0 aHJlYWRzIGFyZSBjcmVhdGVkLgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShj b25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsK KyNlbmRpZgorCitwcml2YXRlOgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJh c2VQYXRoKQogICAgICAgICA6IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAor ICAgIC8vIFRoZSBtZW1iZXIgbWV0aG9kcyBzaG91bGRuJ3QgYWNjZXNzIHRoaXMgU3RyaW5nIGRp cmVjdGx5IGJ1dCBzaG91bGQgdXNlCisgICAgLy8gZmlsZVN5c3RlbUJhc2VQYXRoKCkgaW5zdGVh ZC4KICAgICBTdHJpbmcgbV9iYXNlUGF0aDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9NZXRhZGF0YS5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGEuaWRsCmluZGV4IGE1 YTkwYmM2NjcxMjliODlmN2ExMzFmNDZjMWM2MTJjMGJlMmYwZTUuLjMyYmM4NDdkNGUwNmE5Mjdh NDhjOTUwZmZiZDNlZGZlYTY1ZjNhZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9NZXRh ZGF0YS5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhLmlkbApAQCAtMjgsOSArMjgs MTAgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZp bGVhcGkgewogICAgIGludGVyZmFjZSBbCi0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVN CisgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1RhYmxl cwogICAgIF0gTWV0YWRhdGEgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRGF0ZSBtb2Rp ZmljYXRpb25UaW1lOwogICAgIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRh dGFDYWxsYmFjay5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGFDYWxsYmFjay5pZGwKaW5k ZXggNDRjYTE4MDU0MjBhNmFlMDU0ZmI0MWQ4NjhkM2ZmMDE1NzRkZmMzMy4uOTNjNmZmNTdlMzdl ZjlhYmFmYmIwY2FlN2VhNDM4MjdiMjcwNWQxNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBp L01ldGFkYXRhQ2FsbGJhY2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YUNhbGxi YWNrLmlkbApAQCAtMjgsNyArMjgsNyBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUg c3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29u ZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIENhbGxiYWNrCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCmluZGV4 IDE1ZjNlZDE4MGU2ZmM3YzUyY2VlMjkwMGY1NTQyYzY4MWJlYThiZDkuLmVlN2NkYmI1NjliN2Ez MTY1MjY4ZWIxYzM3NmNjMDFlNWIzNDc3MDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCkBAIC03MjcsMjUgKzcy NywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcg bG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlmICghZG9jdW1lbnQpCiAgICAg ICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0ZW0pIHsKLSAgICAgICAgLy8g RklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAgICAgICBQYWdlKiBwYWdlID0g ZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7Ci0gICAgICAgICAgICBET01G aWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxl RXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAgICAgICAgICAgcmV0dXJuOwot ICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUgcXVvdGEgc2V0dGluZ3MgYXMg d2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0aW5ncygpLT5maWxlU3lzdGVt Um9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0gPSBMb2NhbEZpbGVTeXN0ZW06 OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8 fCAhZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkgewor ICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNh bGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAgICAgcmV0dXJu OwogICAgIH0KIAotICAgIG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1ZXN0RmlsZVN5c3RlbShkb2N1 bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgc3Vj Y2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2Fs RmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3lu Y0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2spOwogfQogCi1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2luZG93OjpURU1QT1JBUlkpID09 IGludChBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwotQ09NUElM RV9BU1NFUlQoaW50KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0gaW50KEFzeW5jRmlsZVN5c3Rl bTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nh c3Q8aW50PihET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0Zp bGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3Rh dGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlBFUlNJU1RFTlQpID09IHN0YXRpY19jYXN0PGludD4o QXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CiAKICNlbmRpZgog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmggYi9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZiMjE4NDFkNjZmMTFkOWNkNC4u NmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAzYSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaApAQCAt NTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgSGlzdG9yeTsKICAg ICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3RvclRpbWVsaW5lQWdlbnQ7Ci0g ICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExvY2F0aW9uOwogICAgIGNsYXNz IFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAtNDQ0LDkgKzQ0Myw2IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKICAgICAgICAg bXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5OwogI2VuZGlmCi0jaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBtX2xvY2Fs RmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFyZ2V0RGF0YSBtX2V2ZW50VGFy Z2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwgYi9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmlkbAppbmRleCA3ZTQ4ZjhjNTMxMTJiNmUwMzE3ZTExMjVhZjUx YjBmOTM1MzM0ZjEzLi4wNTMwMjUwMzY0MTU4ZGI1NWJjYjgzODI3MzA5M2NmYmU4MGRiMzE2IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysgYi9XZWJDb3JlL3BhZ2Uv RE9NV2luZG93LmlkbApAQCAtMTkzLDcgKzE5Myw2IEBAIG1vZHVsZSB3aW5kb3cgewogICAgICAg ICBjb25zdCB1bnNpZ25lZCBzaG9ydCBURU1QT1JBUlkgPSAwOwogICAgICAgICBjb25zdCB1bnNp Z25lZCBzaG9ydCBQRVJTSVNURU5UID0gMTsKICAgICAgICAgW0VuYWJsZWRBdFJ1bnRpbWVdIHZv aWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4gdW5zaWduZWQgc2hvcnQgdHlwZSwgaW4gbG9uZyBsb25n IHNpemUsIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEZpbGVTeXN0ZW1DYWxsYmFjayBzdWNjZXNz Q2FsbGJhY2ssIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxs YmFjayk7Ci0KICAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1d IEZsYWdzQ29uc3RydWN0b3IgRmxhZ3M7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9w YWdlL1NlY3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRl eCA0Nzg5ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2Jk M2E2Yjc2NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2Vj dXJpdHlPcmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIx LDYgKzEyMSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNv bnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkg Y29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3Jk TWFuYWdlcigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nl c3NGaWxlU3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRl Y2huaWNhbGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFn ZSwgYnV0IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Np b25TdG9yYWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmNwcCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggMzI5YzQ3ZjM5ZDE2MjEz Nzc0MTYwOGZiNDFhMWYwMGU3ODk2OGYxMi4uZTM0NjA2OTAzMzE3ZDIyMTNhZWIyZDM3M2ZmMGY0 M2JlMTE5NmIzZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTAsMTEgKzQ5MCw2IEBAIHZvaWQgU2V0dGlu Z3M6OnNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAg bV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpz ZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5 c3RlbVJvb3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25D aHJvbWVNb2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0g bW9kZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdl L1NldHRpbmdzLmgKaW5kZXggOGVjNTEwNmJmNDRkNWEyNjczN2E4ZjM4MTk2Y2ZjNTcyNGU1ODE1 ZC4uN2Y1ZmY3YTEzZDAyMmNmYmE4MGZkN2Y5M2FlZWVkZmUzOTdlNGYwNiAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAg LTIzOSw5ICsyMzksNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9j YWxTdG9yYWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJp bmcmIGxvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgo Y29uc3QgU3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRo KCkgY29uc3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lk IHNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0 aW9uQ2hyb21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7 IH0KIApAQCAtMzMxLDcgKzMyOCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3Ry aW5nIG1fZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVj dG9yeVRlbXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQ YXRoOwotICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwg bV91c2VyU3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFy ZEZvbnRGYW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUv cGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEz ODVjMTNhNmNlYmI2OWZjN2FmLi44NzkwNTU2Yzc1NDQwMmNmYWY0NmJhY2E0MDNjNDhlODhmYzE3 ODk4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zOCw5ICszOCwxNiBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29s IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIC8vIEVhY2ggcGxhdGZvcm0g c2hvdWxkIGltcGxlbWVudCB0aGlzLgorICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYp CiB7Ci0gICAgLy8gRklYTUU6IHJldHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1l bnRhdGlvbi4KKyAgICAvLyBFYWNoIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQgdGhpcy4KICAg ICByZXR1cm4gMDsKIH0KIApAQCAtNjIsNiArNjksNyBAQCB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6 b3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9y YQogCiAgICAgY2FsbGJhY2tzLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCBBc3luY0ZpbGVTeXN0 ZW06OmNyZWF0ZShyb290UGF0aCkpOwogfQorI2VuZGlmCiAKIC8vIERlZmF1bHQgaW1wbGVtZW50 YXRpb24uCiBTdHJpbmcgQXN5bmNGaWxlU3lzdGVtOjp2aXJ0dWFsVG9QbGF0Zm9ybVBhdGgoY29u c3QgU3RyaW5nJiBwYXRoKSBjb25zdApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3lu Y0ZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKaW5kZXgg NjAxZjBlYWUzZTVkMGU4YmViODRkNWE5OTNkNzcwNTE3YmQwYTYyZC4uOGM0ZDVkOTkwZmRhNDZj MmI3ODBkZjliMDlhNjA3N2U1NGQ5ZmY1NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9B c3luY0ZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5o CkBAIC01Niw2ICs1Niw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpIHsgfQog ICAgIHZpcnR1YWwgYm9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKSB7IHJldHVybiBmYWxzZTsgfQog CisgICAgc3RhdGljIGJvb2wgaXNBdmFpbGFibGUoKTsKKwogICAgIC8vIENyZWF0ZXMgYW5kIHJl dHVybnMgYSBuZXcgcGxhdGZvcm0tc3BlY2lmaWMgQXN5bmNGaWxlU3lzdGVtIGluc3RhbmNlIGlm IHRoZSBwbGF0Zm9ybSBoYXMgaXRzIG93biBpbXBsZW1lbnRhdGlvbi4KICAgICBzdGF0aWMgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGNyZWF0ZShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKTsK IApkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwIGIvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCmluZGV4IGI1MmIyODU0NzVmMmVmOTQ3N2U4MTRi YmU0ZDhiZWI5YzNiOWVhMGEuLjQ3NWQ4OTMzYjU4NWQzNTI3OTkxNzQ4ZTRiYmE2YWIxNjM0N2M3 ZmIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAorKysgYi9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKQEAgLTYzLDYgKzYzLDE1IEBACiAjaW5j bHVkZSAiTm90aWZpY2F0aW9uQ2VudGVyLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZ U1RFTSkKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJET01GaWxlU3lz dGVtLmgiCisjaW5jbHVkZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5o IgorI2luY2x1ZGUgIkZpbGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5 c3RlbS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3Jr ZXJDb250ZXh0VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAg LTMzNSw2ICszNDQsMjEgQEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0 IFN0cmluZyYgYmxvYlVSTFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lT VEVNKQordm9pZCBXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9u ZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJh Y2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBpZiAo IUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8fCAhc2VjdXJpdHlPcmlnaW4oKS0+Y2Fu QWNjZXNzRmlsZVN5c3RlbSgpKSB7CisgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2Fs bGJhY2sodGhpcywgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJS KSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2Fs RmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKHRoaXMsIHN0YXRpY19jYXN0PEFzeW5jRmls ZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj ayk7Cit9CisKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6 VEVNUE9SQVJZKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5 KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtl ckNvbnRleHQ6OlBFUlNJU1RFTlQpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVt OjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAppbmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi44ZDJmNTE5 ZDI1NzQxYzg2NWIwZjkwNjllOGVmY2NlODVmNzM1OTc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dv cmtlcnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0 LmgKQEAgLTQ3LDYgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFi YXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5j OworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNr OwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rp b247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTIzLDE1IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYp OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIC8vIFRoZXkgYXJl IHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGls ZS10aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5c3RlbVR5cGUgeworICAg ICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVOVCwKKyAgICAgICAgfTsK KyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUs IFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNr Pik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBt YXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4K ICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2 aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdl dCgpOyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwgYi9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRhZGI4OGJjMmRmNjdm MjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uOWM5ZWVjMGU4NDFhMjNlNjA1MDVmMzU3ZDM5YTAyNGRl ODFjNGIzNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCisr KyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0LDYgKzEwNCwxMyBA QCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVCbG9iVVJMKGluIEJs b2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01TdHJpbmcgYmxvYlVS TCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVNKSAmJiBFTkFCTEVf RklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVNUE9SQVJZID0gMDsK KyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7CisgICAgICAgIFtF bmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVuc2lnbmVkIHNob3J0 IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBGaWxlU3lz dGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBFcnJv ckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1 bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07 CiAKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCmluZGV4IGIyYjkyMTRiM2ZkOTAxNzgwZDVjZDVkNDA0YjQ0MWJjZTU5 YjIyOTEuLjdiYzgyNDAwMTMzMzdiMjE0ZWY4ZjZjYzg5NmViMWRjNmNjNWFhZTMgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTA5LTE1ICBLaW51a28gWWFzdWRhICA8a2ludWtv QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0gQVBJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgwOAorCisgICAgICAgICog cHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21t b25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xv Y2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5 c3RlbTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0pOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4K KyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJD bGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5G aWxlU3lzdGVtKTogQWRkZWQuCisKIDIwMTAtMDktMTQgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJl dmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2 NzUwMy4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5o CmluZGV4IGNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQuLmQ5ZDE2YzYz MTEwNzg2ODM4NmQzY2UyMGM4NWVjYzBiYzY5MDY4OTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzEsNiArMzEsOSBAQAogI2lmbmRl ZiBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogI2RlZmluZSBXZWJDb21tb25Xb3JrZXJDbGllbnRf aAogCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgor CiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CkBA IC04Myw2ICs4NiwxMyBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtp dCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCiAgICAgdmlydHVhbCBib29s IGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdl YlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgPSAwOwog CisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcg YSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUq LCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50 YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVtZW50IHRoaXMuCisgICAgICAg IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKIHByb3RlY3RlZDoKICAgICB+ V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCAwOGZjZWE2Yzk4NWFjMzIxZDI5MTZj M2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMxYjY1YzdmYzE1ZjlhMzUzY2ZjNTFhNjM2 NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9t aXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVt LmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitib29sIEFz eW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIHJldHVybiB0cnVlOworfQorCiBB c3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0oY29uc3QgU3Ry aW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5c3RlbShyb290UGF0aCkKICAgICAsIG1f d2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVudCgpLT5maWxlU3lzdGVtKCkpCmRpZmYg LS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcCBi L1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmluZGV4IDQ1 MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIwZjI1YjIuLjk5ODQzZWFhOTljNDIwNTBj NDUxMjg2NDJhMDA0NTUwYzlhNjc4ZGIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMv TG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9j YWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00MiwxNCArNDIsMTggQEAKICNpbmNsdWRlICJX ZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50Lmgi CiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5jbHVkZSAiV2ViV29ya2VySW1wbC5oIgor I2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJUaHJlYWQuaCIKIAog dXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVm UHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5n JiBwYXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3Rl bSgpCiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOwor ICAgIERFRklORV9TVEFUSUNfTE9DQUwoTG9jYWxGaWxlU3lzdGVtLCBsb2NhbEZpbGVTeXN0ZW0s ICgiIikpOworICAgIHJldHVybiBsb2NhbEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxl U3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0 LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8 RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxs YmFjaz4gZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcgKzY0LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lz dGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBB c3luY0ZpCiAgICAgICAgIFdlYkZyYW1lSW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZy b21GcmFtZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+ b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+ KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0 ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwog ICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdv cmtlcnMuCisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2Fz dDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3 b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVy UHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8 V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5v cGVuRmlsZVN5c3RlbSgwLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwg c2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJh Y2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRl M2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUuLmFmMzAwMGFiYWJiYmJkNGExMmZhYmVlN2M2MmZi NTZjZDNiODA0NzEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFz ZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcs NiArMzcsOCBAQAogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNp bmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5oIgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgor I2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNs aWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQ b3J0Q2hhbm5lbC5oIgpAQCAtNTYsNiArNTgsOCBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKICNpZiBF TkFCTEUoV09SS0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9 ICJhbGxvd0RhdGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3QgY2hhciBvcGVuRmlsZVN5c3RlbU1v ZGVbXSA9ICJvcGVuRmlsZVN5c3RlbU1vZGUiOworCiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2 ICsxMTgsMTA1IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAgICAg V1RGOjpTdHJpbmcgbV9tb2RlOwogfTsKKworLy8gVGhpcyBjbGFzcyBpcyB1c2VkIHRvIHBvc3Qg YSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBtYWluIHRocmVhZC4KKy8vIFRoaXMgbXVz dCBiZSBkZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorY2xhc3MgT3BlbkZpbGVTeXN0 ZW1NYWluVGhyZWFkQnJpZGdlIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgdm9pZCBzdGFydChXZWJX b3JrZXJCYXNlKiB3b3JrZXIsIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBX ZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFj a3MpCisgICAgeworICAgICAgICAvLyBUaGlzIGNsYXNzIGlzIHNlbGYtZGVzdHJ1Y3RlZC4KKyAg ICAgICAgQVNTRVJUKG5ldyBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2Uod29ya2VyLCBj b21tb25DbGllbnQsIGZyYW1lLCBtb2RlLCB0eXBlLCBzaXplLCBjYWxsYmFja3MpKTsKKyAgICB9 CisKKyAgICB+T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKCkKKyAgICB7CisgICAgICAg IEFTU0VSVCghbV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzKTsKKyAgICB9CisKK3ByaXZhdGU6Cisg ICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwg V2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1lKiBmcmFtZSwgY29u c3QgV1RGOjpTdHJpbmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25n IHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICAgICAgOiBtX3dv cmtlcih3b3JrZXIpCisgICAgICAgICwgbV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzKGNhbGxiYWNr cykKKyAgICAgICAgLCBtX21vZGUobW9kZSkKKyAgICB7CisgICAgICAgIHdvcmtlci0+ZGlzcGF0 Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW1Pbk1h aW5UaHJlYWQsIHdvcmtlciwgY29tbW9uQ2xpZW50LCBmcmFtZSwgdHlwZSwgc2l6ZSwgdGhpcykp OworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdl YkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdl YkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIFdlYkZp bGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIE9wZW5GaWxlU3lzdGVtTWFpblRo cmVhZEJyaWRnZSogYnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisg ICAgICAgICAgICBicmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQp OworICAgICAgICBlbHNlCisgICAgICAgICAgICBjb21tb25DbGllbnQtPm9wZW5GaWxlU3lzdGVt KGZyYW1lLCB0eXBlLCBzaXplLCBuZXcgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoYnJp ZGdlKSk7CisgICAgfQorCisgICAgLy8gRmlsZVN5c3RlbUNhbGxiYWNrcyB0aGF0IGFyZSBkaXNw YXRjaGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKKyAgICBwdWJsaWM6 CisgICAgICAgIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKFBhc3NPd25QdHI8T3BlbkZp bGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgICAgICAgICA6IG1fYnJpZGdl KGJyaWRnZSkKKyAgICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB+TWFpblRo cmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAobV9i cmlkZ2UpCisgICAgICAgICAgICAgICAgZGlkRmFpbChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAg ICAgIH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgV2Vi U3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgICAgIHsKKyAgICAgICAg ICAgIEFTU0VSVChtX2JyaWRnZSk7CisgICAgICAgICAgICBtX2JyaWRnZS5sZWFrUHRyKCktPmRp ZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgpOworICAgICAgICAgICAgZGVs ZXRlIHRoaXM7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJG aWxlRXJyb3IgZXJyb3IpCisgICAgICAgIHsKKyAgICAgICAgICAgIEFTU0VSVChtX2JyaWRnZSk7 CisgICAgICAgICAgICBtX2JyaWRnZS5sZWFrUHRyKCktPmRpZEZhaWxPbk1haW5UaHJlYWQoZXJy b3IpOworICAgICAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkU3VjY2VlZCgpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9Cisg ICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgV2ViRmlsZUluZm8mKSB7 IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlk UmVhZERpcmVjdG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYsIGJvb2wp IHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKKyAgICBwcml2YXRlOgorICAgICAg ICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBtX2JyaWRnZTsKKyAgICB9 OworICAgIGZyaWVuZCBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKKworICAg IHN0YXRpYyB2b2lkIGRpZEZhaWxPbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKiBicmlkZ2VQdHIsIFdl YkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1h aW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlkZ2VQdHIpOworICAgICAgICBicmlkZ2UtPm1fd29y a2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV93 b3JrZXJDb250ZXh0Q2FsbGJhY2tzID0gMDsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9pZCBkaWRP cGVuRmlsZVN5c3RlbU9uV29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UqIGJyaWRnZVB0ciwgY29uc3QgV1RG OjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKKyAgICB7CisgICAg ICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlkZ2VQ dHIpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkT3BlbkZp bGVTeXN0ZW0obmFtZSwgcm9vdFBhdGgpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4 dENhbGxiYWNrcyA9IDA7CisgICAgfQorCisgICAgdm9pZCBkaWRGYWlsT25NYWluVGhyZWFkKFdl YkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1v ZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRGYWlsT25Xb3JrZXJUaHJl YWQsIHRoaXMsIGVycm9yKSwgbV9tb2RlKTsKKyAgICB9CisKKyAgICB2b2lkIGRpZE9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFdURjo6U3RyaW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0 cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2Rl VG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkT3BlbkZpbGVTeXN0ZW1Pbldv cmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgpLCBtX21vZGUpOworICAgIH0KKworICAg IFdlYldvcmtlckJhc2UqIG1fd29ya2VyOworICAgIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIG1f d29ya2VyQ29udGV4dENhbGxiYWNrczsKKyAgICBXVEY6OlN0cmluZyBtX21vZGU7Cit9OworCiB9 CiAKIC8vIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZCB0byBmb3Jj ZSB0byBpbml0aWFsaXplIHNvbWUgc3RhdGljCkBAIC0yMzEsNiArMzM0LDE0IEBAIGJvb2wgV2Vi V29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFt ZSwgY29uc3QgV2ViU3RyCiAgICAgcmV0dXJuIGJyaWRnZS0+cmVzdWx0KCk7CiB9CiAKK3ZvaWQg V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFj a3MpCit7CisgICAgQVNTRVJUKG1fd2ViVmlldyk7CisKKyAgICAvLyBUaGUgbWFpbkZyYW1lIGlz IHVzZWQgdG8gY2hlY2sgdGhlIHNlY3VyaXR5IG9yaWdpbi4KKyAgICBPcGVuRmlsZVN5c3RlbU1h aW5UaHJlYWRCcmlkZ2U6OnN0YXJ0KHRoaXMsIGNvbW1vbkNsaWVudCgpLCBtX3dlYlZpZXctPm1h aW5GcmFtZSgpLCBvcGVuRmlsZVN5c3RlbU1vZGUsIHR5cGUsIHNpemUsIGNhbGxiYWNrcyk7Cit9 CisKIC8vIFdvcmtlck9iamVjdFByb3h5IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIHZvaWQgV2ViV29ya2VyQmFzZTo6cG9zdE1l c3NhZ2VUb1dvcmtlck9iamVjdChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gbWVz c2FnZSwKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKaW5kZXggMjI3MTFmOWYyMmNmNzA2 YmRkZWIwMjJjODVjNGMzMjdkNmUzMTJiMy4uZTk4ZGFmMThmMGVhMTYyYTlhYmNmODg1YTk0NGQy ZjVkZmU5ZjkxNCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNl LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKQEAgLTkxLDYgKzkx LDkgQEAgcHVibGljOgogICAgIC8vIENvbnRyb2xzIHdoZXRoZXIgYWNjZXNzIHRvIFdlYiBEYXRh YmFzZXMgaXMgYWxsb3dlZCBmb3IgdGhpcyB3b3JrZXIuCiAgICAgdmlydHVhbCBib29sIGFsbG93 RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmlu ZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAKKyAgICAvLyBS ZXF1ZXN0cyB0byBvcGVuIGEgZmlsZSBzeXN0ZW0gZm9yIHRoaXMgd29ya2VyLgorICAgIHZpcnR1 YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSosIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxv bmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKik7CisKICAgICAvLyBFeGVjdXRl cyB0aGUgZ2l2ZW4gdGFzayBvbiB0aGUgbWFpbiB0aHJlYWQuCiAgICAgc3RhdGljIHZvaWQgZGlz cGF0Y2hUYXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6VGFzaz4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1w bC5oCmluZGV4IDc0MWQ2MDY0MDY5NjFmM2YyNTkwZGIwOTk5ZmIyMDc2NTJhNWY1NDUuLjA2MDQ4 MjM1ZGJmMjhmYzllZmYzNGEyYWVmZGE4NDFhODk3NGM3ZDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC0zMyw4ICszMyw4IEBACiAKICNpZiBFTkFCTEUo V09SS0VSUykKIAorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlICJXZWJXb3Jr ZXJDbGllbnQuaCIKLQogI2luY2x1ZGUgIldvcmtlckNvbnRleHRQcm94eS5oIgogI2luY2x1ZGUg PHd0Zi9QYXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgpAQCAtOTksNiArOTks MTAgQEAgcHVibGljOgogICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0 dXJuIHRydWU7CiAgICAgfQorICAgIHZpcnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGcmFt ZSosIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzKikKKyAgICB7CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KIAog cHJpdmF0ZToKICAgICB2aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7Cg== 67862 2010-09-16 17:12:46 -0700 2010-09-17 17:07:19 -0700 Patch bug-45808-20100916171244.patch text/plain 37741 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZDZmOGI4YTM1MDNjYjI2YjI0YWQwNWQzZWRiY2YxZTJhODRkOWIzNS4uNWEzZmQxYjkzZTA0YWE2 NjE1YjEzMzM1ODQ3Mjg1MWUzMWE5ZmQ4YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOSBAQAorMjAxMC0wOS0xNSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluIG5vbi1jaHJvbWl1bSBw b3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uICBUaGlzIHBhdGNoIGFzc3Vt ZXMgZWFjaCBwb3J0IGNhbGxzIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5 c3RlbSgpIGluIGl0cyBpbml0aWFsaXphdGlvbiBwaGFzZS4KKworICAgICAgICBObyBuZXcgdGVz dHM7IHRlc3RzIHdpbGwgYmUgYWRkZWQgd2hlbiB3ZSBoYXZlIGNvbXBsZXRlIGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmZpbGVTeXN0 ZW1FbmFibGVkKTogQ2hhbmdlZCB0byByZWZsZWN0IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFi bGUKKyAgICAgICAgKiBiaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDoK KyAgICAgICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICogZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6fkxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaDoKKyAgICAgICAgKiBwYWdlL0RPTVdpbmRvdy5pZGw6CisgICAgICAg ICogcGFnZS9TZWN1cml0eU9yaWdpbi5oOgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmln aW46OmNhbkFjY2Vzc0ZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdz LmNwcDoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAgICAgICogd29ya2Vycy9Xb3Jr ZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlcXVlc3RG aWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6Cisg ICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKwogMjAxMC0wOS0xNiAgdGFrYW5v IHRha3VtaSAgPHRha2FubzFAYXNpYS5hcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg RGF2ZSBIeWF0dC4KQEAgLTE0MTUsNiArMTQ1MSwyMSBAQAogICAgICAgICAqIHBsYXRmb3JtL3Rl eHQvd2luY2UvVGV4dENvZGVjV2luQ0UuY3BwOgogICAgICAgICAoV2ViQ29yZTo6VGV4dENvZGVj V2luQ0U6OmVuY29kZSk6CiAKKyAgICAgICAgQWRkZWQgTm9TdGF0aWNUYWJsZXMgYW5kIGNoYW5n ZWQgbW9kdWxlbmFtZSBmcm9tIHN0b3JhZ2UgdG8gZmlsZWFwaToKKyAgICAgICAgKiBmaWxlYXBp L0RPTUZpbGVTeXN0ZW0uaWRsOgorICAgICAgICAqIGZpbGVhcGkvRGlyZWN0b3J5RW50cnkuaWRs OgorICAgICAgICAqIGZpbGVhcGkvRGlyZWN0b3J5UmVhZGVyLmlkbDoKKyAgICAgICAgKiBmaWxl YXBpL0VudHJpZXNDYWxsYmFjay5pZGw6CisgICAgICAgICogZmlsZWFwaS9FbnRyeS5pZGw6Cisg ICAgICAgICogZmlsZWFwaS9FbnRyeUFycmF5LmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0VudHJ5 Q2FsbGJhY2suaWRsOgorICAgICAgICAqIGZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGw6CisgICAg ICAgICogZmlsZWFwaS9GaWxlRW50cnkuaWRsOgorICAgICAgICAqIGZpbGVhcGkvRmlsZVN5c3Rl bUNhbGxiYWNrLmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL0ZsYWdzLmlkbDoKKyAgICAgICAgKiBm aWxlYXBpL01ldGFkYXRhLmlkbDoKKyAgICAgICAgKiBmaWxlYXBpL01ldGFkYXRhQ2FsbGJhY2su aWRsOgorCiAyMDEwLTA5LTE0ICBLaW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBEdW1pdHJ1IERhbmlsaXVjLgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGIvV2ViQ29y ZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmluZGV4IGExNWZk NmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNjZmY3Mjc4Yzc5 MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVy aWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5jbHVk ZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgogCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2Vu ZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVz Ojppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEgQEAgYm9vbCBS dW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQgPSBmYWxzZTsK IAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6 aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVy ZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lzdGVtRW5hYmxl ZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYKIAogI2lmIEVO QUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1l RW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJs ZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUxZGM0MjBkNmVk ZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKKysrIGIv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaApAQCAtMTQ4 LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQot ICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lzdGVt RW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7CiAgICAgc3Rh dGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsgaXNGaWxlU3lz dGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVlc3RGaWxlU3lz dGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNlbmRpZgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0RPTUZpbGVTeXN0ZW0uaWRsIGIvV2ViQ29yZS9maWxl YXBpL0RPTUZpbGVTeXN0ZW0uaWRsCmluZGV4IGI3MzA3ZTJjMTY5OWM1YzYyODA0ODI1MjFkNzk1 Yzc1YjI0NjdlNzYuLmVhMzNmMTUyYjM0NTAzYjdiZTY2MDlkZjMxY2QxZDMzODhlMWM4MzAgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9ET01GaWxlU3lzdGVtLmlkbAorKysgYi9XZWJDb3Jl L2ZpbGVhcGkvRE9NRmlsZVN5c3RlbS5pZGwKQEAgLTI4LDkgKzI4LDEwIEBACiAgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRl cmZhY2UgWwotICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTQorICAgICAgICBDb25kaXRp b25hbD1GSUxFX1NZU1RFTSwKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIERPTUZpbGVT eXN0ZW0gewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRE9NU3RyaW5nIG5hbWU7CiAgICAg ICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBEaXJlY3RvcnlFbnRyeSByb290OwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeUVudHJ5LmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9EaXJl Y3RvcnlFbnRyeS5pZGwKaW5kZXggN2EwZWZkZGQzODkxYWNmNWY5YzY5ODZjYTllYmVjNDZlMjM3 ZDhlZS4uYzk1OTY5NGU1MGExOTU1N2IwMmJjZDYxMjkyZDM3MTAwNzU1Mzc3YiAxMDA2NDQKLS0t IGEvV2ViQ29yZS9maWxlYXBpL0RpcmVjdG9yeUVudHJ5LmlkbAorKysgYi9XZWJDb3JlL2ZpbGVh cGkvRGlyZWN0b3J5RW50cnkuaWRsCkBAIC0yOCwxMSArMjgsMTIgQEAKICAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGludGVyZmFj ZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBHZW5lcmF0ZU5h dGl2ZUNvbnZlcnRlciwKLSAgICAgICAgR2VuZXJhdGVUb0pTCisgICAgICAgIEdlbmVyYXRlVG9K UywKKyAgICAgICAgTm9TdGF0aWNUYWJsZXMKICAgICBdIERpcmVjdG9yeUVudHJ5IDogRW50cnkg ewogICAgICAgICBEaXJlY3RvcnlSZWFkZXIgY3JlYXRlUmVhZGVyKCk7CiAgICAgICAgIFtDdXN0 b21dIHZvaWQgZ2V0RmlsZShpbiBbQ29udmVydFVuZGVmaW5lZE9yTnVsbFRvTnVsbFN0cmluZ10g RE9NU3RyaW5nIHBhdGgsIGluIFtPcHRpb25hbF0gRmxhZ3MgZmxhZ3MsIGluIFtPcHRpb25hbCwg Q2FsbGJhY2tdIEVudHJ5Q2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbT3B0aW9uYWwsIENh bGxiYWNrXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9maWxlYXBpL0RpcmVjdG9yeVJlYWRlci5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5 UmVhZGVyLmlkbAppbmRleCBjM2M3MDEyMDJkYTA4ZWI0YmMxYjc1NzFkNjI4YTE3ZjJjZjM0MTk2 Li5lNWY1M2E2NmU2NjM5NWQxYjVmYzM4M2Q5MDU3MmQ5Y2U1ZWM5NTAxIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvRGlyZWN0b3J5UmVhZGVyLmlkbAorKysgYi9XZWJDb3JlL2ZpbGVhcGkv RGlyZWN0b3J5UmVhZGVyLmlkbApAQCAtMjgsOSArMjgsMTAgQEAKICAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAg Ki8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGludGVyZmFjZSBb Ci0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNCisgICAgICAgIENvbmRpdGlvbmFsPUZJ TEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gRGlyZWN0b3J5UmVhZGVy IHsKICAgICAgICAgdm9pZCByZWFkRW50cmllcyhpbiBbQ2FsbGJhY2tdIEVudHJpZXNDYWxsYmFj ayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sg ZXJyb3JDYWxsYmFjayk7CiAgICAgfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9FbnRy aWVzQ2FsbGJhY2suaWRsIGIvV2ViQ29yZS9maWxlYXBpL0VudHJpZXNDYWxsYmFjay5pZGwKaW5k ZXggNzNiMzc0ZDc5MjhlZTQ4MDY2MmVjMzljMzNjOWIxZjA0ZTg2ODEzNy4uZjkxNGM0ODI4NjM2 MTJhMDE2ZTk3NzhlZGFjNTI0YzYwNzcwZmE2ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBp L0VudHJpZXNDYWxsYmFjay5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0VudHJpZXNDYWxsYmFj ay5pZGwKQEAgLTI4LDcgKzI4LDcgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0 b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRp dGlvbmFsPUZJTEVfU1lTVEVNLAogICAgICAgICBDYWxsYmFjawpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9maWxlYXBpL0VudHJ5LmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeS5pZGwKaW5kZXggYjY3 NDQ1NTEyYTA1ZDIwMGUxOWRiZWNlYTJlOGQ3ZjcxMzdhMjM2YS4uYTk3OGU2NTkzZjYxZDY4MjZi ZTVlMjUxNmY1YjBjYjUzMWYyMjkzMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5 LmlkbAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvRW50cnkuaWRsCkBAIC0yOCwxMCArMjgsMTEgQEAK ICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkg ewogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNLAotICAg ICAgICBDdXN0b21Ub0pTCisgICAgICAgIEN1c3RvbVRvSlMsCisgICAgICAgIE5vU3RhdGljVGFi bGVzCiAgICAgXSBFbnRyeSB7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBib29sZWFuIGlz RmlsZTsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIGJvb2xlYW4gaXNEaXJlY3Rvcnk7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRW50cnlBcnJheS5pZGwgYi9XZWJDb3JlL2ZpbGVh cGkvRW50cnlBcnJheS5pZGwKaW5kZXggZTk4N2VjZWZlYmVkYmNhZWViYzNhN2YxMmI5NzA2ZWU5 MzhhNGRmMC4uY2I3MTkzNmRhM2FiN2QwNmRlZGU1M2M1YmY2NTcwNzY4MTEzYTI5ZiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9maWxlYXBpL0VudHJ5QXJyYXkuaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFw aS9FbnRyeUFycmF5LmlkbApAQCAtMjgsMTAgKzI4LDExIEBACiAgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICov CiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwog ICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgSGFzSW5kZXhHZXR0ZXIs CisgICAgICAgIE5vU3RhdGljVGFibGVzCiAgICAgXSBFbnRyeUFycmF5IHsKICAgICAgICAgcmVh ZG9ubHkgYXR0cmlidXRlIHVuc2lnbmVkIGxvbmcgbGVuZ3RoOwogICAgICAgICBFbnRyeSBpdGVt KGluIFtJc0luZGV4XSB1bnNpZ25lZCBsb25nIGluZGV4KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZmlsZWFwaS9FbnRyeUNhbGxiYWNrLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUNhbGxiYWNr LmlkbAppbmRleCBiZWEzZmQxNDcwZWQwYzdjMDRiOWIxMWUyYzYxMDVjZGZmOWE0YTc5Li40YTg1 MzRiYzFjYjgwMDY1MzA5NTExMGMyNjczMDkwNDc1ZGI1MDlmIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2ZpbGVhcGkvRW50cnlDYWxsYmFjay5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0VudHJ5Q2Fs bGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVs ZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBD b25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZmlsZWFwaS9FcnJvckNhbGxiYWNrLmlkbCBiL1dlYkNvcmUvZmlsZWFwaS9FcnJvckNh bGxiYWNrLmlkbAppbmRleCBmYzdmYTg1YzQwNTgyOGFmNzI3Mjk1ZmVkNmY2NjAwMDI5NDhmNzg4 Li43ZDMzOTFlNDBjNTk5NTQ0NGJmMjM1MWJmMTliOWJiM2EwM2NlYzIwIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2ZpbGVhcGkvRXJyb3JDYWxsYmFjay5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0Vy cm9yQ2FsbGJhY2suaWRsCkBAIC0yOCw3ICsyOCw3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAK LW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAg ICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKICAgICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdp dCBhL1dlYkNvcmUvZmlsZWFwaS9GaWxlRW50cnkuaWRsIGIvV2ViQ29yZS9maWxlYXBpL0ZpbGVF bnRyeS5pZGwKaW5kZXggZWI5MTNiOGRiMWY4YWQyNmZlZDgwYzQyMWI1NGYxY2E2NDllMmU5YS4u MDJhYTA5ZDA5ODc4YTA3OGVjNzMzNmM3YTI3OWUwY2IxMDk1ZWNlMiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9maWxlYXBpL0ZpbGVFbnRyeS5pZGwKKysrIGIvV2ViQ29yZS9maWxlYXBpL0ZpbGVFbnRy eS5pZGwKQEAgLTI4LDExICsyOCwxMiBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUg c3RvcmFnZSB7Cittb2R1bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29u ZGl0aW9uYWw9RklMRV9TWVNURU0sCiAgICAgICAgIEdlbmVyYXRlTmF0aXZlQ29udmVydGVyLAot ICAgICAgICBHZW5lcmF0ZVRvSlMKKyAgICAgICAgR2VuZXJhdGVUb0pTLAorICAgICAgICBOb1N0 YXRpY1RhYmxlcwogICAgIF0gRmlsZUVudHJ5IDogRW50cnkgewogICAgICAgICB2b2lkIGNyZWF0 ZVdyaXRlcihpbiBbQ2FsbGJhY2tdIEZpbGVXcml0ZXJDYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ss IGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7CiAg ICAgICAgIHZvaWQgZmlsZShpbiBbQ2FsbGJhY2tdIEZpbGVDYWxsYmFjayBzdWNjZXNzQ2FsbGJh Y2ssIGluIFtPcHRpb25hbCwgQ2FsbGJhY2tdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvRmlsZVN5c3RlbUNhbGxiYWNrLmlkbCBiL1dl YkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsCmluZGV4IGNmNjg2ZmYxYmY1ZmQw ODgzYmE2ODI0MTIzZWQ2MzAxODBmZDNlMjAuLjJlZjZhOTJmN2NjODQyYTYzNDc4OGJkN2ZmMTcz Mjg3N2FhOWE4MTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJh Y2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9GaWxlU3lzdGVtQ2FsbGJhY2suaWRsCkBAIC0y OCw3ICsyOCw3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21v ZHVsZSBmaWxlYXBpIHsKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxF X1NZU1RFTSwKICAgICAgICAgQ2FsbGJhY2sKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9G bGFncy5pZGwgYi9XZWJDb3JlL2ZpbGVhcGkvRmxhZ3MuaWRsCmluZGV4IDI5NjU4YTFmZTY2NDRk N2M5MjE5NjZiZDVmODc5MmRmYWIwM2YxM2IuLmExN2JmY2E4MDIzYTE4NTNjNzI0M2RkNjZkNWVl YTRjZjliMTQ2MTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9GbGFncy5pZGwKKysrIGIv V2ViQ29yZS9maWxlYXBpL0ZsYWdzLmlkbApAQCAtMjgsMTAgKzI4LDExIEBACiAgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgogICovCiAKLW1vZHVsZSBzdG9yYWdlIHsKK21vZHVsZSBmaWxlYXBpIHsKICAgICBpbnRl cmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1GSUxFX1NZU1RFTSwKLSAgICAgICAgQ2FuQmVD b25zdHJ1Y3RlZAorICAgICAgICBDYW5CZUNvbnN0cnVjdGVkLAorICAgICAgICBOb1N0YXRpY1Rh YmxlcwogICAgIF0gRmxhZ3MgewogICAgICAgICBhdHRyaWJ1dGUgYm9vbGVhbiBjcmVhdGU7CiAg ICAgICAgIGF0dHJpYnV0ZSBib29sZWFuIGV4Y2x1c2l2ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2ZDdiYjE5ZjFkNDgzOWU1ZWUzOTk2MDBmNmUwNDRmNi4u MDhmYWQ0NmZlYjc2MDI2NWNkM2RmNzk4ZDU3ZmZkMGZkNjA4NjlhYiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xv Y2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUwLDkgKzUwLDI5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRl KGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCitzdGF0aWMgTG9jYWxGaWxlU3lzdGVtKiBzdGF0aWNM b2NhbEZpbGVTeXN0ZW0gPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxv Y2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQoreworICAgIC8vIEZJWE1FOiBT aG91bGQgaW5pdGlhbGl6ZSB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KKyAgICBBU1NFUlQo IXN0YXRpY0xvY2FsRmlsZVN5c3RlbSk7CisgICAgaWYgKHN0YXRpY0xvY2FsRmlsZVN5c3RlbSkK KyAgICAgICAgcmV0dXJuOworCisgICAgc3RhdGljTG9jYWxGaWxlU3lzdGVtID0gbmV3IExvY2Fs RmlsZVN5c3RlbShiYXNlUGF0aCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lz dGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQoreworICAgIGlmICghc3RhdGljTG9jYWxGaWxlU3lzdGVt KQorICAgICAgICBzdGF0aWNMb2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIi KTsKKworICAgIHJldHVybiAqc3RhdGljTG9jYWxGaWxlU3lzdGVtOworfQorCitTdHJpbmcgTG9j YWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAogewotICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgcmV0dXJuIG1fYmFz ZVBhdGgudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAogc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0o U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0 cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIFBhc3NPd25QdHI8 RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQpAQCAtNjgsNyArODgsNyBAQCB2b2lkIExv Y2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgQXN5bmNGaQogICAgIH0KIAogICAgIC8vIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZp bGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNvIHRoZSBtZXRob2QgbmVl ZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAgIGNvbnRleHQtPnBvc3RUYXNrKGNy ZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIG1fYmFzZVBhdGgsIGNvbnRleHQtPnNl Y3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3Rl bUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7Cisg ICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwg ZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNl SWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJh Y2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlCmRpZmYg LS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmggYi9XZWJDb3JlL2ZpbGVh cGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggNDhjZmE4ZjY4ODZhNjBhNDAwNDQ0ZTJmY2ViZWE2 OGNkNTIzZGJiNi4uZTNmNjg1MjM4MTIxZThkOTQ3MGRkMjZkYmU4NmJkYzk0NDFkOWI5ZCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUv ZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaApAQCAtNDQsMTkgKzQ0LDMxIEBAIGNsYXNzIEVycm9y Q2FsbGJhY2s7CiBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7CiBjbGFzcyBTY3JpcHRFeGVjdXRp b25Db250ZXh0OwogCi1jbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJsaWMgUmVmQ291bnRlZDxM b2NhbEZpbGVTeXN0ZW0+IHsKKy8vIEtlZXBzIHBlci1wcm9jZXNzIGluZm9ybWF0aW9uIGFuZCBw cm92aWRlcyBhbiBlbnRyeSBwb2ludCB0byBvcGVuIGEgZmlsZSBzeXN0ZW0uCitjbGFzcyBMb2Nh bEZpbGVTeXN0ZW0gOiBwdWJsaWMgTm9uY29weWFibGUgewogcHVibGljOgotICAgIHN0YXRpYyBQ YXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp OwotICAgIHZpcnR1YWwgfkxvY2FsRmlsZVN5c3RlbSgpIHsgfQorICAgIC8vIFJldHVybnMgYSBw ZXItcHJvY2VzcyBpbnN0YW5jZSBvZiBMb2NhbEZpbGVTeXN0ZW0uCisgICAgLy8gTm90ZSB0aGF0 IExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSBtdXN0IGJlIGNhbGxl ZCB0bworICAgIC8vIGluaXRpYWxpemUgdGhlIGJhc2UgcGF0aC4KKyAgICBzdGF0aWMgTG9jYWxG aWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAogICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0 ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBs b25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJv ckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCisgICAg Ly8gVGhpcyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVh dGVkLgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsK KworICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2 YXRlOgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAg ICA6IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAorICAgIC8vIFRoZSBtZW1i ZXIgbWV0aG9kcyBzaG91bGRuJ3QgYWNjZXNzIHRoaXMgU3RyaW5nIGRpcmVjdGx5IGJ1dCBzaG91 bGQgdXNlCisgICAgLy8gZmlsZVN5c3RlbUJhc2VQYXRoKCkgaW5zdGVhZC4KICAgICBTdHJpbmcg bV9iYXNlUGF0aDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YS5p ZGwgYi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGEuaWRsCmluZGV4IGE1YTkwYmM2NjcxMjliODlm N2ExMzFmNDZjMWM2MTJjMGJlMmYwZTUuLjMyYmM4NDdkNGUwNmE5MjdhNDhjOTUwZmZiZDNlZGZl YTY1ZjNhZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YS5pZGwKKysrIGIv V2ViQ29yZS9maWxlYXBpL01ldGFkYXRhLmlkbApAQCAtMjgsOSArMjgsMTAgQEAKICAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCiAgKi8KIAotbW9kdWxlIHN0b3JhZ2UgeworbW9kdWxlIGZpbGVhcGkgewogICAgIGlu dGVyZmFjZSBbCi0gICAgICAgIENvbmRpdGlvbmFsPUZJTEVfU1lTVEVNCisgICAgICAgIENvbmRp dGlvbmFsPUZJTEVfU1lTVEVNLAorICAgICAgICBOb1N0YXRpY1RhYmxlcwogICAgIF0gTWV0YWRh dGEgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRGF0ZSBtb2RpZmljYXRpb25UaW1lOwog ICAgIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGFDYWxsYmFjay5pZGwg Yi9XZWJDb3JlL2ZpbGVhcGkvTWV0YWRhdGFDYWxsYmFjay5pZGwKaW5kZXggNDRjYTE4MDU0MjBh NmFlMDU0ZmI0MWQ4NjhkM2ZmMDE1NzRkZmMzMy4uOTNjNmZmNTdlMzdlZjlhYmFmYmIwY2FlN2Vh NDM4MjdiMjcwNWQxNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL01ldGFkYXRhQ2FsbGJh Y2suaWRsCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9NZXRhZGF0YUNhbGxiYWNrLmlkbApAQCAtMjgs NyArMjgsNyBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KICAqLwogCi1tb2R1bGUgc3RvcmFnZSB7Cittb2R1 bGUgZmlsZWFwaSB7CiAgICAgaW50ZXJmYWNlIFsKICAgICAgICAgQ29uZGl0aW9uYWw9RklMRV9T WVNURU0sCiAgICAgICAgIENhbGxiYWNrCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2lu ZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCmluZGV4IDE1ZjNlZDE4MGU2ZmM3 YzUyY2VlMjkwMGY1NTQyYzY4MWJlYThiZDkuLmVlN2NkYmI1NjliN2EzMTY1MjY4ZWIxYzM3NmNj MDFlNWIzNDc3MDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBi L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERP TVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNz UmVmUHRyPEZpbGVTeXN0ZQogICAgIGlmICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAot ICAgIGlmICghbV9sb2NhbEZpbGVTeXN0ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBh Y2Nlc3MgaXMgYWxsb3dlZC4KLQotICAgICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2Uo KTsKLSAgICAgICAgaWYgKCFwYWdlKSB7Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hl ZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJ TlZBTElEX1NUQVRFX0VSUikpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAg ICAgICAgLy8gRklYTUU6IEdldCB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAg U3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAg ICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0gPSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsK KyAgICBpZiAoIUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNl Y3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxl U3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJy b3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nh c3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrKTsKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJl cXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5 cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1D T01QSUxFX0FTU0VSVChpbnQoRE9NV2luZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVT eXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERP TVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCks IGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5k b3c6OlRFTVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBv cmFyeSksIGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihE T01XaW5kb3c6OlBFUlNJU1RFTlQpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVt OjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BhZ2UvRE9NV2luZG93LmggYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXgg MTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZiMjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVm MWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAzYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5oCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0 b3J5OwogICAgIGNsYXNzIEluc3BlY3RvclRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxG aWxlU3lzdGVtOwogICAgIGNsYXNzIExvY2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAg ICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAtNDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8 SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQotICAgICAgICBSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNl bmRpZgogCiAgICAgICAgIEV2ZW50VGFyZ2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZm IC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwgYi9XZWJDb3JlL3BhZ2UvRE9NV2lu ZG93LmlkbAppbmRleCBiNGM2NTg5ZjY1NDZlNmVlMTY2ODAxYTJiOTcxOTkyNjJkYTdjNWVhLi44 ZWY2ZWMxZjQ1M2QwNTBhMzM0OGE0OWMyYzVhNzg2ZWQ4OWMxNGEyIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbApA QCAtMTkzLDcgKzE5Myw2IEBAIG1vZHVsZSB3aW5kb3cgewogICAgICAgICBjb25zdCB1bnNpZ25l ZCBzaG9ydCBURU1QT1JBUlkgPSAwOwogICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJT SVNURU5UID0gMTsKICAgICAgICAgW0VuYWJsZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVT eXN0ZW0oaW4gdW5zaWduZWQgc2hvcnQgdHlwZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxs YmFjaywgT3B0aW9uYWxdIEZpbGVTeXN0ZW1DYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtD YWxsYmFjaywgT3B0aW9uYWxdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7Ci0KICAgICAg ICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0 b3IgRmxhZ3M7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3Jp Z2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCA0Nzg5ZDNjZTExYTBh MjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2JkM2E2Yjc2NjM3MTYyMzM1 YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAor KysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIxLDYgKzEyMSw3IEBAIHB1 YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNvbnN0IHsgcmV0dXJuICFp c1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkgY29uc3QgeyByZXR1cm4g IWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3JkTWFuYWdlcigpIGNvbnN0 IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nlc3NGaWxlU3lzdGVtKCkg Y29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRlY2huaWNhbGx5LCB3ZSBz aG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFnZSwgYnV0IHdlCiAgICAg Ly8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Npb25TdG9yYWdlIGFyZWEg Zm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCBiL1dlYkNv cmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggMzI5YzQ3ZjM5ZDE2MjEzNzc0MTYwOGZiNDFhMWYw MGU3ODk2OGYxMi4uZTM0NjA2OTAzMzE3ZDIyMTNhZWIyZDM3M2ZmMGY0M2JlMTE5NmIzZSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuY3BwCkBAIC00OTAsMTEgKzQ5MCw2IEBAIHZvaWQgU2V0dGluZ3M6OnNldExvY2FsU3Rv cmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2NhbFN0b3JhZ2VE YXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxlU3lzdGVtUm9v dFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJvb3RQYXRoID0g cGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVNb2RlKGJvb2wg bW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5k ZXggOGVjNTEwNmJmNDRkNWEyNjczN2E4ZjM4MTk2Y2ZjNTcyNGU1ODE1ZC4uN2Y1ZmY3YTEzZDAy MmNmYmE4MGZkN2Y5M2FlZWVkZmUzOTdlNGYwNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1Nl dHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTIzOSw5ICsyMzksNiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxvY2FsU3RvcmFn ZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRo OyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJik7 Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29uc3QgeyByZXR1 cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFwcGxpY2F0aW9u Q2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSgp IGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApAQCAtMzMxLDcg KzMyOCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1fZGVmYXVsdFRl eHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRlbXBsYXRlUGF0 aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwotICAgICAgICBT dHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2VyU3R5bGVTaGVl dExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRGYW1pbHk7CiAg ICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdpdCBhL1dlYkNv cmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNG aWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEzODVjMTNhNmNlYmI2OWZj N2FmLi44NzkwNTU2Yzc1NDQwMmNmYWY0NmJhY2E0MDNjNDhlODhmYzE3ODk4IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0 Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zOCw5ICszOCwxNiBAQAogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKQoreworICAgIC8vIEVhY2ggcGxhdGZvcm0gc2hvdWxkIGltcGxlbWVu dCB0aGlzLgorICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYpCiB7Ci0gICAgLy8gRklY TUU6IHJldHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1lbnRhdGlvbi4KKyAgICAv LyBFYWNoIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQgdGhpcy4KICAgICByZXR1cm4gMDsKIH0K IApAQCAtNjIsNiArNjksNyBAQCB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0o Y29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9yYQogCiAgICAgY2FsbGJh Y2tzLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCBBc3luY0ZpbGVTeXN0ZW06OmNyZWF0ZShyb290 UGF0aCkpOwogfQorI2VuZGlmCiAKIC8vIERlZmF1bHQgaW1wbGVtZW50YXRpb24uCiBTdHJpbmcg QXN5bmNGaWxlU3lzdGVtOjp2aXJ0dWFsVG9QbGF0Zm9ybVBhdGgoY29uc3QgU3RyaW5nJiBwYXRo KSBjb25zdApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaCBi L1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKaW5kZXggNjAxZjBlYWUzZTVkMGU4 YmViODRkNWE5OTNkNzcwNTE3YmQwYTYyZC4uOGM0ZDVkOTkwZmRhNDZjMmI3ODBkZjliMDlhNjA3 N2U1NGQ5ZmY1NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u aAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCkBAIC01Niw2ICs1Niw4 IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpIHsgfQogICAgIHZpcnR1YWwgYm9v bCBoYXNQZW5kaW5nQWN0aXZpdHkoKSB7IHJldHVybiBmYWxzZTsgfQogCisgICAgc3RhdGljIGJv b2wgaXNBdmFpbGFibGUoKTsKKwogICAgIC8vIENyZWF0ZXMgYW5kIHJldHVybnMgYSBuZXcgcGxh dGZvcm0tc3BlY2lmaWMgQXN5bmNGaWxlU3lzdGVtIGluc3RhbmNlIGlmIHRoZSBwbGF0Zm9ybSBo YXMgaXRzIG93biBpbXBsZW1lbnRhdGlvbi4KICAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW0+IGNyZWF0ZShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKTsKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuY3BwCmluZGV4IGI1MmIyODU0NzVmMmVmOTQ3N2U4MTRiYmU0ZDhiZWI5YzNiOWVh MGEuLjQ3NWQ4OTMzYjU4NWQzNTI3OTkxNzQ4ZTRiYmE2YWIxNjM0N2M3ZmIgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAorKysgYi9XZWJDb3JlL3dvcmtlcnMv V29ya2VyQ29udGV4dC5jcHAKQEAgLTYzLDYgKzYzLDE1IEBACiAjaW5jbHVkZSAiTm90aWZpY2F0 aW9uQ2VudGVyLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNsdWRl ICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJET01GaWxlU3lzdGVtLmgiCisjaW5jbHVk ZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIkZp bGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgorI2VuZGlm CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3JrZXJDb250ZXh0VGFzayA6 IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAgLTMzNSw2ICszNDQsMjEg QEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYgYmxvYlVS TFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQordm9pZCBXb3Jr ZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBh c3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8 RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKSB8fCAhc2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRmlsZVN5c3Rl bSgpKSB7CisgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2sodGhpcywgZXJy b3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJl cXVlc3RGaWxlU3lzdGVtKHRoaXMsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4o dHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cit9CisKK0NPTVBJ TEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6VEVNUE9SQVJZKSA9PSBz dGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRj aCk7CitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlBFUlNJ U1RFTlQpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwg ZW51bV9taXNtYXRjaCk7CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5k aWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAppbmRleCA3ZmI4YjQ2 ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi44ZDJmNTE5ZDI1NzQxYzg2NWIwZjkw NjllOGVmY2NlODVmNzM1OTc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKQEAgLTQ3LDYgKzQ3 LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFiYXNlOwogICAgIGNsYXNz IERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5jOworICAgIGNsYXNzIEVy cm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNrOwogICAgIGNsYXNzIE5v dGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247CiAgICAgY2xhc3Mg V29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTIzLDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYpOwogI2VuZGlmCiAKKyNp ZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFu ZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hl Y2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9S QVJZLAorICAgICAgICAgICAgUEVSU0lTVEVOVCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCBy ZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8Rmls ZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwog ICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNX b3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNX b3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25h bE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CmRpZmYgLS1n aXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwgYi9XZWJDb3JlL3dvcmtlcnMv V29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRhZGI4OGJjMmRmNjdmMjdkNWVjZTJiNWE5MjMy ODY3ODEyNC4uOWM5ZWVjMGU4NDFhMjNlNjA1MDVmMzU3ZDM5YTAyNGRlODFjNGIzNiAxMDA2NDQK LS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCisrKyBiL1dlYkNvcmUvd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0LDYgKzEwNCwxMyBAQCBtb2R1bGUgdGhyZWFk cyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVCbG9iVVJMKGluIEJsb2IgYmxvYik7CiAgICAg ICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01TdHJpbmcgYmxvYlVSTCk7CiAjZW5kaWYKKwor I2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVNKSAmJiBFTkFCTEVfRklMRV9TWVNURU0KKyAg ICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVNUE9SQVJZID0gMDsKKyAgICAgICAgY29uc3Qg dW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7CisgICAgICAgIFtFbmFibGVkQXRSdW50aW1l XSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcg bG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3Vj Y2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9y Q2FsbGJhY2spOworICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1bnRpbWU9RmlsZVN5c3Rl bV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07CiAKIH0KZGlmZiAtLWdp dCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CmluZGV4IGEzOTA4M2ZlMTQ3M2MzZGY1OGUyMjg3MDc5ZTEwMzgyYjQzZDcwMmEuLmNhMDY1YWY1 MTg2MzA5NDRmN2M3MTczNjBkNzkwN2ZkZDdiNzZjNjUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsx LDIxIEBACisyMDEwLTA5LTE1ICBLaW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgV29y a2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgwOAorCisgICAgICAgICogcHVibGljL1dlYkNvbW1v bldvcmtlckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6 Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNo cm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxl U3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVT eXN0ZW0pOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBzcmMv V2ViV29ya2VyQmFzZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6Cisg ICAgICAgIChXZWJLaXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRk ZWQuCisKIDIwMTAtMDktMTYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IEphbWVzIFJvYmluc29uLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUwMzI4NTA4 OTBkYzg0NTUyYzQxNjQ0ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5NmEyZGNk NmQyMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJD bGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVu dC5oCkBAIC0zMSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAj ZGVmaW5lIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21tb24uaCIK KyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFz cyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1YmxpYzoKICAg ICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIHdl YiBkYXRhYmFzZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNv bnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWdu ZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4g d2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZpcnR1YWwg dm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwg V2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVl ZCBhIHN0dWIgaW1wbGVtZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVt ZW50IHRoaXMuCisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisK IHByb3RlY3RlZDoKICAgICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCAwOGZj ZWE2Yzk4NWFjMzIxZDI5MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMxYjY1Yzdm YzE1ZjlhMzUzY2ZjNTFhNjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0Fz eW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5j RmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIHJl dHVybiB0cnVlOworfQorCiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxlU3lzdGVt Q2hyb21pdW0oY29uc3QgU3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5c3RlbShy b290UGF0aCkKICAgICAsIG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVudCgpLT5m aWxlU3lzdGVtKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5 c3RlbUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hy b21pdW0uY3BwCmluZGV4IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIwZjI1YjIu Ljk5ODQzZWFhOTljNDIwNTBjNDUxMjg2NDJhMDA0NTUwYzlhNjc4ZGIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00MiwxNCArNDIs MTggQEAKICNpbmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUg IldlYkZyYW1lQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5jbHVkZSAi V2ViV29ya2VySW1wbC5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJX b3JrZXJUaHJlYWQuaCIKIAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpj cmVhdGUoY29uc3QgU3RyaW5nJiBwYXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0 ZW06OmxvY2FsRmlsZVN5c3RlbSgpCiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0ocGF0aCkpOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoTG9jYWxGaWxlU3lzdGVt LCBsb2NhbEZpbGVTeXN0ZW0sICgiIikpOworICAgIHJldHVybiBsb2NhbEZpbGVTeXN0ZW07CiB9 CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25n IHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBh c3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcgKzY0LDEwIEBA IHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZyYW1lSW1wbCogd2ViRnJhbWUg PSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAgICAgICAgIHdl YkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRpY19jYXN0PFdl YkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNhbGxiYWNr c0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxi YWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1FOiBBZGQgaW1w bGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNv bnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIFdv cmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJl YWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29y a2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAg ICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbSgwLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lz dGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5l dyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29u dGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCmlu ZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUuLjY3ZjJmN2VhNzUx Nzk5YjJmOTMyNGEyZWVjNTk2N2E5Zjg3ZjJiMTcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3Jr ZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsOCBAQAogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBv cnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5oIgorI2luY2x1ZGUg IldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKICNp bmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgogI2lu Y2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpAQCAtNTYsNiArNTgsOCBAQCBuYW1lc3Bh Y2UgV2ViS2l0IHsKICNpZiBFTkFCTEUoV09SS0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIgYWxs b3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0RhdGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3QgY2hh ciBvcGVuRmlsZVN5c3RlbU1vZGVbXSA9ICJvcGVuRmlsZVN5c3RlbU1vZGUiOworCiAKIG5hbWVz cGFjZSB7CiAKQEAgLTExNCw2ICsxMTgsMTA2IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFz ZSogbV93b3JrZXI7CiAgICAgV1RGOjpTdHJpbmcgbV9tb2RlOwogfTsKKworLy8gVGhpcyBjbGFz cyBpcyB1c2VkIHRvIHBvc3QgYSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBtYWluIHRo cmVhZCBhbmQgZ2V0IGNhbGxlZCBiYWNrIGZvciB0aGUgcmVxdWVzdC4gIFRoaXMgbXVzdCBiZSBk ZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorY2xhc3MgT3BlbkZpbGVTeXN0ZW1NYWlu VGhyZWFkQnJpZGdlIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgdm9pZCBzdGFydChXZWJXb3JrZXJC YXNlKiB3b3JrZXIsIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBjb25zdCBX VEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAgLy8g VGhpcyBjbGFzcyBpcyBzZWxmLWRlc3RydWN0ZWQuCisgICAgICAgIEFTU0VSVChuZXcgT3BlbkZp bGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgY29tbW9uQ2xpZW50LCBtb2RlLCB0eXBl LCBzaXplLCBjYWxsYmFja3MpKTsKKyAgICB9CisKKyAgICB+T3BlbkZpbGVTeXN0ZW1NYWluVGhy ZWFkQnJpZGdlKCkKKyAgICB7CisgICAgICAgIEFTU0VSVCghbV93b3JrZXJDb250ZXh0Q2FsbGJh Y2tzKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJp ZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25D bGllbnQsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUs IGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAg ICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNr cyhjYWxsYmFja3MpCisgICAgICAgICwgbV9tb2RlKG1vZGUpCisgICAgeworICAgICAgICB3b3Jr ZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkLCB3b3JrZXIsIGNvbW1vbkNsaWVudCwgdHlwZSwgc2l6ZSwgdGhp cykpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFk KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJXb3JrZXJCYXNlKiB3b3JrZXIs IFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpUeXBl IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzT3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVh ZEJyaWRnZT4gYnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisgICAg ICAgICAgICBicmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQpOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBjb21tb25DbGllbnQtPm9wZW5GaWxlU3lzdGVtKHR5 cGUsIHNpemUsIG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2UpKTsKKyAg ICB9CisKKyAgICAvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQgYXJlIGRpc3BhdGNoZWQgb24g dGhlIG1haW4gdGhyZWFkLgorICAgIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tz IDogcHVibGljIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MgeworICAgIHB1YmxpYzoKKyAgICAgICAg TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoUGFzc093blB0cjxPcGVuRmlsZVN5c3RlbU1h aW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSkKKyAgICAgICAgICAgIDogbV9icmlkZ2UoYnJpZGdlKQor ICAgICAgICB7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFsIH5NYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrcygpCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmIChtX2JyaWRnZSkKKyAg ICAgICAgICAgICAgICBkaWRGYWlsKFdlYkZpbGVFcnJvckFib3J0KTsKKyAgICAgICAgfQorCisg ICAgICAgIHZpcnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBXZWJTdHJpbmcmIG5h bWUsIGNvbnN0IFdlYlN0cmluZyYgcGF0aCkKKyAgICAgICAgeworICAgICAgICAgICAgQVNTRVJU KG1fYnJpZGdlKTsKKyAgICAgICAgICAgIG1fYnJpZGdlLmxlYWtQdHIoKS0+ZGlkT3BlbkZpbGVT eXN0ZW1Pbk1haW5UaHJlYWQobmFtZSwgcGF0aCk7CisgICAgICAgICAgICBkZWxldGUgdGhpczsK KyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKFdlYkZpbGVFcnJvciBl cnJvcikKKyAgICAgICAgeworICAgICAgICAgICAgQVNTRVJUKG1fYnJpZGdlKTsKKyAgICAgICAg ICAgIG1fYnJpZGdlLmxlYWtQdHIoKS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvcik7CisgICAg ICAgICAgICBkZWxldGUgdGhpczsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWRTdWNjZWVkKCkgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKyAgICAgICAgdmly dHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYpIHsgV0VCS0lUX0FT U0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0 b3J5KGNvbnN0IFdlYlZlY3RvcjxXZWJGaWxlU3lzdGVtRW50cnk+JiwgYm9vbCkgeyBXRUJLSVRf QVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIE93blB0cjxP cGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IG1fYnJpZGdlOworICAgIH07CisgICAgZnJp ZW5kIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgdm9pZCBkaWRG YWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fd29y a2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZk aWRGYWlsT25Xb3JrZXJUaHJlYWQsIHRoaXMsIGVycm9yKSwgbV9tb2RlKTsKKyAgICB9CisKKyAg ICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFdURjo6U3RyaW5nJiBu YW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAgICBtX3dvcmtl ci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlk T3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgpLCBtX21v ZGUpOworICAgIH0KKworICAgIC8vIFRoaXMgcmVsZWFzZXMgdGhlIE9wZW5GaWxlU3lzdGVtTWFp blRocmVhZEJyaWRnZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1N YWluVGhyZWFkQnJpZGdlPiBicmlkZ2VQdHIsIFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7Cisg ICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlk Z2VQdHIpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkRmFp bChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzID0gMDsK KyAgICB9CisKKyAgICAvLyBUaGlzIHJlbGVhc2VzIHRoZSBPcGVuRmlsZVN5c3RlbU1haW5UaHJl YWRCcmlkZ2UuCisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVh ZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxPcGVuRmlsZVN5 c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZVB0ciwgY29uc3QgV1RGOjpTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKKyAgICB7CisgICAgICAgIE93blB0cjxPcGVu RmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlkZ2VQdHIpOworICAgICAgICBi cmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwg cm9vdFBhdGgpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcyA9IDA7 CisgICAgfQorCisgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV2ViRmlsZVN5c3Rl bUNhbGxiYWNrcyogbV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzOworICAgIFdURjo6U3RyaW5nIG1f bW9kZTsKK307CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4g dGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2ICszMzUs MTEgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3Qg V2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQo KTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSosIFdl YkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxs YmFja3MqIGNhbGxiYWNrcykKK3sKKyAgICBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U6 OnN0YXJ0KHRoaXMsIGNvbW1vbkNsaWVudCgpLCBvcGVuRmlsZVN5c3RlbU1vZGUsIHR5cGUsIHNp emUsIGNhbGxiYWNrcyk7Cit9CisKIC8vIFdvcmtlck9iamVjdFByb3h5IC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIHZvaWQgV2Vi V29ya2VyQmFzZTo6cG9zdE1lc3NhZ2VUb1dvcmtlck9iamVjdChQYXNzUmVmUHRyPFNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZT4gbWVzc2FnZSwKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKaW5k ZXggMjI3MTFmOWYyMmNmNzA2YmRkZWIwMjJjODVjNGMzMjdkNmUzMTJiMy4uZTk4ZGFmMThmMGVh MTYyYTlhYmNmODg1YTk0NGQyZjVkZmU5ZjkxNCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJCYXNlLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJC YXNlLmgKQEAgLTkxLDYgKzkxLDkgQEAgcHVibGljOgogICAgIC8vIENvbnRyb2xzIHdoZXRoZXIg YWNjZXNzIHRvIFdlYiBEYXRhYmFzZXMgaXMgYWxsb3dlZCBmb3IgdGhpcyB3b3JrZXIuCiAgICAg dmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5h bWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSk7CiAKKyAgICAvLyBSZXF1ZXN0cyB0byBvcGVuIGEgZmlsZSBzeXN0ZW0gZm9yIHRoaXMg d29ya2VyLgorICAgIHZpcnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSosIFdlYkZp bGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKik7 CisKICAgICAvLyBFeGVjdXRlcyB0aGUgZ2l2ZW4gdGFzayBvbiB0aGUgbWFpbiB0aHJlYWQuCiAg ICAgc3RhdGljIHZvaWQgZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8V2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQ2xpZW50SW1wbC5oCmluZGV4IDc0MWQ2MDY0MDY5NjFmM2YyNTkwZGIwOTk5ZmIy MDc2NTJhNWY1NDUuLjA2MDQ4MjM1ZGJmMjhmYzllZmYzNGEyYWVmZGE4NDFhODk3NGM3ZDIgMTAw NjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC0zMyw4ICszMyw4 IEBACiAKICNpZiBFTkFCTEUoV09SS0VSUykKIAorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIK ICNpbmNsdWRlICJXZWJXb3JrZXJDbGllbnQuaCIKLQogI2luY2x1ZGUgIldvcmtlckNvbnRleHRQ cm94eS5oIgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0 ci5oPgpAQCAtOTksNiArOTksMTAgQEAgcHVibGljOgogICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQorICAgIHZpcnR1YWwgdm9pZCBvcGVu RmlsZVN5c3RlbShXZWJGcmFtZSosIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXpl LCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgIH0KIAogcHJpdmF0ZToKICAgICB2aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJ bXBsKCk7Cg== 67974 2010-09-17 17:07:23 -0700 2010-09-17 20:28:29 -0700 Patch bug-45808-20100917170722.patch text/plain 31919 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZDZmOGI4YTM1MDNjYjI2YjI0YWQwNWQzZWRiY2YxZTJhODRkOWIzNS4uODljMGM5ZGNmZGVlMzJk ZWExZTVjNTYyYzUxMmExOWJkMWY2ZTQzOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluCisgICAgICAgIG5vbi1j aHJvbWl1bSBwb3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uCisgICAgICAg IFRoaXMgcGF0Y2ggYXNzdW1lcyBlYWNoIHBvcnQgY2FsbHMKKyAgICAgICAgTG9jYWxGaWxlU3lz dGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKCkgaW4gaXRzIGluaXRpYWxpemF0aW9uCisg ICAgICAgIHBoYXNlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgdGVzdHMgd2lsbCBiZSBhZGRl ZCB3aGVuIHdlIGhhdmUgY29tcGxldGUgaW1wbGVtZW50YXRpb24uCisKKyAgICAgICAgKiBiaW5k aW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZmlsZVN5c3RlbUVuYWJsZWQpOiBDaGFuZ2VkIHRv CisgICAgICAgIHJlZmxlY3QgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZQorICAgICAgICAq IGJpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOiBNb3ZlZCB0aGUgaW1w bGVtZW50YXRpb24KKyAgICAgICAgb2YgZmlsZVN5c3RlbUVuYWJsZWQgdG8gLmNwcC4KKyAgICAg ICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6IEFkZGVk LgorICAgICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmg6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06On5Mb2NhbEZpbGVTeXN0ZW0pOiBSZW1vdmVkLiAoQXMgbm93IGl0 J3MKKyAgICAgICAgZ29pbmcgdG8gYmUgdXNlZCBhcyBhIHNpbmdsZXRvbi4pCisgICAgICAgICog cGFnZS9ET01XaW5kb3cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0 RmlsZVN5c3RlbSk6IENoYW5nZWQgdG8gdXNlIGEgc2luZ2xldG9uCisgICAgICAgIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6Cisg ICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6Y2FuQWNjZXNzRmlsZVN5c3RlbSk6IEFk ZGVkLgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOiBSZW1vdmVkIGZpbGVTeXN0ZW1Sb290 UGF0aCBtZXRob2QuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5oOiBSZW1vdmVkIGZpbGVTeXN0 ZW1Sb290UGF0aCBtZXRob2QuCisgICAgICAgICogcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUpOiBBZGRl ZC4KKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCB0byBleHBvc2UKKyAg ICAgICAgcmVxdWVzdEZpbGVTeXN0ZW0gbWV0aG9kIGluIHdvcmtlciBjb250ZXh0cy4KKyAgICAg ICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNv bnRleHQuaWRsOgorCiAyMDEwLTA5LTE2ICB0YWthbm8gdGFrdW1pICA8dGFrYW5vMUBhc2lhLmFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZlIEh5YXR0LgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGIvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmluZGV4IGEx NWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNjZmY3Mjc4 Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2Vu ZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dl bmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5j bHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgog CisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgor I2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1 cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEgQEAgYm9v bCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQgPSBmYWxz ZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJl czo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFibGVkRmVh dHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lzdGVtRW5h YmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYKIAogI2lm IEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50 aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVu YWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUxZGM0MjBk NmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKKysr IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaApAQCAt MTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7CiAgICAg c3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsgaXNGaWxl U3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVlc3RGaWxl U3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNlbmRpZgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3Jl L2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5 ZTVlZTM5OTYwMGY2ZTA0NGY2Li5kNzg2ZDViNmVkODYzMzFjOTQyYTUzYTNiYzU3NmFlZDIyYTY4 YTg4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysg Yi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMzAgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9j YWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2Nh bEZpbGVTeXN0ZW0qIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxl U3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp Cit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBh cyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKCFzdGF0aWNM b2NhbEZpbGVTeXN0ZW0pOworICAgIGlmIChzdGF0aWNMb2NhbEZpbGVTeXN0ZW0pCisgICAgICAg IHJldHVybjsKKworICAgIE93blB0cjxMb2NhbEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9 IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICBzdGF0aWNMb2Nh bEZpbGVTeXN0ZW0gPSBsb2NhbEZpbGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVT eXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0 aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4K KyAgICBBU1NFUlQoc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICByZXR1cm4gKnN0YXRpY0xv Y2FsRmlsZVN5c3RlbTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJh c2VQYXRoKCkgY29uc3QKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3Rl bShiYXNlUGF0aCkpOworICAgIHJldHVybiBtX2Jhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9 CiAKIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBj b25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmls ZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxl U3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAK ICAgICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBz eW5jaHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25v dXNseS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxl U3lzdGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlk ZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNr LCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZp bGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0 KSkpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xv Y2FsRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4 IDQ4Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLjIzMTMxMGMyYzIxMDIx OGQ2ZGZjOGQ1MDYzZDQ2M2U4MTY3MWNkNTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9M b2NhbEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgK QEAgLTQ0LDE5ICs0NCwzMSBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3Rl bUNhbGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxG aWxlU3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVw cyBwZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8g b3BlbiBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNv cHlhYmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IGNyZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVT eXN0ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9j YWxGaWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxp emVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0 aGlzIG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsK IAogICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFz eW5jRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3Rl bUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNp ZiAhUExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBpcyBub3QgdGhyZWFkLXNhZmU7IG11 c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAg dm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYpOworCisgICAgU3Ry aW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAg TG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNl UGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2Rz IHNob3VsZG4ndCBhY2Nlc3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAg ICAvLyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRo OwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCAxNWYzZWQxODBlNmZjN2M1MmNlZTI5MDBmNTU0MmM2 ODFiZWE4YmQ5Li5lZTdjZGJiNTY5YjdhMzE2NTI2OGViMWMzNzZjYzAxZTViMzQ3NzAyIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBET01XaW5kb3c6OnJlcXVlc3RG aWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGUK ICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAoIW1fbG9jYWxG aWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYgYWNjZXNzIGlzIGFsbG93ZWQu Ci0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdlKCk7Ci0gICAgICAgIGlmICgh cGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1 bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoSU5WQUxJRF9TVEFURV9FUlIp KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0gICAgICAgIC8vIEZJWE1FOiBH ZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAgIFN0cmluZyBwYXRoID0gcGFn ZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0gICAgICAgIG1fbG9jYWxGaWxl U3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7CisgICAgaWYgKCFBc3luY0Zp bGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5j YW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVD YWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJ VFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2xvY2FsRmlsZVN5c3Rl bS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3Rl bTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cisg ICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbShk b2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwg c3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAotQ09NUElMRV9BU1NFUlQoaW50 KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3Jhcnkp LCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlBFUlNJU1RF TlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsK K0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpURU1QT1JBUlkpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21h dGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpQRVJTSVNU RU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVu dW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4IDE0NzA2Mjg2NWQ5YjliNzc0 NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLmZkNjM3ZWQzNDNmODgwZjZjOTY0ZTg1YjFjOGQxZTUz OTgzMWI2ZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaAorKysgYi9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFjdG9yeTsKICAgICBjbGFzcyBJ bnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2FsRmlsZVN5c3RlbTsKICAgICBj bGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwogICAgIGNsYXNzIE5hdmlnYXRv cjsKQEAgLTI0MSw2ICsyNDAsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBFTkFCTEUo RklMRV9TWVNURU0pCiAgICAgICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwg Y2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcuCisg ICAgICAgIC8vIFRoZSBjb2RlIGdlbmVyYXRvciBnZW5lcmF0ZXMgdGhlIGNvZGUgdGhhdCBwZXJm b3JtcyBjb21waWxlLXRpbWUgZW51bSBjaGVja2luZyB3aXRoIGNvbnN0YW50IGF0dHJpYnV0ZXMg ZGVmaW5lZCBpbiB0aGUgaWRsIGFuZCBlbnVtIHZhbHVlcyBpbiB0aGUgaGVhZGVyLCBhbmQgdGhl IGVudW0gbmFtZXMgbXVzdCBtYXRjaCB3aXRoIHRoZSBhdHRyaWJ1dGUgbmFtZXMuCiAgICAgICAg IGVudW0gRmlsZVN5c3RlbVR5cGUgewogICAgICAgICAgICAgVEVNUE9SQVJZLAogICAgICAgICAg ICAgUEVSU0lTVEVOVCwKQEAgLTQ0NCw5ICs0NDQsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAj aWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRyPElEQkZh Y3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKLSAg ICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0jZW5kaWYK IAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5p ZGwKaW5kZXggYjRjNjU4OWY2NTQ2ZTZlZTE2NjgwMWEyYjk3MTk5MjYyZGE3YzVlYS4uOGVmNmVj MWY0NTNkMDUwYTMzNDhhNDljMmM1YTc4NmVkODljMTRhMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5pZGwKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTE5 Myw3ICsxOTMsNiBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hv cnQgVEVNUE9SQVJZID0gMDsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVO VCA9IDE7CiAgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVt KGluIHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ss IE9wdGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJh Y2ssIE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwotCiAgICAgICAgIGF0 dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZs YWdzOwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5o IGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1 NjE5YWJjMTA0ZWI5ODFkY2VkNWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5 NzQ3MTY1MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6 CiAgICAgYm9vbCBjYW5BY2Nlc3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlx dWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1Vu aXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJl dHVybiAhaXNVbmlxdWUoKTsgfQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0 IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxk IGFsd2F5cyBhbGxvdyBhY2Nlc3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1 cnJlbnRseSBkb24ndCBoYW5kbGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1 bmlxdWUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCmluZGV4IDMyOWM0N2YzOWQxNjIxMzc3NDE2MDhmYjQxYTFmMDBlNzg5 NjhmMTIuLmUzNDYwNjkwMzMxN2QyMjEzYWViMmQzNzNmZjBmNDNiZTExOTZiM2UgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcApAQCAtNDkwLDExICs0OTAsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VE YXRhYmFzZVBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoID0gcGF0aDsKIH0KIAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRo KGNvbnN0IFN0cmluZyYgcGF0aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7 Ci19Ci0KIHZvaWQgU2V0dGluZ3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUp CiB7CiAgICAgbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDhl YzUxMDZiZjQ0ZDVhMjY3MzdhOGYzODE5NmNmYzU3MjRlNTgxNWQuLjdmNWZmN2ExM2QwMjJjZmJh ODBmZDdmOTNhZWVlZGZlMzk3ZTRmMDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5n cy5oCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCkBAIC0yMzksOSArMjM5LDYgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0 aChjb25zdCBTdHJpbmcmKTsKICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRh YmFzZVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQog Ci0gICAgICAgIHZvaWQgc2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAg ICAgICBjb25zdCBTdHJpbmcmIGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1f ZmlsZVN5c3RlbVJvb3RQYXRoOyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9t ZU1vZGUoYm9vbCk7CiAgICAgICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25z dCB7IHJldHVybiBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzMSw3ICszMjgs NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5j b2RpbmdOYW1lOwogICAgICAgICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAg ICAgICAgIFN0cmluZyBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5n IG1fZmlsZVN5c3RlbVJvb3RQYXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2Nh dGlvbjsKICAgICAgICAgQXRvbWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAg ICBBdG9taWNTdHJpbmcgbV9maXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAKaW5kZXggYjRmY2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4u ODc5MDU1NmM3NTQ0MDJjZmFmNDZiYWNhNDAzYzQ4ZTg4ZmMxNzg5OCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0v QXN5bmNGaWxlU3lzdGVtLmNwcApAQCAtMzgsOSArMzgsMTYgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9vbCBBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkKK3sKKyAgICAvLyBFYWNoIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQgdGhp cy4KKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBB c3luY0ZpbGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmKQogewotICAgIC8vIEZJWE1FOiBy ZXR1cm4gZGVmYXVsdCBBc3luY0ZpbGVTeXN0ZW0gaW1wbGVtZW50YXRpb24uCisgICAgLy8gRWFj aCBwbGF0Zm9ybSBzaG91bGQgaW1wbGVtZW50IHRoaXMuCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAg LTYyLDYgKzY5LDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0 IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUocm9vdFBhdGgp KTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3RyaW5nIEFzeW5j RmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgY29u c3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmggYi9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0 ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRk OWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFz UGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRpYyBib29sIGlz QXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3IHBsYXRmb3Jt LXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0 cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi40 NzVkODkzM2I1ODVkMzUyNzk5MTc0OGU0YmJhNmFiMTYzNDdjN2ZiIDEwMDY0NAotLS0gYS9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNl bnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVy cm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJGaWxlU3lz dGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRhc2sgOiBwdWJs aWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0zMzUsNiArMzQ0LDIxIEBAIHZv aWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJsb2JVUkxTdHJp bmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQgV29ya2VyQ29u dGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVm UHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9y Q2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkg eworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMsIGVycm9yQ2Fs bGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0 RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUp LCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQRVJTSVNURU5U KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1f bWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8v IEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdj YzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGVmYTYzNTBhOWRjNmEwMmZlYTAwZjY3NzMy Yjk1YzgzYzQwMGNmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCkBAIC00Nyw2ICs0Nyw4IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFzcyBEYXRh YmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsKKyAgICBjbGFzcyBFcnJvckNh bGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKICAgICBjbGFzcyBOb3RpZmlj YXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtl ckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg ICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmKTsKICNlbmRpZgogCisjaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFyZSBwbGFjZWQgaGVyZSBhbmQgaW4g YWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBpbGUtdGltZSBlbnVtIGNoZWNraW5n LgorICAgICAgICAvLyBUaGUgY29kZSBnZW5lcmF0b3IgZ2VuZXJhdGVzIHRoZSBjb2RlIHRoYXQg cGVyZm9ybXMgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcgd2l0aCBjb25zdGFudCBhdHRyaWJ1 dGVzIGRlZmluZWQgaW4gdGhlIGlkbCBhbmQgZW51bSB2YWx1ZXMgaW4gdGhlIGhlYWRlciwgYW5k IHRoZSBlbnVtIG5hbWVzIG11c3QgbWF0Y2ggd2l0aCB0aGUgYXR0cmlidXRlIG5hbWVzLgorICAg ICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAgICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAg ICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVT eXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxs YmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOworI2VuZGlmCisKICAgICAgICAgLy8g VGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4 dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4 dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3Io KSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJkZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjlj OWVlYzBlODQxYTIzZTYwNTA1ZjM1N2QzOWEwMjRkZTgxYzRiMzYgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQsMTMgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAg ICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChpbiBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJl dm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJsb2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVk KEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5BQkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0 IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNo b3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1 ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwg aW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFj aywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsK KyAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29u c3RydWN0b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBhMzkw ODNmZTE0NzNjM2RmNThlMjI4NzA3OWUxMDM4MmI0M2Q3MDJhLi4xZjc2N2I1Y2M4YzEwMjFkOWNj NTdhNTk3ZjVlODZiOWMwYmZmZDkwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAx MC0wOS0xNyAgS2ludWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0 IGZvciBGaWxlU3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDU4MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmls ZVN5c3RlbSBhbmQgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0 ZW0gdG8gY2FsbCBpbiB0byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAg ICAgaW4gdGhlIGNocm9taXVtLgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNs aWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxl U3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKTogQWRkZWQgaW1wbGVtZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuICBJbiB3b3Jr ZXIgY2FzZSB0aGlzIGNhbGxzIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAg ICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFz ZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4gIFRoaXMgaXMgY2FsbGVkIGZyb20KKyAgICAgICAg TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSBvbiB0aGUgd29ya2VyIHRocmVhZCBh bmQgY3JlYXRlcworICAgICAgICBhIGJyaWRnZSB0byBjYWxsIFdlYkNvbW1vbldvcmtlckNsaWVu dDo6b3BlbkZpbGVTeXN0ZW0gb24gdGhlIG1haW4KKyAgICAgICAgdGhyZWFkLgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0p OiBBZGRlZC4KKwogMjAxMC0wOS0xNiAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2NDcxMjNhNTJmNTAz Mjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUzYmI1YzhlNzg3Yzk2 YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldv cmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9uV29ya2VyQ2xpZW50 X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1ZGUgIldlYkNvbW1v bi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNlIFdlYktpdCB7CiAK IGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYsMTMgQEAgcHVibGlj OgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5n IGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1l KiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1 bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUg bWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0ZW0uCisgICAgdmly dHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBz aXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAgIC8vIEZJWE1FOiBX ZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBpbiBjaHJvbWl1bSBp bXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg IH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmluZGV4 IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUzYjNkMTUyYzFi NjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpBc3luY0ZpbGVT eXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5bmNGaWxlU3lz dGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2ViS2l0Q2xpZW50 KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxG aWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0 ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2VjYTljZTgyMjBm MjViMi4uZTIxMzFhM2EzMGJkZTNjNjAzNGIwMzQ1ZGY5ODQ3YjA3NGY0ZmE2NSAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQyLDE0 ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsLmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNs dWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogdXNpbmcg bmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExv Y2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBwYXRo KQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCiB7 Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOworICAgIERF RklORV9TVEFUSUNfTE9DQUwoTG9jYWxGaWxlU3lzdGVtLCBsb2NhbEZpbGVTeXN0ZW0sICgiIikp OworICAgIHJldHVybiBsb2NhbEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVt OjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3lu Y0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5 c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4g ZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcgKzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpy ZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0Zp CiAgICAgICAgIFdlYkZyYW1lSW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFt ZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZp bGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUp LCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxs YmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0g ZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMu CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3Jr ZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJM b2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHko KTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29y a2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmls ZVN5c3RlbShzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3 IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nl c3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5 ZDgyZTY1YTU0ODM5NTVlMmUuLmY0Y2E1MTYzZDZjNTFlNzlhMjk0MmJlYzNlZjQzMGVkZmZlYjc0 M2QgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsOCBA QAogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJX ZWJEYXRhU291cmNlSW1wbC5oIgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUg IldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgog I2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5l bC5oIgpAQCAtNTYsNiArNTgsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKICNpZiBFTkFCTEUoV09S S0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0Rh dGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3QgY2hhciBvcGVuRmlsZVN5c3RlbU1vZGVbXSA9ICJv cGVuRmlsZVN5c3RlbU1vZGUiOwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiArMTE3LDEyMyBA QCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5n IG1fbW9kZTsKIH07CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVT eXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFjayBmb3Ig dGhlIHJlcXVlc3QuICBUaGlzIG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVh ZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSB7CitwdWJsaWM6CisgICAg c3RhdGljIHZvaWQgc3RhcnQoV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJD bGllbnQqIGNvbW1vbkNsaWVudCwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUsIFdlYkZpbGVTeXN0 ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNh bGxiYWNrcykKKyAgICB7CisgICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRC cmlkZ2U+IGJyaWRnZSA9IGFkb3B0UHRyKG5ldyBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlk Z2Uod29ya2VyLCBtb2RlLCBjYWxsYmFja3MpKTsKKworICAgICAgICAvLyBUaGlzIGNsYXNzIGlz IHNlbGYtZGVzdHJ1Y3RlZC4KKyAgICAgICAgYnJpZGdlLmxlYWtQdHIoKS0+cG9zdE9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkKGNvbW1vbkNsaWVudCwgdHlwZSwgc2l6ZSk7CisgICAgfQorCisg ICAgfk9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSgpCisgICAgeworICAgICAgICBBU1NF UlQoIW1fd29ya2VyQ29udGV4dENhbGxiYWNrcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIE9w ZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0 IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisg ICAgICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgICAg ICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNrcyhjYWxsYmFja3MpCisgICAgeworICAgIH0KKwor ICAgIHZvaWQgcG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNs aWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBz aXplKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCBtX3dvcmtlciwg Y29tbW9uQ2xpZW50LCB0eXBlLCBzaXplLCB0aGlzKSk7CisgICAgfQorCisgICAgc3RhdGljIHZv aWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21t b25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NP d25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgeworICAg ICAgICBpZiAoIWNvbW1vbkNsaWVudCkKKyAgICAgICAgICAgIGJyaWRnZS0+ZGlkRmFpbE9uTWFp blRocmVhZChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAg Ly8gTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgaXMgc2VsZi1kZXN0cnVjdGVkLCBzbyB3 ZSBsZWFrIHB0ciBoZXJlLgorICAgICAgICAgICAgY29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3Rl bSh0eXBlLCBzaXplLCBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6Y3JlYXRlKGJyaWRn ZSkubGVha1B0cigpKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIC8vIEZpbGVTeXN0ZW1DYWxs YmFja3MgdGhhdCBhcmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgY2xhc3Mg TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgOiBwdWJsaWMgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFk RmlsZVN5c3RlbUNhbGxiYWNrcz4gY3JlYXRlKFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWlu VGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBhZG9w dFB0cihuZXcgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoYnJpZGdlKSk7CisgICAgICAg IH0KKworICAgICAgICB2aXJ0dWFsIH5NYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcygpCisg ICAgICAgIHsKKyAgICAgICAgICAgIGlmIChtX2JyaWRnZSkgeworICAgICAgICAgICAgICAgIC8v IG1fYnJpZGdlIGlzIHNlbGYtZGVzdHJ1Y3RlZCBhbmQgbXVzdCBiZSBkZXN0cnVjdGVkIG9uIHRo ZSB3b3JrZXIgdGhyZWFkLgorICAgICAgICAgICAgICAgIG1fYnJpZGdlLmxlYWtQdHIoKS0+ZGlk RmFpbE9uTWFpblRocmVhZChXZWJLaXQ6OldlYkZpbGVFcnJvckFib3J0KTsKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShj b25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgcGF0aCkKKyAgICAgICAgewor ICAgICAgICAgICAgQVNTRVJUKG1fYnJpZGdlKTsKKyAgICAgICAgICAgIC8vIG1fYnJpZGdlIGlz IHNlbGYtZGVzdHJ1Y3RlZCBhbmQgbXVzdCBiZSBkZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIgdGhy ZWFkLgorICAgICAgICAgICAgbV9icmlkZ2UubGVha1B0cigpLT5kaWRPcGVuRmlsZVN5c3RlbU9u TWFpblRocmVhZChuYW1lLCBwYXRoKTsKKyAgICAgICAgICAgIGRlbGV0ZSB0aGlzOworICAgICAg ICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoV2ViRmlsZUVycm9yIGVycm9yKQor ICAgICAgICB7CisgICAgICAgICAgICBBU1NFUlQobV9icmlkZ2UpOworICAgICAgICAgICAgLy8g bV9icmlkZ2UgaXMgc2VsZi1kZXN0cnVjdGVkIGFuZCBtdXN0IGJlIGRlc3RydWN0ZWQgb24gdGhl IHdvcmtlciB0aHJlYWQuCisgICAgICAgICAgICBtX2JyaWRnZS5sZWFrUHRyKCktPmRpZEZhaWxP bk1haW5UaHJlYWQoZXJyb3IpOworICAgICAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgICAgIH0K KworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpIHsgV0VCS0lUX0FTU0VSVF9OT1Rf UkVBQ0hFRCgpOyB9CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3Qg V2ViRmlsZUluZm8mKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAgICAgICB2 aXJ0dWFsIHZvaWQgZGlkUmVhZERpcmVjdG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3Rl bUVudHJ5PiYsIGJvb2wpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKKyAgICBw cml2YXRlOgorICAgICAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNzT3duUHRy PE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlKQorICAgICAgICAgICAgOiBt X2JyaWRnZShicmlkZ2UpCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIE93blB0cjxP cGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IG1fYnJpZGdlOworICAgIH07CisgICAgZnJp ZW5kIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgdm9pZCBkaWRG YWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fd29y a2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZk aWRGYWlsT25Xb3JrZXJUaHJlYWQsIHRoaXMsIGVycm9yKSwgbV9tb2RlKTsKKyAgICB9CisKKyAg ICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFdURjo6U3RyaW5nJiBu YW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAgICBtX3dvcmtl ci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlk T3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgpLCBtX21v ZGUpOworICAgIH0KKworICAgIC8vIFRoaXMgcmVsZWFzZXMgdGhlIE9wZW5GaWxlU3lzdGVtTWFp blRocmVhZEJyaWRnZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1N YWluVGhyZWFkQnJpZGdlPiBicmlkZ2VQdHIsIFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7Cisg ICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlk Z2VQdHIpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkRmFp bChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2FsbGJhY2tzID0gMDsK KyAgICB9CisKKyAgICAvLyBUaGlzIHJlbGVhc2VzIHRoZSBPcGVuRmlsZVN5c3RlbU1haW5UaHJl YWRCcmlkZ2UuCisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVh ZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxPcGVuRmlsZVN5 c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZVB0ciwgY29uc3QgV1RGOjpTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKKyAgICB7CisgICAgICAgIE93blB0cjxPcGVu RmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlkZ2VQdHIpOworICAgICAgICBi cmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwg cm9vdFBhdGgpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcyA9IDA7 CisgICAgfQorCisgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV1RGOjpTdHJpbmcg bV9tb2RlOworICAgIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIG1fd29ya2VyQ29udGV4dENhbGxi YWNrczsKK307CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4g dGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2ICszNTEs MTEgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3Qg V2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQo KTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVt OjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxs YmFja3MpCit7CisgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlOjpzdGFydCh0aGlz LCBjb21tb25DbGllbnQoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplLCBjYWxsYmFj a3MpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6 OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlm MjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNj YWVhMzdhOWZlYzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05 MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBX ZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9v bCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBX ZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisg ICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5v dGUgdGhhdCB0aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50 OjpvcGVuRmlsZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVt OjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAg Ly8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRp YyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVm NTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAj aWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVk ZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIK ICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAg LTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAg ICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0 ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwo= 67994 2010-09-17 20:28:33 -0700 2010-09-17 20:50:45 -0700 Patch bug-45808-20100917202832.patch text/plain 31608 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZDZmOGI4YTM1MDNjYjI2YjI0YWQwNWQzZWRiY2YxZTJhODRkOWIzNS4uODljMGM5ZGNmZGVlMzJk ZWExZTVjNTYyYzUxMmExOWJkMWY2ZTQzOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluCisgICAgICAgIG5vbi1j aHJvbWl1bSBwb3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uCisgICAgICAg IFRoaXMgcGF0Y2ggYXNzdW1lcyBlYWNoIHBvcnQgY2FsbHMKKyAgICAgICAgTG9jYWxGaWxlU3lz dGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKCkgaW4gaXRzIGluaXRpYWxpemF0aW9uCisg ICAgICAgIHBoYXNlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgdGVzdHMgd2lsbCBiZSBhZGRl ZCB3aGVuIHdlIGhhdmUgY29tcGxldGUgaW1wbGVtZW50YXRpb24uCisKKyAgICAgICAgKiBiaW5k aW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZmlsZVN5c3RlbUVuYWJsZWQpOiBDaGFuZ2VkIHRv CisgICAgICAgIHJlZmxlY3QgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZQorICAgICAgICAq IGJpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOiBNb3ZlZCB0aGUgaW1w bGVtZW50YXRpb24KKyAgICAgICAgb2YgZmlsZVN5c3RlbUVuYWJsZWQgdG8gLmNwcC4KKyAgICAg ICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6IEFkZGVk LgorICAgICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmg6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06On5Mb2NhbEZpbGVTeXN0ZW0pOiBSZW1vdmVkLiAoQXMgbm93IGl0 J3MKKyAgICAgICAgZ29pbmcgdG8gYmUgdXNlZCBhcyBhIHNpbmdsZXRvbi4pCisgICAgICAgICog cGFnZS9ET01XaW5kb3cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0 RmlsZVN5c3RlbSk6IENoYW5nZWQgdG8gdXNlIGEgc2luZ2xldG9uCisgICAgICAgIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6Cisg ICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6Y2FuQWNjZXNzRmlsZVN5c3RlbSk6IEFk ZGVkLgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOiBSZW1vdmVkIGZpbGVTeXN0ZW1Sb290 UGF0aCBtZXRob2QuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5oOiBSZW1vdmVkIGZpbGVTeXN0 ZW1Sb290UGF0aCBtZXRob2QuCisgICAgICAgICogcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUpOiBBZGRl ZC4KKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCB0byBleHBvc2UKKyAg ICAgICAgcmVxdWVzdEZpbGVTeXN0ZW0gbWV0aG9kIGluIHdvcmtlciBjb250ZXh0cy4KKyAgICAg ICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNv bnRleHQuaWRsOgorCiAyMDEwLTA5LTE2ICB0YWthbm8gdGFrdW1pICA8dGFrYW5vMUBhc2lhLmFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZlIEh5YXR0LgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGIvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmluZGV4IGEx NWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNjZmY3Mjc4 Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2Vu ZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dl bmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5j bHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgog CisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgor I2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1 cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEgQEAgYm9v bCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQgPSBmYWxz ZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJl czo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFibGVkRmVh dHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lzdGVtRW5h YmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYKIAogI2lm IEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50 aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVu YWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUxZGM0MjBk NmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKKysr IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaApAQCAt MTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7CiAgICAg c3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsgaXNGaWxl U3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVlc3RGaWxl U3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNlbmRpZgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3Jl L2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5 ZTVlZTM5OTYwMGY2ZTA0NGY2Li5kNzg2ZDViNmVkODYzMzFjOTQyYTUzYTNiYzU3NmFlZDIyYTY4 YTg4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysg Yi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMzAgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9j YWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2Nh bEZpbGVTeXN0ZW0qIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxl U3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp Cit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBh cyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKCFzdGF0aWNM b2NhbEZpbGVTeXN0ZW0pOworICAgIGlmIChzdGF0aWNMb2NhbEZpbGVTeXN0ZW0pCisgICAgICAg IHJldHVybjsKKworICAgIE93blB0cjxMb2NhbEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9 IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICBzdGF0aWNMb2Nh bEZpbGVTeXN0ZW0gPSBsb2NhbEZpbGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVT eXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0 aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4K KyAgICBBU1NFUlQoc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICByZXR1cm4gKnN0YXRpY0xv Y2FsRmlsZVN5c3RlbTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJh c2VQYXRoKCkgY29uc3QKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3Rl bShiYXNlUGF0aCkpOworICAgIHJldHVybiBtX2Jhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9 CiAKIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBj b25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmls ZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxl U3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAK ICAgICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBz eW5jaHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25v dXNseS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxl U3lzdGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlk ZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNr LCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZp bGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0 KSkpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xv Y2FsRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4 IDQ4Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLjIzMTMxMGMyYzIxMDIx OGQ2ZGZjOGQ1MDYzZDQ2M2U4MTY3MWNkNTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9M b2NhbEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgK QEAgLTQ0LDE5ICs0NCwzMSBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3Rl bUNhbGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxG aWxlU3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVw cyBwZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8g b3BlbiBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNv cHlhYmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IGNyZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVT eXN0ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9j YWxGaWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxp emVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0 aGlzIG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsK IAogICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFz eW5jRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3Rl bUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNp ZiAhUExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBpcyBub3QgdGhyZWFkLXNhZmU7IG11 c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAg dm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYpOworCisgICAgU3Ry aW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAg TG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNl UGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2Rz IHNob3VsZG4ndCBhY2Nlc3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAg ICAvLyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRo OwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCAxNWYzZWQxODBlNmZjN2M1MmNlZTI5MDBmNTU0MmM2 ODFiZWE4YmQ5Li5lZTdjZGJiNTY5YjdhMzE2NTI2OGViMWMzNzZjYzAxZTViMzQ3NzAyIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBET01XaW5kb3c6OnJlcXVlc3RG aWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGUK ICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAoIW1fbG9jYWxG aWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYgYWNjZXNzIGlzIGFsbG93ZWQu Ci0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdlKCk7Ci0gICAgICAgIGlmICgh cGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1 bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoSU5WQUxJRF9TVEFURV9FUlIp KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0gICAgICAgIC8vIEZJWE1FOiBH ZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAgIFN0cmluZyBwYXRoID0gcGFn ZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0gICAgICAgIG1fbG9jYWxGaWxl U3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7CisgICAgaWYgKCFBc3luY0Zp bGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5j YW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVD YWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJ VFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2xvY2FsRmlsZVN5c3Rl bS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3Rl bTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cisg ICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbShk b2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwg c3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAotQ09NUElMRV9BU1NFUlQoaW50 KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3Jhcnkp LCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlBFUlNJU1RF TlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsK K0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpURU1QT1JBUlkpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21h dGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpQRVJTSVNU RU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVu dW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4IDE0NzA2Mjg2NWQ5YjliNzc0 NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLmZkNjM3ZWQzNDNmODgwZjZjOTY0ZTg1YjFjOGQxZTUz OTgzMWI2ZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaAorKysgYi9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFjdG9yeTsKICAgICBjbGFzcyBJ bnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2FsRmlsZVN5c3RlbTsKICAgICBj bGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwogICAgIGNsYXNzIE5hdmlnYXRv cjsKQEAgLTI0MSw2ICsyNDAsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBFTkFCTEUo RklMRV9TWVNURU0pCiAgICAgICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwg Y2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcuCisg ICAgICAgIC8vIFRoZSBjb2RlIGdlbmVyYXRvciBnZW5lcmF0ZXMgdGhlIGNvZGUgdGhhdCBwZXJm b3JtcyBjb21waWxlLXRpbWUgZW51bSBjaGVja2luZyB3aXRoIGNvbnN0YW50IGF0dHJpYnV0ZXMg ZGVmaW5lZCBpbiB0aGUgaWRsIGFuZCBlbnVtIHZhbHVlcyBpbiB0aGUgaGVhZGVyLCBhbmQgdGhl IGVudW0gbmFtZXMgbXVzdCBtYXRjaCB3aXRoIHRoZSBhdHRyaWJ1dGUgbmFtZXMuCiAgICAgICAg IGVudW0gRmlsZVN5c3RlbVR5cGUgewogICAgICAgICAgICAgVEVNUE9SQVJZLAogICAgICAgICAg ICAgUEVSU0lTVEVOVCwKQEAgLTQ0NCw5ICs0NDQsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAj aWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRyPElEQkZh Y3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKLSAg ICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0jZW5kaWYK IAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5p ZGwKaW5kZXggYjRjNjU4OWY2NTQ2ZTZlZTE2NjgwMWEyYjk3MTk5MjYyZGE3YzVlYS4uOGVmNmVj MWY0NTNkMDUwYTMzNDhhNDljMmM1YTc4NmVkODljMTRhMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5pZGwKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTE5 Myw3ICsxOTMsNiBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hv cnQgVEVNUE9SQVJZID0gMDsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVO VCA9IDE7CiAgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVt KGluIHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ss IE9wdGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJh Y2ssIE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwotCiAgICAgICAgIGF0 dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZs YWdzOwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5o IGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1 NjE5YWJjMTA0ZWI5ODFkY2VkNWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5 NzQ3MTY1MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6 CiAgICAgYm9vbCBjYW5BY2Nlc3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlx dWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1Vu aXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJl dHVybiAhaXNVbmlxdWUoKTsgfQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0 IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxk IGFsd2F5cyBhbGxvdyBhY2Nlc3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1 cnJlbnRseSBkb24ndCBoYW5kbGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1 bmlxdWUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCmluZGV4IDMyOWM0N2YzOWQxNjIxMzc3NDE2MDhmYjQxYTFmMDBlNzg5 NjhmMTIuLmUzNDYwNjkwMzMxN2QyMjEzYWViMmQzNzNmZjBmNDNiZTExOTZiM2UgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcApAQCAtNDkwLDExICs0OTAsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VE YXRhYmFzZVBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoID0gcGF0aDsKIH0KIAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRo KGNvbnN0IFN0cmluZyYgcGF0aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7 Ci19Ci0KIHZvaWQgU2V0dGluZ3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUp CiB7CiAgICAgbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDhl YzUxMDZiZjQ0ZDVhMjY3MzdhOGYzODE5NmNmYzU3MjRlNTgxNWQuLjdmNWZmN2ExM2QwMjJjZmJh ODBmZDdmOTNhZWVlZGZlMzk3ZTRmMDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5n cy5oCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCkBAIC0yMzksOSArMjM5LDYgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0 aChjb25zdCBTdHJpbmcmKTsKICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRh YmFzZVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQog Ci0gICAgICAgIHZvaWQgc2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAg ICAgICBjb25zdCBTdHJpbmcmIGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1f ZmlsZVN5c3RlbVJvb3RQYXRoOyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9t ZU1vZGUoYm9vbCk7CiAgICAgICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25z dCB7IHJldHVybiBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzMSw3ICszMjgs NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5j b2RpbmdOYW1lOwogICAgICAgICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAg ICAgICAgIFN0cmluZyBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5n IG1fZmlsZVN5c3RlbVJvb3RQYXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2Nh dGlvbjsKICAgICAgICAgQXRvbWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAg ICBBdG9taWNTdHJpbmcgbV9maXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAKaW5kZXggYjRmY2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4u ODc5MDU1NmM3NTQ0MDJjZmFmNDZiYWNhNDAzYzQ4ZTg4ZmMxNzg5OCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0v QXN5bmNGaWxlU3lzdGVtLmNwcApAQCAtMzgsOSArMzgsMTYgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9vbCBBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkKK3sKKyAgICAvLyBFYWNoIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQgdGhp cy4KKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBB c3luY0ZpbGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmKQogewotICAgIC8vIEZJWE1FOiBy ZXR1cm4gZGVmYXVsdCBBc3luY0ZpbGVTeXN0ZW0gaW1wbGVtZW50YXRpb24uCisgICAgLy8gRWFj aCBwbGF0Zm9ybSBzaG91bGQgaW1wbGVtZW50IHRoaXMuCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAg LTYyLDYgKzY5LDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0 IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUocm9vdFBhdGgp KTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3RyaW5nIEFzeW5j RmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgY29u c3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmggYi9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0 ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRk OWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFz UGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRpYyBib29sIGlz QXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3IHBsYXRmb3Jt LXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0 cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi40 NzVkODkzM2I1ODVkMzUyNzk5MTc0OGU0YmJhNmFiMTYzNDdjN2ZiIDEwMDY0NAotLS0gYS9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNl bnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVy cm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJGaWxlU3lz dGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRhc2sgOiBwdWJs aWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0zMzUsNiArMzQ0LDIxIEBAIHZv aWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJsb2JVUkxTdHJp bmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQgV29ya2VyQ29u dGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVm UHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9y Q2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkg eworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMsIGVycm9yQ2Fs bGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0 RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUp LCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQRVJTSVNURU5U KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1f bWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8v IEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdj YzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGVmYTYzNTBhOWRjNmEwMmZlYTAwZjY3NzMy Yjk1YzgzYzQwMGNmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCkBAIC00Nyw2ICs0Nyw4IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFzcyBEYXRh YmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsKKyAgICBjbGFzcyBFcnJvckNh bGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKICAgICBjbGFzcyBOb3RpZmlj YXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtl ckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg ICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmKTsKICNlbmRpZgogCisjaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFyZSBwbGFjZWQgaGVyZSBhbmQgaW4g YWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBpbGUtdGltZSBlbnVtIGNoZWNraW5n LgorICAgICAgICAvLyBUaGUgY29kZSBnZW5lcmF0b3IgZ2VuZXJhdGVzIHRoZSBjb2RlIHRoYXQg cGVyZm9ybXMgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcgd2l0aCBjb25zdGFudCBhdHRyaWJ1 dGVzIGRlZmluZWQgaW4gdGhlIGlkbCBhbmQgZW51bSB2YWx1ZXMgaW4gdGhlIGhlYWRlciwgYW5k IHRoZSBlbnVtIG5hbWVzIG11c3QgbWF0Y2ggd2l0aCB0aGUgYXR0cmlidXRlIG5hbWVzLgorICAg ICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAgICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAg ICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVT eXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxs YmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOworI2VuZGlmCisKICAgICAgICAgLy8g VGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4 dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4 dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3Io KSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJkZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjlj OWVlYzBlODQxYTIzZTYwNTA1ZjM1N2QzOWEwMjRkZTgxYzRiMzYgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQsMTMgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAg ICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChpbiBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJl dm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJsb2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVk KEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5BQkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0 IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNo b3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1 ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwg aW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFj aywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsK KyAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29u c3RydWN0b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBhMzkw ODNmZTE0NzNjM2RmNThlMjI4NzA3OWUxMDM4MmI0M2Q3MDJhLi4xZjc2N2I1Y2M4YzEwMjFkOWNj NTdhNTk3ZjVlODZiOWMwYmZmZDkwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAx MC0wOS0xNyAgS2ludWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0 IGZvciBGaWxlU3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDU4MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmls ZVN5c3RlbSBhbmQgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0 ZW0gdG8gY2FsbCBpbiB0byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAg ICAgaW4gdGhlIGNocm9taXVtLgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNs aWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxl U3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKTogQWRkZWQgaW1wbGVtZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuICBJbiB3b3Jr ZXIgY2FzZSB0aGlzIGNhbGxzIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAg ICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFz ZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4gIFRoaXMgaXMgY2FsbGVkIGZyb20KKyAgICAgICAg TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSBvbiB0aGUgd29ya2VyIHRocmVhZCBh bmQgY3JlYXRlcworICAgICAgICBhIGJyaWRnZSB0byBjYWxsIFdlYkNvbW1vbldvcmtlckNsaWVu dDo6b3BlbkZpbGVTeXN0ZW0gb24gdGhlIG1haW4KKyAgICAgICAgdGhyZWFkLgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0p OiBBZGRlZC4KKwogMjAxMC0wOS0xNiAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2NDcxMjNhNTJmNTAz Mjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUzYmI1YzhlNzg3Yzk2 YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldv cmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9uV29ya2VyQ2xpZW50 X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1ZGUgIldlYkNvbW1v bi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNlIFdlYktpdCB7CiAK IGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYsMTMgQEAgcHVibGlj OgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5n IGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1l KiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1 bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUg bWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0ZW0uCisgICAgdmly dHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBz aXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAgIC8vIEZJWE1FOiBX ZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBpbiBjaHJvbWl1bSBp bXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg IH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmluZGV4 IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUzYjNkMTUyYzFi NjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpBc3luY0ZpbGVT eXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5bmNGaWxlU3lz dGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2ViS2l0Q2xpZW50 KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxG aWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0 ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2VjYTljZTgyMjBm MjViMi4uZTIxMzFhM2EzMGJkZTNjNjAzNGIwMzQ1ZGY5ODQ3YjA3NGY0ZmE2NSAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQyLDE0 ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsLmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNs dWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogdXNpbmcg bmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExv Y2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBwYXRo KQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCiB7 Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOworICAgIERF RklORV9TVEFUSUNfTE9DQUwoTG9jYWxGaWxlU3lzdGVtLCBsb2NhbEZpbGVTeXN0ZW0sICgiIikp OworICAgIHJldHVybiBsb2NhbEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVt OjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3lu Y0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5 c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4g ZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcgKzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpy ZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0Zp CiAgICAgICAgIFdlYkZyYW1lSW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFt ZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZp bGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUp LCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxs YmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0g ZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMu CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3Jr ZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJM b2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHko KTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29y a2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmls ZVN5c3RlbShzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3 IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nl c3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5 ZDgyZTY1YTU0ODM5NTVlMmUuLmU1YTA2ZTE1NTVkYTVmYjk5YTA2NzMyMTZlYmJhMTUxZjFiNzUx M2YgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsOCBA QAogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJX ZWJEYXRhU291cmNlSW1wbC5oIgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUg IldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgog I2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5l bC5oIgpAQCAtNTYsNiArNTgsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKICNpZiBFTkFCTEUoV09S S0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0Rh dGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3QgY2hhciBvcGVuRmlsZVN5c3RlbU1vZGVbXSA9ICJv cGVuRmlsZVN5c3RlbU1vZGUiOwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiArMTE3LDEyMCBA QCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5n IG1fbW9kZTsKIH07CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVT eXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFjayBmb3Ig dGhlIHJlcXVlc3QuICBUaGlzIG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVh ZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSB7CitwdWJsaWM6CisgICAg c3RhdGljIHZvaWQgc3RhcnQoV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJD bGllbnQqIGNvbW1vbkNsaWVudCwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUsIFdlYkZpbGVTeXN0 ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNh bGxiYWNrcykKKyAgICB7CisgICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRC cmlkZ2U+IGJyaWRnZSA9IGFkb3B0UHRyKG5ldyBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlk Z2Uod29ya2VyLCBtb2RlLCBjYWxsYmFja3MpKTsKKworICAgICAgICAvLyBUaGlzIGNsYXNzIGlz IHNlbGYtZGVzdHJ1Y3RlZC4KKyAgICAgICAgYnJpZGdlLmxlYWtQdHIoKS0+cG9zdE9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkKGNvbW1vbkNsaWVudCwgdHlwZSwgc2l6ZSk7CisgICAgfQorCisg ICAgfk9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSgpCisgICAgeworICAgICAgICBBU1NF UlQoIW1fd29ya2VyQ29udGV4dENhbGxiYWNrcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIE9w ZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0 IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisg ICAgICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgICAg ICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNrcyhjYWxsYmFja3MpCisgICAgeworICAgIH0KKwor ICAgIHZvaWQgcG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNs aWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBz aXplKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCBtX3dvcmtlciwg Y29tbW9uQ2xpZW50LCB0eXBlLCBzaXplLCB0aGlzKSk7CisgICAgfQorCisgICAgc3RhdGljIHZv aWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21t b25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIE9wZW5G aWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSogYnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFj b21tb25DbGllbnQpCisgICAgICAgICAgICBicmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2Vi RmlsZUVycm9yQWJvcnQpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIC8vIE1haW5UaHJl YWRGaWxlU3lzdGVtQ2FsbGJhY2tzIGlzIHNlbGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIg aGVyZS4KKyAgICAgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZpbGVTeXN0ZW0odHlwZSwgc2l6 ZSwgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6OmNyZWF0ZShicmlkZ2UpLmxlYWtQdHIo KSk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQg YXJlIGRpc3BhdGNoZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIGNsYXNzIE1haW5UaHJlYWRG aWxlU3lzdGVtQ2FsbGJhY2tzIDogcHVibGljIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MgeworICAg IHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NPd25QdHI8TWFpblRocmVhZEZpbGVTeXN0ZW1D YWxsYmFja3M+IGNyZWF0ZShPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UqIGJyaWRnZSkK KyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBNYWluVGhyZWFkRmls ZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2UpKTsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwg fk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKCkKKyAgICAgICAgeworICAgICAgICAgICAg aWYgKG1fYnJpZGdlKQorICAgICAgICAgICAgICAgIG1fYnJpZGdlLT5kaWRGYWlsT25NYWluVGhy ZWFkKFdlYktpdDo6V2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICB9CisKKyAgICAgICAgdmly dHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3Qg V2ViU3RyaW5nJiBwYXRoKQorICAgICAgICB7CisgICAgICAgICAgICBBU1NFUlQobV9icmlkZ2Up OworICAgICAgICAgICAgbV9icmlkZ2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5h bWUsIHBhdGgpOworICAgICAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgICAgIH0KKworICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJyb3IgZXJyb3IpCisgICAgICAgIHsKKyAg ICAgICAgICAgIEFTU0VSVChtX2JyaWRnZSk7CisgICAgICAgICAgICBtX2JyaWRnZS0+ZGlkRmFp bE9uTWFpblRocmVhZChlcnJvcik7CisgICAgICAgICAgICBkZWxldGUgdGhpczsKKyAgICAgICAg fQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRTdWNjZWVkKCkgeyBXRUJLSVRfQVNTRVJUX05P VF9SRUFDSEVEKCk7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25z dCBXZWJGaWxlSW5mbyYpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisgICAgICAg IHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5KGNvbnN0IFdlYlZlY3RvcjxXZWJGaWxlU3lz dGVtRW50cnk+JiwgYm9vbCkgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKworICAg IHByaXZhdGU6CisgICAgICAgIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKE9wZW5GaWxl U3lzdGVtTWFpblRocmVhZEJyaWRnZSogYnJpZGdlKQorICAgICAgICAgICAgOiBtX2JyaWRnZShi cmlkZ2UpCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIC8vIE5vdCBvd25lZC4gKEl0 J3Mgc2VsZi1kZXN0cnVjdGVkLikKKyAgICAgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJp ZGdlKiBtX2JyaWRnZTsKKyAgICB9OworICAgIGZyaWVuZCBjbGFzcyBNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrczsKKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJy b3IgZXJyb3IpCisgICAgeworICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3Jr ZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29ya2VyVGhyZWFkLCB0aGlz LCBlcnJvciksIG1fbW9kZSk7CisgICAgfQorCisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9u TWFpblRocmVhZChjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3QgV1RGOjpTdHJpbmcmIHJv b3RQYXRoKQorICAgIHsKKyAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2Vy Q29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJl YWQsIHRoaXMsIG5hbWUsIHJvb3RQYXRoKSwgbV9tb2RlKTsKKyAgICB9CisKKyAgICAvLyBUaGlz IHJlbGVhc2VzIHRoZSBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UuCisgICAgc3RhdGlj IHZvaWQgZGlkRmFpbE9uV29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBQYXNzT3duUHRyPE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlUHRy LCBXZWJGaWxlRXJyb3IgZXJyb3IpCisgICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVTeXN0 ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdlLT5t X3dvcmtlckNvbnRleHRDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3IpOworICAgICAgICBicmlkZ2Ut Pm1fd29ya2VyQ29udGV4dENhbGxiYWNrcyA9IDA7CisgICAgfQorCisgICAgLy8gVGhpcyByZWxl YXNlcyB0aGUgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlLgorICAgIHN0YXRpYyB2b2lk IGRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFBhc3NPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlk Z2VQdHIsIGNvbnN0IFdURjo6U3RyaW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBh dGgpCisgICAgeworICAgICAgICBPd25QdHI8T3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdl PiBicmlkZ2UoYnJpZGdlUHRyKTsKKyAgICAgICAgYnJpZGdlLT5tX3dvcmtlckNvbnRleHRDYWxs YmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdl LT5tX3dvcmtlckNvbnRleHRDYWxsYmFja3MgPSAwOworICAgIH0KKworICAgIFdlYldvcmtlckJh c2UqIG1fd29ya2VyOworICAgIFdURjo6U3RyaW5nIG1fbW9kZTsKKyAgICBXZWJGaWxlU3lzdGVt Q2FsbGJhY2tzKiBtX3dvcmtlckNvbnRleHRDYWxsYmFja3M7Cit9OworCiB9CiAKIC8vIFRoaXMg ZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZCB0byBmb3JjZSB0byBpbml0aWFs aXplIHNvbWUgc3RhdGljCkBAIC0yMzEsNiArMzQ4LDExIEBAIGJvb2wgV2ViV29ya2VyQmFzZTo6 YWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2Vi U3RyCiAgICAgcmV0dXJuIGJyaWRnZS0+cmVzdWx0KCk7CiB9CiAKK3ZvaWQgV2ViV29ya2VyQmFz ZTo6b3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQoreworICAgIE9wZW5GaWxlU3lz dGVtTWFpblRocmVhZEJyaWRnZTo6c3RhcnQodGhpcywgY29tbW9uQ2xpZW50KCksIG9wZW5GaWxl U3lzdGVtTW9kZSwgdHlwZSwgc2l6ZSwgY2FsbGJhY2tzKTsKK30KKwogLy8gV29ya2VyT2JqZWN0 UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2VyT2JqZWN0 KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRlYjAyMmM4NWM0YzMyN2Q2 ZTMxMmIzLi42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMxZDk2YWNiIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAg Ly8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBpcyBhbGxvd2VkIGZv ciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSos IGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5z aWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVlc3RzIHRvIG9wZW4gYSBm aWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhpcyBpcyBub3QgdGhlIGlt cGxlbWVudGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVTeXN0ZW0uKQorICAgIHZv aWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdl YkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVzIHRoZSBnaXZlbiB0YXNr IG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNwYXRjaFRhc2tUb01haW5U aHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5o IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5kZXggNzQxZDYw NjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgyMzVkYmYyOGZjOWVmZjM0 YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGll bnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShXT1JLRVJTKQogCisjaW5j bHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgotCiAj aW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIu aD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6CiAg ICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9 CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3Rl bTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKQorICAgIHsK KyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBwcml2YXRlOgogICAgIHZp cnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsK 67995 2010-09-17 20:50:49 -0700 2010-09-20 20:48:49 -0700 Patch bug-45808-20100917205048.patch text/plain 31754 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZDZmOGI4YTM1MDNjYjI2YjI0YWQwNWQzZWRiY2YxZTJhODRkOWIzNS4uODljMGM5ZGNmZGVlMzJk ZWExZTVjNTYyYzUxMmExOWJkMWY2ZTQzOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3Rl bSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1 ODA4CisKKyAgICAgICAgRXhwb3NlZCByZXF1ZXN0RmlsZVN5c3RlbSBhbmQgRmxhZ3MgY29uc3Ry dWN0b3Igb24gd29ya2VyIGNvbnRleHRzLgorCisgICAgICAgIEFsc28gY2hhbmdlZCBob3cgdG8g Z2V0IHRoZSBiYXNlIHBhdGggZm9yIFdlYiBmaWxlIHN5c3RlbXMgKGluCisgICAgICAgIG5vbi1j aHJvbWl1bSBwb3J0cykgc28gdGhhdCBpdCB3b3JrcyBmb3Igd29ya2VycyB0b28uCisgICAgICAg IFRoaXMgcGF0Y2ggYXNzdW1lcyBlYWNoIHBvcnQgY2FsbHMKKyAgICAgICAgTG9jYWxGaWxlU3lz dGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKCkgaW4gaXRzIGluaXRpYWxpemF0aW9uCisg ICAgICAgIHBoYXNlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgdGVzdHMgd2lsbCBiZSBhZGRl ZCB3aGVuIHdlIGhhdmUgY29tcGxldGUgaW1wbGVtZW50YXRpb24uCisKKyAgICAgICAgKiBiaW5k aW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZmlsZVN5c3RlbUVuYWJsZWQpOiBDaGFuZ2VkIHRv CisgICAgICAgIHJlZmxlY3QgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZQorICAgICAgICAq IGJpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOiBNb3ZlZCB0aGUgaW1w bGVtZW50YXRpb24KKyAgICAgICAgb2YgZmlsZVN5c3RlbUVuYWJsZWQgdG8gLmNwcC4KKyAgICAg ICAgKiBmaWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6IEFkZGVk LgorICAgICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmg6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06On5Mb2NhbEZpbGVTeXN0ZW0pOiBSZW1vdmVkLiAoQXMgbm93IGl0 J3MKKyAgICAgICAgZ29pbmcgdG8gYmUgdXNlZCBhcyBhIHNpbmdsZXRvbi4pCisgICAgICAgICog cGFnZS9ET01XaW5kb3cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpyZXF1ZXN0 RmlsZVN5c3RlbSk6IENoYW5nZWQgdG8gdXNlIGEgc2luZ2xldG9uCisgICAgICAgIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6Cisg ICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6Y2FuQWNjZXNzRmlsZVN5c3RlbSk6IEFk ZGVkLgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOiBSZW1vdmVkIGZpbGVTeXN0ZW1Sb290 UGF0aCBtZXRob2QuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5oOiBSZW1vdmVkIGZpbGVTeXN0 ZW1Sb290UGF0aCBtZXRob2QuCisgICAgICAgICogcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUpOiBBZGRl ZC4KKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCB0byBleHBvc2UKKyAg ICAgICAgcmVxdWVzdEZpbGVTeXN0ZW0gbWV0aG9kIGluIHdvcmtlciBjb250ZXh0cy4KKyAgICAg ICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNv bnRleHQuaWRsOgorCiAyMDEwLTA5LTE2ICB0YWthbm8gdGFrdW1pICA8dGFrYW5vMUBhc2lhLmFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZlIEh5YXR0LgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGIvV2Vi Q29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmluZGV4IGEx NWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNjZmY3Mjc4 Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2Vu ZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL2dl bmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5j bHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgog CisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgor I2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1 cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEgQEAgYm9v bCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQgPSBmYWxz ZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJl czo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFibGVkRmVh dHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lzdGVtRW5h YmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYKIAogI2lm IEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50 aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVu YWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUxZGM0MjBk NmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKKysr IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaApAQCAt MTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7CiAgICAg c3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsgaXNGaWxl U3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVlc3RGaWxl U3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNlbmRpZgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3Jl L2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlmMWQ0ODM5 ZTVlZTM5OTYwMGY2ZTA0NGY2Li5kNzg2ZDViNmVkODYzMzFjOTQyYTUzYTNiYzU3NmFlZDIyYTY4 YTg4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysg Yi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAsMzAgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9j YWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3N0YXRpYyBMb2Nh bEZpbGVTeXN0ZW0qIHN0YXRpY0xvY2FsRmlsZVN5c3RlbSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxl U3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp Cit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBh cyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKCFzdGF0aWNM b2NhbEZpbGVTeXN0ZW0pOworICAgIGlmIChzdGF0aWNMb2NhbEZpbGVTeXN0ZW0pCisgICAgICAg IHJldHVybjsKKworICAgIE93blB0cjxMb2NhbEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9 IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICBzdGF0aWNMb2Nh bEZpbGVTeXN0ZW0gPSBsb2NhbEZpbGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVT eXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0 aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4K KyAgICBBU1NFUlQoc3RhdGljTG9jYWxGaWxlU3lzdGVtKTsKKyAgICByZXR1cm4gKnN0YXRpY0xv Y2FsRmlsZVN5c3RlbTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJh c2VQYXRoKCkgY29uc3QKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3Rl bShiYXNlUGF0aCkpOworICAgIHJldHVybiBtX2Jhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9 CiAKIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBj b25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmls ZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxl U3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAK ICAgICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBz eW5jaHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25v dXNseS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxl U3lzdGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlk ZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNr LCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZp bGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0 KSkpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xv Y2FsRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4 IDQ4Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLjIzMTMxMGMyYzIxMDIx OGQ2ZGZjOGQ1MDYzZDQ2M2U4MTY3MWNkNTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9M b2NhbEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgK QEAgLTQ0LDE5ICs0NCwzMSBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3Rl bUNhbGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxG aWxlU3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVw cyBwZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8g b3BlbiBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNv cHlhYmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IGNyZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVT eXN0ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9j YWxGaWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxp emVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0 aGlzIG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsK IAogICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFz eW5jRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3Rl bUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNp ZiAhUExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBpcyBub3QgdGhyZWFkLXNhZmU7IG11 c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAg dm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYpOworCisgICAgU3Ry aW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAg TG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNl UGF0aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2Rz IHNob3VsZG4ndCBhY2Nlc3MgdGhpcyBTdHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAg ICAvLyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRo OwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCAxNWYzZWQxODBlNmZjN2M1MmNlZTI5MDBmNTU0MmM2 ODFiZWE4YmQ5Li5lZTdjZGJiNTY5YjdhMzE2NTI2OGViMWMzNzZjYzAxZTViMzQ3NzAyIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBET01XaW5kb3c6OnJlcXVlc3RG aWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGUK ICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAoIW1fbG9jYWxG aWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYgYWNjZXNzIGlzIGFsbG93ZWQu Ci0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdlKCk7Ci0gICAgICAgIGlmICgh cGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1 bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoSU5WQUxJRF9TVEFURV9FUlIp KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0gICAgICAgIC8vIEZJWE1FOiBH ZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAgIFN0cmluZyBwYXRoID0gcGFn ZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0gICAgICAgIG1fbG9jYWxGaWxl U3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7CisgICAgaWYgKCFBc3luY0Zp bGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5j YW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVD YWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJ VFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2xvY2FsRmlsZVN5c3Rl bS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3Rl bTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cisg ICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbShk b2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwg c3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAotQ09NUElMRV9BU1NFUlQoaW50 KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3Jhcnkp LCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlBFUlNJU1RF TlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsK K0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpURU1QT1JBUlkpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21h dGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpQRVJTSVNU RU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVu dW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4IDE0NzA2Mjg2NWQ5YjliNzc0 NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLmZkNjM3ZWQzNDNmODgwZjZjOTY0ZTg1YjFjOGQxZTUz OTgzMWI2ZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaAorKysgYi9XZWJD b3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFjdG9yeTsKICAgICBjbGFzcyBJ bnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2FsRmlsZVN5c3RlbTsKICAgICBj bGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwogICAgIGNsYXNzIE5hdmlnYXRv cjsKQEAgLTI0MSw2ICsyNDAsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBFTkFCTEUo RklMRV9TWVNURU0pCiAgICAgICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwg Y2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcuCisg ICAgICAgIC8vIFRoZSBjb2RlIGdlbmVyYXRvciBnZW5lcmF0ZXMgdGhlIGNvZGUgdGhhdCBwZXJm b3JtcyBjb21waWxlLXRpbWUgZW51bSBjaGVja2luZyB3aXRoIGNvbnN0YW50IGF0dHJpYnV0ZXMg ZGVmaW5lZCBpbiB0aGUgaWRsIGFuZCBlbnVtIHZhbHVlcyBpbiB0aGUgaGVhZGVyLCBhbmQgdGhl IGVudW0gbmFtZXMgbXVzdCBtYXRjaCB3aXRoIHRoZSBhdHRyaWJ1dGUgbmFtZXMuCiAgICAgICAg IGVudW0gRmlsZVN5c3RlbVR5cGUgewogICAgICAgICAgICAgVEVNUE9SQVJZLAogICAgICAgICAg ICAgUEVSU0lTVEVOVCwKQEAgLTQ0NCw5ICs0NDQsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAj aWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRyPElEQkZh Y3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKLSAg ICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0jZW5kaWYK IAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5p ZGwKaW5kZXggYjRjNjU4OWY2NTQ2ZTZlZTE2NjgwMWEyYjk3MTk5MjYyZGE3YzVlYS4uOGVmNmVj MWY0NTNkMDUwYTMzNDhhNDljMmM1YTc4NmVkODljMTRhMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5pZGwKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTE5 Myw3ICsxOTMsNiBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hv cnQgVEVNUE9SQVJZID0gMDsKICAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVO VCA9IDE7CiAgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVt KGluIHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ss IE9wdGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJh Y2ssIE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOwotCiAgICAgICAgIGF0 dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZs YWdzOwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5o IGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1 NjE5YWJjMTA0ZWI5ODFkY2VkNWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5 NzQ3MTY1MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6 CiAgICAgYm9vbCBjYW5BY2Nlc3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlx dWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1Vu aXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJl dHVybiAhaXNVbmlxdWUoKTsgfQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0 IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxk IGFsd2F5cyBhbGxvdyBhY2Nlc3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1 cnJlbnRseSBkb24ndCBoYW5kbGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1 bmlxdWUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCmluZGV4IDMyOWM0N2YzOWQxNjIxMzc3NDE2MDhmYjQxYTFmMDBlNzg5 NjhmMTIuLmUzNDYwNjkwMzMxN2QyMjEzYWViMmQzNzNmZjBmNDNiZTExOTZiM2UgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcApAQCAtNDkwLDExICs0OTAsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VE YXRhYmFzZVBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoID0gcGF0aDsKIH0KIAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRo KGNvbnN0IFN0cmluZyYgcGF0aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7 Ci19Ci0KIHZvaWQgU2V0dGluZ3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUp CiB7CiAgICAgbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDhl YzUxMDZiZjQ0ZDVhMjY3MzdhOGYzODE5NmNmYzU3MjRlNTgxNWQuLjdmNWZmN2ExM2QwMjJjZmJh ODBmZDdmOTNhZWVlZGZlMzk3ZTRmMDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5n cy5oCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCkBAIC0yMzksOSArMjM5LDYgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0 aChjb25zdCBTdHJpbmcmKTsKICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRh YmFzZVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQog Ci0gICAgICAgIHZvaWQgc2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAg ICAgICBjb25zdCBTdHJpbmcmIGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1f ZmlsZVN5c3RlbVJvb3RQYXRoOyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9t ZU1vZGUoYm9vbCk7CiAgICAgICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25z dCB7IHJldHVybiBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzMSw3ICszMjgs NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5j b2RpbmdOYW1lOwogICAgICAgICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAg ICAgICAgIFN0cmluZyBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5n IG1fZmlsZVN5c3RlbVJvb3RQYXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2Nh dGlvbjsKICAgICAgICAgQXRvbWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAg ICBBdG9taWNTdHJpbmcgbV9maXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAKaW5kZXggYjRmY2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4u ODc5MDU1NmM3NTQ0MDJjZmFmNDZiYWNhNDAzYzQ4ZTg4ZmMxNzg5OCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0v QXN5bmNGaWxlU3lzdGVtLmNwcApAQCAtMzgsOSArMzgsMTYgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9vbCBBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkKK3sKKyAgICAvLyBFYWNoIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQgdGhp cy4KKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBB c3luY0ZpbGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmKQogewotICAgIC8vIEZJWE1FOiBy ZXR1cm4gZGVmYXVsdCBBc3luY0ZpbGVTeXN0ZW0gaW1wbGVtZW50YXRpb24uCisgICAgLy8gRWFj aCBwbGF0Zm9ybSBzaG91bGQgaW1wbGVtZW50IHRoaXMuCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAg LTYyLDYgKzY5LDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0 IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUocm9vdFBhdGgp KTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3RyaW5nIEFzeW5j RmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgY29u c3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmggYi9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0 ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRk OWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFz UGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRpYyBib29sIGlz QXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3IHBsYXRmb3Jt LXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0 cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi40 NzVkODkzM2I1ODVkMzUyNzk5MTc0OGU0YmJhNmFiMTYzNDdjN2ZiIDEwMDY0NAotLS0gYS9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNl bnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVy cm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJGaWxlU3lz dGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRhc2sgOiBwdWJs aWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0zMzUsNiArMzQ0LDIxIEBAIHZv aWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJsb2JVUkxTdHJp bmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQgV29ya2VyQ29u dGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVm UHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9y Q2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06Omlz QXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkg eworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMsIGVycm9yQ2Fs bGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0 RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUp LCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQRVJTSVNURU5U KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1f bWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8v IEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdj YzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGVmYTYzNTBhOWRjNmEwMmZlYTAwZjY3NzMy Yjk1YzgzYzQwMGNmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCkBAIC00Nyw2ICs0Nyw4IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFzcyBEYXRh YmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsKKyAgICBjbGFzcyBFcnJvckNh bGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsKICAgICBjbGFzcyBOb3RpZmlj YXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtl ckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg ICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmKTsKICNlbmRpZgogCisjaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFyZSBwbGFjZWQgaGVyZSBhbmQgaW4g YWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBpbGUtdGltZSBlbnVtIGNoZWNraW5n LgorICAgICAgICAvLyBUaGUgY29kZSBnZW5lcmF0b3IgZ2VuZXJhdGVzIHRoZSBjb2RlIHRoYXQg cGVyZm9ybXMgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcgd2l0aCBjb25zdGFudCBhdHRyaWJ1 dGVzIGRlZmluZWQgaW4gdGhlIGlkbCBhbmQgZW51bSB2YWx1ZXMgaW4gdGhlIGhlYWRlciwgYW5k IHRoZSBlbnVtIG5hbWVzIG11c3QgbWF0Y2ggd2l0aCB0aGUgYXR0cmlidXRlIG5hbWVzLgorICAg ICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAgICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAg ICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVT eXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxs YmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOworI2VuZGlmCisKICAgICAgICAgLy8g VGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4 dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4 dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3Io KSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJkZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjlj OWVlYzBlODQxYTIzZTYwNTA1ZjM1N2QzOWEwMjRkZTgxYzRiMzYgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQsMTMgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAg ICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChpbiBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJl dm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJsb2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVk KEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5BQkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0 IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNo b3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1 ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwg aW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFj aywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsK KyAgICAgICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29u c3RydWN0b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBhMzkw ODNmZTE0NzNjM2RmNThlMjI4NzA3OWUxMDM4MmI0M2Q3MDJhLi4xZjc2N2I1Y2M4YzEwMjFkOWNj NTdhNTk3ZjVlODZiOWMwYmZmZDkwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAx MC0wOS0xNyAgS2ludWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0 IGZvciBGaWxlU3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDU4MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmls ZVN5c3RlbSBhbmQgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0 ZW0gdG8gY2FsbCBpbiB0byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAg ICAgaW4gdGhlIGNocm9taXVtLgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNs aWVudC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxl U3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKTogQWRkZWQgaW1wbGVtZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuICBJbiB3b3Jr ZXIgY2FzZSB0aGlzIGNhbGxzIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAg ICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFz ZTo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4gIFRoaXMgaXMgY2FsbGVkIGZyb20KKyAgICAgICAg TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSBvbiB0aGUgd29ya2VyIHRocmVhZCBh bmQgY3JlYXRlcworICAgICAgICBhIGJyaWRnZSB0byBjYWxsIFdlYkNvbW1vbldvcmtlckNsaWVu dDo6b3BlbkZpbGVTeXN0ZW0gb24gdGhlIG1haW4KKyAgICAgICAgdGhyZWFkLgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0p OiBBZGRlZC4KKwogMjAxMC0wOS0xNiAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2NDcxMjNhNTJmNTAz Mjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUzYmI1YzhlNzg3Yzk2 YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldv cmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9uV29ya2VyQ2xpZW50 X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1ZGUgIldlYkNvbW1v bi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNlIFdlYktpdCB7CiAK IGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYsMTMgQEAgcHVibGlj OgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5n IGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1l KiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1 bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUg bWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0ZW0uCisgICAgdmly dHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBz aXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAgIC8vIEZJWE1FOiBX ZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBpbiBjaHJvbWl1bSBp bXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg IH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmluZGV4 IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUzYjNkMTUyYzFi NjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpBc3luY0ZpbGVT eXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5bmNGaWxlU3lz dGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2ViS2l0Q2xpZW50 KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxG aWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0 ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2VjYTljZTgyMjBm MjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMxOCAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQyLDE0 ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsLmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNs dWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogdXNpbmcg bmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExv Y2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBwYXRo KQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCiB7 Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOworICAgIEF0 b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBsb2NhbEZpbGVTeXN0 ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICpsb2NhbEZpbGVTeXN0 ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9u ZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJh Y2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcgKzY1 LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZyYW1lSW1wbCogd2Vi RnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAgICAg ICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRpY19j YXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNh bGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJv ckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1FOiBB ZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtlckNvbnRleHQqIHdv cmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAg ICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0 LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSog d2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5 KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNfY2FzdDxXZWJGaWxl U3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBs KG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywg Y29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3Bw CmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUuLjFlODNhOTQw MWFjMTBjM2UzODc0OGIzNTRiZmM3Mjc3NzkxNDQ0OGEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsOCBAQAogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2Fn ZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5oIgorI2luY2x1 ZGUgIldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIK ICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgog I2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpAQCAtNTYsNiArNTgsNyBAQCBuYW1l c3BhY2UgV2ViS2l0IHsKICNpZiBFTkFCTEUoV09SS0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIg YWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0RhdGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3Qg Y2hhciBvcGVuRmlsZVN5c3RlbU1vZGVbXSA9ICJvcGVuRmlsZVN5c3RlbU1vZGUiOwogCiBuYW1l c3BhY2UgewogCkBAIC0xMTQsNiArMTE3LDEyMyBAQCBwcml2YXRlOgogICAgIFdlYldvcmtlckJh c2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5nIG1fbW9kZTsKIH07CisKKy8vIFRoaXMgY2xh c3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0 aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFjayBmb3IgdGhlIHJlcXVlc3QuICBUaGlzIG11c3QgYmUg ZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KK2NsYXNzIE9wZW5GaWxlU3lzdGVtTWFp blRocmVhZEJyaWRnZSB7CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgc3RhcnQoV2ViV29ya2Vy QmFzZSogd29ya2VyLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgY29uc3Qg V1RGOjpTdHJpbmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNp emUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICB7CisgICAgICAgIE93 blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSA9IGFkb3B0UHRyKG5l dyBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2Uod29ya2VyLCBtb2RlLCBjYWxsYmFja3Mp KTsKKworICAgICAgICAvLyBUaGlzIGNsYXNzIGlzIHNlbGYtZGVzdHJ1Y3RlZC4KKyAgICAgICAg YnJpZGdlLmxlYWtQdHIoKS0+cG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbW1vbkNs aWVudCwgdHlwZSwgc2l6ZSk7CisgICAgfQorCisgICAgfk9wZW5GaWxlU3lzdGVtTWFpblRocmVh ZEJyaWRnZSgpCisgICAgeworICAgICAgICBBU1NFUlQoIW1fd29ya2VyQ29udGV4dENhbGxiYWNr cyk7CisgICAgfQorCitwcml2YXRlOgorICAgIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRn ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxl U3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgICAgIDogbV93b3JrZXIod29ya2VyKQor ICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgICAgICAsIG1fd29ya2VyQ29udGV4dENhbGxiYWNr cyhjYWxsYmFja3MpCisgICAgeworICAgIH0KKworICAgIHZvaWQgcG9zdE9wZW5GaWxlU3lzdGVt T25NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplKQorICAgIHsKKyAgICAgICAgbV93b3Jr ZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxl U3lzdGVtT25NYWluVGhyZWFkLCBtX3dvcmtlciwgY29tbW9uQ2xpZW50LCB0eXBlLCBzaXplLCB0 aGlzKSk7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJl YWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYldvcmtlckJhc2UqIHdvcmtl ciwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5 cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIE9wZW5GaWxlU3lzdGVtTWFpblRocmVhZEJyaWRnZSog YnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisgICAgICAgICAgICBi cmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICBl bHNlIHsKKyAgICAgICAgICAgIC8vIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzIGlzIHNl bGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIgaGVyZS4KKyAgICAgICAgICAgIGNvbW1vbkNs aWVudC0+b3BlbkZpbGVTeXN0ZW0odHlwZSwgc2l6ZSwgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxs YmFja3M6OmNyZWF0ZShicmlkZ2UpLmxlYWtQdHIoKSk7CisgICAgICAgIH0KKyAgICB9CisKKyAg ICAvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQgYXJlIGRpc3BhdGNoZWQgb24gdGhlIG1haW4g dGhyZWFkLgorICAgIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzIDogcHVibGlj IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MgeworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBh c3NPd25QdHI8TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNyZWF0ZShPcGVuRmlsZVN5 c3RlbU1haW5UaHJlYWRCcmlkZ2UqIGJyaWRnZSkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0 dXJuIGFkb3B0UHRyKG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2UpKTsK KyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJh Y2tzKCkKKyAgICAgICAgeworICAgICAgICAgICAgQVNTRVJUKCFtX2JyaWRnZSk7CisgICAgICAg IH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgV2ViU3Ry aW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgICAgIHsKKyAgICAgICAgICAg IEFTU0VSVChtX2JyaWRnZSk7CisgICAgICAgICAgICAvLyBUaGlzIHdpbGwgZGVsZXRlIHRoZSBi cmlkZ2Ugb24gdGhlIHdvcmtlciB0aHJlYWQuCisgICAgICAgICAgICBtX2JyaWRnZS0+ZGlkT3Bl bkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQobmFtZSwgcGF0aCk7CisgICAgICAgICAgICBtX2JyaWRn ZSA9IDA7CisgICAgICAgICAgICBkZWxldGUgdGhpczsKKyAgICAgICAgfQorCisgICAgICAgIHZp cnR1YWwgdm9pZCBkaWRGYWlsKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICAgICAgeworICAgICAg ICAgICAgQVNTRVJUKG1fYnJpZGdlKTsKKyAgICAgICAgICAgIC8vIFRoaXMgd2lsbCBkZWxldGUg dGhlIGJyaWRnZSBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICAgICAgICAgIG1fYnJpZGdlLT5k aWRGYWlsT25NYWluVGhyZWFkKGVycm9yKTsKKyAgICAgICAgICAgIG1fYnJpZGdlID0gMDsKKyAg ICAgICAgICAgIGRlbGV0ZSB0aGlzOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lk IGRpZFN1Y2NlZWQoKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorICAgICAgICB2 aXJ0dWFsIHZvaWQgZGlkUmVhZE1ldGFkYXRhKGNvbnN0IFdlYkZpbGVJbmZvJikgeyBXRUJLSVRf QVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJl Y3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZpbGVTeXN0ZW1FbnRyeT4mLCBib29sKSB7IFdFQktJ VF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgTWFpblRo cmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlKiBi cmlkZ2UpCisgICAgICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgeworICAgICAg ICB9CisKKyAgICAgICAgLy8gTm90IG93bmVkLiAoSXQncyBzZWxmLWRlc3RydWN0ZWQuKQorICAg ICAgICBPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2UqIG1fYnJpZGdlOworICAgIH07Cisg ICAgZnJpZW5kIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgdm9p ZCBkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAg IG1fd29ya2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tU YXNrKCZkaWRGYWlsT25Xb3JrZXJUaHJlYWQsIHRoaXMsIGVycm9yKSwgbV9tb2RlKTsKKyAgICB9 CisKKyAgICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFdURjo6U3Ry aW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpCisgICAgeworICAgICAgICBt X3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFz aygmZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgp LCBtX21vZGUpOworICAgIH0KKworICAgIC8vIFRoaXMgcmVsZWFzZXMgdGhlIE9wZW5GaWxlU3lz dGVtTWFpblRocmVhZEJyaWRnZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJl YWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8T3BlbkZpbGVT eXN0ZW1NYWluVGhyZWFkQnJpZGdlPiBicmlkZ2VQdHIsIFdlYkZpbGVFcnJvciBlcnJvcikKKyAg ICB7CisgICAgICAgIE93blB0cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRn ZShicmlkZ2VQdHIpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV93b3JrZXJDb250ZXh0Q2FsbGJhY2tz ID0gMDsKKyAgICB9CisKKyAgICAvLyBUaGlzIHJlbGVhc2VzIHRoZSBPcGVuRmlsZVN5c3RlbU1h aW5UaHJlYWRCcmlkZ2UuCisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1Pbldvcmtl clRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxPcGVu RmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZVB0ciwgY29uc3QgV1RGOjpTdHJpbmcm IG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKKyAgICB7CisgICAgICAgIE93blB0 cjxPcGVuRmlsZVN5c3RlbU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZShicmlkZ2VQdHIpOworICAg ICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0o bmFtZSwgcm9vdFBhdGgpOworICAgICAgICBicmlkZ2UtPm1fd29ya2VyQ29udGV4dENhbGxiYWNr cyA9IDA7CisgICAgfQorCisgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV1RGOjpT dHJpbmcgbV9tb2RlOworICAgIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIG1fd29ya2VyQ29udGV4 dENhbGxiYWNrczsKK307CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhl IG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2 ICszNTEsMTEgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwg Y29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5y ZXN1bHQoKTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBjYWxsYmFja3MpCit7CisgICAgT3BlbkZpbGVTeXN0ZW1NYWluVGhyZWFkQnJpZGdlOjpzdGFy dCh0aGlzLCBjb21tb25DbGllbnQoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplLCBj YWxsYmFja3MpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtl ckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2Ny aXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIy NzExZjlmMjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2 Zjg1ZmNjYWVhMzdhOWZlYzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CkBAIC05MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2Vz cyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1 YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBj b25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUp OwogCisgICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtl ci4gKE5vdGUgdGhhdCB0aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1l Q2xpZW50OjpvcGVuRmlsZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxl U3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOwor CiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAg IHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6 OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YldvcmtlckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3 NjUyYTVmNTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBA QAogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAj aW5jbHVkZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJv eHkuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIu aD4KQEAgLTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZp bGVTeXN0ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwg V2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKKyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1w bCgpOwo= 68182 2010-09-20 20:48:54 -0700 2010-09-20 21:03:41 -0700 Patch bug-45808-20100920204853.patch text/plain 40851 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NmQ3ZDJlYzNiOGQ1ZjExOTNkMzU1ZWJhOGY2MzJlMTZlZmMzODcyMS4uNmQyMjAxYWQ4YzE5ODRk OGJlNmYxNWRjMDllYmMxOWZkNWYzZjM3MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAqIHdvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGw6CisKIDIwMTAtMDktMjAgIE5pY28gV2ViZXIgIDx0aGFraXNAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJD b3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgYi9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKaW5kZXggYTE1ZmQ2 ZDA4MDJmYmVlZjExMDlmY2E5YzlkM2IyZjNkMzAyMGMwNC4uOWE5NmYyMjZkM2NmZjcyNzhjNzky NjlhMWM4MmU0YWNjNzg0MDY0YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmlj L1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcApAQCAtMzYsNiArMzYsMTAgQEAKICNpbmNsdWRl ICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjaW5jbHVkZSAiV2ViU29ja2V0LmgiCiAKKyNp ZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjZW5k aWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6 OmlzTG9jYWxTdG9yYWdlRW5hYmxlZCA9IHRydWU7CkBAIC01Nyw2ICs2MSwxMSBAQCBib29sIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzWEhSUmVzcG9uc2VCbG9iRW5hYmxlZCA9IGZhbHNlOwog CiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpp c0ZpbGVTeXN0ZW1FbmFibGVkID0gZmFsc2U7CisKK2Jvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJl czo6ZmlsZVN5c3RlbUVuYWJsZWQoKQoreworICAgIHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVk ICYmIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKTsKK30KICNlbmRpZgogCiAjaWYgRU5B QkxFKFZJREVPKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVF bmFibGVkRmVhdHVyZXMuaCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxl ZEZlYXR1cmVzLmgKaW5kZXggOTE3NjhiMGU1NGU3Zjk3YmFjZDBhOWJkMzM5ZTFkYzQyMGQ2ZWRl ZS4uYmE0YTRmYjA1ZGY1MWQ3NDQ0ZmI5YTNiYTEwMDJhZTQ3YWJkNWZjOCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAorKysgYi9X ZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oCkBAIC0xNDgs NyArMTQ4LDcgQEAgcHVibGljOgogI2VuZGlmCiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCi0g ICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1F bmFibGVkOyB9CisgICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKTsKICAgICBzdGF0 aWMgdm9pZCBzZXRGaWxlU3lzdGVtRW5hYmxlZChib29sIGlzRW5hYmxlZCkgeyBpc0ZpbGVTeXN0 ZW1FbmFibGVkID0gaXNFbmFibGVkOyB9CiAgICAgc3RhdGljIGJvb2wgcmVxdWVzdEZpbGVTeXN0 ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lzdGVtRW5hYmxlZDsgfQogI2VuZGlmCmRpZmYg LS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCmluZGV4IDU5ZWMyYTFlNmQ3YmIxOWYxZDQ4MzllNWVl Mzk5NjAwZjZlMDQ0ZjYuLjE0YzYyYzg5NTY3MmJkZmY3NzJkZjliMmNjOWY2MWUyNWZkNGQ1MjIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCisrKyBiL1dl YkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCkBAIC01MCw5ICs1MCwzMCBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBMb2NhbEZp bGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorTG9jYWxGaWxlU3lzdGVt KiBMb2NhbEZpbGVTeXN0ZW06OnNfaW5zdGFuY2UgPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorewor ICAgIC8vIEZJWE1FOiBTaG91bGQgaW5pdGlhbGl6ZSB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2Vs bC4KKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVCghc19pbnN0YW5jZSk7 CisgICAgaWYgKHNfaW5zdGFuY2UpCisgICAgICAgIHJldHVybjsKKworICAgIE93blB0cjxMb2Nh bEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0 ZW0oYmFzZVBhdGgpKTsKKyAgICBzX2luc3RhbmNlID0gbG9jYWxGaWxlU3lzdGVtLmxlYWtQdHIo KTsKK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3Rl bSgpCit7CisgICAgLy8gaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSBtdXN0IGJlIGNhbGxlZCBw cmlvciBjYWxsaW5nIHRoaXMuCisgICAgQVNTRVJUKHNfaW5zdGFuY2UpOworICAgIHJldHVybiAq c19pbnN0YW5jZTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQ YXRoKCkgY29uc3QKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3RlbShi YXNlUGF0aCkpOworICAgIHJldHVybiBtX2Jhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9CiAK IHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25z dCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAKICAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVT eXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkp OwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2Fs RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4IDQ4 Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLjgzZmVmOWQ2M2M2NWIzZTk5 ZTgzYjdlZGUwNjIyOTdkMjQ4YWU2MDggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2Nh bEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKQEAg LTQ0LDE5ICs0NCwzMyBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxGaWxl U3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVwcyBw ZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8gb3Bl biBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IGNy ZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVTeXN0 ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9jYWxG aWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0aGlz IG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAog ICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNh bGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAh UExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBpcyBub3QgdGhyZWFkLXNhZmU7IG11c3Qg YmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAgdm9p ZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5n IGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAgTG9j YWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNlUGF0 aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSog c19pbnN0YW5jZTsKKworICAgIC8vIFRoZSBtZW1iZXIgbWV0aG9kcyBzaG91bGRuJ3QgYWNjZXNz IHRoaXMgU3RyaW5nIGRpcmVjdGx5IGJ1dCBzaG91bGQgdXNlCisgICAgLy8gZmlsZVN5c3RlbUJh c2VQYXRoKCkgaW5zdGVhZC4KICAgICBTdHJpbmcgbV9iYXNlUGF0aDsKIH07CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5j cHAKaW5kZXggZjViYTI1YzM2YTlhZDJjN2ZkMTY1OWE1YjVkM2QwNmQ4N2JhNWM0Ni4uNmEyMDNj YzdjNDkyZWMzM2FiZTAwMjkyZTNhMDQ4ZDhhMmFjMzQxZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAKQEAgLTcy NywyNSArNzI3LDE2IEBAIHZvaWQgRE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlw ZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlCiAgICAgaWYgKCFkb2N1bWVu dCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgaWYgKCFtX2xvY2FsRmlsZVN5c3RlbSkgewotICAg ICAgICAvLyBGSVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2VkLgotCi0gICAgICAgIFBhZ2Uq IHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgICAgICBpZiAoIXBhZ2UpIHsKLSAgICAgICAg ICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9jdW1lbnQsIGVycm9yQ2FsbGJh Y2ssIEZpbGVFcnJvcjo6Y3JlYXRlKElOVkFMSURfU1RBVEVfRVJSKSk7Ci0gICAgICAgICAgICBy ZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBGSVhNRTogR2V0IHRoZSBxdW90YSBzZXR0 aW5ncyBhcyB3ZWxsLgotICAgICAgICBTdHJpbmcgcGF0aCA9IHBhZ2UtPnNldHRpbmdzKCktPmZp bGVTeXN0ZW1Sb290UGF0aCgpOwotICAgICAgICBtX2xvY2FsRmlsZVN5c3RlbSA9IExvY2FsRmls ZVN5c3RlbTo6Y3JlYXRlKHBhdGgpOworICAgIGlmICghQXN5bmNGaWxlU3lzdGVtOjppc0F2YWls YWJsZSgpIHx8ICFkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRmlsZVN5c3Rl bSgpKSB7CisgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9jdW1lbnQs IGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAg ICByZXR1cm47CiAgICAgfQogCi0gICAgbV9sb2NhbEZpbGVTeXN0ZW0tPnJlcXVlc3RGaWxlU3lz dGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBz aXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAgIExvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19j YXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywg ZXJyb3JDYWxsYmFjayk7CiB9CiAKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlRFTVBP UkFSWSkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7 Ci1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBpbnQoQXN5bmNG aWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChz dGF0aWNfY2FzdDxpbnQ+KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBzdGF0aWNfY2FzdDxpbnQ+ KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nh c3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsKIAog I2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaCBiL1dlYkNvcmUv cGFnZS9ET01XaW5kb3cuaAppbmRleCAxNDcwNjI4NjVkOWI5Yjc3NDcxNjlhZmIyMTg0MWQ2NmYx MWQ5Y2Q0Li42ZmQzNzc1MDNhYjRlZWYxZDllNzc1Zjk4MzA0ZDExMzFmYWZiMDNhIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRv dy5oCkBAIC01OCw3ICs1OCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBIaXN0 b3J5OwogICAgIGNsYXNzIElEQkZhY3Rvcnk7CiAgICAgY2xhc3MgSW5zcGVjdG9yVGltZWxpbmVB Z2VudDsKLSAgICBjbGFzcyBMb2NhbEZpbGVTeXN0ZW07CiAgICAgY2xhc3MgTG9jYXRpb247CiAg ICAgY2xhc3MgU3R5bGVNZWRpYTsKICAgICBjbGFzcyBOYXZpZ2F0b3I7CkBAIC00NDQsOSArNDQz LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQog ICAgICAgICBtdXRhYmxlIFJlZlB0cjxJREJGYWN0b3J5PiBtX2lkYkZhY3Rvcnk7CiAjZW5kaWYK LSNpZiBFTkFCTEUoRklMRV9TWVNURU0pCi0gICAgICAgIFJlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IG1fbG9jYWxGaWxlU3lzdGVtOwotI2VuZGlmCiAKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1f ZXZlbnRUYXJnZXREYXRhOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmln aW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDQ3ODlkM2NlMTFhMGEy MzE1NTYxOWFiYzEwNGViOTgxZGNlZDVlZWYuLjJhNjM5NjZkNDg3YmQzYTZiNzY2MzcxNjIzMzVj NThjOTc0NzE2NTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCisr KyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0xMjEsNiArMTIxLDcgQEAgcHVi bGljOgogICAgIGJvb2wgY2FuQWNjZXNzTG9jYWxTdG9yYWdlKCkgY29uc3QgeyByZXR1cm4gIWlz VW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc0Nvb2tpZXMoKSBjb25zdCB7IHJldHVybiAh aXNVbmlxdWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzUGFzc3dvcmRNYW5hZ2VyKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KKyAgICBib29sIGNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSBj b25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogCiAgICAgLy8gVGVjaG5pY2FsbHksIHdlIHNo b3VsZCBhbHdheXMgYWxsb3cgYWNjZXNzIHRvIHNlc3Npb25TdG9yYWdlLCBidXQgd2UKICAgICAv LyBjdXJyZW50bHkgZG9uJ3QgaGFuZGxlIGNyZWF0aW5nIGEgc2Vzc2lvblN0b3JhZ2UgYXJlYSBm b3IgdW5pcXVlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwIGIvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCBmYWMwYTVmNDk2OGRiNmE0YWExZDc5NDZmZWJkZDNl ZjY5NTE0N2E1Li40ZDE2NjJiNjM2YTk4MTQxNjhiNmU1ODg0OGE1NzBiNmI2NTkxNjI3IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0 aW5ncy5jcHAKQEAgLTQ5NywxMSArNDk3LDYgQEAgdm9pZCBTZXR0aW5nczo6c2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkKICAgICBtX2xvY2FsU3RvcmFnZURh dGFiYXNlUGF0aCA9IHBhdGg7CiB9CiAKLXZvaWQgU2V0dGluZ3M6OnNldEZpbGVTeXN0ZW1Sb290 UGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCi17Ci0gICAgbV9maWxlU3lzdGVtUm9vdFBhdGggPSBw YXRoOwotfQotCiB2b2lkIFNldHRpbmdzOjpzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUoYm9vbCBt b2RlKQogewogICAgIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGUgPSBtb2RlOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRl eCA5OWE0ZjIzMmM1Mjk4MDZlYWEyN2Y4NWQ1N2RiYmFiMTI3NDRiZjMzLi5mOGEyOTdhMTdiMDU1 NjlkODVmYzdiMTEwYzQ2NTZmNDQ3NDA3NjRhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjQxLDkgKzI0MSw2IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRMb2NhbFN0b3JhZ2VEYXRhYmFz ZVBhdGgoY29uc3QgU3RyaW5nJik7CiAgICAgICAgIGNvbnN0IFN0cmluZyYgbG9jYWxTdG9yYWdl RGF0YWJhc2VQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGg7 IH0KIAotICAgICAgICB2b2lkIHNldEZpbGVTeXN0ZW1Sb290UGF0aChjb25zdCBTdHJpbmcmKTsK LSAgICAgICAgY29uc3QgU3RyaW5nJiBmaWxlU3lzdGVtUm9vdFBhdGgoKSBjb25zdCB7IHJldHVy biBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsgfQotCiAgICAgICAgIHZvaWQgc2V0QXBwbGljYXRpb25D aHJvbWVNb2RlKGJvb2wpOwogICAgICAgICBib29sIGluQXBwbGljYXRpb25DaHJvbWVNb2RlKCkg Y29uc3QgeyByZXR1cm4gbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZTsgfQogCkBAIC0zMzYsNyAr MzMzLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBTdHJpbmcgbV9kZWZhdWx0VGV4 dEVuY29kaW5nTmFtZTsKICAgICAgICAgU3RyaW5nIG1fZnRwRGlyZWN0b3J5VGVtcGxhdGVQYXRo OwogICAgICAgICBTdHJpbmcgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGg7Ci0gICAgICAgIFN0 cmluZyBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsKICAgICAgICAgS1VSTCBtX3VzZXJTdHlsZVNoZWV0 TG9jYXRpb247CiAgICAgICAgIEF0b21pY1N0cmluZyBtX3N0YW5kYXJkRm9udEZhbWlseTsKICAg ICAgICAgQXRvbWljU3RyaW5nIG1fZml4ZWRGb250RmFtaWx5OwpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0Zp bGVTeXN0ZW0uY3BwCmluZGV4IGI0ZmNkMGQ0ZDliNGZiY2VkOTQ2MTM4NWMxM2E2Y2ViYjY5ZmM3 YWYuLjc3ODI4ZmYxM2NhMjdmODc1YjMxNWVjODZiZTg2MjFkMmM1M2QwZTYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRm b3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKQEAgLTM0LDEzICszNCwyMSBAQAogI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKIAogI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgorI2lu Y2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmls ZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lz dGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1 bHQgQXN5bmNGaWxlU3lzdGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVkKCk7 CiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0 ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYg c3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxl U3lzdGVtOjpjcmVhdGUocm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxl bWVudGF0aW9uLgogU3RyaW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRo KGNvbnN0IFN0cmluZyYgcGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v QXN5bmNGaWxlU3lzdGVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmlu ZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZk YTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0 ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7 IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7 IH0KIAorICAgIHN0YXRpYyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFu ZCByZXR1cm5zIGEgbmV3IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5j ZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGlj IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0 aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0Nzdl ODE0YmJlNGQ4YmViOWMzYjllYTBhLi40NzVkODkzM2I1ODVkMzUyNzk5MTc0OGU0YmJhNmFiMTYz NDdjN2ZiIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysr IGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAog I2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklM RV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmls ZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJy b3IuaCIKKyNpbmNsdWRlICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZp bGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3Nl V29ya2VyQ29udGV4dFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7 CkBAIC0zMzUsNiArMzQ0LDIxIEBAIHZvaWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChj b25zdCBTdHJpbmcmIGJsb2JVUkxTdHJpbmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxF X1NZU1RFTSkKK3ZvaWQgV29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUs IGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0Nh bGxiYWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAg aWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCkt PmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVs ZUNhbGxiYWNrKHRoaXMsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZ X0VSUikpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjps b2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3lu Y0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2spOworfQorCitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRl eHQ6OlRFTVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBv cmFyeSksIGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihX b3JrZXJDb250ZXh0OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5 c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGQy ZjUxOWQyNTc0MWM4NjViMGY5MDY5ZThlZmNjZTg1ZjczNTk3NiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCkBAIC00Nyw2ICs0Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBE YXRhYmFzZTsKICAgICBjbGFzcyBEYXRhYmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNl U3luYzsKKyAgICBjbGFzcyBFcnJvckNhbGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxs YmFjazsKICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVk QWN0aW9uOwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJp bmcmKTsKICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5 IGFyZSBwbGFjZWQgaGVyZSBhbmQgaW4gYWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNv bXBpbGUtdGltZSBlbnVtIGNoZWNraW5nLgorICAgICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsK KyAgICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAgICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAg IH07CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBz aXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxs YmFjaz4pOworI2VuZGlmCisKICAgICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3Ig R0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYp IGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtl ck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRv ci5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRs IGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJk ZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjNlMTg1YzBkNWI4ZTBhMTM3YmQ5MjhjNTJhMmRi YTgxNzVmODAzMzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmlk bAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQs MTQgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAgICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChp biBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJs b2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVkKEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5B QkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9 IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAg ICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBz aG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmls ZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0g RXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsKKworICAgICAgICAgICAgICAgICBhdHRyaWJ1 dGUgW0VuYWJsZWRBdFJ1bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsK KyNlbmRpZgogICAgIH07CiAKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGRkMjNmNmYyNmVkNjVkMTE1MzBm YjYzNTkwYmRjYmYzMzE4ZTUwODEuLmYwYmJhMGJmZjc3MjE3MDIyZTU5NjAyZWYzYTk3NTVlNTI0 OWQ3NGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA5LTE3ICBLaW51a28g WWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0g QVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgw OAorCisgICAgICAgIEFkZGVkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtIGFuZCBXZWJD b21tb25Xb3JrZXJDbGllbnQ6OgorICAgICAgICBvcGVuRmlsZVN5c3RlbSB0byBjYWxsIGluIHRv IHRoZSBicm93c2VyIHZpYSBXb3JrZXIgc3R1Yi9wcm94eQorICAgICAgICBpbiB0aGUgY2hyb21p dW0uCisKKyAgICAgICAgQWxzbyBhZGRlZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl IGNsYXNzIHRoYXQgcHJveGllcworICAgICAgICByZXF1ZXN0cyBhbmQgY2FsbGJhY2tzIGJldHdl ZW4gZnJvbS90byB3b3JrZXIgdGhyZWFkIHRvL2Zyb20gdGhlCisgICAgICAgIG1haW4gdGhyZWFk LgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAo V2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisg ICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgaW1wbGVt ZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuIEluIHdvcmtlciBjYXNlIHRoaXMgY2FsbHMg V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0uCisgICAgICAgICogc3JjL1dlYldvcmtlckJh c2UuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSk6 IEFkZGVkLiBUaGlzIGlzIGNhbGxlZCBmcm9tCisgICAgICAgIExvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0gb24gdGhlIHdvcmtlciB0aHJlYWQgYW5kIGNyZWF0ZXMKKyAgICAgICAg YSBicmlkZ2UgdG8gY2FsbCBXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtIG9u IHRoZSBtYWluCisgICAgICAgIHRocmVhZC4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5o OgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICog c3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwOiBBZGRlZC4KKyAgICAgICAg KiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oOiBBZGRlZC4KKwogMjAxMC0w OS0yMCAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cCBiL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCmluZGV4IDM1MjNmMjFhMWIxNDg1N2ExYzQ1 Y2NiNmIzZjM4YjEwZmQxMjZhY2MuLjg3NGQ0ODU4ZmIxYWE0OWE1YjczYzJmNDBiNzk2ZjExYTky MjM2MDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9XZWJLaXQuZ3lwCkBAIC01MzMsNiArNTMzLDggQEAKICAgICAgICAgICAgICAg ICAnc3JjL1dlYldvcmtlckNsaWVudEltcGwuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJX b3JrZXJJbXBsLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmgnLAor ICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAn LAorICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5o JywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlcXVlc3QuaCcsCiAgICAg ICAgICAgICAgICAgJ3NyYy9XcmFwcGVkUmVzb3VyY2VSZXNwb25zZS5oJywKICAgICAgICAgICAg ICAgICAnc3JjL3dpbi9XZWJJbnB1dEV2ZW50RmFjdG9yeS5jcHAnLApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUw MzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5 NmEyZGNkNmQyMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25X b3JrZXJDbGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtl ckNsaWVudC5oCkBAIC0zMSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVu dF9oCiAjZGVmaW5lIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21t b24uaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewog CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1Ymxp YzoKICAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3Blbmlu ZyBhIHdlYiBkYXRhYmFzZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFt ZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwg dW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhl IG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZp cnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTog V2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0g aW1wbGVtZW50IHRoaXMuCisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICB9CisKIHByb3RlY3RlZDoKICAgICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9Owpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRl eCAwOGZjZWE2Yzk4NWFjMzIxZDI5MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMx YjY1YzdmYzE1ZjlhMzUzY2ZjNTFhNjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQorewor ICAgIHJldHVybiB0cnVlOworfQorCiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxl U3lzdGVtQ2hyb21pdW0oY29uc3QgU3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5 c3RlbShyb290UGF0aCkKICAgICAsIG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVu dCgpLT5maWxlU3lzdGVtKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2Fs RmlsZVN5c3RlbUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lz dGVtQ2hyb21pdW0uY3BwCmluZGV4IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIw ZjI1YjIuLjk5NGYzMTA0NmIzZGQ3NTc1YWEwMTllNmUxODk5YmFmZjE5MDkzMTggMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Miwx NCArNDIsMTkgQEAKICNpbmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2lu Y2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5j bHVkZSAiV2ViV29ya2VySW1wbC5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNs dWRlICJXb3JrZXJUaHJlYWQuaCIKKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIHVzaW5n IG5hbWVzcGFjZSBXZWJLaXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxM b2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0 aCkKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQog ewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBB dG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWMoTG9jYWxGaWxlU3lzdGVtKiwgbG9jYWxGaWxlU3lz dGVtID0gbmV3IExvY2FsRmlsZVN5c3RlbSgiIikpOworICAgIHJldHVybiAqbG9jYWxGaWxlU3lz dGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxv bmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxi YWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2 NSwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdl YkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAg ICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNf Y2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTog QWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3 b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAg ICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4 dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2Uq IHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94 eSk7CisgICAgICAgIHdlYldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oc3RhdGljX2Nhc3Q8V2ViRmls ZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1w bChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ss IGNvbnRleHQpKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNw cAppbmRleCA0MmY0MWQyZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi42MTMyMjNm ODNiMDI4ZThiYmM5YjA2MzZkOWY4Njk2M2IzNjNkNGY5IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQmFzZS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3Nh Z2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNs dWRlICJXZWJGaWxlRXJyb3IuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1 ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpA QCAtNDUsNiArNDYsOCBAQAogI2luY2x1ZGUgIldlYlZpZXcuaCIKICNpbmNsdWRlICJXZWJXb3Jr ZXJDbGllbnQuaCIKIAorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29u dHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CkBAIC01Niw2ICs1OSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJM RShXT1JLRVJTKQogCiBzdGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFs bG93RGF0YWJhc2VNb2RlIjsKK3N0YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtd ID0gIm9wZW5GaWxlU3lzdGVtTW9kZSI7CiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2ICsxMTgs NyBAQCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3Ry aW5nIG1fbW9kZTsKIH07CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhl IG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2 ICsyMzYsMTYgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwg Y29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5y ZXN1bHQoKTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBjYWxsYmFja3MpCit7CisgICAgV29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhy ZWFkLT5ydW5Mb29wKCk7CisgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9 IFdvcmtlclNjcmlwdENvbnRyb2xsZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgV29y a2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsK KworICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UgPSBX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpjcmVhdGUodGhpcywgd29ya2VyQ29udGV4 dCwgY2FsbGJhY2tzKTsKKyAgICBicmlkZ2UtPnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVh ZChjb21tb25DbGllbnQoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplKTsKK30KKwog Ly8gV29ya2VyT2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2Fn ZVRvV29ya2VyT2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdl LApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRl YjAyMmM4NWM0YzMyN2Q2ZTMxMmIzLi42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMx ZDk2YWNiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBA QCBwdWJsaWM6CiAgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNl cyBpcyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRh YmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVl c3RzIHRvIG9wZW4gYSBmaWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhp cyBpcyBub3QgdGhlIGltcGxlbWVudGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVT eXN0ZW0uKQorICAgIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9u ZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVz IHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBs LmgKaW5kZXggNzQxZDYwNjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgy MzVkYmYyOGZjOWVmZjM0YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShX T1JLRVJTKQogCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtl ckNsaWVudC5oIgotCiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwx MCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1 cm4gdHJ1ZTsKICAgICB9CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1l KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxs YmFja3MqKQorICAgIHsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBw cml2YXRlOgogICAgIHZpcnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjJkMTYzNzc0ZjFlYTI4NmZiZjg4ODE2ODNiY2IwNWQ3NTExZjEwNWMKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UuY3BwCkBAIC0wLDAgKzEsMjE1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lu Y2x1ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKKworI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIkNy b3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIldlYkNvbW1vbldvcmtlckNsaWVudC5oIgorI2lu Y2x1ZGUgIldlYkZpbGVJbmZvLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNrcy5o IgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1FbnRyeS5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5o IgorI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0Lmgi CisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRo cmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVh ZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNv cmU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCisvLyBBIHRocmVhZC1zYWZlIHdyYXBwZXIgZm9y IHRoZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLiBUaGlzIGluc3RhbmNlIGlzIHNo YXJlZCBieSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBhbmQgV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZS4KK2NsYXNzIFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVy IDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXI+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUaHJlYWRhYmxlQ2FsbGJhY2tz QnJpZGdlV3JhcHBlcj4gY3JlYXRlKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJy aWRnZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgVGhyZWFkYWJsZUNhbGxi YWNrc0JyaWRnZVdyYXBwZXIoYnJpZGdlKSk7CisgICAgfQorCisgICAgdm9pZCBzdG9wKCkKKyAg ICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsKKyAgICAgICAgbV9icmlk Z2UgPSAwOworICAgIH0KKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJy b3IgZXJyb3IsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgTXV0ZXhM b2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgICAgICBpZiAobV9icmlkZ2UpCisgICAgICAgICAg ICBtX2JyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvciwgbW9kZSk7CisgICAgfQorCisg ICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUpCisg ICAgeworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAgICAgIGlmICht X2JyaWRnZSkKKyAgICAgICAgICAgIG1fYnJpZGdlLT5kaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRo cmVhZChuYW1lLCByb290UGF0aCwgbW9kZSk7CisgICAgfQorCitwcml2YXRlOgorICAgIFRocmVh ZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UqIGJyaWRnZSkKKyAgICAgICAgOiBtX2JyaWRnZShicmlkZ2UpCisgICAgeworICAgIH0KKwor ICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSog bV9icmlkZ2U7Cit9OworCisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhhdCBhcmUgdG8gYmUg ZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAg ICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcz4gY3JlYXRl KFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJyaWRnZVdyYXBw ZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UHRyKG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2VXcmFwcGVyLCBtb2Rl KSk7CisgICAgfQorCisgICAgdmlydHVhbCB+TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3Mo KQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29u c3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgeworICAgICAg ICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAgICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChuYW1lLCBwYXRoLCBtX21vZGUpOworICAgICAgICBk ZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJy b3IgZXJyb3IpCisgICAgeworICAgICAgICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAg ICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRGYWlsT25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOwor ICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2Vl ZCgpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYpCisg ICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZpbGVTeXN0 ZW1FbnRyeT4mLCBib29sIGhhc01vcmUpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgfQorCitwcml2YXRlOgorICAgIE1haW5UaHJlYWRGaWxlU3lzdGVt Q2FsbGJhY2tzKFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJy aWRnZVdyYXBwZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdl V3JhcHBlcihicmlkZ2VXcmFwcGVyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAg ICB9CisKKyAgICBQYXNzUmVmUHRyPFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyPiBt X2JyaWRnZVdyYXBwZXI7CisgICAgY29uc3QgV1RGOjpTdHJpbmcgbV9tb2RlOworfTsKKworV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHdvcmtl ckNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICA6IEFjdGl2 ZURPTU9iamVjdCh3b3JrZXJDb250ZXh0LCB0aGlzKQorICAgICwgbV9icmlkZ2VXcmFwcGVyKFRo cmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOjpjcmVhdGUodGhpcykpCisgICAgLCBtX3dv cmtlcih3b3JrZXIpCisgICAgLCBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dChjYWxsYmFja3Mp Cit7Cit9CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6On5Xb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlKCkKK3sKKyAgICBBU1NFUlQoIW1fY2FsbGJhY2tzT25Xb3JrZXJD b250ZXh0KTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpzdG9w KCkKK3sKKyAgICBtX2JyaWRnZVdyYXBwZXItPnN0b3AoKTsKKworICAgIEFTU0VSVChtX2NhbGxi YWNrc09uV29ya2VyQ29udGV4dCk7CisgICAgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRp ZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgIG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0 ID0gMDsKKworICAgIC8vIENsZWFyaW5nIHRoZSBzZWxmUmVmICh0aGlzIG1heSBkZWxldGUgaXRz ZWxmKS4KKyAgICBtX3NlbGZSZWYuY2xlYXIoKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29tbW9u V29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJG aWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplKQoreworICAgIG1fc2VsZlJlZiA9 IHRoaXM7CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxs YmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCBjb21tb25DbGllbnQsIG1vZGUs IHR5cGUsIHNpemUsIHRoaXMpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlOjpvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIGNvbnN0IFdURjo6U3RyaW5n JiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKiBicmlkZ2UpCit7CisgICAgaWYgKCFjb21tb25DbGll bnQpCisgICAgICAgIGJyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3JBYm9y dCwgbW9kZSk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2Fs bGJhY2tzIGlzIHNlbGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIgaGVyZS4KKyAgICAgICAg Y29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbSh0eXBlLCBzaXplLCBNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrczo6Y3JlYXRlKGJyaWRnZS0+bV9icmlkZ2VXcmFwcGVyLCBtb2RlKS5sZWFr UHRyKCkpOworICAgIH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl OjpkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvciwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUpCit7CisgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4 dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZEZhaWxPbldvcmtlclRocmVhZCwgdGhpcywgZXJyb3Ip LCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3Qg V1RGOjpTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBXVEY6OlN0cmluZyYgbW9kZSkKK3sKKyAgICBt X3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFz aygmZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgp LCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRG YWlsT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgV2ViRmlsZUVycm9yIGVycm9yKQoreworICAgIEFT U0VSVChicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KTsKKyAgICBicmlkZ2UtPm1f Y2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0LT5kaWRGYWlsKGVycm9yKTsKKyAgICBicmlkZ2UtPm1f Y2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0ID0gMDsKKyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVh cigpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5G aWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3QgV1RGOjpTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKK3sKKyAgICBBU1NFUlQoYnJpZGdlLT5tX2Nh bGxiYWNrc09uV29ya2VyQ29udGV4dCk7CisgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2Vy Q29udGV4dC0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgcm9vdFBhdGgpOworICAgIGJyaWRnZS0+ bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOworICAgIGJyaWRnZS0+bV9zZWxmUmVmLmNs ZWFyKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShG SUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWRmOGZiMDJkNTdkOWI0NWVkYjZlZTEz MzI2MmExNmY0OGFiODE1ZgotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAgKzEsMTA0IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMK KyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBP UiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRl ZiBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZpbmUgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJBY3RpdmVET01PYmplY3QuaCIKKyNp bmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVt LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CisK K2NsYXNzIFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOworY2xhc3MgTWFpblRocmVh ZEZpbGVTeXN0ZW1DYWxsYmFja3M7CitjbGFzcyBXZWJDb21tb25Xb3JrZXJDbGllbnQ7CitjbGFz cyBXZWJXb3JrZXJCYXNlOworY2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxiYWNrczsKKworLy8gVGhp cyBjbGFzcyBpcyB1c2VkIHRvIHBvc3QgYSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBt YWluIHRocmVhZCBhbmQgZ2V0IGNhbGxlZCBiYWNrIGZvciB0aGUgcmVxdWVzdC4gVGhpcyBtdXN0 IGJlIGRlc3RydWN0ZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisvLyBUaGlzIGluaGVyaXRzIGZy b20gQWN0aXZlRE9NT2JqZWN0IGp1c3QgdG8gYmUgbm90aWZpZWQgd2hlbiB0aGUgY29udGV4dCBp cyBnb2luZyB0byBiZSBzdG9wcGVkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZvciBvcGVuRmls ZVN5c3RlbSB3b3VsZCBsb29rIGxpa2UgZm9sbG93aW5nOgorLy8gQnJpZGdlOjpwb3N0T3BlbkZp bGVTeXN0ZW1Pbk1haW5UaHJlYWQoKSBvbiBXb3JrZXJUaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpv cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCgpIGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAg ICAgIFRoaXMgbWFrZXMgYW4gSVBDIHdpdGggYSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNr cyBpbnN0YW5jZS4KKy8vICAgICBbYWN0dWFsIG9wZXJhdGlvbiBpcyBkb25lIGluIHRoZSBicm93 c2VyXQorLy8gIC0tPiBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlzIGNh bGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFkIGlz IGNhbGxlZCBvbiBNYWluVGhyZWFkICh2aWEgVGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXIpCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJUaHJlYWQgaXMgY2FsbGVkIG9uIFdv cmtlclRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSB3b3JrZXIncyBvcmlnaW5hbCBjYWxs YmFja3MgKG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSBhbmQgcmVsZWFzZXMgYSBzZWxmLXJl ZmVyZW5jZSB0byB0aGUgYnJpZGdlLgorY2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZSA6IHB1YmxpYyBXZWJDb3JlOjpBY3RpdmVET01PYmplY3QsIHB1YmxpYyBSZWZDb3VudGVk PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBjcmVhdGUoV2ViV29y a2VyQmFzZSogd29ya2VyLCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiB3b3JrZXJD b250ZXh0LCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgeworICAgICAg ICByZXR1cm4gV1RGOjphZG9wdFJlZihuZXcgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSh3b3JrZXIsIHdvcmtlckNvbnRleHQsIGNhbGxiYWNrcykpOworICAgIH0KKyAgICB+V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpOworCisgICAgLy8gQWN0aXZlRE9NT2JqZWN0IG1l dGhvZC4KKyAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpOworCisgICAgdm9pZCBwb3N0T3BlbkZpbGVT eXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29tbW9uV29ya2VyQ2xpZW50KiwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplKTsKKworICAgIC8v IENhbGxiYWNrIG1ldGhvZHMgdGhhdCBhcmUgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAg ICB2b2lkIGRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yLCBjb25zdCBXVEY6OlN0cmlu ZyYgbW9kZSk7CisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUpOworCitwcml2YXRlOgorICAgIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UoV2ViV29ya2VyQmFzZSosIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJG aWxlU3lzdGVtQ2FsbGJhY2tzKik7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyB0byBiZSBjYWxs ZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25N YWluVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3Jr ZXJDbGllbnQqLCBjb25zdCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSwg bG9uZyBsb25nIHNpemUsIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqKTsKKworICAg IGZyaWVuZCBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKKworICAgIC8vIE1l dGhvZHMgdGhhdCBkaXNwYXRjaCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIG9uIHRoZSB3b3JrZXIg dGhyZWFkcy4KKyAgICAvLyBUaGV5IHJlbGVhc2UgYSBzZWxmUmVmIG9mIHRoZSBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlLgorICAgIHN0YXRpYyB2b2lkIGRpZEZhaWxPbldvcmtlclRo cmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZSosIFdlYkZpbGVFcnJvcik7CisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZp bGVTeXN0ZW1PbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSosIGNvbnN0IFdURjo6U3RyaW5nJiBuYW1l LCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpOworCisgICAgLy8gbV9zZWxmUmVmIGtlZXBz IGEgcmVmZXJlbmNlIHRvIGl0c2VsZiB1bnRpbCBjYWxsYmFja3MgYXJlIGZpcmVkIG9uIHRoZSB3 b3JrZXIgdGhyZWFkLgorICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl PiBtX3NlbGZSZWY7CisKKyAgICBSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXI+IG1fYnJpZGdlV3JhcHBlcjsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBX VEY6OlN0cmluZyBtX21vZGU7CisgICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9jYWxsYmFj a3NPbldvcmtlckNvbnRleHQ7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRp ZiAvLyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gK 68183 2010-09-20 21:03:45 -0700 2010-09-21 03:52:28 -0700 Patch bug-45808-20100920210344.patch text/plain 40826 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NmQ3ZDJlYzNiOGQ1ZjExOTNkMzU1ZWJhOGY2MzJlMTZlZmMzODcyMS4uNmQyMjAxYWQ4YzE5ODRk OGJlNmYxNWRjMDllYmMxOWZkNWYzZjM3MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAqIHdvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGw6CisKIDIwMTAtMDktMjAgIE5pY28gV2ViZXIgIDx0aGFraXNAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJD b3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgYi9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKaW5kZXggYTE1ZmQ2 ZDA4MDJmYmVlZjExMDlmY2E5YzlkM2IyZjNkMzAyMGMwNC4uOWE5NmYyMjZkM2NmZjcyNzhjNzky NjlhMWM4MmU0YWNjNzg0MDY0YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmlj L1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcApAQCAtMzYsNiArMzYsMTAgQEAKICNpbmNsdWRl ICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjaW5jbHVkZSAiV2ViU29ja2V0LmgiCiAKKyNp ZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjZW5k aWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6 OmlzTG9jYWxTdG9yYWdlRW5hYmxlZCA9IHRydWU7CkBAIC01Nyw2ICs2MSwxMSBAQCBib29sIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzWEhSUmVzcG9uc2VCbG9iRW5hYmxlZCA9IGZhbHNlOwog CiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpp c0ZpbGVTeXN0ZW1FbmFibGVkID0gZmFsc2U7CisKK2Jvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJl czo6ZmlsZVN5c3RlbUVuYWJsZWQoKQoreworICAgIHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVk ICYmIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKTsKK30KICNlbmRpZgogCiAjaWYgRU5B QkxFKFZJREVPKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVF bmFibGVkRmVhdHVyZXMuaCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxl ZEZlYXR1cmVzLmgKaW5kZXggOTE3NjhiMGU1NGU3Zjk3YmFjZDBhOWJkMzM5ZTFkYzQyMGQ2ZWRl ZS4uYmE0YTRmYjA1ZGY1MWQ3NDQ0ZmI5YTNiYTEwMDJhZTQ3YWJkNWZjOCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAorKysgYi9X ZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oCkBAIC0xNDgs NyArMTQ4LDcgQEAgcHVibGljOgogI2VuZGlmCiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCi0g ICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1F bmFibGVkOyB9CisgICAgc3RhdGljIGJvb2wgZmlsZVN5c3RlbUVuYWJsZWQoKTsKICAgICBzdGF0 aWMgdm9pZCBzZXRGaWxlU3lzdGVtRW5hYmxlZChib29sIGlzRW5hYmxlZCkgeyBpc0ZpbGVTeXN0 ZW1FbmFibGVkID0gaXNFbmFibGVkOyB9CiAgICAgc3RhdGljIGJvb2wgcmVxdWVzdEZpbGVTeXN0 ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNGaWxlU3lzdGVtRW5hYmxlZDsgfQogI2VuZGlmCmRpZmYg LS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCmluZGV4IDU5ZWMyYTFlNmQ3YmIxOWYxZDQ4MzllNWVl Mzk5NjAwZjZlMDQ0ZjYuLjE0YzYyYzg5NTY3MmJkZmY3NzJkZjliMmNjOWY2MWUyNWZkNGQ1MjIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCisrKyBiL1dl YkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwCkBAIC01MCw5ICs1MCwzMCBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBMb2NhbEZp bGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorTG9jYWxGaWxlU3lzdGVt KiBMb2NhbEZpbGVTeXN0ZW06OnNfaW5zdGFuY2UgPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQorewor ICAgIC8vIEZJWE1FOiBTaG91bGQgaW5pdGlhbGl6ZSB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2Vs bC4KKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVCghc19pbnN0YW5jZSk7 CisgICAgaWYgKHNfaW5zdGFuY2UpCisgICAgICAgIHJldHVybjsKKworICAgIE93blB0cjxMb2Nh bEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0 ZW0oYmFzZVBhdGgpKTsKKyAgICBzX2luc3RhbmNlID0gbG9jYWxGaWxlU3lzdGVtLmxlYWtQdHIo KTsKK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3Rl bSgpCit7CisgICAgLy8gaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSBtdXN0IGJlIGNhbGxlZCBw cmlvciBjYWxsaW5nIHRoaXMuCisgICAgQVNTRVJUKHNfaW5zdGFuY2UpOworICAgIHJldHVybiAq c19pbnN0YW5jZTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQ YXRoKCkgY29uc3QKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3RlbShi YXNlUGF0aCkpOworICAgIHJldHVybiBtX2Jhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9CiAK IHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25z dCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAKICAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVT eXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkp OwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2Fs RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4IDQ4 Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLjgzZmVmOWQ2M2M2NWIzZTk5 ZTgzYjdlZGUwNjIyOTdkMjQ4YWU2MDggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2Nh bEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKQEAg LTQ0LDE5ICs0NCwzMyBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxGaWxl U3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVwcyBw ZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8gb3Bl biBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IGNy ZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVTeXN0 ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9jYWxG aWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0aGlz IG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAog ICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNh bGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAh UExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBpcyBub3QgdGhyZWFkLXNhZmU7IG11c3Qg YmUgY2FsbGVkIGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZHMgYXJlIGNyZWF0ZWQuCisgICAgdm9p ZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5n IGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OworI2VuZGlmCisKK3ByaXZhdGU6CiAgICAgTG9j YWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiAgICAgICAgIDogbV9iYXNlUGF0 aChiYXNlUGF0aCkKICAgICB7CiAgICAgfQogCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSog c19pbnN0YW5jZTsKKworICAgIC8vIFRoZSBtZW1iZXIgbWV0aG9kcyBzaG91bGRuJ3QgYWNjZXNz IHRoaXMgU3RyaW5nIGRpcmVjdGx5IGJ1dCBzaG91bGQgdXNlCisgICAgLy8gZmlsZVN5c3RlbUJh c2VQYXRoKCkgaW5zdGVhZC4KICAgICBTdHJpbmcgbV9iYXNlUGF0aDsKIH07CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5j cHAKaW5kZXggZjViYTI1YzM2YTlhZDJjN2ZkMTY1OWE1YjVkM2QwNmQ4N2JhNWM0Ni4uNmEyMDNj YzdjNDkyZWMzM2FiZTAwMjkyZTNhMDQ4ZDhhMmFjMzQxZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL0RPTVdpbmRvdy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAKQEAgLTcy NywyNSArNzI3LDE2IEBAIHZvaWQgRE9NV2luZG93OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlw ZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlCiAgICAgaWYgKCFkb2N1bWVu dCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgaWYgKCFtX2xvY2FsRmlsZVN5c3RlbSkgewotICAg ICAgICAvLyBGSVhNRTogU2VlIGlmIGFjY2VzcyBpcyBhbGxvd2VkLgotCi0gICAgICAgIFBhZ2Uq IHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgICAgICBpZiAoIXBhZ2UpIHsKLSAgICAgICAg ICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9jdW1lbnQsIGVycm9yQ2FsbGJh Y2ssIEZpbGVFcnJvcjo6Y3JlYXRlKElOVkFMSURfU1RBVEVfRVJSKSk7Ci0gICAgICAgICAgICBy ZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICAvLyBGSVhNRTogR2V0IHRoZSBxdW90YSBzZXR0 aW5ncyBhcyB3ZWxsLgotICAgICAgICBTdHJpbmcgcGF0aCA9IHBhZ2UtPnNldHRpbmdzKCktPmZp bGVTeXN0ZW1Sb290UGF0aCgpOwotICAgICAgICBtX2xvY2FsRmlsZVN5c3RlbSA9IExvY2FsRmls ZVN5c3RlbTo6Y3JlYXRlKHBhdGgpOworICAgIGlmICghQXN5bmNGaWxlU3lzdGVtOjppc0F2YWls YWJsZSgpIHx8ICFkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRmlsZVN5c3Rl bSgpKSB7CisgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2soZG9jdW1lbnQs IGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAg ICByZXR1cm47CiAgICAgfQogCi0gICAgbV9sb2NhbEZpbGVTeXN0ZW0tPnJlcXVlc3RGaWxlU3lz dGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBz aXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAgIExvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19j YXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywg ZXJyb3JDYWxsYmFjayk7CiB9CiAKLUNPTVBJTEVfQVNTRVJUKGludChET01XaW5kb3c6OlRFTVBP UkFSWSkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7 Ci1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBpbnQoQXN5bmNG aWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChz dGF0aWNfY2FzdDxpbnQ+KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBzdGF0aWNfY2FzdDxpbnQ+ KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nh c3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsKIAog I2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaCBiL1dlYkNvcmUv cGFnZS9ET01XaW5kb3cuaAppbmRleCAxNDcwNjI4NjVkOWI5Yjc3NDcxNjlhZmIyMTg0MWQ2NmYx MWQ5Y2Q0Li42ZmQzNzc1MDNhYjRlZWYxZDllNzc1Zjk4MzA0ZDExMzFmYWZiMDNhIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKKysrIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRv dy5oCkBAIC01OCw3ICs1OCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBIaXN0 b3J5OwogICAgIGNsYXNzIElEQkZhY3Rvcnk7CiAgICAgY2xhc3MgSW5zcGVjdG9yVGltZWxpbmVB Z2VudDsKLSAgICBjbGFzcyBMb2NhbEZpbGVTeXN0ZW07CiAgICAgY2xhc3MgTG9jYXRpb247CiAg ICAgY2xhc3MgU3R5bGVNZWRpYTsKICAgICBjbGFzcyBOYXZpZ2F0b3I7CkBAIC00NDQsOSArNDQz LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQog ICAgICAgICBtdXRhYmxlIFJlZlB0cjxJREJGYWN0b3J5PiBtX2lkYkZhY3Rvcnk7CiAjZW5kaWYK LSNpZiBFTkFCTEUoRklMRV9TWVNURU0pCi0gICAgICAgIFJlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IG1fbG9jYWxGaWxlU3lzdGVtOwotI2VuZGlmCiAKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1f ZXZlbnRUYXJnZXREYXRhOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmln aW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDQ3ODlkM2NlMTFhMGEy MzE1NTYxOWFiYzEwNGViOTgxZGNlZDVlZWYuLjJhNjM5NjZkNDg3YmQzYTZiNzY2MzcxNjIzMzVj NThjOTc0NzE2NTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCisr KyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0xMjEsNiArMTIxLDcgQEAgcHVi bGljOgogICAgIGJvb2wgY2FuQWNjZXNzTG9jYWxTdG9yYWdlKCkgY29uc3QgeyByZXR1cm4gIWlz VW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc0Nvb2tpZXMoKSBjb25zdCB7IHJldHVybiAh aXNVbmlxdWUoKTsgfQogICAgIGJvb2wgY2FuQWNjZXNzUGFzc3dvcmRNYW5hZ2VyKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KKyAgICBib29sIGNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSBj b25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogCiAgICAgLy8gVGVjaG5pY2FsbHksIHdlIHNo b3VsZCBhbHdheXMgYWxsb3cgYWNjZXNzIHRvIHNlc3Npb25TdG9yYWdlLCBidXQgd2UKICAgICAv LyBjdXJyZW50bHkgZG9uJ3QgaGFuZGxlIGNyZWF0aW5nIGEgc2Vzc2lvblN0b3JhZ2UgYXJlYSBm b3IgdW5pcXVlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwIGIvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCBmYWMwYTVmNDk2OGRiNmE0YWExZDc5NDZmZWJkZDNl ZjY5NTE0N2E1Li40ZDE2NjJiNjM2YTk4MTQxNjhiNmU1ODg0OGE1NzBiNmI2NTkxNjI3IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0 aW5ncy5jcHAKQEAgLTQ5NywxMSArNDk3LDYgQEAgdm9pZCBTZXR0aW5nczo6c2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkKICAgICBtX2xvY2FsU3RvcmFnZURh dGFiYXNlUGF0aCA9IHBhdGg7CiB9CiAKLXZvaWQgU2V0dGluZ3M6OnNldEZpbGVTeXN0ZW1Sb290 UGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCi17Ci0gICAgbV9maWxlU3lzdGVtUm9vdFBhdGggPSBw YXRoOwotfQotCiB2b2lkIFNldHRpbmdzOjpzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUoYm9vbCBt b2RlKQogewogICAgIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGUgPSBtb2RlOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRl eCA5OWE0ZjIzMmM1Mjk4MDZlYWEyN2Y4NWQ1N2RiYmFiMTI3NDRiZjMzLi5mOGEyOTdhMTdiMDU1 NjlkODVmYzdiMTEwYzQ2NTZmNDQ3NDA3NjRhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjQxLDkgKzI0MSw2IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRMb2NhbFN0b3JhZ2VEYXRhYmFz ZVBhdGgoY29uc3QgU3RyaW5nJik7CiAgICAgICAgIGNvbnN0IFN0cmluZyYgbG9jYWxTdG9yYWdl RGF0YWJhc2VQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGg7 IH0KIAotICAgICAgICB2b2lkIHNldEZpbGVTeXN0ZW1Sb290UGF0aChjb25zdCBTdHJpbmcmKTsK LSAgICAgICAgY29uc3QgU3RyaW5nJiBmaWxlU3lzdGVtUm9vdFBhdGgoKSBjb25zdCB7IHJldHVy biBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsgfQotCiAgICAgICAgIHZvaWQgc2V0QXBwbGljYXRpb25D aHJvbWVNb2RlKGJvb2wpOwogICAgICAgICBib29sIGluQXBwbGljYXRpb25DaHJvbWVNb2RlKCkg Y29uc3QgeyByZXR1cm4gbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZTsgfQogCkBAIC0zMzYsNyAr MzMzLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBTdHJpbmcgbV9kZWZhdWx0VGV4 dEVuY29kaW5nTmFtZTsKICAgICAgICAgU3RyaW5nIG1fZnRwRGlyZWN0b3J5VGVtcGxhdGVQYXRo OwogICAgICAgICBTdHJpbmcgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGg7Ci0gICAgICAgIFN0 cmluZyBtX2ZpbGVTeXN0ZW1Sb290UGF0aDsKICAgICAgICAgS1VSTCBtX3VzZXJTdHlsZVNoZWV0 TG9jYXRpb247CiAgICAgICAgIEF0b21pY1N0cmluZyBtX3N0YW5kYXJkRm9udEZhbWlseTsKICAg ICAgICAgQXRvbWljU3RyaW5nIG1fZml4ZWRGb250RmFtaWx5OwpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0Zp bGVTeXN0ZW0uY3BwCmluZGV4IGI0ZmNkMGQ0ZDliNGZiY2VkOTQ2MTM4NWMxM2E2Y2ViYjY5ZmM3 YWYuLjc3ODI4ZmYxM2NhMjdmODc1YjMxNWVjODZiZTg2MjFkMmM1M2QwZTYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRm b3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKQEAgLTM0LDEzICszNCwyMSBAQAogI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKIAogI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgorI2lu Y2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmls ZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lz dGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1 bHQgQXN5bmNGaWxlU3lzdGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVkKCk7 CiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0 ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYg c3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxl U3lzdGVtOjpjcmVhdGUocm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxl bWVudGF0aW9uLgogU3RyaW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRo KGNvbnN0IFN0cmluZyYgcGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v QXN5bmNGaWxlU3lzdGVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmlu ZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZk YTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0 ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7 IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7 IH0KIAorICAgIHN0YXRpYyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFu ZCByZXR1cm5zIGEgbmV3IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5j ZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGlj IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0 aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0Nzdl ODE0YmJlNGQ4YmViOWMzYjllYTBhLi40NzVkODkzM2I1ODVkMzUyNzk5MTc0OGU0YmJhNmFiMTYz NDdjN2ZiIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysr IGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAog I2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklM RV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmls ZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJy b3IuaCIKKyNpbmNsdWRlICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZp bGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3Nl V29ya2VyQ29udGV4dFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7 CkBAIC0zMzUsNiArMzQ0LDIxIEBAIHZvaWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChj b25zdCBTdHJpbmcmIGJsb2JVUkxTdHJpbmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxF X1NZU1RFTSkKK3ZvaWQgV29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUs IGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0Nh bGxiYWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAg aWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCkt PmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVs ZUNhbGxiYWNrKHRoaXMsIGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZ X0VSUikpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjps b2NhbEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3lu Y0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2spOworfQorCitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRl eHQ6OlRFTVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBv cmFyeSksIGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihX b3JrZXJDb250ZXh0OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5 c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworI2VuZGlmCisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uOGQy ZjUxOWQyNTc0MWM4NjViMGY5MDY5ZThlZmNjZTg1ZjczNTk3NiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCkBAIC00Nyw2ICs0Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBE YXRhYmFzZTsKICAgICBjbGFzcyBEYXRhYmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNl U3luYzsKKyAgICBjbGFzcyBFcnJvckNhbGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxs YmFjazsKICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVk QWN0aW9uOwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwpAQCAtMTIxLDYgKzEyMywxNSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJp bmcmKTsKICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5 IGFyZSBwbGFjZWQgaGVyZSBhbmQgaW4gYWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNv bXBpbGUtdGltZSBlbnVtIGNoZWNraW5nLgorICAgICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsK KyAgICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAgICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAg IH07CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBz aXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxs YmFjaz4pOworI2VuZGlmCisKICAgICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3Ig R0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYp IGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtl ck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRv ci5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRs IGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJk ZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjNlMTg1YzBkNWI4ZTBhMTM3YmQ5MjhjNTJhMmRi YTgxNzVmODAzMzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmlk bAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQs MTQgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAgICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChp biBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJs b2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVkKEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5B QkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9 IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAg ICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBz aG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmls ZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0g RXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsKKworICAgICAgICAgICAgICAgICBhdHRyaWJ1 dGUgW0VuYWJsZWRBdFJ1bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsK KyNlbmRpZgogICAgIH07CiAKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGRkMjNmNmYyNmVkNjVkMTE1MzBm YjYzNTkwYmRjYmYzMzE4ZTUwODEuLmYwYmJhMGJmZjc3MjE3MDIyZTU5NjAyZWYzYTk3NTVlNTI0 OWQ3NGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA5LTE3ICBLaW51a28g WWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0g QVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgw OAorCisgICAgICAgIEFkZGVkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtIGFuZCBXZWJD b21tb25Xb3JrZXJDbGllbnQ6OgorICAgICAgICBvcGVuRmlsZVN5c3RlbSB0byBjYWxsIGluIHRv IHRoZSBicm93c2VyIHZpYSBXb3JrZXIgc3R1Yi9wcm94eQorICAgICAgICBpbiB0aGUgY2hyb21p dW0uCisKKyAgICAgICAgQWxzbyBhZGRlZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl IGNsYXNzIHRoYXQgcHJveGllcworICAgICAgICByZXF1ZXN0cyBhbmQgY2FsbGJhY2tzIGJldHdl ZW4gZnJvbS90byB3b3JrZXIgdGhyZWFkIHRvL2Zyb20gdGhlCisgICAgICAgIG1haW4gdGhyZWFk LgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAo V2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisg ICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgaW1wbGVt ZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuIEluIHdvcmtlciBjYXNlIHRoaXMgY2FsbHMg V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0uCisgICAgICAgICogc3JjL1dlYldvcmtlckJh c2UuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSk6 IEFkZGVkLiBUaGlzIGlzIGNhbGxlZCBmcm9tCisgICAgICAgIExvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0gb24gdGhlIHdvcmtlciB0aHJlYWQgYW5kIGNyZWF0ZXMKKyAgICAgICAg YSBicmlkZ2UgdG8gY2FsbCBXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtIG9u IHRoZSBtYWluCisgICAgICAgIHRocmVhZC4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5o OgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICog c3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwOiBBZGRlZC4KKyAgICAgICAg KiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oOiBBZGRlZC4KKwogMjAxMC0w OS0yMCAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cCBiL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCmluZGV4IDM1MjNmMjFhMWIxNDg1N2ExYzQ1 Y2NiNmIzZjM4YjEwZmQxMjZhY2MuLjg3NGQ0ODU4ZmIxYWE0OWE1YjczYzJmNDBiNzk2ZjExYTky MjM2MDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9XZWJLaXQuZ3lwCkBAIC01MzMsNiArNTMzLDggQEAKICAgICAgICAgICAgICAg ICAnc3JjL1dlYldvcmtlckNsaWVudEltcGwuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJX b3JrZXJJbXBsLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmgnLAor ICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAn LAorICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5o JywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlcXVlc3QuaCcsCiAgICAg ICAgICAgICAgICAgJ3NyYy9XcmFwcGVkUmVzb3VyY2VSZXNwb25zZS5oJywKICAgICAgICAgICAg ICAgICAnc3JjL3dpbi9XZWJJbnB1dEV2ZW50RmFjdG9yeS5jcHAnLApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUw MzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5 NmEyZGNkNmQyMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25X b3JrZXJDbGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtl ckNsaWVudC5oCkBAIC0zMSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVu dF9oCiAjZGVmaW5lIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21t b24uaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewog CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1Ymxp YzoKICAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3Blbmlu ZyBhIHdlYiBkYXRhYmFzZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFt ZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwg dW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhl IG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZp cnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTog V2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0g aW1wbGVtZW50IHRoaXMuCisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICB9CisKIHByb3RlY3RlZDoKICAgICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9Owpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRl eCAwOGZjZWE2Yzk4NWFjMzIxZDI5MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMx YjY1YzdmYzE1ZjlhMzUzY2ZjNTFhNjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQorewor ICAgIHJldHVybiB0cnVlOworfQorCiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxl U3lzdGVtQ2hyb21pdW0oY29uc3QgU3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5 c3RlbShyb290UGF0aCkKICAgICAsIG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVu dCgpLT5maWxlU3lzdGVtKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2Fs RmlsZVN5c3RlbUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lz dGVtQ2hyb21pdW0uY3BwCmluZGV4IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIw ZjI1YjIuLjk5NGYzMTA0NmIzZGQ3NTc1YWEwMTllNmUxODk5YmFmZjE5MDkzMTggMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Miwx NCArNDIsMTkgQEAKICNpbmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2lu Y2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5j bHVkZSAiV2ViV29ya2VySW1wbC5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNs dWRlICJXb3JrZXJUaHJlYWQuaCIKKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIHVzaW5n IG5hbWVzcGFjZSBXZWJLaXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxM b2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0 aCkKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQog ewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBB dG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWMoTG9jYWxGaWxlU3lzdGVtKiwgbG9jYWxGaWxlU3lz dGVtID0gbmV3IExvY2FsRmlsZVN5c3RlbSgiIikpOworICAgIHJldHVybiAqbG9jYWxGaWxlU3lz dGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxv bmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxi YWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2 NSwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdl YkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAg ICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNf Y2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTog QWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3 b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAg ICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4 dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2Uq IHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94 eSk7CisgICAgICAgIHdlYldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oc3RhdGljX2Nhc3Q8V2ViRmls ZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1w bChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ss IGNvbnRleHQpKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNw cAppbmRleCA0MmY0MWQyZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi42MTMyMjNm ODNiMDI4ZThiYmM5YjA2MzZkOWY4Njk2M2IzNjNkNGY5IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQmFzZS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3Nh Z2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNs dWRlICJXZWJGaWxlRXJyb3IuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1 ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpA QCAtNDUsNiArNDYsOCBAQAogI2luY2x1ZGUgIldlYlZpZXcuaCIKICNpbmNsdWRlICJXZWJXb3Jr ZXJDbGllbnQuaCIKIAorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29u dHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CkBAIC01Niw2ICs1OSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJM RShXT1JLRVJTKQogCiBzdGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFs bG93RGF0YWJhc2VNb2RlIjsKK3N0YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtd ID0gIm9wZW5GaWxlU3lzdGVtTW9kZSI7CiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2ICsxMTgs NyBAQCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3Ry aW5nIG1fbW9kZTsKIH07CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhl IG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2 ICsyMzYsMTYgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwg Y29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5y ZXN1bHQoKTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBjYWxsYmFja3MpCit7CisgICAgV29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhy ZWFkLT5ydW5Mb29wKCk7CisgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9 IFdvcmtlclNjcmlwdENvbnRyb2xsZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgV29y a2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsK KworICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UgPSBX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpjcmVhdGUodGhpcywgd29ya2VyQ29udGV4 dCwgY2FsbGJhY2tzKTsKKyAgICBicmlkZ2UtPnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVh ZChjb21tb25DbGllbnQoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplKTsKK30KKwog Ly8gV29ya2VyT2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2Fn ZVRvV29ya2VyT2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdl LApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRl YjAyMmM4NWM0YzMyN2Q2ZTMxMmIzLi42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMx ZDk2YWNiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBA QCBwdWJsaWM6CiAgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNl cyBpcyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRh YmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVl c3RzIHRvIG9wZW4gYSBmaWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhp cyBpcyBub3QgdGhlIGltcGxlbWVudGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVT eXN0ZW0uKQorICAgIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9u ZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVz IHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBs LmgKaW5kZXggNzQxZDYwNjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgy MzVkYmYyOGZjOWVmZjM0YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShX T1JLRVJTKQogCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtl ckNsaWVudC5oIgotCiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwx MCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1 cm4gdHJ1ZTsKICAgICB9CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1l KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxs YmFja3MqKQorICAgIHsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBw cml2YXRlOgogICAgIHZpcnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjJkMTYzNzc0ZjFlYTI4NmZiZjg4ODE2ODNiY2IwNWQ3NTExZjEwNWMKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UuY3BwCkBAIC0wLDAgKzEsMjE1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lu Y2x1ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKKworI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIkNy b3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIldlYkNvbW1vbldvcmtlckNsaWVudC5oIgorI2lu Y2x1ZGUgIldlYkZpbGVJbmZvLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNrcy5o IgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1FbnRyeS5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5o IgorI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0Lmgi CisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRo cmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVh ZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNv cmU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCisvLyBBIHRocmVhZC1zYWZlIHdyYXBwZXIgZm9y IHRoZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLiBUaGlzIGluc3RhbmNlIGlzIHNo YXJlZCBieSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBhbmQgV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZS4KK2NsYXNzIFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVy IDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXI+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUaHJlYWRhYmxlQ2FsbGJhY2tz QnJpZGdlV3JhcHBlcj4gY3JlYXRlKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJy aWRnZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgVGhyZWFkYWJsZUNhbGxi YWNrc0JyaWRnZVdyYXBwZXIoYnJpZGdlKSk7CisgICAgfQorCisgICAgdm9pZCBzdG9wKCkKKyAg ICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsKKyAgICAgICAgbV9icmlk Z2UgPSAwOworICAgIH0KKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJy b3IgZXJyb3IsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgTXV0ZXhM b2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgICAgICBpZiAobV9icmlkZ2UpCisgICAgICAgICAg ICBtX2JyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvciwgbW9kZSk7CisgICAgfQorCisg ICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUpCisg ICAgeworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAgICAgIGlmICht X2JyaWRnZSkKKyAgICAgICAgICAgIG1fYnJpZGdlLT5kaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRo cmVhZChuYW1lLCByb290UGF0aCwgbW9kZSk7CisgICAgfQorCitwcml2YXRlOgorICAgIFRocmVh ZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UqIGJyaWRnZSkKKyAgICAgICAgOiBtX2JyaWRnZShicmlkZ2UpCisgICAgeworICAgIH0KKwor ICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSog bV9icmlkZ2U7Cit9OworCisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhhdCBhcmUgdG8gYmUg ZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAg ICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcz4gY3JlYXRl KFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJyaWRnZVdyYXBw ZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UHRyKG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2VXcmFwcGVyLCBtb2Rl KSk7CisgICAgfQorCisgICAgdmlydHVhbCB+TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3Mo KQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29u c3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgeworICAgICAg ICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAgICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChuYW1lLCBwYXRoLCBtX21vZGUpOworICAgICAgICBk ZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJy b3IgZXJyb3IpCisgICAgeworICAgICAgICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAg ICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRGYWlsT25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOwor ICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2Vl ZCgpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYpCisg ICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZpbGVTeXN0 ZW1FbnRyeT4mLCBib29sIGhhc01vcmUpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgfQorCitwcml2YXRlOgorICAgIE1haW5UaHJlYWRGaWxlU3lzdGVt Q2FsbGJhY2tzKFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJy aWRnZVdyYXBwZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdl V3JhcHBlcihicmlkZ2VXcmFwcGVyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAg ICB9CisKKyAgICBQYXNzUmVmUHRyPFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyPiBt X2JyaWRnZVdyYXBwZXI7CisgICAgY29uc3QgV1RGOjpTdHJpbmcgbV9tb2RlOworfTsKKworV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHdvcmtl ckNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICA6IEFjdGl2 ZURPTU9iamVjdCh3b3JrZXJDb250ZXh0LCB0aGlzKQorICAgICwgbV9icmlkZ2VXcmFwcGVyKFRo cmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOjpjcmVhdGUodGhpcykpCisgICAgLCBtX3dv cmtlcih3b3JrZXIpCisgICAgLCBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dChjYWxsYmFja3Mp Cit7Cit9CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6On5Xb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlKCkKK3sKKyAgICBBU1NFUlQoIW1fY2FsbGJhY2tzT25Xb3JrZXJD b250ZXh0KTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpzdG9w KCkKK3sKKyAgICBtX2JyaWRnZVdyYXBwZXItPnN0b3AoKTsKKworICAgIEFTU0VSVChtX2NhbGxi YWNrc09uV29ya2VyQ29udGV4dCk7CisgICAgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRp ZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgIG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0 ID0gMDsKKworICAgIC8vIENsZWFyaW5nIHRoZSBzZWxmUmVmICh0aGlzIG1heSBkZWxldGUgaXRz ZWxmKS4KKyAgICBtX3NlbGZSZWYuY2xlYXIoKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29tbW9u V29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJG aWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplKQoreworICAgIG1fc2VsZlJlZiA9 IHRoaXM7CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxs YmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkLCBjb21tb25DbGllbnQsIG1vZGUs IHR5cGUsIHNpemUsIHRoaXMpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlOjpvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIGNvbnN0IFdURjo6U3RyaW5n JiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKiBicmlkZ2UpCit7CisgICAgaWYgKCFjb21tb25DbGll bnQpCisgICAgICAgIGJyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3JBYm9y dCwgbW9kZSk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2Fs bGJhY2tzIGlzIHNlbGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIgaGVyZS4KKyAgICAgICAg Y29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbSh0eXBlLCBzaXplLCBNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrczo6Y3JlYXRlKGJyaWRnZS0+bV9icmlkZ2VXcmFwcGVyLCBtb2RlKS5sZWFr UHRyKCkpOworICAgIH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl OjpkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvciwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUpCit7CisgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4 dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZEZhaWxPbldvcmtlclRocmVhZCwgdGhpcywgZXJyb3Ip LCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3Qg V1RGOjpTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBXVEY6OlN0cmluZyYgbW9kZSkKK3sKKyAgICBt X3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFz aygmZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwgcm9vdFBhdGgp LCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRG YWlsT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgV2ViRmlsZUVycm9yIGVycm9yKQoreworICAgIEFT U0VSVChicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KTsKKyAgICBicmlkZ2UtPm1f Y2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0LT5kaWRGYWlsKGVycm9yKTsKKyAgICBicmlkZ2UtPm1f Y2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0ID0gMDsKKyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVh cigpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5G aWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3QgV1RGOjpTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKK3sKKyAgICBBU1NFUlQoYnJpZGdlLT5tX2Nh bGxiYWNrc09uV29ya2VyQ29udGV4dCk7CisgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2Vy Q29udGV4dC0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgcm9vdFBhdGgpOworICAgIGJyaWRnZS0+ bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOworICAgIGJyaWRnZS0+bV9zZWxmUmVmLmNs ZWFyKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShG SUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWRlODcyY2ViNjcxODM3YzJhOGQxMzgy MjQyZjg1MTZlNjA5YjgyOAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAgKzEsMTAzIEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMK KyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBP UiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRl ZiBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZpbmUgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJBY3RpdmVET01PYmplY3QuaCIKKyNp bmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVt LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CisK K2NsYXNzIFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOworY2xhc3MgTWFpblRocmVh ZEZpbGVTeXN0ZW1DYWxsYmFja3M7CitjbGFzcyBXZWJDb21tb25Xb3JrZXJDbGllbnQ7CitjbGFz cyBXZWJXb3JrZXJCYXNlOworY2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxiYWNrczsKKworLy8gVGhp cyBjbGFzcyBpcyB1c2VkIHRvIHBvc3QgYSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBt YWluIHRocmVhZCBhbmQgZ2V0IGNhbGxlZCBiYWNrIGZvciB0aGUgcmVxdWVzdC4gVGhpcyBtdXN0 IGJlIGRlc3RydWN0ZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisvLyBUaGlzIGluaGVyaXRzIGZy b20gQWN0aXZlRE9NT2JqZWN0IGp1c3QgdG8gYmUgbm90aWZpZWQgd2hlbiB0aGUgY29udGV4dCBp cyBnb2luZyB0byBiZSBzdG9wcGVkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZvciBvcGVuRmls ZVN5c3RlbSB3b3VsZCBsb29rIGxpa2UgZm9sbG93aW5nOgorLy8gQnJpZGdlOjpwb3N0T3BlbkZp bGVTeXN0ZW1Pbk1haW5UaHJlYWQoKSBvbiBXb3JrZXJUaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpv cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCgpIGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAg ICAgIFRoaXMgbWFrZXMgYW4gSVBDIHdpdGggYSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNr cyBpbnN0YW5jZS4KKy8vICAgICBbYWN0dWFsIG9wZXJhdGlvbiBpcyBkb25lIGluIHRoZSBicm93 c2VyXQorLy8gIC0tPiBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlzIGNh bGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFkIGlz IGNhbGxlZCBvbiBNYWluVGhyZWFkICh2aWEgVGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXIpCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJUaHJlYWQgaXMgY2FsbGVkIG9uIFdv cmtlclRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSB3b3JrZXIncyBvcmlnaW5hbCBjYWxs YmFja3MgKG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSBhbmQgcmVsZWFzZXMgYSBzZWxmLXJl ZmVyZW5jZSB0byB0aGUgYnJpZGdlLgorY2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZSA6IHB1YmxpYyBXZWJDb3JlOjpBY3RpdmVET01PYmplY3QsIHB1YmxpYyBSZWZDb3VudGVk PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBjcmVhdGUoV2ViV29y a2VyQmFzZSogd29ya2VyLCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiB3b3JrZXJD b250ZXh0LCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgeworICAgICAg ICByZXR1cm4gV1RGOjphZG9wdFJlZihuZXcgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSh3b3JrZXIsIHdvcmtlckNvbnRleHQsIGNhbGxiYWNrcykpOworICAgIH0KKyAgICB+V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpOworCisgICAgLy8gQWN0aXZlRE9NT2JqZWN0IG1l dGhvZC4KKyAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpOworCisgICAgdm9pZCBwb3N0T3BlbkZpbGVT eXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29tbW9uV29ya2VyQ2xpZW50KiwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplKTsKKworICAgIC8v IENhbGxiYWNrIG1ldGhvZHMgdGhhdCBhcmUgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAg ICB2b2lkIGRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yLCBjb25zdCBXVEY6OlN0cmlu ZyYgbW9kZSk7CisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUpOworCitwcml2YXRlOgorICAgIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UoV2ViV29ya2VyQmFzZSosIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJG aWxlU3lzdGVtQ2FsbGJhY2tzKik7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyB0byBiZSBjYWxs ZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25N YWluVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3Jr ZXJDbGllbnQqLCBjb25zdCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSwg bG9uZyBsb25nIHNpemUsIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqKTsKKworICAg IGZyaWVuZCBjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKKworICAgIC8vIE1l dGhvZHMgdGhhdCBkaXNwYXRjaCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIG9uIHRoZSB3b3JrZXIg dGhyZWFkcy4KKyAgICAvLyBUaGV5IHJlbGVhc2UgYSBzZWxmUmVmIG9mIHRoZSBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlLgorICAgIHN0YXRpYyB2b2lkIGRpZEZhaWxPbldvcmtlclRo cmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZSosIFdlYkZpbGVFcnJvcik7CisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZp bGVTeXN0ZW1PbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSosIGNvbnN0IFdURjo6U3RyaW5nJiBuYW1l LCBjb25zdCBXVEY6OlN0cmluZyYgcm9vdFBhdGgpOworCisgICAgLy8gbV9zZWxmUmVmIGtlZXBz IGEgcmVmZXJlbmNlIHRvIGl0c2VsZiB1bnRpbCBjYWxsYmFja3MgYXJlIGZpcmVkIG9uIHRoZSB3 b3JrZXIgdGhyZWFkLgorICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl PiBtX3NlbGZSZWY7CisKKyAgICBSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXI+IG1fYnJpZGdlV3JhcHBlcjsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBX ZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dDsKK307CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2VfaAo= 68211 2010-09-21 03:52:32 -0700 2010-09-21 19:34:53 -0700 Patch bug-45808-20100921035231.patch text/plain 40857 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uMDA4ZTAzMDFhYjI0Nzg2 OGRiN2Y5N2JiMmRiNmYxNjBkZWI4YjhlMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NyBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAqIHdvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGw6CisKIDIwMTAtMDktMjEgIERpcmsgU2NodWx6ZSAgPGtyaXRAd2Via2l0Lm9y Zz4KIAogICAgICAgICBTVkcgRmlsdGVyIGNsZWFudXAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmlu ZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcCBiL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAppbmRleCBhMTVmZDZkMDgwMmZi ZWVmMTEwOWZjYTljOWQzYjJmM2QzMDIwYzA0Li45YTk2ZjIyNmQzY2ZmNzI3OGM3OTI2OWExYzgy ZTRhY2M3ODQwNjRiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGlt ZUVuYWJsZWRGZWF0dXJlcy5jcHAKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRp bWVFbmFibGVkRmVhdHVyZXMuY3BwCkBAIC0zNiw2ICszNiwxMCBAQAogI2luY2x1ZGUgIlNoYXJl ZFdvcmtlclJlcG9zaXRvcnkuaCIKICNpbmNsdWRlICJXZWJTb2NrZXQuaCIKIAorI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNMb2Nh bFN0b3JhZ2VFbmFibGVkID0gdHJ1ZTsKQEAgLTU3LDYgKzYxLDExIEBAIGJvb2wgUnVudGltZUVu YWJsZWRGZWF0dXJlczo6aXNYSFJSZXNwb25zZUJsb2JFbmFibGVkID0gZmFsc2U7CiAKICNpZiBF TkFCTEUoRklMRV9TWVNURU0pCiBib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzRmlsZVN5 c3RlbUVuYWJsZWQgPSBmYWxzZTsKKworYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxl U3lzdGVtRW5hYmxlZCgpCit7CisgICAgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQgJiYgQXN5 bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpOworfQogI2VuZGlmCiAKICNpZiBFTkFCTEUoVklE RU8pCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5oIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVy ZXMuaAppbmRleCA5MTc2OGIwZTU0ZTdmOTdiYWNkMGE5YmQzMzllMWRjNDIwZDZlZGVlLi5iYTRh NGZiMDVkZjUxZDc0NDRmYjlhM2JhMTAwMmFlNDdhYmQ1ZmM4IDEwMDY0NAotLS0gYS9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oCisrKyBiL1dlYkNvcmUv YmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmgKQEAgLTE0OCw3ICsxNDgs NyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKLSAgICBzdGF0 aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7 IH0KKyAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgpOwogICAgIHN0YXRpYyB2b2lk IHNldEZpbGVTeXN0ZW1FbmFibGVkKGJvb2wgaXNFbmFibGVkKSB7IGlzRmlsZVN5c3RlbUVuYWJs ZWQgPSBpc0VuYWJsZWQ7IH0KICAgICBzdGF0aWMgYm9vbCByZXF1ZXN0RmlsZVN5c3RlbUVuYWJs ZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVkOyB9CiAjZW5kaWYKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvV2ViQ29yZS9maWxlYXBpL0xv Y2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2ZDdiYjE5ZjFkNDgzOWU1ZWUzOTk2MDBm NmUwNDRmNi4uMTRjNjJjODk1NjcyYmRmZjc3MmRmOWIyY2M5ZjYxZTI1ZmQ0ZDUyMiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9m aWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUwLDkgKzUwLDMwIEBACiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3Rl bTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCitMb2NhbEZpbGVTeXN0ZW0qIExvY2Fs RmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVtOjppbml0 aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCit7CisgICAgLy8g RklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAg IEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKCFzX2luc3RhbmNlKTsKKyAgICBp ZiAoc19pbnN0YW5jZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgT3duUHRyPExvY2FsRmlsZVN5 c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIobmV3IExvY2FsRmlsZVN5c3RlbShiYXNl UGF0aCkpOworICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZpbGVTeXN0ZW0ubGVha1B0cigpOworfQor CitMb2NhbEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sK KyAgICAvLyBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIHByaW9yIGNh bGxpbmcgdGhpcy4KKyAgICBBU1NFUlQoc19pbnN0YW5jZSk7CisgICAgcmV0dXJuICpzX2luc3Rh bmNlOworfQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBj b25zdAogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRo KSk7CisgICAgcmV0dXJuIG1fYmFzZVBhdGgudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAogc3RhdGlj IHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmlu ZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIFBhc3NPd25QdHI8RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQpAQCAt NjgsNyArODksNyBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgIH0KIAogICAgIC8vIEFz eW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3Vz bHksIHNvIHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAg IGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIG1f YmFzZVBhdGgsIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigp LCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2ssIGNvbnRleHQpKSk7CisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tU YXNrKCZvcGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3Vy aXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNh bGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiB9CiAK IH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lz dGVtLmggYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggNDhjZmE4ZjY4 ODZhNjBhNDAwNDQ0ZTJmY2ViZWE2OGNkNTIzZGJiNi4uODNmZWY5ZDYzYzY1YjNlOTllODNiN2Vk ZTA2MjI5N2QyNDhhZTYwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaApAQCAtNDQsMTkg KzQ0LDMzIEBAIGNsYXNzIEVycm9yQ2FsbGJhY2s7CiBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7 CiBjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogCi1jbGFzcyBMb2NhbEZpbGVTeXN0ZW0g OiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbEZpbGVTeXN0ZW0+IHsKKy8vIEtlZXBzIHBlci1wcm9j ZXNzIGluZm9ybWF0aW9uIGFuZCBwcm92aWRlcyBhbiBlbnRyeSBwb2ludCB0byBvcGVuIGEgZmls ZSBzeXN0ZW0uCitjbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJsaWMgTm9uY29weWFibGUgewog cHVibGljOgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gY3JlYXRlKGNv bnN0IFN0cmluZyYgYmFzZVBhdGgpOwotICAgIHZpcnR1YWwgfkxvY2FsRmlsZVN5c3RlbSgpIHsg fQorICAgIC8vIFJldHVybnMgYSBwZXItcHJvY2VzcyBpbnN0YW5jZSBvZiBMb2NhbEZpbGVTeXN0 ZW0uCisgICAgLy8gTm90ZSB0aGF0IExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmls ZVN5c3RlbSBtdXN0IGJlIGNhbGxlZCBiZWZvcmUKKyAgICAvLyBjYWxsaW5nIHRoaXMgb25lLgor ICAgIHN0YXRpYyBMb2NhbEZpbGVTeXN0ZW0mIGxvY2FsRmlsZVN5c3RlbSgpOwogCiAgICAgdm9p ZCByZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3lz dGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+ LCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+KTsKIAotcHJvdGVjdGVkOgorI2lmICFQTEFURk9S TShDSFJPTUlVTSkKKyAgICAvLyBUaGlzIGlzIG5vdCB0aHJlYWQtc2FmZTsgbXVzdCBiZSBjYWxs ZWQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkcyBhcmUgY3JlYXRlZC4KKyAgICB2b2lkIGluaXRp YWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJik7CisKKyAgICBTdHJpbmcgZmlsZVN5 c3RlbUJhc2VQYXRoKCkgY29uc3Q7CisjZW5kaWYKKworcHJpdmF0ZToKICAgICBMb2NhbEZpbGVT eXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKICAgICAgICAgOiBtX2Jhc2VQYXRoKGJhc2VQ YXRoKQogICAgIHsKICAgICB9CiAKKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtKiBzX2luc3Rh bmNlOworCisgICAgLy8gVGhlIG1lbWJlciBtZXRob2RzIHNob3VsZG4ndCBhY2Nlc3MgdGhpcyBT dHJpbmcgZGlyZWN0bHkgYnV0IHNob3VsZCB1c2UKKyAgICAvLyBmaWxlU3lzdGVtQmFzZVBhdGgo KSBpbnN0ZWFkLgogICAgIFN0cmluZyBtX2Jhc2VQYXRoOwogfTsKIApkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wYWdlL0RPTVdpbmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAppbmRl eCBmNWJhMjVjMzZhOWFkMmM3ZmQxNjU5YTViNWQzZDA2ZDg3YmE1YzQ2Li42YTIwM2NjN2M0OTJl YzMzYWJlMDAyOTJlM2EwNDhkOGEyYWMzNDFkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAtNzI3LDI1ICs3 MjcsMTYgQEAgdm9pZCBET01XaW5kb3c6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25n IGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGUKICAgICBpZiAoIWRvY3VtZW50KQogICAg ICAgICByZXR1cm47CiAKLSAgICBpZiAoIW1fbG9jYWxGaWxlU3lzdGVtKSB7Ci0gICAgICAgIC8v IEZJWE1FOiBTZWUgaWYgYWNjZXNzIGlzIGFsbG93ZWQuCi0KLSAgICAgICAgUGFnZSogcGFnZSA9 IGRvY3VtZW50LT5wYWdlKCk7Ci0gICAgICAgIGlmICghcGFnZSkgewotICAgICAgICAgICAgRE9N RmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmls ZUVycm9yOjpjcmVhdGUoSU5WQUxJRF9TVEFURV9FUlIpKTsKLSAgICAgICAgICAgIHJldHVybjsK LSAgICAgICAgfQotCi0gICAgICAgIC8vIEZJWE1FOiBHZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFz IHdlbGwuCi0gICAgICAgIFN0cmluZyBwYXRoID0gcGFnZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3Rl bVJvb3RQYXRoKCk7Ci0gICAgICAgIG1fbG9jYWxGaWxlU3lzdGVtID0gTG9jYWxGaWxlU3lzdGVt OjpjcmVhdGUocGF0aCk7CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkg fHwgIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsK KyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JD YWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVy bjsKICAgICB9CiAKLSAgICBtX2xvY2FsRmlsZVN5c3RlbS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9j dW1lbnQsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1 Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7CisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKS5yZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5 bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNh bGxiYWNrKTsKIH0KIAotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9 PSBpbnQoQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKLUNPTVBJ TEVfQVNTRVJUKGludChET01XaW5kb3c6OlBFUlNJU1RFTlQpID09IGludChBc3luY0ZpbGVTeXN0 ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19j YXN0PGludD4oRE9NV2luZG93OjpURU1QT1JBUlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNG aWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0 YXRpY19jYXN0PGludD4oRE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+ KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYK IApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RP TVdpbmRvdy5oCmluZGV4IDE0NzA2Mjg2NWQ5YjliNzc0NzE2OWFmYjIxODQxZDY2ZjExZDljZDQu LjZmZDM3NzUwM2FiNGVlZjFkOWU3NzVmOTgzMDRkMTEzMWZhZmIwM2EgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGFnZS9ET01XaW5kb3cuaAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAg LTU4LDcgKzU4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIEhpc3Rvcnk7CiAg ICAgY2xhc3MgSURCRmFjdG9yeTsKICAgICBjbGFzcyBJbnNwZWN0b3JUaW1lbGluZUFnZW50Owot ICAgIGNsYXNzIExvY2FsRmlsZVN5c3RlbTsKICAgICBjbGFzcyBMb2NhdGlvbjsKICAgICBjbGFz cyBTdHlsZU1lZGlhOwogICAgIGNsYXNzIE5hdmlnYXRvcjsKQEAgLTQ0NCw5ICs0NDMsNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAg IG11dGFibGUgUmVmUHRyPElEQkZhY3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVO QUJMRShGSUxFX1NZU1RFTSkKLSAgICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2Nh bEZpbGVTeXN0ZW07Ci0jZW5kaWYKIAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRh cmdldERhdGE7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1NjE5 YWJjMTA0ZWI5ODFkY2VkNWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5NzQ3 MTY1MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6CiAg ICAgYm9vbCBjYW5BY2Nlc3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUo KTsgfQogICAgIGJvb2wgY2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1 ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJldHVy biAhaXNVbmlxdWUoKTsgfQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0IHsg cmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxkIGFs d2F5cyBhbGxvdyBhY2Nlc3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1cnJl bnRseSBkb24ndCBoYW5kbGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1bmlx dWUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuY3BwCmluZGV4IGZhYzBhNWY0OTY4ZGI2YTRhYTFkNzk0NmZlYmRkM2VmNjk1MTQ3 YTUuLjRkMTY2MmI2MzZhOTgxNDE2OGI2ZTU4ODQ4YTU3MGI2YjY1OTE2MjcgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cApAQCAtNDk3LDExICs0OTcsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VEYXRh YmFzZVBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQ YXRoID0gcGF0aDsKIH0KIAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNv bnN0IFN0cmluZyYgcGF0aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7Ci19 Ci0KIHZvaWQgU2V0dGluZ3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUpCiB7 CiAgICAgbV9pbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvU2V0dGluZ3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDk5YTRm MjMyYzUyOTgwNmVhYTI3Zjg1ZDU3ZGJiYWIxMjc0NGJmMzMuLmY4YTI5N2ExN2IwNTU2OWQ4NWZj N2IxMTBjNDY1NmY0NDc0MDc2NGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5o CisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCkBAIC0yNDEsOSArMjQxLDYgQEAgbmFtZXNw YWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChj b25zdCBTdHJpbmcmKTsKICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRhYmFz ZVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQogCi0g ICAgICAgIHZvaWQgc2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAgICAg ICBjb25zdCBTdHJpbmcmIGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fZmls ZVN5c3RlbVJvb3RQYXRoOyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9tZU1v ZGUoYm9vbCk7CiAgICAgICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25zdCB7 IHJldHVybiBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzNiw3ICszMzMsNiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5jb2Rp bmdOYW1lOwogICAgICAgICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAgICAg ICAgIFN0cmluZyBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5nIG1f ZmlsZVN5c3RlbVJvb3RQYXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2NhdGlv bjsKICAgICAgICAgQXRvbWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAgICBB dG9taWNTdHJpbmcgbV9maXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3Rl bS5jcHAKaW5kZXggYjRmY2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4uNzc4 MjhmZjEzY2EyN2Y4NzViMzE1ZWM4NmJlODYyMWQyYzUzZDBlNiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5 bmNGaWxlU3lzdGVtLmNwcApAQCAtMzQsMTMgKzM0LDIxIEBACiAjaWYgRU5BQkxFKEZJTEVfU1lT VEVNKQogCiAjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAi Tm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAorI2lmICFQTEFURk9STShDSFJPTUlVTSkKK2Jvb2wgQXN5bmNGaWxlU3lzdGVt Ojppc0F2YWlsYWJsZSgpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICByZXR1cm4gZmFs c2U7Cit9CisKIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBBc3luY0ZpbGVTeXN0ZW06OmNy ZWF0ZShjb25zdCBTdHJpbmcmKQogewotICAgIC8vIEZJWE1FOiByZXR1cm4gZGVmYXVsdCBBc3lu Y0ZpbGVTeXN0ZW0gaW1wbGVtZW50YXRpb24uCisgICAgbm90SW1wbGVtZW50ZWQoKTsKICAgICBy ZXR1cm4gMDsKIH0KIApAQCAtNjIsNiArNzAsNyBAQCB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6b3Bl bkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9yYQog CiAgICAgY2FsbGJhY2tzLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCBBc3luY0ZpbGVTeXN0ZW06 OmNyZWF0ZShyb290UGF0aCkpOwogfQorI2VuZGlmCiAKIC8vIERlZmF1bHQgaW1wbGVtZW50YXRp b24uCiBTdHJpbmcgQXN5bmNGaWxlU3lzdGVtOjp2aXJ0dWFsVG9QbGF0Zm9ybVBhdGgoY29uc3Qg U3RyaW5nJiBwYXRoKSBjb25zdApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0Zp bGVTeXN0ZW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKaW5kZXggNjAx ZjBlYWUzZTVkMGU4YmViODRkNWE5OTNkNzcwNTE3YmQwYTYyZC4uOGM0ZDVkOTkwZmRhNDZjMmI3 ODBkZjliMDlhNjA3N2U1NGQ5ZmY1NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3lu Y0ZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCkBA IC01Niw2ICs1Niw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpIHsgfQogICAg IHZpcnR1YWwgYm9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKSB7IHJldHVybiBmYWxzZTsgfQogCisg ICAgc3RhdGljIGJvb2wgaXNBdmFpbGFibGUoKTsKKwogICAgIC8vIENyZWF0ZXMgYW5kIHJldHVy bnMgYSBuZXcgcGxhdGZvcm0tc3BlY2lmaWMgQXN5bmNGaWxlU3lzdGVtIGluc3RhbmNlIGlmIHRo ZSBwbGF0Zm9ybSBoYXMgaXRzIG93biBpbXBsZW1lbnRhdGlvbi4KICAgICBzdGF0aWMgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGNyZWF0ZShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKTsKIApk aWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwIGIvV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCmluZGV4IGI1MmIyODU0NzVmMmVmOTQ3N2U4MTRiYmU0 ZDhiZWI5YzNiOWVhMGEuLjQ3NWQ4OTMzYjU4NWQzNTI3OTkxNzQ4ZTRiYmE2YWIxNjM0N2M3ZmIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAorKysgYi9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKQEAgLTYzLDYgKzYzLDE1IEBACiAjaW5jbHVk ZSAiTm90aWZpY2F0aW9uQ2VudGVyLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJET01GaWxlU3lzdGVt LmgiCisjaW5jbHVkZSAiRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgor I2luY2x1ZGUgIkZpbGVTeXN0ZW1DYWxsYmFjay5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2xvc2VXb3JrZXJD b250ZXh0VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKQEAgLTMz NSw2ICszNDQsMjEgQEAgdm9pZCBXb3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0 cmluZyYgYmxvYlVSTFN0cmluZykKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQordm9pZCBXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBs b25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ss IFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBpZiAoIUFz eW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8fCAhc2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNj ZXNzRmlsZVN5c3RlbSgpKSB7CisgICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJh Y2sodGhpcywgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmls ZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKHRoaXMsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5 c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7 Cit9CisKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6VEVN UE9SQVJZKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwg ZW51bV9taXNtYXRjaCk7CitDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNv bnRleHQ6OlBFUlNJU1RFTlQpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQ ZXJzaXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dv cmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaApp bmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi44ZDJmNTE5ZDI1 NzQxYzg2NWIwZjkwNjllOGVmY2NlODVmNzM1OTc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgK QEAgLTQ3LDYgKzQ3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFiYXNl OwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5jOwor ICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNrOwog ICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247 CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTIzLDE1IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYpOwog I2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIC8vIFRoZXkgYXJlIHBs YWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRvIGVuZm9yY2UgY29tcGlsZS10 aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5c3RlbVR5cGUgeworICAgICAg ICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVOVCwKKyAgICAgICAgfTsKKyAg ICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBh c3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7 CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJr aW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAg ICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdh dG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgp OyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwgYi9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRhZGI4OGJjMmRmNjdmMjdk NWVjZTJiNWE5MjMyODY3ODEyNC4uM2UxODVjMGQ1YjhlMGExMzdiZDkyOGM1MmEyZGJhODE3NWY4 MDMzNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCisrKyBi L1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0LDYgKzEwNCwxNCBAQCBt b2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVCbG9iVVJMKGluIEJsb2Ig YmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01TdHJpbmcgYmxvYlVSTCk7 CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVNKSAmJiBFTkFCTEVfRklM RV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVNUE9SQVJZID0gMDsKKyAg ICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7CisgICAgICAgIFtFbmFi bGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVuc2lnbmVkIHNob3J0IHR5 cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBGaWxlU3lzdGVt Q2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9wdGlvbmFsXSBFcnJvckNh bGxiYWNrIGVycm9yQ2FsbGJhY2spOworCisgICAgICAgICAgICAgICAgIGF0dHJpYnV0ZSBbRW5h YmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9yIEZsYWdzOworI2VuZGlm CiAgICAgfTsKIAogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNTZmMmM1YTU5ZWVhM2I3YjgwOTkwYjU4Yjgw ODYzYjJjMTEwZGE3Ni4uOThlNTAyMGJkODJhZDZlNjAwZmExOThlYjIxZmI0NmJkN2U3NmQ3MSAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTAtMDktMTcgIEtpbnVrbyBZYXN1ZGEg IDxraW51a29AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3RlbSBBUEkKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1ODA4CisKKyAg ICAgICAgQWRkZWQgV2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0gYW5kIFdlYkNvbW1vbldv cmtlckNsaWVudDo6CisgICAgICAgIG9wZW5GaWxlU3lzdGVtIHRvIGNhbGwgaW4gdG8gdGhlIGJy b3dzZXIgdmlhIFdvcmtlciBzdHViL3Byb3h5CisgICAgICAgIGluIHRoZSBjaHJvbWl1bS4KKwor ICAgICAgICBBbHNvIGFkZGVkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UgY2xhc3Mg dGhhdCBwcm94aWVzCisgICAgICAgIHJlcXVlc3RzIGFuZCBjYWxsYmFja3MgYmV0d2VlbiBmcm9t L3RvIHdvcmtlciB0aHJlYWQgdG8vZnJvbSB0aGUKKyAgICAgICAgbWFpbiB0aHJlYWQuCisKKyAg ICAgICAgKiBwdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQ6 OldlYkNvbW1vbldvcmtlckNsaWVudDo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAg KiBzcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TG9j YWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkxvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCBpbXBsZW1lbnRhdGlv bgorICAgICAgICBmb3Igd29ya2Vycy4gSW4gd29ya2VyIGNhc2UgdGhpcyBjYWxscyBXZWJXb3Jr ZXJCYXNlOjpvcGVuRmlsZVN5c3RlbS4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5jcHA6 CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQu IFRoaXMgaXMgY2FsbGVkIGZyb20KKyAgICAgICAgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0Rmls ZVN5c3RlbSBvbiB0aGUgd29ya2VyIHRocmVhZCBhbmQgY3JlYXRlcworICAgICAgICBhIGJyaWRn ZSB0byBjYWxsIFdlYkNvbW1vbldvcmtlckNsaWVudDo6b3BlbkZpbGVTeXN0ZW0gb24gdGhlIG1h aW4KKyAgICAgICAgdGhyZWFkLgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAg ICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29y a2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBzcmMvV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9X b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmg6IEFkZGVkLgorCiAyMDEwLTA5LTIwICBQ aGlsaXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdl ZCBieSBFcmljIENhcmxzb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cCBiL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCmluZGV4IDM1MjNmMjFhMWIxNDg1N2ExYzQ1 Y2NiNmIzZjM4YjEwZmQxMjZhY2MuLjg3NGQ0ODU4ZmIxYWE0OWE1YjczYzJmNDBiNzk2ZjExYTky MjM2MDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9XZWJLaXQuZ3lwCkBAIC01MzMsNiArNTMzLDggQEAKICAgICAgICAgICAgICAg ICAnc3JjL1dlYldvcmtlckNsaWVudEltcGwuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJX b3JrZXJJbXBsLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmgnLAor ICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAn LAorICAgICAgICAgICAgICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5o JywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlcXVlc3QuaCcsCiAgICAg ICAgICAgICAgICAgJ3NyYy9XcmFwcGVkUmVzb3VyY2VSZXNwb25zZS5oJywKICAgICAgICAgICAg ICAgICAnc3JjL3dpbi9XZWJJbnB1dEV2ZW50RmFjdG9yeS5jcHAnLApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUw MzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5 NmEyZGNkNmQyMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25X b3JrZXJDbGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtl ckNsaWVudC5oCkBAIC0zMSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVu dF9oCiAjZGVmaW5lIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21t b24uaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewog CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1Ymxp YzoKICAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3Blbmlu ZyBhIHdlYiBkYXRhYmFzZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFt ZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwg dW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhl IG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZp cnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcg c2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTog V2UgbmVlZCBhIHN0dWIgaW1wbGVtZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0g aW1wbGVtZW50IHRoaXMuCisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICB9CisKIHByb3RlY3RlZDoKICAgICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9Owpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRl eCAwOGZjZWE2Yzk4NWFjMzIxZDI5MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMx YjY1YzdmYzE1ZjlhMzUzY2ZjNTFhNjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQorewor ICAgIHJldHVybiB0cnVlOworfQorCiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxl U3lzdGVtQ2hyb21pdW0oY29uc3QgU3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5 c3RlbShyb290UGF0aCkKICAgICAsIG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVu dCgpLT5maWxlU3lzdGVtKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2Fs RmlsZVN5c3RlbUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lz dGVtQ2hyb21pdW0uY3BwCmluZGV4IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIw ZjI1YjIuLjk5NGYzMTA0NmIzZGQ3NTc1YWEwMTllNmUxODk5YmFmZjE5MDkzMTggMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Miwx NCArNDIsMTkgQEAKICNpbmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2lu Y2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5j bHVkZSAiV2ViV29ya2VySW1wbC5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNs dWRlICJXb3JrZXJUaHJlYWQuaCIKKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIHVzaW5n IG5hbWVzcGFjZSBXZWJLaXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxM b2NhbEZpbGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0 aCkKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQog ewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBB dG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWMoTG9jYWxGaWxlU3lzdGVtKiwgbG9jYWxGaWxlU3lz dGVtID0gbmV3IExvY2FsRmlsZVN5c3RlbSgiIikpOworICAgIHJldHVybiAqbG9jYWxGaWxlU3lz dGVtOwogfQogCiB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxv bmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxi YWNrLCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2 NSwxMCBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdl YkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAg ICAgICB3ZWJGcmFtZS0+Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNf Y2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTog QWRkIGltcGxlbWVudGF0aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3 b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAg ICAgICBXb3JrZXJMb2FkZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4 dC0+dGhyZWFkKCktPndvcmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2Uq IHdlYldvcmtlciA9IHN0YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94 eSk7CisgICAgICAgIHdlYldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oc3RhdGljX2Nhc3Q8V2ViRmls ZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1w bChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ss IGNvbnRleHQpKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNw cAppbmRleCA0MmY0MWQyZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi42MTMyMjNm ODNiMDI4ZThiYmM5YjA2MzZkOWY4Njk2M2IzNjNkNGY5IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQmFzZS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3Nh Z2VQb3J0Q2hhbm5lbC5oIgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNs dWRlICJXZWJGaWxlRXJyb3IuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1 ZGUgIldlYkZyYW1lSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpA QCAtNDUsNiArNDYsOCBAQAogI2luY2x1ZGUgIldlYlZpZXcuaCIKICNpbmNsdWRlICJXZWJXb3Jr ZXJDbGllbnQuaCIKIAorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29u dHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CkBAIC01Niw2ICs1OSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJM RShXT1JLRVJTKQogCiBzdGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFs bG93RGF0YWJhc2VNb2RlIjsKK3N0YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtd ID0gIm9wZW5GaWxlU3lzdGVtTW9kZSI7CiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2ICsxMTgs NyBAQCBwcml2YXRlOgogICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3Ry aW5nIG1fbW9kZTsKIH07CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhl IG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2 ICsyMzYsMTYgQEAgYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwg Y29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5y ZXN1bHQoKTsKIH0KIAordm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBjYWxsYmFja3MpCit7CisgICAgV29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhy ZWFkLT5ydW5Mb29wKCk7CisgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9 IFdvcmtlclNjcmlwdENvbnRyb2xsZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgV29y a2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsK KworICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UgPSBX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpjcmVhdGUodGhpcywgd29ya2VyQ29udGV4 dCwgY2FsbGJhY2tzKTsKKyAgICBicmlkZ2UtPnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVh ZChjb21tb25DbGllbnQoKSwgb3BlbkZpbGVTeXN0ZW1Nb2RlLCB0eXBlLCBzaXplKTsKK30KKwog Ly8gV29ya2VyT2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2Fn ZVRvV29ya2VyT2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdl LApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRl YjAyMmM4NWM0YzMyN2Q2ZTMxMmIzLi42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMx ZDk2YWNiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBA QCBwdWJsaWM6CiAgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNl cyBpcyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRh YmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVl c3RzIHRvIG9wZW4gYSBmaWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhp cyBpcyBub3QgdGhlIGltcGxlbWVudGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVT eXN0ZW0uKQorICAgIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9u ZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVz IHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBs LmgKaW5kZXggNzQxZDYwNjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgy MzVkYmYyOGZjOWVmZjM0YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShX T1JLRVJTKQogCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtl ckNsaWVudC5oIgotCiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwx MCBAQCBwdWJsaWM6CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1 cm4gdHJ1ZTsKICAgICB9CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1l KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxs YmFja3MqKQorICAgIHsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBw cml2YXRlOgogICAgIHZpcnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjc5YjVjM2M3OTU2MzU4M2U4NTU4Yjc3MGZiNzA4YzhkODQ1OGM1MTEKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UuY3BwCkBAIC0wLDAgKzEsMjE4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lu Y2x1ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKKworI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIkNy b3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIldlYkNvbW1vbldvcmtlckNsaWVudC5oIgorI2lu Y2x1ZGUgIldlYkZpbGVJbmZvLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNrcy5o IgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1FbnRyeS5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5o IgorI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0Lmgi CisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRo cmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVh ZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNv cmU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCisvLyBBIHRocmVhZC1zYWZlIHdyYXBwZXIgZm9y IHRoZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLiBUaGlzIGluc3RhbmNlIGlzIHNo YXJlZCBieSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBhbmQgV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZS4KK2NsYXNzIFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVy IDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBw ZXI+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxUaHJlYWRhYmxlQ2FsbGJhY2tz QnJpZGdlV3JhcHBlcj4gY3JlYXRlKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJy aWRnZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgVGhyZWFkYWJsZUNhbGxi YWNrc0JyaWRnZVdyYXBwZXIoYnJpZGdlKSk7CisgICAgfQorCisgICAgdm9pZCBzdG9wKCkKKyAg ICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsKKyAgICAgICAgbV9icmlk Z2UgPSAwOworICAgIH0KKworICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJy b3IgZXJyb3IsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgTXV0ZXhM b2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgICAgICBpZiAobV9icmlkZ2UpCisgICAgICAgICAg ICBtX2JyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvciwgbW9kZSk7CisgICAgfQorCisg ICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUpCisg ICAgeworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAgICAgIGlmICht X2JyaWRnZSkKKyAgICAgICAgICAgIG1fYnJpZGdlLT5kaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRo cmVhZChuYW1lLCByb290UGF0aCwgbW9kZSk7CisgICAgfQorCitwcml2YXRlOgorICAgIFRocmVh ZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyKFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UqIGJyaWRnZSkKKyAgICAgICAgOiBtX2JyaWRnZShicmlkZ2UpCisgICAgeworICAgIH0KKwor ICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSog bV9icmlkZ2U7Cit9OworCisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhhdCBhcmUgdG8gYmUg ZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAg ICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcz4gY3JlYXRl KFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJyaWRnZVdyYXBw ZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UHRyKG5ldyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2VXcmFwcGVyLCBtb2Rl KSk7CisgICAgfQorCisgICAgdmlydHVhbCB+TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3Mo KQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29u c3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgeworICAgICAg ICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAgICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRP cGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChuYW1lLCBwYXRoLCBtX21vZGUpOworICAgICAgICBk ZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJy b3IgZXJyb3IpCisgICAgeworICAgICAgICBBU1NFUlQobV9icmlkZ2VXcmFwcGVyKTsKKyAgICAg ICAgbV9icmlkZ2VXcmFwcGVyLT5kaWRGYWlsT25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOwor ICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2Vl ZCgpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYpCisg ICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZpbGVTeXN0 ZW1FbnRyeT4mLCBib29sIGhhc01vcmUpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgfQorCitwcml2YXRlOgorICAgIE1haW5UaHJlYWRGaWxlU3lzdGVt Q2FsbGJhY2tzKFBhc3NSZWZQdHI8VGhyZWFkYWJsZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI+IGJy aWRnZVdyYXBwZXIsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdl V3JhcHBlcihicmlkZ2VXcmFwcGVyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAg ICB9CisKKyAgICBQYXNzUmVmUHRyPFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyPiBt X2JyaWRnZVdyYXBwZXI7CisgICAgY29uc3QgV1RGOjpTdHJpbmcgbV9tb2RlOworfTsKKworV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHdvcmtl ckNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICA6IEFjdGl2 ZURPTU9iamVjdCh3b3JrZXJDb250ZXh0LCB0aGlzKQorICAgICwgbV9icmlkZ2VXcmFwcGVyKFRo cmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOjpjcmVhdGUodGhpcykpCisgICAgLCBtX3dv cmtlcih3b3JrZXIpCisgICAgLCBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dChjYWxsYmFja3Mp Cit7Cit9CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6On5Xb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlKCkKK3sKKyAgICBBU1NFUlQoIW1fY2FsbGJhY2tzT25Xb3JrZXJD b250ZXh0KTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpzdG9w KCkKK3sKKyAgICBtX2JyaWRnZVdyYXBwZXItPnN0b3AoKTsKKworICAgIGlmIChtX2NhbGxiYWNr c09uV29ya2VyQ29udGV4dCkgeworICAgICAgICBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dC0+ ZGlkRmFpbChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIG1fY2FsbGJhY2tzT25Xb3JrZXJD b250ZXh0ID0gMDsKKyAgICB9CisKKyAgICAvLyBDbGVhcmluZyB0aGUgc2VsZlJlZiAodGhpcyBt YXkgZGVsZXRlIGl0c2VsZikuCisgICAgbV9zZWxmUmVmLmNsZWFyKCk7Cit9CisKK3ZvaWQgV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhy ZWFkKFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBjb25zdCBXVEY6OlN0cmlu ZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSkKK3sKKyAg ICBtX3NlbGZSZWYgPSB0aGlzOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJl YWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCwgY29tbW9u Q2xpZW50LCBtb2RlLCB0eXBlLCBzaXplLCB0aGlzKSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBjb25z dCBXVEY6OlN0cmluZyYgbW9kZSwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcg c2l6ZSwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSogYnJpZGdlKQoreworICAgIGlm ICghY29tbW9uQ2xpZW50KQorICAgICAgICBicmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJlYWQoV2Vi RmlsZUVycm9yQWJvcnQsIG1vZGUpOworICAgIGVsc2UgeworICAgICAgICAvLyBNYWluVGhyZWFk RmlsZVN5c3RlbUNhbGxiYWNrcyBpcyBzZWxmLWRlc3RydWN0ZWQsIHNvIHdlIGxlYWsgcHRyIGhl cmUuCisgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZpbGVTeXN0ZW0odHlwZSwgc2l6ZSwgTWFp blRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6OmNyZWF0ZShicmlkZ2UtPm1fYnJpZGdlV3JhcHBl ciwgbW9kZSkubGVha1B0cigpKTsKKyAgICB9Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZTo6ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3IgZXJyb3IsIGNv bnN0IFdURjo6U3RyaW5nJiBtb2RlKQoreworICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1vZGVU b1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRGYWlsT25Xb3JrZXJUaHJlYWQs IHRoaXMsIGVycm9yKSwgbW9kZSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZTo6ZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoY29uc3QgV1RGOjpTdHJpbmcm IG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCwgY29uc3QgV1RGOjpTdHJpbmcmIG1v ZGUpCit7CisgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dChjcmVh dGVDYWxsYmFja1Rhc2soJmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQsIHRoaXMsIG5h bWUsIHJvb3RQYXRoKSwgbW9kZSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZTo6ZGlkRmFpbE9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKiBicmlkZ2UsIFdlYkZpbGVFcnJvciBlcnJv cikKK3sKKyAgICBpZiAobV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQpIHsKKyAgICAgICAgYnJp ZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dC0+ZGlkRmFpbChlcnJvcik7CisgICAgICAg IGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOworICAgIH0KKyAgICBicmlk Z2UtPm1fc2VsZlJlZi5jbGVhcigpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3Qg V1RGOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdURjo6U3RyaW5nJiByb290UGF0aCkKK3sKKyAgICBp ZiAoYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dCkgeworICAgICAgICBicmlkZ2Ut Pm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0LT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCByb290 UGF0aCk7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOwor ICAgIH0KKyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVhcigpOworfQorCit9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmVkZTg3MmNlYjY3MTgzN2MyYThkMTM4MjI0MmY4NTE2ZTYwOWI4MjgKLS0tIC9kZXYv bnVsbAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2UuaApAQCAtMCwwICsxLDEwMyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29n bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisg KiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0 aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250 cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2 ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4g cGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZ UklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBU TywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZV9oCisjZGVmaW5lIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAorCisj aW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIK KyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCisjaW5jbHVkZSAiV2ViRmlsZUVy cm9yLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzT3du UHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFk aW5nLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBUaHJlYWRhYmxlQ2FsbGJhY2tz QnJpZGdlV3JhcHBlcjsKK2NsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xh c3MgV2ViQ29tbW9uV29ya2VyQ2xpZW50OworY2xhc3MgV2ViV29ya2VyQmFzZTsKK2NsYXNzIFdl YkZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEg b3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQgYW5kIGdldCBjYWxsZWQg YmFjayBmb3IgdGhlIHJlcXVlc3QuIFRoaXMgbXVzdCBiZSBkZXN0cnVjdGVkIG9uIHRoZSB3b3Jr ZXIgdGhyZWFkLgorLy8gVGhpcyBpbmhlcml0cyBmcm9tIEFjdGl2ZURPTU9iamVjdCBqdXN0IHRv IGJlIG5vdGlmaWVkIHdoZW4gdGhlIGNvbnRleHQgaXMgZ29pbmcgdG8gYmUgc3RvcHBlZC4KKy8v CisvLyBBIHR5cGljYWwgZmxvdyBmb3Igb3BlbkZpbGVTeXN0ZW0gd291bGQgbG9vayBsaWtlIGZv bGxvd2luZzoKKy8vIEJyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKCkgb24g V29ya2VyVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQo KSBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gICAgICBUaGlzIG1ha2VzIGFuIElQQyB3aXRo IGEgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgaW5zdGFuY2UuCisvLyAgICAgW2FjdHVh bCBvcGVyYXRpb24gaXMgZG9uZSBpbiB0aGUgYnJvd3Nlcl0KKy8vICAtLT4gTWFpblRocmVhZEZp bGVTeXN0ZW1DYWxsYmFja3M6OmRpZFh4eCBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gIC0t PiBCcmlkZ2U6OmRpZFh4eE9uTWFpblRocmVhZCBpcyBjYWxsZWQgb24gTWFpblRocmVhZCAodmlh IFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyKQorLy8gIC0tPiBCcmlkZ2U6OmRpZFh4 eE9uV29ya2VyVGhyZWFkIGlzIGNhbGxlZCBvbiBXb3JrZXJUaHJlYWQKKy8vICAgICAgVGhpcyBj YWxscyB0aGUgd29ya2VyJ3Mgb3JpZ2luYWwgY2FsbGJhY2tzIChtX2NhbGxiYWNrc09uV29ya2Vy Q29udGV4dCkgYW5kIHJlbGVhc2VzIGEgc2VsZi1yZWZlcmVuY2UgdG8gdGhlIGJyaWRnZS4KK2Ns YXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UgOiBwdWJsaWMgV2ViQ29yZTo6QWN0 aXZlRE9NT2JqZWN0LCBwdWJsaWMgUmVmQ291bnRlZDxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlPiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29yZTo6 U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogd29ya2VyQ29udGV4dCwgV2ViRmlsZVN5c3RlbUNhbGxi YWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAgcmV0dXJuIFdURjo6YWRvcHRSZWYobmV3 IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2Uod29ya2VyLCB3b3JrZXJDb250ZXh0LCBj YWxsYmFja3MpKTsKKyAgICB9CisgICAgfldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2Uo KTsKKworICAgIC8vIEFjdGl2ZURPTU9iamVjdCBtZXRob2QuCisgICAgdmlydHVhbCB2b2lkIHN0 b3AoKTsKKworICAgIHZvaWQgcG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdlYkNvbW1v bldvcmtlckNsaWVudCosIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlLCBXZWJGaWxlU3lzdGVtOjpU eXBlLCBsb25nIGxvbmcgc2l6ZSk7CisKKyAgICAvLyBDYWxsYmFjayBtZXRob2RzIHRoYXQgYXJl IGNhbGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgdm9pZCBkaWRGYWlsT25NYWluVGhyZWFk KFdlYkZpbGVFcnJvciwgY29uc3QgV1RGOjpTdHJpbmcmIG1vZGUpOworICAgIHZvaWQgZGlkT3Bl bkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBXVEY6OlN0 cmluZyYgcm9vdFBhdGgsIGNvbnN0IFdURjo6U3RyaW5nJiBtb2RlKTsKKworcHJpdmF0ZToKKyAg ICBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtlckJhc2UqLCBXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCisg ICAgLy8gVGhpcyBtZXRob2QgaXMgdG8gYmUgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAg ICBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb3JlOjpTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiwgY29uc3QgV1RGOjpTdHJp bmcmIG1vZGUsIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlKik7CisKKyAgICBmcmllbmQgY2xhc3MgTWFpblRocmVhZEZp bGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICAvLyBNZXRob2RzIHRoYXQgZGlzcGF0Y2ggV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyBvbiB0aGUgd29ya2VyIHRocmVhZHMuCisgICAgLy8gVGhleSByZWxl YXNlIGEgc2VsZlJlZiBvZiB0aGUgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS4KKyAg ICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqLCBXZWJGaWxlRXJy b3IpOworICAgIHN0YXRpYyB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2UqLCBjb25zdCBXVEY6OlN0cmluZyYgbmFtZSwgY29uc3QgV1RGOjpTdHJpbmcmIHJvb3RQ YXRoKTsKKworICAgIC8vIG1fc2VsZlJlZiBrZWVwcyBhIHJlZmVyZW5jZSB0byBpdHNlbGYgdW50 aWwgY2FsbGJhY2tzIGFyZSBmaXJlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICBSZWZQdHI8 V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gbV9zZWxmUmVmOworCisgICAgUmVmUHRy PFRocmVhZGFibGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyPiBtX2JyaWRnZVdyYXBwZXI7CisgICAg V2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9j YWxsYmFja3NPbldvcmtlckNvbnRleHQ7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gK 68328 2010-09-21 19:34:57 -0700 2010-09-21 19:36:32 -0700 Patch bug-45808-20100921193456.patch text/plain 46149 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uN2FjODE4Zjc2OTA5M2Ez NmRmMDA5NDNkY2YyYWJkNjRjOGJiNWY3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMSAgRGlyayBTY2h1bHpl ICA8a3JpdEB3ZWJraXQub3JnPgogCiAgICAgICAgIFNWRyBGaWx0ZXIgY2xlYW51cApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3Bw IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmlu ZGV4IGExNWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNj ZmY3Mjc4Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRp bmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tl dC5oIgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEg QEAgYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQg PSBmYWxzZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRG ZWF0dXJlczo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYK IAogI2lmIEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUx ZGM0MjBkNmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmgKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMu aApAQCAtMTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNG aWxlU3lzdGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7 CiAgICAgc3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsg aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVl c3RGaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlm MWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2Li4xNGM2MmM4OTU2NzJiZGZmNzcyZGY5YjJjYzlmNjFl MjVmZDRkNTIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNw cAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAs MzAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3Rl bT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK0xvY2Fs RmlsZVN5c3RlbSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNl UGF0aCkKK3sKKyAgICAvLyBGSVhNRTogU2hvdWxkIGluaXRpYWxpemUgdGhlIHF1b3RhIHNldHRp bmdzIGFzIHdlbGwuCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNf aW5zdGFuY2UpOworICAgIGlmIChzX2luc3RhbmNlKQorICAgICAgICByZXR1cm47CisKKyAgICBP d25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3Rl bS5sZWFrUHRyKCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQoreworICAgIC8vIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBi ZSBjYWxsZWQgcHJpb3IgY2FsbGluZyB0aGlzLgorICAgIEFTU0VSVChzX2luc3RhbmNlKTsKKyAg ICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVT eXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9iYXNlUGF0aC50aHJlYWRzYWZlQ29w eSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBB c3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0cjxGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OSw3IEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1 ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAg ICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxs YmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5 bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0 YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKKyAgICBjb250ZXh0LT5wb3N0VGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgo KSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUs IG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywg Y29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u aAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJlYTY4Y2Q1MjNkYmI2Li44M2ZlZjlk NjNjNjViM2U5OWU4M2I3ZWRlMDYyMjk3ZDI0OGFlNjA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Zp bGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJyb3JDYWxsYmFjazsKIGNsYXNzIEZp bGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAKLWNsYXNz IExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsRmlsZVN5c3RlbT4gewor Ly8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5kIHByb3ZpZGVzIGFuIGVudHJ5IHBv aW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCk7Ci0gICAgdmlydHVhbCB+TG9j YWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBhIHBlci1wcm9jZXNzIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRoYXQgTG9jYWxGaWxlU3lzdGVtOjpp bml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIGJlZm9yZQorICAgIC8vIGNh bGxpbmcgdGhpcyBvbmUuCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSYgbG9jYWxGaWxlU3lz dGVtKCk7CiAKICAgICB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZp bGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOwogCi1wcm90ZWN0 ZWQ6CisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorICAgIC8vIFRoaXMgaXMgbm90IHRocmVhZC1z YWZlOyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVhdGVk LgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsKKwor ICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2YXRl OgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAgICA6 IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAorICAgIHN0YXRpYyBMb2NhbEZp bGVTeXN0ZW0qIHNfaW5zdGFuY2U7CisKKyAgICAvLyBUaGUgbWVtYmVyIG1ldGhvZHMgc2hvdWxk bid0IGFjY2VzcyB0aGlzIFN0cmluZyBkaXJlY3RseSBidXQgc2hvdWxkIHVzZQorICAgIC8vIGZp bGVTeXN0ZW1CYXNlUGF0aCgpIGluc3RlYWQuCiAgICAgU3RyaW5nIG1fYmFzZVBhdGg7CiB9Owog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuY3BwCmluZGV4IGY1YmEyNWMzNmE5YWQyYzdmZDE2NTlhNWI1ZDNkMDZkODdiYTVj NDYuLjZhMjAzY2M3YzQ5MmVjMzNhYmUwMDI5MmUzYTA0OGQ4YTJhYzM0MWQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cu Y3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0 ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlm ICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0 ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAg ICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7 Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBl cnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUg cXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0 aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0g PSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vz c0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNr KGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIp KTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1 ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBl Pih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKKyAgICBMb2Nh bEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50 LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNz Q2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1f bWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0g aW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworQ09NUElM RV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlBFUlNJU1RFTlQpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNt YXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93Lmgg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZi MjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAz YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg Y2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3Rv clRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExv Y2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAt NDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9E QVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5 OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxG aWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFy Z2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCA0Nzg5 ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2JkM2E2Yjc2 NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIxLDYgKzEy MSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNvbnN0IHsg cmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3JkTWFuYWdl cigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nlc3NGaWxl U3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRlY2huaWNh bGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFnZSwgYnV0 IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Npb25TdG9y YWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFjMGE1ZjQ5NjhkYjZhNGFhMWQ3 OTQ2ZmViZGQzZWY2OTUxNDdhNS4uNGQxNjYyYjYzNmE5ODE0MTY4YjZlNTg4NDhhNTcwYjZiNjU5 MTYyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTcsMTEgKzQ5Nyw2IEBAIHZvaWQgU2V0dGluZ3M6OnNl dExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2Nh bFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxl U3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJv b3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVN b2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKaW5kZXggOTlhNGYyMzJjNTI5ODA2ZWFhMjdmODVkNTdkYmJhYjEyNzQ0YmYzMy4uZjhh Mjk3YTE3YjA1NTY5ZDg1ZmM3YjExMGM0NjU2ZjQ0NzQwNzY0YSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTI0MSw5 ICsyNDEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0 YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3Qg U3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29u c3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFw cGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hy b21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApA QCAtMzM2LDcgKzMzMyw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1f ZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRl bXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwot ICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2Vy U3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRG YW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEzODVjMTNh NmNlYmI2OWZjN2FmLi43NzgyOGZmMTNjYTI3Zjg3NWIzMTVlYzg2YmU4NjIxZDJjNTNkMGU2IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zNCwxMyArMzQsMjEgQEAKICNp ZiBFTkFCTEUoRklMRV9TWVNURU0pCiAKICNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MuaCIKKyNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogI2luY2x1ZGUgIkZpbGVTeXN0ZW0u aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9v bCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgp OworICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFz eW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYpCiB7Ci0gICAgLy8gRklYTUU6IHJl dHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1lbnRhdGlvbi4KKyAgICBub3RJbXBs ZW1lbnRlZCgpOwogICAgIHJldHVybiAwOwogfQogCkBAIC02Miw2ICs3MCw3IEBAIHZvaWQgQXN5 bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25z dCBTdHJpbmcmIHN0b3JhCiAKICAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUs IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHJvb3RQYXRoKSk7CiB9CisjZW5kaWYKIAogLy8gRGVm YXVsdCBpbXBsZW1lbnRhdGlvbi4KIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW06OnZpcnR1YWxUb1Bs YXRmb3JtUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVT eXN0ZW0uaAppbmRleCA2MDFmMGVhZTNlNWQwZThiZWI4NGQ1YTk5M2Q3NzA1MTdiZDBhNjJkLi44 YzRkNWQ5OTBmZGE0NmMyYjc4MGRmOWIwOWE2MDc3ZTU0ZDlmZjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5 bmNGaWxlU3lzdGVtLmgKQEAgLTU2LDYgKzU2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBzdG9wKCkgeyB9CiAgICAgdmlydHVhbCBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIHsgcmV0 dXJuIGZhbHNlOyB9CiAKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgLy8g Q3JlYXRlcyBhbmQgcmV0dXJucyBhIG5ldyBwbGF0Zm9ybS1zcGVjaWZpYyBBc3luY0ZpbGVTeXN0 ZW0gaW5zdGFuY2UgaWYgdGhlIHBsYXRmb3JtIGhhcyBpdHMgb3duIGltcGxlbWVudGF0aW9uLgog ICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmlu ZyYgcm9vdFBhdGgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5kZXggYjUyYjI4NTQ3 NWYyZWY5NDc3ZTgxNGJiZTRkOGJlYjljM2I5ZWEwYS4uMzkwYWFiYTRkYWJiZDExYjZkM2RhOTM5 ZWRkMDJiNDBlNjc5ZTQ3NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtNjMsNiAr NjMsMTUgQEAKICNpbmNsdWRlICJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2luY2x1 ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiRmlsZVN5c3RlbUNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiTG9jYWxGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBDbG9zZVdvcmtlckNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2sgewpAQCAtMzM1LDYgKzM0NCw2NCBAQCB2b2lkIFdvcmtlckNvbnRleHQ6OnJldm9r ZUJsb2JVUkwoY29uc3QgU3RyaW5nJiBibG9iVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKKyNpZiBF TkFCTEUoRklMRV9TWVNURU0pCit2b2lkIFdvcmtlckNvbnRleHQ6OnJlcXVlc3RGaWxlU3lzdGVt KGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+ IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNr KQoreworICAgIGlmICghQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8ICFzZWN1cml0 eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3Rl bTo6c2NoZWR1bGVDYWxsYmFjayh0aGlzLCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0 ZShTRUNVUklUWV9FUlIpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIExvY2FsRmls ZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkucmVxdWVzdEZpbGVTeXN0ZW0odGhpcywgc3RhdGlj X2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNr LCBlcnJvckNhbGxiYWNrKTsKK30KKworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihX b3JrZXJDb250ZXh0OjpURU1QT1JBUlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lz dGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19j YXN0PGludD4oV29ya2VyQ29udGV4dDo6UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihB c3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpLCBlbnVtX21pc21hdGNoKTsKKyNlbmRpZgorCitX b3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6T2JzZXJ2ZXIoV29ya2VyQ29udGV4dCogY29udGV4dCkK KyAgICA6IG1fY29udGV4dChjb250ZXh0KQoreworICAgIEFTU0VSVChtX2NvbnRleHQpOworICAg IG1fY29udGV4dC0+cmVnaXN0ZXJPYnNlcnZlcih0aGlzKTsKK30KKworV29ya2VyQ29udGV4dDo6 T2JzZXJ2ZXI6On5PYnNlcnZlcigpCit7CisgICAgaWYgKG1fY29udGV4dCkgeworICAgICAgICBB U1NFUlQobV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIG1fY29udGV4dC0+ dW5yZWdpc3Rlck9ic2VydmVyKHRoaXMpOworICAgIH0KK30KKwordm9pZCBXb3JrZXJDb250ZXh0 OjpPYnNlcnZlcjo6c3RvcE9ic2VydmluZygpCit7CisgICAgaWYgKG1fY29udGV4dCkgeworICAg ICAgICBBU1NFUlQobV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIG1fY29u dGV4dCA9IDA7CisgICAgfQorfQorCit2b2lkIFdvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2 ZXIoT2JzZXJ2ZXIqIG9ic2VydmVyKQoreworICAgIEFTU0VSVChvYnNlcnZlcik7CisgICAgbV93 b3JrZXJPYnNlcnZlcnMuYWRkKG9ic2VydmVyKTsKK30KKwordm9pZCBXb3JrZXJDb250ZXh0Ojp1 bnJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIqIG9ic2VydmVyKQoreworICAgIEFTU0VSVChvYnNl cnZlcik7CisgICAgbV93b3JrZXJPYnNlcnZlcnMucmVtb3ZlKG9ic2VydmVyKTsKK30KKwordm9p ZCBXb3JrZXJDb250ZXh0Ojpub3RpZnlPYnNlcnZlcnNPZlN0b3AoKQoreworICAgIEFTU0VSVChp c0NvbnRleHRUaHJlYWQoKSk7CisgICAgSGFzaFNldDxPYnNlcnZlcio+OjppdGVyYXRvciBvYnNl cnZlcnNFbmQgPSBtX3dvcmtlck9ic2VydmVycy5lbmQoKTsKKyAgICBmb3IgKEhhc2hTZXQ8T2Jz ZXJ2ZXIqPjo6aXRlcmF0b3IgaXRlciA9IG1fd29ya2VyT2JzZXJ2ZXJzLmJlZ2luKCk7IGl0ZXIg IT0gb2JzZXJ2ZXJzRW5kOyArK2l0ZXIpCisgICAgICAgICgqaXRlciktPm5vdGlmeVN0b3AoKTsK K30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMp CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuaAppbmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBm YjVlNGQwYTE4MDNhLi45ZWJjNmU0Zjc5MzJmZTE5NzFhNjJkOWJmMWIxZGY3MjY5NDc1NGJmIDEw MDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUv d29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5o IgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4K ICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNp bmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNDcsMTEgKzQ4LDE1IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFzcyBEYXRhYmFzZUNhbGxiYWNr OwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsKKyAgICBjbGFzcyBET01GaWxlU3lzdGVtU3luYzsK KyAgICBjbGFzcyBFcnJvckNhbGxiYWNrOworICAgIGNsYXNzIEZpbGVTeXN0ZW1DYWxsYmFjazsK ICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9u OwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwogICAgIGNsYXNzIFdvcmtlck5hdmlnYXRvcjsK ICAgICBjbGFzcyBXb3JrZXJUaHJlYWQ7CisgICAgY2xhc3MgV29ya2VyV2Vha1JlZmVyZW5jZTsK IAogICAgIGNsYXNzIFdvcmtlckNvbnRleHQgOiBwdWJsaWMgUmVmQ291bnRlZDxXb3JrZXJDb250 ZXh0PiwgcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIHB1YmxpYyBFdmVudFRhcmdldCB7 CiAgICAgcHVibGljOgpAQCAtMTIxLDYgKzEyNiwxNSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmKTsKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFyZSBwbGFjZWQgaGVyZSBhbmQg aW4gYWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBpbGUtdGltZSBlbnVtIGNoZWNr aW5nLgorICAgICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAgICAgICAgICAgIFRFTVBPUkFS WSwKKyAgICAgICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07CisgICAgICAgIHZvaWQgcmVx dWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVT eXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOworI2VuZGlmCisKICAg ICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29y a2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29y a2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxO YXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpAQCAtMTMxLDYg KzE0NSwyMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgYm9vbCBpc0Nsb3Npbmco KSB7IHJldHVybiBtX2Nsb3Npbmc7IH0KIAorICAgICAgICAvLyBBbiBvYnNlcnZlciBpbnRlcmZh Y2UgdG8gYmUgbm90aWZpZWQgd2hlbiB0aGUgd29ya2VyIHRocmVhZCBpcyBnZXR0aW5nIHN0b3Bw ZWQuCisgICAgICAgIGNsYXNzIE9ic2VydmVyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICAg ICAgcHVibGljOgorICAgICAgICAgICAgT2JzZXJ2ZXIoV29ya2VyQ29udGV4dCopOworICAgICAg ICAgICAgdmlydHVhbCB+T2JzZXJ2ZXIoKTsKKyAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBub3Rp ZnlTdG9wKCkgPSAwOworICAgICAgICAgICAgdm9pZCBzdG9wT2JzZXJ2aW5nKCk7CisgICAgICAg IHByaXZhdGU6CisgICAgICAgICAgICBXb3JrZXJDb250ZXh0KiBtX2NvbnRleHQ7CisgICAgICAg IH07CisgICAgICAgIHZvaWQgcmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZlciopOworICAgICAgICB2 b2lkIHVucmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZlciopOworICAgICAgICB2b2lkIG5vdGlmeU9i c2VydmVyc09mU3RvcCgpOworCiAgICAgcHJvdGVjdGVkOgogICAgICAgICBXb3JrZXJDb250ZXh0 KGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLCBXb3JrZXJUaHJlYWQqKTsKIApAQCAtMTYxLDYg KzE4OSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgYm9vbCBtX2Nsb3Npbmc7CiAg ICAgICAgIGJvb2wgbV9yZXBvcnRpbmdFeGNlcHRpb247CiAgICAgICAgIEV2ZW50VGFyZ2V0RGF0 YSBtX2V2ZW50VGFyZ2V0RGF0YTsKKworICAgICAgICBIYXNoU2V0PE9ic2VydmVyKj4gbV93b3Jr ZXJPYnNlcnZlcnM7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsIGIvV2ViQ29yZS93b3JrZXJzL1dv cmtlckNvbnRleHQuaWRsCmluZGV4IDAyYWE0YWRiODhiYzJkZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2 NzgxMjQuLjNlMTg1YzBkNWI4ZTBhMTM3YmQ5MjhjNTJhMmRiYTgxNzVmODAzMzcgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAorKysgYi9XZWJDb3JlL3dvcmtl cnMvV29ya2VyQ29udGV4dC5pZGwKQEAgLTEwNCw2ICsxMDQsMTQgQEAgbW9kdWxlIHRocmVhZHMg ewogICAgICAgICBET01TdHJpbmcgY3JlYXRlQmxvYlVSTChpbiBCbG9iIGJsb2IpOwogICAgICAg ICB2b2lkIHJldm9rZUJsb2JVUkwoaW4gRE9NU3RyaW5nIGJsb2JVUkwpOwogI2VuZGlmCisKKyNp ZiBkZWZpbmVkKEVOQUJMRV9GSUxFX1NZU1RFTSkgJiYgRU5BQkxFX0ZJTEVfU1lTVEVNCisgICAg ICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFRFTVBPUkFSWSA9IDA7CisgICAgICAgIGNvbnN0IHVu c2lnbmVkIHNob3J0IFBFUlNJU1RFTlQgPSAxOworICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0g dm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxv bmcgc2l6ZSwgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nl c3NDYWxsYmFjaywgaW4gW0NhbGxiYWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNh bGxiYWNrKTsKKworICAgICAgICAgICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1bnRpbWU9 RmlsZVN5c3RlbV0gRmxhZ3NDb25zdHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07CiAKIH0K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwIGIvV2ViQ29yZS93 b3JrZXJzL1dvcmtlclRocmVhZC5jcHAKaW5kZXggZDZhMWUwNTdkM2VkODE4YTM3OGU3NTM2NjY5 ZjNhMGE3Yjk0NTdmZS4uZjYxMTIwZWVlMDRjMzFhODAwZmY1NjI5YWY5YTJiODBhNDY3YTNjNCAx MDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAKKysrIGIvV2ViQ29y ZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAKQEAgLTIwMiw2ICsyMDIsOCBAQCBwdWJsaWM6CiAK ICAgICAgICAgd29ya2VyQ29udGV4dC0+c3RvcEFjdGl2ZURPTU9iamVjdHMoKTsKIAorICAgICAg ICB3b3JrZXJDb250ZXh0LT5ub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgICAgICAvLyBF dmVudCBsaXN0ZW5lcnMgd291bGQga2VlcCBET01XcmFwcGVyV29ybGQgb2JqZWN0cyBhbGl2ZSBm b3IgdG9vIGxvbmcuIEFsc28sIHRoZXkgaGF2ZSByZWZlcmVuY2VzIHRvIEpTIG9iamVjdHMsCiAg ICAgICAgIC8vIHdoaWNoIGJlY29tZSBkYW5nbGluZyBvbmNlIEhlYXAgaXMgZGVzdHJveWVkLgog ICAgICAgICB3b3JrZXJDb250ZXh0LT5yZW1vdmVBbGxFdmVudExpc3RlbmVycygpOwpkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cKaW5kZXggNTZmMmM1YTU5ZWVhM2I3YjgwOTkwYjU4YjgwODYzYjJjMTEwZGE3Ni4uOThlNTAy MGJkODJhZDZlNjAwZmExOThlYjIxZmI0NmJkN2U3NmQ3MSAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMzUgQEAKKzIwMTAtMDktMTcgIEtpbnVrbyBZYXN1ZGEgIDxraW51a29AY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBX b3JrZXIgc3VwcG9ydCBmb3IgRmlsZVN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1ODA4CisKKyAgICAgICAgQWRkZWQgV2ViV29ya2Vy QmFzZTo6b3BlbkZpbGVTeXN0ZW0gYW5kIFdlYkNvbW1vbldvcmtlckNsaWVudDo6CisgICAgICAg IG9wZW5GaWxlU3lzdGVtIHRvIGNhbGwgaW4gdG8gdGhlIGJyb3dzZXIgdmlhIFdvcmtlciBzdHVi L3Byb3h5CisgICAgICAgIGluIHRoZSBjaHJvbWl1bS4KKworICAgICAgICBBbHNvIGFkZGVkIFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UgY2xhc3MgdGhhdCBwcm94aWVzCisgICAgICAg IHJlcXVlc3RzIGFuZCBjYWxsYmFja3MgYmV0d2VlbiBmcm9tL3RvIHdvcmtlciB0aHJlYWQgdG8v ZnJvbSB0aGUKKyAgICAgICAgbWFpbiB0aHJlYWQuCisKKyAgICAgICAgKiBwdWJsaWMvV2ViQ29t bW9uV29ya2VyQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYkNvbW1vbldvcmtlckNsaWVu dDo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBzcmMvTG9jYWxGaWxlU3lzdGVt Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZp bGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCBpbXBsZW1lbnRhdGlvbgorICAgICAgICBmb3Igd29ya2Vy cy4gSW4gd29ya2VyIGNhc2UgdGhpcyBjYWxscyBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3Rl bS4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5jcHA6CisgICAgICAgIChXZWJLaXQ6Oldl YldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuIFRoaXMgaXMgY2FsbGVkIGZyb20K KyAgICAgICAgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSBvbiB0aGUgd29ya2Vy IHRocmVhZCBhbmQgY3JlYXRlcworICAgICAgICBhIGJyaWRnZSB0byBjYWxsIFdlYkNvbW1vbldv cmtlckNsaWVudDo6b3BlbkZpbGVTeXN0ZW0gb24gdGhlIG1haW4KKyAgICAgICAgdGhyZWFkLgor ICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNs aWVudEltcGwuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZp bGVTeXN0ZW0pOiBBZGRlZC4KKyAgICAgICAgKiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZS5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlLmg6IEFkZGVkLgorCiAyMDEwLTA5LTIwICBQaGlsaXBwZSBOb3JtYW5kICA8cG5v cm1hbmRAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIENhcmxzb24uCmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cCBiL1dlYktpdC9jaHJvbWl1bS9X ZWJLaXQuZ3lwCmluZGV4IDM1MjNmMjFhMWIxNDg1N2ExYzQ1Y2NiNmIzZjM4YjEwZmQxMjZhY2Mu Ljg3NGQ0ODU4ZmIxYWE0OWE1YjczYzJmNDBiNzk2ZjExYTkyMjM2MDIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CkBAIC01MzMsNiArNTMzLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYldvcmtlckNsaWVu dEltcGwuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmNwcCcsCiAgICAg ICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmgnLAorICAgICAgICAgICAgICAgICdzcmMv V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAnLAorICAgICAgICAgICAgICAgICdz cmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oJywKICAgICAgICAgICAgICAgICAn c3JjL1dyYXBwZWRSZXNvdXJjZVJlcXVlc3QuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XcmFw cGVkUmVzb3VyY2VSZXNwb25zZS5oJywKICAgICAgICAgICAgICAgICAnc3JjL3dpbi9XZWJJbnB1 dEV2ZW50RmFjdG9yeS5jcHAnLApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9u V29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUwMzI4NTA4OTBkYzg0NTUyYzQxNjQ0 ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5NmEyZGNkNmQyMCAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAorKysgYi9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCkBAIC0zMSw2ICsz MSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAjZGVmaW5lIFdlYkNvbW1v bldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21tb24uaCIKKyNpbmNsdWRlICJXZWJG aWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJBcHBsaWNhdGlv bkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1YmxpYzoKICAgICAvLyBDYWxsZWQgb24g dGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIHdlYiBkYXRhYmFzZS4KICAg ICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYg bmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0 ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBi ZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZpcnR1YWwgdm9pZCBvcGVuRmlsZVN5 c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNh bGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIHN0dWIgaW1wbGVt ZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVtZW50IHRoaXMuCisgICAg ICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKIHByb3RlY3RlZDoKICAg ICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2No cm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hyb21pdW0v c3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCAwOGZjZWE2Yzk4NWFjMzIxZDI5 MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMxYjY1YzdmYzE1ZjlhMzUzY2ZjNTFh NjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNo cm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9t aXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitib29s IEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIHJldHVybiB0cnVlOworfQor CiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0oY29uc3Qg U3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5c3RlbShyb290UGF0aCkKICAgICAs IG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVudCgpLT5maWxlU3lzdGVtKCkpCmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmluZGV4 IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIwZjI1YjIuLjk5NGYzMTA0NmIzZGQ3 NTc1YWEwMTllNmUxODk5YmFmZjE5MDkzMTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv TG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00MiwxNCArNDIsMTkgQEAKICNpbmNsdWRl ICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50 LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5jbHVkZSAiV2ViV29ya2VySW1wbC5o IgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJUaHJlYWQuaCIK KyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IExvY2Fs RmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0aCkKK0xvY2FsRmlsZVN5c3RlbSYg TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogewotICAgIHJldHVybiBhZG9wdFJl ZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBBdG9taWNhbGx5SW5pdGlhbGl6ZWRT dGF0aWMoTG9jYWxGaWxlU3lzdGVtKiwgbG9jYWxGaWxlU3lzdGVtID0gbmV3IExvY2FsRmlsZVN5 c3RlbSgiIikpOworICAgIHJldHVybiAqbG9jYWxGaWxlU3lzdGVtOwogfQogCiB2b2lkIExvY2Fs RmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVm UHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVycm9y Q2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2NSwxMCBAQCB2b2lkIExvY2FsRmls ZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4 dCwgQXN5bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBs Ojpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAgICAgICB3ZWJGcmFtZS0+Y2xpZW50 KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5ldyBGaWxl U3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkp KTsKICAgICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTogQWRkIGltcGxlbWVudGF0aW9uIGZv ciB3b3JrZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGlj X2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAgICAgICBXb3JrZXJMb2FkZXJQcm94 eSogd29ya2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4dC0+dGhyZWFkKCktPndvcmtlckxv YWRlclByb3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2UqIHdlYldvcmtlciA9IHN0YXRpY19j YXN0PFdlYldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94eSk7CisgICAgICAgIHdlYldvcmtl ci0+b3BlbkZpbGVTeXN0ZW0oc3RhdGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSks IHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxi YWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfQog fQogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCA0MmY0MWQyZGM3OWI0 ZTNlNDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi42MjdjMWE1MmY5YmU4ZmQ5ZWRjYjQwYTIyMGFh YWZlZDQ1NzgxNTRkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTM3 LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogCiAj aW5jbHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIK ICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgog I2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpAQCAtNDUsNiArNDYsOCBAQAogI2lu Y2x1ZGUgIldlYlZpZXcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJDbGllbnQuaCIKIAorI2luY2x1 ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUg IldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CkBAIC01Niw2ICs1 OSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJMRShXT1JLRVJTKQogCiBzdGF0aWMg Y29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFsbG93RGF0YWJhc2VNb2RlIjsKK3N0 YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtdID0gIm9wZW5GaWxlU3lzdGVtTW9k ZSI7CiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2ICsxMTgsNyBAQCBwcml2YXRlOgogICAgIFdl YldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5nIG1fbW9kZTsKIH07CisKIH0K IAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkIHRvIGZvcmNl IHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2ICsyMzYsMTYgQEAgYm9vbCBXZWJX b3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1l LCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQoKTsKIH0KIAordm9pZCBX ZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxv bmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCit7CisgICAg V29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhyZWFkLT5ydW5Mb29wKCk7CisgICAg V29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9IFdvcmtlclNjcmlwdENvbnRyb2xs ZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29u dGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsKKworICAgIFJlZlB0cjxXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UgPSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlOjpjcmVhdGUodGhpcywgd29ya2VyQ29udGV4dCwgY2FsbGJhY2tzKTsKKyAgICBi cmlkZ2UtPnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb21tb25DbGllbnQoKSwgdHlw ZSwgc2l6ZSwgb3BlbkZpbGVTeXN0ZW1Nb2RlKTsKK30KKwogLy8gV29ya2VyT2JqZWN0UHJveHkg LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2VyT2JqZWN0KFBhc3NS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0tZ2l0IGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRlYjAyMmM4NWM0YzMyN2Q2ZTMxMmIz Li42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMxZDk2YWNiIDEwMDY0NAotLS0gYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgLy8gQ29u dHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBpcyBhbGxvd2VkIGZvciB0aGlz IHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0 IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQg bG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVlc3RzIHRvIG9wZW4gYSBmaWxlIHN5 c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhpcyBpcyBub3QgdGhlIGltcGxlbWVu dGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVTeXN0ZW0uKQorICAgIHZvaWQgb3Bl bkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVT eXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVzIHRoZSBnaXZlbiB0YXNrIG9uIHRo ZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNwYXRjaFRhc2tUb01haW5UaHJlYWQo UGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7CiAKZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5kZXggNzQxZDYwNjQwNjk2 MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgyMzVkYmYyOGZjOWVmZjM0YTJhZWZk YTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJD bGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBs LmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShXT1JLRVJTKQogCisjaW5jbHVkZSAi V2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgotCiAjaW5jbHVk ZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KICNp bmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6CiAgICAgICAg IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CisgICAg dmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3RlbTo6VHlw ZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKQorICAgIHsKKyAgICAg ICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBwcml2YXRlOgogICAgIHZpcnR1YWwg fldlYldvcmtlckNsaWVudEltcGwoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA1MzA2MWM4 NTk1YjhmMGY3ZjJiZWY0NjZhZjM2ZTc3ZmViNGZhZjEKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwCkBAIC0w LDAgKzEsMjQ2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBt ZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUg b2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0 aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJT IEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09Q WVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICog REFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2UuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1 ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIldlYkNvbW1vbldvcmtlckNsaWVudC5o IgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKKyNpbmNsdWRlICJXZWJTdHJp bmcuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJCYXNlLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4 dC5oIgorI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRlICJXb3Jr ZXJUaHJlYWQuaCIKKyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorI2luY2x1ZGUgPHd0Zi9U aHJlYWRpbmcuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBXZWJL aXQgeworCisvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQgYXJlIHRvIGJlIGRpc3BhdGNoZWQg b24gdGhlIG1haW4gdGhyZWFkLgorY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3Mg OiBwdWJsaWMgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NPd25QdHI8TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNyZWF0ZShQYXNzUmVmUHRy PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBt b2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrcyhicmlkZ2UsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIH5NYWlu VGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcygpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwg dm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0 cmluZyYgcGF0aCkKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRPcGVuRmlsZVN5c3RlbU9u TWFpblRocmVhZChuYW1lLCBwYXRoLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJyb3IgZXJyb3IpCisgICAg eworICAgICAgICBtX2JyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvciwgbV9tb2RlKTsK KyAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2Nl ZWQoKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgV2ViRmlsZUluZm8mIGlu Zm8pCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9yPFdlYkZp bGVTeXN0ZW1FbnRyeT4mIGVudHJpZXMsIGJvb2wgaGFzTW9yZSkKKyAgICB7CisgICAgICAgIFdF QktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTWFpblRo cmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlPiBicmlkZ2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICAgICAgOiBtX2JyaWRn ZShicmlkZ2UpCisgICAgICAgICwgbV9tb2RlKG1vZGUpCisgICAgeworICAgICAgICBBU1NFUlQo bV9icmlkZ2UuZ2V0KCkpOworICAgIH0KKworICAgIGZyaWVuZCBjbGFzcyBXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlOworICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlPiBtX2JyaWRnZTsKKyAgICBjb25zdCBTdHJpbmcgbV9tb2RlOworfTsKKworV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICA6 IFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyKHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihzY3Jp cHRFeGVjdXRpb25Db250ZXh0KSkKKyAgICAsIG1fd29ya2VyKHdvcmtlcikKKyAgICAsIG1fY2Fs bGJhY2tzT25Xb3JrZXJDb250ZXh0KGNhbGxiYWNrcykKK3sKK30KKworV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZTo6fldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UoKQorewor ICAgIEFTU0VSVCghbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQpOworfQorCit2b2lkIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnN0b3AoKQoreworICAgIE11dGV4TG9ja2VyIGxv Y2tlcihtX211dGV4KTsKKyAgICBtX3dvcmtlciA9IDA7CisgICAgc3RvcE9ic2VydmluZygpOwor CisgICAgaWYgKG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSB7CisgICAgICAgIG1fY2FsbGJh Y2tzT25Xb3JrZXJDb250ZXh0LT5kaWRGYWlsKFdlYkZpbGVFcnJvckFib3J0KTsKKyAgICAgICAg bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOworICAgIH0KK30KKwordm9pZCBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQo V2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUg dHlwZSwgbG9uZyBsb25nIHNpemUsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZS ZWYgPSB0aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7CisgICAgbV93b3JrZXItPmRpc3BhdGNo VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtT25NYWlu VGhyZWFkLCBjb21tb25DbGllbnQsIHR5cGUsIHNpemUsIHRoaXMsIG1vZGUpKTsKK30KKwordm9p ZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0TW92ZU9uTWFpblRocmVhZChX ZWJGaWxlU3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHNyY1BhdGgsIGNvbnN0IFN0 cmluZyYgZGVzdFBhdGgsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0 aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1Rv TWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVPbk1haW5UaHJlYWQsIGZpbGVTeXN0 ZW0sIHNyY1BhdGgsIGRlc3RQYXRoLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdENvcHlPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3Rl bSogZmlsZVN5c3RlbSwgY29uc3QgU3RyaW5nJiBzcmNQYXRoLCBjb25zdCBTdHJpbmcmIGRlc3RQ YXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhpczsKKyAgICBB U1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQo Y3JlYXRlQ2FsbGJhY2tUYXNrKCZjb3B5T25NYWluVGhyZWFkLCBmaWxlU3lzdGVtLCBzcmNQYXRo LCBkZXN0UGF0aCwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2U6OnBvc3RSZW1vdmVPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3RlbSogZmlsZVN5 c3RlbSwgY29uc3QgU3RyaW5nJiBwYXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9z ZWxmUmVmID0gdGhpczsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZW1vdmVPbk1haW5UaHJl YWQsIGZpbGVTeXN0ZW0sIHBhdGgsIHRoaXMsIG1vZGUpKTsKK30KKwordm9pZCBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0UmVhZE1ldGFkYXRhT25NYWluVGhyZWFkKFdlYkZp bGVTeXN0ZW0qIGZpbGVTeXN0ZW0sIGNvbnN0IFN0cmluZyYgcGF0aCwgY29uc3QgU3RyaW5nJiBt b2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRoaXM7CisgICAgQVNTRVJUKG1fd29ya2VyKTsKKyAg ICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygm cmVhZE1ldGFkYXRhT25NYWluVGhyZWFkLCBmaWxlU3lzdGVtLCBwYXRoLCB0aGlzLCBtb2RlKSk7 Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdENyZWF0ZUZp bGVPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3RlbSogZmlsZVN5c3RlbSwgY29uc3QgU3RyaW5nJiBw YXRoLCBib29sIGV4Y2x1c2l2ZSwgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJl ZiA9IHRoaXM7CisgICAgQVNTRVJUKG1fd29ya2VyKTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hU YXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlRmlsZU9uTWFpblRocmVh ZCwgZmlsZVN5c3RlbSwgcGF0aCwgZXhjbHVzaXZlLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQg V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdENyZWF0ZURpcmVjdG9yeU9uTWFp blRocmVhZChXZWJGaWxlU3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHBhdGgsIGJv b2wgZXhjbHVzaXZlLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhp czsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZjcmVhdGVEaXJlY3RvcnlPbk1haW5UaHJlYWQs IGZpbGVTeXN0ZW0sIHBhdGgsIGV4Y2x1c2l2ZSwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnBvc3RGaWxlRXhpc3RzT25NYWluVGhyZWFk KFdlYkZpbGVTeXN0ZW0qIGZpbGVTeXN0ZW0sIGNvbnN0IFN0cmluZyYgcGF0aCwgY29uc3QgU3Ry aW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRoaXM7CisgICAgQVNTRVJUKG1fd29ya2Vy KTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNr VGFzaygmZmlsZUV4aXN0c09uTWFpblRocmVhZCwgZmlsZVN5c3RlbSwgcGF0aCwgdGhpcywgbW9k ZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnBvc3REaXJl Y3RvcnlFeGlzdHNPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3RlbSogZmlsZVN5c3RlbSwgY29uc3Qg U3RyaW5nJiBwYXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhp czsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaXJlY3RvcnlFeGlzdHNPbk1haW5UaHJlYWQs IGZpbGVTeXN0ZW0sIHBhdGgsIHRoaXMsIG1vZGUpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0UmVhZERpcmVjdG9yeU9uTWFpblRocmVhZChXZWJGaWxl U3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHBhdGgsIGNvbnN0IFN0cmluZyYgbW9k ZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7CisgICAg bV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJl YWREaXJlY3RvcnlPbk1haW5UaHJlYWQsIGZpbGVTeXN0ZW0sIHBhdGgsIHRoaXMsIG1vZGUpKTsK K30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpvcGVuRmlsZVN5c3Rl bU9uTWFpblRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViQ29tbW9uV29ya2VyQ2xp ZW50KiBjb21tb25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNp emUsIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3QgU3RyaW5n JiBtb2RlKQoreworICAgIGlmICghY29tbW9uQ2xpZW50KQorICAgICAgICBicmlkZ2UtPmRpZEZh aWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQsIG1vZGUpOworICAgIGVsc2UgeworICAg ICAgICAvLyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBpcyBzZWxmLWRlc3RydWN0ZWQs IHNvIHdlIGxlYWsgcHRyIGhlcmUuCisgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZpbGVTeXN0 ZW0odHlwZSwgc2l6ZSwgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6OmNyZWF0ZShicmlk Z2UsIG1vZGUpLmxlYWtQdHIoKSk7CisgICAgfQorfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1D YWxsYmFja3NCcmlkZ2U6OmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yIGVycm9yLCBj b25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbWF5UG9zdFRhc2tUb1dvcmtlcihjcmVhdGVDYWxs YmFja1Rhc2soJmRpZEZhaWxPbldvcmtlclRocmVhZCwgdGhpcywgZXJyb3IpLCBtb2RlKTsKK30K Kwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRPcGVuRmlsZVN5c3Rl bU9uTWFpblRocmVhZChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgs IGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtYXlQb3N0VGFza1RvV29ya2VyKGNyZWF0ZUNh bGxiYWNrVGFzaygmZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwgdGhpcywgbmFtZSwg cm9vdFBhdGgpLCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlOjpkaWRGYWlsT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgV2ViRmlsZUVycm9yIGVycm9yKQor eworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSB7CisgICAgICAg IGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRpZEZhaWwoZXJyb3IpOworICAg ICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0ID0gMDsKKyAgICB9CisgICAg YnJpZGdlLT5tX3NlbGZSZWYuY2xlYXIoKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlOjpkaWRPcGVuRmlsZVN5c3RlbU9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKiBicmlkZ2UsIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCkKK3sKKyAgICBpZiAoYnJp ZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dCkgeworICAgICAgICBicmlkZ2UtPm1fY2Fs bGJhY2tzT25Xb3JrZXJDb250ZXh0LT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCByb290UGF0aCk7 CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQgPSAwOworICAgIH0K KyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVhcigpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2U6Om1heVBvc3RUYXNrVG9Xb3JrZXIoUGFzc093blB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAg TXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIGlmIChtX3dvcmtlcikKKyAgICAgICAg bV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dCh0YXNrLCBtb2RlKTsKKyAg ICBlbHNlCisgICAgICAgIG1fc2VsZlJlZi5jbGVhcigpOworfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjNhMzI5NGNhZmE3NTEwYzliZmY2MzMxMGM4NGJmZDhlZmUwNmE3ZmUKLS0tIC9kZXYvbnVs bAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UuaApAQCAtMCwwICsxLDExMSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVy IHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmli dXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg ZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZV9oCisjZGVmaW5lIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAorCisjaW5j bHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNs dWRlICJXZWJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNs dWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBNYWlu VGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKK2NsYXNzIFdlYkNvbW1vbldvcmtlckNsaWVudDsK K2NsYXNzIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3M7CitjbGFzcyBXZWJXb3JrZXJCYXNlOworCisv LyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcG9zdCBhIG9wZW5GaWxlU3lzdGVtIHJlcXVlc3QgdG8g dGhlIG1haW4gdGhyZWFkIGFuZCBnZXQgY2FsbGVkIGJhY2sgZm9yIHRoZSByZXF1ZXN0LiBUaGlz IG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKy8vCisvLyBBIHR5cGlj YWwgZmxvdyBmb3Igb3BlbkZpbGVTeXN0ZW0gd291bGQgbG9vayBsaWtlIHRoaXM6CisvLyBCcmlk Z2U6OnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCgpIG9uIFdvcmtlclRocmVhZAorLy8g IC0tPiBCcmlkZ2U6Om9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKCkgaXMgY2FsbGVkIG9uIE1h aW5UaHJlYWQKKy8vICAgICAgVGhpcyBtYWtlcyBhbiBJUEMgd2l0aCBhIE1haW5UaHJlYWRGaWxl U3lzdGVtQ2FsbGJhY2tzIGluc3RhbmNlCisvLyAgICAgW2FjdHVhbCBvcGVyYXRpb24gaXMgZG93 biBpbiB0aGUgYnJvd3Nlcl0KKy8vICAtLT4gTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6 OmRpZFh4eCBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gIC0tPiBCcmlkZ2U6OmRpZFh4eE9u TWFpblRocmVhZCBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gIC0tPiBCcmlkZ2U6OmRpZFh4 eE9uV29ya2VyVGhyZWFkIGlzIGNhbGxlZCBvbiBXb3JrZXJUaHJlYWQKKy8vICAgICAgVGhpcyBj YWxscyB0aGUgb3JpZ2luYWwgY2FsbGJhY2tzIChtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dCkg YW5kCisvLyAgICAgIHJlbGVhc2VzIGEgc2VsZi1yZWZlcmVuY2UgdG8gdGhlIGJyaWRnZS4KK2Ns YXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNo YXJlZDxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiwgcHVibGljIFdlYkNvcmU6Oldv cmtlckNvbnRleHQ6Ok9ic2VydmVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBjcmVhdGUoV2ViV29ya2VyQmFzZSogd29y a2VyLCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiB3b3JrZXJDb250ZXh0LCBXZWJG aWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCisgICAgeworICAgICAgICByZXR1cm4gV1RG OjphZG9wdFJlZihuZXcgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSh3b3JrZXIsIHdv cmtlckNvbnRleHQsIGNhbGxiYWNrcykpOworICAgIH0KKyAgICB+V29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZSgpOworICAgIHZvaWQgc3RvcCgpOworCisgICAgLy8gV29ya2VyQ29udGV4 dDo6T2JzZXJ2ZXIgbWV0aG9kLgorICAgIHZpcnR1YWwgdm9pZCBub3RpZnlTdG9wKCkKKyAgICB7 CisgICAgICAgIHN0b3AoKTsKKyAgICB9CisKKyAgICAvLyBNZXRob2QgdGhhdCBwb3N0cyBhbiBp bml0aWFsIHJlcXVlc3QgdGFzayB0byB0aGUgbWFpbiB0aHJlYWQuIEl0IGlzIHN1cHBvc2VkIHRv IGJlIGNhbGxlZCBpbW1lZGlhdGVseSBhZnRlciB0aGUgYnJpZGdlIGlzIGNvbnN0cnVjdGVkIChp dCBkb2Vzbid0IGNoZWNrIGlmIHRoZSBjb250ZXh0IGhhcyBiZWVuIHN0b3BwZWQgb3Igbm90KS4K KyAgICB2b2lkIHBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb21tb25Xb3JrZXJD bGllbnQqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgY29uc3QgU3RyaW5n JiBtb2RlKTsKKworICAgIC8vIENhbGxiYWNrIG1ldGhvZHMgdGhhdCBhcmUgY2FsbGVkIG9uIHRo ZSBtYWluIHRocmVhZC4KKyAgICB2b2lkIGRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9y LCBjb25zdCBTdHJpbmcmIG1vZGUpOworICAgIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5U aHJlYWQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBT dHJpbmcmIG1vZGUpOworCitwcml2YXRlOgorICAgIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2UoV2ViV29ya2VyQmFzZSosIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBX ZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKik7CisKKyAgICAvLyBNZXRob2QgdGhhdCBpcyB0byBiZSBj YWxsZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVt T25NYWluVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25X b3JrZXJDbGllbnQqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSosIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICBm cmllbmQgY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICAvLyBNZXRo b2RzIHRoYXQgZGlzcGF0Y2ggV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyBvbiB0aGUgd29ya2VyIHRo cmVhZHMuCisgICAgLy8gVGhleSByZWxlYXNlIGEgc2VsZlJlZiBvZiB0aGUgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJl YWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UqLCBXZWJGaWxlRXJyb3IpOworICAgIHN0YXRpYyB2b2lkIGRpZE9wZW5GaWxl U3lzdGVtT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IFN0cmluZyYgcm9vdFBhdGgpOworCisgICAgLy8gSGVscGVyIG1ldGhvZHMuCisgICAgdm9pZCBt YXlQb3N0VGFza1RvV29ya2VyKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzaz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICAvLyBtX3NlbGZSZWYga2Vl cHMgYSByZWZlcmVuY2UgdG8gaXRzZWxmIHVudGlsIGNhbGxiYWNrcyBhcmUgZmlyZWQgb24gdGhl IHdvcmtlciB0aHJlYWQuCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2U+IG1fc2VsZlJlZjsKKworICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV2ViV29ya2VyQmFzZSog bV93b3JrZXI7CisKKyAgICAvLyBOb3Qgb3duZWQuICBUaGV5IG11c3QgYmUgZmlyZWQgb24gdGhl IHdvcmtlciB0aHJlYWQuCisgICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9jYWxsYmFja3NP bldvcmtlckNvbnRleHQ7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAv LyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gK 68329 2010-09-21 19:36:36 -0700 2010-09-21 19:59:28 -0700 Patch bug-45808-20100921193635.patch text/plain 46124 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uN2FjODE4Zjc2OTA5M2Ez NmRmMDA5NDNkY2YyYWJkNjRjOGJiNWY3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMSAgRGlyayBTY2h1bHpl ICA8a3JpdEB3ZWJraXQub3JnPgogCiAgICAgICAgIFNWRyBGaWx0ZXIgY2xlYW51cApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3Bw IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmlu ZGV4IGExNWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNj ZmY3Mjc4Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRp bmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tl dC5oIgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEg QEAgYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQg PSBmYWxzZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRG ZWF0dXJlczo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYK IAogI2lmIEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUx ZGM0MjBkNmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmgKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMu aApAQCAtMTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNG aWxlU3lzdGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7 CiAgICAgc3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsg aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVl c3RGaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlm MWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2Li4xNGM2MmM4OTU2NzJiZGZmNzcyZGY5YjJjYzlmNjFl MjVmZDRkNTIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNw cAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAs MzAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3Rl bT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK0xvY2Fs RmlsZVN5c3RlbSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNl UGF0aCkKK3sKKyAgICAvLyBGSVhNRTogU2hvdWxkIGluaXRpYWxpemUgdGhlIHF1b3RhIHNldHRp bmdzIGFzIHdlbGwuCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNf aW5zdGFuY2UpOworICAgIGlmIChzX2luc3RhbmNlKQorICAgICAgICByZXR1cm47CisKKyAgICBP d25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3Rl bS5sZWFrUHRyKCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQoreworICAgIC8vIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBi ZSBjYWxsZWQgcHJpb3IgY2FsbGluZyB0aGlzLgorICAgIEFTU0VSVChzX2luc3RhbmNlKTsKKyAg ICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVT eXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9iYXNlUGF0aC50aHJlYWRzYWZlQ29w eSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBB c3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0cjxGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OSw3IEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1 ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAg ICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxs YmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5 bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0 YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKKyAgICBjb250ZXh0LT5wb3N0VGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgo KSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUs IG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywg Y29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u aAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJlYTY4Y2Q1MjNkYmI2Li44M2ZlZjlk NjNjNjViM2U5OWU4M2I3ZWRlMDYyMjk3ZDI0OGFlNjA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Zp bGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJyb3JDYWxsYmFjazsKIGNsYXNzIEZp bGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAKLWNsYXNz IExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsRmlsZVN5c3RlbT4gewor Ly8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5kIHByb3ZpZGVzIGFuIGVudHJ5IHBv aW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCk7Ci0gICAgdmlydHVhbCB+TG9j YWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBhIHBlci1wcm9jZXNzIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRoYXQgTG9jYWxGaWxlU3lzdGVtOjpp bml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIGJlZm9yZQorICAgIC8vIGNh bGxpbmcgdGhpcyBvbmUuCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSYgbG9jYWxGaWxlU3lz dGVtKCk7CiAKICAgICB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZp bGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOwogCi1wcm90ZWN0 ZWQ6CisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorICAgIC8vIFRoaXMgaXMgbm90IHRocmVhZC1z YWZlOyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVhdGVk LgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsKKwor ICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2YXRl OgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAgICA6 IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAorICAgIHN0YXRpYyBMb2NhbEZp bGVTeXN0ZW0qIHNfaW5zdGFuY2U7CisKKyAgICAvLyBUaGUgbWVtYmVyIG1ldGhvZHMgc2hvdWxk bid0IGFjY2VzcyB0aGlzIFN0cmluZyBkaXJlY3RseSBidXQgc2hvdWxkIHVzZQorICAgIC8vIGZp bGVTeXN0ZW1CYXNlUGF0aCgpIGluc3RlYWQuCiAgICAgU3RyaW5nIG1fYmFzZVBhdGg7CiB9Owog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuY3BwCmluZGV4IGY1YmEyNWMzNmE5YWQyYzdmZDE2NTlhNWI1ZDNkMDZkODdiYTVj NDYuLjZhMjAzY2M3YzQ5MmVjMzNhYmUwMDI5MmUzYTA0OGQ4YTJhYzM0MWQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cu Y3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0 ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlm ICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0 ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAg ICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7 Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBl cnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUg cXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0 aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0g PSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vz c0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNr KGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIp KTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1 ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBl Pih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKKyAgICBMb2Nh bEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50 LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNz Q2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1f bWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0g aW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworQ09NUElM RV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlBFUlNJU1RFTlQpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNt YXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93Lmgg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZi MjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAz YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg Y2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3Rv clRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExv Y2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAt NDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9E QVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5 OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxG aWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFy Z2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCA0Nzg5 ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2JkM2E2Yjc2 NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIxLDYgKzEy MSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNvbnN0IHsg cmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3JkTWFuYWdl cigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nlc3NGaWxl U3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRlY2huaWNh bGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFnZSwgYnV0 IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Npb25TdG9y YWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFjMGE1ZjQ5NjhkYjZhNGFhMWQ3 OTQ2ZmViZGQzZWY2OTUxNDdhNS4uNGQxNjYyYjYzNmE5ODE0MTY4YjZlNTg4NDhhNTcwYjZiNjU5 MTYyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTcsMTEgKzQ5Nyw2IEBAIHZvaWQgU2V0dGluZ3M6OnNl dExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2Nh bFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxl U3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJv b3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVN b2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKaW5kZXggOTlhNGYyMzJjNTI5ODA2ZWFhMjdmODVkNTdkYmJhYjEyNzQ0YmYzMy4uZjhh Mjk3YTE3YjA1NTY5ZDg1ZmM3YjExMGM0NjU2ZjQ0NzQwNzY0YSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTI0MSw5 ICsyNDEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0 YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3Qg U3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29u c3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFw cGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hy b21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApA QCAtMzM2LDcgKzMzMyw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1f ZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRl bXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwot ICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2Vy U3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRG YW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEzODVjMTNh NmNlYmI2OWZjN2FmLi41NzMwNWZmYzJiYTBjNGE0ZjNhNmUzZGU4ZjIxYWFlNDE5Zjg1ZTU5IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zNSwxMiArMzUsMjAgQEAKIAog I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgogI2luY2x1ZGUgIkZpbGVTeXN0 ZW0uaCIKKyNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFp bGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJuIGZhbHNlOworfQor CiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoY29u c3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1bHQgQXN5bmNGaWxlU3lz dGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVkKCk7CiAgICAgcmV0dXJuIDA7 CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lz dGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNh bGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUo cm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3Ry aW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYg cGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVt LmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1 ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5 YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lz dGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiAr NTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFs IGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRp YyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3 IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZv cm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMz YjllYTBhLi4zOTBhYWJhNGRhYmJkMTFiNmQzZGE5MzllZGQwMmI0MGU2NzllNDc3IDEwMDY0NAot LS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlm aWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2lu Y2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRl ICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNl bmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRh c2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0zMzUsNiArMzQ0 LDY0IEBAIHZvaWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJs b2JVUkxTdHJpbmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQg V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXpl LCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVm UHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVT eXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVT eXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMs IGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAg ICByZXR1cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0o KS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5 cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitD T01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkg PT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlz bWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQ RVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVu dCksIGVudW1fbWlzbWF0Y2gpOworI2VuZGlmCisKK1dvcmtlckNvbnRleHQ6Ok9ic2VydmVyOjpP YnNlcnZlcihXb3JrZXJDb250ZXh0KiBjb250ZXh0KQorICAgIDogbV9jb250ZXh0KGNvbnRleHQp Cit7CisgICAgQVNTRVJUKG1fY29udGV4dCk7CisgICAgbV9jb250ZXh0LT5yZWdpc3Rlck9ic2Vy dmVyKHRoaXMpOworfQorCitXb3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6fk9ic2VydmVyKCkKK3sK KyAgICBpZiAobV9jb250ZXh0KSB7CisgICAgICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4 dFRocmVhZCgpKTsKKyAgICAgICAgbV9jb250ZXh0LT51bnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7 CisgICAgfQorfQorCit2b2lkIFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyOjpzdG9wT2JzZXJ2aW5n KCkKK3sKKyAgICBpZiAobV9jb250ZXh0KSB7CisgICAgICAgIEFTU0VSVChtX2NvbnRleHQtPmlz Q29udGV4dFRocmVhZCgpKTsKKyAgICAgICAgbV9jb250ZXh0ID0gMDsKKyAgICB9Cit9CisKK3Zv aWQgV29ya2VyQ29udGV4dDo6cmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZlciogb2JzZXJ2ZXIpCit7 CisgICAgQVNTRVJUKG9ic2VydmVyKTsKKyAgICBtX3dvcmtlck9ic2VydmVycy5hZGQob2JzZXJ2 ZXIpOworfQorCit2b2lkIFdvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZl ciogb2JzZXJ2ZXIpCit7CisgICAgQVNTRVJUKG9ic2VydmVyKTsKKyAgICBtX3dvcmtlck9ic2Vy dmVycy5yZW1vdmUob2JzZXJ2ZXIpOworfQorCit2b2lkIFdvcmtlckNvbnRleHQ6Om5vdGlmeU9i c2VydmVyc09mU3RvcCgpCit7CisgICAgQVNTRVJUKGlzQ29udGV4dFRocmVhZCgpKTsKKyAgICBI YXNoU2V0PE9ic2VydmVyKj46Oml0ZXJhdG9yIG9ic2VydmVyc0VuZCA9IG1fd29ya2VyT2JzZXJ2 ZXJzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxPYnNlcnZlcio+OjppdGVyYXRvciBpdGVyID0g bV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsgaXRlciAhPSBvYnNlcnZlcnNFbmQ7ICsraXRlcikK KyAgICAgICAgKCppdGVyKS0+bm90aWZ5U3RvcCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoV09SS0VSUykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29y a2Vycy9Xb3JrZXJDb250ZXh0LmggYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCmlu ZGV4IDdmYjhiNDZmMzg3Y2MwNjg0MzFmZDMzNGRjMGZiNWU0ZDBhMTgwM2EuLjllYmM2ZTRmNzkz MmZlMTk3MWE2MmQ5YmYxYjFkZjcyNjk0NzU0YmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJDb250ZXh0LmgKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaApA QCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNp bmNsdWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4K ICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+ CkBAIC00NywxMSArNDgsMTUgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFi YXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5j OworICAgIGNsYXNzIERPTUZpbGVTeXN0ZW1TeW5jOworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7 CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNrOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNl bnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRp b247CiAgICAgY2xhc3MgV29ya2VyTmF2aWdhdG9yOwogICAgIGNsYXNzIFdvcmtlclRocmVhZDsK KyAgICBjbGFzcyBXb3JrZXJXZWFrUmVmZXJlbmNlOwogCiAgICAgY2xhc3MgV29ya2VyQ29udGV4 dCA6IHB1YmxpYyBSZWZDb3VudGVkPFdvcmtlckNvbnRleHQ+LCBwdWJsaWMgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCwgcHVibGljIEV2ZW50VGFyZ2V0IHsKICAgICBwdWJsaWM6CkBAIC0xMjEsNiAr MTI2LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJM KGNvbnN0IFN0cmluZyYpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAg ICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRv IGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5 c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVO VCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwg bG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0 cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFy ZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4o TWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAg ICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJu IG1fbmF2aWdhdG9yLmdldCgpOyB9CkBAIC0xMzEsNiArMTQ1LDIwIEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogICAgICAgICBib29sIGlzQ2xvc2luZygpIHsgcmV0dXJuIG1fY2xvc2luZzsgfQog CisgICAgICAgIC8vIEFuIG9ic2VydmVyIGludGVyZmFjZSB0byBiZSBub3RpZmllZCB3aGVuIHRo ZSB3b3JrZXIgdGhyZWFkIGlzIGdldHRpbmcgc3RvcHBlZC4KKyAgICAgICAgY2xhc3MgT2JzZXJ2 ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgICAgICBwdWJsaWM6CisgICAgICAgICAgICBP YnNlcnZlcihXb3JrZXJDb250ZXh0Kik7CisgICAgICAgICAgICB2aXJ0dWFsIH5PYnNlcnZlcigp OworICAgICAgICAgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKSA9IDA7CisgICAgICAgICAg ICB2b2lkIHN0b3BPYnNlcnZpbmcoKTsKKyAgICAgICAgcHJpdmF0ZToKKyAgICAgICAgICAgIFdv cmtlckNvbnRleHQqIG1fY29udGV4dDsKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZWdpc3Rl ck9ic2VydmVyKE9ic2VydmVyKik7CisgICAgICAgIHZvaWQgdW5yZWdpc3Rlck9ic2VydmVyKE9i c2VydmVyKik7CisgICAgICAgIHZvaWQgbm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCk7CisKICAgICBw cm90ZWN0ZWQ6CiAgICAgICAgIFdvcmtlckNvbnRleHQoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmlu ZyYsIFdvcmtlclRocmVhZCopOwogCkBAIC0xNjEsNiArMTg5LDggQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgICAgICBib29sIG1fY2xvc2luZzsKICAgICAgICAgYm9vbCBtX3JlcG9ydGluZ0V4 Y2VwdGlvbjsKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1fZXZlbnRUYXJnZXREYXRhOworCisg ICAgICAgIEhhc2hTZXQ8T2JzZXJ2ZXIqPiBtX3dvcmtlck9ic2VydmVyczsKICAgICB9OwogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJh YTRhZGI4OGJjMmRmNjdmMjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uM2UxODVjMGQ1YjhlMGExMzdi ZDkyOGM1MmEyZGJhODE3NWY4MDMzNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuaWRsCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAt MTA0LDYgKzEwNCwxNCBAQCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVh dGVCbG9iVVJMKGluIEJsb2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBE T01TdHJpbmcgYmxvYlVSTCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lT VEVNKSAmJiBFTkFCTEVfRklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQg VEVNUE9SQVJZID0gMDsKKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9 IDE7CisgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGlu IHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9w dGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ss IE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworCisgICAgICAgICAgICAg ICAgIGF0dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVj dG9yIEZsYWdzOworI2VuZGlmCiAgICAgfTsKIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlclRocmVhZC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcApp bmRleCBkNmExZTA1N2QzZWQ4MThhMzc4ZTc1MzY2NjlmM2EwYTdiOTQ1N2ZlLi5mNjExMjBlZWUw NGMzMWE4MDBmZjU2MjlhZjlhMmI4MGE0NjdhM2M0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyVGhyZWFkLmNwcAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNw cApAQCAtMjAyLDYgKzIwMiw4IEBAIHB1YmxpYzoKIAogICAgICAgICB3b3JrZXJDb250ZXh0LT5z dG9wQWN0aXZlRE9NT2JqZWN0cygpOwogCisgICAgICAgIHdvcmtlckNvbnRleHQtPm5vdGlmeU9i c2VydmVyc09mU3RvcCgpOworCiAgICAgICAgIC8vIEV2ZW50IGxpc3RlbmVycyB3b3VsZCBrZWVw IERPTVdyYXBwZXJXb3JsZCBvYmplY3RzIGFsaXZlIGZvciB0b28gbG9uZy4gQWxzbywgdGhleSBo YXZlIHJlZmVyZW5jZXMgdG8gSlMgb2JqZWN0cywKICAgICAgICAgLy8gd2hpY2ggYmVjb21lIGRh bmdsaW5nIG9uY2UgSGVhcCBpcyBkZXN0cm95ZWQuCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnJl bW92ZUFsbEV2ZW50TGlzdGVuZXJzKCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA1NmYyYzVhNTllZWEzYjdi ODA5OTBiNThiODA4NjNiMmMxMTBkYTc2Li45OGU1MDIwYmQ4MmFkNmU2MDBmYTE5OGViMjFmYjQ2 YmQ3ZTc2ZDcxIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSBhbmQg V2ViQ29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0ZW0gdG8gY2FsbCBp biB0byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAgICAgaW4gdGhlIGNo cm9taXVtLgorCisgICAgICAgIEFsc28gYWRkZWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZSBjbGFzcyB0aGF0IHByb3hpZXMKKyAgICAgICAgcmVxdWVzdHMgYW5kIGNhbGxiYWNrcyBi ZXR3ZWVuIGZyb20vdG8gd29ya2VyIHRocmVhZCB0by9mcm9tIHRoZQorICAgICAgICBtYWluIHRo cmVhZC4KKworICAgICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAg ICAgKFdlYktpdDo6V2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVk LgorICAgICAgICAqIHNyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIGlt cGxlbWVudGF0aW9uCisgICAgICAgIGZvciB3b3JrZXJzLiBJbiB3b3JrZXIgY2FzZSB0aGlzIGNh bGxzIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAgICAqIHNyYy9XZWJXb3Jr ZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0 ZW0pOiBBZGRlZC4gVGhpcyBpcyBjYWxsZWQgZnJvbQorICAgICAgICBMb2NhbEZpbGVTeXN0ZW06 OnJlcXVlc3RGaWxlU3lzdGVtIG9uIHRoZSB3b3JrZXIgdGhyZWFkIGFuZCBjcmVhdGVzCisgICAg ICAgIGEgYnJpZGdlIHRvIGNhbGwgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3Rl bSBvbiB0aGUgbWFpbgorICAgICAgICB0aHJlYWQuCisgICAgICAgICogc3JjL1dlYldvcmtlckJh c2UuaDoKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJDbGllbnRJbXBsOjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAqIHNyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaDogQWRkZWQuCisKIDIw MTAtMDktMjAgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEVyaWMgQ2FybHNvbi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9XZWJLaXQuZ3lwIGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggMzUyM2YyMWEx YjE0ODU3YTFjNDVjY2I2YjNmMzhiMTBmZDEyNmFjYy4uODc0ZDQ4NThmYjFhYTQ5YTViNzNjMmY0 MGI3OTZmMTFhOTIyMzYwMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAK KysrIGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKQEAgLTUzMyw2ICs1MzMsOCBAQAogICAg ICAgICAgICAgICAgICdzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oJywKICAgICAgICAgICAgICAg ICAnc3JjL1dlYldvcmtlckltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYldvcmtl ckltcGwuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV3JhcHBlZFJlc291cmNlUmVxdWVz dC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlc3BvbnNlLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvd2luL1dlYklucHV0RXZlbnRGYWN0b3J5LmNwcCcsCmRpZmYg LS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2 NDcxMjNhNTJmNTAzMjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUz YmI1YzhlNzg3Yzk2YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYkNvbW1vbldvcmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi Q29tbW9uV29ya2VyQ2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9u V29ya2VyQ2xpZW50X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1 ZGUgIldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNl IFdlYktpdCB7CiAKIGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYs MTMgQEAgcHVibGljOgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJl Zm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFi YXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENh bGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0 ZW0uCisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUs IGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAg IC8vIEZJWE1FOiBXZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBp biBjaHJvbWl1bSBpbXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQo KSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3Rl bUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21p dW0uY3BwCmluZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBi NzUzYjNkMTUyYzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktp dC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWls YWJsZSgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVt OjpBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDog QXN5bmNGaWxlU3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6 d2ViS2l0Q2xpZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9M b2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRm M2VjYTljZTgyMjBmMjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMx OCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1 bS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAKQEAgLTQyLDE0ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJ bXBsLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUlt cGwuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4 dC5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcu aD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1Q YXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3Qg U3RyaW5nJiBwYXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmls ZVN5c3RlbSgpCiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0 aCkpOworICAgIEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBs b2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICps b2NhbEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5 cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykK QEAgLTYwLDcgKzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3Rl bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZy YW1lSW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJh bWUoKSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJh bWUsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2Vi RmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0Nh bGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAg IC8vIEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtl ckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29u dGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3 b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2Vi V29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtl ckxvYWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNf Y2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVl MmUuLjYyN2MxYTUyZjliZThmZDllZGNiNDBhMjIwYWFhZmVkNDU3ODE1NGQgMTAwNjQ0Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBs YXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1w bC5oIgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50 LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRD aGFubmVsLmgiCkBAIC00NSw2ICs0Niw4IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1 ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2lu Y2x1ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKICNpbmNsdWRlICJXb3Jr ZXJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVk ZSA8d3RmL01haW5UaHJlYWQuaD4KQEAgLTU2LDYgKzU5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7 CiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VN b2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVT eXN0ZW1Nb2RlW10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKIAogbmFtZXNwYWNlIHsKIApAQCAt MTE0LDYgKzExOCw3IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAg ICAgV1RGOjpTdHJpbmcgbV9tb2RlOwogfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNh bGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRp YwpAQCAtMjMxLDYgKzIzNiwxNiBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2Uo V2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVy biBicmlkZ2UtPnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lz dGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0 ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0g bV93b3JrZXJUaHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBj b250cm9sbGVyID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQo KTsKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2Vy Q29udGV4dCgpOworCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+ IGJyaWRnZSA9IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmNyZWF0ZSh0aGlzLCB3 b3JrZXJDb250ZXh0LCBjYWxsYmFja3MpOworICAgIGJyaWRnZS0+cG9zdE9wZW5GaWxlU3lzdGVt T25NYWluVGhyZWFkKGNvbW1vbkNsaWVudCgpLCB0eXBlLCBzaXplLCBvcGVuRmlsZVN5c3RlbU1v ZGUpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6 OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlm MjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNj YWVhMzdhOWZlYzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05 MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBX ZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9v bCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBX ZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisg ICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5v dGUgdGhhdCB0aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50 OjpvcGVuRmlsZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVt OjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAg Ly8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRp YyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVm NTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAj aWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVk ZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIK ICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAg LTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAg ICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0 ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDUzMDYxYzg1OTViOGYwZjdmMmJlZjQ2NmFmMzZlNzdm ZWI0ZmFmMQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAKQEAgLTAsMCArMSwyNDYgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgorCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisj aW5jbHVkZSAiV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3Rl bUNhbGxiYWNrcy5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5oIgorI2luY2x1ZGUgIldlYldvcmtl ckJhc2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyU2Ny aXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0 Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCit1c2luZyBuYW1l c3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKKy8vIEZpbGVTeXN0ZW1DYWxs YmFja3MgdGhhdCBhcmUgdG8gYmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFz cyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY3JlYXRlKFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZT4gYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICByZXR1 cm4gYWRvcHRQdHIobmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSwgbW9k ZSkpOworICAgIH0KKworICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tz KCkKKyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNv bnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgIHsKKyAgICAg ICAgbV9icmlkZ2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgsIG1f bW9kZSk7CisgICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBk aWRGYWlsKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRG YWlsT25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpCisgICAgeworICAgICAgICBXRUJL SVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJl YWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYgaW5mbykKKyAgICB7CisgICAgICAgIFdFQktJ VF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVh ZERpcmVjdG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYgZW50cmllcywg Ym9vbCBoYXNNb3JlKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgp OworICAgIH0KKworcHJpdmF0ZToKKyAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQ YXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3Qg U3RyaW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgLCBtX21v ZGUobW9kZSkKKyAgICB7CisgICAgICAgIEFTU0VSVChtX2JyaWRnZS5nZXQoKSk7CisgICAgfQor CisgICAgZnJpZW5kIGNsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U7CisgICAg UmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fYnJpZGdlOworICAgIGNv bnN0IFN0cmluZyBtX21vZGU7Cit9OworCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl OjpXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwg U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgV2ViRmlsZVN5 c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIDogV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIo c3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpKQorICAg ICwgbV93b3JrZXIod29ya2VyKQorICAgICwgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQoY2Fs bGJhY2tzKQoreworfQorCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjp+V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpCit7CisgICAgQVNTRVJUKCFtX2NhbGxiYWNrc09u V29ya2VyQ29udGV4dCk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZTo6c3RvcCgpCit7CisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIG1fd29y a2VyID0gMDsKKyAgICBzdG9wT2JzZXJ2aW5nKCk7CisKKyAgICBpZiAobV9jYWxsYmFja3NPbldv cmtlckNvbnRleHQpIHsKKyAgICAgICAgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRpZEZh aWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4 dCA9IDA7CisgICAgfQorfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6 OnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNv bW1vbkNsaWVudCwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgY29u c3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRoaXM7CisgICAgQVNTRVJUKG1f d29ya2VyKTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQsIGNvbW1vbkNsaWVudCwgdHlw ZSwgc2l6ZSwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2U6OnBvc3RNb3ZlT25NYWluVGhyZWFkKFdlYkZpbGVTeXN0ZW0qIGZpbGVTeXN0ZW0s IGNvbnN0IFN0cmluZyYgc3JjUGF0aCwgY29uc3QgU3RyaW5nJiBkZXN0UGF0aCwgY29uc3QgU3Ry aW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRoaXM7CisgICAgQVNTRVJUKG1fd29ya2Vy KTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNr VGFzaygmbW92ZU9uTWFpblRocmVhZCwgZmlsZVN5c3RlbSwgc3JjUGF0aCwgZGVzdFBhdGgsIHRo aXMsIG1vZGUpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpw b3N0Q29weU9uTWFpblRocmVhZChXZWJGaWxlU3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJp bmcmIHNyY1BhdGgsIGNvbnN0IFN0cmluZyYgZGVzdFBhdGgsIGNvbnN0IFN0cmluZyYgbW9kZSkK K3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7CisgICAgbV93 b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNvcHlP bk1haW5UaHJlYWQsIGZpbGVTeXN0ZW0sIHNyY1BhdGgsIGRlc3RQYXRoLCB0aGlzLCBtb2RlKSk7 Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdFJlbW92ZU9u TWFpblRocmVhZChXZWJGaWxlU3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHBhdGgs IGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOworICAgIEFTU0VS VChtX3dvcmtlcik7CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVh dGVDYWxsYmFja1Rhc2soJnJlbW92ZU9uTWFpblRocmVhZCwgZmlsZVN5c3RlbSwgcGF0aCwgdGhp cywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnBv c3RSZWFkTWV0YWRhdGFPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3RlbSogZmlsZVN5c3RlbSwgY29u c3QgU3RyaW5nJiBwYXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0g dGhpczsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tU b01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZWFkTWV0YWRhdGFPbk1haW5UaHJlYWQs IGZpbGVTeXN0ZW0sIHBhdGgsIHRoaXMsIG1vZGUpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0Q3JlYXRlRmlsZU9uTWFpblRocmVhZChXZWJGaWxlU3lz dGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wgZXhjbHVzaXZlLCBjb25z dCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhpczsKKyAgICBBU1NFUlQobV93 b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2Fs bGJhY2tUYXNrKCZjcmVhdGVGaWxlT25NYWluVGhyZWFkLCBmaWxlU3lzdGVtLCBwYXRoLCBleGNs dXNpdmUsIHRoaXMsIG1vZGUpKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlOjpwb3N0Q3JlYXRlRGlyZWN0b3J5T25NYWluVGhyZWFkKFdlYkZpbGVTeXN0ZW0qIGZp bGVTeXN0ZW0sIGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIGNvbnN0IFN0cmlu ZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7 CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rh c2soJmNyZWF0ZURpcmVjdG9yeU9uTWFpblRocmVhZCwgZmlsZVN5c3RlbSwgcGF0aCwgZXhjbHVz aXZlLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZTo6cG9zdEZpbGVFeGlzdHNPbk1haW5UaHJlYWQoV2ViRmlsZVN5c3RlbSogZmlsZVN5c3Rl bSwgY29uc3QgU3RyaW5nJiBwYXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxm UmVmID0gdGhpczsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRj aFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZmaWxlRXhpc3RzT25NYWluVGhy ZWFkLCBmaWxlU3lzdGVtLCBwYXRoLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdERpcmVjdG9yeUV4aXN0c09uTWFpblRocmVhZChX ZWJGaWxlU3lzdGVtKiBmaWxlU3lzdGVtLCBjb25zdCBTdHJpbmcmIHBhdGgsIGNvbnN0IFN0cmlu ZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOworICAgIEFTU0VSVChtX3dvcmtlcik7 CisgICAgbV93b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rh c2soJmRpcmVjdG9yeUV4aXN0c09uTWFpblRocmVhZCwgZmlsZVN5c3RlbSwgcGF0aCwgdGhpcywg bW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnBvc3RS ZWFkRGlyZWN0b3J5T25NYWluVGhyZWFkKFdlYkZpbGVTeXN0ZW0qIGZpbGVTeXN0ZW0sIGNvbnN0 IFN0cmluZyYgcGF0aCwgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRo aXM7CisgICAgQVNTRVJUKG1fd29ya2VyKTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9N YWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVhZERpcmVjdG9yeU9uTWFpblRocmVhZCwg ZmlsZVN5c3RlbSwgcGF0aCwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2U6Om9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRmls ZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2VyRmlsZVN5c3RlbUNhbGxi YWNrc0JyaWRnZSogYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgaWYgKCFjb21t b25DbGllbnQpCisgICAgICAgIGJyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJy b3JBYm9ydCwgbW9kZSk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIE1haW5UaHJlYWRGaWxlU3lz dGVtQ2FsbGJhY2tzIGlzIHNlbGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIgaGVyZS4KKyAg ICAgICAgY29tbW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbSh0eXBlLCBzaXplLCBNYWluVGhyZWFk RmlsZVN5c3RlbUNhbGxiYWNrczo6Y3JlYXRlKGJyaWRnZSwgbW9kZSkubGVha1B0cigpKTsKKyAg ICB9Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkRmFpbE9u TWFpblRocmVhZChXZWJGaWxlRXJyb3IgZXJyb3IsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAg ICBtYXlQb3N0VGFza1RvV29ya2VyKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29ya2Vy VGhyZWFkLCB0aGlzLCBlcnJvciksIG1vZGUpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1D YWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFN0cmlu ZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5nJiBtb2RlKQorewor ICAgIG1heVBvc3RUYXNrVG9Xb3JrZXIoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRPcGVuRmlsZVN5 c3RlbU9uV29ya2VyVGhyZWFkLCB0aGlzLCBuYW1lLCByb290UGF0aCksIG1vZGUpOworfQorCit2 b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZEZhaWxPbldvcmtlclRocmVh ZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSogYnJpZGdlLCBXZWJGaWxlRXJyb3IgZXJyb3IpCit7CisgICAgaWYgKGJyaWRnZS0+bV9jYWxs YmFja3NPbldvcmtlckNvbnRleHQpIHsKKyAgICAgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29y a2VyQ29udGV4dC0+ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NP bldvcmtlckNvbnRleHQgPSAwOworICAgIH0KKyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVhcigp OworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxl U3lzdGVtT25Xb3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVT eXN0ZW1DYWxsYmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIHJvb3RQYXRoKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJD b250ZXh0KSB7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRp ZE9wZW5GaWxlU3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdlLT5tX2NhbGxi YWNrc09uV29ya2VyQ29udGV4dCA9IDA7CisgICAgfQorICAgIGJyaWRnZS0+bV9zZWxmUmVmLmNs ZWFyKCk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6bWF5UG9z dFRhc2tUb1dvcmtlcihQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRh c2ssIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRl eCk7CisgICAgaWYgKG1fd29ya2VyKQorICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2Rl VG9Xb3JrZXJDb250ZXh0KHRhc2ssIG1vZGUpOworICAgIGVsc2UKKyAgICAgICAgbV9zZWxmUmVm LmNsZWFyKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2EzMjk0Y2FmYTc1MTBjOWJmZjYz MzEwYzg0YmZkOGVmZTA2YTdmZQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAgKzEsMTExIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAg ICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAq IGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4g bm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdp dGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRP UlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNU SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisg KiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklM SVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lm bmRlZiBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZpbmUgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgor I2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKyNp bmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNp bmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKwor bmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tz OworY2xhc3MgV2ViQ29tbW9uV29ya2VyQ2xpZW50OworY2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxi YWNrczsKK2NsYXNzIFdlYldvcmtlckJhc2U7CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBw b3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQgYW5kIGdldCBj YWxsZWQgYmFjayBmb3IgdGhlIHJlcXVlc3QuIFRoaXMgbXVzdCBiZSBkZXN0cnVjdGVkIG9uIHRo ZSB3b3JrZXIgdGhyZWFkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZvciBvcGVuRmlsZVN5c3Rl bSB3b3VsZCBsb29rIGxpa2UgdGhpczoKKy8vIEJyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtT25N YWluVGhyZWFkKCkgb24gV29ya2VyVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6b3BlbkZpbGVTeXN0 ZW1Pbk1haW5UaHJlYWQoKSBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gICAgICBUaGlzIG1h a2VzIGFuIElQQyB3aXRoIGEgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgaW5zdGFuY2UK Ky8vICAgICBbYWN0dWFsIG9wZXJhdGlvbiBpcyBkb3duIGluIHRoZSBicm93c2VyXQorLy8gIC0t PiBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlzIGNhbGxlZCBvbiBNYWlu VGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFkIGlzIGNhbGxlZCBvbiBN YWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJUaHJlYWQgaXMgY2FsbGVk IG9uIFdvcmtlclRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSBvcmlnaW5hbCBjYWxsYmFj a3MgKG1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSBhbmQKKy8vICAgICAgcmVsZWFzZXMgYSBz ZWxmLXJlZmVyZW5jZSB0byB0aGUgYnJpZGdlLgorY2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxi YWNrc0JyaWRnZSA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2U+LCBwdWJsaWMgV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIgewor cHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2U+IGNyZWF0ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdlYkNvcmU6OlNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIHdvcmtlckNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxi YWNrcykKKyAgICB7CisgICAgICAgIHJldHVybiBXVEY6OmFkb3B0UmVmKG5ldyBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlKHdvcmtlciwgd29ya2VyQ29udGV4dCwgY2FsbGJhY2tzKSk7 CisgICAgfQorICAgIH5Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKCk7CisgICAgdm9p ZCBzdG9wKCk7CisKKyAgICAvLyBXb3JrZXJDb250ZXh0OjpPYnNlcnZlciBtZXRob2QuCisgICAg dmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKQorICAgIHsKKyAgICAgICAgc3RvcCgpOworICAgIH0K KworICAgIC8vIE1ldGhvZCB0aGF0IHBvc3RzIGFuIGluaXRpYWwgcmVxdWVzdCB0YXNrIHRvIHRo ZSBtYWluIHRocmVhZC4gSXQgaXMgc3VwcG9zZWQgdG8gYmUgY2FsbGVkIGltbWVkaWF0ZWx5IGFm dGVyIHRoZSBicmlkZ2UgaXMgY29uc3RydWN0ZWQgKGl0IGRvZXNuJ3QgY2hlY2sgaWYgdGhlIGNv bnRleHQgaGFzIGJlZW4gc3RvcHBlZCBvciBub3QpLgorICAgIHZvaWQgcG9zdE9wZW5GaWxlU3lz dGVtT25NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNsaWVudCosIFdlYkZpbGVTeXN0ZW06OlR5 cGUsIGxvbmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgLy8gQ2FsbGJh Y2sgbWV0aG9kcyB0aGF0IGFyZSBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHZvaWQg ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3IsIGNvbnN0IFN0cmluZyYgbW9kZSk7Cisg ICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFN0cmluZyYgcm9vdFBhdGgsIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKK3ByaXZhdGU6 CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZShXZWJXb3JrZXJCYXNlKiwgV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsK KworICAgIC8vIE1ldGhvZCB0aGF0IGlzIHRvIGJlIGNhbGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQu CisgICAgc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29yZTo6U2Ny aXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkNvbW1vbldvcmtlckNsaWVudCosIFdlYkZpbGVTeXN0 ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl KiwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworICAgIGZyaWVuZCBjbGFzcyBNYWluVGhyZWFkRmls ZVN5c3RlbUNhbGxiYWNrczsKKworICAgIC8vIE1ldGhvZHMgdGhhdCBkaXNwYXRjaCBXZWJGaWxl U3lzdGVtQ2FsbGJhY2tzIG9uIHRoZSB3b3JrZXIgdGhyZWFkcy4KKyAgICAvLyBUaGV5IHJlbGVh c2UgYSBzZWxmUmVmIG9mIHRoZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLgorICAg IHN0YXRpYyB2b2lkIGRpZEZhaWxPbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSosIFdlYkZpbGVFcnJv cik7CisgICAgc3RhdGljIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZChXZWJD b3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZSosIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCk7CisKKyAg ICAvLyBIZWxwZXIgbWV0aG9kcy4KKyAgICB2b2lkIG1heVBvc3RUYXNrVG9Xb3JrZXIoUGFzc093 blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5n JiBtb2RlKTsKKworICAgIC8vIG1fc2VsZlJlZiBrZWVwcyBhIHJlZmVyZW5jZSB0byBpdHNlbGYg dW50aWwgY2FsbGJhY2tzIGFyZSBmaXJlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICBSZWZQ dHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gbV9zZWxmUmVmOworCisgICAgTXV0 ZXggbV9tdXRleDsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKworICAgIC8vIE5vdCBv d25lZC4gIFRoZXkgbXVzdCBiZSBmaXJlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICBXZWJG aWxlU3lzdGVtQ2FsbGJhY2tzKiBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4dDsKK307CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2VfaAo= 68330 2010-09-21 19:59:32 -0700 2010-09-21 21:35:48 -0700 Patch bug-45808-20100921195931.patch text/plain 43338 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uN2FjODE4Zjc2OTA5M2Ez NmRmMDA5NDNkY2YyYWJkNjRjOGJiNWY3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMSAgRGlyayBTY2h1bHpl ICA8a3JpdEB3ZWJraXQub3JnPgogCiAgICAgICAgIFNWRyBGaWx0ZXIgY2xlYW51cApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3Bw IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmlu ZGV4IGExNWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNj ZmY3Mjc4Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRp bmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tl dC5oIgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEg QEAgYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQg PSBmYWxzZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRG ZWF0dXJlczo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYK IAogI2lmIEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUx ZGM0MjBkNmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmgKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMu aApAQCAtMTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNG aWxlU3lzdGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7 CiAgICAgc3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsg aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVl c3RGaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlm MWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2Li4xNGM2MmM4OTU2NzJiZGZmNzcyZGY5YjJjYzlmNjFl MjVmZDRkNTIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNw cAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAs MzAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3Rl bT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK0xvY2Fs RmlsZVN5c3RlbSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNl UGF0aCkKK3sKKyAgICAvLyBGSVhNRTogU2hvdWxkIGluaXRpYWxpemUgdGhlIHF1b3RhIHNldHRp bmdzIGFzIHdlbGwuCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNf aW5zdGFuY2UpOworICAgIGlmIChzX2luc3RhbmNlKQorICAgICAgICByZXR1cm47CisKKyAgICBP d25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3Rl bS5sZWFrUHRyKCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQoreworICAgIC8vIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBi ZSBjYWxsZWQgcHJpb3IgY2FsbGluZyB0aGlzLgorICAgIEFTU0VSVChzX2luc3RhbmNlKTsKKyAg ICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVT eXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9iYXNlUGF0aC50aHJlYWRzYWZlQ29w eSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBB c3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0cjxGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OSw3IEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1 ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAg ICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxs YmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5 bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0 YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKKyAgICBjb250ZXh0LT5wb3N0VGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgo KSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUs IG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywg Y29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u aAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJlYTY4Y2Q1MjNkYmI2Li44M2ZlZjlk NjNjNjViM2U5OWU4M2I3ZWRlMDYyMjk3ZDI0OGFlNjA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Zp bGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJyb3JDYWxsYmFjazsKIGNsYXNzIEZp bGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAKLWNsYXNz IExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsRmlsZVN5c3RlbT4gewor Ly8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5kIHByb3ZpZGVzIGFuIGVudHJ5IHBv aW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCk7Ci0gICAgdmlydHVhbCB+TG9j YWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBhIHBlci1wcm9jZXNzIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRoYXQgTG9jYWxGaWxlU3lzdGVtOjpp bml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIGJlZm9yZQorICAgIC8vIGNh bGxpbmcgdGhpcyBvbmUuCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSYgbG9jYWxGaWxlU3lz dGVtKCk7CiAKICAgICB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZp bGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOwogCi1wcm90ZWN0 ZWQ6CisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorICAgIC8vIFRoaXMgaXMgbm90IHRocmVhZC1z YWZlOyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVhdGVk LgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsKKwor ICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2YXRl OgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAgICA6 IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAorICAgIHN0YXRpYyBMb2NhbEZp bGVTeXN0ZW0qIHNfaW5zdGFuY2U7CisKKyAgICAvLyBUaGUgbWVtYmVyIG1ldGhvZHMgc2hvdWxk bid0IGFjY2VzcyB0aGlzIFN0cmluZyBkaXJlY3RseSBidXQgc2hvdWxkIHVzZQorICAgIC8vIGZp bGVTeXN0ZW1CYXNlUGF0aCgpIGluc3RlYWQuCiAgICAgU3RyaW5nIG1fYmFzZVBhdGg7CiB9Owog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuY3BwCmluZGV4IGY1YmEyNWMzNmE5YWQyYzdmZDE2NTlhNWI1ZDNkMDZkODdiYTVj NDYuLjZhMjAzY2M3YzQ5MmVjMzNhYmUwMDI5MmUzYTA0OGQ4YTJhYzM0MWQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cu Y3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0 ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlm ICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0 ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAg ICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7 Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBl cnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUg cXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0 aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0g PSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vz c0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNr KGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIp KTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1 ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBl Pih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKKyAgICBMb2Nh bEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50 LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNz Q2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1f bWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0g aW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworQ09NUElM RV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlBFUlNJU1RFTlQpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNt YXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93Lmgg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZi MjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAz YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg Y2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3Rv clRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExv Y2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAt NDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9E QVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5 OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxG aWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFy Z2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCA0Nzg5 ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2JkM2E2Yjc2 NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIxLDYgKzEy MSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNvbnN0IHsg cmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3JkTWFuYWdl cigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nlc3NGaWxl U3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRlY2huaWNh bGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFnZSwgYnV0 IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Npb25TdG9y YWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFjMGE1ZjQ5NjhkYjZhNGFhMWQ3 OTQ2ZmViZGQzZWY2OTUxNDdhNS4uNGQxNjYyYjYzNmE5ODE0MTY4YjZlNTg4NDhhNTcwYjZiNjU5 MTYyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTcsMTEgKzQ5Nyw2IEBAIHZvaWQgU2V0dGluZ3M6OnNl dExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2Nh bFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxl U3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJv b3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVN b2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKaW5kZXggOTlhNGYyMzJjNTI5ODA2ZWFhMjdmODVkNTdkYmJhYjEyNzQ0YmYzMy4uZjhh Mjk3YTE3YjA1NTY5ZDg1ZmM3YjExMGM0NjU2ZjQ0NzQwNzY0YSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTI0MSw5 ICsyNDEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0 YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3Qg U3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29u c3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFw cGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hy b21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApA QCAtMzM2LDcgKzMzMyw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1f ZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRl bXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwot ICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2Vy U3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRG YW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEzODVjMTNh NmNlYmI2OWZjN2FmLi41NzMwNWZmYzJiYTBjNGE0ZjNhNmUzZGU4ZjIxYWFlNDE5Zjg1ZTU5IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zNSwxMiArMzUsMjAgQEAKIAog I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgogI2luY2x1ZGUgIkZpbGVTeXN0 ZW0uaCIKKyNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFp bGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJuIGZhbHNlOworfQor CiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoY29u c3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1bHQgQXN5bmNGaWxlU3lz dGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVkKCk7CiAgICAgcmV0dXJuIDA7 CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lz dGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNh bGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUo cm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3Ry aW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYg cGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVt LmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1 ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5 YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lz dGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiAr NTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFs IGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRp YyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3 IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZv cm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMz YjllYTBhLi4zOTBhYWJhNGRhYmJkMTFiNmQzZGE5MzllZGQwMmI0MGU2NzllNDc3IDEwMDY0NAot LS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlm aWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2lu Y2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRl ICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNl bmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRh c2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0zMzUsNiArMzQ0 LDY0IEBAIHZvaWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJs b2JVUkxTdHJpbmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQg V29ya2VyQ29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXpl LCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVm UHRyPEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVT eXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVT eXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMs IGVycm9yQ2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAg ICByZXR1cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0o KS5yZXF1ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5 cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitD T01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkg PT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlz bWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQ RVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVu dCksIGVudW1fbWlzbWF0Y2gpOworI2VuZGlmCisKK1dvcmtlckNvbnRleHQ6Ok9ic2VydmVyOjpP YnNlcnZlcihXb3JrZXJDb250ZXh0KiBjb250ZXh0KQorICAgIDogbV9jb250ZXh0KGNvbnRleHQp Cit7CisgICAgQVNTRVJUKG1fY29udGV4dCk7CisgICAgbV9jb250ZXh0LT5yZWdpc3Rlck9ic2Vy dmVyKHRoaXMpOworfQorCitXb3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6fk9ic2VydmVyKCkKK3sK KyAgICBpZiAobV9jb250ZXh0KSB7CisgICAgICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4 dFRocmVhZCgpKTsKKyAgICAgICAgbV9jb250ZXh0LT51bnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7 CisgICAgfQorfQorCit2b2lkIFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyOjpzdG9wT2JzZXJ2aW5n KCkKK3sKKyAgICBpZiAobV9jb250ZXh0KSB7CisgICAgICAgIEFTU0VSVChtX2NvbnRleHQtPmlz Q29udGV4dFRocmVhZCgpKTsKKyAgICAgICAgbV9jb250ZXh0ID0gMDsKKyAgICB9Cit9CisKK3Zv aWQgV29ya2VyQ29udGV4dDo6cmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZlciogb2JzZXJ2ZXIpCit7 CisgICAgQVNTRVJUKG9ic2VydmVyKTsKKyAgICBtX3dvcmtlck9ic2VydmVycy5hZGQob2JzZXJ2 ZXIpOworfQorCit2b2lkIFdvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZl ciogb2JzZXJ2ZXIpCit7CisgICAgQVNTRVJUKG9ic2VydmVyKTsKKyAgICBtX3dvcmtlck9ic2Vy dmVycy5yZW1vdmUob2JzZXJ2ZXIpOworfQorCit2b2lkIFdvcmtlckNvbnRleHQ6Om5vdGlmeU9i c2VydmVyc09mU3RvcCgpCit7CisgICAgQVNTRVJUKGlzQ29udGV4dFRocmVhZCgpKTsKKyAgICBI YXNoU2V0PE9ic2VydmVyKj46Oml0ZXJhdG9yIG9ic2VydmVyc0VuZCA9IG1fd29ya2VyT2JzZXJ2 ZXJzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxPYnNlcnZlcio+OjppdGVyYXRvciBpdGVyID0g bV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsgaXRlciAhPSBvYnNlcnZlcnNFbmQ7ICsraXRlcikK KyAgICAgICAgKCppdGVyKS0+bm90aWZ5U3RvcCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoV09SS0VSUykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29y a2Vycy9Xb3JrZXJDb250ZXh0LmggYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCmlu ZGV4IDdmYjhiNDZmMzg3Y2MwNjg0MzFmZDMzNGRjMGZiNWU0ZDBhMTgwM2EuLjllYmM2ZTRmNzkz MmZlMTk3MWE2MmQ5YmYxYjFkZjcyNjk0NzU0YmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJDb250ZXh0LmgKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaApA QCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNp bmNsdWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4K ICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+ CkBAIC00NywxMSArNDgsMTUgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIERhdGFi YXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJhc2VTeW5j OworICAgIGNsYXNzIERPTUZpbGVTeXN0ZW1TeW5jOworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7 CisgICAgY2xhc3MgRmlsZVN5c3RlbUNhbGxiYWNrOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNl bnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRp b247CiAgICAgY2xhc3MgV29ya2VyTmF2aWdhdG9yOwogICAgIGNsYXNzIFdvcmtlclRocmVhZDsK KyAgICBjbGFzcyBXb3JrZXJXZWFrUmVmZXJlbmNlOwogCiAgICAgY2xhc3MgV29ya2VyQ29udGV4 dCA6IHB1YmxpYyBSZWZDb3VudGVkPFdvcmtlckNvbnRleHQ+LCBwdWJsaWMgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCwgcHVibGljIEV2ZW50VGFyZ2V0IHsKICAgICBwdWJsaWM6CkBAIC0xMjEsNiAr MTI2LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJM KGNvbnN0IFN0cmluZyYpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAg ICAgIC8vIFRoZXkgYXJlIHBsYWNlZCBoZXJlIGFuZCBpbiBhbGwgY2FwaXRhbCBsZXR0ZXJzIHRv IGVuZm9yY2UgY29tcGlsZS10aW1lIGVudW0gY2hlY2tpbmcuCisgICAgICAgIGVudW0gRmlsZVN5 c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVSU0lTVEVO VCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwg bG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFzc1JlZlB0 cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFy ZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4o TWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAg ICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJu IG1fbmF2aWdhdG9yLmdldCgpOyB9CkBAIC0xMzEsNiArMTQ1LDIwIEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogICAgICAgICBib29sIGlzQ2xvc2luZygpIHsgcmV0dXJuIG1fY2xvc2luZzsgfQog CisgICAgICAgIC8vIEFuIG9ic2VydmVyIGludGVyZmFjZSB0byBiZSBub3RpZmllZCB3aGVuIHRo ZSB3b3JrZXIgdGhyZWFkIGlzIGdldHRpbmcgc3RvcHBlZC4KKyAgICAgICAgY2xhc3MgT2JzZXJ2 ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgICAgICBwdWJsaWM6CisgICAgICAgICAgICBP YnNlcnZlcihXb3JrZXJDb250ZXh0Kik7CisgICAgICAgICAgICB2aXJ0dWFsIH5PYnNlcnZlcigp OworICAgICAgICAgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKSA9IDA7CisgICAgICAgICAg ICB2b2lkIHN0b3BPYnNlcnZpbmcoKTsKKyAgICAgICAgcHJpdmF0ZToKKyAgICAgICAgICAgIFdv cmtlckNvbnRleHQqIG1fY29udGV4dDsKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZWdpc3Rl ck9ic2VydmVyKE9ic2VydmVyKik7CisgICAgICAgIHZvaWQgdW5yZWdpc3Rlck9ic2VydmVyKE9i c2VydmVyKik7CisgICAgICAgIHZvaWQgbm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCk7CisKICAgICBw cm90ZWN0ZWQ6CiAgICAgICAgIFdvcmtlckNvbnRleHQoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmlu ZyYsIFdvcmtlclRocmVhZCopOwogCkBAIC0xNjEsNiArMTg5LDggQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgICAgICBib29sIG1fY2xvc2luZzsKICAgICAgICAgYm9vbCBtX3JlcG9ydGluZ0V4 Y2VwdGlvbjsKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1fZXZlbnRUYXJnZXREYXRhOworCisg ICAgICAgIEhhc2hTZXQ8T2JzZXJ2ZXIqPiBtX3dvcmtlck9ic2VydmVyczsKICAgICB9OwogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJh YTRhZGI4OGJjMmRmNjdmMjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uM2UxODVjMGQ1YjhlMGExMzdi ZDkyOGM1MmEyZGJhODE3NWY4MDMzNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtl ckNvbnRleHQuaWRsCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAt MTA0LDYgKzEwNCwxNCBAQCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVh dGVCbG9iVVJMKGluIEJsb2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBE T01TdHJpbmcgYmxvYlVSTCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lT VEVNKSAmJiBFTkFCTEVfRklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQg VEVNUE9SQVJZID0gMDsKKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9 IDE7CisgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGlu IHVuc2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9w dGlvbmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ss IE9wdGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworCisgICAgICAgICAgICAg ICAgIGF0dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVj dG9yIEZsYWdzOworI2VuZGlmCiAgICAgfTsKIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlclRocmVhZC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcApp bmRleCBkNmExZTA1N2QzZWQ4MThhMzc4ZTc1MzY2NjlmM2EwYTdiOTQ1N2ZlLi5mNjExMjBlZWUw NGMzMWE4MDBmZjU2MjlhZjlhMmI4MGE0NjdhM2M0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyVGhyZWFkLmNwcAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNw cApAQCAtMjAyLDYgKzIwMiw4IEBAIHB1YmxpYzoKIAogICAgICAgICB3b3JrZXJDb250ZXh0LT5z dG9wQWN0aXZlRE9NT2JqZWN0cygpOwogCisgICAgICAgIHdvcmtlckNvbnRleHQtPm5vdGlmeU9i c2VydmVyc09mU3RvcCgpOworCiAgICAgICAgIC8vIEV2ZW50IGxpc3RlbmVycyB3b3VsZCBrZWVw IERPTVdyYXBwZXJXb3JsZCBvYmplY3RzIGFsaXZlIGZvciB0b28gbG9uZy4gQWxzbywgdGhleSBo YXZlIHJlZmVyZW5jZXMgdG8gSlMgb2JqZWN0cywKICAgICAgICAgLy8gd2hpY2ggYmVjb21lIGRh bmdsaW5nIG9uY2UgSGVhcCBpcyBkZXN0cm95ZWQuCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnJl bW92ZUFsbEV2ZW50TGlzdGVuZXJzKCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA1NmYyYzVhNTllZWEzYjdi ODA5OTBiNThiODA4NjNiMmMxMTBkYTc2Li45OGU1MDIwYmQ4MmFkNmU2MDBmYTE5OGViMjFmYjQ2 YmQ3ZTc2ZDcxIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMC0wOS0xNyAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSBhbmQg V2ViQ29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0ZW0gdG8gY2FsbCBp biB0byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAgICAgaW4gdGhlIGNo cm9taXVtLgorCisgICAgICAgIEFsc28gYWRkZWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZSBjbGFzcyB0aGF0IHByb3hpZXMKKyAgICAgICAgcmVxdWVzdHMgYW5kIGNhbGxiYWNrcyBi ZXR3ZWVuIGZyb20vdG8gd29ya2VyIHRocmVhZCB0by9mcm9tIHRoZQorICAgICAgICBtYWluIHRo cmVhZC4KKworICAgICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAg ICAgKFdlYktpdDo6V2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVk LgorICAgICAgICAqIHNyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIGlt cGxlbWVudGF0aW9uCisgICAgICAgIGZvciB3b3JrZXJzLiBJbiB3b3JrZXIgY2FzZSB0aGlzIGNh bGxzIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAgICAqIHNyYy9XZWJXb3Jr ZXJCYXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0 ZW0pOiBBZGRlZC4gVGhpcyBpcyBjYWxsZWQgZnJvbQorICAgICAgICBMb2NhbEZpbGVTeXN0ZW06 OnJlcXVlc3RGaWxlU3lzdGVtIG9uIHRoZSB3b3JrZXIgdGhyZWFkIGFuZCBjcmVhdGVzCisgICAg ICAgIGEgYnJpZGdlIHRvIGNhbGwgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3Rl bSBvbiB0aGUgbWFpbgorICAgICAgICB0aHJlYWQuCisgICAgICAgICogc3JjL1dlYldvcmtlckJh c2UuaDoKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJDbGllbnRJbXBsOjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAqIHNyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaDogQWRkZWQuCisKIDIw MTAtMDktMjAgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEVyaWMgQ2FybHNvbi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9XZWJLaXQuZ3lwIGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggMzUyM2YyMWEx YjE0ODU3YTFjNDVjY2I2YjNmMzhiMTBmZDEyNmFjYy4uODc0ZDQ4NThmYjFhYTQ5YTViNzNjMmY0 MGI3OTZmMTFhOTIyMzYwMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAK KysrIGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKQEAgLTUzMyw2ICs1MzMsOCBAQAogICAg ICAgICAgICAgICAgICdzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oJywKICAgICAgICAgICAgICAg ICAnc3JjL1dlYldvcmtlckltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYldvcmtl ckltcGwuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV3JhcHBlZFJlc291cmNlUmVxdWVz dC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlc3BvbnNlLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvd2luL1dlYklucHV0RXZlbnRGYWN0b3J5LmNwcCcsCmRpZmYg LS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2 NDcxMjNhNTJmNTAzMjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUz YmI1YzhlNzg3Yzk2YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYkNvbW1vbldvcmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi Q29tbW9uV29ya2VyQ2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9u V29ya2VyQ2xpZW50X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1 ZGUgIldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNl IFdlYktpdCB7CiAKIGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYs MTMgQEAgcHVibGljOgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJl Zm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFi YXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENh bGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0 ZW0uCisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUs IGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAg IC8vIEZJWE1FOiBXZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBp biBjaHJvbWl1bSBpbXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQo KSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3Rl bUNocm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21p dW0uY3BwCmluZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBi NzUzYjNkMTUyYzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktp dC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWls YWJsZSgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVt OjpBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDog QXN5bmNGaWxlU3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6 d2ViS2l0Q2xpZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9M b2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRm M2VjYTljZTgyMjBmMjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMx OCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1 bS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAKQEAgLTQyLDE0ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJ bXBsLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUlt cGwuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4 dC5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcu aD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1Q YXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3Qg U3RyaW5nJiBwYXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmls ZVN5c3RlbSgpCiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0 aCkpOworICAgIEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBs b2NhbEZpbGVTeXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICps b2NhbEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5 cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykK QEAgLTYwLDcgKzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3Rl bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZy YW1lSW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJh bWUoKSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJh bWUsIHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2Vi RmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0Nh bGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAg IC8vIEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtl ckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29u dGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3 b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2Vi V29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtl ckxvYWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNf Y2FzdDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1D YWxsYmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVl MmUuLjYyN2MxYTUyZjliZThmZDllZGNiNDBhMjIwYWFhZmVkNDU3ODE1NGQgMTAwNjQ0Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBs YXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1w bC5oIgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50 LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRD aGFubmVsLmgiCkBAIC00NSw2ICs0Niw4IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1 ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2lu Y2x1ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKICNpbmNsdWRlICJXb3Jr ZXJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVk ZSA8d3RmL01haW5UaHJlYWQuaD4KQEAgLTU2LDYgKzU5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7 CiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VN b2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVT eXN0ZW1Nb2RlW10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKIAogbmFtZXNwYWNlIHsKIApAQCAt MTE0LDYgKzExOCw3IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAg ICAgV1RGOjpTdHJpbmcgbV9tb2RlOwogfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNh bGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRp YwpAQCAtMjMxLDYgKzIzNiwxNiBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2Uo V2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVy biBicmlkZ2UtPnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lz dGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0 ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0g bV93b3JrZXJUaHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBj b250cm9sbGVyID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQo KTsKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2Vy Q29udGV4dCgpOworCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+ IGJyaWRnZSA9IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmNyZWF0ZSh0aGlzLCB3 b3JrZXJDb250ZXh0LCBjYWxsYmFja3MpOworICAgIGJyaWRnZS0+cG9zdE9wZW5GaWxlU3lzdGVt T25NYWluVGhyZWFkKGNvbW1vbkNsaWVudCgpLCB0eXBlLCBzaXplLCBvcGVuRmlsZVN5c3RlbU1v ZGUpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6 OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlm MjJjZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNj YWVhMzdhOWZlYzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05 MSw2ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBX ZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9v bCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBX ZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisg ICAgLy8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5v dGUgdGhhdCB0aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50 OjpvcGVuRmlsZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVt OjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAg Ly8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRp YyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVm NTQ1Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAj aWYgRU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVk ZSAiV2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIK ICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAg LTk5LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAg ICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0 ZW0oV2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmls ZVN5c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDBhNGRmZGNiZmNmMDk2NjEyNGNlODBjNGUwYzQwZDIw YTBjZTFhOQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAKQEAgLTAsMCArMSwxODMgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgorCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisj aW5jbHVkZSAiV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3Rl bUNhbGxiYWNrcy5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5oIgorI2luY2x1ZGUgIldlYldvcmtl ckJhc2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyU2Ny aXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0 Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCit1c2luZyBuYW1l c3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKKy8vIEZpbGVTeXN0ZW1DYWxs YmFja3MgdGhhdCBhcmUgdG8gYmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFz cyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY3JlYXRlKFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZT4gYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICByZXR1 cm4gYWRvcHRQdHIobmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSwgbW9k ZSkpOworICAgIH0KKworICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tz KCkKKyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNv bnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgIHsKKyAgICAg ICAgbV9icmlkZ2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgsIG1f bW9kZSk7CisgICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBk aWRGYWlsKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRG YWlsT25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpCisgICAgeworICAgICAgICBXRUJL SVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJl YWRNZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYgaW5mbykKKyAgICB7CisgICAgICAgIFdFQktJ VF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVh ZERpcmVjdG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYgZW50cmllcywg Ym9vbCBoYXNNb3JlKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgp OworICAgIH0KKworcHJpdmF0ZToKKyAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQ YXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3Qg U3RyaW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgLCBtX21v ZGUobW9kZSkKKyAgICB7CisgICAgICAgIEFTU0VSVChtX2JyaWRnZS5nZXQoKSk7CisgICAgfQor CisgICAgZnJpZW5kIGNsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U7CisgICAg UmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fYnJpZGdlOworICAgIGNv bnN0IFN0cmluZyBtX21vZGU7Cit9OworCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl OjpXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwg U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgV2ViRmlsZVN5 c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIDogV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIo c3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpKQorICAg ICwgbV93b3JrZXIod29ya2VyKQorICAgICwgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQoY2Fs bGJhY2tzKQoreworfQorCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjp+V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpCit7CisgICAgQVNTRVJUKCFtX2NhbGxiYWNrc09u V29ya2VyQ29udGV4dCk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZTo6c3RvcCgpCit7CisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIG1fd29y a2VyID0gMDsKKyAgICBzdG9wT2JzZXJ2aW5nKCk7CisKKyAgICBpZiAobV9jYWxsYmFja3NPbldv cmtlckNvbnRleHQpIHsKKyAgICAgICAgbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRpZEZh aWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICBtX2NhbGxiYWNrc09uV29ya2VyQ29udGV4 dCA9IDA7CisgICAgfQorfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6 OnBvc3RPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNv bW1vbkNsaWVudCwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgY29u c3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1fc2VsZlJlZiA9IHRoaXM7CisgICAgQVNTRVJUKG1f d29ya2VyKTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQsIGNvbW1vbkNsaWVudCwgdHlw ZSwgc2l6ZSwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2U6Om9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRmlsZVN5c3RlbTo6 VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSogYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgaWYgKCFjb21tb25DbGllbnQp CisgICAgICAgIGJyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3JBYm9ydCwg bW9kZSk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJh Y2tzIGlzIHNlbGYtZGVzdHJ1Y3RlZCwgc28gd2UgbGVhayBwdHIgaGVyZS4KKyAgICAgICAgY29t bW9uQ2xpZW50LT5vcGVuRmlsZVN5c3RlbSh0eXBlLCBzaXplLCBNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrczo6Y3JlYXRlKGJyaWRnZSwgbW9kZSkubGVha1B0cigpKTsKKyAgICB9Cit9CisK K3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkRmFpbE9uTWFpblRocmVh ZChXZWJGaWxlRXJyb3IgZXJyb3IsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtYXlQb3N0 VGFza1RvV29ya2VyKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29ya2VyVGhyZWFkLCB0 aGlzLCBlcnJvciksIG1vZGUpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFN0cmluZyYgbmFtZSwg Y29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1heVBv c3RUYXNrVG9Xb3JrZXIoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRPcGVuRmlsZVN5c3RlbU9uV29y a2VyVGhyZWFkLCB0aGlzLCBuYW1lLCByb290UGF0aCksIG1vZGUpOworfQorCit2b2lkIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZEZhaWxPbldvcmtlclRocmVhZChTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSogYnJpZGdl LCBXZWJGaWxlRXJyb3IgZXJyb3IpCit7CisgICAgaWYgKGJyaWRnZS0+bV9jYWxsYmFja3NPbldv cmtlckNvbnRleHQpIHsKKyAgICAgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyQ29udGV4 dC0+ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNv bnRleHQgPSAwOworICAgIH0KKyAgICBicmlkZ2UtPm1fc2VsZlJlZi5jbGVhcigpOworfQorCit2 b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25X b3JrZXJUaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UqIGJyaWRnZSwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHJv b3RQYXRoKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJDb250ZXh0KSB7 CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQtPmRpZE9wZW5GaWxl U3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29y a2VyQ29udGV4dCA9IDA7CisgICAgfQorICAgIGJyaWRnZS0+bV9zZWxmUmVmLmNsZWFyKCk7Cit9 CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6bWF5UG9zdFRhc2tUb1dv cmtlcihQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2ssIGNvbnN0 IFN0cmluZyYgbW9kZSkKK3sKKyAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAg aWYgKG1fd29ya2VyKQorICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JNb2RlVG9Xb3JrZXJD b250ZXh0KHRhc2ssIG1vZGUpOworICAgIGVsc2UKKyAgICAgICAgbV9zZWxmUmVmLmNsZWFyKCk7 Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZ U1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjI5M2Y4YTY0MmNlMDRjOGI2NjViNjEyOTA2MWE1 YjI0ZDJkNGQzNwotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAgKzEsMTEzIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZpbmUgV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUg IldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJX b3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3 dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKworbmFtZXNwYWNl IFdlYktpdCB7CisKK2NsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xhc3Mg V2ViQ29tbW9uV29ya2VyQ2xpZW50OworY2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxiYWNrczsKK2Ns YXNzIFdlYldvcmtlckJhc2U7CisKKy8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byBwb3N0IGEgb3Bl bkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFj ayBmb3IgdGhlIHJlcXVlc3QuIFRoaXMgbXVzdCBiZSBkZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIg dGhyZWFkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZvciBvcGVuRmlsZVN5c3RlbSB3b3VsZCBs b29rIGxpa2UgdGhpczoKKy8vIEJyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFk KCkgb24gV29ya2VyVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5U aHJlYWQoKSBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gICAgICBUaGlzIG1ha2VzIGFuIElQ QyB3aXRoIGEgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgaW5zdGFuY2UKKy8vICAgICBb YWN0dWFsIG9wZXJhdGlvbiBpcyBkb3duIGluIHRoZSBicm93c2VyXQorLy8gIC0tPiBNYWluVGhy ZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisv LyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFkIGlzIGNhbGxlZCBvbiBNYWluVGhyZWFk CisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJUaHJlYWQgaXMgY2FsbGVkIG9uIFdvcmtl clRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSBvcmlnaW5hbCBjYWxsYmFja3MgKG1fY2Fs bGJhY2tzT25Xb3JrZXJDb250ZXh0KSBhbmQKKy8vICAgICAgcmVsZWFzZXMgYSBzZWxmLXJlZmVy ZW5jZSB0byB0aGUgYnJpZGdlLgorY2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2U+LCBwdWJsaWMgV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIgeworcHVibGljOgor ICAgIHN0YXRpYyBQYXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGNy ZWF0ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIHdvcmtlckNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAg ICB7CisgICAgICAgIHJldHVybiBXVEY6OmFkb3B0UmVmKG5ldyBXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlKHdvcmtlciwgd29ya2VyQ29udGV4dCwgY2FsbGJhY2tzKSk7CisgICAgfQor ICAgIH5Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKCk7CisKKyAgICAvLyBTdG9wcGlu ZyB0aGUgYnJpZGdlLiBUaGlzIG11c3QgYmUgY2FsbGVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgor ICAgIHZvaWQgc3RvcCgpOworCisgICAgLy8gV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIgbWV0aG9k LgorICAgIHZpcnR1YWwgdm9pZCBub3RpZnlTdG9wKCkKKyAgICB7CisgICAgICAgIHN0b3AoKTsK KyAgICB9CisKKyAgICAvLyBNZXRob2QgdGhhdCBwb3N0cyBhbiBpbml0aWFsIHJlcXVlc3QgdGFz ayB0byB0aGUgbWFpbiB0aHJlYWQuIEl0IGlzIHN1cHBvc2VkIHRvIGJlIGNhbGxlZCBpbW1lZGlh dGVseSBhZnRlciB0aGUgYnJpZGdlIGlzIGNvbnN0cnVjdGVkIChpdCBkb2Vzbid0IGNoZWNrIGlm IHRoZSBjb250ZXh0IGhhcyBiZWVuIHN0b3BwZWQgb3Igbm90KS4KKyAgICB2b2lkIHBvc3RPcGVu RmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb21tb25Xb3JrZXJDbGllbnQqLCBXZWJGaWxlU3lz dGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworICAgIC8v IENhbGxiYWNrIG1ldGhvZHMgdGhhdCBhcmUgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAg ICB2b2lkIGRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yLCBjb25zdCBTdHJpbmcmIG1v ZGUpOworICAgIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoY29uc3QgU3RyaW5n JiBuYW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBTdHJpbmcmIG1vZGUpOworCitw cml2YXRlOgorICAgIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UoV2ViV29ya2VyQmFz ZSosIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJGaWxlU3lzdGVtQ2FsbGJh Y2tzKik7CisKKyAgICAvLyBNZXRob2QgdGhhdCBpcyB0byBiZSBjYWxsZWQgb24gdGhlIG1haW4g dGhyZWFkLgorICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdlYkNv cmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqLCBXZWJG aWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZSosIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICBmcmllbmQgY2xhc3MgTWFpblRo cmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICAvLyBNZXRob2RzIHRoYXQgZGlzcGF0Y2gg V2ViRmlsZVN5c3RlbUNhbGxiYWNrcyBvbiB0aGUgd29ya2VyIHRocmVhZHMuCisgICAgLy8gVGhl eSByZWxlYXNlIGEgc2VsZlJlZiBvZiB0aGUgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0 RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqLCBXZWJG aWxlRXJyb3IpOworICAgIHN0YXRpYyB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJl YWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgp OworCisgICAgLy8gSGVscGVyIG1ldGhvZHMuCisgICAgdm9pZCBtYXlQb3N0VGFza1RvV29ya2Vy KFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4sIGNvbnN0 IFN0cmluZyYgbW9kZSk7CisKKyAgICAvLyBtX3NlbGZSZWYga2VlcHMgYSByZWZlcmVuY2UgdG8g aXRzZWxmIHVudGlsIGNhbGxiYWNrcyBhcmUgZmlyZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisg ICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fc2VsZlJlZjsKKwor ICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisKKyAgICAv LyBOb3Qgb3duZWQuICBUaGV5IG11c3QgYmUgZmlyZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisg ICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9jYWxsYmFja3NPbldvcmtlckNvbnRleHQ7Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlX2gK 68338 2010-09-21 21:35:53 -0700 2010-09-22 16:00:00 -0700 Patch bug-45808-20100921213551.patch text/plain 43631 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uN2FjODE4Zjc2OTA5M2Ez NmRmMDA5NDNkY2YyYWJkNjRjOGJiNWY3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMSAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMSAgRGlyayBTY2h1bHpl ICA8a3JpdEB3ZWJraXQub3JnPgogCiAgICAgICAgIFNWRyBGaWx0ZXIgY2xlYW51cApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3Bw IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmlu ZGV4IGExNWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNj ZmY3Mjc4Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRp bmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tl dC5oIgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEg QEAgYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQg PSBmYWxzZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRG ZWF0dXJlczo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYK IAogI2lmIEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUx ZGM0MjBkNmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmgKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMu aApAQCAtMTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNG aWxlU3lzdGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7 CiAgICAgc3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsg aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVl c3RGaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlm MWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2Li4xNGM2MmM4OTU2NzJiZGZmNzcyZGY5YjJjYzlmNjFl MjVmZDRkNTIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNw cAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAs MzAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3Rl bT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK0xvY2Fs RmlsZVN5c3RlbSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNl UGF0aCkKK3sKKyAgICAvLyBGSVhNRTogU2hvdWxkIGluaXRpYWxpemUgdGhlIHF1b3RhIHNldHRp bmdzIGFzIHdlbGwuCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNf aW5zdGFuY2UpOworICAgIGlmIChzX2luc3RhbmNlKQorICAgICAgICByZXR1cm47CisKKyAgICBP d25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3Rl bS5sZWFrUHRyKCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQoreworICAgIC8vIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBi ZSBjYWxsZWQgcHJpb3IgY2FsbGluZyB0aGlzLgorICAgIEFTU0VSVChzX2luc3RhbmNlKTsKKyAg ICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVT eXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9iYXNlUGF0aC50aHJlYWRzYWZlQ29w eSgpOwogfQogCiBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBB c3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgUGFzc093blB0cjxGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCkBAIC02OCw3ICs4OSw3IEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1 ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAg ICAgfQogCiAgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxs YmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5 bmNocm9ub3VzbHkuCi0gICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgbV9iYXNlUGF0aCwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0 YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3ND YWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29udGV4dCkpKTsKKyAgICBjb250ZXh0LT5wb3N0VGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgo KSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUs IG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywg Y29udGV4dCkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmls ZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u aAppbmRleCA0OGNmYThmNjg4NmE2MGE0MDA0NDRlMmZjZWJlYTY4Y2Q1MjNkYmI2Li44M2ZlZjlk NjNjNjViM2U5OWU4M2I3ZWRlMDYyMjk3ZDI0OGFlNjA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Zp bGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCkBAIC00NCwxOSArNDQsMzMgQEAgY2xhc3MgRXJyb3JDYWxsYmFjazsKIGNsYXNzIEZp bGVTeXN0ZW1DYWxsYmFjazsKIGNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAKLWNsYXNz IExvY2FsRmlsZVN5c3RlbSA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsRmlsZVN5c3RlbT4gewor Ly8gS2VlcHMgcGVyLXByb2Nlc3MgaW5mb3JtYXRpb24gYW5kIHByb3ZpZGVzIGFuIGVudHJ5IHBv aW50IHRvIG9wZW4gYSBmaWxlIHN5c3RlbS4KK2NsYXNzIExvY2FsRmlsZVN5c3RlbSA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxGaWxl U3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCk7Ci0gICAgdmlydHVhbCB+TG9j YWxGaWxlU3lzdGVtKCkgeyB9CisgICAgLy8gUmV0dXJucyBhIHBlci1wcm9jZXNzIGluc3RhbmNl IG9mIExvY2FsRmlsZVN5c3RlbS4KKyAgICAvLyBOb3RlIHRoYXQgTG9jYWxGaWxlU3lzdGVtOjpp bml0aWFsaXplTG9jYWxGaWxlU3lzdGVtIG11c3QgYmUgY2FsbGVkIGJlZm9yZQorICAgIC8vIGNh bGxpbmcgdGhpcyBvbmUuCisgICAgc3RhdGljIExvY2FsRmlsZVN5c3RlbSYgbG9jYWxGaWxlU3lz dGVtKCk7CiAKICAgICB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZp bGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4pOwogCi1wcm90ZWN0 ZWQ6CisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorICAgIC8vIFRoaXMgaXMgbm90IHRocmVhZC1z YWZlOyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVhdGVk LgorICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsKKwor ICAgIFN0cmluZyBmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2YXRl OgogICAgIExvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAgICA6 IG1fYmFzZVBhdGgoYmFzZVBhdGgpCiAgICAgewogICAgIH0KIAorICAgIHN0YXRpYyBMb2NhbEZp bGVTeXN0ZW0qIHNfaW5zdGFuY2U7CisKKyAgICAvLyBUaGUgbWVtYmVyIG1ldGhvZHMgc2hvdWxk bid0IGFjY2VzcyB0aGlzIFN0cmluZyBkaXJlY3RseSBidXQgc2hvdWxkIHVzZQorICAgIC8vIGZp bGVTeXN0ZW1CYXNlUGF0aCgpIGluc3RlYWQuCiAgICAgU3RyaW5nIG1fYmFzZVBhdGg7CiB9Owog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcCBiL1dlYkNvcmUvcGFnZS9E T01XaW5kb3cuY3BwCmluZGV4IGY1YmEyNWMzNmE5YWQyYzdmZDE2NTlhNWI1ZDNkMDZkODdiYTVj NDYuLjZhMjAzY2M3YzQ5MmVjMzNhYmUwMDI5MmUzYTA0OGQ4YTJhYzM0MWQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cu Y3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERPTVdpbmRvdzo6cmVxdWVzdEZpbGVTeXN0 ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRyPEZpbGVTeXN0ZQogICAgIGlm ICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghbV9sb2NhbEZpbGVTeXN0 ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBhY2Nlc3MgaXMgYWxsb3dlZC4KLQotICAg ICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICAgICAgaWYgKCFwYWdlKSB7 Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBl cnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJTlZBTElEX1NUQVRFX0VSUikpOwotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAgICAgICAgLy8gRklYTUU6IEdldCB0aGUg cXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAgU3RyaW5nIHBhdGggPSBwYWdlLT5zZXR0 aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAgICAgICAgbV9sb2NhbEZpbGVTeXN0ZW0g PSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3Rl bTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vz c0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNr KGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIp KTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fbG9jYWxGaWxlU3lzdGVtLT5yZXF1 ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpUeXBl Pih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKKyAgICBMb2Nh bEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxlU3lzdGVtKGRvY3VtZW50 LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBzdWNjZXNz Q2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1DT01QSUxFX0FTU0VSVChpbnQoRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1f bWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6UEVSU0lTVEVOVCkgPT0g aW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOworQ09NUElM RV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlRFTVBPUkFSWSkgPT0gc3RhdGlj X2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlBFUlNJU1RFTlQpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNt YXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93Lmgg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYyODY1ZDliOWI3NzQ3MTY5YWZi MjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3NWY5ODMwNGQxMTMxZmFmYjAz YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisrKyBiL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg Y2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5OwogICAgIGNsYXNzIEluc3BlY3Rv clRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lzdGVtOwogICAgIGNsYXNzIExv Y2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xhc3MgTmF2aWdhdG9yOwpAQCAt NDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBFTkFCTEUoSU5ERVhFRF9E QVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFjdG9yeT4gbV9pZGJGYWN0b3J5 OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAgICAgICBSZWZQdHI8TG9jYWxG aWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgogCiAgICAgICAgIEV2ZW50VGFy Z2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCA0Nzg5 ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4yYTYzOTY2ZDQ4N2JkM2E2Yjc2 NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTIxLDYgKzEy MSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2FsU3RvcmFnZSgpIGNvbnN0IHsg cmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nlc3NDb29raWVzKCkgY29uc3Qg eyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFjY2Vzc1Bhc3N3b3JkTWFuYWdl cigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAgYm9vbCBjYW5BY2Nlc3NGaWxl U3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KIAogICAgIC8vIFRlY2huaWNh bGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBzZXNzaW9uU3RvcmFnZSwgYnV0 IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVhdGluZyBhIHNlc3Npb25TdG9y YWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFjMGE1ZjQ5NjhkYjZhNGFhMWQ3 OTQ2ZmViZGQzZWY2OTUxNDdhNS4uNGQxNjYyYjYzNmE5ODE0MTY4YjZlNTg4NDhhNTcwYjZiNjU5 MTYyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTcsMTEgKzQ5Nyw2IEBAIHZvaWQgU2V0dGluZ3M6OnNl dExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpCiAgICAgbV9sb2Nh bFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lkIFNldHRpbmdzOjpzZXRGaWxl U3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewotICAgIG1fZmlsZVN5c3RlbVJv b3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0QXBwbGljYXRpb25DaHJvbWVN b2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25DaHJvbWVNb2RlID0gbW9kZTsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmgKaW5kZXggOTlhNGYyMzJjNTI5ODA2ZWFhMjdmODVkNTdkYmJhYjEyNzQ0YmYzMy4uZjhh Mjk3YTE3YjA1NTY5ZDg1ZmM3YjExMGM0NjU2ZjQ0NzQwNzY0YSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTI0MSw5 ICsyNDEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0TG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBjb25zdCBTdHJpbmcmIGxv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxTdG9yYWdlRGF0 YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3Qg U3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5c3RlbVJvb3RQYXRoKCkgY29u c3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQogICAgICAgICB2b2lkIHNldEFw cGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9vbCBpbkFwcGxpY2F0aW9uQ2hy b21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlvbkNocm9tZU1vZGU7IH0KIApA QCAtMzM2LDcgKzMzMyw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIG1f ZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmluZyBtX2Z0cERpcmVjdG9yeVRl bXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOwot ICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAgICAgICAgIEtVUkwgbV91c2Vy U3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJpbmcgbV9zdGFuZGFyZEZvbnRG YW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9udEZhbWlseTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5YjRmYmNlZDk0NjEzODVjMTNh NmNlYmI2OWZjN2FmLi41NzMwNWZmYzJiYTBjNGE0ZjNhNmUzZGU4ZjIxYWFlNDE5Zjg1ZTU5IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0zNSwxMiArMzUsMjAgQEAKIAog I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgogI2luY2x1ZGUgIkZpbGVTeXN0 ZW0uaCIKKyNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFp bGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJuIGZhbHNlOworfQor CiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoY29u c3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRlZmF1bHQgQXN5bmNGaWxlU3lz dGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVkKCk7CiAgICAgcmV0dXJuIDA7 CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lz dGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmEKIAogICAgIGNh bGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUo cm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGltcGxlbWVudGF0aW9uLgogU3Ry aW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1QYXRoKGNvbnN0IFN0cmluZyYg cGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVt LmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCmluZGV4IDYwMWYwZWFlM2U1 ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5MGZkYTQ2YzJiNzgwZGY5YjA5 YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lz dGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uaApAQCAtNTYsNiAr NTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSB7IH0KICAgICB2aXJ0dWFs IGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIHN0YXRp YyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVzIGFuZCByZXR1cm5zIGEgbmV3 IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0YW5jZSBpZiB0aGUgcGxhdGZv cm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290UGF0aCk7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBiL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0NzdlODE0YmJlNGQ4YmViOWMz YjllYTBhLi4xM2Q0MTFlYmUwYTY1NDE1Y2VhMDRjMzQ1OGI2ZWE0NjI1NzE2NWY2IDEwMDY0NAot LS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKKysrIGIvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBAQAogI2luY2x1ZGUgIk5vdGlm aWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisjaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9NRmlsZVN5c3RlbS5oIgorI2lu Y2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRl ICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNl bmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENsb3NlV29ya2VyQ29udGV4dFRh c2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CkBAIC0xMDAsNiArMTA5 LDEyIEBAIFdvcmtlckNvbnRleHQ6On5Xb3JrZXJDb250ZXh0KCkKICNpZiBFTkFCTEUoTk9USUZJ Q0FUSU9OUykKICAgICBtX25vdGlmaWNhdGlvbnMuY2xlYXIoKTsKICNlbmRpZgorCisgICAgLy8g TWFrZSBzdXJlIHdlIGhhdmUgbm8gb2JzZXJ2ZXJzLgorICAgIEhhc2hTZXQ8T2JzZXJ2ZXIqPjo6 aXRlcmF0b3Igb2JzZXJ2ZXJzRW5kID0gbV93b3JrZXJPYnNlcnZlcnMuZW5kKCk7CisgICAgZm9y IChIYXNoU2V0PE9ic2VydmVyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX3dvcmtlck9ic2VydmVycy5i ZWdpbigpOyBpdGVyICE9IG9ic2VydmVyc0VuZDsgKytpdGVyKQorICAgICAgICAoKml0ZXIpLT5z dG9wT2JzZXJ2aW5nKCk7CisKICAgICAvLyBOb3RpZnkgcHJveHkgdGhhdCB3ZSBhcmUgZ29pbmcg YXdheS4gVGhpcyBjYW4gZnJlZSB0aGUgV29ya2VyVGhyZWFkIG9iamVjdCwgc28gZG8gbm90IGFj Y2VzcyBpdCBhZnRlciB0aGlzLgogICAgIHRocmVhZCgpLT53b3JrZXJSZXBvcnRpbmdQcm94eSgp LndvcmtlckNvbnRleHREZXN0cm95ZWQoKTsKIH0KQEAgLTMzNSw2ICszNTAsNTQgQEAgdm9pZCBX b3JrZXJDb250ZXh0OjpyZXZva2VCbG9iVVJMKGNvbnN0IFN0cmluZyYgYmxvYlVSTFN0cmluZykK IH0KICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQordm9pZCBXb3JrZXJDb250ZXh0 OjpyZXF1ZXN0RmlsZVN5c3RlbShpbnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8 RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxs YmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBpZiAoIUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFp bGFibGUoKSB8fCAhc2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRmlsZVN5c3RlbSgpKSB7Cisg ICAgICAgIERPTUZpbGVTeXN0ZW06OnNjaGVkdWxlQ2FsbGJhY2sodGhpcywgZXJyb3JDYWxsYmFj aywgRmlsZUVycm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RGaWxl U3lzdGVtKHRoaXMsIHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNp emUsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cit9CisKK0NPTVBJTEVfQVNTRVJU KHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6VEVNUE9SQVJZKSA9PSBzdGF0aWNfY2Fz dDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6VGVtcG9yYXJ5KSwgZW51bV9taXNtYXRjaCk7CitDT01Q SUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlBFUlNJU1RFTlQpID09 IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50KSwgZW51bV9taXNt YXRjaCk7CisjZW5kaWYKKworV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXI6Ok9ic2VydmVyKFdvcmtl ckNvbnRleHQqIGNvbnRleHQpCisgICAgOiBtX2NvbnRleHQoY29udGV4dCkKK3sKKyAgICBBU1NF UlQobV9jb250ZXh0ICYmIG1fY29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpOworICAgIG1fY29u dGV4dC0+bV93b3JrZXJPYnNlcnZlcnMuYWRkKHRoaXMpOworfQorCitXb3JrZXJDb250ZXh0OjpP YnNlcnZlcjo6fk9ic2VydmVyKCkKK3sKKyAgICBpZiAobV9jb250ZXh0KSB7CisgICAgICAgIEFT U0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAgICAgICAgbV9jb250ZXh0LT5t X3dvcmtlck9ic2VydmVycy5yZW1vdmUodGhpcyk7CisgICAgfQorfQorCit2b2lkIFdvcmtlckNv bnRleHQ6Ok9ic2VydmVyOjpzdG9wT2JzZXJ2aW5nKCkKK3sKKyAgICBpZiAobV9jb250ZXh0KSB7 CisgICAgICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAgICAgICAg bV9jb250ZXh0ID0gMDsKKyAgICB9Cit9CisKK3ZvaWQgV29ya2VyQ29udGV4dDo6bm90aWZ5T2Jz ZXJ2ZXJzT2ZTdG9wKCkKK3sKKyAgICBIYXNoU2V0PE9ic2VydmVyKj46Oml0ZXJhdG9yIG9ic2Vy dmVyc0VuZCA9IG1fd29ya2VyT2JzZXJ2ZXJzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxPYnNl cnZlcio+OjppdGVyYXRvciBpdGVyID0gbV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsgaXRlciAh PSBvYnNlcnZlcnNFbmQ7ICsraXRlcikgeworICAgICAgICAoKml0ZXIpLT5ub3RpZnlTdG9wKCk7 CisgICAgICAgICgqaXRlciktPnN0b3BPYnNlcnZpbmcoKTsKKyAgICB9CisgICAgbV93b3JrZXJP YnNlcnZlcnMuY2xlYXIoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYg Ly8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAppbmRleCA3ZmI4YjQ2ZjM4 N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi45NDA4NGYyY2NiM2Y2MGVlYmI4NTUzOTgw ODQwODcyMDVhN2JhODg2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKQEAgLTM1LDYgKzM1LDcg QEAKICNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiV29ya2Vy U2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVk ZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L1Bhc3NSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNDcsMTEgKzQ4 LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFz cyBEYXRhYmFzZUNhbGxiYWNrOwogICAgIGNsYXNzIERhdGFiYXNlU3luYzsKKyAgICBjbGFzcyBE T01GaWxlU3lzdGVtU3luYzsKKyAgICBjbGFzcyBFcnJvckNhbGxiYWNrOworICAgIGNsYXNzIEZp bGVTeXN0ZW1DYWxsYmFjazsKICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xh c3MgU2NoZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwogICAgIGNsYXNz IFdvcmtlck5hdmlnYXRvcjsKICAgICBjbGFzcyBXb3JrZXJUaHJlYWQ7CisgICAgY2xhc3MgV29y a2VyV2Vha1JlZmVyZW5jZTsKIAogICAgIGNsYXNzIFdvcmtlckNvbnRleHQgOiBwdWJsaWMgUmVm Q291bnRlZDxXb3JrZXJDb250ZXh0PiwgcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIHB1 YmxpYyBFdmVudFRhcmdldCB7CiAgICAgcHVibGljOgpAQCAtMTIxLDYgKzEyNiwxNSBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcm KTsKICNlbmRpZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgICAgICAvLyBUaGV5IGFy ZSBwbGFjZWQgaGVyZSBhbmQgaW4gYWxsIGNhcGl0YWwgbGV0dGVycyB0byBlbmZvcmNlIGNvbXBp bGUtdGltZSBlbnVtIGNoZWNraW5nLgorICAgICAgICBlbnVtIEZpbGVTeXN0ZW1UeXBlIHsKKyAg ICAgICAgICAgIFRFTVBPUkFSWSwKKyAgICAgICAgICAgIFBFUlNJU1RFTlQsCisgICAgICAgIH07 CisgICAgICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXpl LCBQYXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4sIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFj az4pOworI2VuZGlmCisKICAgICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0Mg bWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGlu CiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5h dmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5n ZXQoKTsgfQpAQCAtMTMxLDYgKzE0NSwxOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAg ICAgYm9vbCBpc0Nsb3NpbmcoKSB7IHJldHVybiBtX2Nsb3Npbmc7IH0KIAorICAgICAgICAvLyBB biBvYnNlcnZlciBpbnRlcmZhY2UgdG8gYmUgbm90aWZpZWQgd2hlbiB0aGUgd29ya2VyIHRocmVh ZCBpcyBnZXR0aW5nIHN0b3BwZWQuCisgICAgICAgIGNsYXNzIE9ic2VydmVyIDogcHVibGljIE5v bmNvcHlhYmxlIHsKKyAgICAgICAgcHVibGljOgorICAgICAgICAgICAgT2JzZXJ2ZXIoV29ya2Vy Q29udGV4dCopOworICAgICAgICAgICAgdmlydHVhbCB+T2JzZXJ2ZXIoKTsKKyAgICAgICAgICAg IHZpcnR1YWwgdm9pZCBub3RpZnlTdG9wKCkgPSAwOworICAgICAgICAgICAgdm9pZCBzdG9wT2Jz ZXJ2aW5nKCk7CisgICAgICAgIHByaXZhdGU6CisgICAgICAgICAgICBXb3JrZXJDb250ZXh0KiBt X2NvbnRleHQ7CisgICAgICAgIH07CisgICAgICAgIGZyaWVuZCBjbGFzcyBPYnNlcnZlcjsKKyAg ICAgICAgdm9pZCBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIHByb3RlY3RlZDoKICAg ICAgICAgV29ya2VyQ29udGV4dChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiwgV29ya2VyVGhy ZWFkKik7CiAKQEAgLTE2MSw2ICsxODgsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAg IGJvb2wgbV9jbG9zaW5nOwogICAgICAgICBib29sIG1fcmVwb3J0aW5nRXhjZXB0aW9uOwogICAg ICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CisKKyAgICAgICAgSGFzaFNl dDxPYnNlcnZlcio+IG1fd29ya2VyT2JzZXJ2ZXJzOwogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbCBi L1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAppbmRleCAwMmFhNGFkYjg4YmMyZGY2 N2YyN2Q1ZWNlMmI1YTkyMzI4Njc4MTI0Li4zZTE4NWMwZDViOGUwYTEzN2JkOTI4YzUyYTJkYmE4 MTc1ZjgwMzM3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwK KysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCkBAIC0xMDQsNiArMTA0LDE0 IEBAIG1vZHVsZSB0aHJlYWRzIHsKICAgICAgICAgRE9NU3RyaW5nIGNyZWF0ZUJsb2JVUkwoaW4g QmxvYiBibG9iKTsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGluIERPTVN0cmluZyBibG9i VVJMKTsKICNlbmRpZgorCisjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9TWVNURU0pICYmIEVOQUJM RV9GSUxFX1NZU1RFTQorICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBURU1QT1JBUlkgPSAw OworICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0gMTsKKyAgICAgICAg W0VuYWJsZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4gdW5zaWduZWQgc2hv cnQgdHlwZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEZpbGVT eXN0ZW1DYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywgT3B0aW9uYWxdIEVy cm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7CisKKyAgICAgICAgICAgICAgICAgYXR0cmlidXRl IFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0b3IgRmxhZ3M7Cisj ZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhy ZWFkLmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCmluZGV4IGQ2YTFlMDU3 ZDNlZDgxOGEzNzhlNzUzNjY2OWYzYTBhN2I5NDU3ZmUuLmY2MTEyMGVlZTA0YzMxYTgwMGZmNTYy OWFmOWEyYjgwYTQ2N2EzYzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJl YWQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCkBAIC0yMDIsNiAr MjAyLDggQEAgcHVibGljOgogCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01P YmplY3RzKCk7CiAKKyAgICAgICAgd29ya2VyQ29udGV4dC0+bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9w KCk7CisKICAgICAgICAgLy8gRXZlbnQgbGlzdGVuZXJzIHdvdWxkIGtlZXAgRE9NV3JhcHBlcldv cmxkIG9iamVjdHMgYWxpdmUgZm9yIHRvbyBsb25nLiBBbHNvLCB0aGV5IGhhdmUgcmVmZXJlbmNl cyB0byBKUyBvYmplY3RzLAogICAgICAgICAvLyB3aGljaCBiZWNvbWUgZGFuZ2xpbmcgb25jZSBI ZWFwIGlzIGRlc3Ryb3llZC4KICAgICAgICAgd29ya2VyQ29udGV4dC0+cmVtb3ZlQWxsRXZlbnRM aXN0ZW5lcnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJL aXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDU2ZjJjNWE1OWVlYTNiN2I4MDk5MGI1OGI4MDg2 M2IyYzExMGRhNzYuLjk4ZTUwMjBiZDgyYWQ2ZTYwMGZhMTk4ZWIyMWZiNDZiZDdlNzZkNzEgMTAw NjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA5LTE3ICBLaW51a28gWWFzdWRhICA8 a2ludWtvQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0ZW0gQVBJCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTgwOAorCisgICAg ICAgIEFkZGVkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtIGFuZCBXZWJDb21tb25Xb3Jr ZXJDbGllbnQ6OgorICAgICAgICBvcGVuRmlsZVN5c3RlbSB0byBjYWxsIGluIHRvIHRoZSBicm93 c2VyIHZpYSBXb3JrZXIgc3R1Yi9wcm94eQorICAgICAgICBpbiB0aGUgY2hyb21pdW0uCisKKyAg ICAgICAgQWxzbyBhZGRlZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlIGNsYXNzIHRo YXQgcHJveGllcworICAgICAgICByZXF1ZXN0cyBhbmQgY2FsbGJhY2tzIGJldHdlZW4gZnJvbS90 byB3b3JrZXIgdGhyZWFkIHRvL2Zyb20gdGhlCisgICAgICAgIG1haW4gdGhyZWFkLgorCisgICAg ICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpX ZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICog c3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvY2Fs RmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpM b2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgaW1wbGVtZW50YXRpb24K KyAgICAgICAgZm9yIHdvcmtlcnMuIEluIHdvcmtlciBjYXNlIHRoaXMgY2FsbHMgV2ViV29ya2Vy QmFzZTo6b3BlbkZpbGVTeXN0ZW0uCisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLiBU aGlzIGlzIGNhbGxlZCBmcm9tCisgICAgICAgIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVT eXN0ZW0gb24gdGhlIHdvcmtlciB0aHJlYWQgYW5kIGNyZWF0ZXMKKyAgICAgICAgYSBicmlkZ2Ug dG8gY2FsbCBXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtIG9uIHRoZSBtYWlu CisgICAgICAgIHRocmVhZC4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAg ICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtl ckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAgICogc3JjL1dvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBzcmMvV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oOiBBZGRlZC4KKwogMjAxMC0wOS0yMCAgUGhp bGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRXJpYyBDYXJsc29uLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAg Yi9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAppbmRleCAzNTIzZjIxYTFiMTQ4NTdhMWM0NWNj YjZiM2YzOGIxMGZkMTI2YWNjLi44NzRkNDg1OGZiMWFhNDlhNWI3M2MyZjQwYjc5NmYxMWE5MjIz NjAyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAorKysgYi9XZWJLaXQv Y2hyb21pdW0vV2ViS2l0Lmd5cApAQCAtNTMzLDYgKzUzMyw4IEBACiAgICAgICAgICAgICAgICAg J3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViV29y a2VySW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViV29ya2VySW1wbC5oJywKKyAg ICAgICAgICAgICAgICAnc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwJywK KyAgICAgICAgICAgICAgICAnc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCcs CiAgICAgICAgICAgICAgICAgJ3NyYy9XcmFwcGVkUmVzb3VyY2VSZXF1ZXN0LmgnLAogICAgICAg ICAgICAgICAgICdzcmMvV3JhcHBlZFJlc291cmNlUmVzcG9uc2UuaCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy93aW4vV2ViSW5wdXRFdmVudEZhY3RvcnkuY3BwJywKZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IGNlYTY0NzEyM2E1MmY1MDMy ODUwODkwZGM4NDU1MmM0MTY0NGZmMmQuLjRmMTRmMmFmZTBhYWNhMmVjNTNiYjVjOGU3ODdjOTZh MmRjZDZkMjAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29y a2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJD bGllbnQuaApAQCAtMzEsNiArMzEsOSBAQAogI2lmbmRlZiBXZWJDb21tb25Xb3JrZXJDbGllbnRf aAogI2RlZmluZSBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogCisjaW5jbHVkZSAiV2ViQ29tbW9u LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAog Y2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CkBAIC04Myw2ICs4NiwxMyBAQCBwdWJsaWM6 CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcg YSB3ZWIgZGF0YWJhc2UuCiAgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUq LCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgPSAwOwogCisgICAgLy8gQ2FsbGVkIG9uIHRoZSBt YWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0 dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNp emUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKQorICAgIHsKKyAgICAgICAgLy8gRklYTUU6IFdl IG5lZWQgYSBzdHViIGltcGxlbWVudGF0aW9uIHVudGlsIHN1YmNsYXNzIGluIGNocm9taXVtIGlt cGxlbWVudCB0aGlzLgorICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAg fQorCiBwcm90ZWN0ZWQ6CiAgICAgfldlYkNvbW1vbldvcmtlckNsaWVudCgpIHsgfQogfTsKZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3Bw IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXgg MDhmY2VhNmM5ODVhYzMyMWQyOTE2YzNjMmUyZGE2ZmM4ZDQ4ZTgzZi4uMGI3NTNiM2QxNTJjMWI2 NWM3ZmMxNWY5YTM1M2NmYzUxYTYzNjRiYSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9B c3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQzLDYgKzQzLDExIEBACiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAorYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKwogQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW06OkFzeW5jRmlsZVN5 c3RlbUNocm9taXVtKGNvbnN0IFN0cmluZyYgcm9vdFBhdGgpCiAgICAgOiBBc3luY0ZpbGVTeXN0 ZW0ocm9vdFBhdGgpCiAgICAgLCBtX3dlYkZpbGVTeXN0ZW0oV2ViS2l0Ojp3ZWJLaXRDbGllbnQo KS0+ZmlsZVN5c3RlbSgpKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZp bGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3Rl bUNocm9taXVtLmNwcAppbmRleCA0NTM2NWVmMmU2NzlkOTkwYmIzYWViZGYzZWNhOWNlODIyMGYy NWIyLi45OTRmMzEwNDZiM2RkNzU3NWFhMDE5ZTZlMTg5OWJhZmYxOTA5MzE4IDEwMDY0NAotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcApAQCAtNDIsMTQg KzQyLDE5IEBACiAjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwuaCIKICNpbmNs dWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgorI2luY2x1 ZGUgIldlYldvcmtlckltcGwuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVk ZSAiV29ya2VyVGhyZWFkLmgiCisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgogCiB1c2luZyBu YW1lc3BhY2UgV2ViS2l0OwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8TG9j YWxGaWxlU3lzdGVtPiBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShjb25zdCBTdHJpbmcmIHBhdGgp CitMb2NhbEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKIHsK LSAgICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsRmlsZVN5c3RlbShwYXRoKSk7CisgICAgQXRv bWljYWxseUluaXRpYWxpemVkU3RhdGljKExvY2FsRmlsZVN5c3RlbSosIGxvY2FsRmlsZVN5c3Rl bSA9IG5ldyBMb2NhbEZpbGVTeXN0ZW0oIiIpKTsKKyAgICByZXR1cm4gKmxvY2FsRmlsZVN5c3Rl bTsKIH0KIAogdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25n IGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFj aywgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQpAQCAtNjAsNyArNjUs MTAgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJG cmFtZSA9IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAg ICAgd2ViRnJhbWUtPmNsaWVudCgpLT5vcGVuRmlsZVN5c3RlbSh3ZWJGcmFtZSwgc3RhdGljX2Nh c3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzSW1wbChuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9y Q2FsbGJhY2ssIGNvbnRleHQpKSk7CiAgICAgfSBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IEFk ZCBpbXBsZW1lbnRhdGlvbiBmb3Igd29ya2Vycy4KKyAgICAgICAgV29ya2VyQ29udGV4dCogd29y a2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihjb250ZXh0KTsKKyAgICAg ICAgV29ya2VyTG9hZGVyUHJveHkqIHdvcmtlckxvYWRlclByb3h5ID0gJndvcmtlckNvbnRleHQt PnRocmVhZCgpLT53b3JrZXJMb2FkZXJQcm94eSgpOworICAgICAgICBXZWJXb3JrZXJCYXNlKiB3 ZWJXb3JrZXIgPSBzdGF0aWNfY2FzdDxXZWJXb3JrZXJCYXNlKj4od29ya2VyTG9hZGVyUHJveHkp OworICAgICAgICB3ZWJXb3JrZXItPm9wZW5GaWxlU3lzdGVtKHN0YXRpY19jYXN0PFdlYkZpbGVT eXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3RlbUNhbGxiYWNrc0ltcGwo bmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBj b250ZXh0KSkpOwogICAgIH0KIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAK aW5kZXggNDJmNDFkMmRjNzliNGUzZTQ2M2NlNDlkODJlNjVhNTQ4Mzk1NWUyZS4uNjI3YzFhNTJm OWJlOGZkOWVkY2I0MGEyMjBhYWFmZWQ0NTc4MTU0ZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiUGxhdGZvcm1NZXNzYWdl UG9ydENoYW5uZWwuaCIKIAogI2luY2x1ZGUgIldlYkRhdGFTb3VyY2VJbXBsLmgiCisjaW5jbHVk ZSAiV2ViRmlsZUVycm9yLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRl ICJXZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJNZXNzYWdlUG9ydENoYW5uZWwuaCIKQEAg LTQ1LDYgKzQ2LDggQEAKICNpbmNsdWRlICJXZWJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViV29ya2Vy Q2xpZW50LmgiCiAKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgogI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRy b2xsZXIuaCIKICNpbmNsdWRlICJXb3JrZXJUaHJlYWQuaCIKICNpbmNsdWRlIDx3dGYvTWFpblRo cmVhZC5oPgpAQCAtNTYsNiArNTksNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKICNpZiBFTkFCTEUo V09SS0VSUykKIAogc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxv d0RhdGFiYXNlTW9kZSI7CitzdGF0aWMgY29uc3QgY2hhciBvcGVuRmlsZVN5c3RlbU1vZGVbXSA9 ICJvcGVuRmlsZVN5c3RlbU1vZGUiOwogCiBuYW1lc3BhY2UgewogCkBAIC0xMTQsNiArMTE4LDcg QEAgcHJpdmF0ZToKICAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKICAgICBXVEY6OlN0cmlu ZyBtX21vZGU7CiB9OworCiB9CiAKIC8vIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBt YWluIHRocmVhZCB0byBmb3JjZSB0byBpbml0aWFsaXplIHNvbWUgc3RhdGljCkBAIC0yMzEsNiAr MjM2LDE2IEBAIGJvb2wgV2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNv bnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyCiAgICAgcmV0dXJuIGJyaWRnZS0+cmVz dWx0KCk7CiB9CiAKK3ZvaWQgV2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyog Y2FsbGJhY2tzKQoreworICAgIFdvcmtlclJ1bkxvb3AmIHJ1bkxvb3AgPSBtX3dvcmtlclRocmVh ZC0+cnVuTG9vcCgpOworICAgIFdvcmtlclNjcmlwdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBX b3JrZXJTY3JpcHRDb250cm9sbGVyOjpjb250cm9sbGVyRm9yQ29udGV4dCgpOworICAgIFdvcmtl ckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBjb250cm9sbGVyLT53b3JrZXJDb250ZXh0KCk7CisK KyAgICBSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gYnJpZGdlID0gV29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6Y3JlYXRlKHRoaXMsIHdvcmtlckNvbnRleHQs IGNhbGxiYWNrcyk7CisgICAgYnJpZGdlLT5wb3N0T3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQo Y29tbW9uQ2xpZW50KCksIHR5cGUsIHNpemUsIG9wZW5GaWxlU3lzdGVtTW9kZSk7Cit9CisKIC8v IFdvcmtlck9iamVjdFByb3h5IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIHZvaWQgV2ViV29ya2VyQmFzZTo6cG9zdE1lc3NhZ2VU b1dvcmtlck9iamVjdChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gbWVzc2FnZSwK ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKaW5kZXggMjI3MTFmOWYyMmNmNzA2YmRkZWIw MjJjODVjNGMzMjdkNmUzMTJiMy4uNjI4ZDhmMThjM2UxN2EyMDZmODVmY2NhZWEzN2E5ZmVjMWQ5 NmFjYiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKQEAgLTkxLDYgKzkxLDkgQEAg cHVibGljOgogICAgIC8vIENvbnRyb2xzIHdoZXRoZXIgYWNjZXNzIHRvIFdlYiBEYXRhYmFzZXMg aXMgYWxsb3dlZCBmb3IgdGhpcyB3b3JrZXIuCiAgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJh c2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlz cGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAKKyAgICAvLyBSZXF1ZXN0 cyB0byBvcGVuIGEgZmlsZSBzeXN0ZW0gZm9yIHRoaXMgd29ya2VyLiAoTm90ZSB0aGF0IHRoaXMg aXMgbm90IHRoZSBpbXBsZW1lbnRhdGlvbiBmb3IgV2ViRnJhbWVDbGllbnQ6Om9wZW5GaWxlU3lz dGVtLikKKyAgICB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcg bG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKik7CisKICAgICAvLyBFeGVjdXRlcyB0 aGUgZ2l2ZW4gdGFzayBvbiB0aGUgbWFpbiB0aHJlYWQuCiAgICAgc3RhdGljIHZvaWQgZGlzcGF0 Y2hUYXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzaz4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5o CmluZGV4IDc0MWQ2MDY0MDY5NjFmM2YyNTkwZGIwOTk5ZmIyMDc2NTJhNWY1NDUuLjA2MDQ4MjM1 ZGJmMjhmYzllZmYzNGEyYWVmZGE4NDFhODk3NGM3ZDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC0zMyw4ICszMyw4IEBACiAKICNpZiBFTkFCTEUoV09S S0VSUykKIAorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlICJXZWJXb3JrZXJD bGllbnQuaCIKLQogI2luY2x1ZGUgIldvcmtlckNvbnRleHRQcm94eS5oIgogI2luY2x1ZGUgPHd0 Zi9QYXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgpAQCAtOTksNiArOTksMTAg QEAgcHVibGljOgogICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0dXJu IHRydWU7CiAgICAgfQorICAgIHZpcnR1YWwgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGcmFtZSos IFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJh Y2tzKikKKyAgICB7CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KIAogcHJp dmF0ZToKICAgICB2aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7CmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi45NDg3OTllMzAzYjlmZWRiYTVhYmZkYWMzMjFhYjRhODEzNjU5YjljCi0tLSAv ZGV2L251bGwKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlLmNwcApAQCAtMCwwICsxLDE4MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAg KiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRI RSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElN SVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNs dWRlICJXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgiCisKKyNpZiBFTkFCTEUoRklM RV9TWVNURU0pCisKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKKyNpbmNsdWRlICJXZWJD b21tb25Xb3JrZXJDbGllbnQuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzLmgi CisjaW5jbHVkZSAiV2ViU3RyaW5nLmgiCisjaW5jbHVkZSAiV2ViV29ya2VyQmFzZS5oIgorI2lu Y2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVy LmgiCisjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCisjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQu aD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3Jl OworCituYW1lc3BhY2UgV2ViS2l0IHsKKworLy8gRmlsZVN5c3RlbUNhbGxiYWNrcyB0aGF0IGFy ZSB0byBiZSBkaXNwYXRjaGVkIG9uIHRoZSBtYWluIHRocmVhZC4KK2NsYXNzIE1haW5UaHJlYWRG aWxlU3lzdGVtQ2FsbGJhY2tzIDogcHVibGljIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MgeworcHVi bGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjcmVhdGUoUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlk Z2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihu ZXcgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoYnJpZGdlLCBtb2RlKSk7CisgICAgfQor CisgICAgdmlydHVhbCB+TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoKQorICAgIHsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgV2ViU3RyaW5n JiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIHBhdGgpCisgICAgeworICAgICAgICBtX2JyaWRnZS0+ ZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQobmFtZSwgcGF0aCwgbV9tb2RlKTsKKyAgICAg ICAgZGVsZXRlIHRoaXM7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoV2ViRmls ZUVycm9yIGVycm9yKQorICAgIHsKKyAgICAgICAgbV9icmlkZ2UtPmRpZEZhaWxPbk1haW5UaHJl YWQoZXJyb3IsIG1fbW9kZSk7CisgICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBkaWRTdWNjZWVkKCkKKyAgICB7CisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9U X1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZE1ldGFkYXRhKGNv bnN0IFdlYkZpbGVJbmZvJiBpbmZvKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1Rf UkVBQ0hFRCgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5KGNv bnN0IFdlYlZlY3RvcjxXZWJGaWxlU3lzdGVtRW50cnk+JiBlbnRyaWVzLCBib29sIGhhc01vcmUp CisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCitw cml2YXRlOgorICAgIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKFBhc3NSZWZQdHI8V29y a2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUp CisgICAgICAgIDogbV9icmlkZ2UoYnJpZGdlKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAg IHsKKyAgICAgICAgQVNTRVJUKG1fYnJpZGdlLmdldCgpKTsKKyAgICB9CisKKyAgICBmcmllbmQg Y2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTsKKyAgICBSZWZQdHI8V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gbV9icmlkZ2U7CisgICAgY29uc3QgU3RyaW5nIG1f bW9kZTsKK307CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OldvcmtlckZpbGVT eXN0ZW1DYWxsYmFja3NCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0LCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBjYWxsYmFja3MpCisgICAgOiBXb3JrZXJDb250ZXh0OjpPYnNlcnZlcihzdGF0aWNfY2FzdDxX b3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkpCisgICAgLCBtX3dvcmtlcih3 b3JrZXIpCisgICAgLCBtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKGNhbGxiYWNrcykKK3sKK30K KworV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6fldvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UoKQoreworICAgIEFTU0VSVCghbV9jYWxsYmFja3NPbldvcmtlclRocmVhZCk7 Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6c3RvcCgpCit7Cisg ICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIG1fd29ya2VyID0gMDsKKworICAg IGlmIChtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAgICAgIG1fY2FsbGJhY2tzT25X b3JrZXJUaHJlYWQtPmRpZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICBtX2NhbGxi YWNrc09uV29ya2VyVGhyZWFkID0gMDsKKyAgICB9Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFdlYkNvbW1v bldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxv bmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhp czsKKyAgICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCwg Y29tbW9uQ2xpZW50LCB0eXBlLCBzaXplLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50 LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlKiBicmlkZ2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBp ZiAoIWNvbW1vbkNsaWVudCkKKyAgICAgICAgYnJpZGdlLT5kaWRGYWlsT25NYWluVGhyZWFkKFdl YkZpbGVFcnJvckFib3J0LCBtb2RlKTsKKyAgICBlbHNlIHsKKyAgICAgICAgLy8gTWFpblRocmVh ZEZpbGVTeXN0ZW1DYWxsYmFja3MgaXMgc2VsZi1kZXN0cnVjdGVkLCBzbyB3ZSBsZWFrIHB0ciBo ZXJlLgorICAgICAgICBjb21tb25DbGllbnQtPm9wZW5GaWxlU3lzdGVtKHR5cGUsIHNpemUsIE1h aW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOjpjcmVhdGUoYnJpZGdlLCBtb2RlKS5sZWFrUHRy KCkpOworICAgIH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpk aWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvciwgY29uc3QgU3RyaW5nJiBtb2Rl KQoreworICAgIG1heVBvc3RUYXNrVG9Xb3JrZXIoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRGYWls T25Xb3JrZXJUaHJlYWQsIHRoaXMsIGVycm9yKSwgbW9kZSk7Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBTdHJpbmcmIG1v ZGUpCit7CisgICAgbWF5UG9zdFRhc2tUb1dvcmtlcihjcmVhdGVDYWxsYmFja1Rhc2soJmRpZE9w ZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQsIHRoaXMsIG5hbWUsIHJvb3RQYXRoKSwgbW9kZSk7 Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkRmFpbE9uV29y a2VyVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlKiBicmlkZ2UsIFdlYkZpbGVFcnJvciBlcnJvcikKK3sKKyAgICBpZiAoYnJpZGdl LT5tX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFj a3NPbldvcmtlclRocmVhZC0+ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRnZS0+bV9jYWxs YmFja3NPbldvcmtlclRocmVhZCA9IDA7CisgICAgfQorICAgIGJyaWRnZS0+bV9zZWxmUmVmLmNs ZWFyKCk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkT3Bl bkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSogYnJpZGdlLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IFN0cmluZyYgcm9vdFBhdGgpCit7CisgICAgaWYgKGJyaWRnZS0+bV9jYWxsYmFja3NPbldv cmtlclRocmVhZCkgeworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQt PmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIHJvb3RQYXRoKTsKKyAgICAgICAgYnJpZGdlLT5tX2Nh bGxiYWNrc09uV29ya2VyVGhyZWFkID0gMDsKKyAgICB9CisgICAgYnJpZGdlLT5tX3NlbGZSZWYu Y2xlYXIoKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjptYXlQ b3N0VGFza1RvV29ya2VyKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4g dGFzaywgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211 dGV4KTsKKyAgICBpZiAobV93b3JrZXIpCisgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1v ZGVUb1dvcmtlckNvbnRleHQodGFzaywgbW9kZSk7CisgICAgZWxzZQorICAgICAgICBtX3NlbGZS ZWYuY2xlYXIoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5B QkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41YTU4N2ZjZmFkOTBiZjZkODQ4 YThiMDlkMDEwNDdhNmRiMDY0NmYwCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgKQEAgLTAsMCArMSwxMTMgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor ICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5j LiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUg d2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV VE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9X TkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK KyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aWZuZGVmIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAorI2RlZmluZSBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgi CisjaW5jbHVkZSAiV2ViRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5oIgor I2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgor I2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgor CituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFj a3M7CitjbGFzcyBXZWJDb21tb25Xb3JrZXJDbGllbnQ7CitjbGFzcyBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzOworY2xhc3MgV2ViV29ya2VyQmFzZTsKKworLy8gVGhpcyBjbGFzcyBpcyB1c2VkIHRv IHBvc3QgYSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBtYWluIHRocmVhZCBhbmQgZ2V0 IGNhbGxlZCBiYWNrIGZvciB0aGUgcmVxdWVzdC4gVGhpcyBtdXN0IGJlIGRlc3RydWN0ZWQgb24g dGhlIHdvcmtlciB0aHJlYWQuCisvLworLy8gQSB0eXBpY2FsIGZsb3cgZm9yIG9wZW5GaWxlU3lz dGVtIHdvdWxkIGxvb2sgbGlrZSB0aGlzOgorLy8gQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1P bk1haW5UaHJlYWQoKSBvbiBXb3JrZXJUaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpvcGVuRmlsZVN5 c3RlbU9uTWFpblRocmVhZCgpIGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAgICAgIFRoaXMg bWFrZXMgYW4gSVBDIHdpdGggYSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBpbnN0YW5j ZQorLy8gICAgIFthY3R1YWwgb3BlcmF0aW9uIGlzIGRvd24gaW4gdGhlIGJyb3dzZXJdCisvLyAg LS0+IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOjpkaWRYeHggaXMgY2FsbGVkIG9uIE1h aW5UaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpkaWRYeHhPbk1haW5UaHJlYWQgaXMgY2FsbGVkIG9u IE1haW5UaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpkaWRYeHhPbldvcmtlclRocmVhZCBpcyBjYWxs ZWQgb24gV29ya2VyVGhyZWFkCisvLyAgICAgIFRoaXMgY2FsbHMgdGhlIG9yaWdpbmFsIGNhbGxi YWNrcyAobV9jYWxsYmFja3NPbldvcmtlclRocmVhZCkgYW5kCisvLyAgICAgIHJlbGVhc2VzIGEg c2VsZi1yZWZlcmVuY2UgdG8gdGhlIGJyaWRnZS4KK2NsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlPiwgcHVibGljIFdlYkNvcmU6OldvcmtlckNvbnRleHQ6Ok9ic2VydmVyIHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlPiBjcmVhdGUoV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb3JlOjpTY3JpcHRFeGVj dXRpb25Db250ZXh0KiB3b3JrZXJDb250ZXh0LCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxs YmFja3MpCisgICAgeworICAgICAgICByZXR1cm4gV1RGOjphZG9wdFJlZihuZXcgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSh3b3JrZXIsIHdvcmtlckNvbnRleHQsIGNhbGxiYWNrcykp OworICAgIH0KKyAgICB+V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpOworCisgICAg Ly8gU3RvcHBpbmcgdGhlIGJyaWRnZS4gVGhpcyBtdXN0IGJlIGNhbGxlZCBvbiB0aGUgd29ya2Vy IHRocmVhZC4KKyAgICB2b2lkIHN0b3AoKTsKKworICAgIC8vIFdvcmtlckNvbnRleHQ6Ok9ic2Vy dmVyIG1ldGhvZC4KKyAgICB2aXJ0dWFsIHZvaWQgbm90aWZ5U3RvcCgpCisgICAgeworICAgICAg ICBzdG9wKCk7CisgICAgfQorCisgICAgLy8gTWV0aG9kIHRoYXQgcG9zdHMgYW4gaW5pdGlhbCBy ZXF1ZXN0IHRhc2sgdG8gdGhlIG1haW4gdGhyZWFkLiBJdCBpcyBzdXBwb3NlZCB0byBiZSBjYWxs ZWQgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGJyaWRnZSBpcyBjb25zdHJ1Y3RlZCAoaXQgZG9lc24n dCBjaGVjayBpZiB0aGUgY29udGV4dCBoYXMgYmVlbiBzdG9wcGVkIG9yIG5vdCkuCisgICAgdm9p ZCBwb3N0T3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoV2ViQ29tbW9uV29ya2VyQ2xpZW50Kiwg V2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIGNvbnN0IFN0cmluZyYgbW9kZSk7 CisKKyAgICAvLyBDYWxsYmFjayBtZXRob2RzIHRoYXQgYXJlIGNhbGxlZCBvbiB0aGUgbWFpbiB0 aHJlYWQuCisgICAgdm9pZCBkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciwgY29uc3Qg U3RyaW5nJiBtb2RlKTsKKyAgICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5nJiBt b2RlKTsKKworcHJpdmF0ZToKKyAgICBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdl YldvcmtlckJhc2UqLCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViRmlsZVN5 c3RlbUNhbGxiYWNrcyopOworCisgICAgLy8gTWV0aG9kIHRoYXQgaXMgdG8gYmUgY2FsbGVkIG9u IHRoZSBtYWluIHRocmVhZC4KKyAgICBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRo cmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViQ29tbW9uV29ya2VyQ2xp ZW50KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2UqLCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgZnJpZW5kIGNs YXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgLy8gTWV0aG9kcyB0aGF0 IGRpc3BhdGNoIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3Mgb24gdGhlIHdvcmtlciB0aHJlYWRzLgor ICAgIC8vIFRoZXkgcmVsZWFzZSBhIHNlbGZSZWYgb2YgdGhlIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2UuCisgICAgc3RhdGljIHZvaWQgZGlkRmFpbE9uV29ya2VyVGhyZWFkKFdlYkNv cmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlKiwgV2ViRmlsZUVycm9yKTsKKyAgICBzdGF0aWMgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9u V29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcm IHJvb3RQYXRoKTsKKworICAgIC8vIEhlbHBlciBtZXRob2RzLgorICAgIHZvaWQgbWF5UG9zdFRh c2tUb1dvcmtlcihQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRh c2s+LCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgLy8gbV9zZWxmUmVmIGtlZXBzIGEgcmVm ZXJlbmNlIHRvIGl0c2VsZiB1bnRpbCBjYWxsYmFja3MgYXJlIGZpcmVkIG9uIHRoZSB3b3JrZXIg dGhyZWFkLgorICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBtX3Nl bGZSZWY7CisKKyAgICBNdXRleCBtX211dGV4OworICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2Vy OworCisgICAgLy8gTm90IG93bmVkLiBUaGV5IG11c3QgYmUgZmlyZWQgb24gdGhlIHdvcmtlciB0 aHJlYWQuCisgICAgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9jYWxsYmFja3NPbldvcmtlclRo cmVhZDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAo= 68463 2010-09-22 16:00:05 -0700 2010-09-22 16:13:35 -0700 Patch bug-45808-20100922160004.patch text/plain 44132 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODJhZjM0MTdiMzE4M2U1MjJkMGYwMGNiYzcxY2I4ODVkZjAwMmM2NS4uMGJiNzkxYmQyZTc4ZTJj MDYxNjcyYTJmMzQ3ZDMwZGJmNjNlMGE1ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMiAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMSAgRGlyayBTY2h1bHpl ICA8a3JpdEB3ZWJraXQub3JnPgogCiAgICAgICAgIFNWRyBGaWx0ZXIgY2xlYW51cApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3Bw IGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCmlu ZGV4IGExNWZkNmQwODAyZmJlZWYxMTA5ZmNhOWM5ZDNiMmYzZDMwMjBjMDQuLjlhOTZmMjI2ZDNj ZmY3Mjc4Yzc5MjY5YTFjODJlNGFjYzc4NDA2NGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcAorKysgYi9XZWJDb3JlL2JpbmRp bmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiU2hhcmVkV29ya2VyUmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgIldlYlNvY2tl dC5oIgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzOjppc0xvY2FsU3RvcmFnZUVuYWJsZWQgPSB0cnVlOwpAQCAtNTcsNiArNjEsMTEg QEAgYm9vbCBSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjppc1hIUlJlc3BvbnNlQmxvYkVuYWJsZWQg PSBmYWxzZTsKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIGJvb2wgUnVudGltZUVuYWJsZWRG ZWF0dXJlczo6aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGZhbHNlOworCitib29sIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXM6OmZpbGVTeXN0ZW1FbmFibGVkKCkKK3sKKyAgICByZXR1cm4gaXNGaWxlU3lz dGVtRW5hYmxlZCAmJiBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCk7Cit9CiAjZW5kaWYK IAogI2lmIEVOQUJMRShWSURFTykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJp Yy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggYi9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5oCmluZGV4IDkxNzY4YjBlNTRlN2Y5N2JhY2QwYTliZDMzOWUx ZGM0MjBkNmVkZWUuLmJhNGE0ZmIwNWRmNTFkNzQ0NGZiOWEzYmExMDAyYWU0N2FiZDVmYzggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmgKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMu aApAQCAtMTQ4LDcgKzE0OCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQotICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCkgeyByZXR1cm4gaXNG aWxlU3lzdGVtRW5hYmxlZDsgfQorICAgIHN0YXRpYyBib29sIGZpbGVTeXN0ZW1FbmFibGVkKCk7 CiAgICAgc3RhdGljIHZvaWQgc2V0RmlsZVN5c3RlbUVuYWJsZWQoYm9vbCBpc0VuYWJsZWQpIHsg aXNGaWxlU3lzdGVtRW5hYmxlZCA9IGlzRW5hYmxlZDsgfQogICAgIHN0YXRpYyBib29sIHJlcXVl c3RGaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9X ZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA1OWVjMmExZTZkN2JiMTlm MWQ0ODM5ZTVlZTM5OTYwMGY2ZTA0NGY2Li5mODI2YjcxYzJkZDdiMTUyNGQwMDhjMjFmZjRiY2Zk Yzk3NzhjOGE3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNw cAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNTAsOSArNTAs MzAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPExvY2FsRmlsZVN5c3Rl bT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK0xvY2Fs RmlsZVN5c3RlbSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNl UGF0aCkKK3sKKyAgICAvLyBGSVhNRTogU2hvdWxkIGluaXRpYWxpemUgdGhlIHF1b3RhIHNldHRp bmdzIGFzIHdlbGwuCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNf aW5zdGFuY2UpOworICAgIGlmIChzX2luc3RhbmNlKQorICAgICAgICByZXR1cm47CisKKyAgICBP d25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihuZXcgTG9j YWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3Rl bS5sZWFrUHRyKCk7Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQoreworICAgIC8vIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0gbXVzdCBi ZSBjYWxsZWQgcHJpb3IgY2FsbGluZyB0aGlzLgorICAgIEFTU0VSVChzX2luc3RhbmNlKTsKKyAg ICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVT eXN0ZW1CYXNlUGF0aCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZp bGVTeXN0ZW0oYmFzZVBhdGgpKTsKKyAgICByZXR1cm4gbV9iYXNlUGF0aDsKIH0KIAogc3RhdGlj IHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmlu ZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIFBhc3NPd25QdHI8RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQpAQCAt NjgsNyArODksNyBAQCB2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaQogICAgIH0KIAogICAgIC8vIEFz eW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3Vz bHksIHNvIHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAg IGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIG1f YmFzZVBhdGgsIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigp LCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2ssIGNvbnRleHQpKSk7CisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tU YXNrKCZvcGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3Vy aXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBuZXcgRmlsZVN5c3RlbUNh bGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiB9CiAK IH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lz dGVtLmggYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggNDhjZmE4ZjY4 ODZhNjBhNDAwNDQ0ZTJmY2ViZWE2OGNkNTIzZGJiNi4uZDA4ZDBmMGYwZmY3MmJiMDA4ZTc0MDAy MDJiYmQyNTQ3M2NkNzU0OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5oCisrKyBiL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaApAQCAtNDQsMjAg KzQ0LDQ0IEBAIGNsYXNzIEVycm9yQ2FsbGJhY2s7CiBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJhY2s7 CiBjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogCi1jbGFzcyBMb2NhbEZpbGVTeXN0ZW0g OiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbEZpbGVTeXN0ZW0+IHsKKy8vIEtlZXBzIHBlci1wcm9j ZXNzIGluZm9ybWF0aW9uIGFuZCBwcm92aWRlcyBhbiBlbnRyeSBwb2ludCB0byBvcGVuIGEgZmls ZSBzeXN0ZW0uCitjbGFzcyBMb2NhbEZpbGVTeXN0ZW0gOiBwdWJsaWMgTm9uY29weWFibGUgewog cHVibGljOgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gY3JlYXRlKGNv bnN0IFN0cmluZyYgYmFzZVBhdGgpOwotICAgIHZpcnR1YWwgfkxvY2FsRmlsZVN5c3RlbSgpIHsg fQorICAgIC8vIFJldHVybnMgYSBwZXItcHJvY2VzcyBpbnN0YW5jZSBvZiBMb2NhbEZpbGVTeXN0 ZW0uCisgICAgLy8gTm90ZSB0aGF0IExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmls ZVN5c3RlbSBtdXN0IGJlIGNhbGxlZCBiZWZvcmUKKyAgICAvLyBjYWxsaW5nIHRoaXMgb25lLgor ICAgIHN0YXRpYyBMb2NhbEZpbGVTeXN0ZW0mIGxvY2FsRmlsZVN5c3RlbSgpOwogCiAgICAgdm9p ZCByZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlU3lz dGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+ LCBQYXNzUmVmUHRyPEVycm9yQ2FsbGJhY2s+KTsKIAotcHJvdGVjdGVkOgorI2lmICFQTEFURk9S TShDSFJPTUlVTSkKKyAgICAvLyBUaGlzIGNhbGwgaXMgbm90IHRocmVhZC1zYWZlOyBtdXN0IGJl IGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVhdGVkLgorICAgIHZvaWQg aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBm aWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdDsKKyNlbmRpZgorCitwcml2YXRlOgogICAgIExvY2Fs RmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQogICAgICAgICA6IG1fYmFzZVBhdGgo YmFzZVBhdGgpCiAgICAgewogICAgIH0KIAotICAgIFN0cmluZyBtX2Jhc2VQYXRoOworICAgIHN0 YXRpYyBMb2NhbEZpbGVTeXN0ZW0qIHNfaW5zdGFuY2U7CisKKyAgICAvLyBBbiBpbm5lciBjbGFz cyB0aGF0IGVuZm9yY2VzIHRocmVhZC1zYWZlIHN0cmluZyBhY2Nlc3MuCisgICAgY2xhc3MgU3lz dGVtQmFzZVBhdGggeworICAgIHB1YmxpYzoKKyAgICAgICAgZXhwbGljaXQgU3lzdGVtQmFzZVBh dGgoY29uc3QgU3RyaW5nJiBwYXRoKSA6IG1fdmFsdWUocGF0aCkgeyB9CisgICAgICAgIG9wZXJh dG9yIFN0cmluZygpIGNvbnN0CisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBtX3ZhbHVl LnRocmVhZHNhZmVDb3B5KCk7CisgICAgICAgIH0KKyAgICBwcml2YXRlOgorICAgICAgICBTdHJp bmcgbV92YWx1ZTsKKyAgICB9OworCisgICAgU3lzdGVtQmFzZVBhdGggbV9iYXNlUGF0aDsKIH07 CiAKIH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNw cCBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCmluZGV4IGY1YmEyNWMzNmE5YWQyYzdmZDE2 NTlhNWI1ZDNkMDZkODdiYTVjNDYuLjZhMjAzY2M3YzQ5MmVjMzNhYmUwMDI5MmUzYTA0OGQ4YTJh YzM0MWQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwCisrKyBiL1dlYkNv cmUvcGFnZS9ET01XaW5kb3cuY3BwCkBAIC03MjcsMjUgKzcyNywxNiBAQCB2b2lkIERPTVdpbmRv dzo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNzUmVmUHRy PEZpbGVTeXN0ZQogICAgIGlmICghZG9jdW1lbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlm ICghbV9sb2NhbEZpbGVTeXN0ZW0pIHsKLSAgICAgICAgLy8gRklYTUU6IFNlZSBpZiBhY2Nlc3Mg aXMgYWxsb3dlZC4KLQotICAgICAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKTsKLSAg ICAgICAgaWYgKCFwYWdlKSB7Ci0gICAgICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNh bGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShJTlZBTElE X1NUQVRFX0VSUikpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0KLSAgICAgICAg Ly8gRklYTUU6IEdldCB0aGUgcXVvdGEgc2V0dGluZ3MgYXMgd2VsbC4KLSAgICAgICAgU3RyaW5n IHBhdGggPSBwYWdlLT5zZXR0aW5ncygpLT5maWxlU3lzdGVtUm9vdFBhdGgoKTsKLSAgICAgICAg bV9sb2NhbEZpbGVTeXN0ZW0gPSBMb2NhbEZpbGVTeXN0ZW06OmNyZWF0ZShwYXRoKTsKKyAgICBp ZiAoIUFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKSB8fCAhZG9jdW1lbnQtPnNlY3VyaXR5 T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0oKSkgeworICAgICAgICBET01GaWxlU3lzdGVt OjpzY2hlZHVsZUNhbGxiYWNrKGRvY3VtZW50LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNy ZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fbG9j YWxGaWxlU3lzdGVtLT5yZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5 bmNGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNh bGxiYWNrKTsKKyAgICBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLnJlcXVlc3RG aWxlU3lzdGVtKGRvY3VtZW50LCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5 cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOwogfQogCi1DT01QSUxF X0FTU0VSVChpbnQoRE9NV2luZG93OjpURU1QT1JBUlkpID09IGludChBc3luY0ZpbGVTeXN0ZW06 OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gpOwotQ09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRv dzo6UEVSU0lTVEVOVCkgPT0gaW50KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVudW1f bWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5kb3c6OlRF TVBPUkFSWSkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSks IGVudW1fbWlzbWF0Y2gpOworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihET01XaW5k b3c6OlBFUlNJU1RFTlQpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpQZXJz aXN0ZW50KSwgZW51bV9taXNtYXRjaCk7CiAKICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmggYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKaW5kZXggMTQ3MDYy ODY1ZDliOWI3NzQ3MTY5YWZiMjE4NDFkNjZmMTFkOWNkNC4uNmZkMzc3NTAzYWI0ZWVmMWQ5ZTc3 NWY5ODMwNGQxMTMxZmFmYjAzYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5o CisrKyBiL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaApAQCAtNTgsNyArNTgsNiBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgSGlzdG9yeTsKICAgICBjbGFzcyBJREJGYWN0b3J5Owog ICAgIGNsYXNzIEluc3BlY3RvclRpbWVsaW5lQWdlbnQ7Ci0gICAgY2xhc3MgTG9jYWxGaWxlU3lz dGVtOwogICAgIGNsYXNzIExvY2F0aW9uOwogICAgIGNsYXNzIFN0eWxlTWVkaWE7CiAgICAgY2xh c3MgTmF2aWdhdG9yOwpAQCAtNDQ0LDkgKzQ0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNp ZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8SURCRmFj dG9yeT4gbV9pZGJGYWN0b3J5OwogI2VuZGlmCi0jaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQotICAg ICAgICBSZWZQdHI8TG9jYWxGaWxlU3lzdGVtPiBtX2xvY2FsRmlsZVN5c3RlbTsKLSNlbmRpZgog CiAgICAgICAgIEV2ZW50VGFyZ2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsKIApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaAppbmRleCA0Nzg5ZDNjZTExYTBhMjMxNTU2MTlhYmMxMDRlYjk4MWRjZWQ1ZWVmLi4y YTYzOTY2ZDQ4N2JkM2E2Yjc2NjM3MTYyMzM1YzU4Yzk3NDcxNjUxIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmln aW4uaApAQCAtMTIxLDYgKzEyMSw3IEBAIHB1YmxpYzoKICAgICBib29sIGNhbkFjY2Vzc0xvY2Fs U3RvcmFnZSgpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9vbCBjYW5BY2Nl c3NDb29raWVzKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0KICAgICBib29sIGNhbkFj Y2Vzc1Bhc3N3b3JkTWFuYWdlcigpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CisgICAg Ym9vbCBjYW5BY2Nlc3NGaWxlU3lzdGVtKCkgY29uc3QgeyByZXR1cm4gIWlzVW5pcXVlKCk7IH0K IAogICAgIC8vIFRlY2huaWNhbGx5LCB3ZSBzaG91bGQgYWx3YXlzIGFsbG93IGFjY2VzcyB0byBz ZXNzaW9uU3RvcmFnZSwgYnV0IHdlCiAgICAgLy8gY3VycmVudGx5IGRvbid0IGhhbmRsZSBjcmVh dGluZyBhIHNlc3Npb25TdG9yYWdlIGFyZWEgZm9yIHVuaXF1ZQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFj MGE1ZjQ5NjhkYjZhNGFhMWQ3OTQ2ZmViZGQzZWY2OTUxNDdhNS4uNGQxNjYyYjYzNmE5ODE0MTY4 YjZlNTg4NDhhNTcwYjZiNjU5MTYyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC00OTcsMTEgKzQ5Nyw2IEBA IHZvaWQgU2V0dGluZ3M6OnNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcm IHBhdGgpCiAgICAgbV9sb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGggPSBwYXRoOwogfQogCi12b2lk IFNldHRpbmdzOjpzZXRGaWxlU3lzdGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJiBwYXRoKQotewot ICAgIG1fZmlsZVN5c3RlbVJvb3RQYXRoID0gcGF0aDsKLX0KLQogdm9pZCBTZXR0aW5nczo6c2V0 QXBwbGljYXRpb25DaHJvbWVNb2RlKGJvb2wgbW9kZSkKIHsKICAgICBtX2luQXBwbGljYXRpb25D aHJvbWVNb2RlID0gbW9kZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggOTlhNGYyMzJjNTI5ODA2ZWFhMjdmODVkNTdk YmJhYjEyNzQ0YmYzMy4uZjhhMjk3YTE3YjA1NTY5ZDg1ZmM3YjExMGM0NjU2ZjQ0NzQwNzY0YSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1Nl dHRpbmdzLmgKQEAgLTI0MSw5ICsyNDEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAg IHZvaWQgc2V0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoKGNvbnN0IFN0cmluZyYpOwogICAgICAg ICBjb25zdCBTdHJpbmcmIGxvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCgpIGNvbnN0IHsgcmV0dXJu IG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoOyB9CiAKLSAgICAgICAgdm9pZCBzZXRGaWxlU3lz dGVtUm9vdFBhdGgoY29uc3QgU3RyaW5nJik7Ci0gICAgICAgIGNvbnN0IFN0cmluZyYgZmlsZVN5 c3RlbVJvb3RQYXRoKCkgY29uc3QgeyByZXR1cm4gbV9maWxlU3lzdGVtUm9vdFBhdGg7IH0KLQog ICAgICAgICB2b2lkIHNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sKTsKICAgICAgICAgYm9v bCBpbkFwcGxpY2F0aW9uQ2hyb21lTW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faW5BcHBsaWNhdGlv bkNocm9tZU1vZGU7IH0KIApAQCAtMzM2LDcgKzMzMyw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgU3RyaW5nIG1fZGVmYXVsdFRleHRFbmNvZGluZ05hbWU7CiAgICAgICAgIFN0cmlu ZyBtX2Z0cERpcmVjdG9yeVRlbXBsYXRlUGF0aDsKICAgICAgICAgU3RyaW5nIG1fbG9jYWxTdG9y YWdlRGF0YWJhc2VQYXRoOwotICAgICAgICBTdHJpbmcgbV9maWxlU3lzdGVtUm9vdFBhdGg7CiAg ICAgICAgIEtVUkwgbV91c2VyU3R5bGVTaGVldExvY2F0aW9uOwogICAgICAgICBBdG9taWNTdHJp bmcgbV9zdGFuZGFyZEZvbnRGYW1pbHk7CiAgICAgICAgIEF0b21pY1N0cmluZyBtX2ZpeGVkRm9u dEZhbWlseTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cCBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCBiNGZjZDBkNGQ5 YjRmYmNlZDk0NjEzODVjMTNhNmNlYmI2OWZjN2FmLi41NzMwNWZmYzJiYTBjNGE0ZjNhNmUzZGU4 ZjIxYWFlNDE5Zjg1ZTU5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwCkBAIC0z NSwxMiArMzUsMjAgQEAKIAogI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgog I2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKKyNpZiAhUExBVEZPUk0oQ0hST01JVU0pCitib29sIEFzeW5j RmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAg cmV0dXJuIGZhbHNlOworfQorCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxl U3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJikKIHsKLSAgICAvLyBGSVhNRTogcmV0dXJuIGRl ZmF1bHQgQXN5bmNGaWxlU3lzdGVtIGltcGxlbWVudGF0aW9uLgorICAgIG5vdEltcGxlbWVudGVk KCk7CiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTYyLDYgKzcwLDcgQEAgdm9pZCBBc3luY0ZpbGVT eXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmlu ZyYgc3RvcmEKIAogICAgIGNhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNG aWxlU3lzdGVtOjpjcmVhdGUocm9vdFBhdGgpKTsKIH0KKyNlbmRpZgogCiAvLyBEZWZhdWx0IGlt cGxlbWVudGF0aW9uLgogU3RyaW5nIEFzeW5jRmlsZVN5c3RlbTo6dmlydHVhbFRvUGxhdGZvcm1Q YXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZv cm0vQXN5bmNGaWxlU3lzdGVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5o CmluZGV4IDYwMWYwZWFlM2U1ZDBlOGJlYjg0ZDVhOTkzZDc3MDUxN2JkMGE2MmQuLjhjNGQ1ZDk5 MGZkYTQ2YzJiNzgwZGY5YjA5YTYwNzdlNTRkOWZmNTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxh dGZvcm0vQXN5bmNGaWxlU3lzdGVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVT eXN0ZW0uaApAQCAtNTYsNiArNTYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0b3Ao KSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgeyByZXR1cm4gZmFs c2U7IH0KIAorICAgIHN0YXRpYyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICAvLyBDcmVhdGVz IGFuZCByZXR1cm5zIGEgbmV3IHBsYXRmb3JtLXNwZWNpZmljIEFzeW5jRmlsZVN5c3RlbSBpbnN0 YW5jZSBpZiB0aGUgcGxhdGZvcm0gaGFzIGl0cyBvd24gaW1wbGVtZW50YXRpb24uCiAgICAgc3Rh dGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBjcmVhdGUoY29uc3QgU3RyaW5nJiByb290 UGF0aCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcCBi L1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAppbmRleCBiNTJiMjg1NDc1ZjJlZjk0 NzdlODE0YmJlNGQ4YmViOWMzYjllYTBhLi43MDM3YTRmZTM0YWIyNWE2NTY3NDU3MDQ2NGEzNGJi ZjIxMWYzOTU5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAK KysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCkBAIC02Myw2ICs2MywxNSBA QAogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNlbnRlci5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUo RklMRV9TWVNURU0pCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiRE9N RmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgIkVycm9yQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJGaWxl RXJyb3IuaCIKKyNpbmNsdWRlICJGaWxlU3lzdGVtQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJMb2Nh bEZpbGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENs b3NlV29ya2VyQ29udGV4dFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFz ayB7CkBAIC0xMDAsNiArMTA5LDEwIEBAIFdvcmtlckNvbnRleHQ6On5Xb3JrZXJDb250ZXh0KCkK ICNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKICAgICBtX25vdGlmaWNhdGlvbnMuY2xlYXIoKTsK ICNlbmRpZgorCisgICAgLy8gTWFrZSBzdXJlIHdlIGhhdmUgbm8gb2JzZXJ2ZXJzLgorICAgIG5v dGlmeU9ic2VydmVyc09mU3RvcCgpOworCiAgICAgLy8gTm90aWZ5IHByb3h5IHRoYXQgd2UgYXJl IGdvaW5nIGF3YXkuIFRoaXMgY2FuIGZyZWUgdGhlIFdvcmtlclRocmVhZCBvYmplY3QsIHNvIGRv IG5vdCBhY2Nlc3MgaXQgYWZ0ZXIgdGhpcy4KICAgICB0aHJlYWQoKS0+d29ya2VyUmVwb3J0aW5n UHJveHkoKS53b3JrZXJDb250ZXh0RGVzdHJveWVkKCk7CiB9CkBAIC0zMzUsNiArMzQ4LDY3IEBA IHZvaWQgV29ya2VyQ29udGV4dDo6cmV2b2tlQmxvYlVSTChjb25zdCBTdHJpbmcmIGJsb2JVUkxT dHJpbmcpCiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKK3ZvaWQgV29ya2Vy Q29udGV4dDo6cmVxdWVzdEZpbGVTeXN0ZW0oaW50IHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQYXNz UmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEVy cm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCit7CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06 OmlzQXZhaWxhYmxlKCkgfHwgIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0ZpbGVTeXN0ZW0o KSkgeworICAgICAgICBET01GaWxlU3lzdGVtOjpzY2hlZHVsZUNhbGxiYWNrKHRoaXMsIGVycm9y Q2FsbGJhY2ssIEZpbGVFcnJvcjo6Y3JlYXRlKFNFQ1VSSVRZX0VSUikpOworICAgICAgICByZXR1 cm47CisgICAgfQorCisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5yZXF1 ZXN0RmlsZVN5c3RlbSh0aGlzLCBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW06OlR5cGU+KHR5 cGUpLCBzaXplLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworfQorCitDT01QSUxF X0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdvcmtlckNvbnRleHQ6OlRFTVBPUkFSWSkgPT0gc3Rh dGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlRlbXBvcmFyeSksIGVudW1fbWlzbWF0Y2gp OworQ09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpQRVJTSVNU RU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3RlbTo6UGVyc2lzdGVudCksIGVu dW1fbWlzbWF0Y2gpOworI2VuZGlmCisKK1dvcmtlckNvbnRleHQ6Ok9ic2VydmVyOjpPYnNlcnZl cihXb3JrZXJDb250ZXh0KiBjb250ZXh0KQorICAgIDogbV9jb250ZXh0KGNvbnRleHQpCit7Cisg ICAgQVNTRVJUKG1fY29udGV4dCAmJiBtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAg ICBtX2NvbnRleHQtPnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7Cit9CisKK1dvcmtlckNvbnRleHQ6 Ok9ic2VydmVyOjp+T2JzZXJ2ZXIoKQoreworICAgIGlmICghbV9jb250ZXh0KQorICAgICAgICBy ZXR1cm47CisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpOworICAgIG1f Y29udGV4dC0+dW5yZWdpc3Rlck9ic2VydmVyKHRoaXMpOworfQorCit2b2lkIFdvcmtlckNvbnRl eHQ6Ok9ic2VydmVyOjpzdG9wT2JzZXJ2aW5nKCkKK3sKKyAgICBpZiAoIW1fY29udGV4dCkKKyAg ICAgICAgcmV0dXJuOworICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsK KyAgICBtX2NvbnRleHQtPnVucmVnaXN0ZXJPYnNlcnZlcih0aGlzKTsKKyAgICBtX2NvbnRleHQg PSAwOworfQorCit2b2lkIFdvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIq IG9ic2VydmVyKQoreworICAgIEFTU0VSVChvYnNlcnZlcik7CisgICAgbV93b3JrZXJPYnNlcnZl cnMuYWRkKG9ic2VydmVyKTsKK30KKwordm9pZCBXb3JrZXJDb250ZXh0Ojp1bnJlZ2lzdGVyT2Jz ZXJ2ZXIoT2JzZXJ2ZXIqIG9ic2VydmVyKQoreworICAgIEFTU0VSVChvYnNlcnZlcik7CisgICAg bV93b3JrZXJPYnNlcnZlcnMucmVtb3ZlKG9ic2VydmVyKTsKK30KKwordm9pZCBXb3JrZXJDb250 ZXh0Ojpub3RpZnlPYnNlcnZlcnNPZlN0b3AoKQoreworICAgIEhhc2hTZXQ8T2JzZXJ2ZXIqPjo6 aXRlcmF0b3IgaXRlciA9IG1fd29ya2VyT2JzZXJ2ZXJzLmJlZ2luKCk7CisgICAgd2hpbGUgKGl0 ZXIgIT0gbV93b3JrZXJPYnNlcnZlcnMuZW5kKCkpIHsKKyAgICAgICAgKCppdGVyKS0+bm90aWZ5 U3RvcCgpOworICAgICAgICAoKml0ZXIpLT5zdG9wT2JzZXJ2aW5nKCk7CisgICAgICAgIGl0ZXIg PSBtX3dvcmtlck9ic2VydmVycy5iZWdpbigpOworICAgIH0KK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdPUktFUlMpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQu aAppbmRleCA3ZmI4YjQ2ZjM4N2NjMDY4NDMxZmQzMzRkYzBmYjVlNGQwYTE4MDNhLi5kYWQyYWYz NWJkN2E1Yzk4ODA3ZTA4MWM4NDI5NGMxYWNhZmE1YTczIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dv cmtlcnMvV29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0 LmgKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0Lmgi CiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgPHd0Zi9Bc3Nl cnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvT3duUHRy Lmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRl ZC5oPgpAQCAtNDcsNiArNDgsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgRGF0 YWJhc2U7CiAgICAgY2xhc3MgRGF0YWJhc2VDYWxsYmFjazsKICAgICBjbGFzcyBEYXRhYmFzZVN5 bmM7CisgICAgY2xhc3MgRXJyb3JDYWxsYmFjazsKKyAgICBjbGFzcyBGaWxlU3lzdGVtQ2FsbGJh Y2s7CiAgICAgY2xhc3MgTm90aWZpY2F0aW9uQ2VudGVyOwogICAgIGNsYXNzIFNjaGVkdWxlZEFj dGlvbjsKICAgICBjbGFzcyBXb3JrZXJMb2NhdGlvbjsKQEAgLTEyMSw2ICsxMjQsMTQgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwoY29uc3QgU3RyaW5n Jik7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyAgICAgICAgZW51bSBGaWxl U3lzdGVtVHlwZSB7CisgICAgICAgICAgICBURU1QT1JBUlksCisgICAgICAgICAgICBQRVJTSVNU RU5ULAorICAgICAgICB9OworICAgICAgICB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBl LCBsb25nIGxvbmcgc2l6ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+LCBQYXNzUmVm UHRyPEVycm9yQ2FsbGJhY2s+KTsKKyNlbmRpZgorCiAgICAgICAgIC8vIFRoZXNlIG1ldGhvZHMg YXJlIHVzZWQgZm9yIEdDIG1hcmtpbmcuIFNlZSBKU1dvcmtlckNvbnRleHQ6Om1hcmtDaGlsZHJl bihNYXJrU3RhY2smKSBpbgogICAgICAgICAvLyBKU1dvcmtlckNvbnRleHRDdXN0b20uY3BwLgog ICAgICAgICBXb3JrZXJOYXZpZ2F0b3IqIG9wdGlvbmFsTmF2aWdhdG9yKCkgY29uc3QgeyByZXR1 cm4gbV9uYXZpZ2F0b3IuZ2V0KCk7IH0KQEAgLTEzMSw2ICsxNDIsMjEgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogCiAgICAgICAgIGJvb2wgaXNDbG9zaW5nKCkgeyByZXR1cm4gbV9jbG9zaW5nOyB9 CiAKKyAgICAgICAgLy8gQW4gb2JzZXJ2ZXIgaW50ZXJmYWNlIHRvIGJlIG5vdGlmaWVkIHdoZW4g dGhlIHdvcmtlciB0aHJlYWQgaXMgZ2V0dGluZyBzdG9wcGVkLgorICAgICAgICBjbGFzcyBPYnNl cnZlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CisgICAgICAgIHB1YmxpYzoKKyAgICAgICAgICAg IE9ic2VydmVyKFdvcmtlckNvbnRleHQqKTsKKyAgICAgICAgICAgIHZpcnR1YWwgfk9ic2VydmVy KCk7CisgICAgICAgICAgICB2aXJ0dWFsIHZvaWQgbm90aWZ5U3RvcCgpID0gMDsKKyAgICAgICAg ICAgIHZvaWQgc3RvcE9ic2VydmluZygpOworICAgICAgICBwcm90ZWN0ZWQ6CisgICAgICAgICAg ICBXb3JrZXJDb250ZXh0KiBtX2NvbnRleHQ7CisgICAgICAgIH07CisgICAgICAgIGZyaWVuZCBj bGFzcyBPYnNlcnZlcjsKKyAgICAgICAgdm9pZCByZWdpc3Rlck9ic2VydmVyKE9ic2VydmVyKiBv YnNlcnZlcik7CisgICAgICAgIHZvaWQgdW5yZWdpc3Rlck9ic2VydmVyKE9ic2VydmVyKiBvYnNl cnZlcik7CisgICAgICAgIHZvaWQgbm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCk7CisKICAgICBwcm90 ZWN0ZWQ6CiAgICAgICAgIFdvcmtlckNvbnRleHQoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYs IFdvcmtlclRocmVhZCopOwogCkBAIC0xNjEsNiArMTg3LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICBib29sIG1fY2xvc2luZzsKICAgICAgICAgYm9vbCBtX3JlcG9ydGluZ0V4Y2Vw dGlvbjsKICAgICAgICAgRXZlbnRUYXJnZXREYXRhIG1fZXZlbnRUYXJnZXREYXRhOworCisgICAg ICAgIEhhc2hTZXQ8T2JzZXJ2ZXIqPiBtX3dvcmtlck9ic2VydmVyczsKICAgICB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5pZGwgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKaW5kZXggMDJhYTRh ZGI4OGJjMmRmNjdmMjdkNWVjZTJiNWE5MjMyODY3ODEyNC4uM2UxODVjMGQ1YjhlMGExMzdiZDky OGM1MmEyZGJhODE3NWY4MDMzNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuaWRsCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbApAQCAtMTA0 LDYgKzEwNCwxNCBAQCBtb2R1bGUgdGhyZWFkcyB7CiAgICAgICAgIERPTVN0cmluZyBjcmVhdGVC bG9iVVJMKGluIEJsb2IgYmxvYik7CiAgICAgICAgIHZvaWQgcmV2b2tlQmxvYlVSTChpbiBET01T dHJpbmcgYmxvYlVSTCk7CiAjZW5kaWYKKworI2lmIGRlZmluZWQoRU5BQkxFX0ZJTEVfU1lTVEVN KSAmJiBFTkFCTEVfRklMRV9TWVNURU0KKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgVEVN UE9SQVJZID0gMDsKKyAgICAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQgUEVSU0lTVEVOVCA9IDE7 CisgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSB2b2lkIHJlcXVlc3RGaWxlU3lzdGVtKGluIHVu c2lnbmVkIHNob3J0IHR5cGUsIGluIGxvbmcgbG9uZyBzaXplLCBpbiBbQ2FsbGJhY2ssIE9wdGlv bmFsXSBGaWxlU3lzdGVtQ2FsbGJhY2sgc3VjY2Vzc0NhbGxiYWNrLCBpbiBbQ2FsbGJhY2ssIE9w dGlvbmFsXSBFcnJvckNhbGxiYWNrIGVycm9yQ2FsbGJhY2spOworCisgICAgICAgICAgICAgICAg IGF0dHJpYnV0ZSBbRW5hYmxlZEF0UnVudGltZT1GaWxlU3lzdGVtXSBGbGFnc0NvbnN0cnVjdG9y IEZsYWdzOworI2VuZGlmCiAgICAgfTsKIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJz L1dvcmtlclRocmVhZC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcAppbmRl eCBkNmExZTA1N2QzZWQ4MThhMzc4ZTc1MzY2NjlmM2EwYTdiOTQ1N2ZlLi5mNjExMjBlZWUwNGMz MWE4MDBmZjU2MjlhZjlhMmI4MGE0NjdhM2M0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMv V29ya2VyVGhyZWFkLmNwcAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcApA QCAtMjAyLDYgKzIwMiw4IEBAIHB1YmxpYzoKIAogICAgICAgICB3b3JrZXJDb250ZXh0LT5zdG9w QWN0aXZlRE9NT2JqZWN0cygpOwogCisgICAgICAgIHdvcmtlckNvbnRleHQtPm5vdGlmeU9ic2Vy dmVyc09mU3RvcCgpOworCiAgICAgICAgIC8vIEV2ZW50IGxpc3RlbmVycyB3b3VsZCBrZWVwIERP TVdyYXBwZXJXb3JsZCBvYmplY3RzIGFsaXZlIGZvciB0b28gbG9uZy4gQWxzbywgdGhleSBoYXZl IHJlZmVyZW5jZXMgdG8gSlMgb2JqZWN0cywKICAgICAgICAgLy8gd2hpY2ggYmVjb21lIGRhbmds aW5nIG9uY2UgSGVhcCBpcyBkZXN0cm95ZWQuCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnJlbW92 ZUFsbEV2ZW50TGlzdGVuZXJzKCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA1NmYyYzVhNTllZWEzYjdiODA5 OTBiNThiODA4NjNiMmMxMTBkYTc2Li5lYzAyZGM0NzNhNDNmMTA1NGIwNzJlZTVkOTJkM2JmZDll MGQ2MDBmIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMC0wOS0yMiAgS2ludWtv IFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU4 MDgKKworICAgICAgICBBZGRlZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbSBhbmQgV2Vi Q29tbW9uV29ya2VyQ2xpZW50OjoKKyAgICAgICAgb3BlbkZpbGVTeXN0ZW0gdG8gY2FsbCBpbiB0 byB0aGUgYnJvd3NlciB2aWEgV29ya2VyIHN0dWIvcHJveHkKKyAgICAgICAgaW4gdGhlIGNocm9t aXVtLgorCisgICAgICAgIEFsc28gYWRkZWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSBjbGFzcyB0aGF0IHByb3hpZXMKKyAgICAgICAgcmVxdWVzdHMgYW5kIGNhbGxiYWNrcyBiZXR3 ZWVuIGZyb20vdG8gd29ya2VyIHRocmVhZCB0by9mcm9tIHRoZQorICAgICAgICBtYWluIHRocmVh ZC4KKworICAgICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAg KFdlYktpdDo6V2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgor ICAgICAgICAqIHNyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIGltcGxl bWVudGF0aW9uCisgICAgICAgIGZvciB3b3JrZXJzLiBJbiB3b3JrZXIgY2FzZSB0aGlzIGNhbGxz IFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtLgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJC YXNlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0p OiBBZGRlZC4gVGhpcyBpcyBjYWxsZWQgZnJvbQorICAgICAgICBMb2NhbEZpbGVTeXN0ZW06OnJl cXVlc3RGaWxlU3lzdGVtIG9uIHRoZSB3b3JrZXIgdGhyZWFkIGFuZCBjcmVhdGVzCisgICAgICAg IGEgYnJpZGdlIHRvIGNhbGwgV2ViQ29tbW9uV29ya2VyQ2xpZW50OjpvcGVuRmlsZVN5c3RlbSBv biB0aGUgbWFpbgorICAgICAgICB0aHJlYWQuCisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2Uu aDoKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViS2l0 OjpXZWJXb3JrZXJDbGllbnRJbXBsOjpvcGVuRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAgICAq IHNyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNwcDogQWRkZWQuCisgICAgICAg ICogc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaDogQWRkZWQuCisKIDIwMTAt MDktMjAgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IEVyaWMgQ2FybHNvbi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9X ZWJLaXQuZ3lwIGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggMzUyM2YyMWExYjE0 ODU3YTFjNDVjY2I2YjNmMzhiMTBmZDEyNmFjYy4uODc0ZDQ4NThmYjFhYTQ5YTViNzNjMmY0MGI3 OTZmMTFhOTIyMzYwMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKKysr IGIvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKQEAgLTUzMyw2ICs1MzMsOCBAQAogICAgICAg ICAgICAgICAgICdzcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oJywKICAgICAgICAgICAgICAgICAn c3JjL1dlYldvcmtlckltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYldvcmtlcklt cGwuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tz QnJpZGdlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV3JhcHBlZFJlc291cmNlUmVxdWVzdC5o JywKICAgICAgICAgICAgICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlc3BvbnNlLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvd2luL1dlYklucHV0RXZlbnRGYWN0b3J5LmNwcCcsCmRpZmYgLS1n aXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oIGIvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAppbmRleCBjZWE2NDcx MjNhNTJmNTAzMjg1MDg5MGRjODQ1NTJjNDE2NDRmZjJkLi40ZjE0ZjJhZmUwYWFjYTJlYzUzYmI1 YzhlNzg3Yzk2YTJkY2Q2ZDIwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YkNvbW1vbldvcmtlckNsaWVudC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29t bW9uV29ya2VyQ2xpZW50LmgKQEAgLTMxLDYgKzMxLDkgQEAKICNpZm5kZWYgV2ViQ29tbW9uV29y a2VyQ2xpZW50X2gKICNkZWZpbmUgV2ViQ29tbW9uV29ya2VyQ2xpZW50X2gKIAorI2luY2x1ZGUg IldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKwogbmFtZXNwYWNlIFdl YktpdCB7CiAKIGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0OwpAQCAtODMsNiArODYsMTMg QEAgcHVibGljOgogICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9y ZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNl KFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3Bs YXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKIAorICAgIC8vIENhbGxl ZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgZmlsZSBzeXN0ZW0u CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxv bmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKikKKyAgICB7CisgICAgICAgIC8v IEZJWE1FOiBXZSBuZWVkIGEgc3R1YiBpbXBsZW1lbnRhdGlvbiB1bnRpbCBzdWJjbGFzcyBpbiBj aHJvbWl1bSBpbXBsZW1lbnQgdGhpcy4KKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hF RCgpOworICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7 IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNo cm9taXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0u Y3BwCmluZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUz YjNkMTUyYzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJs ZSgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpB c3luY0ZpbGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5 bmNGaWxlU3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2Vi S2l0Q2xpZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2Nh bEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2Vj YTljZTgyMjBmMjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMxOCAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5j cHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAK QEAgLTQyLDE0ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBs LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwu aCIKKyNpbmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5o IgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4K IAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNz UmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3Ry aW5nJiBwYXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5 c3RlbSgpCiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkp OworICAgIEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBsb2Nh bEZpbGVTeXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICpsb2Nh bEZpbGVTeXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3Rl bShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUg dHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNj ZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKQEAg LTYwLDcgKzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZyYW1l SW1wbCogd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJhbWUo KSk7CiAgICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUs IHN0YXRpY19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmls ZVN5c3RlbUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxi YWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAgIC8v IEZJWE1FOiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtlckNv bnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4 dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3Jr ZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29y a2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxv YWRlclByb3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNfY2Fz dDxXZWJGaWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxs YmFja3NJbXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JD YWxsYmFjaywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckJhc2UuY3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUu LmE2OWFhZGE0YjI3YTc5ZTdlYzVkYjA0ZGNjZWEzZThiOWNiN2QwMjIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBsYXRm b3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5o IgorI2luY2x1ZGUgIldlYkZpbGVFcnJvci5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50Lmgi CiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRDaGFu bmVsLmgiCkBAIC00NSw2ICs0Niw4IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUg IldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgIldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKICNpbmNsdWRlICJXb3JrZXJT Y3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8 d3RmL01haW5UaHJlYWQuaD4KQEAgLTU2LDYgKzU5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAj aWYgRU5BQkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2Rl W10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0 ZW1Nb2RlW10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKIAogbmFtZXNwYWNlIHsKIApAQCAtMTE0 LDYgKzExOCw3IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAgICAg V1RGOjpTdHJpbmcgbV9tb2RlOwogfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxl ZCBvbiB0aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwpA QCAtMjMxLDYgKzIzNiwxNiBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2Vi RnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVybiBi cmlkZ2UtPnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVt KFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1D YWxsYmFja3MqIGNhbGxiYWNrcykKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93 b3JrZXJUaHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250 cm9sbGVyID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsK KyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2VyQ29u dGV4dCgpOworCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJy aWRnZSA9IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmNyZWF0ZSh0aGlzLCB3b3Jr ZXJDb250ZXh0LCBjYWxsYmFja3MpOworICAgIGJyaWRnZS0+cG9zdE9wZW5GaWxlU3lzdGVtVG9N YWluVGhyZWFkKGNvbW1vbkNsaWVudCgpLCB0eXBlLCBzaXplLCBvcGVuRmlsZVN5c3RlbU1vZGUp OworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBv c3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+ IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu aCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlmMjJj ZjcwNmJkZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNjYWVh MzdhOWZlYzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2Vy QmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05MSw2 ICs5MSw5IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIg RGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9vbCBh bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisgICAg Ly8gUmVxdWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5vdGUg dGhhdCB0aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50Ojpv cGVuRmlsZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpU eXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAgLy8g RXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2 b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNs aWVudEltcGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVmNTQ1 Li4wNjA0ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0gYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAjaWYg RU5BQkxFKFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAi V2ViV29ya2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIKICNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAgLTk5 LDYgKzk5LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAg ICAgIHJldHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0o V2ViRnJhbWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5 c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpkaWZm IC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uOWJmMmZmNjgwMjZmNDMxYWM3YmQ2ZTE4MzEyMjMyZjE5Mjgz YTkyOQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAKQEAgLTAsMCArMSwxODYgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisjaW5jbHVkZSAiV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgorCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5j bHVkZSAiV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNh bGxiYWNrcy5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5oIgorI2luY2x1ZGUgIldlYldvcmtlckJh c2UuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyU2NyaXB0 Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9N YWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCit1c2luZyBuYW1lc3Bh Y2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFj a3MgdGhhdCBhcmUgdG8gYmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBN YWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJh Y2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY3JlYXRlKFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZT4gYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICByZXR1cm4g YWRvcHRQdHIobmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSwgbW9kZSkp OworICAgIH0KKworICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKCkK KyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0 IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgIHsKKyAgICAgICAg bV9icmlkZ2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgsIG1fbW9k ZSk7CisgICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRG YWlsKFdlYkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRGYWls T25NYWluVGhyZWFkKGVycm9yLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9 CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpCisgICAgeworICAgICAgICBXRUJLSVRf QVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRN ZXRhZGF0YShjb25zdCBXZWJGaWxlSW5mbyYgaW5mbykKKyAgICB7CisgICAgICAgIFdFQktJVF9B U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZERp cmVjdG9yeShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYgZW50cmllcywgYm9v bCBoYXNNb3JlKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwor ICAgIH0KKworcHJpdmF0ZToKKyAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNz UmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3Ry aW5nJiBtb2RlKQorICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgLCBtX21vZGUo bW9kZSkKKyAgICB7CisgICAgICAgIEFTU0VSVChtX2JyaWRnZS5nZXQoKSk7CisgICAgfQorCisg ICAgZnJpZW5kIGNsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U7CisgICAgUmVm UHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fYnJpZGdlOworICAgIGNvbnN0 IFN0cmluZyBtX21vZGU7Cit9OworCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgV2ViRmlsZVN5c3Rl bUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIDogV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIoc3Rh dGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpKQorICAgICwg bV93b3JrZXIod29ya2VyKQorICAgICwgbV9jYWxsYmFja3NPbldvcmtlclRocmVhZChjYWxsYmFj a3MpCit7Cit9CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6On5Xb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlKCkKK3sKKyAgICBBU1NFUlQoIW1fY2FsbGJhY2tzT25Xb3Jr ZXJUaHJlYWQpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnN0 b3AoKQoreworICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAgICBN dXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAgbV93b3JrZXIgPSAwOworCisgICAgaWYg KG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgbV9jYWxsYmFja3NPbldvcmtl clRocmVhZC0+ZGlkRmFpbChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIG1fY2FsbGJhY2tz T25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1Ub01haW5UaHJlYWQoV2ViQ29tbW9uV29y a2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBs b25nIHNpemUsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0aGlzOwor ICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAgICBBU1NFUlQobV93 b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2Fs bGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCwgY29tbW9uQ2xpZW50LCB0eXBl LCBzaXplLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpU eXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl KiBicmlkZ2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFk KCkpOworICAgIGlmICghY29tbW9uQ2xpZW50KQorICAgICAgICBicmlkZ2UtPmRpZEZhaWxPbk1h aW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQsIG1vZGUpOworICAgIGVsc2UgeworICAgICAgICAv LyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBpcyBzZWxmLWRlc3RydWN0ZWQsIHNvIHdl IGxlYWsgcHRyIGhlcmUuCisgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZpbGVTeXN0ZW0odHlw ZSwgc2l6ZSwgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6OmNyZWF0ZShicmlkZ2UsIG1v ZGUpLmxlYWtQdHIoKSk7CisgICAgfQorfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2U6OmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yIGVycm9yLCBjb25zdCBT dHJpbmcmIG1vZGUpCit7CisgICAgbWF5UG9zdFRhc2tUb1dvcmtlcihjcmVhdGVDYWxsYmFja1Rh c2soJmRpZEZhaWxPbldvcmtlclRocmVhZCwgdGhpcy0+bV9zZWxmUmVmLCBlcnJvciksIG1vZGUp OworICAgIHRoaXMtPm1fc2VsZlJlZi5jbGVhcigpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0 ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFN0 cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5nJiBtb2RlKQor eworICAgIG1heVBvc3RUYXNrVG9Xb3JrZXIoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRPcGVuRmls ZVN5c3RlbU9uV29ya2VyVGhyZWFkLCB0aGlzLT5tX3NlbGZSZWYsIG5hbWUsIHJvb3RQYXRoKSwg bW9kZSk7CisgICAgdGhpcy0+bV9zZWxmUmVmLmNsZWFyKCk7Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkRmFpbE9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+ IGJyaWRnZSwgV2ViRmlsZUVycm9yIGVycm9yKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJh Y2tzT25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKGJyaWRnZS0+bV9jb250ZXh0ICYm IGJyaWRnZS0+bV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIGJyaWRnZS0+ bV9jYWxsYmFja3NPbldvcmtlclRocmVhZC0+ZGlkRmFpbChlcnJvcik7CisgICAgICAgIGJyaWRn ZS0+bV9jYWxsYmFja3NPbldvcmtlclRocmVhZCA9IDA7CisgICAgfQorfQorCit2b2lkIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJl YWQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZT4gYnJpZGdlLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYg cm9vdFBhdGgpCit7CisgICAgaWYgKGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtlclRocmVhZCkg eworICAgICAgICBBU1NFUlQoYnJpZGdlLT5tX2NvbnRleHQgJiYgYnJpZGdlLT5tX2NvbnRleHQt PmlzQ29udGV4dFRocmVhZCgpKTsKKyAgICAgICAgYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2Vy VGhyZWFkLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCByb290UGF0aCk7CisgICAgICAgIGJyaWRn ZS0+bV9jYWxsYmFja3NPbldvcmtlclRocmVhZCA9IDA7CisgICAgfQorfQorCit2b2lkIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6Om1heVBvc3RUYXNrVG9Xb3JrZXIoUGFzc093blB0 cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUp Cit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBNdXRleExvY2tlciBsb2NrZXIo bV9tdXRleCk7CisgICAgaWYgKG1fd29ya2VyKQorICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tG b3JNb2RlVG9Xb3JrZXJDb250ZXh0KHRhc2ssIG1vZGUpOworfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmU5NDY5NjMxOWU4MGYzZTIwOGJiYTQwNDMyODYxY2I4OTIyN2Y3ZjQKLS0tIC9kZXYvbnVs bAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UuaApAQCAtMCwwICsxLDExOCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVy IHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmli dXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg ZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0Jy aWRnZV9oCisjZGVmaW5lIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAorCisjaW5j bHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0 LmgiCisjaW5jbHVkZSAiV2ViRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbS5o IgorI2luY2x1ZGUgIldlYlZlY3Rvci5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+Cisj aW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3Mg QXN5bmNGaWxlU3lzdGVtOworY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7Citj bGFzcyBUaHJlYWRhYmxlQ2FsbGJhY2tzQnJpZGdlV3JhcHBlcjsKK2NsYXNzIFdlYkNvbW1vbldv cmtlckNsaWVudDsKK3N0cnVjdCBXZWJGaWxlSW5mbzsKK2NsYXNzIFdlYkZpbGVTeXN0ZW1DYWxs YmFja3M7CitjbGFzcyBXZWJGaWxlU3lzdGVtRW50cnk7CitjbGFzcyBXZWJXb3JrZXJCYXNlOwor CisvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcG9zdCBhIG9wZW5GaWxlU3lzdGVtIHJlcXVlc3Qg dG8gdGhlIG1haW4gdGhyZWFkIGFuZCBnZXQgY2FsbGVkIGJhY2sgZm9yIHRoZSByZXF1ZXN0LiBU aGlzIG11c3QgYmUgZGVzdHJ1Y3RlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKy8vCisvLyBBIHR5 cGljYWwgZmxvdyBmb3Igb3BlbkZpbGVTeXN0ZW0gd291bGQgbG9vayBsaWtlIHRoaXM6CisvLyBC cmlkZ2U6OnBvc3RPcGVuRmlsZVN5c3RlbVRvTWFpblRocmVhZCgpIG9uIFdvcmtlclRocmVhZAor Ly8gIC0tPiBCcmlkZ2U6Om9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKCkgaXMgY2FsbGVkIG9u IE1haW5UaHJlYWQKKy8vICAgICAgVGhpcyBtYWtlcyBhbiBJUEMgd2l0aCBhIE1haW5UaHJlYWRG aWxlU3lzdGVtQ2FsbGJhY2tzIGluc3RhbmNlCisvLyAgICAgW2FjdHVhbCBvcGVyYXRpb24gaXMg ZG93biBpbiB0aGUgYnJvd3Nlcl0KKy8vICAtLT4gTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFj a3M6OmRpZFh4eCBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gIC0tPiBCcmlkZ2U6OmRpZFh4 eE9uTWFpblRocmVhZCBpcyBjYWxsZWQgb24gTWFpblRocmVhZAorLy8gIC0tPiBCcmlkZ2U6OmRp ZFh4eE9uV29ya2VyVGhyZWFkIGlzIGNhbGxlZCBvbiBXb3JrZXJUaHJlYWQKKy8vICAgICAgVGhp cyBjYWxscyB0aGUgb3JpZ2luYWwgY2FsbGJhY2tzIChtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFk KSBhbmQKKy8vICAgICAgcmVsZWFzZXMgYSBzZWxmLXJlZmVyZW5jZSB0byB0aGUgYnJpZGdlLgor Y2xhc3MgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSA6IHB1YmxpYyBUaHJlYWRTYWZl U2hhcmVkPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+LCBwdWJsaWMgV2ViQ29yZTo6 V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRy PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGNyZWF0ZShXZWJXb3JrZXJCYXNlKiB3 b3JrZXIsIFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHdvcmtlckNvbnRleHQsIFdl YkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICB7CisgICAgICAgIHJldHVybiBX VEY6OmFkb3B0UmVmKG5ldyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKHdvcmtlciwg d29ya2VyQ29udGV4dCwgY2FsbGJhY2tzKSk7CisgICAgfQorICAgIH5Xb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlKCk7CisKKyAgICAvLyBXb3JrZXJDb250ZXh0OjpPYnNlcnZlciBtZXRo b2QuCisgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKQorICAgIHsKKyAgICAgICAgc3RvcCgp OworICAgIH0KKworICAgIHZvaWQgc3RvcCgpOworCisgICAgLy8gTWV0aG9kIHRoYXQgcG9zdHMg YW4gaW5pdGlhbCByZXF1ZXN0IHRhc2sgdG8gdGhlIG1haW4gdGhyZWFkLiBJdCBpcyBzdXBwb3Nl ZCB0byBiZSBjYWxsZWQgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGJyaWRnZSBpcyBjb25zdHJ1Y3Rl ZCAoaXQgZG9lc24ndCBjaGVjayBpZiB0aGUgY29udGV4dCBoYXMgYmVlbiBzdG9wcGVkIG9yIG5v dCkuCisgICAgdm9pZCBwb3N0T3BlbkZpbGVTeXN0ZW1Ub01haW5UaHJlYWQoV2ViQ29tbW9uV29y a2VyQ2xpZW50KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIGNvbnN0IFN0 cmluZyYgbW9kZSk7CisKKyAgICAvLyBDYWxsYmFjayBtZXRob2RzIHRoYXQgYXJlIGNhbGxlZCBv biB0aGUgbWFpbiB0aHJlYWQuCisgICAgdm9pZCBkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVF cnJvciwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKyAgICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25N YWluVGhyZWFkKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29u c3QgU3RyaW5nJiBtb2RlKTsKKworcHJpdmF0ZToKKyAgICBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlKFdlYldvcmtlckJhc2UqLCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCisgICAgLy8gTWV0aG9kIHRoYXQgaXMgdG8g YmUgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5 c3RlbU9uTWFpblRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViQ29t bW9uV29ya2VyQ2xpZW50KiwgV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UqLCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisg ICAgZnJpZW5kIGNsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgLy8g TWV0aG9kcyB0aGF0IGRpc3BhdGNoIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3Mgb24gdGhlIHdvcmtl ciB0aHJlYWRzLgorICAgIC8vIFRoZXkgcmVsZWFzZSBhIHNlbGZSZWYgb2YgdGhlIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuCisgICAgc3RhdGljIHZvaWQgZGlkRmFpbE9uV29ya2Vy VGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+LCBXZWJGaWxlRXJyb3IpOworICAgIHN0YXRpYyB2 b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4s IGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCk7CisKKyAgICAvLyBI ZWxwZXIgbWV0aG9kLgorICAgIHZvaWQgbWF5UG9zdFRhc2tUb1dvcmtlcihQYXNzT3duUHRyPFdl YkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+LCBjb25zdCBTdHJpbmcmIG1vZGUp OworCisgICAgLy8gbV9zZWxmUmVmIGtlZXBzIGEgcmVmZXJlbmNlIHRvIGl0c2VsZiB1bnRpbCBj YWxsYmFja3MgYXJlIGZpcmVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorICAgIFJlZlB0cjxXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBtX3NlbGZSZWY7CisKKyAgICBNdXRleCBtX211 dGV4OworICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOworCisgICAgLy8gVGhpcyBpcyBzZWxm LWRlc3RydWN0ZWQgYW5kIG11c3QgYmUgZmlyZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisgICAg V2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogbV9jYWxsYmFja3NPbldvcmtlclRocmVhZDsKK307CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFdvcmtlckZpbGVTeXN0ZW1DYWxs YmFja3NCcmlkZ2VfaAo= 68467 2010-09-22 16:13:41 -0700 2010-09-23 15:36:18 -0700 Patch bug-45808-20100922161339.patch text/plain 44118 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWJmMzcyMGNiYzVjMGU5Y2ZkMTM1ZmFjOGY3YmUwYThkYzM3NzQ2Ni4uZWI4ODBhOGM2M2IwNTFi ODIyMzAzMDllYzhkYWIxNzBhNjkzYmM5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMiAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMiAgRGF2aWQgSHlhdHQg IDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1 cmVzLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcAppbmRleCBhMTVmZDZkMDgwMmZiZWVmMTEwOWZjYTljOWQzYjJmM2QzMDIwYzA0Li45YTk2 ZjIyNmQzY2ZmNzI3OGM3OTI2OWExYzgyZTRhY2M3ODQwNjRiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKKysrIGIvV2ViQ29y ZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCkBAIC0zNiw2ICsz NiwxMCBAQAogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNpbmNsdWRlICJX ZWJTb2NrZXQuaCIKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgUnVudGlt ZUVuYWJsZWRGZWF0dXJlczo6aXNMb2NhbFN0b3JhZ2VFbmFibGVkID0gdHJ1ZTsKQEAgLTU3LDYg KzYxLDExIEBAIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNYSFJSZXNwb25zZUJsb2JF bmFibGVkID0gZmFsc2U7CiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiBib29sIFJ1bnRpbWVF bmFibGVkRmVhdHVyZXM6OmlzRmlsZVN5c3RlbUVuYWJsZWQgPSBmYWxzZTsKKworYm9vbCBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCgpCit7CisgICAgcmV0dXJuIGlz RmlsZVN5c3RlbUVuYWJsZWQgJiYgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpOworfQog I2VuZGlmCiAKICNpZiBFTkFCTEUoVklERU8pCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdz L2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5l cmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAppbmRleCA5MTc2OGIwZTU0ZTdmOTdiYWNkMGE5 YmQzMzllMWRjNDIwZDZlZGVlLi5iYTRhNGZiMDVkZjUxZDc0NDRmYjlhM2JhMTAwMmFlNDdhYmQ1 ZmM4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5oCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmgKQEAgLTE0OCw3ICsxNDgsNyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKLSAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0 dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KKyAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5h YmxlZCgpOwogICAgIHN0YXRpYyB2b2lkIHNldEZpbGVTeXN0ZW1FbmFibGVkKGJvb2wgaXNFbmFi bGVkKSB7IGlzRmlsZVN5c3RlbUVuYWJsZWQgPSBpc0VuYWJsZWQ7IH0KICAgICBzdGF0aWMgYm9v bCByZXF1ZXN0RmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVk OyB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u Y3BwIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2 ZDdiYjE5ZjFkNDgzOWU1ZWUzOTk2MDBmNmUwNDRmNi4uZjgyNmI3MWMyZGQ3YjE1MjRkMDA4YzIx ZmY0YmNmZGM5Nzc4YzhhNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUw LDkgKzUwLDMwIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZp bGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp CitMb2NhbEZpbGVTeXN0ZW0qIExvY2FsRmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3Zv aWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmlu ZyYgYmFzZVBhdGgpCit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90 YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNT RVJUKCFzX2luc3RhbmNlKTsKKyAgICBpZiAoc19pbnN0YW5jZSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIo bmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aCkpOworICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZp bGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVt IG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4KKyAgICBBU1NFUlQoc19pbnN0YW5j ZSk7CisgICAgcmV0dXJuICpzX2luc3RhbmNlOworfQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVt OjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcg TG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgcmV0dXJuIG1fYmFzZVBhdGg7CiB9CiAK IHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25z dCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAKICAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVT eXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkp OwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2Fs RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4IDQ4 Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLmQwOGQwZjBmMGZmNzJiYjAw OGU3NDAwMjAyYmJkMjU0NzNjZDc1NDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2Nh bEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKQEAg LTQ0LDIwICs0NCw0NCBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxGaWxl U3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVwcyBw ZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8gb3Bl biBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IGNy ZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVTeXN0 ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9jYWxG aWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0aGlz IG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAog ICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNh bGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAh UExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBjYWxsIGlzIG5vdCB0aHJlYWQtc2FmZTsg bXVzdCBiZSBjYWxsZWQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkcyBhcmUgY3JlYXRlZC4KKyAg ICB2b2lkIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJik7CisKKyAgICBT dHJpbmcgZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3Q7CisjZW5kaWYKKworcHJpdmF0ZToKICAg ICBMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKICAgICAgICAgOiBtX2Jh c2VQYXRoKGJhc2VQYXRoKQogICAgIHsKICAgICB9CiAKLSAgICBTdHJpbmcgbV9iYXNlUGF0aDsK KyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtKiBzX2luc3RhbmNlOworCisgICAgLy8gQW4gaW5u ZXIgY2xhc3MgdGhhdCBlbmZvcmNlcyB0aHJlYWQtc2FmZSBzdHJpbmcgYWNjZXNzLgorICAgIGNs YXNzIFN5c3RlbUJhc2VQYXRoIHsKKyAgICBwdWJsaWM6CisgICAgICAgIGV4cGxpY2l0IFN5c3Rl bUJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgOiBtX3ZhbHVlKHBhdGgpIHsgfQorICAgICAg ICBvcGVyYXRvciBTdHJpbmcoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4g bV92YWx1ZS50aHJlYWRzYWZlQ29weSgpOworICAgICAgICB9CisgICAgcHJpdmF0ZToKKyAgICAg ICAgU3RyaW5nIG1fdmFsdWU7CisgICAgfTsKKworICAgIFN5c3RlbUJhc2VQYXRoIG1fYmFzZVBh dGg7CiB9OwogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCBmNWJhMjVjMzZhOWFk MmM3ZmQxNjU5YTViNWQzZDA2ZDg3YmE1YzQ2Li42YTIwM2NjN2M0OTJlYzMzYWJlMDAyOTJlM2Ew NDhkOGEyYWMzNDFkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBE T01XaW5kb3c6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFz c1JlZlB0cjxGaWxlU3lzdGUKICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAK LSAgICBpZiAoIW1fbG9jYWxGaWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYg YWNjZXNzIGlzIGFsbG93ZWQuCi0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdl KCk7Ci0gICAgICAgIGlmICghcGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2No ZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUo SU5WQUxJRF9TVEFURV9FUlIpKTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0g ICAgICAgIC8vIEZJWE1FOiBHZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAg IFN0cmluZyBwYXRoID0gcGFnZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0g ICAgICAgIG1fbG9jYWxGaWxlU3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7 CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5z ZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmls ZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVy cm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAg ICBtX2xvY2FsRmlsZVN5c3RlbS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19j YXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywg ZXJyb3JDYWxsYmFjayk7CisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5y ZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAot Q09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxl U3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChE T01XaW5kb3c6OlBFUlNJU1RFTlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQp LCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1w b3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4o RE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3Rl bTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4 IDE0NzA2Mjg2NWQ5YjliNzc0NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLjZmZDM3NzUwM2FiNGVl ZjFkOWU3NzVmOTgzMDRkMTEzMWZhZmIwM2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuaAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFj dG9yeTsKICAgICBjbGFzcyBJbnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2Fs RmlsZVN5c3RlbTsKICAgICBjbGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwog ICAgIGNsYXNzIE5hdmlnYXRvcjsKQEAgLTQ0NCw5ICs0NDMsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRy PElEQkZhY3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKLSAgICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0j ZW5kaWYKIAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1NjE5YWJjMTA0ZWI5ODFkY2Vk NWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5NzQ3MTY1MSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3Vy aXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBjYW5BY2Nl c3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogICAgIGJvb2wg Y2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9v bCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsg fQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1 ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxkIGFsd2F5cyBhbGxvdyBhY2Nl c3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1cnJlbnRseSBkb24ndCBoYW5k bGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1bmlxdWUKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmlu ZGV4IGZhYzBhNWY0OTY4ZGI2YTRhYTFkNzk0NmZlYmRkM2VmNjk1MTQ3YTUuLjRkMTY2MmI2MzZh OTgxNDE2OGI2ZTU4ODQ4YTU3MGI2YjY1OTE2MjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtNDk3LDExICs0 OTcsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoY29uc3Qg U3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoID0gcGF0aDsKIH0K IAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYgcGF0 aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7Ci19Ci0KIHZvaWQgU2V0dGlu Z3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUpCiB7CiAgICAgbV9pbkFwcGxp Y2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDk5YTRmMjMyYzUyOTgwNmVhYTI3 Zjg1ZDU3ZGJiYWIxMjc0NGJmMzMuLmY4YTI5N2ExN2IwNTU2OWQ4NWZjN2IxMTBjNDY1NmY0NDc0 MDc2NGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCisrKyBiL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5oCkBAIC0yNDEsOSArMjQxLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmKTsK ICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoKSBjb25zdCB7 IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQogCi0gICAgICAgIHZvaWQgc2V0 RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAgICAgICBjb25zdCBTdHJpbmcm IGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZVN5c3RlbVJvb3RQYXRo OyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUoYm9vbCk7CiAgICAg ICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25zdCB7IHJldHVybiBtX2luQXBw bGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzNiw3ICszMzMsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5jb2RpbmdOYW1lOwogICAgICAg ICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAgICAgICAgIFN0cmluZyBtX2xv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5nIG1fZmlsZVN5c3RlbVJvb3RQ YXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKICAgICAgICAgQXRv bWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAgICBBdG9taWNTdHJpbmcgbV9m aXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKaW5kZXggYjRm Y2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4uNTczMDVmZmMyYmEwYzRhNGYz YTZlM2RlOGYyMWFhZTQxOWY4NWU1OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3lu Y0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cApAQCAtMzUsMTIgKzM1LDIwIEBACiAKICNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MuaCIKICNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9v bCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgp OworICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFz eW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYpCiB7Ci0gICAgLy8gRklYTUU6IHJl dHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1lbnRhdGlvbi4KKyAgICBub3RJbXBs ZW1lbnRlZCgpOwogICAgIHJldHVybiAwOwogfQogCkBAIC02Miw2ICs3MCw3IEBAIHZvaWQgQXN5 bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25z dCBTdHJpbmcmIHN0b3JhCiAKICAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUs IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHJvb3RQYXRoKSk7CiB9CisjZW5kaWYKIAogLy8gRGVm YXVsdCBpbXBsZW1lbnRhdGlvbi4KIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW06OnZpcnR1YWxUb1Bs YXRmb3JtUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVT eXN0ZW0uaAppbmRleCA2MDFmMGVhZTNlNWQwZThiZWI4NGQ1YTk5M2Q3NzA1MTdiZDBhNjJkLi44 YzRkNWQ5OTBmZGE0NmMyYjc4MGRmOWIwOWE2MDc3ZTU0ZDlmZjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5 bmNGaWxlU3lzdGVtLmgKQEAgLTU2LDYgKzU2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBzdG9wKCkgeyB9CiAgICAgdmlydHVhbCBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIHsgcmV0 dXJuIGZhbHNlOyB9CiAKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgLy8g Q3JlYXRlcyBhbmQgcmV0dXJucyBhIG5ldyBwbGF0Zm9ybS1zcGVjaWZpYyBBc3luY0ZpbGVTeXN0 ZW0gaW5zdGFuY2UgaWYgdGhlIHBsYXRmb3JtIGhhcyBpdHMgb3duIGltcGxlbWVudGF0aW9uLgog ICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmlu ZyYgcm9vdFBhdGgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5kZXggYjUyYjI4NTQ3 NWYyZWY5NDc3ZTgxNGJiZTRkOGJlYjljM2I5ZWEwYS4uNzAzN2E0ZmUzNGFiMjVhNjU2NzQ1NzA0 NjRhMzRiYmYyMTFmMzk1OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtNjMsNiAr NjMsMTUgQEAKICNpbmNsdWRlICJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2luY2x1 ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiRmlsZVN5c3RlbUNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiTG9jYWxGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBDbG9zZVdvcmtlckNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2sgewpAQCAtMTAwLDYgKzEwOSwxMCBAQCBXb3JrZXJDb250ZXh0Ojp+V29ya2VyQ29u dGV4dCgpCiAjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAgICAgbV9ub3RpZmljYXRpb25zLmNs ZWFyKCk7CiAjZW5kaWYKKworICAgIC8vIE1ha2Ugc3VyZSB3ZSBoYXZlIG5vIG9ic2VydmVycy4K KyAgICBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIC8vIE5vdGlmeSBwcm94eSB0aGF0 IHdlIGFyZSBnb2luZyBhd2F5LiBUaGlzIGNhbiBmcmVlIHRoZSBXb3JrZXJUaHJlYWQgb2JqZWN0 LCBzbyBkbyBub3QgYWNjZXNzIGl0IGFmdGVyIHRoaXMuCiAgICAgdGhyZWFkKCktPndvcmtlclJl cG9ydGluZ1Byb3h5KCkud29ya2VyQ29udGV4dERlc3Ryb3llZCgpOwogfQpAQCAtMzM1LDYgKzM0 OCw2NyBAQCB2b2lkIFdvcmtlckNvbnRleHQ6OnJldm9rZUJsb2JVUkwoY29uc3QgU3RyaW5nJiBi bG9iVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCit2b2lk IFdvcmtlckNvbnRleHQ6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1Jl ZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQoreworICAgIGlmICghQXN5bmNGaWxl U3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8ICFzZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxl U3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayh0aGlz LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVt KCkucmVxdWVzdEZpbGVTeXN0ZW0odGhpcywgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKK30KKwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpURU1QT1JBUlkp ID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21p c21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6 UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3Rl bnQpLCBlbnVtX21pc21hdGNoKTsKKyNlbmRpZgorCitXb3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6 T2JzZXJ2ZXIoV29ya2VyQ29udGV4dCogY29udGV4dCkKKyAgICA6IG1fY29udGV4dChjb250ZXh0 KQoreworICAgIEFTU0VSVChtX2NvbnRleHQgJiYgbV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQo KSk7CisgICAgbV9jb250ZXh0LT5yZWdpc3Rlck9ic2VydmVyKHRoaXMpOworfQorCitXb3JrZXJD b250ZXh0OjpPYnNlcnZlcjo6fk9ic2VydmVyKCkKK3sKKyAgICBpZiAoIW1fY29udGV4dCkKKyAg ICAgICAgcmV0dXJuOworICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsK KyAgICBtX2NvbnRleHQtPnVucmVnaXN0ZXJPYnNlcnZlcih0aGlzKTsKK30KKwordm9pZCBXb3Jr ZXJDb250ZXh0OjpPYnNlcnZlcjo6c3RvcE9ic2VydmluZygpCit7CisgICAgaWYgKCFtX2NvbnRl eHQpCisgICAgICAgIHJldHVybjsKKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0NvbnRleHRUaHJl YWQoKSk7CisgICAgbV9jb250ZXh0LT51bnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7CisgICAgbV9j b250ZXh0ID0gMDsKK30KKwordm9pZCBXb3JrZXJDb250ZXh0OjpyZWdpc3Rlck9ic2VydmVyKE9i c2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIpOworICAgIG1fd29ya2Vy T2JzZXJ2ZXJzLmFkZChvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29ya2VyQ29udGV4dDo6dW5yZWdp c3Rlck9ic2VydmVyKE9ic2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIp OworICAgIG1fd29ya2VyT2JzZXJ2ZXJzLnJlbW92ZShvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29y a2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCkKK3sKKyAgICBIYXNoU2V0PE9ic2Vy dmVyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX3dvcmtlck9ic2VydmVycy5iZWdpbigpOworICAgIHdo aWxlIChpdGVyICE9IG1fd29ya2VyT2JzZXJ2ZXJzLmVuZCgpKSB7CisgICAgICAgICgqaXRlcikt Pm5vdGlmeVN0b3AoKTsKKyAgICAgICAgKCppdGVyKS0+c3RvcE9ic2VydmluZygpOworICAgICAg ICBpdGVyID0gbV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsKKyAgICB9Cit9CisKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEv V2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4u ZGFkMmFmMzViZDdhNWM5ODgwN2UwODFjODQyOTRjMWFjYWZhNWE3MyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5oCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29u dGV4dC5oIgogI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlIDx3 dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3Rm L093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Jl ZkNvdW50ZWQuaD4KQEAgLTQ3LDYgKzQ4LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNs YXNzIERhdGFiYXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0 YWJhc2VTeW5jOworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3Rl bUNhbGxiYWNrOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hl ZHVsZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTI0LDE0 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0 IFN0cmluZyYpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIGVu dW0gRmlsZVN5c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAg UEVSU0lTVEVOVCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShp bnQgdHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwg UGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBt ZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJr Q2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9t LmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0 IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkBAIC0xMzEsNiArMTQyLDIxIEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogICAgICAgICBib29sIGlzQ2xvc2luZygpIHsgcmV0dXJuIG1fY2xv c2luZzsgfQogCisgICAgICAgIC8vIEFuIG9ic2VydmVyIGludGVyZmFjZSB0byBiZSBub3RpZmll ZCB3aGVuIHRoZSB3b3JrZXIgdGhyZWFkIGlzIGdldHRpbmcgc3RvcHBlZC4KKyAgICAgICAgY2xh c3MgT2JzZXJ2ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgICAgICBwdWJsaWM6CisgICAg ICAgICAgICBPYnNlcnZlcihXb3JrZXJDb250ZXh0Kik7CisgICAgICAgICAgICB2aXJ0dWFsIH5P YnNlcnZlcigpOworICAgICAgICAgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKSA9IDA7Cisg ICAgICAgICAgICB2b2lkIHN0b3BPYnNlcnZpbmcoKTsKKyAgICAgICAgcHJvdGVjdGVkOgorICAg ICAgICAgICAgV29ya2VyQ29udGV4dCogbV9jb250ZXh0OworICAgICAgICB9OworICAgICAgICBm cmllbmQgY2xhc3MgT2JzZXJ2ZXI7CisgICAgICAgIHZvaWQgcmVnaXN0ZXJPYnNlcnZlcihPYnNl cnZlciogb2JzZXJ2ZXIpOworICAgICAgICB2b2lkIHVucmVnaXN0ZXJPYnNlcnZlcihPYnNlcnZl ciogb2JzZXJ2ZXIpOworICAgICAgICB2b2lkIG5vdGlmeU9ic2VydmVyc09mU3RvcCgpOworCiAg ICAgcHJvdGVjdGVkOgogICAgICAgICBXb3JrZXJDb250ZXh0KGNvbnN0IEtVUkwmLCBjb25zdCBT dHJpbmcmLCBXb3JrZXJUaHJlYWQqKTsKIApAQCAtMTYxLDYgKzE4Nyw4IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgYm9vbCBtX2Nsb3Npbmc7CiAgICAgICAgIGJvb2wgbV9yZXBvcnRp bmdFeGNlcHRpb247CiAgICAgICAgIEV2ZW50VGFyZ2V0RGF0YSBtX2V2ZW50VGFyZ2V0RGF0YTsK KworICAgICAgICBIYXNoU2V0PE9ic2VydmVyKj4gbV93b3JrZXJPYnNlcnZlcnM7CiAgICAgfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dv cmtlckNvbnRleHQuaWRsIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCmluZGV4 IDAyYWE0YWRiODhiYzJkZjY3ZjI3ZDVlY2UyYjVhOTIzMjg2NzgxMjQuLjNlMTg1YzBkNWI4ZTBh MTM3YmQ5MjhjNTJhMmRiYTgxNzVmODAzMzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmlkbAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwK QEAgLTEwNCw2ICsxMDQsMTQgQEAgbW9kdWxlIHRocmVhZHMgewogICAgICAgICBET01TdHJpbmcg Y3JlYXRlQmxvYlVSTChpbiBCbG9iIGJsb2IpOwogICAgICAgICB2b2lkIHJldm9rZUJsb2JVUkwo aW4gRE9NU3RyaW5nIGJsb2JVUkwpOwogI2VuZGlmCisKKyNpZiBkZWZpbmVkKEVOQUJMRV9GSUxF X1NZU1RFTSkgJiYgRU5BQkxFX0ZJTEVfU1lTVEVNCisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNo b3J0IFRFTVBPUkFSWSA9IDA7CisgICAgICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFBFUlNJU1RF TlQgPSAxOworICAgICAgICBbRW5hYmxlZEF0UnVudGltZV0gdm9pZCByZXF1ZXN0RmlsZVN5c3Rl bShpbiB1bnNpZ25lZCBzaG9ydCB0eXBlLCBpbiBsb25nIGxvbmcgc2l6ZSwgaW4gW0NhbGxiYWNr LCBPcHRpb25hbF0gRmlsZVN5c3RlbUNhbGxiYWNrIHN1Y2Nlc3NDYWxsYmFjaywgaW4gW0NhbGxi YWNrLCBPcHRpb25hbF0gRXJyb3JDYWxsYmFjayBlcnJvckNhbGxiYWNrKTsKKworICAgICAgICAg ICAgICAgICBhdHRyaWJ1dGUgW0VuYWJsZWRBdFJ1bnRpbWU9RmlsZVN5c3RlbV0gRmxhZ3NDb25z dHJ1Y3RvciBGbGFnczsKKyNlbmRpZgogICAgIH07CiAKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUv d29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5j cHAKaW5kZXggZDZhMWUwNTdkM2VkODE4YTM3OGU3NTM2NjY5ZjNhMGE3Yjk0NTdmZS4uZjYxMTIw ZWVlMDRjMzFhODAwZmY1NjI5YWY5YTJiODBhNDY3YTNjNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS93 b3JrZXJzL1dvcmtlclRocmVhZC5jcHAKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVh ZC5jcHAKQEAgLTIwMiw2ICsyMDIsOCBAQCBwdWJsaWM6CiAKICAgICAgICAgd29ya2VyQ29udGV4 dC0+c3RvcEFjdGl2ZURPTU9iamVjdHMoKTsKIAorICAgICAgICB3b3JrZXJDb250ZXh0LT5ub3Rp ZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgICAgICAvLyBFdmVudCBsaXN0ZW5lcnMgd291bGQg a2VlcCBET01XcmFwcGVyV29ybGQgb2JqZWN0cyBhbGl2ZSBmb3IgdG9vIGxvbmcuIEFsc28sIHRo ZXkgaGF2ZSByZWZlcmVuY2VzIHRvIEpTIG9iamVjdHMsCiAgICAgICAgIC8vIHdoaWNoIGJlY29t ZSBkYW5nbGluZyBvbmNlIEhlYXAgaXMgZGVzdHJveWVkLgogICAgICAgICB3b3JrZXJDb250ZXh0 LT5yZW1vdmVBbGxFdmVudExpc3RlbmVycygpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNDFhYjA4ZDYzMjU2 NDA5MzNjYTU1MGYyOWRmNTE0N2JiN2I4ZjQ1ZC4uNTBkNTQzMjlhZTM2NzVlNjc2YWRkNmEzM2Uw NGMxMjZkYzAzYTlmNSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysg Yi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTAtMDktMjIg IEtpbnVrbyBZYXN1ZGEgIDxraW51a29AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXb3JrZXIgc3VwcG9ydCBmb3IgRmls ZVN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTQ1ODA4CisKKyAgICAgICAgQWRkZWQgV2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0g YW5kIFdlYkNvbW1vbldvcmtlckNsaWVudDo6CisgICAgICAgIG9wZW5GaWxlU3lzdGVtIHRvIGNh bGwgaW4gdG8gdGhlIGJyb3dzZXIgdmlhIFdvcmtlciBzdHViL3Byb3h5CisgICAgICAgIGluIHRo ZSBjaHJvbWl1bS4KKworICAgICAgICBBbHNvIGFkZGVkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFj a3NCcmlkZ2UgY2xhc3MgdGhhdCBwcm94aWVzCisgICAgICAgIHJlcXVlc3RzIGFuZCBjYWxsYmFj a3MgYmV0d2VlbiBmcm9tL3RvIHdvcmtlciB0aHJlYWQgdG8vZnJvbSB0aGUKKyAgICAgICAgbWFp biB0aHJlYWQuCisKKyAgICAgICAgKiBwdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50Lmg6Cisg ICAgICAgIChXZWJLaXQ6OldlYkNvbW1vbldvcmtlckNsaWVudDo6b3BlbkZpbGVTeXN0ZW0pOiBB ZGRlZC4KKyAgICAgICAgKiBzcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRl ZCBpbXBsZW1lbnRhdGlvbgorICAgICAgICBmb3Igd29ya2Vycy4gSW4gd29ya2VyIGNhc2UgdGhp cyBjYWxscyBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbS4KKyAgICAgICAgKiBzcmMvV2Vi V29ya2VyQmFzZS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6Om9wZW5GaWxl U3lzdGVtKTogQWRkZWQuIFRoaXMgaXMgY2FsbGVkIGZyb20KKyAgICAgICAgTG9jYWxGaWxlU3lz dGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSBvbiB0aGUgd29ya2VyIHRocmVhZCBhbmQgY3JlYXRlcwor ICAgICAgICBhIGJyaWRnZSB0byBjYWxsIFdlYkNvbW1vbldvcmtlckNsaWVudDo6b3BlbkZpbGVT eXN0ZW0gb24gdGhlIG1haW4KKyAgICAgICAgdGhyZWFkLgorICAgICAgICAqIHNyYy9XZWJXb3Jr ZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwuaDoKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6b3BlbkZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHA6IEFkZGVkLgor ICAgICAgICAqIHNyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmg6IEFkZGVkLgor CiAyMDEwLTA5LTIyICBLZW5uZXRoIFJ1c3NlbGwgIDxrYnJAZ29vZ2xlLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCBDaHJvbWl1bSBidWlsZCBmaXguIEZpeCBidWlsZCB3aGVuIGFjY2VsZXJh dGVkCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cCBiL1dlYktpdC9jaHJv bWl1bS9XZWJLaXQuZ3lwCmluZGV4IGZjOGZiZGQzMTU3Mjk2OTBmYjhlZTg1ZWFjNjFlNTE5MzI3 Yzc2MmYuLjUwYzZhODk4NjAzMTdmZWE1YTBjZGNkMWFjY2QwODc3ZjRmMjIwMGQgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9XZWJL aXQuZ3lwCkBAIC01MzAsNiArNTMwLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYldvcmtl ckNsaWVudEltcGwuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmNwcCcs CiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJJbXBsLmgnLAorICAgICAgICAgICAgICAg ICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAnLAorICAgICAgICAgICAg ICAgICdzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oJywKICAgICAgICAgICAg ICAgICAnc3JjL1dyYXBwZWRSZXNvdXJjZVJlcXVlc3QuaCcsCiAgICAgICAgICAgICAgICAgJ3Ny Yy9XcmFwcGVkUmVzb3VyY2VSZXNwb25zZS5oJywKICAgICAgICAgICAgICAgICAnc3JjL3dpbi9X ZWJJbnB1dEV2ZW50RmFjdG9yeS5jcHAnLApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi Q29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggY2VhNjQ3MTIzYTUyZjUwMzI4NTA4OTBkYzg0NTUy YzQxNjQ0ZmYyZC4uNGYxNGYyYWZlMGFhY2EyZWM1M2JiNWM4ZTc4N2M5NmEyZGNkNmQyMCAxMDA2 NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCkBAIC0z MSw2ICszMSw5IEBACiAjaWZuZGVmIFdlYkNvbW1vbldvcmtlckNsaWVudF9oCiAjZGVmaW5lIFdl YkNvbW1vbldvcmtlckNsaWVudF9oCiAKKyNpbmNsdWRlICJXZWJDb21tb24uaCIKKyNpbmNsdWRl ICJXZWJGaWxlU3lzdGVtLmgiCisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJBcHBs aWNhdGlvbkNhY2hlSG9zdDsKQEAgLTgzLDYgKzg2LDEzIEBAIHB1YmxpYzoKICAgICAvLyBDYWxs ZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBiZWZvcmUgb3BlbmluZyBhIHdlYiBkYXRhYmFz ZS4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBl c3RpbWF0ZWRTaXplKSA9IDA7CiAKKyAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRo cmVhZCBiZWZvcmUgb3BlbmluZyBhIGZpbGUgc3lzdGVtLgorICAgIHZpcnR1YWwgdm9pZCBvcGVu RmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5 c3RlbUNhbGxiYWNrcyopCisgICAgeworICAgICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIHN0dWIg aW1wbGVtZW50YXRpb24gdW50aWwgc3ViY2xhc3MgaW4gY2hyb21pdW0gaW1wbGVtZW50IHRoaXMu CisgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKIHByb3RlY3Rl ZDoKICAgICB+V2ViQ29tbW9uV29ya2VyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3NyYy9Bc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAgYi9XZWJLaXQvY2hy b21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVtLmNwcAppbmRleCAwOGZjZWE2Yzk4NWFj MzIxZDI5MTZjM2MyZTJkYTZmYzhkNDhlODNmLi4wYjc1M2IzZDE1MmMxYjY1YzdmYzE1ZjlhMzUz Y2ZjNTFhNjM2NGJhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5 c3RlbUNocm9taXVtLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3Rl bUNocm9taXVtLmNwcApAQCAtNDMsNiArNDMsMTEgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog Citib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAgIHJldHVybiB0cnVl OworfQorCiBBc3luY0ZpbGVTeXN0ZW1DaHJvbWl1bTo6QXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0o Y29uc3QgU3RyaW5nJiByb290UGF0aCkKICAgICA6IEFzeW5jRmlsZVN5c3RlbShyb290UGF0aCkK ICAgICAsIG1fd2ViRmlsZVN5c3RlbShXZWJLaXQ6OndlYktpdENsaWVudCgpLT5maWxlU3lzdGVt KCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9t aXVtLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3Bw CmluZGV4IDQ1MzY1ZWYyZTY3OWQ5OTBiYjNhZWJkZjNlY2E5Y2U4MjIwZjI1YjIuLjk5NGYzMTA0 NmIzZGQ3NTc1YWEwMTllNmUxODk5YmFmZjE5MDkzMTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvTG9jYWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00MiwxNCArNDIsMTkgQEAKICNp bmNsdWRlICJXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUgIldlYkZyYW1l Q2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5jbHVkZSAiV2ViV29ya2Vy SW1wbC5oIgorI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJUaHJl YWQuaCIKKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJL aXQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+ IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgcGF0aCkKK0xvY2FsRmlsZVN5 c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogewotICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxGaWxlU3lzdGVtKHBhdGgpKTsKKyAgICBBdG9taWNhbGx5SW5pdGlh bGl6ZWRTdGF0aWMoTG9jYWxGaWxlU3lzdGVtKiwgbG9jYWxGaWxlU3lzdGVtID0gbmV3IExvY2Fs RmlsZVN5c3RlbSgiIikpOworICAgIHJldHVybiAqbG9jYWxGaWxlU3lzdGVtOwogfQogCiB2b2lk IExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBQ YXNzUmVmUHRyPEZpbGVTeXN0ZW1DYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRy PEVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCkBAIC02MCw3ICs2NSwxMCBAQCB2b2lkIExv Y2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgQXN5bmNGaQogICAgICAgICBXZWJGcmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJh bWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAgICAgICB3ZWJGcmFtZS0+ Y2xpZW50KCktPm9wZW5GaWxlU3lzdGVtKHdlYkZyYW1lLCBzdGF0aWNfY2FzdDxXZWJGaWxlU3lz dGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsKG5l dyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaywgY29u dGV4dCkpKTsKICAgICB9IGVsc2UgewotICAgICAgICAvLyBGSVhNRTogQWRkIGltcGxlbWVudGF0 aW9uIGZvciB3b3JrZXJzLgorICAgICAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0g c3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworICAgICAgICBXb3JrZXJMb2Fk ZXJQcm94eSogd29ya2VyTG9hZGVyUHJveHkgPSAmd29ya2VyQ29udGV4dC0+dGhyZWFkKCktPndv cmtlckxvYWRlclByb3h5KCk7CisgICAgICAgIFdlYldvcmtlckJhc2UqIHdlYldvcmtlciA9IHN0 YXRpY19jYXN0PFdlYldvcmtlckJhc2UqPih3b3JrZXJMb2FkZXJQcm94eSk7CisgICAgICAgIHdl Yldvcmtlci0+b3BlbkZpbGVTeXN0ZW0oc3RhdGljX2Nhc3Q8V2ViRmlsZVN5c3RlbTo6VHlwZT4o dHlwZSksIHNpemUsIG5ldyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzSW1wbChuZXcgRmlsZVN5c3Rl bUNhbGxiYWNrcyhzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGNvbnRleHQpKSk7CiAg ICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu Y3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCA0MmY0MWQy ZGM3OWI0ZTNlNDYzY2U0OWQ4MmU2NWE1NDgzOTU1ZTJlLi5hNjlhYWRhNGIyN2E3OWU3ZWM1ZGIw NGRjY2VhM2U4YjljYjdkMDIyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAK QEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybU1lc3NhZ2VQb3J0Q2hhbm5lbC5o IgogCiAjaW5jbHVkZSAiV2ViRGF0YVNvdXJjZUltcGwuaCIKKyNpbmNsdWRlICJXZWJGaWxlRXJy b3IuaCIKICNpbmNsdWRlICJXZWJGcmFtZUNsaWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1w bC5oIgogI2luY2x1ZGUgIldlYk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgpAQCAtNDUsNiArNDYsOCBA QAogI2luY2x1ZGUgIldlYlZpZXcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJDbGllbnQuaCIKIAor I2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlLmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2lu Y2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CkBAIC01 Niw2ICs1OSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogI2lmIEVOQUJMRShXT1JLRVJTKQogCiBz dGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFsbG93RGF0YWJhc2VNb2Rl IjsKK3N0YXRpYyBjb25zdCBjaGFyIG9wZW5GaWxlU3lzdGVtTW9kZVtdID0gIm9wZW5GaWxlU3lz dGVtTW9kZSI7CiAKIG5hbWVzcGFjZSB7CiAKQEAgLTExNCw2ICsxMTgsNyBAQCBwcml2YXRlOgog ICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOwogICAgIFdURjo6U3RyaW5nIG1fbW9kZTsKIH07 CisKIH0KIAogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkIHRv IGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKQEAgLTIzMSw2ICsyMzYsMTYgQEAgYm9v bCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5n JiBuYW1lLCBjb25zdCBXZWJTdHIKICAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQoKTsKIH0KIAor dm9pZCBXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlIHR5 cGUsIGxvbmcgbG9uZyBzaXplLCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCit7 CisgICAgV29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhyZWFkLT5ydW5Mb29wKCk7 CisgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9IFdvcmtlclNjcmlwdENv bnRyb2xsZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgV29ya2VyQ29udGV4dCogd29y a2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsKKworICAgIFJlZlB0cjxX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UgPSBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlOjpjcmVhdGUodGhpcywgd29ya2VyQ29udGV4dCwgY2FsbGJhY2tzKTsK KyAgICBicmlkZ2UtPnBvc3RPcGVuRmlsZVN5c3RlbVRvTWFpblRocmVhZChjb21tb25DbGllbnQo KSwgdHlwZSwgc2l6ZSwgb3BlbkZpbGVTeXN0ZW1Nb2RlKTsKK30KKwogLy8gV29ya2VyT2JqZWN0 UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2VyT2JqZWN0 KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuaAppbmRleCAyMjcxMWY5ZjIyY2Y3MDZiZGRlYjAyMmM4NWM0YzMyN2Q2 ZTMxMmIzLi42MjhkOGYxOGMzZTE3YTIwNmY4NWZjY2FlYTM3YTlmZWMxZDk2YWNiIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtOTEsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAg Ly8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBpcyBhbGxvd2VkIGZv ciB0aGlzIHdvcmtlci4KICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSos IGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5z aWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAorICAgIC8vIFJlcXVlc3RzIHRvIG9wZW4gYSBm aWxlIHN5c3RlbSBmb3IgdGhpcyB3b3JrZXIuIChOb3RlIHRoYXQgdGhpcyBpcyBub3QgdGhlIGlt cGxlbWVudGF0aW9uIGZvciBXZWJGcmFtZUNsaWVudDo6b3BlbkZpbGVTeXN0ZW0uKQorICAgIHZv aWQgb3BlbkZpbGVTeXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdl YkZpbGVTeXN0ZW1DYWxsYmFja3MqKTsKKwogICAgIC8vIEV4ZWN1dGVzIHRoZSBnaXZlbiB0YXNr IG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNwYXRjaFRhc2tUb01haW5U aHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5o IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5kZXggNzQxZDYw NjQwNjk2MWYzZjI1OTBkYjA5OTlmYjIwNzY1MmE1ZjU0NS4uMDYwNDgyMzVkYmYyOGZjOWVmZjM0 YTJhZWZkYTg0MWE4OTc0YzdkMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGll bnRJbXBsLmgKQEAgLTMzLDggKzMzLDggQEAKIAogI2lmIEVOQUJMRShXT1JLRVJTKQogCisjaW5j bHVkZSAiV2ViRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgotCiAj aW5jbHVkZSAiV29ya2VyQ29udGV4dFByb3h5LmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIu aD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6CiAg ICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9 CisgICAgdmlydHVhbCB2b2lkIG9wZW5GaWxlU3lzdGVtKFdlYkZyYW1lKiwgV2ViRmlsZVN5c3Rl bTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqKQorICAgIHsK KyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQogCiBwcml2YXRlOgogICAgIHZp cnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5jcHAgYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE1 MWUyYmFhOGVkMWJmZDhkNzgwNWJlM2RhNGQzOGY4NmUyYzE2ZjMKLS0tIC9kZXYvbnVsbAorKysg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3Bw CkBAIC0wLDAgKzEsMTg1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJl CisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHly aWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhl IG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9y cyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9t CisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNz aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBI T0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKwor I2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIldlYkNvbW1vbldvcmtlckNs aWVudC5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKKyNpbmNsdWRlICJX ZWJTdHJpbmcuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJCYXNlLmgiCisjaW5jbHVkZSAiV29ya2Vy Q29udGV4dC5oIgorI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRl ICJXb3JrZXJUaHJlYWQuaCIKKyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorI2luY2x1ZGUg PHd0Zi9UaHJlYWRpbmcuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFj ZSBXZWJLaXQgeworCisvLyBGaWxlU3lzdGVtQ2FsbGJhY2tzIHRoYXQgYXJlIHRvIGJlIGRpc3Bh dGNoZWQgb24gdGhlIG1haW4gdGhyZWFkLgorY2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxs YmFja3MgOiBwdWJsaWMgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyB7CitwdWJsaWM6CisgICAgc3Rh dGljIFBhc3NPd25QdHI8TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNyZWF0ZShQYXNz UmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3Ry aW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBNYWluVGhyZWFk RmlsZVN5c3RlbUNhbGxiYWNrcyhicmlkZ2UsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2aXJ0dWFs IH5NYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcygpCisgICAgeworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0 IFdlYlN0cmluZyYgcGF0aCkKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRPcGVuRmlsZVN5 c3RlbU9uTWFpblRocmVhZChuYW1lLCBwYXRoLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhp czsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbChXZWJGaWxlRXJyb3IgZXJyb3Ip CisgICAgeworICAgICAgICBtX2JyaWRnZS0+ZGlkRmFpbE9uTWFpblRocmVhZChlcnJvciwgbV9t b2RlKTsKKyAgICAgICAgZGVsZXRlIHRoaXM7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRp ZFN1Y2NlZWQoKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwor ICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgV2ViRmlsZUlu Zm8mIGluZm8pCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisg ICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnkoY29uc3QgV2ViVmVjdG9y PFdlYkZpbGVTeXN0ZW1FbnRyeT4mIGVudHJpZXMsIGJvb2wgaGFzTW9yZSkKKyAgICB7CisgICAg ICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAg TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MoUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICAgICAgOiBt X2JyaWRnZShicmlkZ2UpCisgICAgICAgICwgbV9tb2RlKG1vZGUpCisgICAgeworICAgICAgICBB U1NFUlQobV9icmlkZ2UuZ2V0KCkpOworICAgIH0KKworICAgIGZyaWVuZCBjbGFzcyBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOworICAgIFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlPiBtX2JyaWRnZTsKKyAgICBjb25zdCBTdHJpbmcgbV9tb2RlOworfTsKKwor V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNr c0JyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykK KyAgICA6IFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyKHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQq PihzY3JpcHRFeGVjdXRpb25Db250ZXh0KSkKKyAgICAsIG1fd29ya2VyKHdvcmtlcikKKyAgICAs IG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQoY2FsbGJhY2tzKQoreworfQorCitXb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjp+V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgp Cit7CisgICAgQVNTRVJUKCFtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKTsKK30KKwordm9pZCBX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpzdG9wKCkKK3sKKyAgICBBU1NFUlQobV9j b250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0 ZXgpOworICAgIG1fd29ya2VyID0gMDsKKworICAgIGlmIChtX2NhbGxiYWNrc09uV29ya2VyVGhy ZWFkKSB7CisgICAgICAgIG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQtPmRpZEZhaWwoV2ViRmls ZUVycm9yQWJvcnQpOworICAgICAgICBtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkID0gMDsKKyAg ICB9Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdE9wZW5G aWxlU3lzdGVtVG9NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50 LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcm IG1vZGUpCit7CisgICAgbV9zZWxmUmVmID0gdGhpczsKKyAgICBBU1NFUlQobV9jb250ZXh0LT5p c0NvbnRleHRUaHJlYWQoKSk7CisgICAgQVNTRVJUKG1fd29ya2VyKTsKKyAgICBtX3dvcmtlci0+ ZGlzcGF0Y2hUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0 ZW1Pbk1haW5UaHJlYWQsIGNvbW1vbkNsaWVudCwgdHlwZSwgc2l6ZSwgdGhpcywgbW9kZSkpOwor fQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6Om9wZW5GaWxlU3lzdGVt T25NYWluVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3JrZXJDbGll bnQqIGNvbW1vbkNsaWVudCwgV2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSogYnJpZGdlLCBjb25zdCBTdHJpbmcm IG1vZGUpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAoIWNvbW1vbkNs aWVudCkKKyAgICAgICAgYnJpZGdlLT5kaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvckFi b3J0LCBtb2RlKTsKKyAgICBlbHNlIHsKKyAgICAgICAgLy8gTWFpblRocmVhZEZpbGVTeXN0ZW1D YWxsYmFja3MgaXMgc2VsZi1kZXN0cnVjdGVkLCBzbyB3ZSBsZWFrIHB0ciBoZXJlLgorICAgICAg ICBjb21tb25DbGllbnQtPm9wZW5GaWxlU3lzdGVtKHR5cGUsIHNpemUsIE1haW5UaHJlYWRGaWxl U3lzdGVtQ2FsbGJhY2tzOjpjcmVhdGUoYnJpZGdlLCBtb2RlKS5sZWFrUHRyKCkpOworICAgIH0K K30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRGYWlsT25NYWlu VGhyZWFkKFdlYkZpbGVFcnJvciBlcnJvciwgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIG1h eVBvc3RUYXNrVG9Xb3JrZXIoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRGYWlsT25Xb3JrZXJUaHJl YWQsIG1fc2VsZlJlZiwgZXJyb3IpLCBtb2RlKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlOjpkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sK KyAgICBtYXlQb3N0VGFza1RvV29ya2VyKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkT3BlbkZpbGVT eXN0ZW1PbldvcmtlclRocmVhZCwgbV9zZWxmUmVmLCBuYW1lLCByb290UGF0aCksIG1vZGUpOwor fQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZEZhaWxPbldvcmtl clRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UsIFdlYkZpbGVFcnJvciBlcnJvcikKK3sKKyAgICBp ZiAoYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAgICAgIEFTU0VSVChi cmlkZ2UtPm1fY29udGV4dCAmJiBicmlkZ2UtPm1fY29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkp OworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQtPmRpZEZhaWwoZXJy b3IpOworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAg IH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRPcGVuRmls ZVN5c3RlbU9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRy PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJh Y2tzT25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKGJyaWRnZS0+bV9jb250ZXh0ICYm IGJyaWRnZS0+bV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIGJyaWRnZS0+ bV9jYWxsYmFja3NPbldvcmtlclRocmVhZC0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgcm9vdFBh dGgpOworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAg IH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjptYXlQb3N0VGFz a1RvV29ya2VyKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywg Y29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAg TXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIGlmIChtX3dvcmtlcikKKyAgICAgICAg bV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dCh0YXNrLCBtb2RlKTsKKyAg ICBtX3NlbGZSZWYuY2xlYXIoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmggYi9XZWJLaXQvY2hyb21pdW0vc3Jj L1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lOTQ2OTYzMTll ODBmM2UyMDhiYmE0MDQzMjg2MWNiODkyMjdmN2Y0Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgKQEAgLTAsMCAr MSwxMTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaWZuZGVmIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2VfaAorI2RlZmlu ZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKworI2luY2x1ZGUgIlBsYXRmb3Jt U3RyaW5nLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorI2luY2x1ZGUg IldlYkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJX ZWJWZWN0b3IuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSA8d3RmL1Bh c3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9U aHJlYWRpbmcuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIEFzeW5jRmlsZVN5c3Rl bTsKK2NsYXNzIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xhc3MgVGhyZWFkYWJs ZUNhbGxiYWNrc0JyaWRnZVdyYXBwZXI7CitjbGFzcyBXZWJDb21tb25Xb3JrZXJDbGllbnQ7Citz dHJ1Y3QgV2ViRmlsZUluZm87CitjbGFzcyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xhc3Mg V2ViRmlsZVN5c3RlbUVudHJ5OworY2xhc3MgV2ViV29ya2VyQmFzZTsKKworLy8gVGhpcyBjbGFz cyBpcyB1c2VkIHRvIHBvc3QgYSBvcGVuRmlsZVN5c3RlbSByZXF1ZXN0IHRvIHRoZSBtYWluIHRo cmVhZCBhbmQgZ2V0IGNhbGxlZCBiYWNrIGZvciB0aGUgcmVxdWVzdC4gVGhpcyBtdXN0IGJlIGRl c3RydWN0ZWQgb24gdGhlIHdvcmtlciB0aHJlYWQuCisvLworLy8gQSB0eXBpY2FsIGZsb3cgZm9y IG9wZW5GaWxlU3lzdGVtIHdvdWxkIGxvb2sgbGlrZSB0aGlzOgorLy8gQnJpZGdlOjpwb3N0T3Bl bkZpbGVTeXN0ZW1Ub01haW5UaHJlYWQoKSBvbiBXb3JrZXJUaHJlYWQKKy8vICAtLT4gQnJpZGdl OjpvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCgpIGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisv LyAgICAgIFRoaXMgbWFrZXMgYW4gSVBDIHdpdGggYSBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxi YWNrcyBpbnN0YW5jZQorLy8gICAgIFthY3R1YWwgb3BlcmF0aW9uIGlzIGRvd24gaW4gdGhlIGJy b3dzZXJdCisvLyAgLS0+IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOjpkaWRYeHggaXMg Y2FsbGVkIG9uIE1haW5UaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpkaWRYeHhPbk1haW5UaHJlYWQg aXMgY2FsbGVkIG9uIE1haW5UaHJlYWQKKy8vICAtLT4gQnJpZGdlOjpkaWRYeHhPbldvcmtlclRo cmVhZCBpcyBjYWxsZWQgb24gV29ya2VyVGhyZWFkCisvLyAgICAgIFRoaXMgY2FsbHMgdGhlIG9y aWdpbmFsIGNhbGxiYWNrcyAobV9jYWxsYmFja3NPbldvcmtlclRocmVhZCkgYW5kCisvLyAgICAg IHJlbGVhc2VzIGEgc2VsZi1yZWZlcmVuY2UgdG8gdGhlIGJyaWRnZS4KK2NsYXNzIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiwgcHVibGljIFdlYkNvcmU6OldvcmtlckNvbnRleHQ6 Ok9ic2VydmVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlPiBjcmVhdGUoV2ViV29ya2VyQmFzZSogd29ya2VyLCBXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiB3b3JrZXJDb250ZXh0LCBXZWJGaWxlU3lzdGVtQ2Fs bGJhY2tzKiBjYWxsYmFja3MpCisgICAgeworICAgICAgICByZXR1cm4gV1RGOjphZG9wdFJlZihu ZXcgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSh3b3JrZXIsIHdvcmtlckNvbnRleHQs IGNhbGxiYWNrcykpOworICAgIH0KKyAgICB+V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSgpOworCisgICAgLy8gV29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIgbWV0aG9kLgorICAgIHZpcnR1 YWwgdm9pZCBub3RpZnlTdG9wKCkKKyAgICB7CisgICAgICAgIHN0b3AoKTsKKyAgICB9CisKKyAg ICB2b2lkIHN0b3AoKTsKKworICAgIC8vIE1ldGhvZCB0aGF0IHBvc3RzIGFuIGluaXRpYWwgcmVx dWVzdCB0YXNrIHRvIHRoZSBtYWluIHRocmVhZC4gSXQgaXMgc3VwcG9zZWQgdG8gYmUgY2FsbGVk IGltbWVkaWF0ZWx5IGFmdGVyIHRoZSBicmlkZ2UgaXMgY29uc3RydWN0ZWQgKGl0IGRvZXNuJ3Qg Y2hlY2sgaWYgdGhlIGNvbnRleHQgaGFzIGJlZW4gc3RvcHBlZCBvciBub3QpLgorICAgIHZvaWQg cG9zdE9wZW5GaWxlU3lzdGVtVG9NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNsaWVudCosIFdl YkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcmIG1vZGUpOwor CisgICAgLy8gQ2FsbGJhY2sgbWV0aG9kcyB0aGF0IGFyZSBjYWxsZWQgb24gdGhlIG1haW4gdGhy ZWFkLgorICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3IsIGNvbnN0IFN0 cmluZyYgbW9kZSk7CisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChjb25z dCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgsIGNvbnN0IFN0cmluZyYgbW9k ZSk7CisKK3ByaXZhdGU6CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZShXZWJX b3JrZXJCYXNlKiwgV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkZpbGVTeXN0 ZW1DYWxsYmFja3MqKTsKKworICAgIC8vIE1ldGhvZCB0aGF0IGlzIHRvIGJlIGNhbGxlZCBvbiB0 aGUgbWFpbiB0aHJlYWQuCisgICAgc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJl YWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkNvbW1vbldvcmtlckNsaWVu dCosIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlKiwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworICAgIGZyaWVuZCBjbGFz cyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKKworICAgIC8vIE1ldGhvZHMgdGhhdCBk aXNwYXRjaCBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIG9uIHRoZSB3b3JrZXIgdGhyZWFkcy4KKyAg ICAvLyBUaGV5IHJlbGVhc2UgYSBzZWxmUmVmIG9mIHRoZSBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJh Y2tzQnJpZGdlLgorICAgIHN0YXRpYyB2b2lkIGRpZEZhaWxPbldvcmtlclRocmVhZChXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlPiwgV2ViRmlsZUVycm9yKTsKKyAgICBzdGF0aWMgdm9pZCBkaWRPcGVuRmls ZVN5c3RlbU9uV29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQ YXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+LCBjb25zdCBTdHJpbmcm IG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgpOworCisgICAgLy8gSGVscGVyIG1ldGhvZC4K KyAgICB2b2lkIG1heVBvc3RUYXNrVG9Xb3JrZXIoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworICAgIC8vIG1f c2VsZlJlZiBrZWVwcyBhIHJlZmVyZW5jZSB0byBpdHNlbGYgdW50aWwgY2FsbGJhY2tzIGFyZSBm aXJlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICBSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZT4gbV9zZWxmUmVmOworCisgICAgTXV0ZXggbV9tdXRleDsKKyAgICBXZWJX b3JrZXJCYXNlKiBtX3dvcmtlcjsKKworICAgIC8vIFRoaXMgaXMgc2VsZi1kZXN0cnVjdGVkIGFu ZCBtdXN0IGJlIGZpcmVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorICAgIFdlYkZpbGVTeXN0ZW1D YWxsYmFja3MqIG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQ7Cit9OworCit9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gK 68608 2010-09-23 15:36:22 -0700 2010-09-23 15:47:18 -0700 Patch bug-45808-20100923153621.patch text/plain 44338 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWJmMzcyMGNiYzVjMGU5Y2ZkMTM1ZmFjOGY3YmUwYThkYzM3NzQ2Ni4uZWI4ODBhOGM2M2IwNTFi ODIyMzAzMDllYzhkYWIxNzBhNjkzYmM5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMiAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMiAgRGF2aWQgSHlhdHQg IDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1 cmVzLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcAppbmRleCBhMTVmZDZkMDgwMmZiZWVmMTEwOWZjYTljOWQzYjJmM2QzMDIwYzA0Li45YTk2 ZjIyNmQzY2ZmNzI3OGM3OTI2OWExYzgyZTRhY2M3ODQwNjRiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKKysrIGIvV2ViQ29y ZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCkBAIC0zNiw2ICsz NiwxMCBAQAogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNpbmNsdWRlICJX ZWJTb2NrZXQuaCIKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgUnVudGlt ZUVuYWJsZWRGZWF0dXJlczo6aXNMb2NhbFN0b3JhZ2VFbmFibGVkID0gdHJ1ZTsKQEAgLTU3LDYg KzYxLDExIEBAIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNYSFJSZXNwb25zZUJsb2JF bmFibGVkID0gZmFsc2U7CiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiBib29sIFJ1bnRpbWVF bmFibGVkRmVhdHVyZXM6OmlzRmlsZVN5c3RlbUVuYWJsZWQgPSBmYWxzZTsKKworYm9vbCBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCgpCit7CisgICAgcmV0dXJuIGlz RmlsZVN5c3RlbUVuYWJsZWQgJiYgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpOworfQog I2VuZGlmCiAKICNpZiBFTkFCTEUoVklERU8pCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdz L2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5l cmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAppbmRleCA5MTc2OGIwZTU0ZTdmOTdiYWNkMGE5 YmQzMzllMWRjNDIwZDZlZGVlLi5iYTRhNGZiMDVkZjUxZDc0NDRmYjlhM2JhMTAwMmFlNDdhYmQ1 ZmM4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5oCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmgKQEAgLTE0OCw3ICsxNDgsNyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKLSAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0 dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KKyAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5h YmxlZCgpOwogICAgIHN0YXRpYyB2b2lkIHNldEZpbGVTeXN0ZW1FbmFibGVkKGJvb2wgaXNFbmFi bGVkKSB7IGlzRmlsZVN5c3RlbUVuYWJsZWQgPSBpc0VuYWJsZWQ7IH0KICAgICBzdGF0aWMgYm9v bCByZXF1ZXN0RmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVk OyB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u Y3BwIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2 ZDdiYjE5ZjFkNDgzOWU1ZWUzOTk2MDBmNmUwNDRmNi4uZjgyNmI3MWMyZGQ3YjE1MjRkMDA4YzIx ZmY0YmNmZGM5Nzc4YzhhNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUw LDkgKzUwLDMwIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZp bGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp CitMb2NhbEZpbGVTeXN0ZW0qIExvY2FsRmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3Zv aWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmlu ZyYgYmFzZVBhdGgpCit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90 YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNT RVJUKCFzX2luc3RhbmNlKTsKKyAgICBpZiAoc19pbnN0YW5jZSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIo bmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aCkpOworICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZp bGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVt IG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4KKyAgICBBU1NFUlQoc19pbnN0YW5j ZSk7CisgICAgcmV0dXJuICpzX2luc3RhbmNlOworfQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVt OjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcg TG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgcmV0dXJuIG1fYmFzZVBhdGg7CiB9CiAK IHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25z dCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAKICAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVT eXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkp OwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2Fs RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4IDQ4 Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLmQwOGQwZjBmMGZmNzJiYjAw OGU3NDAwMjAyYmJkMjU0NzNjZDc1NDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2Nh bEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKQEAg LTQ0LDIwICs0NCw0NCBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxGaWxl U3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVwcyBw ZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8gb3Bl biBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IGNy ZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVTeXN0 ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9jYWxG aWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0aGlz IG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAog ICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNh bGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAh UExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBjYWxsIGlzIG5vdCB0aHJlYWQtc2FmZTsg bXVzdCBiZSBjYWxsZWQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkcyBhcmUgY3JlYXRlZC4KKyAg ICB2b2lkIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJik7CisKKyAgICBT dHJpbmcgZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3Q7CisjZW5kaWYKKworcHJpdmF0ZToKICAg ICBMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKICAgICAgICAgOiBtX2Jh c2VQYXRoKGJhc2VQYXRoKQogICAgIHsKICAgICB9CiAKLSAgICBTdHJpbmcgbV9iYXNlUGF0aDsK KyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtKiBzX2luc3RhbmNlOworCisgICAgLy8gQW4gaW5u ZXIgY2xhc3MgdGhhdCBlbmZvcmNlcyB0aHJlYWQtc2FmZSBzdHJpbmcgYWNjZXNzLgorICAgIGNs YXNzIFN5c3RlbUJhc2VQYXRoIHsKKyAgICBwdWJsaWM6CisgICAgICAgIGV4cGxpY2l0IFN5c3Rl bUJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgOiBtX3ZhbHVlKHBhdGgpIHsgfQorICAgICAg ICBvcGVyYXRvciBTdHJpbmcoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4g bV92YWx1ZS50aHJlYWRzYWZlQ29weSgpOworICAgICAgICB9CisgICAgcHJpdmF0ZToKKyAgICAg ICAgU3RyaW5nIG1fdmFsdWU7CisgICAgfTsKKworICAgIFN5c3RlbUJhc2VQYXRoIG1fYmFzZVBh dGg7CiB9OwogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCBmNWJhMjVjMzZhOWFk MmM3ZmQxNjU5YTViNWQzZDA2ZDg3YmE1YzQ2Li42YTIwM2NjN2M0OTJlYzMzYWJlMDAyOTJlM2Ew NDhkOGEyYWMzNDFkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBE T01XaW5kb3c6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFz c1JlZlB0cjxGaWxlU3lzdGUKICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAK LSAgICBpZiAoIW1fbG9jYWxGaWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYg YWNjZXNzIGlzIGFsbG93ZWQuCi0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdl KCk7Ci0gICAgICAgIGlmICghcGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2No ZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUo SU5WQUxJRF9TVEFURV9FUlIpKTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0g ICAgICAgIC8vIEZJWE1FOiBHZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAg IFN0cmluZyBwYXRoID0gcGFnZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0g ICAgICAgIG1fbG9jYWxGaWxlU3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7 CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5z ZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmls ZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVy cm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAg ICBtX2xvY2FsRmlsZVN5c3RlbS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19j YXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywg ZXJyb3JDYWxsYmFjayk7CisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5y ZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAot Q09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxl U3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChE T01XaW5kb3c6OlBFUlNJU1RFTlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQp LCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1w b3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4o RE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3Rl bTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4 IDE0NzA2Mjg2NWQ5YjliNzc0NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLjZmZDM3NzUwM2FiNGVl ZjFkOWU3NzVmOTgzMDRkMTEzMWZhZmIwM2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuaAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFj dG9yeTsKICAgICBjbGFzcyBJbnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2Fs RmlsZVN5c3RlbTsKICAgICBjbGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwog ICAgIGNsYXNzIE5hdmlnYXRvcjsKQEAgLTQ0NCw5ICs0NDMsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRy PElEQkZhY3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKLSAgICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0j ZW5kaWYKIAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1NjE5YWJjMTA0ZWI5ODFkY2Vk NWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5NzQ3MTY1MSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3Vy aXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBjYW5BY2Nl c3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogICAgIGJvb2wg Y2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9v bCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsg fQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1 ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxkIGFsd2F5cyBhbGxvdyBhY2Nl c3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1cnJlbnRseSBkb24ndCBoYW5k bGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1bmlxdWUKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmlu ZGV4IGZhYzBhNWY0OTY4ZGI2YTRhYTFkNzk0NmZlYmRkM2VmNjk1MTQ3YTUuLjRkMTY2MmI2MzZh OTgxNDE2OGI2ZTU4ODQ4YTU3MGI2YjY1OTE2MjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtNDk3LDExICs0 OTcsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoY29uc3Qg U3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoID0gcGF0aDsKIH0K IAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYgcGF0 aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7Ci19Ci0KIHZvaWQgU2V0dGlu Z3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUpCiB7CiAgICAgbV9pbkFwcGxp Y2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDk5YTRmMjMyYzUyOTgwNmVhYTI3 Zjg1ZDU3ZGJiYWIxMjc0NGJmMzMuLmY4YTI5N2ExN2IwNTU2OWQ4NWZjN2IxMTBjNDY1NmY0NDc0 MDc2NGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCisrKyBiL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5oCkBAIC0yNDEsOSArMjQxLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmKTsK ICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoKSBjb25zdCB7 IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQogCi0gICAgICAgIHZvaWQgc2V0 RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAgICAgICBjb25zdCBTdHJpbmcm IGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZVN5c3RlbVJvb3RQYXRo OyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUoYm9vbCk7CiAgICAg ICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25zdCB7IHJldHVybiBtX2luQXBw bGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzNiw3ICszMzMsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5jb2RpbmdOYW1lOwogICAgICAg ICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAgICAgICAgIFN0cmluZyBtX2xv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5nIG1fZmlsZVN5c3RlbVJvb3RQ YXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKICAgICAgICAgQXRv bWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAgICBBdG9taWNTdHJpbmcgbV9m aXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKaW5kZXggYjRm Y2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4uNTczMDVmZmMyYmEwYzRhNGYz YTZlM2RlOGYyMWFhZTQxOWY4NWU1OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3lu Y0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cApAQCAtMzUsMTIgKzM1LDIwIEBACiAKICNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MuaCIKICNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9v bCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgp OworICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFz eW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYpCiB7Ci0gICAgLy8gRklYTUU6IHJl dHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1lbnRhdGlvbi4KKyAgICBub3RJbXBs ZW1lbnRlZCgpOwogICAgIHJldHVybiAwOwogfQogCkBAIC02Miw2ICs3MCw3IEBAIHZvaWQgQXN5 bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25z dCBTdHJpbmcmIHN0b3JhCiAKICAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUs IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHJvb3RQYXRoKSk7CiB9CisjZW5kaWYKIAogLy8gRGVm YXVsdCBpbXBsZW1lbnRhdGlvbi4KIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW06OnZpcnR1YWxUb1Bs YXRmb3JtUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVT eXN0ZW0uaAppbmRleCA2MDFmMGVhZTNlNWQwZThiZWI4NGQ1YTk5M2Q3NzA1MTdiZDBhNjJkLi44 YzRkNWQ5OTBmZGE0NmMyYjc4MGRmOWIwOWE2MDc3ZTU0ZDlmZjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5 bmNGaWxlU3lzdGVtLmgKQEAgLTU2LDYgKzU2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBzdG9wKCkgeyB9CiAgICAgdmlydHVhbCBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIHsgcmV0 dXJuIGZhbHNlOyB9CiAKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgLy8g Q3JlYXRlcyBhbmQgcmV0dXJucyBhIG5ldyBwbGF0Zm9ybS1zcGVjaWZpYyBBc3luY0ZpbGVTeXN0 ZW0gaW5zdGFuY2UgaWYgdGhlIHBsYXRmb3JtIGhhcyBpdHMgb3duIGltcGxlbWVudGF0aW9uLgog ICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmlu ZyYgcm9vdFBhdGgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5kZXggYjUyYjI4NTQ3 NWYyZWY5NDc3ZTgxNGJiZTRkOGJlYjljM2I5ZWEwYS4uNDk2NGQwNWQ3ODM2YjMyMDlkMDIyOGE4 OWFiNDcwY2ZkZjMyMDUzMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtNjMsNiAr NjMsMTUgQEAKICNpbmNsdWRlICJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2luY2x1 ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiRmlsZVN5c3RlbUNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiTG9jYWxGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBDbG9zZVdvcmtlckNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2sgewpAQCAtMTAwLDYgKzEwOSwxMCBAQCBXb3JrZXJDb250ZXh0Ojp+V29ya2VyQ29u dGV4dCgpCiAjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAgICAgbV9ub3RpZmljYXRpb25zLmNs ZWFyKCk7CiAjZW5kaWYKKworICAgIC8vIE1ha2Ugc3VyZSB3ZSBoYXZlIG5vIG9ic2VydmVycy4K KyAgICBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIC8vIE5vdGlmeSBwcm94eSB0aGF0 IHdlIGFyZSBnb2luZyBhd2F5LiBUaGlzIGNhbiBmcmVlIHRoZSBXb3JrZXJUaHJlYWQgb2JqZWN0 LCBzbyBkbyBub3QgYWNjZXNzIGl0IGFmdGVyIHRoaXMuCiAgICAgdGhyZWFkKCktPndvcmtlclJl cG9ydGluZ1Byb3h5KCkud29ya2VyQ29udGV4dERlc3Ryb3llZCgpOwogfQpAQCAtMzM1LDYgKzM0 OCw2OCBAQCB2b2lkIFdvcmtlckNvbnRleHQ6OnJldm9rZUJsb2JVUkwoY29uc3QgU3RyaW5nJiBi bG9iVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCit2b2lk IFdvcmtlckNvbnRleHQ6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1Jl ZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQoreworICAgIGlmICghQXN5bmNGaWxl U3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8ICFzZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxl U3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayh0aGlz LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVt KCkucmVxdWVzdEZpbGVTeXN0ZW0odGhpcywgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKK30KKwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpURU1QT1JBUlkp ID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21p c21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6 UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3Rl bnQpLCBlbnVtX21pc21hdGNoKTsKKyNlbmRpZgorCitXb3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6 T2JzZXJ2ZXIoV29ya2VyQ29udGV4dCogY29udGV4dCkKKyAgICA6IG1fY29udGV4dChjb250ZXh0 KQoreworICAgIEFTU0VSVChtX2NvbnRleHQgJiYgbV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQo KSk7CisgICAgbV9jb250ZXh0LT5yZWdpc3Rlck9ic2VydmVyKHRoaXMpOworfQorCitXb3JrZXJD b250ZXh0OjpPYnNlcnZlcjo6fk9ic2VydmVyKCkKK3sKKyAgICBpZiAoIW1fY29udGV4dCkKKyAg ICAgICAgcmV0dXJuOworICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsK KyAgICBtX2NvbnRleHQtPnVucmVnaXN0ZXJPYnNlcnZlcih0aGlzKTsKK30KKwordm9pZCBXb3Jr ZXJDb250ZXh0OjpPYnNlcnZlcjo6c3RvcE9ic2VydmluZygpCit7CisgICAgaWYgKCFtX2NvbnRl eHQpCisgICAgICAgIHJldHVybjsKKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0NvbnRleHRUaHJl YWQoKSk7CisgICAgbV9jb250ZXh0LT51bnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7CisgICAgbV9j b250ZXh0ID0gMDsKK30KKwordm9pZCBXb3JrZXJDb250ZXh0OjpyZWdpc3Rlck9ic2VydmVyKE9i c2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIpOworICAgIG1fd29ya2Vy T2JzZXJ2ZXJzLmFkZChvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29ya2VyQ29udGV4dDo6dW5yZWdp c3Rlck9ic2VydmVyKE9ic2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIp OworICAgIG1fd29ya2VyT2JzZXJ2ZXJzLnJlbW92ZShvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29y a2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCkKK3sKKyAgICBIYXNoU2V0PE9ic2Vy dmVyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX3dvcmtlck9ic2VydmVycy5iZWdpbigpOworICAgIHdo aWxlIChpdGVyICE9IG1fd29ya2VyT2JzZXJ2ZXJzLmVuZCgpKSB7CisgICAgICAgIFdvcmtlckNv bnRleHQ6Ok9ic2VydmVyKiBvYnNlcnZlciA9ICppdGVyOworICAgICAgICBvYnNlcnZlci0+c3Rv cE9ic2VydmluZygpOworICAgICAgICBvYnNlcnZlci0+bm90aWZ5U3RvcCgpOworICAgICAgICBp dGVyID0gbV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uMjkz ZDkyOTI2ZTVmZDg1YzI4ZmMxODY2NGNiN2JlZjczNGQ5NTcyMiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4 dC5oIgogI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlIDx3dGYv QXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL093 blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KQEAgLTQ3LDYgKzQ4LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNz IERhdGFiYXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJh c2VTeW5jOworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVs ZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTI0LDE0IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0 cmluZyYpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIGVudW0g RmlsZVN5c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVS U0lTVEVOVCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQg dHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFz c1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRo b2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hp bGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNw cC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsg cmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkBAIC0xMzEsNiArMTQyLDIxIEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogICAgICAgICBib29sIGlzQ2xvc2luZygpIHsgcmV0dXJuIG1fY2xvc2lu ZzsgfQogCisgICAgICAgIC8vIEFuIG9ic2VydmVyIGludGVyZmFjZSB0byBiZSBub3RpZmllZCB3 aGVuIHRoZSB3b3JrZXIgdGhyZWFkIGlzIGdldHRpbmcgc3RvcHBlZC4KKyAgICAgICAgY2xhc3Mg T2JzZXJ2ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgICAgICBwdWJsaWM6CisgICAgICAg ICAgICBPYnNlcnZlcihXb3JrZXJDb250ZXh0Kik7CisgICAgICAgICAgICB2aXJ0dWFsIH5PYnNl cnZlcigpOworICAgICAgICAgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKSA9IDA7CisgICAg ICAgICAgICB2b2lkIHN0b3BPYnNlcnZpbmcoKTsKKyAgICAgICAgcHJpdmF0ZToKKyAgICAgICAg ICAgIFdvcmtlckNvbnRleHQqIG1fY29udGV4dDsKKyAgICAgICAgfTsKKyAgICAgICAgZnJpZW5k IGNsYXNzIE9ic2VydmVyOworICAgICAgICB2b2lkIHJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIq IG9ic2VydmVyKTsKKyAgICAgICAgdm9pZCB1bnJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIqIG9i c2VydmVyKTsKKyAgICAgICAgdm9pZCBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIHBy b3RlY3RlZDoKICAgICAgICAgV29ya2VyQ29udGV4dChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5n JiwgV29ya2VyVGhyZWFkKik7CiAKQEAgLTE2MSw2ICsxODcsOCBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIGJvb2wgbV9jbG9zaW5nOwogICAgICAgICBib29sIG1fcmVwb3J0aW5nRXhj ZXB0aW9uOwogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CisKKyAg ICAgICAgSGFzaFNldDxPYnNlcnZlcio+IG1fd29ya2VyT2JzZXJ2ZXJzOwogICAgIH07CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmlkbCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAppbmRleCAwMmFh NGFkYjg4YmMyZGY2N2YyN2Q1ZWNlMmI1YTkyMzI4Njc4MTI0Li4zZTE4NWMwZDViOGUwYTEzN2Jk OTI4YzUyYTJkYmE4MTc1ZjgwMzM3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCkBAIC0x MDQsNiArMTA0LDE0IEBAIG1vZHVsZSB0aHJlYWRzIHsKICAgICAgICAgRE9NU3RyaW5nIGNyZWF0 ZUJsb2JVUkwoaW4gQmxvYiBibG9iKTsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGluIERP TVN0cmluZyBibG9iVVJMKTsKICNlbmRpZgorCisjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9TWVNU RU0pICYmIEVOQUJMRV9GSUxFX1NZU1RFTQorICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBU RU1QT1JBUlkgPSAwOworICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0g MTsKKyAgICAgICAgW0VuYWJsZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4g dW5zaWduZWQgc2hvcnQgdHlwZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0 aW9uYWxdIEZpbGVTeXN0ZW1DYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywg T3B0aW9uYWxdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7CisKKyAgICAgICAgICAgICAg ICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0 b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyVGhyZWFkLmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCmlu ZGV4IGQ2YTFlMDU3ZDNlZDgxOGEzNzhlNzUzNjY2OWYzYTBhN2I5NDU3ZmUuLmY2MTEyMGVlZTA0 YzMxYTgwMGZmNTYyOWFmOWEyYjgwYTQ2N2EzYzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJUaHJlYWQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3Bw CkBAIC0yMDIsNiArMjAyLDggQEAgcHVibGljOgogCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnN0 b3BBY3RpdmVET01PYmplY3RzKCk7CiAKKyAgICAgICAgd29ya2VyQ29udGV4dC0+bm90aWZ5T2Jz ZXJ2ZXJzT2ZTdG9wKCk7CisKICAgICAgICAgLy8gRXZlbnQgbGlzdGVuZXJzIHdvdWxkIGtlZXAg RE9NV3JhcHBlcldvcmxkIG9iamVjdHMgYWxpdmUgZm9yIHRvbyBsb25nLiBBbHNvLCB0aGV5IGhh dmUgcmVmZXJlbmNlcyB0byBKUyBvYmplY3RzLAogICAgICAgICAvLyB3aGljaCBiZWNvbWUgZGFu Z2xpbmcgb25jZSBIZWFwIGlzIGRlc3Ryb3llZC4KICAgICAgICAgd29ya2VyQ29udGV4dC0+cmVt b3ZlQWxsRXZlbnRMaXN0ZW5lcnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDQxYWIwOGQ2MzI1NjQwOTMz Y2E1NTBmMjlkZjUxNDdiYjdiOGY0NWQuLjUwZDU0MzI5YWUzNjc1ZTY3NmFkZDZhMzNlMDRjMTI2 ZGMwM2E5ZjUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2Vi S2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA5LTIyICBLaW51 a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0 ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00 NTgwOAorCisgICAgICAgIEFkZGVkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtIGFuZCBX ZWJDb21tb25Xb3JrZXJDbGllbnQ6OgorICAgICAgICBvcGVuRmlsZVN5c3RlbSB0byBjYWxsIGlu IHRvIHRoZSBicm93c2VyIHZpYSBXb3JrZXIgc3R1Yi9wcm94eQorICAgICAgICBpbiB0aGUgY2hy b21pdW0uCisKKyAgICAgICAgQWxzbyBhZGRlZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlIGNsYXNzIHRoYXQgcHJveGllcworICAgICAgICByZXF1ZXN0cyBhbmQgY2FsbGJhY2tzIGJl dHdlZW4gZnJvbS90byB3b3JrZXIgdGhyZWFkIHRvL2Zyb20gdGhlCisgICAgICAgIG1haW4gdGhy ZWFkLgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAg ICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQu CisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgaW1w bGVtZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuIEluIHdvcmtlciBjYXNlIHRoaXMgY2Fs bHMgV2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0uCisgICAgICAgICogc3JjL1dlYldvcmtl ckJhc2UuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3Rl bSk6IEFkZGVkLiBUaGlzIGlzIGNhbGxlZCBmcm9tCisgICAgICAgIExvY2FsRmlsZVN5c3RlbTo6 cmVxdWVzdEZpbGVTeXN0ZW0gb24gdGhlIHdvcmtlciB0aHJlYWQgYW5kIGNyZWF0ZXMKKyAgICAg ICAgYSBicmlkZ2UgdG8gY2FsbCBXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVt IG9uIHRoZSBtYWluCisgICAgICAgIHRocmVhZC4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFz ZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJL aXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAg ICogc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwOiBBZGRlZC4KKyAgICAg ICAgKiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oOiBBZGRlZC4KKwogMjAx MC0wOS0yMiAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgQ2hyb21pdW0gYnVpbGQgZml4LiBGaXggYnVpbGQgd2hlbiBhY2NlbGVyYXRlZApk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAgYi9XZWJLaXQvY2hyb21pdW0v V2ViS2l0Lmd5cAppbmRleCBmYzhmYmRkMzE1NzI5NjkwZmI4ZWU4NWVhYzYxZTUxOTMyN2M3NjJm Li41MGM2YTg5ODYwMzE3ZmVhNWEwY2RjZDFhY2NkMDg3N2Y0ZjIyMDBkIDEwMDY0NAotLS0gYS9X ZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAorKysgYi9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cApAQCAtNTMwLDYgKzUzMCw4IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJDbGll bnRJbXBsLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViV29ya2VySW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViV29ya2VySW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3Jj L1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwJywKKyAgICAgICAgICAgICAgICAn c3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCcsCiAgICAgICAgICAgICAgICAg J3NyYy9XcmFwcGVkUmVzb3VyY2VSZXF1ZXN0LmgnLAogICAgICAgICAgICAgICAgICdzcmMvV3Jh cHBlZFJlc291cmNlUmVzcG9uc2UuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy93aW4vV2ViSW5w dXRFdmVudEZhY3RvcnkuY3BwJywKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1v bldvcmtlckNsaWVudC5oCmluZGV4IGNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0 NGZmMmQuLjM5ZDhhYTk3MWQ2MzQyNDg3YzA3OTkxMjQ1NWE0YjAyY2ZiYTU2MmYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzEsNiAr MzEsOSBAQAogI2lmbmRlZiBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogI2RlZmluZSBXZWJDb21t b25Xb3JrZXJDbGllbnRfaAogCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2Vi RmlsZVN5c3RlbS5oIgorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRp b25DYWNoZUhvc3Q7CkBAIC04Myw2ICs4NiwxMiBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9u IHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCiAg ICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcm IG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1h dGVkU2l6ZSkgPSAwOwogCisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQg YmVmb3JlIG9wZW5pbmcgYSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVT eXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1D YWxsYmFja3MqKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwor ICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07 CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVt LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmlu ZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUzYjNkMTUy YzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7 CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpBc3luY0Zp bGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5bmNGaWxl U3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2ViS2l0Q2xp ZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9j YWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVT eXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2VjYTljZTgy MjBmMjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMxOCAxMDA2NDQK LS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQy LDE0ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsLmgiCiAj aW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNp bmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2lu Y2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogdXNp bmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRy PExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBw YXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgp CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOworICAg IEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBsb2NhbEZpbGVT eXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICpsb2NhbEZpbGVT eXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwg bG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2Fs bGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcg KzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZyYW1lSW1wbCog d2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAg ICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRp Y19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3Rl bUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1F OiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtlckNvbnRleHQq IHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7Cisg ICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250 ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFz ZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclBy b3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNfY2FzdDxXZWJG aWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJ bXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj aywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu Y3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUuLmE2OWFh ZGE0YjI3YTc5ZTdlYzVkYjA0ZGNjZWEzZThiOWNiN2QwMjIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtTWVz c2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5oIgorI2lu Y2x1ZGUgIldlYkZpbGVFcnJvci5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRDaGFubmVsLmgi CkBAIC00NSw2ICs0Niw4IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYldv cmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1ZGUgIldv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKICNpbmNsdWRlICJXb3JrZXJTY3JpcHRD b250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8d3RmL01h aW5UaHJlYWQuaD4KQEAgLTU2LDYgKzU5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAjaWYgRU5B QkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAi YWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0ZW1Nb2Rl W10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKIAogbmFtZXNwYWNlIHsKIApAQCAtMTE0LDYgKzEx OCw3IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAgICAgV1RGOjpT dHJpbmcgbV9tb2RlOwogfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbiB0 aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwpAQCAtMjMx LDYgKzIzNiwxNiBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUq LCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVybiBicmlkZ2Ut PnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKFdlYkZp bGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFj a3MqIGNhbGxiYWNrcykKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJU aHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVy ID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBX b3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2VyQ29udGV4dCgp OworCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSA9 IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmNyZWF0ZSh0aGlzLCB3b3JrZXJDb250 ZXh0LCBjYWxsYmFja3MpOworICAgIGJyaWRnZS0+cG9zdE9wZW5GaWxlU3lzdGVtVG9NYWluVGhy ZWFkKGNvbW1vbkNsaWVudCgpLCB0eXBlLCBzaXplLCBvcGVuRmlsZVN5c3RlbU1vZGUpOworfQor CiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNz YWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3Nh Z2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlmMjJjZjcwNmJk ZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNjYWVhMzdhOWZl YzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05MSw2ICs5MSw5 IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJh c2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0Rh dGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcm IGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisgICAgLy8gUmVx dWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5vdGUgdGhhdCB0 aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50OjpvcGVuRmls ZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBs b25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAgLy8gRXhlY3V0 ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2b2lkIGRp c3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudElt cGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVmNTQ1Li4wNjA0 ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0gYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAjaWYgRU5BQkxF KFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiV2ViV29y a2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIKICNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAgLTk5LDYgKzk5 LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJl dHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJh bWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNh bGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CiAK IHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZjQ1YWI2MGQ0MzA3YzI5MDY0ZmRhMWNiNWVmN2M3OGQyYWU2ZTk0ZQot LS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZS5jcHAKQEAgLTAsMCArMSwxOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICog ICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0 cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9k dWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgorCisjaWYgRU5BQkxF KEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAi V2ViQ29tbW9uV29ya2VyQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNr cy5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5oIgorI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIK KyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJv bGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9NYWluVGhy ZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCit1c2luZyBuYW1lc3BhY2UgV2Vi Q29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhh dCBhcmUgdG8gYmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBNYWluVGhy ZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxi YWNrcz4gY3JlYXRlKFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4g YnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQ dHIobmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSwgbW9kZSkpOworICAg IH0KKworICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKCkKKyAgICB7 CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFdlYlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgIHsKKyAgICAgICAgbV9icmlk Z2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgsIG1fbW9kZSk7Cisg ICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKFdl YkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRGYWlsT25NYWlu VGhyZWFkKGVycm9yLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9CisKKyAg ICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJU X05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0 YShjb25zdCBXZWJGaWxlSW5mbyYgaW5mbykKKyAgICB7CisgICAgICAgIFdFQktJVF9BU1NFUlRf Tk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZERpcmVjdG9y eShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYgZW50cmllcywgYm9vbCBoYXNN b3JlKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNzUmVmUHRy PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBt b2RlKQorICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgLCBtX21vZGUobW9kZSkK KyAgICB7CisgICAgICAgIEFTU0VSVChtX2JyaWRnZS5nZXQoKSk7CisgICAgfQorCisgICAgZnJp ZW5kIGNsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U7CisgICAgUmVmUHRyPFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fYnJpZGdlOworICAgIGNvbnN0IFN0cmlu ZyBtX21vZGU7Cit9OworCitXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjp+V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZSgpCit7CisgICAgQVNTRVJUKCFtX2NhbGxiYWNrc09u V29ya2VyVGhyZWFkKTsKK30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdl OjpzdG9wKCkKK3sKKyAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5pc0NvbnRleHRUaHJlYWQo KSk7CisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgIG1fd29ya2VyID0gMDsK KworICAgIGlmIChtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAgICAgIG1fY2FsbGJh Y2tzT25Xb3JrZXJUaHJlYWQtPmRpZEZhaWwoV2ViRmlsZUVycm9yQWJvcnQpOworICAgICAgICBt X2NhbGxiYWNrc09uV29ya2VyVGhyZWFkID0gMDsKKyAgICB9Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6cG9zdE9wZW5GaWxlU3lzdGVtVG9NYWluVGhyZWFkKFdl YkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGaWxlU3lzdGVtOjpUeXBlIHR5 cGUsIGxvbmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgbV9zZWxmUmVm ID0gdGhpczsKKyAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7 CisgICAgQVNTRVJUKG1fd29ya2VyKTsKKyAgICBtX3dvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQsIGNv bW1vbkNsaWVudCwgdHlwZSwgc2l6ZSwgdGhpcywgbW9kZSkpOworfQorCit2b2lkIFdvcmtlckZp bGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6Om9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwg V2ViRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZSogYnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgQVNT RVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAoIWNvbW1vbkNsaWVudCkKKyAgICAgICAgYnJp ZGdlLT5kaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvckFib3J0LCBtb2RlKTsKKyAgICBl bHNlIHsKKyAgICAgICAgLy8gTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MgaXMgc2VsZi1k ZXN0cnVjdGVkLCBzbyB3ZSBsZWFrIHB0ciBoZXJlLgorICAgICAgICBjb21tb25DbGllbnQtPm9w ZW5GaWxlU3lzdGVtKHR5cGUsIHNpemUsIE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzOjpj cmVhdGUoYnJpZGdlLCBtb2RlKS5sZWFrUHRyKCkpOworICAgIH0KK30KKwordm9pZCBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJv ciBlcnJvciwgY29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7CisgICAgbWF5UG9zdFRhc2tUb1dvcmtlcihjcmVhdGVDYWxsYmFja1Rhc2soJmRpZEZhaWxP bldvcmtlclRocmVhZCwgbV9zZWxmUmVmLCBlcnJvciksIG1vZGUpOworfQorCit2b2lkIFdvcmtl ckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFk KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5n JiBtb2RlKQoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgbWF5UG9zdFRhc2tU b1dvcmtlcihjcmVhdGVDYWxsYmFja1Rhc2soJmRpZE9wZW5GaWxlU3lzdGVtT25Xb3JrZXJUaHJl YWQsIG1fc2VsZlJlZiwgbmFtZSwgcm9vdFBhdGgpLCBtb2RlKTsKK30KKworV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZTo6V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZShXZWJX b3JrZXJCYXNlKiB3b3JrZXIsIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQsIFdlYkZpbGVTeXN0ZW1DYWxsYmFja3MqIGNhbGxiYWNrcykKKyAgICA6IFdvcmtl ckNvbnRleHQ6Ok9ic2VydmVyKHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihzY3JpcHRFeGVj dXRpb25Db250ZXh0KSkKKyAgICAsIG1fd29ya2VyKHdvcmtlcikKKyAgICAsIG1fd29ya2VyQ29u dGV4dChzY3JpcHRFeGVjdXRpb25Db250ZXh0KQorICAgICwgbV9jYWxsYmFja3NPbldvcmtlclRo cmVhZChjYWxsYmFja3MpCit7CisgICAgQVNTRVJUKG1fd29ya2VyQ29udGV4dC0+aXNDb250ZXh0 VGhyZWFkKCkpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRp ZEZhaWxPbldvcmtlclRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UsIFdlYkZpbGVFcnJvciBlcnJv cikKK3sKKyAgICBpZiAoYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAg ICAgIEFTU0VSVChicmlkZ2UtPm1fd29ya2VyQ29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpOwor ICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQtPmRpZEZhaWwoZXJyb3Ip OworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0K K30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRPcGVuRmlsZVN5 c3RlbU9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJhY2tz T25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKGJyaWRnZS0+bV93b3JrZXJDb250ZXh0 LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtl clRocmVhZC0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgcm9vdFBhdGgpOworICAgICAgICBicmlk Z2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0KK30KKwordm9pZCBXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjptYXlQb3N0VGFza1RvV29ya2VyKFBhc3NPd25Q dHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3RyaW5nJiBtb2Rl KQoreworICAgIHsgLy8gTGV0IGdvIG9mIHRoZSBtdXRleCBiZWZvcmUgcG9zc2libHkgZGVsZXRp bmcgdGhpcyBkdWUgdG8gbV9zZWxmUmVmLmNsZWFyKCkuCisgICAgICAgIE11dGV4TG9ja2VyIGxv Y2tlcihtX211dGV4KTsKKyAgICAgICAgaWYgKG1fd29ya2VyKQorICAgICAgICAgICAgbV93b3Jr ZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dCh0YXNrLCBtb2RlKTsKKyAgICB9Cisg ICAgbV9zZWxmUmVmLmNsZWFyKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMjljZTViMTFm NWQyZTY3MjY5ZmZlZjMyYmZmOWRmMjcyOTY4Y2Q5MQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAg KzEsMTE4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6 CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIK KyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2Yg R29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlz IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworI2lmbmRlZiBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZp bmUgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRl ICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAi V2ViVmVjdG9yLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1ZGUgPHd0Zi9Q YXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYv VGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBBc3luY0ZpbGVTeXN0 ZW07CitjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKK2NsYXNzIFRocmVhZGFi bGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOworY2xhc3MgV2ViQ29tbW9uV29ya2VyQ2xpZW50Owor Y2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxiYWNrczsKK2NsYXNzIFdlYkZpbGVTeXN0ZW1FbnRyeTsK K2NsYXNzIFdlYldvcmtlckJhc2U7CitzdHJ1Y3QgV2ViRmlsZUluZm87CisKKy8vIFRoaXMgY2xh c3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0 aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFjayBmb3IgdGhlIHJlcXVlc3QuIFRoaXMgbXVzdCBiZSBk ZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZv ciBvcGVuRmlsZVN5c3RlbSB3b3VsZCBsb29rIGxpa2UgdGhpczoKKy8vIEJyaWRnZTo6cG9zdE9w ZW5GaWxlU3lzdGVtVG9NYWluVGhyZWFkKCkgb24gV29ya2VyVGhyZWFkCisvLyAgLS0+IEJyaWRn ZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoKSBpcyBjYWxsZWQgb24gTWFpblRocmVhZAor Ly8gICAgICBUaGlzIG1ha2VzIGFuIElQQyB3aXRoIGEgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxs YmFja3MgaW5zdGFuY2UKKy8vICAgICBbYWN0dWFsIG9wZXJhdGlvbiBpcyBkb3duIGluIHRoZSBi cm93c2VyXQorLy8gIC0tPiBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlz IGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFk IGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJU aHJlYWQgaXMgY2FsbGVkIG9uIFdvcmtlclRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSBv cmlnaW5hbCBjYWxsYmFja3MgKG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQpIGFuZAorLy8gICAg ICByZWxlYXNlcyBhIHNlbGYtcmVmZXJlbmNlIHRvIHRoZSBicmlkZ2UuCitjbGFzcyBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4sIHB1YmxpYyBXZWJDb3JlOjpXb3JrZXJDb250ZXh0 OjpPYnNlcnZlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogd29ya2VyQ29udGV4dCwgV2ViRmlsZVN5c3RlbUNh bGxiYWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAgcmV0dXJuIFdURjo6YWRvcHRSZWYo bmV3IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2Uod29ya2VyLCB3b3JrZXJDb250ZXh0 LCBjYWxsYmFja3MpKTsKKyAgICB9CisgICAgfldvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2UoKTsKKworICAgIC8vIFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyIG1ldGhvZC4KKyAgICB2aXJ0 dWFsIHZvaWQgbm90aWZ5U3RvcCgpCisgICAgeworICAgICAgICBzdG9wKCk7CisgICAgfQorCisg ICAgdm9pZCBzdG9wKCk7CisKKyAgICAvLyBQb3N0cyBhbiBpbml0aWFsIHJlcXVlc3QgdGFzayB0 byB0aGUgbWFpbiB0aHJlYWQuIEl0IGlzIHN1cHBvc2VkIHRvIGJlIGNhbGxlZCBpbW1lZGlhdGVs eSBhZnRlciB0aGUgYnJpZGdlIGlzIGNvbnN0cnVjdGVkLiAoSXQgZG9lc24ndCBjaGVjayBpZiB0 aGUgY29udGV4dCBoYXMgYmVlbiBzdG9wcGVkIG9yIG5vdC4pCisgICAgdm9pZCBwb3N0T3BlbkZp bGVTeXN0ZW1Ub01haW5UaHJlYWQoV2ViQ29tbW9uV29ya2VyQ2xpZW50KiwgV2ViRmlsZVN5c3Rl bTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICAvLyBD YWxsYmFjayBtZXRob2RzIHRoYXQgYXJlIGNhbGxlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAg dm9pZCBkaWRGYWlsT25NYWluVGhyZWFkKFdlYkZpbGVFcnJvciwgY29uc3QgU3RyaW5nJiBtb2Rl KTsKKyAgICB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiByb290UGF0aCwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworcHJp dmF0ZToKKyAgICBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtlckJhc2Uq LCBXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViRmlsZVN5c3RlbUNhbGxiYWNr cyopOworCisgICAgLy8gTWV0aG9kIHRoYXQgaXMgdG8gYmUgY2FsbGVkIG9uIHRoZSBtYWluIHRo cmVhZC4KKyAgICBzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZChXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiwgV2ViRmls ZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NC cmlkZ2UqLCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgZnJpZW5kIGNsYXNzIE1haW5UaHJl YWRGaWxlU3lzdGVtQ2FsbGJhY2tzOworCisgICAgLy8gTWV0aG9kcyB0aGF0IGRpc3BhdGNoIFdl YkZpbGVTeXN0ZW1DYWxsYmFja3Mgb24gdGhlIHdvcmtlciB0aHJlYWRzLgorICAgIC8vIFRoZXkg cmVsZWFzZSBhIHNlbGZSZWYgb2YgdGhlIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2Uu CisgICAgc3RhdGljIHZvaWQgZGlkRmFpbE9uV29ya2VyVGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlk Z2U+LCBXZWJGaWxlRXJyb3IpOworICAgIHN0YXRpYyB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtT25X b3JrZXJUaHJlYWQoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8 V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4sIGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiByb290UGF0aCk7CisKKyAgICB2b2lkIG1heVBvc3RUYXNrVG9Xb3JrZXIoUGFz c093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3Ry aW5nJiBtb2RlKTsKKworICAgIC8vIG1fc2VsZlJlZiBrZWVwcyBhIHJlZmVyZW5jZSB0byBpdHNl bGYgdW50aWwgdGFza3MgYXJlIGNyZWF0ZWQgZm9yIHRoZSB3b3JrZXIgdGhyZWFkIChhdCB3aGlj aCBwb2ludCB0aGUgdGFza3MgaG9sZCB0aGUgcmVmZXJlbmNlKS4KKyAgICBSZWZQdHI8V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4gbV9zZWxmUmVmOworCisgICAgTXV0ZXggbV9tdXRl eDsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBXb3JrZXJDb250ZXh0KiBtX3dv cmtlckNvbnRleHQ7CisKKyAgICAvLyBUaGlzIGlzIHNlbGYtZGVzdHJ1Y3RlZCBhbmQgbXVzdCBi ZSBmaXJlZCBvbiB0aGUgd29ya2VyIHRocmVhZC4KKyAgICBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tz KiBtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZV9oCg== 68610 2010-09-23 15:47:22 -0700 2010-09-23 15:56:24 -0700 Patch bug-45808-20100923154721.patch text/plain 44409 kinuko ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWJmMzcyMGNiYzVjMGU5Y2ZkMTM1ZmFjOGY3YmUwYThkYzM3NzQ2Ni4uZWI4ODBhOGM2M2IwNTFi ODIyMzAzMDllYzhkYWIxNzBhNjkzYmM5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NSBAQAorMjAxMC0wOS0yMiAgS2lu dWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFdvcmtlciBzdXBwb3J0IGZvciBGaWxlU3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDU4MDgKKworICAgICAgICBFeHBvc2VkIHJlcXVlc3RGaWxlU3lzdGVtIGFuZCBGbGFncyBjb25z dHJ1Y3RvciBvbiB3b3JrZXIgY29udGV4dHMuCisKKyAgICAgICAgQWxzbyBjaGFuZ2VkIGhvdyB0 byBnZXQgdGhlIGJhc2UgcGF0aCBmb3IgV2ViIGZpbGUgc3lzdGVtcyAoaW4KKyAgICAgICAgbm9u LWNocm9taXVtIHBvcnRzKSBzbyB0aGF0IGl0IHdvcmtzIGZvciB3b3JrZXJzIHRvby4KKyAgICAg ICAgVGhpcyBwYXRjaCBhc3N1bWVzIGVhY2ggcG9ydCBjYWxscworICAgICAgICBMb2NhbEZpbGVT eXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oKSBpbiBpdHMgaW5pdGlhbGl6YXRpb24K KyAgICAgICAgcGhhc2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyB0ZXN0cyB3aWxsIGJlIGFk ZGVkIHdoZW4gd2UgaGF2ZSBjb21wbGV0ZSBpbXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIGJp bmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCk6IENoYW5nZWQg dG8KKyAgICAgICAgcmVmbGVjdCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlCisgICAgICAg ICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg6IE1vdmVkIHRoZSBp bXBsZW1lbnRhdGlvbgorICAgICAgICBvZiBmaWxlU3lzdGVtRW5hYmxlZCB0byAuY3BwLgorICAg ICAgICAqIGZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okxv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKTogQWRk ZWQuCisgICAgICAgICogZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaDoKKyAgICAgICAgKFdlYkNv cmU6OkxvY2FsRmlsZVN5c3RlbTo6fkxvY2FsRmlsZVN5c3RlbSk6IFJlbW92ZWQuIChBcyBub3cg aXQncworICAgICAgICBnb2luZyB0byBiZSB1c2VkIGFzIGEgc2luZ2xldG9uLikKKyAgICAgICAg KiBwYWdlL0RPTVdpbmRvdy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlcXVl c3RGaWxlU3lzdGVtKTogQ2hhbmdlZCB0byB1c2UgYSBzaW5nbGV0b24KKyAgICAgICAgaW5zdGFu Y2Ugb2YgTG9jYWxGaWxlU3lzdGVtLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDoK KyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3NGaWxlU3lzdGVtKTog QWRkZWQuCisgICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6IFJlbW92ZWQgZmlsZVN5c3RlbVJv b3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IFJlbW92ZWQgZmlsZVN5 c3RlbVJvb3RQYXRoIG1ldGhvZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6IEFk ZGVkLgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpXb3JrZXJDb250ZXh0OjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIHRvIGV4cG9zZQor ICAgICAgICByZXF1ZXN0RmlsZVN5c3RlbSBtZXRob2QgaW4gd29ya2VyIGNvbnRleHRzLgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6T2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnJlZ2lzdGVyT2JzZXJ2ZXIpOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnVucmVnaXN0ZXJPYnNlcnZlcik6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKTog QWRkZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAgICogd29y a2Vycy9Xb3JrZXJDb250ZXh0LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRocmVhZC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVy Zm9ybVRhc2spOiBNb2RpZmllZCB0bworICAgICAgICBjYWxsIHdvcmtlckNvbnRleHQtPm5vdGlm eU9ic2VydmVyc09mU3RvcCB0byBub3RpZnkgd29ya2VyIG9ic2VydmVycworICAgICAgICBvZiB0 aGUgd29ya2VyIHRocmVhZCB0ZXJtaW5hdGlvbi4KKwogMjAxMC0wOS0yMiAgRGF2aWQgSHlhdHQg IDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1 cmVzLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVz LmNwcAppbmRleCBhMTVmZDZkMDgwMmZiZWVmMTEwOWZjYTljOWQzYjJmM2QzMDIwYzA0Li45YTk2 ZjIyNmQzY2ZmNzI3OGM3OTI2OWExYzgyZTRhY2M3ODQwNjRiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAKKysrIGIvV2ViQ29y ZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwCkBAIC0zNiw2ICsz NiwxMCBAQAogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNpbmNsdWRlICJX ZWJTb2NrZXQuaCIKIAorI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKyNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW0uaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgUnVudGlt ZUVuYWJsZWRGZWF0dXJlczo6aXNMb2NhbFN0b3JhZ2VFbmFibGVkID0gdHJ1ZTsKQEAgLTU3LDYg KzYxLDExIEBAIGJvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6aXNYSFJSZXNwb25zZUJsb2JF bmFibGVkID0gZmFsc2U7CiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiBib29sIFJ1bnRpbWVF bmFibGVkRmVhdHVyZXM6OmlzRmlsZVN5c3RlbUVuYWJsZWQgPSBmYWxzZTsKKworYm9vbCBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjpmaWxlU3lzdGVtRW5hYmxlZCgpCit7CisgICAgcmV0dXJuIGlz RmlsZVN5c3RlbUVuYWJsZWQgJiYgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpOworfQog I2VuZGlmCiAKICNpZiBFTkFCTEUoVklERU8pCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdz L2dlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIGIvV2ViQ29yZS9iaW5kaW5ncy9nZW5l cmljL1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuaAppbmRleCA5MTc2OGIwZTU0ZTdmOTdiYWNkMGE5 YmQzMzllMWRjNDIwZDZlZGVlLi5iYTRhNGZiMDVkZjUxZDc0NDRmYjlhM2JhMTAwMmFlNDdhYmQ1 ZmM4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVuYWJsZWRG ZWF0dXJlcy5oCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmgKQEAgLTE0OCw3ICsxNDgsNyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKLSAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5hYmxlZCgpIHsgcmV0 dXJuIGlzRmlsZVN5c3RlbUVuYWJsZWQ7IH0KKyAgICBzdGF0aWMgYm9vbCBmaWxlU3lzdGVtRW5h YmxlZCgpOwogICAgIHN0YXRpYyB2b2lkIHNldEZpbGVTeXN0ZW1FbmFibGVkKGJvb2wgaXNFbmFi bGVkKSB7IGlzRmlsZVN5c3RlbUVuYWJsZWQgPSBpc0VuYWJsZWQ7IH0KICAgICBzdGF0aWMgYm9v bCByZXF1ZXN0RmlsZVN5c3RlbUVuYWJsZWQoKSB7IHJldHVybiBpc0ZpbGVTeXN0ZW1FbmFibGVk OyB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0u Y3BwIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggNTllYzJhMWU2 ZDdiYjE5ZjFkNDgzOWU1ZWUzOTk2MDBmNmUwNDRmNi4uZjgyNmI3MWMyZGQ3YjE1MjRkMDA4YzIx ZmY0YmNmZGM5Nzc4YzhhNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5 c3RlbS5jcHAKKysrIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTUw LDkgKzUwLDMwIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxMb2NhbEZp bGVTeXN0ZW0+IExvY2FsRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgp CitMb2NhbEZpbGVTeXN0ZW0qIExvY2FsRmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3Zv aWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmlu ZyYgYmFzZVBhdGgpCit7CisgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90 YSBzZXR0aW5ncyBhcyB3ZWxsLgorICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNT RVJUKCFzX2luc3RhbmNlKTsKKyAgICBpZiAoc19pbnN0YW5jZSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIo bmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aCkpOworICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZp bGVTeXN0ZW0ubGVha1B0cigpOworfQorCitMb2NhbEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICAvLyBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVt IG11c3QgYmUgY2FsbGVkIHByaW9yIGNhbGxpbmcgdGhpcy4KKyAgICBBU1NFUlQoc19pbnN0YW5j ZSk7CisgICAgcmV0dXJuICpzX2luc3RhbmNlOworfQorCitTdHJpbmcgTG9jYWxGaWxlU3lzdGVt OjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcg TG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoKSk7CisgICAgcmV0dXJuIG1fYmFzZVBhdGg7CiB9CiAK IHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25z dCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKQEAgLTY4LDcgKzg5LDcgQEAgdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lz dGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmkKICAgICB9CiAKICAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBtX2Jhc2VQYXRoLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgbmV3IEZpbGVT eXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBjb250ZXh0KSkp OwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9maWxlYXBpL0xvY2Fs RmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCmluZGV4IDQ4 Y2ZhOGY2ODg2YTYwYTQwMDQ0NGUyZmNlYmVhNjhjZDUyM2RiYjYuLmQwOGQwZjBmMGZmNzJiYjAw OGU3NDAwMjAyYmJkMjU0NzNjZDc1NDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZmlsZWFwaS9Mb2Nh bEZpbGVTeXN0ZW0uaAorKysgYi9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmgKQEAg LTQ0LDIwICs0NCw0NCBAQCBjbGFzcyBFcnJvckNhbGxiYWNrOwogY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAotY2xhc3MgTG9jYWxGaWxl U3lzdGVtIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxGaWxlU3lzdGVtPiB7CisvLyBLZWVwcyBw ZXItcHJvY2VzcyBpbmZvcm1hdGlvbiBhbmQgcHJvdmlkZXMgYW4gZW50cnkgcG9pbnQgdG8gb3Bl biBhIGZpbGUgc3lzdGVtLgorY2xhc3MgTG9jYWxGaWxlU3lzdGVtIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbEZpbGVTeXN0ZW0+IGNy ZWF0ZShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKTsKLSAgICB2aXJ0dWFsIH5Mb2NhbEZpbGVTeXN0 ZW0oKSB7IH0KKyAgICAvLyBSZXR1cm5zIGEgcGVyLXByb2Nlc3MgaW5zdGFuY2Ugb2YgTG9jYWxG aWxlU3lzdGVtLgorICAgIC8vIE5vdGUgdGhhdCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0gbXVzdCBiZSBjYWxsZWQgYmVmb3JlCisgICAgLy8gY2FsbGluZyB0aGlz IG9uZS4KKyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtJiBsb2NhbEZpbGVTeXN0ZW0oKTsKIAog ICAgIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNh bGxiYWNrPiwgUGFzc1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CiAKLXByb3RlY3RlZDoKKyNpZiAh UExBVEZPUk0oQ0hST01JVU0pCisgICAgLy8gVGhpcyBjYWxsIGlzIG5vdCB0aHJlYWQtc2FmZTsg bXVzdCBiZSBjYWxsZWQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkcyBhcmUgY3JlYXRlZC4KKyAg ICB2b2lkIGluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJik7CisKKyAgICBT dHJpbmcgZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3Q7CisjZW5kaWYKKworcHJpdmF0ZToKICAg ICBMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKICAgICAgICAgOiBtX2Jh c2VQYXRoKGJhc2VQYXRoKQogICAgIHsKICAgICB9CiAKLSAgICBTdHJpbmcgbV9iYXNlUGF0aDsK KyAgICBzdGF0aWMgTG9jYWxGaWxlU3lzdGVtKiBzX2luc3RhbmNlOworCisgICAgLy8gQW4gaW5u ZXIgY2xhc3MgdGhhdCBlbmZvcmNlcyB0aHJlYWQtc2FmZSBzdHJpbmcgYWNjZXNzLgorICAgIGNs YXNzIFN5c3RlbUJhc2VQYXRoIHsKKyAgICBwdWJsaWM6CisgICAgICAgIGV4cGxpY2l0IFN5c3Rl bUJhc2VQYXRoKGNvbnN0IFN0cmluZyYgcGF0aCkgOiBtX3ZhbHVlKHBhdGgpIHsgfQorICAgICAg ICBvcGVyYXRvciBTdHJpbmcoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4g bV92YWx1ZS50aHJlYWRzYWZlQ29weSgpOworICAgICAgICB9CisgICAgcHJpdmF0ZToKKyAgICAg ICAgU3RyaW5nIG1fdmFsdWU7CisgICAgfTsKKworICAgIFN5c3RlbUJhc2VQYXRoIG1fYmFzZVBh dGg7CiB9OwogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0RPTVdp bmRvdy5jcHAgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAppbmRleCBmNWJhMjVjMzZhOWFk MmM3ZmQxNjU5YTViNWQzZDA2ZDg3YmE1YzQ2Li42YTIwM2NjN2M0OTJlYzMzYWJlMDAyOTJlM2Ew NDhkOGEyYWMzNDFkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcAorKysg Yi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmNwcApAQCAtNzI3LDI1ICs3MjcsMTYgQEAgdm9pZCBE T01XaW5kb3c6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6ZSwgUGFz c1JlZlB0cjxGaWxlU3lzdGUKICAgICBpZiAoIWRvY3VtZW50KQogICAgICAgICByZXR1cm47CiAK LSAgICBpZiAoIW1fbG9jYWxGaWxlU3lzdGVtKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBTZWUgaWYg YWNjZXNzIGlzIGFsbG93ZWQuCi0KLSAgICAgICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdl KCk7Ci0gICAgICAgIGlmICghcGFnZSkgewotICAgICAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2No ZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVycm9yOjpjcmVhdGUo SU5WQUxJRF9TVEFURV9FUlIpKTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0g ICAgICAgIC8vIEZJWE1FOiBHZXQgdGhlIHF1b3RhIHNldHRpbmdzIGFzIHdlbGwuCi0gICAgICAg IFN0cmluZyBwYXRoID0gcGFnZS0+c2V0dGluZ3MoKS0+ZmlsZVN5c3RlbVJvb3RQYXRoKCk7Ci0g ICAgICAgIG1fbG9jYWxGaWxlU3lzdGVtID0gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUocGF0aCk7 CisgICAgaWYgKCFBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkgfHwgIWRvY3VtZW50LT5z ZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxlU3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmls ZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayhkb2N1bWVudCwgZXJyb3JDYWxsYmFjaywgRmlsZUVy cm9yOjpjcmVhdGUoU0VDVVJJVFlfRVJSKSk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAg ICBtX2xvY2FsRmlsZVN5c3RlbS0+cmVxdWVzdEZpbGVTeXN0ZW0oZG9jdW1lbnQsIHN0YXRpY19j YXN0PEFzeW5jRmlsZVN5c3RlbTo6VHlwZT4odHlwZSksIHNpemUsIHN1Y2Nlc3NDYWxsYmFjaywg ZXJyb3JDYWxsYmFjayk7CisgICAgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5y ZXF1ZXN0RmlsZVN5c3RlbShkb2N1bWVudCwgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKIH0KIAot Q09NUElMRV9BU1NFUlQoaW50KERPTVdpbmRvdzo6VEVNUE9SQVJZKSA9PSBpbnQoQXN5bmNGaWxl U3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21pc21hdGNoKTsKLUNPTVBJTEVfQVNTRVJUKGludChE T01XaW5kb3c6OlBFUlNJU1RFTlQpID09IGludChBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQp LCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oRE9NV2lu ZG93OjpURU1QT1JBUlkpID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1w b3JhcnkpLCBlbnVtX21pc21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4o RE9NV2luZG93OjpQRVJTSVNURU5UKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KEFzeW5jRmlsZVN5c3Rl bTo6UGVyc2lzdGVudCksIGVudW1fbWlzbWF0Y2gpOwogCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oIGIvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCmluZGV4 IDE0NzA2Mjg2NWQ5YjliNzc0NzE2OWFmYjIxODQxZDY2ZjExZDljZDQuLjZmZDM3NzUwM2FiNGVl ZjFkOWU3NzVmOTgzMDRkMTEzMWZhZmIwM2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9ET01X aW5kb3cuaAorKysgYi9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTU4LDcgKzU4LDYgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIEhpc3Rvcnk7CiAgICAgY2xhc3MgSURCRmFj dG9yeTsKICAgICBjbGFzcyBJbnNwZWN0b3JUaW1lbGluZUFnZW50OwotICAgIGNsYXNzIExvY2Fs RmlsZVN5c3RlbTsKICAgICBjbGFzcyBMb2NhdGlvbjsKICAgICBjbGFzcyBTdHlsZU1lZGlhOwog ICAgIGNsYXNzIE5hdmlnYXRvcjsKQEAgLTQ0NCw5ICs0NDMsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAgICAgICAgIG11dGFibGUgUmVmUHRy PElEQkZhY3Rvcnk+IG1faWRiRmFjdG9yeTsKICNlbmRpZgotI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKLSAgICAgICAgUmVmUHRyPExvY2FsRmlsZVN5c3RlbT4gbV9sb2NhbEZpbGVTeXN0ZW07Ci0j ZW5kaWYKIAogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CiAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvV2ViQ29yZS9wYWdlL1Nl Y3VyaXR5T3JpZ2luLmgKaW5kZXggNDc4OWQzY2UxMWEwYTIzMTU1NjE5YWJjMTA0ZWI5ODFkY2Vk NWVlZi4uMmE2Mzk2NmQ0ODdiZDNhNmI3NjYzNzE2MjMzNWM1OGM5NzQ3MTY1MSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3Vy aXR5T3JpZ2luLmgKQEAgLTEyMSw2ICsxMjEsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBjYW5BY2Nl c3NMb2NhbFN0b3JhZ2UoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsgfQogICAgIGJvb2wg Y2FuQWNjZXNzQ29va2llcygpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1ZSgpOyB9CiAgICAgYm9v bCBjYW5BY2Nlc3NQYXNzd29yZE1hbmFnZXIoKSBjb25zdCB7IHJldHVybiAhaXNVbmlxdWUoKTsg fQorICAgIGJvb2wgY2FuQWNjZXNzRmlsZVN5c3RlbSgpIGNvbnN0IHsgcmV0dXJuICFpc1VuaXF1 ZSgpOyB9CiAKICAgICAvLyBUZWNobmljYWxseSwgd2Ugc2hvdWxkIGFsd2F5cyBhbGxvdyBhY2Nl c3MgdG8gc2Vzc2lvblN0b3JhZ2UsIGJ1dCB3ZQogICAgIC8vIGN1cnJlbnRseSBkb24ndCBoYW5k bGUgY3JlYXRpbmcgYSBzZXNzaW9uU3RvcmFnZSBhcmVhIGZvciB1bmlxdWUKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmlu ZGV4IGZhYzBhNWY0OTY4ZGI2YTRhYTFkNzk0NmZlYmRkM2VmNjk1MTQ3YTUuLjRkMTY2MmI2MzZh OTgxNDE2OGI2ZTU4ODQ4YTU3MGI2YjY1OTE2MjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtNDk3LDExICs0 OTcsNiBAQCB2b2lkIFNldHRpbmdzOjpzZXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoY29uc3Qg U3RyaW5nJiBwYXRoKQogICAgIG1fbG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoID0gcGF0aDsKIH0K IAotdm9pZCBTZXR0aW5nczo6c2V0RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYgcGF0 aCkKLXsKLSAgICBtX2ZpbGVTeXN0ZW1Sb290UGF0aCA9IHBhdGg7Ci19Ci0KIHZvaWQgU2V0dGlu Z3M6OnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShib29sIG1vZGUpCiB7CiAgICAgbV9pbkFwcGxp Y2F0aW9uQ2hyb21lTW9kZSA9IG1vZGU7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuaCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCmluZGV4IDk5YTRmMjMyYzUyOTgwNmVhYTI3 Zjg1ZDU3ZGJiYWIxMjc0NGJmMzMuLmY4YTI5N2ExN2IwNTU2OWQ4NWZjN2IxMTBjNDY1NmY0NDc0 MDc2NGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oCisrKyBiL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5oCkBAIC0yNDEsOSArMjQxLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICB2b2lkIHNldExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aChjb25zdCBTdHJpbmcmKTsK ICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoKSBjb25zdCB7 IHJldHVybiBtX2xvY2FsU3RvcmFnZURhdGFiYXNlUGF0aDsgfQogCi0gICAgICAgIHZvaWQgc2V0 RmlsZVN5c3RlbVJvb3RQYXRoKGNvbnN0IFN0cmluZyYpOwotICAgICAgICBjb25zdCBTdHJpbmcm IGZpbGVTeXN0ZW1Sb290UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZVN5c3RlbVJvb3RQYXRo OyB9Ci0KICAgICAgICAgdm9pZCBzZXRBcHBsaWNhdGlvbkNocm9tZU1vZGUoYm9vbCk7CiAgICAg ICAgIGJvb2wgaW5BcHBsaWNhdGlvbkNocm9tZU1vZGUoKSBjb25zdCB7IHJldHVybiBtX2luQXBw bGljYXRpb25DaHJvbWVNb2RlOyB9CiAKQEAgLTMzNiw3ICszMzMsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIFN0cmluZyBtX2RlZmF1bHRUZXh0RW5jb2RpbmdOYW1lOwogICAgICAg ICBTdHJpbmcgbV9mdHBEaXJlY3RvcnlUZW1wbGF0ZVBhdGg7CiAgICAgICAgIFN0cmluZyBtX2xv Y2FsU3RvcmFnZURhdGFiYXNlUGF0aDsKLSAgICAgICAgU3RyaW5nIG1fZmlsZVN5c3RlbVJvb3RQ YXRoOwogICAgICAgICBLVVJMIG1fdXNlclN0eWxlU2hlZXRMb2NhdGlvbjsKICAgICAgICAgQXRv bWljU3RyaW5nIG1fc3RhbmRhcmRGb250RmFtaWx5OwogICAgICAgICBBdG9taWNTdHJpbmcgbV9m aXhlZEZvbnRGYW1pbHk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5 c3RlbS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAKaW5kZXggYjRm Y2QwZDRkOWI0ZmJjZWQ5NDYxMzg1YzEzYTZjZWJiNjlmYzdhZi4uNTczMDVmZmMyYmEwYzRhNGYz YTZlM2RlOGYyMWFhZTQxOWY4NWU1OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Bc3lu Y0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNw cApAQCAtMzUsMTIgKzM1LDIwIEBACiAKICNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MuaCIKICNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQorYm9v bCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgp OworICAgIHJldHVybiBmYWxzZTsKK30KKwogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFz eW5jRmlsZVN5c3RlbTo6Y3JlYXRlKGNvbnN0IFN0cmluZyYpCiB7Ci0gICAgLy8gRklYTUU6IHJl dHVybiBkZWZhdWx0IEFzeW5jRmlsZVN5c3RlbSBpbXBsZW1lbnRhdGlvbi4KKyAgICBub3RJbXBs ZW1lbnRlZCgpOwogICAgIHJldHVybiAwOwogfQogCkBAIC02Miw2ICs3MCw3IEBAIHZvaWQgQXN5 bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25z dCBTdHJpbmcmIHN0b3JhCiAKICAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUs IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHJvb3RQYXRoKSk7CiB9CisjZW5kaWYKIAogLy8gRGVm YXVsdCBpbXBsZW1lbnRhdGlvbi4KIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW06OnZpcnR1YWxUb1Bs YXRmb3JtUGF0aChjb25zdCBTdHJpbmcmIHBhdGgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVT eXN0ZW0uaAppbmRleCA2MDFmMGVhZTNlNWQwZThiZWI4NGQ1YTk5M2Q3NzA1MTdiZDBhNjJkLi44 YzRkNWQ5OTBmZGE0NmMyYjc4MGRmOWIwOWE2MDc3ZTU0ZDlmZjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vQXN5 bmNGaWxlU3lzdGVtLmgKQEAgLTU2LDYgKzU2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBzdG9wKCkgeyB9CiAgICAgdmlydHVhbCBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIHsgcmV0 dXJuIGZhbHNlOyB9CiAKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgLy8g Q3JlYXRlcyBhbmQgcmV0dXJucyBhIG5ldyBwbGF0Zm9ybS1zcGVjaWZpYyBBc3luY0ZpbGVTeXN0 ZW0gaW5zdGFuY2UgaWYgdGhlIHBsYXRmb3JtIGhhcyBpdHMgb3duIGltcGxlbWVudGF0aW9uLgog ICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gY3JlYXRlKGNvbnN0IFN0cmlu ZyYgcm9vdFBhdGgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5kZXggYjUyYjI4NTQ3 NWYyZWY5NDc3ZTgxNGJiZTRkOGJlYjljM2I5ZWEwYS4uNDk2NGQwNWQ3ODM2YjMyMDlkMDIyOGE4 OWFiNDcwY2ZkZjMyMDUzMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtNjMsNiAr NjMsMTUgQEAKICNpbmNsdWRlICJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorI2luY2x1 ZGUgIkRPTUZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiRmlsZVN5c3RlbUNhbGxiYWNrLmgiCisjaW5jbHVk ZSAiTG9jYWxGaWxlU3lzdGVtLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBDbG9zZVdvcmtlckNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2sgewpAQCAtMTAwLDYgKzEwOSwxMCBAQCBXb3JrZXJDb250ZXh0Ojp+V29ya2VyQ29u dGV4dCgpCiAjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAgICAgbV9ub3RpZmljYXRpb25zLmNs ZWFyKCk7CiAjZW5kaWYKKworICAgIC8vIE1ha2Ugc3VyZSB3ZSBoYXZlIG5vIG9ic2VydmVycy4K KyAgICBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIC8vIE5vdGlmeSBwcm94eSB0aGF0 IHdlIGFyZSBnb2luZyBhd2F5LiBUaGlzIGNhbiBmcmVlIHRoZSBXb3JrZXJUaHJlYWQgb2JqZWN0 LCBzbyBkbyBub3QgYWNjZXNzIGl0IGFmdGVyIHRoaXMuCiAgICAgdGhyZWFkKCktPndvcmtlclJl cG9ydGluZ1Byb3h5KCkud29ya2VyQ29udGV4dERlc3Ryb3llZCgpOwogfQpAQCAtMzM1LDYgKzM0 OCw2OCBAQCB2b2lkIFdvcmtlckNvbnRleHQ6OnJldm9rZUJsb2JVUkwoY29uc3QgU3RyaW5nJiBi bG9iVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCit2b2lk IFdvcmtlckNvbnRleHQ6OnJlcXVlc3RGaWxlU3lzdGVtKGludCB0eXBlLCBsb25nIGxvbmcgc2l6 ZSwgUGFzc1JlZlB0cjxGaWxlU3lzdGVtQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1Jl ZlB0cjxFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQoreworICAgIGlmICghQXN5bmNGaWxl U3lzdGVtOjppc0F2YWlsYWJsZSgpIHx8ICFzZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NGaWxl U3lzdGVtKCkpIHsKKyAgICAgICAgRE9NRmlsZVN5c3RlbTo6c2NoZWR1bGVDYWxsYmFjayh0aGlz LCBlcnJvckNhbGxiYWNrLCBGaWxlRXJyb3I6OmNyZWF0ZShTRUNVUklUWV9FUlIpKTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVt KCkucmVxdWVzdEZpbGVTeXN0ZW0odGhpcywgc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtOjpU eXBlPih0eXBlKSwgc2l6ZSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKTsKK30KKwor Q09NUElMRV9BU1NFUlQoc3RhdGljX2Nhc3Q8aW50PihXb3JrZXJDb250ZXh0OjpURU1QT1JBUlkp ID09IHN0YXRpY19jYXN0PGludD4oQXN5bmNGaWxlU3lzdGVtOjpUZW1wb3JhcnkpLCBlbnVtX21p c21hdGNoKTsKK0NPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV29ya2VyQ29udGV4dDo6 UEVSU0lTVEVOVCkgPT0gc3RhdGljX2Nhc3Q8aW50PihBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3Rl bnQpLCBlbnVtX21pc21hdGNoKTsKKyNlbmRpZgorCitXb3JrZXJDb250ZXh0OjpPYnNlcnZlcjo6 T2JzZXJ2ZXIoV29ya2VyQ29udGV4dCogY29udGV4dCkKKyAgICA6IG1fY29udGV4dChjb250ZXh0 KQoreworICAgIEFTU0VSVChtX2NvbnRleHQgJiYgbV9jb250ZXh0LT5pc0NvbnRleHRUaHJlYWQo KSk7CisgICAgbV9jb250ZXh0LT5yZWdpc3Rlck9ic2VydmVyKHRoaXMpOworfQorCitXb3JrZXJD b250ZXh0OjpPYnNlcnZlcjo6fk9ic2VydmVyKCkKK3sKKyAgICBpZiAoIW1fY29udGV4dCkKKyAg ICAgICAgcmV0dXJuOworICAgIEFTU0VSVChtX2NvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsK KyAgICBtX2NvbnRleHQtPnVucmVnaXN0ZXJPYnNlcnZlcih0aGlzKTsKK30KKwordm9pZCBXb3Jr ZXJDb250ZXh0OjpPYnNlcnZlcjo6c3RvcE9ic2VydmluZygpCit7CisgICAgaWYgKCFtX2NvbnRl eHQpCisgICAgICAgIHJldHVybjsKKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0NvbnRleHRUaHJl YWQoKSk7CisgICAgbV9jb250ZXh0LT51bnJlZ2lzdGVyT2JzZXJ2ZXIodGhpcyk7CisgICAgbV9j b250ZXh0ID0gMDsKK30KKwordm9pZCBXb3JrZXJDb250ZXh0OjpyZWdpc3Rlck9ic2VydmVyKE9i c2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIpOworICAgIG1fd29ya2Vy T2JzZXJ2ZXJzLmFkZChvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29ya2VyQ29udGV4dDo6dW5yZWdp c3Rlck9ic2VydmVyKE9ic2VydmVyKiBvYnNlcnZlcikKK3sKKyAgICBBU1NFUlQob2JzZXJ2ZXIp OworICAgIG1fd29ya2VyT2JzZXJ2ZXJzLnJlbW92ZShvYnNlcnZlcik7Cit9CisKK3ZvaWQgV29y a2VyQ29udGV4dDo6bm90aWZ5T2JzZXJ2ZXJzT2ZTdG9wKCkKK3sKKyAgICBIYXNoU2V0PE9ic2Vy dmVyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX3dvcmtlck9ic2VydmVycy5iZWdpbigpOworICAgIHdo aWxlIChpdGVyICE9IG1fd29ya2VyT2JzZXJ2ZXJzLmVuZCgpKSB7CisgICAgICAgIFdvcmtlckNv bnRleHQ6Ok9ic2VydmVyKiBvYnNlcnZlciA9ICppdGVyOworICAgICAgICBvYnNlcnZlci0+c3Rv cE9ic2VydmluZygpOworICAgICAgICBvYnNlcnZlci0+bm90aWZ5U3RvcCgpOworICAgICAgICBp dGVyID0gbV93b3JrZXJPYnNlcnZlcnMuYmVnaW4oKTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXT1JLRVJTKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250 ZXh0LmgKaW5kZXggN2ZiOGI0NmYzODdjYzA2ODQzMWZkMzM0ZGMwZmI1ZTRkMGExODAzYS4uMjkz ZDkyOTI2ZTVmZDg1YzI4ZmMxODY2NGNiN2JlZjczNGQ5NTcyMiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4 dC5oIgogI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlIDx3dGYv QXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL093 blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KQEAgLTQ3LDYgKzQ4LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNz IERhdGFiYXNlOwogICAgIGNsYXNzIERhdGFiYXNlQ2FsbGJhY2s7CiAgICAgY2xhc3MgRGF0YWJh c2VTeW5jOworICAgIGNsYXNzIEVycm9yQ2FsbGJhY2s7CisgICAgY2xhc3MgRmlsZVN5c3RlbUNh bGxiYWNrOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVs ZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRpb247CkBAIC0xMjEsNiArMTI0LDE0IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGNvbnN0IFN0 cmluZyYpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisgICAgICAgIGVudW0g RmlsZVN5c3RlbVR5cGUgeworICAgICAgICAgICAgVEVNUE9SQVJZLAorICAgICAgICAgICAgUEVS U0lTVEVOVCwKKyAgICAgICAgfTsKKyAgICAgICAgdm9pZCByZXF1ZXN0RmlsZVN5c3RlbShpbnQg dHlwZSwgbG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiwgUGFz c1JlZlB0cjxFcnJvckNhbGxiYWNrPik7CisjZW5kaWYKKwogICAgICAgICAvLyBUaGVzZSBtZXRo b2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJDb250ZXh0OjptYXJrQ2hp bGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNw cC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmlnYXRvcigpIGNvbnN0IHsg cmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkBAIC0xMzEsNiArMTQyLDIxIEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogICAgICAgICBib29sIGlzQ2xvc2luZygpIHsgcmV0dXJuIG1fY2xvc2lu ZzsgfQogCisgICAgICAgIC8vIEFuIG9ic2VydmVyIGludGVyZmFjZSB0byBiZSBub3RpZmllZCB3 aGVuIHRoZSB3b3JrZXIgdGhyZWFkIGlzIGdldHRpbmcgc3RvcHBlZC4KKyAgICAgICAgY2xhc3Mg T2JzZXJ2ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgICAgICBwdWJsaWM6CisgICAgICAg ICAgICBPYnNlcnZlcihXb3JrZXJDb250ZXh0Kik7CisgICAgICAgICAgICB2aXJ0dWFsIH5PYnNl cnZlcigpOworICAgICAgICAgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKSA9IDA7CisgICAg ICAgICAgICB2b2lkIHN0b3BPYnNlcnZpbmcoKTsKKyAgICAgICAgcHJpdmF0ZToKKyAgICAgICAg ICAgIFdvcmtlckNvbnRleHQqIG1fY29udGV4dDsKKyAgICAgICAgfTsKKyAgICAgICAgZnJpZW5k IGNsYXNzIE9ic2VydmVyOworICAgICAgICB2b2lkIHJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIq IG9ic2VydmVyKTsKKyAgICAgICAgdm9pZCB1bnJlZ2lzdGVyT2JzZXJ2ZXIoT2JzZXJ2ZXIqIG9i c2VydmVyKTsKKyAgICAgICAgdm9pZCBub3RpZnlPYnNlcnZlcnNPZlN0b3AoKTsKKwogICAgIHBy b3RlY3RlZDoKICAgICAgICAgV29ya2VyQ29udGV4dChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5n JiwgV29ya2VyVGhyZWFkKik7CiAKQEAgLTE2MSw2ICsxODcsOCBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIGJvb2wgbV9jbG9zaW5nOwogICAgICAgICBib29sIG1fcmVwb3J0aW5nRXhj ZXB0aW9uOwogICAgICAgICBFdmVudFRhcmdldERhdGEgbV9ldmVudFRhcmdldERhdGE7CisKKyAg ICAgICAgSGFzaFNldDxPYnNlcnZlcio+IG1fd29ya2VyT2JzZXJ2ZXJzOwogICAgIH07CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJD b250ZXh0LmlkbCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAppbmRleCAwMmFh NGFkYjg4YmMyZGY2N2YyN2Q1ZWNlMmI1YTkyMzI4Njc4MTI0Li4zZTE4NWMwZDViOGUwYTEzN2Jk OTI4YzUyYTJkYmE4MTc1ZjgwMzM3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5pZGwKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCkBAIC0x MDQsNiArMTA0LDE0IEBAIG1vZHVsZSB0aHJlYWRzIHsKICAgICAgICAgRE9NU3RyaW5nIGNyZWF0 ZUJsb2JVUkwoaW4gQmxvYiBibG9iKTsKICAgICAgICAgdm9pZCByZXZva2VCbG9iVVJMKGluIERP TVN0cmluZyBibG9iVVJMKTsKICNlbmRpZgorCisjaWYgZGVmaW5lZChFTkFCTEVfRklMRV9TWVNU RU0pICYmIEVOQUJMRV9GSUxFX1NZU1RFTQorICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBU RU1QT1JBUlkgPSAwOworICAgICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBQRVJTSVNURU5UID0g MTsKKyAgICAgICAgW0VuYWJsZWRBdFJ1bnRpbWVdIHZvaWQgcmVxdWVzdEZpbGVTeXN0ZW0oaW4g dW5zaWduZWQgc2hvcnQgdHlwZSwgaW4gbG9uZyBsb25nIHNpemUsIGluIFtDYWxsYmFjaywgT3B0 aW9uYWxdIEZpbGVTeXN0ZW1DYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtDYWxsYmFjaywg T3B0aW9uYWxdIEVycm9yQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7CisKKyAgICAgICAgICAgICAg ICAgYXR0cmlidXRlIFtFbmFibGVkQXRSdW50aW1lPUZpbGVTeXN0ZW1dIEZsYWdzQ29uc3RydWN0 b3IgRmxhZ3M7CisjZW5kaWYKICAgICB9OwogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyVGhyZWFkLmNwcCBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCmlu ZGV4IGQ2YTFlMDU3ZDNlZDgxOGEzNzhlNzUzNjY2OWYzYTBhN2I5NDU3ZmUuLmY2MTEyMGVlZTA0 YzMxYTgwMGZmNTYyOWFmOWEyYjgwYTQ2N2EzYzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJUaHJlYWQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3Bw CkBAIC0yMDIsNiArMjAyLDggQEAgcHVibGljOgogCiAgICAgICAgIHdvcmtlckNvbnRleHQtPnN0 b3BBY3RpdmVET01PYmplY3RzKCk7CiAKKyAgICAgICAgd29ya2VyQ29udGV4dC0+bm90aWZ5T2Jz ZXJ2ZXJzT2ZTdG9wKCk7CisKICAgICAgICAgLy8gRXZlbnQgbGlzdGVuZXJzIHdvdWxkIGtlZXAg RE9NV3JhcHBlcldvcmxkIG9iamVjdHMgYWxpdmUgZm9yIHRvbyBsb25nLiBBbHNvLCB0aGV5IGhh dmUgcmVmZXJlbmNlcyB0byBKUyBvYmplY3RzLAogICAgICAgICAvLyB3aGljaCBiZWNvbWUgZGFu Z2xpbmcgb25jZSBIZWFwIGlzIGRlc3Ryb3llZC4KICAgICAgICAgd29ya2VyQ29udGV4dC0+cmVt b3ZlQWxsRXZlbnRMaXN0ZW5lcnMoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDQxYWIwOGQ2MzI1NjQwOTMz Y2E1NTBmMjlkZjUxNDdiYjdiOGY0NWQuLjUwZDU0MzI5YWUzNjc1ZTY3NmFkZDZhMzNlMDRjMTI2 ZGMwM2E5ZjUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2Vi S2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA5LTIyICBLaW51 a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgV29ya2VyIHN1cHBvcnQgZm9yIEZpbGVTeXN0 ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00 NTgwOAorCisgICAgICAgIEFkZGVkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtIGFuZCBX ZWJDb21tb25Xb3JrZXJDbGllbnQ6OgorICAgICAgICBvcGVuRmlsZVN5c3RlbSB0byBjYWxsIGlu IHRvIHRoZSBicm93c2VyIHZpYSBXb3JrZXIgc3R1Yi9wcm94eQorICAgICAgICBpbiB0aGUgY2hy b21pdW0uCisKKyAgICAgICAgQWxzbyBhZGRlZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlIGNsYXNzIHRoYXQgcHJveGllcworICAgICAgICByZXF1ZXN0cyBhbmQgY2FsbGJhY2tzIGJl dHdlZW4gZnJvbS90byB3b3JrZXIgdGhyZWFkIHRvL2Zyb20gdGhlCisgICAgICAgIG1haW4gdGhy ZWFkLgorCisgICAgICAgICogcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAg ICAoV2ViS2l0OjpXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQu CisgICAgICAgICogc3JjL0xvY2FsRmlsZVN5c3RlbUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgaW1w bGVtZW50YXRpb24KKyAgICAgICAgZm9yIHdvcmtlcnMuIEluIHdvcmtlciBjYXNlIHRoaXMgY2Fs bHMgV2ViV29ya2VyQmFzZTo6b3BlbkZpbGVTeXN0ZW0uCisgICAgICAgICogc3JjL1dlYldvcmtl ckJhc2UuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpvcGVuRmlsZVN5c3Rl bSk6IEFkZGVkLiBUaGlzIGlzIGNhbGxlZCBmcm9tCisgICAgICAgIExvY2FsRmlsZVN5c3RlbTo6 cmVxdWVzdEZpbGVTeXN0ZW0gb24gdGhlIHdvcmtlciB0aHJlYWQgYW5kIGNyZWF0ZXMKKyAgICAg ICAgYSBicmlkZ2UgdG8gY2FsbCBXZWJDb21tb25Xb3JrZXJDbGllbnQ6Om9wZW5GaWxlU3lzdGVt IG9uIHRoZSBtYWluCisgICAgICAgIHRocmVhZC4KKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFz ZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJL aXQ6OldlYldvcmtlckNsaWVudEltcGw6Om9wZW5GaWxlU3lzdGVtKTogQWRkZWQuCisgICAgICAg ICogc3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwOiBBZGRlZC4KKyAgICAg ICAgKiBzcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oOiBBZGRlZC4KKwogMjAx MC0wOS0yMiAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgQ2hyb21pdW0gYnVpbGQgZml4LiBGaXggYnVpbGQgd2hlbiBhY2NlbGVyYXRlZApk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAgYi9XZWJLaXQvY2hyb21pdW0v V2ViS2l0Lmd5cAppbmRleCBmYzhmYmRkMzE1NzI5NjkwZmI4ZWU4NWVhYzYxZTUxOTMyN2M3NjJm Li41MGM2YTg5ODYwMzE3ZmVhNWEwY2RjZDFhY2NkMDg3N2Y0ZjIyMDBkIDEwMDY0NAotLS0gYS9X ZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAorKysgYi9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cApAQCAtNTMwLDYgKzUzMCw4IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJXb3JrZXJDbGll bnRJbXBsLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViV29ya2VySW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViV29ya2VySW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3Jj L1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuY3BwJywKKyAgICAgICAgICAgICAgICAn c3JjL1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCcsCiAgICAgICAgICAgICAgICAg J3NyYy9XcmFwcGVkUmVzb3VyY2VSZXF1ZXN0LmgnLAogICAgICAgICAgICAgICAgICdzcmMvV3Jh cHBlZFJlc291cmNlUmVzcG9uc2UuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy93aW4vV2ViSW5w dXRFdmVudEZhY3RvcnkuY3BwJywKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1v bldvcmtlckNsaWVudC5oCmluZGV4IGNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0 NGZmMmQuLjM5ZDhhYTk3MWQ2MzQyNDg3YzA3OTkxMjQ1NWE0YjAyY2ZiYTU2MmYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzEsNiAr MzEsOSBAQAogI2lmbmRlZiBXZWJDb21tb25Xb3JrZXJDbGllbnRfaAogI2RlZmluZSBXZWJDb21t b25Xb3JrZXJDbGllbnRfaAogCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2Vi RmlsZVN5c3RlbS5oIgorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRp b25DYWNoZUhvc3Q7CkBAIC04Myw2ICs4NiwxMiBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9u IHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCiAg ICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcm IG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1h dGVkU2l6ZSkgPSAwOwogCisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQg YmVmb3JlIG9wZW5pbmcgYSBmaWxlIHN5c3RlbS4KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVT eXN0ZW0oV2ViRmlsZVN5c3RlbTo6VHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1D YWxsYmFja3MqKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwor ICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07 CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0FzeW5jRmlsZVN5c3RlbUNocm9taXVt LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCmlu ZGV4IDA4ZmNlYTZjOTg1YWMzMjFkMjkxNmMzYzJlMmRhNmZjOGQ0OGU4M2YuLjBiNzUzYjNkMTUy YzFiNjVjN2ZjMTVmOWEzNTNjZmM1MWE2MzY0YmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvQXN5bmNGaWxlU3lzdGVtQ2hyb21pdW0uY3BwCkBAIC00Myw2ICs0MywxMSBAQAogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCit7 CisgICAgcmV0dXJuIHRydWU7Cit9CisKIEFzeW5jRmlsZVN5c3RlbUNocm9taXVtOjpBc3luY0Zp bGVTeXN0ZW1DaHJvbWl1bShjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQogICAgIDogQXN5bmNGaWxl U3lzdGVtKHJvb3RQYXRoKQogICAgICwgbV93ZWJGaWxlU3lzdGVtKFdlYktpdDo6d2ViS2l0Q2xp ZW50KCktPmZpbGVTeXN0ZW0oKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvTG9j YWxGaWxlU3lzdGVtQ2hyb21pdW0uY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVT eXN0ZW1DaHJvbWl1bS5jcHAKaW5kZXggNDUzNjVlZjJlNjc5ZDk5MGJiM2FlYmRmM2VjYTljZTgy MjBmMjViMi4uOTk0ZjMxMDQ2YjNkZDc1NzVhYTAxOWU2ZTE4OTliYWZmMTkwOTMxOCAxMDA2NDQK LS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9Mb2NhbEZpbGVTeXN0ZW1DaHJvbWl1bS5jcHAKQEAgLTQy LDE0ICs0MiwxOSBAQAogI2luY2x1ZGUgIldlYkZpbGVTeXN0ZW1DYWxsYmFja3NJbXBsLmgiCiAj aW5jbHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNp bmNsdWRlICJXZWJXb3JrZXJJbXBsLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2lu Y2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogdXNp bmcgbmFtZXNwYWNlIFdlYktpdDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRy PExvY2FsRmlsZVN5c3RlbT4gTG9jYWxGaWxlU3lzdGVtOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBw YXRoKQorTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgp CiB7Ci0gICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbEZpbGVTeXN0ZW0ocGF0aCkpOworICAg IEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyhMb2NhbEZpbGVTeXN0ZW0qLCBsb2NhbEZpbGVT eXN0ZW0gPSBuZXcgTG9jYWxGaWxlU3lzdGVtKCIiKSk7CisgICAgcmV0dXJuICpsb2NhbEZpbGVT eXN0ZW07CiB9CiAKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwg bG9uZyBsb25nIHNpemUsIFBhc3NSZWZQdHI8RmlsZVN5c3RlbUNhbGxiYWNrPiBzdWNjZXNzQ2Fs bGJhY2ssIFBhc3NSZWZQdHI8RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKQEAgLTYwLDcg KzY1LDEwIEBAIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbShTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpCiAgICAgICAgIFdlYkZyYW1lSW1wbCog d2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmZyb21GcmFtZShkb2N1bWVudC0+ZnJhbWUoKSk7CiAg ICAgICAgIHdlYkZyYW1lLT5jbGllbnQoKS0+b3BlbkZpbGVTeXN0ZW0od2ViRnJhbWUsIHN0YXRp Y19jYXN0PFdlYkZpbGVTeXN0ZW06OlR5cGU+KHR5cGUpLCBzaXplLCBuZXcgV2ViRmlsZVN5c3Rl bUNhbGxiYWNrc0ltcGwobmV3IEZpbGVTeXN0ZW1DYWxsYmFja3Moc3VjY2Vzc0NhbGxiYWNrLCBl cnJvckNhbGxiYWNrLCBjb250ZXh0KSkpOwogICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEZJWE1F OiBBZGQgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtlcnMuCisgICAgICAgIFdvcmtlckNvbnRleHQq IHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7Cisg ICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250 ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFz ZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclBy b3h5KTsKKyAgICAgICAgd2ViV29ya2VyLT5vcGVuRmlsZVN5c3RlbShzdGF0aWNfY2FzdDxXZWJG aWxlU3lzdGVtOjpUeXBlPih0eXBlKSwgc2l6ZSwgbmV3IFdlYkZpbGVTeXN0ZW1DYWxsYmFja3NJ bXBsKG5ldyBGaWxlU3lzdGVtQ2FsbGJhY2tzKHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj aywgY29udGV4dCkpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu Y3BwCmluZGV4IDQyZjQxZDJkYzc5YjRlM2U0NjNjZTQ5ZDgyZTY1YTU0ODM5NTVlMmUuLmE2OWFh ZGE0YjI3YTc5ZTdlYzVkYjA0ZGNjZWEzZThiOWNiN2QwMjIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtTWVz c2FnZVBvcnRDaGFubmVsLmgiCiAKICNpbmNsdWRlICJXZWJEYXRhU291cmNlSW1wbC5oIgorI2lu Y2x1ZGUgIldlYkZpbGVFcnJvci5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTWVzc2FnZVBvcnRDaGFubmVsLmgi CkBAIC00NSw2ICs0Niw4IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYldv cmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1ZGUgIldv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2UuaCIKICNpbmNsdWRlICJXb3JrZXJTY3JpcHRD b250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8d3RmL01h aW5UaHJlYWQuaD4KQEAgLTU2LDYgKzU5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAjaWYgRU5B QkxFKFdPUktFUlMpCiAKIHN0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAi YWxsb3dEYXRhYmFzZU1vZGUiOworc3RhdGljIGNvbnN0IGNoYXIgb3BlbkZpbGVTeXN0ZW1Nb2Rl W10gPSAib3BlbkZpbGVTeXN0ZW1Nb2RlIjsKIAogbmFtZXNwYWNlIHsKIApAQCAtMTE0LDYgKzEx OCw3IEBAIHByaXZhdGU6CiAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CiAgICAgV1RGOjpT dHJpbmcgbV9tb2RlOwogfTsKKwogfQogCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbiB0 aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwpAQCAtMjMx LDYgKzIzNiwxNiBAQCBib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUq LCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cgogICAgIHJldHVybiBicmlkZ2Ut PnJlc3VsdCgpOwogfQogCit2b2lkIFdlYldvcmtlckJhc2U6Om9wZW5GaWxlU3lzdGVtKFdlYkZp bGVTeXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nIHNpemUsIFdlYkZpbGVTeXN0ZW1DYWxsYmFj a3MqIGNhbGxiYWNrcykKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJU aHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVy ID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBX b3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2VyQ29udGV4dCgp OworCisgICAgUmVmUHRyPFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSA9 IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmNyZWF0ZSh0aGlzLCB3b3JrZXJDb250 ZXh0LCBjYWxsYmFja3MpOworICAgIGJyaWRnZS0+cG9zdE9wZW5GaWxlU3lzdGVtVG9NYWluVGhy ZWFkKGNvbW1vbkNsaWVudCgpLCB0eXBlLCBzaXplLCBvcGVuRmlsZVN5c3RlbU1vZGUpOworfQor CiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNz YWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3Nh Z2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IDIyNzExZjlmMjJjZjcwNmJk ZGViMDIyYzg1YzRjMzI3ZDZlMzEyYjMuLjYyOGQ4ZjE4YzNlMTdhMjA2Zjg1ZmNjYWVhMzdhOWZl YzFkOTZhY2IgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC05MSw2ICs5MSw5 IEBAIHB1YmxpYzoKICAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJh c2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0Rh dGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcm IGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCisgICAgLy8gUmVx dWVzdHMgdG8gb3BlbiBhIGZpbGUgc3lzdGVtIGZvciB0aGlzIHdvcmtlci4gKE5vdGUgdGhhdCB0 aGlzIGlzIG5vdCB0aGUgaW1wbGVtZW50YXRpb24gZm9yIFdlYkZyYW1lQ2xpZW50OjpvcGVuRmls ZVN5c3RlbS4pCisgICAgdm9pZCBvcGVuRmlsZVN5c3RlbShXZWJGaWxlU3lzdGVtOjpUeXBlLCBs b25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyopOworCiAgICAgLy8gRXhlY3V0 ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2b2lkIGRp c3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudElt cGwuaAppbmRleCA3NDFkNjA2NDA2OTYxZjNmMjU5MGRiMDk5OWZiMjA3NjUyYTVmNTQ1Li4wNjA0 ODIzNWRiZjI4ZmM5ZWZmMzRhMmFlZmRhODQxYTg5NzRjN2QyIDEwMDY0NAotLS0gYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtMzMsOCArMzMsOCBAQAogCiAjaWYgRU5BQkxF KFdPUktFUlMpCiAKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiV2ViV29y a2VyQ2xpZW50LmgiCi0KICNpbmNsdWRlICJXb3JrZXJDb250ZXh0UHJveHkuaCIKICNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KQEAgLTk5LDYgKzk5 LDEwIEBAIHB1YmxpYzoKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJl dHVybiB0cnVlOwogICAgIH0KKyAgICB2aXJ0dWFsIHZvaWQgb3BlbkZpbGVTeXN0ZW0oV2ViRnJh bWUqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV2ViRmlsZVN5c3RlbUNh bGxiYWNrcyopCisgICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CiAK IHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZDExMjg4NjRlOTA2ZDc4OWNmYjM4MzJmZGYwOTI1MGM4OTdhNWNjMQot LS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZS5jcHAKQEAgLTAsMCArMSwxOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICog ICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0 cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9k dWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIgorCisjaWYgRU5BQkxF KEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAi V2ViQ29tbW9uV29ya2VyQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViRmlsZVN5c3RlbUNhbGxiYWNr cy5oIgorI2luY2x1ZGUgIldlYlN0cmluZy5oIgorI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIK KyNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJv bGxlci5oIgorI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgorI2luY2x1ZGUgPHd0Zi9NYWluVGhy ZWFkLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorCit1c2luZyBuYW1lc3BhY2UgV2Vi Q29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKKy8vIEZpbGVTeXN0ZW1DYWxsYmFja3MgdGhh dCBhcmUgdG8gYmUgZGlzcGF0Y2hlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCitjbGFzcyBNYWluVGhy ZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyA6IHB1YmxpYyBXZWJGaWxlU3lzdGVtQ2FsbGJhY2tzIHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxi YWNrcz4gY3JlYXRlKFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4g YnJpZGdlLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQ dHIobmV3IE1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKGJyaWRnZSwgbW9kZSkpOworICAg IH0KKworICAgIHZpcnR1YWwgfk1haW5UaHJlYWRGaWxlU3lzdGVtQ2FsbGJhY2tzKCkKKyAgICB7 CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFdlYlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBwYXRoKQorICAgIHsKKyAgICAgICAgbV9icmlk Z2UtPmRpZE9wZW5GaWxlU3lzdGVtT25NYWluVGhyZWFkKG5hbWUsIHBhdGgsIG1fbW9kZSk7Cisg ICAgICAgIGRlbGV0ZSB0aGlzOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKFdl YkZpbGVFcnJvciBlcnJvcikKKyAgICB7CisgICAgICAgIG1fYnJpZGdlLT5kaWRGYWlsT25NYWlu VGhyZWFkKGVycm9yLCBtX21vZGUpOworICAgICAgICBkZWxldGUgdGhpczsKKyAgICB9CisKKyAg ICB2aXJ0dWFsIHZvaWQgZGlkU3VjY2VlZCgpCisgICAgeworICAgICAgICBXRUJLSVRfQVNTRVJU X05PVF9SRUFDSEVEKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWRNZXRhZGF0 YShjb25zdCBXZWJGaWxlSW5mbyYgaW5mbykKKyAgICB7CisgICAgICAgIFdFQktJVF9BU1NFUlRf Tk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUmVhZERpcmVjdG9y eShjb25zdCBXZWJWZWN0b3I8V2ViRmlsZVN5c3RlbUVudHJ5PiYgZW50cmllcywgYm9vbCBoYXNN b3JlKQorICAgIHsKKyAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyhQYXNzUmVmUHRy PFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBt b2RlKQorICAgICAgICA6IG1fYnJpZGdlKGJyaWRnZSkKKyAgICAgICAgLCBtX21vZGUobW9kZSkK KyAgICB7CisgICAgICAgIEFTU0VSVChtX2JyaWRnZS5nZXQoKSk7CisgICAgfQorCisgICAgZnJp ZW5kIGNsYXNzIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U7CisgICAgUmVmUHRyPFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IG1fYnJpZGdlOworICAgIGNvbnN0IFN0cmlu ZyBtX21vZGU7Cit9OworCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OnN0 b3AoKQoreworICAgIEFTU0VSVChtX3dvcmtlckNvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsK KyAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7CisgICAgbV93b3JrZXIgPSAwOworCisg ICAgaWYgKG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgbV9jYWxsYmFja3NP bldvcmtlclRocmVhZC0+ZGlkRmFpbChXZWJGaWxlRXJyb3JBYm9ydCk7CisgICAgICAgIG1fY2Fs bGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0KK30KKwordm9pZCBXb3JrZXJGaWxlU3lz dGVtQ2FsbGJhY2tzQnJpZGdlOjpwb3N0T3BlbkZpbGVTeXN0ZW1Ub01haW5UaHJlYWQoV2ViQ29t bW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZpbGVTeXN0ZW06OlR5cGUgdHlwZSwg bG9uZyBsb25nIHNpemUsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBtX3NlbGZSZWYgPSB0 aGlzOworICAgIEFTU0VSVChtX3dvcmtlckNvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKKyAg ICBBU1NFUlQobV93b3JrZXIpOworICAgIG1fd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJl YWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbU9uTWFpblRocmVhZCwgY29tbW9u Q2xpZW50LCB0eXBlLCBzaXplLCB0aGlzLCBtb2RlKSk7Cit9CisKK3ZvaWQgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJG aWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZyBzaXplLCBXb3JrZXJGaWxlU3lzdGVtQ2Fs bGJhY2tzQnJpZGdlKiBicmlkZ2UsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBBU1NFUlQo aXNNYWluVGhyZWFkKCkpOworICAgIGlmICghY29tbW9uQ2xpZW50KQorICAgICAgICBicmlkZ2Ut PmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yQWJvcnQsIG1vZGUpOworICAgIGVsc2Ug eworICAgICAgICAvLyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrcyBpcyBzZWxmLWRlc3Ry dWN0ZWQsIHNvIHdlIGxlYWsgcHRyIGhlcmUuCisgICAgICAgIGNvbW1vbkNsaWVudC0+b3BlbkZp bGVTeXN0ZW0odHlwZSwgc2l6ZSwgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M6OmNyZWF0 ZShicmlkZ2UsIG1vZGUpLmxlYWtQdHIoKSk7CisgICAgfQorfQorCit2b2lkIFdvcmtlckZpbGVT eXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRpZEZhaWxPbk1haW5UaHJlYWQoV2ViRmlsZUVycm9yIGVy cm9yLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsK KyAgICBtYXlQb3N0VGFza1RvV29ya2VyKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkRmFpbE9uV29y a2VyVGhyZWFkLCBtX3NlbGZSZWYsIGVycm9yKSwgbW9kZSk7Cit9CisKK3ZvaWQgV29ya2VyRmls ZVN5c3RlbUNhbGxiYWNrc0JyaWRnZTo6ZGlkT3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoLCBjb25zdCBTdHJpbmcmIG1v ZGUpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBtYXlQb3N0VGFza1RvV29y a2VyKGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkT3BlbkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZCwg bV9zZWxmUmVmLCBuYW1lLCByb290UGF0aCksIG1vZGUpOworfQorCitXb3JrZXJGaWxlU3lzdGVt Q2FsbGJhY2tzQnJpZGdlOjpXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlKFdlYldvcmtl ckJhc2UqIHdvcmtlciwgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29u dGV4dCwgV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzKQorICAgIDogV29ya2VyQ29u dGV4dDo6T2JzZXJ2ZXIoc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQpKQorICAgICwgbV93b3JrZXIod29ya2VyKQorICAgICwgbV93b3JrZXJDb250ZXh0 KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCisgICAgLCBtX2NhbGxiYWNrc09uV29ya2VyVGhyZWFk KGNhbGxiYWNrcykKK3sKKyAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5pc0NvbnRleHRUaHJl YWQoKSk7Cit9CisKK1dvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6On5Xb3JrZXJGaWxl U3lzdGVtQ2FsbGJhY2tzQnJpZGdlKCkKK3sKKyAgICBBU1NFUlQoIW1fY2FsbGJhY2tzT25Xb3Jr ZXJUaHJlYWQpOworfQorCit2b2lkIFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U6OmRp ZEZhaWxPbldvcmtlclRocmVhZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxX b3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBicmlkZ2UsIFdlYkZpbGVFcnJvciBlcnJv cikKK3sKKyAgICBpZiAoYnJpZGdlLT5tX2NhbGxiYWNrc09uV29ya2VyVGhyZWFkKSB7CisgICAg ICAgIEFTU0VSVChicmlkZ2UtPm1fd29ya2VyQ29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpOwor ICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQtPmRpZEZhaWwoZXJyb3Ip OworICAgICAgICBicmlkZ2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0K K30KKwordm9pZCBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjpkaWRPcGVuRmlsZVN5 c3RlbU9uV29ya2VyVGhyZWFkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFdv cmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2U+IGJyaWRnZSwgY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoKQoreworICAgIGlmIChicmlkZ2UtPm1fY2FsbGJhY2tz T25Xb3JrZXJUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKGJyaWRnZS0+bV93b3JrZXJDb250ZXh0 LT5pc0NvbnRleHRUaHJlYWQoKSk7CisgICAgICAgIGJyaWRnZS0+bV9jYWxsYmFja3NPbldvcmtl clRocmVhZC0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgcm9vdFBhdGgpOworICAgICAgICBicmlk Z2UtPm1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQgPSAwOworICAgIH0KK30KKwordm9pZCBXb3Jr ZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlOjptYXlQb3N0VGFza1RvV29ya2VyKFBhc3NPd25Q dHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3RyaW5nJiBtb2Rl KQoreworICAgIHsgLy8gTGV0IGdvIG9mIHRoZSBtdXRleCBiZWZvcmUgcG9zc2libHkgZGVsZXRp bmcgdGhpcyBkdWUgdG8gbV9zZWxmUmVmLmNsZWFyKCkuCisgICAgICAgIE11dGV4TG9ja2VyIGxv Y2tlcihtX211dGV4KTsKKyAgICAgICAgaWYgKG1fd29ya2VyKQorICAgICAgICAgICAgbV93b3Jr ZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dCh0YXNrLCBtb2RlKTsKKyAgICB9Cisg ICAgbV9zZWxmUmVmLmNsZWFyKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Xb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZTZmNTVjODA2 YTM0MDZmYTE1YjBhNmVmMTU2OGRkODhiZTMwMDZhYgotLS0gL2Rldi9udWxsCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZS5oCkBAIC0wLDAg KzEsMTIwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6 CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIK KyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2Yg R29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlz IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworI2lmbmRlZiBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlX2gKKyNkZWZp bmUgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZV9oCisKKyNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRl ICJXZWJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJXZWJGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAi V2ViVmVjdG9yLmgiCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1ZGUgPHd0Zi9Q YXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYv VGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBBc3luY0ZpbGVTeXN0 ZW07CitjbGFzcyBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczsKK2NsYXNzIFRocmVhZGFi bGVDYWxsYmFja3NCcmlkZ2VXcmFwcGVyOworY2xhc3MgV2ViQ29tbW9uV29ya2VyQ2xpZW50Owor Y2xhc3MgV2ViRmlsZVN5c3RlbUNhbGxiYWNrczsKK2NsYXNzIFdlYkZpbGVTeXN0ZW1FbnRyeTsK K2NsYXNzIFdlYldvcmtlckJhc2U7CitzdHJ1Y3QgV2ViRmlsZUluZm87CisKKy8vIFRoaXMgY2xh c3MgaXMgdXNlZCB0byBwb3N0IGEgb3BlbkZpbGVTeXN0ZW0gcmVxdWVzdCB0byB0aGUgbWFpbiB0 aHJlYWQgYW5kIGdldCBjYWxsZWQgYmFjayBmb3IgdGhlIHJlcXVlc3QuIFRoaXMgbXVzdCBiZSBk ZXN0cnVjdGVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorLy8KKy8vIEEgdHlwaWNhbCBmbG93IGZv ciBvcGVuRmlsZVN5c3RlbSB3b3VsZCBsb29rIGxpa2UgdGhpczoKKy8vIEJyaWRnZTo6cG9zdE9w ZW5GaWxlU3lzdGVtVG9NYWluVGhyZWFkKCkgb24gV29ya2VyVGhyZWFkCisvLyAgLS0+IEJyaWRn ZTo6b3BlbkZpbGVTeXN0ZW1Pbk1haW5UaHJlYWQoKSBpcyBjYWxsZWQgb24gTWFpblRocmVhZAor Ly8gICAgICBUaGlzIG1ha2VzIGFuIElQQyB3aXRoIGEgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxs YmFja3MgaW5zdGFuY2UKKy8vICAgICBbYWN0dWFsIG9wZXJhdGlvbiBpcyBkb3duIGluIHRoZSBi cm93c2VyXQorLy8gIC0tPiBNYWluVGhyZWFkRmlsZVN5c3RlbUNhbGxiYWNrczo6ZGlkWHh4IGlz IGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25NYWluVGhyZWFk IGlzIGNhbGxlZCBvbiBNYWluVGhyZWFkCisvLyAgLS0+IEJyaWRnZTo6ZGlkWHh4T25Xb3JrZXJU aHJlYWQgaXMgY2FsbGVkIG9uIFdvcmtlclRocmVhZAorLy8gICAgICBUaGlzIGNhbGxzIHRoZSBv cmlnaW5hbCBjYWxsYmFja3MgKG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQpIGFuZAorLy8gICAg ICByZWxlYXNlcyBhIHNlbGYtcmVmZXJlbmNlIHRvIHRoZSBicmlkZ2UuCitjbGFzcyBXb3JrZXJG aWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8V29ya2Vy RmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRnZT4sIHB1YmxpYyBXZWJDb3JlOjpXb3JrZXJDb250ZXh0 OjpPYnNlcnZlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogd29ya2VyQ29udGV4dCwgV2ViRmlsZVN5c3RlbUNh bGxiYWNrcyogY2FsbGJhY2tzKQorICAgIHsKKyAgICAgICAgcmV0dXJuIFdURjo6YWRvcHRSZWYo bmV3IFdvcmtlckZpbGVTeXN0ZW1DYWxsYmFja3NCcmlkZ2Uod29ya2VyLCB3b3JrZXJDb250ZXh0 LCBjYWxsYmFja3MpKTsKKyAgICB9CisKKyAgICAvLyBXb3JrZXJDb250ZXh0OjpPYnNlcnZlciBt ZXRob2QuCisgICAgdmlydHVhbCB2b2lkIG5vdGlmeVN0b3AoKQorICAgIHsKKyAgICAgICAgc3Rv cCgpOworICAgIH0KKworICAgIHZvaWQgc3RvcCgpOworCisgICAgLy8gUG9zdHMgYW4gaW5pdGlh bCByZXF1ZXN0IHRhc2sgdG8gdGhlIG1haW4gdGhyZWFkLiBJdCBpcyBzdXBwb3NlZCB0byBiZSBj YWxsZWQgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGJyaWRnZSBpcyBjb25zdHJ1Y3RlZC4gKEl0IGRv ZXNuJ3QgY2hlY2sgaWYgdGhlIGNvbnRleHQgaGFzIGJlZW4gc3RvcHBlZCBvciBub3QuKQorICAg IHZvaWQgcG9zdE9wZW5GaWxlU3lzdGVtVG9NYWluVGhyZWFkKFdlYkNvbW1vbldvcmtlckNsaWVu dCosIFdlYkZpbGVTeXN0ZW06OlR5cGUsIGxvbmcgbG9uZyBzaXplLCBjb25zdCBTdHJpbmcmIG1v ZGUpOworCisgICAgLy8gQ2FsbGJhY2sgbWV0aG9kcyB0aGF0IGFyZSBjYWxsZWQgb24gdGhlIG1h aW4gdGhyZWFkLgorICAgIHZvaWQgZGlkRmFpbE9uTWFpblRocmVhZChXZWJGaWxlRXJyb3IsIGNv bnN0IFN0cmluZyYgbW9kZSk7CisgICAgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbU9uTWFpblRocmVh ZChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgcm9vdFBhdGgsIGNvbnN0IFN0cmlu ZyYgbW9kZSk7CisKK3ByaXZhdGU6CisgICAgV29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZShXZWJXb3JrZXJCYXNlKiwgV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFdlYkZp bGVTeXN0ZW1DYWxsYmFja3MqKTsKKyAgICB+V29ya2VyRmlsZVN5c3RlbUNhbGxiYWNrc0JyaWRn ZSgpOworCisgICAgZnJpZW5kIGNsYXNzIFRocmVhZFNhZmVTaGFyZWQ8V29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZT47CisKKyAgICAvLyBNZXRob2QgdGhhdCBpcyB0byBiZSBjYWxsZWQg b24gdGhlIG1haW4gdGhyZWFkLgorICAgIHN0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtT25NYWlu VGhyZWFkKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBXZWJDb21tb25Xb3JrZXJD bGllbnQqLCBXZWJGaWxlU3lzdGVtOjpUeXBlLCBsb25nIGxvbmcgc2l6ZSwgV29ya2VyRmlsZVN5 c3RlbUNhbGxiYWNrc0JyaWRnZSosIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICBmcmllbmQg Y2xhc3MgTWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3M7CisKKyAgICAvLyBNZXRob2RzIHRo YXQgZGlzcGF0Y2ggV2ViRmlsZVN5c3RlbUNhbGxiYWNrcyBvbiB0aGUgd29ya2VyIHRocmVhZHMu CisgICAgLy8gVGhleSByZWxlYXNlIGEgc2VsZlJlZiBvZiB0aGUgV29ya2VyRmlsZVN5c3RlbUNh bGxiYWNrc0JyaWRnZS4KKyAgICBzdGF0aWMgdm9pZCBkaWRGYWlsT25Xb3JrZXJUaHJlYWQoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8V29ya2VyRmlsZVN5c3Rl bUNhbGxiYWNrc0JyaWRnZT4sIFdlYkZpbGVFcnJvcik7CisgICAgc3RhdGljIHZvaWQgZGlkT3Bl bkZpbGVTeXN0ZW1PbldvcmtlclRocmVhZChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc1JlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiwgY29uc3QgU3Ry aW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHJvb3RQYXRoKTsKKworICAgIHZvaWQgbWF5UG9zdFRh c2tUb1dvcmtlcihQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRh c2s+LCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgLy8gbV9zZWxmUmVmIGtlZXBzIGEgcmVm ZXJlbmNlIHRvIGl0c2VsZiB1bnRpbCB0YXNrcyBhcmUgY3JlYXRlZCBmb3IgdGhlIHdvcmtlciB0 aHJlYWQgKGF0IHdoaWNoIHBvaW50IHRoZSB0YXNrcyBob2xkIHRoZSByZWZlcmVuY2UpLgorICAg IFJlZlB0cjxXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJpZGdlPiBtX3NlbGZSZWY7CisKKyAg ICBNdXRleCBtX211dGV4OworICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOworICAgIFdvcmtl ckNvbnRleHQqIG1fd29ya2VyQ29udGV4dDsKKworICAgIC8vIFRoaXMgaXMgc2VsZi1kZXN0cnVj dGVkIGFuZCBtdXN0IGJlIGZpcmVkIG9uIHRoZSB3b3JrZXIgdGhyZWFkLgorICAgIFdlYkZpbGVT eXN0ZW1DYWxsYmFja3MqIG1fY2FsbGJhY2tzT25Xb3JrZXJUaHJlYWQ7Cit9OworCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBXb3JrZXJGaWxlU3lzdGVtQ2FsbGJhY2tzQnJp ZGdlX2gK