106826 2013-01-14 14:11:55 -0800 Synchronous XMLHttpRequests need to go to the NetworkProcess 2013-01-16 16:47:15 -0800 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Mac All RESOLVED FIXED InRadar P2 Normal --- 1 beidson beidson abarth andersca ap japhet mjs sam webkit.review.bot oldest_to_newest 806609 0 beidson 2013-01-14 14:11:55 -0800 Synchronous XMLHTTPRequests need to go to the NetworkProcess In radar as <rdar://problem/12951765> 806722 1 182646 beidson 2013-01-14 16:08:57 -0800 Created attachment 182646 Patch v1 806728 2 webkit.review.bot 2013-01-14 16:11:00 -0800 Attachment 182646 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h:79: The parameter name "reply" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 19 files If any of these errors are false positives, please file a bug against check-webkit-style. 806734 3 beidson 2013-01-14 16:14:14 -0800 (In reply to comment #2) > Attachment 182646 [details] did not pass style-queue: > > Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 > Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h:79: The parameter name "reply" adds no information, so it should be removed. [readability/parameter_name] [5] > Total errors found: 1 in 19 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. Fixed locally. 806799 4 182646 ap 2013-01-14 17:13:58 -0800 Comment on attachment 182646 Patch v1 View in context: https://bugs.webkit.org/attachment.cgi?id=182646&action=review > Source/WebCore/platform/network/NetworkingContext.h:28 > +#include "ResourceHandle.h" This include will cause much longer rebuilds when changing ResourceHandle.h. It's just for StoredCredentials enum, please find another way to pass this argument, or move the enum to another file. > Source/WebCore/platform/network/NetworkingContext.h:80 > + virtual bool handledSynchronousLoad(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>&) { return false; } This makes me quite unhappy. NetworkingContext is a bad beast already, but at least it mostly provides policy functions. A complete load implementation is way out of place here. There is another patch posted for review where ResourceHandle::loadResourceSynchronously() will consult NetworkingContext for referer policy. Together, these will create a circular dependency mess. > Source/WebCore/platform/network/mac/ResourceHandleMac.mm:370 > + if (context->handledSynchronousLoad(request, storedCredentials, error, response, data)) > + return; I understand that you tried to keep these changes port-spefic, but it's not right to drop down all the way to ResourceHandleMac, which is a wrapper for CFNetwork, and then pass control back to WebKit. > Source/WebKit2/NetworkProcess/HostRecord.cpp:66 > +void HostRecord::scheduleSync(PassRefPtr<SyncResourceLoader> loader) > +{ > + m_syncLoadersPending.append(loader); > +} It's unpleasantly asymmetric that adding has a member function, but removing is done via syncLoadersPending(). > Source/WebKit2/NetworkProcess/HostRecord.h:68 > + HashSet<RefPtr<SyncResourceLoader> > m_syncLoadersLoading; Why does this need to keep a reference? Can SyncResourceLoader destruction notify relevant HostRecords? > Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.cpp:195 > + // We serve synchronous requests before any other requests as it doesn't make sense to spend resources performing Perhaps "improves responsiveness" would be more positive and descriptive than "doesn't make sense". > Source/WebKit2/NetworkProcess/SyncResourceLoader.cpp:36 > +#if ENABLE(NETWORK_PROCESS) I think that most files have such checks after the first two includes, slightly improving build times when disabled. > Source/WebKit2/NetworkProcess/SyncResourceLoader.cpp:42 > +SyncResourceLoader::SyncResourceLoader(const NetworkResourceLoadParameters& parameters, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply) Should this class be named SyncNetworkResourceLoader for consistency with NetworkResourceLoader? > Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp:185 > + // FIXME (NetworkProcess): Get the right value for private browsing enabled I don't think that this can be left on a FIXME. Private browsing works now, so breaking it is a fairly big regression. > Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp:187 > + if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, dataReference), 0)) { Will async response messages be delivered to WebProcess during this call? Both "yes" and "no" answers will leave me very concerned, because (1) handling network events during a sync XHR call will cause reentrance in JavaScript code, and (2) not handling them would cause deadlocks, because there may be already six requests to this host, and they need to finish somehow. > Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp:192 > + return true; This looks like a typo, but is actually correct. That's worth a comment (but I as mentioned above, think that this should be refactored). > Source/WebKit2/WebProcess/Network/WebResourceLoader.h:35 > +#include <WebCore/ResourceHandle.h> Again, I hope that we won't need this include. 806817 5 182646 abarth 2013-01-14 17:28:31 -0800 Comment on attachment 182646 Patch v1 View in context: https://bugs.webkit.org/attachment.cgi?id=182646&action=review >> Source/WebCore/platform/network/mac/ResourceHandleMac.mm:370 >> + return; > > I understand that you tried to keep these changes port-spefic, but it's not right to drop down all the way to ResourceHandleMac, which is a wrapper for CFNetwork, and then pass control back to WebKit. I would much prefer if we picked a consistent design for how the NetworkProcess interfaces with WebCore. For example, why are we using NetworkingContext here when in other places we're using PlatformStrategies? 806819 6 ap 2013-01-14 17:29:06 -0800 Thinking about this more - perhaps we have the same deadlock in single process case too? 806983 7 beidson 2013-01-14 22:07:46 -0800 (In reply to comment #5) > (From update of attachment 182646 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182646&action=review > > >> Source/WebCore/platform/network/mac/ResourceHandleMac.mm:370 > >> + return; > > > > I understand that you tried to keep these changes port-spefic, but it's not right to drop down all the way to ResourceHandleMac, which is a wrapper for CFNetwork, and then pass control back to WebKit. While I admit it's not super clean, I don't have nearly as hard a time accepting this. ResourceHandle* is a wrapper for "platform networking implementations". The fact that one of our platform network implementations is implemented by the WK2 network process is an implementation detail that WebCore doesn't need to care about. But... > > I would much prefer if we picked a consistent design for how the NetworkProcess interfaces with WebCore. For example, why are we using NetworkingContext here when in other places we're using PlatformStrategies? The first implementation of this used LoaderStrategy, consistent with previous work. This included an #ifdef block inside of FrameLoader. A brief discussion around the office actually centered around the fact that you personally have objected to some of the cross platform sites where we've had to hook in the NetworkProcess. Your past objections on this are why I refactored this in to something that affected only our platform and therefore you could have no objection to its impact on cross-platform code. It seems both Alexey's objections and your comment here means I should revert to the LoaderStrategy form of this and hook back in to FrameLoader. 806992 8 beidson 2013-01-14 22:17:58 -0800 (In reply to comment #4) > (From update of attachment 182646 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182646&action=review > > > Source/WebCore/platform/network/NetworkingContext.h:28 > > +#include "ResourceHandle.h" > > This include will cause much longer rebuilds when changing ResourceHandle.h. It's just for StoredCredentials enum, please find another way to pass this argument, or move the enum to another file. I felt bad about this, too. I'll move the enum to another file. > > > Source/WebCore/platform/network/NetworkingContext.h:80 > > + virtual bool handledSynchronousLoad(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>&) { return false; } > > This makes me quite unhappy. NetworkingContext is a bad beast already, but at least it mostly provides policy functions. A complete load implementation is way out of place here. This was only necessary due to the refactoring to make this affect only our platform. As mentioned in the comment I just made, it seems like I should go back to the LoaderStrategy version of the patch which makes this unnecessary. > > Source/WebKit2/NetworkProcess/HostRecord.cpp:66 > > +void HostRecord::scheduleSync(PassRefPtr<SyncResourceLoader> loader) > > +{ > > + m_syncLoadersPending.append(loader); > > +} > > It's unpleasantly asymmetric that adding has a member function, but removing is done via syncLoadersPending(). Bizarrely that asymmetry came about during the LoaderStrategy -> ResourceHandle refactoring. I will address it when reworking the patch. > > > Source/WebKit2/NetworkProcess/HostRecord.h:68 > > + HashSet<RefPtr<SyncResourceLoader> > m_syncLoadersLoading; > > Why does this need to keep a reference? Can SyncResourceLoader destruction notify relevant HostRecords? That is not how the HostRecord mechanism works with regards to normal ResourceLoaders, so I'm not sure it's prudent to break symettry for sync XHRs. Especially when we've had discussions about making sync XHR's work with normal subresource loaders which would change this implementation. > > > Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.cpp:195 > > + // We serve synchronous requests before any other requests as it doesn't make sense to spend resources performing > > Perhaps "improves responsiveness" would be more positive and descriptive than "doesn't make sense". Agreed. > > Source/WebKit2/NetworkProcess/SyncResourceLoader.cpp:36 > > +#if ENABLE(NETWORK_PROCESS) > > I think that most files have such checks after the first two includes, slightly improving build times when disabled. Yup. > > Source/WebKit2/NetworkProcess/SyncResourceLoader.cpp:42 > > +SyncResourceLoader::SyncResourceLoader(const NetworkResourceLoadParameters& parameters, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply) > > Should this class be named SyncNetworkResourceLoader for consistency with NetworkResourceLoader? Makes sense. > > Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp:185 > > + // FIXME (NetworkProcess): Get the right value for private browsing enabled > > I don't think that this can be left on a FIXME. Private browsing works now, so breaking it is a fairly big regression. I believe there is another comment literally identical to this one and that I copied this comment from it. I will double check that in the morning. If my memory is correct, that goes at odds with your claim that private browsing works now. > > Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp:187 > > + if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, dataReference), 0)) { > > Will async response messages be delivered to WebProcess during this call? Both "yes" and "no" answers will leave me very concerned, because > (1) handling network events during a sync XHR call will cause reentrance in JavaScript code, and > (2) not handling them would cause deadlocks, because there may be already six requests to this host, and they need to finish somehow. Async response messages from the NetworkProcess will get queued up in the CoreIPC pipeline. So the async loads will complete and the sync load will be serviced. Those response messages are *not* delivered to the WebProcess in the meantime as it is waiting for the synchronous reply to this load. So in the NetworkProcess the async loads actually complete before the sync load starts. But from the WebProcesses perspective the sync load completes and then the messages for the async loads come through. Perhaps there is yet another edge case scenario I have not fully thought through or commented on, but both (1) or (2) that you present here are accounted for. Thanks for your thorough review - Hopefully the LoaderStrategy form of this that I'll get up tomorrow afternoon will address your feedback. 807024 9 abarth 2013-01-14 23:20:55 -0800 > > I would much prefer if we picked a consistent design for how the NetworkProcess interfaces with WebCore. For example, why are we using NetworkingContext here when in other places we're using PlatformStrategies? > > The first implementation of this used LoaderStrategy, consistent with previous work. This included an #ifdef block inside of FrameLoader. > > A brief discussion around the office actually centered around the fact that you personally have objected to some of the cross platform sites where we've had to hook in the NetworkProcess. > > Your past objections on this are why I refactored this in to something that affected only our platform and therefore you could have no objection to its impact on cross-platform code. > > It seems both Alexey's objections and your comment here means I should revert to the LoaderStrategy form of this and hook back in to FrameLoader. I do think it would be better to intercept requests at the ResourceHandle level, but I think we should do that for all sorts of network requests instead of having a hodge-podge of different approaches. My guess is that if you looked at a complete design for intercepting network requests at the ResourceHandle, you wouldn't do it by having a bunch of handledFooLoad functions on NetworkContext. I suspect you'd want to elaborate LoaderStrategy with the ability to create objects to handle each load (e.g., similar to how WebURLLoader works in Chromium). Maybe you have some clear picture in mind of the design you're aiming for, but that's not at all clear from reading the individual patches. 807036 10 ap 2013-01-14 23:59:32 -0800 > Those response messages are *not* delivered to the WebProcess in the meantime as it is waiting for the synchronous reply to this load. Ok. > So in the NetworkProcess the async loads actually complete before the sync load starts. Unfortunately, this is not true if the async loads get redirected, or get an authentication request. In this case, they will wait for a response from WebProcess forever. In fact, this might have changed with my recent refactoring, as we now use sync messages in these cases, and sync messages are probably actually delivered to WebProcess. And thankfully, XHR doesn't (yet?!!!) send DOM events for either. 807041 11 ap 2013-01-15 00:08:07 -0800 > And thankfully, XHR doesn't (yet?!!!) send DOM events for either. More precisely, nothing in the Web platform involves such DOM events AFAICT, or we'd have to dispatch these events during sync XHR to avoid deadlocks. 807334 12 beidson 2013-01-15 08:33:04 -0800 (In reply to comment #9) > > > I would much prefer if we picked a consistent design for how the NetworkProcess interfaces with WebCore. For example, why are we using NetworkingContext here when in other places we're using PlatformStrategies? > > > > The first implementation of this used LoaderStrategy, consistent with previous work. This included an #ifdef block inside of FrameLoader. > > > > A brief discussion around the office actually centered around the fact that you personally have objected to some of the cross platform sites where we've had to hook in the NetworkProcess. > > > > Your past objections on this are why I refactored this in to something that affected only our platform and therefore you could have no objection to its impact on cross-platform code. > > > > It seems both Alexey's objections and your comment here means I should revert to the LoaderStrategy form of this and hook back in to FrameLoader. > > I do think it would be better to intercept requests at the ResourceHandle level, but I think we should do that for all sorts of network requests instead of having a hodge-podge of different approaches. > > My guess is that if you looked at a complete design for intercepting network requests at the ResourceHandle, you wouldn't do it by having a bunch of handledFooLoad functions on NetworkContext. I suspect you'd want to elaborate LoaderStrategy with the ability to create objects to handle each load (e.g., similar to how WebURLLoader works in Chromium). Of course this is what we'd want to do, and how this patch was developed. But since you have been resistant to that approaches effect on cross platform code in the general ResourceLoader case, that's why I let concern for WebKit politics to creep in to design in this case. It seems like you're in agreement that we should continue to expand upon LoaderStrategy, so it seems like the patch I'll get back up here later today won't meet with resistance on that detail. 807856 13 182884 beidson 2013-01-15 17:38:40 -0800 Created attachment 182884 Patch v2 - Use LoaderStrategy 807861 14 sam 2013-01-15 17:45:30 -0800 (In reply to comment #9) > Maybe you have some clear picture in mind of the design you're aiming for, but that's not at all clear from reading the individual patches. The design we are aiming for is for all loading to eventually go through the ResourceLoader, and have ResourceHandle retain its original purpose, to be a thin wrapper around OS level URL loading code (e.g. NSURLConnection on Mac). Since ResourceLoader does not support sync loading yet, this is a stopgap so we can continue working, and we are trying to do it a way that least impacts other ports. Brady will be looking at adding support for sync loading to ResourceLoader. 807926 15 182884 ap 2013-01-15 19:00:36 -0800 Comment on attachment 182884 Patch v2 - Use LoaderStrategy View in context: https://bugs.webkit.org/attachment.cgi?id=182884&action=review As discussed above, this is only safe because NetworkResourceLoader uses sync messages for willSendRequest and authentication now. Please add very explicit comments about this to NetworkResourceLoader.cpp (we should either use sync messages, or pass special flags for async messages, so that they get delivered while waiting for synchronous load). > Source/WebCore/WebCore.xcodeproj/project.pbxproj:1292 > - 49484FC5102CF23C00187DD3 /* CanvasPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 49484FB7102CF23C00187DD3 /* CanvasPattern.h */; }; > 49484FC4102CF23C00188DD3 /* CanvasProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49484FB6102CF23C00188DD3 /* CanvasProxy.cpp */; }; > + 49484FC5102CF23C00187DD3 /* CanvasPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 49484FB7102CF23C00187DD3 /* CanvasPattern.h */; }; This change looks wrong. > Source/WebCore/WebCore.xcodeproj/project.pbxproj:1864 > - 65DF323C09D1DE65000BE325 /* JSCanvasPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 65DF323609D1DE65000BE325 /* JSCanvasPattern.h */; }; > 65DF323B09D1DE65001BE325 /* JSCanvasProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 65DF323509D1DE65001BE325 /* JSCanvasProxy.cpp */; }; > + 65DF323C09D1DE65000BE325 /* JSCanvasPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 65DF323609D1DE65000BE325 /* JSCanvasPattern.h */; }; Ditto. > Source/WebCore/WebCore.xcodeproj/project.pbxproj:8582 > - 49484FB7102CF23C00187DD3 /* CanvasPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CanvasPattern.h; path = canvas/CanvasPattern.h; sourceTree = "<group>"; }; > - 49484FB8102CF23C00187DD3 /* CanvasPattern.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CanvasPattern.idl; path = canvas/CanvasPattern.idl; sourceTree = "<group>"; }; > 49484FB6102CF23C00188DD3 /* CanvasProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CanvasProxy.cpp; path = canvas/CanvasProxy.cpp; sourceTree = "<group>"; }; > + 49484FB7102CF23C00187DD3 /* CanvasPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CanvasPattern.h; path = canvas/CanvasPattern.h; sourceTree = "<group>"; }; > 49484FB7102CF23C00188DD3 /* CanvasProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CanvasProxy.h; path = canvas/CanvasProxy.h; sourceTree = "<group>"; }; > + 49484FB8102CF23C00187DD3 /* CanvasPattern.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CanvasPattern.idl; path = canvas/CanvasPattern.idl; sourceTree = "<group>"; }; Ditto. > Source/WebCore/WebCore.xcodeproj/project.pbxproj:9199 > - 65DF323609D1DE65000BE325 /* JSCanvasPattern.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSCanvasPattern.h; sourceTree = "<group>"; }; > 65DF323509D1DE65001BE325 /* JSCanvasProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSCanvasProxy.cpp; sourceTree = "<group>"; }; > + 65DF323609D1DE65000BE325 /* JSCanvasPattern.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSCanvasPattern.h; sourceTree = "<group>"; }; Ditto. How did this happen? > Source/WebCore/loader/FrameLoader.cpp:2588 > + PrivateBrowsing privateBrowsing = m_frame->settings()->privateBrowsingEnabled() ? PrivateBrowsingEnabled : PrivateBrowsingDisabled; > + platformStrategies()->loaderStrategy()->loadResourceSynchronously(networkingContext(), newRequest, storedCredentials, privateBrowsing, error, response, data); A better way to get private browsing state is via session.isPrivateBrowsingSession(). Please see how it's done in e.g. WebPlatformStrategies::cookiesForDOM(). > Source/WebCore/loader/LoaderStrategy.h:38 > class ResourceLoadScheduler; > +class ResourceError; Alphabetic ordering. > Source/WebCore/loader/LoaderStrategy.h:45 > +enum PrivateBrowsing { > + PrivateBrowsingDisabled, > + PrivateBrowsingEnabled > +}; This won't be needed. > Source/WebKit2/NetworkProcess/SyncNetworkResourceLoader.h:29 > +#include "NetworkConnectionToWebProcessMessages.h" This won't be needed if you forward declare Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply, and add an explicit destructor implemented in .cpp file. > Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:221 > + if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, dataReference), 0)) { I think that a bad thing can happen with IPC here. If there is an outstanding willSendRequest or authentication message from NetworkProcess, PerformSynchronousLoad will be delivered reentrantly, and block that outstanding load until synchronous loading finishes. Is there a way to say that PerformSynchronousLoad should not be dispatched while waiting for sync message reply? I think that it would be a solution for that. 807937 16 ap 2013-01-15 19:11:22 -0800 > I think that a bad thing can happen with IPC here. Actually, unsure - the messages are sent from a secondary thread in NetworkProcess, so there is not reply stack at play. Maybe it's safe. I can't think about this deeply right now. 807952 17 beidson 2013-01-15 19:27:13 -0800 (In reply to comment #15) > (From update of attachment 182884 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182884&action=review > > As discussed above, this is only safe because NetworkResourceLoader uses sync messages for willSendRequest and authentication now. Please add very explicit comments about this to NetworkResourceLoader.cpp (we should either use sync messages, or pass special flags for async messages, so that they get delivered while waiting for synchronous load). > > This change looks wrong. > ... > Ditto. > ... > Ditto. > ... > Ditto. > > How did this happen? Xcode does this periodically. It's happened to me a few times before, and has happened to others. You've never seen it? We've normally checked it in with a "let Xcode have its way with us" mindset. > > > Source/WebCore/loader/FrameLoader.cpp:2588 > > + PrivateBrowsing privateBrowsing = m_frame->settings()->privateBrowsingEnabled() ? PrivateBrowsingEnabled : PrivateBrowsingDisabled; > > + platformStrategies()->loaderStrategy()->loadResourceSynchronously(networkingContext(), newRequest, storedCredentials, privateBrowsing, error, response, data); > > A better way to get private browsing state is via session.isPrivateBrowsingSession(). Please see how it's done in e.g. WebPlatformStrategies::cookiesForDOM(). Will do this. > > > Source/WebCore/loader/LoaderStrategy.h:38 > > class ResourceLoadScheduler; > > +class ResourceError; > > Alphabetic ordering. Done. > > > Source/WebCore/loader/LoaderStrategy.h:45 > > +enum PrivateBrowsing { > > + PrivateBrowsingDisabled, > > + PrivateBrowsingEnabled > > +}; > > This won't be needed. Good. > > > Source/WebKit2/NetworkProcess/SyncNetworkResourceLoader.h:29 > > +#include "NetworkConnectionToWebProcessMessages.h" > > This won't be needed if you forward declare Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply, and add an explicit destructor implemented in .cpp file. > Ugh, but, okay. > > Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:221 > > + if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, dataReference), 0)) { > > I think that a bad thing can happen with IPC here. If there is an outstanding willSendRequest or authentication message from NetworkProcess, PerformSynchronousLoad will be delivered reentrantly, and block that outstanding load until synchronous loading finishes. As you established yourself in the next comment, I also don't think this will be an issue. We've made CoreIPC pretty resilient against this type of issue as its come up before. 807954 18 ap 2013-01-15 19:34:05 -0800 > Xcode does this periodically. It's happened to me a few times before, and has happened to others. You've never seen it? Not like this - it looks like visual order may be broken. > Please add very explicit comments about this to NetworkResourceLoader.cpp You didn't say "yes" to this global comment. 807958 19 beidson 2013-01-15 19:40:48 -0800 (In reply to comment #17) > (In reply to comment #15) > > (From update of attachment 182884 [details] [details]) > > > Source/WebKit2/NetworkProcess/SyncNetworkResourceLoader.h:29 > > > +#include "NetworkConnectionToWebProcessMessages.h" > > > > This won't be needed if you forward declare Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply, and add an explicit destructor implemented in .cpp file. > > > > Ugh, but, okay. Actually, PerformSynchronousLoad is a class and PerformSynchronousLoad::DelayedReply is a nested class, and afaik you can't forward declare nested classes without having the definition of the outer class. Doing that would require the #include in this case. Googling around seems to confirm this... am I wrong? 807959 20 beidson 2013-01-15 19:43:35 -0800 (In reply to comment #18) > > Xcode does this periodically. It's happened to me a few times before, and has happened to others. You've never seen it? > > Not like this - it looks like visual order may be broken. This precise thing has happened to me before. And while the order is broken in the project in this diff, the visual order is definitely not broken. > > > Please add very explicit comments about this to NetworkResourceLoader.cpp > > You didn't say "yes" to this global comment. Yes. 807961 21 beidson 2013-01-15 19:44:11 -0800 I'll try removing my new file, reverting the project, and re-adding it. In my experience that re-causes the nastiness 807962 22 ap 2013-01-15 19:44:34 -0800 I tried this just today, and it worked for me when using clang. I don't know if this is something new or non-standard. class PerformSynchronousLoad; class PerformSynchronousLoad::DelayedReply; 807969 23 beidson 2013-01-15 19:47:45 -0800 (In reply to comment #21) > I'll try removing my new file, reverting the project, and re-adding it. In my experience that re-causes the nastiness Yup. Re-adding it caused the exact same breakage. Note that the project file itself - in these sections - does not have alphabetical order. 807974 24 beidson 2013-01-15 19:50:43 -0800 (In reply to comment #22) > I tried this just today, and it worked for me when using clang. I don't know if this is something new or non-standard. > > class PerformSynchronousLoad; > class PerformSynchronousLoad::DelayedReply; I was using struct, since they're structs in the header, but same concept. Also fails with class. Replacing the #include with: namespace Messages { namespace NetworkConnectionToWebProcess { struct PerformSynchronousLoad; struct PerformSynchronousLoad::DelayedReply; } } Results in: /Volumes/SSD-Data/git/OpenSource/Source/WebKit2/NetworkProcess/SyncNetworkResourceLoader.h:38:8: Incomplete type 'Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad' named in nested name specifier 807976 25 beidson 2013-01-15 19:51:40 -0800 So if it's working for you, perhaps you have a newer clang that supports it. But it does appear to be nonstandard, and the clang I'm using is a supported config for WebKit2, so it seems like we can't do this particular optimization. 807978 26 beidson 2013-01-15 19:52:19 -0800 Will hash out the rest later, need to leave now. 807986 27 ap 2013-01-15 19:59:49 -0800 > So if it's working for you, perhaps you have a newer clang that supports it. I think that what happened was that I wrote such code, quickly refactored it away even before building, and decided that it built successfully when there were no errors later. 808000 28 abarth 2013-01-15 20:16:29 -0800 @Sam: Thanks. 808691 29 183033 beidson 2013-01-16 13:56:21 -0800 Created attachment 183033 Final patch for landing - Give it an EWS run 808717 30 183035 beidson 2013-01-16 14:23:01 -0800 Created attachment 183035 Super-final (updated to ToT and the patch *TOTALLY* applies locally...) 808719 31 webkit.review.bot 2013-01-16 14:26:01 -0800 Attachment 183035 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:44: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 1 in 25 files If any of these errors are false positives, please file a bug against check-webkit-style. 808720 32 beidson 2013-01-16 14:27:02 -0800 (In reply to comment #31) > Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:44: Alphabetical sorting problem. [build/include_order] [4] Fixed locally. 808729 33 beidson 2013-01-16 14:37:04 -0800 Super final patch is much smaller because the xcodeproj nonsense went away! I wish someone knew what that's all about in the first place. 808839 34 beidson 2013-01-16 16:45:59 -0800 It's been hours - gtk ews is a slacker. Landing this without waiting on it to finish. 808842 35 beidson 2013-01-16 16:47:15 -0800 http://trac.webkit.org/changeset/139935 182646 2013-01-14 16:08:57 -0800 2013-01-15 17:38:40 -0800 Patch v1 patch text/plain 32090 beidson ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhOTgzNDA5Li42MzUyYzAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIg QEAKKzIwMTMtMDEtMTQgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAg ICAgIFN5bmNocm9ub3VzIFhNTEhUVFBSZXF1ZXN0cyBuZWVkIHRvIGdvIHRvIHRoZSBOZXR3b3Jr UHJvY2Vzcy4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzEyOTUxNzY1PiBhbmQgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNjgyNgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoTm8gY2hhbmdlcyB0 byBhbnkgY29uZmlnIHRoYXQgaXMgY3VycmVudGx5IHRlc3RlZCkKKworICAgICAgICAqIFdlYkNv cmUuZXhwLmluOgorCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9OZXR3b3JraW5nQ29udGV4 dC5oOgorICAgICAgICAoV2ViQ29yZTo6TmV0d29ya2luZ0NvbnRleHQ6OmhhbmRsZWRTeW5jaHJv bm91c0xvYWQpOiBGb3IgdGhlIE1hYyBwb3J0LCB0byBhbGxvdyBkaWZmZXJlbnRpYXRpb24KKyAg ICAgICAgICBvbiBiZWhhdmlvciB3aXRoaW4gUmVzb3VyY2VIYW5kbGUuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9uZXR3b3JrL21hYy9SZXNvdXJjZUhhbmRsZU1hYy5tbToKKyAgICAgICAgKFdlYkNv cmU6OlJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KTogVHJ5IHRvIGxl dCB0aGUgTmV0d29ya2luZ0NvbnRleHQgaGFuZGxlCisgICAgICAgICAgdGhlIHN5bmNocm9ub3Vz IGxvYWQgYmVmb3JlIGRvaW5nIGl0IGRpcmVjdGx5LgorCiAyMDEzLTAxLTExICBSeW9zdWtlIE5p d2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIE1vdmUgZnVuY3Rpb25zIGZyb20gTm9k ZVJhcmVEYXRhIHRvIEVsZW1lbnRSYXJlRGF0YSBhbmQgb3RoZXIgY2xhc3NlcwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl LmV4cC5pbgppbmRleCA3OTdhN2YxLi4yOTcxMTQ3ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvV2ViQ29yZS5leHAuaW4KKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4KQEAg LTI5Nyw2ICsyOTcsNyBAQCBfX1pON1dlYkNvcmUxNFJlc291cmNlQnVmZmVyQzJFdgogX19aTjdX ZWJDb3JlMTRSZXNvdXJjZUJ1ZmZlckQxRXYKIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VCdWZmZXJE MkV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlMjBmb3JjZUNvbnRlbnRTbmlmZmluZ0V2 CitfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlMjVsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5 RVBOU18xN05ldHdvcmtpbmdDb250ZXh0RVJLTlNfMTVSZXNvdXJjZVJlcXVlc3RFTlNfMTdTdG9y ZWRDcmVkZW50aWFsc0VSTlNfMTNSZXNvdXJjZUVycm9yRVJOU18xNlJlc291cmNlUmVzcG9uc2VF Uk4zV1RGNlZlY3RvckljTG0wRUVFCiBfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlMjZzeW5j aHJvbm91c0xvYWRSdW5Mb29wTW9kZUV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlNmNy ZWF0ZUVQTlNfMTdOZXR3b3JraW5nQ29udGV4dEVSS05TXzE1UmVzb3VyY2VSZXF1ZXN0RVBOU18y MFJlc291cmNlSGFuZGxlQ2xpZW50RWJiCiBfX1pON1dlYkNvcmUxNFJlc291cmNlTG9hZGVyMTNz ZXRJZGVudGlmaWVyRW0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvTmV0d29ya2luZ0NvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv TmV0d29ya2luZ0NvbnRleHQuaAppbmRleCA4NDFmN2VjLi5hODRmNTkzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL05ldHdvcmtpbmdDb250ZXh0LmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9OZXR3b3JraW5nQ29udGV4dC5oCkBAIC0y NSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgogCiAjaWYgUExBVEZPUk0o TUFDKQorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2NoZWR1bGVQYWly LmgiCiAjZW5kaWYKIApAQCAtNzYsNiArNzcsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTY2hl ZHVsZVBhaXJIYXNoU2V0KiBzY2hlZHVsZWRSdW5Mb29wUGFpcnMoKSBjb25zdCB7IHJldHVybiAw OyB9CiAgICAgdmlydHVhbCBOU09wZXJhdGlvblF1ZXVlICpzY2hlZHVsZWRPcGVyYXRpb25RdWV1 ZSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIFJlc291cmNlRXJyb3IgYmxvY2tl ZEVycm9yKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIGNvbnN0ID0gMDsKKyAgICB2aXJ0dWFsIGJv b2wgaGFuZGxlZFN5bmNocm9ub3VzTG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBTdG9yZWRD cmVkZW50aWFscywgUmVzb3VyY2VFcnJvciYsIFJlc291cmNlUmVzcG9uc2UmLCBWZWN0b3I8Y2hh cj4mKSB7IHJldHVybiBmYWxzZTsgfQogI2VuZGlmCiAKICNpZiBQTEFURk9STShNQUMpIHx8IFVT RShDRk5FVFdPUkspCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L21hYy9SZXNvdXJjZUhhbmRsZU1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvbWFjL1Jlc291cmNlSGFuZGxlTWFjLm1tCmluZGV4IGMwYjhkM2EuLmQ5NTdiMGIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvbWFjL1Jlc291cmNlSGFuZGxl TWFjLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvbWFjL1Jlc291cmNl SGFuZGxlTWFjLm1tCkBAIC0zNjYsNiArMzY2LDkgQEAgdm9pZCBSZXNvdXJjZUhhbmRsZTo6bG9h ZFJlc291cmNlU3luY2hyb25vdXNseShOZXR3b3JraW5nQ29udGV4dCogY29udGV4dCwgY29uc3QK IHsKICAgICBMT0coTmV0d29yaywgIlJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJv bm91c2x5OiVAIGFsbG93U3RvcmVkQ3JlZGVudGlhbHM6JXUiLCByZXF1ZXN0Lm5zVVJMUmVxdWVz dCgpLCBzdG9yZWRDcmVkZW50aWFscyk7CiAKKyAgICBpZiAoY29udGV4dC0+aGFuZGxlZFN5bmNo cm9ub3VzTG9hZChyZXF1ZXN0LCBzdG9yZWRDcmVkZW50aWFscywgZXJyb3IsIHJlc3BvbnNlLCBk YXRhKSkKKyAgICAgICAgcmV0dXJuOworCiAjaWYgRU5BQkxFKEJMT0IpCiAgICAgaWYgKHJlcXVl c3QudXJsKCkucHJvdG9jb2xJcygiYmxvYiIpKQogICAgICAgICBpZiAoYmxvYlJlZ2lzdHJ5KCku bG9hZFJlc291cmNlU3luY2hyb25vdXNseShyZXF1ZXN0LCBlcnJvciwgcmVzcG9uc2UsIGRhdGEp KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCmluZGV4IDJhM2RiYWMuLjkxYjk3YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1 MCBAQAorMjAxMy0wMS0xNCAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+CisKKyAg ICAgICAgU3luY2hyb25vdXMgWE1MSFRUUFJlcXVlc3RzIG5lZWQgdG8gZ28gdG8gdGhlIE5ldHdv cmtQcm9jZXNzLgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTI5NTE3NjU+IGFuZCBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA2ODI2CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L21hYy9XZWJGcmFtZU5ldHdvcmtpbmdDb250ZXh0Lmg6CisgICAgICAgICogV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9tYWMvV2ViRnJhbWVOZXR3b3JraW5nQ29udGV4dC5tbToKKyAgICAg ICAgKFdlYktpdDo6V2ViRnJhbWVOZXR3b3JraW5nQ29udGV4dDo6aGFuZGxlZFN5bmNocm9ub3Vz TG9hZCk6IEVudHJ5IHBvaW50IGZvciBXZWJDb3JlIHRvIGdldAorICAgICAgICAgIHN5bmNocm9u b3VzIHJlcXVlc3RzIHRvIHRoZSBOZXR3b3JrUHJvY2Vzcy4KKworICAgICAgICAqIFdlYlByb2Nl c3MvTmV0d29yay9XZWJSZXNvdXJjZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlJl c291cmNlTG9hZGVyOjpoYW5kbGVkU3luY2hyb25vdXNMb2FkKTogU3luY2hyb25vdXNseSBtZXNz YWdlIHRvIHRoZSBOZXR3b3JrUHJvY2VzcworICAgICAgICAgIGFuZCB3YWl0IGZvciB0aGUgbG9h ZCB0byBjb21wbGV0ZSAob3IgdG8gZmFpbCkuCisgICAgICAgICogV2ViUHJvY2Vzcy9OZXR3b3Jr L1dlYlJlc291cmNlTG9hZGVyLmg6CisKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzcy5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtDb25u ZWN0aW9uVG9XZWJQcm9jZXNzOjpwZXJmb3JtU3luY2hyb25vdXNMb2FkKTogQ3JlYXRlIGEgU3lu Y1Jlc291cmNlTG9hZGVyCisgICAgICAgICAgYW5kIHNjaGVkdWxlIGl0LgorICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmg6CisgICAgICAgICog TmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MubWVzc2FnZXMuaW46 CisKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVy LmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2No ZWR1bGVTeW5jUmVzb3VyY2VMb2FkZXIpOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUmVzb3Vy Y2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0c0Zvckhvc3QpOiBTZXJ2ZSBzeW5j aHJvbm91cyBsb2FkZXJzCisgICAgICAgICAgYmVmb3JlIGFzeW5jIGxvYWRlcnMuCisgICAgICAg ICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOgorCisgICAg ICAgIEEgY2xhc3MgdGhhdCBlbmNhcHN1bGF0ZXMgYSBzeW5jaHJvbm91cyBsb2FkIHJlcXVlc3Qg YW5kIHRoZSBDb3JlSVBDIHJlcGx5IHRvIGJlIG1hZGUgb25jZSBpdCBpcyBjb21wbGV0ZToKKyAg ICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9TeW5jUmVzb3VyY2VMb2FkZXIuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYktpdDo6U3luY1Jlc291cmNlTG9hZGVyOjpTeW5jUmVzb3VyY2VMb2FkZXIpOgor ICAgICAgICAoV2ViS2l0OjpTeW5jUmVzb3VyY2VMb2FkZXI6OnN0YXJ0KToKKyAgICAgICAgKiBO ZXR3b3JrUHJvY2Vzcy9TeW5jUmVzb3VyY2VMb2FkZXIuaDoKKyAgICAgICAgKFdlYktpdDo6U3lu Y1Jlc291cmNlTG9hZGVyOjpjcmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpTeW5jUmVzb3VyY2VM b2FkZXI6OnNldElkZW50aWZpZXIpOgorICAgICAgICAoV2ViS2l0OjpTeW5jUmVzb3VyY2VMb2Fk ZXI6OmlkZW50aWZpZXIpOgorICAgICAgICAoV2ViS2l0OjpTeW5jUmVzb3VyY2VMb2FkZXI6Omxv YWRQYXJhbWV0ZXJzKToKKworICAgICAgICBBZGQgYSBzZWNvbmQgcXVldWUgb2Ygc3luYyBsb2Fk ZXJzOgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuY3BwOgorICAgICAgICAo V2ViS2l0OjpIb3N0UmVjb3JkOjpzY2hlZHVsZVN5bmMpOgorICAgICAgICAqIE5ldHdvcmtQcm9j ZXNzL0hvc3RSZWNvcmQuaDoKKyAgICAgICAgKFdlYktpdDo6SG9zdFJlY29yZDo6c3luY0xvYWRl cnNQZW5kaW5nKToKKworICAgICAgICAqIFdlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv ajoKKwogMjAxMy0wMS0xNCAgSHVhbmcgRG9uZ3N1bmcgIDxsdXh0ZWxsYUBjb21wYW55MTAwLm5l dD4KIAogICAgICAgICBbRUZMXSBSRUdSRVNTSU9OKHIxMzkxODkpOiBNaW5pQnJvd3NlciByZW5k ZXJzIGFibm9ybWFsbHkgd2l0aCAtciBvcHRpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9OZXR3b3JrUHJvY2Vzcy9Ib3N0UmVjb3JkLmNwcCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL0hvc3RSZWNvcmQuY3BwCmluZGV4IDdiYzk2MTcuLjVlMWM5NDcgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuY3BwCkBAIC0zMiw2ICszMiw3IEBA CiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMuaCIKICNpbmNsdWRlICJO ZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNl TG9hZGVyLmgiCisjaW5jbHVkZSAiU3luY1Jlc291cmNlTG9hZGVyLmgiCiAKICNpZiBFTkFCTEUo TkVUV09SS19QUk9DRVNTKQogCkBAIC01OSw2ICs2MCwxMSBAQCB2b2lkIEhvc3RSZWNvcmQ6OnNj aGVkdWxlKFBhc3NSZWZQdHI8TmV0d29ya1Jlc291cmNlTG9hZGVyPiBsb2FkZXIpCiAgICAgbV9s b2FkZXJzUGVuZGluZ1tsb2FkZXItPnByaW9yaXR5KCldLmFwcGVuZChsb2FkZXIpOwogfQogCit2 b2lkIEhvc3RSZWNvcmQ6OnNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN5bmNSZXNvdXJjZUxvYWRl cj4gbG9hZGVyKQoreworICAgIG1fc3luY0xvYWRlcnNQZW5kaW5nLmFwcGVuZChsb2FkZXIpOwor fQorCiB2b2lkIEhvc3RSZWNvcmQ6OmFkZExvYWRJblByb2dyZXNzKFJlc291cmNlTG9hZElkZW50 aWZpZXIgaWRlbnRpZmllcikKIHsKICAgICBtX3Jlc291cmNlSWRlbnRpZmllcnNMb2FkaW5nLmFk ZChpZGVudGlmaWVyKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNz L0hvc3RSZWNvcmQuaCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQu aAppbmRleCAxYjIxMzc2Li5lYzAxYTA0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3 b3JrUHJvY2Vzcy9Ib3N0UmVjb3JkLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nl c3MvSG9zdFJlY29yZC5oCkBAIC0zNiw2ICszNiw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAog Y2xhc3MgTmV0d29ya1Jlc291cmNlTG9hZGVyOworY2xhc3MgU3luY1Jlc291cmNlTG9hZGVyOwog dHlwZWRlZiB1aW50NjRfdCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyOwogCiBjbGFzcyBIb3N0UmVj b3JkIHsKQEAgLTQ2LDYgKzQ3LDcgQEAgcHVibGljOgogICAgIAogICAgIGNvbnN0IFN0cmluZyYg bmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fbmFtZTsgfQogICAgIHZvaWQgc2NoZWR1bGUoUGFzc1Jl ZlB0cjxOZXR3b3JrUmVzb3VyY2VMb2FkZXI+KTsKKyAgICB2b2lkIHNjaGVkdWxlU3luYyhQYXNz UmVmUHRyPFN5bmNSZXNvdXJjZUxvYWRlcj4pOwogICAgIHZvaWQgYWRkTG9hZEluUHJvZ3Jlc3Mo UmVzb3VyY2VMb2FkSWRlbnRpZmllcik7CiAgICAgdm9pZCByZW1vdmUoUmVzb3VyY2VMb2FkSWRl bnRpZmllcik7CiAgICAgYm9vbCBoYXNSZXF1ZXN0cygpIGNvbnN0OwpAQCAtNTQsMTAgKzU2LDE2 IEBAIHB1YmxpYzoKICAgICB0eXBlZGVmIERlcXVlPFJlZlB0cjxOZXR3b3JrUmVzb3VyY2VMb2Fk ZXI+ID4gTG9hZGVyUXVldWU7CiAgICAgTG9hZGVyUXVldWUmIGxvYWRlcnNQZW5kaW5nKFdlYkNv cmU6OlJlc291cmNlTG9hZFByaW9yaXR5IHByaW9yaXR5KSB7IHJldHVybiBtX2xvYWRlcnNQZW5k aW5nW3ByaW9yaXR5XTsgfQogCisgICAgdHlwZWRlZiBEZXF1ZTxSZWZQdHI8U3luY1Jlc291cmNl TG9hZGVyPiA+IFN5bmNMb2FkZXJRdWV1ZTsKKyAgICBTeW5jTG9hZGVyUXVldWUmIHN5bmNMb2Fk ZXJzUGVuZGluZygpIHsgcmV0dXJuIG1fc3luY0xvYWRlcnNQZW5kaW5nOyB9CisKIHByaXZhdGU6 ICAgICAgICAgICAgICAgICAgICAKICAgICBMb2FkZXJRdWV1ZSBtX2xvYWRlcnNQZW5kaW5nW1dl YkNvcmU6OlJlc291cmNlTG9hZFByaW9yaXR5SGlnaGVzdCArIDFdOwogICAgIHR5cGVkZWYgSGFz aFNldDxSZXNvdXJjZUxvYWRJZGVudGlmaWVyPiBSZXNvdXJjZUxvYWRJZGVudGlmaWVyU2V0Owog ICAgIFJlc291cmNlTG9hZElkZW50aWZpZXJTZXQgbV9yZXNvdXJjZUlkZW50aWZpZXJzTG9hZGlu ZzsKKyAgICAKKyAgICBTeW5jTG9hZGVyUXVldWUgbV9zeW5jTG9hZGVyc1BlbmRpbmc7CisgICAg SGFzaFNldDxSZWZQdHI8U3luY1Jlc291cmNlTG9hZGVyPiA+IG1fc3luY0xvYWRlcnNMb2FkaW5n OwogCiAgICAgY29uc3QgU3RyaW5nIG1fbmFtZTsKICAgICBpbnQgbV9tYXhSZXF1ZXN0c0luRmxp Z2h0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nv bm5lY3Rpb25Ub1dlYlByb2Nlc3MuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3Mv TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MuY3BwCmluZGV4IDg2NGIxNGIuLjUzZDc3NjYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0 aW9uVG9XZWJQcm9jZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9O ZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNs dWRlICJOZXR3b3JrUHJvY2Vzcy5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5o IgogI2luY2x1ZGUgIlJlbW90ZU5ldHdvcmtpbmdDb250ZXh0LmgiCisjaW5jbHVkZSAiU3luY1Jl c291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9QbGF0Zm9ybUNvb2tpZUphci5oPgog I2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VMb2FkZXJPcHRpb25zLmg+CiAjaW5jbHVkZSA8V2Vi Q29yZS9SZXNvdXJjZVJlcXVlc3QuaD4KQEAgLTEyMCw2ICsxMjEsMTEgQEAgdm9pZCBOZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzczo6c2NoZWR1bGVSZXNvdXJjZUxvYWQoY29uc3QgTmV0d29y a1Jlc291cmNlTG8KICAgICByZXNvdXJjZUxvYWRJZGVudGlmaWVyID0gTmV0d29ya1Byb2Nlc3M6 OnNoYXJlZCgpLm5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS5zY2hlZHVsZVJlc291cmNl TG9hZChsb2FkUGFyYW1ldGVycywgdGhpcyk7CiB9CiAKK3ZvaWQgTmV0d29ya0Nvbm5lY3Rpb25U b1dlYlByb2Nlc3M6OnBlcmZvcm1TeW5jaHJvbm91c0xvYWQoY29uc3QgTmV0d29ya1Jlc291cmNl TG9hZFBhcmFtZXRlcnMmIGxvYWRQYXJhbWV0ZXJzLCBQYXNzUmVmUHRyPE1lc3NhZ2VzOjpOZXR3 b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6RGVsYXll ZFJlcGx5PiByZXBseSkKK3sKKyAgICBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jl c291cmNlTG9hZFNjaGVkdWxlcigpLnNjaGVkdWxlU3luY1Jlc291cmNlTG9hZGVyKFN5bmNSZXNv dXJjZUxvYWRlcjo6Y3JlYXRlKGxvYWRQYXJhbWV0ZXJzLCByZXBseSkpOworfQorCiB2b2lkIE5l dHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjphZGRMb2FkSW5Qcm9ncmVzcyhjb25zdCBLVVJM JiB1cmwsIFJlc291cmNlTG9hZElkZW50aWZpZXImIGlkZW50aWZpZXIpCiB7CiAgICAgaWRlbnRp ZmllciA9IE5ldHdvcmtQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1 bGVyKCkuYWRkTG9hZEluUHJvZ3Jlc3ModXJsKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmggYi9Tb3VyY2Uv V2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oCmlu ZGV4IDUyMzQ0MjQuLjk3NzgxOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmgKKysrIGIvU291cmNlL1dlYktp dDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MuaApAQCAtNzYs NiArNzYsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgZGlkUmVjZWl2ZVN5bmNOZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzc01lc3NhZ2UoQ29yZUlQQzo6Q29ubmVjdGlvbiosIENvcmVJUEM6Ok1l c3NhZ2VJRCwgQ29yZUlQQzo6TWVzc2FnZURlY29kZXImLCBPd25QdHI8Q29yZUlQQzo6TWVzc2Fn ZUVuY29kZXI+Jik7CiAgICAgCiAgICAgdm9pZCBzY2hlZHVsZVJlc291cmNlTG9hZChjb25zdCBO ZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYsIFJlc291cmNlTG9hZElkZW50aWZpZXImKTsK KyAgICB2b2lkIHBlcmZvcm1TeW5jaHJvbm91c0xvYWQoY29uc3QgTmV0d29ya1Jlc291cmNlTG9h ZFBhcmFtZXRlcnMmLCBQYXNzUmVmUHRyPE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2Vi UHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6RGVsYXllZFJlcGx5PiByZXBseSk7CisK ICAgICB2b2lkIGFkZExvYWRJblByb2dyZXNzKGNvbnN0IFdlYkNvcmU6OktVUkwmLCBSZXNvdXJj ZUxvYWRJZGVudGlmaWVyJik7CiAgICAgdm9pZCByZW1vdmVMb2FkSWRlbnRpZmllcihSZXNvdXJj ZUxvYWRJZGVudGlmaWVyKTsKICAgICB2b2lkIGNyb3NzT3JpZ2luUmVkaXJlY3RSZWNlaXZlZChS ZXNvdXJjZUxvYWRJZGVudGlmaWVyLCBjb25zdCBXZWJDb3JlOjpLVVJMJiByZWRpcmVjdFVSTCk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9j ZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2VzLmluCmluZGV4IGY1NzZj OWUuLjU1ZDkxZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05l dHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9XZWJL aXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2Vz LmluCkBAIC0yOSw2ICsyOSw3IEBAIG1lc3NhZ2VzIC0+IE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzIHsKICAgICAvLyBUaGVyZSdzIHBvc3NpYmxlIFJlc291cmNlTG9hZGVyIGlkZW50aWZp ZXIgcmVmYWN0b3JpbmcgdGhhdCBjYW4gcmVtb3ZlIHRoYXQgcmVxdWlyZW1lbnQuCiAgICAgLy8g V2UgbWlnaHQgYWxzbyBoYXZlIHRoZSBOZXR3b3JrUHJvY2VzcyBkaXZ2eSB1cCBpZGVudGlmaWVy cyBpbiBibG9ja3MgdG8gZWFjaCBXZWJQcm9jZXNzIGJlZm9yZWhhbmQuCiAgICAgU2NoZWR1bGVS ZXNvdXJjZUxvYWQoV2ViS2l0OjpOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyByZXNvdXJj ZUxvYWRQYXJhbWV0ZXJzKSAtPiAodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikKKyAg ICBQZXJmb3JtU3luY2hyb25vdXNMb2FkKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFBhcmFt ZXRlcnMgcmVzb3VyY2VMb2FkUGFyYW1ldGVycykgLT4gKFdlYkNvcmU6OlJlc291cmNlRXJyb3Ig ZXJyb3IsIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgcmVzcG9uc2UsIENvcmVJUEM6OkRhdGFS ZWZlcmVuY2UgZGF0YSkgRGVsYXllZAogICAgIEFkZExvYWRJblByb2dyZXNzKFdlYkNvcmU6OktV UkwgdXJsKSAtPiAodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikKICAgICBSZW1vdmVM b2FkSWRlbnRpZmllcih1aW50NjRfdCByZXNvdXJjZUxvYWRJZGVudGlmaWVyKQogICAgIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9h ZFNjaGVkdWxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmNwcAppbmRleCBkMzc4YjgxLi5hMmI0MjE5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1 bGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3Vy Y2VMb2FkU2NoZWR1bGVyLmNwcApAQCAtNyw2ICs3LDcgQEAKICNpbmNsdWRlICJOZXR3b3JrUHJv Y2Vzc2Nvbm5lY3Rpb25NZXNzYWdlcy5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRQ YXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZGVyLmgiCisjaW5jbHVk ZSAiU3luY1Jlc291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KICNp bmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKQEAgLTY3LDYgKzY4LDI3IEBAIFJlc291cmNl TG9hZElkZW50aWZpZXIgTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2NoZWR1bGVSZXNv dXJjZUxvYWQoY29uc3QKICAgICByZXR1cm4gaWRlbnRpZmllcjsKIH0KIAordm9pZCBOZXR3b3Jr UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzY2hlZHVsZVN5bmNSZXNvdXJjZUxvYWRlcihQYXNzUmVm UHRyPFN5bmNSZXNvdXJjZUxvYWRlcj4gbG9hZGVyKQoreworICAgIC8vIEZJWE1FIChOZXR3b3Jr UHJvY2Vzcyk6IFN5bmMgbG9hZGVycyBuZWVkIHRvIGdldCBpZGVudGlmaWVycyBpbiBhIHNhbmUg d2F5LgorICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllciA9ICsrc19jdXJyZW50 UmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKKyAgICBsb2FkZXItPnNldElkZW50aWZpZXIoaWRlbnRp Zmllcik7CisKKyAgICBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCA9IGxv YWRlci0+bG9hZFBhcmFtZXRlcnMoKS5yZXF1ZXN0KCk7CisKKyAgICBMT0coTmV0d29ya1NjaGVk dWxpbmcsICIoTmV0d29ya1Byb2Nlc3MpIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNj aGVkdWxlU3luY1Jlc291cmNlTG9hZGVyIHN5bmNocm9ub3VzIHJlc291cmNlICclcyciLCByZXNv dXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisKKyAgICBIb3N0UmVj b3JkKiBob3N0ID0gaG9zdEZvclVSTChyZXNvdXJjZVJlcXVlc3QudXJsKCksIENyZWF0ZUlmTm90 Rm91bmQpOworICAgIGJvb2wgaGFkUmVxdWVzdHMgPSBob3N0LT5oYXNSZXF1ZXN0cygpOworICAg IGhvc3QtPnNjaGVkdWxlU3luYyhsb2FkZXIpOworICAgIG1faWRlbnRpZmllcnMuYWRkKGlkZW50 aWZpZXIsIGhvc3QpOworICAgIAorICAgIGlmICghaGFkUmVxdWVzdHMpCisgICAgICAgIHNlcnZl UGVuZGluZ1JlcXVlc3RzRm9ySG9zdChob3N0LCBSZXNvdXJjZUxvYWRQcmlvcml0eUhpZ2hlc3Qp OworCisgICAgc2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOworfQorCiBSZXNvdXJjZUxv YWRJZGVudGlmaWVyIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmFkZExvYWRJblByb2dy ZXNzKGNvbnN0IFdlYkNvcmU6OktVUkwmIHVybCkKIHsKICAgICBSZXNvdXJjZUxvYWRJZGVudGlm aWVyIGlkZW50aWZpZXIgPSArK3NfY3VycmVudFJlc291cmNlTG9hZElkZW50aWZpZXI7CkBAIC0x NzAsNiArMTkyLDI0IEBAIHZvaWQgTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2VydmVQ ZW5kaW5nUmVxdWVzdHNGb3JIb3N0KEhvc3RSZWNvcmQqIGhvc3QsCiB7CiAgICAgTE9HKE5ldHdv cmtTY2hlZHVsaW5nLCAiTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2VydmVQZW5kaW5n UmVxdWVzdHMgSG9zdCBuYW1lPSclcyciLCBob3N0LT5uYW1lKCkudXRmOCgpLmRhdGEoKSk7CiAK KyAgICAvLyBXZSBzZXJ2ZSBzeW5jaHJvbm91cyByZXF1ZXN0cyBiZWZvcmUgYW55IG90aGVyIHJl cXVlc3RzIGFzIGl0IGRvZXNuJ3QgbWFrZSBzZW5zZSB0byBzcGVuZCByZXNvdXJjZXMgcGVyZm9y bWluZworICAgIC8vIGFzeW5jaHJvbm91cyBsb2FkIG9uIGJlaGFsZiBvZiBhIFdlYlByb2Nlc3Mg dGhhdCBpcyB3YWl0aW5nIG9uIGEgc3luY2hyb25vdXMgbG9hZC4KKyAgICBIb3N0UmVjb3JkOjpT eW5jTG9hZGVyUXVldWUmIHN5bmNMb2FkZXJzUGVuZGluZyA9IGhvc3QtPnN5bmNMb2FkZXJzUGVu ZGluZygpOworICAgIHdoaWxlICghc3luY0xvYWRlcnNQZW5kaW5nLmlzRW1wdHkoKSkgeworICAg ICAgICBSZWZQdHI8U3luY1Jlc291cmNlTG9hZGVyPiBsb2FkZXIgPSBzeW5jTG9hZGVyc1BlbmRp bmcuZmlyc3QoKTsKKworICAgICAgICAvLyBGSVhNRSAoTmV0d29ya1Byb2Nlc3MpOiBIb3cgZG8g d2Uga25vdyB0aGlzIHN5bmNocm9ub3VzIGxvYWQgaXNuJ3QgYXNzb2NpYXRlZCB3aXRoIGEgV2Vi UHJvY2VzcworICAgICAgICAvLyB3ZSd2ZSBsb3N0IG91ciBjb25uZWN0aW9uIHRvPworICAgICAg ICBib29sIHNob3VsZExpbWl0UmVxdWVzdHMgPSAhaG9zdC0+bmFtZSgpLmlzTnVsbCgpOworICAg ICAgICBpZiAoc2hvdWxkTGltaXRSZXF1ZXN0cyAmJiBob3N0LT5saW1pdFJlcXVlc3RzKFJlc291 cmNlTG9hZFByaW9yaXR5SGlnaGVzdCwgZmFsc2UpKQorICAgICAgICAgICAgcmV0dXJuOworCisg ICAgICAgIHN5bmNMb2FkZXJzUGVuZGluZy5yZW1vdmVGaXJzdCgpOworICAgICAgICBob3N0LT5h ZGRMb2FkSW5Qcm9ncmVzcyhsb2FkZXItPmlkZW50aWZpZXIoKSk7CisKKyAgICAgICAgbG9hZGVy LT5zdGFydCgpOworICAgIH0KKyAgICAKICAgICBmb3IgKGludCBwcmlvcml0eSA9IFJlc291cmNl TG9hZFByaW9yaXR5SGlnaGVzdDsgcHJpb3JpdHkgPj0gbWluaW11bVByaW9yaXR5OyAtLXByaW9y aXR5KSB7CiAgICAgICAgIEhvc3RSZWNvcmQ6OkxvYWRlclF1ZXVlJiBsb2FkZXJzUGVuZGluZyA9 IGhvc3QtPmxvYWRlcnNQZW5kaW5nKFJlc291cmNlTG9hZFByaW9yaXR5KHByaW9yaXR5KSk7CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJj ZUxvYWRTY2hlZHVsZXIuaCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtS ZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAppbmRleCAwNDc2ZmNjLi42MDNkMzkyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1 bGVyLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNl TG9hZFNjaGVkdWxlci5oCkBAIC0zOSw2ICszOSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogY2xh c3MgSG9zdFJlY29yZDsKIGNsYXNzIE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzOwogY2xh c3MgTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3M7CitjbGFzcyBTeW5jUmVzb3VyY2VMb2Fk ZXI7CiB0eXBlZGVmIHVpbnQ2NF90IFJlc291cmNlTG9hZElkZW50aWZpZXI7CiAKIGNsYXNzIE5l dHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIgewpAQCAtNTAsNiArNTEsOSBAQCBwdWJsaWM6CiAg ICAgLy8gQWRkcyB0aGUgcmVxdWVzdCB0byB0aGUgcXVldWUgZm9yIGl0cyBob3N0IGFuZCBjcmVh dGUgYSB1bmlxdWUgaWRlbnRpZmllciBmb3IgaXQuCiAgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmll ciBzY2hlZHVsZVJlc291cmNlTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVy cyYsIE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzKik7CiAgICAgCisgICAgLy8gQWRkcyBh IHN5bmNocm9ub3VzIHJlcXVzdCB0byB0aGUgc3luY2hyb25vdXMgcmVxdWVzdCBxdWV1ZSBmb3Ig aXRzIGhvc3QuCisgICAgdm9pZCBzY2hlZHVsZVN5bmNSZXNvdXJjZUxvYWRlcihQYXNzUmVmUHRy PFN5bmNSZXNvdXJjZUxvYWRlcj4pOworICAgIAogICAgIC8vIENyZWF0ZXMgYSB1bmlxdWUgaWRl bnRpZmllciBmb3IgYW4gYWxyZWFkeS1pbi1wcm9ncmVzcyBsb2FkLgogICAgIFJlc291cmNlTG9h ZElkZW50aWZpZXIgYWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgV2ViQ29yZTo6S1VSTCYpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9TeW5jUmVzb3VyY2VMb2Fk ZXIuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY1Jlc291cmNlTG9hZGVy LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZTA2YjM4Ci0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY1Jlc291cmNlTG9h ZGVyLmNwcApAQCAtMCwwICsxLDc1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEzIEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycn CisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUwor ICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICog SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIlN5bmNSZXNvdXJjZUxvYWRlci5oIgorCisjaW5jbHVkZSAiRGF0YVJlZmVy ZW5jZS5oIgorI2luY2x1ZGUgIk5ldHdvcmtQcm9jZXNzLmgiCisjaW5jbHVkZSAiUmVtb3RlTmV0 d29ya2luZ0NvbnRleHQuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlRXJyb3IuaD4KKyNp bmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlUmVzcG9uc2UuaD4KKyNpbmNsdWRlIDx3dGYvTWFpblRo cmVhZC5oPgorCisjaWYgRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKKwordXNpbmcgbmFtZXNwYWNl IFdlYkNvcmU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitTeW5jUmVzb3VyY2VMb2FkZXI6OlN5 bmNSZXNvdXJjZUxvYWRlcihjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYgcGFy YW1ldGVycywgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nl c3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4gcmVwbHkpCisgICAgOiBt X25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzKHBhcmFtZXRlcnMpCisgICAgLCBtX2RlbGF5 ZWRSZXBseShyZXBseSkKKyAgICAsIG1faWRlbnRpZmllcigwKQoreworfQorCit2b2lkIFN5bmNS ZXNvdXJjZUxvYWRlcjo6c3RhcnQoKQoreworICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6 IFRoaXMgaXMgY2FsbGVkIG9uIHRoZSBOZXR3b3JrUHJvY2VzcyBtYWluIHRocmVhZCwgYmxvY2tp bmcgYW55IG90aGVyIHJlcXVlc3RzIGZyb20gYmVpbmcgc2NoZWR1bGVkLgorICAgIC8vIFRoaXMg c2hvdWxkIG1vdmUgdG8gYSBiYWNrZ3JvdW5kIHRocmVhZCwgYnV0IHdlJ2QgZWl0aGVyIG5lZWQg dG8gYmUgc3VyZSB0aGF0OgorICAgIC8vICAgQSAtIFJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3Vy Y2VTeW5jaHJvbm91c2x5IGlzIHNhZmUgdG8gcnVuIG9uIGEgYmFja2dyb3VuZCB0aHJlYWQuCisg ICAgLy8gICBCIC0gV3JpdGUgY3VzdG9tIGxvYWRpbmcgbG9naWMgdGhhdCBpcyBrbm93biB0byBi ZSBzYWZlIG9uIGEgYmFja2dyb3VuZCB0aHJlYWQuCisgICAgCisgICAgQVNTRVJUKGlzTWFpblRo cmVhZCgpKTsKKyAgICBBU1NFUlQobV9pZGVudGlmaWVyKTsKKworICAgIFJlc291cmNlRXJyb3Ig ZXJyb3I7CisgICAgUmVzb3VyY2VSZXNwb25zZSByZXNwb25zZTsKKyAgICBWZWN0b3I8Y2hhcj4g ZGF0YTsKKyAgICAKKyAgICAvLyBGSVhNRSAoTmV0d29ya1Byb2Nlc3MpOiBDcmVhdGUgUmVtb3Rl TmV0d29ya2luZ0NvbnRleHQgd2l0aCBhY3R1YWwgc2V0dGluZ3MuCisgICAgUmVmUHRyPFJlbW90 ZU5ldHdvcmtpbmdDb250ZXh0PiBuZXR3b3JraW5nQ29udGV4dCA9IFJlbW90ZU5ldHdvcmtpbmdD b250ZXh0OjpjcmVhdGUoZmFsc2UsIGZhbHNlLCBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0 ZXJzLmluUHJpdmF0ZUJyb3dzaW5nTW9kZSgpKTsKKyAgICAKKyAgICBSZXNvdXJjZUhhbmRsZTo6 bG9hZFJlc291cmNlU3luY2hyb25vdXNseShuZXR3b3JraW5nQ29udGV4dC5nZXQoKSwgbV9uZXR3 b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5yZXF1ZXN0KCksIG1fbmV0d29ya1Jlc291cmNlTG9h ZFBhcmFtZXRlcnMuYWxsb3dTdG9yZWRDcmVkZW50aWFscygpLCBlcnJvciwgcmVzcG9uc2UsIGRh dGEpOworCisgICAgbV9kZWxheWVkUmVwbHktPnNlbmQoZXJyb3IsIHJlc3BvbnNlLCBDb3JlSVBD OjpEYXRhUmVmZXJlbmNlKCh1aW50OF90KilkYXRhLmRhdGEoKSwgZGF0YS5zaXplKCkpKTsKKyAg ICAKKyAgICBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlcigpLnJlbW92ZUxvYWRJZGVudGlmaWVyKG1faWRlbnRpZmllcik7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNSZXNvdXJjZUxvYWRlci5o IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY1Jlc291cmNlTG9hZGVyLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmMwNmNlNwotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNSZXNvdXJjZUxvYWRlci5oCkBA IC0wLDAgKzEsNjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFN5bmNSZXNvdXJjZUxvYWRlcl9o CisjZGVmaW5lIFN5bmNSZXNvdXJjZUxvYWRlcl9oCisKKyNpbmNsdWRlICJOZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzc01lc3NhZ2VzLmgiCisjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9h ZFBhcmFtZXRlcnMuaCIKKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorCisjaWYgRU5BQkxF KE5FVFdPUktfUFJPQ0VTUykKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK3R5cGVkZWYgdWludDY0 X3QgUmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKKworY2xhc3MgU3luY1Jlc291cmNlTG9hZGVyIDog cHVibGljIFJlZkNvdW50ZWQ8U3luY1Jlc291cmNlTG9hZGVyPiB7CitwdWJsaWM6CisgICAgc3Rh dGljIFBhc3NSZWZQdHI8U3luY1Jlc291cmNlTG9hZGVyPiBjcmVhdGUoY29uc3QgTmV0d29ya1Jl c291cmNlTG9hZFBhcmFtZXRlcnMmIHBhcmFtZXRlcnMsIFBhc3NSZWZQdHI8TWVzc2FnZXM6Ok5l dHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxh eWVkUmVwbHk+IHJlcGx5KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTeW5j UmVzb3VyY2VMb2FkZXIocGFyYW1ldGVycywgcmVwbHkpKTsKKyAgICB9CisgICAgCisgICAgdm9p ZCBzZXRJZGVudGlmaWVyKFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllcikgeyBtX2lk ZW50aWZpZXIgPSBpZGVudGlmaWVyOyB9CisgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBpZGVu dGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9CisgICAgCisgICAgY29uc3Qg TmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMmIGxvYWRQYXJhbWV0ZXJzKCkgeyByZXR1cm4g bV9uZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVyczsgfQorCisgICAgdm9pZCBzdGFydCgpOwor Citwcml2YXRlOgorICAgIFN5bmNSZXNvdXJjZUxvYWRlcihjb25zdCBOZXR3b3JrUmVzb3VyY2VM b2FkUGFyYW1ldGVycyYsIFBhc3NSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9X ZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+KTsKKyAgICAK KyAgICBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyBtX25ldHdvcmtSZXNvdXJjZUxvYWRQ YXJhbWV0ZXJzOworICAgIFJlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlBy b2Nlc3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4gbV9kZWxheWVkUmVw bHk7CisgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBtX2lkZW50aWZpZXI7Cit9OworCit9IC8v IG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIEVOQUJMRShORVRXT1JLX1BST0NFU1MpCisK KyNlbmRpZiAvLyBTeW5jUmVzb3VyY2VMb2FkZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvV2ViS2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYktpdDIvV2Vi S2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGIyMTIyMzAuLmIyZThkZjEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oK QEAgLTQ2OCw2ICs0NjgsOCBAQAogCQk1MTc5NTU3MTE2Mjg3N0QyMDBGQTQzQjYgLyogTmV0d29y a1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxQThBNjBGMTYyN0YyQkQwMDBEOTBFOSAvKiBOZXR3b3JrUHJv Y2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oICovOyB9OwogCQk1MTdDRjBFMzE2M0E0ODZDMDBDMjk1 MEUgLyogTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uTWVzc2FnZVJlY2VpdmVyLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxN0NGMEUxMTYzQTQ4NkMw MEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3BwICov OyB9OwogCQk1MTdDRjBFNDE2M0E0ODZDMDBDMjk1MEUgLyogTmV0d29ya1Byb2Nlc3NDb25uZWN0 aW9uTWVzc2FnZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDUxN0NGMEUyMTYzQTQ4NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25N ZXNzYWdlcy5oICovOyB9OworCQk1MTgwRENEMzE2QTRCMTQ2MDA2MjVCREEgLyogU3luY1Jlc291 cmNlTG9hZGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDUxODBEQ0QxMTZBNEIxNDYwMDYyNUJEQSAvKiBTeW5jUmVzb3VyY2VMb2FkZXIuY3BwICov OyB9OworCQk1MTgwRENENDE2QTRCMTQ2MDA2MjVCREEgLyogU3luY1Jlc291cmNlTG9hZGVyLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTgwRENEMjE2 QTRCMTQ2MDA2MjVCREEgLyogU3luY1Jlc291cmNlTG9hZGVyLmggKi87IH07CiAJCTUxODI5REE1 MTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REEzMTYzN0M3 MEMwMDA5NTNENiAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCAqLzsgfTsKIAkJ NTE4MjlEQTYxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REE0 MTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi87IH07 CiAJCTUxODM0NTkyMTM0NTMyRTkwMDkyQjY5NiAvKiBXZWJJY29uRGF0YWJhc2VDbGllbnQuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MzQ1OTAx MzQ1MzJFODAwOTJCNjk2IC8qIFdlYkljb25EYXRhYmFzZUNsaWVudC5jcHAgKi87IH07CkBAIC0x NzMyLDYgKzE3MzQsOCBAQAogCQk1MTdBMzNCNDEzMEIzMDhDMDBGODBDQjUgLyogV0tBcHBsaWNh dGlvbkNhY2hlTWFuYWdlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXS0Fw cGxpY2F0aW9uQ2FjaGVNYW5hZ2VyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUx N0NGMEUxMTYzQTQ4NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdl UmVjZWl2ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV0d29y a1Byb2Nlc3NDb25uZWN0aW9uTWVzc2FnZVJlY2VpdmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNTE3Q0YwRTIxNjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29u bmVjdGlvbk1lc3NhZ2VzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5ldHdv cmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTUxODBEQ0QxMTZBNEIxNDYwMDYyNUJEQSAvKiBTeW5jUmVzb3VyY2VMb2FkZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3luY1Jlc291cmNlTG9hZGVyLmNw cDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNzL1N5bmNSZXNvdXJjZUxvYWRlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxODBEQ0QyMTZBNEIxNDYwMDYyNUJEQSAvKiBTeW5jUmVz b3VyY2VMb2FkZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gU3luY1Jlc291 cmNlTG9hZGVyLmg7IHBhdGggPSBOZXR3b3JrUHJvY2Vzcy9TeW5jUmVzb3VyY2VMb2FkZXIuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlEQTMxNjM3QzcwQzAwMDk1M0Q2IC8q IE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBuYW1lID0gTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5jcHA7IHBhdGggPSBO ZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlEQTQxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtS ZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0g TmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBwYXRoID0gTmV0d29ya1Byb2Nlc3MvTmV0 d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk1MTgzNDU5MDEzNDUzMkU4MDA5MkI2OTYgLyogV2ViSWNvbkRhdGFiYXNlQ2xpZW50LmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdlYkljb25EYXRhYmFzZUNsaWVu dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zMTkzLDYgKzMxOTcsOCBAQAog CQkJCTUxNTcwNTUyMTY1NzAxOEMwMDEwMUE5MCAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkZXIubWVz c2FnZXMuaW4gKi8sCiAJCQkJNTE4MjlEQTMxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXIuY3BwICovLAogCQkJCTUxODI5REE0MTYzN0M3MEMwMDA5NTNENiAv KiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi8sCisJCQkJNTE4MERDRDExNkE0QjE0 NjAwNjI1QkRBIC8qIFN5bmNSZXNvdXJjZUxvYWRlci5jcHAgKi8sCisJCQkJNTE4MERDRDIxNkE0 QjE0NjAwNjI1QkRBIC8qIFN5bmNSZXNvdXJjZUxvYWRlci5oICovLAogCQkJKTsKIAkJCW5hbWUg PSBOZXR3b3JrUHJvY2VzczsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC01MDcwLDYg KzUwNzYsNyBAQAogCQkJCUJDMkU2RThFMTE0MTk3MTUwMEE2M0IxRSAvKiBXb3JrUXVldWUuaCBp biBIZWFkZXJzICovLAogCQkJCUUxNzkwODhGMTY5QkFBNkEwMDY5MDRDNyAvKiBTZWNJdGVtU2hp bS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTE3OTA4OTExNjlCQUE4MjAwNjkwNEM3IC8qIFNlY0l0 ZW1TaGltTWVzc2FnZXMuaCBpbiBIZWFkZXJzICovLAorCQkJCTUxODBEQ0Q0MTZBNEIxNDYwMDYy NUJEQSAvKiBTeW5jUmVzb3VyY2VMb2FkZXIuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1 bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtNjA0OSw2ICs2 MDU2LDcgQEAKIAkJCQlCQzAwOTJGODExNTgzN0EzMDBFMEFFMkEgLyogV29ya1F1ZXVlTWFjLmNw cCBpbiBTb3VyY2VzICovLAogCQkJCUUxNzkwODhEMTY5QkFBNjIwMDY5MDRDNyAvKiBTZWNJdGVt U2hpbS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFMTc5MDg5MDE2OUJBQTdGMDA2OTA0QzcgLyog U2VjSXRlbVNoaW1NZXNzYWdlUmVjZWl2ZXIuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNTE4MERD RDMxNkE0QjE0NjAwNjI1QkRBIC8qIFN5bmNSZXNvdXJjZUxvYWRlci5jcHAgaW4gU291cmNlcyAq LywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJ fTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvTmV0d29yay9XZWJSZXNv dXJjZUxvYWRlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL05ldHdvcmsvV2ViUmVz b3VyY2VMb2FkZXIuY3BwCmluZGV4IDE1ZTAzOTYuLjlkNjExZTIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvTmV0d29yay9XZWJSZXNvdXJjZUxvYWRlci5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9OZXR3b3JrL1dlYlJlc291cmNlTG9hZGVyLmNwcApA QCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJOZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzc01lc3NhZ2VzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nl c3NDb25uZWN0aW9uLmgiCisjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMu aCIKICNpbmNsdWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkZXJNZXNzYWdlcy5oIgogI2luY2x1ZGUg IlBsYXRmb3JtQ2VydGlmaWNhdGVJbmZvLmgiCiAjaW5jbHVkZSAiV2ViQ29yZUFyZ3VtZW50Q29k ZXJzLmgiCkBAIC0xNzcsNiArMTc4LDI2IEBAIHZvaWQgV2ViUmVzb3VyY2VMb2FkZXI6Om5ldHdv cmtQcm9jZXNzQ3Jhc2hlZCgpCiAgICAgbV9jb3JlTG9hZGVyLT5kaWRGYWlsKGludGVybmFsRXJy b3IobV9jb3JlTG9hZGVyLT51cmwoKSkpOwogfQogCitib29sIFdlYlJlc291cmNlTG9hZGVyOjpo YW5kbGVkU3luY2hyb25vdXNMb2FkKE5ldHdvcmtpbmdDb250ZXh0KiBjb250ZXh0LCBjb25zdCBS ZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIFN0b3JlZENyZWRlbnRpYWxzIHN0b3JlZENyZWRlbnRp YWxzLCBSZXNvdXJjZUVycm9yJiBlcnJvciwgUmVzb3VyY2VSZXNwb25zZSYgcmVzcG9uc2UsIFZl Y3RvcjxjaGFyPiYgZGF0YSkKK3sKKyAgICBDb3JlSVBDOjpEYXRhUmVmZXJlbmNlIGRhdGFSZWZl cmVuY2U7CisKKyAgICAvLyBGSVhNRSAoTmV0d29ya1Byb2Nlc3MpOiBHZXQgdGhlIHJpZ2h0IHZh bHVlIGZvciBwcml2YXRlIGJyb3dzaW5nIGVuYWJsZWQKKyAgICBOZXR3b3JrUmVzb3VyY2VMb2Fk UGFyYW1ldGVycyBsb2FkUGFyYW1ldGVycyhyZXF1ZXN0LCBSZXNvdXJjZUxvYWRQcmlvcml0eUhp Z2hlc3QsIFNuaWZmQ29udGVudCwgc3RvcmVkQ3JlZGVudGlhbHMsIGZhbHNlKTsKKyAgICBpZiAo IVdlYlByb2Nlc3M6OnNoYXJlZCgpLm5ldHdvcmtDb25uZWN0aW9uKCktPmNvbm5lY3Rpb24oKS0+ c2VuZFN5bmMoTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3Jt U3luY2hyb25vdXNMb2FkKGxvYWRQYXJhbWV0ZXJzKSwgTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0 aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpSZXBseShlcnJvciwgcmVz cG9uc2UsIGRhdGFSZWZlcmVuY2UpLCAwKSkgeworICAgICAgICByZXNwb25zZSA9IFJlc291cmNl UmVzcG9uc2UoKTsKKyAgICAgICAgZXJyb3IgPSBpbnRlcm5hbEVycm9yKHJlcXVlc3QudXJsKCkp OworICAgICAgICBkYXRhLnJlc2l6ZSgwKTsKKyAgICAgICAgCisgICAgICAgIHJldHVybiB0cnVl OworICAgIH0KKworICAgIGRhdGEucmVzaXplKGRhdGFSZWZlcmVuY2Uuc2l6ZSgpKTsKKyAgICBt ZW1jcHkoZGF0YS5kYXRhKCksIGRhdGFSZWZlcmVuY2UuZGF0YSgpLCBkYXRhUmVmZXJlbmNlLnNp emUoKSk7CisgICAgCisgICAgcmV0dXJuIHRydWU7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktp dAogCiAjZW5kaWYgLy8gRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvTmV0d29yay9XZWJSZXNvdXJjZUxvYWRlci5oIGIvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9OZXR3b3JrL1dlYlJlc291cmNlTG9hZGVyLmgKaW5kZXggNDFj MzMyNi4uZjU0MzM1OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9OZXR3 b3JrL1dlYlJlc291cmNlTG9hZGVyLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9O ZXR3b3JrL1dlYlJlc291cmNlTG9hZGVyLmgKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJN ZXNzYWdlU2VuZGVyLmgiCiAjaW5jbHVkZSAiU2hhcmVhYmxlUmVzb3VyY2UuaCIKICNpbmNsdWRl IDxXZWJDb3JlL0F1dGhlbnRpY2F0aW9uQ2xpZW50Lmg+CisjaW5jbHVkZSA8V2ViQ29yZS9SZXNv dXJjZUhhbmRsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L1JlZkNvdW50ZWQuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC00Miw2ICs0Myw3IEBA IGNsYXNzIERhdGFSZWZlcmVuY2U7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIEF1dGhl bnRpY2F0aW9uQ2hhbGxlbmdlOworY2xhc3MgTmV0d29ya2luZ0NvbnRleHQ7CiBjbGFzcyBQcm90 ZWN0aW9uU3BhY2U7CiBjbGFzcyBSZXNvdXJjZUJ1ZmZlcjsKIGNsYXNzIFJlc291cmNlRXJyb3I7 CkBAIC03Nyw2ICs3OSw4IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgbmV0d29ya1Byb2Nlc3NDcmFz aGVkKCk7CiAKKyAgICBzdGF0aWMgYm9vbCBoYW5kbGVkU3luY2hyb25vdXNMb2FkKFdlYkNvcmU6 Ok5ldHdvcmtpbmdDb250ZXh0KiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgV2Vi Q29yZTo6U3RvcmVkQ3JlZGVudGlhbHMsIFdlYkNvcmU6OlJlc291cmNlRXJyb3ImLCBXZWJDb3Jl OjpSZXNvdXJjZVJlc3BvbnNlJiwgVmVjdG9yPGNoYXI+Jik7CisKIHByaXZhdGU6CiAgICAgV2Vi UmVzb3VyY2VMb2FkZXIoUGFzc1JlZlB0cjxXZWJDb3JlOjpSZXNvdXJjZUxvYWRlcj4pOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L21hYy9X ZWJGcmFtZU5ldHdvcmtpbmdDb250ZXh0LmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L21hYy9XZWJGcmFtZU5ldHdvcmtpbmdDb250ZXh0LmgKaW5kZXggYTkxYzg3 Yi4uMDgzZjhkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3Jl U3VwcG9ydC9tYWMvV2ViRnJhbWVOZXR3b3JraW5nQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvbWFjL1dlYkZyYW1lTmV0d29ya2luZ0NvbnRl eHQuaApAQCAtMzgsNiArMzgsMTAgQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lQ cml2YXRlQnJvd3NpbmdTZXNzaW9uKCk7CiAgICAgc3RhdGljIHZvaWQgc2V0Q29va2llQWNjZXB0 UG9saWN5Rm9yQWxsQ29udGV4dHMoSFRUUENvb2tpZUFjY2VwdFBvbGljeSk7CiAKKyNpZiBFTkFC TEUoTkVUV09SS19QUk9DRVNTKQorICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVkU3luY2hyb25vdXNM b2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIFdlYkNvcmU6OlN0b3JlZENyZWRl bnRpYWxzLCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJiwgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25z ZSYsIFZlY3RvcjxjaGFyPiYpIE9WRVJSSURFOworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgV2Vi RnJhbWVOZXR3b3JraW5nQ29udGV4dChXZWJGcmFtZSogZnJhbWUpCiAgICAgICAgIDogV2ViQ29y ZTo6RnJhbWVOZXR3b3JraW5nQ29udGV4dChmcmFtZS0+Y29yZUZyYW1lKCkpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L21hYy9XZWJGcmFtZU5l dHdvcmtpbmdDb250ZXh0Lm1tIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3Vw cG9ydC9tYWMvV2ViRnJhbWVOZXR3b3JraW5nQ29udGV4dC5tbQppbmRleCA0OGVmOTM3Li5mOTJl MDgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L21hYy9XZWJGcmFtZU5ldHdvcmtpbmdDb250ZXh0Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvbWFjL1dlYkZyYW1lTmV0d29ya2luZ0NvbnRleHQubW0K QEAgLTIxLDYgKzIxLDcgQEAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiV2ViRnJhbWVO ZXR3b3JraW5nQ29udGV4dC5oIgogCisjaW1wb3J0ICJXZWJSZXNvdXJjZUxvYWRlci5oIgogI2lt cG9ydCA8V2ViQ29yZS9GcmFtZUxvYWRlckNsaWVudC5oPgogI2ltcG9ydCA8V2ViQ29yZS9QYWdl Lmg+CiAjaW1wb3J0IDxXZWJDb3JlL1Jlc291cmNlRXJyb3IuaD4KQEAgLTExMiw0ICsxMTMsMTMg QEAgdm9pZCBXZWJGcmFtZU5ldHdvcmtpbmdDb250ZXh0OjpzZXRDb29raWVBY2NlcHRQb2xpY3lG b3JBbGxDb250ZXh0cyhIVFRQQ29va2llQWMKICAgICB9CiB9CiAKKyNpZiBFTkFCTEUoTkVUV09S S19QUk9DRVNTKQorCitib29sIFdlYkZyYW1lTmV0d29ya2luZ0NvbnRleHQ6OmhhbmRsZWRTeW5j aHJvbm91c0xvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBTdG9yZWRDcmVkZW50 aWFscyBzdG9yZWRDcmVkZW50aWFscywgUmVzb3VyY2VFcnJvciYgZXJyb3IsIFJlc291cmNlUmVz cG9uc2UmIHJlc3BvbnNlLCBWZWN0b3I8Y2hhcj4mIGRhdGEpCit7CisgICAgcmV0dXJuIFdlYlJl c291cmNlTG9hZGVyOjpoYW5kbGVkU3luY2hyb25vdXNMb2FkKHRoaXMsIHJlcXVlc3QsIHN0b3Jl ZENyZWRlbnRpYWxzLCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOworfQorCisjZW5kaWYKKwogfQo= 182884 2013-01-15 17:38:40 -0800 2013-01-16 13:56:21 -0800 Patch v2 - Use LoaderStrategy patch text/plain 46604 beidson ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhOTgzNDA5Li5lYmU5Yzk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkg QEAKKzIwMTMtMDEtMTUgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAg ICAgIFN5bmNocm9ub3VzIFhNTEhUVFBSZXF1ZXN0cyBuZWVkIHRvIGdvIHRvIHRoZSBOZXR3b3Jr UHJvY2Vzcy4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzEyOTUxNzY1PiBhbmQgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNjgyNgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoTm8gY2hhbmdlcyB0 byBhbnkgY29uZmlnIHRoYXQgaXMgY3VycmVudGx5IHRlc3RlZCkKKworICAgICAgICAqIGxvYWRl ci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6bG9hZFJl c291cmNlU3luY2hyb25vdXNseSk6IENvbnN1bHQgdGhlIExvYWRlclN0cmF0ZWd5IHdoZW4gc3Ry YXRlZ2llcyBhcmUKKyAgICAgICAgICBiZWluZyB1c2VkLgorCisgICAgICAgICogbG9hZGVyL0xv YWRlclN0cmF0ZWd5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlclN0cmF0ZWd5Ojpsb2Fk UmVzb3VyY2VTeW5jaHJvbm91c2x5KTogRGVmYXVsdHMgdG8gdXNpbmcgUmVzb3VyY2VIYW5kbGUg ZGlyZWN0bHkuCisgICAgICAgICogbG9hZGVyL0xvYWRlclN0cmF0ZWd5Lmg6CisKKyAgICAgICAg QnJlYWsgb3V0IHRoZSBTdG9yZWRDcmVkZW50aWFscyBlbnVtIHRvIGEgbmV3IGhlYWRlcjoKKyAg ICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmg6CisgICAgICAgICogcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZVR5cGVzLmg6CisgICAgICAgICogR05VbWFrZWZp bGUubGlzdC5hbToKKyAgICAgICAgKiBUYXJnZXQucHJpOgorICAgICAgICAqIFdlYkNvcmUuZXhw LmluOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qOgorICAgICAgICAq IFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKwogMjAxMy0wMS0xMSAgUnlvc3Vr ZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBNb3ZlIGZ1bmN0aW9ucyBmcm9t IE5vZGVSYXJlRGF0YSB0byBFbGVtZW50UmFyZURhdGEgYW5kIG90aGVyIGNsYXNzZXMKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29y ZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IGFmNTc0OTcuLmFmYTZlZjUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUv R05VbWFrZWZpbGUubGlzdC5hbQpAQCAtNTgwMyw2ICs1ODAzLDcgQEAgd2ViY29yZV9wbGF0Zm9y bV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl SGFuZGxlLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhh bmRsZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl SW50ZXJuYWwuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhh bmRsZVR5cGVzLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VM b2FkSW5mby5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlTG9h ZFByaW9yaXR5LmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VM b2FkVGltaW5nLmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpIGIv U291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCBiYzE2ODQ3Li5lMzIyMWY1IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisrKyBiL1NvdXJjZS9XZWJDb3JlL1Rhcmdl dC5wcmkKQEAgLTIzMDIsNiArMjMwMiw3IEBAIEhFQURFUlMgKz0gXAogICAgIHBsYXRmb3JtL25l dHdvcmsvcXQvUU5ldHdvcmtSZXBseUhhbmRsZXIuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUVycm9yQmFzZS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl LmggXAorICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVUeXBlcy5oIFwKICAgICBw bGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlTG9hZEluZm8uaCBcCiAgICAgcGxhdGZvcm0vbmV0d29y ay9SZXNvdXJjZUxvYWRQcmlvcml0eS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl TG9hZFRpbWluZy5oIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZXhwLmlu IGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4KaW5kZXggNzk3YTdmMS4uM2M2YjkzOCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4KKysrIGIvU291cmNlL1dl YkNvcmUvV2ViQ29yZS5leHAuaW4KQEAgLTI4NCw2ICsyODQsNyBAQCBfX1pON1dlYkNvcmUxNEZy YW1lU2VsZWN0aW9uNm1vZGlmeUVOUzBfMTFFQWx0ZXJhdGlvbkVOU18xOFNlbGVjdGlvbkRpcmVj dGlvbkVOUwogX19aTjdXZWJDb3JlMTRGcmFtZVNlbGVjdGlvbjlzZWxlY3RBbGxFdgogX19aTjdX ZWJDb3JlMTRGcmFtZVNlbGVjdGlvbkMxRVBOU181RnJhbWVFCiBfX1pON1dlYkNvcmUxNExvYWRl clN0cmF0ZWd5MjFyZXNvdXJjZUxvYWRTY2hlZHVsZXJFdgorX19aTjdXZWJDb3JlMTRMb2FkZXJT dHJhdGVneTI1bG9hZFJlc291cmNlU3luY2hyb25vdXNseUVQTlNfMTdOZXR3b3JraW5nQ29udGV4 dEVSS05TXzE1UmVzb3VyY2VSZXF1ZXN0RU5TXzE3U3RvcmVkQ3JlZGVudGlhbHNFTlNfMTVQcml2 YXRlQnJvd3NpbmdFUk5TXzEzUmVzb3VyY2VFcnJvckVSTlNfMTZSZXNvdXJjZVJlc3BvbnNlRVJO M1dURjZWZWN0b3JJY0xtMEVFRQogX19aTjdXZWJDb3JlMTRQbHVnaW5Eb2N1bWVudDEwcGx1Z2lu Tm9kZUV2CiBfX1pOSzdXZWJDb3JlNUZyYW1lMjV0cmFja2VkUmVwYWludFJlY3RzQXNUZXh0RXYK IF9fWk43V2ViQ29yZTlGcmFtZVZpZXcxN3NldFRyYWNrc1JlcGFpbnRzRWIKQEAgLTI5Nyw2ICsy OTgsNyBAQCBfX1pON1dlYkNvcmUxNFJlc291cmNlQnVmZmVyQzJFdgogX19aTjdXZWJDb3JlMTRS ZXNvdXJjZUJ1ZmZlckQxRXYKIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VCdWZmZXJEMkV2CiBfX1pO N1dlYkNvcmUxNFJlc291cmNlSGFuZGxlMjBmb3JjZUNvbnRlbnRTbmlmZmluZ0V2CitfX1pON1dl YkNvcmUxNFJlc291cmNlSGFuZGxlMjVsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5RVBOU18xN05l dHdvcmtpbmdDb250ZXh0RVJLTlNfMTVSZXNvdXJjZVJlcXVlc3RFTlNfMTdTdG9yZWRDcmVkZW50 aWFsc0VSTlNfMTNSZXNvdXJjZUVycm9yRVJOU18xNlJlc291cmNlUmVzcG9uc2VFUk4zV1RGNlZl Y3RvckljTG0wRUVFCiBfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlMjZzeW5jaHJvbm91c0xv YWRSdW5Mb29wTW9kZUV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNlSGFuZGxlNmNyZWF0ZUVQTlNf MTdOZXR3b3JraW5nQ29udGV4dEVSS05TXzE1UmVzb3VyY2VSZXF1ZXN0RVBOU18yMFJlc291cmNl SGFuZGxlQ2xpZW50RWJiCiBfX1pON1dlYkNvcmUxNFJlc291cmNlTG9hZGVyMTNzZXRJZGVudGlm aWVyRW0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUu dmNwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5k ZXggYTAxNjlhZS4uNDczNmU3YyAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ov V2ViQ29yZS52Y3Byb2oKQEAgLTMyNzI5LDYgKzMyNzI5LDEwIEBACiAJCQkJCT4KIAkJCQk8L0Zp bGU+CiAJCQkJPEZpbGUKKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxwbGF0Zm9ybVxuZXR3b3JrXFJl c291cmNlSGFuZGxlVHlwZXMuaCIKKwkJCQkJPgorCQkJCTwvRmlsZT4KKwkJCQk8RmlsZQogCQkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHBsYXRmb3JtXG5ldHdvcmtcUmVzb3VyY2VIYW5kbGVDbGllbnQu aCIKIAkJCQkJPgogCQkJCTwvRmlsZT4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBjOWE3OTBhLi42NjE0NTMwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIv U291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMjg4 LDggKzEyODgsOCBAQAogCQk0OTQ4NEZDMTEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzR3JhZGll bnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDk0 ODRGQjMxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc0dyYWRpZW50LmNwcCAqLzsgfTsKIAkJNDk0 ODRGQzIxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc0dyYWRpZW50LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OTQ4NEZCNDEwMkNGMjNDMDAxODdERDMg LyogQ2FudmFzR3JhZGllbnQuaCAqLzsgfTsKIAkJNDk0ODRGQzQxMDJDRjIzQzAwMTg3REQzIC8q IENhbnZhc1BhdHRlcm4uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNDk0ODRGQjYxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRlcm4uY3BwICov OyB9OwotCQk0OTQ4NEZDNTEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUGF0dGVybi5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDk0ODRGQjcxMDJDRjIz QzAwMTg3REQzIC8qIENhbnZhc1BhdHRlcm4uaCAqLzsgfTsKIAkJNDk0ODRGQzQxMDJDRjIzQzAw MTg4REQzIC8qIENhbnZhc1Byb3h5LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDQ5NDg0RkI2MTAyQ0YyM0MwMDE4OEREMyAvKiBDYW52YXNQcm94eS5j cHAgKi87IH07CisJCTQ5NDg0RkM1MTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNQYXR0ZXJuLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OTQ4NEZCNzEw MkNGMjNDMDAxODdERDMgLyogQ2FudmFzUGF0dGVybi5oICovOyB9OwogCQk0OTQ4NEZDNTEwMkNG MjNDMDAxODhERDMgLyogQ2FudmFzUHJveHkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQ5NDg0RkI3MTAyQ0YyM0MwMDE4OEREMyAvKiBDYW52YXNQcm94 eS5oICovOyB9OwogCQk0OTQ4NEZDQTEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUmVuZGVyaW5n Q29udGV4dDJELmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDQ5NDg0RkJDMTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQu Y3BwICovOyB9OwogCQk0OTQ4NEZDQjEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUmVuZGVyaW5n Q29udGV4dDJELmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA0OTQ4NEZCRDEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmgg Ki87IH07CkBAIC0xNjIwLDYgKzE2MjAsNyBAQAogCQk1MTc0MUQxMjBCMDcyNTlBMDBFRDQ0MkMg LyogSGlzdG9yeUl0ZW0uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNTE3NDFEMEUwQjA3MjU5QTAwRUQ0NDJDIC8qIEhpc3RvcnlJdGVtLmNwcCAqLzsg fTsKIAkJNTE3NEUyMEExMEExRjQ0RjAwRjk1RTZGIC8qIFBvcFN0YXRlRXZlbnQuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxNzRFMjA4MTBBMUY0NEYw MEY5NUU2RiAvKiBQb3BTdGF0ZUV2ZW50LmggKi87IH07CiAJCTUxN0ZCQTFFMTUxQUIxN0MwMEI1 Nzk1OSAvKiBET01XaW5kb3dFeHRlbnNpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNTE3RkJBMTcxNTFBQTcxQjAwQjU3OTU5IC8qIERPTVdpbmRv d0V4dGVuc2lvbi5jcHAgKi87IH07CisJCTUxODE1QjkzMTZBNUY2RDkwMDU0NTAxRiAvKiBSZXNv dXJjZUhhbmRsZVR5cGVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA1MTgxNUI5MjE2QTVGNkQ5MDA1NDUwMUYgLyogUmVzb3VyY2VIYW5kbGVUeXBlcy5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTUxODlG MDFEMTBCMzdCRDkwMEYzQzczOSAvKiBKU1BvcFN0YXRlRXZlbnQuY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4OUYwMUIxMEIzN0JEOTAwRjNDNzM5 IC8qIEpTUG9wU3RhdGVFdmVudC5jcHAgKi87IH07CiAJCTUxODlGMDFFMTBCMzdCRDkwMEYzQzcz OSAvKiBKU1BvcFN0YXRlRXZlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDUxODlGMDFDMTBCMzdCRDkwMEYzQzczOSAvKiBKU1BvcFN0YXRlRXZlbnQu aCAqLzsgfTsKIAkJNTE4OUYwREUxMEI0NkIwRTAwRjNDNzM5IC8qIFBvcFN0YXRlRXZlbnQuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4OUYwREQx MEI0NkIwRTAwRjNDNzM5IC8qIFBvcFN0YXRlRXZlbnQuY3BwICovOyB9OwpAQCAtMTg1OSw4ICsx ODYwLDggQEAKIAkJNjVERjMyMzkwOUQxREU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzR3JhZGllbnQu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjVERjMy MzMwOUQxREU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzR3JhZGllbnQuY3BwICovOyB9OwogCQk2NURG MzIzQTA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNHcmFkaWVudC5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjVERjMyMzQwOUQxREU2NTAwMEJFMzI1 IC8qIEpTQ2FudmFzR3JhZGllbnQuaCAqLzsgfTsKIAkJNjVERjMyM0IwOUQxREU2NTAwMEJFMzI1 IC8qIEpTQ2FudmFzUGF0dGVybi5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA2NURGMzIzNTA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNQYXR0ZXJu LmNwcCAqLzsgfTsKLQkJNjVERjMyM0MwOUQxREU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzUGF0dGVy bi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjVERjMy MzYwOUQxREU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzUGF0dGVybi5oICovOyB9OwogCQk2NURGMzIz QjA5RDFERTY1MDAxQkUzMjUgLyogSlNDYW52YXNQcm94eS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA2NURGMzIzNTA5RDFERTY1MDAxQkUzMjUgLyog SlNDYW52YXNQcm94eS5jcHAgKi87IH07CisJCTY1REYzMjNDMDlEMURFNjUwMDBCRTMyNSAvKiBK U0NhbnZhc1BhdHRlcm4uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDY1REYzMjM2MDlEMURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4uaCAqLzsg fTsKIAkJNjVERjMyM0MwOUQxREU2NTAwMUJFMzI1IC8qIEpTQ2FudmFzUHJveHkuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDY1REYzMjM2MDlEMURFNjUw MDFCRTMyNSAvKiBKU0NhbnZhc1Byb3h5LmggKi87IH07CiAJCTY1REYzMjYxMDlEMUUxOTkwMDBC RTMyNSAvKiBVc2VyQWdlbnRTdHlsZVNoZWV0c0RhdGEuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNjU2NTgxQUYwOUQxNEVFNjAwMEU2MUQ3IC8qIFVz ZXJBZ2VudFN0eWxlU2hlZXRzRGF0YS5jcHAgKi87IH07CiAJCTY1RTBFOTQ0MTEzM0M4OUYwMEI0 Q0IxMCAvKiBKU0RPTVdyYXBwZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDY1RTBFOTQzMTEzM0M4OUYwMEI0Q0IxMCAvKiBKU0RPTVdyYXBwZXIuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtODU3NSwx MCArODU3NiwxMCBAQAogCQk0OTQ4NEZCNDEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzR3JhZGll bnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQ2FudmFzR3JhZGllbnQuaDsg cGF0aCA9IGNhbnZhcy9DYW52YXNHcmFkaWVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0OTQ4NEZCNTEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzR3JhZGllbnQuaWRsICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gdGV4dDsgbmFtZSA9IENhbnZhc0dyYWRpZW50LmlkbDsgcGF0aCA9IGNhbnZhcy9DYW52 YXNHcmFkaWVudC5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ5NDg0RkI2MTAy Q0YyM0MwMDE4N0REMyAvKiBDYW52YXNQYXR0ZXJuLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgbmFtZSA9IENhbnZhc1BhdHRlcm4uY3BwOyBwYXRoID0gY2FudmFzL0NhbnZhc1Bh dHRlcm4uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk0OTQ4NEZCNzEwMkNGMjND MDAxODdERDMgLyogQ2FudmFzUGF0dGVybi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5h bWUgPSBDYW52YXNQYXR0ZXJuLmg7IHBhdGggPSBjYW52YXMvQ2FudmFzUGF0dGVybi5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk0OTQ4NEZCODEwMkNGMjNDMDAxODdERDMgLyogQ2Fu dmFzUGF0dGVybi5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBuYW1lID0gQ2FudmFzUGF0dGVybi5pZGw7 IHBhdGggPSBjYW52YXMvQ2FudmFzUGF0dGVybi5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTQ5NDg0RkI2MTAyQ0YyM0MwMDE4OEREMyAvKiBDYW52YXNQcm94eS5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBDYW52YXNQcm94eS5jcHA7IHBhdGggPSBj YW52YXMvQ2FudmFzUHJveHkuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0OTQ4 NEZCNzEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUGF0dGVybi5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IG5hbWUgPSBDYW52YXNQYXR0ZXJuLmg7IHBhdGggPSBjYW52YXMvQ2FudmFzUGF0 dGVybi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OTQ4NEZCNzEwMkNGMjNDMDAx ODhERDMgLyogQ2FudmFzUHJveHkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0g Q2FudmFzUHJveHkuaDsgcGF0aCA9IGNhbnZhcy9DYW52YXNQcm94eS5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQk0OTQ4NEZCODEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUGF0dGVy bi5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSB0ZXh0OyBuYW1lID0gQ2FudmFzUGF0dGVybi5pZGw7IHBhdGggPSBj YW52YXMvQ2FudmFzUGF0dGVybi5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ5 NDg0RkI4MTAyQ0YyM0MwMDE4OEREMyAvKiBDYW52YXNQcm94eS5pZGwgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0 OyBuYW1lID0gQ2FudmFzUHJveHkuaWRsOyBwYXRoID0gY2FudmFzL0NhbnZhc1Byb3h5LmlkbDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDk0ODRGQkMxMDJDRjIzQzAwMTg3REQzIC8q IENhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IG5hbWUgPSBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwOyBwYXRoID0gY2FudmFzL0Nh bnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTQ5NDg0RkJEMTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJE Lmg7IHBhdGggPSBjYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CkBAIC04OTM5LDYgKzg5NDAsNyBAQAogCQk1MTc0RTIwQjEwQTFGNDlB MDBGOTVFNkYgLyogUG9wU3RhdGVFdmVudC5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gUG9w U3RhdGVFdmVudC5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxN0ZCQTE3MTUx QUE3MUIwMEI1Nzk1OSAvKiBET01XaW5kb3dFeHRlbnNpb24uY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gRE9NV2luZG93RXh0ZW5zaW9uLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJNTE3RkJBMTgxNTFBQTcxQjAwQjU3OTU5IC8qIERPTVdpbmRvd0V4 dGVuc2lvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBET01XaW5kb3dFeHRl bnNpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNTE4MTVCOTIxNkE1RjZEOTAw NTQ1MDFGIC8qIFJlc291cmNlSGFuZGxlVHlwZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gUmVzb3VyY2VIYW5kbGVUeXBlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk1MTg5RjAxQjEwQjM3QkQ5MDBGM0M3MzkgLyogSlNQb3BTdGF0ZUV2ZW50LmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTUG9wU3RhdGVFdmVudC5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxODlGMDFDMTBCMzdCRDkwMEYzQzczOSAvKiBK U1BvcFN0YXRlRXZlbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNQb3BT dGF0ZUV2ZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxODlGMEREMTBCNDZC MEUwMEYzQzczOSAvKiBQb3BTdGF0ZUV2ZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IFBvcFN0YXRlRXZlbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwpAQCAtOTE5Myw4ICs5MTk1LDggQEAKIAkJNjVERjMyMzMwOUQxREU2NTAwMEJFMzI1IC8qIEpT Q2FudmFzR3JhZGllbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IEpTQ2FudmFzR3JhZGllbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk2NURG MzIzNDA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNHcmFkaWVudC5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gSlNDYW52YXNHcmFkaWVudC5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk2NURGMzIzNTA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNQYXR0ZXJu LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU0NhbnZhc1BhdHRl cm4uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk2NURGMzIzNjA5RDFERTY1MDAw QkUzMjUgLyogSlNDYW52YXNQYXR0ZXJuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBKU0NhbnZhc1BhdHRlcm4uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNjVE RjMyMzUwOUQxREU2NTAwMUJFMzI1IC8qIEpTQ2FudmFzUHJveHkuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTQ2FudmFzUHJveHkuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQk2NURGMzIzNjA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNQYXR0 ZXJuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU0NhbnZhc1BhdHRlcm4u aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNjVERjMyMzYwOUQxREU2NTAwMUJFMzI1 IC8qIEpTQ2FudmFzUHJveHkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpT Q2FudmFzUHJveHkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNjVFMEU5NDMxMTMz Qzg5RjAwQjRDQjEwIC8qIEpTRE9NV3JhcHBlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBKU0RPTVdyYXBwZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNjVG ODA2OTcwNTREOUY4NjAwOEJGNzc2IC8qIEJsb2NrRXhjZXB0aW9ucy5tbSAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgaW5kZW50V2lkdGggPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IEJsb2NrRXhjZXB0 aW9ucy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgdGFiV2lkdGggPSA4OyB1c2VzVGFicyA9 IDA7IH07CkBAIC0xNTkyMiw2ICsxNTkyNCw3IEBACiAJCQkJNTE0Qzc2NjQwQ0U5MjNBMTAwN0VG M0NEIC8qIFJlc291cmNlSGFuZGxlLmggKi8sCiAJCQkJNTE0Qzc2NjUwQ0U5MjNBMTAwN0VGM0NE IC8qIFJlc291cmNlSGFuZGxlQ2xpZW50LmggKi8sCiAJCQkJNTE0Qzc2NjYwQ0U5MjNBMTAwN0VG M0NEIC8qIFJlc291cmNlSGFuZGxlSW50ZXJuYWwuaCAqLywKKwkJCQk1MTgxNUI5MjE2QTVGNkQ5 MDA1NDUwMUYgLyogUmVzb3VyY2VIYW5kbGVUeXBlcy5oICovLAogCQkJCTQ5Mjg2Mzk4MTI1M0I4 RkMwMEY3OTJENiAvKiBSZXNvdXJjZUxvYWRJbmZvLmggKi8sCiAJCQkJRTQyOTVGQTMxMkIwNjE0 RTAwRDFBQ0UwIC8qIFJlc291cmNlTG9hZFByaW9yaXR5LmggKi8sCiAJCQkJODYxQzJFQTUxM0ZC NEZGRjAwMDYyQUJCIC8qIFJlc291cmNlTG9hZFRpbWluZy5jcHAgKi8sCkBAIC0yNjA5OCw2ICsy NjEwMSw3IEBACiAJCQkJRTFCRTUxMkUwQ0Y2QzUxMjAwMkVBOTU5IC8qIFhTTFRVbmljb2RlU29y dC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTc3RTJFMEYxMkYwRkM5QzAwQzEzMzc5IC8qIFhTU0F1 ZGl0b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCUZENTM3MzUzMTM3QjY1MTgwMDAwOERDRSAvKiBa ZXJvUG9sZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJNTE4MTVCOTMxNkE1RjZEOTAwNTQ1MDFGIC8q IFJlc291cmNlSGFuZGxlVHlwZXMuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlci5jcHAKaW5kZXggYjdjMmRmZC4uNDQzNmJmOCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvRnJhbWVMb2FkZXIuY3BwCkBAIC03NiwxMiArNzYsMTQgQEAKICNpbmNsdWRlICJIaXN0b3J5 SXRlbS5oIgogI2luY2x1ZGUgIkluc3BlY3RvckNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJJbnNw ZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKKyNpbmNsdWRlICJMb2FkZXJTdHJhdGVneS5oIgogI2lu Y2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5LmgiCiAjaW5jbHVk ZSAiTWFpblJlc291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgogI2luY2x1ZGUgIlBh Z2VDYWNoZS5oIgogI2luY2x1ZGUgIlBhZ2VUcmFuc2l0aW9uRXZlbnQuaCIKKyNpbmNsdWRlICJQ bGF0Zm9ybVN0cmF0ZWdpZXMuaCIKICNpbmNsdWRlICJQbHVnaW5EYXRhLmgiCiAjaW5jbHVkZSAi UGx1Z2luRGF0YWJhc2UuaCIKICNpbmNsdWRlICJQbHVnaW5Eb2N1bWVudC5oIgpAQCAtMjU4MSw3 ICsyNTgzLDEyIEBAIHVuc2lnbmVkIGxvbmcgRnJhbWVMb2FkZXI6OmxvYWRSZXNvdXJjZVN5bmNo cm9ub3VzbHkoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1CiAgICAgICAgIEFTU0VSVCghbmV3 UmVxdWVzdC5pc051bGwoKSk7CiAgICAgICAgIAogICAgICAgICBpZiAoIWRvY3VtZW50TG9hZGVy KCktPmFwcGxpY2F0aW9uQ2FjaGVIb3N0KCktPm1heWJlTG9hZFN5bmNocm9ub3VzbHkobmV3UmVx dWVzdCwgZXJyb3IsIHJlc3BvbnNlLCBkYXRhKSkgeworI2lmIFVTRShQTEFURk9STV9TVFJBVEVH SUVTKQorICAgICAgICAgICAgUHJpdmF0ZUJyb3dzaW5nIHByaXZhdGVCcm93c2luZyA9IG1fZnJh bWUtPnNldHRpbmdzKCktPnByaXZhdGVCcm93c2luZ0VuYWJsZWQoKSA/IFByaXZhdGVCcm93c2lu Z0VuYWJsZWQgOiBQcml2YXRlQnJvd3NpbmdEaXNhYmxlZDsKKyAgICAgICAgICAgIHBsYXRmb3Jt U3RyYXRlZ2llcygpLT5sb2FkZXJTdHJhdGVneSgpLT5sb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5 KG5ldHdvcmtpbmdDb250ZXh0KCksIG5ld1JlcXVlc3QsIHN0b3JlZENyZWRlbnRpYWxzLCBwcml2 YXRlQnJvd3NpbmcsIGVycm9yLCByZXNwb25zZSwgZGF0YSk7CisjZWxzZQogICAgICAgICAgICAg UmVzb3VyY2VIYW5kbGU6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkobmV0d29ya2luZ0NvbnRl eHQoKSwgbmV3UmVxdWVzdCwgc3RvcmVkQ3JlZGVudGlhbHMsIGVycm9yLCByZXNwb25zZSwgZGF0 YSk7CisjZW5kaWYKICAgICAgICAgICAgIGRvY3VtZW50TG9hZGVyKCktPmFwcGxpY2F0aW9uQ2Fj aGVIb3N0KCktPm1heWJlTG9hZEZhbGxiYWNrU3luY2hyb25vdXNseShuZXdSZXF1ZXN0LCBlcnJv ciwgcmVzcG9uc2UsIGRhdGEpOwogICAgICAgICB9CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9Mb2FkZXJTdHJhdGVneS5jcHAKaW5kZXggMTQwNmVhYS4uNjkzMTQ3MCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvTG9hZGVyU3RyYXRlZ3kuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVk ZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiTG9hZGVyU3RyYXRlZ3kuaCIKIAorI2luY2x1ZGUgIlJl c291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgiCiAKICNp ZiBVU0UoUExBVEZPUk1fU1RSQVRFR0lFUykKQEAgLTM3LDYgKzM4LDExIEBAIFJlc291cmNlTG9h ZFNjaGVkdWxlciogTG9hZGVyU3RyYXRlZ3k6OnJlc291cmNlTG9hZFNjaGVkdWxlcigpCiAgICAg cmV0dXJuIFdlYkNvcmU6OnJlc291cmNlTG9hZFNjaGVkdWxlcigpOwogfQogCit2b2lkIExvYWRl clN0cmF0ZWd5Ojpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KE5ldHdvcmtpbmdDb250ZXh0KiBj b250ZXh0LCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIFN0b3JlZENyZWRlbnRpYWxz IHN0b3JlZENyZWRlbnRpYWxzLCBQcml2YXRlQnJvd3NpbmcsIFJlc291cmNlRXJyb3ImIGVycm9y LCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSwgVmVjdG9yPGNoYXI+JiBkYXRhKQoreworICAg IFJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KGNvbnRleHQsIHJlcXVl c3QsIHN0b3JlZENyZWRlbnRpYWxzLCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOworfQorCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBVU0UoUExBVEZPUk1fU1RSQVRFR0lFUykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Mb2FkZXJTdHJhdGVneS5oIGIvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmgKaW5kZXggZTg3Yzc2Ny4uODNkY2I3 YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmgKKysr IGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmgKQEAgLTI4LDE0ICsyOCwy OCBAQAogCiAjaWYgVVNFKFBMQVRGT1JNX1NUUkFURUdJRVMpCiAKKyNpbmNsdWRlICJSZXNvdXJj ZUhhbmRsZVR5cGVzLmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKK2NsYXNzIE5ldHdvcmtpbmdDb250ZXh0OwogY2xhc3MgUmVzb3VyY2VMb2FkU2No ZWR1bGVyOworY2xhc3MgUmVzb3VyY2VFcnJvcjsKK2NsYXNzIFJlc291cmNlUmVxdWVzdDsKK2Ns YXNzIFJlc291cmNlUmVzcG9uc2U7CisKK2VudW0gUHJpdmF0ZUJyb3dzaW5nIHsKKyAgICBQcml2 YXRlQnJvd3NpbmdEaXNhYmxlZCwKKyAgICBQcml2YXRlQnJvd3NpbmdFbmFibGVkCit9OwogCiBj bGFzcyBMb2FkZXJTdHJhdGVneSB7CiBwdWJsaWM6CiAgICAgdmlydHVhbCBSZXNvdXJjZUxvYWRT Y2hlZHVsZXIqIHJlc291cmNlTG9hZFNjaGVkdWxlcigpOwogCisgICAgdmlydHVhbCB2b2lkIGxv YWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoTmV0d29ya2luZ0NvbnRleHQqLCBjb25zdCBSZXNvdXJj ZVJlcXVlc3QmLCBTdG9yZWRDcmVkZW50aWFscywgUHJpdmF0ZUJyb3dzaW5nLCBSZXNvdXJjZUVy cm9yJiwgUmVzb3VyY2VSZXNwb25zZSYsIFZlY3RvcjxjaGFyPiYgZGF0YSk7CisKIHByb3RlY3Rl ZDoKICAgICB2aXJ0dWFsIH5Mb2FkZXJTdHJhdGVneSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IDQxYmEzODguLjQ5 NDFkMmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl SGFuZGxlLmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkF1dGhlbnRpY2F0aW9uQ2xp ZW50LmgiCiAjaW5jbHVkZSAiSFRUUEhlYWRlck1hcC5oIgorI2luY2x1ZGUgIlJlc291cmNlSGFu ZGxlVHlwZXMuaCIKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KIApAQCAtODgsMTEgKzg5LDYgQEAgY2xhc3MgUmVzb3VyY2VSZXNwb25zZTsKIGNs YXNzIFNjaGVkdWxlUGFpcjsKIGNsYXNzIFNoYXJlZEJ1ZmZlcjsKIAotZW51bSBTdG9yZWRDcmVk ZW50aWFscyB7Ci0gICAgQWxsb3dTdG9yZWRDcmVkZW50aWFscywKLSAgICBEb05vdEFsbG93U3Rv cmVkQ3JlZGVudGlhbHMKLX07Ci0KIHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBUaW1lcjsK IAogY2xhc3MgUmVzb3VyY2VIYW5kbGUgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXNvdXJjZUhhbmRs ZT4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGVUeXBlcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhh bmRsZVR5cGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODcwZTc5NQot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGVUeXBlcy5oCkBAIC0wLDAgKzEsMzggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFJl c291cmNlSGFuZGxlVHlwZXNfaAorI2RlZmluZSBSZXNvdXJjZUhhbmRsZVR5cGVzX2gKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitlbnVtIFN0b3JlZENyZWRlbnRpYWxzIHsKKyAgICBBbGxvd1N0 b3JlZENyZWRlbnRpYWxzLAorICAgIERvTm90QWxsb3dTdG9yZWRDcmVkZW50aWFscworfTsKKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUmVzb3VyY2VIYW5kbGVUeXBlc19o CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cKaW5kZXggMmEzZGJhYy4uNjgwMGUwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQz IEBACisyMDEzLTAxLTE1ICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KKworICAg ICAgICBTeW5jaHJvbm91cyBYTUxIVFRQUmVxdWVzdHMgbmVlZCB0byBnbyB0byB0aGUgTmV0d29y a1Byb2Nlc3MuCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8xMjk1MTc2NT4gYW5kIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDY4MjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBv cnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGxhdGZv cm1TdHJhdGVnaWVzOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KTogRW50cnkgcG9pbnQgZm9y IFdlYkNvcmUgdG8gZ2V0CisgICAgICAgICAgc3luY2hyb25vdXMgcmVxdWVzdHMgdG8gdGhlIE5l dHdvcmtQcm9jZXNzLgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxh dGZvcm1TdHJhdGVnaWVzLmg6CisKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29u bmVjdGlvblRvV2ViUHJvY2Vzcy5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtDb25uZWN0 aW9uVG9XZWJQcm9jZXNzOjpwZXJmb3JtU3luY2hyb25vdXNMb2FkKTogQ3JlYXRlIGEgU3luY05l dHdvcmtSZXNvdXJjZUxvYWRlcgorICAgICAgICAgIGFuZCBzY2hlZHVsZSBpdC4KKyAgICAgICAg KiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oOgorICAgICAg ICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2Vz LmluOgorCisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6 OnNjaGVkdWxlU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcik6CisgICAgICAgIChXZWJLaXQ6Ok5l dHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNlcnZlUGVuZGluZ1JlcXVlc3RzRm9ySG9zdCk6 IFNlcnZlIHN5bmNocm9ub3VzIGxvYWRlcnMKKyAgICAgICAgICBiZWZvcmUgYXN5bmMgbG9hZGVy cy4KKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVy Lmg6CisKKyAgICAgICAgQSBjbGFzcyB0aGF0IGVuY2Fwc3VsYXRlcyBhIHN5bmNocm9ub3VzIGxv YWQgcmVxdWVzdCBhbmQgdGhlIENvcmVJUEMgcmVwbHkgdG8gYmUgbWFkZSBvbmNlIGl0IGlzIGNv bXBsZXRlOgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2Fk ZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6U3luY05ldHdvcmtSZXNvdXJjZUxvYWRl cjo6U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcik6CisgICAgICAgIChXZWJLaXQ6OlN5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXI6OnN0YXJ0KToKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9TeW5j TmV0d29ya1Jlc291cmNlTG9hZGVyLmg6IENvcGllZCBmcm9tIFNvdXJjZS9XZWJLaXQyL05ldHdv cmtQcm9jZXNzL0hvc3RSZWNvcmQuaC4KKyAgICAgICAgKFdlYktpdDo6U3luY05ldHdvcmtSZXNv dXJjZUxvYWRlcjo6Y3JlYXRlKToKKyAgICAgICAgKFdlYktpdDo6U3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlcjo6c2V0SWRlbnRpZmllcik6CisgICAgICAgIChXZWJLaXQ6OlN5bmNOZXR3b3JrUmVz b3VyY2VMb2FkZXI6OmlkZW50aWZpZXIpOgorICAgICAgICAoV2ViS2l0OjpTeW5jTmV0d29ya1Jl c291cmNlTG9hZGVyOjpsb2FkUGFyYW1ldGVycyk6CisKKyAgICAgICAgQWRkIGEgc2Vjb25kIHF1 ZXVlIG9mIHN5bmMgbG9hZGVyczoKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9Ib3N0UmVjb3Jk Lmg6CisgICAgICAgIChXZWJLaXQ6Okhvc3RSZWNvcmQ6OnN5bmNMb2FkZXJzUGVuZGluZyk6CisK KyAgICAgICAgKiBXZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisKIDIwMTMtMDEt MTQgIEh1YW5nIERvbmdzdW5nICA8bHV4dGVsbGFAY29tcGFueTEwMC5uZXQ+CiAKICAgICAgICAg W0VGTF0gUkVHUkVTU0lPTihyMTM5MTg5KTogTWluaUJyb3dzZXIgcmVuZGVycyBhYm5vcm1hbGx5 IHdpdGggLXIgb3B0aW9uLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nl c3MvSG9zdFJlY29yZC5oIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJlY29y ZC5oCmluZGV4IDFiMjEzNzYuLmIyMTllNmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05l dHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJv Y2Vzcy9Ib3N0UmVjb3JkLmgKQEAgLTM2LDYgKzM2LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQgewog CiBjbGFzcyBOZXR3b3JrUmVzb3VyY2VMb2FkZXI7CitjbGFzcyBTeW5jTmV0d29ya1Jlc291cmNl TG9hZGVyOwogdHlwZWRlZiB1aW50NjRfdCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyOwogCiBjbGFz cyBIb3N0UmVjb3JkIHsKQEAgLTU0LDEwICs1NSwxNiBAQCBwdWJsaWM6CiAgICAgdHlwZWRlZiBE ZXF1ZTxSZWZQdHI8TmV0d29ya1Jlc291cmNlTG9hZGVyPiA+IExvYWRlclF1ZXVlOwogICAgIExv YWRlclF1ZXVlJiBsb2FkZXJzUGVuZGluZyhXZWJDb3JlOjpSZXNvdXJjZUxvYWRQcmlvcml0eSBw cmlvcml0eSkgeyByZXR1cm4gbV9sb2FkZXJzUGVuZGluZ1twcmlvcml0eV07IH0KIAorICAgIHR5 cGVkZWYgRGVxdWU8UmVmUHRyPFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI+ID4gU3luY0xvYWRl clF1ZXVlOworICAgIFN5bmNMb2FkZXJRdWV1ZSYgc3luY0xvYWRlcnNQZW5kaW5nKCkgeyByZXR1 cm4gbV9zeW5jTG9hZGVyc1BlbmRpbmc7IH0KKwogcHJpdmF0ZTogICAgICAgICAgICAgICAgICAg IAogICAgIExvYWRlclF1ZXVlIG1fbG9hZGVyc1BlbmRpbmdbV2ViQ29yZTo6UmVzb3VyY2VMb2Fk UHJpb3JpdHlIaWdoZXN0ICsgMV07CiAgICAgdHlwZWRlZiBIYXNoU2V0PFJlc291cmNlTG9hZElk ZW50aWZpZXI+IFJlc291cmNlTG9hZElkZW50aWZpZXJTZXQ7CiAgICAgUmVzb3VyY2VMb2FkSWRl bnRpZmllclNldCBtX3Jlc291cmNlSWRlbnRpZmllcnNMb2FkaW5nOworICAgIAorICAgIFN5bmNM b2FkZXJRdWV1ZSBtX3N5bmNMb2FkZXJzUGVuZGluZzsKKyAgICBIYXNoU2V0PFJlZlB0cjxTeW5j TmV0d29ya1Jlc291cmNlTG9hZGVyPiA+IG1fc3luY0xvYWRlcnNMb2FkaW5nOwogCiAgICAgY29u c3QgU3RyaW5nIG1fbmFtZTsKICAgICBpbnQgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0OwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dl YlByb2Nlc3MuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5l Y3Rpb25Ub1dlYlByb2Nlc3MuY3BwCmluZGV4IDg2NGIxNGIuLjIzNTAxODggMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzcy5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJOZXR3b3Jr UHJvY2Vzcy5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgogI2luY2x1ZGUg IlJlbW90ZU5ldHdvcmtpbmdDb250ZXh0LmgiCisjaW5jbHVkZSAiU3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlci5oIgogI2luY2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1Db29raWVKYXIuaD4KICNpbmNs dWRlIDxXZWJDb3JlL1Jlc291cmNlTG9hZGVyT3B0aW9ucy5oPgogI2luY2x1ZGUgPFdlYkNvcmUv UmVzb3VyY2VSZXF1ZXN0Lmg+CkBAIC0xMjAsNiArMTIxLDExIEBAIHZvaWQgTmV0d29ya0Nvbm5l Y3Rpb25Ub1dlYlByb2Nlc3M6OnNjaGVkdWxlUmVzb3VyY2VMb2FkKGNvbnN0IE5ldHdvcmtSZXNv dXJjZUxvCiAgICAgcmVzb3VyY2VMb2FkSWRlbnRpZmllciA9IE5ldHdvcmtQcm9jZXNzOjpzaGFy ZWQoKS5uZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkuc2NoZWR1bGVSZXNvdXJjZUxvYWQo bG9hZFBhcmFtZXRlcnMsIHRoaXMpOwogfQogCit2b2lkIE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpwZXJmb3JtU3luY2hyb25vdXNMb2FkKGNvbnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQ YXJhbWV0ZXJzJiBsb2FkUGFyYW1ldGVycywgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nv bm5lY3Rpb25Ub1dlYlByb2Nlc3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBs eT4gcmVwbHkpCit7CisgICAgTmV0d29ya1Byb2Nlc3M6OnNoYXJlZCgpLm5ldHdvcmtSZXNvdXJj ZUxvYWRTY2hlZHVsZXIoKS5zY2hlZHVsZVN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIoU3luY05l dHdvcmtSZXNvdXJjZUxvYWRlcjo6Y3JlYXRlKGxvYWRQYXJhbWV0ZXJzLCByZXBseSkpOworfQor CiB2b2lkIE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjphZGRMb2FkSW5Qcm9ncmVzcyhj b25zdCBLVVJMJiB1cmwsIFJlc291cmNlTG9hZElkZW50aWZpZXImIGlkZW50aWZpZXIpCiB7CiAg ICAgaWRlbnRpZmllciA9IE5ldHdvcmtQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3JrUmVzb3VyY2VM b2FkU2NoZWR1bGVyKCkuYWRkTG9hZEluUHJvZ3Jlc3ModXJsKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmgg Yi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJv Y2Vzcy5oCmluZGV4IDUyMzQ0MjQuLjljZTQ0MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmgKKysrIGIvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3Mu aApAQCAtNzYsNiArNzYsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgZGlkUmVjZWl2ZVN5bmNOZXR3 b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzc01lc3NhZ2UoQ29yZUlQQzo6Q29ubmVjdGlvbiosIENv cmVJUEM6Ok1lc3NhZ2VJRCwgQ29yZUlQQzo6TWVzc2FnZURlY29kZXImLCBPd25QdHI8Q29yZUlQ Qzo6TWVzc2FnZUVuY29kZXI+Jik7CiAgICAgCiAgICAgdm9pZCBzY2hlZHVsZVJlc291cmNlTG9h ZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYsIFJlc291cmNlTG9hZElkZW50 aWZpZXImKTsKKyAgICB2b2lkIHBlcmZvcm1TeW5jaHJvbm91c0xvYWQoY29uc3QgTmV0d29ya1Jl c291cmNlTG9hZFBhcmFtZXRlcnMmLCBQYXNzUmVmUHRyPE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6RGVsYXllZFJlcGx5Pik7 CisKICAgICB2b2lkIGFkZExvYWRJblByb2dyZXNzKGNvbnN0IFdlYkNvcmU6OktVUkwmLCBSZXNv dXJjZUxvYWRJZGVudGlmaWVyJik7CiAgICAgdm9pZCByZW1vdmVMb2FkSWRlbnRpZmllcihSZXNv dXJjZUxvYWRJZGVudGlmaWVyKTsKICAgICB2b2lkIGNyb3NzT3JpZ2luUmVkaXJlY3RSZWNlaXZl ZChSZXNvdXJjZUxvYWRJZGVudGlmaWVyLCBjb25zdCBXZWJDb3JlOjpLVVJMJiByZWRpcmVjdFVS TCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29u bmVjdGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2VzLmluCmluZGV4IGY1 NzZjOWUuLjU1ZDkxZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNz L05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9X ZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLm1lc3Nh Z2VzLmluCkBAIC0yOSw2ICsyOSw3IEBAIG1lc3NhZ2VzIC0+IE5ldHdvcmtDb25uZWN0aW9uVG9X ZWJQcm9jZXNzIHsKICAgICAvLyBUaGVyZSdzIHBvc3NpYmxlIFJlc291cmNlTG9hZGVyIGlkZW50 aWZpZXIgcmVmYWN0b3JpbmcgdGhhdCBjYW4gcmVtb3ZlIHRoYXQgcmVxdWlyZW1lbnQuCiAgICAg Ly8gV2UgbWlnaHQgYWxzbyBoYXZlIHRoZSBOZXR3b3JrUHJvY2VzcyBkaXZ2eSB1cCBpZGVudGlm aWVycyBpbiBibG9ja3MgdG8gZWFjaCBXZWJQcm9jZXNzIGJlZm9yZWhhbmQuCiAgICAgU2NoZWR1 bGVSZXNvdXJjZUxvYWQoV2ViS2l0OjpOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyByZXNv dXJjZUxvYWRQYXJhbWV0ZXJzKSAtPiAodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikK KyAgICBQZXJmb3JtU3luY2hyb25vdXNMb2FkKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFBh cmFtZXRlcnMgcmVzb3VyY2VMb2FkUGFyYW1ldGVycykgLT4gKFdlYkNvcmU6OlJlc291cmNlRXJy b3IgZXJyb3IsIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgcmVzcG9uc2UsIENvcmVJUEM6OkRh dGFSZWZlcmVuY2UgZGF0YSkgRGVsYXllZAogICAgIEFkZExvYWRJblByb2dyZXNzKFdlYkNvcmU6 OktVUkwgdXJsKSAtPiAodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikKICAgICBSZW1v dmVMb2FkSWRlbnRpZmllcih1aW50NjRfdCByZXNvdXJjZUxvYWRJZGVudGlmaWVyKQogICAgIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNl TG9hZFNjaGVkdWxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3Jr UmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcAppbmRleCBkMzc4YjgxLi44Zjc5YmNjIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2No ZWR1bGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmNwcApAQCAtNyw2ICs3LDcgQEAKICNpbmNsdWRlICJOZXR3b3Jr UHJvY2Vzc2Nvbm5lY3Rpb25NZXNzYWdlcy5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxv YWRQYXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZGVyLmgiCisjaW5j bHVkZSAiU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhy ZWFkLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgogCkBAIC02Nyw2ICs2OCwyNyBA QCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNj aGVkdWxlUmVzb3VyY2VMb2FkKGNvbnN0CiAgICAgcmV0dXJuIGlkZW50aWZpZXI7CiB9CiAKK3Zv aWQgTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2NoZWR1bGVTeW5jTmV0d29ya1Jlc291 cmNlTG9hZGVyKFBhc3NSZWZQdHI8U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcj4gbG9hZGVyKQor eworICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IFN5bmMgbG9hZGVycyBuZWVkIHRvIGdl dCBpZGVudGlmaWVycyBpbiBhIHNhbmUgd2F5LgorICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIg aWRlbnRpZmllciA9ICsrc19jdXJyZW50UmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKKyAgICBsb2Fk ZXItPnNldElkZW50aWZpZXIoaWRlbnRpZmllcik7CisKKyAgICBjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlc291cmNlUmVxdWVzdCA9IGxvYWRlci0+bG9hZFBhcmFtZXRlcnMoKS5yZXF1ZXN0KCk7 CisKKyAgICBMT0coTmV0d29ya1NjaGVkdWxpbmcsICIoTmV0d29ya1Byb2Nlc3MpIE5ldHdvcmtS ZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNjaGVkdWxlU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlciBz eW5jaHJvbm91cyByZXNvdXJjZSAnJXMnIiwgcmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygp LnV0ZjgoKS5kYXRhKCkpOworCisgICAgSG9zdFJlY29yZCogaG9zdCA9IGhvc3RGb3JVUkwocmVz b3VyY2VSZXF1ZXN0LnVybCgpLCBDcmVhdGVJZk5vdEZvdW5kKTsKKyAgICBib29sIGhhZFJlcXVl c3RzID0gaG9zdC0+aGFzUmVxdWVzdHMoKTsKKyAgICBob3N0LT5zeW5jTG9hZGVyc1BlbmRpbmco KS5hcHBlbmQobG9hZGVyKTsKKyAgICBtX2lkZW50aWZpZXJzLmFkZChpZGVudGlmaWVyLCBob3N0 KTsKKyAgICAKKyAgICBpZiAoIWhhZFJlcXVlc3RzKQorICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1 ZXN0c0Zvckhvc3QoaG9zdCwgUmVzb3VyY2VMb2FkUHJpb3JpdHlIaWdoZXN0KTsKKworICAgIHNj aGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKK30KKwogUmVzb3VyY2VMb2FkSWRlbnRpZmll ciBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjphZGRMb2FkSW5Qcm9ncmVzcyhjb25zdCBX ZWJDb3JlOjpLVVJMJiB1cmwpCiB7CiAgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBpZGVudGlm aWVyID0gKytzX2N1cnJlbnRSZXNvdXJjZUxvYWRJZGVudGlmaWVyOwpAQCAtMTcwLDYgKzE5Miwy NCBAQCB2b2lkIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNlcnZlUGVuZGluZ1JlcXVl c3RzRm9ySG9zdChIb3N0UmVjb3JkKiBob3N0LAogewogICAgIExPRyhOZXR3b3JrU2NoZWR1bGlu ZywgIk5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNlcnZlUGVuZGluZ1JlcXVlc3RzIEhv c3QgbmFtZT0nJXMnIiwgaG9zdC0+bmFtZSgpLnV0ZjgoKS5kYXRhKCkpOwogCisgICAgLy8gV2Ug c2VydmUgc3luY2hyb25vdXMgcmVxdWVzdHMgYmVmb3JlIGFueSBvdGhlciByZXF1ZXN0cyB0byBp bXByb3ZlIHJlc3BvbnNpdmVuZXNzIGluIGFueQorICAgIC8vIFdlYlByb2Nlc3MgdGhhdCBpcyB3 YWl0aW5nIG9uIGEgc3luY2hyb25vdXMgbG9hZC4KKyAgICBIb3N0UmVjb3JkOjpTeW5jTG9hZGVy UXVldWUmIHN5bmNMb2FkZXJzUGVuZGluZyA9IGhvc3QtPnN5bmNMb2FkZXJzUGVuZGluZygpOwor ICAgIHdoaWxlICghc3luY0xvYWRlcnNQZW5kaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBSZWZQ dHI8U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcj4gbG9hZGVyID0gc3luY0xvYWRlcnNQZW5kaW5n LmZpcnN0KCk7CisKKyAgICAgICAgLy8gRklYTUUgKE5ldHdvcmtQcm9jZXNzKTogSG93IGRvIHdl IGtub3cgdGhpcyBzeW5jaHJvbm91cyBsb2FkIGlzbid0IGFzc29jaWF0ZWQgd2l0aCBhIFdlYlBy b2Nlc3MKKyAgICAgICAgLy8gd2UndmUgbG9zdCBvdXIgY29ubmVjdGlvbiB0bz8KKyAgICAgICAg Ym9vbCBzaG91bGRMaW1pdFJlcXVlc3RzID0gIWhvc3QtPm5hbWUoKS5pc051bGwoKTsKKyAgICAg ICAgaWYgKHNob3VsZExpbWl0UmVxdWVzdHMgJiYgaG9zdC0+bGltaXRSZXF1ZXN0cyhSZXNvdXJj ZUxvYWRQcmlvcml0eUhpZ2hlc3QsIGZhbHNlKSkKKyAgICAgICAgICAgIHJldHVybjsKKworICAg ICAgICBzeW5jTG9hZGVyc1BlbmRpbmcucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAgaG9zdC0+YWRk TG9hZEluUHJvZ3Jlc3MobG9hZGVyLT5pZGVudGlmaWVyKCkpOworCisgICAgICAgIGxvYWRlci0+ c3RhcnQoKTsKKyAgICB9CisgICAgCiAgICAgZm9yIChpbnQgcHJpb3JpdHkgPSBSZXNvdXJjZUxv YWRQcmlvcml0eUhpZ2hlc3Q7IHByaW9yaXR5ID49IG1pbmltdW1Qcmlvcml0eTsgLS1wcmlvcml0 eSkgewogICAgICAgICBIb3N0UmVjb3JkOjpMb2FkZXJRdWV1ZSYgbG9hZGVyc1BlbmRpbmcgPSBo b3N0LT5sb2FkZXJzUGVuZGluZyhSZXNvdXJjZUxvYWRQcmlvcml0eShwcmlvcml0eSkpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VM b2FkU2NoZWR1bGVyLmggYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmgKaW5kZXggMDQ3NmZjYy4uY2Q1NGE3OSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxl ci5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxv YWRTY2hlZHVsZXIuaApAQCAtMzksNiArMzksNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIGNsYXNz IEhvc3RSZWNvcmQ7CiBjbGFzcyBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVyczsKIGNsYXNz IE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOworY2xhc3MgU3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlcjsKIHR5cGVkZWYgdWludDY0X3QgUmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKIAogY2xh c3MgTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlciB7CkBAIC01MCw2ICs1MSw5IEBAIHB1Ymxp YzoKICAgICAvLyBBZGRzIHRoZSByZXF1ZXN0IHRvIHRoZSBxdWV1ZSBmb3IgaXRzIGhvc3QgYW5k IGNyZWF0ZSBhIHVuaXF1ZSBpZGVudGlmaWVyIGZvciBpdC4KICAgICBSZXNvdXJjZUxvYWRJZGVu dGlmaWVyIHNjaGVkdWxlUmVzb3VyY2VMb2FkKGNvbnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJh bWV0ZXJzJiwgTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MqKTsKICAgICAKKyAgICAvLyBB ZGRzIGEgc3luY2hyb25vdXMgcmVxdXN0IHRvIHRoZSBzeW5jaHJvbm91cyByZXF1ZXN0IHF1ZXVl IGZvciBpdHMgaG9zdC4KKyAgICB2b2lkIHNjaGVkdWxlU3luY05ldHdvcmtSZXNvdXJjZUxvYWRl cihQYXNzUmVmUHRyPFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI+KTsKKyAgICAKICAgICAvLyBD cmVhdGVzIGEgdW5pcXVlIGlkZW50aWZpZXIgZm9yIGFuIGFscmVhZHktaW4tcHJvZ3Jlc3MgbG9h ZC4KICAgICBSZXNvdXJjZUxvYWRJZGVudGlmaWVyIGFkZExvYWRJblByb2dyZXNzKGNvbnN0IFdl YkNvcmU6OktVUkwmKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nl c3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3Jr UHJvY2Vzcy9TeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi4zZGUyM2UxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktp dDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHAKQEAgLTAsMCAr MSw3NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMyBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6Cisg KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBB UFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IK KyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisg KiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTeW5j TmV0d29ya1Jlc291cmNlTG9hZGVyLmgiCisKKyNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQor CisjaW5jbHVkZSAiRGF0YVJlZmVyZW5jZS5oIgorI2luY2x1ZGUgIk5ldHdvcmtQcm9jZXNzLmgi CisjaW5jbHVkZSAiUmVtb3RlTmV0d29ya2luZ0NvbnRleHQuaCIKKyNpbmNsdWRlIDxXZWJDb3Jl L1Jlc291cmNlRXJyb3IuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlUmVzcG9uc2UuaD4K KyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsK KworbmFtZXNwYWNlIFdlYktpdCB7CisKK1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OlN5bmNO ZXR3b3JrUmVzb3VyY2VMb2FkZXIoY29uc3QgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMm IHBhcmFtZXRlcnMsIFBhc3NSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+IHJlcGx5KQorICAg IDogbV9uZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyhwYXJhbWV0ZXJzKQorICAgICwgbV9k ZWxheWVkUmVwbHkocmVwbHkpCisgICAgLCBtX2lkZW50aWZpZXIoMCkKK3sKK30KKwordm9pZCBT eW5jTmV0d29ya1Jlc291cmNlTG9hZGVyOjpzdGFydCgpCit7CisgICAgLy8gRklYTUUgKE5ldHdv cmtQcm9jZXNzKTogVGhpcyBpcyBjYWxsZWQgb24gdGhlIE5ldHdvcmtQcm9jZXNzIG1haW4gdGhy ZWFkLCBibG9ja2luZyBhbnkgb3RoZXIgcmVxdWVzdHMgZnJvbSBiZWluZyBzY2hlZHVsZWQuCisg ICAgLy8gVGhpcyBzaG91bGQgbW92ZSB0byBhIGJhY2tncm91bmQgdGhyZWFkLCBidXQgd2UnZCBl aXRoZXIgbmVlZCB0byBiZSBzdXJlIHRoYXQ6CisgICAgLy8gICBBIC0gUmVzb3VyY2VIYW5kbGU6 OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkgaXMgc2FmZSB0byBydW4gb24gYSBiYWNrZ3JvdW5k IHRocmVhZC4KKyAgICAvLyAgIEIgLSBXcml0ZSBjdXN0b20gbG9hZGluZyBsb2dpYyB0aGF0IGlz IGtub3duIHRvIGJlIHNhZmUgb24gYSBiYWNrZ3JvdW5kIHRocmVhZC4KKyAgICAKKyAgICBBU1NF UlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChtX2lkZW50aWZpZXIpOworCisgICAgUmVz b3VyY2VFcnJvciBlcnJvcjsKKyAgICBSZXNvdXJjZVJlc3BvbnNlIHJlc3BvbnNlOworICAgIFZl Y3RvcjxjaGFyPiBkYXRhOworICAgIAorICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IENy ZWF0ZSBSZW1vdGVOZXR3b3JraW5nQ29udGV4dCB3aXRoIGFjdHVhbCBzZXR0aW5ncy4KKyAgICBS ZWZQdHI8UmVtb3RlTmV0d29ya2luZ0NvbnRleHQ+IG5ldHdvcmtpbmdDb250ZXh0ID0gUmVtb3Rl TmV0d29ya2luZ0NvbnRleHQ6OmNyZWF0ZShmYWxzZSwgZmFsc2UsIG1fbmV0d29ya1Jlc291cmNl TG9hZFBhcmFtZXRlcnMuaW5Qcml2YXRlQnJvd3NpbmdNb2RlKCkpOworICAgIAorICAgIFJlc291 cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KG5ldHdvcmtpbmdDb250ZXh0Lmdl dCgpLCBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzLnJlcXVlc3QoKSwgbV9uZXR3b3Jr UmVzb3VyY2VMb2FkUGFyYW1ldGVycy5hbGxvd1N0b3JlZENyZWRlbnRpYWxzKCksIGVycm9yLCBy ZXNwb25zZSwgZGF0YSk7CisKKyAgICBtX2RlbGF5ZWRSZXBseS0+c2VuZChlcnJvciwgcmVzcG9u c2UsIENvcmVJUEM6OkRhdGFSZWZlcmVuY2UoKHVpbnQ4X3QqKWRhdGEuZGF0YSgpLCBkYXRhLnNp emUoKSkpOworICAgIAorICAgIE5ldHdvcmtQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3JrUmVzb3Vy Y2VMb2FkU2NoZWR1bGVyKCkucmVtb3ZlTG9hZElkZW50aWZpZXIobV9pZGVudGlmaWVyKTsKK30K KworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAvLyBFTkFCTEUoTkVUV09SS19QUk9D RVNTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdv cmtSZXNvdXJjZUxvYWRlci5oIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05l dHdvcmtSZXNvdXJjZUxvYWRlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu Ljc0MmFlOGUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9TeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmgKQEAgLTAsMCArMSw2NSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMg Q09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS CisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisg KiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQor ICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpZm5kZWYgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcl9oCisjZGVmaW5lIFN5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXJfaAorCisjaW5jbHVkZSAiTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlBy b2Nlc3NNZXNzYWdlcy5oIgorI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJz LmgiCisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKworI2lmIEVOQUJMRShORVRXT1JLX1BS T0NFU1MpCisKK25hbWVzcGFjZSBXZWJLaXQgeworCit0eXBlZGVmIHVpbnQ2NF90IFJlc291cmNl TG9hZElkZW50aWZpZXI7CisKK2NsYXNzIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIgOiBwdWJs aWMgUmVmQ291bnRlZDxTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyPiB7CitwdWJsaWM6CisgICAg c3RhdGljIFBhc3NSZWZQdHI8U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcj4gY3JlYXRlKGNvbnN0 IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzJiBwYXJhbWV0ZXJzLCBQYXNzUmVmUHRyPE1l c3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3Vz TG9hZDo6RGVsYXllZFJlcGx5PiByZXBseSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJl ZihuZXcgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcihwYXJhbWV0ZXJzLCByZXBseSkpOworICAg IH0KKyAgICAKKyAgICB2b2lkIHNldElkZW50aWZpZXIoUmVzb3VyY2VMb2FkSWRlbnRpZmllciBp ZGVudGlmaWVyKSB7IG1faWRlbnRpZmllciA9IGlkZW50aWZpZXI7IH0KKyAgICBSZXNvdXJjZUxv YWRJZGVudGlmaWVyIGlkZW50aWZpZXIoKSBjb25zdCB7IHJldHVybiBtX2lkZW50aWZpZXI7IH0K KyAgICAKKyAgICBjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYgbG9hZFBhcmFt ZXRlcnMoKSB7IHJldHVybiBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzOyB9CisKKyAg ICB2b2lkIHN0YXJ0KCk7CisKK3ByaXZhdGU6CisgICAgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRl cihjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYsIFBhc3NSZWZQdHI8TWVzc2Fn ZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2Fk OjpEZWxheWVkUmVwbHk+KTsKKyAgICAKKyAgICBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVy cyBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzOworICAgIFJlZlB0cjxNZXNzYWdlczo6 TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRl bGF5ZWRSZXBseT4gbV9kZWxheWVkUmVwbHk7CisgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBt X2lkZW50aWZpZXI7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIEVO QUJMRShORVRXT1JLX1BST0NFU1MpCisKKyNlbmRpZiAvLyBTeW5jTmV0d29ya1Jlc291cmNlTG9h ZGVyX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagppbmRleCBiMjEyMjMwLi5kMzQ5NDdmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYktpdDIvV2Vi S2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00NjgsNiArNDY4LDggQEAKIAkJNTE3 OTU1NzExNjI4NzdEMjAwRkE0M0I2IC8qIE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MUE4QTYw RjE2MjdGMkJEMDAwRDkwRTkgLyogTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCAq LzsgfTsKIAkJNTE3Q0YwRTMxNjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVj dGlvbk1lc3NhZ2VSZWNlaXZlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MTdDRjBFMTE2M0E0ODZDMDBDMjk1MEUgLyogTmV0d29ya1Byb2Nlc3ND b25uZWN0aW9uTWVzc2FnZVJlY2VpdmVyLmNwcCAqLzsgfTsKIAkJNTE3Q0YwRTQxNjNBNDg2QzAw QzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTdDRjBFMjE2M0E0ODZDMDBDMjk1 MEUgLyogTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uTWVzc2FnZXMuaCAqLzsgfTsKKwkJNTE4MTVC OUYxNkE2MjIyMTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MTVCOUQxNkE2MjIy MTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwICovOyB9OworCQk1MTgx NUJBMDE2QTYyMjIxMDA1NDUwMUYgLyogU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MTVCOUUxNkE2MjIy MTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCAqLzsgfTsKIAkJNTE4MjlE QTUxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MjlEQTMxNjM3 QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICovOyB9Owog CQk1MTgyOURBNjE2MzdDNzBDMDAwOTUzRDYgLyogTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxl ci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MjlE QTQxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCAqLzsg fTsKIAkJNTE4MzQ1OTIxMzQ1MzJFOTAwOTJCNjk2IC8qIFdlYkljb25EYXRhYmFzZUNsaWVudC5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTgzNDU5 MDEzNDUzMkU4MDA5MkI2OTYgLyogV2ViSWNvbkRhdGFiYXNlQ2xpZW50LmNwcCAqLzsgfTsKQEAg LTE3MzIsNiArMTczNCw4IEBACiAJCTUxN0EzM0I0MTMwQjMwOEMwMEY4MENCNSAvKiBXS0FwcGxp Y2F0aW9uQ2FjaGVNYW5hZ2VyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdL QXBwbGljYXRpb25DYWNoZU1hbmFnZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NTE3Q0YwRTExNjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3Nh Z2VSZWNlaXZlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBOZXR3 b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk1MTdDRjBFMjE2M0E0ODZDMDBDMjk1MEUgLyogTmV0d29ya1Byb2Nlc3ND b25uZWN0aW9uTWVzc2FnZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTmV0 d29ya1Byb2Nlc3NDb25uZWN0aW9uTWVzc2FnZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJNTE4MTVCOUQxNkE2MjIyMTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2Fk ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3luY05ldHdvcmtS ZXNvdXJjZUxvYWRlci5jcHA7IHBhdGggPSBOZXR3b3JrUHJvY2Vzcy9TeW5jTmV0d29ya1Jlc291 cmNlTG9hZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNTE4MTVCOUUxNkE2 MjIyMTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBuYW1lID0gU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5oOyBwYXRoID0g TmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk1MTgyOURBMzE2MzdDNzBDMDAwOTUzRDYgLyogTmV0d29ya1Jlc291 cmNlTG9hZFNjaGVkdWxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUg PSBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNz L05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk1MTgyOURBNDE2MzdDNzBDMDAwOTUzRDYgLyogTmV0d29ya1Jlc291cmNlTG9hZFNj aGVkdWxlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBOZXR3b3JrUmVzb3Vy Y2VMb2FkU2NoZWR1bGVyLmg7IHBhdGggPSBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VM b2FkU2NoZWR1bGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxODM0NTkwMTM0 NTMyRTgwMDkyQjY5NiAvKiBXZWJJY29uRGF0YWJhc2VDbGllbnQuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2ViSWNvbkRhdGFiYXNlQ2xpZW50LmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTMxOTMsNiArMzE5Nyw4IEBACiAJCQkJNTE1NzA1NTIx NjU3MDE4QzAwMTAxQTkwIC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRlci5tZXNzYWdlcy5pbiAqLywK IAkJCQk1MTgyOURBMzE2MzdDNzBDMDAwOTUzRDYgLyogTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5jcHAgKi8sCiAJCQkJNTE4MjlEQTQxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXIuaCAqLywKKwkJCQk1MTgxNUI5RDE2QTYyMjIxMDA1NDUwMUYgLyog U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHAgKi8sCisJCQkJNTE4MTVCOUUxNkE2MjIyMTAw NTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCAqLywKIAkJCSk7CiAJCQluYW1l ID0gTmV0d29ya1Byb2Nlc3M7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpAQCAtNTA3MCw2 ICs1MDc2LDcgQEAKIAkJCQlCQzJFNkU4RTExNDE5NzE1MDBBNjNCMUUgLyogV29ya1F1ZXVlLmgg aW4gSGVhZGVycyAqLywKIAkJCQlFMTc5MDg4RjE2OUJBQTZBMDA2OTA0QzcgLyogU2VjSXRlbVNo aW0uaCBpbiBIZWFkZXJzICovLAogCQkJCUUxNzkwODkxMTY5QkFBODIwMDY5MDRDNyAvKiBTZWNJ dGVtU2hpbU1lc3NhZ2VzLmggaW4gSGVhZGVycyAqLywKKwkJCQk1MTgxNUJBMDE2QTYyMjIxMDA1 NDUwMUYgLyogU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkp OwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC02 MDQ5LDYgKzYwNTYsNyBAQAogCQkJCUJDMDA5MkY4MTE1ODM3QTMwMEUwQUUyQSAvKiBXb3JrUXVl dWVNYWMuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTE3OTA4OEQxNjlCQUE2MjAwNjkwNEM3IC8q IFNlY0l0ZW1TaGltLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUUxNzkwODkwMTY5QkFBN0YwMDY5 MDRDNyAvKiBTZWNJdGVtU2hpbU1lc3NhZ2VSZWNlaXZlci5jcHAgaW4gU291cmNlcyAqLywKKwkJ CQk1MTgxNUI5RjE2QTYyMjIxMDA1NDUwMUYgLyogU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5j cHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9j ZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv V2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcCBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAppbmRl eCA5ZGM0OGM1Li4xMzIxMjVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAKKysrIGIvU291cmNlL1dl YktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3Bw CkBAIC0yOSwxMCArMjksMTMgQEAKICNpZiBVU0UoUExBVEZPUk1fU1RSQVRFR0lFUykKIAogI2lu Y2x1ZGUgIkJsb2NraW5nUmVzcG9uc2VNYXAuaCIKKyNpbmNsdWRlICJEYXRhUmVmZXJlbmNlLmgi CisjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMuaCIKICNpbmNsdWRlICJQ bHVnaW5JbmZvU3RvcmUuaCIKICNpbmNsdWRlICJXZWJDb250ZXh0TWVzc2FnZXMuaCIKICNpbmNs dWRlICJXZWJDb29raWVNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiV2ViQ29yZUFyZ3VtZW50Q29kZXJz LmgiCisjaW5jbHVkZSAiV2ViRXJyb3JzLmgiCiAjaW5jbHVkZSAiV2ViUHJvY2Vzcy5oIgogI2lu Y2x1ZGUgIldlYlByb2Nlc3NQcm94eU1lc3NhZ2VzLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9Db2xv ci5oPgpAQCAtNDIsNiArNDUsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvUGFnZS5oPgogI2luY2x1 ZGUgPFdlYkNvcmUvUGxhdGZvcm1Db29raWVKYXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BsYXRm b3JtUGFzdGVib2FyZC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VFcnJvci5oPgogI2lu Y2x1ZGUgPHd0Zi9BdG9taWNzLmg+CiAKICNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQpAQCAt MjA4LDYgKzIxMiwyNCBAQCBSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIFdlYlBsYXRmb3JtU3RyYXRl Z2llczo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKICAgICAKICAgICByZXR1cm4gc2NoZWR1bGVy OwogfQorCit2b2lkIFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6bG9hZFJlc291cmNlU3luY2hyb25v dXNseShOZXR3b3JraW5nQ29udGV4dCogY29udGV4dCwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0LCBTdG9yZWRDcmVkZW50aWFscyBzdG9yZWRDcmVkZW50aWFscywgUHJpdmF0ZUJyb3dz aW5nIHByaXZhdGVCcm93c2luZywgUmVzb3VyY2VFcnJvciYgZXJyb3IsIFJlc291cmNlUmVzcG9u c2UmIHJlc3BvbnNlLCBWZWN0b3I8Y2hhcj4mIGRhdGEpCit7CisgICAgQ29yZUlQQzo6RGF0YVJl ZmVyZW5jZSBkYXRhUmVmZXJlbmNlOworCisgICAgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRl cnMgbG9hZFBhcmFtZXRlcnMocmVxdWVzdCwgUmVzb3VyY2VMb2FkUHJpb3JpdHlIaWdoZXN0LCBT bmlmZkNvbnRlbnQsIHN0b3JlZENyZWRlbnRpYWxzLCBwcml2YXRlQnJvd3NpbmcgPT0gUHJpdmF0 ZUJyb3dzaW5nRW5hYmxlZCk7CisgICAgaWYgKCFXZWJQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3Jr Q29ubmVjdGlvbigpLT5jb25uZWN0aW9uKCktPnNlbmRTeW5jKE1lc3NhZ2VzOjpOZXR3b3JrQ29u bmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZChsb2FkUGFyYW1ldGVy cyksIE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNo cm9ub3VzTG9hZDo6UmVwbHkoZXJyb3IsIHJlc3BvbnNlLCBkYXRhUmVmZXJlbmNlKSwgMCkpIHsK KyAgICAgICAgcmVzcG9uc2UgPSBSZXNvdXJjZVJlc3BvbnNlKCk7CisgICAgICAgIGVycm9yID0g aW50ZXJuYWxFcnJvcihyZXF1ZXN0LnVybCgpKTsKKyAgICAgICAgZGF0YS5yZXNpemUoMCk7Cisg ICAgICAgIAorICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZGF0YS5yZXNpemUoZGF0YVJl ZmVyZW5jZS5zaXplKCkpOworICAgIG1lbWNweShkYXRhLmRhdGEoKSwgZGF0YVJlZmVyZW5jZS5k YXRhKCksIGRhdGFSZWZlcmVuY2Uuc2l6ZSgpKTsKK30KKwogI2VuZGlmCiAKIC8vIFBsdWdpblN0 cmF0ZWd5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaAppbmRleCBjYzBkYzhjLi42NDAw ZGE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv V2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmgKQEAgLTcxLDYgKzcxLDcgQEAg cHJpdmF0ZToKICAgICAvLyBXZWJDb3JlOjpMb2FkZXJTdHJhdGVneQogI2lmIEVOQUJMRShORVRX T1JLX1BST0NFU1MpCiAgICAgdmlydHVhbCBXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXIq IHJlc291cmNlTG9hZFNjaGVkdWxlcigpIE9WRVJSSURFOworICAgIHZpcnR1YWwgdm9pZCBsb2Fk UmVzb3VyY2VTeW5jaHJvbm91c2x5KFdlYkNvcmU6Ok5ldHdvcmtpbmdDb250ZXh0KiwgY29uc3Qg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgV2ViQ29yZTo6U3RvcmVkQ3JlZGVudGlhbHMsIFdl YkNvcmU6OlByaXZhdGVCcm93c2luZywgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYsIFdlYkNvcmU6 OlJlc291cmNlUmVzcG9uc2UmLCBWZWN0b3I8Y2hhcj4mIGRhdGEpIE9WRVJSSURFOwogI2VuZGlm CiAKICAgICAvLyBXZWJDb3JlOjpQbHVnaW5TdHJhdGVneQo= 183033 2013-01-16 13:56:21 -0800 2013-01-16 14:23:01 -0800 Final patch for landing - Give it an EWS run patch text/plain 49344 beidson ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAyNDRmYjc5Ni4uMmUyODFmOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5 IEBACisyMDEzLTAxLTE2ICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KKworICAg ICAgICBTeW5jaHJvbm91cyBYTUxIVFRQUmVxdWVzdHMgbmVlZCB0byBnbyB0byB0aGUgTmV0d29y a1Byb2Nlc3MuCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8xMjk1MTc2NT4gYW5kIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDY4MjYKKworICAgICAgICBSZXZpZXdl ZCBieSBTYW0gV2VpbmlnIGFuZCBBbGV4ZXkgUHJvc2t1cnlha292LgorCisgICAgICAgIE5vIG5l dyB0ZXN0cyAoTm8gY2hhbmdlcyB0byBhbnkgY29uZmlnIHRoYXQgaXMgY3VycmVudGx5IHRlc3Rl ZCkKKworICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseSk6IENvbnN1bHQgdGhlIExv YWRlclN0cmF0ZWd5IHdoZW4gc3RyYXRlZ2llcyBhcmUKKyAgICAgICAgICBiZWluZyB1c2VkLgor CisgICAgICAgICogbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkxvYWRlclN0cmF0ZWd5Ojpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KTogRGVmYXVsdHMgdG8g dXNpbmcgUmVzb3VyY2VIYW5kbGUgZGlyZWN0bHkuCisgICAgICAgICogbG9hZGVyL0xvYWRlclN0 cmF0ZWd5Lmg6CisKKyAgICAgICAgQnJlYWsgb3V0IHRoZSBTdG9yZWRDcmVkZW50aWFscyBlbnVt IHRvIGEgbmV3IGhlYWRlcjoKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFu ZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZVR5cGVzLmg6 CisgICAgICAgICogR05VbWFrZWZpbGUubGlzdC5hbToKKyAgICAgICAgKiBUYXJnZXQucHJpOgor ICAgICAgICAqIFdlYkNvcmUuZXhwLmluOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoK KwogMjAxMy0wMS0xNSAgUm9nZXIgRm9uZyAgPHJvZ2VyX2ZvbmdAYXBwbGUuY29tPgogCiAgICAg ICAgIEdldCByaWQgb2YgYSBzdHJhZ2dsaW5nIGRlcGVuZGVuY3kgb24gU2FmYXJpVGhlbWVDb25z dGFudHMgaW4gUmVuZGVyVGhlbWVXaW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVt YWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQppbmRl eCBjMTI1ZGQ0Li42OTdkMTRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmls ZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAgLTU4 MDYsNiArNTgwNiw3IEBAIHdlYmNvcmVfcGxhdGZvcm1fc291cmNlcyArPSBcCiAJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5jcHAgXAogCVNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBcCiAJU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmggXAorCVNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVUeXBlcy5oIFwKIAlTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlTG9hZEluZm8uaCBcCiAJU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUxvYWRQcmlvcml0eS5oIFwKIAlTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlTG9hZFRpbWluZy5jcHAgXApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaSBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkK aW5kZXggYmMxNjg0Ny4uZTMyMjFmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0 LnByaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCkBAIC0yMzAyLDYgKzIzMDIsNyBA QCBIRUFERVJTICs9IFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL3F0L1FOZXR3b3JrUmVwbHlIYW5k bGVyLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VFcnJvckJhc2UuaCBcCiAgICAg cGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oIFwKKyAgICBwbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlVHlwZXMuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUxv YWRJbmZvLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VMb2FkUHJpb3JpdHkuaCBc CiAgICAgcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUxvYWRUaW1pbmcuaCBcCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu ZXhwLmluCmluZGV4IGFmY2QyMTYuLjZlYjhkNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUuZXhwLmluCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZXhwLmluCkBAIC0y ODQsNiArMjg0LDcgQEAgX19aTjdXZWJDb3JlMTRGcmFtZVNlbGVjdGlvbjZtb2RpZnlFTlMwXzEx RUFsdGVyYXRpb25FTlNfMThTZWxlY3Rpb25EaXJlY3Rpb25FTlMKIF9fWk43V2ViQ29yZTE0RnJh bWVTZWxlY3Rpb245c2VsZWN0QWxsRXYKIF9fWk43V2ViQ29yZTE0RnJhbWVTZWxlY3Rpb25DMUVQ TlNfNUZyYW1lRQogX19aTjdXZWJDb3JlMTRMb2FkZXJTdHJhdGVneTIxcmVzb3VyY2VMb2FkU2No ZWR1bGVyRXYKK19fWk43V2ViQ29yZTE0TG9hZGVyU3RyYXRlZ3kyNWxvYWRSZXNvdXJjZVN5bmNo cm9ub3VzbHlFUE5TXzE3TmV0d29ya2luZ0NvbnRleHRFUktOU18xNVJlc291cmNlUmVxdWVzdEVO U18xN1N0b3JlZENyZWRlbnRpYWxzRVJOU18xM1Jlc291cmNlRXJyb3JFUk5TXzE2UmVzb3VyY2VS ZXNwb25zZUVSTjNXVEY2VmVjdG9ySWNMbTBFRUUKIF9fWk43V2ViQ29yZTE0UGx1Z2luRG9jdW1l bnQxMHBsdWdpbk5vZGVFdgogX19aTks3V2ViQ29yZTVGcmFtZTI1dHJhY2tlZFJlcGFpbnRSZWN0 c0FzVGV4dEV2CiBfX1pON1dlYkNvcmU5RnJhbWVWaWV3MTdzZXRUcmFja3NSZXBhaW50c0ViCkBA IC0yOTcsNiArMjk4LDcgQEAgX19aTjdXZWJDb3JlMTRSZXNvdXJjZUJ1ZmZlckMyRXYKIF9fWk43 V2ViQ29yZTE0UmVzb3VyY2VCdWZmZXJEMUV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNlQnVmZmVy RDJFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTIwZm9yY2VDb250ZW50U25pZmZpbmdF dgorX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTI1bG9hZFJlc291cmNlU3luY2hyb25vdXNs eUVQTlNfMTdOZXR3b3JraW5nQ29udGV4dEVSS05TXzE1UmVzb3VyY2VSZXF1ZXN0RU5TXzE3U3Rv cmVkQ3JlZGVudGlhbHNFUk5TXzEzUmVzb3VyY2VFcnJvckVSTlNfMTZSZXNvdXJjZVJlc3BvbnNl RVJOM1dURjZWZWN0b3JJY0xtMEVFRQogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTI2c3lu Y2hyb25vdXNMb2FkUnVuTG9vcE1vZGVFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTZj cmVhdGVFUE5TXzE3TmV0d29ya2luZ0NvbnRleHRFUktOU18xNVJlc291cmNlUmVxdWVzdEVQTlNf MjBSZXNvdXJjZUhhbmRsZUNsaWVudEViYgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUxvYWRlcjEz c2V0SWRlbnRpZmllckVtCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnZjcHJv ai9XZWJDb3JlLnZjcHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUu dmNwcm9qCmluZGV4IDlkNTAzZjIuLmU0M2IyOWEgMTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0zMjcyOSw2ICszMjcyOSwxMCBAQAogCQkJCQk+ CiAJCQkJPC9GaWxlPgogCQkJCTxGaWxlCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5ccGxhdGZvcm1c bmV0d29ya1xSZXNvdXJjZUhhbmRsZVR5cGVzLmgiCisJCQkJCT4KKwkJCQk8L0ZpbGU+CisJCQkJ PEZpbGUKIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxwbGF0Zm9ybVxuZXR3b3JrXFJlc291cmNlSGFu ZGxlQ2xpZW50LmgiCiAJCQkJCT4KIAkJCQk8L0ZpbGU+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggYzlhNzkwYS4uNTg2MTgyMSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agpAQCAtMTI4OCw4ICsxMjg4LDggQEAKIAkJNDk0ODRGQzExMDJDRjIzQzAwMTg3REQzIC8qIENh bnZhc0dyYWRpZW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQ5NDg0RkIzMTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNHcmFkaWVudC5jcHAgKi87 IH07CiAJCTQ5NDg0RkMyMTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNHcmFkaWVudC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDk0ODRGQjQxMDJDRjIz QzAwMTg3REQzIC8qIENhbnZhc0dyYWRpZW50LmggKi87IH07CiAJCTQ5NDg0RkM0MTAyQ0YyM0Mw MDE4N0REMyAvKiBDYW52YXNQYXR0ZXJuLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQ5NDg0RkI2MTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNQYXR0 ZXJuLmNwcCAqLzsgfTsKLQkJNDk0ODRGQzUxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRl cm4uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ5NDg0 RkI3MTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNQYXR0ZXJuLmggKi87IH07CiAJCTQ5NDg0RkM0 MTAyQ0YyM0MwMDE4OEREMyAvKiBDYW52YXNQcm94eS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OTQ4NEZCNjEwMkNGMjNDMDAxODhERDMgLyogQ2Fu dmFzUHJveHkuY3BwICovOyB9OworCQk0OTQ4NEZDNTEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFz UGF0dGVybi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NDk0ODRGQjcxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRlcm4uaCAqLzsgfTsKIAkJNDk0 ODRGQzUxMDJDRjIzQzAwMTg4REQzIC8qIENhbnZhc1Byb3h5LmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0OTQ4NEZCNzEwMkNGMjNDMDAxODhERDMgLyog Q2FudmFzUHJveHkuaCAqLzsgfTsKIAkJNDk0ODRGQ0ExMDJDRjIzQzAwMTg3REQzIC8qIENhbnZh c1JlbmRlcmluZ0NvbnRleHQyRC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0OTQ4NEZCQzEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUmVuZGVyaW5n Q29udGV4dDJELmNwcCAqLzsgfTsKIAkJNDk0ODRGQ0IxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZh c1JlbmRlcmluZ0NvbnRleHQyRC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNDk0ODRGQkQxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1JlbmRlcmluZ0Nv bnRleHQyRC5oICovOyB9OwpAQCAtMTY1Nyw2ICsxNjU3LDcgQEAKIAkJNTFFMUVDQzMwQzkxQzkw NDAwREMyNTVCIC8qIFBhZ2VVUkxSZWNvcmQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxRTFFQ0JEMEM5MUM5MDQwMERDMjU1QiAvKiBQYWdlVVJMUmVj b3JkLmggKi87IH07CiAJCTUxRTNGOUM3MERBMDU5REMwMDI1MDkxMSAvKiBTdG9yYWdlLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxRTNGOUM1MERB MDU5REMwMDI1MDkxMSAvKiBTdG9yYWdlLmNwcCAqLzsgfTsKIAkJNTFFM0Y5RDYwREEwNUUxRDAw MjUwOTExIC8qIEpTU3RvcmFnZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MUUzRjlENDBEQTA1RTFEMDAyNTA5MTEgLyogSlNTdG9yYWdlLmNwcCAq LzsgfTsKKwkJNTFFNDE0MzQxNkE2NTk2MzAwQzYzM0M3IC8qIFJlc291cmNlSGFuZGxlVHlwZXMu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxRTQxNDMy MTZBNjU5NTEwMEM2MzNDNyAvKiBSZXNvdXJjZUhhbmRsZVR5cGVzLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNTFFNjgyMTAxNjM4NzMwMjAwM0JC RjNDIC8qIExvYWRlclN0cmF0ZWd5LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MUU2ODIwRjE2Mzg3MzAyMDAzQkJGM0MgLyogTG9hZGVyU3RyYXRlZ3ku aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk1MUVD OTI2NTBDRTkwREQ0MDBGOTAzMDggLyogSlNDdXN0b21TUUxTdGF0ZW1lbnRFcnJvckNhbGxiYWNr LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxRUM5 MjVEMENFOTBERDQwMEY5MDMwOCAvKiBKU0N1c3RvbVNRTFN0YXRlbWVudEVycm9yQ2FsbGJhY2su Y3BwICovOyB9OwogCQk1MUZBMkQ3ODE1MjEzMkIzMDBDMUJBMEIgLyogRE9NV2luZG93RXh0ZW5z aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTdG QkExODE1MUFBNzFCMDBCNTc5NTkgLyogRE9NV2luZG93RXh0ZW5zaW9uLmggKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTE4NTksOCArMTg2MCw4IEBA CiAJCTY1REYzMjM5MDlEMURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc0dyYWRpZW50LmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDY1REYzMjMzMDlEMURF NjUwMDBCRTMyNSAvKiBKU0NhbnZhc0dyYWRpZW50LmNwcCAqLzsgfTsKIAkJNjVERjMyM0EwOUQx REU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzR3JhZGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDY1REYzMjM0MDlEMURFNjUwMDBCRTMyNSAvKiBKU0Nh bnZhc0dyYWRpZW50LmggKi87IH07CiAJCTY1REYzMjNCMDlEMURFNjUwMDBCRTMyNSAvKiBKU0Nh bnZhc1BhdHRlcm4uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNjVERjMyMzUwOUQxREU2NTAwMEJFMzI1IC8qIEpTQ2FudmFzUGF0dGVybi5jcHAgKi87 IH07Ci0JCTY1REYzMjNDMDlEMURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4uaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDY1REYzMjM2MDlEMURF NjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4uaCAqLzsgfTsKIAkJNjVERjMyM0IwOUQxREU2 NTAwMUJFMzI1IC8qIEpTQ2FudmFzUHJveHkuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNjVERjMyMzUwOUQxREU2NTAwMUJFMzI1IC8qIEpTQ2FudmFz UHJveHkuY3BwICovOyB9OworCQk2NURGMzIzQzA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNQ YXR0ZXJuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA2 NURGMzIzNjA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNQYXR0ZXJuLmggKi87IH07CiAJCTY1 REYzMjNDMDlEMURFNjUwMDFCRTMyNSAvKiBKU0NhbnZhc1Byb3h5LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA2NURGMzIzNjA5RDFERTY1MDAxQkUzMjUg LyogSlNDYW52YXNQcm94eS5oICovOyB9OwogCQk2NURGMzI2MTA5RDFFMTk5MDAwQkUzMjUgLyog VXNlckFnZW50U3R5bGVTaGVldHNEYXRhLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDY1NjU4MUFGMDlEMTRFRTYwMDBFNjFENyAvKiBVc2VyQWdlbnRT dHlsZVNoZWV0c0RhdGEuY3BwICovOyB9OwogCQk2NUUwRTk0NDExMzNDODlGMDBCNENCMTAgLyog SlNET01XcmFwcGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA2NUUwRTk0MzExMzNDODlGMDBCNENCMTAgLyogSlNET01XcmFwcGVyLmggKi87IHNldHRp bmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTg1NzUsMTAgKzg1NzYs MTAgQEAKIAkJNDk0ODRGQjQxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc0dyYWRpZW50LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IENhbnZhc0dyYWRpZW50Lmg7IHBhdGggPSBj YW52YXMvQ2FudmFzR3JhZGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDk0 ODRGQjUxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc0dyYWRpZW50LmlkbCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRl eHQ7IG5hbWUgPSBDYW52YXNHcmFkaWVudC5pZGw7IHBhdGggPSBjYW52YXMvQ2FudmFzR3JhZGll bnQuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OTQ4NEZCNjEwMkNGMjNDMDAx ODdERDMgLyogQ2FudmFzUGF0dGVybi5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IG5hbWUgPSBDYW52YXNQYXR0ZXJuLmNwcDsgcGF0aCA9IGNhbnZhcy9DYW52YXNQYXR0ZXJuLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJNDk0ODRGQjcxMDJDRjIzQzAwMTg3REQz IC8qIENhbnZhc1BhdHRlcm4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gQ2Fu dmFzUGF0dGVybi5oOyBwYXRoID0gY2FudmFzL0NhbnZhc1BhdHRlcm4uaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKLQkJNDk0ODRGQjgxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRl cm4uaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gdGV4dDsgbmFtZSA9IENhbnZhc1BhdHRlcm4uaWRsOyBwYXRoID0g Y2FudmFzL0NhbnZhc1BhdHRlcm4uaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0 OTQ4NEZCNjEwMkNGMjNDMDAxODhERDMgLyogQ2FudmFzUHJveHkuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gQ2FudmFzUHJveHkuY3BwOyBwYXRoID0gY2FudmFzL0Nh bnZhc1Byb3h5LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDk0ODRGQjcxMDJD RjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRlcm4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBuYW1lID0gQ2FudmFzUGF0dGVybi5oOyBwYXRoID0gY2FudmFzL0NhbnZhc1BhdHRlcm4uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDk0ODRGQjcxMDJDRjIzQzAwMTg4REQzIC8q IENhbnZhc1Byb3h5LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IENhbnZhc1By b3h5Lmg7IHBhdGggPSBjYW52YXMvQ2FudmFzUHJveHkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDk0ODRGQjgxMDJDRjIzQzAwMTg3REQzIC8qIENhbnZhc1BhdHRlcm4uaWRsICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gdGV4dDsgbmFtZSA9IENhbnZhc1BhdHRlcm4uaWRsOyBwYXRoID0gY2FudmFzL0Nh bnZhc1BhdHRlcm4uaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OTQ4NEZCODEw MkNGMjNDMDAxODhERDMgLyogQ2FudmFzUHJveHkuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgbmFtZSA9 IENhbnZhc1Byb3h5LmlkbDsgcGF0aCA9IGNhbnZhcy9DYW52YXNQcm94eS5pZGw7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ5NDg0RkJDMTAyQ0YyM0MwMDE4N0REMyAvKiBDYW52YXNS ZW5kZXJpbmdDb250ZXh0MkQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1l ID0gQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmNwcDsgcGF0aCA9IGNhbnZhcy9DYW52YXNSZW5k ZXJpbmdDb250ZXh0MkQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0OTQ4NEZC RDEwMkNGMjNDMDAxODdERDMgLyogQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IENhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5oOyBwYXRo ID0gY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwpAQCAtODk4Miw2ICs4OTgzLDcgQEAKIAkJNTFFM0Y5RDEwREEwNUQ3MTAwMjUwOTEx IC8qIFN0b3JhZ2UuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IFN0b3JhZ2UuaWRsOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUUzRjlENDBEQTA1RTFEMDAyNTA5MTEgLyogSlNT dG9yYWdlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTU3RvcmFn ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxRTNGOUQ1MERBMDVFMUQwMDI1 MDkxMSAvKiBKU1N0b3JhZ2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNT dG9yYWdlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxRTQxNDMyMTZBNjU5NTEw MEM2MzNDNyAvKiBSZXNvdXJjZUhhbmRsZVR5cGVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFJlc291cmNlSGFuZGxlVHlwZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJNTFFNjgyMEYxNjM4NzMwMjAwM0JCRjNDIC8qIExvYWRlclN0cmF0ZWd5LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IExvYWRlclN0cmF0ZWd5Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTUxRUM5MjVEMENFOTBERDQwMEY5MDMwOCAvKiBKU0N1c3RvbVNR TFN0YXRlbWVudEVycm9yQ2FsbGJhY2suY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gSlNDdXN0b21TUUxTdGF0ZW1lbnRFcnJvckNhbGxiYWNrLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTFGNkEzRDUwNjYzQkYwNDAwNEQyOTE5IC8qIEhUTUxDYW52 YXNFbGVtZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSAzMDsgaW5kZW50V2lkdGggPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IEhUTUxDYW52YXNFbGVtZW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgdGFiV2lkdGggPSA4OyB1c2VzVGFicyA9IDA7IH07CkBAIC05MTkzLDggKzkxOTUsOCBAQAog CQk2NURGMzIzMzA5RDFERTY1MDAwQkUzMjUgLyogSlNDYW52YXNHcmFkaWVudC5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSlNDYW52YXNHcmFkaWVudC5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1REYzMjM0MDlEMURFNjUwMDBCRTMyNSAvKiBK U0NhbnZhc0dyYWRpZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU0Nh bnZhc0dyYWRpZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTY1REYzMjM1MDlE MURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4uY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEpTQ2FudmFzUGF0dGVybi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07Ci0JCTY1REYzMjM2MDlEMURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4u aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTQ2FudmFzUGF0dGVybi5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk2NURGMzIzNTA5RDFERTY1MDAxQkUzMjUgLyog SlNDYW52YXNQcm94eS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g SlNDYW52YXNQcm94eS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTY1REYzMjM2 MDlEMURFNjUwMDBCRTMyNSAvKiBKU0NhbnZhc1BhdHRlcm4uaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IEpTQ2FudmFzUGF0dGVybi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk2NURGMzIzNjA5RDFERTY1MDAxQkUzMjUgLyogSlNDYW52YXNQcm94eS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNDYW52YXNQcm94eS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk2NUUwRTk0MzExMzNDODlGMDBCNENCMTAgLyogSlNET01XcmFw cGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTRE9NV3JhcHBlci5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk2NUY4MDY5NzA1NEQ5Rjg2MDA4QkY3NzYgLyog QmxvY2tFeGNlcHRpb25zLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDMwOyBpbmRlbnRXaWR0aCA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAub2JqY3BwOyBwYXRoID0gQmxvY2tFeGNlcHRpb25zLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB0YWJXaWR0aCA9IDg7IHVzZXNUYWJzID0gMDsgfTsKQEAgLTE1OTIyLDYgKzE1OTI0 LDcgQEAKIAkJCQk1MTRDNzY2NDBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VIYW5kbGUuaCAq LywKIAkJCQk1MTRDNzY2NTBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VIYW5kbGVDbGllbnQu aCAqLywKIAkJCQk1MTRDNzY2NjBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VIYW5kbGVJbnRl cm5hbC5oICovLAorCQkJCTUxRTQxNDMyMTZBNjU5NTEwMEM2MzNDNyAvKiBSZXNvdXJjZUhhbmRs ZVR5cGVzLmggKi8sCiAJCQkJNDkyODYzOTgxMjUzQjhGQzAwRjc5MkQ2IC8qIFJlc291cmNlTG9h ZEluZm8uaCAqLywKIAkJCQlFNDI5NUZBMzEyQjA2MTRFMDBEMUFDRTAgLyogUmVzb3VyY2VMb2Fk UHJpb3JpdHkuaCAqLywKIAkJCQk4NjFDMkVBNTEzRkI0RkZGMDAwNjJBQkIgLyogUmVzb3VyY2VM b2FkVGltaW5nLmNwcCAqLywKQEAgLTI2MDk4LDYgKzI2MTAxLDcgQEAKIAkJCQlFMUJFNTEyRTBD RjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVTb3J0LmggaW4gSGVhZGVycyAqLywKIAkJCQk5 NzdFMkUwRjEyRjBGQzlDMDBDMTMzNzkgLyogWFNTQXVkaXRvci5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJRkQ1MzczNTMxMzdCNjUxODAwMDA4RENFIC8qIFplcm9Qb2xlLmggaW4gSGVhZGVycyAqLywK KwkJCQk1MUU0MTQzNDE2QTY1OTYzMDBDNjMzQzcgLyogUmVzb3VyY2VIYW5kbGVUeXBlcy5oIGlu IEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2lu ZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2Fk ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAppbmRleCBiN2My ZGZkLi5hZDE5YjViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2Fk ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTc2 LDEyICs3NiwxNCBAQAogI2luY2x1ZGUgIkhpc3RvcnlJdGVtLmgiCiAjaW5jbHVkZSAiSW5zcGVj dG9yQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkluc3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgor I2luY2x1ZGUgIkxvYWRlclN0cmF0ZWd5LmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2luY2x1 ZGUgIk1JTUVUeXBlUmVnaXN0cnkuaCIKICNpbmNsdWRlICJNYWluUmVzb3VyY2VMb2FkZXIuaCIK ICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGFnZUNhY2hlLmgiCiAjaW5jbHVkZSAiUGFn ZVRyYW5zaXRpb25FdmVudC5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyYXRlZ2llcy5oIgogI2lu Y2x1ZGUgIlBsdWdpbkRhdGEuaCIKICNpbmNsdWRlICJQbHVnaW5EYXRhYmFzZS5oIgogI2luY2x1 ZGUgIlBsdWdpbkRvY3VtZW50LmgiCkBAIC0yNTgxLDcgKzI1ODMsMTEgQEAgdW5zaWduZWQgbG9u ZyBGcmFtZUxvYWRlcjo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseShjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlcXUKICAgICAgICAgQVNTRVJUKCFuZXdSZXF1ZXN0LmlzTnVsbCgpKTsKICAgICAg ICAgCiAgICAgICAgIGlmICghZG9jdW1lbnRMb2FkZXIoKS0+YXBwbGljYXRpb25DYWNoZUhvc3Qo KS0+bWF5YmVMb2FkU3luY2hyb25vdXNseShuZXdSZXF1ZXN0LCBlcnJvciwgcmVzcG9uc2UsIGRh dGEpKSB7CisjaWYgVVNFKFBMQVRGT1JNX1NUUkFURUdJRVMpCisgICAgICAgICAgICBwbGF0Zm9y bVN0cmF0ZWdpZXMoKS0+bG9hZGVyU3RyYXRlZ3koKS0+bG9hZFJlc291cmNlU3luY2hyb25vdXNs eShuZXR3b3JraW5nQ29udGV4dCgpLCBuZXdSZXF1ZXN0LCBzdG9yZWRDcmVkZW50aWFscywgZXJy b3IsIHJlc3BvbnNlLCBkYXRhKTsKKyNlbHNlCiAgICAgICAgICAgICBSZXNvdXJjZUhhbmRsZTo6 bG9hZFJlc291cmNlU3luY2hyb25vdXNseShuZXR3b3JraW5nQ29udGV4dCgpLCBuZXdSZXF1ZXN0 LCBzdG9yZWRDcmVkZW50aWFscywgZXJyb3IsIHJlc3BvbnNlLCBkYXRhKTsKKyNlbmRpZgogICAg ICAgICAgICAgZG9jdW1lbnRMb2FkZXIoKS0+YXBwbGljYXRpb25DYWNoZUhvc3QoKS0+bWF5YmVM b2FkRmFsbGJhY2tTeW5jaHJvbm91c2x5KG5ld1JlcXVlc3QsIGVycm9yLCByZXNwb25zZSwgZGF0 YSk7CiAgICAgICAgIH0KICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIv TG9hZGVyU3RyYXRlZ3kuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5 LmNwcAppbmRleCAxNDA2ZWFhLi45NWJjNjBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9s b2FkZXIvTG9hZGVyU3RyYXRlZ3kuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Mb2Fk ZXJTdHJhdGVneS5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNp bmNsdWRlICJMb2FkZXJTdHJhdGVneS5oIgogCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIK ICNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKIAogI2lmIFVTRShQTEFURk9STV9T VFJBVEVHSUVTKQpAQCAtMzcsNiArMzgsMTEgQEAgUmVzb3VyY2VMb2FkU2NoZWR1bGVyKiBMb2Fk ZXJTdHJhdGVneTo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKICAgICByZXR1cm4gV2ViQ29yZTo6 cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CiB9CiAKK3ZvaWQgTG9hZGVyU3RyYXRlZ3k6OmxvYWRS ZXNvdXJjZVN5bmNocm9ub3VzbHkoTmV0d29ya2luZ0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCwgU3RvcmVkQ3JlZGVudGlhbHMgc3RvcmVkQ3JlZGVudGlh bHMsIFJlc291cmNlRXJyb3ImIGVycm9yLCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSwgVmVj dG9yPGNoYXI+JiBkYXRhKQoreworICAgIFJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5j aHJvbm91c2x5KGNvbnRleHQsIHJlcXVlc3QsIHN0b3JlZENyZWRlbnRpYWxzLCBlcnJvciwgcmVz cG9uc2UsIGRhdGEpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBV U0UoUExBVEZPUk1fU1RSQVRFR0lFUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9Mb2FkZXJTdHJhdGVneS5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5 LmgKaW5kZXggZTg3Yzc2Ny4uM2QwZTFkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9h ZGVyL0xvYWRlclN0cmF0ZWd5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0 cmF0ZWd5LmgKQEAgLTI4LDE0ICsyOCwyMyBAQAogCiAjaWYgVVNFKFBMQVRGT1JNX1NUUkFURUdJ RVMpCiAKKyNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZVR5cGVzLmgiCisjaW5jbHVkZSA8d3RmL1Zl Y3Rvci5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIE5ldHdvcmtpbmdDb250ZXh0 OworY2xhc3MgUmVzb3VyY2VFcnJvcjsKIGNsYXNzIFJlc291cmNlTG9hZFNjaGVkdWxlcjsKK2Ns YXNzIFJlc291cmNlUmVxdWVzdDsKK2NsYXNzIFJlc291cmNlUmVzcG9uc2U7CiAKIGNsYXNzIExv YWRlclN0cmF0ZWd5IHsKIHB1YmxpYzoKICAgICB2aXJ0dWFsIFJlc291cmNlTG9hZFNjaGVkdWxl ciogcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CiAKKyAgICB2aXJ0dWFsIHZvaWQgbG9hZFJlc291 cmNlU3luY2hyb25vdXNseShOZXR3b3JraW5nQ29udGV4dCosIGNvbnN0IFJlc291cmNlUmVxdWVz dCYsIFN0b3JlZENyZWRlbnRpYWxzLCBSZXNvdXJjZUVycm9yJiwgUmVzb3VyY2VSZXNwb25zZSYs IFZlY3RvcjxjaGFyPiYgZGF0YSk7CisKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIH5Mb2FkZXJT dHJhdGVneSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9SZXNvdXJjZUhhbmRsZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUhhbmRsZS5oCmluZGV4IDQxYmEzODguLjQ5NDFkMmIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKQEAgLTI4LDYgKzI4LDcg QEAKIAogI2luY2x1ZGUgIkF1dGhlbnRpY2F0aW9uQ2xpZW50LmgiCiAjaW5jbHVkZSAiSFRUUEhl YWRlck1hcC5oIgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlVHlwZXMuaCIKICNpbmNsdWRlIDx3 dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KIApAQCAtODgsMTEgKzg5 LDYgQEAgY2xhc3MgUmVzb3VyY2VSZXNwb25zZTsKIGNsYXNzIFNjaGVkdWxlUGFpcjsKIGNsYXNz IFNoYXJlZEJ1ZmZlcjsKIAotZW51bSBTdG9yZWRDcmVkZW50aWFscyB7Ci0gICAgQWxsb3dTdG9y ZWRDcmVkZW50aWFscywKLSAgICBEb05vdEFsbG93U3RvcmVkQ3JlZGVudGlhbHMKLX07Ci0KIHRl bXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBUaW1lcjsKIAogY2xhc3MgUmVzb3VyY2VIYW5kbGUg OiBwdWJsaWMgUmVmQ291bnRlZDxSZXNvdXJjZUhhbmRsZT4KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVUeXBlcy5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZVR5cGVzLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODcwZTc5NQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVUeXBlcy5oCkBAIC0wLDAg KzEsMzggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S CisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgor ICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFJlc291cmNlSGFuZGxlVHlwZXNfaAorI2Rl ZmluZSBSZXNvdXJjZUhhbmRsZVR5cGVzX2gKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitlbnVt IFN0b3JlZENyZWRlbnRpYWxzIHsKKyAgICBBbGxvd1N0b3JlZENyZWRlbnRpYWxzLAorICAgIERv Tm90QWxsb3dTdG9yZWRDcmVkZW50aWFscworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gUmVzb3VyY2VIYW5kbGVUeXBlc19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYzY2NjcyMS4u ZDFjZDkxMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDEzLTAxLTE2ICBCcmFkeSBF aWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBYTUxIVFRQ UmVxdWVzdHMgbmVlZCB0byBnbyB0byB0aGUgTmV0d29ya1Byb2Nlc3MuCisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS8xMjk1MTc2NT4gYW5kIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xMDY4MjYKKworICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnIGFuZCBBbGV4 ZXkgUHJvc2t1cnlha292LgorCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQbGF0Zm9ybVN0 cmF0ZWdpZXM6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkpOiBFbnRyeSBwb2ludCBmb3IgV2Vi Q29yZSB0byBnZXQKKyAgICAgICAgICBzeW5jaHJvbm91cyByZXF1ZXN0cyB0byB0aGUgTmV0d29y a1Byb2Nlc3MuCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9y bVN0cmF0ZWdpZXMuaDoKKworICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0 aW9uVG9XZWJQcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya0Nvbm5lY3Rpb25U b1dlYlByb2Nlc3M6OnBlcmZvcm1TeW5jaHJvbm91c0xvYWQpOiBDcmVhdGUgYSBTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyCisgICAgICAgICAgYW5kIHNjaGVkdWxlIGl0LgorICAgICAgICAqIE5l dHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmg6CisgICAgICAgICog TmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MubWVzc2FnZXMuaW46 CisKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVy LmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2No ZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKToKKyAgICAgICAgKFdlYktpdDo6TmV0d29y a1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2VydmVQZW5kaW5nUmVxdWVzdHNGb3JIb3N0KTogU2Vy dmUgc3luY2hyb25vdXMgbG9hZGVycworICAgICAgICAgIGJlZm9yZSBhc3luYyBsb2FkZXJzLgor ICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaDoK KworICAgICAgICBBIGNsYXNzIHRoYXQgZW5jYXBzdWxhdGVzIGEgc3luY2hyb25vdXMgbG9hZCBy ZXF1ZXN0IGFuZCB0aGUgQ29yZUlQQyByZXBseSB0byBiZSBtYWRlIG9uY2UgaXQgaXMgY29tcGxl dGU6CisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyOjpT eW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKToKKyAgICAgICAgKFdlYktpdDo6U3luY05ldHdvcmtS ZXNvdXJjZUxvYWRlcjo6c3RhcnQpOgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL1N5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXIuaDogQ29waWVkIGZyb20gU291cmNlL1dlYktpdDIvTmV0d29ya1By b2Nlc3MvSG9zdFJlY29yZC5oLgorICAgICAgICAoV2ViS2l0OjpTeW5jTmV0d29ya1Jlc291cmNl TG9hZGVyOjpjcmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpTeW5jTmV0d29ya1Jlc291cmNlTG9h ZGVyOjpzZXRJZGVudGlmaWVyKToKKyAgICAgICAgKFdlYktpdDo6U3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlcjo6aWRlbnRpZmllcik6CisgICAgICAgIChXZWJLaXQ6OlN5bmNOZXR3b3JrUmVzb3Vy Y2VMb2FkZXI6OmxvYWRQYXJhbWV0ZXJzKToKKworICAgICAgICBBZGQgYSBzZWNvbmQgcXVldWUg b2Ygc3luYyBsb2FkZXJzOgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuaDoK KyAgICAgICAgKFdlYktpdDo6SG9zdFJlY29yZDo6c3luY0xvYWRlcnNQZW5kaW5nKToKKworICAg ICAgICBBZGQgY29tbWVudHMgdG8gZXhwbGljaXRseSBzcGVsbCBvdXQgdGhlIGN1cnJlbnQgcmVs aWFuY2Ugb24gc29tZSBtZXNzYWdlcyB0aGF0IGFyZSBjdXJyZW50bHkgc3luY2hyb25vdXM6Cisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcDoKKyAgICAg ICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZGVyOjp3aWxsU2VuZFJlcXVlc3QpOgorICAg ICAgICAoV2ViS2l0OjpOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OmNhbkF1dGhlbnRpY2F0ZUFnYWlu c3RQcm90ZWN0aW9uU3BhY2UpOgorCisgICAgICAgICogV2ViS2l0Mi54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qOgorCiAyMDEzLTAxLTE1ICBFbnJpY2EgQ2FzdWNjaSAgPGVucmljYUBhcHBsZS5j b20+CiAKICAgICAgICAgQWRkIGEgbmV3IHNldCBvZiBXZWJLaXQyIEFQSXMgZm9yIHRleHQgc2Vh cmNoIGFuZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJl Y29yZC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9Ib3N0UmVjb3JkLmNwcApp bmRleCA3YmM5NjE3Li4zNzM5MWI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3Jr UHJvY2Vzcy9Ib3N0UmVjb3JkLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9Ib3N0UmVjb3JkLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIk5ldHdvcmtSZXNv dXJjZUxvYWRQYXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlN5 bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKIAogI2lmIEVOQUJMRShORVRXT1JLX1BST0NFU1Mp CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQu aCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuaAppbmRleCAxYjIx Mzc2Li5iMjE5ZTZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9I b3N0UmVjb3JkLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJlY29y ZC5oCkBAIC0zNiw2ICszNiw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgTmV0d29y a1Jlc291cmNlTG9hZGVyOworY2xhc3MgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcjsKIHR5cGVk ZWYgdWludDY0X3QgUmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKIAogY2xhc3MgSG9zdFJlY29yZCB7 CkBAIC01NCwxMCArNTUsMTYgQEAgcHVibGljOgogICAgIHR5cGVkZWYgRGVxdWU8UmVmUHRyPE5l dHdvcmtSZXNvdXJjZUxvYWRlcj4gPiBMb2FkZXJRdWV1ZTsKICAgICBMb2FkZXJRdWV1ZSYgbG9h ZGVyc1BlbmRpbmcoV2ViQ29yZTo6UmVzb3VyY2VMb2FkUHJpb3JpdHkgcHJpb3JpdHkpIHsgcmV0 dXJuIG1fbG9hZGVyc1BlbmRpbmdbcHJpb3JpdHldOyB9CiAKKyAgICB0eXBlZGVmIERlcXVlPFJl ZlB0cjxTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyPiA+IFN5bmNMb2FkZXJRdWV1ZTsKKyAgICBT eW5jTG9hZGVyUXVldWUmIHN5bmNMb2FkZXJzUGVuZGluZygpIHsgcmV0dXJuIG1fc3luY0xvYWRl cnNQZW5kaW5nOyB9CisKIHByaXZhdGU6ICAgICAgICAgICAgICAgICAgICAKICAgICBMb2FkZXJR dWV1ZSBtX2xvYWRlcnNQZW5kaW5nW1dlYkNvcmU6OlJlc291cmNlTG9hZFByaW9yaXR5SGlnaGVz dCArIDFdOwogICAgIHR5cGVkZWYgSGFzaFNldDxSZXNvdXJjZUxvYWRJZGVudGlmaWVyPiBSZXNv dXJjZUxvYWRJZGVudGlmaWVyU2V0OwogICAgIFJlc291cmNlTG9hZElkZW50aWZpZXJTZXQgbV9y ZXNvdXJjZUlkZW50aWZpZXJzTG9hZGluZzsKKyAgICAKKyAgICBTeW5jTG9hZGVyUXVldWUgbV9z eW5jTG9hZGVyc1BlbmRpbmc7CisgICAgSGFzaFNldDxSZWZQdHI8U3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlcj4gPiBtX3N5bmNMb2FkZXJzTG9hZGluZzsKIAogICAgIGNvbnN0IFN0cmluZyBtX25h bWU7CiAgICAgaW50IG1fbWF4UmVxdWVzdHNJbkZsaWdodDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmNwcCBi L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzLmNwcAppbmRleCA4NjRiMTRiLi4yMzUwMTg4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nl c3MuY3BwCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3MuaCIKICNp bmNsdWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlICJSZW1vdGVOZXR3b3Jr aW5nQ29udGV4dC5oIgorI2luY2x1ZGUgIlN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNp bmNsdWRlIDxXZWJDb3JlL1BsYXRmb3JtQ29va2llSmFyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9S ZXNvdXJjZUxvYWRlck9wdGlvbnMuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlUmVxdWVz dC5oPgpAQCAtMTIwLDYgKzEyMSwxMSBAQCB2b2lkIE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzOjpzY2hlZHVsZVJlc291cmNlTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMbwogICAgIHJl c291cmNlTG9hZElkZW50aWZpZXIgPSBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jl c291cmNlTG9hZFNjaGVkdWxlcigpLnNjaGVkdWxlUmVzb3VyY2VMb2FkKGxvYWRQYXJhbWV0ZXJz LCB0aGlzKTsKIH0KIAordm9pZCBOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6cGVyZm9y bVN5bmNocm9ub3VzTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYgbG9h ZFBhcmFtZXRlcnMsIFBhc3NSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+IHJlcGx5KQorewor ICAgIE5ldHdvcmtQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVy KCkuc2NoZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKFN5bmNOZXR3b3JrUmVzb3VyY2VM b2FkZXI6OmNyZWF0ZShsb2FkUGFyYW1ldGVycywgcmVwbHkpKTsKK30KKwogdm9pZCBOZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzczo6YWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgS1VSTCYgdXJs LCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyJiBpZGVudGlmaWVyKQogewogICAgIGlkZW50aWZpZXIg PSBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcigp LmFkZExvYWRJblByb2dyZXNzKHVybCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3 b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oIGIvU291cmNlL1dlYktp dDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MuaAppbmRleCA1 MjM0NDI0Li45Y2U0NDI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05l dHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmgKQEAgLTc2LDYgKzc2 LDggQEAgcHJpdmF0ZToKICAgICB2b2lkIGRpZFJlY2VpdmVTeW5jTmV0d29ya0Nvbm5lY3Rpb25U b1dlYlByb2Nlc3NNZXNzYWdlKENvcmVJUEM6OkNvbm5lY3Rpb24qLCBDb3JlSVBDOjpNZXNzYWdl SUQsIENvcmVJUEM6Ok1lc3NhZ2VEZWNvZGVyJiwgT3duUHRyPENvcmVJUEM6Ok1lc3NhZ2VFbmNv ZGVyPiYpOwogICAgIAogICAgIHZvaWQgc2NoZWR1bGVSZXNvdXJjZUxvYWQoY29uc3QgTmV0d29y a1Jlc291cmNlTG9hZFBhcmFtZXRlcnMmLCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyJik7CisgICAg dm9pZCBwZXJmb3JtU3luY2hyb25vdXNMb2FkKGNvbnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJh bWV0ZXJzJiwgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nl c3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4pOworCiAgICAgdm9pZCBh ZGRMb2FkSW5Qcm9ncmVzcyhjb25zdCBXZWJDb3JlOjpLVVJMJiwgUmVzb3VyY2VMb2FkSWRlbnRp ZmllciYpOwogICAgIHZvaWQgcmVtb3ZlTG9hZElkZW50aWZpZXIoUmVzb3VyY2VMb2FkSWRlbnRp Zmllcik7CiAgICAgdm9pZCBjcm9zc09yaWdpblJlZGlyZWN0UmVjZWl2ZWQoUmVzb3VyY2VMb2Fk SWRlbnRpZmllciwgY29uc3QgV2ViQ29yZTo6S1VSTCYgcmVkaXJlY3RVUkwpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlBy b2Nlc3MubWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgppbmRleCBmNTc2YzllLi41NWQ5MWQ5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3Jr UHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgpAQCAtMjks NiArMjksNyBAQCBtZXNzYWdlcyAtPiBOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2VzcyB7CiAg ICAgLy8gVGhlcmUncyBwb3NzaWJsZSBSZXNvdXJjZUxvYWRlciBpZGVudGlmaWVyIHJlZmFjdG9y aW5nIHRoYXQgY2FuIHJlbW92ZSB0aGF0IHJlcXVpcmVtZW50LgogICAgIC8vIFdlIG1pZ2h0IGFs c28gaGF2ZSB0aGUgTmV0d29ya1Byb2Nlc3MgZGl2dnkgdXAgaWRlbnRpZmllcnMgaW4gYmxvY2tz IHRvIGVhY2ggV2ViUHJvY2VzcyBiZWZvcmVoYW5kLgogICAgIFNjaGVkdWxlUmVzb3VyY2VMb2Fk KFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgcmVzb3VyY2VMb2FkUGFyYW1l dGVycykgLT4gKHVpbnQ2NF90IHJlc291cmNlTG9hZElkZW50aWZpZXIpCisgICAgUGVyZm9ybVN5 bmNocm9ub3VzTG9hZChXZWJLaXQ6Ok5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzIHJlc291 cmNlTG9hZFBhcmFtZXRlcnMpIC0+IChXZWJDb3JlOjpSZXNvdXJjZUVycm9yIGVycm9yLCBXZWJD b3JlOjpSZXNvdXJjZVJlc3BvbnNlIHJlc3BvbnNlLCBDb3JlSVBDOjpEYXRhUmVmZXJlbmNlIGRh dGEpIERlbGF5ZWQKICAgICBBZGRMb2FkSW5Qcm9ncmVzcyhXZWJDb3JlOjpLVVJMIHVybCkgLT4g KHVpbnQ2NF90IHJlc291cmNlTG9hZElkZW50aWZpZXIpCiAgICAgUmVtb3ZlTG9hZElkZW50aWZp ZXIodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikKICAgICAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIu Y3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNj aGVkdWxlci5jcHAKaW5kZXggZDM3OGI4MS4uOGY3OWJjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5jcHAKQEAgLTcsNiArNyw3IEBACiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3Njb25uZWN0 aW9uTWVzc2FnZXMuaCIKICNpbmNsdWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5o IgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlN5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogI2luY2x1 ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KIApAQCAtNjcsNiArNjgsMjcgQEAgUmVzb3VyY2VMb2Fk SWRlbnRpZmllciBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzY2hlZHVsZVJlc291cmNl TG9hZChjb25zdAogICAgIHJldHVybiBpZGVudGlmaWVyOwogfQogCit2b2lkIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXI6OnNjaGVkdWxlU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcihQYXNz UmVmUHRyPFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI+IGxvYWRlcikKK3sKKyAgICAvLyBGSVhN RSAoTmV0d29ya1Byb2Nlc3MpOiBTeW5jIGxvYWRlcnMgbmVlZCB0byBnZXQgaWRlbnRpZmllcnMg aW4gYSBzYW5lIHdheS4KKyAgICBSZXNvdXJjZUxvYWRJZGVudGlmaWVyIGlkZW50aWZpZXIgPSAr K3NfY3VycmVudFJlc291cmNlTG9hZElkZW50aWZpZXI7CisgICAgbG9hZGVyLT5zZXRJZGVudGlm aWVyKGlkZW50aWZpZXIpOworCisgICAgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QgPSBsb2FkZXItPmxvYWRQYXJhbWV0ZXJzKCkucmVxdWVzdCgpOworCisgICAgTE9HKE5l dHdvcmtTY2hlZHVsaW5nLCAiKE5ldHdvcmtQcm9jZXNzKSBOZXR3b3JrUmVzb3VyY2VMb2FkU2No ZWR1bGVyOjpzY2hlZHVsZVN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIgc3luY2hyb25vdXMgcmVz b3VyY2UgJyVzJyIsIHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKworICAgIEhvc3RSZWNvcmQqIGhvc3QgPSBob3N0Rm9yVVJMKHJlc291cmNlUmVxdWVzdC51 cmwoKSwgQ3JlYXRlSWZOb3RGb3VuZCk7CisgICAgYm9vbCBoYWRSZXF1ZXN0cyA9IGhvc3QtPmhh c1JlcXVlc3RzKCk7CisgICAgaG9zdC0+c3luY0xvYWRlcnNQZW5kaW5nKCkuYXBwZW5kKGxvYWRl cik7CisgICAgbV9pZGVudGlmaWVycy5hZGQoaWRlbnRpZmllciwgaG9zdCk7CisgICAgCisgICAg aWYgKCFoYWRSZXF1ZXN0cykKKyAgICAgICAgc2VydmVQZW5kaW5nUmVxdWVzdHNGb3JIb3N0KGhv c3QsIFJlc291cmNlTG9hZFByaW9yaXR5SGlnaGVzdCk7CisKKyAgICBzY2hlZHVsZVNlcnZlUGVu ZGluZ1JlcXVlc3RzKCk7Cit9CisKIFJlc291cmNlTG9hZElkZW50aWZpZXIgTmV0d29ya1Jlc291 cmNlTG9hZFNjaGVkdWxlcjo6YWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgV2ViQ29yZTo6S1VSTCYg dXJsKQogewogICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllciA9ICsrc19jdXJy ZW50UmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKQEAgLTE3MCw2ICsxOTIsMjQgQEAgdm9pZCBOZXR3 b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0c0Zvckhvc3QoSG9z dFJlY29yZCogaG9zdCwKIHsKICAgICBMT0coTmV0d29ya1NjaGVkdWxpbmcsICJOZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyBIb3N0IG5hbWU9JyVzJyIs IGhvc3QtPm5hbWUoKS51dGY4KCkuZGF0YSgpKTsKIAorICAgIC8vIFdlIHNlcnZlIHN5bmNocm9u b3VzIHJlcXVlc3RzIGJlZm9yZSBhbnkgb3RoZXIgcmVxdWVzdHMgdG8gaW1wcm92ZSByZXNwb25z aXZlbmVzcyBpbiBhbnkKKyAgICAvLyBXZWJQcm9jZXNzIHRoYXQgaXMgd2FpdGluZyBvbiBhIHN5 bmNocm9ub3VzIGxvYWQuCisgICAgSG9zdFJlY29yZDo6U3luY0xvYWRlclF1ZXVlJiBzeW5jTG9h ZGVyc1BlbmRpbmcgPSBob3N0LT5zeW5jTG9hZGVyc1BlbmRpbmcoKTsKKyAgICB3aGlsZSAoIXN5 bmNMb2FkZXJzUGVuZGluZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgUmVmUHRyPFN5bmNOZXR3b3Jr UmVzb3VyY2VMb2FkZXI+IGxvYWRlciA9IHN5bmNMb2FkZXJzUGVuZGluZy5maXJzdCgpOworCisg ICAgICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IEhvdyBkbyB3ZSBrbm93IHRoaXMgc3lu Y2hyb25vdXMgbG9hZCBpc24ndCBhc3NvY2lhdGVkIHdpdGggYSBXZWJQcm9jZXNzCisgICAgICAg IC8vIHdlJ3ZlIGxvc3Qgb3VyIGNvbm5lY3Rpb24gdG8/CisgICAgICAgIGJvb2wgc2hvdWxkTGlt aXRSZXF1ZXN0cyA9ICFob3N0LT5uYW1lKCkuaXNOdWxsKCk7CisgICAgICAgIGlmIChzaG91bGRM aW1pdFJlcXVlc3RzICYmIGhvc3QtPmxpbWl0UmVxdWVzdHMoUmVzb3VyY2VMb2FkUHJpb3JpdHlI aWdoZXN0LCBmYWxzZSkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgc3luY0xvYWRl cnNQZW5kaW5nLnJlbW92ZUZpcnN0KCk7CisgICAgICAgIGhvc3QtPmFkZExvYWRJblByb2dyZXNz KGxvYWRlci0+aWRlbnRpZmllcigpKTsKKworICAgICAgICBsb2FkZXItPnN0YXJ0KCk7CisgICAg fQorICAgIAogICAgIGZvciAoaW50IHByaW9yaXR5ID0gUmVzb3VyY2VMb2FkUHJpb3JpdHlIaWdo ZXN0OyBwcmlvcml0eSA+PSBtaW5pbXVtUHJpb3JpdHk7IC0tcHJpb3JpdHkpIHsKICAgICAgICAg SG9zdFJlY29yZDo6TG9hZGVyUXVldWUmIGxvYWRlcnNQZW5kaW5nID0gaG9zdC0+bG9hZGVyc1Bl bmRpbmcoUmVzb3VyY2VMb2FkUHJpb3JpdHkocHJpb3JpdHkpKTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5o IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5oCmluZGV4IDA0NzZmY2MuLjA0NDEyM2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgK QEAgLTM5LDYgKzM5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiBjbGFzcyBIb3N0UmVjb3JkOwog Y2xhc3MgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnM7CiBjbGFzcyBOZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2VzczsKK2NsYXNzIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI7CiB0eXBl ZGVmIHVpbnQ2NF90IFJlc291cmNlTG9hZElkZW50aWZpZXI7CiAKIGNsYXNzIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXIgewpAQCAtNTAsNiArNTEsOSBAQCBwdWJsaWM6CiAgICAgLy8gQWRk cyB0aGUgcmVxdWVzdCB0byB0aGUgcXVldWUgZm9yIGl0cyBob3N0IGFuZCBjcmVhdGUgYSB1bmlx dWUgaWRlbnRpZmllciBmb3IgaXQuCiAgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBzY2hlZHVs ZVJlc291cmNlTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYsIE5ldHdv cmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzKik7CiAgICAgCisgICAgLy8gQWRkcyBhIHN5bmNocm9u b3VzIHJlcXVlc3QgdG8gdGhlIHN5bmNocm9ub3VzIHJlcXVlc3QgcXVldWUgZm9yIGl0cyBob3N0 LgorICAgIHZvaWQgc2NoZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKFBhc3NSZWZQdHI8 U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcj4pOworICAgIAogICAgIC8vIENyZWF0ZXMgYSB1bmlx dWUgaWRlbnRpZmllciBmb3IgYW4gYWxyZWFkeS1pbi1wcm9ncmVzcyBsb2FkLgogICAgIFJlc291 cmNlTG9hZElkZW50aWZpZXIgYWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgV2ViQ29yZTo6S1VSTCYp OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkZXIuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jl c291cmNlTG9hZGVyLmNwcAppbmRleCBjZTQ2YmQwLi5iZDAxYmJmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHAK QEAgLTE4OCw2ICsxODgsMTAgQEAgdm9pZCBOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OndpbGxTZW5k UmVxdWVzdChSZXNvdXJjZUhhbmRsZSosIFJlc291cmNlUmVxdWVzdCYgcmUKICAgICBBU1NFUlQo IXJlZGlyZWN0UmVzcG9uc2UuaXNOdWxsKCkpOwogICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkp OwogCisgICAgLy8gSU1QT1JUQU5UOiBUaGUgZmFjdCB0aGF0IHRoaXMgbWVzc2FnZSB0byB0aGUg V2ViUHJvY2VzcyBpcyBzeW5jIGlzIHdoYXQgbWFrZXMgb3VyIGN1cnJlbnQgYXBwcm9hY2ggdG8g c3luY2hyb25vdXMgWE1MSHR0cFJlcXVlc3RzIHNhZmUuCisgICAgLy8gSWYgdGhpcyBtZXNzYWdl IGNoYW5nZXMgdG8gYmUgYXN5bmNocm9ub3VzIHdlIG1pZ2h0IGludHJvZHVjZSBhIHNpdHVhdGlv biB3aGVyZSB0aGUgTmV0d29ya1Byb2Nlc3MgaXMgZGVhZGxvY2tlZCB3YWl0aW5nIGZvciA2IGNv bm5lY3Rpb25zCisgICAgLy8gdG8gY29tcGxldGUgd2hpbGUgdGhlIFdlYlByb2Nlc3MgaXMgd2Fp dGluZyBmb3IgYSA3dGggdG8gY29tcGxldGUuCisgICAgLy8gSWYgd2UgZXZlciBjaGFuZ2UgdGhp cyBtZXNzYWdlIHRvIGJlIGFzeW5jaHJvbm91cyB3ZSBoYXZlIHRvIGluY2x1ZGUgc2FmZWd1YXJk cyB0byBtYWtlIHN1cmUgdGhlIG5ldyBkZXNpZ24gaW50ZXJhY3RzIHdlbGwgd2l0aCBzeW5jIFhI Ui4KICAgICBpZiAoIXNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJSZXNvdXJjZUxvYWRlcjo6V2lsbFNl bmRSZXF1ZXN0KHJlcXVlc3QsIHJlZGlyZWN0UmVzcG9uc2UpLCBNZXNzYWdlczo6V2ViUmVzb3Vy Y2VMb2FkZXI6OldpbGxTZW5kUmVxdWVzdDo6UmVwbHkocmVxdWVzdCkpKQogICAgICAgICByZXF1 ZXN0ID0gUmVzb3VyY2VSZXF1ZXN0KCk7CiB9CkBAIC0yODcsNiArMjkxLDEwIEBAIGJvb2wgTmV0 d29ya1Jlc291cmNlTG9hZGVyOjpjYW5BdXRoZW50aWNhdGVBZ2FpbnN0UHJvdGVjdGlvblNwYWNl KFJlc291cmNlSGFuZGxlCiB7CiAgICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CiAKKyAgICAv LyBJTVBPUlRBTlQ6IFRoZSBmYWN0IHRoYXQgdGhpcyBtZXNzYWdlIHRvIHRoZSBXZWJQcm9jZXNz IGlzIHN5bmMgaXMgd2hhdCBtYWtlcyBvdXIgY3VycmVudCBhcHByb2FjaCB0byBzeW5jaHJvbm91 cyBYTUxIdHRwUmVxdWVzdHMgc2FmZS4KKyAgICAvLyBJZiB0aGlzIG1lc3NhZ2UgY2hhbmdlcyB0 byBiZSBhc3luY2hyb25vdXMgd2UgbWlnaHQgaW50cm9kdWNlIGEgc2l0dWF0aW9uIHdoZXJlIHRo ZSBOZXR3b3JrUHJvY2VzcyBpcyBkZWFkbG9ja2VkIHdhaXRpbmcgZm9yIDYgY29ubmVjdGlvbnMK KyAgICAvLyB0byBjb21wbGV0ZSB3aGlsZSB0aGUgV2ViUHJvY2VzcyBpcyB3YWl0aW5nIGZvciBh IDd0aCB0byBjb21wbGV0ZS4KKyAgICAvLyBJZiB3ZSBldmVyIGNoYW5nZSB0aGlzIG1lc3NhZ2Ug dG8gYmUgYXN5bmNocm9ub3VzIHdlIGhhdmUgdG8gaW5jbHVkZSBzYWZlZ3VhcmRzIHRvIG1ha2Ug c3VyZSB0aGUgbmV3IGRlc2lnbiBpbnRlcmFjdHMgd2VsbCB3aXRoIHN5bmMgWEhSLgogICAgIGJv b2wgcmVzdWx0OwogICAgIGlmICghc2VuZFN5bmMoTWVzc2FnZXM6OldlYlJlc291cmNlTG9hZGVy OjpDYW5BdXRoZW50aWNhdGVBZ2FpbnN0UHJvdGVjdGlvblNwYWNlKHByb3RlY3Rpb25TcGFjZSks IE1lc3NhZ2VzOjpXZWJSZXNvdXJjZUxvYWRlcjo6Q2FuQXV0aGVudGljYXRlQWdhaW5zdFByb3Rl Y3Rpb25TcGFjZTo6UmVwbHkocmVzdWx0KSkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VM b2FkZXIuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNv dXJjZUxvYWRlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2RlMjNl MQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNO ZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwCkBAIC0wLDAgKzEsNzUgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJ VFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5o IgorCisjaWYgRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKKworI2luY2x1ZGUgIkRhdGFSZWZlcmVu Y2UuaCIKKyNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzcy5oIgorI2luY2x1ZGUgIlJlbW90ZU5ldHdv cmtpbmdDb250ZXh0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9SZXNvdXJjZUVycm9yLmg+CisjaW5j bHVkZSA8V2ViQ29yZS9SZXNvdXJjZVJlc3BvbnNlLmg+CisjaW5jbHVkZSA8d3RmL01haW5UaHJl YWQuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBXZWJLaXQgewor CitTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyOjpTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKGNv bnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzJiBwYXJhbWV0ZXJzLCBQYXNzUmVmUHRy PE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9u b3VzTG9hZDo6RGVsYXllZFJlcGx5PiByZXBseSkKKyAgICA6IG1fbmV0d29ya1Jlc291cmNlTG9h ZFBhcmFtZXRlcnMocGFyYW1ldGVycykKKyAgICAsIG1fZGVsYXllZFJlcGx5KHJlcGx5KQorICAg ICwgbV9pZGVudGlmaWVyKDApCit7Cit9CisKK3ZvaWQgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRl cjo6c3RhcnQoKQoreworICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IFRoaXMgaXMgY2Fs bGVkIG9uIHRoZSBOZXR3b3JrUHJvY2VzcyBtYWluIHRocmVhZCwgYmxvY2tpbmcgYW55IG90aGVy IHJlcXVlc3RzIGZyb20gYmVpbmcgc2NoZWR1bGVkLgorICAgIC8vIFRoaXMgc2hvdWxkIG1vdmUg dG8gYSBiYWNrZ3JvdW5kIHRocmVhZCwgYnV0IHdlJ2QgZWl0aGVyIG5lZWQgdG8gYmUgc3VyZSB0 aGF0OgorICAgIC8vICAgQSAtIFJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91 c2x5IGlzIHNhZmUgdG8gcnVuIG9uIGEgYmFja2dyb3VuZCB0aHJlYWQuCisgICAgLy8gICBCIC0g V3JpdGUgY3VzdG9tIGxvYWRpbmcgbG9naWMgdGhhdCBpcyBrbm93biB0byBiZSBzYWZlIG9uIGEg YmFja2dyb3VuZCB0aHJlYWQuCisgICAgCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAg ICBBU1NFUlQobV9pZGVudGlmaWVyKTsKKworICAgIFJlc291cmNlRXJyb3IgZXJyb3I7CisgICAg UmVzb3VyY2VSZXNwb25zZSByZXNwb25zZTsKKyAgICBWZWN0b3I8Y2hhcj4gZGF0YTsKKyAgICAK KyAgICAvLyBGSVhNRSAoTmV0d29ya1Byb2Nlc3MpOiBDcmVhdGUgUmVtb3RlTmV0d29ya2luZ0Nv bnRleHQgd2l0aCBhY3R1YWwgc2V0dGluZ3MuCisgICAgUmVmUHRyPFJlbW90ZU5ldHdvcmtpbmdD b250ZXh0PiBuZXR3b3JraW5nQ29udGV4dCA9IFJlbW90ZU5ldHdvcmtpbmdDb250ZXh0OjpjcmVh dGUoZmFsc2UsIGZhbHNlLCBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzLmluUHJpdmF0 ZUJyb3dzaW5nTW9kZSgpKTsKKyAgICAKKyAgICBSZXNvdXJjZUhhbmRsZTo6bG9hZFJlc291cmNl U3luY2hyb25vdXNseShuZXR3b3JraW5nQ29udGV4dC5nZXQoKSwgbV9uZXR3b3JrUmVzb3VyY2VM b2FkUGFyYW1ldGVycy5yZXF1ZXN0KCksIG1fbmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMu YWxsb3dTdG9yZWRDcmVkZW50aWFscygpLCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOworCisgICAg bV9kZWxheWVkUmVwbHktPnNlbmQoZXJyb3IsIHJlc3BvbnNlLCBDb3JlSVBDOjpEYXRhUmVmZXJl bmNlKCh1aW50OF90KilkYXRhLmRhdGEoKSwgZGF0YS5zaXplKCkpKTsKKyAgICAKKyAgICBOZXR3 b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcigpLnJlbW92 ZUxvYWRJZGVudGlmaWVyKG1faWRlbnRpZmllcik7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktp dAorCisjZW5kaWYgLy8gRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCBiL1Nv dXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NDJhZThlCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxv YWRlci5oCkBAIC0wLDAgKzEsNjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycK KyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisg KiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFN5bmNOZXR3b3Jr UmVzb3VyY2VMb2FkZXJfaAorI2RlZmluZSBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyX2gKKwor I2luY2x1ZGUgIk5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzTWVzc2FnZXMuaCIKKyNpbmNs dWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5oIgorI2luY2x1ZGUgPHd0Zi9SZWZD b3VudGVkLmg+CisKKyNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQorCituYW1lc3BhY2UgV2Vi S2l0IHsKKwordHlwZWRlZiB1aW50NjRfdCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyOworCitjbGFz cyBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyIDogcHVibGljIFJlZkNvdW50ZWQ8U3luY05ldHdv cmtSZXNvdXJjZUxvYWRlcj4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFN5bmNO ZXR3b3JrUmVzb3VyY2VMb2FkZXI+IGNyZWF0ZShjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFy YW1ldGVycyYgcGFyYW1ldGVycywgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rp b25Ub1dlYlByb2Nlc3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4gcmVw bHkpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFN5bmNOZXR3b3JrUmVzb3Vy Y2VMb2FkZXIocGFyYW1ldGVycywgcmVwbHkpKTsKKyAgICB9CisgICAgCisgICAgdm9pZCBzZXRJ ZGVudGlmaWVyKFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllcikgeyBtX2lkZW50aWZp ZXIgPSBpZGVudGlmaWVyOyB9CisgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBpZGVudGlmaWVy KCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9CisgICAgCisgICAgY29uc3QgTmV0d29y a1Jlc291cmNlTG9hZFBhcmFtZXRlcnMmIGxvYWRQYXJhbWV0ZXJzKCkgeyByZXR1cm4gbV9uZXR3 b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVyczsgfQorCisgICAgdm9pZCBzdGFydCgpOworCitwcml2 YXRlOgorICAgIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIoY29uc3QgTmV0d29ya1Jlc291cmNl TG9hZFBhcmFtZXRlcnMmLCBQYXNzUmVmUHRyPE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRv V2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6RGVsYXllZFJlcGx5Pik7CisgICAg CisgICAgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgbV9uZXR3b3JrUmVzb3VyY2VMb2Fk UGFyYW1ldGVyczsKKyAgICBSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+IG1fZGVsYXllZFJl cGx5OworICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIgbV9pZGVudGlmaWVyOworfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAvLyBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQor CisjZW5kaWYgLy8gU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcl9oCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2Vi S2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMWIwNDYzYS4uMTcw MjQ4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViS2l0Mi54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagpAQCAtNDcwLDYgKzQ3MCw4IEBACiAJCTUxNzk1NTcxMTYyODc3RDIwMEZBNDNCNiAv KiBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTFBOEE2MEYxNjI3RjJCRDAwMEQ5MEU5IC8qIE5l dHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggKi87IH07CiAJCTUxN0NGMEUzMTYzQTQ4 NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE3Q0YwRTEx NjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VSZWNlaXZl ci5jcHAgKi87IH07CiAJCTUxN0NGMEU0MTYzQTQ4NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vz c0Nvbm5lY3Rpb25NZXNzYWdlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNTE3Q0YwRTIxNjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29u bmVjdGlvbk1lc3NhZ2VzLmggKi87IH07CisJCTUxODE1QjlGMTZBNjIyMjEwMDU0NTAxRiAvKiBT eW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxODE1QjlEMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyLmNwcCAqLzsgfTsKKwkJNTE4MTVCQTAxNkE2MjIyMTAwNTQ1MDFGIC8q IFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyLmggKi87IH07CiAJCTUxODI5REE1MTYzN0M3MEMwMDA5NTNENiAvKiBO ZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REEzMTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3Jr UmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCAqLzsgfTsKIAkJNTE4MjlEQTYxNjM3QzcwQzAwMDk1 M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REE0MTYzN0M3MEMwMDA5NTNENiAvKiBO ZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi87IH07CiAJCTUxODM0NTkyMTM0NTMyRTkw MDkyQjY5NiAvKiBXZWJJY29uRGF0YWJhc2VDbGllbnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MzQ1OTAxMzQ1MzJFODAwOTJCNjk2IC8qIFdl Ykljb25EYXRhYmFzZUNsaWVudC5jcHAgKi87IH07CkBAIC0xNzM0LDYgKzE3MzYsOCBAQAogCQk1 MTdBMzNCNDEzMEIzMDhDMDBGODBDQjUgLyogV0tBcHBsaWNhdGlvbkNhY2hlTWFuYWdlci5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXS0FwcGxpY2F0aW9uQ2FjaGVNYW5hZ2Vy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxN0NGMEUxMTYzQTQ4NkMwMEMyOTUw RSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uTWVz c2FnZVJlY2VpdmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE3Q0YwRTIx NjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VzLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1l c3NhZ2VzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxODE1QjlEMTZBNjIyMjEw MDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwOyBwYXRo ID0gTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0 d29ya1Jlc291cmNlTG9hZGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFN5 bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNzL1N5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlE QTMxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gTmV0d29ya1Jlc291cmNlTG9hZFNj aGVkdWxlci5jcHA7IHBhdGggPSBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2No ZWR1bGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlEQTQxNjM3Qzcw QzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBuYW1lID0gTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBwYXRo ID0gTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk1MTgzNDU5MDEzNDUzMkU4MDA5MkI2OTYgLyogV2ViSWNv bkRhdGFiYXNlQ2xpZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFdlYkljb25EYXRhYmFzZUNsaWVudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBA IC0zMTkzLDYgKzMxOTcsOCBAQAogCQkJCTUxNTcwNTUyMTY1NzAxOEMwMDEwMUE5MCAvKiBOZXR3 b3JrUmVzb3VyY2VMb2FkZXIubWVzc2FnZXMuaW4gKi8sCiAJCQkJNTE4MjlEQTMxNjM3QzcwQzAw MDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICovLAogCQkJCTUxODI5 REE0MTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi8s CisJCQkJNTE4MTVCOUQxNkE2MjIyMTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2Fk ZXIuY3BwICovLAorCQkJCTUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jl c291cmNlTG9hZGVyLmggKi8sCiAJCQkpOwogCQkJbmFtZSA9IE5ldHdvcmtQcm9jZXNzOwogCQkJ c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTUwNzAsNiArNTA3Niw3IEBACiAJCQkJRTE3OTA4 OEYxNjlCQUE2QTAwNjkwNEM3IC8qIFNlY0l0ZW1TaGltLmggaW4gSGVhZGVycyAqLywKIAkJCQlF MTc5MDg5MTE2OUJBQTgyMDA2OTA0QzcgLyogU2VjSXRlbVNoaW1NZXNzYWdlcy5oIGluIEhlYWRl cnMgKi8sCiAJCQkJMUE5N0UwNzYxNkE1RjlFMDAwMEJDOUU1IC8qIExheWVyVHJlZUhvc3RNYWMu aCBpbiBIZWFkZXJzICovLAorCQkJCTUxODE1QkEwMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0 d29ya1Jlc291cmNlTG9hZGVyLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTYwNDksNiArNjA1Niw3IEBA CiAJCQkJRTE3OTA4OEQxNjlCQUE2MjAwNjkwNEM3IC8qIFNlY0l0ZW1TaGltLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUUxNzkwODkwMTY5QkFBN0YwMDY5MDRDNyAvKiBTZWNJdGVtU2hpbU1lc3Nh Z2VSZWNlaXZlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQTk3RTA3NzE2QTVGOUUwMDAwQkM5 RTUgLyogTGF5ZXJUcmVlSG9zdE1hYy5tbSBpbiBTb3VyY2VzICovLAorCQkJCTUxODE1QjlGMTZB NjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwog CQl9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwCmluZGV4IDlkYzQ4YzUuLjYx MDkzNzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBv cnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAKQEAgLTI5LDE5ICsy OSwyNCBAQAogI2lmIFVTRShQTEFURk9STV9TVFJBVEVHSUVTKQogCiAjaW5jbHVkZSAiQmxvY2tp bmdSZXNwb25zZU1hcC5oIgorI2luY2x1ZGUgIkRhdGFSZWZlcmVuY2UuaCIKKyNpbmNsdWRlICJO ZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5oIgogI2luY2x1ZGUgIlBsdWdpbkluZm9TdG9y ZS5oIgogI2luY2x1ZGUgIldlYkNvbnRleHRNZXNzYWdlcy5oIgogI2luY2x1ZGUgIldlYkNvb2tp ZU1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJDb3JlQXJndW1lbnRDb2RlcnMuaCIKKyNpbmNsdWRl ICJXZWJFcnJvcnMuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCiAjaW5jbHVkZSAiV2ViUHJv Y2Vzc1Byb3h5TWVzc2FnZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL0NvbG9yLmg+CiAjaW5jbHVk ZSA8V2ViQ29yZS9LVVJMLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9Mb2FkZXJTdHJhdGVneS5oPgor I2luY2x1ZGUgPFdlYkNvcmUvTmV0d29ya2luZ0NvbnRleHQuaD4KICNpbmNsdWRlIDxXZWJDb3Jl L05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGFnZS5oPgogI2lu Y2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1Db29raWVKYXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Bs YXRmb3JtUGFzdGVib2FyZC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VFcnJvci5oPgog I2luY2x1ZGUgPHd0Zi9BdG9taWNzLmg+CiAKICNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQpA QCAtMjA4LDYgKzIxMywyNCBAQCBSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIFdlYlBsYXRmb3JtU3Ry YXRlZ2llczo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKICAgICAKICAgICByZXR1cm4gc2NoZWR1 bGVyOwogfQorCit2b2lkIFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6bG9hZFJlc291cmNlU3luY2hy b25vdXNseShOZXR3b3JraW5nQ29udGV4dCogY29udGV4dCwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0 JiByZXF1ZXN0LCBTdG9yZWRDcmVkZW50aWFscyBzdG9yZWRDcmVkZW50aWFscywgUmVzb3VyY2VF cnJvciYgZXJyb3IsIFJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlLCBWZWN0b3I8Y2hhcj4mIGRh dGEpCit7CisgICAgQ29yZUlQQzo6RGF0YVJlZmVyZW5jZSBkYXRhUmVmZXJlbmNlOworCisgICAg TmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgbG9hZFBhcmFtZXRlcnMocmVxdWVzdCwgUmVz b3VyY2VMb2FkUHJpb3JpdHlIaWdoZXN0LCBTbmlmZkNvbnRlbnQsIHN0b3JlZENyZWRlbnRpYWxz LCBjb250ZXh0LT5zdG9yYWdlU2Vzc2lvbigpLmlzUHJpdmF0ZUJyb3dzaW5nU2Vzc2lvbigpKTsK KyAgICBpZiAoIVdlYlByb2Nlc3M6OnNoYXJlZCgpLm5ldHdvcmtDb25uZWN0aW9uKCktPmNvbm5l Y3Rpb24oKS0+c2VuZFN5bmMoTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNz OjpQZXJmb3JtU3luY2hyb25vdXNMb2FkKGxvYWRQYXJhbWV0ZXJzKSwgTWVzc2FnZXM6Ok5ldHdv cmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpSZXBseShl cnJvciwgcmVzcG9uc2UsIGRhdGFSZWZlcmVuY2UpLCAwKSkgeworICAgICAgICByZXNwb25zZSA9 IFJlc291cmNlUmVzcG9uc2UoKTsKKyAgICAgICAgZXJyb3IgPSBpbnRlcm5hbEVycm9yKHJlcXVl c3QudXJsKCkpOworICAgICAgICBkYXRhLnJlc2l6ZSgwKTsKKworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgZGF0YS5yZXNpemUoZGF0YVJlZmVyZW5jZS5zaXplKCkpOworICAgIG1lbWNw eShkYXRhLmRhdGEoKSwgZGF0YVJlZmVyZW5jZS5kYXRhKCksIGRhdGFSZWZlcmVuY2Uuc2l6ZSgp KTsKK30KKwogI2VuZGlmCiAKIC8vIFBsdWdpblN0cmF0ZWd5CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5o IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0 cmF0ZWdpZXMuaAppbmRleCBjYzBkYzhjLi5jMWZmMTBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1T dHJhdGVnaWVzLmgKQEAgLTcxLDYgKzcxLDcgQEAgcHJpdmF0ZToKICAgICAvLyBXZWJDb3JlOjpM b2FkZXJTdHJhdGVneQogI2lmIEVOQUJMRShORVRXT1JLX1BST0NFU1MpCiAgICAgdmlydHVhbCBX ZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIHJlc291cmNlTG9hZFNjaGVkdWxlcigpIE9W RVJSSURFOworICAgIHZpcnR1YWwgdm9pZCBsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KFdlYkNv cmU6Ok5ldHdvcmtpbmdDb250ZXh0KiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg V2ViQ29yZTo6U3RvcmVkQ3JlZGVudGlhbHMsIFdlYkNvcmU6OlJlc291cmNlRXJyb3ImLCBXZWJD b3JlOjpSZXNvdXJjZVJlc3BvbnNlJiwgVmVjdG9yPGNoYXI+JiBkYXRhKSBPVkVSUklERTsKICNl bmRpZgogCiAgICAgLy8gV2ViQ29yZTo6UGx1Z2luU3RyYXRlZ3kK 183035 2013-01-16 14:23:01 -0800 2013-01-16 14:23:01 -0800 Super-final (updated to ToT and the patch *TOTALLY* applies locally...) patch text/plain 42048 beidson ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA4MDk3MWQ2Li5jNWRmMWFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkg QEAKKzIwMTMtMDEtMTYgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAg ICAgIFN5bmNocm9ub3VzIFhNTEhUVFBSZXF1ZXN0cyBuZWVkIHRvIGdvIHRvIHRoZSBOZXR3b3Jr UHJvY2Vzcy4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzEyOTUxNzY1PiBhbmQgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNjgyNgorCisgICAgICAgIFJldmlld2Vk IGJ5IFNhbSBXZWluaWcgYW5kIEFsZXhleSBQcm9za3VyeWFrb3YuCisKKyAgICAgICAgTm8gbmV3 IHRlc3RzIChObyBjaGFuZ2VzIHRvIGFueSBjb25maWcgdGhhdCBpcyBjdXJyZW50bHkgdGVzdGVk KQorCisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkZyYW1lTG9hZGVyOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KTogQ29uc3VsdCB0aGUgTG9h ZGVyU3RyYXRlZ3kgd2hlbiBzdHJhdGVnaWVzIGFyZQorICAgICAgICAgIGJlaW5nIHVzZWQuCisK KyAgICAgICAgKiBsb2FkZXIvTG9hZGVyU3RyYXRlZ3kuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 TG9hZGVyU3RyYXRlZ3k6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkpOiBEZWZhdWx0cyB0byB1 c2luZyBSZXNvdXJjZUhhbmRsZSBkaXJlY3RseS4KKyAgICAgICAgKiBsb2FkZXIvTG9hZGVyU3Ry YXRlZ3kuaDoKKworICAgICAgICBCcmVhayBvdXQgdGhlIFN0b3JlZENyZWRlbnRpYWxzIGVudW0g dG8gYSBuZXcgaGVhZGVyOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5k bGUuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlVHlwZXMuaDoK KyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFRhcmdldC5wcmk6Cisg ICAgICAgICogV2ViQ29yZS5leHAuaW46CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29y ZS52Y3Byb2o6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgor CiAyMDEzLTAxLTE2ICBLZW5uZXRoIFJ1c3NlbGwgIDxrYnJAZ29vZ2xlLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTM5OTE0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxp c3QuYW0KaW5kZXggNWNhYmZlMi4uYjc3ZjAwOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv R05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0 LmFtCkBAIC01ODExLDYgKzU4MTEsNyBAQCB3ZWJjb3JlX3BsYXRmb3JtX3NvdXJjZXMgKz0gXAog CVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmggXAogCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oIFwKKwlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlVHlwZXMuaCBcCiAJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUxvYWRJbmZvLmggXAogCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VMb2FkUHJpb3JpdHkuaCBcCiAJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUxvYWRUaW1pbmcuY3BwIFwK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkgYi9Tb3VyY2UvV2ViQ29yZS9U YXJnZXQucHJpCmluZGV4IDgwMGY0NjkuLjQ1NTdjNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQpAQCAtMjMwNCw2 ICsyMzA0LDcgQEAgSEVBREVSUyArPSBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9RTmV0d29y a1JlcGx5SGFuZGxlci5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlRXJyb3JCYXNl LmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBcCisgICAgcGxhdGZv cm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZVR5cGVzLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsv UmVzb3VyY2VMb2FkSW5mby5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlTG9hZFBy aW9yaXR5LmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VMb2FkVGltaW5nLmggXApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29y ZS9XZWJDb3JlLmV4cC5pbgppbmRleCA4MWEwOWIwLi43NjA2NzhlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4 cC5pbgpAQCAtMjg0LDYgKzI4NCw3IEBAIF9fWk43V2ViQ29yZTE0RnJhbWVTZWxlY3Rpb242bW9k aWZ5RU5TMF8xMUVBbHRlcmF0aW9uRU5TXzE4U2VsZWN0aW9uRGlyZWN0aW9uRU5TCiBfX1pON1dl YkNvcmUxNEZyYW1lU2VsZWN0aW9uOXNlbGVjdEFsbEV2CiBfX1pON1dlYkNvcmUxNEZyYW1lU2Vs ZWN0aW9uQzFFUE5TXzVGcmFtZUUKIF9fWk43V2ViQ29yZTE0TG9hZGVyU3RyYXRlZ3kyMXJlc291 cmNlTG9hZFNjaGVkdWxlckV2CitfX1pON1dlYkNvcmUxNExvYWRlclN0cmF0ZWd5MjVsb2FkUmVz b3VyY2VTeW5jaHJvbm91c2x5RVBOU18xN05ldHdvcmtpbmdDb250ZXh0RVJLTlNfMTVSZXNvdXJj ZVJlcXVlc3RFTlNfMTdTdG9yZWRDcmVkZW50aWFsc0VSTlNfMTNSZXNvdXJjZUVycm9yRVJOU18x NlJlc291cmNlUmVzcG9uc2VFUk4zV1RGNlZlY3RvckljTG0wRUVFCiBfX1pON1dlYkNvcmUxNFBs dWdpbkRvY3VtZW50MTBwbHVnaW5Ob2RlRXYKIF9fWk5LN1dlYkNvcmU1RnJhbWUyNXRyYWNrZWRS ZXBhaW50UmVjdHNBc1RleHRFdgogX19aTjdXZWJDb3JlOUZyYW1lVmlldzE3c2V0VHJhY2tzUmVw YWludHNFYgpAQCAtMjk3LDYgKzI5OCw3IEBAIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VCdWZmZXJD MkV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNlQnVmZmVyRDFFdgogX19aTjdXZWJDb3JlMTRSZXNv dXJjZUJ1ZmZlckQyRXYKIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VIYW5kbGUyMGZvcmNlQ29udGVu dFNuaWZmaW5nRXYKK19fWk43V2ViQ29yZTE0UmVzb3VyY2VIYW5kbGUyNWxvYWRSZXNvdXJjZVN5 bmNocm9ub3VzbHlFUE5TXzE3TmV0d29ya2luZ0NvbnRleHRFUktOU18xNVJlc291cmNlUmVxdWVz dEVOU18xN1N0b3JlZENyZWRlbnRpYWxzRVJOU18xM1Jlc291cmNlRXJyb3JFUk5TXzE2UmVzb3Vy Y2VSZXNwb25zZUVSTjNXVEY2VmVjdG9ySWNMbTBFRUUKIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VI YW5kbGUyNnN5bmNocm9ub3VzTG9hZFJ1bkxvb3BNb2RlRXYKIF9fWk43V2ViQ29yZTE0UmVzb3Vy Y2VIYW5kbGU2Y3JlYXRlRVBOU18xN05ldHdvcmtpbmdDb250ZXh0RVJLTlNfMTVSZXNvdXJjZVJl cXVlc3RFUE5TXzIwUmVzb3VyY2VIYW5kbGVDbGllbnRFYmIKIF9fWk43V2ViQ29yZTE0UmVzb3Vy Y2VMb2FkZXIxM3NldElkZW50aWZpZXJFbQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnZjcHJv ai9XZWJDb3JlLnZjcHJvagppbmRleCAxNjU2ZTUzLi5mNzk5NGNjIDEwMDc1NQotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMzI3ODUsNiArMzI3ODUsMTAg QEAKIAkJCQkJPgogCQkJCTwvRmlsZT4KIAkJCQk8RmlsZQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4u XHBsYXRmb3JtXG5ldHdvcmtcUmVzb3VyY2VIYW5kbGVUeXBlcy5oIgorCQkJCQk+CisJCQkJPC9G aWxlPgorCQkJCTxGaWxlCiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5ccGxhdGZvcm1cbmV0d29ya1xS ZXNvdXJjZUhhbmRsZUNsaWVudC5oIgogCQkJCQk+CiAJCQkJPC9GaWxlPgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGM1Y2U3ZTcu LmM2YWJhNDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKQEAgLTE2NTcsNiArMTY1Nyw3IEBACiAJCTUxRTFFQ0MzMEM5MUM5MDQwMERD MjU1QiAvKiBQYWdlVVJMUmVjb3JkLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MUUxRUNCRDBDOTFDOTA0MDBEQzI1NUIgLyogUGFnZVVSTFJlY29yZC5o ICovOyB9OwogCQk1MUUzRjlDNzBEQTA1OURDMDAyNTA5MTEgLyogU3RvcmFnZS5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MUUzRjlDNTBEQTA1OURD MDAyNTA5MTEgLyogU3RvcmFnZS5jcHAgKi87IH07CiAJCTUxRTNGOUQ2MERBMDVFMUQwMDI1MDkx MSAvKiBKU1N0b3JhZ2UuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNTFFM0Y5RDQwREEwNUUxRDAwMjUwOTExIC8qIEpTU3RvcmFnZS5jcHAgKi87IH07 CisJCTUxRTQxNDM0MTZBNjU5NjMwMEM2MzNDNyAvKiBSZXNvdXJjZUhhbmRsZVR5cGVzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MUU0MTQzMjE2QTY1 OTUxMDBDNjMzQzcgLyogUmVzb3VyY2VIYW5kbGVUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTUxRTY4MjEwMTYzODczMDIwMDNCQkYzQyAv KiBMb2FkZXJTdHJhdGVneS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNTFFNjgyMEYxNjM4NzMwMjAwM0JCRjNDIC8qIExvYWRlclN0cmF0ZWd5LmggKi87 IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNTFFQzkyNjUw Q0U5MERENDAwRjkwMzA4IC8qIEpTQ3VzdG9tU1FMU3RhdGVtZW50RXJyb3JDYWxsYmFjay5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MUVDOTI1RDBD RTkwREQ0MDBGOTAzMDggLyogSlNDdXN0b21TUUxTdGF0ZW1lbnRFcnJvckNhbGxiYWNrLmNwcCAq LzsgfTsKIAkJNTFGQTJENzgxNTIxMzJCMzAwQzFCQTBCIC8qIERPTVdpbmRvd0V4dGVuc2lvbi5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE3RkJBMTgx NTFBQTcxQjAwQjU3OTU5IC8qIERPTVdpbmRvd0V4dGVuc2lvbi5oICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC05MDEwLDYgKzkwMTEsNyBAQAogCQk1 MUUzRjlEMTBEQTA1RDcxMDAyNTA5MTEgLyogU3RvcmFnZS5pZGwgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBw YXRoID0gU3RvcmFnZS5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxRTNGOUQ0 MERBMDVFMUQwMDI1MDkxMSAvKiBKU1N0b3JhZ2UuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gSlNTdG9yYWdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJNTFFM0Y5RDUwREEwNUUxRDAwMjUwOTExIC8qIEpTU3RvcmFnZS5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBKU1N0b3JhZ2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJNTFFNDE0MzIxNkE2NTk1MTAwQzYzM0M3IC8qIFJlc291cmNlSGFuZGxlVHlwZXMuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVzb3VyY2VIYW5kbGVUeXBlcy5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUU2ODIwRjE2Mzg3MzAyMDAzQkJGM0MgLyog TG9hZGVyU3RyYXRlZ3kuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTG9hZGVy U3RyYXRlZ3kuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTFFQzkyNUQwQ0U5MERE NDAwRjkwMzA4IC8qIEpTQ3VzdG9tU1FMU3RhdGVtZW50RXJyb3JDYWxsYmFjay5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU0N1c3RvbVNRTFN0YXRlbWVudEVycm9y Q2FsbGJhY2suY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUY2QTNENTA2NjNC RjA0MDA0RDI5MTkgLyogSFRNTENhbnZhc0VsZW1lbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBpbmRlbnRXaWR0aCA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSFRNTENhbnZhc0VsZW1lbnQuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB0YWJXaWR0aCA9IDg7IHVzZXNUYWJzID0gMDsgfTsK QEAgLTE1OTgzLDYgKzE1OTg1LDcgQEAKIAkJCQk1MTRDNzY2NDBDRTkyM0ExMDA3RUYzQ0QgLyog UmVzb3VyY2VIYW5kbGUuaCAqLywKIAkJCQk1MTRDNzY2NTBDRTkyM0ExMDA3RUYzQ0QgLyogUmVz b3VyY2VIYW5kbGVDbGllbnQuaCAqLywKIAkJCQk1MTRDNzY2NjBDRTkyM0ExMDA3RUYzQ0QgLyog UmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oICovLAorCQkJCTUxRTQxNDMyMTZBNjU5NTEwMEM2MzND NyAvKiBSZXNvdXJjZUhhbmRsZVR5cGVzLmggKi8sCiAJCQkJNDkyODYzOTgxMjUzQjhGQzAwRjc5 MkQ2IC8qIFJlc291cmNlTG9hZEluZm8uaCAqLywKIAkJCQlFNDI5NUZBMzEyQjA2MTRFMDBEMUFD RTAgLyogUmVzb3VyY2VMb2FkUHJpb3JpdHkuaCAqLywKIAkJCQk4NjFDMkVBNTEzRkI0RkZGMDAw NjJBQkIgLyogUmVzb3VyY2VMb2FkVGltaW5nLmNwcCAqLywKQEAgLTI2MjI2LDYgKzI2MjI5LDcg QEAKIAkJCQlFMUJFNTEyRTBDRjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVTb3J0LmggaW4g SGVhZGVycyAqLywKIAkJCQk5NzdFMkUwRjEyRjBGQzlDMDBDMTMzNzkgLyogWFNTQXVkaXRvci5o IGluIEhlYWRlcnMgKi8sCiAJCQkJRkQ1MzczNTMxMzdCNjUxODAwMDA4RENFIC8qIFplcm9Qb2xl LmggaW4gSGVhZGVycyAqLywKKwkJCQk1MUU0MTQzNDE2QTY1OTYzMDBDNjMzQzcgLyogUmVzb3Vy Y2VIYW5kbGVUeXBlcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxv eW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyLmNwcAppbmRleCBiN2MyZGZkLi5hZDE5YjViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFt ZUxvYWRlci5jcHAKQEAgLTc2LDEyICs3NiwxNCBAQAogI2luY2x1ZGUgIkhpc3RvcnlJdGVtLmgi CiAjaW5jbHVkZSAiSW5zcGVjdG9yQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkluc3BlY3Rvcklu c3RydW1lbnRhdGlvbi5oIgorI2luY2x1ZGUgIkxvYWRlclN0cmF0ZWd5LmgiCiAjaW5jbHVkZSAi TG9nZ2luZy5oIgogI2luY2x1ZGUgIk1JTUVUeXBlUmVnaXN0cnkuaCIKICNpbmNsdWRlICJNYWlu UmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGFnZUNhY2hl LmgiCiAjaW5jbHVkZSAiUGFnZVRyYW5zaXRpb25FdmVudC5oIgorI2luY2x1ZGUgIlBsYXRmb3Jt U3RyYXRlZ2llcy5oIgogI2luY2x1ZGUgIlBsdWdpbkRhdGEuaCIKICNpbmNsdWRlICJQbHVnaW5E YXRhYmFzZS5oIgogI2luY2x1ZGUgIlBsdWdpbkRvY3VtZW50LmgiCkBAIC0yNTgxLDcgKzI1ODMs MTEgQEAgdW5zaWduZWQgbG9uZyBGcmFtZUxvYWRlcjo6bG9hZFJlc291cmNlU3luY2hyb25vdXNs eShjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXUKICAgICAgICAgQVNTRVJUKCFuZXdSZXF1ZXN0 LmlzTnVsbCgpKTsKICAgICAgICAgCiAgICAgICAgIGlmICghZG9jdW1lbnRMb2FkZXIoKS0+YXBw bGljYXRpb25DYWNoZUhvc3QoKS0+bWF5YmVMb2FkU3luY2hyb25vdXNseShuZXdSZXF1ZXN0LCBl cnJvciwgcmVzcG9uc2UsIGRhdGEpKSB7CisjaWYgVVNFKFBMQVRGT1JNX1NUUkFURUdJRVMpCisg ICAgICAgICAgICBwbGF0Zm9ybVN0cmF0ZWdpZXMoKS0+bG9hZGVyU3RyYXRlZ3koKS0+bG9hZFJl c291cmNlU3luY2hyb25vdXNseShuZXR3b3JraW5nQ29udGV4dCgpLCBuZXdSZXF1ZXN0LCBzdG9y ZWRDcmVkZW50aWFscywgZXJyb3IsIHJlc3BvbnNlLCBkYXRhKTsKKyNlbHNlCiAgICAgICAgICAg ICBSZXNvdXJjZUhhbmRsZTo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseShuZXR3b3JraW5nQ29u dGV4dCgpLCBuZXdSZXF1ZXN0LCBzdG9yZWRDcmVkZW50aWFscywgZXJyb3IsIHJlc3BvbnNlLCBk YXRhKTsKKyNlbmRpZgogICAgICAgICAgICAgZG9jdW1lbnRMb2FkZXIoKS0+YXBwbGljYXRpb25D YWNoZUhvc3QoKS0+bWF5YmVMb2FkRmFsbGJhY2tTeW5jaHJvbm91c2x5KG5ld1JlcXVlc3QsIGVy cm9yLCByZXNwb25zZSwgZGF0YSk7CiAgICAgICAgIH0KICAgICB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvTG9hZGVyU3RyYXRlZ3kuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9h ZGVyL0xvYWRlclN0cmF0ZWd5LmNwcAppbmRleCAxNDA2ZWFhLi45NWJjNjBmIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvTG9hZGVyU3RyYXRlZ3kuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9Mb2FkZXJTdHJhdGVneS5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNs dWRlICJjb25maWcuaCIKICNpbmNsdWRlICJMb2FkZXJTdHJhdGVneS5oIgogCisjaW5jbHVkZSAi UmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKIAog I2lmIFVTRShQTEFURk9STV9TVFJBVEVHSUVTKQpAQCAtMzcsNiArMzgsMTEgQEAgUmVzb3VyY2VM b2FkU2NoZWR1bGVyKiBMb2FkZXJTdHJhdGVneTo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKICAg ICByZXR1cm4gV2ViQ29yZTo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CiB9CiAKK3ZvaWQgTG9h ZGVyU3RyYXRlZ3k6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoTmV0d29ya2luZ0NvbnRleHQq IGNvbnRleHQsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgU3RvcmVkQ3JlZGVudGlh bHMgc3RvcmVkQ3JlZGVudGlhbHMsIFJlc291cmNlRXJyb3ImIGVycm9yLCBSZXNvdXJjZVJlc3Bv bnNlJiByZXNwb25zZSwgVmVjdG9yPGNoYXI+JiBkYXRhKQoreworICAgIFJlc291cmNlSGFuZGxl Ojpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KGNvbnRleHQsIHJlcXVlc3QsIHN0b3JlZENyZWRl bnRpYWxzLCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBVU0UoUExBVEZPUk1fU1RSQVRFR0lFUykKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2xvYWRlci9Mb2FkZXJTdHJhdGVneS5oIGIvU291cmNlL1dlYkNvcmUvbG9h ZGVyL0xvYWRlclN0cmF0ZWd5LmgKaW5kZXggZTg3Yzc2Ny4uM2QwZTFkYiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmgKKysrIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL0xvYWRlclN0cmF0ZWd5LmgKQEAgLTI4LDE0ICsyOCwyMyBAQAogCiAjaWYgVVNF KFBMQVRGT1JNX1NUUkFURUdJRVMpCiAKKyNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZVR5cGVzLmgi CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNz IE5ldHdvcmtpbmdDb250ZXh0OworY2xhc3MgUmVzb3VyY2VFcnJvcjsKIGNsYXNzIFJlc291cmNl TG9hZFNjaGVkdWxlcjsKK2NsYXNzIFJlc291cmNlUmVxdWVzdDsKK2NsYXNzIFJlc291cmNlUmVz cG9uc2U7CiAKIGNsYXNzIExvYWRlclN0cmF0ZWd5IHsKIHB1YmxpYzoKICAgICB2aXJ0dWFsIFJl c291cmNlTG9hZFNjaGVkdWxlciogcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CiAKKyAgICB2aXJ0 dWFsIHZvaWQgbG9hZFJlc291cmNlU3luY2hyb25vdXNseShOZXR3b3JraW5nQ29udGV4dCosIGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIFN0b3JlZENyZWRlbnRpYWxzLCBSZXNvdXJjZUVycm9yJiwg UmVzb3VyY2VSZXNwb25zZSYsIFZlY3RvcjxjaGFyPiYgZGF0YSk7CisKIHByb3RlY3RlZDoKICAg ICB2aXJ0dWFsIH5Mb2FkZXJTdHJhdGVneSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IDQxYmEzODguLjQ5NDFkMmIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5k bGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl LmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkF1dGhlbnRpY2F0aW9uQ2xpZW50Lmgi CiAjaW5jbHVkZSAiSFRUUEhlYWRlck1hcC5oIgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlVHlw ZXMuaCIKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQu aD4KIApAQCAtODgsMTEgKzg5LDYgQEAgY2xhc3MgUmVzb3VyY2VSZXNwb25zZTsKIGNsYXNzIFNj aGVkdWxlUGFpcjsKIGNsYXNzIFNoYXJlZEJ1ZmZlcjsKIAotZW51bSBTdG9yZWRDcmVkZW50aWFs cyB7Ci0gICAgQWxsb3dTdG9yZWRDcmVkZW50aWFscywKLSAgICBEb05vdEFsbG93U3RvcmVkQ3Jl ZGVudGlhbHMKLX07Ci0KIHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBUaW1lcjsKIAogY2xh c3MgUmVzb3VyY2VIYW5kbGUgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXNvdXJjZUhhbmRsZT4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVU eXBlcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZVR5 cGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODcwZTc5NQotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5k bGVUeXBlcy5oCkBAIC0wLDAgKzEsMzggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElT JycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT CisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisg KiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQg KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAq IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFJlc291cmNl SGFuZGxlVHlwZXNfaAorI2RlZmluZSBSZXNvdXJjZUhhbmRsZVR5cGVzX2gKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitlbnVtIFN0b3JlZENyZWRlbnRpYWxzIHsKKyAgICBBbGxvd1N0b3JlZENy ZWRlbnRpYWxzLAorICAgIERvTm90QWxsb3dTdG9yZWRDcmVkZW50aWFscworfTsKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUmVzb3VyY2VIYW5kbGVUeXBlc19oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKaW5kZXggNzg0YzI2Mi4uOTlhZjI0ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisy MDEzLTAxLTE2ICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KKworICAgICAgICBT eW5jaHJvbm91cyBYTUxIVFRQUmVxdWVzdHMgbmVlZCB0byBnbyB0byB0aGUgTmV0d29ya1Byb2Nl c3MuCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8xMjk1MTc2NT4gYW5kIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDY4MjYKKworICAgICAgICBSZXZpZXdlZCBieSBT YW0gV2VpbmlnIGFuZCBBbGV4ZXkgUHJvc2t1cnlha292LgorCisgICAgICAgICogV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkpOiBF bnRyeSBwb2ludCBmb3IgV2ViQ29yZSB0byBnZXQKKyAgICAgICAgICBzeW5jaHJvbm91cyByZXF1 ZXN0cyB0byB0aGUgTmV0d29ya1Byb2Nlc3MuCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3Jl U3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaDoKKworICAgICAgICAqIE5ldHdvcmtQcm9j ZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3M6OnBlcmZvcm1TeW5jaHJvbm91c0xvYWQpOiBD cmVhdGUgYSBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyCisgICAgICAgICAgYW5kIHNjaGVkdWxl IGl0LgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzLmg6CisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlBy b2Nlc3MubWVzc2FnZXMuaW46CisKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNl TG9hZFNjaGVkdWxlcjo6c2NoZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKToKKyAgICAg ICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6c2VydmVQZW5kaW5nUmVx dWVzdHNGb3JIb3N0KTogU2VydmUgc3luY2hyb25vdXMgbG9hZGVycworICAgICAgICAgIGJlZm9y ZSBhc3luYyBsb2FkZXJzLgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJj ZUxvYWRTY2hlZHVsZXIuaDoKKworICAgICAgICBBIGNsYXNzIHRoYXQgZW5jYXBzdWxhdGVzIGEg c3luY2hyb25vdXMgbG9hZCByZXF1ZXN0IGFuZCB0aGUgQ29yZUlQQyByZXBseSB0byBiZSBtYWRl IG9uY2UgaXQgaXMgY29tcGxldGU6CisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvU3luY05ldHdv cmtSZXNvdXJjZUxvYWRlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyOjpTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKToKKyAgICAgICAgKFdl YktpdDo6U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcjo6c3RhcnQpOgorICAgICAgICAqIE5ldHdv cmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaDogQ29waWVkIGZyb20gU291cmNl L1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJlY29yZC5oLgorICAgICAgICAoV2ViS2l0OjpT eW5jTmV0d29ya1Jlc291cmNlTG9hZGVyOjpjcmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpTeW5j TmV0d29ya1Jlc291cmNlTG9hZGVyOjpzZXRJZGVudGlmaWVyKToKKyAgICAgICAgKFdlYktpdDo6 U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcjo6aWRlbnRpZmllcik6CisgICAgICAgIChXZWJLaXQ6 OlN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OmxvYWRQYXJhbWV0ZXJzKToKKworICAgICAgICBB ZGQgYSBzZWNvbmQgcXVldWUgb2Ygc3luYyBsb2FkZXJzOgorICAgICAgICAqIE5ldHdvcmtQcm9j ZXNzL0hvc3RSZWNvcmQuaDoKKyAgICAgICAgKFdlYktpdDo6SG9zdFJlY29yZDo6c3luY0xvYWRl cnNQZW5kaW5nKToKKworICAgICAgICBBZGQgY29tbWVudHMgdG8gZXhwbGljaXRseSBzcGVsbCBv dXQgdGhlIGN1cnJlbnQgcmVsaWFuY2Ugb24gc29tZSBtZXNzYWdlcyB0aGF0IGFyZSBjdXJyZW50 bHkgc3luY2hyb25vdXM6CisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNl TG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZGVyOjp3aWxs U2VuZFJlcXVlc3QpOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OmNh bkF1dGhlbnRpY2F0ZUFnYWluc3RQcm90ZWN0aW9uU3BhY2UpOgorCisgICAgICAgICogV2ViS2l0 Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorCiAyMDEzLTAxLTE2ICBBbmRlcnMgQ2FybHNz b24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIENvcmVJUENNZXNzYWdl S2luZHMuaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJl Y29yZC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9Ib3N0UmVjb3JkLmNwcApp bmRleCA3YmM5NjE3Li4zNzM5MWI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3Jr UHJvY2Vzcy9Ib3N0UmVjb3JkLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9Ib3N0UmVjb3JkLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIk5ldHdvcmtSZXNv dXJjZUxvYWRQYXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5oIgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlN5 bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKIAogI2lmIEVOQUJMRShORVRXT1JLX1BST0NFU1Mp CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQu aCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL0hvc3RSZWNvcmQuaAppbmRleCAxYjIx Mzc2Li5iMjE5ZTZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9I b3N0UmVjb3JkLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvSG9zdFJlY29y ZC5oCkBAIC0zNiw2ICszNiw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgTmV0d29y a1Jlc291cmNlTG9hZGVyOworY2xhc3MgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcjsKIHR5cGVk ZWYgdWludDY0X3QgUmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKIAogY2xhc3MgSG9zdFJlY29yZCB7 CkBAIC01NCwxMCArNTUsMTYgQEAgcHVibGljOgogICAgIHR5cGVkZWYgRGVxdWU8UmVmUHRyPE5l dHdvcmtSZXNvdXJjZUxvYWRlcj4gPiBMb2FkZXJRdWV1ZTsKICAgICBMb2FkZXJRdWV1ZSYgbG9h ZGVyc1BlbmRpbmcoV2ViQ29yZTo6UmVzb3VyY2VMb2FkUHJpb3JpdHkgcHJpb3JpdHkpIHsgcmV0 dXJuIG1fbG9hZGVyc1BlbmRpbmdbcHJpb3JpdHldOyB9CiAKKyAgICB0eXBlZGVmIERlcXVlPFJl ZlB0cjxTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyPiA+IFN5bmNMb2FkZXJRdWV1ZTsKKyAgICBT eW5jTG9hZGVyUXVldWUmIHN5bmNMb2FkZXJzUGVuZGluZygpIHsgcmV0dXJuIG1fc3luY0xvYWRl cnNQZW5kaW5nOyB9CisKIHByaXZhdGU6ICAgICAgICAgICAgICAgICAgICAKICAgICBMb2FkZXJR dWV1ZSBtX2xvYWRlcnNQZW5kaW5nW1dlYkNvcmU6OlJlc291cmNlTG9hZFByaW9yaXR5SGlnaGVz dCArIDFdOwogICAgIHR5cGVkZWYgSGFzaFNldDxSZXNvdXJjZUxvYWRJZGVudGlmaWVyPiBSZXNv dXJjZUxvYWRJZGVudGlmaWVyU2V0OwogICAgIFJlc291cmNlTG9hZElkZW50aWZpZXJTZXQgbV9y ZXNvdXJjZUlkZW50aWZpZXJzTG9hZGluZzsKKyAgICAKKyAgICBTeW5jTG9hZGVyUXVldWUgbV9z eW5jTG9hZGVyc1BlbmRpbmc7CisgICAgSGFzaFNldDxSZWZQdHI8U3luY05ldHdvcmtSZXNvdXJj ZUxvYWRlcj4gPiBtX3N5bmNMb2FkZXJzTG9hZGluZzsKIAogICAgIGNvbnN0IFN0cmluZyBtX25h bWU7CiAgICAgaW50IG1fbWF4UmVxdWVzdHNJbkZsaWdodDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmNwcCBi L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzLmNwcAppbmRleCA4NjRiMTRiLi4yMzUwMTg4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nl c3MuY3BwCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3MuaCIKICNp bmNsdWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlICJSZW1vdGVOZXR3b3Jr aW5nQ29udGV4dC5oIgorI2luY2x1ZGUgIlN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNp bmNsdWRlIDxXZWJDb3JlL1BsYXRmb3JtQ29va2llSmFyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9S ZXNvdXJjZUxvYWRlck9wdGlvbnMuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlUmVxdWVz dC5oPgpAQCAtMTIwLDYgKzEyMSwxMSBAQCB2b2lkIE5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9j ZXNzOjpzY2hlZHVsZVJlc291cmNlTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMbwogICAgIHJl c291cmNlTG9hZElkZW50aWZpZXIgPSBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jl c291cmNlTG9hZFNjaGVkdWxlcigpLnNjaGVkdWxlUmVzb3VyY2VMb2FkKGxvYWRQYXJhbWV0ZXJz LCB0aGlzKTsKIH0KIAordm9pZCBOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6cGVyZm9y bVN5bmNocm9ub3VzTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYgbG9h ZFBhcmFtZXRlcnMsIFBhc3NSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+IHJlcGx5KQorewor ICAgIE5ldHdvcmtQcm9jZXNzOjpzaGFyZWQoKS5uZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVy KCkuc2NoZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKFN5bmNOZXR3b3JrUmVzb3VyY2VM b2FkZXI6OmNyZWF0ZShsb2FkUGFyYW1ldGVycywgcmVwbHkpKTsKK30KKwogdm9pZCBOZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzczo6YWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgS1VSTCYgdXJs LCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyJiBpZGVudGlmaWVyKQogewogICAgIGlkZW50aWZpZXIg PSBOZXR3b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcigp LmFkZExvYWRJblByb2dyZXNzKHVybCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3 b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oIGIvU291cmNlL1dlYktp dDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nlc3MuaAppbmRleCA1 MjM0NDI0Li45Y2U0NDI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05l dHdvcmtQcm9jZXNzL05ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzLmgKQEAgLTc2LDYgKzc2 LDggQEAgcHJpdmF0ZToKICAgICB2b2lkIGRpZFJlY2VpdmVTeW5jTmV0d29ya0Nvbm5lY3Rpb25U b1dlYlByb2Nlc3NNZXNzYWdlKENvcmVJUEM6OkNvbm5lY3Rpb24qLCBDb3JlSVBDOjpNZXNzYWdl SUQsIENvcmVJUEM6Ok1lc3NhZ2VEZWNvZGVyJiwgT3duUHRyPENvcmVJUEM6Ok1lc3NhZ2VFbmNv ZGVyPiYpOwogICAgIAogICAgIHZvaWQgc2NoZWR1bGVSZXNvdXJjZUxvYWQoY29uc3QgTmV0d29y a1Jlc291cmNlTG9hZFBhcmFtZXRlcnMmLCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyJik7CisgICAg dm9pZCBwZXJmb3JtU3luY2hyb25vdXNMb2FkKGNvbnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJh bWV0ZXJzJiwgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlByb2Nl c3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4pOworCiAgICAgdm9pZCBh ZGRMb2FkSW5Qcm9ncmVzcyhjb25zdCBXZWJDb3JlOjpLVVJMJiwgUmVzb3VyY2VMb2FkSWRlbnRp ZmllciYpOwogICAgIHZvaWQgcmVtb3ZlTG9hZElkZW50aWZpZXIoUmVzb3VyY2VMb2FkSWRlbnRp Zmllcik7CiAgICAgdm9pZCBjcm9zc09yaWdpblJlZGlyZWN0UmVjZWl2ZWQoUmVzb3VyY2VMb2Fk SWRlbnRpZmllciwgY29uc3QgV2ViQ29yZTo6S1VSTCYgcmVkaXJlY3RVUkwpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya0Nvbm5lY3Rpb25Ub1dlYlBy b2Nlc3MubWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3Jr Q29ubmVjdGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgppbmRleCBmNTc2YzllLi41NWQ5MWQ5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3Jr UHJvY2Vzcy9OZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzcy5tZXNzYWdlcy5pbgpAQCAtMjks NiArMjksNyBAQCBtZXNzYWdlcyAtPiBOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2VzcyB7CiAg ICAgLy8gVGhlcmUncyBwb3NzaWJsZSBSZXNvdXJjZUxvYWRlciBpZGVudGlmaWVyIHJlZmFjdG9y aW5nIHRoYXQgY2FuIHJlbW92ZSB0aGF0IHJlcXVpcmVtZW50LgogICAgIC8vIFdlIG1pZ2h0IGFs c28gaGF2ZSB0aGUgTmV0d29ya1Byb2Nlc3MgZGl2dnkgdXAgaWRlbnRpZmllcnMgaW4gYmxvY2tz IHRvIGVhY2ggV2ViUHJvY2VzcyBiZWZvcmVoYW5kLgogICAgIFNjaGVkdWxlUmVzb3VyY2VMb2Fk KFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgcmVzb3VyY2VMb2FkUGFyYW1l dGVycykgLT4gKHVpbnQ2NF90IHJlc291cmNlTG9hZElkZW50aWZpZXIpCisgICAgUGVyZm9ybVN5 bmNocm9ub3VzTG9hZChXZWJLaXQ6Ok5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzIHJlc291 cmNlTG9hZFBhcmFtZXRlcnMpIC0+IChXZWJDb3JlOjpSZXNvdXJjZUVycm9yIGVycm9yLCBXZWJD b3JlOjpSZXNvdXJjZVJlc3BvbnNlIHJlc3BvbnNlLCBDb3JlSVBDOjpEYXRhUmVmZXJlbmNlIGRh dGEpIERlbGF5ZWQKICAgICBBZGRMb2FkSW5Qcm9ncmVzcyhXZWJDb3JlOjpLVVJMIHVybCkgLT4g KHVpbnQ2NF90IHJlc291cmNlTG9hZElkZW50aWZpZXIpCiAgICAgUmVtb3ZlTG9hZElkZW50aWZp ZXIodWludDY0X3QgcmVzb3VyY2VMb2FkSWRlbnRpZmllcikKICAgICAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIu Y3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNj aGVkdWxlci5jcHAKaW5kZXggZDM3OGI4MS4uOGY3OWJjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5jcHAKQEAgLTcsNiArNyw3IEBACiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3Njb25uZWN0 aW9uTWVzc2FnZXMuaCIKICNpbmNsdWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5o IgogI2luY2x1ZGUgIk5ldHdvcmtSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlN5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogI2luY2x1 ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KIApAQCAtNjcsNiArNjgsMjcgQEAgUmVzb3VyY2VMb2Fk SWRlbnRpZmllciBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzY2hlZHVsZVJlc291cmNl TG9hZChjb25zdAogICAgIHJldHVybiBpZGVudGlmaWVyOwogfQogCit2b2lkIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXI6OnNjaGVkdWxlU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcihQYXNz UmVmUHRyPFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI+IGxvYWRlcikKK3sKKyAgICAvLyBGSVhN RSAoTmV0d29ya1Byb2Nlc3MpOiBTeW5jIGxvYWRlcnMgbmVlZCB0byBnZXQgaWRlbnRpZmllcnMg aW4gYSBzYW5lIHdheS4KKyAgICBSZXNvdXJjZUxvYWRJZGVudGlmaWVyIGlkZW50aWZpZXIgPSAr K3NfY3VycmVudFJlc291cmNlTG9hZElkZW50aWZpZXI7CisgICAgbG9hZGVyLT5zZXRJZGVudGlm aWVyKGlkZW50aWZpZXIpOworCisgICAgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QgPSBsb2FkZXItPmxvYWRQYXJhbWV0ZXJzKCkucmVxdWVzdCgpOworCisgICAgTE9HKE5l dHdvcmtTY2hlZHVsaW5nLCAiKE5ldHdvcmtQcm9jZXNzKSBOZXR3b3JrUmVzb3VyY2VMb2FkU2No ZWR1bGVyOjpzY2hlZHVsZVN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIgc3luY2hyb25vdXMgcmVz b3VyY2UgJyVzJyIsIHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKworICAgIEhvc3RSZWNvcmQqIGhvc3QgPSBob3N0Rm9yVVJMKHJlc291cmNlUmVxdWVzdC51 cmwoKSwgQ3JlYXRlSWZOb3RGb3VuZCk7CisgICAgYm9vbCBoYWRSZXF1ZXN0cyA9IGhvc3QtPmhh c1JlcXVlc3RzKCk7CisgICAgaG9zdC0+c3luY0xvYWRlcnNQZW5kaW5nKCkuYXBwZW5kKGxvYWRl cik7CisgICAgbV9pZGVudGlmaWVycy5hZGQoaWRlbnRpZmllciwgaG9zdCk7CisgICAgCisgICAg aWYgKCFoYWRSZXF1ZXN0cykKKyAgICAgICAgc2VydmVQZW5kaW5nUmVxdWVzdHNGb3JIb3N0KGhv c3QsIFJlc291cmNlTG9hZFByaW9yaXR5SGlnaGVzdCk7CisKKyAgICBzY2hlZHVsZVNlcnZlUGVu ZGluZ1JlcXVlc3RzKCk7Cit9CisKIFJlc291cmNlTG9hZElkZW50aWZpZXIgTmV0d29ya1Jlc291 cmNlTG9hZFNjaGVkdWxlcjo6YWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgV2ViQ29yZTo6S1VSTCYg dXJsKQogewogICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllciA9ICsrc19jdXJy ZW50UmVzb3VyY2VMb2FkSWRlbnRpZmllcjsKQEAgLTE3MCw2ICsxOTIsMjQgQEAgdm9pZCBOZXR3 b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0c0Zvckhvc3QoSG9z dFJlY29yZCogaG9zdCwKIHsKICAgICBMT0coTmV0d29ya1NjaGVkdWxpbmcsICJOZXR3b3JrUmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyBIb3N0IG5hbWU9JyVzJyIs IGhvc3QtPm5hbWUoKS51dGY4KCkuZGF0YSgpKTsKIAorICAgIC8vIFdlIHNlcnZlIHN5bmNocm9u b3VzIHJlcXVlc3RzIGJlZm9yZSBhbnkgb3RoZXIgcmVxdWVzdHMgdG8gaW1wcm92ZSByZXNwb25z aXZlbmVzcyBpbiBhbnkKKyAgICAvLyBXZWJQcm9jZXNzIHRoYXQgaXMgd2FpdGluZyBvbiBhIHN5 bmNocm9ub3VzIGxvYWQuCisgICAgSG9zdFJlY29yZDo6U3luY0xvYWRlclF1ZXVlJiBzeW5jTG9h ZGVyc1BlbmRpbmcgPSBob3N0LT5zeW5jTG9hZGVyc1BlbmRpbmcoKTsKKyAgICB3aGlsZSAoIXN5 bmNMb2FkZXJzUGVuZGluZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgUmVmUHRyPFN5bmNOZXR3b3Jr UmVzb3VyY2VMb2FkZXI+IGxvYWRlciA9IHN5bmNMb2FkZXJzUGVuZGluZy5maXJzdCgpOworCisg ICAgICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IEhvdyBkbyB3ZSBrbm93IHRoaXMgc3lu Y2hyb25vdXMgbG9hZCBpc24ndCBhc3NvY2lhdGVkIHdpdGggYSBXZWJQcm9jZXNzCisgICAgICAg IC8vIHdlJ3ZlIGxvc3Qgb3VyIGNvbm5lY3Rpb24gdG8/CisgICAgICAgIGJvb2wgc2hvdWxkTGlt aXRSZXF1ZXN0cyA9ICFob3N0LT5uYW1lKCkuaXNOdWxsKCk7CisgICAgICAgIGlmIChzaG91bGRM aW1pdFJlcXVlc3RzICYmIGhvc3QtPmxpbWl0UmVxdWVzdHMoUmVzb3VyY2VMb2FkUHJpb3JpdHlI aWdoZXN0LCBmYWxzZSkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgc3luY0xvYWRl cnNQZW5kaW5nLnJlbW92ZUZpcnN0KCk7CisgICAgICAgIGhvc3QtPmFkZExvYWRJblByb2dyZXNz KGxvYWRlci0+aWRlbnRpZmllcigpKTsKKworICAgICAgICBsb2FkZXItPnN0YXJ0KCk7CisgICAg fQorICAgIAogICAgIGZvciAoaW50IHByaW9yaXR5ID0gUmVzb3VyY2VMb2FkUHJpb3JpdHlIaWdo ZXN0OyBwcmlvcml0eSA+PSBtaW5pbXVtUHJpb3JpdHk7IC0tcHJpb3JpdHkpIHsKICAgICAgICAg SG9zdFJlY29yZDo6TG9hZGVyUXVldWUmIGxvYWRlcnNQZW5kaW5nID0gaG9zdC0+bG9hZGVyc1Bl bmRpbmcoUmVzb3VyY2VMb2FkUHJpb3JpdHkocHJpb3JpdHkpKTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5o IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVk dWxlci5oCmluZGV4IDA0NzZmY2MuLjA0NDEyM2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgK QEAgLTM5LDYgKzM5LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiBjbGFzcyBIb3N0UmVjb3JkOwog Y2xhc3MgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnM7CiBjbGFzcyBOZXR3b3JrQ29ubmVj dGlvblRvV2ViUHJvY2VzczsKK2NsYXNzIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXI7CiB0eXBl ZGVmIHVpbnQ2NF90IFJlc291cmNlTG9hZElkZW50aWZpZXI7CiAKIGNsYXNzIE5ldHdvcmtSZXNv dXJjZUxvYWRTY2hlZHVsZXIgewpAQCAtNTAsNiArNTEsOSBAQCBwdWJsaWM6CiAgICAgLy8gQWRk cyB0aGUgcmVxdWVzdCB0byB0aGUgcXVldWUgZm9yIGl0cyBob3N0IGFuZCBjcmVhdGUgYSB1bmlx dWUgaWRlbnRpZmllciBmb3IgaXQuCiAgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBzY2hlZHVs ZVJlc291cmNlTG9hZChjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycyYsIE5ldHdv cmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzKik7CiAgICAgCisgICAgLy8gQWRkcyBhIHN5bmNocm9u b3VzIHJlcXVlc3QgdG8gdGhlIHN5bmNocm9ub3VzIHJlcXVlc3QgcXVldWUgZm9yIGl0cyBob3N0 LgorICAgIHZvaWQgc2NoZWR1bGVTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKFBhc3NSZWZQdHI8 U3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcj4pOworICAgIAogICAgIC8vIENyZWF0ZXMgYSB1bmlx dWUgaWRlbnRpZmllciBmb3IgYW4gYWxyZWFkeS1pbi1wcm9ncmVzcyBsb2FkLgogICAgIFJlc291 cmNlTG9hZElkZW50aWZpZXIgYWRkTG9hZEluUHJvZ3Jlc3MoY29uc3QgV2ViQ29yZTo6S1VSTCYp OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVz b3VyY2VMb2FkZXIuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jl c291cmNlTG9hZGVyLmNwcAppbmRleCBjZTQ2YmQwLi5iZDAxYmJmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHAK QEAgLTE4OCw2ICsxODgsMTAgQEAgdm9pZCBOZXR3b3JrUmVzb3VyY2VMb2FkZXI6OndpbGxTZW5k UmVxdWVzdChSZXNvdXJjZUhhbmRsZSosIFJlc291cmNlUmVxdWVzdCYgcmUKICAgICBBU1NFUlQo IXJlZGlyZWN0UmVzcG9uc2UuaXNOdWxsKCkpOwogICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkp OwogCisgICAgLy8gSU1QT1JUQU5UOiBUaGUgZmFjdCB0aGF0IHRoaXMgbWVzc2FnZSB0byB0aGUg V2ViUHJvY2VzcyBpcyBzeW5jIGlzIHdoYXQgbWFrZXMgb3VyIGN1cnJlbnQgYXBwcm9hY2ggdG8g c3luY2hyb25vdXMgWE1MSHR0cFJlcXVlc3RzIHNhZmUuCisgICAgLy8gSWYgdGhpcyBtZXNzYWdl IGNoYW5nZXMgdG8gYmUgYXN5bmNocm9ub3VzIHdlIG1pZ2h0IGludHJvZHVjZSBhIHNpdHVhdGlv biB3aGVyZSB0aGUgTmV0d29ya1Byb2Nlc3MgaXMgZGVhZGxvY2tlZCB3YWl0aW5nIGZvciA2IGNv bm5lY3Rpb25zCisgICAgLy8gdG8gY29tcGxldGUgd2hpbGUgdGhlIFdlYlByb2Nlc3MgaXMgd2Fp dGluZyBmb3IgYSA3dGggdG8gY29tcGxldGUuCisgICAgLy8gSWYgd2UgZXZlciBjaGFuZ2UgdGhp cyBtZXNzYWdlIHRvIGJlIGFzeW5jaHJvbm91cyB3ZSBoYXZlIHRvIGluY2x1ZGUgc2FmZWd1YXJk cyB0byBtYWtlIHN1cmUgdGhlIG5ldyBkZXNpZ24gaW50ZXJhY3RzIHdlbGwgd2l0aCBzeW5jIFhI Ui4KICAgICBpZiAoIXNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJSZXNvdXJjZUxvYWRlcjo6V2lsbFNl bmRSZXF1ZXN0KHJlcXVlc3QsIHJlZGlyZWN0UmVzcG9uc2UpLCBNZXNzYWdlczo6V2ViUmVzb3Vy Y2VMb2FkZXI6OldpbGxTZW5kUmVxdWVzdDo6UmVwbHkocmVxdWVzdCkpKQogICAgICAgICByZXF1 ZXN0ID0gUmVzb3VyY2VSZXF1ZXN0KCk7CiB9CkBAIC0yODcsNiArMjkxLDEwIEBAIGJvb2wgTmV0 d29ya1Jlc291cmNlTG9hZGVyOjpjYW5BdXRoZW50aWNhdGVBZ2FpbnN0UHJvdGVjdGlvblNwYWNl KFJlc291cmNlSGFuZGxlCiB7CiAgICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CiAKKyAgICAv LyBJTVBPUlRBTlQ6IFRoZSBmYWN0IHRoYXQgdGhpcyBtZXNzYWdlIHRvIHRoZSBXZWJQcm9jZXNz IGlzIHN5bmMgaXMgd2hhdCBtYWtlcyBvdXIgY3VycmVudCBhcHByb2FjaCB0byBzeW5jaHJvbm91 cyBYTUxIdHRwUmVxdWVzdHMgc2FmZS4KKyAgICAvLyBJZiB0aGlzIG1lc3NhZ2UgY2hhbmdlcyB0 byBiZSBhc3luY2hyb25vdXMgd2UgbWlnaHQgaW50cm9kdWNlIGEgc2l0dWF0aW9uIHdoZXJlIHRo ZSBOZXR3b3JrUHJvY2VzcyBpcyBkZWFkbG9ja2VkIHdhaXRpbmcgZm9yIDYgY29ubmVjdGlvbnMK KyAgICAvLyB0byBjb21wbGV0ZSB3aGlsZSB0aGUgV2ViUHJvY2VzcyBpcyB3YWl0aW5nIGZvciBh IDd0aCB0byBjb21wbGV0ZS4KKyAgICAvLyBJZiB3ZSBldmVyIGNoYW5nZSB0aGlzIG1lc3NhZ2Ug dG8gYmUgYXN5bmNocm9ub3VzIHdlIGhhdmUgdG8gaW5jbHVkZSBzYWZlZ3VhcmRzIHRvIG1ha2Ug c3VyZSB0aGUgbmV3IGRlc2lnbiBpbnRlcmFjdHMgd2VsbCB3aXRoIHN5bmMgWEhSLgogICAgIGJv b2wgcmVzdWx0OwogICAgIGlmICghc2VuZFN5bmMoTWVzc2FnZXM6OldlYlJlc291cmNlTG9hZGVy OjpDYW5BdXRoZW50aWNhdGVBZ2FpbnN0UHJvdGVjdGlvblNwYWNlKHByb3RlY3Rpb25TcGFjZSks IE1lc3NhZ2VzOjpXZWJSZXNvdXJjZUxvYWRlcjo6Q2FuQXV0aGVudGljYXRlQWdhaW5zdFByb3Rl Y3Rpb25TcGFjZTo6UmVwbHkocmVzdWx0KSkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VM b2FkZXIuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNv dXJjZUxvYWRlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2RlMjNl MQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNO ZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwCkBAIC0wLDAgKzEsNzUgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJ VFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5o IgorCisjaWYgRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKKworI2luY2x1ZGUgIkRhdGFSZWZlcmVu Y2UuaCIKKyNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzcy5oIgorI2luY2x1ZGUgIlJlbW90ZU5ldHdv cmtpbmdDb250ZXh0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9SZXNvdXJjZUVycm9yLmg+CisjaW5j bHVkZSA8V2ViQ29yZS9SZXNvdXJjZVJlc3BvbnNlLmg+CisjaW5jbHVkZSA8d3RmL01haW5UaHJl YWQuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBXZWJLaXQgewor CitTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyOjpTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyKGNv bnN0IE5ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzJiBwYXJhbWV0ZXJzLCBQYXNzUmVmUHRy PE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9u b3VzTG9hZDo6RGVsYXllZFJlcGx5PiByZXBseSkKKyAgICA6IG1fbmV0d29ya1Jlc291cmNlTG9h ZFBhcmFtZXRlcnMocGFyYW1ldGVycykKKyAgICAsIG1fZGVsYXllZFJlcGx5KHJlcGx5KQorICAg ICwgbV9pZGVudGlmaWVyKDApCit7Cit9CisKK3ZvaWQgU3luY05ldHdvcmtSZXNvdXJjZUxvYWRl cjo6c3RhcnQoKQoreworICAgIC8vIEZJWE1FIChOZXR3b3JrUHJvY2Vzcyk6IFRoaXMgaXMgY2Fs bGVkIG9uIHRoZSBOZXR3b3JrUHJvY2VzcyBtYWluIHRocmVhZCwgYmxvY2tpbmcgYW55IG90aGVy IHJlcXVlc3RzIGZyb20gYmVpbmcgc2NoZWR1bGVkLgorICAgIC8vIFRoaXMgc2hvdWxkIG1vdmUg dG8gYSBiYWNrZ3JvdW5kIHRocmVhZCwgYnV0IHdlJ2QgZWl0aGVyIG5lZWQgdG8gYmUgc3VyZSB0 aGF0OgorICAgIC8vICAgQSAtIFJlc291cmNlSGFuZGxlOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91 c2x5IGlzIHNhZmUgdG8gcnVuIG9uIGEgYmFja2dyb3VuZCB0aHJlYWQuCisgICAgLy8gICBCIC0g V3JpdGUgY3VzdG9tIGxvYWRpbmcgbG9naWMgdGhhdCBpcyBrbm93biB0byBiZSBzYWZlIG9uIGEg YmFja2dyb3VuZCB0aHJlYWQuCisgICAgCisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAg ICBBU1NFUlQobV9pZGVudGlmaWVyKTsKKworICAgIFJlc291cmNlRXJyb3IgZXJyb3I7CisgICAg UmVzb3VyY2VSZXNwb25zZSByZXNwb25zZTsKKyAgICBWZWN0b3I8Y2hhcj4gZGF0YTsKKyAgICAK KyAgICAvLyBGSVhNRSAoTmV0d29ya1Byb2Nlc3MpOiBDcmVhdGUgUmVtb3RlTmV0d29ya2luZ0Nv bnRleHQgd2l0aCBhY3R1YWwgc2V0dGluZ3MuCisgICAgUmVmUHRyPFJlbW90ZU5ldHdvcmtpbmdD b250ZXh0PiBuZXR3b3JraW5nQ29udGV4dCA9IFJlbW90ZU5ldHdvcmtpbmdDb250ZXh0OjpjcmVh dGUoZmFsc2UsIGZhbHNlLCBtX25ldHdvcmtSZXNvdXJjZUxvYWRQYXJhbWV0ZXJzLmluUHJpdmF0 ZUJyb3dzaW5nTW9kZSgpKTsKKyAgICAKKyAgICBSZXNvdXJjZUhhbmRsZTo6bG9hZFJlc291cmNl U3luY2hyb25vdXNseShuZXR3b3JraW5nQ29udGV4dC5nZXQoKSwgbV9uZXR3b3JrUmVzb3VyY2VM b2FkUGFyYW1ldGVycy5yZXF1ZXN0KCksIG1fbmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMu YWxsb3dTdG9yZWRDcmVkZW50aWFscygpLCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOworCisgICAg bV9kZWxheWVkUmVwbHktPnNlbmQoZXJyb3IsIHJlc3BvbnNlLCBDb3JlSVBDOjpEYXRhUmVmZXJl bmNlKCh1aW50OF90KilkYXRhLmRhdGEoKSwgZGF0YS5zaXplKCkpKTsKKyAgICAKKyAgICBOZXR3 b3JrUHJvY2Vzczo6c2hhcmVkKCkubmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlcigpLnJlbW92 ZUxvYWRJZGVudGlmaWVyKG1faWRlbnRpZmllcik7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktp dAorCisjZW5kaWYgLy8gRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCBiL1Nv dXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL1N5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NDJhZThlCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxv YWRlci5oCkBAIC0wLDAgKzEsNjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycK KyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisg KiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFN5bmNOZXR3b3Jr UmVzb3VyY2VMb2FkZXJfaAorI2RlZmluZSBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyX2gKKwor I2luY2x1ZGUgIk5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzTWVzc2FnZXMuaCIKKyNpbmNs dWRlICJOZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5oIgorI2luY2x1ZGUgPHd0Zi9SZWZD b3VudGVkLmg+CisKKyNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQorCituYW1lc3BhY2UgV2Vi S2l0IHsKKwordHlwZWRlZiB1aW50NjRfdCBSZXNvdXJjZUxvYWRJZGVudGlmaWVyOworCitjbGFz cyBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyIDogcHVibGljIFJlZkNvdW50ZWQ8U3luY05ldHdv cmtSZXNvdXJjZUxvYWRlcj4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFN5bmNO ZXR3b3JrUmVzb3VyY2VMb2FkZXI+IGNyZWF0ZShjb25zdCBOZXR3b3JrUmVzb3VyY2VMb2FkUGFy YW1ldGVycyYgcGFyYW1ldGVycywgUGFzc1JlZlB0cjxNZXNzYWdlczo6TmV0d29ya0Nvbm5lY3Rp b25Ub1dlYlByb2Nlc3M6OlBlcmZvcm1TeW5jaHJvbm91c0xvYWQ6OkRlbGF5ZWRSZXBseT4gcmVw bHkpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFN5bmNOZXR3b3JrUmVzb3Vy Y2VMb2FkZXIocGFyYW1ldGVycywgcmVwbHkpKTsKKyAgICB9CisgICAgCisgICAgdm9pZCBzZXRJ ZGVudGlmaWVyKFJlc291cmNlTG9hZElkZW50aWZpZXIgaWRlbnRpZmllcikgeyBtX2lkZW50aWZp ZXIgPSBpZGVudGlmaWVyOyB9CisgICAgUmVzb3VyY2VMb2FkSWRlbnRpZmllciBpZGVudGlmaWVy KCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9CisgICAgCisgICAgY29uc3QgTmV0d29y a1Jlc291cmNlTG9hZFBhcmFtZXRlcnMmIGxvYWRQYXJhbWV0ZXJzKCkgeyByZXR1cm4gbV9uZXR3 b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVyczsgfQorCisgICAgdm9pZCBzdGFydCgpOworCitwcml2 YXRlOgorICAgIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIoY29uc3QgTmV0d29ya1Jlc291cmNl TG9hZFBhcmFtZXRlcnMmLCBQYXNzUmVmUHRyPE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRv V2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6RGVsYXllZFJlcGx5Pik7CisgICAg CisgICAgTmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgbV9uZXR3b3JrUmVzb3VyY2VMb2Fk UGFyYW1ldGVyczsKKyAgICBSZWZQdHI8TWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpEZWxheWVkUmVwbHk+IG1fZGVsYXllZFJl cGx5OworICAgIFJlc291cmNlTG9hZElkZW50aWZpZXIgbV9pZGVudGlmaWVyOworfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAvLyBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQor CisjZW5kaWYgLy8gU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlcl9oCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2Vi S2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNDZjYmUwOS4uNWQz MDg5MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViS2l0Mi54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagpAQCAtNDcwLDYgKzQ3MCw4IEBACiAJCTUxNzk1NTcxMTYyODc3RDIwMEZBNDNCNiAv KiBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTFBOEE2MEYxNjI3RjJCRDAwMEQ5MEU5IC8qIE5l dHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggKi87IH07CiAJCTUxN0NGMEUzMTYzQTQ4 NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE3Q0YwRTEx NjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VSZWNlaXZl ci5jcHAgKi87IH07CiAJCTUxN0NGMEU0MTYzQTQ4NkMwMEMyOTUwRSAvKiBOZXR3b3JrUHJvY2Vz c0Nvbm5lY3Rpb25NZXNzYWdlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNTE3Q0YwRTIxNjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29u bmVjdGlvbk1lc3NhZ2VzLmggKi87IH07CisJCTUxODE1QjlGMTZBNjIyMjEwMDU0NTAxRiAvKiBT eW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxODE1QjlEMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyLmNwcCAqLzsgfTsKKwkJNTE4MTVCQTAxNkE2MjIyMTAwNTQ1MDFGIC8q IFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29y a1Jlc291cmNlTG9hZGVyLmggKi87IH07CiAJCTUxODI5REE1MTYzN0M3MEMwMDA5NTNENiAvKiBO ZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REEzMTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3Jr UmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCAqLzsgfTsKIAkJNTE4MjlEQTYxNjM3QzcwQzAwMDk1 M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODI5REE0MTYzN0M3MEMwMDA5NTNENiAvKiBO ZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi87IH07CiAJCTUxODM0NTkyMTM0NTMyRTkw MDkyQjY5NiAvKiBXZWJJY29uRGF0YWJhc2VDbGllbnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE4MzQ1OTAxMzQ1MzJFODAwOTJCNjk2IC8qIFdl Ykljb25EYXRhYmFzZUNsaWVudC5jcHAgKi87IH07CkBAIC0xNzMzLDYgKzE3MzUsOCBAQAogCQk1 MTdBMzNCNDEzMEIzMDhDMDBGODBDQjUgLyogV0tBcHBsaWNhdGlvbkNhY2hlTWFuYWdlci5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXS0FwcGxpY2F0aW9uQ2FjaGVNYW5hZ2Vy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxN0NGMEUxMTYzQTQ4NkMwMEMyOTUw RSAvKiBOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb25NZXNzYWdlUmVjZWl2ZXIuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uTWVz c2FnZVJlY2VpdmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE3Q0YwRTIx NjNBNDg2QzAwQzI5NTBFIC8qIE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1lc3NhZ2VzLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbk1l c3NhZ2VzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxODE1QjlEMTZBNjIyMjEw MDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFN5bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuY3BwOyBwYXRo ID0gTmV0d29ya1Byb2Nlc3MvU3luY05ldHdvcmtSZXNvdXJjZUxvYWRlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0 d29ya1Jlc291cmNlTG9hZGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFN5 bmNOZXR3b3JrUmVzb3VyY2VMb2FkZXIuaDsgcGF0aCA9IE5ldHdvcmtQcm9jZXNzL1N5bmNOZXR3 b3JrUmVzb3VyY2VMb2FkZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlE QTMxNjM3QzcwQzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gTmV0d29ya1Jlc291cmNlTG9hZFNj aGVkdWxlci5jcHA7IHBhdGggPSBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUmVzb3VyY2VMb2FkU2No ZWR1bGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4MjlEQTQxNjM3Qzcw QzAwMDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBuYW1lID0gTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBwYXRo ID0gTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk1MTgzNDU5MDEzNDUzMkU4MDA5MkI2OTYgLyogV2ViSWNv bkRhdGFiYXNlQ2xpZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFdlYkljb25EYXRhYmFzZUNsaWVudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBA IC0zMTkwLDYgKzMxOTQsOCBAQAogCQkJCTUxNTcwNTUyMTY1NzAxOEMwMDEwMUE5MCAvKiBOZXR3 b3JrUmVzb3VyY2VMb2FkZXIubWVzc2FnZXMuaW4gKi8sCiAJCQkJNTE4MjlEQTMxNjM3QzcwQzAw MDk1M0Q2IC8qIE5ldHdvcmtSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICovLAogCQkJCTUxODI5 REE0MTYzN0M3MEMwMDA5NTNENiAvKiBOZXR3b3JrUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi8s CisJCQkJNTE4MTVCOUQxNkE2MjIyMTAwNTQ1MDFGIC8qIFN5bmNOZXR3b3JrUmVzb3VyY2VMb2Fk ZXIuY3BwICovLAorCQkJCTUxODE1QjlFMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jl c291cmNlTG9hZGVyLmggKi8sCiAJCQkpOwogCQkJbmFtZSA9IE5ldHdvcmtQcm9jZXNzOwogCQkJ c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTUwNTAsNiArNTA1Niw3IEBACiAJCQkJRTE3OTA4 OEYxNjlCQUE2QTAwNjkwNEM3IC8qIFNlY0l0ZW1TaGltLmggaW4gSGVhZGVycyAqLywKIAkJCQlF MTc5MDg5MTE2OUJBQTgyMDA2OTA0QzcgLyogU2VjSXRlbVNoaW1NZXNzYWdlcy5oIGluIEhlYWRl cnMgKi8sCiAJCQkJMUE5N0UwNzYxNkE1RjlFMDAwMEJDOUU1IC8qIExheWVyVHJlZUhvc3RNYWMu aCBpbiBIZWFkZXJzICovLAorCQkJCTUxODE1QkEwMTZBNjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0 d29ya1Jlc291cmNlTG9hZGVyLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTYwMjksNiArNjAzNiw3IEBA CiAJCQkJRTE3OTA4OEQxNjlCQUE2MjAwNjkwNEM3IC8qIFNlY0l0ZW1TaGltLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUUxNzkwODkwMTY5QkFBN0YwMDY5MDRDNyAvKiBTZWNJdGVtU2hpbU1lc3Nh Z2VSZWNlaXZlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxQTk3RTA3NzE2QTVGOUUwMDAwQkM5 RTUgLyogTGF5ZXJUcmVlSG9zdE1hYy5tbSBpbiBTb3VyY2VzICovLAorCQkJCTUxODE1QjlGMTZB NjIyMjEwMDU0NTAxRiAvKiBTeW5jTmV0d29ya1Jlc291cmNlTG9hZGVyLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwog CQl9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwCmluZGV4IDlkYzQ4YzUuLjYx MDkzNzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBv cnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAKQEAgLTI5LDE5ICsy OSwyNCBAQAogI2lmIFVTRShQTEFURk9STV9TVFJBVEVHSUVTKQogCiAjaW5jbHVkZSAiQmxvY2tp bmdSZXNwb25zZU1hcC5oIgorI2luY2x1ZGUgIkRhdGFSZWZlcmVuY2UuaCIKKyNpbmNsdWRlICJO ZXR3b3JrUmVzb3VyY2VMb2FkUGFyYW1ldGVycy5oIgogI2luY2x1ZGUgIlBsdWdpbkluZm9TdG9y ZS5oIgogI2luY2x1ZGUgIldlYkNvbnRleHRNZXNzYWdlcy5oIgogI2luY2x1ZGUgIldlYkNvb2tp ZU1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJDb3JlQXJndW1lbnRDb2RlcnMuaCIKKyNpbmNsdWRl ICJXZWJFcnJvcnMuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCiAjaW5jbHVkZSAiV2ViUHJv Y2Vzc1Byb3h5TWVzc2FnZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL0NvbG9yLmg+CiAjaW5jbHVk ZSA8V2ViQ29yZS9LVVJMLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9Mb2FkZXJTdHJhdGVneS5oPgor I2luY2x1ZGUgPFdlYkNvcmUvTmV0d29ya2luZ0NvbnRleHQuaD4KICNpbmNsdWRlIDxXZWJDb3Jl L05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGFnZS5oPgogI2lu Y2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1Db29raWVKYXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Bs YXRmb3JtUGFzdGVib2FyZC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VFcnJvci5oPgog I2luY2x1ZGUgPHd0Zi9BdG9taWNzLmg+CiAKICNpZiBFTkFCTEUoTkVUV09SS19QUk9DRVNTKQpA QCAtMjA4LDYgKzIxMywyNCBAQCBSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIFdlYlBsYXRmb3JtU3Ry YXRlZ2llczo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKICAgICAKICAgICByZXR1cm4gc2NoZWR1 bGVyOwogfQorCit2b2lkIFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6bG9hZFJlc291cmNlU3luY2hy b25vdXNseShOZXR3b3JraW5nQ29udGV4dCogY29udGV4dCwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0 JiByZXF1ZXN0LCBTdG9yZWRDcmVkZW50aWFscyBzdG9yZWRDcmVkZW50aWFscywgUmVzb3VyY2VF cnJvciYgZXJyb3IsIFJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlLCBWZWN0b3I8Y2hhcj4mIGRh dGEpCit7CisgICAgQ29yZUlQQzo6RGF0YVJlZmVyZW5jZSBkYXRhUmVmZXJlbmNlOworCisgICAg TmV0d29ya1Jlc291cmNlTG9hZFBhcmFtZXRlcnMgbG9hZFBhcmFtZXRlcnMocmVxdWVzdCwgUmVz b3VyY2VMb2FkUHJpb3JpdHlIaWdoZXN0LCBTbmlmZkNvbnRlbnQsIHN0b3JlZENyZWRlbnRpYWxz LCBjb250ZXh0LT5zdG9yYWdlU2Vzc2lvbigpLmlzUHJpdmF0ZUJyb3dzaW5nU2Vzc2lvbigpKTsK KyAgICBpZiAoIVdlYlByb2Nlc3M6OnNoYXJlZCgpLm5ldHdvcmtDb25uZWN0aW9uKCktPmNvbm5l Y3Rpb24oKS0+c2VuZFN5bmMoTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNz OjpQZXJmb3JtU3luY2hyb25vdXNMb2FkKGxvYWRQYXJhbWV0ZXJzKSwgTWVzc2FnZXM6Ok5ldHdv cmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpSZXBseShl cnJvciwgcmVzcG9uc2UsIGRhdGFSZWZlcmVuY2UpLCAwKSkgeworICAgICAgICByZXNwb25zZSA9 IFJlc291cmNlUmVzcG9uc2UoKTsKKyAgICAgICAgZXJyb3IgPSBpbnRlcm5hbEVycm9yKHJlcXVl c3QudXJsKCkpOworICAgICAgICBkYXRhLnJlc2l6ZSgwKTsKKworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgZGF0YS5yZXNpemUoZGF0YVJlZmVyZW5jZS5zaXplKCkpOworICAgIG1lbWNw eShkYXRhLmRhdGEoKSwgZGF0YVJlZmVyZW5jZS5kYXRhKCksIGRhdGFSZWZlcmVuY2Uuc2l6ZSgp KTsKK30KKwogI2VuZGlmCiAKIC8vIFBsdWdpblN0cmF0ZWd5CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5o IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0 cmF0ZWdpZXMuaAppbmRleCBjYzBkYzhjLi5jMWZmMTBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1T dHJhdGVnaWVzLmgKQEAgLTcxLDYgKzcxLDcgQEAgcHJpdmF0ZToKICAgICAvLyBXZWJDb3JlOjpM b2FkZXJTdHJhdGVneQogI2lmIEVOQUJMRShORVRXT1JLX1BST0NFU1MpCiAgICAgdmlydHVhbCBX ZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIHJlc291cmNlTG9hZFNjaGVkdWxlcigpIE9W RVJSSURFOworICAgIHZpcnR1YWwgdm9pZCBsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KFdlYkNv cmU6Ok5ldHdvcmtpbmdDb250ZXh0KiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg V2ViQ29yZTo6U3RvcmVkQ3JlZGVudGlhbHMsIFdlYkNvcmU6OlJlc291cmNlRXJyb3ImLCBXZWJD b3JlOjpSZXNvdXJjZVJlc3BvbnNlJiwgVmVjdG9yPGNoYXI+JiBkYXRhKSBPVkVSUklERTsKICNl bmRpZgogCiAgICAgLy8gV2ViQ29yZTo6UGx1Z2luU3RyYXRlZ3kK